def show_users(request, *args, **kwargs):
"""Вывод пользователей админки"""
mh_vars = users_vars.copy()
mh = create_model_helper(mh_vars, request, CUR_APP, disable_fas=True)
mh.select_related_add('customuser')
context = mh.context
# -----------------------
# Фильтрация и сортировка
# -----------------------
filters_and_sorters = tabulator_filters_and_sorters(
request, custom_position_field='customuser__position')
for rfilter in filters_and_sorters['filters']:
mh.filter_add(rfilter)
for rsorter in filters_and_sorters['sorters']:
mh.order_by_add(rsorter)
context['fas'] = filters_and_sorters['params']
# -----------------------------
# Вся выборка только через аякс
# -----------------------------
if request.is_ajax():
rows = mh.standard_show()
result = []
for row in rows:
item = object_fields(row, pass_fields=('password', ))
item['actions'] = row.id
if row.customuser.phone:
item['customuser__phone'] = defiz_phone(row.customuser.phone)
item['customuser__function'] = row.customuser.function
# -------------------------------------
# OneToOneField связь User с customUser
# -------------------------------------
item['customuser'] = object_fields(row.customuser,
only_fields=('phone',
'function'))
item['thumb'] = row.customuser.thumb()
item['imagine'] = row.customuser.imagine()
item['position'] = row.customuser.position
result.append(item)
if request.GET.get('page'):
result = {
'data': result,
'last_page': mh.raw_paginator['total_pages'],
'total_records': mh.raw_paginator['total_records'],
'cur_page': mh.raw_paginator['cur_page'],
'by': mh.raw_paginator['by'],
}
return JsonResponse(result, safe=False)
context['import_xlsx_url'] = reverse('%s:%s' % (CUR_APP, 'import_xlsx'),
kwargs={'action': 'users'})
template = '%stable.html' % (mh.template_prefix, )
return render(request, template, context)
def add_photo2gallery(photo, product, context):
"""Добавить фото к товару/услугу в галерею
:param photo: ссылка или request.FILES.get('img')
:param product: Товар/услуга
:param context: результирующая информация о загрузке
"""
new_photo = ProductsPhotos.objects.create(product=product)
new_photo.upload_img(photo)
context['photo'] = object_fields(new_photo, pass_fields=('product', ))
context['photo']['folder'] = new_photo.get_folder()
context['photo']['thumb'] = new_photo.thumb()
context['photo']['imagine'] = new_photo.imagine()
if not 'row' in context:
context['row'] = object_fields(product)
context['row']['is_gallery'] = True
def show_flattooltip(request, *args, **kwargs):
"""Вывод подсказок"""
mh_vars = flattooltip_vars.copy()
mh = create_model_helper(mh_vars, request, CUR_APP)
mh.select_related_add('block')
context = mh.context
# -----------------------------
# Вся выборка только через аякс
# -----------------------------
if request.is_ajax():
rows = mh.standard_show()
result = []
for row in rows:
item = object_fields(row)
item['actions'] = row.id
item['folder'] = row.get_folder()
item['thumb'] = row.thumb()
item['imagine'] = row.imagine()
result.append(item)
if request.GET.get('page'):
result = {'data': result,
'last_page': mh.raw_paginator['total_pages'],
'total_records': mh.raw_paginator['total_records'],
'cur_page': mh.raw_paginator['cur_page'],
'by': mh.raw_paginator['by'], }
return JsonResponse(result, safe=False)
template = '%stable.html' % (mh.template_prefix, )
return render(request, template, context)
def show_dealers(request, *args, **kwargs):
"""Вывод дилеров
:param request: HttpRequest
"""
mh_vars = dealers_vars.copy()
mh = create_model_helper(mh_vars, request, CUR_APP)
mh.select_related_add('address')
context = mh.context
context['city_choices'] = Dealer.city_choices
# -----------------------------
# Вся выборка только через аякс
# -----------------------------
if request.is_ajax():
rows = mh.standard_show()
result = []
for row in rows:
item = object_fields(row)
item['actions'] = row.id
item['folder'] = row.get_folder()
item['thumb'] = row.thumb()
item['imagine'] = row.imagine()
if row.address:
item['address'] = row.address.address_str()
result.append(item)
if request.GET.get('page'):
result = {
'data': result,
'last_page': mh.raw_paginator['total_pages'],
'total_records': mh.raw_paginator['total_records'],
'cur_page': mh.raw_paginator['cur_page'],
'by': mh.raw_paginator['by'],
}
return JsonResponse(result, safe=False)
template = '%stable.html' % (mh.template_prefix, )
return render(request, template, context)
def show_pickup_points(request, *args, **kwargs):
"""Вывод точек вывоза пользователей
:param request: HttpRequest
"""
mh_vars = pickup_points_vars.copy()
mh = create_model_helper(mh_vars, request, CUR_APP)
mh.select_related_add('shopper')
mh.select_related_add('address')
mh.select_related_add('order')
context = mh.context
# -----------------------------
# Вся выборка только через аякс
# -----------------------------
if request.is_ajax():
result = []
rows = mh.standard_show(only_fields=pp_only_fields)
for row in rows:
item = object_fields(row,
only_fields=pp_only_fields,
fk_only_keys=pp_fk_keys)
item['actions'] = row.id
result.append(item)
if request.GET.get('page'):
result = {
'data': result,
'last_page': mh.raw_paginator['total_pages'],
'total_records': mh.raw_paginator['total_records'],
'cur_page': mh.raw_paginator['cur_page'],
'by': mh.raw_paginator['by'],
}
return JsonResponse(result, safe=False)
template = '%stable.html' % (mh.template_prefix, )
return render(request, template, context)
def edit_robot(request, action: str, row_id: int = None, *args, **kwargs):
"""Создание/редактирование роботов
:param request: HttpRequest
:param action: действие над объектом (создание/редактирование/удаление)
:param row_id: ид записи
"""
mh_vars = robots_vars.copy()
mh = create_model_helper(mh_vars, request, CUR_APP, action)
row = mh.get_row(row_id)
context = mh.context
if mh.error:
return redirect('%s?error=not_found' % (mh.root_url, ))
if request.method == 'GET':
if action == 'create':
mh.breadcrumbs_add({
'link': mh.url_create,
'name': '%s %s' % (mh.action_create, mh.rp_singular_obj),
})
elif action == 'edit' and row:
mh.breadcrumbs_add({
'link': mh.url_edit,
'name': '%s %s' % (mh.action_edit, mh.rp_singular_obj),
})
elif action == 'drop' and row:
if mh.permissions['drop']:
row.delete()
mh.row = None
context['success'] = '%s удален' % (mh.singular_obj, )
else:
context['error'] = 'Недостаточно прав'
elif request.method == 'POST':
pass_fields = ()
mh.post_vars(pass_fields=pass_fields)
if action == 'create' or (action == 'edit' and row):
if action == 'create':
if mh.permissions['create']:
mh.row = mh.model()
mh.save_row()
context['success'] = 'Данные успешно записаны'
else:
context['error'] = 'Недостаточно прав'
if action == 'edit':
if mh.permissions['edit']:
mh.save_row()
context['success'] = 'Данные успешно записаны'
else:
context['error'] = 'Недостаточно прав'
elif action == 'img' and request.FILES:
mh.uploads()
if mh.row:
context['row'] = object_fields(mh.row, pass_fields=('password', ))
context['row']['folder'] = mh.row.get_folder()
context['row']['thumb'] = mh.row.thumb()
context['row']['imagine'] = mh.row.imagine()
context['redirect'] = mh.get_url_edit()
if request.is_ajax() or action == 'img':
return JsonResponse(context, safe=False)
template = '%sedit.html' % (mh.template_prefix, )
return render(request, template, context)
def show_seances(request, *args, **kwargs):
"""Вывод сеансов для Афиши"""
mh_vars = seances_vars.copy()
mh = create_model_helper(mh_vars, request, CUR_APP)
mh.select_related_add('place')
mh.select_related_add('event')
context = mh.context
# -----------------------------
# Вся выборка только через аякс
# -----------------------------
if request.is_ajax():
rows = mh.standard_show()
result = []
for row in rows:
item = object_fields(row)
item['actions'] = row.id
item['folder'] = row.get_folder()
if row.place:
item['place__name'] = row.place.name
if row.event:
item['event__name'] = row.event.name
result.append(item)
if request.GET.get('page'):
result = {
'data': result,
'last_page': mh.raw_paginator['total_pages'],
'total_records': mh.raw_paginator['total_records'],
'cur_page': mh.raw_paginator['cur_page'],
'by': mh.raw_paginator['by'],
}
return JsonResponse(result, safe=False)
template = '%stable.html' % (mh.template_prefix, )
return render(request, template, context)
def show_email_accounts(request, *args, **kwargs):
"""Вывод Email аккаунтов"""
mh_vars = email_accounts_vars.copy()
mh = create_model_helper(mh_vars, request, CUR_APP)
mh.breadcrumbs.insert(0, root_breadcrumbs)
context = mh.context
# -----------------------------
# Вся выборка только через аякс
# -----------------------------
if request.is_ajax():
rows = mh.standard_show()
result = []
for row in rows:
item = object_fields(row)
item['actions'] = row.id
item['folder'] = row.get_folder()
item['thumb'] = row.thumb()
item['imagine'] = row.imagine()
result.append(item)
if request.GET.get('page'):
result = {
'data': result,
'last_page': mh.raw_paginator['total_pages'],
'total_records': mh.raw_paginator['total_records'],
'cur_page': mh.raw_paginator['cur_page'],
'by': mh.raw_paginator['by'],
}
return JsonResponse(result, safe=False)
context['import_xlsx_url'] = reverse('%s:%s' % (CUR_APP, 'import_xlsx'),
kwargs={'action': 'email_accounts'})
template = '%stable.html' % (mh.template_prefix, )
return render(request, template, context)
def show_black_list(request, *args, **kwargs):
"""Вывод Черного списка emails"""
mh_vars = black_list_vars.copy()
mh = create_model_helper(mh_vars, request, CUR_APP)
mh.breadcrumbs.insert(0, root_breadcrumbs)
context = mh.context
# -----------------------------
# Вся выборка только через аякс
# -----------------------------
if request.is_ajax():
rows = mh.standard_show()
result = []
for row in rows:
item = object_fields(row)
item['actions'] = row.id
item['folder'] = row.get_folder()
item['thumb'] = row.thumb()
item['imagine'] = row.imagine()
result.append(item)
if request.GET.get('page'):
result = {
'data': result,
'last_page': mh.raw_paginator['total_pages'],
'total_records': mh.raw_paginator['total_records'],
'cur_page': mh.raw_paginator['cur_page'],
'by': mh.raw_paginator['by'],
}
return JsonResponse(result, safe=False)
template = '%stable.html' % (mh.template_prefix, )
return render(request, template, context)
def show_holding_kss(request, *args, **kwargs):
"""Вывод проведений КСС"""
mh_vars = holding_kss_vars.copy()
mh = create_model_helper(mh_vars, request, CUR_APP)
mh.select_related_add('welder')
mh.select_related_add('welder__subject')
mh.select_related_add('certification')
context = mh.context
context['insert_breadcrumbs'] = insert_breadcrumbs
context['welding_types'] = WELDING_TYPES
context['materials'] = MATERIALS
context['group_choices'] = CertSections.group_choices
# -----------------------------
# Вся выборка только через аякс
# -----------------------------
if request.is_ajax():
rows = mh.standard_show()
result = []
ids_certs = {
row.certification.id: []
for row in rows if row.certification
}
# Вытаскиваем группы для удостоверений
cert_sections = CertSections.objects.filter(
certification__in=ids_certs.keys()).values('certification',
'group', 'points')
for cert_section in cert_sections:
ids_certs[cert_section['certification']].append(cert_section)
for row in rows:
item = object_fields(row)
item['sections'] = []
if row.certification:
item['sections'] = ids_certs.get(row.certification.id, [])
welding_view = 'ТТ'
with_tt = False
with_mk = False
for section in item['sections']:
if section['group'] == 12:
with_mk = True
else:
with_tt = True
if with_mk:
welding_view = 'МК'
if with_mk and with_tt:
welding_view = 'ТТ/МК'
item['certification__certsections__group'] = welding_view
item['actions'] = row.id
result.append(item)
if request.GET.get('page'):
result = {
'data': result,
'last_page': mh.raw_paginator['total_pages'],
'total_records': mh.raw_paginator['total_records'],
'cur_page': mh.raw_paginator['cur_page'],
'by': mh.raw_paginator['by'],
}
return JsonResponse(result, safe=False)
template = '%stable.html' % (mh.template_prefix, )
return render(request, template, context)
def api(request, action: str = 'users'):
"""Апи-метод для получения всех данных"""
mh_vars = users_vars.copy()
#if action == 'users':
# mh_vars = users_vars.copy()
mh = create_model_helper(mh_vars, request, CUR_APP)
# Принудительные права на просмотр
#mh.permissions['view'] = True
mh.select_related_add('customuser')
context = mh.context
rows = mh.standard_show()
result = []
for row in rows:
item = object_fields(row, pass_fields=('password', ))
item['folder'] = row.customuser.get_folder()
item['thumb'] = row.customuser.thumb()
item['name'] = str(row.customuser)
item['phone'] = row.customuser.phone
item['function'] = row.customuser.function
result.append(item)
result = {
'data': result,
'last_page': mh.raw_paginator['total_pages'],
'total_records': mh.raw_paginator['total_records'],
'cur_page': mh.raw_paginator['cur_page'],
'by': mh.raw_paginator['by'],
}
return JsonResponse(result, safe=False)
def create_double(product):
"""Создать дубль товара/услуги
TODO: если несколько цен
:param product: Product model instance
"""
pass_fields = ('id', 'created', 'updated', 'position', 'parents', 'code')
new_product = Products()
for field in object_fields(product, pass_fields=pass_fields):
value = getattr(product, field)
setattr(new_product, field, value)
code = '%s-DOUBLE' % product.code
new_product.code = code
new_product.save()
# Изображение
if product.img:
imga = os.path.join(product.get_folder(), product.img)
if not check_path(imga):
new_imga = os.path.join(new_product.get_folder(), product.img)
copy_file(imga, new_imga)
# Галерея
gallery = ProductsPhotos.objects.filter(
product=product).order_by('position')
for photo in gallery:
imga = os.path.join(photo.get_folder(), photo.img)
if not check_path(imga):
params = {
'name': photo.name,
'product': new_product,
'img': photo.img,
}
new_photo = ProductsPhotos.objects.create(**params)
new_imga = os.path.join(new_photo.get_folder(), photo.img)
copy_file(imga, new_imga)
# Рубрики
cats = ProductsCats.objects.select_related('cat').filter(product=product)
for cat in cats:
ProductsCats.objects.create(product=new_product, cat=cat.cat)
# SEO
seo_block = product.get_seo()
if seo_block:
seo = {
'seo_title': seo_block.title,
'seo_description': seo_block.description,
'seo_keywords': seo_block.keywords,
}
new_product.fill_seo(**seo)
# Свойства товара
props = ProductsProperties.objects.select_related('prop').filter(
product=product)
for prop in props:
ProductsProperties.objects.create(product=new_product, prop=prop.prop)
return new_product
def show_groups(request, *args, **kwargs):
"""Вывод групп пользователей админки"""
mh_vars = groups_vars.copy()
mh = create_model_helper(mh_vars, request, CUR_APP)
context = mh.context
# -----------------------
# Фильтрация и сортировка
# -----------------------
filters_and_sorters = tabulator_filters_and_sorters(request)
for rfilter in filters_and_sorters['filters']:
mh.filter_add(rfilter)
for rsorter in filters_and_sorters['sorters']:
mh.order_by_add(rsorter)
context['fas'] = filters_and_sorters['params']
# -----------------------------
# Вся выборка только через аякс
# -----------------------------
if request.is_ajax():
rows = mh.standard_show()
result = []
ids_groups = {row.id: {} for row in rows}
# Достаем пользователей групп
users = User.objects.select_related('customuser').filter(
groups__in=ids_groups.keys())
for user in users:
groups = user.groups.all().values_list('id', flat=True)
for group in groups:
if not user.id in ids_groups[group]:
ids_groups[group][user.id] = '%s (%s id=%s)' % (str(
user.customuser), user.username, user.id)
for row in rows:
item = object_fields(row)
item['actions'] = row.id
item['users'] = '<br>'.join(ids_groups[row.id].values())
result.append(item)
if request.GET.get('page'):
result = {
'data': result,
'last_page': mh.raw_paginator['total_pages'],
'total_records': mh.raw_paginator['total_records'],
'cur_page': mh.raw_paginator['cur_page'],
'by': mh.raw_paginator['by'],
}
return JsonResponse(result, safe=False)
template = '%stable.html' % (mh.template_prefix, )
return render(request, template, context)
def export_templates():
"""Экспорт шаблонов"""
templates = Containers.objects.filter(state__in=(99, 100),
tag__isnull=False)
for template in templates:
make_folder('export')
path = os.path.join('export', template.tag)
make_folder(path)
if template.img:
copy_file(os.path.join(template.get_folder(), template.img),
os.path.join(path, template.img))
obj = object_fields(template)
obj['blocks'] = []
blocks = template.blocks_set.all()
blocks_path = os.path.join(path, 'blocks')
make_folder(blocks_path)
for block in blocks:
if block.img:
copy_file(os.path.join(block.get_folder(), block.img),
os.path.join(blocks_path, block.img))
obj['blocks'].append(
object_fields(block, pass_fields=('container', )))
json_path = os.path.join(path, 'template.json')
with open_file(json_path, 'w+', encoding='utf-8') as f:
f.write(json.dumps(obj))
template_fname = '%s.html' % template.tag
template_src = os.path.join(settings.BASE_DIR,
'apps/site/templates/web/containers/',
template_fname)
template_dest = os.path.join(settings.MEDIA_ROOT, path, template_fname)
if os.path.exists(template_src):
shutil.copy2(template_src, template_dest)
else:
logger.info('template not found %s' % template_src)
def get_pickup_point(request, *args, **kwargs):
"""Получение точки вывоза для пользователя
:param request: HttpRequest
"""
result = {}
shopper = get_shopper(request)
if shopper:
pickup_point = PickupPoint.objects.select_related(
'shopper', 'order', 'address').filter(order__isnull=True,
shopper=shopper).first()
if pickup_point:
result = object_fields(pickup_point,
only_fields=pp_only_fields,
fk_only_keys=pp_fk_keys)
return JsonResponse(result, safe=False)
def show_welding_joint_state(request, *args, **kwargs):
"""Вывод истории изменений статусов заявок на стыки"""
mh_vars = welding_joint_state_vars.copy()
mh = create_model_helper(mh_vars, request, CUR_APP)
mh.select_related_add('welding_joint')
mh.select_related_add('user')
mh.order_by_add('-date')
context = mh.context
context['state_choices'] = WELDING_JOINT_STATES
# -----------------------------
# Вся выборка только через аякс
# -----------------------------
if request.is_ajax():
only_fields = (
'id',
'welding_joint__request_number',
'date',
'from_state',
'to_state',
'user__username',
)
rows = mh.standard_show(only_fields=only_fields)
fk_keys = {
'welding_joint': ('request_number', ),
'user': ('username'),
}
result = []
for row in rows:
item = object_fields(
row,
only_fields=only_fields,
fk_only_keys=fk_keys,
)
item['actions'] = row.id
result.append(item)
if request.GET.get('page'):
result = {
'data': result,
'last_page': mh.raw_paginator['total_pages'],
'total_records': mh.raw_paginator['total_records'],
'cur_page': mh.raw_paginator['cur_page'],
'by': mh.raw_paginator['by'],
}
return JsonResponse(result, safe=False)
template = '%stable.html' % (mh.template_prefix, )
return render(request, template, context)
def to_dict(self):
return object_fields(self,
only_fields=(
'id',
'name',
'first_name',
'last_name',
'middle_name',
'email',
'phone',
'phone_confirmed',
'address',
'login',
'discount',
'balance',
'ip',
))
def show_cdrcsv(request, *args, **kwargs):
"""Вывод звонков"""
mh_vars = cdrcsv_vars.copy()
mh = create_model_helper(mh_vars, request, CUR_APP)
context = mh.context
# -----------------------
# Фильтрация и сортировка
# -----------------------
if not mh.filters_and_sorters['sorters']:
mh.filters_and_sorters['params']['sorters']['created'] = 'desc'
for rsorter in mh.filters_and_sorters['sorters']:
mh.order_by_add(rsorter)
cache_var_sip_codes = 'sip_codes_cache'
cache_time_sip_codes = 3600
sip_codes = cache.get(cache_var_sip_codes)
if not sip_codes:
sip_codes = CdrCsv.objects.values_list('state', flat=True).distinct()
cache.set(cache_var_sip_codes, sip_codes, cache_time_sip_codes)
context['sip_codes'] = sip_codes
# -----------------------------
# Вся выборка только через аякс
# -----------------------------
if request.is_ajax():
rows = mh.standard_show()
result = []
for row in rows:
item = object_fields(row)
#item['folder'] = row.created.strftime('%Y-%m-%d')
item['record'] = row.get_record_path()
result.append(item)
if request.GET.get('page'):
result = {
'data': result,
'last_page': mh.raw_paginator['total_pages'],
'total_records': mh.raw_paginator['total_records'],
'cur_page': mh.raw_paginator['cur_page'],
'by': mh.raw_paginator['by'],
}
return JsonResponse(result, safe=False)
template = '%stable.html' % (mh.template_prefix, )
return render(request, template, context)
def get_welding_joint_analog(joint, new_joint: dict):
"""Ищем аналог joint по словарю new_joint
:param joint: экземпляр модели WeldingJoint
:param new_joint: словарь для новой заявки на стык
"""
show_diff = False
analog = WeldingJoint.objects.filter(joint=joint).first()
if analog:
# Пишем различия
if show_diff:
print(" ### analog ### ")
analog_obj = object_fields(analog)
for key, value in analog_obj.items():
new_value = new_joint.get(key)
if not value == new_value:
print('diff %s %s' % (value, new_value))
return analog
return None
def inform_server(request):
"""Апи-метод для получения всех данных по роботу
:param request: HttpRequest
"""
result = {}
if not request.headers.get('token') == settings.FS_TOKEN:
return JsonResponse(result, safe=False)
body = json.loads(request.body)
versions = body.get('versions', {})
hostname = body.get('hostname')
free_space = body.get('free_space', {})
robot = Robots.objects.filter(server_name=hostname).first()
if not robot:
robot = Robots(server_name=hostname)
robot.ip = get_request_ip(request)
robot.selenium_version = versions.get('selenium')
robot.chrome_version = versions.get('chrome')
robot.server_free_space = int(free_space.get('free', 0)) / 1024
robot.save()
profile = body.get('profile')
if profile and profile.get('name'):
robot_profile = RobotProfiles.objects.filter(robot=robot, name=profile['name']).first()
if not robot_profile:
robot_profile = RobotProfiles(robot=robot, name=profile['name'])
profile_fields = (
'user_agent',
'resolution',
'yandex_login',
'yandex_passwd',
)
needSave = False
for field in profile_fields:
if not getattr(robot_profile, field) == profile.get(field):
setattr(robot_profile, field, profile.get(field))
needSave = True
if needSave:
robot_profile.save()
result['success'] = True
result['robot'] = object_fields(robot)
return JsonResponse(result, safe=False)
def show_users(request, *args, **kwargs):
"""Вывод пользователей АТС"""
mh_vars = users_vars.copy()
mh = create_model_helper(mh_vars, request, CUR_APP)
mh.select_related_add('user')
mh.select_related_add('personal_user')
context = mh.context
# -----------------------------
# Вся выборка только через аякс
# -----------------------------
if request.is_ajax():
rows = mh.standard_show()
result = []
for row in rows:
item = object_fields(row)
user = item['user']
item['user'] = user['username']
item['user__username'] = user['username']
personal_user = item['personal_user']
if personal_user:
item['personal_user'] = personal_user['username']
item['personal_user__username'] = personal_user['username']
item['actions'] = row.id
item['folder'] = row.get_folder()
result.append(item)
if request.GET.get('page'):
result = {
'data': result,
'last_page': mh.raw_paginator['total_pages'],
'total_records': mh.raw_paginator['total_records'],
'cur_page': mh.raw_paginator['cur_page'],
'by': mh.raw_paginator['by'],
}
return JsonResponse(result, safe=False)
template = '%stable.html' % (mh.template_prefix, )
return render(request, template, context)
def show_purchases(request, *args, **kwargs):
"""Вывод покупок
:param request: HttpRequest
"""
mh_vars = purchases_vars.copy()
mh = create_model_helper(mh_vars, request, CUR_APP)
mh.select_related_add('shopper')
mh.select_related_add('order')
mh.select_related_add('cost_type')
context = mh.context
# -----------------------------
# Вся выборка только через аякс
# -----------------------------
if request.is_ajax():
rows = mh.standard_show()
result = []
for row in rows:
item = object_fields(row)
item['actions'] = row.id
item['folder'] = row.get_folder()
item['thumb'] = row.thumb()
item['imagine'] = row.imagine()
item['shopper__id'] = '%s #%s' % (str(
row.shopper), row.shopper.id) if row.shopper else ''
item['order__id'] = '%s #%s' % (row.order.number or '',
row.order.id) if row.order else ''
item['cost_type__id'] = row.cost_type.name if row.cost_type else ''
result.append(item)
if request.GET.get('page'):
result = {
'data': result,
'last_page': mh.raw_paginator['total_pages'],
'total_records': mh.raw_paginator['total_records'],
'cur_page': mh.raw_paginator['cur_page'],
'by': mh.raw_paginator['by'],
}
return JsonResponse(result, safe=False)
template = '%stable.html' % (mh.template_prefix, )
return render(request, template, context)
def show_struct(request, *args, **kwargs):
"""Вывод объектов
:param request: HttpRequest
"""
return show_view(
request,
model_vars=struct_vars,
cur_app=CUR_APP,
extra_vars=None,
)
mh_vars = struct_vars.copy()
mh = create_model_helper(mh_vars, request, CUR_APP)
context = mh.context
# -----------------------------
# Вся выборка только через аякс
# -----------------------------
if request.is_ajax():
rows = mh.standard_show()
result = []
for row in rows:
item = object_fields(row)
item['actions'] = row.id
item['folder'] = row.get_folder()
item['thumb'] = row.thumb()
item['imagine'] = row.imagine()
result.append(item)
if request.GET.get('page'):
result = {
'data': result,
'last_page': mh.raw_paginator['total_pages'],
'total_records': mh.raw_paginator['total_records'],
'cur_page': mh.raw_paginator['cur_page'],
'by': mh.raw_paginator['by'],
}
return JsonResponse(result, safe=False)
template = '%stable.html' % (mh.template_prefix, )
return render(request, template, context)
def translate_mode(request, *args, **kwargs):
"""Перевод текстов админки"""
result = {}
domain = get_domain(request, priority='session')
# Если русский, то без перевода
if domain.get('lang') == 'rus':
result['error'] = 'Русский то не надо переводить!'
if request.POST.get('old_value'):
result['old_value'] = request.POST['old_value']
return JsonResponse(result, safe=False)
perms = get_user_permissions(request.user, UITranslate)
if not perms['edit']:
result['error'] = 'Недостаточно прав'
elif not domain:
result['error'] = 'Не выбран домен'
else:
domain_pk = domain.get('pk')
class_name = request.POST.get('pk')
value = request.POST.get('value', '')[:254]
value = value.strip()
analog = UITranslate.objects.filter(class_name=class_name,
domain_pk=domain_pk).first()
# Херим, если пустое поле
if not value:
if analog:
analog.delete()
result['success'] = 'Перевод удален'
return JsonResponse(result, safe=False)
if not analog:
analog = UITranslate(class_name=class_name, domain_pk=domain_pk)
analog.value = value
analog.save()
result['translate'] = object_fields(analog)
result['success'] = 'Данные записаны'
result['domain'] = domain
return JsonResponse(result, safe=False)
def show_search_queries(request, *args, **kwargs):
"""Вывод поисковых запросов
:param request: HttpRequest
"""
mh_vars = search_queries_vars.copy()
mh = create_model_helper(mh_vars, request, CUR_APP)
mh.select_related_add('site')
context = mh.context
# -----------------------------
# Вся выборка только через аякс
# -----------------------------
if request.is_ajax():
rows = mh.standard_show()
result = []
for row in rows:
item = object_fields(row)
item['actions'] = row.id
item['folder'] = row.get_folder()
item['thumb'] = row.thumb()
item['imagine'] = row.imagine()
result.append(item)
if request.GET.get('page'):
result = {'data': result,
'last_page': mh.raw_paginator['total_pages'],
'total_records': mh.raw_paginator['total_records'],
'cur_page': mh.raw_paginator['cur_page'],
'by': mh.raw_paginator['by'], }
return JsonResponse(result, safe=False)
context['import_xlsx_url'] = reverse(
'%s:%s' % (CUR_APP, 'import_xlsx'),
kwargs={'action': 'search_queries'}
)
template = '%stable.html' % (mh.template_prefix, )
return render(request, template, context)
def show_view(request,
model_vars: dict,
cur_app: str,
only_fields: list = None,
fk_only_keys: dict = None,
extra_vars: dict = None):
"""Вывод в таблицу записей модели
:param request: HttpRequest
:param model_vars: словарь с данными для модели,
например,
costs_vars = {
'singular_obj': 'Тип цены',
'plural_obj': 'Типы цен',
'rp_singular_obj': 'типа цены',
'rp_plural_obj': 'типов цен',
'template_prefix': 'costs_',
'action_create': 'Создание',
'action_edit': 'Редактирование',
'action_drop': 'Удаление',
'menu': 'products',
'submenu': 'costs',
'show_urla': 'show_costs',
'create_urla': 'create_cost',
'edit_urla': 'edit_cost',
'model': CostsTypes,
'custom_model_permissions': Products,
'select_related_list': ('user', ),
}
:param cur_app: CUR_APP во view.py,
например,
CUR_APP='products'
:param only_fields: поля, которые нужно достать, остальные игнорируем,
например,
only_fields = (
'id',
'name',
'img',
'welding_joint__welding_date',
'welding_joint__side_thickness',
'line__titul__subject__company__name',
)
:param fk_only_keys: связанные поля ForeignKeys,
если надо выбрать не все, а только нужные поля в связях,
например,
fk_keys = {
'line': ('name', ),
'titul': ('name', ),
'welding_joint': (
'welding_date',
'side_thickness',
'state', ),
}
:param extra_vars: дополнительные данные, которые нужно передать в контекст,
а затем, через контекст для обработки в special_model_vars
"""
if not extra_vars:
extra_vars = {}
mh_vars = model_vars.copy()
mh = create_model_helper(mh_vars, request, cur_app)
context = mh.context
if extra_vars:
context.update(extra_vars)
special_model_vars(mh, mh_vars, context)
# -----------------------------
# Вся выборка только через аякс
# -----------------------------
if request.is_ajax():
rows = mh.standard_show(only_fields=only_fields)
result = []
for row in rows:
item = object_fields(row,
only_fields=only_fields,
fk_only_keys=fk_only_keys)
item['actions'] = row.id
item['folder'] = row.get_folder()
item['thumb'] = row.thumb()
item['imagine'] = row.imagine()
result.append(item)
if request.GET.get('page'):
result = {
'data': result,
'last_page': mh.raw_paginator['total_pages'],
'total_records': mh.raw_paginator['total_records'],
'cur_page': mh.raw_paginator['cur_page'],
'by': mh.raw_paginator['by'],
}
return JsonResponse(result, safe=False)
template = '%stable.html' % (mh.template_prefix, )
return render(request, template, context)
def edit_view(request,
model_vars: dict,
cur_app: str,
action: str,
row_id: int = None,
pass_fields: list = None,
extra_vars: dict = None):
"""Создание/редактирование записи для для модели
:param request: HttpRequest
:param model_vars: словарь с данными для модели
:param cur_app: CUR_APP во view.py
:param action: выполняемое действие
:param row_id: ид записи
:param pass_fields: поля, которые пропускаем при сохранении
:param extra_vars: дополнительные данные,
которые надо передать в шаблон
"""
if not extra_vars:
extra_vars = {}
if not pass_fields:
pass_fields = ()
mh_vars = model_vars.copy()
mh = create_model_helper(mh_vars, request, cur_app, action)
context = mh.context
if extra_vars:
context.update(extra_vars)
special_model_vars(mh, mh_vars, context)
row = mh.get_row(row_id)
if mh.error:
return redirect('%s?error=not_found' % (mh.root_url, ))
if request.method == 'GET':
if action == 'create':
mh.breadcrumbs_add({
'link':
mh.url_create,
'name':
'%s %s' % (mh.action_create, mh.rp_singular_obj),
})
elif action == 'edit' and row:
mh.breadcrumbs_add({
'link':
mh.url_edit,
'name':
'%s %s' % (mh.action_edit, mh.rp_singular_obj),
})
elif action == 'drop' and row:
if mh.permissions['drop']:
row.delete()
mh.row = None
context['success'] = '%s удален' % (mh.singular_obj, )
else:
context['error'] = 'Недостаточно прав'
elif request.method == 'POST':
mh.post_vars(pass_fields=pass_fields)
if action == 'create' or (action == 'edit' and row):
if action == 'create':
if mh.permissions['create']:
mh.row = mh.model()
mh.save_row()
if mh.error:
context['error'] = mh.error
else:
context['success'] = 'Данные успешно записаны'
else:
context['error'] = 'Недостаточно прав'
if action == 'edit':
if mh.permissions['edit']:
mh.save_row()
if mh.error:
context['error'] = mh.error
else:
context['success'] = 'Данные успешно записаны'
else:
context['error'] = 'Недостаточно прав'
elif not mh.error and action == 'img' and request.FILES:
mh.uploads()
if not mh.error and mh.row:
if not 'row' in context:
context['row'] = object_fields(mh.row)
context['row']['folder'] = mh.row.get_folder()
context['row']['thumb'] = mh.row.thumb()
context['row']['imagine'] = mh.row.imagine()
context['redirect'] = mh.get_url_edit()
if request.is_ajax() or action == 'img':
return JsonResponse(context, safe=False)
template = '%sedit.html' % (mh.template_prefix, )
return render(request, template, context)
def edit_pickup_point(request,
action: str,
row_id: int = None,
*args,
**kwargs):
"""Создание/редактирование пункта вывоза пользователя
:param request: HttpRequest
:param action: действие над объектом (создание/редактирование/удаление)
:param row_id: ид записи
"""
mh_vars = pickup_points_vars.copy()
mh = create_model_helper(mh_vars, request, CUR_APP, action)
mh.select_related_add('shopper')
mh.select_related_add('address')
mh.select_related_add('order')
row = mh.get_row(row_id)
context = mh.context # Контекст дозаполняется в get_row
if mh.error:
return redirect('%s?error=not_found' % (mh.root_url, ))
if request.method == 'GET':
if action == 'create':
mh.breadcrumbs_add({
'link':
mh.url_create,
'name':
'%s %s' % (mh.action_create, mh.rp_singular_obj),
})
elif action == 'edit' and row:
mh.breadcrumbs_add({
'link':
mh.url_edit,
'name':
'%s %s' % (mh.action_edit, mh.rp_singular_obj),
})
elif action == 'drop' and row:
if mh.permissions['drop']:
row.delete()
mh.row = None
context['success'] = '%s удален' % (mh.singular_obj, )
else:
context['error'] = 'Недостаточно прав'
elif request.method == 'POST':
pass_fields = ()
mh.post_vars(pass_fields=pass_fields)
if action == 'create' or (action == 'edit' and row):
if action == 'create':
if mh.permissions['create']:
mh.row = mh.model()
mh.save_row()
context['success'] = 'Данные успешно записаны'
else:
context['error'] = 'Недостаточно прав'
if action == 'edit':
if mh.permissions['edit']:
mh.save_row()
context['success'] = 'Данные успешно записаны'
else:
context['error'] = 'Недостаточно прав'
if mh.row:
context['row'] = object_fields(mh.row,
only_fields=pp_only_fields,
fk_only_keys=pp_fk_keys)
context['redirect'] = mh.get_url_edit()
template = '%sedit.html' % (mh.template_prefix, )
return render(request, template, context)
def import_from_excel(model, excel_file, required_names: list = None):
"""Импорт данных из excel
:param model: модель, в которую импортируем данные
:param excel_file: экселька, например, request.FILES.get("excel_file")
:param required_names: список обязательных полей в шапке
"""
if not required_names:
required_names = []
result = {'errors': []}
if not excel_file:
result['errors'].append('Не передан файл')
return result
wb = load_workbook(BytesIO(excel_file.read()))
sheet = wb.active
rows = list(sheet.rows)
if not len(rows) > 0:
result['errors'].append('Файл пустой')
return result
# ----------------
# Обработка ошибок
# ----------------
errors = []
names = [cell.value for cell in rows[0]]
for name in required_names:
if not name in names:
result['errors'].append('обязательное поле %s' % name)
if result['errors']:
return result
template = object_fields(model(), only_fields=names)
indexes = {name: names.index(name) for name in names if name in template}
# Добавить foreign keys в шапку
with_fk = [name for name in names if '__' in name]
if with_fk:
fkeys = object_foreign_keys(model())
for name in with_fk:
wrong_key = False
name_parts = name.split('__')
for i in range(len(name_parts) - 1):
if i == 0:
prev_fkeys = fkeys
else:
prev_fkeys = object_foreign_keys(prev_fkeys[name_parts[i]])
if not name_parts[i] in prev_fkeys:
wrong_key = True
if not wrong_key:
indexes[name] = names.index(name)
def fill_fkey(item: dict, name: str, value: str):
"""Перезаполнить выходящее значение из строки в словарь
:param item: словарь с текущими значениями
:param name: Название поля
:param value: Значение поля в виде словаря
"""
parts = name.split('__')
prev = item
# Последняя вложенность - строкой (не словарем)
for part in parts[:-1]:
if not part in prev:
prev[part] = {}
prev = prev[part]
prev[parts[-1]] = value
data = []
for row in rows:
item = {}
is_empty = True
# В первой записи будут названия полей
for name, ind in indexes.items():
value = row[ind].value
if value:
is_empty = False
# Будет дубль и key1__key2 и [key1][key2]
item[name] = value
# Спец обработка в словарь, если это foreign_key
if name in with_fk:
fill_fkey(item, name, value)
continue
if not is_empty:
data.append(item)
result['data'] = data[1:]
return result
def ApiHelper(request,
model_vars: dict,
CUR_APP: str,
reverse_params: dict = None,
restrictions: list = None):
"""Апи-метод для получения всех данных
:param request: HttpRequest
:param model_vars: по какой модели отдаем данные
:param CUR_APP: текущее приложение
:param reverse_params: словарь для параметров в urls.py
:param restrictions: аналог filters (массив Q() условий),
только уже из вьюхи, а по GET/POST
"""
# Если нету метода, то не надо мучать жопу
model = model_vars['model']
with_get_folder = hasattr(model, 'get_folder')
if not reverse_params:
reverse_params = {}
mh_vars = model_vars.copy()
mh = create_model_helper(mh_vars,
request,
CUR_APP,
reverse_params=reverse_params)
# Принудительные права на просмотр
mh.permissions['view'] = True
# Независимо от метода
params = request.GET if request.method == 'GET' else request.POST
model_fields = object_fields(model())
only_fields = []
get_only_fields = params.get('only_fields')
if get_only_fields:
get_only_fields = [
field.strip() for field in get_only_fields.split(',')
]
only_fields = [
field for field in get_only_fields if field in model_fields
]
# Параметры фильтрации через filter__field = ''
# filter__ означает, что мы хотим отфильтровать по какому то полю,
# например, ?filter__id=1&filter__is_active=1
filters = {
k.replace('filter__', ''): v
for k, v in params.items() if k.startswith('filter__')
}
if filters:
mh.filter_add(Q(**filters))
if restrictions:
for restriction in restrictions:
mh.filter_add(restriction)
orders_by = {
k.replace('order__', ''): v
for k, v in params.items() if k.startswith('order__')
}
for order_by, direction in orders_by.items():
if direction == 'asc':
mh.order_by_add(order_by)
elif direction == 'desc':
mh.order_by_add('-%s' % order_by)
context = mh.context
rows = mh.standard_show(only_fields=only_fields)
result = []
for row in rows:
item = object_fields(row, only_fields=only_fields)
if not only_fields or 'folder' in only_fields:
if with_get_folder:
item['folder'] = row.get_folder()
result.append(item)
result = {
'data': result,
'last_page': mh.raw_paginator['total_pages'],
'total_records': mh.raw_paginator['total_records'],
'cur_page': mh.raw_paginator['cur_page'],
'by': mh.raw_paginator['by'],
}
return JsonResponse(result, safe=False)
