def _verify_user(self):
try:
type_statusUser = type_status_user(self.user)
if not type_statusUser:
raise ErrorRun_impl('{0} Нет данных Type_status_user'.format(
self.s_err))
if type_statusUser.levelperm > 39: return
advData = AdvUser.get_advData(self.user)
if advData is None:
raise ErrorRun_impl(
'{0} нет данных advData for self.user'.format(self.s_err))
logincl = Res_proc.FN_get_val_dict(advData, 'logincl')
pswcl = Res_proc.FN_get_val_dict(advData, 'pswcl')
# Обновление по значениям, полученным из гостВхода
if logincl != self.logincl or pswcl != self.pswcl:
_dict = dict(logincl=self.logincl, pswcl=self.pswcl)
self._upd_quest(self.user.advuser, _dict, True)
except Exception as ex:
self._init_err(ex, self.s_err_serv)
def _run_raise(s_arg, showMes=None):
s_err = 'advuser.serv_typestatus.type_status_user'
if showMes:
raise ErrorRun_impl('verify##{0}'.format(s_arg))
else:
raise ErrorRun_impl('{0} {1}'.format(s_err, s_arg))
def _add_quest(self, arg_user):
try:
res_templ = self.profForm.create_templDict_qust(arg_user)
if not res_templ:
raise ErrorRun_impl(
'{0} процедура create_templDict_qust вернула None '.format(
self.s_err))
dict_templ = res_templ.res_dict
res_add = self.profForm.addProfilUser(dict_templ)
if not res_add:
raise ErrorRun_impl(
'{0} Ошибка создания объекта user_cl'.format(self.s_err))
advData = AdvUser.get_advData(dict_templ['username'])
if not advData:
raise ErrorRun_impl('{0} нет данных advData '.format(
self.s_err))
self.logincl = advData['username']
self.pswcl = advData['pswcl']
except Exception as ex:
self._init_err(ex, self.s_err_serv)
def run_raise(s_arg, showMes=None):
s_err = 'modify_models.get_dictData_init_Form'
if showMes:
raise ErrorRun_impl('verify##{0}'.format(s_arg))
else:
raise ErrorRun_impl('{0} {1}'.format(s_err, s_arg))
def run_raise(s_arg, showMes=None):
s_err = 'ValError##advuser.modify_models.get_list_prof_memb'
if showMes:
raise ErrorRun_impl('verify##{0}'.format(s_arg))
else:
raise ErrorRun_impl('{0}: {1}'.format(s_err, s_arg))
def run_raise(s_arg, showMes=None):
s_err = 'advuser.modify_serv.restor_data_quest'
if showMes:
raise ErrorRun_impl('verify##{0}'.format(s_arg))
else:
raise ErrorRun_impl('{0} {1}'.format(s_err, s_arg))
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))
def _run_raise(s_arg, showMes=None):
_s_err = 'SyntaxError##advuser.serv_advuser.servAdvUser_get_advUser'
if showMes:
raise ErrorRun_impl('verify##{0}'.format(s_arg))
else:
s_mes = '{0} {1}'.format(_s_err, s_arg)
TypeError_system(
ErrorRun_impl(s_mes)) # запись в файл app/loggin/*.log
raise ErrorRun_impl(s_mes)
def _run_raise(cls, s_arg, showMes=None, s_err=None):
s_err = s_err or cls._s_err
if showMes:
raise ErrorRun_impl('verify##{0}'.format(s_arg))
else:
s_mes = '{0} {1}'.format(s_err, s_arg)
TypeError_system(
ErrorRun_impl(s_mes)) # запись в файл app/loggin/*.log
raise ErrorRun_impl(s_mes)
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)
def _ver_exists_quest(self):
try:
row_cl = AdvUser.objects.filter(parentuser=self.user.username,
status__levelperm=10)
if row_cl.exists():
row_cl = row_cl.last()
self.logincl = row_cl.user.username
advuser = row_cl.user.advuser
advData = json.loads(advuser.advData)
_pswcl = Res_proc.FN_get_val_dict(advData, 'pswcl')
if _pswcl is None:
res_pswcl = get_pswcl_fromHead(self.user)
if res_pswcl:
_pswcl = res_pswcl.any_str
self._upd_quest(row_cl, dict(pswcl=_pswcl))
else:
raise ErrorRun_impl(
'{0} pswcl не определен из get_pswcl_fromHead'.
format(self.s_err))
else:
self.pswcl = _pswcl
else:
self._add_quest(self.user)
except Exception as ex:
self._init_err(ex, self.s_err_serv)
def _initData_quest(self):
try:
row_cl = AdvUser.objects.filter(user=self.user_quest)
if row_cl.exists():
row_cl = row_cl.first()
advuser = row_cl.user.advuser
advData = json.loads(advuser.advData)
_pswcl = Res_proc.FN_get_val_dict(advData, 'pswcl')
if _pswcl is None:
_pswcl = generate_pswcl()
if _pswcl:
self._upd_quest(row_cl, dict(pswcl=_pswcl))
else:
raise ErrorRun_impl(
'{0} pswcl не определен из advuser.forms.Base_profilForm.generate_pswcl'
.format(self.s_err))
else:
self.pswcl = _pswcl
else:
self._add_quest(self.user_quest)
except Exception as ex:
self._init_err(ex, self.s_err_serv)
def PM_run_raise(s_arg, showMes=None):
""" Обработчик исключения в структуре кода
s_arg сообщение исключения
showMes=True -> сообщение будет использовано для браузера
showMEs=False -> ErrorRun_impl данные будут записаны в журнал
через цепочку присвоения res_proc.error=ErrorRun_impl -> TypeError_system(value)
поэтому s_arg д/быть сформирован с учетом формата сообщПомещяемых в *.log
"""
from app import ErrorRun_impl
s_err = 'встраиваемый шаблон'
if showMes:
raise ErrorRun_impl('verify##{0}'.format(s_arg))
else:
raise ErrorRun_impl('{0} {1}'.format(s_err, s_arg))
def _run_raise(cls, s_arg, showMes=None, s_err=None):
"""s_arg строка сообщения исключения из кода
showMes=Falst/True идентификатор отображения в браузере
если True остальные аргументы игнорируются
в браузере отображается информация s_arg
------------------------------------------------------------------
s_err базовая строка к которой добавляется дополнительные данные
используется для перекрытия шаблона cls._s_err
"""
s_err = s_err or cls._s_err
if showMes:
raise ErrorRun_impl(f'verify##{s_arg}')
else:
s_mes = '{0} {1}'.format(s_err, s_arg)
TypeError_system(
ErrorRun_impl(s_mes)) # запись в файл app/loggin/*.log
raise ErrorRun_impl(s_mes)
def PM_write_except_into_log(arg_mes, arg_except):
""" Процедура на уровне модуля app.com_serv_dbase.serv_modf_profil
Запись текста исключения в журнал *.log
----------------------------------------------------------------
arg_mes базовая строка для конфигурирования строки журнала *.log
arg_except строка детализации сообщения """
from app import TypeError_system, ErrorRun_impl
""" тип и уровень сообщения определяется в arg_mes: verify, ValueError, SyntaxError, ...
на пример: SyntaxError##текст сообщения исключения """
s_mes = '{0} {1}'.format(arg_mes, arg_except)
TypeError_system(ErrorRun_impl(s_mes)) # запись в файл app/loggin/*.log
def __init__(self, arg_user):
self.user_quest = None
self.pswcl = None
self.error = None
self.user_quest = getUser(arg_user)
if self.user_quest is None:
raise ErrorRun_impl('{0} arg_user не инициализированы'.format(
self.s_err))
self._initData_quest()
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
def get_data_parentuser(cls, arg_user):
res_dict = {}
try:
user = getUser(arg_user)
if user is None:
raise ErrorRun_impl(
'NotData##advuser.Type_status_user arg_user: нет данных '
)
_status = Com_proc_sprstatus.getStatus_or_None(user)
if _status is None:
raise ErrorRun_impl(
'NotData##advuser.Type_status_user: нет статуса')
res_dict = dict(full_name=user.get_full_name(),
strIdent=_status.strIdent)
except Exception as ex:
TypeError_system(ex)
raise ex
return res_dict
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
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
def serv_SprStatus(arg_proc, arg_param=None, **kwargs):
""" Процедура-диспетчер обработки сервиса
arg_proc стрИдентиф процедуры из Com_proc_sprstatus
arg_dict_param dict параметров:
key - идентифПараметра
val - значениеПараметра """
if not hasattr(Com_proc_sprstatus, arg_proc):
raise ErrorRun_impl(
'NotData##advuser.serv_sprstatus.serv_SprStatus arg_param не найдена процедура в Com_proc_sprstatus'
)
proc = getattr(Com_proc_sprstatus, arg_proc)
return proc(arg_param, **kwargs)
def __init__(self, argObj, argDict):
self.username = None
self.obj_model = argObj # задумано для инициализации модели
self.ext_dict = Ext_dict(argDict)
self.list_fieldsModel = argDict.get('list_fieldsModel')
if not self.list_fieldsModel:
raise ErrorRun_impl(
'ValueError##Init_model.__init__: argDict[list_fieldsModel] нет данных'
)
s_type = type(argObj).__name__
if s_type == 'User': self.username = argObj.username
if s_type == 'AdvUser': self.username = argObj.user.username
self._init_field_from_dict()
if isinstance(self.obj_model, AdvUser):
self._init_advdata()
def __init__(self, arg_user):
self.user = None
self.logincl_user = None
self.pswcl_user = None
self.logincl = None
self.pswcl = None
self.error = None
self.user = getUser(arg_user)
if self.user is None:
raise ErrorRun_impl('{0} arg_user не инициализированы'.format(
self.s_err))
self._ver_exists_quest()
if self.error is None:
self._verify_user()
def _init_field_from_dict(self):
from .serv_sprstatus import Com_proc_sprstatus
_getVal = self.ext_dict.get_val
for key in self.list_fieldsModel:
if key == 'username': continue
if not hasattr(self.obj_model, key): continue
if key == 'status_id':
_id = _getVal(key)
if not _id: continue
_spr = Com_proc_sprstatus.getStatus_or_None(_id)
if _spr:
"""
Это заполнение используется при обновлении,
но при новой записи этот идентификатор None
поэтому заполнение поля status делается в условии
"""
setattr(self.obj_model, 'status', _spr)
continue
else:
raise ErrorRun_impl(
'ValueError##Init_model._init_field_from_dict: status={0} не определен'
.format(_id))
if key == 'sendMes':
_val = True if _getVal('sendMes') == 'true' else False
setattr(self.obj_model, key, _val)
continue
val = _getVal(key)
if val:
_val = None if val == 'empty' else val
setattr(self.obj_model, key, _val)
def _upd_quest(self, row_cl, arg_dict, updUser=None):
try:
FM_init_advData(row_cl, arg_dict)
row_cl.save()
advData = AdvUser.get_advData(row_cl.user)
if advData is None:
raise ErrorRun_impl(
'{0}._upd_quest advData не определено'.format(self.s_err))
if updUser:
self.logincl_user = Res_proc.FN_get_val_dict(
advData, 'logincl')
self.pswcl_user = Res_proc.FN_get_val_dict(advData, 'pswcl')
else:
self.logincl = Res_proc.FN_get_val_dict(advData, 'username')
self.pswcl = Res_proc.FN_get_val_dict(advData, 'pswcl')
except Exception as ex:
self._init_err(ex, self.s_err_serv)
def _init_advdata(self):
from app import Ext_dict
_status = self.obj_model.status
# это исходный шаблон
tmp_dict = spr_fields_models.get_list_fields_advDataExt(_status)
if tmp_dict is None:
raise ErrorRun_impl(
'ValueError##modify_models.Init_model._init_advdata _status: None стр.67'
)
# шаблон заполненный по данным предОбработки
_advData = AdvUser.get_advData(self.username)
if _advData:
# обновление tmp_dict исходными значениями
Ext_dict.modifyTmplDict_byExt_dict(tmp_dict, _advData)
# logincl and pswcl в форме не заполняются, поэтому загружаются из предОбработки
# наложение данных, полученных из заполнения формы
self.ext_dict.modifyExtDict_bySelf_dict(tmp_dict)
s_advdata = json.dumps(tmp_dict, ensure_ascii=False)
self.obj_model.advData = s_advdata
def run_raise(s_arg):
s_err = 'ResError##advuser.modify_serv.resubm_parentuser'
raise ErrorRun_impl('{0} {1}'.format(s_err, s_arg))
def _write_except_into_log(cls, arg_except):
s_mes = '{0} {1}'.format(cls._s_err, arg_except)
TypeError_system(
ErrorRun_impl(s_mes)) # запись в файл app/loggin/*.log
def get_profil_user(cls, user):
""" Создание dict профиля """
from app import Ext_dict
from .serv_sprstatus import Com_proc_sprstatus
structDef = Struct_default_AdvUser
res_proc = Res_proc()
s_err = 'get_profil_user'
try:
user = getUser(user)
if user is None:
raise ErrorRun_impl(
'{0} нет данных для аргумента user'.format(s_err))
res_proc.any_str = user.username
type_status = type_status_user(user)
res_proc.res_obj = type_status
"""
imgphoto = self.imgphoto,
full_name = self.full_name,
status = self.status,
idcomp = self.idcomp
"""
if user.is_superuser:
param = dict(
imgphoto=cls.get_path_photo(user),
full_name='Супер-пользоатель',
status=Com_proc_sprstatus.get_status_suadm().strIdent,
idcomp=structDef.idcomp)
_dict = dict(btn_upd=False, param=param, prof=[])
res_proc.res_dict = _dict
res_proc.res = True
return res_proc
# возврат нулевого статуса
if not type_status:
param = dict(
imgphoto=cls.get_path_photo('suadm'),
full_name='Пользователь не определен',
status=Com_proc_sprstatus.get_status_notstatus().strIdent,
idcomp=structDef.idcomp)
_dict = dict(btn_upd=False, param=param, prof=[])
res_proc.res_obj.levelperm = 20 # чтобы отображение стало как у клиента
res_proc.res_dict = _dict
res_proc.res = True
return res_proc
# ------------- обработка данных профиля -----------------
status_strIdent = type_status.strIdent # structDef.conv_status_into_str(type_status.statusID)
dict_head = cls.get_dataHeader()
dict_cons = cls.get_dataCons(user)
dict_user = cls.get_advData(user)
dict_user['sendMes'] = structDef.conv_send_mes(
dict_user.get('sendMes'))
if dict_cons is None:
dict_cont = dict_head
Ext_dict.CL_modify_empty(dict_head)
Ext_dict.CL_modify_empty(dict_cons)
Ext_dict.CL_modify_empty(dict_user)
param = dict(imgphoto=cls.get_path_photo(user),
full_name=dict_user.get('full_name'),
status=status_strIdent,
idcomp=dict_user.get('idcomp') or structDef.idcomp)
arrayProf = [dict(val=user.username, str='Логин:')]
if type_status.levelperm < 30:
arrayProf += [dict(val=dict_user.get('pswcl'), str='Пароль:')]
# Обработка гостВхода
if type_status.levelperm < 20: # гостевой вход или клиент сайта
arrayProf += [
dict(val=dict_cons.get('full_name') or structDef.full_name,
str='Личн. консультант:',
idrow='parentData'),
dict(val=dict_cons.get('phone') or structDef.phone,
str='Тел. личн. консультанта:')
]
arrayProf += [
dict(val=dict_head.get('full_name') or structDef.full_name,
str='Админ. проекта:',
idrow='parentData'),
dict(val=dict_head.get('phone') or structDef.phone,
str='Телефон адмПроекта:')
]
else: # структура профиля для менеджеров и рукГрупп
arrayProf += [
dict(val=dict_user.get('phone') or structDef.phone,
str='Телефон:'),
dict(val=dict_user.get('email') or structDef.email,
str='email:'),
dict(val=dict_user.get('sendMes'), str='Получать сообщ.:'),
dict(val=dict_user.get('ageGroup') or structDef.ageGroup,
str='ВозрГруппа:'),
dict(val=structDef.conv_pol(dict_user.get('pol')),
str='Пол:'),
]
if type_status.levelperm > 20:
arrayProf += [
dict(val=dict_user.get('pswcl') or structDef.pswcl,
str='Пароль клиента:',
idrow='parentData'),
dict(val=dict_user.get('logincl') or structDef.logincl,
str='Логин клиента:')
]
if type_status.levelperm < 100:
arrayProf += [
dict(val=dict_cons.get('full_name')
or structDef.full_name,
str='Консультант:',
idrow='parentData'),
dict(val=dict_cons.get('phone') or structDef.phone,
str='Тел. консультанта:'),
dict(val=dict_cons.get('email') or structDef.email,
str='email консультанта:')
]
if type_status.levelperm in (40, 70):
if type_status.levelperm == 40:
arrayProf += [
dict(val=dict_user.get('limitcon')
or structDef.limitcon,
str='Лимит подкл.:')
]
else:
arrayProf += [
dict(val=dict_user.get('limitcon')
or structDef.limitcon,
str='Лимит подкл.:'),
dict(val=dict_user.get('limitcon40')
or structDef.limitcon,
str='Подкл. рукГр:'),
dict(val=dict_user.get('limitcon70')
or structDef.limitcon,
str='Подкл. максУровень:')
]
res_proc.res_dict = dict(btn_upd=True, param=param, prof=arrayProf)
res_proc.res = True
return res_proc
except Exception as ex:
res_proc.error = ex
return res_proc
def upd_pswcl(arg_head):
# встроенная процедура обновления advData
def upd_advData(row, pswcl):
advData = json.loads(row.advData)
advData['pswcl'] = pswcl
row.advData = json.dumps(advData, ensure_ascii=False)
# --------------------------------------------------------
res_proc = Res_proc()
res_lst = []
res_proc.res_list = res_lst
s_resError = 'ResError##advuser.modify_serv.Upd_pswcl_in_dependData.upd_pswcl:'
s_notData = 'NotData##advuser.modify_serv.Upd_pswcl_in_dependData.upd_pswcl:'
try:
# --------------- верификация и инициализация ---------------
# --------- поля log_modf_models: id_log, row_parent, id_parent, id_end, inf_modf, arg_modf
# для удобства отображения кода
if 1 < 2:
# базовые параметры обновленя
empty_key = getEMTPY_id(
15) # empty идентификатор for: id_log and row_parent
word_pswcl = None # новый пароль гостВхода
user_head = getUser(arg_head)
if user_head is None:
res_lst.append('нет данных по аргументу user_head')
raise ErrorRun_impl(
'{0} нет данных по аргументу user_head'.format(
s_notData))
type_status = type_status_user(user_head)
if not type_status:
raise ErrorRun_impl('{0} {1} нет статуса'.format(
s_notData, user_head.username))
if type_status.levelperm < 40 or type_status.levelperm > 100:
res_lst.append('Нет прав на обработку')
raise ErrorRun_impl(
'{0} нет прав на обработку'.format(s_resError))
res_pswcl = spr_pswcl.get_rand_pswcl()
if res_pswcl:
word_pswcl = res_pswcl.res_obj[0]
else:
raise ErrorRun_impl(
'{0} ошибка вызываемой процедуры'.format(s_resError))
# ********************* конец блока верификации и инициализации *****************
_row_parent = '{0}##{1}'.format(empty_key, user_head.username)
# вставить базовую запись рукГруппы
if not log_modf_models.objects.filter(
row_parent=_row_parent).exists():
log_modf_models.objects.create(
id_log=_row_parent,
row_parent=_row_parent,
arg_modf=word_pswcl,
id_parent=True,
inf_modf='пароль гостВхода рукГруппы:' +
user_head.username)
# Создание дочерних записей - пользователей рукГруппы
for row in AdvUser.objects.filter(
parentuser=user_head,
status__levelperm__gte=10,
status__levelperm__lt=40).exclude(
status__levelperm=20):
_username = row.user.username
id_log = '{0}##{1}'.format(_row_parent, _username)
if not log_modf_models.objects.filter(
id_log=id_log).exists():
log_modf_models.objects.create(
id_log=id_log,
row_parent=_row_parent,
arg_modf=word_pswcl,
inf_modf='пароль гостВхода user:'******'##')[1]
else:
_login = row_log.id_log.split('##')[2]
pswcl = row_log.arg_modf
row_cl_advuser = AdvUser.objects.filter(
parentuser=_login, status__levelperm=10)
if row_cl_advuser.exists():
row_cl_advuser = row_cl_advuser.first()
head_advuser = AdvUser.get_advUser(_login)
upd_advData(row_cl_advuser,
pswcl) # обновление advData клиента
upd_advData(head_advuser,
pswcl) # обновление advData наставника
user_cl = getUser(row_cl_advuser.user)
user_cl.set_password(pswcl)
user_cl.save() # сохранение пароля
head_advuser.save(
) # сохранение head_advuser.advData
row_cl_advuser.save(
) # сохранение row_cl_advuser.advData
res_lst.append('{0} pswcl:{1} обновлено; '.format(
_login, pswcl))
res_proc.res = True
except Exception as ex:
res_lst.append('Сервер остановил обработку')
res_proc.error = ex
return res_proc