init

AuthApp/admin.py

@@ -0,0 +1,253 @@
+# coding=utf-8
+from django.contrib import admin
+from django.contrib.auth.admin import UserAdmin
+from BaseModels.admin_utils import *
+from django.contrib.auth.models import User
+from django.utils.translation import gettext_lazy as _
+
+from AuthApp.models import *
+
+from django.contrib.auth.models import Group
+from django.db import models
+from django.contrib.admin.models import LogEntry
+
+from django.db.models import F, Value as V
+from django.db.models.functions import Concat
+
+from django.contrib.auth.admin import GroupAdmin as BaseGroupAdmin
+from django.contrib.auth.models import Group
+from django.contrib.admin import SimpleListFilter
+
+
+class LogEntryAdmin(admin.ModelAdmin):
+    # pass
+    list_display = (
+    '__str__', 'action_time', 'user', 'content_type', 'object_id', 'object_repr', 'action_flag', 'change_message')
+    list_filter = ('content_type', 'action_flag')
+    search_fields = ['user__username', 'change_message', 'object_id', 'object_repr']
+    date_hierarchy = 'action_time'
+
+    def has_delete_permission(self, request, obj=None):
+        return False
+
+
+admin.site.register(LogEntry, LogEntryAdmin)
+
+# class Admin_ProfileInline(admin.StackedInline):
+    # fieldsets = (
+    #     (None, {
+    #         'classes': ['wide'],
+    #         'fields': (
+    #             ('enable',),
+    #             ('regions',),
+    #             ('company_obj', 'office', 'company_position', 'departament'),
+    #             ('delivery_address'),
+    #             ('discount',),
+    #             ('work_start_D', 'work_finish_D'),
+    #             ('days_to_order_cancellation_default', 'days_to_pay_default', 'pay_terms'),
+    #             ('authMailCode', 'document_sign_person'),
+    #             ('birthdate'),
+    #             'comment', 'creator'
+    #         )
+    #     }),
+    #     ('Дополнительно', {
+    #         'classes': ['wide'],
+    #         'fields': (
+    #             ('connected_mailings',),
+    #             ('mailing_sets', 'json_data', 'sync_data')
+    #         )
+    #     }),
+    #     ('1С', {
+    #         'classes': ['wide'],
+    #         'fields': (
+    #             ('id_1s', 'name',),
+    #         )
+    #     }),
+    # )
+    #
+    # model = UserProfile
+    # can_delete = False
+    # extra = 1
+    # fk_name = 'user'
+    #
+    # filter_horizontal = ['regions', 'connected_mailings']
+    # raw_id_fields = ("company_obj", 'office')
+    # verbose_name_plural = _(u'Профиль пользователя')
+    #
+    # list_display = ['company_obj', 'office', 'company_position', 'departament', 'creator']
+    # readonly_fields = ['creator', ]
+
+
+
+
+
+# Define a new User admin
+class Admin_User(UserAdmin):
+    pass
+    # def user_groups(self, obj):
+    #     return ' \ '.join(obj.groups.all().values_list('name', flat=True))
+    #
+    # user_groups.short_description = u'Группы'
+    #
+    # def last_web_request(self, obj):
+    #     return obj.user_profile.last_web_request
+    #
+    # last_web_request.short_description = u'Последний запрос'
+
+    # def profile_enable(self, obj):
+    #     if obj.user_profile.enable:
+    #         return '+'
+    #     else:
+    #         return '-'
+    #
+    # profile_enable.short_description = u'Включен'
+
+    # fieldsets = (
+    #     (None, {
+    #         'classes': ['wide'],
+    #         'fields': (
+    #             ('username', 'password'),
+    #             ('first_name', 'last_name', 'email'),
+    #             ('is_active', 'is_staff', 'is_superuser'),
+    #             ('groups', 'user_permissions'),
+    #             ('last_login', 'date_joined'),
+    #             # ('username', 'first_name', 'last_name'),
+    #             # ('password'),
+    #             # ('email', 'is_active'),
+    #             # ('is_staff')
+    #         )
+    #     }),
+    #
+    # )
+
+    save_on_top = True
+
+    # list_display = ['id', 'profile_enable', 'last_name', 'first_name', 'email', 'last_web_request', 'is_staff',
+    #                 'is_active', 'user_groups']
+    # list_editable = ['is_staff', 'is_active']
+    # list_display_links = ['first_name', 'last_name', 'email']
+    # search_fields = ['first_name', 'last_name', 'email']
+    #
+    # inlines = (Admin_ProfileInline,)
+    # actions = ['del_all_temp_users', ]
+    #
+    # ordering = ['is_staff', 'last_name', 'first_name']
+    #
+    # def del_all_temp_users(modeladmin, request, queryset):
+    #     queryset.filter(mipp_user__temporary_user=True).delete()
+    #
+    # del_all_temp_users.short_description = _(u'Удалить всех временных пользователей')
+
+
+# Re-register UserAdmin
+admin.site.unregister(User)
+admin.site.register(User, Admin_User)
+
+
+class Admin_UserProfile(Admin_BaseIconModel):
+    pass
+    # def get_list_filter(self, request):
+    #     res = super(Admin_UserProfile, self).get_list_filter(request)
+    #     user_groups = request.user.groups.all().values_list('name', flat=True)
+    #     if request.user.is_superuser or 'Отдел продаж: Начальник отдела продаж' in user_groups or 'Маркетинг: Маркетолог' in user_groups:
+    #         return res
+    #
+    #     return []
+    #
+    # def get_queryset(self, request):
+    #     user_groups = request.user.groups.all().values_list('name', flat=True)
+    #     if request.user.is_superuser or 'Отдел продаж: Начальник отдела продаж' in user_groups or 'Маркетинг: Маркетолог' in user_groups:
+    #         return UserProfile.objects.all()
+    #
+    #     companies_ids = request.user.companies_for_manager.all().values_list('id', flat=True)
+    #     queryset = UserProfile.objects.filter(
+    #         company_obj__id__in=companies_ids
+    #         # ).annotate(
+    #         #     lead_source = F('company_obj__lead_source')
+    #     )
+    #     return queryset
+    #
+    # def get_list_display_links(self, request, list_display):
+    #     res = super(Admin_UserProfile, self).get_list_display_links(request, list_display)
+    #     if not request.user.is_superuser:  # and not request.user.has_perm('AuthApp.change_userprofile'):
+    #         return None
+    #     return res
+    #
+    # def get_changelist_instance(self, request):
+    #     if not request.user.is_superuser:  # and not request.user.has_perm('AuthApp.change_userprofile'):
+    #         self.list_editable = ['birthdate']
+    #     return super(Admin_UserProfile, self).get_changelist_instance(request)
+    #
+    # def user_name(self, obj):
+    #     return '{0} {1}'.format(obj.user.last_name, obj.user.first_name)
+    #
+    # user_name.short_description = u'Имя'
+    #
+    # def lead_source(self, obj):
+    #     res = None
+    #     if obj.company_obj:
+    #         res = obj.company_obj.lead_source
+    #     if not res:
+    #         res = '-'
+    #     else:
+    #         res = obj.company_obj.get_lead_source_display()
+    #     return res
+    #
+    # lead_source.short_description = 'Источник'
+    # lead_source.admin_order_field = 'company_obj__lead_source'
+    #
+    # def manager(self, obj):
+    #     if not obj.company_obj or not obj.company_obj.manager_obj:
+    #         return '-'
+    #
+    #     return '{0}'.format(obj.company_obj.manager_obj.get_full_name())
+    #
+    # manager.short_description = u'Менеджер'
+    #
+    # fieldsets = (
+    #     (None, {
+    #         'classes': ['wide'],
+    #         'fields': (
+    #             'user', 'enable', 'account_type',
+    #             ('discount',),
+    #             ('work_start_D', 'work_finish_D'),
+    #             ('company_obj', 'company', 'office', 'company_position', 'departament'),
+    #             ('delivery_address'),
+    #             ('days_to_order_cancellation_default', 'days_to_pay_default', 'pay_terms'),
+    #             ('authMailCode', 'document_sign_person'),
+    #             ('birthdate'),
+    #             ('connected_mailings',),
+    #             'creator'
+    #         )
+    #     }),
+    #     ('1С', {
+    #         'classes': ['wide'],
+    #         'fields': (
+    #             ('id_1s', 'name',),
+    #         )
+    #     }),
+    # )
+    #
+    # save_on_top = True
+    #
+    # list_display = [
+    #     # 'user__last_name', 'user__first_name', 'user__email', 'user__is_staff', 'user__is_active',
+    #     'id', 'user_name', 'user', 'enable', 'birthdate', 'lead_source', 'manager',
+    #     'company_obj', 'office', 'company_position', 'departament', 'account_type', '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', 'company_obj__name', 'company_position',
+    #     'departament',
+    #     'company_obj', 'company_obj__manager_obj'
+    # ]  # 'user__last_name', 'user__first_name', 'user__email']
+    #
+    # list_filter = ['company_obj__lead_source', ManagersFilter, 'account_type']
+    #
+    # filter_horizontal = ['connected_mailings']
+    # # raw_id_fields = ("favourites",)
+    # verbose_name_plural = _(u'Профиль пользователя')
+
+
+admin.site.register(UserProfile, Admin_UserProfile)

AuthApp/api/api_1C_views.py

@@ -0,0 +1,88 @@
+# coding=utf-8
+from BaseModels.api.base_api_views import *
+from ..models import *
+from rest_framework.response import Response
+from BaseModels.mailSender import techSendMail
+import json
+from BaseModels.api.base_api_permissions import *
+from datetime import datetime
+import re
+from rest_framework import status
+from BaseModels.api.base_api_serializers import Import_Pocket_Srializer
+
+
+
+class Managers_1C_get_timestamp(APIBaseSimplaClass):
+
+    permission_classes = (api_1C_perm,)
+    serializer_class = Import_Pocket_Srializer
+
+    def get(self, request):
+        from GeneralApp.views import get_timestamp_by_property_item_name
+
+        property_item_name = u'1S_managers'
+
+        last_timestamp = get_timestamp_by_property_item_name(property_item_name)
+
+        return Response({
+            'property_item_name' : property_item_name,
+            'timestamp' : last_timestamp
+        })
+
+
+class Managers_1C_import(APIBaseSimplaClass):
+
+    # authentication_classes = (authentication.TokenAuthentication,)
+    permission_classes = (api_1C_perm,)
+    serializer_class = Import_Pocket_Srializer
+
+    def post(self, request, format=None):
+        """
+        import 1C companies data
+        """
+
+        log = ''
+        res = ''
+
+        try:
+
+            data = request.data
+
+            if not data:
+                msg = 'нет данных в пакете'
+                res_Dict = {
+                    'status': 'error',
+                    'error': msg
+                }
+                return Response(res_Dict, status=status.HTTP_400_BAD_REQUEST)
+
+
+            from .import_1C_data import import_1C_pocket
+            res = import_1C_pocket(data)
+
+            res_Dict = {
+                'status': 'finished',
+                'log': log
+            }
+            res_Dict.update(res)
+
+            return Response(res_Dict)
+
+        except Exception as e:
+            len_data = 0
+            if request.data:
+                len_data = len(request.data)
+            title = 'ОШИБКА tE Managers_1C_import'
+            msg = 'Managers_1C_import Error = {0}({1})<br>lenght data = {2}<br>log...<br>{3}'.format(
+                str(e), str(e.args), str(len_data), str(res)
+            )
+            from BaseModels.mailSender import techSendMail_for_specified_email_list
+            from tEDataProj.inter import problem_solvers_personal_1S
+            techSendMail_for_specified_email_list(msg, problem_solvers_personal_1S, title=title)
+
+            res_Dict = {
+                'status': 'error',
+                'error': str(e)
+            }
+
+            return Response(res_Dict, status=status.HTTP_400_BAD_REQUEST)

AuthApp/api/api_permissions.py

@@ -0,0 +1,76 @@
+# coding=utf-8
+from rest_framework.permissions import BasePermission
+from rest_framework.exceptions import PermissionDenied
+from tEDataProj.inter import check_user_key_inter
+
+
+class Auth_API_perms(BasePermission):
+    """
+    Allows access only users w full access.
+    """
+
+    def has_permission(self, request, view):
+
+        if not request.user or request.user.is_anonymous or not request.user.is_active:
+            return False
+
+        # auth_data = request.query_params
+        # if not check_user_key_inter(auth_data):
+        #     raise PermissionDenied(code=403)
+
+        user = request.user
+        groups = user.groups.all()
+
+        groups_name_list = groups.values_list('name', flat=True)
+
+        if u'API 1С импорт' in groups_name_list:
+            return False
+
+        if view.basename == u'user':
+            # if view.action in ('get_subordinate_staff',):
+            #     return True
+
+            if view.action in (
+                    'get_sales_department_staff',) and u'Отдел продаж: Начальник отдела продаж' in groups_name_list:
+                return True
+
+            if view.action in ('create',):
+                perm = user.has_perm('AuthApp.UI_managers_create')
+                return perm
+
+            if view.action in ('update', 'partial_update', 'add_communication_item'):
+                perm = user.has_perm('AuthApp.UI_managers_modify')
+                return perm
+
+            if view.action in ('destroy',):
+                perm = user.has_perm('AuthApp.UI_managers_delete')
+                return perm
+
+            if view.action in (
+                    'retrieve', 'list', 'list_by_company_id', 'list_by_office_id', 'get_subordinate_staff',
+                    'get_all_staff'):
+                perm = user.has_perm('AuthApp.UI_managers_retrieve')
+                return perm
+
+            if view.action in ('get_sales_stat_by_productid', 'stat_list'):
+                perm = user.has_perm('AuthApp.UI_managers_all_stat') or user.has_perm('AuthApp.UI_managers_self_stat')
+                return perm
+
+        # if view.basename == u'userprofile':
+        #
+        #     if view.action in ('create',):
+        #         perm = user.has_perm('AuthApp.add_userprofile')
+        #         return perm
+        #
+        #     if view.action in ('update', 'partial_update'):
+        #         perm = user.has_perm('AuthApp.change_userprofile')
+        #         return perm
+        #
+        #     if view.action in ('destroy',):
+        #         perm = user.has_perm('AuthApp.delete_userprofile')
+        #         return perm
+        #
+        #     if view.action in ('retrieve', 'list'):
+        #         return True
+
+        return False

AuthApp/api/api_urls.py

@@ -0,0 +1,17 @@
+from django.conf.urls import url, include
+# from .api_views import *
+from rest_framework import routers
+from .api_1C_views import *
+from .v1.user.user_api_views import *
+
+router = routers.SimpleRouter()
+# router.register(r'user', UserProfile_ViewSet)
+# router.register(r'client_person', Client_Person_ViewSet)
+router.register(r'v1/managers', v1_Managers_ViewSet)
+router.register(r'v1/personal', v1_Personal_ViewSet)
+
+urlpatterns = router.urls + [
+    url(r'^1c/import_managers_data$', Managers_1C_import.as_view()),
+    # url(r'^1c/managers_import_1C_pocket_from_file$', ),
+    url(r'^1c/import_managers/get_last_timestamp$', Managers_1C_get_timestamp.as_view()),
+]

AuthApp/api/api_views.py

@@ -0,0 +1,94 @@
+# coding=utf-8
+from BaseModels.api.base_api_views import *
+from AuthApp.models import *
+from .serializers import *
+from .api_permissions import *
+from rest_framework.decorators import action
+
+
+
+def get_buttons_states_Dict(user):
+
+    Dict = {
+        'managers_menu': user.has_perm('AuthApp.UI_managers_show'),
+        'managers_add_but': user.has_perm('AuthApp.UI_managers_create'),
+        'managers_change_but': user.has_perm('AuthApp.UI_managers_modify'),
+        'managers_delete_but': user.has_perm('AuthApp.UI_managers_delete'),
+
+        'admin_group_menu': user.has_perm('AuthApp.UI_adminGroup_show'), #показываем в меню группу Администрирование
+        'personal_show': user.has_perm('AuthApp.UI_personal_show'), #показываем в группе Администрирование пункт Персонал
+    }
+
+    return Dict
+
+
+
+class Client_Person_ViewSet(APIViewSet_ModelClass):
+    queryset = UserProfile.objects.filter(user__is_staff=False)
+    serializer_class = UserProfile_Serializer
+    permission_classes = (Auth_API_perms,)
+
+    def get_serializer_class(self):
+
+        try:
+            if self.action == 'retrieve':
+                return UserProfile_Serializer
+
+        except (KeyError, AttributeError):
+            pass
+
+        return super(Client_Person_ViewSet, self).get_serializer_class()
+
+
+
+
+class Staff_Person_ViewSet(APIViewSet_ModelClass):
+    queryset = UserProfile.objects.filter(user__is_staff=True)
+    serializer_class = UserProfile_Serializer
+    permission_classes = (Auth_API_perms,)
+
+    def get_serializer_class(self):
+
+        try:
+            if self.action == 'retrieve':
+                return UserProfile_Serializer
+
+        except (KeyError, AttributeError):
+            pass
+
+        return super(Staff_Person_ViewSet, self).get_serializer_class()
+
+
+
+class UserProfile_ViewSet(APIViewSet_ModelClass):
+    queryset = UserProfile.objects.all()
+    serializer_class = UserProfile_Serializer
+    permission_classes = (Auth_API_perms,)
+
+    def get_serializer_class(self):
+
+        try:
+            if self.action == 'retrieve':
+                return UserProfile_Serializer
+
+        except (KeyError, AttributeError):
+            pass
+
+        return super(UserProfile_ViewSet, self).get_serializer_class()
+
+    # @action(methods=['GET'], detail=True)
+    # def get_current_order(self, request, pk):
+    #     from B2BApp.models import Order
+    #     from B2BApp.api.serializers import B2B_Order_serializer
+    #
+    #     try:
+    #         from B2BApp.views import get_waiting_order_or_create_new
+    #         order = get_waiting_order_or_create_new(request, pk)
+    #     except Order.DoesNotExist:
+    #         raise serializers.ValidationError(
+    #             u'Ошибка, функция недоступна'
+    #         )
+    #
+    #     order_data = B2B_Order_serializer(order)
+    #
+    #     return Response(order_data.data)

AuthApp/api/import_1C_data.py

@@ -0,0 +1,194 @@
+# coding=utf-8
+from BaseModels.mailSender import techSendMail
+
+from ..models import *
+from datetime import date, datetime
+from GeneralApp.views import get_timestamp_by_property_item_name, set_timestamp_by_propertiy_item_name
+from BaseModels.error_processing import *
+from uuid import uuid1
+from GeneralApp.temp_data_funcs import add_tmp_data, del_tmp_data_by_obj
+
+def avg(val):
+    """uses floating-point division."""
+    return sum(val) / float(len(val))
+
+
+from django.http import HttpResponse
+import json
+
+def import_1C_pocket_from_file(request):
+
+    if not request.user.is_superuser:
+        return HttpResponse(u'import_1C_pocket_from_file PERMISSION FAIL')
+
+    try:
+        f = open('companies_1s.txt')
+        data = f.read()
+    except:
+        return HttpResponse(u'import_1C_pocket_from_file READ FILE FAIL')
+
+    import re
+    data = re.sub(r'[\r\n\t]', ' ', data)
+    data = re.sub(r'\s+', ' ', data)
+
+    request_data = data
+
+    data = json.loads(request_data)
+
+    import_1C_pocket(data)
+
+    return HttpResponse(u'import_1C_pocket_from_file Accept')
+
+
+def import_1C_pocket(json_data):
+
+
+    log = ''
+    log_begin_DT = datetime.now()
+    msg = 'import_1C_pocket MANAGERS start - {0}<br>---------------<br><br>'.format(str(log_begin_DT))
+    log = '{0}<br>{1}'.format(log, msg)
+
+    try:
+        data = json_data['data_list']
+        timestamp = json_data['timestamp']
+        msg = str(timestamp)
+        log = '{0}<br>{1}'.format(log, msg)
+
+        # dt = datetime.fromtimestamp(timestamp)
+
+        saved_timestamp = get_timestamp_by_property_item_name('1S_managers')
+
+        if saved_timestamp and saved_timestamp >= timestamp:
+            # generate_error(f, u'import_1S_companies', u'1S_companies пакет устарел, импорт не был произведен', u'')
+            msg = '<b style="color : red;">!!!!! --- 1S_managers пакет устарел, импорт не был произведен</b>'
+            print(msg)
+            return {u'result': u'1S_managers пакет устарел, импорт не был произведен', 'error': 304}
+        set_timestamp_by_propertiy_item_name('1S_managers', timestamp)
+    except:
+        data = json_data
+
+    # сохраняем данные для импорта временно в БД
+    tmp_data = add_tmp_data(data_type='import_proc', data_target='managers_1s_import', data=data)
+
+
+    for item in data:
+        # print(str(item))
+        # break
+
+        json_item = json.dumps(item, ensure_ascii=False)
+
+        try:
+            if not u'id' in item:
+                # generate_error(f, u'import_1S_companies', u'1S_companies ID отсутствует в экзепляре данных', json_item)
+                msg = '<b style="color : red;">!!!!! --- 1S_managers ID отсутствует в экзепляре данных</b>'
+                log = '{0}<br>{1}'.format(log, msg)
+                return {
+                    u'result': msg,
+                    u'error': 400,
+
+                }
+
+            msg = '{0} - {1}'.format(item[u'id'], item[u'name'])
+            log = '{0}<br>{1}'.format(log, msg)
+
+            user_profiles = UserProfile.objects.filter(id_1s=item[u'id'])
+
+
+            kwargs = {
+                'name' : item[u'name'].replace(u"'", '"'),
+                'id_1s' : item[u'id'],
+                'company_position' : item[u'position'],
+                'departament': str(item[u'subdiv']),
+            }
+
+            work_start_D = item[u'datein'].replace(u" ", '')
+            if len(work_start_D) > 9:
+                work_start_D = datetime.strptime(work_start_D, "%d.%m.%Y")
+                kwargs.update({'work_start_D' : work_start_D})
+
+            work_finish_D = item[u'dateout'].replace(u" ", '')
+            if len(work_finish_D) > 9:
+                work_finish_D = datetime.strptime(work_finish_D, "%d.%m.%Y")
+                kwargs.update({'work_finish_D': work_finish_D})
+
+            birthday = item[u'birthday'].replace(u" ", '')
+            if len(birthday) > 9:
+                birthday = datetime.strptime(birthday, "%d.%m.%Y")
+                kwargs.update({'birthdate': birthday})
+
+
+
+            user = None
+            u_profile = None
+            if user_profiles:
+                user_profiles.update(**kwargs)
+                u_profile = user_profiles[0]
+                msg = ' - ОБНОВЛЕНИЕ данных МЕНЕДЖЕРА - {0}'.format(str(u_profile.__dict__))
+                user = u_profile.user
+
+            if not user:
+                username = str(item[u'id'])
+                mail = '{0}@truenergy.by'.format(str(item[u'id']))
+                password = user_id = str(uuid1().hex)[:10]
+                user = User.objects.create_user(username=username, email=mail, password=password)
+                user.is_staff = True
+                user.is_active = True
+                user.is_superuser = False
+                user.set_password(password)
+                user.save()
+
+                kwargs.update({'user': user})
+
+                user_profiles = UserProfile.objects.filter(user=user)
+                user_profiles.update(**kwargs)
+                u_profile = user_profiles[0]
+
+                msg = ' - СОЗДАНИЕ МЕНЕДЖЕРА - {0}'.format(str(u_profile.__dict__))
+
+            log = '{0}<br>{1}'.format(log, msg)
+
+            msg = ''
+            if 'work_finish_D' in kwargs and user.is_active:
+               user.is_active = False
+               msg = ' - отключен доступ<br>'
+            name_list = item[u'name'].split(' ')
+            if len(name_list) > 1 and user.first_name != ' '.join(name_list[1:]):
+                user.first_name = ' '.join(name_list[1:])
+                msg = ' - изменено имя<br>'
+            if len(name_list) > 0 and user.last_name != name_list[0]:
+                user.last_name = name_list[0]
+                msg = ' - изменена фамилия'
+
+            if msg:
+                user.save()
+                log = '{0}<br>{1}'.format(log, msg)
+
+
+
+        except Exception as e:
+            # generate_error(f, u'import_1S_companies', str(e), json_item)
+            msg = '<b style="color : red;">!!!!! --- import_1C_pocket MANAGERS error={0}</b>'.format(str(e))
+            print(msg)
+            log = '{0}<br>{1}'.format(log, msg)
+
+        # close_log_file(f, u'END import_1S_companies')
+
+    # удаляем временные данные для импорта из БД
+    if tmp_data:
+        del_tmp_data_by_obj(tmp_data)
+
+    msg = 'import_1C_package MANAGERS finish - {0} (processing time = {1}<br>---------------<br><br>'.format(
+        str(datetime.now()),
+        str(datetime.now() - log_begin_DT)
+    )
+    log = '{0}<br>{1}'.format(log, msg)
+
+    title = 'import_1C_pocket MANAGERS'
+    techSendMail(log, title)
+
+    return {
+        u'result': log
+    }
+
+
+

AuthApp/api/init_api.py

@@ -0,0 +1,26 @@
+from ..models import mail_list_types
+from django.http import JsonResponse, Http404
+
+
+def init_API(request, get_Dict=False):
+
+    # auth_data = request.GET
+    # if not check_user_key_inter(auth_data):
+    #     raise exceptions.PermissionDenied()
+
+    Dict = {
+
+    }
+
+    mail_list_types_Dict = {}
+    for item in mail_list_types:
+        mail_list_types_Dict.update({
+            item[0] : item[1]
+        })
+    Dict.update({'mail_list_types' : mail_list_types_Dict})
+
+    if get_Dict:
+        return Dict
+
+
+    return JsonResponse({'data': Dict})

AuthApp/api/serializers.py

@@ -0,0 +1,49 @@
+from rest_framework import serializers
+from AuthApp.models import *
+
+
+# Person
+
+
+class client_UserProfile_Serializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = UserProfile
+        fields = (
+            'id',
+            # 'name', 'company', 'departament', 'company_position', 'phone', 'email', 'document_sign_person',
+            # 'days_to_order_cancellation_default', 'days_to_pay_default', 'pay_terms', 'discount', 'birthdate',
+
+        )
+
+
+class staff_UserProfile_Serializer(serializers.ModelSerializer):
+    class Meta:
+        model = UserProfile
+        fields = (
+            'id',
+            # 'name', 'company', 'departament', 'company_position', 'phone', 'email',
+            # 'birthdate',
+        )
+
+
+class UserProfile_Serializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = UserProfile
+        fields = (
+            'id',
+            # 'name', 'company', 'departament', 'company_position', 'phone', 'email', 'document_sign_person',
+            # 'days_to_order_cancellation_default', 'days_to_pay_default', 'pay_terms', 'discount', 'birthdate',
+        )
+
+class UserProfile_list_Serializer(serializers.ModelSerializer):
+    class Meta:
+        model = UserProfile
+        fields = (
+            'id',
+            # 'name'
+        )
+
+
+# ----------------------------------------

AuthApp/api/v1/permissions/personal_api_permissions.py

@@ -0,0 +1,116 @@
+# coding=utf-8
+from rest_framework.permissions import BasePermission
+from rest_framework.exceptions import PermissionDenied
+from tEDataProj.inter import check_user_key_inter
+from AuthApp.models import User
+
+
+def check_of_user_is_manager_of_company(user, view):
+    if not 'pk' in view.kwargs:
+        return False
+
+    try:
+        objs = User.objects.get(
+            user_profile__company_obj__manager_obj=user,
+            id=view.kwargs['pk']
+        )
+    except:
+        return False
+
+    return objs
+
+
+def check_of_user_is_company_staff(user, view):
+    if not 'pk' in view.kwargs:
+        return False
+
+    try:
+        objs = User.objects.get(
+            user_profile__company_obj=user.user_profile.company_obj,
+            id=view.kwargs['pk']
+        )
+    except:
+        return False
+
+    return objs
+
+
+class Personal_API_perms(BasePermission):
+    """
+    Allows access only users w full access.
+    """
+
+    def has_permission(self, request, view):
+
+        if not request.user or request.user.is_anonymous or not request.user.is_active:
+            return False
+
+        # auth_data = request.query_params
+        # if not check_user_key_inter(auth_data):
+        #     raise PermissionDenied(code=403)
+
+        user = request.user
+        groups = user.groups.all()
+
+        groups_name_list = groups.values_list('name', flat=True)
+
+        if u'API 1С импорт' in groups_name_list:
+            return False
+
+        if view.basename == u'user':
+
+            if view.action in ('create',):
+                perm = user.has_perm('AuthApp.UI_company_staff_create')
+                return perm
+
+            if view.action in (
+                    'update', 'partial_update', 'add_communication_item', 'get_connected_mailings', 'possible_mailings',
+                    'change_mailing_status'):
+                # perm = user.has_perm('AuthApp.UI_managers_modify')
+                # return perm
+                if not user.is_staff:
+                    # персонал компании
+                    if user.has_perm('AuthApp.UI_company_staff_modify_if_staff_company'):
+                        return check_of_user_is_company_staff(user, view)
+
+                    return False
+
+                # если персонал
+                else:
+                    if check_of_user_is_manager_of_company(user, view) and user.has_perm(
+                            'AuthApp.UI_company_staff_modify_if_manager'):
+                        return True
+                    elif user.has_perm('AuthApp.UI_company_staff_modify_any'):
+                        return True
+
+            if view.action in ('destroy',):
+                perm = user.has_perm('AuthApp.UI_company_staff_delete')
+                return perm
+
+            if view.action in (
+                    'retrieve', 'list', 'list_by_company_id', 'list_by_office_id',
+                    'possible_departaments_list', 'possible_company_positions_list'
+            ):
+                perm = user.has_perm('AuthApp.UI_company_staff_retrieve_any_no_staff')
+                if not perm:
+                    perm = user.has_perm('AuthApp.UI_company_staff_retrieve')
+                return perm
+
+        # if view.basename == u'userprofile':
+        #
+        #     if view.action in ('create',):
+        #         perm = user.has_perm('AuthApp.add_userprofile')
+        #         return perm
+        #
+        #     if view.action in ('update', 'partial_update'):
+        #         perm = user.has_perm('AuthApp.change_userprofile')
+        #         return perm
+        #
+        #     if view.action in ('destroy',):
+        #         perm = user.has_perm('AuthApp.delete_userprofile')
+        #         return perm
+        #
+        #     if view.action in ('retrieve', 'list'):
+        #         return True
+
+        return False

AuthApp/api/v1/user/user_api_serializars.py

@@ -0,0 +1,124 @@
+from rest_framework import serializers
+from ....models import *
+from ....funcs import fullname_for_user
+
+
+class Personal_change_mailing_status_Serializer(serializers.Serializer):
+    mailing_ID = serializers.IntegerField()
+    mailing_status = serializers.BooleanField()
+
+
+class User_sync_Serializer(serializers.ModelSerializer):
+    id_1s = serializers.SerializerMethodField()
+
+    def get_id_1s(self, obj):
+        return obj.user_profile.id_1s
+
+    class Meta:
+        model = User
+        fields = (
+            'id_1s',
+        )
+
+
+class Profile_list_Serializer(serializers.ModelSerializer):
+    from GeneralApp.api.v1.communications.communications_api_serializers import Communications_create_Serializer
+
+    office_name = serializers.SerializerMethodField(required=False)
+    company_name = serializers.SerializerMethodField(required=False)
+    manager_name = serializers.SerializerMethodField(required=False)
+    company_client_type = serializers.SerializerMethodField(required=False)
+
+    communications = Communications_create_Serializer(many=True)
+
+    def get_company_client_type(self, obj):
+        try:
+            if obj and obj.company_obj:
+                return obj.company_obj.client_type
+            else:
+                return None
+        except:
+            return None
+
+    def get_office_name(self, obj):
+        try:
+            if obj and obj.office:
+                return obj.office.name
+        except:
+            return None
+
+        return None
+
+    def get_company_name(self, obj):
+        try:
+            if obj and obj.company_obj:
+                return obj.company_obj.name
+        except:
+            return None
+
+        return None
+
+    def get_manager_name(self, obj):
+        try:
+            if obj and obj.company_obj and obj.company_obj.manager_obj:
+                return '{0} {1}'.format(obj.company_obj.manager_obj.last_name, obj.company_obj.manager_obj.first_name)
+        except:
+            return None
+
+        return None
+
+    class Meta:
+        model = UserProfile
+        fields = (
+            'id',
+            'enable',
+            'company_obj', 'company_name',
+            'company_position', 'company_client_type',
+            'phone',
+            'delivery_address',
+            'office', 'office_name',
+            'departament',
+            'document_sign_person',
+            'work_start_D',
+            'work_finish_D',
+            'birthdate',
+            'comment',
+            'communications',
+            'priority_connect_type',
+            'modifiedDT',
+            'mailing_sets',
+            'manager_name'
+        )
+
+
+class User_list_Serializer(serializers.ModelSerializer):
+    full_name = serializers.SerializerMethodField('get_full_name_user', required=False)
+
+    # user_profile = Profile_list_Serializer()
+
+    def get_full_name_user(self, obj):
+        name = fullname_for_user(obj)
+        if not name:
+            name = obj.email
+        return name
+
+    class Meta:
+        model = User
+        fields = (
+            'id', 'full_name'
+        )
+
+
+class Personal_list_Serializer(User_list_Serializer):
+    user_profile = Profile_list_Serializer()
+
+    class Meta:
+        model = User
+        fields = (
+            'id', 'full_name', 'first_name', 'last_name', 'is_active', 'is_staff', 'user_profile', 'email'
+        )
+        extra_kwargs = {
+            'email': {'required': 'False'},
+            'first_name': {'required': 'False'},
+            'last_name': {'required': 'False'},
+        }

AuthApp/forms.py

@@ -0,0 +1,70 @@
+# coding=utf-8
+from django import forms
+from django.contrib.auth.forms import AuthenticationForm
+from django.utils.translation import ugettext_lazy as _
+from django.core.exceptions import ValidationError
+from .models import *
+# from djng.styling.bootstrap3.forms import Bootstrap3ModelForm
+# from djng.forms import fields, NgModelFormMixin, NgFormValidationMixin, NgModelForm
+# from datetimepicker.widgets import DateTimePicker
+# from datetimepicker.helpers import js_loader_url
+
+
+
+# class PersonForm(NgModelFormMixin, NgFormValidationMixin, NgModelForm, Bootstrap3ModelForm):
+#
+#     form_name = 'person_form'
+#     scope_prefix = 'person_data'
+#
+#     class Meta:
+#         model = UserProfile
+#         fields = ['name', 'departament', 'company', 'company_position',
+#                   'days_to_order_cancellation_default', 'days_to_pay_default',
+#                   'pay_terms', 'birthdate',
+#                   'phone', 'email', 'discount', 'document_sign_person']
+
+
+
+def emailValid(value):
+    if User.objects.filter(username=value, is_active=True):
+        raise ValidationError(_(u'пользователь с таким e-mail уже существует, воспользуйтесь восстановлением пароля'))
+
+def check_authorizationBy_cleaned_data(cleaned_data):
+    from django.contrib.auth import authenticate
+    print('check_authorizationBy_cleaned_data')
+    username = cleaned_data.get('username')
+    password = cleaned_data.get('password')
+
+    user = authenticate(username=username, password=password)
+    # print(user)
+    if user:
+    #     if user.is_active:
+        return user
+
+def check_activate_by_user(reg_user):
+    print('check_activate_by_user')
+    if reg_user:
+        if reg_user.is_active:
+            return True
+
+    return False
+
+class LoginForm(AuthenticationForm):
+    username = forms.EmailField(label=_('Email'), widget=forms.TextInput())
+    password = forms.CharField(min_length=8, label=_('Пароль'), widget=forms.PasswordInput(render_value=False))
+
+    def clean(self):
+        # print('check')
+        cleaned_data = super(LoginForm, self).clean()
+        reg_user = check_authorizationBy_cleaned_data(cleaned_data)
+        # print(reg_user)
+        if not reg_user:
+            raise ValidationError(_(u'Пользователь с введенными регистрационными данными не зарегистрирован. Проверьте правильность ввода e-mail и пароля.'))
+        else:
+            if not check_activate_by_user(reg_user):
+                raise ValidationError(_(u'Указанная учетная запись не была Активирована'))
+        return cleaned_data
+
+
+class ResetPassword_byEmail_Form(AuthenticationForm):
+    email = forms.EmailField(label=_('Email'), widget=forms.TextInput())

AuthApp/funcs.py

@@ -0,0 +1,392 @@
+# -*- coding: utf-8 -*-
+from .models import *
+from datetime import datetime, timedelta, date
+from django.db.models import Q, F, Value as V
+from django.db.models.functions import ExtractYear, Concat, Coalesce
+from functools import reduce
+from operator import or_
+
+sales_department_groups = [
+    'Отдел продаж: Начальник отдела продаж',
+    'Отдел продаж: Менеджер отдела продаж',
+    'Отдел продаж: Региональный руководитель отдела продаж',
+    'Отдел продаж: Стажер отдела продаж'
+]
+
+heads_of_sales_groups = [
+    'Отдел продаж: Начальник отдела продаж',
+    'Отдел продаж: Региональный руководитель отдела продаж',
+]
+
+
+def get_personal_companies_by_managers_list(managers_list, filter_kwargs={}, exclude_kwargs={}, only_emails=False):
+    try:
+        users = User.objects.filter(
+            user_profile__company_obj__manager_obj__in=managers_list,
+            **filter_kwargs
+        ).exclude(
+            **exclude_kwargs
+        ).order_by('-is_active', 'last_name', 'first_name')
+
+        if only_emails:
+            users = list(users.values_list('email', flat=True))
+
+    except Exception as e:
+        msg = f'get_personal_companies_by_managers_list Error = {str(e)}'
+        users = []
+
+    return users
+
+
+def get_head_staffs_by_user_email(user_email, only_emails=False):
+    try:
+        user = User.objects.get(email=user_email)
+        heads = get_head_staffs(user.user_profile, only_emails=True)
+    except User.DoesNotExist as e:
+        heads = None
+    return heads
+
+
+def get_head_staffs(user_profile_or_user_ID, only_emails=False):
+    if type(user_profile_or_user_ID) == str:
+        user = User.objects.get(id=int(user_profile_or_user_ID))
+        user_profile = user.user_profile
+    else:
+        user_profile = user_profile_or_user_ID
+        user = user_profile.user
+
+    groups = user.groups.all()
+    groups_name_list = groups.values_list('name', flat=True)
+
+    Q_list = []
+
+    if user_profile.is_sales_department_staff():
+        if 'Отдел продаж: Менеджер отдела продаж' in groups_name_list:
+            groups_list = ['Отдел продаж: Региональный руководитель отдела продаж']
+            kwargs = {
+                'groups__name__in': groups_list,
+                'user_profile__regions__in': user.user_profile.regions.all(),
+            }
+            Q_list.append(Q(**kwargs))
+
+        if not 'Отдел продаж: Начальник отдела продаж' in groups_name_list:
+            groups_list = ['Отдел продаж: Начальник отдела продаж']
+            kwargs = {'groups__name__in': groups_list}
+            Q_list.append(Q(**kwargs))
+
+    # groups_list = ['Управляющий']
+    # kwargs.update({'groups__name__in': groups_list})
+    if not 'Управляющий' in groups_name_list:
+        kwargs = {'is_superuser': True}
+        Q_list.append(Q(**kwargs))
+
+    Q_obj = reduce(lambda p1, p2: (p1 | p2), Q_list)
+    heads = User.objects.filter(
+        Q_obj,
+        is_active=True,
+        is_staff=True
+    )
+
+    heads = heads.distinct().order_by('-is_active', 'last_name', 'first_name')
+
+    if only_emails:
+        heads = list(heads.values_list('email', flat=True))
+
+    return heads
+
+
+def get_bosses_and_subordinate_staff_ids(user, only_active=False, include_cur_user=False, only_emails=False):
+    users = []
+
+    kwargs = {
+        'is_staff': True,
+    }
+
+    if only_active:
+        kwargs.update({'is_active': True})
+
+    groups = user.groups.all()
+    groups_name_list = groups.values_list('name', flat=True)
+
+    Q_obj = Q()
+
+    if 'Отдел продаж: Начальник отдела продаж' in groups_name_list:
+        Q_obj.add(Q(is_superuser=True), Q.OR)
+
+    elif 'Отдел продаж: Региональный руководитель отдела продаж' in groups_name_list:
+        Q_obj.add(Q(is_superuser=True), Q.OR)
+        Q_obj.add(Q(groups__name='Отдел продаж: Начальник отдела продаж'), Q.OR)
+
+    elif 'Отдел продаж: Менеджер отдела продаж' in groups_name_list:
+        Q_obj.add(Q(is_superuser=True), Q.OR)
+        Q_obj.add(Q(groups__name='Отдел продаж: Начальник отдела продаж'), Q.OR)
+        Q_obj.add(Q(
+            groups__name='Отдел продаж: Региональный руководитель отдела продаж',
+            user_profile__regions__in=user.user_profile.regions.all()), Q.OR)
+
+    subordinate_users = get_subordinate_staff(
+        user, only_active=only_active, include_cur_user=include_cur_user, only_emails=only_emails
+    )
+    res_val = 'id'
+    if only_emails:
+        res_val = 'user_profile__email'
+
+    subordinate_users = subordinate_users.values_list(res_val, flat=True)
+
+    if user.is_superuser:
+        users = subordinate_users
+    else:
+        bosses = User.objects.filter(Q_obj, **kwargs).values_list(res_val, flat=True)
+        users = set(subordinate_users) | set(bosses)
+
+    return users
+
+
+def get_subordinate_sales_staff(user, groups, only_active=False, only_emails=False, include_cur_user=False):
+    kwargs = {
+        'is_staff': True,
+    }
+
+    if only_active:
+        kwargs.update({'is_active': True})
+
+    Q_obj = Q()
+
+    if 'Отдел продаж: Начальник отдела продаж' in groups:
+        kwargs_groups = [
+            'Отдел продаж: Менеджер отдела продаж',
+            'Отдел продаж: Региональный руководитель отдела продаж',
+            'Отдел продаж: Стажер отдела продаж'
+        ]
+        Q_obj.add(Q(groups__name__in=kwargs_groups), Q.OR)
+
+
+    elif u'Отдел продаж: Региональный руководитель отдела продаж' in groups:
+        kwargs_groups = [
+            'Отдел продаж: Менеджер отдела продаж',
+            'Отдел продаж: Стажер отдела продаж'
+        ]
+        Q_obj.add(Q(groups__name__in=kwargs_groups, user_profile__regions__in=user.user_profile.regions.all()), Q.OR)
+
+    elif u'Отдел продаж: Менеджер отдела продаж' in groups:
+        kwargs_groups = [
+            'Отдел продаж: Стажер отдела продаж'
+        ]
+        Q_obj.add(Q(groups__name__in=kwargs_groups, user_profile__regions__in=user.user_profile.regions.all()), Q.OR)
+
+    elif 'Отдел закупок: Начальник отдела закупок' in groups:
+        kwargs_groups = [
+            'Отдел закупок: Менеджер отдела закупок',
+        ]
+        Q_obj.add(Q(groups__name__in=kwargs_groups), Q.OR)
+
+    if include_cur_user:
+        Q_obj.add(Q(id=user.id), Q.OR)
+
+    users = User.objects.filter(Q_obj, **kwargs).exclude(is_superuser=True)
+    users = users.distinct().order_by('-is_active', 'last_name', 'first_name')
+
+    # if kwargs:
+    #     other_users = User.objects.filter(
+    #         **kwargs
+    #     ).exclude(
+    #         is_superuser=True
+    #     )
+    #     users = users.union(other_users)
+    #     users = users.distinct().order_by('-is_active', 'last_name', 'first_name')
+
+    if only_emails:
+        users = list(users.values_list('email', flat=True))
+
+    return users
+
+
+def get_subordinate_staff(user, only_active=False, include_cur_user=False, only_emails=False):
+    users = []
+
+    groups = user.groups.all()
+    groups_name_list = groups.values_list('name', flat=True)
+
+    # отдел продаж
+    if set(groups_name_list):
+        users = get_subordinate_sales_staff(user, groups_name_list, include_cur_user=include_cur_user)
+
+    if not users and user.is_superuser:
+        users = get_all_staff()
+
+    if not users and include_cur_user:
+        users = User.objects.filter(id=user.id)
+
+    if users and only_active:
+        users = users.filter(is_active=True)
+
+    if only_emails:
+        users = list(users.values_list('email', flat=True))
+
+    return users
+
+
+def get_all_staff(only_active=False, only_emails=False):
+    kwargs = {
+        'is_staff': True,
+    }
+    if only_active:
+        kwargs.update({'is_active': True})
+
+    users = User.objects.filter(**kwargs).order_by('-is_active', 'last_name', 'first_name')
+
+    if only_emails:
+        users = list(users.values_list('email', flat=True))
+    return users
+
+
+def get_managers_wo_work():
+    managers = get_sales_managers()
+    managers = managers.filter(
+        user_profile__last_web_request__lt=datetime.now() - timedelta(minutes=20),
+        user_profile__last_web_request__contains=date.today()
+    )
+
+    return managers
+
+
+def get_birthdays(manager=None, for_next_count_days=None, only_first=False):
+    from_D = datetime.now()
+    Q_obj = Q()
+    Q_obj.add(Q(Q(birthdate__day=from_D.day) & Q(birthdate__month=from_D.month)), Q.OR)
+
+    # в for_next_count_days количество будущих дней для которых собираем дни рождения
+    if for_next_count_days:
+        for i in range(1, for_next_count_days):
+            Q_obj.add(Q(Q(birthdate__day=(from_D + timedelta(days=i)).day) & Q(
+                birthdate__month=(from_D + timedelta(days=i)).month)), Q.OR)
+
+    kwargs = {}
+    if manager:
+        kwargs.update({
+            'company_obj__manager_obj': manager,
+
+        })
+
+    from .models import UserProfile
+    user_profiles = UserProfile.objects.filter(
+        Q_obj,
+        # birthdate__lte=(datetime.now() + timedelta(days=3)).date(),
+        # birthdate__gte=datetime.now().date()
+        **kwargs
+    ).annotate(
+        age=datetime.now().year - ExtractYear('birthdate')
+    ).order_by('company_obj__manager_obj', 'birthdate')
+
+    if user_profiles and only_first:
+        return user_profiles[0]
+
+    return user_profiles
+
+
+def get_sales_managers(only_active=False, only_emails=False):
+    from CompaniesApp.models import Company
+
+    kwargs = {
+        'is_staff': True,
+        'companies_for_manager__company_type': 'client',
+    }
+    if only_active:
+        kwargs.update({'is_active': True})
+
+    managers = User.objects.filter(**kwargs).exclude(companies_for_manager=None).distinct().order_by('-is_active',
+                                                                                                     'last_name',
+                                                                                                     'first_name')
+
+    # managers = Company.objects.filter(
+    #     company_type='client'
+    # ).values_list('manager_obj', flat=True).distinct()
+
+    if only_emails:
+        managers = list(managers.values_list('email', flat=True))
+    return managers
+
+
+def get_full_names_by_id(ids):
+    names = User.objects.filter(
+        id__in=ids
+    ).annotate(
+        fullname=Concat(F('last_name'), V(' '), F('first_name'))
+    ).values('id', 'fullname')
+    names = {item['id']: item['fullname'] for item in names}
+
+    return names
+
+
+def fullname_for_user(user):
+    full_name = '%s %s' % (user.last_name, user.first_name)
+    return full_name.strip()
+
+
+def get_heads_of_sales(only_active=False, only_emails=False):
+    kwargs = {
+        'is_staff': True,
+    }
+
+    Q_obj = Q(groups__name__in=heads_of_sales_groups) | Q(is_superuser=True)
+
+    if only_active:
+        kwargs.update({'is_active': True})
+
+    users = User.objects.filter(
+        Q_obj,
+        **kwargs
+    ).order_by('-is_active', 'last_name', 'first_name')
+
+    if only_emails:
+        users = list(users.values_list('email', flat=True))
+    return users
+
+
+def get_sales_department_staff(regions=None, only_active=False, only_emails=False):
+    kwargs = {
+        'is_staff': True,
+    }
+
+    if not regions:
+        sales_department_groups = [
+            'Отдел продаж: Менеджер отдела продаж', 'Отдел продаж: Начальник отдела продаж',
+            'Отдел продаж: Региональный руководитель отдела продаж',
+            'Отдел продаж: Стажер отдела продаж'
+        ]
+        kwargs.update({
+            'groups__name__in': sales_department_groups,
+        })
+
+    else:
+        sales_department_groups = [
+            'Отдел продаж: Менеджер отдела продаж',
+            'Отдел продаж: Региональный руководитель отдела продаж',
+            'Отдел продаж: Стажер отдела продаж'
+        ]
+        kwargs.update({
+            'groups__name__in': sales_department_groups,
+        })
+
+    if only_active:
+        kwargs.update({'is_active': True})
+
+    users = User.objects.filter(**kwargs).exclude(is_superuser=True).order_by('-is_active', 'last_name', 'first_name')
+    if only_emails:
+        users = list(users.values_list('email', flat=True))
+    return users
+
+
+def get_marketing_departament_persons(only_active=False, only_emails=False):
+    kwargs = {
+        'is_staff': True,
+        'groups__name': 'Маркетинг: Маркетолог',
+    }
+    if only_active:
+        kwargs.update({'is_active': True})
+
+    users = User.objects.filter(**kwargs).order_by('-is_active', 'last_name', 'first_name')
+
+    if only_emails:
+        users = list(users.values_list('email', flat=True))
+    return users

AuthApp/migrations/0001_initial.py

@@ -0,0 +1,44 @@
+# Generated by Django 4.2.1 on 2023-05-16 09:47
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='UserProfile',
+            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='Дополнительные данные')),
+                ('UI_lang', models.CharField(choices=[('ru', 'Russian'), ('en', 'English')], max_length=2, verbose_name='Язык интерфейса')),
+                ('nick_name', models.CharField(blank=True, max_length=250, null=True, verbose_name='Псевдоним')),
+                ('authCode', models.CharField(blank=True, max_length=32, null=True)),
+                ('phone', models.CharField(blank=True, max_length=100, null=True, verbose_name='Телефон')),
+                ('birthdate', models.DateField(blank=True, null=True, verbose_name='Дата рождения')),
+                ('comment', models.TextField(blank=True, null=True, verbose_name='Дополнительные сведения')),
+                ('referal_link', models.TextField(verbose_name='Реферальная ссылка')),
+                ('user', models.OneToOneField(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='user_profile', to=settings.AUTH_USER_MODEL, verbose_name='id пользователя')),
+            ],
+            options={
+                'verbose_name': 'Профиль',
+                'verbose_name_plural': 'Профили',
+                'ordering': ('user__last_name', 'user__first_name'),
+                'permissions': (),
+            },
+        ),
+    ]

AuthApp/migrations/0002_userprofile_answer_success_count_userprofile_balance_and_more.py

@@ -0,0 +1,41 @@
+# Generated by Django 4.2.1 on 2023-05-16 14:01
+
+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),
+        ('AuthApp', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='userprofile',
+            name='answer_success_count',
+            field=models.IntegerField(default=0, verbose_name='Успешных ответов'),
+        ),
+        migrations.AddField(
+            model_name='userprofile',
+            name='balance',
+            field=models.FloatField(default=0, verbose_name='Баланс'),
+        ),
+        migrations.AddField(
+            model_name='userprofile',
+            name='questions_count',
+            field=models.IntegerField(default=0, verbose_name='Задано вопросов'),
+        ),
+        migrations.AlterField(
+            model_name='userprofile',
+            name='comment',
+            field=models.TextField(blank=True, null=True, verbose_name='Комментарий'),
+        ),
+        migrations.AlterField(
+            model_name='userprofile',
+            name='user',
+            field=models.OneToOneField(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='user_profile', to=settings.AUTH_USER_MODEL, verbose_name='Пользователь'),
+        ),
+    ]

AuthApp/models.py

@@ -0,0 +1,83 @@
+# coding=utf-8
+from __future__ import unicode_literals
+from django.contrib.auth.models import User
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+from django.db.models.signals import post_save, pre_save
+from django.contrib.contenttypes.fields import GenericRelation
+from BaseModels.base_models import BaseModel
+from datetime import datetime
+from django.conf import settings
+
+
+
+
+def user_name_str(self):
+    return f'{self.last_name} {self.first_name}'
+
+
+User.add_to_class("__str__", user_name_str)
+
+
+class UserProfile(BaseModel):
+
+    user = models.OneToOneField(User, verbose_name=_('Пользователь'), related_name=u'user_profile',
+                                null=True, blank=True, on_delete=models.CASCADE)
+
+    UI_lang = models.CharField(max_length=2, verbose_name=_('Язык интерфейса'), choices=settings.LANGUAGES)
+
+    nick_name = models.CharField(max_length=250, verbose_name=_('Псевдоним'), null=True, blank=True)
+
+    authCode = models.CharField(max_length=32, null=True, blank=True)
+
+    phone = models.CharField(max_length=100, verbose_name=_('Телефон'), null=True, blank=True)
+
+    birthdate = models.DateField(verbose_name=_(u'Дата рождения'), null=True, blank=True)
+
+    comment = models.TextField(verbose_name=_('Комментарий'), null=True, blank=True)
+
+    referal_link = models.TextField(verbose_name=_('Реферальная ссылка'))
+    balance = models.FloatField(verbose_name=_('Баланс'), default=0)
+    questions_count = models.IntegerField(verbose_name=_('Задано вопросов'), default=0)
+    answer_success_count = models.IntegerField(verbose_name=_('Успешных ответов'), default=0)
+
+
+    def __str__(self):
+        if self.user:
+            return '{0} {1}'.format(self.user.last_name, self.user.first_name)
+        else:
+            return str(self.id)
+
+
+    class Meta:
+        permissions = (
+
+        )
+
+        verbose_name = _('Профиль')
+        verbose_name_plural = _('Профили')
+        ordering = ('user__last_name', 'user__first_name')
+
+
+
+# @receiver(post_save, sender=User)
+def create_user_profile(sender, instance, created, **kwargs):
+    if created:
+        UserProfile.objects.create(user=instance)
+
+
+post_save.connect(create_user_profile, sender=User, dispatch_uid='post_save_connect')
+
+
+# @receiver(pre_save, sender=User)
+def preSaveUser(sender, instance, **kwargs):
+    if not instance.email:
+        instance.email = str(instance.username).lower()
+
+    try:
+        instance.user_profile.modifiedDT = datetime.now()
+    except:
+        pass
+
+
+pre_save.connect(preSaveUser, sender=User, dispatch_uid='pre_save_connect')

AuthApp/stat_funcs.py

@@ -0,0 +1,194 @@
+from BaseModels.mailSender import techSendMail
+from django.db.models import Sum, FloatField, F, Value as V, Count, OuterRef, Subquery, Q, Max, Exists
+from django.db.models.functions import Concat, Length
+from operator import itemgetter
+from datetime import datetime
+import copy
+from .models import User
+from datetime import datetime, date, timedelta
+from collections import OrderedDict
+
+
+def managers_sales_by_period_n_regions(period_from=None, period_to=None, region_ids=None, kwargs=None, sum_w_prev_data=None):
+    from CompaniesApp.models import Company
+
+    log_begin_DT = datetime.now()
+    msg = 'managers_sales_by_period_n_regions start - {0}<br>---------------<br><br>'.format(str(log_begin_DT))
+    print(msg)
+
+
+    stat_kwargs = {}
+    queryset_kwargs = {}
+    all_managers = False
+    separate_managers_sales_by_link_in_order = False
+    if kwargs:
+        if 'stat_kwargs' in kwargs:
+            stat_kwargs.update(kwargs['stat_kwargs'])
+
+
+        if 'all_managers' in kwargs:
+            all_managers = kwargs['all_managers']
+
+
+        if 'queryset_kwargs' in kwargs:
+            queryset_kwargs.update(kwargs['queryset_kwargs'])
+
+
+        if 'separate_managers_sales_by_link_in_order' in kwargs:
+            separate_managers_sales_by_link_in_order = kwargs['separate_managers_sales_by_link_in_order']
+
+
+    from B2BApp.stat_funcs import get_sales_by_period_n_regions
+    orders, receipts, pays = get_sales_by_period_n_regions(period_from=period_from, period_to=period_to, region_ids=region_ids, kwargs=kwargs)
+
+
+    ids = []
+    if not all_managers:
+
+        ord_manager_ids = set(item['manager_obj__id'] for item in orders)
+        receipt_manager_ids = set(item['manager_obj__id'] for item in receipts)
+        pay_manager_ids = set(item['manager__id'] for item in pays)
+
+        ids = set.union(ord_manager_ids, receipt_manager_ids, pay_manager_ids)
+
+        queryset_kwargs.update({'id__in': ids})
+
+    if not sum_w_prev_data:
+        managers = User.objects.filter(
+            **queryset_kwargs
+        ).annotate(
+            full_name=Concat(F('last_name'), V(' '), F('first_name')),
+        ).order_by('full_name').values(
+            'id', 'full_name'
+        )
+
+        objs = list(managers)
+        objs.sort(key=itemgetter('full_name'), reverse=False)
+        if None in ids:
+            objs.append({'id': None, 'full_name': 'не назначен менеджер'})
+    else:
+        objs = copy.deepcopy(sum_w_prev_data)
+
+    from_date = None
+    to_date = None
+    if orders:
+        orders.sort(key=itemgetter('delivery_DT'), reverse=False)
+        from_date = orders[0]['delivery_DT'].date()
+        to_date = orders[-1]['delivery_DT'].date()
+
+    if from_date:
+        from_DT = from_date
+    else:
+        from_DT = date(year=2000, month=1, day=1)
+
+    if to_date:
+        to_DT = to_date + timedelta(days=1)
+    else:
+        to_DT = datetime.now().date() + timedelta(days=1)
+
+    chart_data_Dict = OrderedDict({
+        str(from_DT + timedelta(n)): {
+            'sales_count': 0,
+            'sales_sum': 0,
+            'paid_sum': 0,
+            'paid_cash': 0,
+            'paid_invoice': 0
+        } for n in range(int((to_DT - from_DT).days) + 1)
+    })
+
+
+    objs_i = 0
+    while objs_i < len(objs):
+        obj_i = objs[objs_i]
+
+        # if separate_managers_sales_by_link_in_order:
+
+
+        if not 'sales_count' in  obj_i:
+            obj_i['sales_count'] = 0
+        if not 'sales_sum' in  obj_i:
+            obj_i['sales_sum'] = 0
+        if not 'paid_sum' in  obj_i:
+            obj_i['paid_sum'] = 0
+        if not 'receipts_sum' in  obj_i:
+            obj_i['receipts_sum'] = 0
+        if not 'receipts_count' in  obj_i:
+            obj_i['receipts_count'] = 0
+        # # if not 'top_sales_80' in  obj_i:
+        # # обнуляем все при каждой итерации
+        #  obj_i['top_sales_80'] = ''
+        #  obj_i['manager_top_sales_80'] = ''
+
+        # if  obj_i['id'] == 657:
+        #     print('!')
+
+        obj_orders = list(filter(lambda item: item['manager_obj__id'] ==  obj_i['id'], orders))
+        cash_orders = list(filter(lambda item: item['pay_type'] == 'cash', obj_orders))
+
+        obj_pays = list(filter(lambda item: item['manager__id'] ==  obj_i['id'], pays))
+
+        obj_receipts = list(filter(lambda item: item['manager_obj__id'] ==  obj_i['id'], receipts))
+        cash_receipts = list(filter(lambda item: item['pay_type'] == 'cash' and item['receipts_sum'], obj_receipts))
+
+        if obj_orders:
+             obj_i['sales_sum'] += round(sum(item['sales_sum'] for item in obj_orders if item['sales_sum']), 2)
+             obj_i['sales_count'] += round(sum(item['sales_count'] for item in obj_orders if item['sales_count']), 2)
+        if cash_orders:
+            # добавляем в оплаты кэшевые операции потому как они отсутствуют в платежах
+             obj_i['paid_sum'] += round(sum(item['paid_sum'] for item in cash_orders if item['paid_sum']), 2)
+
+        # if  obj_i['id'] == 1199:
+        #     print('!')
+
+        if obj_receipts:
+             obj_i['receipts_sum'] += round(
+                sum(item['receipts_sum'] for item in obj_receipts if item['receipts_sum']), 2)
+             obj_i['receipts_count'] += round(
+                sum(item['receipts_count'] for item in obj_receipts if item['receipts_count']), 2)
+
+             obj_i['sales_sum'] -=  obj_i['receipts_sum']
+             obj_i['sales_count'] -=  obj_i['receipts_count']
+
+        if cash_receipts:
+            # минусуем из оплат кэшевые операции потому как возвраты
+            obj_i['paid_sum'] -= round(sum(item['receipts_sum'] for item in cash_receipts if item['receipts_sum']), 2)
+
+        if obj_pays:
+            obj_i['paid_sum'] += round(sum(item['sum_pay_byn'] for item in obj_pays if item['sum_pay_byn']), 2)
+
+        obj_i['indicative_sales'] = round(( obj_i['sales_sum'] + obj_i['paid_sum']) / 2, 2)
+
+        required_del_client = False
+        if stat_kwargs:
+            if stat_kwargs and 'sales_count__gte' in stat_kwargs and stat_kwargs['sales_count__gte'] and \
+                    objs[objs_i][
+                        'sales_count'] < float(stat_kwargs['sales_count__gte']):
+                required_del_client = True
+            elif stat_kwargs and 'sales_count__lte' in stat_kwargs and stat_kwargs['sales_count__lte'] and \
+                    objs[objs_i][
+                        'sales_count'] > float(stat_kwargs['sales_count__lte']):
+                required_del_client = True
+            elif stat_kwargs and 'sales_sum__gte' in stat_kwargs and stat_kwargs['sales_sum__gte'] and objs[objs_i][
+                'sales_sum'] < float(stat_kwargs['sales_sum__gte']):
+                required_del_client = True
+            elif stat_kwargs and 'sales_sum__lte' in stat_kwargs and stat_kwargs['sales_sum__lte'] and objs[objs_i][
+                'sales_sum'] > float(stat_kwargs['sales_sum__lte']):
+                required_del_client = True
+
+        # if 'months_count' in kwargs:
+        #      obj_i['middle_sum_for_month'] = round( obj_i['indicative_sales'] / kwargs['months_count'], 2)
+        # # else:
+        # #     print('!')
+
+        if required_del_client:
+            del objs[objs_i]
+        else:
+            objs_i += 1
+
+    msg = 'managers_sales_by_period_n_regions finish - {0} (processing time = {1}<br>---------------<br><br>'.format(
+        str(datetime.now()),
+        str(datetime.now() - log_begin_DT)
+    )
+    print(msg)
+
+    return objs, chart_data_Dict

AuthApp/tests.py

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

AuthApp/urls.py

@@ -0,0 +1,57 @@
+# coding=utf-8
+from django.conf.urls import url
+# from AuthApp.js_views import *
+# from AuthApp.import_funcs import *
+from AuthApp.views import *
+from django.contrib.auth import views
+
+urlpatterns = [
+
+    # ajax ----------------
+    # url(r'^login$', user_login_View_ajax, name='user_login_View_ajax'),
+    # url(r'^login_confirm$', user_login_confirm_ajax, name='user_login_confirm_ajax'),
+    #
+    # url(r'^logout$', user_logout_ajax, name='user_logout_View_ajax'),
+    # url(r'^logout_confirm$', user_logout_confirm_ajax, name='user_logout_confirm_ajax'),
+    #
+    # url(r'^check_exists_email$', check_exists_email_ajax, name='check_exists_email_ajax'),
+    #
+    # url(r'^registration$', user_registration_View_ajax, name='user_registration_View_ajax'),
+    # url(r'^user_registration_send_confirmation_mail$',
+    #     user_registration_send_confirmation_mail_ajax, name='user_registration_send_confirmation_mail_ajax'),
+    #
+    # url(r'^password_recovery$', password_recovery_View_ajax, name='password_recovery_View_ajax'),
+    # url(r'^password_reset$', password_reset_send_mail_ajax, name='password_reset_send_mail_ajax'),
+    #
+    # url(r'^registration_by_order_data_and_send_confirmation_mail$',
+    #     registration_by_order_data_and_send_confirmation_mail_ajax, name='registration_by_order_data_and_send_confirmation_mail_ajax'),
+    #
+    #
+    # # -----------------------
+    #
+    # 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'),
+    #
+    # # url(r'^user/password/reset/$',
+    # #    'django.contrib.auth.views.password_reset',
+    # #    {'post_reset_redirect' : '/user/password/reset/done/',
+    # #     'password_reset_form': ResetForm
+    # #     },
+    # #    name="password_reset"),
+    # # url(r'^user/password/reset/done/$', views.password_reset_done, name='password_reset_done'),
+    # url(r'^reset/(?P<uidb64>[0-9A-Za-z_\-]+)/(?P<token>[0-9A-Za-z]{1,13}-[0-9A-Za-z]{1,20})/$',
+    #     views.password_reset_confirm, name='password_reset_confirm'),
+    # url(r'^reset/done/$', views.password_reset_complete, name='password_reset_complete'),
+    #
+    #
+    # # import
+    # url(r'^import_one_user/(?P<user_id>[\d+]*)$',
+    #     import_json_mipp_user_by_id, name='import_one_mipp'),
+    # url(r'^import_web_users$',
+    #     import_json_mipp_webUsers, name='import_mipp_webUsers'),
+    #
+    # url(r'^import_invoices_for_user_by_user_id/(?P<user_id>[\d+]*)$',
+    #     import_invoices_for_user_by_user_id, name='import_invoices_for_user_by_user_id'),
+
+]

AuthApp/views.py

@@ -0,0 +1,292 @@
+# coding=utf-8
+
+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.template import loader, RequestContext
+from django.contrib.auth.decorators import login_required
+from BaseModels.mailSender import techSendMail
+from django.utils.translation import ugettext as _
+from datetime import datetime
+
+
+def create_personal_user(data, creator):
+
+    try:
+
+        user_id = str(uuid1().hex)[:10]
+        user_name = data['email']
+        mail = user_name
+        user = User.objects.create_user(username=user_name, email=mail, password=user_id)
+
+        if 'first_name' in data and data['first_name']:
+            user.first_name = data['first_name']
+        if 'last_name' in data and data['last_name']:
+            user.last_name = data['last_name']
+        user.is_staff = False
+        user.is_active = False
+        user.is_superuser = False
+        # user.set_password(user_id)
+        user.save()
+
+        user_communications_ads_list = []
+
+        if 'office__name' in data['user_profile']:
+            del data['user_profile']['office__name']
+        if 'communications' in data['user_profile']:
+
+            user_communications_ads_list.extend(data['user_profile']['communications'])
+            del data['user_profile']['communications']
+
+        if not 'creator' in data['user_profile'] and creator:
+            data['user_profile']['creator'] = creator
+
+        profiles = UserProfile.objects.filter(user=user).update(**data['user_profile'])
+
+        if user_communications_ads_list:
+            from GeneralApp.funcs import create_communications_items_by_list
+            comm_objs = create_communications_items_by_list(user.user_profile, user_communications_ads_list)
+
+        user.refresh_from_db()
+
+        return {
+            'name' : mail,
+            'pass' : user_id,
+            'user' : user
+        }
+    except Exception as e:
+        return {
+            'error': 'Ошибка добавление нового пользователя = {0}'.format(str(e)),
+        }
+
+
+
+def decode_get_param(data):
+    import base64
+    import json
+
+    d = data['data'].encode()
+    token_data = base64.b64decode(d)
+
+    try:
+        request_data = token_data.decode('utf8')
+    except:
+        request_data = token_data
+
+    data = json.loads(request_data)
+
+    return data
+
+def check_user_key(data):
+    # print(u'check_user_key')
+
+
+    # try:
+    #     user_id = int(data[0])
+    # except:
+    #     user_id = None
+    # try:
+    #     user1S_id = int(data[1])
+    #
+    # company_id = data[2]
+    # user_key = data[3]
+
+    res = u'Key Broken'
+    # user_id = data[u'userId']
+    # user_key = data[u'userKey']
+    # user1S_id = data['user1S_id']
+    # company_id = data[u'companyId']
+
+    data = decode_get_param(data)
+
+    try:
+        token = UserTokens.objects.get(
+            user_id=data['pk'],
+            user_key=data['code'],
+            user1S_id=data['1S_pk'],
+            company_id = data['comp_pk']
+        )
+        res = u'Accept'
+        # print(u'try1 ok')
+    except UserTokens.DoesNotExist:
+        # если не найден id и ключ
+        try:
+            token = UserTokens.objects.get(
+                user_id=data['pk']
+            )
+            # techSendMail(
+            #     u'user try access by id={0}, key={1}, c_id={2}'.format(
+            #         str(user_id),
+            #         str(user_key),
+            #         str(company_id)
+            #     )
+            # )
+
+            res = u'Key Broken'
+            # print(u'try2 ok')
+        except UserTokens.DoesNotExist:
+            # если не найден id
+            token = UserTokens.objects.create(
+                user_id=data['pk'],
+                user_key=data['code'],
+                company_id=data['comp_pk']
+            )
+            res = u'Accept'
+            # print(u'except ok')
+
+    return res
+
+
+
+def recovery_password_user(request, uidb64=None, token=None):
+    from django.contrib.auth.views import PasswordResetConfirmView
+
+    return PasswordResetConfirmView(request=request, uidb64=uidb64, token=token
+    )
+
+
+# def recovery_password_user_complete(request, user_id, authCode):
+#     from django.contrib.auth.forms import SetPasswordForm
+#     from AuthApp.funcs import sendActivationMail
+#
+#     try:
+#         user = User.objects.get(id=user_id, mipp_user__authMailCode=authCode)
+#
+#     except:
+#         user = None
+#
+#     if user:
+#
+#         user.set_password()
+#
+#         if reg_user.is_active:
+#             activated_early = True
+#         else:
+#             reg_user.backend = 'AuthApp.backends.BaldeniniAuthBackend'
+#             login(request, reg_user)
+#
+#             reg_user.is_active = True
+#             reg_user.save()
+#             sendActivationMail(reg_user)
+#
+#     else:
+#         raise Http404
+#         # print(reg_user)
+#
+#     context = {
+#         'user': user,
+#         'activated_early' : activated_early,
+#         }
+#
+#     t = loader.get_template('pages/profile.html')
+#
+#     rContext = RequestContext(request, context)
+#     return HttpResponse(t.render(rContext))
+
+
+
+# def check_user_registration_and_activate(request, user_id, authCode):
+#     from django.contrib.auth import authenticate, login
+#     from AuthApp.funcs import sendActivationMail
+#
+#     try:
+#         reg_user = User.objects.get(id=user_id, mipp_user__authMailCode=authCode)
+#
+#     except:
+#         reg_user = None
+#
+#     activated_early = False
+#
+#     if reg_user:
+#
+#         if reg_user.is_active:
+#             activated_early = True
+#         else:
+#             reg_user.backend = 'AuthApp.backends.BaldeniniAuthBackend'
+#             login(request, reg_user)
+#
+#             reg_user.is_active = True
+#             reg_user.save()
+#             sendActivationMail(reg_user)
+#
+#     else:
+#         raise Http404
+#         # print(reg_user)
+#
+#     context = {
+#         'reg_user': reg_user,
+#         'activated_early' : activated_early,
+#         }
+#
+#
+#
+#     t = loader.get_template('admin_pages/pages/Profile/profile.html')
+#
+#     # rContext = RequestContext(request, context)
+#     # return HttpResponse(t.render(rContext))
+#     return HttpResponse(t.render(context, request))
+
+
+
+def create_temporary_user():
+    from django.utils.translation import ugettext as _
+    user_id = str(uuid1().hex)[:10]
+    user_name = u'user'+user_id
+    mail = user_id+u'@truenergy.by'
+    user = User.objects.create_user(mail, mail,user_id)
+    user.first_name = _(u'незарег. пользователь')
+    user.last_name = u''
+    user.is_staff = False
+    user.is_active = True
+    user.is_superuser = False
+    user.set_password(user_id)
+    # print(u'user_create_pass', user.password)
+    # p = user.get_profile()
+    # p.address = ''
+    # p.phone = ''
+    # p.group = None
+    # p.discount = 0
+    # p.pay_balance = 0
+    # p.authMailCode = uuid1().hex
+    # p.save()
+
+    user.save()
+    user.mipp_user.temporary_user = True
+    user.mipp_user.save()
+    # print('user',user)
+    # print('created profile',p)
+    # print('user created', user)
+    return {
+        'name' : mail,
+        'pass' : user_id,
+        'user' : user
+    }
+
+
+def get_active_user(request):
+    if request.user.is_anonymous:
+        return None
+    else:
+        user = request.user
+        # try:
+        #     bd = user.mipp_user.birthdate
+        # except MIPPUser.DoesNotExist:
+        #     MIPPUser.objects.create(user=user)
+
+        return user
+
+
+def get_active_user_if_anonymous_create_temporary(request):
+
+    user = get_active_user(request)
+
+    if not user:
+        new_user_Dict = create_temporary_user()
+        user = auth.authenticate(username=new_user_Dict['name'], password=new_user_Dict['pass'])
+        if user:
+            auth.login(request, user)
+
+    return user