def __init__(self, arg_model, arg_file=None):
s_type = ('User', 'str', 'int')
if type(arg_model).__name__ in s_type:
if s_type == 'User':
self.model = arg_model
else:
arg_model = getUser(arg_model)
if not arg_model:
raise TypeError(
'InitDict_fromUser.__init__ arg_model: не данных')
else:
raise TypeError(
'InitDict_fromUser.__init__ arg_model: не соответствие типа')
if not arg_model:
raise TypeError(
'InitDict_fromUser.__init__ arg_model: arg_mode не определен')
super().__init__(arg_model, arg_file)
self._conv_into_dict()
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 get_limit_used(self, arg_levelperm_sel: int):
""" Используется для clean
Определяет разницу введенных значений по отношению к введенных в БД
"""
from collections import namedtuple
from app.models import spr_fields_models as fields
import sys
from .serv_sprstatus import Com_proc_sprstatus
user_head = self.PR_dc_param_verf.user_head # dc_cleaned['user_head']
user_modf = self.PR_dc_param_verf.user_modf # dc_cleaned['user_modf']
user = getUser(user_modf)
dc_status = Com_proc_sprstatus.get_list_levelperm()
dc_status = dc_status.res_list # Список dict используемых status.levelperm
limit_max = sys.maxsize
dc_cleaned = self.cleaned_data
# Локальный процедурный контент
def loc_get_status(arg_level: int) -> str:
""" Локальная функция выборки значения из dc_status """
res = [item for item in dc_status
if item['lvperm'] == arg_level][0]['status']
return res
def loc_get_used_limit(arg_level: int) -> int:
""" Локальная функция обработки использованного лимита """
status_level = [
item for item in dc_status if item['lvperm'] == arg_level
][0]['status']
row = AdvUser.objects.filter(
parentuser=user_head,
status=loc_get_status(arg_level)).exclude(pk=user)
return row.count()
# Конец блока локального процедурного контента
use_limit = namedtuple('use_limit',
'used30 limit30 used40 limit40 used70 limit70',
defaults=(0, 0, 0, 0))
res_limit = None
status_head = type_status_user(user_head)
levelperm_head = status_head.levelperm
if arg_levelperm_sel == 40:
if levelperm_head < 100:
used30 = loc_get_used_limit(30) # row.count()
limit30 = fields.get_limitcon40(40)
else:
used30 = 0
limit30 = limit_max
res_limit = use_limit(used30=used30, limit30=limit30)
if arg_levelperm_sel == 70:
if levelperm_head < 100:
dc_limit70 = fields.get_limitcon70()
dc_limit70 = dc_limit70.res_dict
used30 = loc_get_used_limit(30)
used40 = loc_get_used_limit(40)
used70 = loc_get_used_limit(70)
limit30 = dc_limit70.get('limitcon') or 0
limit40 = dc_limit70.get('limitcon40') or 0
limit70 = dc_limit70.get('limitcon70') or 0
else:
used30 = used40 = used70 = 0
limit30 = limit40 = limit70 = limit_max
res_limit = use_limit(used30=used30,
limit30=limit30,
used40=used40,
limit40=limit40,
used70=used70,
limit70=limit70)
return res_limit
def save(self, arg_user):
""" Сохранение профиля пользователя на уровне рукГруппы """
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
cd_dict = self.cleaned_data
s_error = 'advuser.form.AddProf_memberForm.save'
s_err = 'verify##'
res_proc = Res_proc()
try:
if self.errors_clean: # ошибка из процедуры clean()
run_raise(self.errors_clean, showMes=True)
user_head = getUser(arg_user)
status_head = type_status_user(user_head)
levelperm_head = status_head.levelperm
levelperm_sel = cd_dict['status'].levelperm
statusID = cd_dict['status'].pk
del cd_dict['status']
cd_dict['sendMes'] = 'true'
if levelperm_sel == 20:
run_raise(
'Профиль клиента должен создавать пользователь гостВхода',
showMes=True)
if levelperm_head < 40 or levelperm_sel > levelperm_head:
run_raise(s_err + 'Нет прав на создание профиля', showMes=True)
# Заполнение структуры js_struct
# from spr_fields_models.js_data where levelperm = levelperm_sel
js_struct = spr_fields_models.get_js_struct(levelperm_sel)
# Для рукГрупп создается новый набор свойств pswcl and logincl
if levelperm_sel < 40:
js_struct = self.com_modf_quest(
user_head, js_struct) # Заполнение pswcl logincl
else:
# Заполнение pswcl logincl новыми значениями
js_struct = self.com_modf_quest(user_head,
js_struct,
new_pswd=True)
js_struct['idcomp'] = cd_dict['idcomp']
cd_dict.update(
dict(
parentuser=user_head.username,
password=make_password(cd_dict['password']),
password_cl=make_password(js_struct['pswcl']),
full_name=cd_dict['first_name'] + ' ' +
cd_dict['last_name'],
status_id=statusID,
js_struct=js_struct,
pswcl=js_struct[
'pswcl'], # используется для инициализации questProfil
logincl=js_struct['logincl']))
res_proc = serv_add_profil(cd_dict)
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 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
def test_getStatus_or_None():
from advuser.serv_sprstatus import Com_proc_sprstatus, serv_SprStatus, getStatus_or_None
from app import getUser
try:
res = ['Testing Com_proc_sprstatus## ']
user = getUser('podg-vl')
getStatus = Com_proc_sprstatus.getStatus_or_None
res_status = getStatus_or_None(user)
if res_status:
res.append(str(res_status))
else:
res.append('Статус не определен')
# ---------- тестирование через процедуру-диспетчер ------------
# тестирование через arg_status
res_serv = serv_SprStatus('getStatus_or_None', user)
if res_serv:
res.append(res_serv.PR_strStatus)
else:
res.append('serv_SprStatus: статус не определен')
# тестирование через модель AdvUser
res_serv = serv_SprStatus('getStatus_or_None', getUser('basam').advuser)
if res_serv:
res.append('##' + res_serv.PR_strStatus+ '##')
else:
res.append('serv_SprStatus: статус не определен')
# тестирование через аргумент dict
arg = dict(username='******')
res_serv = serv_SprStatus('getStatus_or_None', **arg)
if res_serv:
res.append(res_serv.PR_strStatus)
else:
res.append('serv_SprStatus: статус не определен')
# тестирование через строковый идентификатор status_id
res_serv = serv_SprStatus('getStatus_or_None', 'proj-sadm')
if res_serv:
res.append(res_serv.PR_strStatus)
else:
res.append('serv_SprStatus: статус не определен')
# тестирование через строковый идентификатор status_id
arg = dict(statusID='proj-memb')
res_serv = serv_SprStatus('getStatus_or_None', **arg)
if res_serv:
res.append(res_serv.PR_strStatus)
else:
res.append('serv_SprStatus: статус не определен')
# тестирование выброса исключения и записи в файл *.log
arg = dict(statusID='proj-memb', username='******')
res_serv = serv_SprStatus('getStatus_or_None', user, **arg)
if res_serv:
res.append(res_serv.PR_strStatus)
else:
res.append('serv_SprStatus: статус не определен')
## тестирование приоритетности
#arg = dict(statusID='proj-memb')
#res_serv = serv_SprStatus('getStatus_or_None', 'qust-simp', **arg)
#if res_serv:
# res.append(str(res_serv))
#else:
# res.append('serv_SprStatus: статус не определен')
# тестирование приоритетности
arg = dict(statusID='proj-memb')
res_serv = serv_SprStatus('getStatus_or_None', 'qust-simp', **dict(statusID='proj-memb'))
if res_serv:
res.append(res_serv.PR_strStatus)
else:
res.append('serv_SprStatus: статус не определен')
# тестирование выбороса исключения через параметр statusID
res_serv = serv_SprStatus('getStatus_or_None', 'qust-simp_')
if res_serv:
res.append(res_serv.PR_strStatus)
else:
res.append('serv_SprStatus: статус не определен ')
#res_serv = getStatus_or_None(**dict(statusID='proj-memb'))
#if res_serv:
# res.append(str(res_serv))
#else:
# res.append('serv_SprStatus: статус не определен')
res_serv = getStatus_or_None('proj-memb')
if res_serv:
res.append('## ' + res_serv.PR_strStatus)
else:
res.append('serv_SprStatus: статус не определен')
return res
except Exception as ex:
return str(ex)
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 UpdStatus_user(request):
""" Контроллер обраотки изменений status_id
Изменения осуществляются только рукГрупп
"""
def return_render(arg_form:UpdStatus_userForm, arg_dc:dict):
""" Локальная процедура для запуска render:
arg_form: UpdStatus_userForm
arg_dc: dc_session = request.session['UpdStatus_user']
return render with cont form and dc_session """
cont = dict(form=arg_form)
cont.update(arg_dc)
return render(request,'advuser/upd_status_user.html', cont)
if not cache.has_key('UpdStatus_user'):
return redirect_empty(arg_title='Сервер отклонил обработку', arg_mes='Параметры запроса устарели')
user = cache.get('UpdStatus_user')
user = getUser(user)
if user is None:
cache.delete('UpdStatus_user')
return redirect_empty(arg_title='Сервер отклонил обработку', arg_mes='Нет данных по логину')
if request.method == 'POST':
form = UpdStatus_userForm(request.POST)
dc_session = request.session['UpdStatus_user']
# изициализация локальных полей для процедуры clear()
user_head = getUser(request.user.username)
form.dc_param_verf = form.param_verf(user_head=user_head.username,
user_modf=dc_session['upd_username'])
if form.is_valid():
user = request.user;
res_save = form.save_data_status(user, dc_session)
if res_save:
mes = res_save.res_dict['data_mes']
dict_cache = dict(username=dc_session['upd_username'], mes=mes)
cache.set('Success_register_user', dict_cache)
del request.session['UpdStatus_user']
return redirect('ver_profil') # переход на view Success_register_user
else:
return return_render(form, dc_session)
else: # сообщения из процедуры clean()
return return_render(form, dc_session)
else: # Обработка запроса GET
from .serv_sprstatus import Com_proc_sprstatus
from app.models import spr_fields_models
import json
type_status = type_status_user(user)
levelperm_user = type_status.levelperm
user_master = getUser( request.user)
type_status_master = type_status_user(user_master)
# Блок верификации
if 1 < 2 :
if type_status_master.levelperm < 40 or type_status_master.levelperm <= levelperm_user:
return redirect_empty(arg_title='Сервер отклонил обработку', arg_mes='Нет прав на обработку')
if levelperm_user < 30:
return redirect_empty(arg_title='Сервер отклонил обработку', arg_mes='Статус клиента не меняется')
if levelperm_user == 100 :
return redirect_empty(arg_title='Сервер отклонил обработку', arg_mes='Статус руководителя проекта постоянный')
parentuser = Com_proc_advuser.get_parentuser_02(user)
if parentuser.username != user_master.username:
return redirect_empty(arg_title='Сервер отклонил обработку', arg_mes='Руководитель группы может изменять профиль только своей структуры')
# Конец блока верификации
# Значение as default for levelperm== 40 кол-во менеджеров
limitcon30 = spr_fields_models.get_limitcon40(40)
# значение поля advuser.js_struct
dc_jsstruct = Com_proc_advuser.get_js_struct(user)
# значения app_spr_fields_models.js_data
dc_limit70 = spr_fields_models.get_limitcon70()
dc_limit70 = dc_limit70.res_dict
# инициализация переменных status.* для user_modf
res_dict = dict()
if levelperm_user == 40: # если уровень доступа был 40
res_dict['limitcon30'] = dc_jsstruct.get('limitcon') or 0
res_dict.update(dc_limit70 ) # значения default for levelperm=70
if levelperm_user == 70: # если уровень доступа был 70 -> максНабор данных
res_dict.update(dict(
limitcon = dc_jsstruct.get('limitcon') or 0 ,
limitcon40 = dc_jsstruct.get('limitcon40') or 0,
limitcon70 = dc_jsstruct.get('limitcon70') or 0,
limitcon30 = limitcon30 # default for levelperm=40
))
lst_lvperm = Com_proc_sprstatus.get_list_levelperm().res_list
res_dict.update( dict(lvperm=lst_lvperm ) )
s_limit = json.dumps(res_dict, ensure_ascii=True)
dc_datauser = Com_proc_advuser.get_advData(user)
dc_session = dict( 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
)
request.session['UpdStatus_user'] = dc_session
# инициализация limitcon30, limitcon,limitcon40,limitcon70
# через upd_status_user_01.js после загрузки контента html
dc_initial = dict(status=type_status.statusID)
form = UpdStatus_userForm(initial=dc_initial)
return return_render(form, dc_session)
def UpdProf_quest(request):
""" Изменение профиля клиента самим пользователем """
from .serv_advuser import type_status_user, Com_proc_advuser
user = request.user
parentuser = Com_proc_advuser.get_user_cons(user)
if parentuser is None:
return redirect_empty(arg_mes='Наставник не определен')
if request.method == 'POST':
form = Base_profForm(request.POST)
if form.is_valid():
user = getUser(request.user)
res_save = form.save_upd(user, parentuser)
if res_save: # успешное обновление
#Success_register_user заполнение cache
dict_cache = dict(username=res_save.any_str, mes=res_save.mes)
cache.set('Success_register_user', dict_cache)
return redirect('ver_profil')
else: # ошибка обработки
return render(request, 'advuser/regUser_ext.html', dict(
res=False,
parentuser=parentuser.username,
error= res_save.error,
title='Обновление профиля',
form=form
))
else: # Не прошла валидация данных
return render(request, 'advuser/regUser_ext.html', dict(
res=False,
parentuser=parentuser.username,
error='Ошибка заполнения полей формы',
title= 'Обновление профиля' ,
form=form
))
else:
# Проверка, кто делает запрос
type_status = type_status_user(user)
if not type_status:
return redirect_empty(arg_title='Статус', arg_mes='Нет данных статуса')
from .modify_models import get_dictData_init_Form_regQuest
if not (type_status.levelperm == 20):
return redirect_empty(arg_mes='Только для зарегистрированных клиентов')
dict_param = dict()
if not Com_proc_advuser.get_advData_user(user, dict_param) :
return redirect_empty(
arg_title='Отказ сервера',
arg_mes='Нет данных для обработки' )
dict_param = modf_data_dict(dict_param) # сброс значений '' or 'empty'
form = Base_profForm(initial=dict_param)
return render(request, 'advuser/regUser_ext.html', dict(
parentuser=parentuser.username,
res=True,
title='Редактор профиля',
form=form
))
def AddProf_quest(request):
""" Добавление/изм профиля клиента """
from .serv_advuser import type_status_user, Com_proc_advuser
user = request.user
parentuser = Com_proc_advuser.get_user_cons(user)
if parentuser is None:
return redirect_empty(arg_mes='Наставник не определен')
if request.method == 'POST':
form = Base_profForm(request.POST)
# dict по умолчанию для сообщений об ошибках
dc_cont_err = dict(
res=False,
parentuser=parentuser.username,
error= 'Сервер отклонил обработку. Проверьте введенные данные',
title='Создание профиля',
form=form
)
if form.is_valid():
user = getUser(request.user)
res_save = form.save_add(user)
if res_save: # успешное обновление
#Success_register_user заполнение cache
dict_cache = dict(username=res_save.any_str, mes=res_save.mes)
cache.set('Success_register_user', dict_cache)
return redirect('ver_profil')
else: # ошибка обработки
dc_cont_err.update(dict(error=res_save.error))
return render(request, 'advuser/regUser_ext.html', dc_cont_err)
return render(request, 'advuser/regUser_ext.html', dc_cont_err )
else: # Обработка создания профиля клиента
type_status = type_status_user(user)
if not type_status:
return redirect_empty(arg_title='Статус', arg_mes='Нет данных статуса')
if type_status.levelperm == 10:
form = Base_profForm()
return render(request, 'advuser/regUser_ext.html', dict(
parentuser=parentuser.username,
res=True,
error='',
title='Создание профиля',
form=form
))
else:
return redirect_empty(arg_mes='Нет прав. Только для гостевого входа')
def UpdPsw_byUser(request):
""" Изменение пароля самими пользователями """
from .serv_typestatus import type_status_user
user = getUser(request.user)
if request.method == 'POST':
form = UpdPsw_byUserForm(request.POST)
form.data_username = user.username
dc_session = request.session['UpdPsw_byUser']
if form.is_valid():
res_save = form.save(user)
if res_save:
dict_cache = dict(username=user.username, mes=res_save.mes)
cache.set('Success_register_user', dict_cache)
del request.session['UpdPsw_byUser']
return redirect('ver_profil') # переход на view Success_register_user
else:
# возврат формы на доработку и отображение сообщений об ошибках
dc_cont = dict(form=form)
dc_cont.update(dc_session)
dc_cont.update(error=res_save.error )
return render(request, 'advuser/upd_password_by_user.html', dc_cont)
else: # возврат формы на доработку
dc_cont = dict(form=form) # отображение ошибок, выявленных на уровне валидации form
dc_cont.update(dc_session)
return render(request, 'advuser/upd_password_by_user.html', dc_cont)
else: # Обработка GET запроса
type_status = type_status_user(user)
dc_cont = Com_proc_advuser.get_advData(user)
dc_session = dict(
title='Изменение пароля пользователя проекта',
upd_username=dc_cont['username'],
upd_full_name=dc_cont['full_name'],
upd_status=type_status.strIdent
)
request.session['UpdPsw_byUser'] = dc_session
dc_init = dict(dataupd=user.username)
form = UpdPsw_byUserForm(initial=dc_init)
res_cont = dict(form=form)
res_cont.update(dc_session)
return render (request, 'advuser/upd_password_by_user.html' , res_cont)
def clean(self):
import sys
super().clean()
errors = {}
# используется в clear_data_status self.PR_list_fields_status
self.list_fields_status = []
dc_cleaned = self.cleaned_data
user_head = getUser(self.PR_dc_param_verf.user_head)
user_modf = getUser(self.PR_dc_param_verf.user_modf)
status_head = type_status_user(user_head)
status_user_base = type_status_user(user_modf)
levelperm_user_base = status_user_base.levelperm
levelperm_sel = dc_cleaned['status'].levelperm
levelperm_head = status_head.levelperm
if levelperm_sel > levelperm_head:
errors['status'] = 'Статус больше допустимого'
if levelperm_sel == 40: #верификация заполнения поля limitcon30
if not dc_cleaned.get('limitcon30'):
errors['limitcon30'] = 'Укажите кол-во подключений менеджеров'
if levelperm_sel == 70: # Проверка прав
if not dc_cleaned.get('limitcon'):
errors['limitcon'] = 'Укажите кол-во подключений менеджеров'
if not dc_cleaned.get('limitcon40'):
errors['limitcon40'] = 'Укажите кол-во подключений рукГрупп'
# верификация резкого повышения/понижения levelperm
num = 1
dc_levelperm = {}
for item in (20, 30, 40, 70):
dc = {item: num}
dc_levelperm.update(dc)
num += 1
# Определение величины перехода levelperm относительно исходного значения
div = dc_levelperm[levelperm_sel] - dc_levelperm[levelperm_user_base]
if abs(div) > 1:
errors[
'status'] = 'Изменение статуса более чем на один порядок - отклонено'
# верификация на уровне levelperm
if not errors:
if levelperm_sel > 30:
if levelperm_sel == 40:
dc_limit_used40 = self.get_limit_used(40)
# Верификация введенных значений limitcon для levelperm_sel=40
if dc_limit_used40.limit30 < (dc_limit_used40.used30 +
dc_cleaned['limitcon30']):
errors['limitcon30'] = 'Превышен лимит подключений'
if levelperm_sel == 70:
# словарь типа nametuple используемых/назначенных лимитов
dc_limit_used70 = self.get_limit_used(70)
# Верификация введенных значений limitcon для levelperm_sel = 70
if dc_limit_used70.limit30 < dc_limit_used70.used30 + dc_cleaned[
'limitcon']:
errors['limitcon'] = 'Превышен лимит подключений'
if dc_limit_used70.limit40 < dc_limit_used70.used40 + dc_cleaned[
'limitcon40']:
errors['limitcon40'] = 'Превышен лимит подключений'
if dc_cleaned.get('limitcon70') and (
dc_limit_used70.limit70 <
(dc_limit_used70.used70 + dc_cleaned['limitcon70'])):
errors['limitcon70'] = 'Превышен лимит подключений'
if errors:
raise ValidationError(errors)
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 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 getUser():
return app.getUser()
