gestioCOF/kfet/views.py

# -*- 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)
                    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:
                to_checkout_balance += -operation.amount
            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'] = 'LIQ'
                return JsonResponse(data, status=400)
            if operation.type != Operation.EDIT:
                to_checkout_balance += operation.amount
        operationgroup.amount += operation.amount
        if operation.type == Operation.DEPOSIT:
            required_perms.add('kfet.perform_deposit')
        if operation.type == Operation.EDIT:
            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,
            '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.is_checkout:
                    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,
                '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)