Sith/launderette/views.py

286 lines
12 KiB
Python
Raw Normal View History

2016-07-28 23:38:46 +00:00
from datetime import datetime, timedelta
from collections import OrderedDict
import pytz
2016-07-28 23:38:46 +00:00
2016-07-28 18:05:56 +00:00
from django.shortcuts import render
from django.views.generic import ListView, DetailView, RedirectView, TemplateView
from django.views.generic.edit import UpdateView, CreateView, DeleteView, BaseFormView
2016-07-28 18:05:56 +00:00
from django.forms.models import modelform_factory
from django.forms import CheckboxSelectMultiple
from django.utils.translation import ugettext as _
2016-07-28 23:38:46 +00:00
from django.utils import dateparse
from django.core.urlresolvers import reverse_lazy
2016-07-28 18:05:56 +00:00
from django.conf import settings
from django.db import transaction
from django import forms
from django.template import defaultfilters
from django.utils import formats
2016-07-28 18:05:56 +00:00
from core.models import Page
from club.models import Club
2016-07-28 18:05:56 +00:00
from core.views import CanViewMixin, CanEditMixin, CanEditPropMixin, CanCreateMixin
from launderette.models import Launderette, Token, Machine, Slot
2016-07-28 23:38:46 +00:00
from subscription.views import get_subscriber
from counter.models import Counter, Customer
from counter.views import GetUserForm
2016-07-28 18:05:56 +00:00
# For users
class LaunderetteMainView(TemplateView):
"""Main presentation view"""
template_name = 'launderette/launderette_main.jinja'
def get_context_data(self, **kwargs):
""" Add page to the context """
kwargs = super(LaunderetteMainView, self).get_context_data(**kwargs)
kwargs['page'] = Page.objects.filter(name='launderette').first()
return kwargs
class LaunderetteBookMainView(CanViewMixin, ListView):
"""Choose which launderette to book"""
model = Launderette
2016-07-28 23:38:46 +00:00
template_name = 'launderette/launderette_book_choose.jinja'
2016-07-28 18:05:56 +00:00
class LaunderetteBookView(CanViewMixin, DetailView):
2016-07-28 18:05:56 +00:00
"""Display the launderette schedule"""
model = Launderette
pk_url_kwarg = "launderette_id"
template_name = 'launderette/launderette_book.jinja'
def get(self, request, *args, **kwargs):
self.slot_type = "BOTH"
self.machines = {}
return super(LaunderetteBookView, self).get(request, *args, **kwargs)
2016-07-28 23:38:46 +00:00
def post(self, request, *args, **kwargs):
self.slot_type = "BOTH"
self.machines = {}
with transaction.atomic():
self.object = self.get_object()
if 'slot_type' in request.POST.keys():
self.slot_type = request.POST['slot_type']
if 'slot' in request.POST.keys() and request.user.is_authenticated():
self.subscriber = get_subscriber(request.user)
if self.subscriber.is_subscribed():
self.date = dateparse.parse_datetime(request.POST['slot']).replace(tzinfo=pytz.UTC)
if self.slot_type == "WASHING":
if self.check_slot(self.slot_type):
Slot(user=self.subscriber, start_date=self.date, machine=self.machines[self.slot_type], type=self.slot_type).save()
elif self.slot_type == "DRYING":
if self.check_slot(self.slot_type):
Slot(user=self.subscriber, start_date=self.date, machine=self.machines[self.slot_type], type=self.slot_type).save()
else:
if self.check_slot("WASHING") and self.check_slot("DRYING", self.date + timedelta(hours=1)):
Slot(user=self.subscriber, start_date=self.date, machine=self.machines["WASHING"], type="WASHING").save()
Slot(user=self.subscriber, start_date=self.date + timedelta(hours=1),
machine=self.machines["DRYING"], type="DRYING").save()
2016-07-28 23:38:46 +00:00
return super(LaunderetteBookView, self).get(request, *args, **kwargs)
def check_slot(self, type, date=None):
if date is None: date = self.date
for m in self.object.machines.filter(is_working=True, type=type).all():
slot = Slot.objects.filter(start_date=date, machine=m).first()
if slot is None:
self.machines[type] = m
return True
return False
2016-07-28 23:38:46 +00:00
@staticmethod
def date_iterator(startDate, endDate, delta=timedelta(days=1)):
currentDate = startDate
while currentDate < endDate:
yield currentDate
currentDate += delta
def get_context_data(self, **kwargs):
""" Add page to the context """
kwargs = super(LaunderetteBookView, self).get_context_data(**kwargs)
kwargs['planning'] = OrderedDict()
kwargs['slot_type'] = self.slot_type
start_date = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0, tzinfo=pytz.UTC)
2016-07-28 23:38:46 +00:00
for date in LaunderetteBookView.date_iterator(start_date, start_date+timedelta(days=6), timedelta(days=1)):
kwargs['planning'][date] = []
for h in LaunderetteBookView.date_iterator(date, date+timedelta(days=1), timedelta(hours=1)):
free = False
if self.slot_type == "BOTH" and self.check_slot("WASHING", h) and self.check_slot("DRYING", h + timedelta(hours=1)):
free = True
elif self.slot_type == "WASHING" and self.check_slot("WASHING", h):
free = True
elif self.slot_type == "DRYING" and self.check_slot("DRYING", h):
free = True
if free and datetime.now().replace(tzinfo=pytz.UTC) < h:
2016-07-28 23:38:46 +00:00
kwargs['planning'][date].append(h)
else:
kwargs['planning'][date].append(None)
return kwargs
2016-07-28 18:05:56 +00:00
# For admins
class LaunderetteListView(CanEditPropMixin, ListView):
2016-07-28 18:05:56 +00:00
"""Choose which launderette to administer"""
model = Launderette
template_name = 'launderette/launderette_list.jinja'
class LaunderetteEditView(CanEditPropMixin, UpdateView):
2016-07-28 18:05:56 +00:00
"""Edit a launderette"""
model = Launderette
pk_url_kwarg = "launderette_id"
fields = ['name']
2016-07-28 18:05:56 +00:00
template_name = 'core/edit.jinja'
class LaunderetteCreateView(CanCreateMixin, CreateView):
"""Create a new launderette"""
model = Launderette
fields = ['name']
2016-07-28 18:05:56 +00:00
template_name = 'core/create.jinja'
def form_valid(self, form):
club = Club.objects.filter(unix_name=settings.SITH_LAUNDERETTE_MANAGER['unix_name']).first()
c = Counter(name=form.instance.name, club=club, type='OFFICE')
c.save()
form.instance.counter = c
return super(LaunderetteCreateView, self).form_valid(form)
class LaunderetteDetailView(CanEditPropMixin, DetailView):
"""The admin page of the launderette"""
model = Launderette
pk_url_kwarg = "launderette_id"
template_name = 'launderette/launderette_detail.jinja'
class LaunderetteMainClickView(CanEditMixin, BaseFormView, DetailView):
"""The click page of the launderette"""
model = Launderette
pk_url_kwarg = "launderette_id"
template_name = 'counter/counter_main.jinja'
form_class = GetUserForm # Form to enter a client code and get the corresponding user id
def get_context_data(self, **kwargs):
"""
We handle here the login form for the barman
"""
kwargs = super(LaunderetteMainClickView, self).get_context_data(**kwargs)
kwargs['counter'] = self.object.counter
kwargs['form'] = self.get_form()
kwargs['barmen'] = [self.request.user]
if 'last_basket' in self.request.session.keys():
kwargs['last_basket'] = self.request.session.pop('last_basket', None)
kwargs['last_customer'] = self.request.session.pop('last_customer', None)
kwargs['last_total'] = self.request.session.pop('last_total', None)
kwargs['new_customer_amount'] = self.request.session.pop('new_customer_amount', None)
return kwargs
def form_valid(self, form):
"""
We handle here the redirection, passing the user id of the asked customer
"""
self.object = self.get_object()
self.kwargs['user_id'] = form.cleaned_data['user_id']
return super(LaunderetteMainClickView, self).form_valid(form)
def get_success_url(self):
return reverse_lazy('launderette:click', args=self.args, kwargs=self.kwargs)
class ClickTokenForm(forms.BaseForm):
pass
class LaunderetteClickView(CanEditMixin, DetailView, BaseFormView):
"""The click page of the launderette"""
model = Launderette
pk_url_kwarg = "launderette_id"
template_name = 'launderette/launderette_click.jinja'
def get_form_class(self):
fields = OrderedDict()
kwargs = {}
def clean_field_factory(field_name, slot):
def clean_field(self2):
t_name = str(self2.data[field_name])
if t_name != "":
t = Token.objects.filter(name=str(self2.data[field_name]), type=slot.type, launderette=self.object).first()
if t is None:
raise forms.ValidationError(_("Token not found"))
return clean_field
for s in self.subscriber.slots.filter(token=None).all():
field_name = "slot-%s" % (str(s.id))
fields[field_name] = forms.CharField(max_length=5, required=False,
label="%s - %s" % (s.get_type_display(), defaultfilters.date(s.start_date, "j N Y H:i")))
# XXX l10n settings.DATETIME_FORMAT did'nt work here :/
kwargs["clean_"+field_name] = clean_field_factory(field_name, s)
def clean_form(self2):
raise forms.ValidationError(_("Not enough money"))
return self2.cleaned_data
kwargs['base_fields'] = fields
kwargs['clean'] = clean_form
return type('ClickForm', (ClickTokenForm,), kwargs)
def get(self, request, *args, **kwargs):
"""Simple get view"""
self.customer = Customer.objects.filter(user__id=self.kwargs['user_id']).first()
self.subscriber = get_subscriber(self.customer.user)
return super(LaunderetteClickView, self).get(request, *args, **kwargs)
def post(self, request, *args, **kwargs):
""" Handle the many possibilities of the post request """
self.object = self.get_object()
self.customer = Customer.objects.filter(user__id=self.kwargs['user_id']).first()
self.subscriber = get_subscriber(self.customer.user)
return super(LaunderetteClickView, self).post(request, *args, **kwargs)
def form_valid(self, form):
"""
We handle here the redirection, passing the user id of the asked customer
"""
self.request.session['last_basket'] = ["GUY"]
return super(LaunderetteClickView, self).form_valid(form)
def get_context_data(self, **kwargs):
"""
We handle here the login form for the barman
"""
kwargs = super(LaunderetteClickView, self).get_context_data(**kwargs)
if 'form' not in kwargs.keys():
kwargs['form'] = self.get_form()
kwargs['counter'] = self.object.counter
kwargs['customer'] = self.customer
return kwargs
def get_success_url(self):
self.kwargs.pop('user_id', None)
return reverse_lazy('launderette:main_click', args=self.args, kwargs=self.kwargs)
class MachineEditView(CanEditPropMixin, UpdateView):
"""Edit a machine"""
model = Machine
pk_url_kwarg = "machine_id"
fields = ['name', 'launderette', 'type', 'is_working']
template_name = 'core/edit.jinja'
class MachineDeleteView(CanEditPropMixin, DeleteView):
"""Edit a machine"""
model = Machine
pk_url_kwarg = "machine_id"
template_name = 'core/delete_confirm.jinja'
success_url = reverse_lazy('launderette:launderette_list')
class MachineCreateView(CanCreateMixin, CreateView):
"""Create a new machine"""
model = Machine
fields = ['name', 'launderette', 'type']
template_name = 'core/create.jinja'
def get_initial(self):
ret = super(MachineCreateView, self).get_initial()
if 'launderette' in self.request.GET.keys():
obj = Launderette.objects.filter(id=int(self.request.GET['launderette'])).first()
if obj is not None:
ret['launderette'] = obj.id
return ret