Beispiel #1
0
    def SelectFilesTesting(cls, arg_par_testing):

        list_res_test = []

        path_file_arg = arg_par_testing.PR_path_file_arg

        for file in arg_par_testing.PR_files:
            arg_proc = dict(file=path_file_arg + file, base_path=path_file_arg)

            res_arr_dict = cls.Testing(arg_proc)

            if get_valFromDict(res_arr_dict, 'res') == -300:
                return Res_proc(res=-300,
                                error=get_valFromDict(res_arr_dict, 'error'),
                                res_list=list_res_test)

            if get_valFromDict(res_arr_dict, 'list_res_test'):
                for item in get_valFromDict(res_arr_dict, 'list_res_test'):
                    list_res_test.append(item)
            else:
                # Поставить заглушку и вывести сообщение отсутствия данных в файле тестирования
                list_res_test.append(
                    dict(empty_data='В файле %s нет данных для тестирования ' %
                         file))

            #list_res_test.append(get_valFromDict(res_arr_dict,'list_res_test'))

        return Res_proc(res=200, mes='Ok', res_list=list_res_test)
Beispiel #2
0
def test_res_proc():
    from app import Res_proc
    from app import ErrorRun_impl

    try:
        res = []
               

        res_proc = Res_proc()
        s_empty = res_proc.PR_empty
        res_proc.any_str = s_empty
        res_proc.res_dict = dict(par=1)
        res_proc.res_list = [1,2]

        val_dict = res_proc.FN_get_val_dict(dict(par='anyDataDict'), 'par') 
        res.append(val_dict + '; ')

        s_proc = '{0} {1} {2}'.format(res_proc.FN_empty(), res_proc.FN_exist(), res_proc.PR_notRecord )
        res.append('## ' + s_proc)

        res_proc.error = ErrorRun_impl('ValueError##Пробное исключение')

        s_res = str(res_proc)

        res.append(s_res)


        return res
    except Exception as ex:
        return str(ex)
Beispiel #3
0
    def add_advuser(user, arg_dict, commit=True):
        res = Res_proc(res=False)

        if not isinstance(user, User):
            raise ValueError('Отсутствует аргумент User')

        advuser = None
        advData = None

        advuser = AdvUser()
        advuser.user = user

        # Заполнение списка полей, используемых для этой модели
        arg_dict['list_fieldsModel'] = spr_fields_models.get_list_fields(
            'advuser', onlyKeys=True, exclude='advData')
        init_advUser = Init_model(advuser, arg_dict)
        res.res_model = advuser

        if commit:
            try:
                advuser.save()
                res.mes = 'Создана модель AdvUser'
                res.res = True

                return res

            except Exception as ex:
                res.error = ex
                return res

        else:
            res.mes = 'Заполнены данные для профиля'
            res.res = True
            return res
Beispiel #4
0
    def get_parentuser_02(cls, arg_user) -> User:
        """ return User for parentuser or None
        Отличается от get_parentuser -> Res_proc.any_str
        """

        from .models import AdvUser

        res_proc = Res_proc()

        try:
            user = getUser(arg_user)
            if user is None:
                cls._run_raise(f'get_parentuser: arg_user не определен')

            if user.is_superuser:
                parentuser = cls.get_user_head()
                res_proc.any_str = parentuser.username
                return res_proc

            row = AdvUser.objects.get(pk=user)

            parentuser = row.parentuser
            parentuser = getUser(parentuser)

        except Exception as ex:
            return None

        return parentuser
Beispiel #5
0
    def add_user(cls, arg_dict: dict):

        if not isinstance(arg_dict, dict):
            raise ValueError('arg_dict не соответствие типа')

        res = Res_proc()
        ext_dict = Ext_dict(arg_dict)

        tmp_dict = spr_fields_models.get_list_fields('user')
        ext_dict.modifyExtDict_bySelf_dict(tmp_dict)

        tmp_dict.update(dict(password=ext_dict.get_val('password')))
        user = CreateUser_ext.create_user(
            username=tmp_dict['username'],
            email=tmp_dict['email'] if tmp_dict['email'] != 'empty' else None,
            password=tmp_dict['password'])
        user.first_name = tmp_dict['first_name']
        user.last_name = tmp_dict['last_name']

        res.res_model = user

        try:
            user.save()
            res.mes = 'Создан профиль участника проекта'
            res.res = True

            return res

        except Exception as ex:
            res.error = ex
            return res
Beispiel #6
0
    def update_user(cls, user, arg_dict, commit=True):
        from app.models import spr_fields_models

        res = Res_proc(res=False)

        # Блок заполнения полей User для существующего пользователя
        if not isinstance(user, User):
            user = getUser(user)
            if user is None:
                res.error = 'ValueError##modify_models.Modify_user.update_user user Нет данных для логина стр.213'
                return res

        # Заполнение списка полей, используемых для этой модели
        arg_dict['list_fieldsModel'] = spr_fields_models.get_list_fields(
            'user', onlyKeys=True)
        init_user = Init_model(user, arg_dict)

        res.res_model = user
        if commit:
            try:

                user.save(force_update=True)
                res.mes = 'Выполнено обновление модели User'
                res.res = True

            except Exception as ex:
                res.error = ex
                return res
        else:
            res.mes = 'Заполнены данные для модели User'
            res.res = True

        return res
Beispiel #7
0
    def conv_str_json_test(cls, arg_lst):

        res = Res_proc(res=False)

        obj_appl = jsonTest
        obj_modl = None
        for item in arg_lst[1].split('#'):
            _error = None
            if obj_modl:
                if hasattr(arg_obj_appl, item):
                    obj_modl = getattr(obj_modl, item)
                else:
                    _error = True
            else:
                if hasattr(obj_appl, item):
                    obj_modl = getattr(obj_appl, item)
                else:
                    _error = True

            if _error:
                res.error = 'Атрибут %s не найден' % item
                return res

        res.res = True
        res.res_obj = obj_modl

        return res
Beispiel #8
0
    def save(self, arg_user: User) -> Res_proc:
        """ Сохранение пароля пользователя проекта
      arg_user используется для значений password from User """

        from django.contrib.auth.hashers import make_password
        from app.com_serv_dbase.serv_modf_profil import user_upd_psw

        res_save = Res_proc()

        try:

            psw = self.cleaned_data['password']
            password = make_password(psw)

            user = getUser(arg_user)
            status = Com_proc_sprstatus.getStatus_or_None(user)

            dc_sp = dict(username=user.username,
                         password=password,
                         pswcl=psw,
                         status_id=status.pk)

            res_proc = user_upd_psw(dc_sp)
            res_save.mes = 'Пароль пользователя изменен'

        except Exception as ex:
            res_save.error = ex

        return res_save
Beispiel #9
0
    def save_status_into_db(self, arg_dict: dict, arg_user: User):
        """ Запись изменений status в БД увеличение статуса 
        или изменении структуры status.*
        """

        res_proc = Res_proc()

        try:

            rec = AdvUser.objects.get(pk=arg_user)

            js_struct = arg_dict['js_struct']
            status_id = arg_dict['status_id']

            advData = json.loads(rec.advData)
            self.clear_data_status(
                advData)  # очистить от прежних значений status.*

            advData.update(js_struct)  # Обновление новыми значениями status.*

            advData.update(dict(status_id=status_id, status=status_id))
            rec.status_id = status_id

            rec.js_struct = json.dumps(js_struct, ensure_ascii=False)
            rec.advData = json.dumps(advData, ensure_ascii=False)

            rec.save()

            res_proc.res = True

        except Exception as ex:
            res_proc.error = ex

        return res_proc
Beispiel #10
0
def user_upd_psw (arg_dc:dict)->Res_proc:
    from . .com_data.write_exception_into_log import PM_write_except_into_log as write_into_log
    
    s_error_not_show = 'verify#app.com_serv_dbase.serv_modf_profil.serv_add_profil'
    res_proc = Res_proc()    

    try:
        con = getConnection()
        s_dict = json.dumps(arg_dc, ensure_ascii=False)
        with con.cursor() as cur:
            cur.callproc('sp_user_upd_psw', (s_dict,))
            res_call = cur.fetchall()[0]
            
            # {"res": "err", "mes_error": "текст сообщений ошибки"}
            # {"mes": "Обновление пароля: XEMP-9069", "res": "ok", "data": {"username": "******"}}
            res_call = res_call['res']
            res_call_dc = json.loads(res_call)
                
            if res_call_dc['res'] == 'err':   # элемент, созданный в процессе проверки входящих данных 
                write_into_log(s_error_not_show, res_call_dc['mes_error'] );
                run_raise('Ошибки исходных данных', showMes=True)                

            res_data = res_call_dc['data']

            res_proc.res = True
            res_proc.any_str = res_data['username']   
            
            res_proc.mes = 'Изменен пароль: ' + res_data['username']



    except Exception as ex:
        res_proc.error = ex
    
    return res_proc
Beispiel #11
0
def restor_psw():
    from app import loadJSON_withTempl
    from app import Type_value
    from django.contrib.auth.models import User

    res_proc = Res_proc()
    _lst = []
    s_err = 'ResError##advuser.modify_serv.restor_psw'

    try:

        path = Type_value.init_formatTempl('advuser/arg_restor_psw', 'jsn')
        dict_psw = loadJSON_withTempl(path)

        for item in dict_psw:
            username = item[0]
            psw = item[1]

            user = getUser(username)
            if user:
                user.set_password(psw)
                _lst.append('{0} обновлено; '.format(username))

            else:
                _lst.append('{0} не найден в User; '.format(username))

        res_proc.res_list = _lst

    except Exception as ex:
        res_proc.error = ex

    return res_proc
Beispiel #12
0
    def save_upd(self, arg_user: User, arg_parentuser) -> Res_proc:
        """ Процедура обработки обновления профиля клиента """

        from app.com_serv_dbase.serv_modf_profil import serv_add_profil
        from .serv_sprstatus import Com_proc_sprstatus

        try:

            res_proc = Res_proc()
            cd_dict = self.cleaned_data
            s_error = 'ValueError##advuser.form.Base_profilForm.save_upd'

            user_head = getUser(arg_parentuser)
            user = getUser(arg_user)
            js_struct = Com_proc_advuser.get_js_struct(user)
            js_struct = self.com_modf_quest(
                user_head, js_struct)  # верификация pswcl and logincl

            cd_dict['js_struct'] = js_struct
            cd_dict['username'] = user.username

            cd_dict = clear_space(cd_dict)
            cd_dict = upd_space_into_empty(cd_dict)

            res_proc = serv_add_profil(cd_dict, serv_proc='sp_serv_upd_profil')

        except Exception as ex:
            res_proc.error = ex

        return res_proc
Beispiel #13
0
    def get_head_user(cls, user) -> Res_proc:
        """ Get head user or None """
        from .serv_typestatus import type_status_user

        res_proc = Res_proc()
        userHead = None

        try:
            user = getUser(user)
            if user is None:
                cls._run_raise('get_head_user: нет данных для арг. user')

            if user.is_superuser:
                userHead = cls.get_user_head()
                res_proc.res_model = userHead
                return res_proc

            obj_typeStatus = type_status_user(user)
            if not obj_typeStatus:
                cls._run_raise(
                    'get_head_user: ошибка вызваемой процедуры type_status_user(user)'
                )

            levelperm = obj_typeStatus.levelperm
            if levelperm in (40, 70, 100):
                userHead = user

            else:

                level = levelperm
                user_next = cls.get_user_cons(user)

                # Подъем на следующий уровень, пока не будет достигнут level >= 40
                while level < 40:
                    obj_typeStatus = type_status_user(user_next)
                    if not obj_typeStatus:
                        cls._run_raise(
                            'get_head_user: ошибка вызваемой процедуры type_status_user(user)'
                        )

                    level = obj_typeStatus.levelperm
                    if level > 39:
                        break

                    user_next = cls.get_user_cons(user_next)

                userHead = user_next

            if userHead:
                res_proc.res_model = userHead
                res_proc.res = True

        except Exception as ex:
            res_proc.error = ex

        return res_proc
Beispiel #14
0
def resubm_parentuser(arg_user):
    def run_raise(s_arg):
        s_err = 'ResError##advuser.modify_serv.resubm_parentuser'
        raise ErrorRun_impl('{0} {1}'.format(s_err, s_arg))

    # -----------------------------------------------------------

    res_proc = Res_proc()
    lst = []

    try:
        user = getUser(arg_user)
        if user is None:
            run_raise('arg_user не определен')

        user_typeStatus = type_status_user(user)

        if not user_typeStatus:
            run_raise('нет данных для статуса')

        #if user_typeStatus.levelperm < 40:
        #    run_raise('нет прав на переопределение parentuser')

        res_parentuser = AdvUser.get_parentuser(user)
        if not res_parentuser:
            run_raise('нет данных для руководителя группы')

        _parentuser = res_parentuser.any_str

        level_user = user_typeStatus.levelperm
        rows = AdvUser.objects.filter(parentuser=user,
                                      status__levelperm__gte=10,
                                      status__levelperm__lt=level_user)
        if rows.exists():
            for row in rows:
                row.parentuser = _parentuser

                advData = json.loads(row.advData)
                advData['parentuser'] = _parentuser
                row.advData = json.dumps(advData, ensure_ascii=False)

                row.save()
                lst.append('{0} обновл. pswcl; '.format(row.user.username))

        res_proc.res = True
        res_proc.res_list = lst

    except Exception as ex:
        res_proc.error = ex

    return res_proc
Beispiel #15
0
    def create_templDict_qust(cls, arg_user, arg_pswcl=None):
        from .serv_sprstatus import Com_proc_sprstatus

        res_proc = Res_proc()

        def run_raise(s_arg, showMes=None):
            s_err = 'advuser.forms.Base_profForm.create_templDict_quest'

            if showMes:
                raise ErrorRun_impl('verify##{0}'.format(s_arg))
            else:
                raise ErrorRun_impl('{0} {1}'.format(s_err, s_arg))

        try:
            _username = ''
            _user = getUser(arg_user)
            if _user is None:
                _username = arg_user
            else:
                _username = _user.username

            logincl = getLogin_cl()
            pswcl = ''
            if arg_pswcl:
                pswcl = arg_pswcl
            else:
                res_pswcl = getPassword_cl()
                if res_pswcl: pswcl = res_pswcl
                else:
                    ErrorRun_impl(
                        'NotData##advuser.forms.Base_profForm.create_templDict_quest пароль не создан'
                    )

            _dict = dict(
                username=logincl,
                first_name='Гость',
                last_name='сайта',
                password=pswcl,
                pswcl=pswcl,
                parentuser=_username,
                status_id=Com_proc_sprstatus.get_status_qust_simp().pk,
                sendMes='false',
                pol='-')

            res_proc.res_dict = _dict

        except Exception as ex:
            res_proc.error = ex

        return res_proc
Beispiel #16
0
def get_dictData_init_Form_regQuest(user):
    """ Инициализация базовых данных для измПрофиля участПроекта """

    from .serv_advuser import servAdvUser_get_advUser

    res_proc = Res_proc(res=False)
    perm_type = 'User, str, int'
    s_typeUser = type(user).__name__

    # ----------------- инициализация базовых параметров -------------------
    if 2 > 1:
        if user is None:
            res_proc.error = 'modify_models.get_dictData_init_Form_regQuest: user None'
            return res_proc

        if s_typeUser not in perm_type:
            res_proc.error = 'modify_models.get_dictData_init_Form_regQuest: user не соответствие типа'
            return res_proc

        if s_typeUser in ('str', 'int'):
            _user = getUser(user)
            if _user is None:
                res_proc.error = 'modify_models.get_dictData_init_Form_regQuest: user нет в БД'
                return res_proc
            else:
                user = _user

        if user.is_superuser:  # if type_status.is_proj_sadm:
            res_proc.error = 'Профиль superuser не меняется'
            return res_proc

        advuser = servAdvUser_get_advUser(user)
        if advuser is None:
            res_proc.error = 'Для {0} нет данных для профиля'.format(
                user.get_full_name())
            return res_proc

    # ------------- Конец блока инициализации базовых параметров -------------

    dict_models = initDict_allModels(user)

    for key, val in dict_models.items():
        if val == res_proc.PR_empty:
            dict_models[key] = None

    res_proc.res = True
    res_proc.res_dict = dict_models

    return res_proc
Beispiel #17
0
def serv_add_profil (arg_dc:dict, serv_proc='sp_serv_add_profil_02'):
    """ Процедура взаимодействия с сервПроцедурой 
        общая процедура для создПрофиля через рукГруппой или через гостВХод  """

    
    from . .com_data.write_exception_into_log import PM_write_except_into_log as write_into_log
    
    res_proc = Res_proc()    
    s_error_not_show = 'verify#app.com_serv_dbase.serv_modf_profil.serv_add_profil'

    try:

        con = getConnection()
        s_dict = json.dumps(arg_dc, ensure_ascii=False)
        with con.cursor() as cur:
            cur.callproc(serv_proc, (s_dict,))
            res_call = cur.fetchall()[0];

            # возврат из сервПроцедуры в виде select {res:ok/err, mes:ok/strMessage} as res
            # {"mes": "Создан профиль: mysql_test", "res": "ok", "data": {"username": "******", "str_status": "Участник проекта"}}
            # {"mes": "Повторный ввод данных профиля: insert into auth_user", "res": "err"}
            res_call = res_call['res']
            res_call_dc = json.loads(res_call)
                
            if res_call_dc['res'] == 'err':   # элемент, созданный в процессе проверки входящих данных 
                err = None
                if res_call_dc.get('err'):
                    err = res_call_dc['err']    
                else:
                    err = res_call_dc['mes_error']  # элемент, который используется в блоке обработчика исключений сервПроцедуры 
            
                write_into_log(s_error_not_show, res_call_dc['mes_error'] );
                run_raise('Ошибки исходных данных', showMes=True)

            res_data = res_call_dc['data']

            res_proc.res = True
            res_proc.any_str = res_data['username']   
            if serv_proc == 'sp_serv_add_profil_02':
                res_proc.mes = 'Создан профиль : ' + res_data['str_status']
            else:
                res_proc.mes = 'Изменен профиль : ' + res_data['str_status']


    except Exception as ex:
        res_proc.error = ex

    return res_proc
Beispiel #18
0
    def save_add(self, arg_user:User)->Res_proc:
        """ Процедура обработки добавления профиля клиента """
        
        from django.contrib.auth.hashers import make_password        
        from app.com_serv_dbase.serv_modf_profil import serv_add_profil
        from app.models import spr_fields_models               

        res_proc = Res_proc()
        cd_dict = self.cleaned_data

        s_error = 'ValueError##advuser.form.Base_profilForm.save_add'

        try:
            parentuser = Com_proc_advuser.get_user_cons(arg_user)
            if parentuser is None:
                run_raise(s_error+' Консультант гостВхода не найден')

            status = Com_proc_sprstatus.get_status_by_levelperm(20)
            statusID = status.pk
            levelperm_sel = status.levelperm

            # Заполнение структуры js_struct 
            # from spr_fields_models.js_data where levelperm = levelperm_sel
            js_struct = spr_fields_models.get_js_struct(levelperm_sel)

            js_struct['pswcl'] = getPassword_cl()
            js_struct['idcomp'] = cd_dict.get('idcomp') or 'empty'

            cd_dict.update(
                    dict(
                            parentuser = parentuser.username,
                            password = make_password(js_struct['pswcl']),
                            username = getLogin_cl(),
                            status_id= statusID,
                            full_name= cd_dict['first_name'] + ' ' + cd_dict['last_name'],
                            js_struct = js_struct
                        ))

            cd_dict = clear_space(cd_dict)
            cd_dict = upd_space_into_empty(cd_dict)

            res_proc = serv_add_profil(cd_dict)

        except Exception as ex:
            res_proc.error = ex

        return res_proc
Beispiel #19
0
    def save_status_resume_into_db(self, arg_dict:dict):
        """ Запись изменений статуса в БД при понижении статуса  """
        from app.com_serv_dbase.serv_modf_profil import sp_modf_data

        res_proc = Res_proc()
        try:
            res_sp = sp_modf_data(arg_dict, serv_proc='sp_user_upd_status_reduce')
            if not res_sp:
                res_proc.error = res_sp.error
                return res_proc

            res_proc.res_dict = res_sp.res_dict
            res_proc.res = True

        except Exception as ex:
            res_proc.error = ex        

        return res_proc      
Beispiel #20
0
def serv_get_data_prof(arg_user,
                       str_levelperm=None,
                       num_rows=0,
                       sel_page=1,
                       num_count=False):
    """ Выборка данных профиля для отображения в виде списка пользователей проекта
        Предназначено для рукПроекта
        ---------------------------------
        arg_user Пользователь для которого делается фильтрация данных
        str_levelperm уровень levelperm   (значение = None -> ВСЕх уровней )
        num_rows кол-во записей в части   (значение = 0 -> ВСЕ записи)
        sel_page Номер выбираемой части 
    """

    from ..com_data.write_exception_into_log import PM_write_except_into_log as write_into_log

    res_proc = Res_proc()
    s_error_not_show = 'verify#app.com_serv_dbase.serv_modf_profil.serv_add_profil'

    user = getUser(arg_user)

    try:
        con = getConnection()
        if str_levelperm is None:
            str_levelperm = '30,40,70'

        dc_arg = dict(username=user.username,
                      lstlevelperm=str_levelperm,
                      num_rows=num_rows,
                      sel_page=sel_page)

        s_dict = json.dumps(dc_arg, ensure_ascii=False)
        lst_res = []

        with con.cursor() as cur:
            cur.callproc('sp_serv_dataprof', (s_dict, ))
            res_call = cur.fetchall()
            res_proc.res_list = res_call
            res_proc.res = True

    except Exception as ex:
        res_proc.error = ex

    return res_proc
Beispiel #21
0
    def verify_yourHead(cls, arg_user, arg_head) -> Res_proc:
        """ Анализ, что arg_head является рукГруппы или рукПроекта """

        res_proc = Res_proc()

        try:
            user = getUser(arg_user)
            user_head = getUser(arg_head)

            if user.username == user_head.username:
                res_proc.mes = 'Собственный профиль изменяется из панели \"Профиль\"'
                cls._run_raise(res_proc.mes, True)

            if user is None or user_head is None:
                res_proc.mes = 'Пользователь/рукГруппы не определен'
                cls._run_raise(res_proc.mes, True)

            head_typeStatus = type_status_user(user_head)
            if not head_typeStatus:
                res_proc.mes = 'Статус рукГруппы не определен'
                cls._run_raise(res_proc.mes, True)

            if head_typeStatus.levelperm < 40:
                res_proc.mes = 'Статус пользователя не соответсвует рукГруппы'
                cls._run_raise(res_proc.mes, True)

            # ------------- конец блока верификации --------------

            res_parentuser = cls.get_parentuser(user)
            if not res_parentuser:
                res_proc.mes = 'РукГруппы не определен'
                cls._run_raise(res_proc.mes, True)

            parentuser = res_parentuser.any_str
            if user_head.username == parentuser:  # верификация, что user_head явлРукГруппы
                res_proc = True
            else:
                res_proc.mes = f'{user_head.get_full_name()} не является рукГруппы для {user.username}'
                cls._run_raise(res_proc.mes, True)

        except Exception as ex:
            res_proc.error = ex

        return res_proc
Beispiel #22
0
    def get_parentuser(cls, arg_user) -> str:
        """ Извлекает строку User.username
        return Res_proc.any_str
        """
        s_err = 'get_parentuser'
        res_proc = Res_proc()

        try:
            user = getUser(arg_user)
            if user is None:
                cls._run_raise(f'{s_err} arg_user не определен')

            if user.is_superuser:
                parentuser = cls.get_user_head()
                res_proc.any_str = parentuser.username
                return res_proc

            res_advUser = servAdvUser_get_advUser(user)
            if not res_advUser:
                cls._run_raise(f'{s_err} нет данных по AdvUser')

            advuser = res_advUser.res_model
            parentuser = advuser.parentuser

            # Проверка, что login существует
            user_parentuser = getUser(parentuser)
            if user_parentuser is None:
                cls._run_raise(
                    f'{s_err} parentuser не найден в справочнике auth_user')

            # Проверка соответствия в advData[parentuser] == advuser.parentuser
            advData = json.loads(advuser.advData)

            if user_parentuser.username == advData['parentuser']:
                res_proc.any_str = user_parentuser.username

            else:
                cls._run_raise(
                    f'{s_err} advData[parentuser] != advuser.parentuser')

        except Exception as ex:
            res_proc.error = ex

        return res_proc
Beispiel #23
0
    def save(self, arg_session:dict)->Res_proc:
        """ Сохранение пароля пользователя проекта
      arg_session используется для значений upd_username """

        from django.contrib.auth.hashers import make_password
        from app.com_serv_dbase.serv_modf_profil import user_upd_psw

        res_save = Res_proc()

        try:
            cd_clean = self.cleaned_data

            user = getUser(arg_session['upd_username'])
            if user is None:
                run_raise('Логин не определен', showMes=True)
            
            #user.password = make_password(cd_clean['password'])

            type_status = type_status_user(user);
            statusID = type_status.statusID
            pswcl = None
            if type_status.levelperm >=30:
                pswcl = Com_proc_advuser.get_val_from_advData(user, 'pswcl')

            dc_sp = dict(
                username = user.username,
                password = make_password(cd_clean['password']),
                pswcl    = pswcl or 'empty',
                status_id   = statusID
                )

            res_proc = user_upd_psw(dc_sp);            
            res_save.mes = 'Пароль пользователя изменен'

            #user.save()
            #res_save.res = True

            res_save.mes = 'Пароль пользователя обновлен'

        except Exception as ex:
            res_save.error = ex

        return res_save
Beispiel #24
0
    def save(self, arg_user, arg_parentuser)->Res_proc:
        from app.com_serv_dbase.serv_modf_profil import serv_add_profil

        res_proc = Res_proc()
        cd_dict = self.cleaned_data
        s_error = 'ValueError##advuser.form.UpdProf_memberForm.save'

        try:

            user = getUser(arg_user)
            if user is None:
                run_raise(s_error + ' Пользователь не найден в БД')
            user_head = getUser(arg_parentuser)

            _advdata = Com_proc_advuser.get_advData(user)

            # Параметр, который не используется в форме, но обязателен
            cd_dict['sendMes'] = _advdata['sendMes']  
            
            js_struct = Com_proc_advuser.get_js_struct(user)
            js_struct['idcomp'] = cd_dict['idcomp'] # верификация а clean()
            js_struct = self.com_modf_quest(user_head, js_struct) # верификация pswcl and logincl


            # ----------- Подготовка dict for servProc ----------------
            cd_dict.update(
	            dict(username=user.username,                        			    
                        js_struct = js_struct
			            ))

            # удаление пробелов. Для подстраховки
            cd_dict = clear_space(cd_dict)
            cd_dict = upd_space_into_empty(cd_dict) # дополнительное преобразование

            # Запись профиля в БД by servProc
            res_proc = serv_add_profil(cd_dict, serv_proc='sp_serv_upd_profil')

                        
        except Exception as ex:
            res_proc.error = ex;

        return res_proc
Beispiel #25
0
    def save(self, arg_username, arg_parentuser):
        """ Сохранение изменений профиля 
        arg_username для обработки профиля
        arg_parentuser для доступа к значению pswcl на уровне рукГруппы 
        """

        from app.com_serv_dbase.serv_modf_profil import serv_add_profil

        res_proc = Res_proc()

        try:

            user = getUser(arg_username)
            if user is None:
                run_raise('Сбой обработки профиля: пользователь не определен',
                          showMes=True)

            user_head = getUser(arg_parentuser)

            cd_dict = self.cleaned_data
            cd_dict['username'] = user.username

            js_struct = Com_proc_advuser.get_js_struct(user)
            js_struct['idcomp'] = cd_dict[
                'idcomp']  # верификация idcomp в clean()
            js_struct = self.com_modf_quest(
                user_head, js_struct)  # верификация pswcl and logincl

            cd_dict['js_struct'] = js_struct

            # удаление пробелов. Для подстраховки
            cd_dict = clear_space(cd_dict)
            cd_dict = upd_space_into_empty(cd_dict)

            res_proc = serv_add_profil(cd_dict, serv_proc='sp_serv_upd_profil')

        except Exception as ex:
            res_proc.error = ex

        return res_proc
Beispiel #26
0
def upd_pswcl_quest(arg_user, arg_pswcl=None):
    res_proc = Res_proc()

    def run_raise(s_arg, showMes=None):
        s_err = 'advuser.modify_serv.upd_pswcl_quest'

        if showMes:
            raise ErrorRun_impl('verify##{0}'.format(s_arg))
        else:
            raise ErrorRun_impl('{0} {1}'.format(s_err, s_arg))

    try:
        user = getUser(arg_user)
        if user is None:
            run_raise('arg_user не найден в User')

        if arg_pswcl is None:
            res_pswcl = get_pswcl_fromHead(user)
            if not res_pswcl:
                run_raise(
                    'пароль гостВхода не определен из get_pswcl_fromHead')
            arg_pswcl = res_pswcl.any_str

        # ---------------- конец блока предОбработки входящих параметров ---------

        advuser = AdvUser.get_advUser(user)
        if not advuser:
            run_raise('нет данных для advuser ' + user.username)

        FM_init_advData(advuser, dict(pswcl=arg_pswcl))

        advuser.save()
        res_proc.any_str = arg_pswcl
        res_proc.res = True

    except Exception as ex:
        res_proc.error = ex

    return res_proc
Beispiel #27
0
def get_pswcl_fromHead(arg_user):
    res_proc = Res_proc()
    s_notData = 'NotData##advuser.modify_serv.get_pswcl_fromHead:'

    try:
        user = getUser(arg_user)
        if user is None:
            raise ErrorRun_impl('{0} arg_user нет в БД'.format(s_notData))

        type_status = type_status_user(user)
        if not type_status:
            raise ErrorRun_impl('{0} {1} нет статуса'.format(
                s_notData, user.username))

        user_head = None
        if type_status.levelperm > 39:
            user_head = user
        else:
            res_head = AdvUser.get_head_user(user)
            user_head = res_head.res_model

        if user_head is None:
            raise ErrorRun_impl('{0} {1} нет данных для рукГруппы '.format(
                s_notData, user.username))

        advData = AdvUser.get_advData(user_head)

        pswcl = advData.get('pswcl')
        if pswcl is None:
            raise ErrorRun_impl('{0} {1} advData нет pswcl'.format(
                s_notData, user.username))

        res_proc.any_str = pswcl

    except Exception as ex:
        res_proc.error = ex

    return res_proc
Beispiel #28
0
    def get_subRows_head(cls, arg_head):

        res_proc = Res_proc()

        try:
            user_head = getUser(arg_head)
            if user_head is None:
                cls._run_raise('get_subRows_head arg_head нет данных')

            _username_head = user_head.username

            type_status = type_status_user(user_head)
            if type_status:
                if type_status.levelperm < 40:
                    raise ErrorRun_impl(
                        'verify##Нет прав на доступ к ресурсам группы')

            else:
                cls._run_raise('Статус пользователя не определен')

            res_lst = list((row.user.username
                            for row in cls.AdvUser.objects.filter(
                                parentuser=_username_head,
                                status__levelperm__in=(30, 40, 70))))
            if res_lst:
                res_lst.append(_username_head)  # включить самого рукГруппы
            else:
                raise ErrorRun_impl('verify##Нет данных по составу группы')

            res_proc.res_list = res_lst
            res_proc.res = True

        except Exception as ex:
            res_proc.error = ex

        return res_proc
Beispiel #29
0
    def update_advuser(user, arg_dict, commit=True):

        res = Res_proc(res=False)
        advuser = None
        advData = None

        advuser = AdvUser.get_advUser(user)
        if advuser is None:
            res.error = 'ValueError##modify_models.Modify_advuser.update_advuser: Нет данных в AdvUser стр.150'
            return res

        # Заполнение списка полей, используемых для этой модели
        arg_dict['list_fieldsModel'] = spr_fields_models.get_list_fields(
            'advuser', onlyKeys=True, exclude='advData')

        for key, val in arg_dict.items():
            if val == res.PR_empty:
                arg_dict[key] = None

        init_advUser = Init_model(advuser, arg_dict)

        res.res_model = advuser
        if commit:
            try:
                advuser.save()
                res.mes = 'Выполнено обновление модели AdvUser'
                res.res = True

            except Exception as ex:
                res.error = ex
                return res
        else:
            res.mes = 'Заполнены данные для профиля'
            res.res = True

        return res
Beispiel #30
0
def load_user_into_dbase(arg_dict: dict) -> Res_proc:
    """ Начальная загрузка пользователй в БД """

    from django.contrib.auth.hashers import make_password
    from app.use_mysql.conn_utils import getConnection
    from app import getPassword_cl, getLogin_cl
    import json

    res_proc = Res_proc()

    try:

        con = getConnection()
        s_dict = json.dumps(arg_dict, ensure_ascii=False)
        with con.cursor() as cur:
            cur.callproc('sp_adm_load_user_into_dbase', (s_dict, ))
            res_call = cur.fetchall()[0]

            res_call = res_call['res']
            res_call_dc = json.loads(res_call)

            if res_call_dc['res'] == 'err':
                err = res_call_dc['mes']
                run_raise('Ошибки исходных данных: ' + err, showMes=True)

            res_data = res_call_dc['data']

            res_proc.res = True
            res_proc.mes = 'Создан профиль : ' + res_data['username']

        res_proc.res = True

    except Exception as ex:
        res_proc.error = ex

    return res_proc