[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));
}
public async Task <RetourDeService <DemandeSite> > Ajoute(FournisseurAAjouter ajout)
{
Fournisseur fournisseur = new Fournisseur();
Fournisseur.CopieData(ajout, fournisseur);
fournisseur.Site = new Site();
Site.CopieData(ajout.Site, fournisseur.Site);
DateTime date = DateTime.Now;
RetourDeService <Fournisseur> retourFournisseur = await base.Ajoute(fournisseur, date);
RetourDeService <DemandeSite> retour;
if (!retourFournisseur.Ok)
{
return(new RetourDeService <DemandeSite>(retourFournisseur));
}
fournisseur = retourFournisseur.Entité;
DemandeSite demande = new DemandeSite
{
Email = ajout.Email,
Id = fournisseur.Id,
Date = date
};
_context.DemandeSite.Add(demande);
retour = await SaveChangesAsync <DemandeSite>(demande);
if (retour.Ok)
{
retour.Entité.Fournisseur = fournisseur;
}
return(retour);
}
[ProducesResponseType(409)] // Conflict
public async Task <IActionResult> Edite([FromQuery] ParamsVide paramsLigne, CLFLigne ligne)
{
vérificateur.Initialise(ligne, paramsLigne);
try
{
await ClientDeLAction();
await UtilisateurEstClientActifOuNouveauOuFournisseur();
ContexteCatalogue();
await LigneExiste();
DocModifiable();
await PeutCommanderProduit();
ChampsInterditsAbsents();
ChampsPrésentsValides();
}
catch (VérificationException)
{
return(vérificateur.Erreur);
}
RetourDeService retour = await _service.EditeLigne(vérificateur.LigneCLF, ligne);
return(SaveChangesActionResult(retour));
}
[ProducesResponseType(409)] // Conflict
public async Task <IActionResult> CopieBon([FromQuery] ParamsCréeCommande paramsCrée)
{
Vérificateur vérificateur = new Vérificateur(paramsCrée);
await vérificateur.Vérifie(
ClientDeLAction,
UtilisateurEstClientOuFournisseur,
EtatSiteChangé,
DerniereCommandePrésenteEtEnvoyée
);
if (vérificateur.Erreur != null)
{
return(vérificateur.Erreur);
}
long noCommande = vérificateur.DernièreCommande == null ? 1 : vérificateur.DernièreCommande.No + 1;
RetourDeService <Commande> retour = await _service.AjouteCommande(vérificateur.KeyClient, noCommande, vérificateur.Site, vérificateur.EstFournisseur);
if (retour.Ok)
{
await _détailCommandeService.AjouteCopiesDétails(vérificateur.DernièreCommande);
}
return(SaveChangesActionResult(retour));
}
[ProducesResponseType(409)] // Conflict
public async Task <IActionResult> Ajoute([FromQuery] ParamsEditeDétail paramsDétail, DétailCommandeVue vue)
{
Vérificateur vérificateur = new Vérificateur(vue, paramsDétail);
await vérificateur.Vérifie(
ClientDeLAction,
UtilisateurEstClientOuFournisseur,
EtatSiteChangé,
CommandeExiste,
DétailNExistePas,
CommandeModifiable,
PeutCommanderProduit,
ChampsInterditsAbsents,
ChampsRequisPrésents,
ChampsPrésentsValides
);
if (vérificateur.Erreur != null)
{
return(vérificateur.Erreur);
}
RetourDeService <DétailCommande> retour = await _détailCommandeService.Ajoute(vue);
if (retour.Ok)
{
return(CreatedAtAction(nameof(LitDétail), vérificateur.KeyDétail, retour.Entité));
}
return(SaveChangesActionResult(retour));
}
public async Task <IActionResult> Supprime([FromQuery] ParamsSupprimeLigne paramsSupprime)
{
vérificateur.Initialise(paramsSupprime);
try
{
await ClientDeLAction();
await UtilisateurEstClientActifOuNouveauOuFournisseur();
ContexteCatalogue();
await DocExiste();
DocModifiable();
// vérifie que la ligne commandant le produit dont le No est le No2 du paramétre existe et fixe vérificateur.LigneCLF
LigneCLF ligne = vérificateur.DocCLF.Lignes.Where(l => l.ProduitId == paramsSupprime.ProduitId).FirstOrDefault();
if (ligne == null)
{
return(NotFound());
}
vérificateur.LigneCLF = ligne;
}
catch (VérificationException)
{
return(vérificateur.Erreur);
}
RetourDeService retour = await _service.SupprimeLigne(vérificateur.LigneCLF);
return(SaveChangesActionResult(retour));
}
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));
}
protected async Task <IActionResult> Fixe(ParamsFixeLigne paramsFixeLigne)
{
vérificateur.Initialise(paramsFixeLigne);
try
{
await ClientDeLAction();
await UtilisateurEstFournisseur();
ContexteCatalogue();
await LigneExiste();
DocEstASynthétiser();
string code = QuantitéDef.Vérifie(paramsFixeLigne.AFixer);
if (code != null)
{
vérificateur.Erreur = RésultatBadRequest("aFixer", code);
throw new VérificationException();
}
}
catch (VérificationException)
{
return(vérificateur.Erreur);
}
RetourDeService retour = await _service.FixeLigne(vérificateur.LigneCLF, paramsFixeLigne.AFixer);
return(SaveChangesActionResult(retour));
}
/// <summary>
/// Exécute une action sur chaque ligne des documents d'un client dont le No est dans une liste.
/// Retourne une erreur si l'un des documents n'est pas à synthétiser.
/// </summary>
/// <param name="paramsSynthèse">contient l'Id du client et la liste des No des documents à synthétiser</param>
/// <param name="action">retourne null si l'action est impossible</param>
/// <returns></returns>
protected async Task <IActionResult> Action(ParamsSynthèse paramsSynthèse, Func <List <DocCLF>, Task <RetourDeService> > action)
{
vérificateur.Initialise(paramsSynthèse.Id);
try
{
await ClientDeLAction();
await UtilisateurEstFournisseur();
ContexteCatalogue();
}
catch (VérificationException)
{
return(vérificateur.Erreur);
}
// Lit la liste des documents synthétisables dont le No est dans la liste.
List <DocCLF> docs = await _service.DocumentsEnvoyésSansSynthèse(paramsSynthèse, DocCLF.TypeBon(_type));
if (docs.Count != paramsSynthèse.NoDocs.Count)
{
// L'un des No de la liste ne correspond pas à un document synthétisable.
return(RésultatBadRequest("DocumentsPasEnvoyésOuAvecSynthèse"));
}
RetourDeService retour = await action(docs);
return(SaveChangesActionResult(retour));
}
/// <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);
}
/// <summary>
/// Crée un Client avec son Utilisateur.
/// </summary>
/// <param name="vue">PeupleClientVue définissant le Client à créer</param>
/// <param name="peupleId">PeupleId contenant les Id des derniers objets créés</param>
/// <returns></returns>
private async Task <RetourDeService> AjouteClient(PeupleClientVue vue, PeupleId peupleId)
{
uint id = peupleId.Client + 1;
RetourDeService <Utilisateur> retourUtilisateur = await _utilisateurService.CréeUtilisateur(vue);
if (!retourUtilisateur.Ok)
{
return(retourUtilisateur);
}
Utilisateur utilisateur = retourUtilisateur.Entité;
await _utilisateurService.ConfirmeEmailDirect(utilisateur);
Client client = new Client
{
Id = id,
UtilisateurId = utilisateur.Id,
SiteId = peupleId.Fournisseur,
Etat = EtatRole.Nouveau
};
Role.CopieData(vue, client);
RetourDeService retour = await _clientService.Ajoute(client);
if (retour.Ok)
{
peupleId.Client = id;
}
return(retour);
}
[ProducesResponseType(409)] // Conflict
public async Task <IActionResult> Envoi([FromQuery] ParamsKeyClient paramsClient)
{
vérificateur.Initialise(paramsClient);
try
{
await ClientDeLAction();
await UtilisateurEstClientActifOuNouveau();
ContexteCatalogue();
}
catch (VérificationException)
{
return(vérificateur.Erreur);
}
DocCLF dernièreCommande = await _service.DernierDoc(paramsClient.Id, TypeCLF.Commande);
// la dernière commande doit exister et ne pas être envoyée
if (dernièreCommande == null || dernièreCommande.Date.HasValue)
{
return(RésultatBadRequest("DerniereCommandeAbsenteOuEnvoyée"));
}
RetourDeService <CLFDoc> retour = await _service.EnvoiCommande(vérificateur.Site, dernièreCommande);
if (retour.Ok)
{
return(RésultatCréé(retour.Entité));
}
return(SaveChangesActionResult(retour));
}
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 <IActionResult> Peuple()
{
if (await _peupleService.EstPeuplé())
{
return(BadRequest());
}
RetourDeService retour = await _peupleService.Peuple();
return(SaveChangesActionResult(retour));
}
private async Task <RésultatEnregistrement> CréeUtilisateur(string type, VueBase vue)
{
RésultatEnregistrement résultat = new RésultatEnregistrement();
ApplicationUser existant = await _service.TrouveParEmail(vue.Email);
if (existant == null)
{
ApplicationUser applicationUser = new ApplicationUser
{
UserName = vue.Email,
Email = vue.Email,
};
RetourDeService <Utilisateur> retour = await _service.CréeUtilisateur(applicationUser, vue.Password);
if (retour.Ok)
{
résultat.ACréé = true;
résultat.user = applicationUser;
résultat.Utilisateur = retour.Entité;
}
else
{
résultat.ActionResult = SaveChangesActionResult(retour);
}
}
else
{
Utilisateur utilisateur = await _service.UtilisateurDeUser(existant.Id);
CarteUtilisateur carte = await _service.CréeCarteUtilisateur(HttpContext.User);
bool permis = carte != null && ((carte.EstUtilisateurActif && carte.Uid == utilisateur.Uid) || carte.EstAdministrateur);
if (permis)
{
résultat.ACréé = false;
résultat.user = existant;
résultat.Utilisateur = utilisateur;
permis = await PeutAjouterRole(utilisateur, type, vue);
if (!permis)
{
résultat.ActionResult = BadRequest();
}
}
else
{
résultat.ActionResult = Forbid();
}
}
return(résultat);
}
private async Task <IActionResult> Enregistre(string type, VueBase vue)
{
RésultatEnregistrement résultat = null;
try
{
résultat = await CréeUtilisateur(type, vue);
if (résultat.ActionResult != null)
{
return(résultat.ActionResult);
}
résultat.Role = await _roleService.CréeRole(résultat.Utilisateur);
CréeEntité(résultat, type, vue);
await ValideEntité(résultat, type);
if (!ModelState.IsValid)
{
if (résultat.ACréé)
{
await _service.Supprime(résultat.Utilisateur);
}
return(BadRequest(ModelState));
}
_roleService.AjouteSansSauver(résultat.Role);
AjouteEntitéSansSauver(résultat, type);
RetourDeService retour = await _service.SaveChangesAsync();
if (retour.Type != TypeRetourDeService.Ok && résultat.ACréé)
{
await _service.Supprime(résultat.Utilisateur);
return(SaveChangesActionResult(retour));
}
}
catch (Exception ex)
{
if (résultat != null && résultat.ACréé)
{
await _service.Supprime(résultat.Utilisateur);
}
throw ex;
}
return(await Connecte(résultat.applicationUser, true));
}
public async Task <RetourDeService> Peuple()
{
PeupleId peupleId = new PeupleId();
RetourDeService retour = await AjouteAdministrateur();
// Crée les fournisseurs: Utilisateur, Fournisseur, Site
for (int i = 0; i < PeuplementUtilisateurs.Fournisseurs.Length && retour.Ok; i++)
{
PeupleFournisseurVue vue = PeuplementUtilisateurs.Fournisseurs[i];
retour = await AjouteFournisseur(vue, peupleId);
}
return(retour);
}
/// <summary>
/// Crée l'administrateur.
/// </summary>
/// <returns></returns>
private async Task <RetourDeService> AjouteAdministrateur()
{
CréeCompteVue vue = new CréeCompteVue
{
Email = "*****@*****.**",
Password = "******"
};
RetourDeService <Utilisateur> retourUtilisateur = await _utilisateurService.CréeUtilisateur(vue);
if (retourUtilisateur.Ok)
{
await _utilisateurService.ConfirmeEmailDirect(retourUtilisateur.Entité);
}
return(retourUtilisateur);
}
[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));
}
public async Task <IActionResult> Edite(TVue vue)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
// fausse carte
return(Forbid());
}
if (dEditeEstPermis == null || !(await dEditeEstPermis(carte, vue.KeyParam)))
{
return(Forbid());
}
T nouveau = __service.CréeDonnée(vue);
if (dEcritVerrouillé != null && await dEcritVerrouillé(carte, nouveau))
{
return(Conflict());
}
DValideEdite <T> dValideEdite = __service.DValideEdite();
if (dValideEdite != null)
{
await dValideEdite(nouveau, ModelState);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
}
T donnée = await __service.Lit(vue.KeyParam as TParam);
if (donnée == null)
{
return(NotFound());
}
RetourDeService <T> retour = await __service.Edite(donnée, nouveau);
return(SaveChangesActionResult(retour));
}
public async Task <IActionResult> Ajoute(TVue vue)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
// fausse carte
return(Forbid());
}
if (dAjouteEstPermis == null || !(await dAjouteEstPermis(carte, vue.KeyParamParent)))
{
return(Forbid());
}
await FixeKeyParamAjout(vue);
T donnée = __service.CréeDonnée(vue);
if (dEcritVerrouillé != null && await dEcritVerrouillé(carte, donnée))
{
return(Conflict());
}
DValideAjoute <T> dValideAjoute = __service.DValideAjoute();
if (dValideAjoute != null)
{
await dValideAjoute(donnée, ModelState);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
}
RetourDeService <T> retour = await __service.Ajoute(donnée);
if (retour.Ok)
{
return(CreatedAtAction(nameof(Lit), vue.TexteKey, vue));
}
return(SaveChangesActionResult(retour));
}
public async Task <IActionResult> Ajoute([FromBody] CréeCompteVue vue)
{
RetourDeService <Utilisateur> retour = await CréeUtilisateur(vue);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (retour.Type != TypeRetourDeService.Ok)
{
return(SaveChangesActionResult(retour));
}
// envoie un mail contenant le lien de confirmation
await UtilisateurService.EnvoieEmailConfirmeCompte(retour.Entité);
return(Ok());
}
[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(409)] // Conflict
public async Task <IActionResult> Nouveau([FromQuery] ParamsCréeCommande paramsCrée)
{
Vérificateur vérificateur = new Vérificateur(paramsCrée);
await vérificateur.Vérifie(
ClientDeLAction,
UtilisateurEstClientOuFournisseur,
EtatSiteChangé,
DerniereCommandeAbsenteOuEnvoyée
);
if (vérificateur.Erreur != null)
{
return(vérificateur.Erreur);
}
long noCommande = vérificateur.DernièreCommande == null ? 1 : vérificateur.DernièreCommande.No + 1;
RetourDeService retour = await _service.AjouteCommande(vérificateur.KeyClient, noCommande, vérificateur.Site, vérificateur.EstFournisseur);
return(SaveChangesActionResult(retour));
}
[ProducesResponseType(409)] // Conflict
public async Task <IActionResult> Supprime([FromQuery] ParamsSupprimeDétail paramsDétail)
{
Vérificateur vérificateur = new Vérificateur(paramsDétail);
await vérificateur.Vérifie(
ClientDeLAction,
UtilisateurEstClientOuFournisseur,
EtatSiteChangé,
DétailExiste,
CommandeModifiable
);
if (vérificateur.Erreur != null)
{
return(vérificateur.Erreur);
}
RetourDeService retour = await _détailCommandeService.Supprime(vérificateur.Détail);
return(SaveChangesActionResult(retour));
}
[ProducesResponseType(409)] // Conflict
public async Task <IActionResult> Edite(CLFLigne clfLigne)
{
vérificateur.Initialise(clfLigne);
try
{
await ClientDeLAction();
await UtilisateurEstFournisseur();
await LigneExiste();
DocEstASynthétiser();
}
catch (VérificationException)
{
return(vérificateur.Erreur);
}
RetourDeService retour = await _service.EditeLigne(vérificateur.LigneCLF, clfLigne);
return(SaveChangesActionResult(retour));
}
/// <summary>
/// Crée un Client sans Utilisateur.
/// </summary>
/// <param name="peupleId">PeupleId contenant les Id des derniers objets créés</param>
/// <returns></returns>
private async Task <RetourDeService> AjouteClient(PeupleId peupleId)
{
uint id = peupleId.Client + 1;
Client client = new Client
{
Id = id,
SiteId = peupleId.Fournisseur,
Nom = "Client" + id,
Adresse = "Adresse" + id,
Ville = "Ville" + id,
Etat = EtatRole.Actif
};
RetourDeService retour = await _clientService.Ajoute(client);
if (retour.Ok)
{
peupleId.Client = id;
}
return(retour);
}
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));
}
/// <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));
}