public async Task <RetourDeService <Commande> > AjouteCommande(AKeyUidRno keyClient, long noCommande, Site site, bool estFournisseur)
{
Commande commande = new Commande
{
Uid = keyClient.Uid,
Rno = keyClient.Rno,
No = noCommande,
SiteUid = site.Uid,
SiteRno = site.Rno,
};
if (estFournisseur)
{
commande.Date = new DateTime();
}
// [A SUPPRIMER
if (site.Etat == TypeEtatSite.Livraison)
{
Livraison livraison = await _utile.DernièreLivraison(site);
commande.LivraisonNo = livraison.No;
}
// A SUPPRIMER]
_context.Commande.Add(commande);
return(await SaveChangesAsync(commande));
}
/// <summary>
/// retourne la liste des CommandeAFacturer avec Détails d'un client
/// </summary>
/// <param name="site"></param>
/// <param name="keyClient"></param>
/// <returns></returns>
public async Task <List <CommandeAFacturer> > CommandesAFacturer(Site site, AKeyUidRno keyClient)
{
var x = await _utile.CommandesAvecDétailsLivraisonEtFacture(
filtreCommande : c => keyClient.Uid == c.Uid && keyClient.Rno == c.Rno, filtreDétails : null, filtreRole : null, keySite : null)
.Where(c => c.Livraison != null && c.Livraison.Date.HasValue && !c.Livraison.FactureNo.HasValue)
.Join(_context.Livraison.Where(l => l.Uid == site.Uid && l.Rno == site.Rno),
c => c.LivraisonNo.Value, l => l.No, (c, l) => new { livraison = l, commande = c })
.Where(lc => lc.livraison.Date.HasValue)
.Select(lc => lc.commande)
.GroupJoin(_context.DétailCommande,
c => new { c.Uid, c.Rno, c.No },
d => new { d.Uid, d.Rno, d.No },
(commande, détails) => new { commande, détails }
)
.Where(cd => cd.détails.Where(d => d.ALivrer > 0).Any())
.Select(cd => new CommandeAFacturer
{
No = cd.commande.No,
LivraisonNo = cd.commande.LivraisonNo.Value,
Details = cd.détails.Select(d => new DétailAFacturer
{
No = d.No2,
ALivrer = d.ALivrer.Value,
AFacturer = d.AFacturer
}).ToList()
})
.ToListAsync();
return(x);
}
/// <summary>
/// retourne la Commande ouverte (sans date) d'un client
/// crée une nouvelle Commande s'il n'y en a pas d'ouvertes
/// </summary>
/// <param name="keyClient"></param>
/// <returns></returns>
public async Task <Commande> Ouverte(AKeyUidRno keyClient)
{
Commande commande = await _context.Commande
.Where(c => c.Uid == keyClient.Uid && c.Rno == keyClient.Rno)
.LastOrDefaultAsync();
long no = 1;
if (commande != null)
{
if (commande.Date != null)
{
no = commande.No + 1;
}
commande = null;
}
if (commande == null)
{
commande = new Commande
{
Uid = keyClient.Uid,
Rno = keyClient.Rno,
No = no,
};
_context.Commande.Add(commande);
RetourDeService retour = await SaveChangesAsync(commande);
if (!retour.Ok)
{
return(null);
}
}
return(commande);
}
public async Task <Documents> ListeF(AKeyUidRno keySite)
{
bool filtreCommandes(Commande c) => c.Date.HasValue;
List <Commande> commandes = await _utile.CommandesAvecDétailsLivraisonEtFacture(filtreCommandes, null, null, keySite).ToListAsync();
return(await Liste(keySite, commandes));
}
/// <summary>
/// retourne la liste des commandes sans numéro de livraison émises par les clients autorisés d'un site
/// </summary>
/// <param name="keySite"></param>
/// <returns></returns>
public async Task <List <Commande> > CommandesOuvertes(AKeyUidRno keySite)
{
bool filtreCommande(Commande commande) => commande.Date.HasValue && !commande.LivraisonNo.HasValue;
List <Commande> commandes = await _utile.CommandesAvecDétailsLivraisonEtFacture(filtreCommande, null, null, keySite).ToListAsync();
return(commandes);
}
/// <summary>
/// retourne les dernières Commandes des clients actifs ou nouveau du site défini par keySite
/// </summary>
/// <param name="keySite"></param>
/// <returns></returns>
public async Task <List <Commande> > DernièresCommandes(AKeyUidRno keySite)
{
bool filtreCommande(Commande commande) => !commande.Date.HasValue || commande.Date.Value.Ticks == 0;
List <Commande> commandes = await _utile.CommandesAvecDétailsLivraisonEtFacture(filtreCommande, null, _utile.FiltreRoleActif(), keySite).ToListAsync();
return(commandes);
}
public async Task <List <CommandeVue> > NouvellesCommandes(AKeyUidRno key)
{
return(await _context.Commande
.Where(c => c.LivraisonUid == key.Uid && c.LivraisonRno == key.Rno && c.LivraisonNo == null)
.Include(c => c.Client)
.Include(c => c.DétailCommandes)
.Select(c => CréeVueNouvelle(c))
.ToListAsync());
}
/// <summary>
/// retourne la dernière commande du client défini par keyClient
/// </summary>
/// <param name="keyClient"></param>
/// <returns></returns>
public async Task <Commande> DernièreCommande(AKeyUidRno keyClient)
{
bool filtre(Commande c) => c.Uid == keyClient.Uid && c.Rno == keyClient.Rno;
Commande commande = await _utile.CommandesAvecDétailsLivraisonEtFacture(filtre, null, null, null)
.LastOrDefaultAsync();
return(commande);
}
/// <summary>
/// retourne les commandes reçues depuis la date
/// </summary>
/// <param name="keySite"></param>
/// <returns></returns>
public async Task <List <Commande> > CommandesOuvertesDesClientsAvecCompte(AKeyUidRno keySite)
{
// ce sont celles qui n'ont pas de date
bool filtreCommande(Commande commande) => !commande.Date.HasValue;
List <Commande> commandes = await _utile.CommandesAvecDétailsLivraisonEtFacture(filtreCommande, null, null, keySite).ToListAsync();
return(commandes);
}
public async Task <List <Commande> > ListeDuSite(AKeyUidRno key)
{
var site = await _context.Site.Where(s => s.Uid == key.Uid && s.Rno == key.Rno).FirstOrDefaultAsync();
return(await _context.Commande
.Include(c => c.Client)
.ThenInclude(cl => cl.Role)
.Where(c => c.Client.Role.SiteUid == key.Uid && c.Client.Role.SiteRno == key.Rno)
.ToListAsync());
}
/// <summary>
/// retourne un CommandeVue contenant la dernière Commande d'un client
/// </summary>
/// <param name="keyClient">key du client</param>
/// <returns>CommandesVue</returns>
public async Task <CommandeVue> EnCours(AKeyUidRno keyClient)
{
Commande dernièreCommande = await DernièreCommande(keyClient);
if (dernièreCommande != null)
{
return(CréeCommandeVue(dernièreCommande));
}
return(null);
}
/// <summary>
/// retourne la liste des commandes d'un fournisseur d'état etatCommande
/// </summary>
/// <param name="keyFournisseur"></param>
/// <param name="etatCommande">TypeEtatCommande</param>
/// <returns></returns>
private async Task <List <Commande> > CommandesParEtat(AKeyUidRno keyFournisseur, string etatCommande)
{
List <Commande> commandes = await _context.Commande
.Where(c => c.LivraisonUid == keyFournisseur.Uid && c.LivraisonRno == keyFournisseur.Rno && c.Etat == etatCommande)
.ToListAsync();
return(commandes
.Where(c => c.Client.Role.Etat == TypeEtatRole.Actif || c.Client.Role.Etat == TypeEtatRole.Nouveau)
.Where(c => c.DétailCommandes.Count > 0)
.ToList());
}
private async Task <Documents> Liste(AKeyUidRno keySite, List <Commande> commandes)
{
List <DocumentCommande> commandesAvecTarif = await DocumentCommandes(keySite, commandes, filtreDétails : null, avecDétails : false);
return(new Documents
{
Commandes = commandesAvecTarif.Select(cat => DocumentCommandeBilan(cat)).ToList(),
Livraisons = DocumentLivraisonBilan(commandes, commandesAvecTarif),
Factures = DocumentFactureBilan(commandes, commandesAvecTarif)
});
}
/// <summary>
/// retourne la vue à éditer de la dernière Commande d'un client
/// </summary>
/// <param name="keyClient"></param>
/// <returns></returns>
public async Task <CommandeVue> CommandeEnCours(AKeyUidRno keyClient)
{
Commande commande = await _context.Commande
.Where(c => c.Uid == keyClient.Uid && c.Rno == keyClient.Rno)
.Include(c => c.DétailCommandes)
.LastAsync();
CommandeVue vue = CréeVueCommander(commande);
return(vue);
}
/// <summary>
/// appelé à la création du Fournisseur
/// </summary>
/// <param name="keyFournisseur"></param>
/// <returns></returns>
public void CréePremièreLivraison(AKeyUidRno keyFournisseur)
{
Livraison livraison = new Livraison
{
Uid = keyFournisseur.Uid,
Rno = keyFournisseur.Rno,
No = 1,
};
_context.Livraison.Add(livraison);
}
/// <summary>
/// retourne la liste des commandes d'un fournisseur d'état Accepté et s'il n'y en a pas d'état Nouveau
/// </summary>
/// <param name="keyFournisseur"></param>
/// <returns></returns>
public async Task <List <CommandeVue> > CommandesDeLivraison(AKeyUidRno keyFournisseur)
{
List <Commande> commandes = await CommandesParEtat(keyFournisseur, TypeEtatCommande.Accepté);
if (commandes.Count == 0)
{
commandes = await CommandesParEtat(keyFournisseur, TypeEtatCommande.Nouveau);
}
return(commandes
.Select(c => CréeVueAccepter(c))
.ToList());
}
/// <summary>
/// retourne un ContexteCommande contenant les données d'état définissant les droits
/// </summary>
/// <param name="keyClient">key du client</param>
/// <param name="site">Site du client</param>
/// <returns>CommandesVue</returns>
public async Task <ContexteCommande> Contexte(AKeyUidRno keyClient, Site site)
{
ContexteCommande contexte = await ContexteCommande(site);
Commande dernièreCommande = await DernièreCommande(keyClient);
if (dernièreCommande != null)
{
contexte.NoDC = dernièreCommande.No;
}
return(contexte);
}
private async Task <DocumentCommande> DocumentCommandeTarif(AKeyUidRno keySite, Commande commande, Func <DétailCommande, bool> filtreDétails, bool avecDétails)
{
DocumentCommande documentCommande = DocumentCommandeBase(commande);
IEnumerable <DétailCommande> détails = filtreDétails == null ? commande.Détails : commande.Détails.Where(d => filtreDétails(d)).ToList();
if (avecDétails)
{
documentCommande.Détails = détails.Select(d => _détailCommandeService.DétailCommandeData(d)).ToList();
}
documentCommande.Tarif = await _catalogueService.Tarif(keySite, commande.Date.Value, détails);
return(documentCommande);
}
// inutile?
public async Task <RetourDeService> FermeOuvertes(AKeyUidRno keyFournisseur)
{
DateTime date = DateTime.Now;
List <Commande> fermer = await _context.Commande
.Where(c => c.LivraisonUid == keyFournisseur.Uid && c.LivraisonRno == keyFournisseur.Rno && c.Date == null)
.Include(c => c.DétailCommandes)
.Where(c => c.DétailCommandes.Count > 0)
.ToListAsync();
fermer.ForEach(c => c.Date = date);
_context.Commande.UpdateRange(fermer);
return(await SaveChangesAsync());
}
/// <summary>
/// retourne la vue de la dernière Livraison d'un Fournisseur
/// </summary>
/// <param name="keyFournisseur">key du client</param>
/// <returns></returns>
public async Task <LivraisonVue> LivraisonEnCours(AKeyUidRno keyFournisseur)
{
Livraison livraison = await _context.Livraison
.Where(l => l.Uid == keyFournisseur.Uid && l.Rno == keyFournisseur.Rno)
.LastAsync();
LivraisonVue vue = new LivraisonVue
{
Commandes = await _commandeService.CommandesDeLivraison(keyFournisseur)
};
vue.CopieKey(livraison.KeyParam);
return(vue);
}
/// <summary>
/// appelé à la création du Client
/// </summary>
/// <param name="keyClient"></param>
/// <param name="keySite"></param>
/// <returns></returns>
public void CréePremièreCommande(AKeyUidRno keyClient, AKeyUidRno keySite)
{
Commande commande = new Commande
{
Uid = keyClient.Uid,
Rno = keyClient.Rno,
No = 1,
LivraisonUid = keySite.Uid,
LivraisonRno = keySite.Rno,
Etat = TypeEtatCommande.Nouveau
};
_context.Commande.Add(commande);
}
public async Task <AKeyUidRnoNo> Facture(AKeyUidRno keySite, KeyUidRnoNo keyDocument)
{
Func <Commande, bool> filtreCommandes = c => c.Uid == keyDocument.Uid && c.Rno == keyDocument.Rno;
Func <DétailCommande, bool> filtreDétails = d => d.AFacturer.HasValue && d.AFacturer.Value > 0;
List <Commande> commandes = await _utile.CommandesAvecDétailsLivraisonEtFacture(filtreCommandes, filtreDétails, null, null)
.Where(c => c.Livraison != null && c.Livraison.Facture != null && c.Livraison.Facture.No == keyDocument.No && c.Livraison.Facture.Date.HasValue)
.ToListAsync();
if (commandes.Count() == 0)
{
return(null);
}
List <DocumentCommande> documents = await DocumentCommandes(keySite, commandes, filtreDétails, avecDétails : true);
return(DocumentsFactureTarif(commandes, documents).First());
}
public async Task <RetourDeService> FactureCommandes(Site site, AKeyUidRno keyClient, List <Commande> commandes)
{
long factureNo = await ProchainFactureNo(site);
Facture facture = new Facture
{
Uid = keyClient.Uid,
Rno = keyClient.Rno,
No = factureNo,
SiteUid = site.Uid,
SiteRno = site.Rno,
Date = DateTime.Now
};
_context.Facture.Add(facture);
commandes.ForEach(commande => commande.Livraison.FactureNo = factureNo);
_context.Commande.UpdateRange(commandes);
return(await SaveChangesAsync());
}
/// <summary>
/// retourne un CommandesVue contenant les dernières Commande non vides de tous les clients d'un site
/// </summary>
/// <param name="keySite">key du Site</param>
/// <returns>CommandesVue</returns>
public async Task <List <CommandeVue> > CommandesVue(AKeyUidRno keySite)
{
Role[] roles = await _context.Role
.Where(r => r.Uid != r.SiteUid && r.SiteUid == keySite.Uid && r.SiteRno == keySite.Rno)
.ToArrayAsync();
var commandes = new List <CommandeVue>();
for (int i = 0; i < roles.Count(); i++)
{
Role role = roles[i];
Commande commande = await DernièreCommande(role);
if (commande != null)
{
commandes.Add(CréeCommandeVue(commande));
}
}
return(commandes);
}
/// <summary>
/// return null si les vues à enregistrer ne correspondent pas aux commandes ouvertes
/// sinon fixe l'état des commandes ouvertes sur accepté ou refusé suivant les vues et retourne les commandes
/// </summary>
/// <param name="keyFournisseur"></param>
/// <param name="vues"></param>
/// <returns></returns>
public async Task <List <Commande> > VérifieEnregistre(AKeyUidRno keyFournisseur, List <CommandeVue> vues)
{
List <Commande> commandes = await CommandesParEtat(keyFournisseur, TypeEtatCommande.Nouveau);
if (commandes.Count == 0)
{
return(null);
}
var àVérifier = commandes.Join(vues, c => c.Uid, v => v.Uid, (c, v) => new { c, v }).ToList();
if (àVérifier.Count != commandes.Count || àVérifier.Count != vues.Count)
{
return(null);
}
àVérifier.ForEach(a =>
{
a.c.Etat = a.v.Etat;
});
return(commandes);
}
/// <summary>
/// modèle de vérification pour exécuter une action du fournisseur
/// </summary>
/// <param name="keyOuVueCommande"></param>
/// <param name="action"></param>
/// <returns></returns>
private async Task <IActionResult> ActionFournisseur(AKeyUidRno keySite,
DVérifieEtatSite vérifieEtatSite, DLivraisonDeLAction livraisonDeLAction, DActionLivraison actionLivraison)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
// fausse carte
return(Forbid());
}
if (!await carte.EstActifEtAMêmeUidRno(keySite.KeyParam))
{
// pas le fournisseur
return(Forbid());
}
Site site = await _utile.SiteDeKey(keySite);
if (site == null)
{
return(NotFound());
}
vérifieEtatSite(site);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Livraison livraison = await livraisonDeLAction(site);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
RetourDeService retour = await actionLivraison(site, livraison);
return(SaveChangesActionResult(retour));
}
public async Task <AKeyUidRnoNo> Commande(AKeyUidRno keySite, KeyUidRnoNo keyDocument)
{
bool filtreCommandes(Commande c) => c.Uid == keyDocument.Uid && c.Rno == keyDocument.Rno && c.No == keyDocument.No;
bool filtreDétails(DétailCommande d) => d.Demande.HasValue;
List <Commande> commandes = await _utile.CommandesAvecDétailsLivraisonEtFacture(filtreCommandes, filtreDétails, null, null).ToListAsync();
if (commandes.Count() == 0)
{
return(null);
}
DocumentCommande commande = (await DocumentCommandes(keySite, commandes, filtreDétails, avecDétails: true)).First();
commande.Détails = commande.Détails.Select(d => new DétailCommandeData
{
No = d.No,
TypeCommande = d.TypeCommande,
Demande = d.Demande
}).ToList();
return(commande);
}
/// <summary>
/// s'il y a des commandes acceptées, crée une livraison et fixe leur LivraisonNo
/// enregistre les changements dans la base de données
/// </summary>
/// <param name="keyFournisseur"></param>
/// <param name="vérifiées">les commandes ouvertes qui sont passées par VérifieEnregistre</param>
/// <returns></returns>
public async Task <RetourDeService> Enregistre(AKeyUidRno keyFournisseur, List <Commande> vérifiées)
{
List <Commande> acceptées = vérifiées.Where(c => c.Etat == TypeEtatCommande.Accepté).ToList();
RetourDeService retour;
if (acceptées.Count > 0)
{
Livraison dernièreLivraison = await _context.Livraison
.Where(l => l.Uid == keyFournisseur.Uid && l.Rno == keyFournisseur.Rno)
.LastOrDefaultAsync();
retour = await SaveChangesAsync();
if (!retour.Ok)
{
return(retour);
}
acceptées.ForEach(c => { c.LivraisonNo = dernièreLivraison.No; });
}
vérifiées.ForEach(c =>
{
_context.Commande.Update(c);
Commande c1 = new Commande
{
Uid = c.Uid,
Rno = c.Rno,
No = 1,
LivraisonUid = c.LivraisonUid,
LivraisonRno = c.LivraisonRno,
Etat = TypeEtatCommande.Nouveau,
};
_context.Commande.Add(c1);
});
return(await SaveChangesAsync());
}
public async Task <bool> TitrePrisParAutre(AKeyUidRno key, string titre)
{
return(await _dbSet.Where(site => site.Titre == titre && (site.Uid != key.Uid || site.Rno != key.Rno)).AnyAsync());
}
public async Task <bool> NomPrisParAutre(AKeyUidRno key, string nomSite)
{
return(await _dbSet.Where(site => site.NomSite == nomSite && (site.Uid != key.Uid || site.Rno != key.Rno)).AnyAsync());
}