1107 lines
56 KiB
Python
1107 lines
56 KiB
Python
# -*- coding: utf-8 -*-
|
||
"""
|
||
Django management command: make_rating
|
||
|
||
Вычисляет (каждый раз заново) рейтинги оконных профилей и стеклопакетов.
|
||
Вычисление базируется на ренкинге методом Манна-Уитни (Mann-Whitney U test шаг).
|
||
|
||
В базовом ренкинге участвуют только профили и стеклопакеты, присутствующие
|
||
в коммерческих предложениях размещённых в ОКНАРДИИ.
|
||
|
||
АЛГОРИТМ РАНЖИРОВАНИЯ (Mann-Whitney U Step Rank):
|
||
====================================================
|
||
|
||
1. Для каждой характеристики (параметра):
|
||
- Сортируем список объектов по значению параметра (от МЕНЬШЕГО к БОЛЬШЕМУ)
|
||
- Начинаем с начального ранга = 0
|
||
- Проходим по отсортированному списку и увеличиваем ранг на вес характеристики
|
||
ТОЛьКО когда значение МЕНЯЕТСЯ на новое уникальное значение
|
||
|
||
2. Логика определения "улучшения":
|
||
- revers=False (ПО ВОЗРАСТАНИЮ):
|
||
* Начинаем с МИНИМУМА, повышаем ранг при УВЕЛИЧЕНИИ значения
|
||
* Используется для параметров где БОЛЬШЕ = ЛУЧШЕ
|
||
* Примеры: HeatTransfer (Ro), Soundproofing (дБ), LightTransmission (%)
|
||
|
||
- revers=True (ПО УБЫВАНИЮ):
|
||
* Начинаем с МАКСИМУМА, повышаем ранг при УМЕНЬШЕНИИ значения
|
||
* Используется для параметров где МЕНЬШЕ = ЛУЧШЕ
|
||
* Примеры: PassingSun (%), Height (для фальца)
|
||
|
||
3. После ранжирования по всем параметрам:
|
||
- Суммируем ранги по каждому объекту
|
||
- Нормализуем итоговый ранг: (значение - минимум) / максимум
|
||
- Переводим в финальный рейтинг: нормализованный * 5.0 звёзд
|
||
|
||
ДИАПАЗОНЫ РЕЙТИНГА:
|
||
===================
|
||
- ТемпоральныйРейтинг (TmpRating): от 0 до максимальной суммы всех рангов
|
||
- Нормализованный (RatingConsist): 0.0 … 1.0 (для каждого параметра)
|
||
- Финальный рейтинг профиля/стеклопакета (fProfileRating/fGlazingRating): 0.0 … 5.0 звёзд
|
||
|
||
ПАРАМЕТРЫ РАНЖИРОВАНИЯ И ИХ НАПРАВЛЕНИЯ:
|
||
==========================================
|
||
|
||
ПРОФИЛИ (PVCprofiles):
|
||
- fProfileSoundproofing (дБ) → БОЛЬШЕ дБ = ЛУЧШЕ звукоизоляция → revers=False
|
||
- fProfileHeatTransf (м²×°C/Вт) → БОЛЬШЕ сопротивление = ЛУЧШЕ теплоизоляция → revers=False
|
||
- iProfileHeight (см) → МЕНЬШЕ высота в проёме = ЛУЧШЕ (экономия) → revers=True
|
||
- iProfileRabbet (мм) → БОЛЬШЕ высота фальца = ЛУЧШЕ (надежнее) → revers=False
|
||
- iProfileGlazingThickness (мм) → БОЛЬШЕ толщина = ЛУЧШЕ → revers=False
|
||
- iProfileThickness (мм) → БОЛЬШЕ толщина профиля = ЛУЧШЕ → revers=False
|
||
- fProfileSeals (контуры) → БОЛЬШЕ контуров = ЛУЧШЕ уплотнение → revers=False
|
||
- iProfileCamerasN (камер) → БОЛЬШЕ камер = ЛУЧШЕ теплоизоляция → revers=False
|
||
- NumOffer (кол-во предложений) → БОЛЬШЕ предложений = популярнее → revers=False
|
||
|
||
СТЕКЛОПАКЕТЫ (Glazing):
|
||
- fGlazingHeatTransfer (м²×°C/Вт) → БОЛЬШЕ сопротивление = ЛУЧШЕ теплоизоляция → revers=False
|
||
- fGlazingSoundproofing (дБ) → БОЛЬШЕ дБ = ЛУЧШЕ звукоизоляция → revers=False
|
||
- fGlazingLightTransmission (%) → БОЛЬШЕ светопропускание = ЛУЧШЕ видимость → revers=False ⚠️ ИСПРАВЛЕНО
|
||
- fGlazingPassingSun (%) → МЕНЬШЕ солнцепропускания = ЛУЧШЕ (летнее охлаждение) → revers=True
|
||
- iGlazingThickness (мм) → БОЛЬШЕ толщина = ЛУЧШЕ → revers=False
|
||
- iGlazingCamerasN (камер) → БОЛЬШЕ камер = ЛУЧШЕ теплоизоляция → revers=False
|
||
|
||
НАБОРЫ УСЛУГ (SetKit) - КОМБИНИРОВАННЫЙ РЕЙТИНГ:
|
||
Рейтинг набора = k1 (услуги) + k2 (стеклопакет) + k3 (профиль)
|
||
|
||
Параметры услуг ранжирования:
|
||
- dModify (дата последнего обновления) → МЕНЬШЕ дата = ЛУЧШЕ (свежее) → revers=True
|
||
- bSetDelivery (доставка включена) → БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
- bSetUninstallInstall (монтаж/демонтаж) → БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
- sSetSill (подоконник) → БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
- sSetPanes (водоотлив) → БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
- sSetSlope (откос) → БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
- sSetClimateControl (климат-контроль) → БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
- NumOffer (кол-во предложений) → БОЛЬШЕ = ЛУЧШЕ (популярность) → revers=False
|
||
- iDiscountVariantsCount (гибкость скидок) → БОЛЬШЕ вариантов = ЛУЧШЕ → revers=False
|
||
- fDiscountMax (размер скидок) → БОЛЬШЕ скидка = ЛУЧШЕ → revers=False
|
||
|
||
Веса компонентов набора в итоговом рейтинге:
|
||
- k1 (услуги): RARING_SET_MAX - RARING_WEIGHT_PVC_PROFILE_IN_SET - RARING_WEIGHT_GLAZING_IN_SET (остаток)
|
||
- k2 (стеклопакет): RARING_WEIGHT_GLAZING_IN_SET (обычно 1.5)
|
||
- k3 (профиль): RARING_WEIGHT_PVC_PROFILE_IN_SET (обычно 1.5)
|
||
- Итого: от 0.0 до 5.0 звёзд
|
||
|
||
ВАЖНО:
|
||
- sGlazingLightReflectance (строка "30/20") - НЕ РАНЖИРУЕТСЯ, это только информация
|
||
- В России отопление независимое, поэтому низкий SHGC (PassingSun) лучше для летнего охлаждения
|
||
- Рейтинг наборов зависит от качества входящих компонентов (профиль + стеклопакет) И услуг (доставка, монтаж и т.д.)
|
||
|
||
ТЕХНИЧЕСКАЯ ИНФОРМАЦИЯ:
|
||
=======================
|
||
- Функция GetRank() реализует алгоритм Mann-Whitney U test
|
||
- Prepare_PVC_Dictionary() исправляет данные перед ранжированием
|
||
* Конвертирует iProfileCamerasN из строки (например "3/3") в число суммированием цифр
|
||
* Для деревянных окон (камер = 0) ставит 1000 (максимум, т.к. дерево лучше)
|
||
* Для профилей с высотой < 10см ставит 1000 (не валидные данные)
|
||
|
||
- Prepare_GLAZ_Dictionary() исправляет данные стеклопакетов
|
||
* Для светопропускания/солнцепропускания < 1% ставит 10000 (нет данных = минимум)
|
||
|
||
"""
|
||
|
||
from django.core.management.base import BaseCommand
|
||
import json
|
||
import time
|
||
|
||
from oknardia.models import PVCprofiles, Glazing, SetKit
|
||
from oknardia.settings import (
|
||
RANK_PVCP_SOUNDPROOFING, RANK_PVCP_HEAT_TRANSFER,
|
||
RANK_PVCP_HEIGHT, RANK_PVCP_RABBET, RANK_PVCP_G_THICKNESS,
|
||
RANK_PVCP_THICKNESS, RANK_PVCP_SEALS, RANK_PVCP_CAMERAS_NUM,
|
||
RANK_PVCP_SOUNDPROOFING_NAME, RANK_PVCP_HEAT_TRANSFER_NAME,
|
||
RANK_PVCP_HEIGHT_NAME, RANK_PVCP_RABBET_NAME, RANK_PVCP_G_THICKNESS_NAME,
|
||
RANK_PVCP_THICKNESS_NAME, RANK_PVCP_SEALS_NAME, RANK_PVCP_CAMERAS_NUM_NAME,
|
||
RANK_PVCP_CAMERAS_POPULARITY_NAME,
|
||
RANK_STEP_SET_NUM_OFFER, RANK_STEP_SET_MODIFY, RANK_STEP_SET_DELIVERY,
|
||
RANK_STEP_SET_UNINSTALL_INSTALL, RANK_STEP_SET_SILL, RANK_STEP_SET_PANES,
|
||
RANK_STEP_SET_SLOPE, RANK_STEP_SET_CLIMATE_CONTROL,
|
||
RANK_STEP_DISCOUNT_FLEX, RANK_STEP_DISCOUNT_MAX,
|
||
RANK_GLAZ_SOUNDPROOFING, RANK_GLAZ_HEAT_TRANSFER,
|
||
RANK_GLAZ_LIGHT_TRANSMISSION, RANK_GLAZ_PASSING_SUN,
|
||
RANK_GLAZ_THICKNESS, RANK_GLAZ_CAMERAS_NUM,
|
||
RARING_PVC_PROFILE_MIN, RARING_PVC_PROFILE_MAX,
|
||
RARING_GLAZING_MIN, RARING_GLAZING_MAX,
|
||
RARING_SET_MAX, RARING_SET_MIN,
|
||
RARING_WEIGHT_PVC_PROFILE_IN_SET, RARING_WEIGHT_GLAZING_IN_SET,
|
||
KEY_RATING, KEY_RATING_VIRTUAL, KEY_DICSOUNT
|
||
)
|
||
from web.add_func import sum_through, normalize
|
||
|
||
|
||
def get_rank(set_dictionary, key, key_weight: float = 1, rank_name="", revers=False):
|
||
"""
|
||
Реализует алгоритм ранжирования Манна-Уитни (Mann-Whitney U Step Rank).
|
||
|
||
Алгоритм:
|
||
1. Сортируем список по значению ключа (от МЕНЬШЕГО к БОЛЬШЕМУ)
|
||
2. Если revers=True, разворачиваем список (от БОЛЬШЕГО к МЕНЬШЕМУ)
|
||
3. Начинаем с начального значения (минимум или максимум)
|
||
4. Проходим по списку, ПОВЫШАЕМ ранг на key_weight когда значение МЕНЯЕТСЯ
|
||
|
||
Параметры:
|
||
- set_dictionary: список словарей для ранжирования
|
||
- key: название поля/ключа для ранжирования
|
||
- key_weight: вес этого параметра в итоговом рейтинге
|
||
- rank_name: подпись названия параметра (для логирования/хранения)
|
||
- revers: True если МЕНЬШЕ = ЛУЧШЕ, False если БОЛЬШЕ = ЛУЧШЕ
|
||
|
||
Возвращает:
|
||
- (словарь с ранжированными объектами, максимальный ранг для параметра)
|
||
"""
|
||
new_set_dictionary = sorted(set_dictionary, key=lambda item: float(item[key]))
|
||
rank = 0
|
||
|
||
# Выбираем стартовое значение
|
||
if revers:
|
||
# ПО УБЫВАНИЮ: начинаем с МАКСИМУМА, повышаем ранг при УМЕНЬШЕНИИ
|
||
low_value = new_set_dictionary[-1][key]
|
||
new_set_dictionary = new_set_dictionary[::-1] # разворачиваем список
|
||
else:
|
||
# ПО ВОЗРАСТАНИЮ: начинаем с МИНИМУМА, повышаем ранг при УВЕЛИЧЕНИИ
|
||
low_value = new_set_dictionary[0][key]
|
||
|
||
# Проходим по отсортированному списку и присваиваем ранги
|
||
for i in new_set_dictionary:
|
||
# Инициализируем поля если их ещё нет
|
||
if "RatingConsist" not in i:
|
||
i.update({"RatingConsist": {}})
|
||
if "TmpRating" not in i:
|
||
i.update({"TmpRating": 0})
|
||
|
||
# Логика повышения ранга: при УЛУЧШЕНИИ параметра
|
||
if revers:
|
||
# МЕНЬШЕ = ЛУЧШЕ → повышаем ранг когда значение ПАДАЕТ
|
||
if i[key] < low_value:
|
||
low_value = i[key]
|
||
rank += key_weight
|
||
else:
|
||
# БОЛЬШЕ = ЛУЧШЕ → повышаем ранг когда значение РАСТЕТ
|
||
if i[key] > low_value:
|
||
low_value = i[key]
|
||
rank += key_weight
|
||
|
||
# Аккумулируем ранг в общий TmpRating
|
||
i["TmpRating"] += rank
|
||
i["RatingConsist"].update({rank_name: rank})
|
||
|
||
# Нормализуем ранги для этого параметра (0.0 … 1.0)
|
||
for i in new_set_dictionary:
|
||
# Если rank == 0, значит все значения одинаковые (ноль изменений)
|
||
if rank > 0:
|
||
i["RatingConsist"].update({rank_name: round(normalize(i["RatingConsist"][rank_name], val_max=rank), 3)})
|
||
else:
|
||
# Если нет различий, то все имеют одинаковый ранг (0.5 по нормализации)
|
||
i["RatingConsist"].update({rank_name: 0.5})
|
||
|
||
return new_set_dictionary, rank
|
||
|
||
|
||
def prepare_pvc_dictionary(profile_use_list):
|
||
"""
|
||
Конвертирует RawQuerySet в список словарей и исправляет данные для ранжирования.
|
||
|
||
Коррекции:
|
||
1. iProfileCameras: конвертирует строку "3/3" в число суммированием цифр
|
||
- Деревянные окна (число камер = 0) → ставим 1000 (максимум, т.к. дерево лучше)
|
||
2. iProfileHeight: для значений < 10 см → ставим 1000 (невалидные данные)
|
||
3. NumOffer: добавляем поле если его нет (количество коммерческих предложений)
|
||
|
||
:param profile_use_list: RawQuerySet с объектами профилей
|
||
:return: список словарей с исправленными данными
|
||
"""
|
||
pvc_dictionary = []
|
||
|
||
for profile in profile_use_list:
|
||
profile_dict = profile.__dict__.copy()
|
||
|
||
# Коррекция: количество камер из строки в число
|
||
if 'iProfileCameras' in profile_dict:
|
||
profile_dict['iProfileCameras'] = sum_through(str(profile_dict['iProfileCameras']))
|
||
# Деревянные окна (ноль камер) → ставим 1000 как максимум (они лучше для ранжирования)
|
||
if profile_dict['iProfileCameras'] == 0:
|
||
profile_dict['iProfileCameras'] = 1000
|
||
|
||
# Коррекция: невалидная высота в световом проёме
|
||
if 'iProfileHeight' in profile_dict and profile_dict['iProfileHeight'] < 10:
|
||
profile_dict['iProfileHeight'] = 1000
|
||
|
||
# Инициализация: количество коммерческих предложений
|
||
if 'NumOffer' not in profile_dict:
|
||
profile_dict['NumOffer'] = 0
|
||
|
||
pvc_dictionary.append(profile_dict)
|
||
|
||
return pvc_dictionary
|
||
|
||
|
||
def prepare_glaz_dictionary(glazing_use_list):
|
||
"""
|
||
Конвертирует RawQuerySet в список словарей и исправляет данные для ранжирования.
|
||
|
||
Коррекции:
|
||
1. fGlazingLightTransmission: если < 1% → ставим 10000 (нет данных о светопропускании)
|
||
2. fGlazingPassingSun: если < 1% → ставим 10000 (нет данных о солнцепропускании)
|
||
|
||
:param glazing_use_list: RawQuerySet с объектами стеклопакетов
|
||
:return: список словарей с исправленными данными
|
||
"""
|
||
glaz_dictionary = []
|
||
|
||
for glazing in glazing_use_list:
|
||
glazing_dict = glazing.__dict__.copy()
|
||
|
||
# Коррекция: светопропускание < 1% означает нет данных
|
||
if glazing_dict.get("fGlazingLightTransmission", 0) < 1:
|
||
glazing_dict["fGlazingLightTransmission"] = 10000
|
||
|
||
# Коррекция: солнцепропускание < 1% означает нет данных
|
||
if glazing_dict.get("fGlazingPassingSun", 0) < 1:
|
||
glazing_dict["fGlazingPassingSun"] = 10000
|
||
|
||
glaz_dictionary.append(glazing_dict)
|
||
|
||
return glaz_dictionary
|
||
|
||
|
||
def ranking_pvc(pvc_dictionary):
|
||
"""
|
||
Ранжирует профили по всем параметрам используя алгоритм Манна-Уитни.
|
||
|
||
Параметры ранжирования (в порядке применения):
|
||
1. Звукоизоляция (fProfileSoundproofing) - БОЛЬШЕ = ЛУЧШЕ
|
||
2. Сопротивление теплопередаче (fProfileHeatTransf) - БОЛЬШЕ = ЛУЧШЕ
|
||
3. Высота в световом проёме (iProfileHeight) - МЕНЬШЕ = ЛУЧШЕ
|
||
4. Высота фальца (iProfileRabbet) - БОЛЬШЕ = ЛУЧШЕ
|
||
5. Максимальная толщина стеклопакета (iProfileGlazingThickness) - БОЛЬШЕ = ЛУЧШЕ
|
||
6. Толщина профиля (iProfileThickness) - БОЛЬШЕ = ЛУЧШЕ
|
||
7. Контуры уплотнения (fProfileSeals) - БОЛЬШЕ = ЛУЧШЕ
|
||
8. Количество камер (iProfileCamerasN) - БОЛЬШЕ = ЛУЧШЕ
|
||
9. Популярность/кол-во предложений (NumOffer) - БОЛЬШЕ = ЛУЧШЕ
|
||
|
||
:param pvc_dictionary: список словарей с профилями
|
||
:return: (словарь со статистикой, ранжированный список словарей)
|
||
"""
|
||
dimension_to_template = {}
|
||
dimension_to_template.update({'NUM_PROFILE': len(pvc_dictionary)})
|
||
|
||
# 1. Звукоизоляция (дБ) - БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
pvc_dictionary, max_rank = get_rank(
|
||
pvc_dictionary,
|
||
"fProfileSoundproofing",
|
||
key_weight=RANK_PVCP_SOUNDPROOFING,
|
||
rank_name=RANK_PVCP_SOUNDPROOFING_NAME,
|
||
revers=False
|
||
)
|
||
|
||
# 2. Теплопередача (м²×°C/Вт) - БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
pvc_dictionary, max_rank = get_rank(
|
||
pvc_dictionary,
|
||
"fProfileHeatTransf",
|
||
key_weight=RANK_PVCP_HEAT_TRANSFER,
|
||
rank_name=RANK_PVCP_HEAT_TRANSFER_NAME,
|
||
revers=False
|
||
)
|
||
|
||
# 3. Высота в световом проёме (см) - МЕНЬШЕ = ЛУЧШЕ → revers=True
|
||
pvc_dictionary, max_rank = get_rank(
|
||
pvc_dictionary,
|
||
"iProfileHeight",
|
||
key_weight=RANK_PVCP_HEIGHT,
|
||
rank_name=RANK_PVCP_HEIGHT_NAME,
|
||
revers=True
|
||
)
|
||
|
||
# 4. Высота фальца (мм) - БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
pvc_dictionary, max_rank = get_rank(
|
||
pvc_dictionary,
|
||
"iProfileRabbet",
|
||
key_weight=RANK_PVCP_RABBET,
|
||
rank_name=RANK_PVCP_RABBET_NAME,
|
||
revers=False
|
||
)
|
||
|
||
# 5. Максимальная толщина стеклопакета (мм) - БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
pvc_dictionary, max_rank = get_rank(
|
||
pvc_dictionary,
|
||
"iProfileGlazingThickness",
|
||
key_weight=RANK_PVCP_G_THICKNESS,
|
||
rank_name=RANK_PVCP_G_THICKNESS_NAME,
|
||
revers=False
|
||
)
|
||
|
||
# 6. Монтажная ширина профиля (мм) - БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
pvc_dictionary, max_rank = get_rank(
|
||
pvc_dictionary,
|
||
"iProfileThickness",
|
||
key_weight=RANK_PVCP_THICKNESS,
|
||
rank_name=RANK_PVCP_THICKNESS_NAME,
|
||
revers=False
|
||
)
|
||
|
||
# 7. Контуры уплотнения - БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
pvc_dictionary, max_rank = get_rank(
|
||
pvc_dictionary,
|
||
"fProfileSeals",
|
||
key_weight=RANK_PVCP_SEALS,
|
||
rank_name=RANK_PVCP_SEALS_NAME,
|
||
revers=False
|
||
)
|
||
|
||
# 8. Количество камер - БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
pvc_dictionary, max_rank = get_rank(
|
||
pvc_dictionary,
|
||
"iProfileCameras",
|
||
key_weight=RANK_PVCP_CAMERAS_NUM,
|
||
rank_name=RANK_PVCP_CAMERAS_NUM_NAME,
|
||
revers=False
|
||
)
|
||
|
||
# 9. Популярность (кол-во коммерческих предложений) - БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
pvc_dictionary, max_rank = get_rank(
|
||
pvc_dictionary,
|
||
"NumOffer",
|
||
key_weight=RANK_STEP_SET_NUM_OFFER,
|
||
rank_name=RANK_PVCP_CAMERAS_POPULARITY_NAME,
|
||
revers=False
|
||
)
|
||
|
||
return dimension_to_template, pvc_dictionary
|
||
|
||
|
||
def prepare_setkit_dictionary(setkit_use_list):
|
||
"""
|
||
Конвертирует RawQuerySet в список словарей и исправляет данные для ранжирования.
|
||
|
||
Коррекции:
|
||
1. Строковые поля (sSetSill, sSetPanes, sSetSlope, sSetClimateControl) преобразуются в 0/1
|
||
2. sOfficeDiscountMetaFormula парсится для максимальной скидки и количества вариантов
|
||
3. dModify (datetime) преобразуется в timestamp (число) для ранжирования
|
||
4. Логические поля должны быть числами для алгоритма ранжирования
|
||
|
||
:param setkit_use_list: RawQuerySet с объектами наборов
|
||
:return: список словарей с исправленными данными
|
||
"""
|
||
import datetime
|
||
|
||
setkit_dictionary = []
|
||
|
||
for setkit in setkit_use_list:
|
||
setkit_dict = setkit.__dict__.copy()
|
||
|
||
# Коррекция: преобразуем дату в timestamp для ранжирования
|
||
# Свежие данные (большие timestamp) должны иметь более высокий ранг
|
||
if 'dModify' in setkit_dict and setkit_dict['dModify']:
|
||
# Если это datetime-объект, конвертируем в timestamp
|
||
if isinstance(setkit_dict['dModify'], datetime.datetime):
|
||
setkit_dict['dModify'] = setkit_dict['dModify'].timestamp()
|
||
elif isinstance(setkit_dict['dModify'], datetime.date):
|
||
# Если это просто date, конвертируем в datetime сначала
|
||
dt = datetime.datetime.combine(setkit_dict['dModify'], datetime.time())
|
||
setkit_dict['dModify'] = dt.timestamp()
|
||
else:
|
||
# Если это строка, пытаемся распарсить
|
||
try:
|
||
dt = datetime.datetime.fromisoformat(str(setkit_dict['dModify']))
|
||
setkit_dict['dModify'] = dt.timestamp()
|
||
except:
|
||
setkit_dict['dModify'] = 0 # Если не смогли распарсить, ставим 0
|
||
else:
|
||
setkit_dict['dModify'] = 0 # Если нет даты, ставим 0
|
||
|
||
# Коррекция: преобразуем строковые поля в 0/1
|
||
# Подоконник: если нет, — то 0, иначе 1
|
||
if setkit_dict.get("sSetSill", "").lower() in ["нет", "-", "—", "", " "]:
|
||
setkit_dict["sSetSill"] = 0
|
||
else:
|
||
setkit_dict["sSetSill"] = 1
|
||
|
||
# Водоотлив: если нет, — то 0, иначе 1
|
||
if setkit_dict.get("sSetPanes", "").lower() in ["нет", "-", "—", "", " "]:
|
||
setkit_dict["sSetPanes"] = 0
|
||
else:
|
||
setkit_dict["sSetPanes"] = 1
|
||
|
||
# Откос: если нет, — то 0, иначе 1
|
||
if setkit_dict.get("sSetSlope", "").lower() in ["нет", "-", "—", "", " "]:
|
||
setkit_dict["sSetSlope"] = 0
|
||
else:
|
||
setkit_dict["sSetSlope"] = 1
|
||
|
||
# Климат-контроль: если нет, — то 0, иначе 1
|
||
if setkit_dict.get("sSetClimateControl", "").lower() in ["нет", "-", "—", "", " "]:
|
||
setkit_dict["sSetClimateControl"] = 0
|
||
else:
|
||
setkit_dict["sSetClimateControl"] = 1
|
||
|
||
# Парсим формулу скидок офиса и извлекаем информацию о скидках
|
||
try:
|
||
import json as json_module
|
||
discount_formula = json_module.loads(setkit_dict.get("sOfficeDiscountMetaFormula", "{}"))
|
||
discount_values = discount_formula.get(KEY_DICSOUNT, {})
|
||
|
||
# Количество вариантов скидок
|
||
setkit_dict["iDiscountVariantsCount"] = len(discount_values.keys()) if discount_values else 0
|
||
|
||
# Максимальная скидка из всех вариантов
|
||
if discount_values:
|
||
setkit_dict["fDiscountMax"] = float(max(discount_values.values()))
|
||
else:
|
||
setkit_dict["fDiscountMax"] = 0.0
|
||
|
||
except (ValueError, KeyError, AttributeError):
|
||
# Если парс неудался, то скидок нет
|
||
setkit_dict["iDiscountVariantsCount"] = 0
|
||
setkit_dict["fDiscountMax"] = 0.0
|
||
|
||
# Инициализация: количество коммерческих предложений
|
||
if 'NumOffer' not in setkit_dict:
|
||
setkit_dict['NumOffer'] = 0
|
||
|
||
setkit_dictionary.append(setkit_dict)
|
||
|
||
return setkit_dictionary
|
||
|
||
|
||
def ranking_setkit(setkit_dictionary):
|
||
"""
|
||
Ранжирует наборы (SetKit) по всем параметрам используя алгоритм Манна-Уитни.
|
||
|
||
Параметры ранжирования (в порядке применения):
|
||
1. Актуальность — дата последнего обновления (dModify) ← МЕНЬШЕ=ЛУЧШЕ (свежее) → revers=True
|
||
2. Доставка (bSetDelivery) — включена ли в стоимость → БОЛЬШЕ=ЛУЧШЕ
|
||
3. Монтаж/демонтаж (bSetUninstallInstall) — включён ли → БОЛЬШЕ=ЛУЧШЕ
|
||
4. Подоконник (sSetSill) — включён ли → БОЛЬШЕ=ЛУЧШЕ
|
||
5. Водоотлив (sSetPanes) — включён ли → БОЛЬШЕ=ЛУЧШЕ
|
||
6. Откос (sSetSlope) — включён ли → БОЛЬШЕ=ЛУЧШЕ
|
||
7. Климат-контроль (sSetClimateControl) — включён ли → БОЛЬШЕ=ЛУЧШЕ
|
||
8. Число предложений (NumOffer) — популярность → БОЛЬШЕ=ЛУЧШЕ
|
||
9. Гибкость скидок (iDiscountVariantsCount) — кол-во вариантов → БОЛЬШЕ=ЛУЧШЕ
|
||
10. Размер скидок (fDiscountMax) — максимальная скидка → БОЛЬШЕ=ЛУЧШЕ
|
||
|
||
:param setkit_dictionary: список словарей с наборами
|
||
:return: ранжированный список словарей
|
||
"""
|
||
|
||
# 1. Актуальность (дата последнего обновления) - МЕНЬШЕ = ЛУЧШЕ → revers=True
|
||
setkit_dictionary, _ = get_rank(
|
||
setkit_dictionary,
|
||
"dModify",
|
||
key_weight=RANK_STEP_SET_MODIFY,
|
||
rank_name="Актуальность",
|
||
revers=True
|
||
)
|
||
|
||
# 2. Доставка включена в стоимость - БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
setkit_dictionary, _ = get_rank(
|
||
setkit_dictionary,
|
||
"bSetDelivery",
|
||
key_weight=RANK_STEP_SET_DELIVERY,
|
||
rank_name="Доставка",
|
||
revers=False
|
||
)
|
||
|
||
# 3. Монтаж/демонтаж включен - БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
setkit_dictionary, _ = get_rank(
|
||
setkit_dictionary,
|
||
"bSetUninstallInstall",
|
||
key_weight=RANK_STEP_SET_UNINSTALL_INSTALL,
|
||
rank_name="Монтаж",
|
||
revers=False
|
||
)
|
||
|
||
# 4. Подоконник включен - БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
setkit_dictionary, _ = get_rank(
|
||
setkit_dictionary,
|
||
"sSetSill",
|
||
key_weight=RANK_STEP_SET_SILL,
|
||
rank_name="Подоконник",
|
||
revers=False
|
||
)
|
||
|
||
# 5. Водоотлив включен - БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
setkit_dictionary, _ = get_rank(
|
||
setkit_dictionary,
|
||
"sSetPanes",
|
||
key_weight=RANK_STEP_SET_PANES,
|
||
rank_name="Водоотлив",
|
||
revers=False
|
||
)
|
||
|
||
# 6. Откос включен - БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
setkit_dictionary, _ = get_rank(
|
||
setkit_dictionary,
|
||
"sSetSlope",
|
||
key_weight=RANK_STEP_SET_SLOPE,
|
||
rank_name="Откос",
|
||
revers=False
|
||
)
|
||
|
||
# 7. Климат-контроль включен - БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
setkit_dictionary, _ = get_rank(
|
||
setkit_dictionary,
|
||
"sSetClimateControl",
|
||
key_weight=RANK_STEP_SET_CLIMATE_CONTROL,
|
||
rank_name="Климат-контроль",
|
||
revers=False
|
||
)
|
||
|
||
# 8. Число предложений (популярность) - БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
setkit_dictionary, _ = get_rank(
|
||
setkit_dictionary,
|
||
"NumOffer",
|
||
key_weight=RANK_STEP_SET_NUM_OFFER,
|
||
rank_name="Число предложений",
|
||
revers=False
|
||
)
|
||
|
||
# 9. Гибкость скидок (количество вариантов) - БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
setkit_dictionary, _ = get_rank(
|
||
setkit_dictionary,
|
||
"iDiscountVariantsCount",
|
||
key_weight=RANK_STEP_DISCOUNT_FLEX,
|
||
rank_name="Гибкость скидок",
|
||
revers=False
|
||
)
|
||
|
||
# 10. Размер скидок (максимальная скидка) - БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
setkit_dictionary, _ = get_rank(
|
||
setkit_dictionary,
|
||
"fDiscountMax",
|
||
key_weight=RANK_STEP_DISCOUNT_MAX,
|
||
rank_name="Размер скидок",
|
||
revers=False
|
||
)
|
||
|
||
return setkit_dictionary
|
||
|
||
|
||
def ranking_glazing(glaz_dictionary):
|
||
"""
|
||
Ранжирует стеклопакеты по всем параметрам используя алгоритм Манна-Уитни.
|
||
|
||
Параметры ранжирования (в порядке применения):
|
||
1. Звукоизоляция (fGlazingSoundproofing) - БОЛЬШЕ = ЛУЧШЕ
|
||
2. Сопротивление теплопередаче (fGlazingHeatTransfer) - БОЛЬШЕ = ЛУЧШЕ
|
||
3. Светопропускание (fGlazingLightTransmission) - БОЛЬШЕ = ЛУЧШЕ ⚠️ ИСПРАВЛЕНО
|
||
4. Солнцепропускание (fGlazingPassingSun) - МЕНЬШЕ = ЛУЧШЕ (летнее охлаждение в РФ)
|
||
5. Толщина стеклопакета (iGlazingThickness) - БОЛЬШЕ = ЛУЧШЕ
|
||
6. Количество камер (iGlazingCamerasN) - БОЛЬШЕ = ЛУЧШЕ
|
||
|
||
ВАЖНО: sGlazingLightReflectance (строка "30/20") НЕ ранжируется - только информация!
|
||
|
||
:param glaz_dictionary: список словарей со стеклопакетами
|
||
:return: (словарь со статистикой, ранжированный список словарей)
|
||
"""
|
||
# ... existing code ...
|
||
|
||
# 1. Звукоизоляция (дБ) - БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
glaz_dictionary, max_rank = get_rank(
|
||
glaz_dictionary,
|
||
"fGlazingSoundproofing",
|
||
key_weight=RANK_GLAZ_SOUNDPROOFING,
|
||
rank_name=RANK_PVCP_SOUNDPROOFING_NAME,
|
||
revers=False
|
||
)
|
||
|
||
# 2. Теплопередача (м²×°C/Вт) - БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
glaz_dictionary, max_rank = get_rank(
|
||
glaz_dictionary,
|
||
"fGlazingHeatTransfer",
|
||
key_weight=RANK_GLAZ_HEAT_TRANSFER,
|
||
rank_name=RANK_PVCP_HEAT_TRANSFER_NAME,
|
||
revers=False
|
||
)
|
||
|
||
# 3. Светопропускание (%) - БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
# БОЛЬШЕ света в помещение = ЛУЧШЕ освещенность!
|
||
glaz_dictionary, max_rank = get_rank(
|
||
glaz_dictionary,
|
||
"fGlazingLightTransmission",
|
||
key_weight=RANK_GLAZ_LIGHT_TRANSMISSION,
|
||
rank_name="Светопропускание",
|
||
revers=False
|
||
)
|
||
|
||
# 4. Солнцепропускание (%) - МЕНЬШЕ = ЛУЧШЕ → revers=True
|
||
# В России отопление независимое, поэтому меньше солнечного нагрева = лучше для лета
|
||
# На внутреннем стекле напыление отражает тепло, не пуская его в квартиру
|
||
glaz_dictionary, max_rank = get_rank(
|
||
glaz_dictionary,
|
||
"fGlazingPassingSun",
|
||
key_weight=RANK_GLAZ_PASSING_SUN,
|
||
rank_name="Солнцепропускание",
|
||
revers=True
|
||
)
|
||
|
||
# 5. Толщина стеклопакета (мм) - БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
glaz_dictionary, max_rank = get_rank(
|
||
glaz_dictionary,
|
||
"iGlazingThickness",
|
||
key_weight=RANK_GLAZ_THICKNESS,
|
||
rank_name="Толщина",
|
||
revers=False
|
||
)
|
||
|
||
# 6. Количество камер - БОЛЬШЕ = ЛУЧШЕ → revers=False
|
||
glaz_dictionary, max_rank = get_rank(
|
||
glaz_dictionary,
|
||
"iGlazingCamerasN",
|
||
key_weight=RANK_GLAZ_CAMERAS_NUM,
|
||
rank_name="Камеры",
|
||
revers=False
|
||
)
|
||
|
||
# ПРОПУСКАЕМ: sGlazingLightReflectance это СТРОКА ("30/20"), не число!
|
||
# Не ранжируем, только информация об отражении света
|
||
|
||
return {}, glaz_dictionary
|
||
|
||
|
||
class Command(BaseCommand):
|
||
help = 'Пересчитывает рейтинги профилей и стеклопакетов используя Mann-Whitney метод'
|
||
|
||
def add_arguments(self, parser):
|
||
# Django уже добавляет --verbosity автоматически
|
||
# 0 = минимум, 1 = нормально, 2 = подробно, 3 = очень подробно
|
||
pass
|
||
|
||
def format_profile_table(self, profile_item, profile_obj):
|
||
"""Форматирует таблицу характеристик профиля для подробного вывода"""
|
||
output = []
|
||
output.append(f"\n {'='*100}")
|
||
output.append(f" ПРОФИЛЬ: {profile_obj.sProfileName} (ID: {profile_item['id']})")
|
||
output.append(f" {'='*100}")
|
||
|
||
# Основные параметры
|
||
if 'RatingConsist' in profile_item:
|
||
output.append(f" {'Характеристика':<30} {'Значение':<15} {'Ранг (0..1)':<15} {'Вклад':<15}")
|
||
output.append(f" {'-'*100}")
|
||
|
||
for param_name, rank_value in sorted(profile_item['RatingConsist'].items()):
|
||
# Получаем значение параметра из словаря
|
||
if param_name == RANK_PVCP_SOUNDPROOFING_NAME and 'fProfileSoundproofing' in profile_item:
|
||
value = f"{profile_item['fProfileSoundproofing']:.2f} дБ"
|
||
elif param_name == RANK_PVCP_HEAT_TRANSFER_NAME and 'fProfileHeatTransf' in profile_item:
|
||
value = f"{profile_item['fProfileHeatTransf']:.2f} Ro"
|
||
elif param_name == RANK_PVCP_HEIGHT_NAME and 'iProfileHeight' in profile_item:
|
||
value = f"{profile_item['iProfileHeight']} мм"
|
||
elif param_name == RANK_PVCP_RABBET_NAME and 'iProfileRabbet' in profile_item:
|
||
value = f"{profile_item['iProfileRabbet']} мм"
|
||
elif param_name == RANK_PVCP_G_THICKNESS_NAME and 'iProfileGlazingThickness' in profile_item:
|
||
value = f"{profile_item['iProfileGlazingThickness']} мм"
|
||
elif param_name == RANK_PVCP_THICKNESS_NAME and 'iProfileThickness' in profile_item:
|
||
value = f"{profile_item['iProfileThickness']} мм"
|
||
elif param_name == RANK_PVCP_SEALS_NAME and 'fProfileSeals' in profile_item:
|
||
value = f"{profile_item['fProfileSeals']} контуров"
|
||
elif param_name == RANK_PVCP_CAMERAS_NUM_NAME and 'iProfileCameras' in profile_item:
|
||
value = f"{profile_item['iProfileCameras']} шт"
|
||
elif param_name == RANK_PVCP_CAMERAS_POPULARITY_NAME and 'NumOffer' in profile_item:
|
||
value = f"{profile_item['NumOffer']} предл."
|
||
else:
|
||
value = "—"
|
||
|
||
rank_str = f"{rank_value:.3f}" if isinstance(rank_value, float) else str(rank_value)
|
||
output.append(f" {param_name:<30} {value:<15} {rank_value:.3f} {'*' * int(float(rank_str)*5):<15}")
|
||
|
||
output.append(f" {'-'*100}")
|
||
output.append(f" ИТОГО: Рейтинг = {profile_obj.fProfileRating:.2f}/5.0 "
|
||
f"{'*' * int(profile_obj.fProfileRating)}")
|
||
|
||
return "\n".join(output)
|
||
|
||
def format_glazing_table(self, glazing_item, glazing_obj):
|
||
"""Форматирует таблицу характеристик стеклопакета для подробного вывода"""
|
||
output = []
|
||
output.append(f"\n {'='*100}")
|
||
output.append(f" СТЕКЛОПАКЕТ: {glazing_obj.sGlazingName} (ID: {glazing_item['id']}) | Марка:"
|
||
f"{glazing_obj.sGlazingMark}")
|
||
output.append(f" {'='*100}")
|
||
|
||
# Основные параметры
|
||
if 'RatingConsist' in glazing_item:
|
||
output.append(f" {'Характеристика':<35} {'Значение':<20} {'Ранг (0..1)':<15} {'Вклад':<15}")
|
||
output.append(f" {'-'*100}")
|
||
|
||
for param_name, rank_value in sorted(glazing_item['RatingConsist'].items()):
|
||
# Получаем значение параметра из словаря
|
||
if param_name == "Звукоизоляция" and 'fGlazingSoundproofing' in glazing_item:
|
||
value = f"{glazing_item['fGlazingSoundproofing']:.2f} дБ"
|
||
elif param_name == "Теплопередача" and 'fGlazingHeatTransfer' in glazing_item:
|
||
value = f"{glazing_item['fGlazingHeatTransfer']:.2f} Ro"
|
||
elif param_name == "Светопропускание" and 'fGlazingLightTransmission' in glazing_item:
|
||
value = f"{glazing_item['fGlazingLightTransmission']:.2f}%"
|
||
elif param_name == "Солнцепропускание" and 'fGlazingPassingSun' in glazing_item:
|
||
value = f"{glazing_item['fGlazingPassingSun']:.2f}%"
|
||
elif param_name == "Толщина" and 'iGlazingThickness' in glazing_item:
|
||
value = f"{glazing_item['iGlazingThickness']} мм"
|
||
elif param_name == "Число камер" and 'iGlazingCamerasN' in glazing_item:
|
||
value = f"{glazing_item['iGlazingCamerasN']} камер"
|
||
else:
|
||
value = "—"
|
||
|
||
rank_str = f"{rank_value:.3f}" if isinstance(rank_value, float) else str(rank_value)
|
||
output.append(f" {param_name:<35} {value:<20} {rank_value:.3f} {'*' * int(float(rank_str)*5):<15}")
|
||
|
||
output.append(f" {'-'*100}")
|
||
output.append(f" ИТОГО: Рейтинг = {glazing_obj.fGlazingRating:.2f}/5.0 "
|
||
f"{'*' * int(glazing_obj.fGlazingRating)}")
|
||
|
||
return "\n".join(output)
|
||
|
||
def format_setkit_table(self, setkit_item, setkit_obj):
|
||
"""Форматирует таблицу характеристик набора для подробного вывода"""
|
||
output = []
|
||
output.append(f"\n {'='*120}")
|
||
output.append(f" НАБОР: {setkit_obj.sSetName} (ID: {setkit_item['id']})")
|
||
output.append(f" {'='*120}")
|
||
|
||
# Основные параметры из RatingConsist
|
||
if 'RatingConsist' in setkit_item:
|
||
output.append(f" {'Параметр':<35} {'Значение':<20} {'Ранг (0..1)':<15} {'Вклад':<15}")
|
||
output.append(f" {'-'*120}")
|
||
|
||
for param_name, rank_value in sorted(setkit_item['RatingConsist'].items()):
|
||
# Извлекаем значение параметра
|
||
if param_name == "Актуальность":
|
||
# dModify кодируется в специальный формат, просто показываем дату
|
||
value = "свежий" if setkit_item.get("dModify") else "старый"
|
||
elif param_name == "Доставка" and 'bSetDelivery' in setkit_item:
|
||
value = "✓ Да" if setkit_item['bSetDelivery'] else "✗ Нет"
|
||
elif param_name == "Монтаж" and 'bSetUninstallInstall' in setkit_item:
|
||
value = "✓ Да" if setkit_item['bSetUninstallInstall'] else "✗ Нет"
|
||
elif param_name == "Подоконник" and 'sSetSill' in setkit_item:
|
||
value = "✓ Да" if setkit_item['sSetSill'] else "✗ Нет"
|
||
elif param_name == "Водоотлив" and 'sSetPanes' in setkit_item:
|
||
value = "✓ Да" if setkit_item['sSetPanes'] else "✗ Нет"
|
||
elif param_name == "Откос" and 'sSetSlope' in setkit_item:
|
||
value = "✓ Да" if setkit_item['sSetSlope'] else "✗ Нет"
|
||
elif param_name == "Климат-контроль" and 'sSetClimateControl' in setkit_item:
|
||
value = "✓ Да" if setkit_item['sSetClimateControl'] else "✗ Нет"
|
||
elif param_name == "Число предложений" and 'NumOffer' in setkit_item:
|
||
value = f"{setkit_item['NumOffer']} шт"
|
||
elif param_name == "Гибкость скидок" and 'iDiscountVariantsCount' in setkit_item:
|
||
value = f"{setkit_item['iDiscountVariantsCount']} вариантов"
|
||
elif param_name == "Размер скидок" and 'fDiscountMax' in setkit_item:
|
||
value = f"{setkit_item['fDiscountMax']:.1f}%"
|
||
else:
|
||
value = "—"
|
||
|
||
rank_str = f"{rank_value:.3f}" if isinstance(rank_value, float) else str(rank_value)
|
||
output.append(f" {param_name:<35} {value:<20} {rank_value:.3f} {'*' * int(float(rank_str)*5):<15}")
|
||
|
||
output.append(f" {'-'*120}")
|
||
output.append(f" ИТОГО: Рейтинг = {setkit_obj.fSetRating:.2f}/5.0 {'*' * int(setkit_obj.fSetRating)}")
|
||
|
||
return "\n".join(output)
|
||
|
||
def handle(self, *args, **options):
|
||
verbose = int(options.get('verbosity', 1))
|
||
|
||
time_start = time.perf_counter()
|
||
|
||
self.stdout.write(self.style.SUCCESS('=== НАЧАЛИ ПЕРЕСЧЁТ РЕЙТИНГОВ ==='))
|
||
|
||
# ========== РАНЖИРОВАНИЕ ПРОФИЛЕЙ ==========
|
||
self.stdout.write('\n========================================')
|
||
self.stdout.write('[ЭТАП 1]: Пересчёт рейтингов ПРОФИЛЕЙ...')
|
||
self.stdout.write('========================================\n')
|
||
|
||
# Обнуляем все рейтинги профилей
|
||
profile_all_num = PVCprofiles.objects.all().update(fProfileRating=0.0)
|
||
self.stdout.write(f' ✓ Обнулены рейтинги у {profile_all_num} профилей')
|
||
|
||
# Извлекаем профили которые используются в коммерческих предложениях
|
||
q = PVCprofiles.objects.raw(
|
||
"SELECT oknardia_pvcprofiles.*, COUNT(oknardia_priceoffer.id) AS NumOffer "
|
||
"FROM oknardia_setkit "
|
||
"INNER JOIN oknardia_priceoffer "
|
||
" ON oknardia_setkit.id = oknardia_priceoffer.kOffer2SetKit_id "
|
||
"RIGHT OUTER JOIN oknardia_pvcprofiles "
|
||
" ON oknardia_setkit.kSet2PVCprofiles_id = oknardia_pvcprofiles.id "
|
||
"GROUP BY oknardia_pvcprofiles.id"
|
||
)
|
||
profile_use_list = list(q)
|
||
self.stdout.write(f' ✓ Найдено {len(profile_use_list)} профилей для ранжирования')
|
||
|
||
# Подготавливаем словарь профилей с коррекциями
|
||
pvc_dictionary = prepare_pvc_dictionary(profile_use_list)
|
||
|
||
# Ранжируем профили
|
||
dim, pvc_dictionary = ranking_pvc(pvc_dictionary)
|
||
|
||
# Сортируем по рейтингу
|
||
pvc_dictionary = sorted(pvc_dictionary, key=lambda item: item["TmpRating"])
|
||
|
||
# Нахождение минимального и максимального рейтинга
|
||
num_max_rank = 0
|
||
num_min_rank = -1
|
||
for j, i in enumerate(pvc_dictionary):
|
||
if i["NumOffer"] != 0:
|
||
num_max_rank = j
|
||
if num_min_rank == -1:
|
||
num_min_rank = j
|
||
|
||
# Сохраняем финальные рейтинги в БД
|
||
for j, i in enumerate(pvc_dictionary):
|
||
obj = PVCprofiles.objects.get(id=i["id"])
|
||
|
||
# Загружаем JSON описание профиля
|
||
try:
|
||
getted_json = json.loads(obj.sProfileDescription)
|
||
except:
|
||
getted_json = {}
|
||
|
||
# Обновляем JSON рейтингом
|
||
if i["NumOffer"] != 0:
|
||
try:
|
||
del getted_json[KEY_RATING_VIRTUAL]
|
||
except:
|
||
pass
|
||
getted_json[KEY_RATING] = i["RatingConsist"]
|
||
else:
|
||
try:
|
||
del getted_json[KEY_RATING]
|
||
except:
|
||
pass
|
||
getted_json[KEY_RATING_VIRTUAL] = i["RatingConsist"]
|
||
|
||
obj.sProfileDescription = json.dumps(
|
||
getted_json,
|
||
separators=(",", ":"),
|
||
sort_keys=True,
|
||
ensure_ascii=False
|
||
)
|
||
|
||
# Вычисляем финальный рейтинг (0.0 … 5.0 звёзд)
|
||
if j <= num_max_rank:
|
||
obj.fProfileRating = (
|
||
normalize(i["TmpRating"], pvc_dictionary[num_max_rank]["TmpRating"]) *
|
||
(RARING_PVC_PROFILE_MAX - RARING_PVC_PROFILE_MIN) +
|
||
RARING_PVC_PROFILE_MIN
|
||
)
|
||
else:
|
||
obj.fProfileRating = 5.0
|
||
|
||
obj.save()
|
||
|
||
# Подробный вывод в режиме verbosity >= 3
|
||
if verbose >= 3:
|
||
self.stdout.write(self.format_profile_table(i, obj))
|
||
|
||
self.stdout.write(f' ✓ Сохранено {len(pvc_dictionary)} профилей с финальными рейтингами')
|
||
|
||
# ========== РАНЖИРОВАНИЕ СТЕКЛОПАКЕТОВ ==========
|
||
self.stdout.write('\n=============================================')
|
||
self.stdout.write('[ЭТАП 2]: Пересчёт рейтингов СТЕКЛОПАКЕТОВ...')
|
||
self.stdout.write('=============================================\n')
|
||
|
||
# Обнуляем все рейтинги стеклопакетов
|
||
glazing_all_num = Glazing.objects.all().update(fGlazingRating=0.0)
|
||
self.stdout.write(f' ✓ Обнулены рейтинги у {glazing_all_num} стеклопакетов')
|
||
|
||
# Извлекаем стеклопакеты которые используются в коммерческих предложениях
|
||
q = Glazing.objects.raw(
|
||
"SELECT oknardia_glazing.*, COUNT(oknardia_priceoffer.id) AS NumOffer "
|
||
"FROM oknardia_setkit "
|
||
"INNER JOIN oknardia_priceoffer "
|
||
" ON oknardia_setkit.id = oknardia_priceoffer.kOffer2SetKit_id "
|
||
"RIGHT OUTER JOIN oknardia_glazing "
|
||
" ON oknardia_setkit.kSet2Glazing_id = oknardia_glazing.id "
|
||
"GROUP BY oknardia_glazing.id"
|
||
)
|
||
glazing_use_list = list(q)
|
||
self.stdout.write(f' ✓ Найдено {len(glazing_use_list)} стеклопакетов для ранжирования')
|
||
|
||
# Подготавливаем словарь стеклопакетов с коррекциями
|
||
glaz_dictionary = prepare_glaz_dictionary(glazing_use_list)
|
||
|
||
# Ранжируем стеклопакеты
|
||
dim, glaz_dictionary = ranking_glazing(glaz_dictionary)
|
||
|
||
# Сортируем по рейтингу
|
||
glaz_dictionary = sorted(glaz_dictionary, key=lambda item: item["TmpRating"])
|
||
|
||
# Нахождение минимального и максимального рейтинга
|
||
num_max_rank = 0
|
||
num_min_rank = -1
|
||
for j, i in enumerate(glaz_dictionary):
|
||
if i["NumOffer"] != 0:
|
||
num_max_rank = j
|
||
if num_min_rank == -1:
|
||
num_min_rank = j
|
||
|
||
# Сохраняем финальные рейтинги в БД
|
||
for j, i in enumerate(glaz_dictionary):
|
||
obj = Glazing.objects.get(id=i["id"])
|
||
|
||
# Загружаем JSON описание стеклопакета
|
||
try:
|
||
getted_json = json.loads(obj.sGlazingDescription)
|
||
except:
|
||
getted_json = {}
|
||
|
||
# Обновляем JSON рейтингом
|
||
if i["NumOffer"] != 0:
|
||
try:
|
||
del getted_json[KEY_RATING_VIRTUAL]
|
||
except:
|
||
pass
|
||
getted_json[KEY_RATING] = i["RatingConsist"]
|
||
else:
|
||
try:
|
||
del getted_json[KEY_RATING]
|
||
except:
|
||
pass
|
||
getted_json[KEY_RATING_VIRTUAL] = i["RatingConsist"]
|
||
|
||
obj.sGlazingDescription = json.dumps(
|
||
getted_json,
|
||
separators=(",", ":"),
|
||
sort_keys=True,
|
||
ensure_ascii=False
|
||
)
|
||
|
||
# Вычисляем финальный рейтинг (0.0 … 5.0 звёзд)
|
||
if j <= num_max_rank:
|
||
obj.fGlazingRating = (
|
||
normalize(i["TmpRating"], glaz_dictionary[num_max_rank]["TmpRating"]) *
|
||
(RARING_GLAZING_MAX - RARING_GLAZING_MIN) +
|
||
RARING_GLAZING_MIN
|
||
)
|
||
else:
|
||
obj.fGlazingRating = 5.0
|
||
|
||
obj.save()
|
||
|
||
# Подробный вывод в режиме verbosity >= 3
|
||
if verbose >= 3:
|
||
self.stdout.write(self.format_glazing_table(i, obj))
|
||
|
||
self.stdout.write(f' ✓ Сохранено {len(glaz_dictionary)} стеклопакетов с финальными рейтингами')
|
||
|
||
# ========== РАНЖИРОВАНИЕ НАБОРОВ ==========
|
||
self.stdout.write('\n================================================')
|
||
self.stdout.write('[ЭТАП 3]: Пересчёт рейтингов НАБОРОВ (SetKit)...')
|
||
self.stdout.write('================================================\n')
|
||
|
||
# Обнуляем все рейтинги наборов
|
||
setkit_all_num = SetKit.objects.all().update(fSetRating=0.0)
|
||
self.stdout.write(f' ✓ Обнулены рейтинги у {setkit_all_num} наборов')
|
||
|
||
# Извлекаем наборы которые используются в коммерческих предложениях
|
||
q = SetKit.objects.raw(
|
||
"SELECT oknardia_setkit.*, COUNT(oknardia_priceoffer.id) AS NumOffer, "
|
||
"MAX(oknardia_priceoffer.dOfferModify) AS dModify, "
|
||
"oknardia_pvcprofiles.fProfileRating, "
|
||
"oknardia_glazing.fGlazingRating, "
|
||
"oknardia_merchantoffice.sOfficeDiscountMetaFormula "
|
||
"FROM oknardia_setkit "
|
||
"INNER JOIN oknardia_priceoffer "
|
||
" ON oknardia_priceoffer.kOffer2SetKit_id = oknardia_setkit.id "
|
||
"INNER JOIN oknardia_glazing "
|
||
" ON oknardia_setkit.kSet2Glazing_id = oknardia_glazing.id "
|
||
"INNER JOIN oknardia_pvcprofiles "
|
||
" ON oknardia_pvcprofiles.id = oknardia_setkit.kSet2PVCprofiles_id "
|
||
"INNER JOIN oknardia_ouruser "
|
||
" ON oknardia_setkit.kSet2User_id = oknardia_ouruser.id "
|
||
"INNER JOIN oknardia_merchantoffice "
|
||
" ON oknardia_ouruser.kMerchantOffice_id = oknardia_merchantoffice.id "
|
||
"WHERE oknardia_setkit.sSetActive = TRUE "
|
||
"GROUP BY oknardia_pvcprofiles.fProfileRating, "
|
||
" oknardia_glazing.fGlazingRating, "
|
||
" oknardia_merchantoffice.sOfficeDiscountMetaFormula, "
|
||
" oknardia_setkit.sSetActive, oknardia_setkit.id "
|
||
"ORDER BY MAX(oknardia_priceoffer.dOfferModify)"
|
||
)
|
||
|
||
setkit_use_list = list(q)
|
||
self.stdout.write(f' ✓ Найдено {len(setkit_use_list)} наборов для ранжирования')
|
||
|
||
# Подготавливаем словарь наборов с коррекциями
|
||
setkit_dictionary = prepare_setkit_dictionary(setkit_use_list)
|
||
|
||
# Ранжируем наборы
|
||
setkit_dictionary = ranking_setkit(setkit_dictionary)
|
||
|
||
# Сортируем по рейтингу
|
||
setkit_dictionary = sorted(setkit_dictionary, key=lambda item: item["TmpRating"])
|
||
|
||
# Нахождение минимального и максимального рейтинга
|
||
num_max_rank = 0
|
||
num_min_rank = -1
|
||
for j, i in enumerate(setkit_dictionary):
|
||
if i["NumOffer"] != 0:
|
||
num_max_rank = j
|
||
if num_min_rank == -1:
|
||
num_min_rank = j
|
||
|
||
# Сохраняем финальные рейтинги в БД
|
||
for j, i in enumerate(setkit_dictionary):
|
||
obj = SetKit.objects.get(id=i["id"])
|
||
|
||
# Загружаем JSON описание набора
|
||
try:
|
||
getted_json = json.loads(obj.sSetDescription)
|
||
except:
|
||
getted_json = {}
|
||
|
||
# Обновляем JSON рейтингом
|
||
if i["NumOffer"] != 0:
|
||
try:
|
||
del getted_json[KEY_RATING_VIRTUAL]
|
||
except:
|
||
pass
|
||
getted_json[KEY_RATING] = i["RatingConsist"]
|
||
else:
|
||
try:
|
||
del getted_json[KEY_RATING]
|
||
except:
|
||
pass
|
||
getted_json[KEY_RATING_VIRTUAL] = i["RatingConsist"]
|
||
|
||
obj.sSetDescription = json.dumps(
|
||
getted_json,
|
||
separators=(",", ":"),
|
||
sort_keys=True,
|
||
ensure_ascii=False
|
||
)
|
||
|
||
# Вычисляем финальный рейтинг набора как комбинацию:
|
||
# k1 = нормализованный TmpRating (параметры сервиса) * вес сервиса
|
||
# k2 = рейтинг стеклопакета * вес стеклопакета в наборе
|
||
# k3 = рейтинг профиля * вес профиля в наборе
|
||
# fSetRating = k1 + k2 + k3
|
||
if j <= num_max_rank:
|
||
# Нормализуем TmpRating (от 0 до максимума)
|
||
norm_tmp_rating = normalize(
|
||
i["TmpRating"],
|
||
setkit_dictionary[num_max_rank]["TmpRating"]
|
||
)
|
||
|
||
# вес для TmpRating (всё что не профиль и не стеклопакет)
|
||
service_rating_weight = (
|
||
RARING_SET_MAX - RARING_WEIGHT_PVC_PROFILE_IN_SET - RARING_WEIGHT_GLAZING_IN_SET - RARING_SET_MIN
|
||
)
|
||
|
||
k1 = norm_tmp_rating * service_rating_weight
|
||
k2 = normalize(i["fGlazingRating"], RARING_GLAZING_MAX) * RARING_WEIGHT_GLAZING_IN_SET
|
||
k3 = normalize(i["fProfileRating"], RARING_PVC_PROFILE_MAX) * RARING_WEIGHT_PVC_PROFILE_IN_SET
|
||
|
||
obj.fSetRating = k1 + k2 + k3
|
||
else:
|
||
obj.fSetRating = 5.0
|
||
|
||
obj.save()
|
||
|
||
# Подробный вывод в режиме verbosity >= 3
|
||
if verbose >= 3:
|
||
self.stdout.write(self.format_setkit_table(i, obj))
|
||
|
||
self.stdout.write(f' ✓ Сохранено {len(setkit_dictionary)} наборов с финальными рейтингами')
|
||
|
||
self.stdout.write(self.style.SUCCESS('\n[OK!] ПЕРЕСЧЁТ РЕЙТИНГОВ ЗАВЕРШЁН УСПЕШНО!'))
|
||
self.stdout.write(f' • Обновлено профилей: {len(pvc_dictionary)}')
|
||
self.stdout.write(f' • Обновлено стеклопакетов: {len(glaz_dictionary)}')
|
||
self.stdout.write(f' • Обновлено наборов: {len(setkit_dictionary)}')
|