la-chariotte/la_chariotte/order/views/grouped_order.py

import csv
import json
from io import BytesIO

from django import http
from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin
from django.core.serializers.json import DjangoJSONEncoder
from django.shortcuts import get_object_or_404
from django.template.loader import get_template
from django.urls import reverse, reverse_lazy
from django.utils import timezone
from django.views import generic
from django_weasyprint import WeasyTemplateResponseMixin
from django_weasyprint.views import WeasyTemplateResponse, WeasyTemplateView
from xhtml2pdf import pisa

from ..forms import GroupedOrderForm, Item
from ..models import GroupedOrder, OrderAuthor


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"
        )  # deadline >= 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"

    def get_object(self, queryset=None):
        """Get the object from the code in url path"""
        return get_object_or_404(GroupedOrder, code=self.kwargs.get("code"))

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        # Get remaining quantities
        qty_dict = {}
        for item in self.get_object().item_set.all():
            qty_dict[item.id] = item.get_remaining_nb()
        context["remaining_qty"] = qty_dict

        # Get a dict with prices for the js display of total price of an order
        prices_dict = {}
        for item in self.get_object().item_set.all():
            prices_dict[item.id] = item.price
        context["prices_dict"] = json.dumps(prices_dict, cls=DjangoJSONEncoder)
        return context


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 get_object(self, queryset=None):
        """Get the object from the code in url path"""
        return get_object_or_404(GroupedOrder, code=self.kwargs.get("code"))

    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):
        # Compute grouped order total price before display
        self.get_object().compute_total_price()
        self.get_object().compute_items_ordered_nb()
        return super().get(self, request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(GroupedOrderOverview, self).get_context_data(**kwargs)
        # Add share link to context
        context["share_link"] = self.request.build_absolute_uri(
            reverse("order:grouped_order_detail", args=(self.get_object().pk,))
        )
        return context


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

    def form_valid(self, form):
        """If the form is valid, generate a unique code and save"""
        self.object = form.save()
        self.object.create_code_from_pk()
        return super().form_valid(form)


class GroupedOrderUpdateView(UserPassesTestMixin, generic.UpdateView):
    """View for updating a grouped order"""

    model = GroupedOrder
    template_name = "order/grouped_order_update.html"
    context_object_name = "grouped_order"
    form_class = GroupedOrderForm

    def get_object(self, queryset=None):
        """Get the object from the code in url path"""
        return get_object_or_404(GroupedOrder, code=self.kwargs.get("code"))

    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_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs["user"] = self.request.user
        return kwargs


class GroupedOrderDuplicateView(UserPassesTestMixin, generic.RedirectView):
    """View for duplicating an existing grouped order : the groupedOrder is duplicated
    and the user is redirected to the new grouped order update view"""

    def test_func(self):
        """Accessible only if the requesting user is the grouped order organizer"""
        initial_grouped_order = get_object_or_404(
            GroupedOrder, code=self.kwargs.get("code")
        )
        return initial_grouped_order.orga == self.request.user

    def get(self, request, *args, **kwargs):
        # overwrite the get function to copy the initial grouped order before redirecting to
        # the update view of the new grouped order
        initial_grouped_order = get_object_or_404(
            GroupedOrder, code=self.kwargs.get("code")
        )
        new_grouped_order = GroupedOrder.objects.create(
            name=f"{initial_grouped_order.name} - copie",
            orga=self.request.user,
            delivery_date=initial_grouped_order.delivery_date,
            deadline=initial_grouped_order.deadline,
            place=initial_grouped_order.place,
            description=initial_grouped_order.description,
        )
        # create a unique code for the new grouped order
        new_grouped_order.create_code_from_pk()
        new_grouped_order.save()
        # duplicate each item and add it to new_grouped_order
        for item in initial_grouped_order.item_set.all():
            item.pk = None
            item.ordered_nb = 0
            item.save()
            new_grouped_order.item_set.add(item)

        self.kwargs["new_go_code"] = new_grouped_order.code

        return super().get(request, *args, **kwargs)

    def get_redirect_url(self, *args, **kwargs):
        return reverse_lazy(
            "order:update_grouped_order", kwargs={"code": self.kwargs["new_go_code"]}
        )


class GroupedOrderDeleteView(UserPassesTestMixin, generic.DeleteView):
    """View for deleting a grouped order"""

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

    def get_object(self, queryset=None):
        """Get the object from the code in url path"""
        return get_object_or_404(GroupedOrder, code=self.kwargs.get("code"))

    def get_success_url(self):
        return reverse_lazy("order:index")

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

    def form_valid(self, form):
        # Delete the related OrderAuthors
        grouped_order = self.get_object()
        for order in grouped_order.order_set.all():
            order.author.delete()
        return super().form_valid(form)


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__code=self.kwargs.get("code"))
        return items

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

    def test_func(self):
        """Accessible only if the requesting user is the grouped order organizer"""
        grouped_order = get_object_or_404(GroupedOrder, code=self.kwargs.get("code"))
        return grouped_order.orga == self.request.user


class GroupedOrderExportView(UserPassesTestMixin, generic.DetailView):
    """View for gathering information about the groupedorder, in order to download it
    in the DownloadGroupedOrderSheetView"""

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

    def get_object(self, queryset=None):
        """Get the object from the code in url path"""
        return get_object_or_404(GroupedOrder, code=self.kwargs.get("code"))

    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_context_data(self, **kwargs):
        context = super(GroupedOrderExportView, self).get_context_data(**kwargs)
        grouped_order = self.get_object()

        # Get ordered items
        items = grouped_order.item_set.filter(ordered_nb__gt=0).order_by("name")

        # Get content of orders as a dict {order : [ordered_nb for item 1, ordered_nb for item 2, ...]}
        orders_dict = {}
        for order in grouped_order.order_set.all().order_by(
            "author__last_name", "author__first_name"
        ):
            ordered_values = []  # ordered_values list as value of the dict
            for item in items:  # items that has actually been ordered
                # find the ordered nb of this item in this order
                # if no item of the type has been ordered in this order, put 0
                value = order.ordered_items.filter(item=item).first()
                value = value.nb if value else 0
                ordered_values.append(value)
            orders_dict[order] = ordered_values  # order as key of the dict

        context["items"] = items
        context["orders_dict"] = orders_dict

        return context


class DownloadGroupedOrderSheetView(WeasyTemplateResponseMixin, GroupedOrderExportView):
    """View for downloading the grouped order sheet,
    using django-weasyprint : https://pypi.org/project/django-weasyprint/"""

    def get_pdf_filename(self):
        # filename for download
        return f"{self.get_object().delivery_date} - {self.get_object().name}"


class ExportGroupedOrderEmailAddressesToCSVView(UserPassesTestMixin, generic.View):
    """Export all participant email addresses in a csv line"""

    def test_func(self):
        """Accessible only if the requesting user is the grouped order organizer"""
        initial_grouped_order = get_object_or_404(
            GroupedOrder, code=self.kwargs.get("code")
        )
        return initial_grouped_order.orga == self.request.user

    def get(self, request, *args, **kwargs):
        grouped_order = get_object_or_404(GroupedOrder, code=self.kwargs.get("code"))
        participants = OrderAuthor.objects.filter(
            order__in=grouped_order.order_set.all()
        )

        response = http.HttpResponse(
            content_type="text/csv",
            headers={
                "Content-Disposition": f'attachment; filename="{ grouped_order.name }-mails.csv"'
            },
        )
        writer = csv.writer(response)
        row = [participant.email for participant in participants]
        writer.writerow(row)
        return response


class ExportGroupedOrderToCSVView(GroupedOrderExportView):
    """Export a csv with the same info as in pdf sheet"""

    def get(self, request, *args, **kwargs):
        super(ExportGroupedOrderToCSVView, self).get(self, request, *args, **kwargs)
        context = self.get_context_data()

        response = http.HttpResponse(
            content_type="text/csv",
            headers={
                "Content-Disposition": f'attachment; filename="{ context["object"].name }-commandes"'
            },
        )
        writer = csv.writer(response)

        # write headers rows
        row = [""]
        for item in context["items"]:
            row.append(item.name)
        row.append("Prix de la commande")
        row.append("Mail")
        row.append("Téléphone")
        writer.writerow(row)

        row = ["Prix unitaire TTC (€)"]
        for item in context["items"]:
            row.append(str(item.price).replace(".", ","))
        writer.writerow(row)

        # write ordered values rows
        for order, ordered_items in context["orders_dict"].items():
            row = [order.author]
            for ordered_nb in ordered_items:
                row.append(ordered_nb)
            row.append(str(order.price).replace(".", ","))
            row.append(order.author.email)
            row.append(f"'{order.author.phone}")
            writer.writerow(row)

        # write total row

        row = ["TOTAL"]
        for item in context["items"]:
            row.append(item.ordered_nb)
        row.append(str(context["object"].total_price).replace(".", ","))
        writer.writerow(row)

        return response