la-chariotte/la_chariotte/order/views.py

from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin
from django.http import HttpResponseRedirect
from django.shortcuts import get_object_or_404, render
from django.urls import reverse, reverse_lazy
from django.utils import timezone
from django.views import generic

from .forms import GroupedOrderForm, ItemCreateForm
from .models import GroupedOrder, Item, Order, OrderedItem


class IndexView(LoginRequiredMixin, generic.ListView):
    """View showing all the grouped orders organized by the authenticated user"""

    template_name = "order/index.html"
    context_object_name = "grouped_order_list"

    def get_queryset(self):
        """Only grouped orders organized by logged user"""
        logged_user_grouped_orders = GroupedOrder.objects.filter(orga=self.request.user)

        """3 grouped_order status : incoming, crossed_deadline, and old"""
        now = timezone.now()
        today = now.date()

        """Return the 5 most recent old grouped orders"""
        old_grouped_orders = logged_user_grouped_orders.filter(
            # is_to_be_delivered=False
            delivery_date__lt=today
        ).order_by("-delivery_date")[
            :5
        ]  # delivery date < today (delivered)

        """Return all grouped orders, that have crossed their ordering deadline but the delivery date is still to come"""
        crossed_dealine_grouped_orders = (
            logged_user_grouped_orders.filter(delivery_date__gte=today)
            .filter(deadline__lt=now)
            .order_by("-delivery_date")
        )  # delivery date >= today (not delivered) and deadline < today (we cannot order)

        """Return all incoming grouped orders"""
        incoming_grouped_orders = logged_user_grouped_orders.filter(
            deadline__gte=now
        ).order_by(
            "deadline"
        )  # dealine >= today (we can still order)
        return {
            "old_grouped_orders": old_grouped_orders,
            "crossed_deadline_grouped_orders": crossed_dealine_grouped_orders,
            "incoming_grouped_orders": incoming_grouped_orders,
        }


class GroupedOrderDetailView(generic.DetailView):
    """Detail view for a grouped order - possibility to order if it is ongoing - No permissions restriction"""

    model = GroupedOrder
    template_name = "order/grouped_order_detail.html"
    context_object_name = "grouped_order"


class GroupedOrderOrgaView(UserPassesTestMixin, generic.DetailView):
    """Overview of a grouped order, for the organizer"""

    model = GroupedOrder
    template_name = "order/grouped_order_overview.html"
    context_object_name = "grouped_order"

    def test_func(self):
        """Accessible only if the requesting user is the grouped order organizer"""
        return self.get_object().orga == self.request.user


class GroupedOrderCreateView(LoginRequiredMixin, generic.CreateView):
    """View for creating a new grouped order"""

    model = GroupedOrder
    form_class = GroupedOrderForm
    template_name = "order/grouped_order_create.html"

    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs["user"] = self.request.user
        return kwargs


class GroupedOrderAddItemsView(UserPassesTestMixin, generic.ListView):
    """After creating grouped order, view for adding items to it"""

    model = Item
    template_name = "order/grouped_order_add_items.html"
    queryset = Item.objects.all()

    def get_queryset(self):
        items = super().get_queryset()
        items = items.filter(grouped_order__id=self.kwargs.get("pk"))
        return items

    def get_context_data(self, **kwargs):
        context = super(GroupedOrderAddItemsView, self).get_context_data(**kwargs)
        context["grouped_order"] = GroupedOrder.objects.get(id=self.kwargs.get("pk"))
        return context

    def test_func(self):
        """Accessible only if the requesting user is the grouped order organizer"""
        grouped_order_id = self.kwargs.get("pk")
        return GroupedOrder.objects.get(pk=grouped_order_id).orga == self.request.user


class ItemCreateView(UserPassesTestMixin, generic.CreateView):
    """CreateView for an item"""

    model = Item
    form_class = ItemCreateForm

    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs["grouped_order"] = GroupedOrder.objects.get(id=self.kwargs.get("pk"))
        return kwargs

    def test_func(self):
        """Accessible only if the requesting user is the grouped order organizer"""
        grouped_order_id = self.kwargs.get("pk")
        return GroupedOrder.objects.get(pk=grouped_order_id).orga == self.request.user


def order(
    request, grouped_order_id
):  # crée une commande (order) pour cette commande groupée, avec l'item selectionné dedans
    grouped_order = get_object_or_404(GroupedOrder, pk=grouped_order_id)
    try:
        selected_item = grouped_order.item_set.get(pk=request.POST["item"])
    except (KeyError, Item.DoesNotExist):
        # Redisplay the order form for this grouped order.
        return render(
            request,
            "order/grouped_order_detail.html",
            {
                "grouped_order": grouped_order,
                "error_message": "You didn't select an item.",
            },
        )
    else:
        order = Order.objects.create(author="Auteur teur", grouped_order=grouped_order)
        OrderedItem.objects.create(nb=1, order=order, item=selected_item)
        compute_ordered_nb(selected_item)
        selected_item.save()
        # Always return an HttpResponseRedirect after successfully dealing
        # with POST data. This prevents data from being posted twice if a
        # user hits the Back button.
        return HttpResponseRedirect(
            reverse("order:grouped_order_overview", args=(grouped_order.pk,))
        )


def compute_ordered_nb(item):
    """Calcule le nombre de produits de ce type commandés (pour cette commande groupée)"""
    ordered_nb = 0
    for order in item.orders.all():
        ordered_nb += order.nb
    item.ordered_nb = ordered_nb
    item.save()