Files
Sith/stock/views/items.py
T
2026-11-09 09:27:53 +00:00

416 lines
15 KiB
Python

from csv import Error
from django import forms
from django.contrib.auth.mixins import UserPassesTestMixin
from django.contrib.messages.views import SuccessMessageMixin
from django.db import transaction
from django.http import HttpResponseRedirect
from django.shortcuts import get_object_or_404
from django.urls import reverse
from django.utils.translation import gettext_lazy as _
from django.views.generic import ListView
from django.views.generic.edit import CreateView, FormView, UpdateView
from club.models import Club
from stock.forms import (
METADATA_FORMS,
ItemLineForm,
StockActionForm,
StockItemActionFormSet,
StockItemStockForm,
)
from stock.heper import can_be_edited_by, can_be_view_by
from stock.models import (
OperationType,
Stock,
StockAction,
StockItemAction,
StockItemStock,
)
class ItemListView(UserPassesTestMixin, ListView):
model = StockItemStock
template_name = "stock/items_list.jinja"
context_object_name = "items"
def dispatch(self, request, *args, **kwargs):
self.club = get_object_or_404(Club, pk=kwargs["club_id"])
self.stock = get_object_or_404(Stock, pk=kwargs["stock_id"], club=self.club)
self.is_editor = can_be_edited_by(self.request.user, self.club)
return super().dispatch(request, *args, **kwargs)
def test_func(self):
return can_be_view_by(self.request.user, self.club, self.stock)
def get_queryset(self):
return (
StockItemStock.objects.filter(stock=self.stock)
.select_related("item")
.order_by("item__name")
)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs) | {
"club": self.club,
"stock": self.stock,
"is_editor": self.is_editor,
}
return context
class ItemCreateView(UserPassesTestMixin, SuccessMessageMixin, FormView):
form_class = ItemLineForm
template_name = "stock/items_create.jinja"
success_message = _("Item(s) created.")
def dispatch(self, request, *args, **kwargs):
self.club = get_object_or_404(Club, pk=kwargs["club_id"])
self.stock = get_object_or_404(Stock, pk=kwargs["stock_id"], club=self.club)
return super().dispatch(request, *args, **kwargs)
def test_func(self):
return can_be_edited_by(self.request.user, self.club)
def get_form_kwargs(self):
return super().get_form_kwargs() | {
"instance": self.stock,
"queryset": StockItemStock.objects.none(),
}
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context.update(
{
"club": self.club,
"stock": self.stock,
"formset": context["form"],
}
)
return context
def form_valid(self, form):
form.save()
return super().form_valid(form)
def get_success_url(self):
return reverse(
"stock:items_list",
kwargs={"club_id": self.club.id, "stock_id": self.stock.id},
)
class ItemUpdateView(UserPassesTestMixin, SuccessMessageMixin, UpdateView):
model = StockItemStock
form_class = StockItemStockForm
pk_url_kwarg = "item_id"
template_name = "stock/item_edit.jinja"
def dispatch(self, request, *args, **kwargs):
self.club = get_object_or_404(Club, pk=kwargs["club_id"])
self.stock = get_object_or_404(Stock, pk=kwargs["stock_id"], club=self.club)
return super().dispatch(request, *args, **kwargs)
def test_func(self):
return can_be_edited_by(self.request.user, self.club)
def get_queryset(self):
return StockItemStock.objects.filter(stock=self.stock).select_related("item")
def get_success_url(self):
return reverse(
"stock:items_list",
kwargs={"club_id": self.club.id, "stock_id": self.stock.id},
)
def get_success_message(self, cleaned_data):
return cleaned_data["name"] + _(" edited.")
def update_quantities(stock_items, item_actions, metadata_entries, operation_type):
match operation_type:
case OperationType.TransferFrom | OperationType.Refuel:
for item_action, metadata_entry in zip(
item_actions, metadata_entries, strict=True
):
item = stock_items[item_action.item_id]
item_action.quantity_before = item.quantity
item_action.quantity_after = (
item_action.quantity_before + metadata_entry.added_quantity
)
item.quantity = item_action.quantity_after
case _:
for item_action in item_actions:
item = stock_items[item_action.item_id]
item_action.quantity_before = item.quantity
item.quantity = item_action.quantity_after
def apply_transfer(stock_items, item_actions, metadata_entries, user, source_stock):
destinations = {}
for item_action, metadata_entry in zip(
item_actions, metadata_entries, strict=True
):
key = (item_action.item.item_id, metadata_entry.new_stock_id)
if key not in destinations:
destinations[key], _created = (
StockItemStock.objects.select_for_update().get_or_create(
item_id=key[0],
stock_id=key[1],
defaults={"quantity": 0},
)
)
destination_stock_action = StockAction(
action=OperationType.TransferFrom,
comment=_("Transferred from stock %s") % source_stock.name,
user=user,
)
destination_item_actions = []
for item_action, metadata_entry in zip(
item_actions, metadata_entries, strict=True
):
source_item = stock_items[item_action.item_id]
destination = destinations[(source_item.item_id, metadata_entry.new_stock_id)]
quantity = metadata_entry.remove_quantity
if source_item.quantity - quantity < 0:
raise forms.ValidationError(
_("The new quantity cannot be less than zero for item %s.")
% source_item.name,
code="lesser_than_zero",
)
item_action.quantity_before = source_item.quantity
source_item.quantity -= quantity
item_action.quantity_after = source_item.quantity
destination_item_actions.append(
StockItemAction(
action=destination_stock_action,
item=destination,
quantity_before=destination.quantity,
quantity_after=destination.quantity + quantity,
)
)
destination.quantity += quantity
metadata_entry.other_item_action = destination_item_actions[-1]
return destination_stock_action, list(destinations.values()), destination_item_actions
class ItemActionCreateView(UserPassesTestMixin, SuccessMessageMixin, CreateView):
model = StockAction
form_class = StockActionForm
template_name = "stock/action_form.jinja"
metadata_required = True
success_message = _("Action complete")
def test_func(self):
return can_be_edited_by(self.request.user, self.club)
def posted_operation_type(self):
try:
return int(self.request.POST.get("action"))
except (TypeError, ValueError):
return None
def attach_metadata_forms(self, form, active_operation_type=None):
form.blocks = []
for operation_type, metadata_form_class in METADATA_FORMS.items():
kwargs = {
"prefix": f"{form.prefix}-{operation_type.name.lower()}",
"empty_permitted": not self.metadata_required,
}
if active_operation_type == operation_type.value:
kwargs.update(data=self.request.POST, files=self.request.FILES)
metadata_form = metadata_form_class(**kwargs)
if operation_type == OperationType.TransferTo:
metadata_form.fields["new_stock"].queryset = Stock.objects.filter(
club=self.club
).exclude(pk=self.stock.pk)
form.blocks.append(
{
"action": operation_type.value,
"label": operation_type.label,
"form": metadata_form,
}
)
return form
def build_formset(self, instance=None, *, bound=False, active_operation_type=None):
kwargs = {"instance": instance, "prefix": "item_action"}
if bound:
kwargs.update(data=self.request.POST, files=self.request.FILES)
formset = StockItemActionFormSet(**kwargs)
item_queryset = (
StockItemStock.objects.filter(stock=self.stock)
.select_related("item")
.order_by("item__name")
)
for item_action_form in (*formset.forms, formset.empty_form):
item_action_form.fields["item"].queryset = item_queryset
self.attach_metadata_forms(
item_action_form, active_operation_type if bound else None
)
return formset
def live_forms(self, formset):
return [
f
for f in formset.forms
if f not in formset.deleted_forms and f.has_changed()
]
def active_metadata_form(self, item_action_form, operation_type):
return next(
(
block["form"]
for block in item_action_form.blocks
if block["action"] == operation_type
),
None,
)
def render_form(self, form, formset):
empty = self.attach_metadata_forms(formset.empty_form)
return self.render_to_response(
self.get_context_data(form=form, formset=formset, empty_form=empty)
)
def get_context_data(self, **kwargs):
ctx = super().get_context_data(**kwargs)
if "formset" not in ctx:
ctx["formset"] = self.build_formset()
ctx["empty_form"] = self.attach_metadata_forms(ctx["formset"].empty_form)
ctx["stock"] = self.stock
return ctx
def form_valid(self, form):
self.object = form.save(commit=False)
operation_type = self.object.action
formset = self.build_formset(
self.object,
bound=True,
active_operation_type=operation_type,
)
ok = formset.is_valid()
if ok:
for item_action_form in self.live_forms(formset):
metadata_form = self.active_metadata_form(
item_action_form, operation_type
)
if metadata_form is not None:
ok = metadata_form.is_valid() and ok
if ok:
stock_actions, item_actions, metadata_entries = self.serialize_forms(
form, formset, operation_type
)
with transaction.atomic():
stock_items = (
StockItemStock.objects.select_for_update()
.select_related("item")
.in_bulk(item_action.item_id for item_action in item_actions)
)
for item_action in item_actions:
item_action.item = stock_items[item_action.item_id]
try:
if operation_type == OperationType.TransferTo:
(
destination_stock_action,
destination_stock_items,
destination_item_actions,
) = apply_transfer(
stock_items,
item_actions,
metadata_entries,
user=stock_actions[0].user,
source_stock=self.stock,
)
stock_actions.append(destination_stock_action)
item_actions.extend(destination_item_actions)
stock_items.update(
{item.pk: item for item in destination_stock_items}
)
else:
update_quantities(
stock_items, item_actions, metadata_entries, operation_type
)
except forms.ValidationError as error:
error.message = error.message + _(
" Check if the quantity has not changed."
)
form.add_error(None, error)
transaction.set_rollback(True)
return self.render_form(form, formset)
self.save_all(
list(stock_items.values()),
stock_actions,
item_actions,
metadata_entries,
)
return HttpResponseRedirect(self.get_success_url())
return self.render_form(form, formset)
def form_invalid(self, form):
formset = self.build_formset(
form.instance,
bound=True,
active_operation_type=self.posted_operation_type(),
)
return self.render_form(form, formset)
def save_all(self, stock_items, stock_actions, item_actions, metadata_entries):
# MariaDB dosen't populate IDs after bulk_create, But we dont use it
StockAction.objects.bulk_create(stock_actions, batch_size=1000)
StockItemAction.objects.bulk_create(item_actions, batch_size=1000)
if metadata_entries:
type(metadata_entries[0]).objects.bulk_create(
metadata_entries, batch_size=1000
)
StockItemStock.objects.bulk_update(stock_items, ["quantity"], batch_size=1000)
def serialize_forms(self, form, formset, operation_type):
stock_action = form.save(commit=False)
stock_action.user = self.request.user
item_action_forms = self.live_forms(formset)
item_actions = [
item_action_form.save(commit=False)
for item_action_form in item_action_forms
]
for _item_action_form, item_action in zip(
item_action_forms, item_actions, strict=True
):
item_action.action = stock_action
metadata_entries = []
for item_action_form, item_action in zip(
item_action_forms, item_actions, strict=True
):
metadata_form = self.active_metadata_form(item_action_form, operation_type)
if metadata_form is None or (
not self.metadata_required and not metadata_form.has_changed()
):
continue
metadata_entry = metadata_form.save(commit=False)
metadata_entry.item_action = item_action
if operation_type == OperationType.TransferTo:
metadata_entry.old_stock = self.stock
metadata_entries.append(metadata_entry)
return [stock_action], item_actions, metadata_entries
def dispatch(self, request, *args, **kwargs):
self.club = get_object_or_404(Club, pk=kwargs["club_id"])
self.stock = get_object_or_404(Stock, pk=kwargs["stock_id"], club=self.club)
return super().dispatch(request, *args, **kwargs)
def get_success_url(self):
return reverse(
"stock:items_list",
kwargs={"club_id": self.club.id, "stock_id": self.stock.id},
)