997 lines
41 KiB
Python
997 lines
41 KiB
Python
"""
|
||
Сервис управления витринами - резервирование, продажа и разбор витринных букетов.
|
||
|
||
Новая архитектура с ShowcaseItem:
|
||
- ProductKit = шаблон (рецепт букета)
|
||
- ShowcaseItem = физический экземпляр на витрине
|
||
- Каждый ShowcaseItem имеет свой набор Reservation
|
||
- Защита от двойной продажи через OneToOneField на sold_order_item
|
||
"""
|
||
from decimal import Decimal
|
||
from django.db import transaction, IntegrityError
|
||
from django.utils import timezone
|
||
from django.core.exceptions import ValidationError
|
||
|
||
from inventory.models import Showcase, Reservation, Warehouse, ShowcaseItem, Stock
|
||
from products.models import ProductKit
|
||
from orders.models import Order, OrderItem, OrderStatus
|
||
from customers.models import Customer
|
||
|
||
|
||
class ShowcaseManager:
|
||
"""
|
||
Менеджер для работы с витринами и витринными букетами.
|
||
"""
|
||
|
||
@staticmethod
|
||
def reserve_kit_to_showcase(product_kit, showcase, quantity=1):
|
||
"""
|
||
Резервирует N экземпляров комплекта на витрину.
|
||
Создаёт ShowcaseItem для каждого экземпляра и резервы компонентов.
|
||
|
||
Args:
|
||
product_kit: ProductKit - шаблон комплекта
|
||
showcase: Showcase - витрина
|
||
quantity: int - количество экземпляров (например, 5 одинаковых букетов)
|
||
|
||
Returns:
|
||
dict: {
|
||
'success': bool,
|
||
'showcase_items': list[ShowcaseItem],
|
||
'reservations': list[Reservation],
|
||
'message': str
|
||
}
|
||
"""
|
||
if not showcase.is_active:
|
||
return {
|
||
'success': False,
|
||
'showcase_items': [],
|
||
'reservations': [],
|
||
'warnings': None,
|
||
'message': f'Витрина "{showcase.name}" не активна'
|
||
}
|
||
|
||
warehouse = showcase.warehouse
|
||
showcase_items = []
|
||
all_reservations = []
|
||
|
||
try:
|
||
with transaction.atomic():
|
||
kit_items = product_kit.kit_items.all()
|
||
|
||
if not kit_items.exists():
|
||
return {
|
||
'success': False,
|
||
'showcase_items': [],
|
||
'reservations': [],
|
||
'warnings': None,
|
||
'message': f'Комплект "{product_kit.name}" не содержит компонентов'
|
||
}
|
||
|
||
# Проверяем дефицит компонентов (предупреждение, не блокировка)
|
||
warnings = []
|
||
for kit_item in kit_items:
|
||
product = kit_item.product
|
||
if not product:
|
||
continue
|
||
qty_needed = (kit_item.quantity or Decimal('1')) * quantity
|
||
stock = Stock.objects.filter(product=product, warehouse=warehouse).first()
|
||
free_qty = stock.quantity_free if stock else Decimal('0')
|
||
if free_qty < qty_needed:
|
||
deficit = qty_needed - free_qty
|
||
warnings.append(f"{product.name}: не хватает {deficit} шт.")
|
||
|
||
# Создаём N экземпляров
|
||
for _ in range(quantity):
|
||
# 1. Создаём ShowcaseItem
|
||
showcase_item = ShowcaseItem.objects.create(
|
||
showcase=showcase,
|
||
product_kit=product_kit,
|
||
status='available'
|
||
)
|
||
showcase_items.append(showcase_item)
|
||
|
||
# 2. Создаём резервы ДЛЯ ЭТОГО ЭКЗЕМПЛЯРА
|
||
for kit_item in kit_items:
|
||
product_to_reserve = None
|
||
|
||
if kit_item.product:
|
||
product_to_reserve = kit_item.product
|
||
elif kit_item.variant_group:
|
||
# Группа вариантов - резервируем первый доступный вариант
|
||
variant_items = kit_item.variant_group.items.all()
|
||
if variant_items.exists():
|
||
product_to_reserve = variant_items.first().product
|
||
|
||
if product_to_reserve:
|
||
reservation = Reservation.objects.create(
|
||
product=product_to_reserve,
|
||
warehouse=warehouse,
|
||
showcase=showcase,
|
||
product_kit=product_kit,
|
||
showcase_item=showcase_item, # Связь с экземпляром!
|
||
quantity=kit_item.quantity,
|
||
quantity_base=kit_item.quantity, # Для корректного учёта в Stock
|
||
status='reserved'
|
||
)
|
||
all_reservations.append(reservation)
|
||
|
||
# Обновляем агрегаты Stock
|
||
affected_products = set(r.product_id for r in all_reservations)
|
||
for product_id in affected_products:
|
||
stock, _ = Stock.objects.get_or_create(
|
||
product_id=product_id,
|
||
warehouse=warehouse
|
||
)
|
||
stock.refresh_from_batches()
|
||
|
||
return {
|
||
'success': True,
|
||
'showcase_items': showcase_items,
|
||
'reservations': all_reservations,
|
||
'warnings': warnings if warnings else None,
|
||
'message': f'Создано {quantity} экз. комплекта "{product_kit.name}" на витрине "{showcase.name}"'
|
||
}
|
||
|
||
except Exception as e:
|
||
return {
|
||
'success': False,
|
||
'showcase_items': [],
|
||
'reservations': [],
|
||
'warnings': None,
|
||
'message': f'Ошибка резервирования: {str(e)}'
|
||
}
|
||
|
||
@staticmethod
|
||
def sell_showcase_items(showcase_items, order_item):
|
||
"""
|
||
Продаёт указанные экземпляры с витрины.
|
||
Привязывает каждый ShowcaseItem к OrderItem и конвертирует резервы в продажи.
|
||
|
||
Args:
|
||
showcase_items: list[ShowcaseItem] - экземпляры для продажи
|
||
order_item: OrderItem - позиция заказа
|
||
|
||
Returns:
|
||
dict: {
|
||
'success': bool,
|
||
'sold_count': int,
|
||
'message': str
|
||
}
|
||
|
||
Raises:
|
||
IntegrityError: если экземпляр уже был продан (защита на уровне БД)
|
||
"""
|
||
from inventory.services.sale_processor import SaleProcessor
|
||
|
||
sold_count = 0
|
||
order = order_item.order
|
||
|
||
try:
|
||
with transaction.atomic():
|
||
# Собираем ID для перезагрузки с блокировкой
|
||
showcase_item_ids = [item.id for item in showcase_items]
|
||
|
||
# Перезагружаем объекты из БД с блокировкой для актуального статуса
|
||
showcase_items_locked = list(
|
||
ShowcaseItem.objects.select_for_update().filter(
|
||
id__in=showcase_item_ids
|
||
)
|
||
)
|
||
|
||
for showcase_item in showcase_items_locked:
|
||
# Проверяем статус перед продажей
|
||
if showcase_item.status == 'sold':
|
||
raise ValidationError(
|
||
f'Экземпляр "{showcase_item}" уже продан'
|
||
)
|
||
if showcase_item.status == 'dismantled':
|
||
raise ValidationError(
|
||
f'Экземпляр "{showcase_item}" был разобран'
|
||
)
|
||
|
||
# Помечаем как проданный (OneToOneField защитит от дублей!)
|
||
showcase_item.mark_sold(order_item)
|
||
|
||
# Конвертируем резервы этого экземпляра в продажи
|
||
reservations = Reservation.objects.filter(
|
||
showcase_item=showcase_item,
|
||
status='reserved'
|
||
)
|
||
|
||
for reservation in reservations:
|
||
# Проверяем что резерв ещё НЕ обработан
|
||
if reservation.status == 'converted_to_sale':
|
||
# Этот резерв уже преобразован в продажу, пропускаем
|
||
continue
|
||
|
||
# Сначала устанавливаем order_item для правильного определения цены
|
||
reservation.order_item = order_item
|
||
reservation.save()
|
||
|
||
# ВАЖНО: Мы НЕ создаём продажу (Sale) здесь и НЕ меняем статус на 'converted_to_sale'.
|
||
# Это сделает сигнал create_sale_on_order_completion автоматически.
|
||
# Таким образом обеспечивается единая точка создания продаж для всех типов товаров.
|
||
|
||
# SaleProcessor.create_sale_from_reservation(
|
||
# reservation=reservation,
|
||
# order=order
|
||
# )
|
||
|
||
# Статус резерва остается 'reserved', чтобы сигнал его увидел
|
||
# reservation.status = 'converted_to_sale'
|
||
# reservation.converted_at = timezone.now()
|
||
# reservation.save()
|
||
|
||
sold_count += 1
|
||
|
||
return {
|
||
'success': True,
|
||
'sold_count': sold_count,
|
||
'message': f'Продано {sold_count} экз.'
|
||
}
|
||
|
||
except ValidationError as e:
|
||
# Ошибка валидации (например, экземпляр уже продан)
|
||
return {
|
||
'success': False,
|
||
'sold_count': 0,
|
||
'message': str(e)
|
||
}
|
||
|
||
@staticmethod
|
||
def sell_from_showcase(product_kit, showcase, customer, payment_method='cash_to_courier',
|
||
custom_price=None, user=None, quantity=1):
|
||
"""
|
||
Продаёт N экземпляров комплекта с витрины.
|
||
Создаёт Order, OrderItem, выбирает доступные ShowcaseItem и продаёт их.
|
||
|
||
Args:
|
||
product_kit: ProductKit - шаблон комплекта
|
||
showcase: Showcase - витрина
|
||
customer: Customer - покупатель
|
||
payment_method: str - способ оплаты
|
||
custom_price: Decimal - кастомная цена за единицу (опционально)
|
||
user: CustomUser - пользователь, выполняющий операцию
|
||
quantity: int - количество экземпляров для продажи
|
||
|
||
Returns:
|
||
dict: {
|
||
'success': bool,
|
||
'order': Order or None,
|
||
'sold_count': int,
|
||
'message': str
|
||
}
|
||
"""
|
||
warehouse = showcase.warehouse
|
||
|
||
try:
|
||
with transaction.atomic():
|
||
# Находим доступные экземпляры этого комплекта на витрине
|
||
available_items = ShowcaseItem.objects.select_for_update(
|
||
skip_locked=True
|
||
).filter(
|
||
showcase=showcase,
|
||
product_kit=product_kit,
|
||
status='available'
|
||
)[:quantity]
|
||
|
||
available_items = list(available_items)
|
||
|
||
if len(available_items) < quantity:
|
||
return {
|
||
'success': False,
|
||
'order': None,
|
||
'sold_count': 0,
|
||
'message': f'Доступно только {len(available_items)} из {quantity} запрошенных экземпляров'
|
||
}
|
||
|
||
# Получаем статус "Завершён" для POS-продаж
|
||
completed_status = OrderStatus.objects.filter(
|
||
code='completed',
|
||
is_positive_end=True
|
||
).first()
|
||
|
||
if not completed_status:
|
||
completed_status = OrderStatus.objects.filter(
|
||
is_positive_end=True
|
||
).first()
|
||
|
||
# Создаём заказ
|
||
order = Order.objects.create(
|
||
customer=customer,
|
||
status=completed_status,
|
||
is_paid=True,
|
||
modified_by=user
|
||
)
|
||
|
||
# Создаём доставку (самовывоз)
|
||
from orders.models import Delivery
|
||
from django.utils import timezone as tz
|
||
now_local = tz.localtime(tz.now())
|
||
|
||
Delivery.objects.create(
|
||
order=order,
|
||
delivery_type=Delivery.DELIVERY_TYPE_PICKUP,
|
||
pickup_warehouse=warehouse,
|
||
delivery_date=now_local.date(),
|
||
time_from=now_local.time(),
|
||
time_to=now_local.time(),
|
||
cost=0
|
||
)
|
||
|
||
# Определяем цену
|
||
price = custom_price if custom_price else product_kit.actual_price
|
||
is_custom = custom_price is not None
|
||
|
||
# Создаём позицию заказа
|
||
order_item = OrderItem.objects.create(
|
||
order=order,
|
||
product_kit=product_kit,
|
||
quantity=len(available_items),
|
||
price=price,
|
||
is_custom_price=is_custom,
|
||
is_from_showcase=True,
|
||
showcase=showcase
|
||
)
|
||
|
||
# Продаём экземпляры
|
||
result = ShowcaseManager.sell_showcase_items(available_items, order_item)
|
||
|
||
if not result['success']:
|
||
raise ValidationError(result['message'])
|
||
|
||
# Пересчитываем итоговую сумму заказа
|
||
order.calculate_total()
|
||
order.amount_paid = order.total_amount
|
||
order.update_payment_status()
|
||
order.save()
|
||
|
||
return {
|
||
'success': True,
|
||
'order': order,
|
||
'sold_count': result['sold_count'],
|
||
'message': f'Заказ #{order.order_number} создан. Продано {result["sold_count"]} экз. с витрины "{showcase.name}"'
|
||
}
|
||
|
||
except Exception as e:
|
||
return {
|
||
'success': False,
|
||
'order': None,
|
||
'sold_count': 0,
|
||
'message': f'Ошибка продажи: {str(e)}'
|
||
}
|
||
|
||
@staticmethod
|
||
def reserve_product_to_showcase(product, showcase, product_kit, quantity_per_item):
|
||
"""
|
||
Дозарезервировать товар для всех АКТИВНЫХ экземпляров витринного комплекта.
|
||
НЕ блокирует при нехватке товара - допускает резерв "в минус".
|
||
|
||
Args:
|
||
product: Product – товар-компонент
|
||
showcase: Showcase – витрина
|
||
product_kit: ProductKit – шаблон витринного комплекта
|
||
quantity_per_item: Decimal или int – насколько увеличить количество
|
||
этого товара в ОДНОМ экземпляре букета
|
||
|
||
Returns:
|
||
dict: {
|
||
'success': bool,
|
||
'overdraft': Decimal, # сколько не хватает (может быть 0)
|
||
'message': str
|
||
}
|
||
"""
|
||
from decimal import Decimal
|
||
|
||
if not showcase or not product_kit:
|
||
return {
|
||
'success': True,
|
||
'overdraft': Decimal('0'),
|
||
'message': 'Нет витрины или комплекта – резервы не изменены'
|
||
}
|
||
|
||
quantity_per_item = Decimal(str(quantity_per_item))
|
||
if quantity_per_item <= 0:
|
||
return {
|
||
'success': True,
|
||
'overdraft': Decimal('0'),
|
||
'message': 'Изменение количества не требует дополнительного резерва'
|
||
}
|
||
|
||
# Берём только актуальные экземпляры на витрине
|
||
# (available, in_cart, reserved — все физически присутствующие)
|
||
active_items = ShowcaseItem.objects.filter(
|
||
showcase=showcase,
|
||
product_kit=product_kit,
|
||
status__in=['available', 'in_cart', 'reserved'],
|
||
)
|
||
|
||
item_count = active_items.count()
|
||
if item_count == 0:
|
||
return {
|
||
'success': True,
|
||
'overdraft': Decimal('0'),
|
||
'message': 'Нет активных экземпляров на витрине – резервы не изменены'
|
||
}
|
||
|
||
warehouse = showcase.warehouse
|
||
total_needed = quantity_per_item * item_count
|
||
|
||
# Проверяем, хватает ли свободного остатка (НЕ блокируем, только считаем дефицит)
|
||
try:
|
||
stock = Stock.objects.get(product=product, warehouse=warehouse)
|
||
free_qty = stock.quantity_free
|
||
except Stock.DoesNotExist:
|
||
free_qty = Decimal('0')
|
||
|
||
overdraft = max(Decimal('0'), total_needed - free_qty)
|
||
|
||
# Создаём/увеличиваем резервы по каждому экземпляру (даже если не хватает!)
|
||
with transaction.atomic():
|
||
for showcase_item in active_items:
|
||
reservation, created = Reservation.objects.get_or_create(
|
||
product=product,
|
||
warehouse=warehouse,
|
||
showcase=showcase,
|
||
product_kit=product_kit,
|
||
showcase_item=showcase_item,
|
||
status='reserved',
|
||
defaults={'quantity': quantity_per_item, 'quantity_base': quantity_per_item},
|
||
)
|
||
if not created:
|
||
reservation.quantity = (reservation.quantity or Decimal('0')) + quantity_per_item
|
||
reservation.quantity_base = (reservation.quantity_base or Decimal('0')) + quantity_per_item
|
||
reservation.save(update_fields=['quantity', 'quantity_base'])
|
||
|
||
return {
|
||
'success': True,
|
||
'overdraft': overdraft,
|
||
'message': (
|
||
f'Зарезервировано {total_needed} ед. товара "{product.name}"'
|
||
+ (f' (не хватает {overdraft})' if overdraft > 0 else '')
|
||
),
|
||
}
|
||
|
||
@staticmethod
|
||
def release_showcase_reservation(product, showcase, product_kit, quantity_per_item):
|
||
"""
|
||
Освободить часть резерва товара для всех АКТИВНЫХ экземпляров витринного комплекта.
|
||
|
||
Args:
|
||
product: Product – товар-компонент
|
||
showcase: Showcase – витрина
|
||
product_kit: ProductKit – шаблон витринного комплекта
|
||
quantity_per_item: Decimal или int – насколько уменьшить количество
|
||
этого товара в ОДНОМ экземпляре букета
|
||
|
||
Returns:
|
||
dict: {
|
||
'success': bool,
|
||
'released': Decimal,
|
||
'message': str
|
||
}
|
||
"""
|
||
from decimal import Decimal
|
||
|
||
if not showcase or not product_kit:
|
||
return {
|
||
'success': True,
|
||
'released': Decimal('0'),
|
||
'message': 'Нет витрины или комплекта – резервы не изменены',
|
||
}
|
||
|
||
quantity_per_item = Decimal(str(quantity_per_item))
|
||
if quantity_per_item <= 0:
|
||
return {
|
||
'success': True,
|
||
'released': Decimal('0'),
|
||
'message': 'Изменение количества не требует освобождения резерва',
|
||
}
|
||
|
||
active_items = ShowcaseItem.objects.filter(
|
||
showcase=showcase,
|
||
product_kit=product_kit,
|
||
status__in=['available', 'in_cart', 'reserved'],
|
||
)
|
||
|
||
if not active_items.exists():
|
||
return {
|
||
'success': True,
|
||
'released': Decimal('0'),
|
||
'message': 'Нет активных экземпляров на витрине – резервы не изменены',
|
||
}
|
||
|
||
released_total = Decimal('0')
|
||
|
||
with transaction.atomic():
|
||
reservations = Reservation.objects.filter(
|
||
showcase_item__in=active_items,
|
||
product=product,
|
||
product_kit=product_kit,
|
||
showcase=showcase,
|
||
warehouse=showcase.warehouse,
|
||
status='reserved',
|
||
)
|
||
|
||
for res in reservations:
|
||
old_qty = res.quantity or Decimal('0')
|
||
new_qty = old_qty - quantity_per_item
|
||
|
||
if new_qty > 0:
|
||
res.quantity = new_qty
|
||
res.quantity_base = new_qty
|
||
res.save(update_fields=['quantity', 'quantity_base'])
|
||
released_amount = quantity_per_item
|
||
else:
|
||
# Полностью освобождаем резерв
|
||
released_amount = old_qty
|
||
res.status = 'released'
|
||
res.released_at = timezone.now()
|
||
res.save(update_fields=['status', 'released_at'])
|
||
|
||
released_total += released_amount
|
||
|
||
return {
|
||
'success': True,
|
||
'released': released_total,
|
||
'message': f'Освобождено {released_total} ед. товара "{product.name}"',
|
||
}
|
||
|
||
@staticmethod
|
||
def dismantle_showcase_item(showcase_item):
|
||
"""
|
||
Разбирает один экземпляр на витрине - освобождает его резервы.
|
||
|
||
Args:
|
||
showcase_item: ShowcaseItem - экземпляр для разбора
|
||
|
||
Returns:
|
||
dict: {
|
||
'success': bool,
|
||
'released_count': int,
|
||
'message': str
|
||
}
|
||
"""
|
||
if showcase_item.status == 'sold':
|
||
return {
|
||
'success': False,
|
||
'released_count': 0,
|
||
'message': 'Нельзя разобрать проданный экземпляр'
|
||
}
|
||
|
||
try:
|
||
with transaction.atomic():
|
||
warehouse = showcase_item.showcase.warehouse
|
||
|
||
# Находим резервы этого экземпляра
|
||
reservations = Reservation.objects.filter(
|
||
showcase_item=showcase_item,
|
||
status='reserved'
|
||
)
|
||
|
||
released_count = reservations.count()
|
||
affected_products = list(reservations.values_list('product_id', flat=True).distinct())
|
||
|
||
# Освобождаем резервы
|
||
reservations.update(
|
||
status='released',
|
||
released_at=timezone.now(),
|
||
showcase=None,
|
||
showcase_item=None
|
||
)
|
||
|
||
# Обновляем статус экземпляра
|
||
showcase_item.status = 'dismantled'
|
||
showcase_item.save()
|
||
|
||
# Обновляем агрегаты Stock
|
||
for product_id in affected_products:
|
||
try:
|
||
stock = Stock.objects.get(
|
||
product_id=product_id,
|
||
warehouse=warehouse
|
||
)
|
||
stock.refresh_from_batches()
|
||
except Stock.DoesNotExist:
|
||
pass
|
||
|
||
return {
|
||
'success': True,
|
||
'released_count': released_count,
|
||
'message': f'Экземпляр разобран, освобождено {released_count} резервов'
|
||
}
|
||
|
||
except Exception as e:
|
||
return {
|
||
'success': False,
|
||
'released_count': 0,
|
||
'message': f'Ошибка разбора: {str(e)}'
|
||
}
|
||
|
||
@staticmethod
|
||
def dismantle_from_showcase(showcase, product_kit=None):
|
||
"""
|
||
Разбирает все экземпляры на витрине (или конкретного комплекта).
|
||
Освобождает резервы.
|
||
|
||
Args:
|
||
showcase: Showcase - витрина
|
||
product_kit: ProductKit - конкретный комплект (опционально)
|
||
|
||
Returns:
|
||
dict: {
|
||
'success': bool,
|
||
'released_count': int,
|
||
'dismantled_items_count': int,
|
||
'message': str
|
||
}
|
||
"""
|
||
try:
|
||
with transaction.atomic():
|
||
# Находим экземпляры для разбора
|
||
items_qs = ShowcaseItem.objects.filter(
|
||
showcase=showcase,
|
||
status='available'
|
||
)
|
||
|
||
if product_kit:
|
||
items_qs = items_qs.filter(product_kit=product_kit)
|
||
|
||
items_to_dismantle = list(items_qs)
|
||
|
||
if not items_to_dismantle:
|
||
return {
|
||
'success': False,
|
||
'released_count': 0,
|
||
'dismantled_items_count': 0,
|
||
'message': f'На витрине "{showcase.name}" нет доступных экземпляров для разбора'
|
||
}
|
||
|
||
total_released = 0
|
||
for item in items_to_dismantle:
|
||
result = ShowcaseManager.dismantle_showcase_item(item)
|
||
if result['success']:
|
||
total_released += result['released_count']
|
||
|
||
return {
|
||
'success': True,
|
||
'released_count': total_released,
|
||
'dismantled_items_count': len(items_to_dismantle),
|
||
'message': f'Разобрано {len(items_to_dismantle)} экз., освобождено {total_released} резервов'
|
||
}
|
||
|
||
except Exception as e:
|
||
return {
|
||
'success': False,
|
||
'released_count': 0,
|
||
'dismantled_items_count': 0,
|
||
'message': f'Ошибка разбора: {str(e)}'
|
||
}
|
||
|
||
@staticmethod
|
||
def write_off_from_showcase(showcase_item, reason='spoilage', notes=None, created_by=None):
|
||
"""
|
||
Списывает экземпляр витринного комплекта:
|
||
1. Создаёт документ списания с компонентами комплекта
|
||
2. Преобразует резервы комплекта в позиции документа списания
|
||
3. Помечает экземпляр как разобранный
|
||
|
||
Args:
|
||
showcase_item: ShowcaseItem - экземпляр для списания
|
||
reason: str - причина списания (spoilage по умолчанию)
|
||
notes: str - примечания
|
||
created_by: User - пользователь
|
||
|
||
Returns:
|
||
dict: {
|
||
'success': bool,
|
||
'document_id': int,
|
||
'document_number': str,
|
||
'items_count': int,
|
||
'message': str,
|
||
'error': str (при ошибке)
|
||
}
|
||
"""
|
||
from inventory.services.writeoff_document_service import WriteOffDocumentService
|
||
|
||
# Проверка статуса
|
||
if showcase_item.status == 'sold':
|
||
return {
|
||
'success': False,
|
||
'document_id': None,
|
||
'message': 'Нельзя списать проданный экземпляр'
|
||
}
|
||
|
||
if showcase_item.status == 'dismantled':
|
||
return {
|
||
'success': False,
|
||
'document_id': None,
|
||
'message': 'Экземпляр уже разобран'
|
||
}
|
||
|
||
try:
|
||
with transaction.atomic():
|
||
warehouse = showcase_item.showcase.warehouse
|
||
product_kit = showcase_item.product_kit
|
||
|
||
# Создаём документ списания (черновик)
|
||
document = WriteOffDocumentService.create_document(
|
||
warehouse=warehouse,
|
||
date=timezone.now().date(),
|
||
notes=f'Списание витринного комплекта: {product_kit.name}',
|
||
created_by=created_by
|
||
)
|
||
|
||
# Получаем резервы этого экземпляра
|
||
reservations = Reservation.objects.filter(
|
||
showcase_item=showcase_item,
|
||
status='reserved'
|
||
).select_related('product')
|
||
|
||
items_count = 0
|
||
|
||
for reservation in reservations:
|
||
# Добавляем позицию в документ списания
|
||
# Используем add_item без создания резерва (меняем статус существующего)
|
||
from inventory.models import WriteOffDocumentItem
|
||
|
||
item = WriteOffDocumentItem.objects.create(
|
||
document=document,
|
||
product=reservation.product,
|
||
quantity=reservation.quantity,
|
||
reason=reason,
|
||
notes=notes
|
||
)
|
||
|
||
# Привязываем существующий резерв к позиции документа
|
||
reservation.writeoff_document_item = item
|
||
reservation.status = 'converted_to_writeoff'
|
||
reservation.converted_at = timezone.now()
|
||
reservation.save(update_fields=['writeoff_document_item', 'status', 'converted_at'])
|
||
|
||
items_count += 1
|
||
|
||
# Помечаем экземпляр как разобранный
|
||
showcase_item.status = 'dismantled'
|
||
showcase_item.save(update_fields=['status'])
|
||
|
||
# Помечаем шаблон комплекта как снятый
|
||
if product_kit.status != 'discontinued':
|
||
product_kit.status = 'discontinued'
|
||
product_kit.save(update_fields=['status'])
|
||
|
||
return {
|
||
'success': True,
|
||
'document_id': document.id,
|
||
'document_number': document.document_number,
|
||
'items_count': items_count,
|
||
'message': f'Создан документ {document.document_number} с {items_count} позициями'
|
||
}
|
||
|
||
except Exception as e:
|
||
return {
|
||
'success': False,
|
||
'document_id': None,
|
||
'message': f'Ошибка списания: {str(e)}'
|
||
}
|
||
|
||
@staticmethod
|
||
def get_showcase_items_for_pos(showcase=None):
|
||
"""
|
||
Возвращает витринные экземпляры, сгруппированные по шаблону комплекта.
|
||
Для использования в POS интерфейсе.
|
||
|
||
Args:
|
||
showcase: Showcase - конкретная витрина (опционально, если None - все активные)
|
||
|
||
Returns:
|
||
list: [
|
||
{
|
||
'kit_id': int,
|
||
'kit_name': str,
|
||
'kit_sku': str,
|
||
'price': Decimal,
|
||
'available_count': int,
|
||
'showcase_item_ids': list[int],
|
||
'showcase_id': int,
|
||
'showcase_name': str,
|
||
'type': 'showcase_kit'
|
||
},
|
||
...
|
||
]
|
||
"""
|
||
from django.db.models import Count
|
||
|
||
# Базовый queryset
|
||
qs = ShowcaseItem.objects.filter(
|
||
status='available',
|
||
showcase__is_active=True
|
||
)
|
||
|
||
if showcase:
|
||
qs = qs.filter(showcase=showcase)
|
||
|
||
# Группируем по (product_kit, showcase)
|
||
grouped = qs.values(
|
||
'product_kit_id',
|
||
'product_kit__name',
|
||
'product_kit__sku',
|
||
'product_kit__price',
|
||
'product_kit__sale_price',
|
||
'showcase_id',
|
||
'showcase__name'
|
||
).annotate(
|
||
available_count=Count('id')
|
||
).order_by('showcase__name', 'product_kit__name')
|
||
|
||
result = []
|
||
for item in grouped:
|
||
# Получаем IDs всех доступных экземпляров этой группы
|
||
item_ids = list(ShowcaseItem.objects.filter(
|
||
product_kit_id=item['product_kit_id'],
|
||
showcase_id=item['showcase_id'],
|
||
status='available'
|
||
).values_list('id', flat=True))
|
||
|
||
# Определяем актуальную цену
|
||
price = item['product_kit__sale_price'] or item['product_kit__price']
|
||
|
||
result.append({
|
||
'kit_id': item['product_kit_id'],
|
||
'kit_name': item['product_kit__name'],
|
||
'kit_sku': item['product_kit__sku'] or '',
|
||
'price': str(price),
|
||
'available_count': item['available_count'],
|
||
'showcase_item_ids': item_ids,
|
||
'showcase_id': item['showcase_id'],
|
||
'showcase_name': item['showcase__name'],
|
||
'type': 'showcase_kit'
|
||
})
|
||
|
||
return result
|
||
|
||
@staticmethod
|
||
def get_showcase_kits(showcase):
|
||
"""
|
||
Возвращает список компонентов, зарезервированных на витрине.
|
||
(Для совместимости со старым API)
|
||
|
||
Args:
|
||
showcase: Showcase
|
||
|
||
Returns:
|
||
list: список словарей с информацией о компонентах
|
||
"""
|
||
reservations = Reservation.objects.filter(
|
||
showcase=showcase,
|
||
status='reserved'
|
||
).select_related('product').values('product__id', 'product__name', 'quantity')
|
||
|
||
# Группируем по товарам
|
||
products_dict = {}
|
||
for res in reservations:
|
||
product_id = res['product__id']
|
||
if product_id not in products_dict:
|
||
products_dict[product_id] = {
|
||
'product_name': res['product__name'],
|
||
'quantity': Decimal('0')
|
||
}
|
||
products_dict[product_id]['quantity'] += res['quantity']
|
||
|
||
return [
|
||
{
|
||
'product_id': pid,
|
||
'product_name': data['product_name'],
|
||
'quantity': data['quantity']
|
||
}
|
||
for pid, data in products_dict.items()
|
||
]
|
||
|
||
@staticmethod
|
||
def lock_showcase_items_for_cart(showcase_item_ids, user, session_id=None, duration_minutes=30):
|
||
"""
|
||
Блокирует указанные экземпляры для корзины.
|
||
|
||
Args:
|
||
showcase_item_ids: list[int] - ID экземпляров для блокировки
|
||
user: User - пользователь (кассир)
|
||
session_id: str - ID сессии корзины
|
||
duration_minutes: int - длительность блокировки в минутах
|
||
|
||
Returns:
|
||
dict: {
|
||
'success': bool,
|
||
'locked_item_ids': list[int],
|
||
'lock_expires_at': datetime,
|
||
'message': str
|
||
}
|
||
"""
|
||
from datetime import timedelta
|
||
|
||
try:
|
||
with transaction.atomic():
|
||
# Выбираем и блокируем экземпляры
|
||
items = ShowcaseItem.objects.select_for_update(
|
||
skip_locked=True
|
||
).filter(
|
||
id__in=showcase_item_ids,
|
||
status='available'
|
||
)
|
||
|
||
items = list(items)
|
||
|
||
if len(items) < len(showcase_item_ids):
|
||
# Некоторые экземпляры недоступны
|
||
unavailable_count = len(showcase_item_ids) - len(items)
|
||
return {
|
||
'success': False,
|
||
'locked_item_ids': [],
|
||
'lock_expires_at': None,
|
||
'message': f'{unavailable_count} экземпляр(ов) недоступны. Возможно, они уже в корзине или проданы.'
|
||
}
|
||
|
||
lock_expires_at = timezone.now() + timedelta(minutes=duration_minutes)
|
||
locked_ids = []
|
||
|
||
for item in items:
|
||
item.lock_for_cart(user, session_id, duration_minutes)
|
||
locked_ids.append(item.id)
|
||
|
||
return {
|
||
'success': True,
|
||
'locked_item_ids': locked_ids,
|
||
'lock_expires_at': lock_expires_at,
|
||
'message': f'Заблокировано {len(locked_ids)} экз.'
|
||
}
|
||
|
||
except Exception as e:
|
||
return {
|
||
'success': False,
|
||
'locked_item_ids': [],
|
||
'lock_expires_at': None,
|
||
'message': f'Ошибка блокировки: {str(e)}'
|
||
}
|
||
|
||
@staticmethod
|
||
def release_showcase_items_from_cart(showcase_item_ids, user):
|
||
"""
|
||
Снимает блокировку с указанных экземпляров.
|
||
|
||
Args:
|
||
showcase_item_ids: list[int] - ID экземпляров
|
||
user: User - пользователь (только владелец блокировки может снять)
|
||
|
||
Returns:
|
||
dict: {
|
||
'success': bool,
|
||
'released_count': int,
|
||
'message': str
|
||
}
|
||
"""
|
||
try:
|
||
# Снимаем блокировку только для экземпляров, заблокированных этим пользователем
|
||
updated = ShowcaseItem.objects.filter(
|
||
id__in=showcase_item_ids,
|
||
status='in_cart',
|
||
locked_by_user=user
|
||
).update(
|
||
status='available',
|
||
locked_by_user=None,
|
||
cart_lock_expires_at=None,
|
||
cart_session_id=None
|
||
)
|
||
|
||
return {
|
||
'success': True,
|
||
'released_count': updated,
|
||
'message': f'Освобождено {updated} экз.'
|
||
}
|
||
|
||
except Exception as e:
|
||
return {
|
||
'success': False,
|
||
'released_count': 0,
|
||
'message': f'Ошибка освобождения: {str(e)}'
|
||
}
|