2588 lines
98 KiB
Python
2588 lines
98 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
from django.shortcuts import render, get_object_or_404, redirect
|
|
from django.core.exceptions import PermissionDenied
|
|
from django.core.cache import cache
|
|
from django.views.generic import ListView, DetailView, TemplateView
|
|
from django.views.generic.list import BaseListView, MultipleObjectTemplateResponseMixin
|
|
from django.views.generic.detail import BaseDetailView, SingleObjectTemplateResponseMixin
|
|
from django.views.generic.edit import CreateView, UpdateView, DeleteView, FormView
|
|
from django.core.urlresolvers import reverse, reverse_lazy
|
|
from django.contrib import messages
|
|
from django.contrib.messages.views import SuccessMessageMixin
|
|
from django.contrib.auth import authenticate, login
|
|
from django.contrib.auth.decorators import login_required, permission_required
|
|
from django.contrib.auth.models import User, Permission, Group
|
|
from django.http import JsonResponse, Http404
|
|
from django.forms import formset_factory
|
|
from django.db import transaction
|
|
from django.db.models import F, Sum, Prefetch, Count
|
|
from django.db.models.functions import Coalesce
|
|
from django.utils import timezone
|
|
from django.utils.crypto import get_random_string
|
|
from django.utils.decorators import method_decorator
|
|
from gestioncof.models import CofProfile
|
|
from kfet.decorators import teamkfet_required
|
|
from kfet.models import (
|
|
Account, Checkout, Article, Settings, AccountNegative,
|
|
CheckoutStatement, GenericTeamToken, Supplier, SupplierArticle, Inventory,
|
|
InventoryArticle, Order, OrderArticle, Operation, OperationGroup,
|
|
TransferGroup, Transfer)
|
|
from kfet.forms import (
|
|
AccountTriForm, AccountBalanceForm, AccountNoTriForm, UserForm, CofForm,
|
|
UserRestrictTeamForm, UserGroupForm, AccountForm, CofRestrictForm,
|
|
AccountPwdForm, AccountNegativeForm, UserRestrictForm, AccountRestrictForm,
|
|
GroupForm, CheckoutForm, CheckoutRestrictForm, CheckoutStatementCreateForm,
|
|
CheckoutStatementUpdateForm, ArticleForm, ArticleRestrictForm,
|
|
KPsulOperationGroupForm, KPsulAccountForm, KPsulCheckoutForm,
|
|
KPsulOperationFormSet, AddcostForm, FilterHistoryForm, SettingsForm,
|
|
TransferFormSet, InventoryArticleForm, OrderArticleForm,
|
|
OrderArticleToInventoryForm
|
|
)
|
|
from collections import defaultdict
|
|
from kfet import consumers
|
|
from datetime import timedelta
|
|
from decimal import Decimal
|
|
import django_cas_ng
|
|
import heapq
|
|
import statistics
|
|
from .statistic import daynames, monthnames, weeknames, \
|
|
lastdays, lastweeks, lastmonths, \
|
|
this_morning, this_monday_morning, this_first_month_day, \
|
|
tot_ventes
|
|
|
|
class Home(TemplateView):
|
|
template_name = "kfet/home.html"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(TemplateView, self).get_context_data(**kwargs)
|
|
articles = Article.objects.all().filter(is_sold=True, hidden=False)
|
|
context['pressions'] = articles.filter(category__name='Pression')
|
|
context['articles'] = (articles.exclude(category__name='Pression')
|
|
.order_by('category'))
|
|
return context
|
|
|
|
@method_decorator(login_required)
|
|
def dispatch(self, *args, **kwargs):
|
|
return super(TemplateView, self).dispatch(*args, **kwargs)
|
|
|
|
|
|
@teamkfet_required
|
|
def login_genericteam(request):
|
|
# Check si besoin de déconnecter l'utilisateur de CAS
|
|
profile, _ = CofProfile.objects.get_or_create(user=request.user)
|
|
need_cas_logout = False
|
|
if profile.login_clipper:
|
|
need_cas_logout = True
|
|
# Récupèration de la vue de déconnexion de CAS
|
|
# Ici, car request sera modifié après
|
|
logout_cas = django_cas_ng.views.logout(request)
|
|
|
|
# Authentification du compte générique
|
|
token = GenericTeamToken.objects.create(token=get_random_string(50))
|
|
user = authenticate(username="kfet_genericteam", token=token.token)
|
|
login(request, user)
|
|
|
|
if need_cas_logout:
|
|
# Vue de déconnexion de CAS
|
|
return logout_cas
|
|
|
|
return render(request, "kfet/login_genericteam.html")
|
|
|
|
def put_cleaned_data_in_dict(dict, form):
|
|
for field in form.cleaned_data:
|
|
dict[field] = form.cleaned_data[field]
|
|
|
|
# -----
|
|
# Account views
|
|
# -----
|
|
|
|
# Account - General
|
|
|
|
@login_required
|
|
@teamkfet_required
|
|
def account(request):
|
|
accounts = Account.objects.select_related('cofprofile__user').order_by('trigramme')
|
|
return render(request, "kfet/account.html", { 'accounts' : accounts })
|
|
|
|
@login_required
|
|
@teamkfet_required
|
|
def account_is_validandfree_ajax(request):
|
|
if not request.GET.get("trigramme", ''):
|
|
raise Http404
|
|
trigramme = request.GET.get("trigramme")
|
|
data = Account.is_validandfree(trigramme)
|
|
return JsonResponse(data)
|
|
|
|
# Account - Create
|
|
|
|
@login_required
|
|
@teamkfet_required
|
|
def account_create_special(request):
|
|
|
|
# Enregistrement
|
|
if request.method == "POST":
|
|
trigramme_form = AccountTriForm(request.POST, initial={'balance':0})
|
|
balance_form = AccountBalanceForm(request.POST)
|
|
|
|
# Peuplement des forms
|
|
username = request.POST.get('username')
|
|
login_clipper = request.POST.get('login_clipper')
|
|
|
|
forms = get_account_create_forms(
|
|
request, username=username, login_clipper=login_clipper)
|
|
|
|
account_form = forms['account_form']
|
|
cof_form = forms['cof_form']
|
|
user_form = forms['user_form']
|
|
|
|
if all((user_form.is_valid(), cof_form.is_valid(),
|
|
trigramme_form.is_valid(), account_form.is_valid(),
|
|
balance_form.is_valid())):
|
|
# Checking permission
|
|
if not request.user.has_perm('kfet.special_add_account'):
|
|
messages.error(request, 'Permission refusée')
|
|
else:
|
|
data = {}
|
|
# Fill data for Account.save()
|
|
put_cleaned_data_in_dict(data, user_form)
|
|
put_cleaned_data_in_dict(data, cof_form)
|
|
|
|
try:
|
|
account = trigramme_form.save(data = data)
|
|
account_form = AccountNoTriForm(request.POST, instance=account)
|
|
account_form.save()
|
|
balance_form = AccountBalanceForm(request.POST, instance=account)
|
|
balance_form.save()
|
|
amount = balance_form.cleaned_data['balance']
|
|
checkout = Checkout.objects.get(name='Initial')
|
|
is_cof = account.is_cof
|
|
opegroup = OperationGroup.objects.create(
|
|
on_acc=account,
|
|
checkout=checkout,
|
|
amount = amount,
|
|
is_cof = account.is_cof)
|
|
ope = Operation.objects.create(
|
|
group = opegroup,
|
|
type = Operation.INITIAL,
|
|
amount = amount,
|
|
is_checkout = False)
|
|
messages.success(request, 'Compte créé : %s' % account.trigramme)
|
|
return redirect('kfet.account.create')
|
|
except Account.UserHasAccount as e:
|
|
messages.error(request, \
|
|
"Cet utilisateur a déjà un compte K-Fêt : %s" % e.trigramme)
|
|
else:
|
|
initial = { 'trigramme': request.GET.get('trigramme', '') }
|
|
trigramme_form = AccountTriForm(initial = initial)
|
|
balance_form = AccountBalanceForm(initial = {'balance': 0})
|
|
account_form = None
|
|
cof_form = None
|
|
user_form = None
|
|
|
|
return render(request, "kfet/account_create_special.html", {
|
|
'trigramme_form': trigramme_form,
|
|
'account_form': account_form,
|
|
'cof_form': cof_form,
|
|
'user_form': user_form,
|
|
'balance_form': balance_form,
|
|
})
|
|
|
|
|
|
# Account - Create
|
|
|
|
@login_required
|
|
@teamkfet_required
|
|
def account_create(request):
|
|
|
|
# Enregistrement
|
|
if request.method == "POST":
|
|
trigramme_form = AccountTriForm(request.POST)
|
|
|
|
# Peuplement des forms
|
|
username = request.POST.get('username')
|
|
login_clipper = request.POST.get('login_clipper')
|
|
|
|
forms = get_account_create_forms(
|
|
request, username=username, login_clipper=login_clipper)
|
|
|
|
account_form = forms['account_form']
|
|
cof_form = forms['cof_form']
|
|
user_form = forms['user_form']
|
|
|
|
if all((user_form.is_valid(), cof_form.is_valid(),
|
|
trigramme_form.is_valid(), account_form.is_valid())):
|
|
# Checking permission
|
|
if not request.user.has_perm('kfet.add_account'):
|
|
messages.error(request, 'Permission refusée')
|
|
else:
|
|
data = {}
|
|
# Fill data for Account.save()
|
|
put_cleaned_data_in_dict(data, user_form)
|
|
put_cleaned_data_in_dict(data, cof_form)
|
|
|
|
try:
|
|
account = trigramme_form.save(data = data)
|
|
account_form = AccountNoTriForm(request.POST, instance=account)
|
|
account_form.save()
|
|
messages.success(request, 'Compte créé : %s' % account.trigramme)
|
|
return redirect('kfet.account.create')
|
|
except Account.UserHasAccount as e:
|
|
messages.error(request, \
|
|
"Cet utilisateur a déjà un compte K-Fêt : %s" % e.trigramme)
|
|
else:
|
|
initial = { 'trigramme': request.GET.get('trigramme', '') }
|
|
trigramme_form = AccountTriForm(initial = initial)
|
|
account_form = None
|
|
cof_form = None
|
|
user_form = None
|
|
|
|
return render(request, "kfet/account_create.html", {
|
|
'trigramme_form': trigramme_form,
|
|
'account_form': account_form,
|
|
'cof_form': cof_form,
|
|
'user_form': user_form,
|
|
})
|
|
|
|
def account_form_set_readonly_fields(user_form, cof_form):
|
|
user_form.fields['username'].widget.attrs['readonly'] = True
|
|
cof_form.fields['login_clipper'].widget.attrs['readonly'] = True
|
|
cof_form.fields['is_cof'].widget.attrs['disabled'] = True
|
|
|
|
def get_account_create_forms(request=None, username=None, login_clipper=None,
|
|
fullname=None):
|
|
user = None
|
|
clipper = False
|
|
if login_clipper and (login_clipper == username or not username):
|
|
# à partir d'un clipper
|
|
# le user associé à ce clipper ne devrait pas encore exister
|
|
clipper = True
|
|
try:
|
|
# Vérification que clipper ne soit pas déjà dans User
|
|
user = User.objects.get(username=login_clipper)
|
|
# Ici, on nous a menti, le user existe déjà
|
|
username = user.username
|
|
clipper = False
|
|
except User.DoesNotExist:
|
|
# Clipper (sans user déjà existant)
|
|
|
|
# UserForm - Prefill
|
|
user_initial = {
|
|
'username' : login_clipper,
|
|
'email' : "%s@clipper.ens.fr" % login_clipper}
|
|
if fullname:
|
|
# Prefill du nom et prénom
|
|
names = fullname.split()
|
|
# Le premier, c'est le prénom
|
|
user_initial['first_name'] = names[0]
|
|
if len(names) > 1:
|
|
# Si d'autres noms -> tous dans le nom de famille
|
|
user_initial['last_name'] = " ".join(names[1:])
|
|
# CofForm - Prefill
|
|
cof_initial = { 'login_clipper': login_clipper }
|
|
|
|
# Form créations
|
|
if request:
|
|
user_form = UserForm(request.POST, initial=user_initial, from_clipper=True)
|
|
cof_form = CofForm(request.POST, initial=cof_initial)
|
|
else:
|
|
user_form = UserForm(initial=user_initial, from_clipper=True)
|
|
cof_form = CofForm(initial=cof_initial)
|
|
|
|
# Protection (read-only) des champs username et login_clipper
|
|
account_form_set_readonly_fields(user_form, cof_form)
|
|
if username and not clipper:
|
|
try:
|
|
user = User.objects.get(username=username)
|
|
# le user existe déjà
|
|
# récupération du profil cof
|
|
(cof, _) = CofProfile.objects.get_or_create(user=user)
|
|
# UserForm + CofForm - Création à partir des instances existantes
|
|
if request:
|
|
user_form = UserForm(request.POST, instance = user)
|
|
cof_form = CofForm(request.POST, instance = cof)
|
|
else:
|
|
user_form = UserForm(instance=user)
|
|
cof_form = CofForm(instance=cof)
|
|
# Protection (read-only) des champs username, login_clipper et is_cof
|
|
account_form_set_readonly_fields(user_form, cof_form)
|
|
except User.DoesNotExist:
|
|
# le username donnée n'existe pas -> Création depuis rien
|
|
# (éventuellement en cours avec erreurs précédemment)
|
|
pass
|
|
if not user and not clipper:
|
|
# connaît pas du tout, faut tout remplir
|
|
if request:
|
|
user_form = UserForm(request.POST)
|
|
cof_form = CofForm(request.POST)
|
|
else:
|
|
user_form = UserForm()
|
|
cof_form = CofForm()
|
|
# mais on laisse le username en écriture
|
|
cof_form.fields['login_clipper'].widget.attrs['readonly'] = True
|
|
cof_form.fields['is_cof'].widget.attrs['disabled'] = True
|
|
|
|
if request:
|
|
account_form = AccountNoTriForm(request.POST)
|
|
else:
|
|
account_form = AccountNoTriForm()
|
|
|
|
return {
|
|
'account_form': account_form,
|
|
'cof_form': cof_form,
|
|
'user_form': user_form,
|
|
}
|
|
|
|
|
|
@login_required
|
|
@teamkfet_required
|
|
def account_create_ajax(request, username=None, login_clipper=None,
|
|
fullname=None):
|
|
forms = get_account_create_forms(
|
|
request=None, username=username, login_clipper=login_clipper,
|
|
fullname=fullname)
|
|
return render(request, "kfet/account_create_form.html", {
|
|
'account_form' : forms['account_form'],
|
|
'cof_form' : forms['cof_form'],
|
|
'user_form' : forms['user_form'],
|
|
})
|
|
|
|
# Account - Read
|
|
|
|
@login_required
|
|
def account_read(request, trigramme):
|
|
try:
|
|
account = Account.objects.select_related('negative').get(trigramme=trigramme)
|
|
except Account.DoesNotExist:
|
|
raise Http404
|
|
|
|
# Checking permissions
|
|
if not request.user.has_perm('kfet.is_team') \
|
|
and request.user != account.user:
|
|
raise PermissionDenied
|
|
|
|
addcosts = (OperationGroup.objects
|
|
.filter(opes__addcost_for=account,opes__canceled_at=None)
|
|
.extra({'date':"date(at)"})
|
|
.values('date')
|
|
.annotate(sum_addcosts=Sum('opes__addcost_amount'))
|
|
.order_by('-date'))
|
|
|
|
return render(request, "kfet/account_read.html", {
|
|
'account' : account,
|
|
'addcosts': addcosts,
|
|
'settings': { 'subvention_cof': Settings.SUBVENTION_COF() },
|
|
})
|
|
|
|
# Account - Update
|
|
|
|
|
|
@login_required
|
|
def account_update(request, trigramme):
|
|
account = get_object_or_404(Account, trigramme=trigramme)
|
|
|
|
# Checking permissions
|
|
if not request.user.has_perm('kfet.is_team') \
|
|
and request.user != account.user:
|
|
raise PermissionDenied
|
|
|
|
if request.user.has_perm('kfet.is_team'):
|
|
user_form = UserRestrictTeamForm(instance=account.user)
|
|
group_form = UserGroupForm(instance=account.user)
|
|
account_form = AccountForm(instance=account)
|
|
cof_form = CofRestrictForm(instance=account.cofprofile)
|
|
pwd_form = AccountPwdForm()
|
|
if account.balance < 0 and not hasattr(account, 'negative'):
|
|
AccountNegative.objects.create(account=account,
|
|
start=timezone.now())
|
|
account.refresh_from_db()
|
|
if hasattr(account, 'negative'):
|
|
negative_form = AccountNegativeForm(instance=account.negative)
|
|
else:
|
|
negative_form = None
|
|
else:
|
|
user_form = UserRestrictForm(instance=account.user)
|
|
account_form = AccountRestrictForm(instance=account)
|
|
cof_form = None
|
|
group_form = None
|
|
negative_form = None
|
|
pwd_form = None
|
|
|
|
if request.method == "POST":
|
|
# Update attempt
|
|
success = False
|
|
missing_perm = True
|
|
|
|
if request.user.has_perm('kfet.is_team'):
|
|
account_form = AccountForm(request.POST, instance=account)
|
|
cof_form = CofRestrictForm(request.POST,
|
|
instance=account.cofprofile)
|
|
user_form = UserRestrictTeamForm(request.POST,
|
|
instance=account.user)
|
|
group_form = UserGroupForm(request.POST, instance=account.user)
|
|
pwd_form = AccountPwdForm(request.POST)
|
|
if hasattr(account, 'negative'):
|
|
negative_form = AccountNegativeForm(request.POST,
|
|
instance=account.negative)
|
|
|
|
if (request.user.has_perm('kfet.change_account')
|
|
and account_form.is_valid() and cof_form.is_valid()
|
|
and user_form.is_valid()):
|
|
missing_perm = False
|
|
data = {}
|
|
# Fill data for Account.save()
|
|
put_cleaned_data_in_dict(data, user_form)
|
|
put_cleaned_data_in_dict(data, cof_form)
|
|
|
|
# Updating
|
|
account_form.save(data=data)
|
|
|
|
# Checking perm to update password
|
|
if (request.user.has_perm('kfet.change_account_password')
|
|
and pwd_form.is_valid()):
|
|
pwd = pwd_form.cleaned_data['pwd1']
|
|
account.change_pwd(pwd)
|
|
account.save()
|
|
messages.success(request, 'Mot de passe mis à jour')
|
|
|
|
# Checking perm to manage perms
|
|
if (request.user.has_perm('kfet.manage_perms')
|
|
and group_form.is_valid()):
|
|
group_form.save()
|
|
|
|
# Checking perm to manage negative
|
|
if hasattr(account, 'negative'):
|
|
balance_offset_old = 0
|
|
if account.negative.balance_offset:
|
|
balance_offset_old = account.negative.balance_offset
|
|
if (hasattr(account, 'negative')
|
|
and request.user.has_perm('kfet.change_accountnegative')
|
|
and negative_form.is_valid()):
|
|
balance_offset_new = \
|
|
negative_form.cleaned_data['balance_offset']
|
|
if not balance_offset_new:
|
|
balance_offset_new = 0
|
|
balance_offset_diff = (balance_offset_new
|
|
- balance_offset_old)
|
|
Account.objects.filter(pk=account.pk).update(
|
|
balance=F('balance') + balance_offset_diff)
|
|
negative_form.save()
|
|
if Account.objects.get(pk=account.pk).balance >= 0 \
|
|
and not balance_offset_new:
|
|
AccountNegative.objects.get(account=account).delete()
|
|
|
|
success = True
|
|
messages.success(
|
|
request,
|
|
'Informations du compte %s mises à jour'
|
|
% account.trigramme)
|
|
|
|
# Modification de ses propres informations
|
|
if request.user == account.user:
|
|
missing_perm = False
|
|
account.refresh_from_db()
|
|
user_form = UserRestrictForm(request.POST, instance=account.user)
|
|
account_form = AccountRestrictForm(request.POST, instance=account)
|
|
pwd_form = AccountPwdForm(request.POST)
|
|
|
|
if user_form.is_valid() and account_form.is_valid():
|
|
user_form.save()
|
|
account_form.save()
|
|
success = True
|
|
messages.success(request,
|
|
'Vos informations ont été mises à jour')
|
|
|
|
if request.user.has_perm('kfet.is_team') \
|
|
and pwd_form.is_valid():
|
|
pwd = pwd_form.cleaned_data['pwd1']
|
|
account.change_pwd(pwd)
|
|
account.save()
|
|
messages.success(
|
|
request, 'Votre mot de passe a été mis à jour')
|
|
|
|
if missing_perm:
|
|
messages.error(request, 'Permission refusée')
|
|
if success:
|
|
return redirect('kfet.account.read', account.trigramme)
|
|
else:
|
|
messages.error(
|
|
request, 'Informations non mises à jour. Corrigez les erreurs')
|
|
|
|
return render(request, "kfet/account_update.html", {
|
|
'account': account,
|
|
'account_form': account_form,
|
|
'cof_form': cof_form,
|
|
'user_form': user_form,
|
|
'group_form': group_form,
|
|
'negative_form': negative_form,
|
|
'pwd_form': pwd_form,
|
|
})
|
|
|
|
@permission_required('kfet.manage_perms')
|
|
def account_group(request):
|
|
groups = (Group.objects
|
|
.filter(name__icontains='K-Fêt')
|
|
.prefetch_related('permissions', 'user_set__profile__account_kfet')
|
|
)
|
|
return render(request, 'kfet/account_group.html', { 'groups': groups })
|
|
|
|
class AccountGroupCreate(SuccessMessageMixin, CreateView):
|
|
model = Group
|
|
template_name = 'kfet/account_group_form.html'
|
|
form_class = GroupForm
|
|
success_message = 'Nouveau groupe : %(name)s'
|
|
success_url = reverse_lazy('kfet.account.group')
|
|
|
|
class AccountGroupUpdate(UpdateView):
|
|
queryset = Group.objects.filter(name__icontains='K-Fêt')
|
|
template_name = 'kfet/account_group_form.html'
|
|
form_class = GroupForm
|
|
success_message = 'Groupe modifié : %(name)s'
|
|
success_url = reverse_lazy('kfet.account.group')
|
|
|
|
class AccountNegativeList(ListView):
|
|
queryset = (AccountNegative.objects
|
|
.select_related('account', 'account__cofprofile__user')
|
|
.exclude(account__trigramme='#13'))
|
|
template_name = 'kfet/account_negative.html'
|
|
context_object_name = 'negatives'
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(AccountNegativeList, self).get_context_data(**kwargs)
|
|
context['settings'] = {
|
|
'overdraft_amount': Settings.OVERDRAFT_AMOUNT(),
|
|
'overdraft_duration': Settings.OVERDRAFT_DURATION(),
|
|
}
|
|
negs_sum = (AccountNegative.objects
|
|
.exclude(account__trigramme='#13')
|
|
.aggregate(
|
|
bal = Coalesce(Sum('account__balance'),0),
|
|
offset = Coalesce(Sum('balance_offset'),0),
|
|
)
|
|
)
|
|
context['negatives_sum'] = negs_sum['bal'] - negs_sum['offset']
|
|
return context
|
|
|
|
# -----
|
|
# Checkout views
|
|
# -----
|
|
|
|
# Checkout - General
|
|
|
|
class CheckoutList(ListView):
|
|
model = Checkout
|
|
template_name = 'kfet/checkout.html'
|
|
context_object_name = 'checkouts'
|
|
|
|
# Checkout - Create
|
|
|
|
class CheckoutCreate(SuccessMessageMixin, CreateView):
|
|
model = Checkout
|
|
template_name = 'kfet/checkout_create.html'
|
|
form_class = CheckoutForm
|
|
success_message = 'Nouvelle caisse : %(name)s'
|
|
|
|
# Surcharge de la validation
|
|
def form_valid(self, form):
|
|
# Checking permission
|
|
if not self.request.user.has_perm('kfet.add_checkout'):
|
|
form.add_error(None, 'Permission refusée')
|
|
return self.form_invalid(form)
|
|
|
|
# Creating
|
|
form.instance.created_by = self.request.user.profile.account_kfet
|
|
checkout = form.save()
|
|
|
|
# Création d'un relevé avec balance initiale
|
|
CheckoutStatement.objects.create(
|
|
checkout = checkout,
|
|
by = self.request.user.profile.account_kfet,
|
|
balance_old = checkout.balance,
|
|
balance_new = checkout.balance,
|
|
amount_taken = 0)
|
|
|
|
return super(CheckoutCreate, self).form_valid(form)
|
|
|
|
# Checkout - Read
|
|
|
|
class CheckoutRead(DetailView):
|
|
model = Checkout
|
|
template_name = 'kfet/checkout_read.html'
|
|
context_object_name = 'checkout'
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(CheckoutRead, self).get_context_data(**kwargs)
|
|
context['statements'] = context['checkout'].statements.order_by('-at')
|
|
return context
|
|
|
|
# Checkout - Update
|
|
|
|
class CheckoutUpdate(SuccessMessageMixin, UpdateView):
|
|
model = Checkout
|
|
template_name = 'kfet/checkout_update.html'
|
|
form_class = CheckoutRestrictForm
|
|
success_message = 'Informations mises à jour pour la caisse : %(name)s'
|
|
|
|
# Surcharge de la validation
|
|
def form_valid(self, form):
|
|
# Checking permission
|
|
if not self.request.user.has_perm('kfet.change_checkout'):
|
|
form.add_error(None, 'Permission refusée')
|
|
return self.form_invalid(form)
|
|
# Updating
|
|
return super(CheckoutUpdate, self).form_valid(form)
|
|
|
|
# -----
|
|
# Checkout Statement views
|
|
# -----
|
|
|
|
# Checkout Statement - General
|
|
|
|
class CheckoutStatementList(ListView):
|
|
model = CheckoutStatement
|
|
queryset = CheckoutStatement.objects.order_by('-at')
|
|
template_name = 'kfet/checkoutstatement.html'
|
|
context_object_name= 'checkoutstatements'
|
|
|
|
# Checkout Statement - Create
|
|
|
|
def getAmountTaken(data):
|
|
return Decimal(data.taken_001 * 0.01 + data.taken_002 * 0.02
|
|
+ data.taken_005 * 0.05 + data.taken_01 * 0.1
|
|
+ data.taken_02 * 0.2 + data.taken_05 * 0.5
|
|
+ data.taken_1 * 1 + data.taken_2 * 2
|
|
+ data.taken_5 * 5 + data.taken_10 * 10
|
|
+ data.taken_20 * 20 + data.taken_50 * 50
|
|
+ data.taken_100 * 100 + data.taken_200 * 200
|
|
+ data.taken_500 * 500 + float(data.taken_cheque))
|
|
|
|
def getAmountBalance(data):
|
|
return Decimal(data['balance_001'] * 0.01 + data['balance_002'] * 0.02
|
|
+ data['balance_005'] * 0.05 + data['balance_01'] * 0.1
|
|
+ data['balance_02'] * 0.2 + data['balance_05'] * 0.5
|
|
+ data['balance_1'] * 1 + data['balance_2'] * 2
|
|
+ data['balance_5'] * 5 + data['balance_10'] * 10
|
|
+ data['balance_20'] * 20 + data['balance_50'] * 50
|
|
+ data['balance_100'] * 100 + data['balance_200'] * 200
|
|
+ data['balance_500'] * 500)
|
|
|
|
class CheckoutStatementCreate(SuccessMessageMixin, CreateView):
|
|
model = CheckoutStatement
|
|
template_name = 'kfet/checkoutstatement_create.html'
|
|
form_class = CheckoutStatementCreateForm
|
|
success_message = 'Nouveau relevé : %(checkout)s - %(at)s'
|
|
|
|
def get_success_url(self):
|
|
return reverse_lazy('kfet.checkout.read', kwargs={'pk':self.kwargs['pk_checkout']})
|
|
|
|
def get_success_message(self, cleaned_data):
|
|
return self.success_message % dict(
|
|
cleaned_data,
|
|
checkout = self.object.checkout.name,
|
|
at = self.object.at)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(CheckoutStatementCreate, self).get_context_data(**kwargs)
|
|
checkout = Checkout.objects.get(pk=self.kwargs['pk_checkout'])
|
|
context['checkout'] = checkout
|
|
return context
|
|
|
|
def form_valid(self, form):
|
|
# Checking permission
|
|
if not self.request.user.has_perm('kfet.add_checkoutstatement'):
|
|
form.add_error(None, 'Permission refusée')
|
|
return self.form_invalid(form)
|
|
# Creating
|
|
form.instance.amount_taken = getAmountTaken(form.instance)
|
|
if not form.instance.not_count:
|
|
form.instance.balance_new = getAmountBalance(form.cleaned_data)
|
|
form.instance.checkout_id = self.kwargs['pk_checkout']
|
|
form.instance.by = self.request.user.profile.account_kfet
|
|
return super(CheckoutStatementCreate, self).form_valid(form)
|
|
|
|
class CheckoutStatementUpdate(SuccessMessageMixin, UpdateView):
|
|
model = CheckoutStatement
|
|
template_name = 'kfet/checkoutstatement_update.html'
|
|
form_class = CheckoutStatementUpdateForm
|
|
success_message = 'Relevé modifié'
|
|
|
|
def get_success_url(self):
|
|
return reverse_lazy('kfet.checkout.read', kwargs={'pk':self.kwargs['pk_checkout']})
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(CheckoutStatementUpdate, self).get_context_data(**kwargs)
|
|
checkout = Checkout.objects.get(pk=self.kwargs['pk_checkout'])
|
|
context['checkout'] = checkout
|
|
return context
|
|
|
|
def form_valid(self, form):
|
|
# Checking permission
|
|
if not self.request.user.has_perm('kfet.change_checkoutstatement'):
|
|
form.add_error(None, 'Permission refusée')
|
|
return self.form_invalid(form)
|
|
# Updating
|
|
form.instance.amount_taken = getAmountTaken(form.instance)
|
|
return super(CheckoutStatementUpdate, self).form_valid(form)
|
|
|
|
# -----
|
|
# Article views
|
|
# -----
|
|
|
|
# Article - General
|
|
|
|
class ArticleList(ListView):
|
|
queryset = (Article.objects
|
|
.select_related('category')
|
|
.prefetch_related(Prefetch('inventories',
|
|
queryset = Inventory.objects.order_by('-at'),
|
|
to_attr = 'inventory'))
|
|
.order_by('category', '-is_sold', 'name'))
|
|
template_name = 'kfet/article.html'
|
|
context_object_name = 'articles'
|
|
|
|
# Article - Create
|
|
|
|
class ArticleCreate(SuccessMessageMixin, CreateView):
|
|
model = Article
|
|
template_name = 'kfet/article_create.html'
|
|
form_class = ArticleForm
|
|
success_message = 'Nouvel item : %(category)s - %(name)s'
|
|
|
|
# Surcharge de la validation
|
|
def form_valid(self, form):
|
|
# Checking permission
|
|
if not self.request.user.has_perm('kfet.add_article'):
|
|
form.add_error(None, 'Permission refusée')
|
|
return self.form_invalid(form)
|
|
|
|
# Save ici pour save le manytomany suppliers
|
|
article = form.save()
|
|
# Save des suppliers déjà existant
|
|
for supplier in form.cleaned_data['suppliers']:
|
|
SupplierArticle.objects.create(
|
|
article = article, supplier = supplier)
|
|
|
|
# Nouveau supplier
|
|
supplier_new = form.cleaned_data['supplier_new'].strip()
|
|
if supplier_new:
|
|
supplier, created = Supplier.objects.get_or_create(
|
|
name=supplier_new)
|
|
if created:
|
|
SupplierArticle.objects.create(
|
|
article = article, supplier = supplier)
|
|
|
|
# Inventaire avec stock initial
|
|
inventory = Inventory()
|
|
inventory.by = self.request.user.profile.account_kfet
|
|
inventory.save()
|
|
InventoryArticle.objects.create(
|
|
inventory = inventory,
|
|
article = article,
|
|
stock_old = article.stock,
|
|
stock_new = article.stock,
|
|
)
|
|
|
|
# Creating
|
|
return super(ArticleCreate, self).form_valid(form)
|
|
|
|
# Article - Read
|
|
|
|
class ArticleRead(DetailView):
|
|
model = Article
|
|
template_name = 'kfet/article_read.html'
|
|
context_object_name = 'article'
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(ArticleRead, self).get_context_data(**kwargs)
|
|
inventoryarts = (InventoryArticle.objects
|
|
.filter(article = self.object)
|
|
.select_related('inventory')
|
|
.order_by('-inventory__at'))
|
|
context['inventoryarts'] = inventoryarts
|
|
supplierarts = (SupplierArticle.objects
|
|
.filter(article = self.object)
|
|
.select_related('supplier')
|
|
.order_by('-at'))
|
|
context['supplierarts'] = supplierarts
|
|
return context
|
|
|
|
# Article - Update
|
|
|
|
class ArticleUpdate(SuccessMessageMixin, UpdateView):
|
|
model = Article
|
|
template_name = 'kfet/article_update.html'
|
|
form_class = ArticleRestrictForm
|
|
success_message = "Informations mises à jour pour l'article : %(name)s"
|
|
|
|
# Surcharge de la validation
|
|
def form_valid(self, form):
|
|
# Checking permission
|
|
if not self.request.user.has_perm('kfet.change_article'):
|
|
form.add_error(None, 'Permission refusée')
|
|
return self.form_invalid(form)
|
|
|
|
# Save ici pour save le manytomany suppliers
|
|
article = form.save()
|
|
# Save des suppliers déjà existant
|
|
for supplier in form.cleaned_data['suppliers']:
|
|
if supplier not in article.suppliers.all():
|
|
SupplierArticle.objects.create(
|
|
article = article, supplier = supplier)
|
|
|
|
# On vire les suppliers désélectionnés
|
|
for supplier in article.suppliers.all():
|
|
if supplier not in form.cleaned_data['suppliers']:
|
|
SupplierArticle.objects.filter(
|
|
article = article, supplier = supplier).delete()
|
|
|
|
# Nouveau supplier
|
|
supplier_new = form.cleaned_data['supplier_new'].strip()
|
|
if supplier_new:
|
|
supplier, created = Supplier.objects.get_or_create(
|
|
name=supplier_new)
|
|
if created:
|
|
SupplierArticle.objects.create(
|
|
article = article, supplier = supplier)
|
|
|
|
# Updating
|
|
return super(ArticleUpdate, self).form_valid(form)
|
|
|
|
|
|
|
|
# -----
|
|
# K-Psul
|
|
# -----
|
|
|
|
@teamkfet_required
|
|
def kpsul(request):
|
|
data = {}
|
|
data['operationgroup_form'] = KPsulOperationGroupForm()
|
|
data['trigramme_form'] = KPsulAccountForm()
|
|
initial = {}
|
|
try:
|
|
checkout = Checkout.objects.filter(
|
|
is_protected=False, valid_from__lte=timezone.now(),
|
|
valid_to__gte=timezone.now()).get()
|
|
initial['checkout'] = checkout
|
|
except (Checkout.DoesNotExist, Checkout.MultipleObjectsReturned):
|
|
pass
|
|
data['checkout_form'] = KPsulCheckoutForm(initial=initial)
|
|
operation_formset = KPsulOperationFormSet(queryset=Operation.objects.none())
|
|
data['operation_formset'] = operation_formset
|
|
return render(request, 'kfet/kpsul.html', data)
|
|
|
|
@teamkfet_required
|
|
def kpsul_get_settings(request):
|
|
addcost_for = Settings.ADDCOST_FOR()
|
|
data = {
|
|
'subvention_cof': Settings.SUBVENTION_COF(),
|
|
'addcost_for' : addcost_for and addcost_for.trigramme or '',
|
|
'addcost_amount': Settings.ADDCOST_AMOUNT(),
|
|
}
|
|
return JsonResponse(data)
|
|
|
|
@teamkfet_required
|
|
def account_read_json(request):
|
|
trigramme = request.POST.get('trigramme', '')
|
|
account = get_object_or_404(Account, trigramme=trigramme)
|
|
data = { 'id': account.pk, 'name': account.name, 'email': account.email,
|
|
'is_cof': account.is_cof, 'promo': account.promo,
|
|
'balance': account.balance, 'is_frozen': account.is_frozen,
|
|
'departement': account.departement, 'nickname': account.nickname,
|
|
'trigramme': account.trigramme }
|
|
return JsonResponse(data)
|
|
|
|
@teamkfet_required
|
|
def kpsul_checkout_data(request):
|
|
pk = request.POST.get('pk', 0)
|
|
if not pk:
|
|
pk = 0
|
|
data = (Checkout.objects
|
|
.annotate(
|
|
last_statement_by_first_name=F('statements__by__cofprofile__user__first_name'),
|
|
last_statement_by_last_name=F('statements__by__cofprofile__user__last_name'),
|
|
last_statement_by_trigramme=F('statements__by__trigramme'),
|
|
last_statement_balance=F('statements__balance_new'),
|
|
last_statement_at=F('statements__at'))
|
|
.values(
|
|
'id', 'name', 'balance', 'valid_from', 'valid_to',
|
|
'last_statement_balance', 'last_statement_at',
|
|
'last_statement_by_trigramme', 'last_statement_by_last_name',
|
|
'last_statement_by_first_name')
|
|
.select_related(
|
|
'statements'
|
|
'statements__by',
|
|
'statements__by__cofprofile__user')
|
|
.filter(pk=pk)
|
|
.order_by('statements__at')
|
|
.last())
|
|
if data is None:
|
|
raise Http404
|
|
return JsonResponse(data)
|
|
|
|
@teamkfet_required
|
|
def kpsul_update_addcost(request):
|
|
addcost_form = AddcostForm(request.POST)
|
|
|
|
if not addcost_form.is_valid():
|
|
data = { 'errors': { 'addcost': list(addcost_form.errors) } }
|
|
return JsonResponse(data, status=400)
|
|
required_perms = ['kfet.manage_addcosts']
|
|
if not request.user.has_perms(required_perms):
|
|
data = {
|
|
'errors': {
|
|
'missing_perms': get_missing_perms(required_perms, request.user)
|
|
}
|
|
}
|
|
return JsonResponse(data, status=403)
|
|
|
|
trigramme = addcost_form.cleaned_data['trigramme']
|
|
account = trigramme and Account.objects.get(trigramme=trigramme) or None
|
|
Settings.objects.filter(name='ADDCOST_FOR').update(value_account=account)
|
|
Settings.objects.filter(name='ADDCOST_AMOUNT').update(value_decimal=addcost_form.cleaned_data['amount'])
|
|
cache.delete('ADDCOST_FOR')
|
|
cache.delete('ADDCOST_AMOUNT')
|
|
data = {
|
|
'addcost': {
|
|
'for': trigramme and account.trigramme or None,
|
|
'amount': addcost_form.cleaned_data['amount'],
|
|
}
|
|
}
|
|
consumers.KPsul.group_send('kfet.kpsul', data)
|
|
return JsonResponse(data)
|
|
|
|
def get_missing_perms(required_perms, user):
|
|
missing_perms_codenames = [ (perm.split('.'))[1]
|
|
for perm in required_perms if not user.has_perm(perm)]
|
|
missing_perms = list(
|
|
Permission.objects
|
|
.filter(codename__in=missing_perms_codenames)
|
|
.values_list('name', flat=True))
|
|
return missing_perms
|
|
|
|
@teamkfet_required
|
|
def kpsul_perform_operations(request):
|
|
# Initializing response data
|
|
data = { 'operationgroup': 0, 'operations': [],
|
|
'warnings': {}, 'errors': {} }
|
|
|
|
# Checking operationgroup
|
|
operationgroup_form = KPsulOperationGroupForm(request.POST)
|
|
if not operationgroup_form.is_valid():
|
|
data['errors']['operation_group'] = list(operationgroup_form.errors)
|
|
|
|
# Checking operation_formset
|
|
operation_formset = KPsulOperationFormSet(request.POST)
|
|
if not operation_formset.is_valid():
|
|
data['errors']['operations'] = list(operation_formset.errors)
|
|
|
|
# Returning BAD REQUEST if errors
|
|
if data['errors']:
|
|
return JsonResponse(data, status=400)
|
|
|
|
# Pre-saving (no commit)
|
|
operationgroup = operationgroup_form.save(commit = False)
|
|
operations = operation_formset.save(commit = False)
|
|
|
|
# Retrieving COF grant
|
|
cof_grant = Settings.SUBVENTION_COF()
|
|
# Retrieving addcosts data
|
|
addcost_amount = Settings.ADDCOST_AMOUNT()
|
|
addcost_for = Settings.ADDCOST_FOR()
|
|
|
|
# Initializing vars
|
|
required_perms = set() # Required perms to perform all operations
|
|
cof_grant_divisor = 1 + cof_grant / 100
|
|
to_addcost_for_balance = 0 # For balance of addcost_for
|
|
to_checkout_balance = 0 # For balance of selected checkout
|
|
to_articles_stocks = defaultdict(lambda:0) # For stocks articles
|
|
is_addcost = (addcost_for and addcost_amount
|
|
and addcost_for != operationgroup.on_acc)
|
|
need_comment = operationgroup.on_acc.need_comment
|
|
|
|
# Filling data of each operations + operationgroup + calculating other stuffs
|
|
for operation in operations:
|
|
if operation.type == Operation.PURCHASE:
|
|
operation.amount = - operation.article.price * operation.article_nb
|
|
if is_addcost:
|
|
operation.addcost_for = addcost_for
|
|
operation.addcost_amount = addcost_amount * operation.article_nb
|
|
operation.amount -= operation.addcost_amount
|
|
to_addcost_for_balance += operation.addcost_amount
|
|
if operationgroup.on_acc.is_cash:
|
|
operation.is_checkout = True
|
|
to_checkout_balance += -operation.amount
|
|
else:
|
|
operation.is_checkout = False
|
|
if operationgroup.on_acc.is_cof:
|
|
if is_addcost:
|
|
operation.addcost_amount = operation.addcost_amount / cof_grant_divisor
|
|
operation.amount = operation.amount / cof_grant_divisor
|
|
to_articles_stocks[operation.article] -= operation.article_nb
|
|
else:
|
|
if operationgroup.on_acc.is_cash:
|
|
data['errors']['account'] = 'Charge et retrait impossible sur LIQ'
|
|
to_checkout_balance += operation.amount
|
|
operationgroup.amount += operation.amount
|
|
if operation.type == Operation.DEPOSIT:
|
|
required_perms.add('kfet.perform_deposit')
|
|
if (not operation.is_checkout
|
|
and operation.type in [Operation.DEPOSIT, Operation.WITHDRAW]):
|
|
required_perms.add('kfet.edit_balance_account')
|
|
need_comment = True
|
|
if operationgroup.on_acc.is_cof:
|
|
to_addcost_for_balance = to_addcost_for_balance / cof_grant_divisor
|
|
|
|
(perms, stop) = operationgroup.on_acc.perms_to_perform_operation(
|
|
amount = operationgroup.amount)
|
|
required_perms |= perms
|
|
|
|
if need_comment:
|
|
operationgroup.comment = operationgroup.comment.strip()
|
|
if not operationgroup.comment:
|
|
data['errors']['need_comment'] = True
|
|
return JsonResponse(data, status=400)
|
|
|
|
if stop or not request.user.has_perms(required_perms):
|
|
missing_perms = get_missing_perms(required_perms, request.user)
|
|
if missing_perms:
|
|
data['errors']['missing_perms'] = missing_perms
|
|
if stop:
|
|
data['errors']['negative'] = [operationgroup.on_acc.trigramme]
|
|
return JsonResponse(data, status=403)
|
|
|
|
# If 1 perm is required, filling who perform the operations
|
|
if required_perms:
|
|
operationgroup.valid_by = request.user.profile.account_kfet
|
|
# Filling cof status for statistics
|
|
operationgroup.is_cof = operationgroup.on_acc.is_cof
|
|
|
|
# Starting transaction to ensure data consistency
|
|
with transaction.atomic():
|
|
# If not cash account,
|
|
# saving account's balance and adding to Negative if not in
|
|
if not operationgroup.on_acc.is_cash:
|
|
Account.objects.filter(pk=operationgroup.on_acc.pk).update(
|
|
balance = F('balance') + operationgroup.amount)
|
|
operationgroup.on_acc.refresh_from_db()
|
|
if operationgroup.on_acc.balance < 0:
|
|
if hasattr(operationgroup.on_acc, 'negative'):
|
|
if not operationgroup.on_acc.negative.start:
|
|
operationgroup.on_acc.negative.start = timezone.now()
|
|
operationgroup.on_acc.negative.save()
|
|
else:
|
|
negative = AccountNegative(
|
|
account = operationgroup.on_acc, start = timezone.now())
|
|
negative.save()
|
|
elif (hasattr(operationgroup.on_acc, 'negative')
|
|
and not operationgroup.on_acc.negative.balance_offset):
|
|
operationgroup.on_acc.negative.delete()
|
|
|
|
# Updating checkout's balance
|
|
if to_checkout_balance:
|
|
Checkout.objects.filter(pk=operationgroup.checkout.pk).update(
|
|
balance = F('balance') + to_checkout_balance)
|
|
|
|
# Saving addcost_for with new balance if there is one
|
|
if is_addcost and to_addcost_for_balance:
|
|
Account.objects.filter(pk=addcost_for.pk).update(
|
|
balance = F('balance') + to_addcost_for_balance)
|
|
|
|
# Saving operation group
|
|
operationgroup.save()
|
|
data['operationgroup'] = operationgroup.pk
|
|
|
|
# Filling operationgroup id for each operations and saving
|
|
for operation in operations:
|
|
operation.group = operationgroup
|
|
operation.save()
|
|
data['operations'].append(operation.pk)
|
|
|
|
# Updating articles stock
|
|
for article in to_articles_stocks:
|
|
Article.objects.filter(pk=article.pk).update(
|
|
stock = F('stock') + to_articles_stocks[article])
|
|
|
|
# Websocket data
|
|
websocket_data = {}
|
|
websocket_data['opegroups'] = [{
|
|
'add': True,
|
|
'id': operationgroup.pk,
|
|
'amount': operationgroup.amount,
|
|
'checkout__name': operationgroup.checkout.name,
|
|
'at': operationgroup.at,
|
|
'is_cof': operationgroup.is_cof,
|
|
'comment': operationgroup.comment,
|
|
'valid_by__trigramme': ( operationgroup.valid_by and
|
|
operationgroup.valid_by.trigramme or None),
|
|
'on_acc__trigramme': operationgroup.on_acc.trigramme,
|
|
'opes': [],
|
|
}]
|
|
for operation in operations:
|
|
ope_data = {
|
|
'id': operation.pk, 'type': operation.type, 'amount': operation.amount,
|
|
'addcost_amount': operation.addcost_amount,
|
|
'addcost_for__trigramme': is_addcost and addcost_for.trigramme or None,
|
|
'is_checkout': operation.is_checkout,
|
|
'article__name': operation.article and operation.article.name or None,
|
|
'article_nb': operation.article_nb,
|
|
'group_id': operationgroup.pk,
|
|
'canceled_by__trigramme': None, 'canceled_at': None,
|
|
}
|
|
websocket_data['opegroups'][0]['opes'].append(ope_data)
|
|
# Need refresh from db cause we used update on queryset
|
|
operationgroup.checkout.refresh_from_db()
|
|
websocket_data['checkouts'] = [{
|
|
'id': operationgroup.checkout.pk,
|
|
'balance': operationgroup.checkout.balance,
|
|
}]
|
|
websocket_data['articles'] = []
|
|
# Need refresh from db cause we used update on querysets
|
|
articles_pk = [ article.pk for article in to_articles_stocks]
|
|
articles = Article.objects.values('id', 'stock').filter(pk__in=articles_pk)
|
|
for article in articles:
|
|
websocket_data['articles'].append({
|
|
'id': article['id'],
|
|
'stock': article['stock']
|
|
})
|
|
consumers.KPsul.group_send('kfet.kpsul', websocket_data)
|
|
return JsonResponse(data)
|
|
|
|
@teamkfet_required
|
|
def kpsul_cancel_operations(request):
|
|
# Pour la réponse
|
|
data = { 'canceled': [], 'warnings': {}, 'errors': {}}
|
|
|
|
# Checking if BAD REQUEST (opes_pk not int or not existing)
|
|
try:
|
|
# Set pour virer les doublons
|
|
opes_post = set(map(int, filter(None, request.POST.getlist('operations[]', []))))
|
|
except ValueError:
|
|
return JsonResponse(data, status=400)
|
|
opes_all = (
|
|
Operation.objects
|
|
.select_related('group', 'group__on_acc', 'group__on_acc__negative')
|
|
.filter(pk__in=opes_post))
|
|
opes_pk = [ ope.pk for ope in opes_all ]
|
|
opes_notexisting = [ ope for ope in opes_post if ope not in opes_pk ]
|
|
if opes_notexisting:
|
|
data['errors']['opes_notexisting'] = opes_notexisting
|
|
return JsonResponse(data, status=400)
|
|
|
|
opes_already_canceled = [] # Déjà annulée
|
|
opes = [] # Pas déjà annulée
|
|
required_perms = set()
|
|
stop_all = False
|
|
cancel_duration = Settings.CANCEL_DURATION()
|
|
to_accounts_balances = defaultdict(lambda:0) # Modifs à faire sur les balances des comptes
|
|
to_groups_amounts = defaultdict(lambda:0) # ------ sur les montants des groupes d'opé
|
|
to_checkouts_balances = defaultdict(lambda:0) # ------ sur les balances de caisses
|
|
to_articles_stocks = defaultdict(lambda:0) # ------ sur les stocks d'articles
|
|
for ope in opes_all:
|
|
if ope.canceled_at:
|
|
# Opération déjà annulée, va pour un warning en Response
|
|
opes_already_canceled.append(ope.pk)
|
|
else:
|
|
opes.append(ope.pk)
|
|
# Si opé il y a plus de CANCEL_DURATION, permission requise
|
|
if ope.group.at + cancel_duration < timezone.now():
|
|
required_perms.add('kfet.cancel_old_operations')
|
|
|
|
# Calcul de toutes modifs à faire en cas de validation
|
|
|
|
# Pour les balances de comptes
|
|
if not ope.group.on_acc.is_cash:
|
|
to_accounts_balances[ope.group.on_acc] -= ope.amount
|
|
if ope.addcost_for and ope.addcost_amount:
|
|
to_accounts_balances[ope.addcost_for] -= ope.addcost_amount
|
|
# Pour les groupes d'opés
|
|
to_groups_amounts[ope.group] -= ope.amount
|
|
|
|
# Pour les balances de caisses
|
|
# Les balances de caisses dont il y a eu un relevé depuis la date
|
|
# de la commande ne doivent pas être modifiées
|
|
# TODO : Prendre en compte le dernier relevé où la caisse a été
|
|
# comptée et donc modifier les balance_old (et amount_error)
|
|
# des relevés suivants.
|
|
# Note : Dans le cas où un CheckoutStatement est mis à jour
|
|
# par `.save()`, amount_error est recalculé automatiquement,
|
|
# ce qui n'est pas le cas en faisant un update sur queryset
|
|
# TODO ? : Maj les balance_old de relevés pour modifier l'erreur
|
|
last_statement = (CheckoutStatement.objects
|
|
.filter(checkout=ope.group.checkout)
|
|
.order_by('at')
|
|
.last())
|
|
if not last_statement or last_statement.at < ope.group.at:
|
|
if ope.type == Operation.PURCHASE:
|
|
if ope.group.on_acc.is_cash:
|
|
to_checkouts_balances[ope.group.checkout] -= - ope.amount
|
|
else:
|
|
to_checkouts_balances[ope.group.checkout] -= ope.amount
|
|
|
|
# Pour les stocks d'articles
|
|
# Les stocks d'articles dont il y a eu un inventaire depuis la date
|
|
# de la commande ne doivent pas être modifiés
|
|
# TODO : Prendre en compte le dernier inventaire où le stock a bien
|
|
# été compté (pas dans le cas d'une livraison).
|
|
# Note : si InventoryArticle est maj par .save(), stock_error
|
|
# est recalculé automatiquement
|
|
if ope.article and ope.article_nb:
|
|
last_stock = (InventoryArticle.objects
|
|
.select_related('inventory')
|
|
.filter(article=ope.article)
|
|
.order_by('inventory__at')
|
|
.last())
|
|
if not last_stock or last_stock.inventory.at < ope.group.at:
|
|
to_articles_stocks[ope.article] += ope.article_nb
|
|
|
|
if not opes:
|
|
data['warnings']['already_canceled'] = opes_already_canceled
|
|
return JsonResponse(data)
|
|
|
|
negative_accounts = []
|
|
# Checking permissions or stop
|
|
for account in to_accounts_balances:
|
|
(perms, stop) = account.perms_to_perform_operation(
|
|
amount = to_accounts_balances[account])
|
|
required_perms |= perms
|
|
stop_all = stop_all or stop
|
|
if stop:
|
|
negative_accounts.append(account.trigramme)
|
|
|
|
if stop_all or not request.user.has_perms(required_perms):
|
|
missing_perms = get_missing_perms(required_perms, request.user)
|
|
if missing_perms:
|
|
data['errors']['missing_perms'] = missing_perms
|
|
if stop_all:
|
|
data['errors']['negative'] = negative_accounts
|
|
return JsonResponse(data, status=403)
|
|
|
|
canceled_by = required_perms and request.user.profile.account_kfet or None
|
|
canceled_at = timezone.now()
|
|
|
|
with transaction.atomic():
|
|
(Operation.objects.filter(pk__in=opes)
|
|
.update(canceled_by=canceled_by, canceled_at=canceled_at))
|
|
for account in to_accounts_balances:
|
|
Account.objects.filter(pk=account.pk).update(
|
|
balance = F('balance') + to_accounts_balances[account])
|
|
for checkout in to_checkouts_balances:
|
|
Checkout.objects.filter(pk=checkout.pk).update(
|
|
balance = F('balance') + to_checkouts_balances[checkout])
|
|
for group in to_groups_amounts:
|
|
OperationGroup.objects.filter(pk=group.pk).update(
|
|
amount = F('amount') + to_groups_amounts[group])
|
|
for article in to_articles_stocks:
|
|
Article.objects.filter(pk=article.pk).update(
|
|
stock = F('stock') + to_articles_stocks[article])
|
|
|
|
# Websocket data
|
|
websocket_data = { 'opegroups': [], 'opes': [], 'checkouts': [], 'articles': [] }
|
|
# Need refresh from db cause we used update on querysets
|
|
opegroups_pk = [ opegroup.pk for opegroup in to_groups_amounts ]
|
|
opegroups = (OperationGroup.objects
|
|
.values('id','amount','is_cof').filter(pk__in=opegroups_pk))
|
|
for opegroup in opegroups:
|
|
websocket_data['opegroups'].append({
|
|
'cancellation': True,
|
|
'id': opegroup['id'],
|
|
'amount': opegroup['amount'],
|
|
'is_cof': opegroup['is_cof'],
|
|
})
|
|
canceled_by__trigramme = canceled_by and canceled_by.trigramme or None
|
|
for ope in opes:
|
|
websocket_data['opes'].append({
|
|
'cancellation': True,
|
|
'id': ope,
|
|
'canceled_by__trigramme': canceled_by__trigramme,
|
|
'canceled_at': canceled_at,
|
|
})
|
|
# Need refresh from db cause we used update on querysets
|
|
checkouts_pk = [ checkout.pk for checkout in to_checkouts_balances]
|
|
checkouts = (Checkout.objects
|
|
.values('id', 'balance').filter(pk__in=checkouts_pk))
|
|
for checkout in checkouts:
|
|
websocket_data['checkouts'].append({
|
|
'id': checkout['id'],
|
|
'balance': checkout['balance']})
|
|
# Need refresh from db cause we used update on querysets
|
|
articles_pk = [ article.pk for articles in to_articles_stocks]
|
|
articles = Article.objects.values('id', 'stock').filter(pk__in=articles_pk)
|
|
for article in articles:
|
|
websocket_data['articles'].append({
|
|
'id': article['id'],
|
|
'stock': article['stock']})
|
|
consumers.KPsul.group_send('kfet.kpsul', websocket_data)
|
|
|
|
data['canceled'] = opes
|
|
if opes_already_canceled:
|
|
data['warnings']['already_canceled'] = opes_already_canceled
|
|
return JsonResponse(data)
|
|
|
|
@login_required
|
|
def history_json(request):
|
|
# Récupération des paramètres
|
|
from_date = request.POST.get('from', None)
|
|
to_date = request.POST.get('to', None)
|
|
limit = request.POST.get('limit', None);
|
|
checkouts = request.POST.getlist('checkouts[]', None)
|
|
accounts = request.POST.getlist('accounts[]', None)
|
|
|
|
# Construction de la requête (sur les opérations) pour le prefetch
|
|
queryset_prefetch = Operation.objects.select_related(
|
|
'canceled_by__trigramme', 'addcost_for__trigramme',
|
|
'article__name')
|
|
|
|
# Construction de la requête principale
|
|
opegroups = (OperationGroup.objects
|
|
.prefetch_related(Prefetch('opes', queryset = queryset_prefetch))
|
|
.select_related('on_acc__trigramme', 'valid_by__trigramme')
|
|
.order_by('at')
|
|
)
|
|
# Application des filtres
|
|
if from_date:
|
|
opegroups = opegroups.filter(at__gte=from_date)
|
|
if to_date:
|
|
opegroups = opegroups.filter(at__lt=to_date)
|
|
if checkouts:
|
|
opegroups = opegroups.filter(checkout_id__in=checkouts)
|
|
if accounts:
|
|
opegroups = opegroups.filter(on_acc_id__in=accounts)
|
|
# Un non-membre de l'équipe n'a que accès à son historique
|
|
if not request.user.has_perm('kfet.is_team'):
|
|
opegroups = opegroups.filter(on_acc=request.user.profile.account_kfet)
|
|
if limit:
|
|
opegroups = opegroups[:limit]
|
|
|
|
|
|
# Construction de la réponse
|
|
opegroups_list = []
|
|
for opegroup in opegroups:
|
|
opegroup_dict = {
|
|
'id' : opegroup.id,
|
|
'amount' : opegroup.amount,
|
|
'at' : opegroup.at,
|
|
'checkout_id': opegroup.checkout_id,
|
|
'is_cof' : opegroup.is_cof,
|
|
'comment' : opegroup.comment,
|
|
'opes' : [],
|
|
'on_acc__trigramme':
|
|
opegroup.on_acc and opegroup.on_acc.trigramme or None,
|
|
}
|
|
if request.user.has_perm('kfet.is_team'):
|
|
opegroup_dict['valid_by__trigramme'] = (
|
|
opegroup.valid_by and opegroup.valid_by.trigramme or None)
|
|
for ope in opegroup.opes.all():
|
|
ope_dict = {
|
|
'id' : ope.id,
|
|
'type' : ope.type,
|
|
'amount' : ope.amount,
|
|
'article_nb' : ope.article_nb,
|
|
'is_checkout' : ope.is_checkout,
|
|
'addcost_amount': ope.addcost_amount,
|
|
'canceled_at' : ope.canceled_at,
|
|
'article__name':
|
|
ope.article and ope.article.name or None,
|
|
'addcost_for__trigramme':
|
|
ope.addcost_for and ope.addcost_for.trigramme or None,
|
|
}
|
|
if request.user.has_perm('kfet.is_team'):
|
|
ope_dict['canceled_by__trigramme'] = (
|
|
ope.canceled_by and ope.canceled_by.trigramme or None)
|
|
opegroup_dict['opes'].append(ope_dict)
|
|
opegroups_list.append(opegroup_dict)
|
|
return JsonResponse({ 'opegroups': opegroups_list })
|
|
|
|
@teamkfet_required
|
|
def kpsul_articles_data(request):
|
|
articles = (
|
|
Article.objects
|
|
.values('id', 'name', 'price', 'stock', 'category_id', 'category__name')
|
|
.filter(is_sold=True))
|
|
return JsonResponse({ 'articles': list(articles) })
|
|
|
|
@teamkfet_required
|
|
def history(request):
|
|
data = {
|
|
'filter_form': FilterHistoryForm(),
|
|
'settings': {
|
|
'subvention_cof': Settings.SUBVENTION_COF(),
|
|
}
|
|
}
|
|
return render(request, 'kfet/history.html', data)
|
|
|
|
# -----
|
|
# Settings views
|
|
# -----
|
|
|
|
class SettingsList(ListView):
|
|
model = Settings
|
|
context_object_name = 'settings'
|
|
template_name = 'kfet/settings.html'
|
|
|
|
def get_context_data(self, **kwargs):
|
|
Settings.create_missing()
|
|
return super(SettingsList, self).get_context_data(**kwargs)
|
|
|
|
class SettingsUpdate(SuccessMessageMixin, UpdateView):
|
|
model = Settings
|
|
form_class = SettingsForm
|
|
template_name = 'kfet/settings_update.html'
|
|
success_message = 'Paramètre %(name)s mis à jour'
|
|
success_url = reverse_lazy('kfet.settings')
|
|
|
|
def form_valid(self, form):
|
|
# Checking permission
|
|
if not self.request.user.has_perm('kfet.change_settings'):
|
|
form.add_error(None, 'Permission refusée')
|
|
return self.form_invalid(form)
|
|
# Creating
|
|
Settings.empty_cache()
|
|
return super(SettingsUpdate, self).form_valid(form)
|
|
|
|
# -----
|
|
# Transfer views
|
|
# -----
|
|
|
|
@teamkfet_required
|
|
def transfers(request):
|
|
transfergroups = (TransferGroup.objects
|
|
.prefetch_related('transfers')
|
|
.order_by('-at'))
|
|
return render(request, 'kfet/transfers.html', {
|
|
'transfergroups': transfergroups,
|
|
})
|
|
|
|
@teamkfet_required
|
|
def transfers_create(request):
|
|
transfer_formset = TransferFormSet(queryset=Transfer.objects.none())
|
|
return render(request, 'kfet/transfers_create.html',
|
|
{ 'transfer_formset': transfer_formset })
|
|
|
|
@teamkfet_required
|
|
def perform_transfers(request):
|
|
data = { 'errors': {}, 'transfers': [], 'transfergroup': 0 }
|
|
|
|
# Checking transfer_formset
|
|
transfer_formset = TransferFormSet(request.POST)
|
|
if not transfer_formset.is_valid():
|
|
return JsonResponse({ 'errors': list(transfer_formset.errors)}, status=400)
|
|
|
|
transfers = transfer_formset.save(commit = False)
|
|
|
|
# Initializing vars
|
|
required_perms = set(['kfet.add_transfer']) # Required perms to perform all transfers
|
|
to_accounts_balances = defaultdict(lambda:0) # For balances of accounts
|
|
|
|
for transfer in transfers:
|
|
to_accounts_balances[transfer.from_acc] -= transfer.amount
|
|
to_accounts_balances[transfer.to_acc] += transfer.amount
|
|
|
|
stop_all = False
|
|
|
|
negative_accounts = []
|
|
# Checking if ok on all accounts
|
|
for account in to_accounts_balances:
|
|
(perms, stop) = account.perms_to_perform_operation(
|
|
amount = to_accounts_balances[account])
|
|
required_perms |= perms
|
|
stop_all = stop_all or stop
|
|
if stop:
|
|
negative_accounts.append(account.trigramme)
|
|
|
|
if stop_all or not request.user.has_perms(required_perms):
|
|
missing_perms = get_missing_perms(required_perms, request.user)
|
|
if missing_perms:
|
|
data['errors']['missing_perms'] = missing_perms
|
|
if stop_all:
|
|
data['errors']['negative'] = negative_accounts
|
|
return JsonResponse(data, status=403)
|
|
|
|
# Creating transfer group
|
|
transfergroup = TransferGroup()
|
|
if required_perms:
|
|
transfergroup.valid_by = request.user.profile.account_kfet
|
|
|
|
comment = request.POST.get('comment', '')
|
|
transfergroup.comment = comment.strip()
|
|
|
|
with transaction.atomic():
|
|
# Updating balances accounts
|
|
for account in to_accounts_balances:
|
|
Account.objects.filter(pk=account.pk).update(
|
|
balance = F('balance') + to_accounts_balances[account])
|
|
account.refresh_from_db()
|
|
if account.balance < 0:
|
|
if hasattr(account, 'negative'):
|
|
if not account.negative.start:
|
|
account.negative.start = timezone.now()
|
|
account.negative.save()
|
|
else:
|
|
negative = AccountNegative(
|
|
account = account, start = timezone.now())
|
|
negative.save()
|
|
elif (hasattr(account, 'negative')
|
|
and not account.negative.balance_offset):
|
|
account.negative.delete()
|
|
|
|
# Saving transfer group
|
|
transfergroup.save()
|
|
data['transfergroup'] = transfergroup.pk
|
|
|
|
# Saving all transfers with group
|
|
for transfer in transfers:
|
|
transfer.group = transfergroup
|
|
transfer.save()
|
|
data['transfers'].append(transfer.pk)
|
|
|
|
return JsonResponse(data)
|
|
|
|
@teamkfet_required
|
|
def cancel_transfers(request):
|
|
# Pour la réponse
|
|
data = { 'canceled': [], 'warnings': {}, 'errors': {}}
|
|
|
|
# Checking if BAD REQUEST (transfers_pk not int or not existing)
|
|
try:
|
|
# Set pour virer les doublons
|
|
transfers_post = set(map(int, filter(None, request.POST.getlist('transfers[]', []))))
|
|
except ValueError:
|
|
return JsonResponse(data, status=400)
|
|
transfers_all = (
|
|
Transfer.objects
|
|
.select_related('group', 'from_acc', 'from_acc__negative',
|
|
'to_acc', 'to_acc__negative')
|
|
.filter(pk__in=transfers_post))
|
|
transfers_pk = [ transfer.pk for transfer in transfers_all ]
|
|
transfers_notexisting = [ transfer for transfer in transfers_post
|
|
if transfer not in transfers_pk ]
|
|
if transfers_notexisting:
|
|
data['errors']['transfers_notexisting'] = transfers_notexisting
|
|
return JsonResponse(data, status=400)
|
|
|
|
transfers_already_canceled = [] # Déjà annulée
|
|
transfers = [] # Pas déjà annulée
|
|
required_perms = set()
|
|
stop_all = False
|
|
cancel_duration = Settings.CANCEL_DURATION()
|
|
to_accounts_balances = defaultdict(lambda:0) # Modifs à faire sur les balances des comptes
|
|
for transfer in transfers_all:
|
|
if transfer.canceled_at:
|
|
# Transfert déjà annulé, va pour un warning en Response
|
|
transfers_already_canceled.append(transfer.pk)
|
|
else:
|
|
transfers.append(transfer.pk)
|
|
# Si transfer il y a plus de CANCEL_DURATION, permission requise
|
|
if transfer.group.at + cancel_duration < timezone.now():
|
|
required_perms.add('kfet.cancel_old_operations')
|
|
|
|
# Calcul de toutes modifs à faire en cas de validation
|
|
|
|
# Pour les balances de comptes
|
|
to_accounts_balances[transfer.from_acc] += transfer.amount
|
|
to_accounts_balances[transfer.to_acc] += -transfer.amount
|
|
|
|
if not transfers:
|
|
data['warnings']['already_canceled'] = transfers_already_canceled
|
|
return JsonResponse(data)
|
|
|
|
negative_accounts = []
|
|
# Checking permissions or stop
|
|
for account in to_accounts_balances:
|
|
(perms, stop) = account.perms_to_perform_operation(
|
|
amount = to_accounts_balances[account])
|
|
required_perms |= perms
|
|
stop_all = stop_all or stop
|
|
if stop:
|
|
negative_accounts.append(account.trigramme)
|
|
|
|
print(required_perms)
|
|
print(request.user.get_all_permissions())
|
|
|
|
if stop_all or not request.user.has_perms(required_perms):
|
|
missing_perms = get_missing_perms(required_perms, request.user)
|
|
if missing_perms:
|
|
data['errors']['missing_perms'] = missing_perms
|
|
if stop_all:
|
|
data['errors']['negative'] = negative_accounts
|
|
return JsonResponse(data, status=403)
|
|
|
|
canceled_by = required_perms and request.user.profile.account_kfet or None
|
|
canceled_at = timezone.now()
|
|
|
|
with transaction.atomic():
|
|
(Transfer.objects.filter(pk__in=transfers)
|
|
.update(canceled_by=canceled_by, canceled_at=canceled_at))
|
|
|
|
for account in to_accounts_balances:
|
|
Account.objects.filter(pk=account.pk).update(
|
|
balance = F('balance') + to_accounts_balances[account])
|
|
account.refresh_from_db()
|
|
if account.balance < 0:
|
|
if hasattr(account, 'negative'):
|
|
if not account.negative.start:
|
|
account.negative.start = timezone.now()
|
|
account.negative.save()
|
|
else:
|
|
negative = AccountNegative(
|
|
account = account, start = timezone.now())
|
|
negative.save()
|
|
elif (hasattr(account, 'negative')
|
|
and not account.negative.balance_offset):
|
|
account.negative.delete()
|
|
|
|
data['canceled'] = transfers
|
|
if transfers_already_canceled:
|
|
data['warnings']['already_canceled'] = transfers_already_canceled
|
|
return JsonResponse(data)
|
|
|
|
class InventoryList(ListView):
|
|
queryset = (Inventory.objects
|
|
.select_related('by', 'order')
|
|
.annotate(nb_articles=Count('articles'))
|
|
.order_by('-at'))
|
|
template_name = 'kfet/inventory.html'
|
|
context_object_name = 'inventories'
|
|
|
|
@teamkfet_required
|
|
def inventory_create(request):
|
|
|
|
articles = (Article.objects
|
|
.select_related('category')
|
|
.order_by('category__name', 'name')
|
|
)
|
|
initial = []
|
|
for article in articles:
|
|
initial.append({
|
|
'article' : article.pk,
|
|
'stock_old': article.stock,
|
|
'name' : article.name,
|
|
'category' : article.category_id,
|
|
'category__name': article.category.name
|
|
})
|
|
|
|
cls_formset = formset_factory(
|
|
form = InventoryArticleForm,
|
|
extra = 0,
|
|
)
|
|
|
|
if request.POST:
|
|
formset = cls_formset(request.POST, initial=initial)
|
|
|
|
if not request.user.has_perm('kfet.add_inventory'):
|
|
messages.error(request, 'Permission refusée')
|
|
elif formset.is_valid():
|
|
with transaction.atomic():
|
|
|
|
articles = Article.objects.select_for_update()
|
|
inventory = Inventory()
|
|
inventory.by = request.user.profile.account_kfet
|
|
saved = False
|
|
for form in formset:
|
|
if form.cleaned_data['stock_new'] is not None:
|
|
if not saved:
|
|
inventory.save()
|
|
saved = True
|
|
|
|
article = articles.get(pk=form.cleaned_data['article'].pk)
|
|
stock_old = article.stock
|
|
stock_new = form.cleaned_data['stock_new']
|
|
InventoryArticle.objects.create(
|
|
inventory = inventory,
|
|
article = article,
|
|
stock_old = stock_old,
|
|
stock_new = stock_new)
|
|
article.stock = stock_new
|
|
article.save()
|
|
if saved:
|
|
messages.success(request, 'Inventaire créé')
|
|
return redirect('kfet.inventory')
|
|
messages.warning(request, 'Bah alors ? On a rien compté ?')
|
|
else:
|
|
messages.error(request, 'Pas marché')
|
|
else:
|
|
formset = cls_formset(initial = initial)
|
|
|
|
return render(request, 'kfet/inventory_create.html', {
|
|
'formset': formset,
|
|
})
|
|
|
|
class InventoryRead(DetailView):
|
|
model = Inventory
|
|
template_name = 'kfet/inventory_read.html'
|
|
context_object_name = 'inventory'
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(InventoryRead, self).get_context_data(**kwargs)
|
|
inventoryarticles = (InventoryArticle.objects
|
|
.select_related('article', 'article__category')
|
|
.filter(inventory = self.object)
|
|
.order_by('article__category__name', 'article__name'))
|
|
context['inventoryarts'] = inventoryarticles
|
|
return context
|
|
|
|
# -----
|
|
# Order views
|
|
# -----
|
|
|
|
class OrderList(ListView):
|
|
queryset = Order.objects.select_related('supplier', 'inventory')
|
|
template_name = 'kfet/order.html'
|
|
context_object_name = 'orders'
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(OrderList, self).get_context_data(**kwargs)
|
|
context['suppliers'] = Supplier.objects.order_by('name')
|
|
return context
|
|
|
|
@teamkfet_required
|
|
def order_create(request, pk):
|
|
supplier = get_object_or_404(Supplier, pk=pk)
|
|
|
|
articles = (Article.objects
|
|
.filter(suppliers=supplier.pk)
|
|
.distinct()
|
|
.select_related('category')
|
|
.order_by('category__name', 'name'))
|
|
|
|
initial = []
|
|
today = timezone.now().date()
|
|
sales_q = (Operation.objects
|
|
.select_related('group')
|
|
.filter(article__in=articles, canceled_at=None)
|
|
.values('article'))
|
|
sales_s1 = (sales_q
|
|
.filter(
|
|
group__at__gte = today-timedelta(weeks=5),
|
|
group__at__lt = today-timedelta(weeks=4))
|
|
.annotate(nb=Sum('article_nb'))
|
|
)
|
|
sales_s1 = { d['article']:d['nb'] for d in sales_s1 }
|
|
sales_s2 = (sales_q
|
|
.filter(
|
|
group__at__gte = today-timedelta(weeks=4),
|
|
group__at__lt = today-timedelta(weeks=3))
|
|
.annotate(nb=Sum('article_nb'))
|
|
)
|
|
sales_s2 = { d['article']:d['nb'] for d in sales_s2 }
|
|
sales_s3 = (sales_q
|
|
.filter(
|
|
group__at__gte = today-timedelta(weeks=3),
|
|
group__at__lt = today-timedelta(weeks=2))
|
|
.annotate(nb=Sum('article_nb'))
|
|
)
|
|
sales_s3 = { d['article']:d['nb'] for d in sales_s3 }
|
|
sales_s4 = (sales_q
|
|
.filter(
|
|
group__at__gte = today-timedelta(weeks=2),
|
|
group__at__lt = today-timedelta(weeks=1))
|
|
.annotate(nb=Sum('article_nb'))
|
|
)
|
|
sales_s4 = { d['article']:d['nb'] for d in sales_s4 }
|
|
sales_s5 = (sales_q
|
|
.filter(group__at__gte = today-timedelta(weeks=1))
|
|
.annotate(nb=Sum('article_nb'))
|
|
)
|
|
sales_s5 = { d['article']:d['nb'] for d in sales_s5 }
|
|
|
|
for article in articles:
|
|
v_s1 = sales_s1.get(article.pk, 0)
|
|
v_s2 = sales_s2.get(article.pk, 0)
|
|
v_s3 = sales_s3.get(article.pk, 0)
|
|
v_s4 = sales_s4.get(article.pk, 0)
|
|
v_s5 = sales_s5.get(article.pk, 0)
|
|
v_all = [v_s1, v_s2, v_s3, v_s4, v_s5]
|
|
v_3max = heapq.nlargest(3, v_all)
|
|
v_moy = statistics.mean(v_3max)
|
|
v_et = statistics.pstdev(v_3max, v_moy)
|
|
v_prev = v_moy + v_et
|
|
c_rec_tot = max(v_prev * 1.5 - article.stock, 0)
|
|
if article.box_capacity:
|
|
c_rec_temp = c_rec_tot / article.box_capacity
|
|
if c_rec_temp >= 10:
|
|
c_rec = round(c_rec_temp)
|
|
elif c_rec_temp > 5:
|
|
c_rec = 10
|
|
elif c_rec_temp > 2:
|
|
c_rec = 5
|
|
else:
|
|
c_rec = round(c_rec_temp)
|
|
initial.append({
|
|
'article': article.pk,
|
|
'name': article.name,
|
|
'category': article.category_id,
|
|
'category__name': article.category.name,
|
|
'stock': article.stock,
|
|
'box_capacity': article.box_capacity,
|
|
'v_s1': v_s1,
|
|
'v_s2': v_s2,
|
|
'v_s3': v_s3,
|
|
'v_s4': v_s4,
|
|
'v_s5': v_s5,
|
|
'v_moy': round(v_moy),
|
|
'v_et': round(v_et),
|
|
'v_prev': round(v_prev),
|
|
'c_rec': article.box_capacity and c_rec or round(c_rec_tot),
|
|
})
|
|
|
|
cls_formset = formset_factory(
|
|
form = OrderArticleForm,
|
|
extra = 0)
|
|
|
|
if request.POST:
|
|
formset = cls_formset(request.POST, initial=initial)
|
|
|
|
if not request.user.has_perm('kfet.add_order'):
|
|
messages.error(request, 'Permission refusée')
|
|
elif formset.is_valid():
|
|
order = Order()
|
|
order.supplier = supplier
|
|
saved = False
|
|
for form in formset:
|
|
if form.cleaned_data['quantity_ordered'] is not None:
|
|
if not saved:
|
|
order.save()
|
|
saved = True
|
|
|
|
article = articles.get(pk=form.cleaned_data['article'].pk)
|
|
q_ordered = form.cleaned_data['quantity_ordered']
|
|
if article.box_capacity:
|
|
q_ordered *= article.box_capacity
|
|
OrderArticle.objects.create(
|
|
order = order,
|
|
article = article,
|
|
quantity_ordered = q_ordered)
|
|
if saved:
|
|
messages.success(request, 'Commande créée')
|
|
return redirect('kfet.order.read', order.pk)
|
|
messages.warning(request, 'Rien commandé => Pas de commande')
|
|
else:
|
|
messages.error(request, 'Corrigez les erreurs')
|
|
else:
|
|
formset = cls_formset(initial=initial)
|
|
|
|
return render(request, 'kfet/order_create.html', {
|
|
'supplier': supplier,
|
|
'formset' : formset,
|
|
})
|
|
|
|
class OrderRead(DetailView):
|
|
model = Order
|
|
template_name = 'kfet/order_read.html'
|
|
context_object_name = 'order'
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(OrderRead, self).get_context_data(**kwargs)
|
|
orderarticles = (OrderArticle.objects
|
|
.select_related('article', 'article__category')
|
|
.filter(order=self.object)
|
|
.order_by('article__category__name', 'article__name')
|
|
)
|
|
context['orderarts'] = orderarticles
|
|
mail = ("Bonjour,\n\nNous voudrions pour le ##DATE## à la K-Fêt de "
|
|
"l'ENS Ulm :")
|
|
category = 0
|
|
for orderarticle in orderarticles:
|
|
if category != orderarticle.article.category:
|
|
category = orderarticle.article.category
|
|
mail += '\n'
|
|
nb = orderarticle.quantity_ordered
|
|
box = ''
|
|
if orderarticle.article.box_capacity:
|
|
nb /= orderarticle.article.box_capacity
|
|
if nb >= 2:
|
|
box = ' %ss de' % orderarticle.article.box_type
|
|
else:
|
|
box = ' %s de' % orderarticle.article.box_type
|
|
name = orderarticle.article.name.capitalize()
|
|
mail += "\n- %s%s %s" % (round(nb), box, name)
|
|
|
|
mail += ("\n\nMerci d'appeler le numéro suivant lorsque les livreurs "
|
|
"sont là : ##TELEPHONE##\nCordialement,\n##PRENOM## ##NOM## "
|
|
", pour la K-Fêt de l'ENS Ulm")
|
|
|
|
context['mail'] = mail
|
|
return context
|
|
|
|
@teamkfet_required
|
|
def order_to_inventory(request, pk):
|
|
order = get_object_or_404(Order, pk=pk)
|
|
|
|
if hasattr(order, 'inventory'):
|
|
raise Http404
|
|
|
|
articles = (Article.objects
|
|
.filter(orders=order.pk)
|
|
.select_related('category')
|
|
.prefetch_related(Prefetch('orderarticle_set',
|
|
queryset = OrderArticle.objects.filter(order=order),
|
|
to_attr = 'order'))
|
|
.prefetch_related(Prefetch('supplierarticle_set',
|
|
queryset = (SupplierArticle.objects
|
|
.filter(supplier=order.supplier)
|
|
.order_by('-at')),
|
|
to_attr = 'supplier'))
|
|
.order_by('category__name', 'name'))
|
|
|
|
initial = []
|
|
for article in articles:
|
|
initial.append({
|
|
'article': article.pk,
|
|
'name': article.name,
|
|
'category': article.category_id,
|
|
'category__name': article.category.name,
|
|
'quantity_ordered': article.order[0].quantity_ordered,
|
|
'quantity_received': article.order[0].quantity_ordered,
|
|
'price_HT': article.supplier[0].price_HT,
|
|
'TVA': article.supplier[0].TVA,
|
|
'rights': article.supplier[0].rights,
|
|
})
|
|
|
|
cls_formset = formset_factory(OrderArticleToInventoryForm, extra=0)
|
|
|
|
if request.method == 'POST':
|
|
formset = cls_formset(request.POST, initial=initial)
|
|
|
|
if not request.user.has_perm('kfet.order_to_inventory'):
|
|
messages.error(request, 'Permission refusée')
|
|
elif formset.is_valid():
|
|
with transaction.atomic():
|
|
inventory = Inventory()
|
|
inventory.order = order
|
|
inventory.by = request.user.profile.account_kfet
|
|
inventory.save()
|
|
for form in formset:
|
|
q_received = form.cleaned_data['quantity_received']
|
|
article = form.cleaned_data['article']
|
|
SupplierArticle.objects.create(
|
|
supplier = order.supplier,
|
|
article = article,
|
|
price_HT = form.cleaned_data['price_HT'],
|
|
TVA = form.cleaned_data['TVA'],
|
|
rights = form.cleaned_data['rights'])
|
|
(OrderArticle.objects
|
|
.filter(order=order, article=article)
|
|
.update(quantity_received = q_received))
|
|
InventoryArticle.objects.create(
|
|
inventory = inventory,
|
|
article = article,
|
|
stock_old = article.stock,
|
|
stock_new = article.stock + q_received)
|
|
article.stock += q_received
|
|
if q_received > 0:
|
|
article.is_sold = True
|
|
article.save()
|
|
messages.success(request, "C'est tout bon !")
|
|
return redirect('kfet.order')
|
|
else:
|
|
messages.error(request, "Corrigez les erreurs")
|
|
else:
|
|
formset = cls_formset(initial=initial)
|
|
|
|
return render(request, 'kfet/order_to_inventory.html', {
|
|
'formset': formset,
|
|
})
|
|
|
|
class SupplierUpdate(SuccessMessageMixin, UpdateView):
|
|
model = Supplier
|
|
template_name = 'kfet/supplier_form.html'
|
|
fields = ['name', 'address', 'email', 'phone', 'comment']
|
|
success_url = reverse_lazy('kfet.order')
|
|
sucess_message = 'Données fournisseur mis à jour'
|
|
|
|
# Surcharge de la validation
|
|
def form_valid(self, form):
|
|
# Checking permission
|
|
if not self.request.user.has_perm('kfet.change_supplier'):
|
|
form.add_error(None, 'Permission refusée')
|
|
return self.form_invalid(form)
|
|
# Updating
|
|
return super(SupplierUpdate, self).form_valid(form)
|
|
|
|
|
|
# ==========
|
|
# Statistics
|
|
# ==========
|
|
|
|
# ---------------
|
|
# Vues génériques
|
|
# ---------------
|
|
# source : docs.djangoproject.com/fr/1.10/topics/class-based-views/mixins/
|
|
class JSONResponseMixin(object):
|
|
"""
|
|
A mixin that can be used to render a JSON response.
|
|
"""
|
|
def render_to_json_response(self, context, **response_kwargs):
|
|
"""
|
|
Returns a JSON response, transforming 'context' to make the payload.
|
|
"""
|
|
return JsonResponse(
|
|
self.get_data(context),
|
|
**response_kwargs
|
|
)
|
|
|
|
def get_data(self, context):
|
|
"""
|
|
Returns an object that will be serialized as JSON by json.dumps().
|
|
"""
|
|
# Note: This is *EXTREMELY* naive; in reality, you'll need
|
|
# to do much more complex handling to ensure that arbitrary
|
|
# objects -- such as Django model instances or querysets
|
|
# -- can be serialized as JSON.
|
|
return context
|
|
|
|
|
|
class JSONDetailView(JSONResponseMixin,
|
|
BaseDetailView):
|
|
"""
|
|
Returns a DetailView that renders a JSON
|
|
"""
|
|
def render_to_response(self, context):
|
|
return self.render_to_json_response(context)
|
|
|
|
class HybridDetailView(JSONResponseMixin,
|
|
SingleObjectTemplateResponseMixin,
|
|
BaseDetailView):
|
|
"""
|
|
Returns a DetailView as an html page except if a JSON file is requested
|
|
by the GET method in which case it returns a JSON response.
|
|
"""
|
|
def render_to_response(self, context):
|
|
# Look for a 'format=json' GET argument
|
|
if self.request.GET.get('format') == 'json':
|
|
return self.render_to_json_response(context)
|
|
else:
|
|
return super(HybridDetailView, self).render_to_response(context)
|
|
|
|
|
|
class HybridListView(JSONResponseMixin,
|
|
MultipleObjectTemplateResponseMixin,
|
|
BaseListView):
|
|
"""
|
|
Returns a ListView as an html page except if a JSON file is requested
|
|
by the GET method in which case it returns a JSON response.
|
|
"""
|
|
def render_to_response(self, context):
|
|
# Look for a 'format=json' GET argument
|
|
if self.request.GET.get('format') == 'json':
|
|
return self.render_to_json_response(context)
|
|
else:
|
|
return super(HybridListView, self).render_to_response(context)
|
|
|
|
|
|
class ObjectResumeStat(JSONDetailView):
|
|
"""
|
|
Summarize all the stats of an object
|
|
Handles JSONResponse
|
|
"""
|
|
context_object_name = ''
|
|
id_prefix = ''
|
|
# nombre de vues à résumer
|
|
nb_stat = 2
|
|
# Le combienième est celui par defaut ?
|
|
# (entre 0 et nb_stat-1)
|
|
nb_default = 0
|
|
stat_labels = ['stat_1', 'stat_2']
|
|
stat_urls = ['url_1', 'url_2']
|
|
|
|
# sert à renverser les urls
|
|
# utile de le surcharger quand l'url prend d'autres arguments que l'id
|
|
def get_object_url_kwargs(self, **kwargs):
|
|
return {'pk': self.object.id}
|
|
|
|
def url_kwargs(self, **kwargs):
|
|
return [{}] * self.nb_stat
|
|
|
|
def get_context_data(self, **kwargs):
|
|
# On n'hérite pas
|
|
object_id = self.object.id
|
|
url_kwargs = self.url_kwargs()
|
|
context = {}
|
|
stats = {}
|
|
for i in range(self.nb_stat):
|
|
stats[i] = {
|
|
'label': self.stat_labels[i],
|
|
'btn': "btn_%s_%d_%d" % (self.id_prefix,
|
|
object_id,
|
|
i),
|
|
'url': reverse(self.stat_urls[i],
|
|
kwargs=dict(
|
|
self.get_object_url_kwargs(),
|
|
**url_kwargs[i]
|
|
),
|
|
),
|
|
}
|
|
prefix = "%s_%d" % (self.id_prefix, object_id)
|
|
context['id_prefix'] = prefix
|
|
context['content_id'] = "content_%s" % prefix
|
|
context['stats'] = stats
|
|
context['default_stat'] = self.nb_default
|
|
context['object_id'] = object_id
|
|
return context
|
|
|
|
|
|
# -----------------------
|
|
# Evolution Balance perso
|
|
# -----------------------
|
|
ID_PREFIX_ACC_BALANCE = "balance_acc"
|
|
|
|
|
|
# Un résumé de toutes les vues ArticleStatBalance
|
|
# REND DU JSON
|
|
class AccountStatBalanceAll(ObjectResumeStat):
|
|
model = Account
|
|
context_object_name = 'account'
|
|
trigramme_url_kwarg = 'trigramme'
|
|
id_prefix = ID_PREFIX_ACC_BALANCE
|
|
nb_stat = 5
|
|
nb_default = 0
|
|
stat_labels = ["Tout le temps", "1 an", "6 mois", "3 mois", "30 jours"]
|
|
stat_urls = ['kfet.account.stat.balance.anytime'] \
|
|
+ ['kfet.account.stat.balance.days'] * 4
|
|
|
|
def get_object(self, **kwargs):
|
|
trigramme = self.kwargs.get(self.trigramme_url_kwarg)
|
|
return get_object_or_404(Account, trigramme=trigramme)
|
|
|
|
def get_object_url_kwargs(self, **kwargs):
|
|
return {'trigramme': self.object.trigramme}
|
|
|
|
def url_kwargs(self, **kwargs):
|
|
context_list = (super(AccountStatBalanceAll, self)
|
|
.url_kwargs(**kwargs))
|
|
context_list[1] = {'nb_date': 365}
|
|
context_list[2] = {'nb_date': 183}
|
|
context_list[3] = {'nb_date': 90}
|
|
context_list[4] = {'nb_date': 30}
|
|
return context_list
|
|
|
|
@method_decorator(login_required)
|
|
def dispatch(self, *args, **kwargs):
|
|
return super(AccountStatBalanceAll, self).dispatch(*args, **kwargs)
|
|
|
|
|
|
class AccountStatBalance(JSONDetailView):
|
|
"""
|
|
Returns a JSON containing the evolution a the personnal
|
|
balance of a trigramme between timezone.now() and `nb_days`
|
|
ago (specified to the view as an argument)
|
|
takes into account the Operations and the Transfers
|
|
does not takes into account the balance offset
|
|
"""
|
|
model = Account
|
|
trigramme_url_kwarg = 'trigramme'
|
|
nb_date_url_kwargs = 'nb_date'
|
|
context_object_name = 'account'
|
|
id_prefix = ""
|
|
|
|
def get_object(self, **kwargs):
|
|
trigramme = self.kwargs.get(self.trigramme_url_kwarg)
|
|
return get_object_or_404(Account, trigramme=trigramme)
|
|
|
|
def get_changes_list(self, **kwargs):
|
|
account = self.object
|
|
nb_date = self.kwargs.get(self.nb_date_url_kwargs, None)
|
|
end_date = this_morning()
|
|
if nb_date is None:
|
|
begin_date = timezone.datetime(year=1980, month=1, day=1)
|
|
anytime = True
|
|
else:
|
|
begin_date = this_morning() \
|
|
- timezone.timedelta(days=int(nb_date))
|
|
anytime = False
|
|
# On récupère les opérations
|
|
# TODO: retirer les opgroup dont tous les op sont annulées
|
|
opgroups = list(OperationGroup.objects
|
|
.filter(on_acc=account)
|
|
.filter(at__gte=begin_date)
|
|
.filter(at__lte=end_date))
|
|
# On récupère les transferts reçus
|
|
received_transfers = list(Transfer.objects
|
|
.filter(to_acc=account)
|
|
.filter(canceled_at=None)
|
|
.filter(group__at__gte=begin_date)
|
|
.filter(group__at__lte=end_date))
|
|
# On récupère les transferts émis
|
|
emitted_transfers = list(Transfer.objects
|
|
.filter(from_acc=account)
|
|
.filter(canceled_at=None)
|
|
.filter(group__at__gte=begin_date)
|
|
.filter(group__at__lte=end_date))
|
|
# On transforme tout ça en une liste de dictionnaires sous la forme
|
|
# {'at': date,
|
|
# 'amount': changement de la balance (négatif si diminue la balance,
|
|
# positif si l'augmente),
|
|
# 'label': text descriptif,
|
|
# 'balance': état de la balance après l'action (0 pour le moment,
|
|
# sera mis à jour lors d'une
|
|
# autre passe)
|
|
# }
|
|
actions = [
|
|
# Maintenant (à changer si on gère autre chose que now)
|
|
{
|
|
'at': end_date.isoformat(),
|
|
'amout': 0,
|
|
'label': "actuel",
|
|
'balance': 0,
|
|
}
|
|
] + [
|
|
{
|
|
'at': op.at.isoformat(),
|
|
'amount': op.amount,
|
|
'label': str(op),
|
|
'balance': 0,
|
|
} for op in opgroups
|
|
] + [
|
|
{
|
|
'at': tr.group.at.isoformat(),
|
|
'amount': tr.amount,
|
|
'label': "%d€: %s -> %s" % (tr.amount,
|
|
tr.from_acc.trigramme,
|
|
tr.to_acc.trigramme),
|
|
'balance': 0,
|
|
} for tr in received_transfers
|
|
] + [
|
|
{
|
|
'at': tr.group.at.isoformat(),
|
|
'amount': -tr.amount,
|
|
'label': "%d€: %s -> %s" % (tr.amount,
|
|
tr.from_acc.trigramme,
|
|
tr.to_acc.trigramme),
|
|
'balance': 0,
|
|
} for tr in emitted_transfers
|
|
]
|
|
if not anytime:
|
|
actions += [
|
|
# Date de début :
|
|
{
|
|
'at': begin_date.isoformat(),
|
|
'amount': 0,
|
|
'label': "début",
|
|
'balance': 0,
|
|
}
|
|
]
|
|
# Maintenant on trie la liste des actions par ordre du plus récent
|
|
# an plus ancien et on met à jour la balance
|
|
actions = sorted(actions, key=lambda k: k['at'], reverse=True)
|
|
actions[0]['balance'] = account.balance
|
|
for i in range(len(actions)-1):
|
|
actions[i+1]['balance'] = actions[i]['balance'] \
|
|
- actions[i+1]['amount']
|
|
return actions
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = {}
|
|
changes = self.get_changes_list()
|
|
nb_days = self.kwargs.get(self.nb_date_url_kwargs, None)
|
|
if nb_days is None:
|
|
nb_days_string = 'anytime'
|
|
else:
|
|
nb_days_string = str(int(nb_days))
|
|
context['charts'] = [ { "color": "rgb(255, 99, 132)",
|
|
"label": "Balance",
|
|
"values": changes } ]
|
|
context['is_time_chart'] = True
|
|
context['min_date'] = changes[len(changes)-1]['at']
|
|
context['max_date'] = changes[0]['at']
|
|
# TODO: offset
|
|
return context
|
|
|
|
@method_decorator(login_required)
|
|
def dispatch(self, *args, **kwargs):
|
|
return super(AccountStatBalance, self).dispatch(*args, **kwargs)
|
|
|
|
|
|
# ------------------------
|
|
# Consommation personnelle
|
|
# ------------------------
|
|
ID_PREFIX_ACC_LAST = "last_acc"
|
|
ID_PREFIX_ACC_LAST_DAYS = "last_days_acc"
|
|
ID_PREFIX_ACC_LAST_WEEKS = "last_weeks_acc"
|
|
ID_PREFIX_ACC_LAST_MONTHS = "last_months_acc"
|
|
|
|
|
|
# Un résumé de toutes les vues ArticleStatLast
|
|
# NE REND PAS DE JSON
|
|
class AccountStatLastAll(ObjectResumeStat):
|
|
model = Account
|
|
context_object_name = 'account'
|
|
trigramme_url_kwarg = 'trigramme'
|
|
id_prefix = ID_PREFIX_ACC_LAST
|
|
nb_stat = 3
|
|
nb_default = 2
|
|
stat_labels = ["Derniers mois", "Dernières semaines", "Derniers jours"]
|
|
stat_urls = ['kfet.account.stat.last.month',
|
|
'kfet.account.stat.last.week',
|
|
'kfet.account.stat.last.day']
|
|
|
|
def get_object(self, **kwargs):
|
|
trigramme = self.kwargs.get(self.trigramme_url_kwarg)
|
|
return get_object_or_404(Account, trigramme=trigramme)
|
|
|
|
def get_object_url_kwargs(self, **kwargs):
|
|
return {'trigramme': self.object.trigramme}
|
|
|
|
@method_decorator(login_required)
|
|
def dispatch(self, *args, **kwargs):
|
|
return super(AccountStatLastAll, self).dispatch(*args, **kwargs)
|
|
|
|
|
|
class AccountStatLast(JSONDetailView):
|
|
"""
|
|
Returns a JSON containing the evolution a the personnal
|
|
consommation of a trigramme at the diffent dates specified
|
|
"""
|
|
model = Account
|
|
trigramme_url_kwarg = 'trigramme'
|
|
context_object_name = 'account'
|
|
end_date = timezone.now()
|
|
id_prefix = ""
|
|
|
|
# doit rendre un dictionnaire des dates
|
|
# la première date correspond au début
|
|
# la dernière date est la fin de la dernière plage
|
|
def get_dates(self, **kwargs):
|
|
return {}
|
|
|
|
# doit rendre un dictionnaire des labels
|
|
# le dernier label ne sera pas utilisé
|
|
def get_labels(self, **kwargs):
|
|
pass
|
|
|
|
def get_object(self, **kwargs):
|
|
trigramme = self.kwargs.get(self.trigramme_url_kwarg)
|
|
return get_object_or_404(Account, trigramme=trigramme)
|
|
|
|
def sort_operations(self, **kwargs):
|
|
# On récupère les dates
|
|
dates = self.get_dates()
|
|
# On ajoute la date de fin
|
|
extended_dates = dates.copy()
|
|
extended_dates[len(dates)+1] = self.end_date
|
|
# On selectionne les opérations qui correspondent
|
|
# à l'article en question et qui ne sont pas annulées
|
|
# puis on choisi pour chaques intervalle les opérations
|
|
# effectuées dans ces intervalles de temps
|
|
all_operations = (Operation.objects
|
|
.filter(type='purchase')
|
|
.filter(group__on_acc=self.object)
|
|
.filter(canceled_at=None)
|
|
)
|
|
operations = {}
|
|
for i in dates:
|
|
operations[i] = (all_operations
|
|
.filter(group__at__gte=extended_dates[i])
|
|
.filter(group__at__lte=extended_dates[i+1])
|
|
)
|
|
return operations
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = {}
|
|
nb_ventes = {}
|
|
# On récupère les labels des dates
|
|
context['labels'] = self.get_labels().copy()
|
|
# On compte les opérations
|
|
operations = self.sort_operations()
|
|
for i in operations:
|
|
nb_ventes[i] = tot_ventes(operations[i])
|
|
context['charts'] = [ { "color": "rgb(255, 99, 132)",
|
|
"label": "NB items achetés",
|
|
"values": nb_ventes } ]
|
|
return context
|
|
|
|
@method_decorator(login_required)
|
|
def dispatch(self, *args, **kwargs):
|
|
return super(AccountStatLast, self).dispatch(*args, **kwargs)
|
|
|
|
|
|
# Rend les achats pour ce compte des 7 derniers jours
|
|
# Aujourd'hui non compris
|
|
class AccountStatLastDay(AccountStatLast):
|
|
end_date = this_morning()
|
|
id_prefix = ID_PREFIX_ACC_LAST_DAYS
|
|
|
|
def get_dates(self, **kwargs):
|
|
return lastdays(7)
|
|
|
|
def get_labels(self, **kwargs):
|
|
days = lastdays(7)
|
|
return daynames(days)
|
|
|
|
|
|
# Rend les achats de ce compte des 7 dernières semaines
|
|
# La semaine en cours n'est pas comprise
|
|
class AccountStatLastWeek(AccountStatLast):
|
|
end_date = this_monday_morning()
|
|
id_prefix = ID_PREFIX_ACC_LAST_WEEKS
|
|
|
|
def get_dates(self, **kwargs):
|
|
return lastweeks(7)
|
|
|
|
def get_labels(self, **kwargs):
|
|
weeks = lastweeks(7)
|
|
return weeknames(weeks)
|
|
|
|
|
|
# Rend les achats de ce compte des 7 derniers mois
|
|
# Le mois en cours n'est pas compris
|
|
class AccountStatLastMonth(AccountStatLast):
|
|
end_date = this_monday_morning()
|
|
id_prefix = ID_PREFIX_ACC_LAST_MONTHS
|
|
|
|
def get_dates(self, **kwargs):
|
|
return lastmonths(7)
|
|
|
|
def get_labels(self, **kwargs):
|
|
months = lastmonths(7)
|
|
return monthnames(months)
|
|
|
|
|
|
# ------------------------
|
|
# Article Satistiques Last
|
|
# ------------------------
|
|
ID_PREFIX_ART_LAST = "last_art"
|
|
ID_PREFIX_ART_LAST_DAYS = "last_days_art"
|
|
ID_PREFIX_ART_LAST_WEEKS = "last_weeks_art"
|
|
ID_PREFIX_ART_LAST_MONTHS = "last_months_art"
|
|
|
|
|
|
# Un résumé de toutes les vues ArticleStatLast
|
|
# NE REND PAS DE JSON
|
|
class ArticleStatLastAll(ObjectResumeStat):
|
|
model = Article
|
|
context_object_name = 'article'
|
|
id_prefix = ID_PREFIX_ART_LAST
|
|
nb_stat = 3
|
|
nb_default = 2
|
|
stat_labels = ["Derniers mois", "Dernières semaines", "Derniers jours"]
|
|
stat_urls = ['kfet.article.stat.last.month',
|
|
'kfet.article.stat.last.week',
|
|
'kfet.article.stat.last.day']
|
|
|
|
@method_decorator(login_required)
|
|
def dispatch(self, *args, **kwargs):
|
|
return super(ArticleStatLastAll, self).dispatch(*args, **kwargs)
|
|
|
|
|
|
class ArticleStatLast(JSONDetailView):
|
|
"""
|
|
Returns a JSON containing the consommation
|
|
of an article at the diffent dates precised
|
|
"""
|
|
model = Article
|
|
context_object_name = 'article'
|
|
end_date = timezone.now()
|
|
id_prefix = ""
|
|
|
|
def render_to_response(self, context):
|
|
# Look for a 'format=json' GET argument
|
|
if self.request.GET.get('format') == 'json':
|
|
return self.render_to_json_response(context)
|
|
else:
|
|
return super(ArticleStatLast, self).render_to_response(context)
|
|
|
|
# doit rendre un dictionnaire des dates
|
|
# la première date correspond au début
|
|
# la dernière date est la fin de la dernière plage
|
|
def get_dates(self, **kwargs):
|
|
pass
|
|
|
|
# doit rendre un dictionnaire des labels
|
|
# le dernier label ne sera pas utilisé
|
|
def get_labels(self, **kwargs):
|
|
pass
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = {}
|
|
# On récupère les labels des dates
|
|
context['labels'] = self.get_labels().copy()
|
|
# On récupère les dates
|
|
dates = self.get_dates()
|
|
# On ajoute la date de fin
|
|
extended_dates = dates.copy()
|
|
extended_dates[len(dates)+1] = self.end_date
|
|
# On selectionne les opérations qui correspondent
|
|
# à l'article en question et qui ne sont pas annulées
|
|
# puis on choisi pour chaques intervalle les opérations
|
|
# effectuées dans ces intervalles de temps
|
|
all_operations = (Operation.objects
|
|
.filter(type='purchase')
|
|
.filter(article=self.object)
|
|
.filter(canceled_at=None)
|
|
)
|
|
operations = {}
|
|
for i in dates:
|
|
operations[i] = (all_operations
|
|
.filter(group__at__gte=extended_dates[i])
|
|
.filter(group__at__lte=extended_dates[i+1])
|
|
)
|
|
# On compte les opérations
|
|
nb_ventes = {}
|
|
nb_accounts = {}
|
|
nb_liq = {}
|
|
for i in operations:
|
|
nb_ventes[i] = tot_ventes(operations[i])
|
|
nb_liq[i] = tot_ventes(
|
|
operations[i]
|
|
.filter(group__on_acc__trigramme='LIQ')
|
|
)
|
|
nb_accounts[i] = tot_ventes(
|
|
operations[i]
|
|
.exclude(group__on_acc__trigramme='LIQ')
|
|
)
|
|
context['charts'] = [ { "color": "rgb(255, 99, 132)",
|
|
"label": "Toutes consommations",
|
|
"values": nb_ventes },
|
|
{ "color": "rgb(54, 162, 235)",
|
|
"label": "LIQ",
|
|
"values": nb_liq },
|
|
{ "color": "rgb(255, 205, 86)",
|
|
"label": "Comptes K-Fêt",
|
|
"values": nb_accounts } ]
|
|
return context
|
|
|
|
@method_decorator(login_required)
|
|
def dispatch(self, *args, **kwargs):
|
|
return super(ArticleStatLast, self).dispatch(*args, **kwargs)
|
|
|
|
|
|
# Rend les ventes des 7 derniers jours
|
|
# Aujourd'hui non compris
|
|
class ArticleStatLastDay(ArticleStatLast):
|
|
end_date = this_morning()
|
|
id_prefix = ID_PREFIX_ART_LAST_DAYS
|
|
|
|
def get_dates(self, **kwargs):
|
|
return lastdays(7)
|
|
|
|
def get_labels(self, **kwargs):
|
|
days = lastdays(7)
|
|
return daynames(days)
|
|
|
|
|
|
# Rend les ventes de 7 dernières semaines
|
|
# La semaine en cours n'est pas comprise
|
|
class ArticleStatLastWeek(ArticleStatLast):
|
|
end_date = this_monday_morning()
|
|
id_prefix = ID_PREFIX_ART_LAST_WEEKS
|
|
|
|
def get_dates(self, **kwargs):
|
|
return lastweeks(7)
|
|
|
|
def get_labels(self, **kwargs):
|
|
weeks = lastweeks(7)
|
|
return weeknames(weeks)
|
|
|
|
|
|
# Rend les ventes des 7 derniers mois
|
|
# Le mois en cours n'est pas compris
|
|
class ArticleStatLastMonth(ArticleStatLast):
|
|
end_date = this_monday_morning()
|
|
id_prefix = ID_PREFIX_ART_LAST_MONTHS
|
|
|
|
def get_dates(self, **kwargs):
|
|
return lastmonths(7)
|
|
|
|
def get_labels(self, **kwargs):
|
|
months = lastmonths(7)
|
|
return monthnames(months)
|