from io import BytesIO from django import http from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin from django.core.exceptions import ValidationError from django.shortcuts import get_object_or_404, render 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 xhtml2pdf import pisa 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" ) # 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_context_data(self, **kwargs): context = super().get_context_data(**kwargs) qty_dict = {} for item in self.get_object().item_set.all(): qty_dict[item.id] = item.get_remaining_nb() context["remaining_qty"] = qty_dict 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 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() 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 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 class ItemDeleteView(UserPassesTestMixin, generic.DeleteView): """DeleteView for an item The form does a GET to this view - it displays a confirmation page - then we post this view """ model = Item def get_success_url(self): return reverse_lazy("order:manage_items", args=[self.object.grouped_order.id]) def test_func(self): """Accessible only if the requesting user is the grouped order organizer""" return self.get_object().grouped_order.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) # check if the grouped order is ongoing if not grouped_order.is_ongoing(): return http.HttpResponseForbidden() # get a dict with quantity_{{item_id}}:[ {{ quantity on phone }},{{ quantity on desktop }} ] orders_dict = { key: request.POST.getlist(key) for key, value in request.POST.items() if key.startswith("quantity") } # transform it into quantity_{{item_id}}: {{ greatest of the two quantities }} for i in orders_dict: value = ( orders_dict[i][0] if orders_dict[i][0] >= orders_dict[i][1] else orders_dict[i][1] ) orders_dict[i] = value # create an order 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) # add items to the order error_message = None for key, quantity in orders_dict.items(): quantity = int(quantity) item = grouped_order.item_set.get(pk=key.split("_")[1]) # check if too many items are ordered error_message = validate_item_ordered_nb(item, quantity) if error_message: break # stop creating items if there is an error if quantity > 0: OrderedItem.objects.create(nb=quantity, order=order, item=item) # Redisplay the form with error messages if there is an error if error_message: order.delete() author.delete() grouped_order.compute_items_ordered_nb() return render( request, "order/grouped_order_detail.html", { "grouped_order": grouped_order, "error_message": error_message, }, ) # check if the order contains articles error_message = validate_articles_ordered_nb(order) # Redisplay the form with error messages if there is an error if error_message: order.delete() author.delete() return render( request, "order/grouped_order_detail.html", { "grouped_order": grouped_order, "error_message": error_message, }, ) # Redirect to confirmation page order.compute_order_price() grouped_order.compute_items_ordered_nb() # Always return an http.HttpResponseRedirect after successfully dealing # with POST data. This prevents data from being posted twice if a # user hits the Back button. return http.HttpResponseRedirect( reverse("order:order_confirm", args=(grouped_order.pk, order.pk)) ) def validate_item_ordered_nb(item, ordered_nb): """Returns an error message if the ordered items are not available""" if item.get_remaining_nb() and item.get_remaining_nb() - ordered_nb < 0: return f"Trop de {item.name} commandés pour la quantité disponible" return None def validate_articles_ordered_nb(order): """Return an error if no items are ordered""" order.compute_order_articles_nb() if order.articles_nb == 0: return "Veuillez commander au moins un produit" return None class OrderDetailView(generic.DetailView): """Confirmation page after a user orders""" model = Order class GroupedOrderSheetMixin: """Mixin for grouped order info export (pdf sheet and csv)""" def get_grouped_order_infos(self, grouped_order_id): grouped_order = get_object_or_404(GroupedOrder, id=grouped_order_id) # 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(): 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 return { "name": grouped_order.name, "delivery_date": grouped_order.delivery_date, "items": items, "orders_dict": orders_dict, "total_price": grouped_order.total_price, } class GroupedOrderSheetView(GroupedOrderOverview, GroupedOrderSheetMixin): """View to get a pdf sheet summing up the grouped order for delivery""" template_name = "order/grouped_order_sheet.html" def get(self, request, pk): grouped_order_sheet_info = self.get_grouped_order_infos(pk) # should_include_prices = True if request.GET.get("with_prices", False) else False # delivery_sheet_info["include_prices"] = should_include_prices - à ajouter plus tard template = get_template(self.template_name) html = template.render(grouped_order_sheet_info) result = BytesIO() pdf = pisa.pisaDocument(BytesIO(html.encode("UTF-8")), result) return http.HttpResponse(result.getvalue(), content_type="application/pdf")