328 lines
10 KiB
Python
328 lines
10 KiB
Python
"""Fichier views.py de gestion de la page dashboard de l'application SGL.
|
|
|
|
Principales fonctionnalités couvertes :
|
|
1- Gestion des stocks des produits (rupture, pré-rupture, normal).
|
|
2- Affichage des commandes en cours et validations des dites commandes
|
|
3- Affichage des demandes en cours et validations des dites demandes.
|
|
"""
|
|
|
|
from django.shortcuts import render, redirect
|
|
from django.http import JsonResponse
|
|
from gestion_produit.models import Commander, Demander, Produit
|
|
# from django.views.decorators.csrf import csrf_exempt
|
|
from django.contrib.auth.decorators import login_required
|
|
|
|
import json
|
|
|
|
from gestion_produit.views import calcul_stock_produit
|
|
|
|
|
|
def dashboard_quantite_produit():
|
|
"""Calculez les quantités des produits en rupture, pré-rupture et normal.
|
|
|
|
Returns
|
|
-------
|
|
dict
|
|
Dictionnaire contenant les nombres et les listes des produits par
|
|
catégorie.
|
|
|
|
"""
|
|
tous_les_produits = Produit.objects.all()
|
|
|
|
produit_rupture = []
|
|
produit_pre_rupture = []
|
|
produit_normal = []
|
|
|
|
for produit in tous_les_produits:
|
|
stock_actuel = calcul_stock_produit(produit)
|
|
stock_actuel.pop("image")
|
|
if stock_actuel["stockActuel"] == 0:
|
|
produit_rupture.append(stock_actuel)
|
|
elif stock_actuel["stockActuel"] < produit.seuil_pre_rupture:
|
|
produit_pre_rupture.append(stock_actuel)
|
|
else:
|
|
produit_normal.append(stock_actuel)
|
|
|
|
return {
|
|
"nombre_rupture": len(produit_rupture),
|
|
"nombre_pre_rupture": len(produit_pre_rupture),
|
|
"nombre_normal": len(produit_normal),
|
|
"produit_rupture": produit_rupture,
|
|
"produit_pre_rupture": produit_pre_rupture,
|
|
"produit_normale": produit_normal,
|
|
}
|
|
|
|
|
|
@login_required(login_url="authentification:login")
|
|
def index(request):
|
|
"""Retournez la page d'accueil du dashboard.
|
|
|
|
Parameters
|
|
----------
|
|
request : HttpRequest
|
|
La requête HTTP entrante.
|
|
|
|
Returns
|
|
-------
|
|
HttpResponse
|
|
La réponse HTTP contenant la page d'accueil du dashboard.
|
|
|
|
"""
|
|
if request.user.groups.filter(name="Chauffeur").exists():
|
|
return redirect("gestion_vehicule:index")
|
|
|
|
if not request.user.groups.filter(name="Administration").exists():
|
|
return redirect("gestion_produit:index")
|
|
|
|
commandes_en_cours = Commander.objects.filter(livrer=False)
|
|
demandes_en_cours = Demander.objects.filter(
|
|
valider_par_chef=True, valider_par_logisticien=None
|
|
)
|
|
|
|
gestion_quantite_produit = dashboard_quantite_produit()
|
|
|
|
nombre_rupture = gestion_quantite_produit["nombre_rupture"]
|
|
nombre_pre_rupture = gestion_quantite_produit["nombre_pre_rupture"]
|
|
nombre_normal = gestion_quantite_produit["nombre_normal"]
|
|
|
|
return render(
|
|
request,
|
|
"index.html",
|
|
{
|
|
"nb_commande": len(commandes_en_cours),
|
|
"nb_demande": len(demandes_en_cours),
|
|
"nombre_rupture": nombre_rupture,
|
|
"nombre_pre_rupture": nombre_pre_rupture,
|
|
"nombre_normal": nombre_normal,
|
|
},
|
|
)
|
|
|
|
@login_required(login_url="login")
|
|
def produit_a_rendre(_request):
|
|
"""Retournez la liste des équipements à rendre.
|
|
|
|
Cette vue est appelée via une requête AJAX et renvoie une liste
|
|
d'équipements qui doivent être rendus.
|
|
|
|
Parameters
|
|
----------
|
|
request : HttpRequest
|
|
La requête HTTP entrante.
|
|
|
|
Returns
|
|
-------
|
|
JsonResponse
|
|
Une réponse JSON contenant la liste des équipements à rendre.
|
|
|
|
"""
|
|
equipement_a_rendre = Demander.objects.filter(a_rendre=True, rendu=False)
|
|
liste_equipement = [
|
|
{
|
|
"id_demande": equipement.id,
|
|
"produit": equipement.produit.libelle,
|
|
"quantite": equipement.quantite,
|
|
"detenteur": (
|
|
f"{equipement.user.user.first_name} "
|
|
f"{equipement.user.user.last_name}"
|
|
),
|
|
"action": equipement.rendu,
|
|
}
|
|
for equipement in equipement_a_rendre
|
|
]
|
|
|
|
return JsonResponse(liste_equipement, safe=False)
|
|
|
|
@login_required(login_url="login")
|
|
def produit_a_rendre_update(request):
|
|
"""Mettez à jour le statut des équipements à rendre.
|
|
|
|
Lorsqu'une requête POST est reçue, cette vue met à jour le statut
|
|
des équipements à rendre en fonction des données fournies dans la
|
|
requête.
|
|
|
|
Parameters
|
|
----------
|
|
request : HttpRequest
|
|
request.id_demande : int
|
|
L'identifiant de la demande d'équipement à mettre à jour.
|
|
request.action : bool
|
|
Le nouveau statut de rendu de l'équipement.
|
|
|
|
Returns
|
|
-------
|
|
JsonResponse
|
|
Une réponse JSON indiquant le succès de l'opération.
|
|
|
|
"""
|
|
if request.method == "POST":
|
|
data = json.loads(request.body)
|
|
for d in data:
|
|
demande = Demander.objects.get(id=d["id_demande"])
|
|
demande.rendu = d["action"]
|
|
demande.save()
|
|
|
|
return JsonResponse(
|
|
{"status": "success", "message": "Produits mis à jour"}
|
|
)
|
|
|
|
@login_required(login_url="login")
|
|
def liste_produit_rupture(request):
|
|
"""Vue pour obtenir la liste des produits en fonction de leur type.
|
|
|
|
Cette vue est appelée via une requête AJAX à chaque fois que l'on clique
|
|
sur un cadran (rupture, pré-rupture, en stock normal) et renvoie une liste
|
|
de produits en fonction du type spécifié dans les paramètres de la
|
|
requête.
|
|
|
|
Parameters
|
|
----------
|
|
request : HttpRequest
|
|
request.type : str
|
|
Le statut de produits à récupérer qui sont en "rupture",
|
|
"pre_rupture" ou "normal".
|
|
|
|
Returns
|
|
-------
|
|
JsonResponse
|
|
Une réponse JSON contenant la liste des produits correspondant
|
|
au type spécifié.
|
|
|
|
"""
|
|
type_encadrer = request.GET["type"]
|
|
dashboard_gestion = dashboard_quantite_produit()
|
|
|
|
donnees_charger = []
|
|
|
|
if type_encadrer == "rupture":
|
|
donnees_charger = dashboard_gestion["produit_rupture"]
|
|
elif type_encadrer == "pre_rupture":
|
|
donnees_charger = dashboard_gestion["produit_pre_rupture"]
|
|
elif type_encadrer == "normal":
|
|
donnees_charger = dashboard_gestion["produit_normale"]
|
|
|
|
return JsonResponse(donnees_charger, safe=False)
|
|
|
|
@login_required(login_url="login")
|
|
def liste_produit_commander(request):
|
|
"""Listez des produits commandés non encore livrés.
|
|
|
|
Parameters
|
|
----------
|
|
request : HttpRequest
|
|
La requête HTTP entrante.
|
|
|
|
Returns
|
|
-------
|
|
JsonResponse
|
|
Une réponse JSON contenant la liste des produits commandés
|
|
non encore livrés.
|
|
|
|
"""
|
|
commandes_en_cours = Commander.objects.filter(livrer=False)
|
|
ma_liste_commandes = [
|
|
{
|
|
"id_commande": commande.id,
|
|
"produit": commande.produit.libelle,
|
|
"quantite": commande.quantite_commander,
|
|
"date_commande": commande.date_commande,
|
|
"date_livraison": commande.date_livraison,
|
|
"fournisseur": commande.fournisseur.nom_entreprise,
|
|
"is_logisticien": (
|
|
request.user.profile.departement.
|
|
nom_departement == "Logistique"
|
|
),
|
|
}
|
|
for commande in commandes_en_cours
|
|
]
|
|
|
|
return JsonResponse(ma_liste_commandes, safe=False)
|
|
|
|
|
|
@login_required(login_url="login")
|
|
def enregistrer_livraison_produit(request):
|
|
"""Enregistrez la livraison d'un produit commandé.
|
|
|
|
Lorsqu'une requête POST est reçue, cette vue met à jour le statut
|
|
de livraison du produit commandé en fonction de l'identifiant de la
|
|
commande fourni dans la requête.
|
|
|
|
Parameters
|
|
----------
|
|
request : HttpRequest
|
|
request.id_commande : int
|
|
L'identifiant de la commande dont la livraison doit
|
|
être enregistrée.
|
|
|
|
Returns
|
|
-------
|
|
JsonResponse
|
|
Une réponse JSON indiquant le succès ou l'échec de l'opération.
|
|
|
|
"""
|
|
if request.method == "POST":
|
|
id_commande = request.POST.get("id_commande")
|
|
try:
|
|
commande = Commander.objects.get(id=id_commande)
|
|
commande.livrer = True
|
|
commande.save()
|
|
return JsonResponse(
|
|
{
|
|
"status": "success",
|
|
"message": "Livraison enregistrée avec succès."
|
|
}
|
|
)
|
|
except Commander.DoesNotExist:
|
|
return JsonResponse(
|
|
{"status": "error", "message": "Commande non trouvée."}
|
|
)
|
|
return JsonResponse(
|
|
{"status": "error", "message": "Méthode non autorisée."}
|
|
)
|
|
|
|
|
|
@login_required(login_url="login")
|
|
def liste_demandes(request):
|
|
"""Listez des demandes en cours de validation.
|
|
|
|
Parameters
|
|
----------
|
|
request : HttpRequest
|
|
La requête HTTP entrante.
|
|
|
|
Returns
|
|
-------
|
|
JsonResponse
|
|
Une réponse JSON contenant la liste des demandes en cours
|
|
de validation.
|
|
|
|
"""
|
|
demandes_en_cours = Demander.objects.filter(
|
|
valider_par_chef=True, valider_par_logisticien=None
|
|
)
|
|
is_logisticien = (
|
|
request.user.profile.departement.nom_departement == "Logistique"
|
|
)
|
|
ma_liste_demandes = [
|
|
{
|
|
"id_demande": demande.id,
|
|
"demandeur": (
|
|
f"{demande.user.user.first_name} "
|
|
f"{demande.user.user.last_name}"
|
|
),
|
|
"produit": demande.produit.libelle,
|
|
"quantite": demande.quantite,
|
|
"motifs": demande.motifs,
|
|
"date_de_mise_a_dispo_souhaite": (
|
|
demande.date_de_mise_a_dispo_souhaite
|
|
.strftime("%Y-%m-%d")
|
|
),
|
|
"a_rendre": demande.a_rendre,
|
|
"valider_par_chef": demande.valider_par_chef,
|
|
"valider_par_logisticien": demande.valider_par_logisticien,
|
|
"is_logisticien": is_logisticien,
|
|
}
|
|
for demande in demandes_en_cours
|
|
]
|
|
|
|
return JsonResponse(ma_liste_demandes, safe=False)
|