klmp200/Sith
1
0
Fork 0
mirror of https://github.com/ae-utbm/sith.git synced 2025-07-10 11:59:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

All: Apply Black coding rules

Browse Source
This commit is contained in:
Antoine Bartuccio
2018-10-04 21:29:19 +02:00
parent 0581c667de
commit cb58b00b6e
204 changed files with 13173 additions and 6376 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
launderette/__init__.py
View File

@ -21,4 +21,3 @@
# Place - Suite 330, Boston, MA 02111-1307, USA.
#
#

188
launderette/migrations/0001_initial.py
View File

@ -6,76 +6,168 @@ from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('subscription', '0001_initial'),
('counter', '0001_initial'),
]
dependencies = [("subscription", "0001_initial"), ("counter", "0001_initial")]
operations = [
migrations.CreateModel(
name='Launderette',
name="Launderette",
fields=[
('id', models.AutoField(primary_key=True, serialize=False, verbose_name='ID', auto_created=True)),
('name', models.CharField(max_length=30, verbose_name='name')),
('counter', models.OneToOneField(related_name='launderette', verbose_name='counter', to='counter.Counter')),
(
"id",
models.AutoField(
primary_key=True,
serialize=False,
verbose_name="ID",
auto_created=True,
),
),
("name", models.CharField(max_length=30, verbose_name="name")),
(
"counter",
models.OneToOneField(
related_name="launderette",
verbose_name="counter",
to="counter.Counter",
),
),
],
options={
'verbose_name': 'Launderette',
},
options={"verbose_name": "Launderette"},
),
migrations.CreateModel(
name='Machine',
name="Machine",
fields=[
('id', models.AutoField(primary_key=True, serialize=False, verbose_name='ID', auto_created=True)),
('name', models.CharField(max_length=30, verbose_name='name')),
('type', models.CharField(choices=[('WASHING', 'Washing'), ('DRYING', 'Drying')], max_length=10, verbose_name='type')),
('is_working', models.BooleanField(verbose_name='is working', default=True)),
('launderette', models.ForeignKey(verbose_name='launderette', to='launderette.Launderette', related_name='machines')),
(
"id",
models.AutoField(
primary_key=True,
serialize=False,
verbose_name="ID",
auto_created=True,
),
),
("name", models.CharField(max_length=30, verbose_name="name")),
(
"type",
models.CharField(
choices=[("WASHING", "Washing"), ("DRYING", "Drying")],
max_length=10,
verbose_name="type",
),
),
(
"is_working",
models.BooleanField(verbose_name="is working", default=True),
),
(
"launderette",
models.ForeignKey(
verbose_name="launderette",
to="launderette.Launderette",
related_name="machines",
),
),
],
options={
'verbose_name': 'Machine',
},
options={"verbose_name": "Machine"},
),
migrations.CreateModel(
name='Slot',
name="Slot",
fields=[
('id', models.AutoField(primary_key=True, serialize=False, verbose_name='ID', auto_created=True)),
('start_date', models.DateTimeField(verbose_name='start date')),
('type', models.CharField(choices=[('WASHING', 'Washing'), ('DRYING', 'Drying')], max_length=10, verbose_name='type')),
('machine', models.ForeignKey(verbose_name='machine', to='launderette.Machine', related_name='slots')),
(
"id",
models.AutoField(
primary_key=True,
serialize=False,
verbose_name="ID",
auto_created=True,
),
),
("start_date", models.DateTimeField(verbose_name="start date")),
(
"type",
models.CharField(
choices=[("WASHING", "Washing"), ("DRYING", "Drying")],
max_length=10,
verbose_name="type",
),
),
(
"machine",
models.ForeignKey(
verbose_name="machine",
to="launderette.Machine",
related_name="slots",
),
),
],
options={
'verbose_name': 'Slot',
'ordering': ['start_date'],
},
options={"verbose_name": "Slot", "ordering": ["start_date"]},
),
migrations.CreateModel(
name='Token',
name="Token",
fields=[
('id', models.AutoField(primary_key=True, serialize=False, verbose_name='ID', auto_created=True)),
('name', models.CharField(max_length=5, verbose_name='name')),
('type', models.CharField(choices=[('WASHING', 'Washing'), ('DRYING', 'Drying')], max_length=10, verbose_name='type')),
('borrow_date', models.DateTimeField(null=True, verbose_name='borrow date', blank=True)),
('launderette', models.ForeignKey(verbose_name='launderette', to='launderette.Launderette', related_name='tokens')),
('user', models.ForeignKey(null=True, related_name='tokens', verbose_name='user', to='core.User', blank=True)),
(
"id",
models.AutoField(
primary_key=True,
serialize=False,
verbose_name="ID",
auto_created=True,
),
),
("name", models.CharField(max_length=5, verbose_name="name")),
(
"type",
models.CharField(
choices=[("WASHING", "Washing"), ("DRYING", "Drying")],
max_length=10,
verbose_name="type",
),
),
(
"borrow_date",
models.DateTimeField(
null=True, verbose_name="borrow date", blank=True
),
),
(
"launderette",
models.ForeignKey(
verbose_name="launderette",
to="launderette.Launderette",
related_name="tokens",
),
),
(
"user",
models.ForeignKey(
null=True,
related_name="tokens",
verbose_name="user",
to="core.User",
blank=True,
),
),
],
options={
'verbose_name': 'Token',
'ordering': ['type', 'name'],
},
options={"verbose_name": "Token", "ordering": ["type", "name"]},
),
migrations.AddField(
model_name='slot',
name='token',
field=models.ForeignKey(null=True, related_name='slots', verbose_name='token', to='launderette.Token', blank=True),
model_name="slot",
name="token",
field=models.ForeignKey(
null=True,
related_name="slots",
verbose_name="token",
to="launderette.Token",
blank=True,
),
),
migrations.AddField(
model_name='slot',
name='user',
field=models.ForeignKey(verbose_name='user', to='core.User', related_name='slots'),
model_name="slot",
name="user",
field=models.ForeignKey(
verbose_name="user", to="core.User", related_name="slots"
),
),
migrations.AlterUniqueTogether(
name='token',
unique_together=set([('name', 'launderette', 'type')]),
name="token", unique_together=set([("name", "launderette", "type")])
),
]

107
launderette/models.py
View File

@ -35,24 +35,30 @@ from club.models import Club
class Launderette(models.Model):
name = models.CharField(_('name'), max_length=30)
counter = models.OneToOneField(Counter, verbose_name=_('counter'), related_name='launderette')
name = models.CharField(_("name"), max_length=30)
counter = models.OneToOneField(
Counter, verbose_name=_("counter"), related_name="launderette"
)
class Meta:
verbose_name = _('Launderette')
verbose_name = _("Launderette")
def is_owned_by(self, user):
"""
Method to see if that object can be edited by the given user
"""
launderette_club = Club.objects.filter(unix_name=settings.SITH_LAUNDERETTE_MANAGER['unix_name']).first()
launderette_club = Club.objects.filter(
unix_name=settings.SITH_LAUNDERETTE_MANAGER["unix_name"]
).first()
m = launderette_club.get_membership_for(user)
if m and m.role >= 9:
return True
return False
def can_be_edited_by(self, user):
launderette_club = Club.objects.filter(unix_name=settings.SITH_LAUNDERETTE_MANAGER['unix_name']).first()
launderette_club = Club.objects.filter(
unix_name=settings.SITH_LAUNDERETTE_MANAGER["unix_name"]
).first()
m = launderette_club.get_membership_for(user)
if m and m.role >= 2:
return True
@ -65,7 +71,7 @@ class Launderette(models.Model):
return self.name
def get_absolute_url(self):
return reverse('launderette:launderette_list')
return reverse("launderette:launderette_list")
def get_machine_list(self):
return Machine.objects.filter(launderette_id=self.id)
@ -81,19 +87,25 @@ class Launderette(models.Model):
class Machine(models.Model):
name = models.CharField(_('name'), max_length=30)
launderette = models.ForeignKey(Launderette, related_name='machines', verbose_name=_('launderette'))
type = models.CharField(_('type'), max_length=10, choices=settings.SITH_LAUNDERETTE_MACHINE_TYPES)
is_working = models.BooleanField(_('is working'), default=True)
name = models.CharField(_("name"), max_length=30)
launderette = models.ForeignKey(
Launderette, related_name="machines", verbose_name=_("launderette")
)
type = models.CharField(
_("type"), max_length=10, choices=settings.SITH_LAUNDERETTE_MACHINE_TYPES
)
is_working = models.BooleanField(_("is working"), default=True)
class Meta:
verbose_name = _('Machine')
verbose_name = _("Machine")
def is_owned_by(self, user):
"""
Method to see if that object can be edited by the given user
"""
launderette_club = Club.objects.filter(unix_name=settings.SITH_LAUNDERETTE_MANAGER['unix_name']).first()
launderette_club = Club.objects.filter(
unix_name=settings.SITH_LAUNDERETTE_MANAGER["unix_name"]
).first()
m = launderette_club.get_membership_for(user)
if m and m.role >= 9:
return True
@ -103,20 +115,29 @@ class Machine(models.Model):
return "%s %s" % (self._meta.verbose_name, self.name)
def get_absolute_url(self):
return reverse('launderette:launderette_admin', kwargs={"launderette_id": self.launderette.id})
return reverse(
"launderette:launderette_admin",
kwargs={"launderette_id": self.launderette.id},
)
class Token(models.Model):
name = models.CharField(_('name'), max_length=5)
launderette = models.ForeignKey(Launderette, related_name='tokens', verbose_name=_('launderette'))
type = models.CharField(_('type'), max_length=10, choices=settings.SITH_LAUNDERETTE_MACHINE_TYPES)
borrow_date = models.DateTimeField(_('borrow date'), null=True, blank=True)
user = models.ForeignKey(User, related_name='tokens', verbose_name=_('user'), null=True, blank=True)
name = models.CharField(_("name"), max_length=5)
launderette = models.ForeignKey(
Launderette, related_name="tokens", verbose_name=_("launderette")
)
type = models.CharField(
_("type"), max_length=10, choices=settings.SITH_LAUNDERETTE_MACHINE_TYPES
)
borrow_date = models.DateTimeField(_("borrow date"), null=True, blank=True)
user = models.ForeignKey(
User, related_name="tokens", verbose_name=_("user"), null=True, blank=True
)
class Meta:
verbose_name = _('Token')
unique_together = ('name', 'launderette', 'type')
ordering = ['type', 'name']
verbose_name = _("Token")
unique_together = ("name", "launderette", "type")
ordering = ["type", "name"]
def save(self, *args, **kwargs):
if self.name == "":
@ -128,14 +149,25 @@ class Token(models.Model):
"""
Method to see if that object can be edited by the given user
"""
launderette_club = Club.objects.filter(unix_name=settings.SITH_LAUNDERETTE_MANAGER['unix_name']).first()
launderette_club = Club.objects.filter(
unix_name=settings.SITH_LAUNDERETTE_MANAGER["unix_name"]
).first()
m = launderette_club.get_membership_for(user)
if m and m.role >= 9:
return True
return False
def __str__(self):
return self.__class__._meta.verbose_name + " " + self.get_type_display() + " #" + self.name + " (" + self.launderette.name + ")"
return (
self.__class__._meta.verbose_name
+ " "
+ self.get_type_display()
+ " #"
+ self.name
+ " ("
+ self.launderette.name
+ ")"
)
def is_avaliable(self):
if not self.borrow_date and not self.user:
@ -145,19 +177,30 @@ class Token(models.Model):
class Slot(models.Model):
start_date = models.DateTimeField(_('start date'))
type = models.CharField(_('type'), max_length=10, choices=settings.SITH_LAUNDERETTE_MACHINE_TYPES)
machine = models.ForeignKey(Machine, related_name='slots', verbose_name=_('machine'))
token = models.ForeignKey(Token, related_name='slots', verbose_name=_('token'), blank=True, null=True)
user = models.ForeignKey(User, related_name='slots', verbose_name=_('user'))
start_date = models.DateTimeField(_("start date"))
type = models.CharField(
_("type"), max_length=10, choices=settings.SITH_LAUNDERETTE_MACHINE_TYPES
)
machine = models.ForeignKey(
Machine, related_name="slots", verbose_name=_("machine")
)
token = models.ForeignKey(
Token, related_name="slots", verbose_name=_("token"), blank=True, null=True
)
user = models.ForeignKey(User, related_name="slots", verbose_name=_("user"))
class Meta:
verbose_name = _('Slot')
ordering = ['start_date']
verbose_name = _("Slot")
ordering = ["start_date"]
def is_owned_by(self, user):
return user == self.user
def __str__(self):
return "User: %s - Date: %s - Type: %s - Machine: %s - Token: %s" % (self.user, self.start_date, self.get_type_display(),
self.machine.name, self.token)
return "User: %s - Date: %s - Type: %s - Machine: %s - Token: %s" % (
self.user,
self.start_date,
self.get_type_display(),
self.machine.name,
self.token,
)

61
launderette/urls.py
View File

@ -28,20 +28,49 @@ from launderette.views import *
urlpatterns = [
# views
url(r'^$', LaunderetteMainView.as_view(), name='launderette_main'),
url(r'^slot/(?P<slot_id>[0-9]+)/delete$', SlotDeleteView.as_view(), name='delete_slot'),
url(r'^book$', LaunderetteBookMainView.as_view(), name='book_main'),
url(r'^book/(?P<launderette_id>[0-9]+)$', LaunderetteBookView.as_view(), name='book_slot'),
url(r'^(?P<launderette_id>[0-9]+)/click$', LaunderetteMainClickView.as_view(), name='main_click'),
url(r'^(?P<launderette_id>[0-9]+)/click/(?P<user_id>[0-9]+)$', LaunderetteClickView.as_view(), name='click'),
url(r'^admin$', LaunderetteListView.as_view(), name='launderette_list'),
url(r'^admin/(?P<launderette_id>[0-9]+)$', LaunderetteAdminView.as_view(), name='launderette_admin'),
url(r'^admin/(?P<launderette_id>[0-9]+)/edit$', LaunderetteEditView.as_view(), name='launderette_edit'),
url(r'^admin/new$', LaunderetteCreateView.as_view(), name='launderette_new'),
url(r'^admin/machine/new$', MachineCreateView.as_view(), name='machine_new'),
url(r'^admin/machine/(?P<machine_id>[0-9]+)/edit$', MachineEditView.as_view(), name='machine_edit'),
url(r'^admin/machine/(?P<machine_id>[0-9]+)/delete$', MachineDeleteView.as_view(), name='machine_delete'),
url(r"^$", LaunderetteMainView.as_view(), name="launderette_main"),
url(
r"^slot/(?P<slot_id>[0-9]+)/delete$",
SlotDeleteView.as_view(),
name="delete_slot",
),
url(r"^book$", LaunderetteBookMainView.as_view(), name="book_main"),
url(
r"^book/(?P<launderette_id>[0-9]+)$",
LaunderetteBookView.as_view(),
name="book_slot",
),
url(
r"^(?P<launderette_id>[0-9]+)/click$",
LaunderetteMainClickView.as_view(),
name="main_click",
),
url(
r"^(?P<launderette_id>[0-9]+)/click/(?P<user_id>[0-9]+)$",
LaunderetteClickView.as_view(),
name="click",
),
url(r"^admin$", LaunderetteListView.as_view(), name="launderette_list"),
url(
r"^admin/(?P<launderette_id>[0-9]+)$",
LaunderetteAdminView.as_view(),
name="launderette_admin",
),
url(
r"^admin/(?P<launderette_id>[0-9]+)/edit$",
LaunderetteEditView.as_view(),
name="launderette_edit",
),
url(r"^admin/new$", LaunderetteCreateView.as_view(), name="launderette_new"),
url(r"^admin/machine/new$", MachineCreateView.as_view(), name="machine_new"),
url(
r"^admin/machine/(?P<machine_id>[0-9]+)/edit$",
MachineEditView.as_view(),
name="machine_edit",
),
url(
r"^admin/machine/(?P<machine_id>[0-9]+)/delete$",
MachineDeleteView.as_view(),
name="machine_delete",
),
]

304
launderette/views.py
View File

@ -48,26 +48,29 @@ from counter.views import GetUserForm
class LaunderetteMainView(TemplateView):
"""Main presentation view"""
template_name = 'launderette/launderette_main.jinja'
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()
kwargs["page"] = Page.objects.filter(name="launderette").first()
return kwargs
class LaunderetteBookMainView(CanViewMixin, ListView):
"""Choose which launderette to book"""
model = Launderette
template_name = 'launderette/launderette_book_choose.jinja'
template_name = "launderette/launderette_book_choose.jinja"
class LaunderetteBookView(CanViewMixin, DetailView):
"""Display the launderette schedule"""
model = Launderette
pk_url_kwarg = "launderette_id"
template_name = 'launderette/launderette_book.jinja'
template_name = "launderette/launderette_book.jinja"
def get(self, request, *args, **kwargs):
self.slot_type = "BOTH"
@ -79,23 +82,46 @@ class LaunderetteBookView(CanViewMixin, DetailView):
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():
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 = request.user
if self.subscriber.is_subscribed:
self.date = dateparse.parse_datetime(request.POST['slot']).replace(tzinfo=pytz.UTC)
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()
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()
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()
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()
return super(LaunderetteBookView, self).get(request, *args, **kwargs)
def check_slot(self, type, date=None):
@ -118,31 +144,42 @@ class LaunderetteBookView(CanViewMixin, DetailView):
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)
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)):
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
)
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)):
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:
kwargs['planning'][date].append(h)
kwargs["planning"][date].append(h)
else:
kwargs['planning'][date].append(None)
kwargs["planning"][date].append(None)
return kwargs
class SlotDeleteView(CanEditPropMixin, DeleteView):
"""Delete a slot"""
model = Slot
pk_url_kwarg = "slot_id"
template_name = 'core/delete_confirm.jinja'
template_name = "core/delete_confirm.jinja"
def get_success_url(self):
return self.request.user.get_absolute_url()
@ -150,76 +187,108 @@ class SlotDeleteView(CanEditPropMixin, DeleteView):
# For admins
class LaunderetteListView(CanEditPropMixin, ListView):
"""Choose which launderette to administer"""
model = Launderette
template_name = 'launderette/launderette_list.jinja'
template_name = "launderette/launderette_list.jinja"
class LaunderetteEditView(CanEditPropMixin, UpdateView):
"""Edit a launderette"""
model = Launderette
pk_url_kwarg = "launderette_id"
fields = ['name']
template_name = 'core/edit.jinja'
fields = ["name"]
template_name = "core/edit.jinja"
class LaunderetteCreateView(CanCreateMixin, CreateView):
"""Create a new launderette"""
model = Launderette
fields = ['name']
template_name = 'core/create.jinja'
fields = ["name"]
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')
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 ManageTokenForm(forms.Form):
action = forms.ChoiceField(choices=[("BACK", _("Back")), ("ADD", _("Add")), ("DEL", _("Delete"))], initial="BACK",
label=_("Action"), widget=forms.RadioSelect)
token_type = forms.ChoiceField(choices=settings.SITH_LAUNDERETTE_MACHINE_TYPES, label=_("Type"), initial="WASHING",
widget=forms.RadioSelect)
tokens = forms.CharField(max_length=512, widget=forms.widgets.Textarea, label=_("Tokens, separated by spaces"))
action = forms.ChoiceField(
choices=[("BACK", _("Back")), ("ADD", _("Add")), ("DEL", _("Delete"))],
initial="BACK",
label=_("Action"),
widget=forms.RadioSelect,
)
token_type = forms.ChoiceField(
choices=settings.SITH_LAUNDERETTE_MACHINE_TYPES,
label=_("Type"),
initial="WASHING",
widget=forms.RadioSelect,
)
tokens = forms.CharField(
max_length=512,
widget=forms.widgets.Textarea,
label=_("Tokens, separated by spaces"),
)
def process(self, launderette):
cleaned_data = self.cleaned_data
token_list = cleaned_data['tokens'].strip(" \n\r").split(" ")
token_type = cleaned_data['token_type']
token_list = cleaned_data["tokens"].strip(" \n\r").split(" ")
token_type = cleaned_data["token_type"]
self.data = {}
if cleaned_data['action'] == "BACK":
if cleaned_data["action"] == "BACK":
for t in token_list:
try:
tok = Token.objects.filter(launderette=launderette, type=token_type, name=t).first()
tok = Token.objects.filter(
launderette=launderette, type=token_type, name=t
).first()
tok.borrow_date = None
tok.user = None
tok.save()
except:
self.add_error(None, _("Token %(token_name)s does not exists") % {'token_name': t})
elif cleaned_data['action'] == "ADD":
self.add_error(
None,
_("Token %(token_name)s does not exists") % {"token_name": t},
)
elif cleaned_data["action"] == "ADD":
for t in token_list:
try:
Token(launderette=launderette, type=token_type, name=t).save()
except DataError as e:
self.add_error(None, e)
except:
self.add_error(None, _("Token %(token_name)s already exists") % {'token_name': t})
elif cleaned_data['action'] == "DEL":
self.add_error(
None,
_("Token %(token_name)s already exists") % {"token_name": t},
)
elif cleaned_data["action"] == "DEL":
for t in token_list:
try:
Token.objects.filter(launderette=launderette, type=token_type, name=t).delete()
Token.objects.filter(
launderette=launderette, type=token_type, name=t
).delete()
except:
self.add_error(None, _("Token %(token_name)s does not exists") % {'token_name': t})
self.add_error(
None,
_("Token %(token_name)s does not exists") % {"token_name": t},
)
class LaunderetteAdminView(CanEditPropMixin, BaseFormView, DetailView):
"""The admin page of the launderette"""
model = Launderette
pk_url_kwarg = "launderette_id"
template_name = 'launderette/launderette_admin.jinja'
template_name = "launderette/launderette_admin.jinja"
form_class = ManageTokenForm
def get(self, request, *args, **kwargs):
@ -252,17 +321,19 @@ class LaunderetteAdminView(CanEditPropMixin, BaseFormView, DetailView):
"""
kwargs = super(LaunderetteAdminView, self).get_context_data(**kwargs)
if self.request.method == "GET":
kwargs['form'] = self.get_form()
kwargs["form"] = self.get_form()
return kwargs
def get_success_url(self):
return reverse_lazy('launderette:launderette_admin', args=self.args, kwargs=self.kwargs)
return reverse_lazy(
"launderette:launderette_admin", args=self.args, kwargs=self.kwargs
)
class GetLaunderetteUserForm(GetUserForm):
def clean(self):
cleaned_data = super(GetLaunderetteUserForm, self).clean()
sub = cleaned_data['user']
sub = cleaned_data["user"]
if sub.slots.all().count() <= 0:
raise forms.ValidationError(_("User has booked no slot"))
return cleaned_data
@ -270,10 +341,13 @@ class GetLaunderetteUserForm(GetUserForm):
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 = GetLaunderetteUserForm # Form to enter a client code and get the corresponding user id
template_name = "counter/counter_main.jinja"
form_class = (
GetLaunderetteUserForm
) # Form to enter a client code and get the corresponding user id
def get(self, request, *args, **kwargs):
self.object = self.get_object()
@ -287,7 +361,7 @@ class LaunderetteMainClickView(CanEditMixin, BaseFormView, DetailView):
"""
We handle here the redirection, passing the user id of the asked customer
"""
self.kwargs['user_id'] = form.cleaned_data['user_id']
self.kwargs["user_id"] = form.cleaned_data["user_id"]
return super(LaunderetteMainClickView, self).form_valid(form)
def get_context_data(self, **kwargs):
@ -295,18 +369,20 @@ class LaunderetteMainClickView(CanEditMixin, BaseFormView, DetailView):
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)
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 get_success_url(self):
return reverse_lazy('launderette:click', args=self.args, kwargs=self.kwargs)
return reverse_lazy("launderette:click", args=self.args, kwargs=self.kwargs)
class ClickTokenForm(forms.BaseForm):
@ -317,8 +393,8 @@ class ClickTokenForm(forms.BaseForm):
counter = Counter.objects.filter(id=self.counter_id).first()
subscriber = customer.user
self.last_basket = {
'last_basket': [],
'last_customer': customer.user.get_display_name(),
"last_basket": [],
"last_customer": customer.user.get_display_name(),
}
total = 0
for k, t in self.cleaned_data.items():
@ -331,50 +407,77 @@ class ClickTokenForm(forms.BaseForm):
t.borrow_date = datetime.now().replace(tzinfo=pytz.UTC)
t.save()
price = settings.SITH_LAUNDERETTE_PRICES[t.type]
s = Selling(label="Jeton " + t.get_type_display() + " N°" + t.name, club=counter.club, product=None, counter=counter, unit_price=price,
quantity=1, seller=operator, customer=customer)
s = Selling(
label="Jeton " + t.get_type_display() + " N°" + t.name,
club=counter.club,
product=None,
counter=counter,
unit_price=price,
quantity=1,
seller=operator,
customer=customer,
)
s.save()
total += price
self.last_basket['last_basket'].append("Jeton " + t.get_type_display() + " N°" + t.name)
self.last_basket['new_customer_amount'] = str(customer.amount)
self.last_basket['last_total'] = str(total)
self.last_basket["last_basket"].append(
"Jeton " + t.get_type_display() + " N°" + t.name
)
self.last_basket["new_customer_amount"] = str(customer.amount)
self.last_basket["last_total"] = str(total)
return self.cleaned_data
class LaunderetteClickView(CanEditMixin, DetailView, BaseFormView):
"""The click page of the launderette"""
model = Launderette
pk_url_kwarg = "launderette_id"
template_name = 'launderette/launderette_click.jinja'
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,
user=None).first()
t = Token.objects.filter(
name=str(self2.data[field_name]),
type=slot.type,
launderette=self.object,
user=None,
).first()
if t is None:
raise forms.ValidationError(_("Token not found"))
return t
return clean_field
for s in self.subscriber.slots.filter(token=None, start_date__gte=timezone.now().replace(tzinfo=None)).all():
for s in self.subscriber.slots.filter(
token=None, start_date__gte=timezone.now().replace(tzinfo=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")))
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 didn't work here :/
kwargs["clean_" + field_name] = clean_field_factory(field_name, s)
kwargs['subscriber_id'] = self.subscriber.id
kwargs['counter_id'] = self.object.counter.id
kwargs['operator_id'] = self.operator.id
kwargs['base_fields'] = fields
return type('ClickForm', (ClickTokenForm,), kwargs)
kwargs["subscriber_id"] = self.subscriber.id
kwargs["counter_id"] = self.object.counter.id
kwargs["operator_id"] = self.operator.id
kwargs["base_fields"] = fields
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.customer = Customer.objects.filter(user__id=self.kwargs["user_id"]).first()
self.subscriber = self.customer.user
self.operator = request.user
return super(LaunderetteClickView, self).get(request, *args, **kwargs)
@ -382,7 +485,7 @@ class LaunderetteClickView(CanEditMixin, DetailView, BaseFormView):
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.customer = Customer.objects.filter(user__id=self.kwargs["user_id"]).first()
self.subscriber = self.customer.user
self.operator = request.user
return super(LaunderetteClickView, self).post(request, *args, **kwargs)
@ -399,43 +502,50 @@ class LaunderetteClickView(CanEditMixin, DetailView, BaseFormView):
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
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)
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'
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')
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'
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 "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
ret["launderette"] = obj.id
return ret