Merge pull request 'dev' (#66) from dev into main

Reviewed-on: #66

.gitignore

@@ -415,3 +415,7 @@ fabric.properties
 # Android studio 3.1+ serialized cache file
 .idea/caches/build_file_checksums.ser
 
+# packages for node
+package.json
+package-lock.json
+

ArticlesApp/admin.py

@@ -0,0 +1,157 @@
+# -*- coding: utf-8 -*-
+from django.contrib import admin
+from django.utils.translation import gettext_lazy as _
+from ArticlesApp.models import ArticleModel, UserPageModel
+from sets.admin import *
+
+
+# class Admin_ArticlesPageSets(Admin_BaseIconModel):
+#
+#     fieldsets = (
+#         (None, {
+#             'classes': ['wide'],
+#             'fields': (
+#                 'name', 'url', 'description', 'picture'
+#             )
+#
+#
+#         }),
+#         ('Управление отображением страницы', {
+#             'classes': ['wide'],
+#             'fields': (
+#                        # ('serviceBlockStateShow'),
+#                        # ('articlesCountInBlock'),
+#                        # ('advicesCountInBlock'),
+#             )
+#         }),
+#
+#         ('SEO', {
+#             'classes': ['wide', 'collapse'],
+#             'fields': ('seo_title', 'seo_description','seo_keywords', 'seo_text')
+#         }),
+#
+#     )
+#
+#     prepopulated_fields = {"url": ("name",)}
+#     list_display = ('name', 'url', 'seo_title', 'createDT')
+#     # list_editable = ('dish_price', 'allowForDelivery', 'dish_maxDiscount','dish_rating',
+#     #                  'dish_enabled')
+#     # filter_horizontal = ['service_works',]
+#     # date_hierarchy = 'createDT'
+#     # list_filter = ('device_name', 'vendor',)
+#     list_display_links = ('name',)
+#     save_on_top = True
+#
+#     def has_add_permission(self, request):
+#         return not ArticlesPageSets.objects.all().count() > 0
+#
+#     def has_delete_permission(self, request, obj=None):
+#         if not request.user.is_superuser:
+#             return False
+#         else:
+#             return True
+#
+# admin.site.register(ArticlesPageSets,Admin_ArticlesPageSets)
+
+
+
+
+class Admin_Article(Admin_Trans_BaseModelViewPage):
+
+    fieldsets = (
+        (None, {
+            'classes': ['wide'],
+            'fields': (('name'),
+                       ('url'),
+                       # 'pub_DT',
+                       'picture',
+                       # ('devices'),
+            )
+        }),
+        (_('Статья'), {
+            'classes': ['wide'],
+            'fields': (
+                'description', 'text',
+            )
+        }),
+
+        ('SEO', {
+            'classes': ['wide', 'collapse'],
+            'fields': ('seo_title', 'seo_description','seo_keywords')
+        }),
+
+    )
+
+    prepopulated_fields = {"url": ("name",)}
+    list_display = (
+        # 'image_thumb',
+        'name', 'url', 'order', 'createDT')
+    list_editable = ('order',) # 'allowForDelivery', 'dish_maxDiscount','dish_rating',
+    #                  'dish_enabled')
+    # filter_horizontal = ['sites']
+    date_hierarchy = 'createDT'
+    list_filter = ('enable', 'createDT')
+    list_display_links = (
+        'name',
+        # 'image_thumb',
+    )
+    save_on_top = True
+
+admin.site.register(ArticleModel, Admin_Article)
+
+# class Admin_ArticleSliders(admin.TabularInline):
+#     model = ArticleModel.SliderSets.through
+
+
+class Admin_UserPage(Admin_Trans_BaseModelViewPage):
+
+    fieldsets = (
+        (None, {
+            'classes': ['wide'],
+            'fields': (('name'),
+                       ('url'),
+                       # 'pub_DT',
+                       # ('devices'),
+            )
+        }),
+        (_('Статья'), {
+            'classes': ['wide'],
+            'fields': ('picture', 'description', 'text')
+        }),
+
+        ('SEO', {
+            'classes': ['wide', 'collapse'],
+            'fields': ('seo_title', 'seo_description','seo_keywords')
+        }),
+
+    )
+
+    prepopulated_fields = {"url": ("name",)}
+    list_display = (
+        # 'image_thumb',
+        'name', 'url', 'order', 'seo_title', 'createDT')
+    list_editable = ('order', ) # 'allowForDelivery', 'dish_maxDiscount','dish_rating',
+    #                  'dish_enabled')
+    # filter_horizontal = ['sites']
+    date_hierarchy = 'createDT'
+    list_filter = ('enable', 'createDT')
+    list_display_links = (
+        'name',
+        # 'image_thumb',
+    )
+    save_on_top = True
+
+    actions = ['create_copy']
+
+
+
+    def has_delete_permission(self, request, obj=None):
+        if request.user.is_superuser:
+            return True
+
+        if obj and obj.url in ('for-partners', 'dealers', 'contacts'):
+            return False
+
+        return True
+
+admin.site.register(UserPageModel,Admin_UserPage)

ArticlesApp/funcs.py

@@ -0,0 +1,45 @@
+from .models import *
+
+
+elements_on_page = 10
+
+def get_articles(art_kwargs, request_Data=None, from_el=None, to_el=None):
+
+    if request_Data:
+        if not from_el and 'from_el' in request_Data:
+            from_el = request_Data['from_el']
+
+        if not to_el and 'to_el' in request_Data:
+            to_el = request_Data['to_el']
+
+    arts = ArticleModel.objects.filter(**art_kwargs).order_by('-createDT')
+    el_count = arts.count()
+
+    if from_el and to_el:
+        arts = arts[from_el:to_el]
+    elif from_el:
+        arts = arts[from_el:]
+    elif to_el:
+        arts = arts[:to_el]
+    else:
+        to_el = elements_on_page
+        arts = arts[:to_el]
+
+    last_block = False
+    if not to_el or to_el >= el_count:
+        last_block = True
+
+    if el_count - to_el > elements_on_page:
+        next_page_els_count = elements_on_page
+    else:
+        next_page_els_count = el_count - to_el
+
+    Dict = {
+        'articles': arts,
+        'last_block': last_block,
+        'last_el': to_el,
+        'next_page_els_count': next_page_els_count,
+        'elements_on_page': elements_on_page
+    }
+
+    return Dict

ArticlesApp/js_urls.py

@@ -0,0 +1,10 @@
+# coding=utf-8
+from django.urls import path
+# from AuthApp.js_views import *
+# from AuthApp.import_funcs import *
+from .js_views import *
+
+urlpatterns = [
+    path('get_articles_block/', get_articles_block_ajax, name='get_articles_block_ajax'),
+
+]

ArticlesApp/js_views.py

@@ -0,0 +1,61 @@
+import json
+
+from django.shortcuts import render
+
+from uuid import uuid1
+from .models import *
+from django.contrib import auth
+from django.http import HttpResponse, Http404, JsonResponse
+from django.template import loader, RequestContext
+from django.contrib.auth.decorators import login_required
+from BaseModels.mailSender import techSendMail
+from django.utils.translation import gettext as _
+from datetime import datetime
+from django.template.loader import render_to_string
+from django.urls import reverse
+# from .forms import *
+from .funcs import *
+
+def get_articles_block_ajax(request):
+
+    if request.method != 'POST':
+        raise Http404
+
+    from GeneralApp.funcs import get_and_set_lang
+    lang = get_and_set_lang(request)
+
+    try:
+
+        data = request.POST.dict()
+        if not data and request.body:
+            data = json.loads(request.body)
+
+        art_kwargs = {}
+
+        Dict = get_articles(art_kwargs=art_kwargs, request_Data=data)
+        if 'errors' in Dict:
+            return JsonResponse(Dict, status=400)
+
+        html = render_to_string('blocks/articles/b_news_elements.html', Dict, request=request)
+
+        res_Dict = {
+            'html': html,
+            'last_block': Dict['last_block'],
+            'next_page_els_count': Dict['next_page_els_count'],
+            # 'form': RouteForm(initial=data)
+        }
+
+        from GeneralApp.funcs import get_add_to_ajax_response_Dict
+        res_Dict.update(get_add_to_ajax_response_Dict(request.user))
+
+        return JsonResponse(res_Dict)
+
+    except Exception as e:
+
+
+        errors_Dict = {
+            'errors': {
+                'all__': f'{_("ошибка в запросе")} = {str(e)}'
+            }
+        }
+        return JsonResponse(errors_Dict, status=400)

ArticlesApp/migrations/0001_initial.py

@@ -0,0 +1,103 @@
+# Generated by Django 4.2.2 on 2023-08-28 17:17
+
+import ckeditor.fields
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='ArticleModel',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.TextField(blank=True, help_text='Название', null=True, verbose_name='Название')),
+                ('name_ru', models.TextField(blank=True, help_text='Название', null=True, verbose_name='Название')),
+                ('name_en', models.TextField(blank=True, help_text='Название', null=True, verbose_name='Название')),
+                ('name_plural', models.TextField(blank=True, null=True, verbose_name='Название (множественное число)')),
+                ('order', models.IntegerField(blank=True, null=True, verbose_name='Очередность отображения')),
+                ('createDT', models.DateTimeField(auto_now_add=True, verbose_name='Дата и время создания')),
+                ('modifiedDT', models.DateTimeField(blank=True, null=True, verbose_name='Дата и время последнего изменения')),
+                ('enable', models.BooleanField(db_index=True, default=True, verbose_name='Включено')),
+                ('json_data', models.JSONField(blank=True, default=dict, verbose_name='Дополнительные данные')),
+                ('url', models.TextField(help_text='можно изменить адрес страницы (!!! ВНИМАНИЕ !!! поисковые системы потеряют страницу и найдут лишь спустя неделю...месяц)', unique=True, verbose_name='URL привязанной страницы')),
+                ('title', models.TextField(blank=True, null=True, verbose_name='Заголовок')),
+                ('description', ckeditor.fields.RichTextField(blank=True, help_text='краткое описание страницы (до 240 символов)', null=True, verbose_name='Краткое описание')),
+                ('description_ru', ckeditor.fields.RichTextField(blank=True, help_text='краткое описание страницы (до 240 символов)', null=True, verbose_name='Краткое описание')),
+                ('description_en', ckeditor.fields.RichTextField(blank=True, help_text='краткое описание страницы (до 240 символов)', null=True, verbose_name='Краткое описание')),
+                ('picture', models.ImageField(blank=True, null=True, upload_to='uploads/', verbose_name='Картинка')),
+                ('visible', models.BooleanField(default=True, verbose_name='Отображать')),
+                ('background_image_left', models.ImageField(blank=True, null=True, upload_to='', verbose_name='Левая подложка')),
+                ('background_image_right', models.ImageField(blank=True, null=True, upload_to='', verbose_name='Правая подложка')),
+                ('seo_title', models.CharField(blank=True, max_length=250, null=True, verbose_name='Title (80 знаков)')),
+                ('seo_title_ru', models.CharField(blank=True, max_length=250, null=True, verbose_name='Title (80 знаков)')),
+                ('seo_title_en', models.CharField(blank=True, max_length=250, null=True, verbose_name='Title (80 знаков)')),
+                ('seo_description', models.CharField(blank=True, max_length=250, null=True, verbose_name='Description (150 знаков)')),
+                ('seo_description_ru', models.CharField(blank=True, max_length=250, null=True, verbose_name='Description (150 знаков)')),
+                ('seo_description_en', models.CharField(blank=True, max_length=250, null=True, verbose_name='Description (150 знаков)')),
+                ('seo_keywords', models.CharField(blank=True, max_length=250, null=True, verbose_name='Keywords (200 знаков)')),
+                ('seo_keywords_ru', models.CharField(blank=True, max_length=250, null=True, verbose_name='Keywords (200 знаков)')),
+                ('seo_keywords_en', models.CharField(blank=True, max_length=250, null=True, verbose_name='Keywords (200 знаков)')),
+                ('seo_text', ckeditor.fields.RichTextField(blank=True, null=True, verbose_name='Текст SEO статьи')),
+                ('seo_text_ru', ckeditor.fields.RichTextField(blank=True, null=True, verbose_name='Текст SEO статьи')),
+                ('seo_text_en', ckeditor.fields.RichTextField(blank=True, null=True, verbose_name='Текст SEO статьи')),
+                ('FAQ_title', models.CharField(blank=True, max_length=250, null=True, verbose_name='FAQ Заголовок')),
+                ('text', ckeditor.fields.RichTextField(verbose_name='Текст')),
+                ('text_ru', ckeditor.fields.RichTextField(null=True, verbose_name='Текст')),
+                ('text_en', ckeditor.fields.RichTextField(null=True, verbose_name='Текст')),
+            ],
+            options={
+                'verbose_name': 'Статья',
+                'verbose_name_plural': 'Статьи',
+            },
+        ),
+        migrations.CreateModel(
+            name='UserPageModel',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.TextField(blank=True, help_text='Название', null=True, verbose_name='Название')),
+                ('name_ru', models.TextField(blank=True, help_text='Название', null=True, verbose_name='Название')),
+                ('name_en', models.TextField(blank=True, help_text='Название', null=True, verbose_name='Название')),
+                ('name_plural', models.TextField(blank=True, null=True, verbose_name='Название (множественное число)')),
+                ('order', models.IntegerField(blank=True, null=True, verbose_name='Очередность отображения')),
+                ('createDT', models.DateTimeField(auto_now_add=True, verbose_name='Дата и время создания')),
+                ('modifiedDT', models.DateTimeField(blank=True, null=True, verbose_name='Дата и время последнего изменения')),
+                ('enable', models.BooleanField(db_index=True, default=True, verbose_name='Включено')),
+                ('json_data', models.JSONField(blank=True, default=dict, verbose_name='Дополнительные данные')),
+                ('url', models.TextField(help_text='можно изменить адрес страницы (!!! ВНИМАНИЕ !!! поисковые системы потеряют страницу и найдут лишь спустя неделю...месяц)', unique=True, verbose_name='URL привязанной страницы')),
+                ('title', models.TextField(blank=True, null=True, verbose_name='Заголовок')),
+                ('description', ckeditor.fields.RichTextField(blank=True, help_text='краткое описание страницы (до 240 символов)', null=True, verbose_name='Краткое описание')),
+                ('description_ru', ckeditor.fields.RichTextField(blank=True, help_text='краткое описание страницы (до 240 символов)', null=True, verbose_name='Краткое описание')),
+                ('description_en', ckeditor.fields.RichTextField(blank=True, help_text='краткое описание страницы (до 240 символов)', null=True, verbose_name='Краткое описание')),
+                ('picture', models.ImageField(blank=True, null=True, upload_to='uploads/', verbose_name='Картинка')),
+                ('visible', models.BooleanField(default=True, verbose_name='Отображать')),
+                ('background_image_left', models.ImageField(blank=True, null=True, upload_to='', verbose_name='Левая подложка')),
+                ('background_image_right', models.ImageField(blank=True, null=True, upload_to='', verbose_name='Правая подложка')),
+                ('seo_title', models.CharField(blank=True, max_length=250, null=True, verbose_name='Title (80 знаков)')),
+                ('seo_title_ru', models.CharField(blank=True, max_length=250, null=True, verbose_name='Title (80 знаков)')),
+                ('seo_title_en', models.CharField(blank=True, max_length=250, null=True, verbose_name='Title (80 знаков)')),
+                ('seo_description', models.CharField(blank=True, max_length=250, null=True, verbose_name='Description (150 знаков)')),
+                ('seo_description_ru', models.CharField(blank=True, max_length=250, null=True, verbose_name='Description (150 знаков)')),
+                ('seo_description_en', models.CharField(blank=True, max_length=250, null=True, verbose_name='Description (150 знаков)')),
+                ('seo_keywords', models.CharField(blank=True, max_length=250, null=True, verbose_name='Keywords (200 знаков)')),
+                ('seo_keywords_ru', models.CharField(blank=True, max_length=250, null=True, verbose_name='Keywords (200 знаков)')),
+                ('seo_keywords_en', models.CharField(blank=True, max_length=250, null=True, verbose_name='Keywords (200 знаков)')),
+                ('seo_text', ckeditor.fields.RichTextField(blank=True, null=True, verbose_name='Текст SEO статьи')),
+                ('seo_text_ru', ckeditor.fields.RichTextField(blank=True, null=True, verbose_name='Текст SEO статьи')),
+                ('seo_text_en', ckeditor.fields.RichTextField(blank=True, null=True, verbose_name='Текст SEO статьи')),
+                ('FAQ_title', models.CharField(blank=True, max_length=250, null=True, verbose_name='FAQ Заголовок')),
+                ('text', ckeditor.fields.RichTextField(verbose_name='Текст')),
+                ('text_ru', ckeditor.fields.RichTextField(null=True, verbose_name='Текст')),
+                ('text_en', ckeditor.fields.RichTextField(null=True, verbose_name='Текст')),
+            ],
+            options={
+                'verbose_name': 'Пользовательская страница',
+                'verbose_name_plural': 'Пользовательские страницы',
+            },
+        ),
+    ]

ArticlesApp/migrations/0002_alter_articlemodel_description_and_more.py

@@ -0,0 +1,104 @@
+# Generated by Django 4.2.2 on 2023-09-22 13:29
+
+import ckeditor_uploader.fields
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('ArticlesApp', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='articlemodel',
+            name='description',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, help_text='краткое описание страницы (до 240 символов)', null=True, verbose_name='Краткое описание'),
+        ),
+        migrations.AlterField(
+            model_name='articlemodel',
+            name='description_en',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, help_text='краткое описание страницы (до 240 символов)', null=True, verbose_name='Краткое описание'),
+        ),
+        migrations.AlterField(
+            model_name='articlemodel',
+            name='description_ru',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, help_text='краткое описание страницы (до 240 символов)', null=True, verbose_name='Краткое описание'),
+        ),
+        migrations.AlterField(
+            model_name='articlemodel',
+            name='seo_text',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, null=True, verbose_name='Текст SEO статьи'),
+        ),
+        migrations.AlterField(
+            model_name='articlemodel',
+            name='seo_text_en',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, null=True, verbose_name='Текст SEO статьи'),
+        ),
+        migrations.AlterField(
+            model_name='articlemodel',
+            name='seo_text_ru',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, null=True, verbose_name='Текст SEO статьи'),
+        ),
+        migrations.AlterField(
+            model_name='articlemodel',
+            name='text',
+            field=ckeditor_uploader.fields.RichTextUploadingField(verbose_name='Текст'),
+        ),
+        migrations.AlterField(
+            model_name='articlemodel',
+            name='text_en',
+            field=ckeditor_uploader.fields.RichTextUploadingField(null=True, verbose_name='Текст'),
+        ),
+        migrations.AlterField(
+            model_name='articlemodel',
+            name='text_ru',
+            field=ckeditor_uploader.fields.RichTextUploadingField(null=True, verbose_name='Текст'),
+        ),
+        migrations.AlterField(
+            model_name='userpagemodel',
+            name='description',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, help_text='краткое описание страницы (до 240 символов)', null=True, verbose_name='Краткое описание'),
+        ),
+        migrations.AlterField(
+            model_name='userpagemodel',
+            name='description_en',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, help_text='краткое описание страницы (до 240 символов)', null=True, verbose_name='Краткое описание'),
+        ),
+        migrations.AlterField(
+            model_name='userpagemodel',
+            name='description_ru',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, help_text='краткое описание страницы (до 240 символов)', null=True, verbose_name='Краткое описание'),
+        ),
+        migrations.AlterField(
+            model_name='userpagemodel',
+            name='seo_text',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, null=True, verbose_name='Текст SEO статьи'),
+        ),
+        migrations.AlterField(
+            model_name='userpagemodel',
+            name='seo_text_en',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, null=True, verbose_name='Текст SEO статьи'),
+        ),
+        migrations.AlterField(
+            model_name='userpagemodel',
+            name='seo_text_ru',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, null=True, verbose_name='Текст SEO статьи'),
+        ),
+        migrations.AlterField(
+            model_name='userpagemodel',
+            name='text',
+            field=ckeditor_uploader.fields.RichTextUploadingField(verbose_name='Текст'),
+        ),
+        migrations.AlterField(
+            model_name='userpagemodel',
+            name='text_en',
+            field=ckeditor_uploader.fields.RichTextUploadingField(null=True, verbose_name='Текст'),
+        ),
+        migrations.AlterField(
+            model_name='userpagemodel',
+            name='text_ru',
+            field=ckeditor_uploader.fields.RichTextUploadingField(null=True, verbose_name='Текст'),
+        ),
+    ]

ArticlesApp/models.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+
+__author__ = 'sync'
+
+from django.db import models
+
+from BaseModels.base_models import BaseModelViewPage, BaseModel
+# from ckeditor.fields import RichTextField
+from ckeditor_uploader.fields import RichTextUploadingField
+from django.utils.translation import gettext_lazy as _
+
+
+# class ArticlesPageSets(BaseModelViewPage):
+#
+#     class Meta:
+#         verbose_name = 'Настройки страницы архива статей'
+#         verbose_name_plural = 'Настройки страницы архива статей'
+
+
+class UserPageModel(BaseModelViewPage):
+    # pub_DT = models.DateTimeField(verbose_name=u'Дата и время публикации', auto_created=True)
+    text = RichTextUploadingField(verbose_name=_('Текст'))
+
+    class Meta:
+        verbose_name=_("Пользовательская страница")
+        verbose_name_plural =_("Пользовательские страницы")
+        # unique_together = ('url', 'region')
+        # managed=True
+        # app_label = u'ArticlesApp'
+
+
+class ArticleModel(BaseModelViewPage):
+    # pub_DT = models.DateTimeField(verbose_name=u'Дата и время публикации', auto_created=True)
+    text = RichTextUploadingField(verbose_name=_("Текст"))
+
+    class Meta:
+        verbose_name=_("Статья")
+        verbose_name_plural =_("Статьи")

ArticlesApp/templatetags/__init__.py

@@ -0,0 +1 @@
+__author__ = 'SDE'

ArticlesApp/templatetags/arts_tags_extra.py

@@ -0,0 +1,48 @@
+__author__ = 'SDE'
+
+from django import template
+from django.template.defaultfilters import stringfilter
+
+register = template.Library()
+
+
+# @register.filter('get_side_art')
+@register.simple_tag
+def get_side_art(last_el, counter, els_on_page):
+    cur_el = last_el - els_on_page + counter
+    if els_on_page < 4:
+        first_left_el = els_on_page + 1
+    else:
+        first_left_el = 4
+    if (cur_el - first_left_el) % 2:
+        return 'even'
+    else:
+        return 'odd'
+
+# @register.filter()
+# def get_numbers_list(from_el, to_el):
+#     res = range(from_el, to_el+1)
+#     return res
+#
+#
+# def val_type(value):
+#     res = type(value)
+#     return res.__name__
+# register.filter('val_type', val_type)
+#
+# @register.filter()
+# def get_cols_table_data_for_row_when_cols3(value, row):
+#     el_count = 3
+#     from_el = (row-1) * el_count
+#     to_el = row * el_count
+#     part = list(value)[from_el:to_el]
+#     return part
+# # register.filter('val_type', val_type)
+#
+#
+# @register.filter
+# @stringfilter
+# def correct_for_tables(value):
+#     if value in ['None', '0.0']:
+#         return '-'
+#     return value

ArticlesApp/tests.py

@@ -0,0 +1,16 @@
+"""
+This file demonstrates writing tests using the unittest module. These will pass
+when you run "manage.py test".
+
+Replace this with more appropriate tests for your application.
+"""
+
+from django.test import TestCase
+
+
+class SimpleTest(TestCase):
+    def test_basic_addition(self):
+        """
+        Tests that 1 + 1 always equals 2.
+        """
+        self.assertEqual(1 + 1, 2)

ArticlesApp/translation.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+from modeltranslation.translator import translator, TranslationOptions, register
+from .models import *
+
+@register(ArticleModel)
+class Article_TranslationOptions(TranslationOptions):
+
+    fields = (
+        'name', 'description', 'seo_title', 'seo_description', 'seo_keywords', 'seo_text',
+        'text'
+    )
+
+# translator.register(ArticleModel, Article_TranslationOptions)
+
+
+
+@register(UserPageModel)
+class UserPage_TranslationOptions(TranslationOptions):
+
+    fields = (
+        'name', 'description', 'seo_title', 'seo_description', 'seo_keywords', 'seo_text',
+        'text'
+    )
+
+# translator.register(UserPageModel, UserPage_TranslationOptions)

ArticlesApp/urls.py

@@ -0,0 +1,5 @@
+from django.urls import path
+from .views import *
+
+urlpatterns = [
+]

ArticlesApp/urls_translate.py

@@ -0,0 +1,9 @@
+from django.urls import path
+from .views import *
+
+urlpatterns = [
+   path('articles/', ArticlesPageView, name=u'articles'),
+   path('articles/<int:year>/', ArticlesPageView, name=u'articles_by_year'),
+   path('article/<str:art_url>/', ArticlesOnePageView, name=u'article_one'),
+   path('info_page/<str:page_url>/', UserPageView, name=u'user_page'),
+]

ArticlesApp/views.py

@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*-
+
+from .models import *
+
+from datetime import datetime, date
+from django.http import Http404, HttpResponse
+from django.template import loader
+from .funcs import *
+from GeneralApp.funcs import get_inter_http_response
+from django.utils.translation import gettext_lazy as _
+
+# from django.contrib.auth.decorators import login_required
+# from BaseModels.search_optimization.ld_json.ld_article_news import get_ld_article_news
+# from django.contrib.sites.shortcuts import get_current_site
+
+
+
+def get_flat_pages_links_Dict(site):
+
+    flat_pages_links = UserPageModel.objects.filter(
+        url__in=('for-partners', 'contacts'),
+        sites=site
+    ).values_list('url', flat=True)
+
+    return {'flat_pages_links': flat_pages_links}
+
+
+
+def get_article_breadcrumbs(request, art):
+    # print('get_article_breadcrumbs')
+    articles_add_count = 3
+    # half_count = articlesCountInBlock / 2
+
+    # arts_top = ArticleModel.objects.filter(enable=True, createDT__gt=art.createDT).order_by(
+    #     'createDT')[:articles_add_count]
+    # arts_down = ArticleModel.objects.filter(enable=True, createDT__lt=art.createDT).order_by(
+    #     '-createDT')[:articles_add_count]
+    # if len(artListDown)<half_count:
+    #     art_List = ArticleModel.objects.filter(enable=True, article_DT__gte=art.article_DT).order_by(
+    #     'article_DT')[:art.articlesCountInBlock-len(artListDown)]
+
+    breadcrumbs_arts = ArticleModel.objects.exclude(id=art.id).order_by('?')[:3]
+
+    Dict = {
+        'breadcrumbs_arts': breadcrumbs_arts
+        # 'arts_top': arts_top,
+        # 'arts_down': arts_down
+    }
+    return Dict
+
+
+def get_user_pages_breadcrumbs(request, art):
+    from ArticlesApp.models import UserPageModel
+    # print('get_user_pages_breadcrumbs')
+    half_count = art.articlesCountInBlock / 2
+
+    art_List = UserPageModel.objects.filter(enable=True, article_DT__gte=art.article_DT).order_by(
+        'article_DT')[:half_count]
+    artListDown = UserPageModel.objects.filter(enable=True, article_DT__lt=art.article_DT).order_by(
+        '-article_DT')[:art.articlesCountInBlock-len(art_List)]
+    if len(artListDown)<half_count:
+        art_List = UserPageModel.objects.filter(enable=True, article_DT__gte=art.article_DT).order_by(
+        'article_DT')[:art.articlesCountInBlock-len(artListDown)]
+
+    art_List = list(art_List)
+    art_List.reverse()
+    artlist = art_List + list(artListDown)
+    # print('artlist',artlist)
+    return artlist
+
+
+# @login_required(login_url='/admin/')
+def ArticlesPageView(request, year=None):
+
+    kwargs = {}
+
+    if year:
+        try:
+            year = int(year)
+            kwargs.update({'createDT__year': year})
+        except:
+            raise Http404
+
+
+    Dict = get_articles(art_kwargs=kwargs)
+    Dict.update({
+        'page': {
+            'title': _('Новости сервиса доставки посылок | TripWB'),
+            'description': _('Обновления, полезные статьи и свежие новости от TripWB ✓ Актуальные новости в мире доставок по всему СНГ ➡️ Следите за нашими новостями'),
+            'keywords': _('Все новости сайта tripwb.com'),
+        }
+    })
+
+    t = loader.get_template('pages/p_articles.html')
+    return get_inter_http_response(t, Dict, request)
+    # return HttpResponse(t.render(Dict, request))
+
+
+
+# @login_required(login_url='/admin/')
+def UserPageView(request, page_url):
+
+
+    kwargs = {
+        'url': page_url
+    }
+
+    try:
+        art = UserPageModel.objects.get(**kwargs)
+    except UserPageModel.DoesNotExist:
+        raise Http404
+
+    # service = ServiceModel.objects.filter(enable=True, artDevs=art)[0]
+
+    # article_breadcrumbs = get_user_pages_breadcrumbs(request,art)
+    # print('article_breadcrumbs',article_breadcrumbs)
+
+    Dict = {
+        'page' : art,
+        'user_page' : True,
+        # 'service' : service,
+        # 'article_breadcrumbs' : article_breadcrumbs
+    }
+
+
+
+    t = loader.get_template('pages/p_user_page.html')
+    return get_inter_http_response(t, Dict, request)
+    # return HttpResponse(t.render(Dict, request))
+
+
+
+# @login_required(login_url='/admin/')
+def ArticlesOnePageView(request, art_url):
+
+    kwargs = {
+        'url': art_url
+    }
+
+    try:
+        art = ArticleModel.objects.get(**kwargs)
+    except ArticleModel.DoesNotExist:
+        raise Http404
+
+
+
+    # print('article_breadcrumbs',article_breadcrumbs)
+
+    Dict = {
+        'page' : art,
+    }
+
+    Dict.update(get_article_breadcrumbs(request, art))
+
+
+
+    t = loader.get_template('pages/p_article.html')
+    return get_inter_http_response(t, Dict, request)
+    # return HttpResponse(t.render(Dict, request))

AuthApp/admin.py

@@ -39,16 +39,17 @@ class Admin_ProfileInline(admin.StackedInline):
         (None, {
             'classes': ['wide'],
             'fields': (
-                ('account_type',),
+                # ('account_type',),
                 ('enable',),
                 ('phone',),
                 ('country', 'city'),
+                ('mailing_on', ),
                 ('authMailCode',),
                 ('birthdate'),
                 'comment', 'creator'
             )
         }),
-        ('Дополнительно', {
+        (_('Дополнительно'), {
             'classes': ['wide'],
             'fields': (
                 ('json_data',)
@@ -71,6 +72,10 @@ class Admin_ProfileInline(admin.StackedInline):
 
 class Admin_User(UserAdmin):
 
+    def mailing_on(self, obj):
+        return obj.user_profile.mailing_on
+    mailing_on.boolean = True
+
     fieldsets = (
         (None, {
             'classes': ['wide'],
@@ -91,61 +96,65 @@ class Admin_User(UserAdmin):
 
     save_on_top = True
 
-    list_display = ['id', 'last_name', 'first_name', 'email', 'is_staff',
-                    'is_active']
+    list_display = ['id', 'last_name', 'first_name', 'mailing_on', 'email', 'is_staff',
+                    'is_active', 'date_joined', 'last_login']
     list_editable = ['is_staff', 'is_active']
     list_display_links = ['first_name', 'last_name', 'email']
     search_fields = ['first_name', 'last_name', 'email']
 
+    readonly_fields = ['date_joined', 'last_login']
+
+    list_filter = ['user_profile__mailing_on', 'is_staff', 'is_active', 'date_joined', 'last_login']
+
     inlines = (Admin_ProfileInline,)
     # actions = ['del_all_temp_users', ]
 
-    ordering = ['is_staff', 'last_name', 'first_name']
+    ordering = ['is_staff', '-id', 'last_name', 'first_name']
 
 # Re-register UserAdmin
 admin.site.unregister(User)
 admin.site.register(User, Admin_User)
 
 
-class Admin_UserProfile(Admin_BaseIconModel):
-
-    fieldsets = (
-        (None, {
-            'classes': ['wide'],
-            'fields': (
-                'user', 'enable',
-                ('account_type',),
-                ('phone',),
-                ('country', 'city'),
-                ('authMailCode',),
-                ('birthdate'),
-                'creator'
-            )
-        }),
-        ('1С', {
-            'classes': ['wide'],
-            'fields': (
-                ('name',),
-            )
-        }),
-    )
-
-    save_on_top = True
-
-    list_display = [
-        'id', 'user', 'enable', 'birthdate', 'modifiedDT', 'createDT'
-    ]
-    list_editable = ['enable', 'birthdate']
-    list_display_links = ['id', ]  # 'user__last_name', 'user__first_name']
-    search_fields = [
-        'id', 'user__last_name', 'user__first_name', 'user__email',
-    ]
-
-    list_filter = ['enable', 'account_type']
-
-    # filter_horizontal = ['connected_mailings']
-    # raw_id_fields = ("favourites",)
-    verbose_name_plural = _(u'Профиль пользователя')
-
-
-admin.site.register(UserProfile, Admin_UserProfile)
+# class Admin_UserProfile(Admin_BaseIconModel):
+#
+#     fieldsets = (
+#         (None, {
+#             'classes': ['wide'],
+#             'fields': (
+#                 'user', 'enable',
+#                 ('account_type',),
+#                 ('phone',),
+#                 ('country', 'city'),
+#                 ('authMailCode',),
+#                 ('birthdate'),
+#                 'creator'
+#             )
+#         }),
+#         ('1С', {
+#             'classes': ['wide'],
+#             'fields': (
+#                 ('name',),
+#             )
+#         }),
+#     )
+#
+#     save_on_top = True
+#
+#     list_display = [
+#         'id', 'user', 'enable', 'birthdate', 'modifiedDT', 'createDT'
+#     ]
+#     list_editable = ['enable', 'birthdate']
+#     list_display_links = ['id', ]  # 'user__last_name', 'user__first_name']
+#     search_fields = [
+#         'id', 'user__last_name', 'user__first_name', 'user__email',
+#     ]
+#
+#     list_filter = ['enable', 'account_type']
+#
+#     # filter_horizontal = ['connected_mailings']
+#     # raw_id_fields = ("favourites",)
+#     verbose_name_plural = _(u'Профиль пользователя')
+#
+#
+# admin.site.register(UserProfile, Admin_UserProfile)

AuthApp/forms.py

@@ -14,17 +14,78 @@ class LoginForm(forms.Form):
     username = forms.CharField(required=True)
     password = forms.CharField(required=True)
 
+
+
 class RegistrationForm(forms.Form):
     from .models import account_type_choices
-    account_type = forms.ChoiceField(choices=account_type_choices, initial='sender', required=True)
+    # account_type = forms.ChoiceField(choices=account_type_choices, initial='sender', required=True)
     firstname = forms.CharField(required=False)
     lastname = forms.CharField(required=False)
+    country = forms.CharField(required=False)
+    city = forms.CharField(required=False)
     email = forms.EmailField()
     password = forms.CharField(widget=forms.PasswordInput())
     confirm_password = forms.CharField(widget=forms.PasswordInput())
-    tel = forms.CharField()
+    tel = forms.CharField(required=False)
     agreement = forms.BooleanField(initial=False, required=True)
 
+    def __init__(self, *args, **kwargs):
+        required_password = True
+        required_agreement = True
+        required_email = True
+        create_new_account = True
+        if 'not_required_password' in kwargs.keys() and kwargs['not_required_password']:
+            required_password = False
+            del kwargs['not_required_password']
+        if 'not_required_agreement' in kwargs.keys() and kwargs['not_required_agreement']:
+            required_agreement = False
+            del kwargs['not_required_agreement']
+        if 'not_required_email' in kwargs.keys() and kwargs['not_required_email']:
+            required_email = False
+            del kwargs['not_required_email']
+        if 'create_new_account' in kwargs.keys() and not kwargs['create_new_account']:
+            create_new_account = False
+            del kwargs['create_new_account']
+
+        super(RegistrationForm, self).__init__(*args, **kwargs)
+
+        self.fields['password'].required = required_password
+        self.fields['confirm_password'].required = required_password
+
+        self.fields['agreement'].required = required_agreement
+
+        self.fields['email'].required = required_email
+
+        self.create_new_account = create_new_account
+
+    def clean(self):
+        cleaned_data = super().clean()
+        # i = 0
+        # names = list(cleaned_data.keys())
+        # while i < len(names):
+        #     if not cleaned_data[names[i]]:
+        #         if self.fields[names[i]].required:
+        #             self.add_error(names[i], _('Обязательное поле'))
+        #     i += 1
+
+        if 'tel' in cleaned_data and 'tel' in cleaned_data:
+            from BaseModels.validators.form_field_validators import get_phone_valid_error
+            error = get_phone_valid_error(cleaned_data["tel"])
+            if error:
+                self.add_error('tel', error)
+
+        if cleaned_data and 'confirm_password' in cleaned_data and 'password' in cleaned_data:
+            if cleaned_data['confirm_password'] != cleaned_data['password']:
+                self.add_error("password", _('Пароль и подтверждение пароля не совпадают'))
+                self.add_error("confirm_password", _('Пароль и подтверждение пароля не совпадают'))
+
+        if self.create_new_account and cleaned_data and 'email' in cleaned_data:
+            users = User.objects.filter(email=cleaned_data['email'])
+            if users:
+                self.add_error('email', _("Пользователь с указанным email уже существует"))
+
+
+
 
 # # class PersonForm(NgModelFormMixin, NgFormValidationMixin, NgModelForm, Bootstrap3ModelForm):
 # #

AuthApp/funcs.py

@@ -1,2 +1,120 @@
+from django.http import QueryDict
+from django.template.loader import render_to_string
+from SubscribesApp.funcs import check_option_in_cur_user_subscribe
 
 
+def get_user_timezone_Dict(user, request=None):
+    tz = None
+    if request:
+        tz = request.COOKIES.get("user_tz")
+    if not tz and user.is_authenticated:
+        tz = user.user_profile.get_timezone()
+
+    if not tz:
+        from django.conf import settings
+        tz = settings.TIME_ZONE
+
+    return {'user_tz': tz}
+
+def get_dashboard_page_content_html(request):
+
+    from ChatServiceApp.funcs import get_unanswered_msgs_count_for_user
+
+    Dict = {
+        'unanswered_msgs_count': get_unanswered_msgs_count_for_user(request.user)
+    }
+
+    html = render_to_string('blocks/profile/b_profile_first_page.html', Dict, request=request)
+    return html
+
+def get_profile_page_content_html(request, page_name, data):
+
+    if page_name == 'chat':
+        from ChatServiceApp.funcs import get_chat_page_content_html
+        return get_chat_page_content_html(request, data)
+    elif (page_name == 'create_route_for_customer' and
+          check_option_in_cur_user_subscribe(request.user, 'размещение заявок')):
+        from RoutesApp.funcs import get_profile_new_route_page_html
+        return get_profile_new_route_page_html(request, {'owner_type': 'customer'})
+    elif (page_name == 'create_route_for_mover' and
+          check_option_in_cur_user_subscribe(request.user, 'размещение заявок')):
+        from RoutesApp.funcs import get_profile_new_route_page_html
+        return get_profile_new_route_page_html(request, {'owner_type': 'mover'})
+    elif page_name == 'my_routes':
+        from RoutesApp.funcs import get_profile_my_routes_page_content_html
+        return get_profile_my_routes_page_content_html(request)
+    elif page_name == 'support':
+        return get_profile_support_page_content_html(request, data)
+    elif page_name == 'my_subscribe':
+        from SubscribesApp.funcs import get_profile_subscribe_page_content_Dict
+        res = get_profile_subscribe_page_content_Dict(request, check_orders_required=True)
+        return res['html']
+    elif page_name == 'change_profile':
+        return get_profile_change_page_content_html(request)
+    elif page_name == 'dashboard':
+        return get_dashboard_page_content_html(request)
+    else:
+        return None
+
+
+def get_profile_change_page_content_html(request, data=None):
+
+    init_Dict = {
+        'firstname': request.user.first_name,
+        'lastname': request.user.last_name,
+        'email': request.user.email,
+        'tel': request.user.user_profile.phone,
+        'country': request.user.user_profile.country,
+        'city': request.user.user_profile.city,
+    }
+
+    if data:
+        if type(data) == QueryDict:
+            data = data.dict()
+        init_Dict.update(data)
+        # if 'firstname' in data:
+        #     init_Dict.update({'first_name': data['firstname']})
+        # if 'lastname' in data:
+        #     init_Dict.update({'last_name': data['lastname']})
+        # if 'email' in data:
+        #     init_Dict.update({'email': data['email']})
+        #     init_Dict.update({'username': data['email']})
+        # if 'country' in data:
+        #     init_Dict.update({'country': data['country']})
+        # if 'city' in data:
+        #     init_Dict.update({'city': data['city']})
+        # if 'tel' in data:
+        #     init_Dict.update({'tel': data['tel']})
+
+    from .forms import RegistrationForm
+    form = RegistrationForm(initial=init_Dict)
+
+    from SubscribesApp.funcs import get_cur_user_subscribe
+
+    Dict = {
+        'profileForm': form,
+        'user_subscribe': get_cur_user_subscribe(request.user)
+    }
+
+    html = render_to_string('blocks/profile/b_profile.html', Dict, request=request)
+    return html
+
+
+def get_profile_support_page_content_html(request, data=None):
+    if request.user.is_staff:
+        from ChatServiceApp.funcs import get_ticketsDict_for_staff
+        Dict = get_ticketsDict_for_staff(request.user)
+        tpl_name = 'blocks/profile/b_support_chat.html'
+    else:
+        from ChatServiceApp.models import MsgGroup
+        tickets = MsgGroup.objects.filter(enable=True, owner=request.user).order_by('-modifiedDT')
+
+        Dict = {
+            'tickets': tickets,
+        }
+        tpl_name = 'blocks/profile/b_support_tickets.html'
+
+    Dict.update(get_user_timezone_Dict(request.user, request=request))
+
+    html = render_to_string(tpl_name, Dict, request=request)
+    return html

AuthApp/js_urls.py

@@ -14,13 +14,24 @@ urlpatterns = [
 
     path('new_route_view/', new_route_view_ajax, name='new_route_view_ajax'),
 
+    path('dashboard/', dashboard_ajax, name='dashboard_ajax'),
+
 
     path('my_routes/', my_routes_ajax, name='my_routes_ajax'),
-    path('subscribe/', subscribe_ajax, name='subscribe_ajax'),
+    # path('subscribe/', subscribe_ajax, name='subscribe_ajax'),
     path('chats/', chats_ajax, name='chats_ajax'),
 
     path('support_tickets/', support_tickets_ajax, name='support_tickets_ajax'),
 
+    path('password_recovery/', password_recovery_ajax, name='password_recovery_ajax'),
+    path('password_recovery_confirm/', password_recovery_confirm_ajax, name='password_recovery_confirm_ajax'),
 
     path('change_profile/', change_profile_ajax, name='change_profile_ajax'),
+    path('change_profile_confirm/', change_profile_confirm_ajax, name='change_profile_confirm_ajax'),
+    path('change_avatar_confirm/', change_avatar_confirm_ajax, name='change_avatar_confirm_ajax'),
+
+    path('send_message/', send_message_ajax, name='send_message_ajax'),
+
+    path('mailing_subscribe/', mailing_subscribe_ajax, name='mailing_subscribe_ajax')
+
 ]

AuthApp/js_views.py

@@ -11,24 +11,358 @@ from django.utils.translation import gettext as _
 from datetime import datetime
 from django.template.loader import render_to_string
 from django.urls import reverse
+from .funcs import *
+from django.core.exceptions import ValidationError
+import json
+from django.core.files import File
+import base64
+from django.core.validators import validate_email
+from django.urls import reverse
+from GeneralApp.funcs import get_and_set_lang
 
+# @login_required()#login_url='/profile/login/')
+# def subscribe_ajax(request):
+#     if request.method != 'POST':
+#         raise Http404
+#
+#     Dict = {
+#     }
+#
+#     html = render_to_string('blocks/profile/b_subscribe.html', Dict, request=request)
+#     return JsonResponse({'html': html}, status=200)
 
-@login_required(login_url='/profile/login/')
-def subscribe_ajax(request):
+def password_recovery_confirm_ajax(request):
     if request.method != 'POST':
         raise Http404
 
-    Dict = {
-    }
+    if not 'pass' in request.POST or not 'pass_confirm' in request.POST or not 'user_id' in request.POST:
+        raise Http404
 
-    html = render_to_string('blocks/profile/b_subscribe.html', Dict, request=request)
-    return JsonResponse({'html': html}, status=200)
+    lang = get_and_set_lang(request)
 
-@login_required(login_url='/profile/login/')
+    try:
+
+        if not request.POST['pass'] or request.POST['pass'] != request.POST['pass_confirm']:
+            return JsonResponse({
+                'status': 'error',
+                'error': _('Пароли не совпадают')
+            }, status=400)
+
+        user = User.objects.get(id=request.POST['user_id'])
+        user.set_password(request.POST['pass'])
+        user.user_profile.authMailCode = None
+        user.user_profile.save(update_fields=['authMailCode'])
+        user.is_active = True
+        user.save()
+
+        return JsonResponse({
+            'status': 'success',
+            'message': _('Пароль был успешно изменен')
+        })
+
+    except Exception as e:
+        return JsonResponse({
+            'status': 'error',
+            'error': str(e)
+        }, status=400)
+
+def password_recovery_ajax(request):
+    if request.method != 'POST':
+        raise Http404
+
+    lang = get_and_set_lang(request)
+
+    try:
+        email = request.POST['email']
+
+        try:
+            user = User.objects.get(email=email)
+        except User.DoesNotExist:
+            msg = _('Пользователь с указанным email не зарегистрирован на сайте')
+            return JsonResponse({
+                'status': 'error',
+                'error': msg
+            }, status=400)
+
+        user.user_profile.authMailCode = uuid1().hex
+        user.user_profile.save(update_fields=['authMailCode'])
+
+        from GeneralApp.funcs_options import get_options_by_opt_types, get_mail_send_options
+        sets = get_options_by_opt_types(['domain', 'project_name'], only_vals=True)
+
+        subject = _('Изменение пароля учетной записи на сайте tripwb.com')
+
+        mail_txt = _('Вы получили это письмо потому что '
+                     'был произведен запрос на изменение пароля '
+                     'для данного email на сайте tripwb.com.<br>'
+                     '<br>'
+                     'Если Вы не выполняли запрос - просто проигнорируйте это письмо.<br><br>'
+                     'Если же это были Вы и Вам требуется изменить пароль от учетной записи - '
+                     'перейдите по ссылке, указанной ниже.<br><br>')
+        link = sets["domain"] + f'/profile/reset_password/{str(user.id)}/{user.user_profile.authMailCode}/'
+        link_str = f'<a href="{link}">ИЗМЕНИТЬ ПАРОЛЬ</a><br><br>'
+
+        sign_txt = _('Спасибо за то, что вы с нами!<br>'
+                     'С уважением,<br>'
+                     'Команда Trip With Bonus.<br>')
+
+        Dict = {
+            'logo': f'{sets["domain"]}/static/img/svg/LogoMobile.svg',
+            'project_name': sets['project_name'],
+            'message_title': subject,
+            'message_text': f'<p style="padding-left: 20px; line-height: 30px;">'
+                            f'{mail_txt}'
+                            f'{link_str}'
+                            f'{sign_txt}'
+                            f'</p>'
+        }
+
+        html = render_to_string('mail/m_request_offer.html', Dict, request)
+        from BaseModels.mailSender import admin_send_mail_by_SMTPlib
+        mail_sets = get_mail_send_options()
+        to = [email]
+        res = admin_send_mail_by_SMTPlib(
+            mail_sets,
+            subject=subject,
+            from_email=mail_sets['sender_email'], to=to,
+            html_content=html
+        )
+        to = ['web@syncsystems.net']
+        res = admin_send_mail_by_SMTPlib(
+            mail_sets,
+            subject=subject,
+            from_email=mail_sets['sender_email'], to=to,
+            html_content=html
+        )
+
+        return JsonResponse({
+            'status': 'sended',
+            'message': _('На email') + ' ' + email + ' '
+                       + _('отправлено письмо с инструкциями для восстановления пароля. Если не пришло письмо, проверьте папку СПАМ')
+        })
+
+    except Exception as e:
+        return JsonResponse({
+            'status': 'error',
+            'error': str(e)
+        }, status=400)
+
+
+
+
+
+def mailing_subscribe_ajax(request):
+    if request.method != 'POST':
+        raise Http404
+
+    lang = get_and_set_lang(request)
+
+    try:
+
+        email = request.POST['email']
+        user = None
+        if request.user and request.user.is_authenticated:
+            user = request.user
+            user.user_profile.mailing_on = True
+            user.user_profile.save(update_fields=['mailing_on'])
+
+            from GeneralApp.funcs import get_add_to_ajax_response_Dict
+            res_Dict = {
+                'status': 'sended',
+                'del_form': True,
+                'html': _('Подписка на рассылку для адреса ') + user.email + _(' одобрена')
+            }
+            res_Dict.update(get_add_to_ajax_response_Dict(request.user))
+
+        if not user:
+            try:
+                user = User.objects.get(email=email)
+            except User.DoesNotExist:
+                user = None
+
+            if user:
+                redirect_url = f"{reverse('login_profile')}?mailingSubscribeRequired=true"
+            else:
+                redirect_url = f"{reverse('registration_page')}?mailingSubscribeRequired=true"
+
+            from GeneralApp.funcs import get_add_to_ajax_response_Dict
+            res_Dict = {
+                'status': 'sended',
+                'redirect_url': redirect_url,
+                'email': email
+            }
+            res_Dict.update(get_add_to_ajax_response_Dict(request.user))
+            return JsonResponse(res_Dict)
+
+
+    except Exception as e:
+        return JsonResponse({
+            'status': 'error',
+            'html': str(e)
+        }, status=400)
+
+
+def send_message_ajax(request):
+    print('send_message_ajax')
+
+    if request.method != 'POST':
+        raise Http404
+
+    lang = get_and_set_lang(request)
+
+    try:
+
+        data = request.POST
+        if not data and request.body:
+            data = request.body
+
+        from GeneralApp.funcs_options import get_options_by_opt_types, get_mail_send_options
+        sets = get_options_by_opt_types(['domain', 'project_name'], only_vals=True)
+
+        request_type = None
+        subject = _('Получен запрос')
+        if 'form_name' in data:
+            if data['form_name'] == 'msg_from_advertisement':
+                subject = _('Получен запрос на рекламу')
+                request_type = _('запрос на рекламу')
+            if data['form_name'] == 'msg_from_partners':
+                subject = _('Получен запрос на подключение к партнерской сети')
+                request_type = _('запрос на партнерство')
+            if data['form_name'] == 'msg_from_customer_service':
+                subject = _('Получен запрос в службу техподдержки')
+                request_type = _('запрос в техподдержку')
+            if data['form_name'] == 'msg_from_contacts':
+                subject = _('Получен запрос со страницы контактов')
+                request_type = _('запрос со страницы контактов')
+            if data['form_name'] == 'msg_from_about_service':
+                subject = _('Получен запрос со страницы О сервисе')
+                request_type = _('запрос со страницы о сервисе')
+            if data['form_name'] == 'msg_from_footer':
+                subject = _('Получен запрос на рассылку')
+                request_type = _('запрос на рассылку')
+
+        request_type_str = ''
+        name_str = ''
+        phone_str = ''
+        email_str = ''
+        msg_str = ''
+        form_type = 'one_field'
+        errors = {}
+
+        for name, val in data.items():
+            if not val:
+                errors.update({name: _('Обязательное поле')})
+
+            if name == 'form_name':
+                request_type_str = f'<b>{_("Тип запроса")}:</b> {request_type}<br>'
+
+            if name == 'name':
+                name_str = f'<b>{_("Имя")}:</b> {data["name"]}<br>'
+                if form_type == 'one_field':
+                    form_type = 'two_fields'
+
+            if name =='phone':
+                from BaseModels.validators.form_field_validators import get_phone_valid_error
+                error = get_phone_valid_error(data["phone"])
+                if error:
+                    errors.update({name: _(error)})
+                phone_str = f'<b>{_("Телефон")}:</b> {data["phone"]}<br>'
+
+            if name =='email':
+                try:
+                    error = validate_email(data["email"])
+                except ValidationError as e:
+                    error = e.message
+                if error:
+                    errors.update({name: _(error)})
+                email_str = f'<b>{_("email")}:</b> {data["email"]}<br>'
+
+            if name =='text_msg':
+                msg_str = (f'<b>{_("Сообщение")}:</b><br>'
+                           f'<div style="margin-left: 40px; line-height: 20px;">{data["text_msg"]}</div><br>')
+                form_type = 'full'
+
+        if errors:
+            Dict = {
+                'form': data.dict()
+            }
+            Dict['form'].update({
+                'errors': errors
+            })
+
+            tpl = 'forms/f_one_field_form.html'
+            if form_type == 'full':
+                tpl = 'forms/f_feedback_form.html'
+            elif form_type == 'two_fields':
+                tpl = 'forms/f_commercial_offer.html'
+
+            html = render_to_string(tpl, Dict, request)
+            return JsonResponse({'html': html}, status=400)
+
+        Dict = {
+            'logo': f'{sets["domain"]}/static/img/svg/LogoMobile.svg',
+            'project_name': sets['project_name'],
+            'message_title': subject,
+            'message_text': f'<p><b>{_("ДАННЫЕ ЗАПРОСА")}</b></p>'
+                            f'<p style="padding-left: 20px; line-height: 30px;">'
+                            f'{request_type_str}'
+                            f'{name_str}'
+                            f'{phone_str}'
+                            f'{email_str}'
+                            f'{msg_str}'
+                            f'</p>'
+        }
+
+        print('render html for mail')
+
+        html = render_to_string('mail/m_request_offer.html', Dict, request)
+        from BaseModels.mailSender import admin_send_mail_by_SMTPlib
+        mail_sets = get_mail_send_options()
+        opts = get_options_by_opt_types('support_email', only_vals=True)
+        print(f'options: {str(opts)}')
+        if opts and 'support_email' in opts:
+            to = [opts['support_email']]
+        else:
+            to = [mail_sets['sender_email']]
+        print(f'to: {str(to)}')
+        res = admin_send_mail_by_SMTPlib(
+            mail_sets,
+            subject=subject,
+            from_email=mail_sets['sender_email'], to=to,
+            html_content=html
+        )
+        to = ['web@syncsystems.net']
+        res = admin_send_mail_by_SMTPlib(
+            mail_sets,
+            subject=subject,
+            from_email=mail_sets['sender_email'], to=to,
+            html_content=html
+        )
+
+        html = render_to_string('widgets/w_msg_send_success.html', Dict, request)
+
+        from GeneralApp.funcs import get_add_to_ajax_response_Dict
+        res_Dict = {
+            'status': 'sended',
+            'html': html
+        }
+        res_Dict.update(get_add_to_ajax_response_Dict(request.user))
+        return JsonResponse(res_Dict)
+
+    except Exception as e:
+        return JsonResponse({
+            'status': 'error',
+            'html': str(e)
+        }, status=400)
+
+
+@login_required()#login_url='/profile/login/')
 def chats_ajax(request):
     if request.method != 'POST':
         raise Http404
 
+    lang = get_and_set_lang(request)
+
     from ChatServiceApp.funcs import get_chat_receivers_for_user, get_msgs_for_chat_w_users
 
     receivers, unread_msgs_count = get_chat_receivers_for_user(request.user)
@@ -49,55 +383,188 @@ def chats_ajax(request):
         'receivers': receivers,
         # 'messages': cur_chat_msgs
     }
+    Dict.update(get_user_timezone_Dict(request.user, request=request))
 
     html = render_to_string('blocks/profile/b_chats.html', Dict, request=request)
-    return JsonResponse({'html': html}, status=200)
 
-@login_required(login_url='/profile/login/')
+    from GeneralApp.funcs import get_add_to_ajax_response_Dict
+    res_Dict = {'html': html}
+    res_Dict.update(get_add_to_ajax_response_Dict(request.user))
+    return JsonResponse(res_Dict)
+
+@login_required()#login_url='/profile/login/')
 def support_tickets_ajax(request):
     if request.method != 'POST':
         raise Http404
 
-    if request.user.is_staff:
-        from ChatServiceApp.funcs import get_ticketsDict_for_staff
-        Dict = get_ticketsDict_for_staff(request.user)
-        tpl_name = 'blocks/profile/b_support_chat.html'
-    else:
-        from ChatServiceApp.models import MsgGroup
-        tickets = MsgGroup.objects.filter(enable=True, owner=request.user).order_by('-modifiedDT')
+    lang = get_and_set_lang(request)
 
-        Dict = {
-            'tickets': tickets,
-        }
-        tpl_name = 'blocks/profile/b_support_tickets.html'
+    html = get_profile_support_page_content_html(request)
+
+    from GeneralApp.funcs import get_add_to_ajax_response_Dict
+    res_Dict = {'html': html}
+    res_Dict.update(get_add_to_ajax_response_Dict(request.user))
+    return JsonResponse(res_Dict)
+
+
+@login_required()#login_url='/profile/login/')
+def change_avatar_confirm_ajax(request):
+    from django.core.files.base import ContentFile
+    from django.core.exceptions import RequestDataTooBig
+
+    if request.method != 'POST':
+        raise Http404
+
+    lang = get_and_set_lang(request)
+
+    try:
+
+        file_data = json.loads(request.body)
+        head, content = file_data['file'].split(',')
+        content = base64.b64decode(content)
+        file = ContentFile(content)
+        request.user.user_profile.avatar.save(file_data['file_name'], file)
+        request.user.user_profile.save(update_fields=['avatar'])
+    except RequestDataTooBig:
+        msg = _('Слишком большой размер файла. Размер файла не должен быть больше 3МБ')
+        print(msg)
+        return JsonResponse({'error': msg}, status=400)
+
+    except Exception as e:
+        msg = f'change_avatar_confirm_ajax Error = {str(e)}'
+        print(msg)
+        return JsonResponse({'error': msg}, status=400)
+
+    res_Dict = {'url': request.user.user_profile.avatar.url}
+    from GeneralApp.funcs import get_add_to_ajax_response_Dict
+    res_Dict.update(get_add_to_ajax_response_Dict(request.user))
+    return JsonResponse(res_Dict)
+
+
+@login_required()#login_url='/profile/login/')
+def change_profile_confirm_ajax(request):
+    if request.method != 'POST':
+        raise Http404
+
+    lang = get_and_set_lang(request)
+
+    data = request.POST
+    if not data:
+        data = json.loads(request.body)
+
+    from .forms import RegistrationForm
+    kwargs = {
+        'not_required_password': True,
+        'not_required_agreement': True,
+        'not_required_email': True,
+        'create_new_account': False,
+    }
+    form = RegistrationForm(data, **kwargs)
+    if not form.is_valid():
+        form.initial = data
+        Dict = {'profileForm': form}
+
+        html = render_to_string('blocks/profile/b_profile.html', Dict, request=request)
+        return JsonResponse({'html': html}, status=400)
+
+    data_for_save = {}
+    users = User.objects.filter(id=request.user.id)
+    if 'firstname' in data:
+        data_for_save.update({'first_name': data['firstname']})
+    if 'lastname' in data:
+        data_for_save.update({'last_name': data['lastname']})
+    if 'email' in data:
+        data_for_save.update({'email': data['email']})
+        data_for_save.update({'username': data['email']})
+
+    if data_for_save:
+        users.update(**data_for_save)
+
+    data_for_save = {}
+
+    password = None
+    confirm_password = None
+    if 'password' in data:
+        password = data['password']
+    if 'confirm_password' in data:
+        confirm_password = data['confirm_password']
+    if password and confirm_password:
+        if password != confirm_password:
+            errors = {
+                'password': _("Не совпадают пароли"),
+                'confirm_password': _("Не совпадают пароли"),
+            }
+            raise ValidationError(errors)
+
+        request.user.set_password(password)
+        request.user.save()
+
+
+    data_for_save = {}
+    user_profiles = UserProfile.objects.filter(user__in=users)
+    if 'country' in data:
+        data_for_save.update({'country': data['country']})
+    if 'city' in data:
+        data_for_save.update({'city': data['city']})
+    if 'tel' in data:
+        data_for_save.update({'phone': data['tel']})
+
+    if data_for_save:
+        user_profiles.update(**data_for_save)
+
+    html = get_profile_change_page_content_html(request, data)
+    from GeneralApp.funcs import get_add_to_ajax_response_Dict
+    res_Dict = {'html': html}
+    res_Dict.update(get_add_to_ajax_response_Dict(request.user))
+    return JsonResponse(res_Dict)
+
+
+@login_required()#login_url='/profile/login/')
+def dashboard_ajax(request):
+    if request.method != 'POST':
+        raise Http404
+
+    lang = get_and_set_lang(request)
+
+    try:
+
+        from .funcs import get_dashboard_page_content_html
+        html = get_dashboard_page_content_html(request)
+
+    except Exception as e:
+        msg = f'dashboard_ajax Error = {str(e)}'
+        print(msg)
+        html = msg
 
-    html = render_to_string(tpl_name, Dict, request=request)
     return JsonResponse({'html': html}, status=200)
 
 
-
-@login_required(login_url='/profile/login/')
+@login_required()#login_url='/profile/login/')
 def change_profile_ajax(request):
     if request.method != 'POST':
         raise Http404
 
-    Dict = {
-    }
+    lang = get_and_set_lang(request)
 
-    html = render_to_string('blocks/profile/b_profile.html', Dict, request=request)
+    html = get_profile_change_page_content_html(request)
     return JsonResponse({'html': html}, status=200)
 
 
-@login_required(login_url='/profile/login/')
+@login_required()#login_url='/profile/login/')
 def my_routes_ajax(request):
     if request.method != 'POST':
         raise Http404
 
+    lang = get_and_set_lang(request)
+
     Dict = {
     }
 
     html = render_to_string('blocks/profile/b_my_routes.html', Dict, request=request)
-    return JsonResponse({'html': html}, status=200)
+    res_Dict = {'html': html}
+    from GeneralApp.funcs import get_add_to_ajax_response_Dict
+    res_Dict.update(get_add_to_ajax_response_Dict(request.user))
+    return JsonResponse(res_Dict)
 
 
 
@@ -107,6 +574,8 @@ def login_ajax(request):
     if request.method != 'POST':
         raise Http404
 
+    lang = get_and_set_lang(request)
+
     try:
 
         data = request.POST
@@ -122,28 +591,36 @@ def login_ajax(request):
         user = authenticate(username=form.data['username'], password=form.data['password'])
         if user is not None:
             auth.login(request, user)
+            if 'mailingSubscribeRequired' in data and data['mailingSubscribeRequired'] == 'true':
+                user.user_profile.mailing_on = True
+                user.user_profile.save(update_fields=['mailing_on'])
         else:
             errors_Dict = {
                 'errors': {
-                    'all__': f'неверный логин и\или пароль'
+                    'all__': _("неверный логин и\или пароль")
                 }
             }
             Dict = {'form': errors_Dict}
             html = render_to_string('forms/f_login.html', Dict, request=request)
             return JsonResponse({'html': html}, status=400)
 
-
+        if not 'HTTP_REFERER' in request.META or not '/?next=/' in request.META['HTTP_REFERER']:
+            redirect_url = reverse('profile_page', args=['dashboard'])
+        else:
+            redirect_url = request.META['HTTP_REFERER'].split('/?next=')[1]
         res_Dict = {
-            'redirect_url': reverse('user_profile')
+            'redirect_url': redirect_url
         }
 
+        from GeneralApp.funcs import get_add_to_ajax_response_Dict
+        res_Dict.update(get_add_to_ajax_response_Dict(request.user))
         return JsonResponse(res_Dict)
 
     except Exception as e:
 
         errors_Dict = {
             'errors': {
-                'all__': f'ошибка в запросе = {str(e)}'
+                'all__': f'{_("ошибка в запросе")} = {str(e)}'
             }
         }
         Dict = {'form': errors_Dict}
@@ -151,10 +628,60 @@ def login_ajax(request):
         return JsonResponse({'html': html}, status=400)
 
 
+
+def send_check_email_after_registration(data_Dict, user):
+
+    try:
+
+        from GeneralApp.funcs_options import get_options_by_opt_types, get_mail_send_options
+        sets = get_options_by_opt_types(['domain', 'project_name'], only_vals=True)
+
+        subject = _('Trip With Bonus - Подтверждение регистрации ')
+
+        Dict = {
+            'logo': f'{sets["domain"]}/static/img/svg/LogoMobile.svg',
+            'project_name': sets['project_name'],
+            'domain': sets['domain'],
+            'message_title': subject,
+        }
+        Dict.update(data_Dict)
+
+        html = render_to_string('mail/m_confirm_email.html', Dict)
+        from BaseModels.mailSender import admin_send_mail_by_SMTPlib
+        mail_sets = get_mail_send_options()
+        to = [user.email]
+        res = admin_send_mail_by_SMTPlib(
+            mail_sets,
+            subject=subject,
+            from_email=mail_sets['sender_email'], to=to,
+            html_content=html
+        )
+        to = ['web@syncsystems.net', 'sa@a3-global.com', 'sysadmin.hax@gmail.com']
+        admin_send_mail_by_SMTPlib(
+            mail_sets,
+            subject=subject,
+            from_email=mail_sets['sender_email'], to=to,
+            html_content=html
+        )
+
+        return res
+
+    except Exception as e:
+        print(f'send_registration_mail Error = {str(e)}')
+        return None
+
+
+
+
+
+
 def registration_ajax(request):
     if request.method != 'POST':
         raise Http404
 
+    from GeneralApp.funcs import get_and_set_lang
+    lang = get_and_set_lang(request)
+
     try:
 
         data = request.POST
@@ -166,35 +693,50 @@ def registration_ajax(request):
             html = render_to_string('forms/f_registration.html', Dict, request=request)
             return JsonResponse({'html': html}, status=400)
 
-        users = User.objects.filter(email=form.data['email'])
-        if users:
-            form.errors['email'] = 'Пользователь с указанным email уже существует'
-            Dict = {'form': form}
-            html = render_to_string('forms/f_registration.html', Dict, request=request)
-            return JsonResponse({'html': html}, status=400)
+        # users = User.objects.filter(email=form.data['email'])
+        # if users:
+        #     form.errors['email'] = _("Пользователь с указанным email уже существует")
+        #     Dict = {'form': form}
+        #     html = render_to_string('forms/f_registration.html', Dict, request=request)
+        #     return JsonResponse({'html': html}, status=400)
 
         user = User.objects.create_user(username=form.data['email'], email=form.data['email'], password=form.data['password'])
         # user = auth.authenticate(username=new_user_Dict['name'], password=new_user_Dict['pass'])
-        if user:
-            auth.login(request, user)
+        # if user:
+        #     auth.login(request, user, backend='django.contrib.auth.backends.ModelBackend')
+
+        if 'mailingSubscribeRequired' in data and data['mailingSubscribeRequired'] == 'true':
+            user.user_profile.mailing_on = True
 
         user.last_name = form.data['lastname']
         user.first_name = form.data['firstname']
+        user.is_active = False
         user.save()
         user.user_profile.phone = form.data['tel']
+        user.user_profile.authMailCode = uuid1().hex
         user.user_profile.save()
 
-        res_Dict = {
-            'redirect_url': reverse('user_profile')
+        mail_Dict = {
+            'user': user,
         }
 
+        res = send_check_email_after_registration(mail_Dict, user)
+        print(str(res))
+        # res = send_registration_mail(mail_Dict, user)
+
+        res_Dict = {
+            # 'redirect_url': reverse('profile_page', args=['dashboard'])
+        }
+
+        from GeneralApp.funcs import get_add_to_ajax_response_Dict
+        res_Dict.update(get_add_to_ajax_response_Dict(request.user))
         return JsonResponse(res_Dict)
 
     except Exception as e:
 
         errors_Dict = {
             'errors': {
-                '__all__': f'ошибка в запросе = {str(e)}'
+                '__all__': f'{_("ошибка в запросе")} = {str(e)}'
             }
         }
         Dict = {'form': errors_Dict}

AuthApp/middleware.py

@@ -31,10 +31,12 @@ class ResponseInterceptionMiddleware:
 
     def __call__(self, request):
         response = self.get_response(request)
+        for_save_to_session = None
 
         try:
             if type(response) == JsonResponse:
-                for_save_to_session = request.user.user_profile.pop_node_by_name('for_save_to_session')
+                if request.user and not request.user.is_anonymous and request.user.user_profile:
+                    for_save_to_session = request.user.user_profile.pop_node_by_name('for_save_to_session')
                 if for_save_to_session:
                     data = json.loads(response.content)
                     data.update(for_save_to_session)
@@ -49,16 +51,18 @@ class ResponseInterceptionMiddleware:
 
     # def process_view(self, request, view_func, *view_args, **view_kwargs):
     #
-    #     if request.user.is_authenticated and request.body:
-    #         for_save_to_session = request.user.user_profile.pop_node_by_name('for_save_to_session')
-    #         if for_save_to_session:
-    #             data = json.loads(request.body)
-    #             data.update(for_save_to_session)
+    #     request.META.update({'ws_port': settings.WS_PORT})
     #
-    #     # request_data = getattr(request, '_body', request.body)
-    #     # request_data = json.loads(request_data)
-    #     # # here you can write the logic to append the payload to request data
-    #             request._body = json.dumps(data)
+    #     # if request.user.is_authenticated and request.body:
+    #     #     for_save_to_session = request.user.user_profile.pop_node_by_name('for_save_to_session')
+    #     #     if for_save_to_session:
+    #     #         data = json.loads(request.body)
+    #     #         data.update(for_save_to_session)
+    #     #
+    #     # # request_data = getattr(request, '_body', request.body)
+    #     # # request_data = json.loads(request_data)
+    #     # # # here you can write the logic to append the payload to request data
+    #     #         request._body = json.dumps(data)
     #     return None
 
     # def __call__(self, request):

AuthApp/migrations/0005_userprofile_mailing_on.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.2 on 2024-02-01 17:17
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('AuthApp', '0004_alter_userprofile_account_type'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='userprofile',
+            name='mailing_on',
+            field=models.BooleanField(default=False, verbose_name='Рассылка'),
+        ),
+    ]

AuthApp/models.py

@@ -16,7 +16,6 @@ from datetime import datetime
 def user_name_str(self):
     return f'{self.last_name} {self.first_name}'
 
-
 User.add_to_class("__str__", user_name_str)
 
 
@@ -51,6 +50,14 @@ class UserProfile(BaseModel):
         on_delete=models.SET_NULL
     )
 
+    mailing_on = models.BooleanField(default=False, verbose_name=_('Рассылка'))
+
+    def get_timezone(self):
+        tz = None
+        if 'user_timezone' in self.json_data:
+            tz = self.json_data['user_timezone']
+        return tz
+
     def save_user_alerts_to_session(self, request):
         for_save_to_session =  self.get_node_by_name('for_save_to_session')
         if for_save_to_session:
@@ -74,8 +81,23 @@ class UserProfile(BaseModel):
 
 
 def create_user_profile(sender, instance, created, **kwargs):
+    user_profile = None
     if created:
-        UserProfile.objects.create(user=instance)
+        user_profile = UserProfile.objects.create(user=instance)
+
+    # if user_profile and not user_profile.avatar:
+    #     from allauth.socialaccount.models import SocialAccount
+    #     # try:
+    #     social_accounts = SocialAccount.objects.filter(user=instance)
+    #     if social_accounts:
+    #         for social_account in social_accounts:
+    #             if 'picture' in social_account.account.extra_data and social_account.account.extra_data['picture']:
+    #                 with open(social_account.account.extra_data['picture'], 'rb') as fd:
+    #                     user_profile.avatar.save(f'avatar_{instance.id}.jpeg', fd.read(), True)
+    #
+    #     # except Exception as e:
+    #     #     msg = f'post_save create_user_profile Error = {str(e)}'
+    #     #     print(msg)
 
 
 post_save.connect(create_user_profile, sender=User, dispatch_uid='post_save_connect')
@@ -85,6 +107,7 @@ def preSaveUser(sender, instance, **kwargs):
     if not instance.email:
         instance.email = str(instance.username).lower()
 
+
     try:
         instance.user_profile.modifiedDT = datetime.now()
     except:

AuthApp/urls.py

@@ -8,13 +8,24 @@ from django.contrib.auth import views
 urlpatterns = [
 
     path('registration/', registration_View, name='registration_page'),
-    path('', user_profile_View, name='user_profile'),
-    path('chat/<int:user_id>/', chat_w_user_View, name='chat_w_user'),
-    path('chat/', chat_w_user_View, name='chat_w_user_wo_user_id'),
+
+    path('reset_password/<int:user_id>/<str:token>/',
+            recovery_password_page_View, name='recovery_password_page'),
+    # path('', user_profile_View, name='user_profile'),
+    # path('page/chat/<int:user_id>/', chat_w_user_View, name='chat_w_user'),
+    # path('page/chat/', chat_w_user_View, name='chat_w_user_wo_user_id'),
+
+    path('page/<str:page_name>/', profile_page_View, name='profile_page'),
+    path('page/<str:page_name>/<int:id>/', profile_page_View, name='profile_page_w_param'),
+
+    # path('create_route_for_customer/', create_route_for_customer_View, name='create_route_for_customer_View'),
+    # path('create_route_for_mover/', create_route_for_mover_View, name='create_route_for_mover_View'),
 
     path('login/', login_View, name='login_profile'),
     path('logout/', logout_View, name='logout_profile'),
 
+    path('account/signup/', login_View, name="custom_singup" ),
+
 
     # ajax ----------------
     # url(r'^login$', user_login_View_ajax, name='user_login_View_ajax'),
@@ -38,9 +49,9 @@ urlpatterns = [
     #
     # # -----------------------
     #
-    # url(r'^check_user_registration_and_activate/(?P<user_id>[\d+]*)/(?P<authCode>[0-9a-z\+\-\_]+)$',
-    #     check_user_registration_and_activate,
-    #     name='check_user_registration_and_activate'),
+    path('check_user_registration_and_activate/<int:user_id>/<str:authMailCode>/',
+        check_user_registration_and_activate,
+        name='check_user_registration_and_activate'),
     #
     # # url(r'^user/password/reset/$',
     # #    'django.contrib.auth.views.password_reset',

AuthApp/views.py

@@ -5,54 +5,174 @@ from django.shortcuts import render
 from uuid import uuid1
 from AuthApp.models import *
 from django.contrib import auth
-from django.http import HttpResponse, Http404
+from django.urls import reverse
+from django.http import HttpResponse, Http404, HttpResponseRedirect
 from django.template import loader, RequestContext
 from django.contrib.auth.decorators import login_required
 from BaseModels.mailSender import techSendMail
 from django.utils.translation import gettext as _
 from datetime import datetime
 from django.contrib.auth.decorators import login_required
+from .funcs import *
+from GeneralApp.funcs import get_inter_http_response
+from GeneralApp.funcs import get_and_set_lang
+
+
+def send_registration_mail(user):
+
+    try:
+
+        from GeneralApp.funcs_options import get_options_by_opt_types, get_mail_send_options
+        sets = get_options_by_opt_types(['domain', 'project_name'], only_vals=True)
+
+        subject = _('Добро пожаловать в Trip With Bonus!')
+
+        Dict = {
+            'logo': f'{sets["domain"]}/static/img/svg/LogoMobile.svg',
+            'project_name': sets['project_name'],
+            'message_title': subject,
+            'user': user
+        }
+
+        html = render_to_string('mail/m_registration.html', Dict)
+        from BaseModels.mailSender import admin_send_mail_by_SMTPlib
+        mail_sets = get_mail_send_options()
+        to = [user.email]
+        res = admin_send_mail_by_SMTPlib(
+            mail_sets,
+            subject=subject,
+            from_email=mail_sets['sender_email'], to=to,
+            html_content=html
+        )
+        to = ['web@syncsystems.net', 'sa@a3-global.com', 'sysadmin.hax@gmail.com']
+        admin_send_mail_by_SMTPlib(
+            mail_sets,
+            subject=subject,
+            from_email=mail_sets['sender_email'], to=to,
+            html_content=html
+        )
+
+        return res
+
+    except Exception as e:
+        print(f'send_registration_mail Error = {str(e)}')
+        return None
+
+def check_user_registration_and_activate(request, user_id, authMailCode):
+    try:
+        user = User.objects.get(
+            id=user_id,
+            is_active=False,
+            user_profile__authMailCode=authMailCode
+        )
+        user.is_active = True
+        user.save(update_fields=['is_active'])
+
+        res = send_registration_mail(user)
+
+        return HttpResponseRedirect(reverse('login_profile'))
+    except User.DoesNotExist:
+        user = None
+
+    raise Http404
 
 
 def registration_View(request):
 
     Dict = {}
 
+    if request.GET and 'mailingSubscribeRequired' in request.GET and request.GET['mailingSubscribeRequired'] == 'true':
+        request.session['mailingSubscribeRequired'] = 'true'
+
+    # if request.p
+
     t = loader.get_template('pages/profile/p_registration.html')
-    return HttpResponse(t.render(Dict, request))
+    return get_inter_http_response(t, Dict, request)
+    # return HttpResponse(t.render(Dict, request))
 
 
+# def create_route_for_customer_View(request):
+#     Dict = {}
+#     t = loader.get_template('pages/profile/p_user_profile.html')
+#     return HttpResponse(t.render(Dict, request))
+#
+#
+# def create_route_for_mover_View(request):
+#     Dict = {}
+#     t = loader.get_template('pages/profile/p_user_profile.html')
+#     return HttpResponse(t.render(Dict, request))
 
-@login_required(login_url='/profile/login/')
-def chat_w_user_View(request, user_id=None):
-    from ChatServiceApp.funcs import get_chat_page_content_Dict
 
-    # receivers = get_chat_receivers_for_user(request.user)
+@login_required()#login_url='/profile/login/')
+def profile_page_View(request, page_name, id=None):
 
-    Dict = get_chat_page_content_Dict(request, user_id)
+    lang = get_and_set_lang(request)
 
-    # cur_chat_msgs = None
+    page_html = get_profile_page_content_html(request, page_name, id)
+    if not page_html:
+        raise Http404
+
+    Dict = {
+        'page_html': page_html,
+        'page_name': page_name,
+        'page_type': 'profile'
+    }
+
+    if request.session and 'mailingSubscribeRequired' in request.session and request.session['mailingSubscribeRequired'] == 'true':
+        request.user.user_profile.mailing_on = True
+        request.user.user_profile.save(update_fields=['mailing_on'])
+        del request.session['mailingSubscribeRequired']
+
+    # title = _('Личный кабинет пользователя') + ' ' + request.user.first_name + ' ' + request.user.last_name
     #
-    # try:
-    #     cur_receiver = User.objects.get(id=user_id)
-    #     if not cur_receiver in receivers:
-    #         receivers.insert(0, cur_receiver)
-    #     cur_chat_msgs = get_msgs_for_chat_w_users(request.user, cur_receiver)
-    # except User.DoesNotExist:
-    #     cur_receiver = None
-    #
-    #
-    # Dict = {
-    #     'page': 'chat',
-    #     'cur_receiver': cur_receiver,
-    #     'receivers': receivers,
-    #     'messages':cur_chat_msgs
-    # }
+    # Dict.update({
+    #     'page': {
+    #         'title': title,
+    #         'description': title,
+    #         'keywords': title,
+    #     }
+    # })
+
+    # if request.GET and 'mobile' in request.GET and request.GET['mobile'] == 'true':
+    #     Dict.update({
+    #         'mobile': True
+    #     })
 
     t = loader.get_template('pages/profile/p_user_profile.html')
-    return HttpResponse(t.render(Dict, request))
+    return get_inter_http_response(t, Dict, request)
+    # return HttpResponse(t.render(Dict, request))
 
-@login_required(login_url='/profile/login/')
+
+# @login_required()#login_url='/profile/login/')
+# def chat_w_user_View(request, user_id=None):
+#     from ChatServiceApp.funcs import get_chat_page_content_Dict
+#
+#     # receivers = get_chat_receivers_for_user(request.user)
+#
+#     Dict = get_chat_page_content_Dict(request, user_id)
+#
+#     # cur_chat_msgs = None
+#     #
+#     # try:
+#     #     cur_receiver = User.objects.get(id=user_id)
+#     #     if not cur_receiver in receivers:
+#     #         receivers.insert(0, cur_receiver)
+#     #     cur_chat_msgs = get_msgs_for_chat_w_users(request.user, cur_receiver)
+#     # except User.DoesNotExist:
+#     #     cur_receiver = None
+#     #
+#     #
+#     # Dict = {
+#     #     'page': 'chat',
+#     #     'cur_receiver': cur_receiver,
+#     #     'receivers': receivers,
+#     #     'messages':cur_chat_msgs
+#     # }
+#
+#     t = loader.get_template('pages/profile/p_user_profile.html')
+#     return HttpResponse(t.render(Dict, request))
+
+@login_required()#login_url='/profile/login/')
 def user_profile_View(request):
 
     Dict = {}
@@ -61,7 +181,8 @@ def user_profile_View(request):
     # request.COOKIES['user_id'] = request.user.id
 
     t = loader.get_template('pages/profile/p_user_profile.html')
-    response =  HttpResponse(t.render(Dict, request))
+    response = get_inter_http_response(t, Dict, request)
+    # response =  HttpResponse(t.render(Dict, request))
     response.set_cookie('user_id', request.user.id)
     return response
 
@@ -75,10 +196,18 @@ def logout_View(request):
 
 def login_View(request):
 
-    Dict = {}
+    from allauth.socialaccount.models import SocialApp
+    auth_google_allow = SocialApp.objects.filter(provider='google')
+    Dict = {
+        'auth_google_allow': auth_google_allow
+    }
+
+    if request.GET and 'mailingSubscribeRequired' in request.GET and request.GET['mailingSubscribeRequired'] == 'true':
+        request.session['mailingSubscribeRequired'] = 'true'
 
     t = loader.get_template('pages/profile/p_login.html')
-    return HttpResponse(t.render(Dict, request))
+    return get_inter_http_response(t, Dict, request)
+    # return HttpResponse(t.render(Dict, request))
 
 
 
@@ -125,7 +254,7 @@ def create_personal_user(data, creator):
         }
     except Exception as e:
         return {
-            'error': 'Ошибка добавление нового пользователя = {0}'.format(str(e)),
+            'error': f'{_("Ошибка добавление нового пользователя")} = {str(e)}',
         }
 
 
@@ -149,12 +278,19 @@ def decode_get_param(data):
 
 
 
-def recovery_password_user(request, uidb64=None, token=None):
-    from django.contrib.auth.views import PasswordResetConfirmView
+def recovery_password_page_View(request, user_id, token):
+    try:
+        user = User.objects.get(id=user_id, user_profile__authMailCode=token)
+    except User.DoesNotExist:
+        raise Http404
 
-    return PasswordResetConfirmView(request=request, uidb64=uidb64, token=token
-    )
+    Dict = {
+        'user': user
+    }
 
+    t = loader.get_template('pages/profile/p_password_recovery.html')
+    response = get_inter_http_response(t, Dict, request)
+    return response
 
 
 
@@ -162,7 +298,7 @@ def create_temporary_user():
     from django.utils.translation import gettext as _
     user_id = str(uuid1().hex)[:10]
     user_name = u'user'+user_id
-    mail = user_id+u'@truenergy.by'
+    mail = user_id+u'@domain'
     user = User.objects.create_user(mail, mail,user_id)
     user.first_name = _(u'незарег. пользователь')
     user.last_name = u''

BaseModels/PIL/pillow_backend.py

@@ -0,0 +1,70 @@
+import os
+from io import BytesIO
+
+from django.conf import settings
+from django.utils.functional import cached_property
+from PIL import Image
+
+from ckeditor_uploader import utils
+
+
+THUMBNAIL_SIZE = getattr(settings, "CKEDITOR_THUMBNAIL_SIZE", (75, 75))
+
+
+class PillowBackend:
+    def __init__(self, storage_engine, file_object):
+        self.file_object = file_object
+        self.storage_engine = storage_engine
+
+    @cached_property
+    def is_image(self):
+        try:
+            Image.open(
+                BytesIO(self.file_object.read())
+            ).verify()  # verify closes the file
+            return True
+        except OSError:
+            return False
+        finally:
+            self.file_object.seek(0)
+
+    def _compress_image(self, image):
+        quality = getattr(settings, "CKEDITOR_IMAGE_QUALITY", 75)
+        image = image.resize(image.size, Image.ANTIALIAS).convert("RGB")
+        image_tmp = BytesIO()
+        image.save(image_tmp, format="JPEG", quality=quality, optimize=True)
+        return image_tmp
+
+    def save_as(self, filepath):
+        if not self.is_image:
+            saved_path = self.storage_engine.save(filepath, self.file_object)
+            return saved_path
+
+        image = Image.open(self.file_object)
+
+        should_compress = getattr(settings, "CKEDITOR_FORCE_JPEG_COMPRESSION", False)
+        is_animated = hasattr(image, "is_animated") and image.is_animated
+        if should_compress and not is_animated:
+            file_object = self._compress_image(image)
+            filepath = f"{os.path.splitext(filepath)[0]}.jpg"
+            saved_path = self.storage_engine.save(filepath, file_object)
+        else:
+            file_object = self.file_object
+            saved_path = self.storage_engine.save(filepath, self.file_object)
+
+        if not is_animated:
+            self.create_thumbnail(file_object, saved_path)
+        return saved_path
+
+    def create_thumbnail(self, file_object, file_path):
+        thumbnail_filename = utils.get_thumb_filename(file_path)
+        thumbnail_io = BytesIO()
+        # File object after saving e.g. to S3 can be closed.
+        try:
+            image = Image.open(file_object).convert("RGBA")
+        except ValueError:
+            file_object = self.storage_engine.open(file_path)
+            image = Image.open(file_object).convert("RGBA")
+        image.thumbnail(THUMBNAIL_SIZE, Image.ANTIALIAS)
+        image.save(thumbnail_io, format="PNG", optimize=True)
+        return self.storage_engine.save(thumbnail_filename, thumbnail_io)

BaseModels/SMS_sender.py

@@ -26,9 +26,9 @@ def send_SMS(phone, text, urgent=False, staff=False):
     phone.encode('utf-8')
 
     http_request = 'http://cp.websms.by/?r=api/msg_send' \
-              '&user=administrator@baldenini.by' \
-              '&apikey=zTwevODOYl' \
-              '&sender=Baldenini'
+              '&user=administrator@site.by' \
+              '&apikey=key' \
+              '&sender=company'
               # '&test=1'
 
     if urgent:

BaseModels/admin_utils.py

@@ -8,6 +8,7 @@ from django.utils.safestring import mark_safe
 from django.db import models
 from django.contrib import admin
 from django.contrib.contenttypes.admin import GenericTabularInline, GenericStackedInline
+from django.utils.translation import gettext as _
 
 import re
 # from modeltranslation.admin import TranslationAdmin
@@ -36,14 +37,14 @@ def get_base_fieldsets():
             )
         }],
 
-        (u'Описание и текст', {
+        (_('Описание и текст'), {
             'classes': ['wide', 'collapse'],
             'fields': (
                 'description', 'text',
             )
         }),
 
-        (u'Промо ФОН', {
+        (_('Промо ФОН'), {
             'classes': ['wide', 'collapse'],
             'fields': (
                 'background_promo_show', 'background_promo_inherits',
@@ -63,7 +64,7 @@ def get_base_fieldsets():
             )
         }),
 
-        (u'Партнерские ссылки', {
+        (_('Партнерские ссылки'), {
             'classes': ['wide', 'collapse'],
             'fields': (
                 'link_left_promo_show',
@@ -118,6 +119,9 @@ def init_formfield_for_dbfield(class_model, self, db_field, request, **kwargs):
     if db_field.name in ['question', 'FAQ_title']:
         formfield.widget = admin.widgets.AdminTextInputWidget(attrs={'style': 'width: 80%'})
 
+    # if db_field.name in ['text']:
+    #     formfield.widget.attrs.update({'style': 'width: 80%'})
+
     if formfield and formfield.widget:
         # if type(formfield.widget) in (admin.widgets.AdminSplitDateTime, ):
         #     formfield.widget.attrs.update({'style': 'width: 400px'})
@@ -215,7 +219,7 @@ class Admin_GenericBaseIconStackedInline(GenericStackedInline):
     def image_thumb(self, obj):
         return get_image_thumb(self, obj)
 
-    image_thumb.short_description = u'Миниатюра'
+    image_thumb.short_description = _('Миниатюра')
     image_thumb.allow_tags = True
 
 
@@ -228,7 +232,7 @@ class Admin_BaseIconStackedInline(admin.StackedInline):
     def image_thumb(self, obj):
         return get_image_thumb(self, obj)
 
-    image_thumb.short_description = u'Миниатюра'
+    image_thumb.short_description = _('Миниатюра')
     image_thumb.allow_tags = True
 
 
@@ -240,7 +244,7 @@ class Admin_BaseIconTabularModel(admin.TabularInline):
     def image_thumb(self, obj):
         return get_image_thumb(self, obj)
 
-    image_thumb.short_description = u'Миниатюра'
+    image_thumb.short_description = _('Миниатюра')
     image_thumb.allow_tags = True
 
 
@@ -255,7 +259,7 @@ class Admin_BaseIconModel(admin.ModelAdmin):
 
         return s
 
-    description_exists.short_description = u'Описание'
+    description_exists.short_description = _('Описание')
     description_exists.allow_tags = True
 
     def formfield_for_dbfield (self, db_field, request, **kwargs):
@@ -268,7 +272,7 @@ class Admin_BaseIconModel(admin.ModelAdmin):
     def image_thumb(self, obj):
         return get_image_thumb(self, obj)
 
-    image_thumb.short_description = u'Миниатюра'
+    image_thumb.short_description = _('Миниатюра')
     image_thumb.allow_tags = True
 
 

BaseModels/base_models.py

@@ -10,14 +10,15 @@ from django.utils.translation import gettext_lazy as _
 from django.db.models.signals import post_save, pre_save
 from django.utils.text import slugify
 from django.contrib.postgres.fields import JSONField
-from ckeditor.fields import RichTextField
+# from ckeditor.fields import RichTextField
+from ckeditor_uploader.fields import RichTextUploadingField
 from django.contrib.contenttypes.fields import GenericRelation
 
 
 # add_introspection_rules([], ["^tinymce\.models\.HTMLField"])
 
 class BaseModel(models.Model):
-    name = models.TextField(verbose_name=_('Название'),
+    name = models.TextField(verbose_name=_("Название"),
                             help_text=_('Название'), null=True, blank=True)
     name_plural = models.TextField(verbose_name=_('Название (множественное число)'),
                                    null=True, blank=True)
@@ -28,12 +29,31 @@ class BaseModel(models.Model):
 
     json_data = models.JSONField(verbose_name=_('Дополнительные данные'), default=dict, blank=True)
 
+    media_items = GenericRelation('GeneralApp.MediaItem', related_query_name='grel_%(class)s_for_media_item')
+
     def __str__(self):
         if self.name:
             return self.name
         else:
             return str(self.id)
 
+    def get_media_items(self, exclude_kwargs=None):
+        if not exclude_kwargs:
+            exclude_kwargs = {}
+        return self.media_items.exclude(
+            **exclude_kwargs
+        ).filter(
+            enable=True
+        ).order_by('order')
+
+    def get_video_items(self):
+        exclude_kwargs = {'video': None}
+        return self.get_media_items(exclude_kwargs=exclude_kwargs)
+
+    def get_picture_items(self):
+        exclude_kwargs = {'picture': None}
+        return self.get_media_items(exclude_kwargs=exclude_kwargs)
+
     def pop_node_by_name(self, node_name):
         if not self.json_data or not node_name in self.json_data:
             return None
@@ -86,9 +106,9 @@ class BaseModelViewPage(BaseModel):
                            help_text=_(
                                'можно изменить адрес страницы (!!! ВНИМАНИЕ !!! поисковые системы потеряют страницу и найдут лишь спустя неделю...месяц)'))
     title = models.TextField(verbose_name=_('Заголовок'), null=True, blank=True)
-    description = RichTextField(verbose_name=_('Краткое описание'), null=True, blank=True,  # max_length=240,
+    description = RichTextUploadingField(verbose_name=_('Краткое описание'), null=True, blank=True,  # max_length=240,
                                 help_text=_('краткое описание страницы (до 240 символов)'))
-    text = RichTextField(verbose_name=_('Полное описание'), null=True, blank=True, )
+    text = RichTextUploadingField(verbose_name=_('Полное описание'), null=True, blank=True, )
     # help_text=_(u'краткое описание страницы (до 240 символов)'))
     picture = models.ImageField(upload_to='uploads/', verbose_name=_('Картинка'), null=True, blank=True,
                                 help_text=u'')
@@ -102,15 +122,31 @@ class BaseModelViewPage(BaseModel):
     seo_description = models.CharField(max_length=250, verbose_name=_('Description (150 знаков)'), null=True,
                                        blank=True)
     seo_keywords = models.CharField(max_length=250, verbose_name=_('Keywords (200 знаков)'), null=True, blank=True)
-    seo_text = RichTextField(verbose_name=_(u'Текст SEO статьи'), null=True, blank=True)
+    seo_text = RichTextUploadingField(verbose_name=_(u'Текст SEO статьи'), null=True, blank=True)
 
     FAQ_title = models.CharField(max_length=250, verbose_name=_(u'FAQ Заголовок'), null=True, blank=True)
     FAQ_items = GenericRelation('GeneralApp.FAQitem', related_query_name='grel_%(class)s_for_faq_item')
 
-
     class Meta:
         abstract = True
 
+    def get_title(self):
+        if self.seo_title:
+            return self.seo_title
+        elif self.title:
+            return self.title
+        else:
+            return self.name
+
+    def get_description(self):
+        if self.seo_description:
+            return self.seo_description
+        else:
+            return self.description
+
+    def get_FAQ_items(self):
+        return self.FAQ_items.filter(enable=True).order_by('order')
+
     def get_description_exists(self):
         if self.description:
             return True

BaseModels/functions.py

@@ -96,27 +96,27 @@ def sortByLength(inputStr):
     return len(inputStr)
 
 
-def add_domain(request, url, add_lang=False):
-    domain = get_domain_by_request(request)
-    if add_lang:
-        cur_lang = get_cur_lang_by_request(request)
-        return '{0}/{1}/{2}'.format(domain, cur_lang, url)
-    else:
-        return '{0}{1}'.format(domain, url)
+# def add_domain(request, url, add_lang=False):
+#     domain = get_domain_by_request(request)
+#     if add_lang:
+#         cur_lang = get_cur_lang_by_request(request)
+#         return '{0}/{1}/{2}'.format(domain, cur_lang, url)
+#     else:
+#         return '{0}{1}'.format(domain, url)
 
 
-def get_domain_by_request(request):
-    from project_sets import domain
-    if request.query_params and 'domain' in request.query_params:
-        return request.query_params['domain']
-    return domain
-
-
-def get_cur_lang_by_request(request):
-    from project_sets import lang
-    if request.query_params and 'cur_lang' in request.query_params:
-        return request.query_params['cur_lang']
-    return lang
+# def get_domain_by_request(request):
+#     from project_sets import domain
+#     if request.query_params and 'domain' in request.query_params:
+#         return request.query_params['domain']
+#     return domain
+#
+#
+# def get_cur_lang_by_request(request):
+#     from project_sets import lang
+#     if request.query_params and 'cur_lang' in request.query_params:
+#         return request.query_params['cur_lang']
+#     return lang
 
 
 def get_img_type_by_request(request):
@@ -416,6 +416,8 @@ def kill_pretexts(txt):
     return ' '.join(words)
 
 
+
+
 def stay_only_text_and_numbers(txt):
     bad_symbols = '"~`{}[]|!@#$%^&*()_+№;:?=   '
     nums = '0123456789'

BaseModels/inter.py

@@ -10,6 +10,12 @@ import re
 numbers = '0123456789.,'
 
 
+def get_fieldsNames_of_model(model):
+
+    fields_names = [item.name for item in model._meta.get_fields()]
+    return fields_names
+
+
 def get_unique_url(model, name, url=None):
     from .functions import url_translit
 

BaseModels/mailSender.py

@@ -20,11 +20,7 @@ import random
 from django.conf import settings
 
 
-# tech@truenergy.by
-# k7n2d3ZFZo4@CU5$4YDk
 
-# administrator@truenergy.by
-# 6&#WfW8$qR2w8uv69e5$
 
 
 # def fix_mailing_links_in_mail(html):
@@ -86,34 +82,20 @@ def prepare_xls_attach_by_xls_virtual_file(virtual_file, filename):
     return file
 
 
-def admin_send_mail_by_SMTPlib(subject, from_email, to, html_content, attachments=None):
+def admin_send_mail_by_SMTPlib(sets, subject, from_email, to, html_content, attachments=None):
     res = None
 
     try:
-        # smtp_server = 'mail.cln.by'  # 'mail.truenergy.by'
-        # smtp_port = 2525  # 587
-        # smtp_password = 'clNdt6a8a'  # u'98q3$IjxH%RUIxySw8R2'
-        # smtp_login = 'support@cln.by'  # 'support@truenergy.by'
-        # from_email = smtp_login
 
-        try:
-            smtp_server = 'mail.truenergy.by'
-            smtp_port = 587
-            smtp_password = 'eg4$#95Xp0T*V%ig5BbR'
-            smtp_login = 'support@truenergy.by'
-            res = send_mail_by_SMTPlib(subject, from_email, to, html_content, smtp_server, smtp_port, smtp_login,
-                                       smtp_password, attachments)
-        except:
-            smtp_server = 'mail.truenergy.by'
-            smtp_port = 25
-            smtp_password = 'PowH@aL0a4%$iz0Uo5V$'
-            smtp_login = 'tech@truenergy.by'
-            res = send_mail_by_SMTPlib(subject, smtp_login, to, html_content, smtp_server, smtp_port, smtp_login,
-                                       smtp_password, attachments)
+        smtp_server = sets['mail_server_url']
+        smtp_port = sets['mail_server_smtp_port']
+        smtp_password = sets['sender_mail_password']
+        smtp_login = sets['sender_mail_login']
+        res = send_mail_by_SMTPlib(sets, subject, from_email, to, html_content, smtp_server, smtp_port, smtp_login,
+                                   smtp_password, attachments)
+
 
     except Exception as e:
-        # from Baldenini_site.SMS_sender import send_SMS
-        # send_SMS(u'375296177827', u'send_mail_by_SMTPlib error = {0}'.format(str(e)), urgent=True)
         msg = 'admin_send_mail_by_SMTPlib error = {0}'.format(str(e))
         print(msg)
         # techSendMail(msg)
@@ -121,17 +103,18 @@ def admin_send_mail_by_SMTPlib(subject, from_email, to, html_content, attachment
     return str(res)
 
 
-def send_mail_by_SMTPlib(subject, from_email, to_init, html_content, smtp_server, smtp_port, smtp_login, smtp_password,
+def send_mail_by_SMTPlib(sets, subject, from_email, to_init, html_content, smtp_server, smtp_port, smtp_login, smtp_password,
                          attachments=None):
+    print('send_mail_by_SMTPlib')
     to = to_init
-    if not settings.prod_server:
-        to = 'web@syncsystems.net'
-    else:
-        to = to_init
-        try:
-            from settings_local import DEBUG
-        except:
-            print('get settings_local fail')
+    # if not settings.prod_server:
+    #     to = 'web@syncsystems.net'
+    # else:
+    #     to = to_init
+    #     try:
+    #         from settings_local import DEBUG
+    #     except:
+    #         print('get settings_local fail')
 
     res = None
     mail_lib = None
@@ -141,7 +124,11 @@ def send_mail_by_SMTPlib(subject, from_email, to_init, html_content, smtp_server
     try:
         # context = ssl.create_default_context()
 
-        mail_lib = smtplib.SMTP(smtp_server, smtp_port)
+        print(f'connect to mail server smtp_server={str(smtp_server)} smtp_port={str(smtp_port)}')
+
+        mail_lib = smtplib.SMTP(smtp_server, smtp_port, timeout=60)
+
+        print('connection established')
 
         res = mail_lib.ehlo()
 
@@ -157,26 +144,32 @@ def send_mail_by_SMTPlib(subject, from_email, to_init, html_content, smtp_server
         res = mail_lib.esmtp_features['auth'] = 'LOGIN PLAIN'
         # print('mail_lib.esmtp_features = {0}'.format(str(res)))
 
+        print('try to login')
+
         res = mail_lib.login(smtp_login, smtp_password)
         # print('mail_lib.login = {0}'.format(str(res)))
 
+        print('login')
+
         res = None
 
         if type(to) in (list, tuple):
-            if 'support@truenergy.by' in to:
-                to.remove('support@truenergy.by')
+            # if sets['sender_email'] in to:
+            #     to.remove(sets['sender_email'])
 
             if len(to) > 1:
                 to_str = u', '.join(to)
             else:
                 to_str = to[0]
         else:
-            if to == 'support@truenergy.by':
-                return None
+            # if to == sets['sender_email']:
+            #     return None
             to_str = to
             to = []
             to.append(to_str)
 
+        print(f'send mail to {str(to)}')
+
         if type(subject) != str:
             try:
                 subject = subject.decode('utf-8')
@@ -186,6 +179,8 @@ def send_mail_by_SMTPlib(subject, from_email, to_init, html_content, smtp_server
                 except:
                     pass
 
+        print(f'add context')
+
         msg = MIMEMultipart()
         from email.headerregistry import Address
         msg['From'] = from_email
@@ -210,15 +205,17 @@ def send_mail_by_SMTPlib(subject, from_email, to_init, html_content, smtp_server
                 res = msg.attach(attachments)
                 # print('else attach file complete = {0}'.format(str(res)))
 
+        print(f'send mail')
+
         res = mail_lib.sendmail(from_email, to, msg.as_string())
 
         msg = mail_lib.quit()
         # print('mail_lib.quit = {0}'.format(str(msg)))
 
     except Exception as e:
-        # from Baldenini_site.SMS_sender import send_SMS
-        # send_SMS(u'375296177827', u'send_mail_by_SMTPlib error = {0}'.format(str(e)), urgent=True)
-        msg = 'send_mail_by_SMTPlib error = {0}'.format(str(e))
+        import traceback
+        msg = (f'send_mail_by_SMTPlib error = {str(e)}\n<br>'
+               f'{str(traceback.format_exc())}')
         print(msg)
         try:
             mail_lib.quit()
@@ -241,10 +238,10 @@ def send_mail_by_SMTPlib(subject, from_email, to_init, html_content, smtp_server
     return msg
 
 
-def sendMail(subject, text_content, from_email, to, html_content):
+def sendMail(sets, subject, text_content, from_email, to, html_content):
     print('sendMail to {0}'.format(str(to)))
 
-    admin_send_mail_by_SMTPlib(subject, from_email, [to], html_content)
+    admin_send_mail_by_SMTPlib(sets, subject, from_email, [to], html_content)
 
     # msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
     # msg.attach_alternative(html_content, "text/html")
@@ -253,52 +250,10 @@ def sendMail(subject, text_content, from_email, to, html_content):
     return u'Accept'
 
 
-# def techSendMail_for_top_management(html_content, title=None):
-#     try:
-#
-#         # if not prod_server:
-#         #     msg = '{0}. Not sended because is local'.format(html_content)
-#         #     print(msg)
-#         #     return msg
-#         from AuthApp.models import User
-#         from django.db.models import Q
-#
-#         # to = ['web@syncsystems.net']
-#         to = User.objects.filter(
-#             Q(is_superuser=True) | Q(groups__name__in=[
-#                 'Отдел продаж: Начальник отдела продаж', 'Управляющий',
-#                 'Бухгалтерия: Главный бухгалтер'
-#             ]),
-#             is_active=True,
-#             is_staff=True
-#         ).values_list('email', flat=True)
-#         to = list(to)
-#         to.append('office@truenergy.by')
-#
-#         print('techSendMail_for_top_management')
-#         if title:
-#             subject = title
-#         else:
-#             subject = u'truEnergy Data техническое оповещение'
-#         from_email = 'support@truenergy.by'
-#
-#         res = admin_send_mail_by_SMTPlib(subject, from_email, to, html_content)
-#
-#         # msg = EmailMultiAlternatives(subject, text_content, from_email, to)
-#         # msg.attach_alternative(html_content, "text/html")
-#         # msg.send()
-#         print(res)
-#         return u'Accept'
-#
-#     except Exception as e:
-#         msg = 'techSendMail_for_top_management error={0}'.format(str(e))
-#         techSendMail(msg)
-#         print(msg)
-#
-#     return 'Fail'
 
 
-def techSendMail_for_specified_email_list(html_content, email_list, title=None):
+
+def techSendMail_for_specified_email_list(sets, html_content, email_list, title=None):
     try:
 
         print('techSendMail_for_specified_email_list')
@@ -308,41 +263,44 @@ def techSendMail_for_specified_email_list(html_content, email_list, title=None):
             subject = u'truEnergy Data техническое оповещение'
         from_email = 'support@truenergy.by'
 
-        res = admin_send_mail_by_SMTPlib(subject, from_email, email_list, html_content)
+        res = admin_send_mail_by_SMTPlib(sets, subject, from_email, email_list, html_content)
 
         print(res)
         return u'Accept'
 
     except Exception as e:
         msg = 'techSendMail_for_specified_email_list error={0}'.format(str(e))
-        techSendMail(msg)
+        techSendMail(sets, msg)
         print(msg)
 
     return 'Fail'
 
 
-def techSendMail(html_content, title=None, add_emails=None):
+def techSendMail(sets, html_content, title=None, add_emails=None):
     # if not prod_server:
     #     msg = '{0}. Not sended because is local'.format(html_content)
     #     print(msg)
     #     return msg
 
     print('techSendMail')
+    project_name = ''
+    if 'project_name' in sets:
+        project_name = sets['project_name']
 
     try:
         # subject = u'truEnergy Data техническое оповещение'
-        from_email = 'support@truenergy.by'
+        from_email = sets['sender_email']
         to = ['web@syncsystems.net']
         if add_emails:
             to.extend(add_emails)
-        text_content = 'Technical message from truEnergy.'
+        text_content = f'Technical message from {project_name}'
 
         if title:
             subject = title
         else:
-            subject = u'truEnergy Data техническое оповещение'
+            subject = f'{project_name} - техническое оповещение'
 
-        res = admin_send_mail_by_SMTPlib(subject, from_email, to, html_content)
+        res = admin_send_mail_by_SMTPlib(sets, subject, from_email, to, html_content)
 
         print(res)
 

BaseModels/messages.py

@@ -1,6 +1,5 @@
 ## -*- coding: utf-8 -*-
 __author__ = 'SDE'
-# from Baldenini_site.inter import jsonify
 
 def get_error_message_Dict(show_icon=None):
     print('get_error_message_Dict')

BaseModels/paging.py

@@ -1,12 +1,12 @@
 # -*- coding: utf-8 -*-
 __author__ = 'SDE'
 
-def get_paging_Dict(request, elements_count, elements_on_page, from_page, to_page=None):
+def get_paging_Dict(request, elements_count, next_page_els_count, from_page, to_page=None):
 
 
 
-    pages_count = elements_count / elements_on_page
-    if elements_count % elements_on_page > 0:
+    pages_count = elements_count / next_page_els_count
+    if elements_count % next_page_els_count > 0:
         pages_count = pages_count + 1
 
     pages = []

BaseModels/pay_systems/DVL_Group_kaz/api/funcs.py

@@ -0,0 +1,113 @@
+import json
+from django.conf import settings
+
+import requests
+from requests_pkcs12 import get,post
+
+# для песочницы
+# pkcs12_filename = 'dvldigitalprojects.p12'
+# pkcs12_password = 'QNlhRStcY7mB'
+# api_pass = 'aPqSRVZhxFjjSqbB'
+
+# для прода
+# pkcs12_filename = 'dvldigitalprojects.p12'
+# pkcs12_password = 'fzSBm6WISje7'
+# api_pass = 't9g2+bZSvxNxCu+t'
+
+
+def get_domain_url():
+    return settings.PAY_SYSTEM_URL #'https://sandboxapi.paymtech.kz/'
+
+def get_kwargs_for_request():
+    return {
+        'headers': {
+            'content-type': 'application/json',
+        },
+        'auth': ('dvldigitalprojects', settings.API_PASS),
+        'pkcs12_filename': settings.PKCS12_FILENAME,
+        'pkcs12_password': settings.PKCS12_PASS
+    }
+
+def ping():
+
+    url = f'{get_domain_url()}ping'
+    data = {}
+
+    try:
+        msg = f'GET {url}'
+        print(msg)
+        res = get(
+            url,
+            **get_kwargs_for_request()
+        )
+
+        msg = f'answer received = {str(res)}'
+        print(msg)
+    except Exception as e:
+        msg = f'Exception GET {url} = {str(e)} ({str(res)})'
+        print(msg)
+        res = None
+        return False
+
+    return True
+
+
+def get_order_status(bank_order_id):
+
+    url = f'{get_domain_url()}orders/{str(bank_order_id)}'
+
+    res = None
+
+    data = {
+        'expand': [
+            'card', 'client', 'location', 'custom_fields',
+            'issuer', 'secure3d', 'operations', 'cashflow'
+        ]
+    }
+
+    try:
+        msg = f'GET {url}'
+        print(msg)
+        res = get(
+            url,
+            data=json.dumps(data),
+            **get_kwargs_for_request()
+        )
+
+        msg = f'get_order_status answer received = {str(res)}'
+        print(msg)
+    except Exception as e:
+        msg = f'Exception get_order_status GET {url} = {str(e)} ({str(res)})'
+        print(msg)
+        res = None
+
+    return res
+
+
+def create_order(data):
+
+    url = f'{get_domain_url()}orders/create'
+
+    res = None
+
+    try:
+        msg = f'POST {url}'
+        print(msg)
+        res = post(
+            url,
+            data=json.dumps(data),
+            **get_kwargs_for_request()
+        )
+
+        msg = f'create_order answer received = {str(res.text)}'
+        # if res:# and res.status_code > 300:
+        #     msg += f' > ({str(res.text)})'
+        print(msg)
+    except Exception as e:
+        msg = f'Exception create_order POST {url} = {str(e)} ({str(res)})'
+        if res:
+            msg += f' > ({str(res.text)})'
+        print(msg)
+        res = None
+
+    return res

BaseModels/search_optimization/ld_json/ld_search.py

@@ -8,7 +8,7 @@ def get_ld_search(domain):
     data = {
         "@context": "https://schema.org",
         "@type": "WebSite",
-        "url": domain, #"https://truenergy.by/",
+        "url": domain,
         "potentialAction": {
             "@type": "SearchAction",
             "target": {

BaseModels/seo_text_generators.py

@@ -1,258 +1,75 @@
 from BaseModels.inter import cut_to_number_w_point
 
 
-def generate_seotext_by_properties(product_data_Dict):
-
-    power_txt = ''
-    ip_txt = ''
-    lm_txt = ''
-    temp_txt = ''
-    install_txt = ''
-    diametr_txt = ''
-
-    try:
-
-        if 'diameter' in product_data_Dict:
-            val = int(product_data_Dict['diameter'])
-        else:
-            val = int(product_data_Dict['width'])
-
-        diametr_txt = '{0} truEnergy {1} серии {2}.<br>'.format(
-            product_data_Dict['product_type']['name'].upper(),
-            product_data_Dict['article'],
-            product_data_Dict['product_series']['name'].upper()
-        )
-
-        # if product_data_Dict['product_type']['name'] == 'Светильник светодиодный':
-        #
-        #     if val < 100:
-        #         diametr_txt = '{0} truEnergy {1} серии {2} -  это хорошее решение для дома.<br>'.format(
-        #             product_data_Dict['product_type']['name'].upper(),
-        #             product_data_Dict['article'],
-        #             product_data_Dict['product_series']['name'].upper()
-        #         )
-        #
-        #     elif val < 150:
-        #         diametr_txt = '{0} truEnergy {1} серии {2} отлично подойдет для освещения вашей квартиры, дома или офиса.<br>'.format(
-        #             product_data_Dict['product_type']['name'].upper(),
-        #             product_data_Dict['article'],
-        #             product_data_Dict['product_series']['name'].upper()
-        #         )
-        #
-        #     else:
-        #         diametr_txt = '{0} truEnergy {1} серии {2} - это энергоэффективное освещение для различных площадей и объектов.<br>'.format(
-        #             product_data_Dict['product_type']['name'].upper(),
-        #             product_data_Dict['article'],
-        #             product_data_Dict['product_series']['name'].upper()
-        #         )
-        # # не светильник
-        # else:
-        #     diametr_txt = '{0} truEnergy {1} серии {2} - это энергоэффективное решение для освещения различных пространств.<br>'.format(
-        #         product_data_Dict['product_type']['name'].upper(),
-        #         product_data_Dict['article'],
-        #         product_data_Dict['product_series']['name'].upper()
-        #     )
-    except Exception as e:
-        pass
-
-    # ---------
-    for property in product_data_Dict['properties_w_values_filtred']:
-
-        # ------
-
-        try:
-
-            if property['property']['name'] == 'Мощность':
-                power = int(property['property_value'])
-
-                if power < 7:
-                    power_txt = 'Обладая низким энергопотреблением, этот {0} является заменой лампочки накаливания мощностью до 40 Ватт.<br>'.format(
-                        product_data_Dict['product_type']['name'].lower(),
-                    )
-
-                elif power < 13:
-                    power_txt = 'Энергоэффективность этого устройства позволяет использовть его в местах, ' \
-                                'где ранее использовались светильники с лампами накаливания мощностью до 75 Ватт.<br>'.format(
-                    )
-                elif power < 19:
-                    power_txt = 'Этот {0} мощностью {1} Ватт легко заменит старые лампы накаливания мощностью до 100 Ватт ' \
-                                'или люминесцентные лампы мощностью до 40 Ватт.<br>'.format(
-                        product_data_Dict['product_type']['name'].lower(),
-                        str(power)
-                    )
-
-                elif power < 37:
-                    power_txt = 'Данная модель подходит для освещения больших пространств. ' \
-                                'Она не только поможет решить вопрос освещения, но и существенно сэкономит бюджет, ' \
-                                'выделенный на решение этой задачи.<br>'.format(
-                        product_data_Dict['product_type']['name'].lower(),
-                    )
-                else:
-                    power_txt = '{0} Ватт, в данной модели обеспечивает мощный световой поток. ' \
-                                'Это дает возможность установки одного изделия для освещения помещений с большой ' \
-                                'площадью или открытых пространств.<br>'.format(
-                        str(power),
-                        product_data_Dict['product_type']['name'].lower(),
-                    )
-
-        except Exception as e:
-            pass
-
-        # ------
-
-        try:
-
-            if property['property']['name'] == 'Световой поток' and product_data_Dict['article'] != '11043':
-                val = int(property['property_value'])
-
-                if product_data_Dict['product_type']['name'] == 'Светильник светодиодный':
-                    lm_txt = 'Один {0} данной модели способен осветить до {1} м.кв. площади ' \
-                            'для рабочих зон и жилых комнат, и до {2} м.кв. площади для проходных и подсобных помещений ' \
-                            '(при стандартной высоте потолка и нормальной освещенности помещения).<br>'.format(
-                        product_data_Dict['product_type']['name'].lower(),
-                        str(round(val / 300,2)),
-                        str(round(val / 120, 2)),
-                    )
-
-        except Exception as e:
-            pass
-
-        # -------
-
-        try:
-
-            if property['property']['name'] == 'IP (пылевлагозащита)':
-                val = int(property['property_value'])
-
-                if val > 66:
-                    ip_txt = 'Максимальная защита IP{0} способна выдержать самые сильные испытания водой. ' \
-                             'Освещение с такой защитой используют для фонтанов и бассейнов.<br>'.format(
-                        str(val),
-                    )
-
-                elif val > 64:
-                    ip_txt = 'Данный продукт имеет высокую степень пылевлагозащиты - IP{0}. В связи с этим данная модель прекрасно подходит как ' \
-                             'для отапливаемых помещений с нормальным уровнем влажности, так и для помещений неотапливаемых, ' \
-                             'а также для эксплуатации на улице. Устройство с данной степенью защиты не боится пыли и влаги' \
-                             'а так же имеет защиту от струй воды со всех направлений.<br>'.format(
-                        str(val),
-                    )
-
-                elif val > 60:
-                    ip_txt = 'Степень защиты IP{0} обозначает полную защиту от брызг с любых сторон и имеет полную пылинепроницаемость ' \
-                             '(никакая пыль не может проникнуть внутрь корпуса устройства). ' \
-                             'Светильники подходят для установки в помещении и на улице, при рабочих температурах -20 до +40 градусов.<br>'.format(
-                        str(val),
-                    )
-
-                elif val > 53:
-                    ip_txt = 'У изделия с степенью защиты IP{0} снижена возможность попадания пыли внутрь корпуса ' \
-                             'и обеспечена полная защита расположенной внутри устройстав электроники.' \
-                             'Часто используют для рабочих помещений с повышенным содержанием пыли и влаги, а также под навесами.<br>'.format(
-                        str(val),
-                        product_data_Dict['product_type']['name'].lower(),
-                        product_data_Dict['product_type']['name_plural'].lower(),
-                    )
-
-                elif val > 40:
-                    ip_txt = 'Могут устанавливаться в помещения с повышенным уровнем пыли.'.format(
-                        product_data_Dict['product_type']['name'].lower(),
-                    )
-                else:
-                    ip_txt = 'IP{0} - степень защиты данной модели, в связи с этим могут устанавливаться в' \
-                             ' отапливаемые помещения с умеренным уровнем влажности.<br>'.format(
-                        str(val),
-                    )
-
-        except Exception as e:
-            pass
-
-        # -------
-
-        try:
-
-            if property['property']['name'] == 'Цветовая температура':
-                val = int(property['property_value'])
-
-                if val < 3001:
-                    temp_txt = 'Теплый свет, генерируемый этой моделью способствует отдыху и расслаблению. ' \
-                             'Он приятен для глаз. В связи с этим рекомендуется устанавливать {0} ' \
-                             'с температурой {1}К в зоны отдыха, жилые комнаты и спальни, кафе, лаундж зоны. ' \
-                             'Очень удачное решение для обеденных и гостинных комнат.<br>'.format(
-                        product_data_Dict['product_type']['name_plural'].lower(),
-                        str(val),
-                    )
-
-                elif val < 4601:
-                    temp_txt = 'Модель обладает нейтральным цветом свечения, который прекрасно подходит и как для жилых помещений и комнат, ' \
-                             'так и для рабочих зон (офисов, кабинетов, производств) . ' \
-                             'Данный свет стимулирует к работе не вызывая перенапряжения глаз и не искажая цветопередачу. ' \
-                             'Универсальное и наиболее распространенное решение.<br>'.format(
-                        str(val),
-                    )
-
-                elif val < 7001:
-                    temp_txt = 'Цветовая температура {0}К - наиболее оптимально использование  в помещениях промышленного назначения, ' \
-                             'административных зданиях, на производствах, складах, гаражах, паркингах. ' \
-                             'Однако могут применяться и в интерьере для создания акцентов в дизайне, ' \
-                             'либо если предпочтения потребителя отданы в пользу белого света. <br>'.format(
-                        str(val),
-                    )
-
-
-
-                else:
-                    temp_txt = 'От показателя цветовой температуры зависит то, как Вы будут воспринимать предметы и другие объекты освещенные устройством. ' \
-                             'С помощью цветовой температуры можно сделать более приятным отдых и улучшить эффективность работы. ' \
-                             'Отниситесь внимательно к выбору устройства по этому параметру.<br>'.format(
-                        str(val),
-                    )
-        except Exception as e:
-            pass
-
-        # -------
-
-        try:
-
-            if property['property']['name'] == 'Тип монтажа':
-                val = property['property_value']
-
-                if val == 'встраиваемый':
-                    install_txt = 'Устройство устанавливается в предварительно вырезанное в поверхности отверстие. ' \
-                             'Этот вариант монтажа используется для подвесных и натяжных потолков, а так же для фальш-стен и ниш.'.format(
-                        str(val),
-                    )
-
-                elif val == 'накладной':
-                    install_txt = 'Способ крепления - накладной. Значит эта модель может быть закреплена на любую ровную поверхность.'.format(
-                        str(val),
-                    )
-
-                elif val == 'встраиваемый/накладной':
-                    install_txt = '{0} обладает возможностью монтажа как в отверстия на поверхности плоскостей, так и на любую ровную поверхность.'.format(
-                        product_data_Dict['article'],
-                    )
-
-                else:
-                    pass
-
-                if 'height_visible_part' in product_data_Dict and product_data_Dict['height_visible_part']:
-                    install_txt = install_txt + ' Высота видимой части устройства после монтажа составит {0}мм.<br>'.format(
-                        str(round(product_data_Dict['height_visible_part']))
-                    )
-                else:
-                    install_txt = install_txt + '<br>'
-
-        except Exception as e:
-            pass
-
-    product_data_Dict['seo_text'] = '{0}{1}{2}{3}{4}{5}'.format(
-        diametr_txt,
-        power_txt,
-        lm_txt,
-        ip_txt,
-        temp_txt,
-        install_txt
-    )
-
-    return product_data_Dict
+# def generate_seotext_by_properties(product_data_Dict):
+#
+#     power_txt = ''
+#     ip_txt = ''
+#     lm_txt = ''
+#     temp_txt = ''
+#     install_txt = ''
+#     diametr_txt = ''
+#
+#     try:
+#
+#
+#
+#     except Exception as e:
+#         pass
+#
+#     # ---------
+#     for property in product_data_Dict['properties_w_values_filtred']:
+#
+#         # ------
+#
+#         try:
+#
+#
+#         except Exception as e:
+#             pass
+#
+#         # ------
+#
+#         try:
+#
+#
+#
+#         except Exception as e:
+#             pass
+#
+#         # -------
+#
+#         try:
+#
+#
+#
+#         except Exception as e:
+#             pass
+#
+#         # -------
+#
+#         try:
+#
+#
+#         except Exception as e:
+#             pass
+#
+#         # -------
+#
+#         try:
+#
+#
+#
+#         except Exception as e:
+#             pass
+#
+#     product_data_Dict['seo_text'] = '{0}{1}{2}{3}{4}{5}'.format(
+#         diametr_txt,
+#         power_txt,
+#         lm_txt,
+#         ip_txt,
+#         temp_txt,
+#         install_txt
+#     )
+#
+#     return product_data_Dict

BaseModels/validators/form_field_validators.py

@@ -0,0 +1,24 @@
+from django.utils.translation import gettext as _
+from django.utils.safestring import mark_safe
+def get_phone_valid_error(val):
+    allow_chars = '01234567890()+ -'
+
+    error_msg = mark_safe(_('Некорректные символы в номере, введите номер в международном формате с кодом страны'))
+
+    if not val:
+        return None
+
+    if len(val) < 10:
+        return error_msg
+
+    if '+' in val and val[0] != '+':
+        return error_msg
+
+    i = 0
+    while i < len(val):
+        if val[i] not in allow_chars:
+            return error_msg
+
+        i += 1
+
+    return None

BillingApp/admin.py

@@ -0,0 +1,39 @@
+from sets.admin import *
+from .models import *
+from django.contrib import admin
+
+class Admin_SubscribeOrder(Admin_BaseModel):
+
+    fieldsets = (
+        (None, {
+            'classes': ['wide'],
+            'fields': (
+                ('user', 'subscribe', 'subscribe_for_user'),
+                ('enable', 'order'),
+                ('sum', 'currency'),
+                ('status', 'last_operation_status'),
+                ('bank_order_id', 'pay_page'),
+                'json_data',
+            )
+        }),
+    )
+
+    list_display = [
+        'id', 'enable',
+        'user', 'subscribe', 'subscribe_for_user',
+        'bank_order_id',
+        'sum', 'currency',
+        'status', 'last_operation_status',
+        'order', 'modifiedDT', 'createDT'
+    ]
+
+    list_display_links = ['id', 'user', 'subscribe']
+    list_editable = ['enable']
+
+    readonly_fields = ['subscribe_for_user', 'sum', 'currency', 'modifiedDT', 'createDT']
+
+    list_filter = ['enable', 'status', 'modifiedDT', 'createDT']
+    search_fields = ['id', 'last_operation_status', 'status']
+    # filter_horizontal = ['options']
+
+admin.site.register(SubscribeOrder, Admin_SubscribeOrder)

BillingApp/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class BillingappConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'BillingApp'

BillingApp/funcs.py

@@ -0,0 +1,101 @@
+from datetime import datetime, timedelta
+
+from .models import *
+import json
+
+
+def get_order_status(order):
+    from BaseModels.pay_systems.DVL_Group_kaz.api.funcs import get_order_status
+    res_status = None
+
+    if not order or not order.bank_order_id:
+        return order
+
+    try:
+        res_data = get_order_status(order.bank_order_id)
+
+        res = json.loads(res_data.text)
+        res = res['orders'][0]
+        order.json_data['status'] = res
+
+        order.status = res['status']
+
+
+        # if res['amount'] == res['amount_charged'] and res['status'] == 'charged':
+        order.save()
+        # return order.status
+
+
+    except Exception as e:
+        msg = f'Exception get_order_status = {str(e)}'
+        if order:
+            msg = f'Exception get_order_status (data = {str(order.id)}) = {str(e)}'
+        print(msg)
+
+    return order
+
+def get_orders_for_user(user):
+
+    orders = SubscribeOrder.objects.filter(
+        enable=True,
+        user=user,
+        subscribe_for_user=None,
+        createDT__gt=datetime.now() - timedelta(hours=1)
+    ).order_by('subscribe', '-createDT').distinct('subscribe')
+
+    SubscribeOrder.objects.filter(
+        user=user
+    ).exclude(
+        id__in=orders.values_list('id', flat=True)
+    ).update(enable=False)
+
+    return orders
+
+
+def create_subscribe_order(data):
+    order = None
+
+    try:
+
+        order = SubscribeOrder.objects.create(**data)
+
+        from GeneralApp.funcs_options import get_options_by_opt_types, get_mail_send_options
+        sets = get_options_by_opt_types(['domain', 'project_name'], only_vals=True)
+
+        from BaseModels.pay_systems.DVL_Group_kaz.api.funcs import create_order
+        data = {
+            'currency': data['currency'],
+            'amount': data['sum'],
+            'description': f'Заказ {order.id} на подписку '
+                           f'{data["subscribe"].name} '
+                           f'для пользователя {data["user"].username}',
+            'options': {
+                'force3d': 1,
+                'auto_charge': 1,
+                'return_url': f'{sets["domain"]}/profile/page/my_subscribe/'
+            }
+        }
+
+        res_data = create_order(data)
+
+        order.pay_page = res_data.headers.get('location')
+
+        res = json.loads(res_data.text)
+        res = res['orders'][0]
+        order.json_data['create_order'] = res
+
+        order.modifiedDT = datetime.strptime(res['updated'], '%Y-%m-%d %H:%M:%S')
+        order.status = res['status']
+        order.bank_order_id = res['id']
+        if 'segment' in res:
+            order.segment = res['segment']
+        if 'merchant_order_id' in res:
+            order.merchant_order_id = res['merchant_order_id']
+        order.save()
+
+
+    except Exception as e:
+        msg = f'Exception create_subscribe_order (data = {str(data)}) = {str(e)}'
+        print(msg)
+
+    return order

BillingApp/migrations/0001_initial.py

@@ -0,0 +1,42 @@
+# Generated by Django 4.2.2 on 2024-04-19 16:24
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('SubscribesApp', '0003_alter_subscribe_bg_color_alter_subscribe_text_color'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='SubscribeOrder',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.TextField(blank=True, help_text='Название', null=True, verbose_name='Название')),
+                ('name_plural', models.TextField(blank=True, null=True, verbose_name='Название (множественное число)')),
+                ('order', models.IntegerField(blank=True, null=True, verbose_name='Очередность отображения')),
+                ('createDT', models.DateTimeField(auto_now_add=True, verbose_name='Дата и время создания')),
+                ('modifiedDT', models.DateTimeField(blank=True, null=True, verbose_name='Дата и время последнего изменения')),
+                ('enable', models.BooleanField(db_index=True, default=True, verbose_name='Включено')),
+                ('json_data', models.JSONField(blank=True, default=dict, verbose_name='Дополнительные данные')),
+                ('sum', models.PositiveSmallIntegerField(verbose_name='Сумма')),
+                ('currency', models.CharField(max_length=3, verbose_name='Валюта')),
+                ('segment', models.CharField(verbose_name='ID Сегмента')),
+                ('merchant_order_id', models.CharField(verbose_name='merchant_order_id')),
+                ('bank_order_id', models.CharField(verbose_name='ID заказа в банке')),
+                ('status', models.CharField(verbose_name='Статус заказа в банке')),
+                ('subscribe', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='subscribe_orders_for_subscribe', to='SubscribesApp.subscribe', verbose_name='Подписка')),
+                ('subscribe_for_user', models.OneToOneField(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='subscribe_orders_for_user_subscribe', to='SubscribesApp.subscribeforuser', verbose_name='Подписка пользователя')),
+                ('user', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='subscribe_orders_for_user', to='SubscribesApp.subscribe', verbose_name='Пользователь')),
+            ],
+            options={
+                'verbose_name': 'Заказ на подписку',
+                'verbose_name_plural': 'Заказы на подписки',
+            },
+        ),
+    ]

BillingApp/migrations/0002_alter_subscribeorder_user.py

@@ -0,0 +1,21 @@
+# Generated by Django 4.2.2 on 2024-04-19 16:29
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ('BillingApp', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='subscribeorder',
+            name='user',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='subscribe_orders_for_user', to=settings.AUTH_USER_MODEL, verbose_name='Пользователь'),
+        ),
+    ]

BillingApp/migrations/0003_subscribeorder_pay_page_and_more.py

@@ -0,0 +1,43 @@
+# Generated by Django 4.2.2 on 2024-04-19 16:36
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('BillingApp', '0002_alter_subscribeorder_user'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='subscribeorder',
+            name='pay_page',
+            field=models.URLField(blank=True, default=None, null=True, verbose_name='Ссылка на страницу оплаты'),
+        ),
+        migrations.AlterField(
+            model_name='subscribeorder',
+            name='bank_order_id',
+            field=models.CharField(default='', verbose_name='ID заказа в банке'),
+        ),
+        migrations.AlterField(
+            model_name='subscribeorder',
+            name='merchant_order_id',
+            field=models.CharField(default='', verbose_name='merchant_order_id'),
+        ),
+        migrations.AlterField(
+            model_name='subscribeorder',
+            name='segment',
+            field=models.CharField(default='', verbose_name='ID Сегмента'),
+        ),
+        migrations.AlterField(
+            model_name='subscribeorder',
+            name='status',
+            field=models.CharField(default='', verbose_name='Статус заказа в банке'),
+        ),
+        migrations.AlterField(
+            model_name='subscribeorder',
+            name='sum',
+            field=models.PositiveSmallIntegerField(default=0, verbose_name='Сумма'),
+        ),
+    ]

BillingApp/migrations/0004_alter_subscribeorder_bank_order_id_and_more.py

@@ -0,0 +1,38 @@
+# Generated by Django 4.2.2 on 2024-04-19 16:47
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('BillingApp', '0003_subscribeorder_pay_page_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='subscribeorder',
+            name='bank_order_id',
+            field=models.CharField(default=None, null=True, verbose_name='ID заказа в банке'),
+        ),
+        migrations.AlterField(
+            model_name='subscribeorder',
+            name='currency',
+            field=models.CharField(default='USD', max_length=3, verbose_name='Валюта'),
+        ),
+        migrations.AlterField(
+            model_name='subscribeorder',
+            name='merchant_order_id',
+            field=models.CharField(default=None, null=True, verbose_name='merchant_order_id'),
+        ),
+        migrations.AlterField(
+            model_name='subscribeorder',
+            name='segment',
+            field=models.CharField(default=None, null=True, verbose_name='ID Сегмента'),
+        ),
+        migrations.AlterField(
+            model_name='subscribeorder',
+            name='status',
+            field=models.CharField(default=None, null=True, verbose_name='Статус заказа в банке'),
+        ),
+    ]

BillingApp/migrations/0005_subscribeorder_last_operation_status.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.2 on 2024-04-19 17:57
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('BillingApp', '0004_alter_subscribeorder_bank_order_id_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='subscribeorder',
+            name='last_operation_status',
+            field=models.CharField(default=None, null=True, verbose_name='Статус последней операции'),
+        ),
+    ]

BillingApp/migrations/0006_alter_subscribeorder_currency.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.2 on 2024-07-12 17:23
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('BillingApp', '0005_subscribeorder_last_operation_status'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='subscribeorder',
+            name='currency',
+            field=models.CharField(default='KZT', max_length=3, verbose_name='Валюта'),
+        ),
+    ]

BillingApp/models.py

@@ -0,0 +1,75 @@
+from django.db import models
+from BaseModels.base_models import BaseModel
+from SubscribesApp.models import Subscribe, SubscribeForUser
+from AuthApp.models import User
+from django.utils.translation import gettext as _
+
+class SubscribeOrder(BaseModel):
+
+    subscribe = models.ForeignKey(
+        Subscribe, verbose_name=_('Подписка'),
+        on_delete=models.SET_NULL, blank=True, null=True,
+        related_name='subscribe_orders_for_subscribe'
+    )
+
+    user = models.ForeignKey(
+        User, verbose_name=_('Пользователь'),
+        on_delete=models.SET_NULL, blank=True, null=True,
+        related_name='subscribe_orders_for_user'
+    )
+
+    subscribe_for_user = models.OneToOneField(
+        SubscribeForUser, verbose_name=_('Подписка пользователя'),
+        on_delete=models.SET_NULL, blank=True, null=True,
+        related_name='subscribe_orders_for_user_subscribe'
+    )
+
+    sum = models.PositiveSmallIntegerField(verbose_name=_('Сумма'), default=0)
+    currency = models.CharField(verbose_name=_('Валюта'), max_length=3, default='KZT')
+    segment = models.CharField(verbose_name=_('ID Сегмента'), null=True, default=None)
+    merchant_order_id = models.CharField(verbose_name=_('merchant_order_id'), null=True, default=None)
+    bank_order_id = models.CharField(verbose_name=_('ID заказа в банке'), null=True, default=None)
+
+    status = models.CharField(verbose_name=_('Статус заказа в банке'), null=True, default=None)
+    last_operation_status = models.CharField(verbose_name=_('Статус последней операции'), null=True, default=None)
+
+    pay_page = models.URLField(verbose_name=_('Ссылка на страницу оплаты'), null=True, blank=True, default=None)
+
+    class Meta:
+        verbose_name = _('Заказ на подписку')
+        verbose_name_plural = _('Заказы на подписки')
+
+    def activate_subscribe_for_user(self):
+        from datetime import datetime, timedelta
+
+        kwargs = {
+            'user': self.user,
+            'subscribe': self.subscribe,
+            'last_paid_DT': datetime.now(),
+            'receive_finish_subscribe_msg': True,
+            # 'enable': True,
+        }
+
+        from SubscribesApp.funcs import create_subscribe_by_data
+        subscribe_for_user = create_subscribe_by_data(kwargs)
+        self.subscribe_for_user = subscribe_for_user
+        self.enable = False
+        self.save()
+
+        subscribe_for_user.activate(
+            paid_period_from_DT=datetime.now(),
+            paid_period_to_DT=datetime.now() + timedelta(hours=self.subscribe.period)
+        )
+
+        return self
+
+    def __str__(self):
+        res = 'Заказ'
+        if self.subscribe:
+            res += f' на подписку {self.subscribe.name}'
+        if self.user:
+            res += f' для {self.user.username}'
+
+        if not res:
+            res += f' {str(self.id)}'
+        return res

BillingApp/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

BillingApp/views.py

@@ -0,0 +1,3 @@
+from django.shortcuts import render
+
+# Create your views here.

ChatServiceApp/admin.py

@@ -1,6 +1,11 @@
 from sets.admin import *
 from .models import *
 from django.contrib import admin
+from django import forms
+from django.forms import widgets
+
+
+
 
 class Admin_MsgGroup(Admin_BaseModel):
     list_display = [
@@ -11,8 +16,33 @@ class Admin_MsgGroup(Admin_BaseModel):
 admin.site.register(MsgGroup,Admin_MsgGroup)
 
 class Admin_Message(Admin_BaseModel):
+
+    def cut_group_text(self, obj):
+        if obj.group:
+            return obj.group.name[:10]
+        return '-'
+    cut_group_text.allow_tags = True
+    cut_group_text.short_description = 'ticket'
+
+
+    def cut_text(self, obj):
+        if obj.text:
+            if len(obj.text) > 20:
+                return f'{obj.text[:20]}...'
+            else:
+                return obj.text
+        return '-'
+    cut_text.allow_tags = True
+    cut_text.short_description = 'сообщение'
+
+    search_fields = ['group__name', 'text', 'name', 'id']
+
+    list_filter = ['status']
+
     list_display = [
-        'id', 'msg_type', 'group', 'status', 'sender', 'receiver', 'text',
+        'id',
+        # 'msg_type',
+        'cut_group_text', 'status', 'sender', 'receiver', 'cut_text',
         'name',
         'order', 'modifiedDT', 'createDT'
     ]

ChatServiceApp/funcs.py

@@ -1,5 +1,7 @@
+import copy
+
 from .models import *
-from django.db.models import Q
+from django.db.models import Q, Value as V, Count, OuterRef, Subquery
 from django.http import HttpResponse, Http404, JsonResponse
 from django.template import loader, RequestContext
 from django.contrib.auth.decorators import login_required
@@ -10,20 +12,146 @@ from django.template.loader import render_to_string
 from django.urls import reverse
 import json
 from datetime import datetime, time
+from django.conf import settings
+from AuthApp.funcs import get_user_timezone_Dict
 
-def send_msg(data):
+
+def get_unanswered_msgs_count_for_user(user):
+    if not user or not user.is_authenticated:
+        return 0
+
+    msgs = Message.objects.filter(receiver=user, status='sended', group=None)
+    return msgs.count()
+
+
+
+def get_update_chat_Dict(data):
     from AuthApp.models import User
+
     res_Dict = {}
-    msg = None
+    msgs = []
+    Dict = {}
+    context_Dict = {}
+
+    last_message_modifiedDT = None
+
+    required_beep = False
+
+    required_full_support_chat_html = False
 
     try:
 
-        data = json.loads(data)
+        if type(data) == str:
+            data = json.loads(data)
         ticket = None
 
         tpl_name = 'blocks/profile/b_messages_container.html'
 
-        if data['text']:
+        if 'ticket_id' in data and data['ticket_id'] and data['ticket_id'] != 'null':
+            ticket = MsgGroup.objects.get(id=data['ticket_id'])
+            res_Dict.update({'ticket': ticket.id})
+
+        sender = User.objects.get(id=data['sender'])
+        receiver = None
+        if 'receiver' in data and data['receiver']:
+            receiver = User.objects.get(id=data['receiver'])
+
+        if data['sender'] == data['cur_user']:
+            user = copy.copy(sender)
+            cur_receiver = copy.copy(receiver)
+        else:
+            user = copy.copy(receiver)
+            cur_receiver = copy.copy(sender)
+            # context_Dict.update({'user': receiver})
+
+        # context_Dict.update({'cur_receiver': receiver})
+        context_Dict.update({
+            'cur_receiver': cur_receiver,
+            'user': user,
+        })
+        context_Dict.update(get_user_timezone_Dict(user))
+
+        if sender == receiver:
+            print('!')
+
+        required_beep = data['required_beep']
+
+
+        if not ticket:
+
+            if data['receiver'] == data['cur_user']:
+                # получаем правую панель с получателями
+                # получатели
+                receivers, unread_msgs_count = get_chat_receivers_for_user(receiver)
+
+
+                # формируем правую панель
+                context_Dict.update({
+                    'receivers': receivers,
+                    'MEDIA_URL': settings.MEDIA_URL
+                })
+                users_list_html = render_to_string(
+                    'blocks/profile/b_list_of_users_messenger.html', context_Dict)
+                res_Dict.update({
+                    'users_list_html': users_list_html,
+                    'unread_msgs_count': unread_msgs_count
+                })
+
+            msgs = get_msgs_for_chat_w_users(sender, receiver)
+
+        if ticket:
+            msgs = get_messages_for_ticket(ticket)
+            # если меньше 3 сообщений значит выведена не полная форма - требуется другой шаблон
+            if len(msgs) < 3 and data['receiver'] == data['cur_user']:
+                tpl_name = 'blocks/profile/b_support_chat.html'
+                required_full_support_chat_html = True
+            elif 'bad_manager' in data:
+                tpl_name = 'blocks/profile/b_support_chat.html'
+                required_full_support_chat_html = True
+
+            context_Dict.update({'ticket': ticket})
+            if ticket.manager:
+                context_Dict.update({'new_msg_allow': True})
+
+        context_Dict.update({
+            'messages': msgs,
+            'MEDIA_URL': settings.MEDIA_URL,
+        })
+        html = render_to_string(tpl_name, context_Dict)
+        if required_full_support_chat_html:
+            res_Dict.update({'support_chat_html': html})
+        else:
+            res_Dict.update({'chat_html': html})
+
+
+        res_Dict.update({
+            'required_beep': required_beep,
+        })
+        return res_Dict
+
+    except Exception as e:
+        msg = f'update_chat_ajax2 Error = {str(e)}'
+        return {'error': msg}
+
+
+def send_msg(data):
+    from AuthApp.models import User
+    import base64
+    import os
+
+    res_Dict = {}
+    msg = None
+    required_update_tickets_list_wo_managers = False
+
+    try:
+        if type(data) == str:
+            data = json.loads(data)
+
+        ticket = None
+
+        tpl_name = 'blocks/profile/b_messages_container.html'
+
+        if 'text' in data or 'files' in data:
 
             if 'ticket_id' in data:
                 ticket = MsgGroup.objects.get(id=data['ticket_id'])
@@ -35,6 +163,7 @@ def send_msg(data):
 
             # если только что манагер присоединился к тикету
             if ticket:
+                required_update_tickets_list_wo_managers = True
                 if not ticket.manager:
                     if sender.is_staff:
                         ticket.manager = sender
@@ -43,23 +172,27 @@ def send_msg(data):
 
                     ticket.save()
 
+                    # создаем сообщение на базе темы и сообщения введенных пользователем при создании тикета
                     kwargs = {
                         'sender': ticket.owner,
                         'receiver': ticket.manager,
                         'text': ticket.text,
+                        'group': ticket,
                     }
 
-                    kwargs.update({'group': ticket})
-
                     msg = Message.objects.create(**kwargs)
                     Message.objects.filter(id=msg.id).update(modifiedDT=ticket.createDT, createDT=ticket.createDT)
+                    # ------------------------
+
+                else:
+                    if not sender in (ticket.owner, ticket.manager) or not receiver in (ticket.owner, ticket.manager):
+                        return {
+                            'msg': None,
+                            'required_update_tickets_list_wo_managers': required_update_tickets_list_wo_managers
+                        }
 
                 res_Dict.update({
                     'ticket': ticket,
-                    # 'cur_receiver': receiver,
-                    # 'messages': get_messages_for_ticket(ticket),
-                    # 'text': data['text'],
-                    # 'modifiedDT': msg.modifiedDT
                 })
 
                 msg_create_kwargs.update({
@@ -72,45 +205,117 @@ def send_msg(data):
             msg_create_kwargs.update({
                 'sender': sender,
                 'receiver': receiver,
-                'text': data['text']
             })
 
-            session_data = {
-                'for_save_to_session': {
-                    'user_alerts': {
-                        'new_message': True
-                    }
-                }
-            }
-
-            receiver.user_profile.add_node_to_json_data(session_data, save=True)
+            if 'text' in data:
+                msg_create_kwargs.update({'text': data['text']})
 
             msg = Message.objects.create(**msg_create_kwargs)
 
-            if ticket:
-                msgs = get_messages_for_ticket(ticket)
-            else:
-                msgs = get_msgs_for_chat_w_users(sender, receiver)
+            if 'files' in data:
+                files_list = []
+                for file in data['files']:
+                    file_data =json.loads(file)
 
-            receivers, unread_msgs_count = get_chat_receivers_for_user(sender)
+                    if not os.path.exists(f'chat_file_storage/{msg.id}'):
+                        os.makedirs(f'chat_file_storage/{msg.id}')
+                    f = open(f'chat_file_storage/{msg.id}/{file_data["file_name"]}', 'wb+')
+                    head, content = file_data['file'].split(',')
+                    content = base64.b64decode(content)
+                    f.write(content)
+                    f.close()
 
-            res_Dict.update({
-                'messages': msgs,
-                'cur_receiver': receiver,
-                'receivers': receivers,
-                'text': data['text'],
-                'modifiedDT': msgs[0].modifiedDT
-            })
+                    del file_data['file']
+                    files_list.append(file_data)
+                msg.files = files_list
+                msg.save(update_fields=['files'])
 
-        html = render_to_string(tpl_name, res_Dict)
-        return {'html': html}
+
+
+        #     if ticket:
+        #         msgs = get_messages_for_ticket(ticket)
+        #     else:
+        #         msgs = get_msgs_for_chat_w_users(sender, receiver)
+        #
+        #     receivers, unread_msgs_count = get_chat_receivers_for_user(sender)
+        #
+        #     res_Dict.update({
+        #         'messages': msgs,
+        #         'cur_receiver': receiver,
+        #         'receivers': receivers,
+        #         'text': data['text'],
+        #         'modifiedDT': msgs[0].modifiedDT
+        #     })
+        #
+        # html = render_to_string(tpl_name, res_Dict)
+        # return {'html': html, 'sender': data['sender']}
+        return {
+            'msg': msg,
+            'required_update_tickets_list_wo_managers': required_update_tickets_list_wo_managers
+        }
 
     except Exception as e:
         msg = f'send_msg_ajax Error = {str(e)}'
-        return {'error': msg}
+        print(msg)
+        # return {'error': msg}
+        return {
+            'msg': msg,
+            'required_update_tickets_list_wo_managers': required_update_tickets_list_wo_managers
+        }
 
 
 
+# def get_create_route_for_customer_page_content_Dict(request):
+#     from AuthApp.models import User
+#
+#     msgs = []
+#     try:
+#         cur_receiver = User.objects.get(id=receiver_id)
+#
+#         msgs = get_msgs_for_chat_w_users(request.user, cur_receiver)
+#         msgs.filter(receiver=request.user).update(status='seen')
+#
+#     except User.DoesNotExist:
+#         cur_receiver = None
+#
+#     receivers, unread_msgs_count = get_chat_receivers_for_user(request.user)
+#
+#     Dict = {
+#         'cur_receiver': cur_receiver,
+#         'messages': msgs,
+#         'receivers': receivers,
+#         'page': 'chat',
+#     }
+#     return Dict
+
+
+def get_chat_page_content_html(request, receiver_id=None):
+    from AuthApp.models import User
+    from AuthApp.funcs import get_user_timezone_Dict
+
+    msgs = []
+    try:
+        cur_receiver = User.objects.get(id=receiver_id)
+
+        msgs = get_msgs_for_chat_w_users(request.user, cur_receiver)
+        msgs.filter(receiver=request.user).update(status='seen')
+
+    except User.DoesNotExist:
+        cur_receiver = None
+
+    receivers, unread_msgs_count = get_chat_receivers_for_user(request.user)
+
+    Dict = {
+        'cur_receiver': cur_receiver,
+        'messages': msgs,
+        'receivers': receivers,
+        'page': 'chat',
+    }
+    Dict.update(get_user_timezone_Dict(request.user, request=request))
+    tpl_name = 'blocks/profile/b_chats.html'
+
+    html = render_to_string(tpl_name, Dict, request=request)
+    return html
 
 def get_chat_page_content_Dict(request, receiver_id=None):
     from AuthApp.models import User
@@ -158,19 +363,38 @@ def get_chat_receivers_for_user(user, cur_receiver=None):
     for msg in msgs:
         if msg.receiver not in receivers_list and msg.receiver != user:
             msg.receiver.unread_msgs_count = 0
-            msg.receiver.last_msg = msg.text
+            if msg.text:
+                msg.receiver.last_msg = msg.text
+            elif msg.files:
+                msg.receiver.last_msg = msg.files[len(msg.files)-1]['file_name']
             receivers_list.append(msg.receiver)
+
+
+
         if msg.sender not in receivers_list and msg.sender != user:
             msg.sender.unread_msgs_count = 0
             receivers_list.append(msg.sender)
-            msg.sender.last_msg = msg.text
+            if msg.text:
+                msg.sender.last_msg = msg.text
+            elif msg.files:
+                msg.sender.last_msg = msg.files[len(msg.files)-1]['file_name']
 
-        if msg.receiver == user:# and (not cur_receiver or msg.sender != cur_receiver):
             if msg.status == 'sended':
                 i = receivers_list.index(msg.sender)
                 receivers_list[i].unread_msgs_count += 1
                 unread_msgs_count += 1
 
+            # if msg.status == 'sended':
+            #     i = receivers_list.index(msg.sender)
+            #     receivers_list[i].unread_msgs_count += 1
+            #     unread_msgs_count += 1
+
+        # if msg.receiver == user:# and (not cur_receiver or msg.sender != cur_receiver):
+        # if msg.status == 'sended':
+        #     i = receivers_list.index(msg.sender)
+        #     receivers_list[i].unread_msgs_count += 1
+        #     unread_msgs_count += 1
+
     return receivers_list, unread_msgs_count
 
     # receivers_list.extend((item.sender for item in receivers if item.sender != user))
@@ -200,12 +424,38 @@ def get_ticketsDict_for_staff(user):
 
 def get_tickets_wo_manager():
 
-    tickets = MsgGroup.objects.filter(enable=True, manager=None).order_by('-modifiedDT')
+    tickets = MsgGroup.objects.filter(
+        enable=True, manager=None
+    ).annotate(
+        unread_msgs_count=V(1)
+    ).order_by('-modifiedDT')
+
 
     return tickets
 
 def get_tickets_for_manager(user):
+    unread_msgs = Message.objects.filter(
+        group=31, status='sended', receiver=user
+    )
+
+    unread_msgs = Message.objects.filter(
+        group=OuterRef('pk'), status='sended', receiver=user
+    ).values('id')[:1]
+
+    msgs = Message.objects.filter(
+        group=OuterRef('pk')
+    ).order_by('-modifiedDT').values('modifiedDT')[:1]
+
+    tickets = MsgGroup.objects.filter(
+        enable=True, manager=user
+    ).annotate(
+        unread_msgs_count = Count(Subquery(unread_msgs)),
+        last_msg_modifiedDT = Subquery(msgs)
+        # unread_msgs_count=Count(
+        #     'rel_messages_for_group',
+        #     filter=Q(rel_messages_for_group__status='sended', rel_messages_for_group__receiver=user)
+        # )
+    ).order_by('-unread_msgs_count', '-last_msg_modifiedDT')
 
-    tickets = MsgGroup.objects.filter(enable=True, manager=user).order_by('-modifiedDT')
 
     return tickets

ChatServiceApp/js_urls.py

@@ -10,7 +10,9 @@ urlpatterns = [
     path('support_create_ticket_form/', support_create_ticket_form_ajax, name='support_create_ticket_form_ajax'),
     path('create_ticket/', create_ticket_ajax, name='create_ticket_ajax'),
     path('support_show_chat_by_ticket/', support_show_chat_by_ticket_ajax, name='support_show_chat_by_ticket_ajax'),
-    path('send_msg/', send_msg_ajax, name='send_msg_ajax'),
+    # path('send_msg/', send_msg_ajax, name='send_msg_ajax'),
     # path('update_chat/', update_chat_ajax2, name='update_chat_ajax'),
     path('show_chat_w_user/', show_chat_w_user_ajax, name='show_chat_w_user_ajax'),
+
+    path('get_file_from_msg/', get_file_from_msg_ajax, name='get_file_from_msg_ajax'),
 ]

ChatServiceApp/js_views.py

@@ -14,25 +14,63 @@ from django.urls import reverse
 from .funcs import *
 import json
 from datetime import datetime, time
+from channels.layers import get_channel_layer
+from asgiref.sync import async_to_sync
 
 
-@login_required(login_url='/profile/login/')
+@login_required()#login_url='/profile/login/')
+def get_file_from_msg_ajax(request):
+
+    if request.method != 'POST':
+        raise Http404
+
+    from GeneralApp.funcs import get_and_set_lang
+    lang = get_and_set_lang(request)
+
+    try:
+
+        data = json.loads(request.body)
+        msg = Message.objects.get(id=data['message_id'])
+
+        res_Dict = {}
+        for file in msg.files:
+            if file['file_name'] == data['file_name']:
+                res_Dict = file
+                break
+
+        from GeneralApp.funcs import get_add_to_ajax_response_Dict
+        res_Dict.update(get_add_to_ajax_response_Dict(request.user))
+        return JsonResponse(res_Dict)
+
+    except Exception as e:
+        msg = f'get_file_from_msg_ajax Error = {str(e)}'
+        return JsonResponse({'error': msg}, status=400)
+
+
+
+@login_required()#login_url='/profile/login/')
 def show_chat_w_user_ajax(request):
 
     if request.method != 'POST':
         raise Http404
 
+    from GeneralApp.funcs import get_and_set_lang
+    lang = get_and_set_lang(request)
+
     try:
 
         data = json.loads(request.body)
         Dict = get_chat_page_content_Dict(request, data['user_id'])
+        Dict.update(get_user_timezone_Dict(request.user, request=request))
 
         tpl_name = 'blocks/profile/b_chats.html'
 
-
-
         html = render_to_string(tpl_name, Dict, request=request)
-        return JsonResponse({'html': html}, status=200)
+
+        res_Dict = {'html': html}
+        from GeneralApp.funcs import get_add_to_ajax_response_Dict
+        res_Dict.update(get_add_to_ajax_response_Dict(request.user))
+        return JsonResponse(res_Dict)
 
     except Exception as e:
         msg = f'show_chat_w_user_ajax Error = {str(e)}'
@@ -46,6 +84,9 @@ def update_chat_ajax2(request):
     if request.method != 'POST':
         raise Http404
 
+    from GeneralApp.funcs import get_and_set_lang
+    lang = get_and_set_lang(request)
+
     res_Dict = {}
     msgs = []
     Dict = {}
@@ -72,7 +113,7 @@ def update_chat_ajax2(request):
             receiver = User.objects.get(id=data['receiver'])
 
         context_Dict.update({'cur_receiver': receiver})
-
+        context_Dict.update(get_user_timezone_Dict(request.user, request=request))
 
         if not ticket:
 
@@ -96,6 +137,7 @@ def update_chat_ajax2(request):
 
                 # формируем правую панель
                 context_Dict.update({'receivers': receivers})
+
                 users_list_html = render_to_string(
                     'blocks/profile/b_list_of_users_messenger.html', context_Dict, request=request)
                 res_Dict.update({
@@ -119,7 +161,9 @@ def update_chat_ajax2(request):
         res_Dict.update({
             'required_beep': required_beep,
         })
-        return JsonResponse(res_Dict, status=200)
+        from GeneralApp.funcs import get_add_to_ajax_response_Dict
+        res_Dict.update(get_add_to_ajax_response_Dict(request.user))
+        return JsonResponse(res_Dict)
 
     except Exception as e:
         msg = f'update_chat_ajax2 Error = {str(e)}'
@@ -134,6 +178,9 @@ def update_chat_ajax(request):
     if request.method != 'POST':
         raise Http404
 
+    from GeneralApp.funcs import get_and_set_lang
+    lang = get_and_set_lang(request)
+
     res_Dict = {}
     msgs = []
     Dict = {}
@@ -163,6 +210,7 @@ def update_chat_ajax(request):
             receiver = User.objects.get(id=data['receiver'])
 
         context_Dict.update({'cur_receiver': receiver})
+        context_Dict.update(get_user_timezone_Dict(request.user, request=request))
 
         if ticket:
 
@@ -174,6 +222,8 @@ def update_chat_ajax(request):
             context_Dict.update({'messages': msgs})
             context_Dict = get_ticketsDict_for_staff(request.user)
 
+            context_Dict.update(get_user_timezone_Dict(request.user))
+
             tickets_list_html = render_to_string(
                 'blocks/profile/b_list_of_tickets_support_chat.html', context_Dict, request=request)
             res_Dict.update({
@@ -193,6 +243,8 @@ def update_chat_ajax(request):
                 required_beep = True
 
                 context_Dict.update({'receivers': receivers})
+                context_Dict.update(get_user_timezone_Dict(request.user))
+
                 users_list_html = render_to_string(
                     'blocks/profile/b_list_of_users_messenger.html', context_Dict, request=request)
                 res_Dict.update({
@@ -222,129 +274,137 @@ def update_chat_ajax(request):
         res_Dict.update({
             'required_beep': required_beep,
         })
-        return JsonResponse(res_Dict, status=200)
+
+        from GeneralApp.funcs import get_add_to_ajax_response_Dict
+        res_Dict.update(get_add_to_ajax_response_Dict(request.user))
+        return JsonResponse(res_Dict)
 
     except Exception as e:
         msg = f'update_chat_ajax Error = {str(e)}'
         return JsonResponse({'error': msg}, status=400)
 
 
-@login_required(login_url='/profile/login/')
-def send_msg_ajax(request):
-    from AuthApp.models import User
-
-    if request.method != 'POST':
-        raise Http404
-
-    res_Dict = {}
-    msg = None
-
-    try:
-
-        data = json.loads(request.body)
-        ticket = None
-
-        tpl_name = 'blocks/profile/b_messages_container.html'
-
-        if data['text']:
-
-
-            if 'ticket_id' in data:
-                ticket = MsgGroup.objects.get(id=data['ticket_id'])
-
-            sender = User.objects.get(id=data['sender'])
-            receiver = User.objects.get(id=data['receiver'])
-
-            msg_create_kwargs = {}
-
-            # если только что манагер присоединился к тикету
-            if ticket:
-                if not ticket.manager:
-                    if sender.is_staff:
-                        ticket.manager = sender
-                    else:
-                        ticket.manager = receiver
-
-                    ticket.save()
-
-                    kwargs = {
-                        'sender': ticket.owner,
-                        'receiver': ticket.manager,
-                        'text': ticket.text,
-                    }
-
-                    kwargs.update({'group': ticket})
-
-                    msg = Message.objects.create(**kwargs)
-                    Message.objects.filter(id=msg.id).update(modifiedDT=ticket.createDT, createDT=ticket.createDT)
-
-                res_Dict.update({
-                    'ticket': ticket,
-                    # 'cur_receiver': receiver,
-                    # 'messages': get_messages_for_ticket(ticket),
-                    # 'text': data['text'],
-                    # 'modifiedDT': msg.modifiedDT
-                })
-
-                msg_create_kwargs.update({
-                    'group': ticket,
-                })
-
-                res_Dict.update(get_ticketsDict_for_staff(request.user))
-
-
-            # if not msg:
-            msg_create_kwargs.update({
-                'sender': sender,
-                'receiver': receiver,
-                'text': data['text']
-            })
-
-            session_data = {
-                'for_save_to_session':{
-                    'user_alerts':{
-                        'new_message': True
-                    }
-                }
-            }
-
-            receiver.user_profile.add_node_to_json_data(session_data, save=True)
-
-            msg = Message.objects.create(**msg_create_kwargs)
-
-            if ticket:
-                msgs = get_messages_for_ticket(ticket)
-            else:
-                msgs = get_msgs_for_chat_w_users(sender, receiver)
-
-            receivers, unread_msgs_count = get_chat_receivers_for_user(request.user)
-
-
-            res_Dict.update({
-                'messages': msgs,
-                'cur_receiver': receiver,
-                'receivers': receivers,
-                'text': data['text'],
-                'modifiedDT': msgs[0].modifiedDT
-            })
-
-
-        html = render_to_string(tpl_name, res_Dict, request=request)
-        return JsonResponse({'html': html}, status=200)
-
-    except Exception as e:
-        msg = f'send_msg_ajax Error = {str(e)}'
-        return JsonResponse({'error': msg}, status=400)
+# @login_required()#login_url='/profile/login/')
+# def send_msg_ajax(request):
+#     from AuthApp.models import User
+#
+#     if request.method != 'POST':
+#         raise Http404
+#
+#     res_Dict = {}
+#     msg = None
+#
+#     try:
+#
+#         data = json.loads(request.body)
+#         ticket = None
+#
+#         tpl_name = 'blocks/profile/b_messages_container.html'
+#
+#         if data['text']:
+#
+#
+#             if 'ticket_id' in data:
+#                 ticket = MsgGroup.objects.get(id=data['ticket_id'])
+#
+#             sender = User.objects.get(id=data['sender'])
+#             receiver = User.objects.get(id=data['receiver'])
+#
+#             msg_create_kwargs = {}
+#
+#             # если только что манагер присоединился к тикету
+#             if ticket:
+#                 if not ticket.manager:
+#                     if sender.is_staff:
+#                         ticket.manager = sender
+#                     else:
+#                         ticket.manager = receiver
+#
+#                     ticket.save()
+#
+#                     kwargs = {
+#                         'sender': ticket.owner,
+#                         'receiver': ticket.manager,
+#                         'text': ticket.text,
+#                     }
+#
+#                     kwargs.update({'group': ticket})
+#
+#                     msg = Message.objects.create(**kwargs)
+#                     Message.objects.filter(id=msg.id).update(modifiedDT=ticket.createDT, createDT=ticket.createDT)
+#
+#                 # if
+#
+#                 res_Dict.update({
+#                     'ticket': ticket,
+#                     # 'cur_receiver': receiver,
+#                     # 'messages': get_messages_for_ticket(ticket),
+#                     # 'text': data['text'],
+#                     # 'modifiedDT': msg.modifiedDT
+#                 })
+#
+#                 msg_create_kwargs.update({
+#                     'group': ticket,
+#                 })
+#
+#                 res_Dict.update(get_ticketsDict_for_staff(request.user))
+#
+#
+#             # if not msg:
+#             msg_create_kwargs.update({
+#                 'sender': sender,
+#                 'receiver': receiver,
+#                 'text': data['text']
+#             })
+#
+#             session_data = {
+#                 'for_save_to_session':{
+#                     'user_alerts':{
+#                         'new_message': True
+#                     }
+#                 }
+#             }
+#
+#             receiver.user_profile.add_node_to_json_data(session_data, save=True)
+#
+#             msg = Message.objects.create(**msg_create_kwargs)
+#
+#             if ticket:
+#                 msgs = get_messages_for_ticket(ticket)
+#             else:
+#                 msgs = get_msgs_for_chat_w_users(sender, receiver)
+#
+#             receivers, unread_msgs_count = get_chat_receivers_for_user(request.user)
+#
+#
+#             res_Dict.update({
+#                 'messages': msgs,
+#                 'cur_receiver': receiver,
+#                 'receivers': receivers,
+#                 'text': data['text'],
+#                 'modifiedDT': msgs[0].modifiedDT
+#             })
+#
+#
+#         html = render_to_string(tpl_name, res_Dict, request=request)
+#         return JsonResponse({'html': html}, status=200)
+#
+#     except Exception as e:
+#         msg = f'send_msg_ajax Error = {str(e)}'
+#         return JsonResponse({'error': msg}, status=400)
 
 
 
 
-@login_required(login_url='/profile/login/')
+@login_required()#login_url='/profile/login/')
 def support_show_chat_by_ticket_ajax(request):
 
     if request.method != 'POST':
         raise Http404
 
+    from GeneralApp.funcs import get_and_set_lang
+    lang = get_and_set_lang(request)
+
     try:
 
         data = json.loads(request.body)
@@ -364,48 +424,73 @@ def support_show_chat_by_ticket_ajax(request):
             # if len(msgs) > 1:
                 new_msg_allow = True
 
+        seen_msgs = msgs.filter(receiver=request.user, status='sended')
+        if seen_msgs:
+            seen_msgs.update(status='seen')
+            msgs = get_messages_for_ticket(ticket)
+
         Dict = {
             'ticket': ticket,
             'messages': msgs,
             'cur_receiver': cur_receiver,
-            'new_msg_allow': new_msg_allow
+            'new_msg_allow': new_msg_allow,
+            'staff': request.user.is_staff,
+            # 'mobile': data['mobile']
         }
         Dict.update(get_ticketsDict_for_staff(request.user))
 
-        tpl_name = 'blocks/profile/b_support_chat.html'
+        Dict.update(get_user_timezone_Dict(request.user))
 
+        tpl_name = 'blocks/profile/b_support_chat.html'
+        Dict.update(get_user_timezone_Dict(request.user, request=request))
         html = render_to_string(tpl_name, Dict, request=request)
-        return JsonResponse({'html': html}, status=200)
+
+        res_Dict = {'html': html}
+        from GeneralApp.funcs import get_add_to_ajax_response_Dict
+        res_Dict.update(get_add_to_ajax_response_Dict(request.user))
+        return JsonResponse(res_Dict)
 
     except Exception as e:
         msg = f'support_show_chat_by_ticket_ajax Error = {str(e)}'
         return JsonResponse({'error': msg}, status=400)
 
 
-@login_required(login_url='/profile/login/')
+@login_required()#login_url='/profile/login/')
 def support_create_ticket_form_ajax(request):
     from ChatServiceApp.forms import TicketForm
 
     if request.method != 'POST':
         raise Http404
 
+    from GeneralApp.funcs import get_and_set_lang
+    lang = get_and_set_lang(request)
 
     Dict = {
         'form': TicketForm()
     }
+
+    Dict.update(get_user_timezone_Dict(request.user))
+
     tpl_name = 'blocks/profile/b_create_ticket.html'
 
     html = render_to_string(tpl_name, Dict, request=request)
-    return JsonResponse({'html': html}, status=200)
+
+    res_Dict = {'html': html}
+    from GeneralApp.funcs import get_add_to_ajax_response_Dict
+    res_Dict.update(get_add_to_ajax_response_Dict(request.user))
+    return JsonResponse(res_Dict)
 
 
-@login_required(login_url='/profile/login/')
+@login_required()#login_url='/profile/login/')
 def create_ticket_ajax(request):
     from ChatServiceApp.forms import TicketForm
 
     if request.method != 'POST':
         raise Http404
 
+    from GeneralApp.funcs import get_and_set_lang
+    lang = get_and_set_lang(request)
+
     try:
 
         data = request.POST
@@ -414,6 +499,8 @@ def create_ticket_ajax(request):
         if not form.is_valid():
             form.initial = form.cleaned_data
             Dict = {'form': form}
+            Dict.update(get_user_timezone_Dict(request.user))
+
             html = render_to_string('blocks/profile/b_create_ticket.html', Dict, request=request)
             return JsonResponse({'html': html}, status=400)
 
@@ -422,11 +509,39 @@ def create_ticket_ajax(request):
         ticket.enable = True
         ticket.save()
 
+        from .websocket_views import send_to_support_managers_list_tickets_wo_manager
+        send_to_support_managers_list_tickets_wo_manager(ticket, required_beep=True)
+        # # рассылаем всем менеджерам сообщение
+        #
+        # Dict = {
+        #     'ticket': ticket,
+        #     'tickets_wo_manager': get_tickets_wo_manager()
+        # }
+        # tickets_wo_manager_html = render_to_string('widgets/w_tickets_wo_manager.html', Dict, request=request)
+        #
+        # group_name = 'support_managers'
+        # Dict = {
+        #     'type': 'update_chat',
+        #     'tickets_wo_manager_html': tickets_wo_manager_html,
+        #     'required_beep': True,
+        #     'group_name': group_name,
+        # }
+        # channel_layer = get_channel_layer()
+        # async_to_sync(channel_layer.group_send)(
+        #     group_name,
+        #     Dict
+        # )
+        #
+        #
+        # # ---------------------
+
+        msgs_for_ticket = get_messages_for_ticket(ticket)
         Dict = {
             'ticket': ticket,
-            'messages': get_messages_for_ticket(ticket)
+            'messages': msgs_for_ticket
         }
 
+        Dict.update(get_user_timezone_Dict(request.user))
 
         html = render_to_string('blocks/profile/b_support_chat.html', Dict, request=request)
 
@@ -434,16 +549,30 @@ def create_ticket_ajax(request):
             'html': html
         }
 
+        from GeneralApp.funcs import get_add_to_ajax_response_Dict
+        res_Dict.update(get_add_to_ajax_response_Dict(request.user))
         return JsonResponse(res_Dict)
 
     except Exception as e:
 
+        msg = f'{_("ошибка в запросе")} = {str(e)}'
+
         errors_Dict = {
             'errors': {
-                'all__': f'ошибка в запросе = {str(e)}'
+                'all__': msg
             }
         }
         Dict = {'form': errors_Dict}
         html = render_to_string('blocks/profile/b_create_ticket.html', Dict, request=request)
         return JsonResponse({'html': html}, status=400)
 
+
+
+def sendDeployments(owner, armies):
+    type = "renderDeployments"
+    message = owner + " has " + str(armies) + " to deploy"
+    channel_layer = get_channel_layer()
+    async_to_sync(channel_layer.group_send)(
+        'render_updates_group',
+        {'type': 'render', 'message': message}
+    )

ChatServiceApp/models.py

@@ -3,41 +3,53 @@ from BaseModels.base_models import BaseModel
 from django.utils.translation import gettext_lazy as _
 
 msg_type_choices = (
-    ('support', 'техподдержка'),
-    ('private', 'личное')
+    ('support', _('техподдержка')),
+    ('private', _('личное'))
 )
 
 msg_status_choices = (
-    ('sended', 'Отправлено'),
-    ('seen', 'Просмотрено')
+    ('sended', _('Отправлено')),
+    ('seen', _('Просмотрено'))
 )
 
 grp_msg_status = (
-    ('open', 'Открыт'),
-    ('answered', 'Отвечен'),
-    ('closed', 'Закрыт')
+    ('open', _('Открыт')),
+    ('answered', _('Отвечен')),
+    ('closed', _('Закрыт'))
 )
 
 
 grp_msg_department = (
-    ('support', 'Отдел: Техническая поддержка'),
-    ('finance', 'Отдел: Финансовый департамент'),
+    ('support', _('Отдел: Техническая поддержка')),
+    ('finance', _('Отдел: Финансовый департамент')),
 )
 
 
 class MsgGroup(BaseModel):
     from AuthApp.models import User
 
-    department = models.CharField(verbose_name='Отдел', default='support', choices=grp_msg_department)
-    status = models.CharField(verbose_name='Статус', default='open', choices=grp_msg_status)
+    department = models.CharField(verbose_name=_('Отдел'), default='support', choices=grp_msg_department)
+    status = models.CharField(verbose_name=_('Статус'), default='open', choices=grp_msg_status)
 
-    text = models.TextField(verbose_name='Сообщение')
+    text = models.TextField(verbose_name=_('Сообщение'))
 
     owner = models.ForeignKey(User, verbose_name=_('Владелец'), related_name='rel_msgGroups_for_owner',
                               on_delete=models.SET_NULL, null=True)
     manager = models.ForeignKey(User, verbose_name=_('Менеджер'), related_name='rel_msgGroups_for_manager',
                               on_delete=models.SET_NULL, null=True)
 
+    def get_last_msg_txt(self):
+        msg = self.rel_messages_for_group.all().order_by('-createDT').first()
+        if not msg:
+            return self.text
+
+        if msg.text:
+            return msg.text
+        elif msg.files:
+            return msg.files[0]['file_name']
+
+        return self.name
+
     class Meta:
         verbose_name = _('Тикет')
         verbose_name_plural = _('Тикеты')
@@ -46,23 +58,23 @@ class MsgGroup(BaseModel):
 class Message(BaseModel):
     from AuthApp.models import User
 
-    msg_type = models.CharField(max_length=50, verbose_name='Тип сообщения', default='private', choices=msg_type_choices)
+    msg_type = models.CharField(max_length=50, verbose_name=_('Тип сообщения'), default='private', choices=msg_type_choices)
     group = models.ForeignKey(
-        MsgGroup, verbose_name='Группа сообщений', related_name='rel_messages_for_group',
+        MsgGroup, verbose_name=_('Группа сообщений'), related_name='rel_messages_for_group',
         on_delete=models.SET_NULL, null=True)
 
     sender = models.ForeignKey(
-        User, verbose_name='Отправитель', on_delete=models.CASCADE, related_name='rel_messages_for_sender'
+        User, verbose_name=_('Отправитель'), on_delete=models.CASCADE, related_name='rel_messages_for_sender'
     )
     receiver = models.ForeignKey(
-        User, verbose_name='Получатель', on_delete=models.CASCADE, related_name='rel_messages_for_receiver'
+        User, verbose_name=_('Получатель'), on_delete=models.CASCADE, related_name='rel_messages_for_receiver'
     )
 
-    text = models.TextField(verbose_name='Сообщение')
+    text = models.TextField(verbose_name=_('Сообщение'))
 
-    status = models.CharField(verbose_name='Статус', default='sended', choices=msg_status_choices)
+    status = models.CharField(verbose_name=_('Статус'), default='sended', choices=msg_status_choices)
 
-    files = models.JSONField(verbose_name='Прикрепленные файлы', default=dict)
+    files = models.JSONField(verbose_name=_('Прикрепленные файлы'), default=dict)
 
     class Meta:
         verbose_name = _('Сообщение')

ChatServiceApp/templatetags/tt_chat.py

@@ -1,5 +1,6 @@
 from django import template
 from django.template.defaultfilters import stringfilter
+from django.conf import settings
 
 register = template.Library()
 
@@ -10,9 +11,40 @@ register = template.Library()
 # from django.utils.html import mark_safe
 
 # @register.filter('get_msg_side')
+
+@register.simple_tag
+def get_ws_address():
+    return settings.WS_ADDRESS
+
+@register.simple_tag
+def get_filesize(size):
+    if size:
+        unit = 'B'
+        if size / 1024 > 1:
+            unit = 'KB'
+            size = size / 1024
+            if size / 1024 > 1:
+                unit = 'MB'
+                size = size / 1024
+                if size / 1024 > 1:
+                    unit = 'GB'
+                    size = size / 1024
+                    if size / 1024 > 1:
+                        unit = 'TB'
+                        size = size / 1024
+        size = round(size, 2)
+        return f'{str(size)}{unit}'
+    else:
+        return ''
+
+
 @register.simple_tag
 def get_msg_side(cur_user, ticket, msg):
     if msg:
+        # if msg.sender == cur_user:
+        #     return 'left'
+        # else:
+        #     return 'right'
         if msg.sender == cur_user:
             return 'right'
         else:

ChatServiceApp/urls.py

@@ -0,0 +1,11 @@
+# coding=utf-8
+from django.urls import path
+# from AuthApp.js_views import *
+# from AuthApp.import_funcs import *
+from .views import *
+from django.contrib.auth import views
+from RoutesApp.js_views import new_route_view_ajax
+
+urlpatterns = [
+    path('get_file/<str:msg_id>/<str:file_name>', get_file_from_message, name='get_file_from_message'),
+]

ChatServiceApp/views.py

@@ -1,3 +1,26 @@
-from django.shortcuts import render
+import json
 
-# Create your views here.
+from django.http import HttpResponse, Http404, FileResponse
+from django.template import loader, RequestContext
+from django.contrib.auth.decorators import login_required
+from .models import *
+from django.conf import settings
+
+def get_file_from_message(request, msg_id, file_name):
+    from django.http import FileResponse
+
+    try:
+
+        msg = Message.objects.get(id=msg_id)
+
+        if request.user not in (msg.sender, msg.receiver):
+            raise Http404
+
+        for file in msg.files:
+            if file['file_name'] == file_name:
+                f = open(f'chat_file_storage/{msg.id}/{file["file_name"]}', 'rb')
+
+                return FileResponse(f)
+
+    except Exception as e:
+        raise Http404

ChatServiceApp/websocket_urls.py

@@ -1,7 +1,8 @@
 from django.urls import re_path
+
 from .websocket_views import *
 
 websocket_urlpatterns = [
-    re_path(r'ws/socket-server/', ChatConsumer.as_asgi())
-
+    re_path(r'ws/socket-server/', ChatConsumer.as_asgi()),
+    # re_path(r'ws/chat/(?P<room_name>\w+)/$', consumers.ChatConsumer),
 ]

ChatServiceApp/websocket_views.py

@@ -1,53 +1,260 @@
 import json
-from channels.generic.websocket import WebsocketConsumer
-from asgiref.sync import async_to_sync
-# from .funcs import *
+from channels.generic.websocket import WebsocketConsumer, AsyncWebsocketConsumer, JsonWebsocketConsumer
+from asgiref.sync import async_to_sync, sync_to_async
+# from channels.auth import channel_session_user, channel_session_user_from_http
+from channels.layers import get_channel_layer
+from django.template.loader import render_to_string
+
+
+def send_to_support_managers_list_tickets_wo_manager(ticket, required_beep=False):
+    from.funcs import get_tickets_wo_manager
+
+    # рассылаем всем менеджерам сообщение
+
+    Dict = {
+        'ticket': ticket,
+        'tickets_wo_manager': get_tickets_wo_manager()
+    }
+    tickets_wo_manager_html = render_to_string('widgets/w_tickets_wo_manager.html', Dict)
+
+    group_name = 'support_managers'
+    Dict = {
+        'type': 'update_chat',
+        'tickets_wo_manager_html': tickets_wo_manager_html,
+        'required_beep': required_beep,
+        'group_name': group_name,
+    }
+    if ticket.manager:
+        Dict.update({'ticket_manager': ticket.manager.id})
+
+    channel_layer = get_channel_layer()
+    async_to_sync(channel_layer.group_send)(
+        group_name,
+        Dict
+    )
+
+    # ---------------------
+    return True
+
+
+def get_tickets_wo_manager_html(ticket, user, data):
+    from .funcs import get_tickets_wo_manager
+
+    # если не менеджер - возвращаем None
+    if not ticket or ticket.manager.id != user.id:
+        return None
+
+    Dict = {
+        'ticket': ticket,
+        'tickets_wo_manager': get_tickets_wo_manager()
+    }
+    tickets_wo_manager_html = render_to_string('widgets/w_tickets_wo_manager.html', Dict)
+
+    return tickets_wo_manager_html
+
+
+def get_tickets_w_manager_html(ticket, user, data):
+    from .funcs import get_tickets_for_manager
+
+    # если не менеджер - возвращаем None
+    if not ticket or ticket.manager.id != user.id:
+        return None
+
+    Dict = {
+        'ticket': ticket,
+        'tickets_for_manager': get_tickets_for_manager(user)
+    }
+    tickets_w_manager_html = render_to_string('widgets/w_tickets_w_manager.html', Dict)
+
+    return tickets_w_manager_html
+
 
 class ChatConsumer(WebsocketConsumer):
+
+    # def __init__(self, *args, **kwargs):
+    #     super().__init__(args, kwargs)
+    #     self.room_name = None
+
+    def disconnect(self, close_code):
+        print("Closed websocket with code: ", close_code)
+
+        for gr in self.groups:
+            async_to_sync(self.channel_layer.group_discard)(
+                gr,
+                self.channel_name
+            )
+        self.close()
+
     def connect(self):
         print('ws connect')
-        self.room_group_name = 'test'
 
-        async_to_sync(self.channel_layer.group_add)(
-            self.room_group_name,
-            self.channel_name
-        )
-        print(f'self.room_group_name = {self.room_group_name}')
-        print(f'self.channel_name = {self.channel_name}')
+        user_group = f'user_{self.scope["user"].id}'
+
+        add_to_group = False
+        if not self.groups or not user_group in self.groups or not self.channel_name in self.groups[user_group]:
+            add_to_group = True
+
+        if add_to_group:
+            if not self.groups:
+                self.groups = {user_group: [self.channel_name]}
+            elif not user_group in self.groups:
+                self.groups[user_group].append(self.channel_name)
+            else:
+                self.groups.update({user_group: [self.channel_name]})
+
+            async_to_sync(self.channel_layer.group_add)(
+                user_group,
+                self.channel_name
+            )
+
+            print(f'created group user_{self.scope["user"].id}')
+
+        if self.scope['user'].is_staff:
+            async_to_sync(self.channel_layer.group_add)(
+                f'support_managers',
+                self.channel_name
+            )
+            print(f'add user {self.scope["user"].id} to group support_managers')
+
         self.accept()
 
-    def receive(self, text_data):
-        print(f'ws receive text_data = {text_data}')
 
-        from .funcs import send_msg
-        resDict = send_msg(text_data)
-        resDict.update({
-            'type': 'ws_send_msg',
-            'message': resDict,
-            # 'sender': sender
+
+
+    def receive(self, text_data=None, bytes_data=None):
+        if len(text_data) < 500:
+            print(f'ws receive text_data = {text_data}')
+        else:
+            print(f'ws receive text_data size = {len(text_data)}')
+
+        import base64
+
+        from AuthApp.models import User
+        from .models import Message, MsgGroup
+
+
+        data = json.loads(text_data)
+
+        # if 'file' in data:
+        #     file_Dict = json.loads(data['file'])
+        #
+        #     f = open(f'chat_file_storage/{file_Dict["file_name"]}', 'wb+')
+        #     head, content = file_Dict['file'].split(',')
+        #     content = base64.b64decode(content)
+        #     f.write(content)
+        #     f.close()
+
+        sender = data['sender']
+        receiver = data['receiver']
+        sender_obj = User.objects.get(id=sender)
+        receiver_obj = User.objects.get(id=receiver)
+
+
+
+        from .funcs import send_msg, get_update_chat_Dict
+        data.update({
+            'cur_user': sender,
+            'required_beep': False,
         })
-        print(f'send_msg res = {len(resDict)}')
+        res = send_msg(data)
+        if not res['msg'] or type(res['msg']) == str:
+            data.update({'bad_manager': True})
 
-        self.send(json.dumps(resDict))
+        ticket = None
 
+        if 'ticket_id' in data and data['ticket_id']:
+            ticket = MsgGroup.objects.get(id=data['ticket_id'])
+            # receiver_obj = User.objects.get(id=receiver)
+            msgs = Message.objects.filter(
+                receiver__id=sender, group__id=data['ticket_id']
+            )
+            msgs.update(status='seen')
+
+            if 'required_update_tickets_list_wo_managers' in res and res['required_update_tickets_list_wo_managers']:
+                send_to_support_managers_list_tickets_wo_manager(ticket, required_beep=False)
+
+        Dict = get_update_chat_Dict(data)
+
+
+
+        group_name = f'user_{sender}'
+        resDict = {
+            'type': 'update_chat',
+            'sender': sender,
+            'receiver': receiver,
+            'group_name': group_name,
+
+        }
+
+        if ticket:
+            tickets_wo_manager_html = get_tickets_wo_manager_html(ticket, sender_obj, data)
+            if tickets_wo_manager_html:
+                resDict.update({'tickets_wo_manager_html': tickets_wo_manager_html})
+
+            tickets_w_manager_html = get_tickets_w_manager_html(ticket, sender_obj, data)
+            if tickets_w_manager_html:
+                resDict.update({'tickets_w_manager_html': tickets_w_manager_html})
+
+
+        resDict.update(Dict)
         async_to_sync(self.channel_layer.group_send)(
-            self.room_group_name,
+            group_name,
             resDict
-            # {
-            #     'type': 'chat_message',
-            #     'message': message,
-            #     'sender': sender
-            # }
         )
 
-    def ws_send_msg(self, event):
+        group_name = f'user_{receiver}'
+        # if group_name in self.channel_layer.groups.keys():
+        data.update({
+            'cur_user': receiver,
+            'required_beep': True,
+        })
+        Dict = get_update_chat_Dict(data)
+
+        if 'support_chat_html' in Dict:
+            msg_type = 'update_support_chat'
+        else:
+            msg_type = 'update_chat'
+
+        resDict = {
+            'type': msg_type,
+            'sender': receiver,
+            'receiver': sender,
+            'group_name': group_name,
+        }
+
+        if ticket:
+            tickets_wo_manager_html = get_tickets_wo_manager_html(ticket, receiver_obj, data)
+            if tickets_wo_manager_html:
+                resDict.update({'tickets_wo_manager_html': tickets_wo_manager_html})
+
+            tickets_w_manager_html = get_tickets_w_manager_html(ticket, receiver_obj, data)
+            if tickets_w_manager_html:
+                resDict.update({'tickets_w_manager_html': tickets_w_manager_html})
+
+        resDict.update(Dict)
+        async_to_sync(self.channel_layer.group_send)(
+            group_name,
+            resDict
+        )
+
+
+
+    def echo(self, data):
+        print('ws echo')
+
+        self.send(text_data=json.dumps(data))
+
+    def update_support_chat(self, data):
+        print(f'ws update_support_chat {data["group_name"]}')
+
+        self.send(text_data=json.dumps(data))
+
+    def update_chat(self, data):
+        print(f'ws update_chat {data["group_name"]}')
+
+        self.send(text_data=json.dumps(data))
+
+    def ws_send_msg(self, data):
         print('ws ws_send_msg')
 
-        message = event['message']
-        # sender = event['sender']
-
-        self.send(text_data=json.dumps({
-            'type': 'chat',
-            'message': message,
-            # 'sender': sender
-        }))
+        self.send(text_data=json.dumps(data))

GeneralApp/admin.py

@@ -1,75 +1,114 @@
 from sets.admin import *
 from .models import *
 from django.contrib import admin
+from django.utils.translation import gettext as _
+
+
 
 class Admin_StaticPage(Admin_Trans_BaseModelViewPage):
 
-    def get_fieldsets(self, request, obj=None):
-        fieldsets = super(type(self), self).get_fieldsets(request, obj)
-        if not request.user.is_superuser and obj.url and obj.url in ('main', 'spec_technics', 'works'):
-            fieldsets[0][1]['fields'].pop(2)
-        # fieldsets.insert(
-        #     1, ('Промо-хэдер', {
-        #         'classes': ['wide'],
-        #         'fields': (
-        #             'promo_header',
-        #             'title', 'description', 'text',
-        #             'picture',
-        #         )
-        #
-        #     })
-        # )
-        return fieldsets
+    fieldsets = [
+        (None, {
+            'classes': ['wide'],
+            'fields': ('name',
+                       'url',
+                       'title', 'description', 'text',
+                       'picture',
+                       'order',
+                       )
+        }),
+        (_('Настройки'), {
+            'classes': ['wide', 'collapse'],
+            'fields': (
+                'FAQ_title',
+            )
+        }),
+        ('SEO', {
+            'classes': ['wide', 'collapse'],
+            'fields': (
+                'seo_title', 'seo_description', 'seo_keywords', 'seo_text',
+           )
+        }),
+    ]
+
+
+    list_display = [
+        'id',
+        'name', 'url', 'title',
+        'order', 'modifiedDT', 'createDT'
+    ]
+
+    list_display_links = ['id']
+    list_editable = ['order']
+
+    list_filter = ['modifiedDT', 'createDT']
+    search_fields = ['name', 'title']
+    # filter_horizontal = ['options']
 
     def has_delete_permission(self, request, obj=None):
         if request.user.is_superuser:
            return True
 
-        if obj.url in ('main', 'spec_technics', 'works'):
+        if not obj or obj.url in ('main', 'works'):
             return False
 
 admin.site.register(StaticPage,Admin_StaticPage)
 
-class Admin_Block(Admin_BaseBlock):
+# class Admin_Block(Admin_Trans_BaseModel):
+#     pass
+#
+#     # def get_fieldsets(self, request, obj=None):
+#     #     fieldsets = super(type(self), self).get_fieldsets(request, obj)
+#     #     if not request.user.is_superuser and obj.name and obj.name in ('About US', 'machines', 'works'):
+#     #         fieldsets[0][1]['fields'].pop(0)
+#     #     fieldsets.insert(
+#     #         1, (_('Контент'), {
+#     #             'classes': ['wide'],
+#     #             'fields': (
+#     #                 'title', 'description', 'text',
+#     #                 'picture',
+#     #             )
+#     #
+#     #         })
+#     #     )
+#     #     return fieldsets
+#     #
+#     # def has_delete_permission(self, request, obj=None):
+#     #     if request.user.is_superuser:
+#     #        return True
+#     #
+#     #     if obj.name in ('About US', 'machines', 'works'):
+#     #         return False
+#
+# admin.site.register(Block,Admin_Block)
 
-    def get_fieldsets(self, request, obj=None):
-        fieldsets = super(type(self), self).get_fieldsets(request, obj)
-        if not request.user.is_superuser and obj.name and obj.name in ('About US', 'machines', 'works'):
-            fieldsets[0][1]['fields'].pop(0)
-        fieldsets.insert(
-            1, ('Контент', {
-                'classes': ['wide'],
-                'fields': (
-                    'title', 'description', 'text',
-                    'picture',
-                )
+class Admin_Option(Admin_Trans_BaseModel):
 
-            })
-        )
-        return fieldsets
+    # def get_fieldsets(self, request, obj=None):
+    #     fieldsets = super(type(self), self).get_fieldsets(request, obj)
+    #     fieldsets.insert(
+    #         1, ('Контент', {
+    #             'classes': ['wide'],
+    #             'fields': (
+    #                 'opt_type', 'prefix', 'value', 'picture'
+    #             )
+    #
+    #         })
+    #     )
+    #     return fieldsets
 
-    def has_delete_permission(self, request, obj=None):
-        if request.user.is_superuser:
-           return True
 
-        if obj.name in ('About US', 'machines', 'works'):
-            return False
+    fieldsets = [
+        (_('Контент'), {
+            'classes': ['wide'],
+            'fields': (
+               'name', 'opt_type', 'prefix', 'value', 'picture'
+            )
+        }),
+    ]
 
-admin.site.register(Block,Admin_Block)
-
-class Admin_Option(Admin_BaseModel):
-
-    def get_fieldsets(self, request, obj=None):
-        fieldsets = super(type(self), self).get_fieldsets(request, obj)
-        fieldsets.insert(
-            1, ('Контент', {
-                'classes': ['wide'],
-                'fields': (
-                    'opt_type', 'prefix', 'value', 'picture'
-                )
-
-            })
-        )
-        return fieldsets
+    list_display = ['image_thumb', 'opt_type', 'name', 'value', 'prefix']
+    list_editable = ['value', 'prefix']
+    list_filter = ['opt_type']
 
 admin.site.register(Option,Admin_Option)

GeneralApp/allauth_funcs.py

@@ -0,0 +1,51 @@
+from allauth.socialaccount.adapter import DefaultSocialAccountAdapter
+from allauth.account.utils import user_field
+from django.conf import settings
+from allauth.account.adapter import DefaultAccountAdapter
+import requests
+from django.core.files import File
+from django.core.files.temp import NamedTemporaryFile
+
+class MyAccountAdapter(DefaultAccountAdapter):
+
+    def get_login_redirect_url(self, request):
+        path = super(MyAccountAdapter, self).get_login_redirect_url(request)
+
+        try:
+            user = request.user
+            user_profile = user.user_profile
+            if user_profile and not user_profile.avatar:
+                social_accounts = user.socialaccount_set.all()
+                if social_accounts:
+                    for social_account in social_accounts:
+                        if 'picture' in social_account.extra_data and social_account.extra_data['picture']:
+                            r = requests.get(social_account.extra_data['picture'])
+
+                            img_temp = NamedTemporaryFile()
+                            img_temp.write(r.content)
+                            img_temp.flush()
+                            user_profile.avatar.save(f'avatar_{user.id}.jpeg', File(img_temp), True)
+                            break
+
+        except Exception as e:
+            msg = f'post_save create_user_profile Error = {str(e)}'
+            print(msg)
+
+        return path
+
+# class CustomSocialAccountAdapter(DefaultSocialAccountAdapter):
+#     def populate_user(self, request, sociallogin, data):
+#         from AuthApp.models import UserProfile
+#
+#         user = super().populate_user(request, sociallogin, data)
+#         try:
+#             picture = sociallogin.account.extra_data['picture']
+#             user_profile = UserProfile.objects.get_or_create(user=user)
+#             with open(picture, 'rb') as fd:
+#                 user_profile.avatar.save(f'user_{user.id}_avatar.jpeg', fd.read(), True)
+#             # user_field(user, "profile_photo", picture)
+#         except Exception as e:
+#             msg = f'CustomSocialAccountAdapter populate_user Error = {str(e)}'
+#             print(msg)
+#
+#         return user

GeneralApp/funcs.py

@@ -0,0 +1,91 @@
+from django.http import HttpResponse, Http404, FileResponse
+from django.conf import settings
+
+
+def get_and_set_lang(request):
+    from django.utils.translation import activate, get_language
+    lang = None
+
+    cur_url_list = request.path.split('/')
+    if len(cur_url_list) > 1 and cur_url_list[1] in settings.MODELTRANSLATION_LANGUAGES:
+        lang = cur_url_list[1]
+
+    if not lang:
+        referer_url = request.META.get('HTTP_REFERER')
+        if referer_url:
+            url_list = referer_url.split('//')
+            if len(url_list) > 1:
+                url_list = url_list[1].split('/')
+                if len(url_list) > 1 and url_list[1] in settings.MODELTRANSLATION_LANGUAGES:
+                    lang = url_list[1]
+
+    if not lang:
+        lang = get_language()
+
+    if not lang:
+        lang = 'en'
+
+    activate(lang)
+
+    return lang
+
+
+def get_add_to_ajax_response_Dict(user):
+    context_Dict = {}
+
+    from ChatServiceApp.funcs import get_unanswered_msgs_count_for_user
+    context_Dict.update({
+        'unanswered_msgs_count': get_unanswered_msgs_count_for_user(user)
+    })
+
+    return context_Dict
+
+
+
+def get_inter_Dict(user):
+
+    from SubscribesApp.funcs import get_cur_user_subscribe
+    user_subscribe = get_cur_user_subscribe(user)
+
+
+    Dict = {
+        'user_subscribe': user_subscribe,
+        'prod': True
+    }
+
+    if settings.WS_ADDRESS == 'localhost:8000':
+        Dict.update({'prod': False})
+
+
+    from PushMessages.views import get_key_Dict
+    Dict.update(get_key_Dict())
+
+    return Dict
+
+def get_inter_http_response(template_obj, context_Dict, request):
+
+    context_Dict.update(get_inter_Dict(request.user))
+
+    from PushMessages.views import send_push
+    if request and 'page' in context_Dict:
+        text = None
+        title = None
+
+        if context_Dict['page'] == dict:
+            if 'title' in context_Dict['page']:
+                title = context_Dict['page']['title']
+            if 'description' in context_Dict['page']:
+                text = context_Dict['page']['description']
+        else:
+            title = getattr(context_Dict['page'], 'title', None)
+            text = getattr(context_Dict['page'], 'description', None)
+
+        # if text and title and not request.user.is_anonymous:
+        #     send_push(user=request.user, title=title, text=text)
+
+    from ChatServiceApp.funcs import get_unanswered_msgs_count_for_user
+    context_Dict.update({
+        'unanswered_msgs_count': get_unanswered_msgs_count_for_user(request.user)
+    })
+
+    return HttpResponse(template_obj.render(context_Dict, request))

GeneralApp/funcs_options.py

@@ -0,0 +1,44 @@
+from .models import *
+
+def get_options_by_opt_types(opt_types, only_vals=False):
+    if type(opt_types) == str:
+        kwargs = {'opt_type': opt_types}
+    elif type(opt_types) == dict:
+        kwargs = opt_types
+    else:
+        kwargs = {'opt_type__in': opt_types}
+
+    opts = Option.objects.filter(**kwargs)
+    if opts and only_vals:
+        res = {}
+        opts = opts.values('opt_type', 'value', 'prefix')
+        for item in opts:
+            # if item['opt_type'] == 'domain':
+            #
+            #     try:
+            #         from django.contrib.sites.models import Site
+            #         current_site = Site.objects.get_current()
+            #         res.update({item['opt_type']: current_site.domain})
+            #         # continue
+            #     except Exception as e:
+            #         print(str(e))
+
+            if item['prefix']:
+                res.update({item['opt_type']: f"{item['prefix']}{item['value']}"})
+            else:
+                res.update({item['opt_type']: f"{item['value']}"})
+        return res
+
+    return opts
+
+def get_first_option_value_by_opt_type(opt_type):
+    opts = get_options_by_opt_types(opt_type)
+    if opts:
+        return opts[0].value
+    else:
+        return None
+
+def get_mail_send_options():
+    opt_types = ['mail_server_url', 'mail_server_smtp_port', 'sender_mail_login', 'sender_mail_password', 'sender_email', 'project_name']
+
+    return get_options_by_opt_types(opt_types, only_vals=True)

GeneralApp/init_options.py

@@ -0,0 +1,66 @@
+from .models import *
+from django.utils.translation import gettext as _
+
+
+required_options_Dict = {
+    'mail_server_url': {
+        'name_ru': 'Адрес почтового сервера',
+        'opt_type': 'mail_server_url',
+        'value': '213.142.147.40',
+    },
+    'mail_server_smtp_port': {
+        'name_ru': 'SMTP порт почтового сервера',
+        'opt_type': 'mail_server_smtp_port',
+        'value': 587,
+    },
+    'sender_mail_login': {
+        'name_ru': 'email для отправки писем с сайта',
+        'opt_type': 'sender_mail_login',
+        'value': 'admin@tripwb.com',
+    },
+    'sender_email': {
+        'name_ru': 'email для отправки',
+        'opt_type': 'sender_email',
+        'value': 'admin@tripwb.com',
+    },
+    'sender_mail_password': {
+        'name_ru': 'пароль для отправки писем с сайта',
+        'opt_type': 'sender_mail_password',
+        'value': 't5Fdcah^gdajY',
+    },
+    'project_name': {
+        'name_ru': 'Название проекта',
+        'opt_type': 'project_name',
+        'value': 'TWB',
+    },
+    'domain': {
+        'name_ru': 'Адрес сайта',
+        'opt_type': 'domain',
+        'value': 'tripwb.com',
+    },
+    'support_email': {
+        'name_ru': 'email техподдержки',
+        'opt_type': 'support_email',
+        'value': 'admin@tripwb.com',
+    },
+    'corp_email': {
+        'name_ru': 'корпоративный email',
+        'opt_type': 'corp_email',
+        'value': 'admin@tripwb.com',
+    },
+
+ }
+
+def init_options():
+    options = Option.objects.all()
+    option_types_list = options.values_list('opt_type', flat=True)
+
+    opts_for_create = []
+    for opt_type, data_Dict in required_options_Dict.items():
+        if not opt_type in option_types_list:
+            opt = Option(**data_Dict)
+            opts_for_create.append(opt)
+
+    Option.objects.bulk_create(opts_for_create)
+
+    return True

GeneralApp/management/commands/every_1hour_start.py

@@ -0,0 +1,48 @@
+from django.core.management.base import BaseCommand
+from datetime import datetime
+from BaseModels.mailSender import techSendMail
+from ...funcs_options import get_options_by_opt_types, get_mail_send_options
+
+class Command(BaseCommand):
+
+    def handle(self, *args, **options):
+        mail_sets = get_mail_send_options()
+
+        log = ''
+        log_begin_DT = datetime.now()
+        msg = str(log_begin_DT)
+        print('-------------')
+        print(msg)
+
+        try:
+            from RoutesApp.search_matches import search_matches
+            msg = search_matches()
+            if msg:
+                print(msg)
+                log += f'\n{msg}'
+        except Exception as e:
+            msg = f'every_1hour_start search_matches fail = {str(e)}'
+            print(msg)
+            techSendMail(mail_sets, msg, title='every_1hour_start search_matches')
+
+
+        if datetime.now().hour == 19:
+            try:
+                from SubscribesApp.reports import send_mail_for_user_subscribes_that_is_going_to_finish
+                msg = send_mail_for_user_subscribes_that_is_going_to_finish()
+                if msg:
+                    print(msg)
+                    log += f'\n{msg}'
+            except Exception as e:
+                msg = f'send_mail_for_user_subscribes_that_is_going_to_finish search_matches fail = {str(e)}'
+                print(msg)
+                techSendMail(mail_sets, msg, title='every_1hour_start send_mail_for_user_subscribes_that_is_going_to_finish')
+
+            if log:
+                techSendMail(mail_sets, str(msg), title='every_1hour_start get_competitors_prices')
+
+
+
+        print(f'- processing time = {str(datetime.now() - log_begin_DT)} -')
+
+

GeneralApp/management/commands/every_day_start.py

@@ -0,0 +1,31 @@
+from django.core.management.base import BaseCommand
+from datetime import datetime
+from BaseModels.mailSender import techSendMail
+from GeneralApp.funcs_options import get_options_by_opt_types, get_mail_send_options
+
+class Command(BaseCommand):
+
+    def handle(self, *args, **options):
+        mail_sets = get_mail_send_options()
+
+        log = ''
+        log_begin_DT = datetime.now()
+        msg = str(log_begin_DT)
+        print('-------------')
+        print(msg)
+
+        try:
+            from SubscribesApp.funcs import finish_user_subscribes, extension_free_subscribes
+            extension_free_subscribes()
+            finish_user_subscribes()
+        except Exception as e:
+            msg = f'every_day_start fail = {str(e)}'
+            print(msg)
+            techSendMail(mail_sets, msg, title='every_day_start fail')
+
+        # if msg:
+        #     techSendMail(mail_sets, str(msg), title='every_1hour_start get_competitors_prices')
+
+        print(f'- processing time = {str(datetime.now() - log_begin_DT)} -')
+
+

GeneralApp/migrations/0003_staticpage_seo_description_en_and_more.py

@@ -0,0 +1,44 @@
+# Generated by Django 4.2.2 on 2023-08-31 13:21
+
+import ckeditor.fields
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('GeneralApp', '0002_block_faq_title_en_block_faq_title_ru_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='staticpage',
+            name='seo_description_en',
+            field=models.CharField(blank=True, max_length=250, null=True, verbose_name='Description (150 знаков)'),
+        ),
+        migrations.AddField(
+            model_name='staticpage',
+            name='seo_description_ru',
+            field=models.CharField(blank=True, max_length=250, null=True, verbose_name='Description (150 знаков)'),
+        ),
+        migrations.AddField(
+            model_name='staticpage',
+            name='seo_text_en',
+            field=ckeditor.fields.RichTextField(blank=True, null=True, verbose_name='Текст SEO статьи'),
+        ),
+        migrations.AddField(
+            model_name='staticpage',
+            name='seo_text_ru',
+            field=ckeditor.fields.RichTextField(blank=True, null=True, verbose_name='Текст SEO статьи'),
+        ),
+        migrations.AddField(
+            model_name='staticpage',
+            name='seo_title_en',
+            field=models.CharField(blank=True, max_length=250, null=True, verbose_name='Title (80 знаков)'),
+        ),
+        migrations.AddField(
+            model_name='staticpage',
+            name='seo_title_ru',
+            field=models.CharField(blank=True, max_length=250, null=True, verbose_name='Title (80 знаков)'),
+        ),
+    ]

GeneralApp/migrations/0004_alter_block_description_alter_block_description_en_and_more.py

@@ -0,0 +1,109 @@
+# Generated by Django 4.2.2 on 2023-09-22 13:29
+
+import ckeditor_uploader.fields
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('GeneralApp', '0003_staticpage_seo_description_en_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='block',
+            name='description',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, help_text='краткое описание страницы (до 240 символов)', null=True, verbose_name='Краткое описание'),
+        ),
+        migrations.AlterField(
+            model_name='block',
+            name='description_en',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, help_text='краткое описание страницы (до 240 символов)', null=True, verbose_name='Краткое описание'),
+        ),
+        migrations.AlterField(
+            model_name='block',
+            name='description_ru',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, help_text='краткое описание страницы (до 240 символов)', null=True, verbose_name='Краткое описание'),
+        ),
+        migrations.AlterField(
+            model_name='block',
+            name='seo_text',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, null=True, verbose_name='Текст SEO статьи'),
+        ),
+        migrations.AlterField(
+            model_name='block',
+            name='text',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, null=True, verbose_name='Полное описание'),
+        ),
+        migrations.AlterField(
+            model_name='block',
+            name='text_en',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, null=True, verbose_name='Полное описание'),
+        ),
+        migrations.AlterField(
+            model_name='block',
+            name='text_ru',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, null=True, verbose_name='Полное описание'),
+        ),
+        migrations.AlterField(
+            model_name='faqitem',
+            name='answer',
+            field=ckeditor_uploader.fields.RichTextUploadingField(verbose_name='Ответ'),
+        ),
+        migrations.AlterField(
+            model_name='faqitem',
+            name='answer_en',
+            field=ckeditor_uploader.fields.RichTextUploadingField(null=True, verbose_name='Ответ'),
+        ),
+        migrations.AlterField(
+            model_name='faqitem',
+            name='answer_ru',
+            field=ckeditor_uploader.fields.RichTextUploadingField(null=True, verbose_name='Ответ'),
+        ),
+        migrations.AlterField(
+            model_name='staticpage',
+            name='description',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, help_text='краткое описание страницы (до 240 символов)', null=True, verbose_name='Краткое описание'),
+        ),
+        migrations.AlterField(
+            model_name='staticpage',
+            name='description_en',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, help_text='краткое описание страницы (до 240 символов)', null=True, verbose_name='Краткое описание'),
+        ),
+        migrations.AlterField(
+            model_name='staticpage',
+            name='description_ru',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, help_text='краткое описание страницы (до 240 символов)', null=True, verbose_name='Краткое описание'),
+        ),
+        migrations.AlterField(
+            model_name='staticpage',
+            name='seo_text',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, null=True, verbose_name='Текст SEO статьи'),
+        ),
+        migrations.AlterField(
+            model_name='staticpage',
+            name='seo_text_en',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, null=True, verbose_name='Текст SEO статьи'),
+        ),
+        migrations.AlterField(
+            model_name='staticpage',
+            name='seo_text_ru',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, null=True, verbose_name='Текст SEO статьи'),
+        ),
+        migrations.AlterField(
+            model_name='staticpage',
+            name='text',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, null=True, verbose_name='Полное описание'),
+        ),
+        migrations.AlterField(
+            model_name='staticpage',
+            name='text_en',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, null=True, verbose_name='Полное описание'),
+        ),
+        migrations.AlterField(
+            model_name='staticpage',
+            name='text_ru',
+            field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, null=True, verbose_name='Полное описание'),
+        ),
+    ]

GeneralApp/migrations/0005_option_name_en_option_name_ru_option_prefix_en_and_more.py

@@ -0,0 +1,43 @@
+# Generated by Django 4.2.2 on 2023-11-30 13:42
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('GeneralApp', '0004_alter_block_description_alter_block_description_en_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='option',
+            name='name_en',
+            field=models.TextField(blank=True, help_text='Название', null=True, verbose_name='Название'),
+        ),
+        migrations.AddField(
+            model_name='option',
+            name='name_ru',
+            field=models.TextField(blank=True, help_text='Название', null=True, verbose_name='Название'),
+        ),
+        migrations.AddField(
+            model_name='option',
+            name='prefix_en',
+            field=models.CharField(blank=True, max_length=250, null=True, verbose_name='Префикс'),
+        ),
+        migrations.AddField(
+            model_name='option',
+            name='prefix_ru',
+            field=models.CharField(blank=True, max_length=250, null=True, verbose_name='Префикс'),
+        ),
+        migrations.AddField(
+            model_name='option',
+            name='value_en',
+            field=models.CharField(max_length=250, null=True, verbose_name='Значение'),
+        ),
+        migrations.AddField(
+            model_name='option',
+            name='value_ru',
+            field=models.CharField(max_length=250, null=True, verbose_name='Значение'),
+        ),
+    ]

GeneralApp/migrations/0006_mediaitem.py

@@ -0,0 +1,41 @@
+# Generated by Django 4.2.2 on 2024-11-15 14:50
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('contenttypes', '0002_remove_content_type_name'),
+        ('GeneralApp', '0005_option_name_en_option_name_ru_option_prefix_en_and_more'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='MediaItem',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.TextField(blank=True, help_text='Название', null=True, verbose_name='Название')),
+                ('name_ru', models.TextField(blank=True, help_text='Название', null=True, verbose_name='Название')),
+                ('name_en', models.TextField(blank=True, help_text='Название', null=True, verbose_name='Название')),
+                ('name_plural', models.TextField(blank=True, null=True, verbose_name='Название (множественное число)')),
+                ('order', models.IntegerField(blank=True, null=True, verbose_name='Очередность отображения')),
+                ('createDT', models.DateTimeField(auto_now_add=True, verbose_name='Дата и время создания')),
+                ('modifiedDT', models.DateTimeField(blank=True, null=True, verbose_name='Дата и время последнего изменения')),
+                ('enable', models.BooleanField(db_index=True, default=True, verbose_name='Включено')),
+                ('json_data', models.JSONField(blank=True, default=dict, verbose_name='Дополнительные данные')),
+                ('object_id', models.PositiveIntegerField()),
+                ('picture', models.ImageField(blank=True, null=True, upload_to='media/', verbose_name='Фото')),
+                ('video', models.FileField(blank=True, null=True, upload_to='media/video/', verbose_name='Видео')),
+                ('comment', models.TextField(blank=True, null=True, verbose_name='Комментарий')),
+                ('comment_ru', models.TextField(blank=True, null=True, verbose_name='Комментарий')),
+                ('comment_en', models.TextField(blank=True, null=True, verbose_name='Комментарий')),
+                ('content_type', models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, to='contenttypes.contenttype')),
+            ],
+            options={
+                'verbose_name': 'Медиа элемент',
+                'verbose_name_plural': 'Медиа элементы',
+            },
+        ),
+    ]

GeneralApp/migrations/0007_alter_mediaitem_picture_alter_mediaitem_video.py

@@ -0,0 +1,23 @@
+# Generated by Django 4.2.2 on 2024-11-15 15:58
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('GeneralApp', '0006_mediaitem'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='mediaitem',
+            name='picture',
+            field=models.ImageField(blank=True, null=True, upload_to='uploads/', verbose_name='Фото'),
+        ),
+        migrations.AlterField(
+            model_name='mediaitem',
+            name='video',
+            field=models.FileField(blank=True, null=True, upload_to='uploads/video/', verbose_name='Видео'),
+        ),
+    ]

GeneralApp/migrations/0008_alter_mediaitem_picture_alter_mediaitem_video.py

@@ -0,0 +1,23 @@
+# Generated by Django 4.2.2 on 2024-11-15 15:59
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('GeneralApp', '0007_alter_mediaitem_picture_alter_mediaitem_video'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='mediaitem',
+            name='picture',
+            field=models.ImageField(blank=True, null=True, upload_to='media_items/photo/', verbose_name='Фото'),
+        ),
+        migrations.AlterField(
+            model_name='mediaitem',
+            name='video',
+            field=models.FileField(blank=True, null=True, upload_to='media_items/video/', verbose_name='Видео'),
+        ),
+    ]

GeneralApp/models.py

@@ -1,10 +1,31 @@
 from django.db import models
 from BaseModels.base_models import BaseModelViewPage, BaseModel
 from django.utils.translation import gettext_lazy as _
-from ckeditor.fields import RichTextField
+# from ckeditor.fields import RichTextField
+from ckeditor_uploader.fields import RichTextUploadingField
+from django.contrib.contenttypes.models import ContentType
+from django.contrib.contenttypes.fields import GenericForeignKey
+
+
+class MediaItem(BaseModel):
+
+    content_type = models.ForeignKey(ContentType, on_delete=models.SET_NULL, null=True)
+    object_id = models.PositiveIntegerField()
+    content_object = GenericForeignKey('content_type', 'object_id')
+
+    picture = models.ImageField(upload_to='media_items/photo/', verbose_name=_('Фото'), null=True, blank=True)
+    video = models.FileField(upload_to='media_items/video/', verbose_name=_('Видео'), null=True, blank=True)
+
+    comment = models.TextField(verbose_name=_('Комментарий'), null=True, blank=True)
+
+    class Meta:
+        verbose_name = _('Медиа элемент')
+        verbose_name_plural = _('Медиа элементы')
+
+
 
 class StaticPage(BaseModelViewPage):
-    promo_header = models.BooleanField(verbose_name='Промо-хэдер', default=False)
+    promo_header = models.BooleanField(verbose_name=_('Промо-хэдер'), default=False)
 
     class Meta:
         verbose_name = _('Статическая страница')
@@ -16,9 +37,9 @@ class Block(BaseModelViewPage):
         verbose_name_plural = _('Блоки на страницах')
 
 class Option(BaseModel):
-    opt_type = models.CharField(max_length=250, verbose_name='Тип', blank=True, null=True)
-    prefix = models.CharField(max_length=250, verbose_name='Префикс', blank=True, null=True)
-    value = models.CharField(max_length=250, verbose_name='Значение')
+    opt_type = models.CharField(max_length=250, verbose_name=_('Тип'), blank=True, null=True)
+    prefix = models.CharField(max_length=250, verbose_name=_('Префикс'), blank=True, null=True)
+    value = models.CharField(max_length=250, verbose_name=_('Значение'))
     picture = models.ImageField(upload_to='uploads/', verbose_name=_('Миниатюра'), null=True, blank=True,
                                 help_text=u'')
 
@@ -28,15 +49,12 @@ class Option(BaseModel):
 
 class FAQitem(BaseModel):
 
-    from django.contrib.contenttypes.models import ContentType
-    from django.contrib.contenttypes.fields import GenericForeignKey
-
     content_type = models.ForeignKey(ContentType, on_delete=models.SET_NULL, null=True)
     object_id = models.PositiveIntegerField()
     content_object = GenericForeignKey('content_type', 'object_id')
 
-    question = models.TextField(verbose_name='Вопрос')
-    answer = RichTextField(verbose_name='Ответ')
+    question = models.TextField(verbose_name=_('Вопрос'))
+    answer = RichTextUploadingField(verbose_name=_('Ответ'))
 
     def __str__(self):
         if self.question:

GeneralApp/templatetags/__init__.py

@@ -0,0 +1 @@
+__author__ = 'SDE'

GeneralApp/templatetags/base_tags_extra.py

@@ -0,0 +1,160 @@
+__author__ = 'SDE'
+
+from django import template
+from django.template.defaultfilters import stringfilter
+
+register = template.Library()
+
+from django.core.serializers import serialize
+from django.db.models.query import QuerySet
+# import simplejson
+from django.template import Library
+from django.utils.html import mark_safe
+
+@register.filter('get_value_from_dict')
+def get_value_from_dict(dict_data, key):
+    """
+    usage example {{ your_dict|get_value_from_dict:your_key }}
+    """
+
+    if key in dict_data:
+        res = dict_data[key]
+        return res
+
+    return False
+
+
+
+@register.filter()
+def get_rows_count_by_cols_count(data, cols_count):
+    rows_count = len(data) // cols_count
+    if len(data) % cols_count:
+        rows_count += 1
+    return rows_count
+
+@register.filter()
+def get_numbers_list(from_el, to_el):
+    res = range(from_el, to_el+1)
+    return res
+
+
+def val_type(value):
+    res = type(value)
+    return res.__name__
+register.filter('val_type', val_type)
+
+@register.filter()
+def get_cols_table_data_for_row_when_cols3(value, row):
+    el_count = 3
+    from_el = (row-1) * el_count
+    to_el = row * el_count
+    part = list(value)[from_el:to_el]
+    return part
+# register.filter('val_type', val_type)
+
+
+@register.filter
+@stringfilter
+def correct_for_tables(value):
+    if value in ['None', '0.0']:
+        return '-'
+    return value
+
+
+@register.filter
+@stringfilter
+def del_bad_symbols(value):
+    from BaseModels.functions import del_bad_symbols
+    return del_bad_symbols(value)
+
+
+@register.filter
+@stringfilter
+def del_amp_symbols(value):
+    from BaseModels.functions import del_nbsp
+    return del_nbsp(value)
+
+@register.filter
+@stringfilter
+def del_lang_from_path(value):
+    path_list = value.split('/')
+    path = '/' + '/'.join(path_list[4:])
+
+    # for i in path_list[1:]:
+    #     path.join(i + '/')
+    return path
+
+@register.filter
+@stringfilter
+def get_color_by_number(value, arg=None):
+
+    color = None
+    try:
+        val = float(value)
+
+        if not color and arg == u'%':
+
+            color = u'black'
+            if val > 50:
+                color = u'green'
+            elif val <= 50 and val >= 25:
+                color = u'#6c8107'
+            elif val <= 25 and val >= 10:
+                color = u'#a89803'
+            elif val <= 10 and val >= 5:
+                color = u'#e6a707'
+            elif val <= 5 and val >= 0:
+                color = u'#e67307'
+            elif val <= 0:
+                color = u'red'
+
+
+        # val_range = val_max - val_min
+        # # val_percent = (val_range * 100 / val) - 100
+        # offset = -(val_min + -(val))
+        # if val <0:
+        #     val = offset
+        # if val > val_max:
+        #     val = val_max
+        # elif val < 0:
+        #     val = 0
+        #
+        # color_range = 16711680 - 1211136
+        # val_1unit = float(color_range) / float(val_range)
+        # dec_color = 16711680 - int(val_1unit * val)
+
+        if not color:
+            color = u'black'
+            if val > 1000:
+                color = u'green'
+            elif val <= 1000 and val >= 500:
+                color = u'#6c8107'
+            elif val <= 500 and val >= 250:
+                color = u'#a89803'
+            elif val <= 250 and val >= 125:
+                color = u'#e6a707'
+            elif val <= 125 and val >= 50:
+                color = u'#e67307'
+            elif val <= 50:
+                color = u'red'
+
+        # s = u'style="color: #{0}12;"'.format(str(hex(dec_color))[2:6])
+        s = u'style="color: {0};"'.format(color)
+        return s
+    except:
+        return u''
+
+
+# @register.filter
+# @stringfilter
+# def check_aprox_compare_strings(search_phrase, txt):
+#     from ProductApp.search import get_highlight_string
+#
+#     s = get_highlight_string(search_phrase, txt)
+#
+#     return s
+
+
+
+
+

GeneralApp/translation.py

@@ -4,7 +4,7 @@ from .models import *
 
 class StaticPage_TranslationOptions(TranslationOptions):
     fields = (
-        'name', 'description', 'text', 'title', 'FAQ_title'
+        'name', 'description', 'text', 'title', 'FAQ_title', 'seo_title', 'seo_description', 'seo_text'
     )
 translator.register(StaticPage, StaticPage_TranslationOptions)
 
@@ -14,6 +14,12 @@ class Block_TranslationOptions(TranslationOptions):
     )
 translator.register(Block, Block_TranslationOptions)
 
+class Option_TranslationOptions(TranslationOptions):
+    fields = (
+        'name', 'value', 'prefix'
+    )
+translator.register(Option, Option_TranslationOptions)
+
 
 class FAQitem_TranslationOptions(TranslationOptions):
     fields = (
@@ -21,3 +27,9 @@ class FAQitem_TranslationOptions(TranslationOptions):
     )
 translator.register(FAQitem, FAQitem_TranslationOptions)
 
+class MediaItem_TranslationOptions(TranslationOptions):
+    fields = (
+        'name', 'comment',
+    )
+translator.register(MediaItem, MediaItem_TranslationOptions)
+

GeneralApp/urls.py

@@ -6,4 +6,11 @@ from .views import *
 
 urlpatterns = [
     path('', MainPage, name='main'),
+    path('mover_landing_page/', LandingMoverPage, name='mover_landing_page'),
+    path('customer_landing_page/', LandingCustomerPage, name='customer_landing_page'),
+
+
+    path('page/<str:url>/', StaticPageView, name='static_page'),
+    path('test_code', test_code, name='test_code'),
+    path('generate_routes/<int:routes_count>/', generate_routes, name='generate_routes'),
 ]

GeneralApp/views.py

@@ -1,32 +1,286 @@
 import json
 
-from django.http import HttpResponse, Http404, FileResponse
+from django.http import HttpResponse, Http404, FileResponse, HttpResponseRedirect
 from django.template import loader, RequestContext
 from django.contrib.auth.decorators import login_required
+
 from .models import *
 from django.conf import settings
+from .funcs import get_inter_http_response
+from django.http.response import JsonResponse, HttpResponse
+from django.views.decorators.http import require_GET, require_POST
+from django.shortcuts import get_object_or_404
+from django.contrib.auth.models import User
+from django.views.decorators.csrf import csrf_exempt
+from webpush import send_user_notification
+import json
+from datetime import datetime, timedelta
+from django.urls import reverse
+
+def generate_routes(request, routes_count):
+    if (not request.user
+        or not request.user.is_active
+        or not request.user.is_authenticated
+        or not request.user.is_staff
+    ):
+        raise Http404
+
+    from RoutesApp.funcs import get_city_by_type_transport_and_address_point
+    from RoutesApp.models import Route
+    from ReferenceDataApp.models import Airport, City
+
+    res = None
+
+    from_air = Airport.objects.get(iata_code='MSQ')
+    to_air = Airport.objects.get(iata_code='SVO')
+
+    routes = [
+        Route(
+            type_transport='road',
+            departure_DT=datetime.now() + timedelta(days=7),
+            arrival_DT=datetime.now() + timedelta(days=8),
+            from_address_point=to_air.city.id,
+            to_address_point=from_air.city.id,
+            from_city=to_air.city,
+            to_city=from_air.city,
+            weight=item,
+            phone='0987654321',
+            owner=request.user
+        ) for item in range(routes_count)
+    ]
+
+    Route.objects.bulk_create(routes)
+
+    if res:
+        if type(res) == str:
+            return HttpResponse(res)
+        else:
+            return res
+
+    return HttpResponse('finished')
 
 
 
+def test_code(request):
 
-def MainPage(request):
+    if (not request.user
+        or not request.user.is_active
+        or not request.user.is_authenticated
+        or not request.user.is_staff
+    ):
+        raise Http404
 
-    # from ReferenceDataApp.funcs import parse_data, search_cities_in_db, search_airports_in_db
-    # res = search_airports_in_db('ang')
-    # res = parse_data()
+    res = ''
 
-    page = StaticPage.objects.get(url='main')
+    from RoutesApp.search_matches import search_matches
+    from RoutesApp.models import Route
+    search_matches(Route.objects.filter(id=17158))
+
+    # from RoutesApp.funcs import get_city_by_type_transport_and_address_point
+    # from RoutesApp.models import Route
+    # from ReferenceDataApp.models import Airport, City
+    #
+    # res = None
+    #
+    # from_air = Airport.objects.get(iata_code='MSQ')
+    # to_air = Airport.objects.get(iata_code='SVO')
+    #
+    # routes = [
+    #     Route(
+    #         type_transport='road',
+    #         departure_DT=datetime.now() + timedelta(days=7),
+    #         arrival_DT=datetime.now() + timedelta(days=8),
+    #         from_address_point=to_air.city.id,
+    #         to_address_point=from_air.city.id,
+    #         from_city=to_air.city,
+    #         to_city=from_air.city,
+    #         weight=item,
+    #         phone='0987654321',
+    #         owner=request.user
+    #     ) for item in range(100)
+    # ]
+
+    # routes = [
+    #     Route(
+    #         type_transport='avia',
+    #         departure_DT=datetime(year=2024, month=9, day=1),
+    #         arrival_DT=datetime(year=2024, month=9, day=3),
+    #         from_address_point = from_air.id,
+    #         to_address_point = to_air.id,
+    #         from_city = from_air.city,
+    #         to_city = to_air.city,
+    #         weight = item,
+    #         phone = '1234567890',
+    #         owner = request.user
+    #     ) for item in range(1000)
+    # ]
+    #
+    # Route.objects.bulk_create(routes)
+
+
+    # from RoutesApp.search_matches import search_matches
+    # routes = Route.objects.filter()[:10]
+    # msg = search_matches(routes)
+
+    # from ReferenceDataApp.funcs import parse_data
+    # parse_data()
+
+    # from SubscribesApp.reports import send_mail_for_user_subscribes_that_is_going_to_finish
+    # send_mail_for_user_subscribes_that_is_going_to_finish()
+
+    if res:
+        if type(res) == str:
+            return HttpResponse(res)
+        else:
+            return res
+
+    return HttpResponse('finished')
+
+
+
+def Page404(request, exeption=None):
+
+    Dict = {}
+
+    t = loader.get_template('404.html')
+    try:
+        res = get_inter_http_response(t, Dict, request)
+        return HttpResponse(res, status=404)
+    except Exception as e:
+        return HttpResponse(str(e))
+
+def LandingMoverPage(request):
+
+    from .init_options import init_options
+    init_options()
+
+
+    print(f'LOCALE_PATHS = {str(settings.LOCALE_PATHS)}')
+
+    page, is_created = StaticPage.objects.get_or_create(url='landing_mover')
 
     Dict = {
         'page': page,
-        'FAQ': page.FAQ_items.filter(enable=True)
     }
 
+
+
+    breadcrumbs_Dict = {
+    }
+    Dict.update({'breadcrumbs': breadcrumbs_Dict})
+
+    t = loader.get_template('pages/p_mover_landing_page.html')
+    return get_inter_http_response(t, Dict, request)
+
+
+def LandingCustomerPage(request):
+
+    from .init_options import init_options
+    init_options()
+
+
+    print(f'LOCALE_PATHS = {str(settings.LOCALE_PATHS)}')
+
+    page, is_created = StaticPage.objects.get_or_create(url='landing_customer')
+
+    Dict = {
+        'page': page,
+    }
+
+
+
+    breadcrumbs_Dict = {
+    }
+    Dict.update({'breadcrumbs': breadcrumbs_Dict})
+
+    t = loader.get_template('pages/p_customer_landing_page.html')
+    return get_inter_http_response(t, Dict, request)
+
+
+def MainPage(request):
+    from RoutesApp.forms import RouteForm
+
+    from .init_options import init_options
+    init_options()
+
+
+    print(f'LOCALE_PATHS = {str(settings.LOCALE_PATHS)}')
+
+    page = StaticPage.objects.get(url='main')
+
+    from ArticlesApp.models import ArticleModel
+    arts = ArticleModel.objects.filter(enable=True).order_by('-createDT')[:3]
+
+    Dict = {
+        'page': page,
+        'FAQ': page.FAQ_items.filter(enable=True),
+        'route_form': RouteForm(),
+        'articles': arts,
+        'owner_type': 'mover'
+    }
+
+
+
     breadcrumbs_Dict = {
     }
     Dict.update({'breadcrumbs': breadcrumbs_Dict})
 
     t = loader.get_template('pages/p_main.html')
-    return HttpResponse(t.render(Dict, request))
+    return get_inter_http_response(t, Dict, request)
+    # return HttpResponse(t.render(Dict, request))
+
+
+
+def StaticPageView(request, url):
+    from RoutesApp.forms import RouteForm
+    from SubscribesApp.funcs import get_subscribes_w_options
+
+    Dict = {}
+
+    if url == '':
+        return MainPage(request)
+    elif url  == 'for_movers':
+        Dict.update({
+            'route_form': RouteForm(),
+            'owner_type': 'customer',
+        })
+    elif url == 'for_customers':
+        Dict.update({
+            'route_form': RouteForm(),
+            'owner_type': 'mover'
+        })
+    elif url in ['landing_customer', 'landing_mover']:
+        raise Http404
+    #     return HttpResponseRedirect(reverse('customer_landing_page'))
+    # elif url == 'landing_mover':
+    #     return HttpResponseRedirect(reverse('mover_landing_page'))
+
+    # elif  url == 'works':
+    #     return WorksPage(request)
+    elif url in ['main']:
+        raise Http404
+
+    if url in ['for_movers', 'for_customers']:
+        subscribes, all_options = get_subscribes_w_options()
+        Dict.update({
+            'subscribes': subscribes,
+        })
+
+    try:
+        page = StaticPage.objects.get(url=url)
+    except StaticPage.DoesNotExist:
+        raise Http404
+
+
+    Dict.update({
+        'page': page,
+    })
+
+    # from PushMessages.views import send_push
+    # send_push(user=request.user, title='title', text='text')
+
+    t = loader.get_template('pages/p_static_page.html')
+    return get_inter_http_response(t, Dict, request)
+    # return HttpResponse(t.render(Dict, request))
 
 

PushMessages/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

PushMessages/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class PushmessagesConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'PushMessages'

PushMessages/models.py

@@ -0,0 +1,3 @@
+from django.db import models
+
+# Create your models here.

PushMessages/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

PushMessages/urls.py

@@ -0,0 +1,16 @@
+# coding=utf-8
+from django.urls import path, include
+# from AuthApp.js_views import *
+# from AuthApp.import_funcs import *
+from .views import *
+from django.contrib.auth import views
+from RoutesApp.js_views import new_route_view_ajax
+from django.views.generic import TemplateView
+
+urlpatterns = [
+
+    path('send_push', send_push),
+    path('webpush/', include('webpush.urls')),
+    path('sw.js', TemplateView.as_view(template_name='sw.js', content_type='application/x-javascript')),
+
+]

PushMessages/views.py

@@ -0,0 +1,53 @@
+from django.http.response import JsonResponse, HttpResponse
+from django.views.decorators.http import require_GET, require_POST
+from django.contrib.auth.models import User
+from django.views.decorators.csrf import csrf_exempt
+from webpush import send_user_notification
+import json
+from django.shortcuts import render, get_object_or_404
+from django.conf import settings
+from django.utils.translation import gettext as _
+from SubscribesApp.funcs import check_option_in_cur_user_subscribe
+
+
+def get_key_Dict():
+    webpush_settings = getattr(settings, 'WEBPUSH_SETTINGS', {})
+    vapid_key = webpush_settings.get('VAPID_PUBLIC_KEY')
+    Dict = {
+        'vapid_key': vapid_key
+    }
+    return Dict
+
+def send_push(user, title, text, url=None, button_name=None, img=None):
+    if not check_option_in_cur_user_subscribe(user, 'push уведомления'):
+        return False
+
+    try:
+        # body = request.body
+        # data = json.loads(body)
+        #
+        # if 'head' not in data or 'body' not in data or 'id' not in data:
+        #     return JsonResponse(status=400, data={"message": "Invalid data format"})
+        #
+        # user_id = data['id']
+        # user = get_object_or_404(User, pk=user_id)
+        Dict = {
+            'head': title,
+            'body': text,
+        }
+        if url:
+            Dict['url'] = url
+            if button_name:
+                Dict['button_name'] = button_name
+            else:
+                Dict['button_name'] = _('Перейти'),
+
+        if img:
+            Dict['img'] = img
+
+        # payload = {'head': data['head'], 'body': data['body']}
+        send_user_notification(user=user, payload=Dict, ttl=1000)
+
+        return JsonResponse(status=200, data={"message": "Web push successful"})
+    except TypeError:
+        return JsonResponse(status=500, data={"message": "An error occurred"})

ReferenceDataApp/admin.py

@@ -2,10 +2,29 @@ from django.contrib import admin
 from sets.admin import Admin_Trans_BaseModel
 from .models import *
 from modeltranslation.admin import TranslationAdmin
+from django.utils.translation import gettext as _
 
 class Admin_Country(Admin_Trans_BaseModel):
+    fieldsets = [
+        [None, {
+            'classes': ['wide'],
+            'fields': [
+                'name', 'enable', 'short_code', 'code',
+            ]
+        }],
+        [_('Дополнительно'), {
+            'classes': ['wide', 'collapse'],
+            'fields': (
+                'timezone',
+                'geo_lat', 'geo_lon',
+                'json_data',
+            )
+        }],
+    ]
+
     list_display = [
         'id', 'name', 'name_en', 'name_ru',
+        'timezone',
         'short_code', 'code',
         'enable', 'area_id', 'parsing_finished_DT',
         'order', 'modifiedDT', 'createDT']
@@ -13,9 +32,35 @@ class Admin_Country(Admin_Trans_BaseModel):
 admin.site.register(Country, Admin_Country)
 
 class Admin_City(Admin_Trans_BaseModel):
+
+    def cur_dt(self, obj):
+        if obj.timezone:
+            return obj.get_current_datetime()
+        else:
+            return '-'
+    cur_dt.short_description = 'текущее время'
+
+    fieldsets = [
+        [None, {
+            'classes': ['wide'],
+            'fields': [
+                'name', 'enable', 'country',
+            ]
+        }],
+        [_('Дополнительно'), {
+            'classes': ['wide', 'collapse'],
+            'fields': (
+                'timezone',
+                'geo_lat', 'geo_lon',
+                'json_data',
+            )
+        }],
+    ]
+
     list_display = [
         'id', 'name', 'name_en', 'name_ru',
         'country',
+        'timezone', 'cur_dt',
         'enable', 'area_id', 'parsing_finished_DT',
         'order', 'modifiedDT', 'createDT']
     search_fields = ['id', 'name_en', 'name_ru', 'country__name']
@@ -23,12 +68,37 @@ class Admin_City(Admin_Trans_BaseModel):
 admin.site.register(City, Admin_City)
 
 class Admin_Airport(Admin_Trans_BaseModel):
+    fieldsets = [
+        [None, {
+            'classes': ['wide'],
+            'fields': [
+                'name', 'enable',
+                'city', 'iata_code', 'icao_code',
+                'international_name',
+                # 'area_id'
+            ]
+        }],
+        [_('Дополнительно'), {
+            'classes': ['wide', 'collapse'],
+            'fields': (
+                'timezone',
+                'geo_lat', 'geo_lon',
+                'json_data',
+            )
+        }],
+    ]
+
     list_display = [
         'id', 'name', 'name_en', 'name_ru',
         'city', 'iata_code', 'icao_code',
+        'timezone',
         'international_name',
         'enable', 'area_id', 'parsing_finished_DT',
         'order', 'modifiedDT', 'createDT']
     search_fields = ['id', 'name_en', 'name_ru', 'city__name', 'city__country__name', 'iata_code', 'icao_code', 'international_name']
     list_filter = ['city__country']
+    raw_id_fields = [
+        'city'
+    ]
+
 admin.site.register(Airport, Admin_Airport)

ReferenceDataApp/funcs.py

@@ -3,24 +3,45 @@ from .models import *
 import hashlib, json
 from datetime import datetime, timedelta
 from django.db.models import Q
+from timezonefinder import TimezoneFinder
 
+tzf = TimezoneFinder()
 
 def search_cities_in_db(search_str):
-
-
-
+    res_data = []
     Q_obj = Q(name_en__icontains=search_str) | Q(name_ru__icontains=search_str) | \
             Q(country__name_en__icontains=search_str) | Q(country__name_ru__icontains=search_str)
-    res_data = City.objects.filter(Q_obj).values('id', 'name', 'country__name')
+    objs = City.objects.filter(Q_obj)
+    if objs:
+        ids = objs.values_list('id', flat=True)
+        objs_wo_tz = objs.filter(timezone=None)
+        for item in objs_wo_tz:
+            item.get_n_save_timezone()
+        res_data = City.objects.filter(id__in=ids).values(
+            'id', 'name', 'country__name', 'timezone'
+        )
+
     return list(res_data)
 
 def search_airports_in_db(search_str):
+    res_data = []
     Q_obj = Q(iata_code__icontains=search_str) | \
             Q(name_en__icontains=search_str) | Q(name_ru__icontains=search_str) | \
             Q(city__name_en__icontains=search_str) | Q(city__name_ru__icontains=search_str) | \
             Q(city__country__name_en__icontains=search_str) | \
             Q(city__country__name_ru__icontains=search_str)
-    res_data = Airport.objects.filter(Q_obj).values('id', 'name', 'iata_code', 'city__name', 'city__country__name')
+    objs = Airport.objects.filter(Q_obj)
+    if objs:
+        ids = objs.values_list('id', flat=True)
+        objs_wo_tz = objs.filter(city__timezone=None)
+        for item in objs_wo_tz:
+            item.city.get_n_save_timezone()
+
+        res_data = Airport.objects.filter(id__in=ids).values(
+            'id', 'name', 'iata_code',
+            'city__name', 'city__country__name', 'city__timezone'
+        )
+
     return list(res_data)
 
 
@@ -57,25 +78,39 @@ def create_airports_by_airportsList(airportsList, city=None):
             if airport_Dict['iata']:
                 kwargs.update({'iata_code': airport_Dict['iata']})
             airport = Airport.objects.get(**kwargs)
+            if airport.geo_lat and airport.geo_lon and not airport.timezone:
+                airport.timezone = tzf.timezone_at(
+                    lng=float(airport.geo_lon), lat=float(airport.geo_lat))
+                airport.modifiedDT = datetime.now()
+                airport.save()
+                print(f'airport {airport.international_name} - {airport.timezone}')
         except Airport.DoesNotExist:
             print(f' - - {airport_Dict["iata"]} не найден в БД > добавляем')
         except Exception as e:
             print(f'error = {str(e)}')
 
         if not airport:
+            geo_lat = float(airport_Dict['@lat'])
+            geo_lon = float(airport_Dict['@lon'])
+            tz = tzf.timezone_at(lng=geo_lon, lat=geo_lat)
+            print(f'airport {airport_Dict["int_name"]} - {tz}')
+
             airport_kwargs = {
                 'city': city,
 
                 # 'name_ru': airport_Dict['name:ru'],
                 # 'name_en': airport_Dict['name:en'],
+                'timezone': tz,
 
-                'geo_lat': str(airport_Dict['@lat']),
-                'geo_lon': str(airport_Dict['@lon']),
+                'geo_lat': str(geo_lat),
+                'geo_lon': str(geo_lon),
 
                 'international_name': airport_Dict['int_name'],
 
                 'iata_code': airport_Dict['iata'],
                 'icao_code': airport_Dict['icao'],
+
+                'modifiedDT': datetime.now(),
             }
 
             if airport_Dict['name:ru']:
@@ -119,7 +154,10 @@ def parse_data():
 
             country = Country.objects.get(**kwargs)
 
-            if country.parsing_finished_DT and (datetime.now() - country.parsing_finished_DT).days < 30:
+            if (country.parsing_finished_DT
+                and (datetime.now() - country.parsing_finished_DT).days < 30
+                and country.timezone
+            ):
                 print(f' + {country.name} - существует в БД, не требует парсинга')
                 continue
 
@@ -194,6 +232,12 @@ def parse_data():
                     else:
                         print(f'error = {str(e)}')
 
+                geo_lat = float(city_Dict['@lat'])
+                geo_lon = float(city_Dict['@lon'])
+                tz = tzf.timezone_at(lng=geo_lon, lat=geo_lat)
+                if not city or not city.timezone:
+                    print(f'city {city_Dict["name:en"]} - {tz}')
+
                 # собираем данные
                 city_kwargs = {
                     'country': country,
@@ -201,8 +245,11 @@ def parse_data():
                     # 'name_ru': city_Dict['name:ru'],
                     # 'name_en': city_Dict['name:en'],
 
-                    'geo_lat': str(city_Dict['@lat']),
-                    'geo_lon': str(city_Dict['@lon']),
+                    'timezone': tz,
+
+                    'geo_lat': str(geo_lat),
+                    'geo_lon': str(geo_lon),
+
                 }
 
                 if city_Dict['name:ru']:
@@ -232,8 +279,12 @@ def parse_data():
         hash_data = hashlib.md5(json.dumps(country_Dict, sort_keys=True, ensure_ascii=True).encode('utf-8')).hexdigest()
         country.add_node_to_json_data({'hash': hash_data})
 
+        if not country.timezone:
+            country.timezone = tzf.timezone_at(lng=float(country.geo_lon), lat=float(country.geo_lat))
+            print(f'country {country.name} - {country.timezone}')
+
         if 'parsing_status' in country_Dict and country_Dict['parsing_status'] == 'finished':
             country.parsing_finished_DT = datetime.now()
-            country.save(update_fields=['parsing_finished_DT'])
+            country.save()
 
     return True

ReferenceDataApp/js_views.py

@@ -13,6 +13,8 @@ from django.template.loader import render_to_string
 from django.urls import reverse
 from django.db.models import Q
 import json
+from GeneralApp.funcs import get_inter_http_response
+from GeneralApp.funcs import get_and_set_lang
 
 def get_address_point_ajax(request):
     from .funcs import search_cities_in_db, search_airports_in_db
@@ -20,6 +22,9 @@ def get_address_point_ajax(request):
     if request.method != 'POST':
         raise Http404
 
+
+    lang = get_and_set_lang(request)
+
     try:
 
         data = json.loads(request.body)
@@ -51,10 +56,12 @@ def get_address_point_ajax(request):
                 item['fullname'] = f'{item["iata_code"]} - {item["name"]}'
                 item['city_name'] = item['city__name']
                 item['country_name'] = item['city__country__name']
+                item['city_DT'] = datetime.now(tz=pytz.timezone(item['city__timezone']))
             else:
                 item['city_name'] = item['name']
                 item['country_name'] = item['country__name']
-                item['fullname'] = f'{item["country_name"]} / {item["city_name"]}'
+                item['fullname'] = f'{item["city_name"]} / {item["country_name"]}'
+                item['city_DT'] = datetime.now(tz=pytz.timezone(item['timezone']))
             html = f"{html}{render_to_string('widgets/w_ac_input_address_point.html', item)}"
             i += 1
 
@@ -63,6 +70,8 @@ def get_address_point_ajax(request):
             'res_search_list': html
         }
 
+        from GeneralApp.funcs import get_add_to_ajax_response_Dict
+        res_Dict.update(get_add_to_ajax_response_Dict(request.user))
         return JsonResponse(res_Dict)
 
     except Exception as e:

ReferenceDataApp/migrations/0006_airport_timezone_city_timezone_country_timezone.py

@@ -0,0 +1,28 @@
+# Generated by Django 4.2.2 on 2024-07-12 17:23
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('ReferenceDataApp', '0005_remove_airport_parsing_finished_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='airport',
+            name='timezone',
+            field=models.CharField(blank=True, max_length=250, null=True, verbose_name='Часовая зона'),
+        ),
+        migrations.AddField(
+            model_name='city',
+            name='timezone',
+            field=models.CharField(blank=True, max_length=250, null=True, verbose_name='Часовая зона'),
+        ),
+        migrations.AddField(
+            model_name='country',
+            name='timezone',
+            field=models.CharField(blank=True, max_length=250, null=True, verbose_name='Часовая зона'),
+        ),
+    ]

ReferenceDataApp/models.py

@@ -1,23 +1,27 @@
+import pytz
 from django.db import models
 from BaseModels.base_models import BaseModel
 from django.utils.translation import gettext_lazy as _
+from datetime import datetime
 
 class Country(BaseModel):
-    international_name = models.CharField(max_length=250, verbose_name='Международное название', blank=True, null=True)
-    official_name = models.CharField(max_length=250, verbose_name='Официальное название', blank=True, null=True)
+    international_name = models.CharField(max_length=250, verbose_name=_('Международное название'), blank=True, null=True)
+    official_name = models.CharField(max_length=250, verbose_name=_('Официальное название'), blank=True, null=True)
 
-    short_code = models.CharField(max_length=2, verbose_name='Код страны по ISO3166-1:alpha2')
-    code = models.CharField(max_length=3, verbose_name='Код страны по ISO3166-1:alpha3')
-    num_code = models.CharField(max_length=3, verbose_name='Код страны по ISO3166-1:numeric', blank=True, null=True)
+    short_code = models.CharField(max_length=2, verbose_name=_('Код страны по ISO3166-1:alpha2'))
+    code = models.CharField(max_length=3, verbose_name=_('Код страны по ISO3166-1:alpha3'))
+    num_code = models.CharField(max_length=3, verbose_name=_('Код страны по ISO3166-1:numeric'), blank=True, null=True)
 
-    flag_img_url = models.URLField(verbose_name='Ссылка на изображение флага', blank=True, null=True)
+    flag_img_url = models.URLField(verbose_name=_('Ссылка на изображение флага'), blank=True, null=True)
 
-    geo_lat = models.CharField(max_length=20, verbose_name='GPS широта', blank=True, null=True)
-    geo_lon = models.CharField(max_length=20, verbose_name='GPS долгота', blank=True, null=True)
+    geo_lat = models.CharField(max_length=20, verbose_name=_('GPS широта'), blank=True, null=True)
+    geo_lon = models.CharField(max_length=20, verbose_name=_('GPS долгота'), blank=True, null=True)
+
+    timezone = models.CharField(max_length=250, verbose_name=_('Часовая зона'), blank=True, null=True)
 
     area_id = models.BigIntegerField(blank=True, null=True)
 
-    parsing_finished_DT = models.DateTimeField(verbose_name='Дата и время завершения парсинга', blank=True, null=True)
+    parsing_finished_DT = models.DateTimeField(verbose_name=_('Дата и время завершения парсинга'), blank=True, null=True)
 
     def __str__(self):
         if self.name:
@@ -39,14 +43,16 @@ class Country(BaseModel):
 class City(BaseModel):
 
     country = models.ForeignKey(
-        Country, verbose_name='Страна', related_name='rel_cities_for_country', on_delete=models.CASCADE)
+        Country, verbose_name=_('Страна'), related_name='rel_cities_for_country', on_delete=models.CASCADE)
 
-    geo_lat = models.CharField(max_length=20, verbose_name='GPS широта', blank=True, null=True)
-    geo_lon = models.CharField(max_length=20, verbose_name='GPS долгота', blank=True, null=True)
+    geo_lat = models.CharField(max_length=20, verbose_name=_('GPS широта'), blank=True, null=True)
+    geo_lon = models.CharField(max_length=20, verbose_name=_('GPS долгота'), blank=True, null=True)
 
     area_id = models.BigIntegerField(blank=True, null=True)
 
-    parsing_finished_DT = models.DateTimeField(verbose_name='Дата и время завершения парсинга', blank=True, null=True)
+    timezone = models.CharField(max_length=250, verbose_name=_('Часовая зона'), blank=True, null=True)
+
+    parsing_finished_DT = models.DateTimeField(verbose_name=_('Дата и время завершения парсинга'), blank=True, null=True)
 
     def __str__(self):
         if self.name:
@@ -54,6 +60,25 @@ class City(BaseModel):
         else:
             return f'{self.id}'
 
+    def get_n_save_timezone(self):
+        from ReferenceDataApp.funcs import tzf
+        self.timezone = tzf.timezone_at(lng=float(self.geo_lon), lat=float(self.geo_lat))
+        self.save(update_fields=['timezone'])
+        return self.timezone
+
+    def get_current_datetime(self):
+        if not self.timezone:
+            self.timezone = self.get_n_save_timezone()
+        return datetime.now(tz=pytz.timezone(self.timezone))
+
+    def get_country_n_city_str(self):
+        country = _('Неизвестно')
+        city = self.name
+        if self.country:
+            country = self.country
+
+        return f'{city} / {country}'
+
 
     class Meta:
         verbose_name = _('Город')
@@ -64,20 +89,22 @@ class City(BaseModel):
 class Airport(BaseModel):
 
     city = models.ForeignKey(
-        City, verbose_name='Город', related_name='rel_airports_for_city', on_delete=models.CASCADE,
+        City, verbose_name=_('Город'), related_name='rel_airports_for_city', on_delete=models.CASCADE,
         blank=True, null=True)
 
-    international_name = models.CharField(max_length=250, verbose_name='Международное название', blank=True, null=True)
+    international_name = models.CharField(max_length=250, verbose_name=_('Международное название'), blank=True, null=True)
 
     iata_code = models.CharField(max_length=3, verbose_name='IATA')
     icao_code = models.CharField(max_length=4, verbose_name='ICAO')
 
-    geo_lat = models.CharField(max_length=20, verbose_name='GPS широта', blank=True, null=True)
-    geo_lon = models.CharField(max_length=20, verbose_name='GPS долгота', blank=True, null=True)
+    geo_lat = models.CharField(max_length=20, verbose_name=_('GPS широта'), blank=True, null=True)
+    geo_lon = models.CharField(max_length=20, verbose_name=_('GPS долгота'), blank=True, null=True)
+
+    timezone = models.CharField(max_length=250, verbose_name=_('Часовая зона'), blank=True, null=True)
 
     area_id = models.BigIntegerField(blank=True, null=True)
 
-    parsing_finished_DT = models.DateTimeField(verbose_name='Дата и время завершения парсинга', blank=True, null=True)
+    parsing_finished_DT = models.DateTimeField(verbose_name=_('Дата и время завершения парсинга'), blank=True, null=True)
 
     def __str__(self):
         if self.name:

RoutesApp/admin.py

@@ -3,13 +3,33 @@ from .models import *
 from django.contrib import admin
 
 class Admin_Route(Admin_Trans_BaseModel):
+    readonly_fields = [
+        # 'highlight_end_DT',
+        'rising_DT'
+    ]
     list_display = [
-        'id', 'type_transport', 'cargo_type',
-        'departure_DT', 'from_address_point', 'from_place',
-        'arrival_DT', 'to_place', 'owner',
+        'id', 'owner_type',
+        'rising_DT',
+        'receive_msg_by_email', 'type_transport', 'cargo_type',
+        'departure_DT', 'from_city', 'from_place',
+        'arrival_DT', 'to_city', 'to_place', 'owner',
         'order', 'modifiedDT', 'createDT'
     ]
+    list_editable = ['rising_DT']
 
     list_display_links = ['id']
 
-admin.site.register(Route,Admin_Route)
+    list_filter = [
+        'owner_type', 'type_transport',
+        'rising_DT',
+        'cargo_type',
+        'from_place', 'arrival_DT',
+        'modifiedDT', 'createDT'
+    ]
+
+    search_fields = [
+        'owner__first_name', 'owner__last_name', 'from_city__name', 'to_city__name', 'owner__email'
+    ]
+    raw_id_fields = ['from_city', 'to_city', 'owner']
+
+admin.site.register(Route, Admin_Route)

RoutesApp/forms.py

@@ -6,9 +6,53 @@ from django.core.exceptions import ValidationError
 from .models import *
 
 
+def routeForm_assign_choices_by_type_transport(form, type_transport):
+    if type_transport == 'avia':
+        transfer_location_choices = (
+            ('airport', _('В аэропорту')),
+            ('city', _('По городу')),
+            ('other', _('По договоренности'))
+        )
+
+        cargo_type_choices = (
+            ('cargo', _('Груз')),
+            ('parcel', _('Бандероль')),
+            ('package', _('Посылка')),
+            ('letter', _('Письмо\Документ'))
+        )
+
+    else:
+        transfer_location_choices = (
+            ('city', _('По городу')),
+            ('other', _('По договоренности'))
+        )
+
+        cargo_type_choices = (
+            ('passenger', _('Пассажир')),
+            ('cargo', _('Груз')),
+            ('parcel', _('Бандероль')),
+            ('package', _('Посылка')),
+            ('letter', _('Письмо\Документ'))
+        )
+
+    form.fields['from_place'].choices = transfer_location_choices
+    form.fields['to_place'].choices = transfer_location_choices
+    form.fields['cargo_type'].choices = cargo_type_choices
+
+    form.base_fields['from_place'].choices = transfer_location_choices
+    form.base_fields['to_place'].choices = transfer_location_choices
+    form.base_fields['cargo_type'].choices = cargo_type_choices
+
+    return form
+
+
+
 class RouteForm(forms.ModelForm):
     from_address_point_txt = forms.CharField(required=True)
     to_address_point_txt = forms.CharField(required=True)
+    departure_DT = forms.DateTimeField(required=True, input_formats=['%d.%m.%Y %H:%M'])
+    arrival_DT = forms.DateTimeField(required=True, input_formats=['%d.%m.%Y %H:%M'])
+
     class Meta:
         model = Route
         exclude = [
@@ -20,10 +64,24 @@ class RouteForm(forms.ModelForm):
         # print('check')
         cleaned_data = super(RouteForm, self).clean()
 
-
-
         try:
 
+            if 'phone' in cleaned_data and 'phone' in cleaned_data:
+                from BaseModels.validators.form_field_validators import get_phone_valid_error
+                error = get_phone_valid_error(cleaned_data["phone"])
+                if error:
+                    self.add_error('phone', error)
+
+            if 'extra_phone' in cleaned_data and 'extra_phone' in cleaned_data:
+                from BaseModels.validators.form_field_validators import get_phone_valid_error
+                error = get_phone_valid_error(cleaned_data["extra_phone"])
+                if error:
+                    self.add_error('extra_phone', error)
+
+            if 'departure_DT' in cleaned_data and 'arrival_DT' in cleaned_data and cleaned_data['arrival_DT'] < cleaned_data['departure_DT']:
+                self.add_error('arrival_DT', _('Указана неверная дата прибытия'))
+
+
             if 'from_place' in self.data and self.data['from_place'] not in [item[0] for item in self.fields['from_place'].choices]:
                 cleaned_data['from_place'] = self.fields['from_place'].choices[0][0]
                 if 'from_place' in self.errors and self.errors['from_place'].data[0].code == 'invalid_choice':