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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
def servAdvUser_get_advUser(arg_user):
from .models import AdvUser
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)
#-----------------------------------------------------------------
res_proc = Res_proc()
try:
_user = getUser(arg_user)
if _user is None:
_run_raise(s_arg='Пользователь не определен User')
row = AdvUser.objects.filter(user=_user)
if row.exists():
res_proc.res_model = row.first()
res_proc.res = True
else:
_run_raise(s_arg='Нет данных AdvUser')
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 save_data_status(self, arg_head, arg_session) -> Res_proc:
""" Процедура на уровне class -> сохранение изменений status_id/limitcon
вызывается из views.UpdStatus_user url:updpermuser
"""
# Структура arg_session
#lst_lvperm = lst_lvperm,
#s_limit=s_limit,
#upd_username=dc_datauser['username'],
#upd_full_name=dc_datauser['full_name'],
#upd_status=type_status.strIdent
res_proc = Res_proc()
try:
dc_clean = self.cleaned_data
user_head = getUser(arg_head)
user_modf = getUser(arg_session['upd_username'])
status_head = type_status_user(user_head)
levelperm_sel = dc_clean['status'].levelperm
levelperm_head = status_head.levelperm
levelperm_user_base = type_status_user(user_modf).levelperm
# Предварительное заполнение dict for update model advUser
status_id = dc_clean['status'].pk
dc_servproc = dict(user_modf=user_modf.username,
status_id=status_id,
status=status_id)
js_struct = Com_proc_advuser.get_js_struct(user_modf)
self.clear_data_status(
js_struct) # Удаление всех данных, связанных со status.*
if levelperm_sel < 30:
if js_struct.get('pswcl'): del js_struct['pswcl']
if js_struct.get('logincl'): del js_struct['logincl']
# Блок подготовки данных для сохранения изменений в БД
if levelperm_sel < levelperm_user_base: # Понижение привелигий
user_head70 = Com_proc_advuser.get_head70_user(
user_modf).username
if levelperm_sel == 40:
js_struct['limitcon'] = dc_clean['limitcon30']
lst = [70, 40]
elif levelperm_sel in (20, 30):
if levelperm_sel == 30:
lst = [70, 40, 30]
else:
lst = [70, 40, 30, 20, 10]
dc_servproc['js_struct'] = js_struct
dc_servproc['lst'] = lst
dc_servproc[
'user_head'] = user_head70 # рукГруппы на кого переводить структуру
res_proc = self.save_status_resume_into_db(dc_servproc)
# ---------- Конец контента обработки понижения статуса
# блок обработки повышения статуса или только изменение параметров status.*
if levelperm_sel > levelperm_user_base or levelperm_sel == levelperm_user_base:
if levelperm_sel == 40:
js_struct['limitcon'] = dc_clean['limitcon30']
elif levelperm_sel == 70:
js_struct.update(
dict(
limitcon=dc_clean['limitcon'],
limitcon40=dc_clean['limitcon40'],
limitcon70=dc_clean.get('limitcon70') or 0,
user_head=user_head.
username # рукГруппы проводивший изменения профиля
))
#dc_servproc['advData'] = advData
dc_servproc['js_struct'] = js_struct
# Обновление данных через сервис django
res_sp = self.save_status_into_db(dc_servproc, user_modf)
if not res_sp:
res_proc.error = res_sp.error
res_proc.res = True
res_proc.res_dict = dict(
mes='Обновлен статус',
data_mes=f'Статус {user_modf} обновлен ')
except Exception as ex:
res_proc.error = ex
return res_proc
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 get_list_prof_memb(arg_user, arg_list=None, num_rows=5, sel_page=1):
""" Создание списка данных для отображения в шаблоне prof_table_format
Предназначено для руководителей групп
Загрузка данных из БД
arg_list формат '30,49,70' строка levelperm
num_rows кол-во записей в одной странице
sel_page номер извлекаемой страницы
full_show Использование максимальной ширины данных
"""
from .serv_advuser import Struct_default_AdvUser as Struct_def
from app.com_serv_dbase.serv_modf_profil import serv_get_data_prof
import json
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))
#---------------------------------------------------------
res_proc = Res_proc()
res_list = []
if arg_list is None:
arg_list = '30,40,70'
try:
user = getUser(arg_user)
if user is None:
run_raise('Пользователь не определен', True)
res_data = serv_get_data_prof(user,
arg_list,
num_rows,
sel_page,
num_count=0)
res_page = {}
for item in res_data.res_list:
_dict = json.loads(item['advData'])
levelperm = item['levelperm']
if levelperm == 0:
res_page = _dict
else:
_dict['levelperm'] = levelperm
_dict['status'] = Struct_def.conv_status_into_str(
_dict.get('status_id'))
_dict['idcomp'] = res_proc.FN_get_val_dict(
_dict, 'idcomp') or Struct_def.idcomp
_dict['email'] = res_proc.FN_get_val_dict(
_dict, 'email') or Struct_def.email
_dict['phone'] = res_proc.FN_get_val_dict(
_dict, 'phone') or Struct_def.phone
_dict['pol'] = Struct_def.conv_pol(_dict.get('pol'))
_dict['sendMes'] = Struct_def.conv_send_mes(
_dict.get('sendMes'))
_dict['ageGroup'] = res_proc.FN_get_val_dict(
_dict, 'ageGroup') or Struct_def.ageGroup
_dict['post'] = res_proc.FN_get_val_dict(_dict,
'post') or 'Нет'
_dict['logincl'] = res_proc.FN_get_val_dict(_dict,
'logincl') or 'Нет'
if levelperm > 30:
_dict[
'status_perm'] = f'Мендж:{_dict.get("limitcon") or 0} '
if levelperm == 70:
_dict[
'status_perm'] = f'Мендж:{_dict.get("limitcon") or 0} РукГр:{_dict.get("limitcon40") or 0} РукГрРасш:{_dict.get("limitcon70") or 0}'
else:
_dict['status_perm'] = 'Не назначено'
res_list.append(_dict)
res_proc.res_dict = res_page # сведения пагинатора
res_proc.res_list = res_list
res_proc.res = True
except Exception as ex:
res_proc.error = ex
return res_proc
def get_dictData_init_Form(user_head, user_modf):
""" Процедура выборки данных для редактирования профиля
рукГруппы
"""
from .serv_typestatus import type_status_user
from .serv_advuser import Com_proc_advuser
res_proc = Res_proc(res=False)
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))
# -------------------------------------------------------
try:
# ----------------- инициализация базовых параметров -------------------
user_head = getUser(user_head)
user_modf = getUser(user_modf)
if user_head is None or user_modf is None:
run_raise('user_head or user_modf is None')
if user_modf.is_superuser:
run_raise('Профиль суперПользователя не меняется', True)
if user_modf.username == user_head.username:
run_raise('Свой профиль изменяется из панели Профиль', True)
# ------------- Конец блока инициализации базовых параметров -------------
type_status_modf = type_status_user(user_modf)
if not type_status_modf:
run_raise('ошибка из advuser.models.Type_status_userExt(user_modf')
type_status_head = type_status_user(user_head)
if not type_status_head:
run_raise('ошибка из advuser.models.Type_status_userExt(user_head')
# Профиль изменяется пользователями со статусом subheader, headerexp, proj-head,
if type_status_modf.levelperm in (10, 20):
run_raise('Профиль гостевого входа не меняется', True)
if type_status_modf.levelperm == 100:
run_raise(
'Изменение проводятся из панели Профиль под учетной записью рукПроекта',
True)
if type_status_head.levelperm < 40:
run_raise('Нет прав на изменение профиля', True)
# выборочная верификация прав
levelperm_modf = type_status_modf.levelperm
levelperm_head = type_status_head.levelperm
if levelperm_head == 40 and levelperm_modf >= 40:
run_raise('Нет прав на изменение профиля рукГруппы', True)
#if levelperm_head == 70 and levelperm_modf > 69:
# run_raise('Нет прав на изменение профиля супер рукГруппы', True)
# Загрузка данных из user_head.advuser.advData
advData = Com_proc_advuser.get_advData(user_modf)
if not advData:
run_raise('Нет данных для профиля. Обратитесь к рукГруппы', True)
for key, val in advData.items():
if val == res_proc.PR_empty:
advData[key] = None
res_proc.res = True
res_proc.res_dict = advData
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
def restor_data_quest(arg_user):
from .models import AdvUser
from .forms import Base_profForm as profForm
res_proc = Res_proc()
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))
# ------------------------------------------------------------
try:
logincl = None
pswcl = None
_user = getUser(arg_user)
if _user is None:
run_raise('arg_user не определен как User')
# Поиск последней записи гостВхода
advUser_cl = AdvUser.objects.filter(parentuser=_user.username,
status__levelperm=10)
if advUser_cl.exists():
# запись гостВхода найдена -> выборка значений logincl and pswcl
advUser_cl = advUser_cl.last()
advData_cl = json.loads(advUser_cl.advData)
logincl = advUser_cl.user.username
pswcl = advData_cl.get('pswcl')
if pswcl is None:
# Обновление pswcl гостВхода
res_upd_pswcl = upd_pswcl_quest(logincl)
if not res_upd_pswcl:
run_raise('ошибка обновления pswcl из upd_pswcl_quest')
pswcl = res_upd_pswcl.any_str
_dict = dict(logincl=logincl, pswcl=pswcl)
# Обновление advData
advUser_user = AdvUser.get_advUser(_user)
if not advUser_user:
run_raise('нет данных для advuser ' + _user.username)
FM_init_advData(advUser_user, _dict)
advUser_user.save()
res_proc.res_dict = _dict
res_proc.res = True
else: # продолжение, если запись гостВхода не найдена
res_templ = profForm.create_templDict_qust(_user)
if not res_templ:
run_raise('шаблон templDict_quest не создан')
dict_templ = res_templ.res_dict
_dict = dict(logincl=dict_templ['username'],
pswcl=dict_templ['pswcl'])
advUser_user = AdvUser.get_advUser(_user)
if not advUser_user:
run_raise('Нет данных advuser для ' + _user.username)
# Обновление advData
FM_init_advData(advUser_user, _dict)
with transaction.atomic():
advUser_user.save()
res_addProf = profForm.addProfilUser(dict_templ)
if not res_addProf:
run_raise(
'сбой сохранения пакета advUser_user and addProfUser')
res_proc.res_dict = _dict
res_proc.res = True
except Exception as ex:
res_proc.error = ex
return res_proc
