mirror of
https://framagit.org/la-chariotte/la-chariotte.git
synced 2025-05-01 11:22:24 +02:00
378 lines
14 KiB
Python
378 lines
14 KiB
Python
import csv
|
|
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 GroupedOrderUpdateView(UserPassesTestMixin, generic.UpdateView):
|
|
"""View for updating a grouped order"""
|
|
|
|
model = GroupedOrder
|
|
template_name = "order/grouped_order_update.html"
|
|
fields = ["name", "deadline", "delivery_date", "place", "description"]
|
|
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 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() is not None 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")
|
|
|
|
|
|
class ExportGroupedOrderEmailAddressesToCSVView(UserPassesTestMixin, generic.View):
|
|
# grouped_order_id = self.kwargs.get("grouped_order_id")
|
|
# grouped_order = get_object_or_404(GroupedOrder, pk=grouped_order_id)
|
|
|
|
def test_func(self):
|
|
"""Accessible only if the requesting user is the grouped order organizer"""
|
|
grouped_order_id = self.kwargs.get("grouped_order_id")
|
|
return GroupedOrder.objects.get(pk=grouped_order_id).orga == self.request.user
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
grouped_order_id = self.kwargs.get("grouped_order_id")
|
|
grouped_order = get_object_or_404(GroupedOrder, pk=grouped_order_id)
|
|
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
|
|
|
|
|
|
# def export_grouped_order_email_addresses_to_csv(request, grouped_order_id):
|
|
# """Exports a csv list of participants email addresses - only for the organizer"""
|
|
|
|
# # Check if the user is orga
|
|
# if request.user
|
|
# grouped_order = get_object_or_404(GroupedOrder, pk=grouped_order_id)
|
|
# 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
|