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()); }