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, OrderAuthor, 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 GroupedOrderOverview(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

    def get(self, request, *args, **kwargs):
        self.get_object().compute_total_price()
        return super().get(self, request, *args, **kwargs)


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):
    """Creates an AnonymousUser, and an Order for this GroupedOrder, with related OrderedItems"""
    grouped_order = get_object_or_404(GroupedOrder, pk=grouped_order_id)
    # get a dict with (quantity_{{item_id}}:{{quantity}})
    orders_dict = {
        key: value for key, value in request.POST.items() if key.startswith("quantity")
    }
    first_name = request.POST["first_name"]
    last_name = request.POST["last_name"]
    phone = request.POST["phone"]
    email = request.POST["email"]
    author = OrderAuthor.objects.create(
        first_name=first_name, last_name=last_name, email=email, phone=phone
    )
    order = Order.objects.create(author=author, grouped_order=grouped_order)
    for key, quantity in orders_dict.items():
        if quantity == "":
            quantity = 0
        if int(quantity) > 0:
            item = grouped_order.item_set.get(pk=key.split("_")[1])
            OrderedItem.objects.create(nb=quantity, order=order, item=item)
            item.compute_ordered_nb()
    order.compute_order_articles_nb()
    if order.articles_nb == 0:
        # Redisplay the order form for this grouped order.
        return render(
            request,
            "order/grouped_order_detail.html",
            {
                "grouped_order": grouped_order,
                "error_message": "Veuillez commander au moins un produit",
            },
        )
    else:
        order.compute_order_price()
        # 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:order_confirm", args=(grouped_order.pk, order.pk))
        )


class OrderDetailView(generic.DetailView):
    """Confirmation page after a user orders"""

    model = Order