private void AjouteEntitéSansSauver(RésultatEnregistrement résultat, string type)
{
switch (type)
{
case TypeDeRole.Administrateur.Code:
_administrateurService.AjouteSansSauver(résultat.Entité as Administrateur);
break;
case TypeDeRole.Fournisseur.Code:
_fournisseurService.AjouteSansSauver(résultat.Entité as Fournisseur);
_siteService.AjouteSansSauver(résultat.Site);
_livraisonService.CréePremièreLivraison(résultat.Entité as Fournisseur);
break;
case TypeDeRole.Client.Code:
_clientService.AjouteSansSauver(résultat.Entité as Client);
KeyUidRno keySite = new KeyUidRno
{
Uid = résultat.Role.SiteUid,
Rno = résultat.Role.SiteRno
};
_commandeService.CréePremièreCommande(résultat.Entité as Client, keySite);
break;
default:
break;
}
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> Clients([FromQuery] KeyUidRno keySite)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
// fausse carte
return(Forbid());
}
if (!await carte.EstActifEtAMêmeUidRno(keySite.KeyParam))
{
return(Forbid());
}
Site site = await _utile.SiteDeKey(keySite);
if (site == null)
{
return(NotFound());
}
AFacturer àFacturer = await _service.AFacturer(site);
return(Ok(àFacturer));
}
public async Task <IActionResult> ActionCommandes([FromQuery] KeyUidRno keyClient, Func <Site, KeyUidRno, List <Commande>, Task <RetourDeService> > action)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
// fausse carte
return(Forbid());
}
Site site = await _utile.SiteDeClient(keyClient);
if (site == null)
{
return(NotFound());
}
if (!await carte.EstActifEtAMêmeUidRno(site.KeyParam))
{
return(Forbid());
}
List <Commande> commandes = await _service.CommandesLivréesEtNonFacturées(site, keyClient);
if (commandes.Count == 0)
{
Erreurs.ErreurDeModel.AjouteAModelState(ModelState, "PasDeCommandeLivréeEtNonFacturée");
return(BadRequest());
}
RetourDeService retour = await action(site, keyClient, commandes);
return(SaveChangesActionResult(retour));
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> Commandes([FromQuery] KeyUidRno keyClient)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
// fausse carte
return(Forbid());
}
Site site = await _utile.SiteDeClient(keyClient);
if (site == null)
{
return(NotFound());
}
if (!await carte.EstActifEtAMêmeUidRno(site.KeyParam))
{
return(Forbid());
}
List <CommandeAFacturer> commandes = await _service.CommandesAFacturer(site, keyClient);
return(Ok(commandes));
}
[ProducesResponseType(409)] // Conflict
public async Task <IActionResult> CopieDems([FromQuery] KeyUidRno keySite)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
return(Forbid());
}
bool estFournisseur = await carte.EstActifEtAMêmeUidRno(keySite.KeyParam);
if (!estFournisseur)
{
return(Forbid());
}
Site site = await _utile.SiteDeKey(keySite);
if (site == null)
{
return(NotFound());
}
RetourDeService retour = await _service.CopieDemandes(site);
if (retour == null)
{
return(RésultatBadRequest("RienACopier"));
}
return(SaveChangesActionResult(retour));
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> ListeC([FromQuery] KeyUidRno keyClient)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
// fausse carte
return(Forbid());
}
Site site = await _utile.SiteDeClient(keyClient);
if (site == null)
{
return(NotFound());
}
if (!carte.EstClient(site))
{
return(Forbid());
}
Documents documents = await _service.ListeC(site, keyClient);
return(Ok(documents));
}
public async Task <RetourDeService> Ferme(KeyUidRno key, DateTime jusquA)
{
Site site = await LitSite(key);
if (site.Etat != TypeEtatSite.Actif && site.Etat != TypeEtatSite.Inactif)
{
return(new RetourDeService <Site>(TypeRetourDeService.Ok));
}
DateTime maintenant = DateTime.Now;
string type;
DateTime?date;
if (jusquA < maintenant)
{
type = TypeEtatSite.Inactif;
date = null;
}
else
{
type = TypeEtatSite.Actif;
date = jusquA;
}
if (site.Etat != type || site.DateEtat != date)
{
site.Etat = type;
site.DateEtat = date;
_context.Site.Update(site);
EtatSite etat = new EtatSite
{
Uid = key.Uid,
Rno = key.Rno,
Etat = type,
DateEtat = date,
Date = maintenant
};
_context.EtatSite.Add(etat);
}
RetourDeService retour = await SaveChangesAsync();
if (retour.Ok)
{
List <Commande> commandes = await _context.Commande
.Where(c => c.Date == null && c.LivraisonUid == key.Uid && c.LivraisonRno == key.Rno)
.ToListAsync();
if (commandes.Count > 0)
{
commandes.ForEach(c =>
{
c.Etat = TypeEtatCommande.Accepté;
_context.Commande.Update(c);
});
retour = await SaveChangesAsync();
}
}
return(retour);
}
public async Task <RetourDeService> Ouvre(KeyUidRno key)
{
Site site = await LitSite(key);
DateTime maintenant = DateTime.Now;
switch (site.Etat)
{
case TypeEtatSite.Nouveau:
List <ProduitVue> produits = await _produitService.Disponibles(key.KeyParam);
if (produits.Count == 0)
{
// impossible d'ouvrir un site qui n'a pas de produits
return(null);
}
break;
case TypeEtatSite.Actif:
if (site.DateEtat < maintenant)
{
// le site est déjà ouvert
return(new RetourDeService <Site>(TypeRetourDeService.Ok));
}
break;
case TypeEtatSite.Inactif:
break;
default:
// on ne fait rien
return(new RetourDeService <Site>(TypeRetourDeService.Ok));
}
// mise à jour du site
site.Etat = TypeEtatSite.Actif;
site.DateEtat = maintenant;
_context.Site.Update(site);
// ajout de l'état
EtatSite etat = new EtatSite
{
Uid = site.Uid,
Rno = site.Rno,
Etat = TypeEtatSite.Actif,
DateEtat = maintenant,
Date = maintenant
};
_context.EtatSite.Add(etat);
return(await SaveChangesAsync());
}
[ProducesResponseType(409)] // Conflict
public async Task <IActionResult> CopieDemC([FromQuery] KeyUidRno keyClient)
{
Vérificateur vérificateur = new Vérificateur
{
KeyClient = keyClient
};
await vérificateur.Vérifie(
ClientDeLAction,
UtilisateurEstFournisseur,
DétailExiste,
ALivrerModifiable
);
if (vérificateur.Erreur != null)
{
return(vérificateur.Erreur);
}
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
return(Forbid());
}
Site site = await _utile.SiteDeClient(keyClient);
if (site == null)
{
return(NotFound());
}
bool estFournisseur = await carte.EstActifEtAMêmeUidRno(site.KeyParam);
if (!estFournisseur)
{
return(Forbid());
}
RetourDeService retour = await _service.CopieDemandes(site, keyClient);
if (retour == null)
{
return(RésultatBadRequest("RienACopier"));
}
return(SaveChangesActionResult(retour));
}
[ProducesResponseType(409)] // Conflict
public async Task <IActionResult> Commence([FromQuery] KeyUidRno keySite)
{
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());
}
if (site.Etat != TypeEtatSite.Ouvert)
{
ErreurDeModel.AjouteAModelState(ModelState, "EtatSiteIncorrect");
return(BadRequest(ModelState));
}
Livraison livraison = await _utile.DernièreLivraison(site);
if (livraison != null && !livraison.Date.HasValue)
{
ErreurDeModel.AjouteAModelState(ModelState, "DernièreLivraisonPasTerminée");
}
await _service.CommenceLivraison(site);
RetourDeService retour = await _siteService.ChangeEtat(site, TypeEtatSite.Livraison);
if (retour.Ok)
{
return(Ok(await _service.VueDesCommandesOuvertesDesClientsAvecCompte(site)));
}
return(SaveChangesActionResult(retour));
}
[ProducesResponseType(409)] // Conflict
public async Task <IActionResult> Detail(DétailCommandeVue vue)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
// fausse carte
return(Forbid());
}
KeyUidRno keySite = new KeyUidRno {
Uid = vue.Uid2, Rno = vue.Rno
};
if (!await carte.EstActifEtAMêmeUidRno(keySite.KeyParam))
{
return(Forbid());
}
Commande commande = await _service.CommandeDeDétail(vue);
if (commande == null)
{
return(NotFound());
}
if (!(await _service.EstDansSynthèseEnvoyée(commande)))
{
Erreurs.ErreurDeModel.AjouteAModelState(ModelState, "CommandeLivréeEtNonFacturée");
return(BadRequest());
}
DétailCommande détail = await _service.LitDétail(vue);
if (détail == null)
{
return(NotFound());
}
RetourDeService retour = await _service.EcritDétail(détail, vue);
return(SaveChangesActionResult(retour));
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> Contexte([FromQuery] KeyUidRno keyClient)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
// fausse carte
return(Forbid());
}
Site site = await _utile.SiteDeClient(keyClient);
if (site == null)
{
return(NotFound());
}
return(Ok(await _service.Contexte(keyClient, site)));
}
private async Task <IActionResult> Document(KeyUidRnoNo keyDocument, Func <Site, KeyUidRnoNo, Task <AKeyUidRnoNo> > litDocument)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
// fausse carte
return(Forbid());
}
KeyUidRno keyClient = new KeyUidRno
{
Uid = keyDocument.Uid,
Rno = keyDocument.Rno
};
Site site = await _utile.SiteDeClient(keyClient);
if (site == null)
{
return(NotFound());
}
if (!await carte.EstActifEtAMêmeUidRno(site.KeyParam))
{
// l'utilisateur n'est pas le fournisseur
if (!carte.EstClient(site))
{
return(Forbid());
}
}
AKeyUidRnoNo document = await litDocument(site, keyDocument);
if (document == null)
{
return(NotFound());
}
return(Ok(document));
}
public async Task <IActionResult> ActionCommande([FromQuery] KeyUidRnoNo keyCommande, Func <Commande, Task <RetourDeService> > action)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
// fausse carte
return(Forbid());
}
KeyUidRno keyClient = new KeyUidRno {
Uid = keyCommande.Uid, Rno = keyCommande.Rno
};
Site site = await _utile.SiteDeClient(keyClient);
if (site == null)
{
return(NotFound());
}
if (!await carte.EstActifEtAMêmeUidRno(site.KeyParam))
{
return(Forbid());
}
Commande commande = await _service.LitCommande(keyCommande);
if (commande == null)
{
return(NotFound());
}
if (!(await _service.EstDansSynthèseEnvoyée(commande)))
{
Erreurs.ErreurDeModel.AjouteAModelState(ModelState, "CommandeLivréeEtNonFacturée");
}
RetourDeService retour = await action(commande);
return(SaveChangesActionResult(retour));
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> EnCours([FromQuery] KeyUidRno keyClient)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
// fausse carte
return(Forbid());
}
if (!await carte.EstActifEtAMêmeUidRno(keyClient.KeyParam))
{
return(Forbid());
}
CommandeVue commandeVue = await _service.EnCours(keyClient);
if (commandeVue == null)
{
return(NotFound());
}
return(Ok(commandeVue));
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> AvecCompte([FromQuery] KeyUidRno keySite)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
// fausse carte
return(Forbid());
}
if (!await carte.EstActifEtAMêmeUidRno(keySite.KeyParam))
{
return(Forbid());
}
Site site = await _utile.SiteDeKey(keySite);
if (site == null)
{
return(NotFound());
}
return(Ok(await _service.VueDesCommandesOuvertesDesClientsAvecCompte(site)));
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> EnCours([FromQuery] KeyUidRno keySite)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
// fausse carte
return(Forbid());
}
if (!await carte.EstActifEtAMêmeUidRno(keySite.KeyParam))
{
return(Forbid());
}
Site site = await _utile.SiteDeKey(keySite);
if (site == null)
{
return(NotFound());
}
return(Ok(await _service.LivraisonVueEnCours(site)));
}
[ProducesResponseType(409)] // Conflict
public async Task <IActionResult> Annule([FromQuery] KeyUidRno keySite)
{
return(await ActionFournisseur(keySite, VérifieEtatSiteAnnule, LivraisonDeAnnule, ActionAnnule));
}
/// <summary>
/// Copie Demande dans AServir pour tous les DétailCommande du client dont la demande est copiable
/// </summary>
/// <param name="site"></param>
/// <param name="keyClient"></param>
/// <returns>null s'il n'y a pas de détails copiables</returns>
public async Task <RetourDeService> CopieDemandes(Site site, KeyUidRno keyClient)
{
return(await CopieDemandes(site, filtreClient : c => keyClient.CommenceKey(c.KeyParam), filtreProduit : null, filtreDétail : null));
}
IQueryable <DétailCommande> QuerySite(KeyUidRno key)
{
return(_context.DétailCommande.Where(d => key.EstSemblable(Key2(d))));
}
[ProducesResponseType(409)] // Conflict
public async Task <IActionResult> Facture([FromQuery] KeyUidRno keyClient)
{
Task <RetourDeService> action(Site site, KeyUidRno keyClient1, List <Commande> commandes) => _service.FactureCommandes(site, keyClient, commandes);
return(await ActionCommandes(keyClient, action));
}
public async Task <List <DétailCommande> > ListeSite(KeyUidRno key)
{
return(await _context.DétailCommande.Where(d => key.EstSemblable(Key2(d))).ToListAsync());
}
[ProducesResponseType(409)] // Conflict
public async Task <IActionResult> Commence1([FromQuery] KeyUidRno keySite)
{
return(await ActionFournisseur(keySite, VérifieEtatSiteCommence, LivraisonDeCommence, ActionCommencer));
}
[ProducesResponseType(409)] // Conflict
public async Task <IActionResult> Termine([FromQuery] KeyUidRno keySite)
{
return(await ActionFournisseur(keySite, VérifieEtatSiteTermine, LivraisonDeTerminer, ActionTermine));
}
