461 lines
27 KiB
Python
461 lines
27 KiB
Python
# -*- coding: utf-8 -*-
|
||
# from django.shortcuts import render, redirect
|
||
from django.shortcuts import render, redirect
|
||
from django.http import HttpRequest, HttpResponse
|
||
from django.utils.dateformat import format
|
||
from django.utils import timezone
|
||
from django.db.models import F, Q, ExpressionWrapper, BooleanField, Max, Count, Avg
|
||
from oknardia.models import LogVisitPriceReport, SetKit
|
||
from oknardia.settings import *
|
||
from web.add_func import normalize, get_rating_set_for_stars, sum_through
|
||
# from time import time
|
||
import django.utils.dateformat
|
||
import time
|
||
import json
|
||
import re
|
||
import pytils
|
||
|
||
# Сигнальные значения для поиска min/max: заведомо вне диапазона реальных данных
|
||
_INI_MAX = -100_000
|
||
_INI_MIN = 1_000_000
|
||
|
||
|
||
def _color_hi(value, val_min: float, val_max: float, threshold=None, epsilon: float = 0.001) -> str | None:
|
||
"""Цвет ячейки "чем больше, тем лучше": зеленее → значение ближе к max.
|
||
|
||
:param value: значение поля для текущей строки
|
||
:param val_min: минимум по всей выборке (из первого прогона)
|
||
:param val_max: максимум по всей выборке
|
||
:param threshold: нижний порог: значения <= threshold считаются "нет данных" и не окрашиваются
|
||
:param epsilon: минимальный разброс, при котором окраска имеет смысл
|
||
:return: hex-строка цвета или None
|
||
"""
|
||
try:
|
||
v = float(value)
|
||
except (TypeError, ValueError):
|
||
return None
|
||
if val_max == _INI_MAX or val_min == _INI_MIN or val_max - val_min < epsilon:
|
||
return None
|
||
if threshold is not None and v <= threshold:
|
||
return None
|
||
if v <= val_min:
|
||
return None
|
||
ratio = (v - val_min) / (val_max - val_min)
|
||
c = 255 - int(ratio * 128)
|
||
return f"#{c:02x}ff{c:02x}"
|
||
|
||
|
||
def _color_lo(value, val_min: float, val_max: float, threshold=None, epsilon: float = 0.001) -> str | None:
|
||
"""Цвет ячейки "чем меньше, тем лучше": зеленее → значение ближе к min.
|
||
|
||
:param value: значение поля для текущей строки
|
||
:param val_min: минимум по всей выборке
|
||
:param val_max: максимум по всей выборке
|
||
:param threshold: нижний порог: значения <= threshold не окрашиваются
|
||
:param epsilon: минимальный разброс
|
||
:return: hex-строка цвета или None
|
||
"""
|
||
try:
|
||
v = float(value)
|
||
except (TypeError, ValueError):
|
||
return None
|
||
if val_max == _INI_MAX or val_min == _INI_MIN or val_max - val_min < epsilon:
|
||
return None
|
||
if threshold is not None and v <= threshold:
|
||
return None
|
||
if v >= val_max:
|
||
return None
|
||
ratio = (v - val_min) / (val_max - val_min)
|
||
c = 127 + int(ratio * 128)
|
||
return f"#{c:02x}ff{c:02x}"
|
||
|
||
|
||
def _bounds(items: list, field: str, threshold=None) -> tuple[float, float]:
|
||
"""Вычисляет (min, max) значений поля field по списку items, игнорируя None и <= threshold.
|
||
|
||
:param items: список объектов (SetKit с аннотациями)
|
||
:param field: имя атрибута
|
||
:param threshold: значения <= threshold исключаются из выборки
|
||
:return: (min, max) или (_INI_MIN, _INI_MAX) если нет валидных значений
|
||
"""
|
||
vals = []
|
||
for item in items:
|
||
raw = getattr(item, field, None)
|
||
if raw is None:
|
||
continue
|
||
try:
|
||
v = float(raw)
|
||
except (TypeError, ValueError):
|
||
continue
|
||
if threshold is not None and v <= threshold:
|
||
continue
|
||
vals.append(v)
|
||
if not vals:
|
||
return _INI_MIN, _INI_MAX
|
||
return min(vals), max(vals)
|
||
|
||
|
||
def get_last_user_visit_list(list_visit: list) -> list:
|
||
""" Служебная функция: получает список с посещенных страниц с ценовой выдачей (ListVisit), меняет в нем даты
|
||
на описание типа "три недели назад" и возвращает обратно.
|
||
|
||
:param list_visit:
|
||
:return:
|
||
"""
|
||
result_list_visit = []
|
||
for i in list_visit:
|
||
result_list_visit.append({
|
||
"Time": pytils.dt.distance_of_time_in_words(int(i["Time"])),
|
||
"LastURL": i["LastURL"],
|
||
"LastAddress": i["LastAddress"],
|
||
"LastApart": i["LastApart"]
|
||
})
|
||
return result_list_visit
|
||
|
||
|
||
# def get_last_all_user_visit_list() -> tuple:
|
||
def get_last_all_user_visit_list() -> list:
|
||
""" Служебная функция: получает список с посещенных страниц с ценовой выдачей для всех пользователей из DB
|
||
|
||
:return: list -- список четырех последних посещений ценовых предложений всеми пользователями
|
||
"""
|
||
result_list_visit = []
|
||
# id_last_visit = 0 # id четвертого посещения??? Зачем??? Не помню хоть убей!!!
|
||
try:
|
||
q_log_visit = LogVisitPriceReport.objects.all().order_by('-dLogVisitTime')[:4]
|
||
for i in q_log_visit:
|
||
# if id_last_visit == 0:
|
||
# id_last_visit = i.id
|
||
result_list_visit.append({
|
||
"id": i.id,
|
||
"Time": pytils.dt.distance_of_time_in_words(int(django.utils.dateformat.format(i.dLogVisitTime, 'U'))),
|
||
"LogURL": i.sLogURL,
|
||
"LogAddress": i.sLogAddress,
|
||
"LogApart": i.sLogNameApartment
|
||
})
|
||
except LogVisitPriceReport.DoesNotExist:
|
||
pass
|
||
# return id_last_visit+1, list_visit
|
||
return result_list_visit
|
||
|
||
|
||
def compare_offers(request: HttpRequest, to_compare: str = "1,2") -> HttpResponse:
|
||
""" Сравнение нескольких коммерческих предложений (оконных набора).
|
||
|
||
:param request: HttpRequest -- входящий http-запрос
|
||
:param to_compare: str -- список ,через запятую, id оконных наборов (Set) для сравнения
|
||
:return: HttpResponse --
|
||
"""
|
||
time_start = time.perf_counter()
|
||
to_template: dict[str, object] = {}
|
||
try:
|
||
# Этот блок нужен для 302-переадресации, когда разные URL отдают одинаковые страницы.
|
||
# Например, такое происходит для страницы: /compare_offers/1,2 и /compare_offers/2,1
|
||
# т.е. сравнивают одни и те же наборы, но они указаны в строке сравнения в разном порядке
|
||
# ----------------------------------------------------------------------------------------------
|
||
# получил строку: to_compare
|
||
# превращаем в список
|
||
list_input = to_compare.split(",")
|
||
list_fin = []
|
||
# убираем мусор и создаем список только из целых чисел (listResult)
|
||
for i in list_input:
|
||
try:
|
||
list_fin.append(int(i))
|
||
except ValueError:
|
||
continue
|
||
if len(list_fin) < 2:
|
||
return redirect("/compare_offers/1,2")
|
||
# Сортируем этот список (list_fin)
|
||
list_fin.sort()
|
||
# Превращаем список list_fin в строку list_fine (разделитель -- запятая)
|
||
list_fine = ','.join(map(str, list_fin))
|
||
# Сравниваем входной порядок параметров и отсоветованный. Если не совпадает, то переадресация-302
|
||
if to_compare != list_fine:
|
||
return redirect(f"/compare_offers/{list_fine}")
|
||
try:
|
||
q_set_kit = (
|
||
SetKit.objects
|
||
.filter(id__in=list_fin)
|
||
.annotate(
|
||
# Активность коммерческого предложения (аналог dSetCommercialUntil > NOW())
|
||
bCommercial=ExpressionWrapper(
|
||
Q(dSetCommercialUntil__gt=timezone.now()),
|
||
output_field=BooleanField()
|
||
),
|
||
# Алиасы из MerchantBrand (SetKit → OurUser → MerchantOffice → MerchantBrand)
|
||
MERCHANT_ID=F('kSet2User__kMerchantOffice__kMerchantName'),
|
||
sMerchantName=F('kSet2User__kMerchantOffice__kMerchantName__sMerchantName'),
|
||
sMerchantMainURL=F('kSet2User__kMerchantOffice__kMerchantName__sMerchantMainURL'),
|
||
pMerchantLogo=F('kSet2User__kMerchantOffice__kMerchantName__pMerchantLogo'),
|
||
# Алиасы из PVCprofiles (SetKit → kSet2PVCprofiles)
|
||
PROFILE_ID=F('kSet2PVCprofiles'),
|
||
sProfileName=F('kSet2PVCprofiles__sProfileName'),
|
||
sProfileBriefDescription=F('kSet2PVCprofiles__sProfileBriefDescription'),
|
||
sProfileManufacturer=F('kSet2PVCprofiles__sProfileManufacturer'),
|
||
sProfileColor=F('kSet2PVCprofiles__sProfileColor'),
|
||
iProfileCameras=F('kSet2PVCprofiles__iProfileCameras'),
|
||
iProfileThickness=F('kSet2PVCprofiles__iProfileThickness'),
|
||
iProfileGlazingThickness=F('kSet2PVCprofiles__iProfileGlazingThickness'),
|
||
fProfileHeatTransf=F('kSet2PVCprofiles__fProfileHeatTransf'),
|
||
fProfileSeals=F('kSet2PVCprofiles__fProfileSeals'),
|
||
sProfileSealDescription=F('kSet2PVCprofiles__sProfileSealDescription'),
|
||
fProfileSoundproofing=F('kSet2PVCprofiles__fProfileSoundproofing'),
|
||
iProfileHeight=F('kSet2PVCprofiles__iProfileHeight'),
|
||
iProfileRabbet=F('kSet2PVCprofiles__iProfileRabbet'),
|
||
sProfileFillet=F('kSet2PVCprofiles__sProfileFillet'),
|
||
sProfileReinforcement=F('kSet2PVCprofiles__sProfileReinforcement'),
|
||
sProfileOther=F('kSet2PVCprofiles__sProfileOther'),
|
||
fProfileRating=F('kSet2PVCprofiles__fProfileRating'),
|
||
sProfileDescription=F('kSet2PVCprofiles__sProfileDescription'),
|
||
# Алиасы из Glazing (SetKit → kSet2Glazing)
|
||
iGlazingCamerasN=F('kSet2Glazing__iGlazingCamerasN'),
|
||
iGlazingThickness=F('kSet2Glazing__iGlazingThickness'),
|
||
sGlazingBriefDescription=F('kSet2Glazing__sGlazingBriefDescription'),
|
||
sGlazingDescription=F('kSet2Glazing__sGlazingDescription'),
|
||
sGlazingMark=F('kSet2Glazing__sGlazingMark'),
|
||
sGlazingManufacturer=F('kSet2Glazing__sGlazingManufacturer'),
|
||
fGlazingHeatTransfer=F('kSet2Glazing__fGlazingHeatTransfer'),
|
||
fGlazingSoundproofing=F('kSet2Glazing__fGlazingSoundproofing'),
|
||
fGlazingLightTransmission=F('kSet2Glazing__fGlazingLightTransmission'),
|
||
sGlazingLightReflectance=F('kSet2Glazing__sGlazingLightReflectance'),
|
||
fGlazingPassingSun=F('kSet2Glazing__fGlazingPassingSun'),
|
||
sGlazingReflectionAndAbsorptionOfHeat=F('kSet2Glazing__sGlazingReflectionAndAbsorptionOfHeat'),
|
||
sGlazingToning=F('kSet2Glazing__sGlazingToning'),
|
||
fGlazingRating=F('kSet2Glazing__fGlazingRating'),
|
||
)
|
||
)
|
||
except SetKit.DoesNotExist:
|
||
return redirect("/compare_offers/1,2")
|
||
list_set_kit = list(q_set_kit)
|
||
if len(list_set_kit) == 0:
|
||
return redirect("/compare_offers/1,2")
|
||
if len(list_set_kit) == 1:
|
||
return redirect(f"/specification_set/{list_set_kit[0].id}")
|
||
except (ValueError, TypeError):
|
||
return render("/compare_offers/1,2")
|
||
# ПРЕДВАРИТЕЛЬНЫЙ "ПРОГОН"
|
||
# Вычисляем min/max по каждому параметру для дальнейшей покраски ячеек.
|
||
# Камеры профиля требуют sum_through() — обрабатываем отдельно.
|
||
cameras_vals = [
|
||
c for i in list_set_kit
|
||
if (c := sum_through(i.iProfileCameras)) is not None and c > 0
|
||
]
|
||
min_cameras = min(cameras_vals) if cameras_vals else _INI_MIN
|
||
max_cameras = max(cameras_vals) if cameras_vals else _INI_MAX
|
||
|
||
# Остальные поля — через _bounds() с соответствующими порогами
|
||
# (threshold: значения <= порога считаются "нет данных" и исключаются из диапазона)
|
||
min_seals, max_seals = _bounds(list_set_kit, 'fProfileSeals', threshold=0)
|
||
min_thick, max_thick = _bounds(list_set_kit, 'iProfileThickness', threshold=10)
|
||
min_glaz_d, max_glaz_d = _bounds(list_set_kit, 'iProfileGlazingThickness', threshold=4)
|
||
min_heat_p, max_heat_p = _bounds(list_set_kit, 'fProfileHeatTransf', threshold=0)
|
||
min_sound_p, max_sound_p = _bounds(list_set_kit, 'fProfileSoundproofing', threshold=0)
|
||
min_rabbet, max_rabbet = _bounds(list_set_kit, 'iProfileRabbet', threshold=1)
|
||
min_height, max_height = _bounds(list_set_kit, 'iProfileHeight', threshold=12)
|
||
min_gl_cam, max_gl_cam = _bounds(list_set_kit, 'iGlazingCamerasN', threshold=0)
|
||
min_gl_thick, max_gl_thick = _bounds(list_set_kit, 'iGlazingThickness', threshold=3)
|
||
min_heat_g, max_heat_g = _bounds(list_set_kit, 'fGlazingHeatTransfer', threshold=0.05)
|
||
min_sound_g, max_sound_g = _bounds(list_set_kit, 'fGlazingSoundproofing', threshold=5)
|
||
min_light, max_light = _bounds(list_set_kit, 'fGlazingLightTransmission', threshold=5)
|
||
min_sun, max_sun = _bounds(list_set_kit, 'fGlazingPassingSun', threshold=5)
|
||
min_rating, max_rating = _bounds(list_set_kit, 'fSetRating', threshold=0.05)
|
||
|
||
list_of_merchant_name = list({i.sMerchantName for i in list_set_kit})
|
||
list_of_profile_name = list({i.sProfileName for i in list_set_kit})
|
||
list_of_glazing_brief = list({i.sGlazingMark for i in list_set_kit})
|
||
|
||
# ОКОНЧАТЕЛЬНЫЙ ПРОГОН
|
||
# Формируем список словарей для шаблона; цвета вычисляются через хелперы _color_hi / _color_lo.
|
||
dim = []
|
||
for i in list_set_kit:
|
||
profile_num_cameras = sum_through(i.iProfileCameras)
|
||
|
||
# Рейтинг НАБОРА — особая логика со "звёздочками"
|
||
if i.fSetRating > RARING_SET_MAX:
|
||
rating_set_n = RARING_SET_MAX
|
||
rating_set_color = "#80ff80"
|
||
elif i.fSetRating < RARING_SET_MIN + 0.05 or max_rating - min_rating < 0.001:
|
||
rating_set_n = RARING_SET_MIN
|
||
rating_set_color = ""
|
||
else:
|
||
try:
|
||
rating_set_n = i.fSetRating * (RARING_SET_MAX - RARING_SET_MIN) / RARING_STAR
|
||
rating_set_color = _color_hi(i.fSetRating, min_rating, max_rating)
|
||
except (ZeroDivisionError, TypeError):
|
||
rating_set_color = None
|
||
rating_set_n = RARING_SET_MIN
|
||
|
||
list2_del = f",{to_compare},"
|
||
dim.append({
|
||
"MERCHANT": i.sMerchantName,
|
||
"MERCHANT_ID": i.MERCHANT_ID,
|
||
"IS_COMMERCIAL": i.bCommercial,
|
||
"MERCHANT_T": pytils.translit.slugify(i.sMerchantName),
|
||
"MERCHANT_URL": i.sMerchantMainURL,
|
||
"MERCHANT_URL_SHOT": re.sub(r"(?:^https?://|/$|www\.)", "", i.sMerchantMainURL),
|
||
"SET_NAME": i.sSetName,
|
||
"MERCHANT_LOGO": i.pMerchantLogo,
|
||
"RATING_SET": get_rating_set_for_stars(i.fSetRating),
|
||
"RATING_SET_N": rating_set_n,
|
||
"RATING_SET_COLOR": rating_set_color,
|
||
"PROFILE_ID": i.PROFILE_ID,
|
||
"PROFILE_NAME": i.sProfileName,
|
||
"PROFILE_NAME_T": pytils.translit.slugify(i.sProfileName),
|
||
"PROFILE_MANUFACTURER": i.sProfileManufacturer,
|
||
"PROFILE_MANUFACTURER_T": pytils.translit.slugify(i.sProfileManufacturer),
|
||
"PROFILE_NUM_COLOR": i.sProfileColor,
|
||
"PROFILE_NUM_CAMERAS": i.iProfileCameras, # Число камер рамы/створки
|
||
"PROFILE_NUM_CAMERAS_COLOR": _color_hi(profile_num_cameras, min_cameras, max_cameras, threshold=1),
|
||
"PROFILE_THICKNESS": i.iProfileThickness, # Монтажная ширина профиля
|
||
"PROFILE_THICKNESS_COLOR": _color_hi(i.iProfileThickness, min_thick, max_thick, threshold=10),
|
||
"PROFILE_GLAZING_THICKNESS": i.iProfileGlazingThickness, # Макс. толщина стеклопакета
|
||
"PROFILE_GLAZING_THICKNESS_COLOR": _color_hi(i.iProfileGlazingThickness, min_glaz_d, max_glaz_d, threshold=4),
|
||
"PROFILE_HEAT_TRANSFER": i.fProfileHeatTransf, # Сопротивление теплопередаче
|
||
"PROFILE_HEAT_TRANSFER_COLOR": _color_hi(i.fProfileHeatTransf, min_heat_p, max_heat_p),
|
||
"PROFILE_NUM_SEALS": i.fProfileSeals, # Контуров уплотнения
|
||
"PROFILE_NUM_SEALS_COLOR": _color_hi(i.fProfileSeals, min_seals, max_seals, threshold=0),
|
||
"PROFILE_SEAL_DESCRIPTION": i.sProfileSealDescription,
|
||
"PROFILE_SOUND_PROOFING": i.fProfileSoundproofing, # Коэффициент звукоизоляции профиля
|
||
"PROFILE_SOUND_PROOFING_COLOR": _color_hi(i.fProfileSoundproofing, min_sound_p, max_sound_p),
|
||
"PROFILE_HEIGHT": i.iProfileHeight, # Высота в световом проеме (меньше = лучше)
|
||
"PROFILE_HEIGHT_COLOR": _color_lo(i.iProfileHeight, min_height, max_height, threshold=12),
|
||
"PROFILE_RABBET": i.iProfileRabbet, # Фальц
|
||
"PROFILE_RABBET_COLOR": _color_hi(i.iProfileRabbet, min_rabbet, max_rabbet, threshold=1),
|
||
"PROFILE_FILLET": i.sProfileFillet, # Штапик
|
||
"PROFILE_REINFORCEMENT": i.sProfileReinforcement, # Армирование профиля
|
||
"PROFILE_OTHER": i.sProfileOther,
|
||
"SET_ID": i.id,
|
||
"SET_CLIMATE_CONTROL": i.sSetClimateControl,
|
||
"SET_STILL": i.sSetSill,
|
||
"SET_IMPLEMENTS_ALL": i.sSetImplementAll,
|
||
"SET_IMPLEMENTS_HANDLES": i.sSetImplementHandles,
|
||
"SET_IMPLEMENTS_HINGES": i.sSetImplementHinges,
|
||
"SET_IMPLEMENTS_LATCH": i.sSetImplementLatch,
|
||
"SET_IMPLEMENTS_LIMITER": i.sSetImplementLimiter,
|
||
"SET_IMPLEMENTS_CATCH": i.sSetImplementCatch,
|
||
"SET_PANES": i.sSetPanes,
|
||
"SET_SLOPE": i.sSetSlope,
|
||
"SET_DELIVERY": i.sSetDelivery,
|
||
"SET_DELIVERY_B": i.bSetDelivery,
|
||
"SET_UNINSTALL_INSTALL": i.sSetUninstallInstall,
|
||
"SET_UNINSTALL_INSTALL_B": i.bSetUninstallInstall,
|
||
"SET_OTHER_CONDITIONS": i.sSetOtherConditions,
|
||
"GLAZING_CAMERAS_NUM": i.iGlazingCamerasN, # Камер стеклопакета
|
||
"GLAZING_CAMERAS_COLOR": _color_hi(i.iGlazingCamerasN, min_gl_cam, max_gl_cam),
|
||
"GLAZING_THICKNESS": i.iGlazingThickness, # Толщина стеклопакета
|
||
"GLAZING_THICKNESS_COLOR": _color_hi(i.iGlazingThickness, min_gl_thick, max_gl_thick, threshold=3),
|
||
"GLAZING_BRIEF_DESCRIPTION": re.sub(r",[\s\d]+мм", "", i.sGlazingBriefDescription),
|
||
"GLAZING_MARK": i.sGlazingMark,
|
||
"GLAZING_MANUFACTURER": i.sGlazingManufacturer,
|
||
"GLAZING_HEAT_TRANSFER": i.fGlazingHeatTransfer, # Ro стеклопакета (м²×°C/Вт)
|
||
"GLAZING_HEAT_TRANSFER_COLOR": _color_hi(i.fGlazingHeatTransfer, min_heat_g, max_heat_g, threshold=0.05),
|
||
"GLAZING_SOUNDPROOFING": i.fGlazingSoundproofing, # Звукоизоляция стеклопакета
|
||
"GLAZING_SOUNDPROOFING_COLOR": _color_hi(i.fGlazingSoundproofing, min_sound_g, max_sound_g, threshold=5),
|
||
"GLAZING_LIGHT_TRANSMISSION": i.fGlazingLightTransmission,
|
||
"GLAZING_LIGHT_TRANSMISSION_COLOR": _color_hi(i.fGlazingLightTransmission, min_light, max_light, threshold=5, epsilon=0.002),
|
||
"GLAZING_LIGHT_REFLECTION": i.sGlazingLightReflectance,
|
||
"GLAZING_PASSING_SUN": i.fGlazingPassingSun, # Солнцепропускание (меньше = лучше)
|
||
"GLAZING_PASSING_SUN_COLOR": _color_lo(i.fGlazingPassingSun, min_sun, max_sun, threshold=5, epsilon=0.0001),
|
||
"GLAZING_REFLECTION_AND_ABSORPTION": i.sGlazingReflectionAndAbsorptionOfHeat,
|
||
"GLAZING_TONING": i.sGlazingToning,
|
||
"URL_W_DEL": list2_del.replace(f",{i.id},", ",")[1:-1],
|
||
})
|
||
to_template.update({'SET_LIST': dim,
|
||
'LIST_MERCHANT': list_of_merchant_name,
|
||
'LIST_PROFILE': list_of_profile_name,
|
||
'LIST_GLAZING': list_of_glazing_brief})
|
||
# Предложения для добавления в сравнения:
|
||
if len(list_set_kit) < 7:
|
||
try:
|
||
q_set_kit = (
|
||
SetKit.objects
|
||
.exclude(id__in=list_fin) # исключаем уже сравниваемые наборы
|
||
.filter(priceoffer__isnull=False) # только наборы с ценовыми предложениями
|
||
.annotate(
|
||
dLastData=Max('priceoffer__dOfferModify'),
|
||
sMerchantName=F('kSet2User__kMerchantOffice__kMerchantName__sMerchantName'),
|
||
)
|
||
.order_by('-dLastData')[:25]
|
||
)
|
||
dim = []
|
||
for i in q_set_kit:
|
||
# Вычисляем deltaData в Python (аналог TO_DAYS(NOW()) - TO_DAYS(MAX(dOfferModify)))
|
||
i.deltaData = (
|
||
(timezone.now().date() - i.dLastData.date()).days
|
||
if i.dLastData else 999
|
||
)
|
||
if i.deltaData < 100:
|
||
early_data = pytils.dt.distance_of_time_in_words(
|
||
int(django.utils.dateformat.format(i.dLastData, 'U')), accuracy=2
|
||
)
|
||
else:
|
||
early_data = ""
|
||
dim.append({
|
||
"ID_LIST": "%s,%d" % (to_compare, i.id),
|
||
"SET_NAME": i.sSetName,
|
||
"MERCHANT": i.sMerchantName,
|
||
"DATA_MODIFY": early_data,
|
||
"R": i.fSetRating,
|
||
"R_STAR": get_rating_set_for_stars(i.fSetRating),
|
||
})
|
||
to_template.update({'LIST_TO_ADD': dim})
|
||
except SetKit.DoesNotExist:
|
||
pass
|
||
to_template.update({
|
||
# получаем последние визиты всех посетителей из базы
|
||
'LOG_VISIT': get_last_all_user_visit_list(),
|
||
'ticks': float(time.perf_counter() - time_start)
|
||
})
|
||
return render(request, "report/report_compare_set.html", to_template)
|
||
|
||
|
||
def show_rating_components(request: HttpRequest, win_set: str = "1") -> HttpResponse:
|
||
""" Показать состав рейтинга оконного предложения (компоненты рейтинга)
|
||
|
||
:param request: HttpRequest -- входящий http-запрос
|
||
:param win_set: str -- id оконного набора, для которого показать состав рейтинга
|
||
:return: HttpResponse --
|
||
"""
|
||
time_start = time.perf_counter()
|
||
to_template: dict[str, object] = {}
|
||
try:
|
||
win_set = int(win_set)
|
||
except ValueError:
|
||
win_set = 1
|
||
q = (
|
||
SetKit.objects
|
||
.filter(id=win_set)
|
||
.annotate(
|
||
dPriceModify=Max('priceoffer__dOfferModify'),
|
||
NumOffer=Count('priceoffer__id'),
|
||
fOfferRatingAvg=Avg('priceoffer__fOfferRating'),
|
||
fProfileRating=F('kSet2PVCprofiles__fProfileRating'),
|
||
fGlazingRating=F('kSet2Glazing__fGlazingRating'),
|
||
)
|
||
)
|
||
raring_list = list(q)
|
||
f_rating_service = raring_list[0].fSetRating - RARING_WEIGHT_PVC_PROFILE_IN_SET * normalize(
|
||
raring_list[0].fProfileRating, val_max=RARING_PVC_PROFILE_MAX
|
||
)
|
||
f_rating_service -= RARING_WEIGHT_GLAZING_IN_SET * normalize(raring_list[0].fGlazingRating,
|
||
val_max=RARING_GLAZING_MAX)
|
||
f_rating_service = normalize(f_rating_service,
|
||
val_max=RARING_SET_MAX-RARING_WEIGHT_PVC_PROFILE_IN_SET-RARING_WEIGHT_GLAZING_IN_SET)
|
||
f_rating_service *= RARING_SET_MAX
|
||
to_template.update({'RATING_SERVIZ': f_rating_service,
|
||
'RATING_SERVIZ_STARS': get_rating_set_for_stars(f_rating_service),
|
||
'RATING_GLAZ': raring_list[0].fGlazingRating,
|
||
'RATING_GLAZ_STARS': get_rating_set_for_stars(raring_list[0].fGlazingRating),
|
||
'RATING_PVC': raring_list[0].fProfileRating,
|
||
'RATING_PVC_STARS': get_rating_set_for_stars(raring_list[0].fProfileRating),
|
||
'RATING_OFFER': raring_list[0].fOfferRatingAvg,
|
||
'RATING_OFFER_STARS': get_rating_set_for_stars(raring_list[0].fOfferRatingAvg),
|
||
'DATA_OFFER_UPDATE': pytils.dt.distance_of_time_in_words(
|
||
int(django.utils.dateformat.format(raring_list[0].dPriceModify, 'U')), accuracy=2),
|
||
'NUM_OFFERS': pytils.numeral.get_plural(raring_list[0].NumOffer,
|
||
"коммерческое предложение, коммерческих предложения,"
|
||
" коммерческих предложений"),
|
||
'TEST': win_set,
|
||
'ticks': float(time.perf_counter() - time_start)})
|
||
return render(request, "report/show_rating_components.html", to_template)
|