Sith/counter/models.py

1085 lines
37 KiB
Python
Raw Normal View History

# -*- coding:utf-8 -*
#
# Copyright 2023 © AE UTBM
# ae@utbm.fr / ae.info@utbm.fr
#
# This file is part of the website of the UTBM Student Association (AE UTBM),
# https://ae.utbm.fr.
#
# You can find the source code of the website at https://github.com/ae-utbm/sith3
#
# LICENSED UNDER THE GNU GENERAL PUBLIC LICENSE VERSION 3 (GPLv3)
# SEE : https://raw.githubusercontent.com/ae-utbm/sith3/master/LICENSE
# OR WITHIN THE LOCAL FILE "LICENSE"
#
#
2022-11-23 11:23:17 +00:00
from __future__ import annotations
from typing import Tuple
2017-06-12 07:47:24 +00:00
from django.db import models
from django.db.models import F, Value, Sum, QuerySet, OuterRef, Exists
from django.db.models.functions import Concat, Length
from django.utils.translation import gettext_lazy as _
from django.utils import timezone
2016-03-28 12:54:35 +00:00
from django.conf import settings
from django.urls import reverse
2018-10-18 23:21:57 +00:00
from django.core.validators import MinLengthValidator
2016-08-01 22:32:55 +00:00
from django.forms import ValidationError
from django.utils.functional import cached_property
2016-03-28 12:54:35 +00:00
from datetime import timedelta, date, datetime
2016-08-04 22:50:25 +00:00
import random
import string
2016-10-03 17:30:05 +00:00
import os
import base64
from dict2xml import dict2xml
from core.utils import get_start_of_semester
2022-12-10 19:41:35 +00:00
from sith.settings import SITH_COUNTER_OFFICES, SITH_MAIN_CLUB
2022-04-20 12:01:33 +00:00
from club.models import Club, Membership
from accounting.models import CurrencyField
2016-12-08 18:47:28 +00:00
from core.models import Group, User, Notification
2016-12-10 00:58:30 +00:00
from subscription.models import Subscription
2016-03-28 12:54:35 +00:00
from django_countries.fields import CountryField
2017-06-12 07:47:24 +00:00
class Customer(models.Model):
"""
This class extends a user to make a customer. It adds some basic customers' information, such as the account ID, and
is used by other accounting classes as reference to the customer, rather than using User
"""
2018-10-04 19:29:19 +00:00
user = models.OneToOneField(User, primary_key=True, on_delete=models.CASCADE)
2018-10-04 19:29:19 +00:00
account_id = models.CharField(_("account id"), max_length=10, unique=True)
2022-11-23 11:23:17 +00:00
amount = CurrencyField(_("amount"), default=0)
2018-10-04 19:29:19 +00:00
recorded_products = models.IntegerField(_("recorded product"), default=0)
class Meta:
2018-10-04 19:29:19 +00:00
verbose_name = _("customer")
verbose_name_plural = _("customers")
ordering = ["account_id"]
def __str__(self):
2016-08-14 17:28:14 +00:00
return "%s - %s" % (self.user.username, self.account_id)
2017-07-21 19:39:49 +00:00
@property
def can_record(self):
2017-08-15 00:09:44 +00:00
return self.recorded_products > -settings.SITH_ECOCUP_LIMIT
2017-07-21 19:39:49 +00:00
def can_record_more(self, number):
2017-08-15 00:09:44 +00:00
return self.recorded_products - number >= -settings.SITH_ECOCUP_LIMIT
2017-07-21 19:39:49 +00:00
@property
2022-09-25 19:29:42 +00:00
def can_buy(self) -> bool:
"""
Check if whether this customer has the right to
purchase any item.
This must be not confused with the Product.can_be_sold_to(user)
method as the present method returns an information
about a customer whereas the other tells something
about the relation between a User (not a Customer,
don't mix them) and a Product.
"""
2023-03-04 14:01:08 +00:00
subscription = self.user.subscriptions.order_by("subscription_end").last()
if subscription is None:
return False
return (date.today() - subscription.subscription_end) < timedelta(days=90)
@classmethod
2022-11-23 11:23:17 +00:00
def get_or_create(cls, user: User) -> Tuple[Customer, bool]:
"""
2022-11-23 11:23:17 +00:00
Work in pretty much the same way as the usual get_or_create method,
but with the default field replaced by some under the hood.
If the user has an account, return it as is.
Else create a new account with no money on it and a new unique account id
Example : ::
user = User.objects.get(pk=1)
account, created = Customer.get_or_create(user)
if created:
print(f"created a new account with id {account.id}")
else:
print(f"user has already an account, with {account.id} € on it"
"""
2022-11-23 11:23:17 +00:00
if hasattr(user, "customer"):
return user.customer, False
# account_id are always a number with a letter appended
account_id = (
Customer.objects.order_by(Length("account_id"), "account_id")
.values("account_id")
.last()
)
if account_id is None:
# legacy from the old site
2022-11-23 11:23:17 +00:00
account = cls.objects.create(user=user, account_id="1504a")
return account, True
account_id = account_id["account_id"]
2022-11-23 11:23:17 +00:00
account_num = int(account_id[:-1])
while Customer.objects.filter(account_id=account_id).exists():
2022-11-23 11:23:17 +00:00
# when entering the first iteration, we are using an already existing account id
# so the loop should always execute at least one time
account_num += 1
account_id = f"{account_num}{random.choice(string.ascii_lowercase)}"
2022-11-23 11:23:17 +00:00
account = cls.objects.create(user=user, account_id=account_id)
return account, True
2017-08-15 00:09:44 +00:00
def save(self, allow_negative=False, is_selling=False, *args, **kwargs):
2017-08-15 12:03:56 +00:00
"""
2020-08-27 13:59:42 +00:00
is_selling : tell if the current action is a selling
allow_negative : ignored if not a selling. Allow a selling to put the account in negative
Those two parameters avoid blocking the save method of a customer if his account is negative
2017-08-15 12:03:56 +00:00
"""
2017-08-15 00:09:44 +00:00
if self.amount < 0 and (is_selling and not allow_negative):
2016-08-01 22:32:55 +00:00
raise ValidationError(_("Not enough money"))
super(Customer, self).save(*args, **kwargs)
2016-09-21 12:09:16 +00:00
def recompute_amount(self):
2023-03-04 14:01:08 +00:00
refillings = self.refillings.aggregate(sum=Sum(F("amount")))["sum"]
self.amount = refillings if refillings is not None else 0
purchases = (
self.buyings.filter(payment_method="SITH_ACCOUNT")
.annotate(amount=F("quantity") * F("unit_price"))
.aggregate(sum=Sum(F("amount")))
)["sum"]
if purchases is not None:
self.amount -= purchases
self.save()
2016-09-21 12:09:16 +00:00
def get_absolute_url(self):
2018-10-04 19:29:19 +00:00
return reverse("core:user_account", kwargs={"user_id": self.user.pk})
def get_full_url(self):
2018-10-04 19:29:19 +00:00
return "".join(["https://", settings.SITH_URL, self.get_absolute_url()])
class BillingInfo(models.Model):
"""
Represent the billing information of a user, which are required
by the 3D-Secure v2 system used by the etransaction module
"""
customer = models.OneToOneField(
Customer, related_name="billing_infos", on_delete=models.CASCADE
)
# declaring surname and name even though they are already defined
# in User add some redundancy, but ensures that the billing infos
# shall stay correct, whatever shenanigans the user commits on its profile
first_name = models.CharField(_("First name"), max_length=22)
last_name = models.CharField(_("Last name"), max_length=22)
address_1 = models.CharField(_("Address 1"), max_length=50)
address_2 = models.CharField(_("Address 2"), max_length=50, blank=True, null=True)
zip_code = models.CharField(_("Zip code"), max_length=16) # code postal
city = models.CharField(_("City"), max_length=50)
country = CountryField(blank_label=_("Country"))
def to_3dsv2_xml(self) -> str:
"""
Convert the data from this model into a xml usable
by the online paying service of the Crédit Agricole bank.
2022-12-10 19:41:35 +00:00
see : `https://www.ca-moncommerce.com/espace-client-mon-commerce/up2pay-e-transactions/ma-documentation/manuel-dintegration-focus-3ds-v2/principes-generaux/#integration-3dsv2-developpeur-webmaster`
"""
data = {
2022-12-10 19:41:35 +00:00
"Address": {
"FirstName": self.first_name,
"LastName": self.last_name,
"Address1": self.address_1,
"ZipCode": self.zip_code,
"City": self.city,
"CountryCode": self.country.numeric, # ISO-3166-1 numeric code
}
}
if self.address_2:
2022-12-10 19:41:35 +00:00
data["Address"]["Address2"] = self.address_2
xml = dict2xml(data, wrap="Billing", newlines=False)
return '<?xml version="1.0" encoding="UTF-8" ?>' + xml
def __str__(self):
return f"{self.first_name} {self.last_name}"
class ProductType(models.Model):
"""
This describes a product type
Useful only for categorizing, changes are made at the product level for now
"""
2018-10-04 19:29:19 +00:00
name = models.CharField(_("name"), max_length=30)
description = models.TextField(_("description"), null=True, blank=True)
comment = models.TextField(_("comment"), null=True, blank=True)
icon = models.ImageField(upload_to="products", null=True, blank=True)
2022-11-16 19:41:24 +00:00
# priority holds no real backend logic but helps to handle the order in which
# the items are to be shown to the user
priority = models.PositiveIntegerField(default=0)
2016-07-27 18:05:45 +00:00
class Meta:
2018-10-04 19:29:19 +00:00
verbose_name = _("product type")
2022-11-16 19:41:24 +00:00
ordering = ["-priority", "name"]
2016-07-27 18:05:45 +00:00
def is_owned_by(self, user):
"""
Method to see if that object can be edited by the given user
"""
if user.is_anonymous:
return False
if user.is_in_group(pk=settings.SITH_GROUP_ACCOUNTING_ADMIN_ID):
return True
return False
def __str__(self):
return self.name
2016-07-27 18:05:45 +00:00
def get_absolute_url(self):
2018-10-04 19:29:19 +00:00
return reverse("counter:producttype_list")
2016-07-27 18:05:45 +00:00
2017-06-12 07:47:24 +00:00
class Product(models.Model):
"""
This describes a product, with all its related informations
"""
2018-10-04 19:29:19 +00:00
name = models.CharField(_("name"), max_length=64)
description = models.TextField(_("description"), blank=True)
product_type = models.ForeignKey(
ProductType,
related_name="products",
verbose_name=_("product type"),
null=True,
blank=True,
on_delete=models.SET_NULL,
)
code = models.CharField(_("code"), max_length=16, blank=True)
purchase_price = CurrencyField(_("purchase price"))
selling_price = CurrencyField(_("selling price"))
special_selling_price = CurrencyField(_("special selling price"))
icon = models.ImageField(
upload_to="products", null=True, blank=True, verbose_name=_("icon")
)
club = models.ForeignKey(
Club, related_name="products", verbose_name=_("club"), on_delete=models.CASCADE
)
2018-10-04 19:29:19 +00:00
limit_age = models.IntegerField(_("limit age"), default=0)
tray = models.BooleanField(_("tray price"), default=False)
parent_product = models.ForeignKey(
"self",
related_name="children_products",
verbose_name=_("parent product"),
null=True,
blank=True,
on_delete=models.SET_NULL,
)
buying_groups = models.ManyToManyField(
Group, related_name="products", verbose_name=_("buying groups"), blank=True
)
archived = models.BooleanField(_("archived"), default=False)
2016-07-27 18:05:45 +00:00
class Meta:
2018-10-04 19:29:19 +00:00
verbose_name = _("product")
2016-07-27 18:05:45 +00:00
2017-07-21 19:39:49 +00:00
@property
def is_record_product(self):
2017-08-15 00:09:44 +00:00
return settings.SITH_ECOCUP_CONS == self.id
2017-07-21 19:39:49 +00:00
@property
def is_unrecord_product(self):
2017-08-15 00:09:44 +00:00
return settings.SITH_ECOCUP_DECO == self.id
2017-07-21 19:39:49 +00:00
def is_owned_by(self, user):
"""
Method to see if that object can be edited by the given user
"""
if user.is_anonymous:
return False
2018-10-04 19:29:19 +00:00
if user.is_in_group(
pk=settings.SITH_GROUP_ACCOUNTING_ADMIN_ID
) or user.is_in_group(pk=settings.SITH_GROUP_COUNTER_ADMIN_ID):
return True
return False
2016-07-27 15:23:02 +00:00
def get_absolute_url(self):
2018-10-04 19:29:19 +00:00
return reverse("counter:product_list")
2016-07-27 15:23:02 +00:00
2022-09-25 19:29:42 +00:00
def can_be_sold_to(self, user: User) -> bool:
"""
Check if whether the user given in parameter has the right to buy
this product or not.
This must be not confused with the Customer.can_buy()
method as the present method returns an information
about the relation between a User and a Product,
whereas the other tells something about a Customer
(and not a user, they are not the same model).
:return: True if the user can buy this product else False
"""
if not self.buying_groups.exists():
return True
for group_id in self.buying_groups.values_list("pk", flat=True):
if user.is_in_group(pk=group_id):
2022-09-25 19:29:42 +00:00
return True
return False
2022-12-19 19:55:33 +00:00
@property
def profit(self):
return self.selling_price - self.purchase_price
2022-09-25 19:29:42 +00:00
def __str__(self):
return "%s (%s)" % (self.name, self.code)
2017-06-12 07:47:24 +00:00
class CounterQuerySet(models.QuerySet):
def annotate_has_barman(self, user: User) -> CounterQuerySet:
"""
Annotate the queryset with the `user_is_barman` field.
For each counter, this field has value True if the user
is a barman of this counter, else False.
:param user: the user we want to check if he is a barman
Example::
sli = User.objects.get(username="sli")
counters = (
Counter.objects
.annotate_has_barman(sli) # add the user_has_barman boolean field
.filter(has_annotated_barman=True) # keep only counters where this user is barman
)
print("Sli est barman dans les comptoirs suivants :")
for counter in counters:
print(f"- {counter.name}")
"""
subquery = user.counters.filter(pk=OuterRef("pk"))
# noinspection PyTypeChecker
return self.annotate(has_annotated_barman=Exists(subquery))
2016-03-28 12:54:35 +00:00
class Counter(models.Model):
2018-10-04 19:29:19 +00:00
name = models.CharField(_("name"), max_length=30)
club = models.ForeignKey(
Club, related_name="counters", verbose_name=_("club"), on_delete=models.CASCADE
)
2018-10-04 19:29:19 +00:00
products = models.ManyToManyField(
Product, related_name="counters", verbose_name=_("products"), blank=True
)
type = models.CharField(
_("counter type"),
max_length=255,
choices=[("BAR", _("Bar")), ("OFFICE", _("Office")), ("EBOUTIC", _("Eboutic"))],
)
sellers = models.ManyToManyField(
User, verbose_name=_("sellers"), related_name="counters", blank=True
)
edit_groups = models.ManyToManyField(
Group, related_name="editable_counters", blank=True
)
view_groups = models.ManyToManyField(
Group, related_name="viewable_counters", blank=True
)
token = models.CharField(_("token"), max_length=30, null=True, blank=True)
2016-03-28 12:54:35 +00:00
objects = CounterQuerySet.as_manager()
2016-07-27 18:05:45 +00:00
class Meta:
2018-10-04 19:29:19 +00:00
verbose_name = _("counter")
2016-07-27 18:05:45 +00:00
2016-03-28 12:54:35 +00:00
def __getattribute__(self, name):
if name == "edit_groups":
2018-10-04 19:29:19 +00:00
return Group.objects.filter(
name=self.club.unix_name + settings.SITH_BOARD_SUFFIX
).all()
2016-03-28 12:54:35 +00:00
return object.__getattribute__(self, name)
def __str__(self):
return self.name
2016-03-29 08:30:24 +00:00
def get_absolute_url(self):
2016-07-22 11:34:34 +00:00
if self.type == "EBOUTIC":
2018-10-04 19:29:19 +00:00
return reverse("eboutic:main")
return reverse("counter:details", kwargs={"counter_id": self.id})
2016-03-29 08:30:24 +00:00
def is_owned_by(self, user):
if user.is_anonymous:
return False
mem = self.club.get_membership_for(user)
if mem and mem.role >= 7:
return True
return user.is_in_group(pk=settings.SITH_GROUP_COUNTER_ADMIN_ID)
2016-03-29 08:30:24 +00:00
def can_be_viewed_by(self, user):
2017-01-04 18:39:37 +00:00
if self.type == "BAR":
return True
return user.is_board_member or user in self.sellers.all()
def gen_token(self):
"""Generate a new token for this counter"""
2018-10-04 19:29:19 +00:00
self.token = "".join(
random.choice(string.ascii_letters + string.digits) for x in range(30)
)
self.save()
def add_barman(self, user):
2016-07-18 11:22:50 +00:00
"""
Logs a barman in to the given counter
A user is stored as a tuple with its login time
"""
Permanency(user=user, counter=self, start=timezone.now(), end=None).save()
def del_barman(self, user):
2016-07-18 11:22:50 +00:00
"""
Logs a barman out and store its permanency
"""
perm = Permanency.objects.filter(counter=self, user=user, end=None).all()
for p in perm:
p.end = p.activity
p.save()
2016-07-18 11:22:50 +00:00
@cached_property
def barmen_list(self):
return self.get_barmen_list()
2016-08-06 10:37:36 +00:00
def get_barmen_list(self):
2016-07-18 11:22:50 +00:00
"""
2016-07-21 18:03:31 +00:00
Returns the barman list as list of User
2016-07-18 11:22:50 +00:00
Also handle the timeout of the barmen
"""
pl = Permanency.objects.filter(counter=self, end=None).all()
bl = []
for p in pl:
2018-10-04 19:29:19 +00:00
if timezone.now() - p.activity < timedelta(
minutes=settings.SITH_BARMAN_TIMEOUT
):
bl.append(p.user)
else:
p.end = p.activity
p.save()
return bl
2016-08-06 10:37:36 +00:00
def get_random_barman(self):
2016-09-12 15:34:33 +00:00
"""
Return a random user being currently a barman
"""
2016-08-06 10:37:36 +00:00
bl = self.get_barmen_list()
2016-08-18 19:06:10 +00:00
return bl[random.randrange(0, len(bl))]
2016-05-31 17:32:15 +00:00
2016-09-12 15:34:33 +00:00
def update_activity(self):
"""
Update the barman activity to prevent timeout
"""
for p in Permanency.objects.filter(counter=self, end=None).all():
2017-06-12 07:47:24 +00:00
p.save() # Update activity
2016-09-12 15:34:33 +00:00
2016-08-05 18:01:23 +00:00
def is_open(self):
return len(self.barmen_list) > 0
2016-08-05 18:01:23 +00:00
2016-10-16 16:52:04 +00:00
def is_inactive(self):
"""
Returns True if the counter self is inactive from SITH_COUNTER_MINUTE_INACTIVE's value minutes, else False
2016-10-16 16:52:04 +00:00
"""
2018-10-04 19:29:19 +00:00
return self.is_open() and (
(timezone.now() - self.permanencies.order_by("-activity").first().activity)
> timedelta(minutes=settings.SITH_COUNTER_MINUTE_INACTIVE)
2018-10-04 19:29:19 +00:00
)
2016-10-16 16:52:04 +00:00
2016-08-06 10:37:36 +00:00
def barman_list(self):
2016-09-12 15:34:33 +00:00
"""
Returns the barman id list
"""
2016-08-06 10:37:36 +00:00
return [b.id for b in self.get_barmen_list()]
2022-04-20 12:01:33 +00:00
def can_refill(self):
"""
Show if the counter authorize the refilling with physic money
"""
if self.type != "BAR":
return False
if self.id in SITH_COUNTER_OFFICES:
# If the counter is either 'AE' or 'BdF', refills are authorized
return True
2022-04-20 12:01:33 +00:00
is_ae_member = False
ae = Club.objects.get(unix_name=SITH_MAIN_CLUB["unix_name"])
2022-04-20 12:01:33 +00:00
for barman in self.get_barmen_list():
if ae.get_membership_for(barman):
2022-04-20 12:01:33 +00:00
is_ae_member = True
return is_ae_member
def get_top_barmen(self) -> QuerySet:
"""
Return a QuerySet querying the office hours stats of all the barmen of all time
of this counter, ordered by descending number of hours.
Each element of the QuerySet corresponds to a barman and has the following data :
- the full name (first name + last name) of the barman
- the nickname of the barman
- the promo of the barman
- the total number of office hours the barman did attend
"""
return (
self.permanencies.exclude(end=None)
.annotate(
name=Concat(F("user__first_name"), Value(" "), F("user__last_name"))
)
.annotate(nickname=F("user__nick_name"))
.annotate(promo=F("user__promo"))
.values("user", "name", "nickname", "promo")
.annotate(perm_sum=Sum(F("end") - F("start")))
.exclude(perm_sum=None)
.order_by("-perm_sum")
)
def get_top_customers(self, since=get_start_of_semester()) -> QuerySet:
"""
Return a QuerySet querying the money spent by customers of this counter
since the specified date, ordered by descending amount of money spent.
Each element of the QuerySet corresponds to a customer and has the following data :
- the full name (first name + last name) of the customer
- the nickname of the customer
- the amount of money spent by the customer
"""
return (
self.sellings.filter(date__gte=since)
.annotate(
name=Concat(
F("customer__user__first_name"),
Value(" "),
F("customer__user__last_name"),
)
)
.annotate(nickname=F("customer__user__nick_name"))
.annotate(promo=F("customer__user__promo"))
.values("customer__user", "name", "nickname")
.annotate(
selling_sum=Sum(
F("unit_price") * F("quantity"), output_field=CurrencyField()
)
)
.filter(selling_sum__gt=0)
.order_by("-selling_sum")
)
def get_total_sales(self, since=get_start_of_semester()) -> CurrencyField:
"""
Compute and return the total turnover of this counter
since the date specified in parameter (by default, since the start of the current
semester)
:param since: timestamp from which to perform the calculation
:type since: datetime | date
:return: Total revenue earned at this counter
"""
if isinstance(since, date):
since = datetime.combine(since, datetime.min.time())
total = self.sellings.filter(date__gte=since).aggregate(
total=Sum(F("quantity") * F("unit_price"), output_field=CurrencyField())
)["total"]
return total if total is not None else CurrencyField(0)
2017-06-12 07:47:24 +00:00
2016-05-31 17:32:15 +00:00
class Refilling(models.Model):
"""
Handle the refilling
"""
2018-10-04 19:29:19 +00:00
counter = models.ForeignKey(
Counter, related_name="refillings", blank=False, on_delete=models.CASCADE
)
2018-10-04 19:29:19 +00:00
amount = CurrencyField(_("amount"))
operator = models.ForeignKey(
User,
related_name="refillings_as_operator",
blank=False,
on_delete=models.CASCADE,
)
customer = models.ForeignKey(
Customer, related_name="refillings", blank=False, on_delete=models.CASCADE
2018-10-04 19:29:19 +00:00
)
date = models.DateTimeField(_("date"))
payment_method = models.CharField(
_("payment method"),
max_length=255,
choices=settings.SITH_COUNTER_PAYMENT_METHOD,
default="CASH",
)
bank = models.CharField(
_("bank"), max_length=255, choices=settings.SITH_COUNTER_BANK, default="OTHER"
)
is_validated = models.BooleanField(_("is validated"), default=False)
2016-05-31 17:32:15 +00:00
2016-07-27 18:05:45 +00:00
class Meta:
verbose_name = _("refilling")
2016-05-31 17:32:15 +00:00
def __str__(self):
2018-10-04 19:29:19 +00:00
return "Refilling: %.2f for %s" % (
self.amount,
self.customer.user.get_display_name(),
)
2016-05-31 17:32:15 +00:00
2016-08-18 19:06:10 +00:00
def is_owned_by(self, user):
if user.is_anonymous:
return False
return user.is_owner(self.counter) and self.payment_method != "CARD"
2016-05-31 17:32:15 +00:00
2016-08-18 19:06:10 +00:00
def delete(self, *args, **kwargs):
self.customer.amount -= self.amount
self.customer.save()
super(Refilling, self).delete(*args, **kwargs)
2016-05-31 17:32:15 +00:00
def save(self, *args, **kwargs):
if not self.date:
2016-08-18 19:06:10 +00:00
self.date = timezone.now()
2016-05-31 17:32:15 +00:00
self.full_clean()
2016-08-01 22:32:55 +00:00
if not self.is_validated:
self.customer.amount += self.amount
self.customer.save()
self.is_validated = True
if self.customer.user.preferences.notify_on_refill:
2018-10-04 19:29:19 +00:00
Notification(
user=self.customer.user,
url=reverse(
"core:user_account_detail",
kwargs={
"user_id": self.customer.user.id,
"year": self.date.year,
"month": self.date.month,
},
),
param=str(self.amount),
type="REFILLING",
).save()
2016-06-26 18:07:29 +00:00
super(Refilling, self).save(*args, **kwargs)
2016-05-31 17:32:15 +00:00
2017-06-12 07:47:24 +00:00
2016-05-31 17:32:15 +00:00
class Selling(models.Model):
"""
Handle the sellings
"""
2018-10-04 19:29:19 +00:00
label = models.CharField(_("label"), max_length=64)
2018-10-04 19:29:19 +00:00
product = models.ForeignKey(
Product,
related_name="sellings",
null=True,
blank=True,
on_delete=models.SET_NULL,
)
counter = models.ForeignKey(
Counter,
related_name="sellings",
null=True,
blank=False,
on_delete=models.SET_NULL,
)
club = models.ForeignKey(
Club, related_name="sellings", null=True, blank=False, on_delete=models.SET_NULL
)
unit_price = CurrencyField(_("unit price"))
quantity = models.IntegerField(_("quantity"))
seller = models.ForeignKey(
User,
related_name="sellings_as_operator",
null=True,
blank=False,
on_delete=models.SET_NULL,
)
customer = models.ForeignKey(
Customer,
related_name="buyings",
null=True,
blank=False,
on_delete=models.SET_NULL,
)
date = models.DateTimeField(_("date"))
payment_method = models.CharField(
_("payment method"),
max_length=255,
choices=[("SITH_ACCOUNT", _("Sith account")), ("CARD", _("Credit card"))],
default="SITH_ACCOUNT",
)
is_validated = models.BooleanField(_("is validated"), default=False)
2016-05-31 17:32:15 +00:00
2016-07-27 18:05:45 +00:00
class Meta:
verbose_name = _("selling")
2016-05-31 17:32:15 +00:00
def __str__(self):
2018-10-04 19:29:19 +00:00
return "Selling: %d x %s (%f) for %s" % (
self.quantity,
self.label,
self.quantity * self.unit_price,
self.customer.user.get_display_name(),
)
2016-05-31 17:32:15 +00:00
2016-08-18 19:06:10 +00:00
def is_owned_by(self, user):
if user.is_anonymous:
return False
return user.is_owner(self.counter) and self.payment_method != "CARD"
2016-08-18 19:06:10 +00:00
2016-10-03 17:30:05 +00:00
def can_be_viewed_by(self, user):
2019-10-17 09:11:13 +00:00
if (
not hasattr(self, "customer") or self.customer is None
): # Customer can be set to Null
return False
2016-10-03 17:30:05 +00:00
return user == self.customer.user
2016-08-18 19:06:10 +00:00
def delete(self, *args, **kwargs):
if self.payment_method == "SITH_ACCOUNT":
self.customer.amount += self.quantity * self.unit_price
self.customer.save()
2016-08-18 19:06:10 +00:00
super(Selling, self).delete(*args, **kwargs)
def send_mail_customer(self):
2016-10-25 19:53:40 +00:00
event = self.product.eticket.event_title or _("Unknown event")
2018-10-04 19:29:19 +00:00
subject = _("Eticket bought for the event %(event)s") % {"event": event}
message_html = _(
2019-10-13 22:32:11 +00:00
"You bought an eticket for the event %(event)s.\nYou can download it directly from this link %(eticket)s.\nYou can also retrieve all your e-tickets on your account page %(url)s."
) % {
2018-10-04 19:29:19 +00:00
"event": event,
"url": "".join(
(
'<a href="',
self.customer.get_full_url(),
'">',
self.customer.get_full_url(),
"</a>",
)
),
2019-10-13 22:32:11 +00:00
"eticket": "".join(
(
'<a href="',
self.get_eticket_full_url(),
'">',
self.get_eticket_full_url(),
"</a>",
)
),
}
message_txt = _(
2019-10-13 22:32:11 +00:00
"You bought an eticket for the event %(event)s.\nYou can download it directly from this link %(eticket)s.\nYou can also retrieve all your e-tickets on your account page %(url)s."
2019-10-13 15:29:08 +00:00
) % {
"event": event,
"url": self.customer.get_full_url(),
2019-10-13 22:32:11 +00:00
"eticket": self.get_eticket_full_url(),
2019-10-13 15:29:08 +00:00
}
2018-10-04 19:29:19 +00:00
self.customer.user.email_user(subject, message_txt, html_message=message_html)
2017-08-14 11:52:58 +00:00
def save(self, allow_negative=False, *args, **kwargs):
2017-08-15 12:03:56 +00:00
"""
2020-08-27 13:59:42 +00:00
allow_negative : Allow this selling to use more money than available for this user
2017-08-15 12:03:56 +00:00
"""
if not self.date:
2016-08-18 19:06:10 +00:00
self.date = timezone.now()
2016-05-31 17:32:15 +00:00
self.full_clean()
2016-08-01 22:32:55 +00:00
if not self.is_validated:
self.customer.amount -= self.quantity * self.unit_price
2017-08-15 00:09:44 +00:00
self.customer.save(allow_negative=allow_negative, is_selling=True)
2016-08-01 22:32:55 +00:00
self.is_validated = True
u = User.objects.filter(id=self.customer.user.id).first()
if u.was_subscribed:
2018-10-04 19:29:19 +00:00
if (
self.product
and self.product.id == settings.SITH_PRODUCT_SUBSCRIPTION_ONE_SEMESTER
):
sub = Subscription(
2017-06-12 07:47:24 +00:00
member=u,
2018-10-04 19:29:19 +00:00
subscription_type="un-semestre",
2017-06-12 07:47:24 +00:00
payment_method="EBOUTIC",
location="EBOUTIC",
)
sub.subscription_start = Subscription.compute_start()
sub.subscription_start = Subscription.compute_start(
2018-10-04 19:29:19 +00:00
duration=settings.SITH_SUBSCRIPTIONS[sub.subscription_type][
"duration"
]
)
sub.subscription_end = Subscription.compute_end(
2018-10-04 19:29:19 +00:00
duration=settings.SITH_SUBSCRIPTIONS[sub.subscription_type][
"duration"
],
start=sub.subscription_start,
)
sub.save()
2018-10-04 19:29:19 +00:00
elif (
self.product
and self.product.id == settings.SITH_PRODUCT_SUBSCRIPTION_TWO_SEMESTERS
):
u = User.objects.filter(id=self.customer.user.id).first()
sub = Subscription(
2017-06-12 07:47:24 +00:00
member=u,
2018-10-04 19:29:19 +00:00
subscription_type="deux-semestres",
2017-06-12 07:47:24 +00:00
payment_method="EBOUTIC",
location="EBOUTIC",
)
sub.subscription_start = Subscription.compute_start()
sub.subscription_start = Subscription.compute_start(
2018-10-04 19:29:19 +00:00
duration=settings.SITH_SUBSCRIPTIONS[sub.subscription_type][
"duration"
]
)
sub.subscription_end = Subscription.compute_end(
2018-10-04 19:29:19 +00:00
duration=settings.SITH_SUBSCRIPTIONS[sub.subscription_type][
"duration"
],
start=sub.subscription_start,
)
sub.save()
if self.customer.user.preferences.notify_on_click:
Notification(
user=self.customer.user,
2018-10-04 19:29:19 +00:00
url=reverse(
"core:user_account_detail",
kwargs={
"user_id": self.customer.user.id,
"year": self.date.year,
"month": self.date.month,
},
),
param="%d x %s" % (self.quantity, self.label),
type="SELLING",
).save()
2016-05-31 17:32:15 +00:00
super(Selling, self).save(*args, **kwargs)
2019-10-13 15:29:08 +00:00
try:
# The product has no id until it's saved
if self.product.eticket:
self.send_mail_customer()
except:
pass
def get_eticket_full_url(self):
eticket_url = reverse("counter:eticket_pdf", kwargs={"selling_id": self.id})
2019-10-13 22:32:11 +00:00
return "".join(["https://", settings.SITH_URL, eticket_url])
2016-05-31 17:32:15 +00:00
2017-06-12 07:47:24 +00:00
2016-07-18 11:22:50 +00:00
class Permanency(models.Model):
"""
This class aims at storing a traceability of who was barman where and when
"""
2018-10-04 19:29:19 +00:00
user = models.ForeignKey(
User,
related_name="permanencies",
verbose_name=_("user"),
on_delete=models.CASCADE,
)
2018-10-04 19:29:19 +00:00
counter = models.ForeignKey(
Counter,
related_name="permanencies",
verbose_name=_("counter"),
on_delete=models.CASCADE,
2018-10-04 19:29:19 +00:00
)
start = models.DateTimeField(_("start date"))
end = models.DateTimeField(_("end date"), null=True, db_index=True)
activity = models.DateTimeField(_("last activity date"), auto_now=True)
2016-07-18 11:22:50 +00:00
2016-07-27 18:05:45 +00:00
class Meta:
verbose_name = _("permanency")
2016-07-18 11:22:50 +00:00
def __str__(self):
2018-10-04 19:29:19 +00:00
return "%s in %s from %s (last activity: %s) to %s" % (
self.user,
self.counter,
self.start.strftime("%Y-%m-%d %H:%M:%S"),
self.activity.strftime("%Y-%m-%d %H:%M:%S"),
self.end.strftime("%Y-%m-%d %H:%M:%S") if self.end else "",
)
2017-06-12 07:47:24 +00:00
2022-12-19 19:55:33 +00:00
@property
def duration(self):
if self.end is None:
return self.activity - self.start
return self.end - self.start
2016-07-18 11:22:50 +00:00
2016-08-26 18:57:04 +00:00
class CashRegisterSummary(models.Model):
2018-10-04 19:29:19 +00:00
user = models.ForeignKey(
User,
related_name="cash_summaries",
verbose_name=_("user"),
on_delete=models.CASCADE,
2018-10-04 19:29:19 +00:00
)
counter = models.ForeignKey(
Counter,
related_name="cash_summaries",
verbose_name=_("counter"),
on_delete=models.CASCADE,
2018-10-04 19:29:19 +00:00
)
date = models.DateTimeField(_("date"))
comment = models.TextField(_("comment"), null=True, blank=True)
emptied = models.BooleanField(_("emptied"), default=False)
2016-08-26 18:57:04 +00:00
class Meta:
verbose_name = _("cash register summary")
def __str__(self):
return "At %s by %s - Total: %s" % (self.counter, self.user, self.get_total())
def __getattribute__(self, name):
2018-10-04 19:29:19 +00:00
if name[:5] == "check":
checks = self.items.filter(check=True).order_by("value").all()
if name == "ten_cents":
return self.items.filter(value=0.1, check=False).first()
2018-10-04 19:29:19 +00:00
elif name == "twenty_cents":
return self.items.filter(value=0.2, check=False).first()
2018-10-04 19:29:19 +00:00
elif name == "fifty_cents":
return self.items.filter(value=0.5, check=False).first()
2018-10-04 19:29:19 +00:00
elif name == "one_euro":
return self.items.filter(value=1, check=False).first()
2018-10-04 19:29:19 +00:00
elif name == "two_euros":
return self.items.filter(value=2, check=False).first()
2018-10-04 19:29:19 +00:00
elif name == "five_euros":
return self.items.filter(value=5, check=False).first()
2018-10-04 19:29:19 +00:00
elif name == "ten_euros":
return self.items.filter(value=10, check=False).first()
2018-10-04 19:29:19 +00:00
elif name == "twenty_euros":
return self.items.filter(value=20, check=False).first()
2018-10-04 19:29:19 +00:00
elif name == "fifty_euros":
return self.items.filter(value=50, check=False).first()
2018-10-04 19:29:19 +00:00
elif name == "hundred_euros":
return self.items.filter(value=100, check=False).first()
2018-10-04 19:29:19 +00:00
elif name == "check_1":
return checks[0] if 0 < len(checks) else None
2018-10-04 19:29:19 +00:00
elif name == "check_2":
return checks[1] if 1 < len(checks) else None
2018-10-04 19:29:19 +00:00
elif name == "check_3":
return checks[2] if 2 < len(checks) else None
2018-10-04 19:29:19 +00:00
elif name == "check_4":
return checks[3] if 3 < len(checks) else None
2018-10-04 19:29:19 +00:00
elif name == "check_5":
return checks[4] if 4 < len(checks) else None
else:
return object.__getattribute__(self, name)
2016-09-13 00:04:49 +00:00
def is_owned_by(self, user):
"""
Method to see if that object can be edited by the given user
"""
if user.is_anonymous:
return False
if user.is_in_group(pk=settings.SITH_GROUP_COUNTER_ADMIN_ID):
2016-09-13 00:04:49 +00:00
return True
return False
2016-08-26 18:57:04 +00:00
def get_total(self):
t = 0
for it in self.items.all():
t += it.quantity * it.value
return t
def save(self, *args, **kwargs):
if not self.id:
self.date = timezone.now()
return super(CashRegisterSummary, self).save(*args, **kwargs)
def get_absolute_url(self):
2018-10-04 19:29:19 +00:00
return reverse("counter:cash_summary_list")
2017-06-12 07:47:24 +00:00
2016-08-26 18:57:04 +00:00
class CashRegisterSummaryItem(models.Model):
2018-10-04 19:29:19 +00:00
cash_summary = models.ForeignKey(
CashRegisterSummary,
related_name="items",
verbose_name=_("cash summary"),
on_delete=models.CASCADE,
2018-10-04 19:29:19 +00:00
)
2016-08-26 18:57:04 +00:00
value = CurrencyField(_("value"))
2018-10-04 19:29:19 +00:00
quantity = models.IntegerField(_("quantity"), default=0)
check = models.BooleanField(_("check"), default=False)
2016-08-26 18:57:04 +00:00
class Meta:
verbose_name = _("cash register summary item")
2017-06-12 07:47:24 +00:00
2016-10-03 17:30:05 +00:00
class Eticket(models.Model):
"""
Eticket can be linked to a product an allows PDF generation
"""
2018-10-04 19:29:19 +00:00
product = models.OneToOneField(
Product,
related_name="eticket",
verbose_name=_("product"),
on_delete=models.CASCADE,
2018-10-04 19:29:19 +00:00
)
banner = models.ImageField(
upload_to="etickets", null=True, blank=True, verbose_name=_("banner")
)
event_date = models.DateField(_("event date"), null=True, blank=True)
event_title = models.CharField(
_("event title"), max_length=64, null=True, blank=True
)
secret = models.CharField(_("secret"), max_length=64, unique=True)
2016-10-03 17:30:05 +00:00
def __str__(self):
return "%s" % (self.product.name)
def get_absolute_url(self):
2018-10-04 19:29:19 +00:00
return reverse("counter:eticket_list")
2016-10-03 17:30:05 +00:00
def save(self, *args, **kwargs):
if not self.id:
self.secret = base64.b64encode(os.urandom(32))
return super(Eticket, self).save(*args, **kwargs)
def is_owned_by(self, user):
"""
Method to see if that object can be edited by the given user
"""
if user.is_anonymous:
return False
return user.is_in_group(pk=settings.SITH_GROUP_COUNTER_ADMIN_ID)
2016-10-03 17:30:05 +00:00
def get_hash(self, string):
2017-06-12 07:47:24 +00:00
import hashlib
import hmac
2018-10-04 19:29:19 +00:00
return hmac.new(
bytes(self.secret, "utf-8"), bytes(string, "utf-8"), hashlib.sha1
).hexdigest()
class StudentCard(models.Model):
"""
Alternative way to connect a customer into a counter
We are using Mifare DESFire EV1 specs since it's used for izly cards
https://www.nxp.com/docs/en/application-note/AN10927.pdf
UID is 7 byte long that means 14 hexa characters
"""
UID_SIZE = 14
@staticmethod
def is_valid(uid):
return (
(uid.isupper() or uid.isnumeric())
and len(uid) == StudentCard.UID_SIZE
and not StudentCard.objects.filter(uid=uid).exists()
)
@staticmethod
def can_create(customer, user):
return user.pk == customer.user.pk or user.is_board_member or user.is_root
def can_be_edited_by(self, obj):
if isinstance(obj, User):
return StudentCard.can_create(self.customer, obj)
return False
2018-10-18 23:21:57 +00:00
uid = models.CharField(
_("uid"), max_length=14, unique=True, validators=[MinLengthValidator(4)]
)
customer = models.ForeignKey(
Customer,
related_name="student_cards",
verbose_name=_("student cards"),
null=False,
blank=False,
on_delete=models.CASCADE,
)