from io import BytesIO from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin from django.http import FileResponse, HttpResponse, HttpResponseRedirect 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" ) # 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): # 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 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 class GroupedOrderSheetMixin(): 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) # Get content of orders orders_values = [] for order in grouped_order.order_set.all(): for ordered_item in order.ordered_items.all(): orders_values[order.id][ordered_item.id] = ordered_item.nb return {"name": grouped_order.name,"delivery_date":grouped_order.delivery_date,"items":items,"orders":orders_dict} class GroupedOrderSheetView(GroupedOrderOverview, GroupedOrderSheetMixin): template_name = "order/grouped_order_sheet.html" def get(self, request, pk): # ferme = Ferme.get_or_404(ferme_id) # ferme.check_access(request.user) 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 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 HttpResponse(result.getvalue(), content_type="application/pdf")