[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));
}
/// <summary>
/// Vérifie que vérificateur.DocCLF peut être édité ou supprimé et que l'utilisateur en a le droit.
/// </summary>
protected void DocModifiable()
{
DocCLF doc = vérificateur.DocCLF;
if (vérificateur.EstClient)
{
// Le client peut modifier un bon de commande qui n'a pas été envoyé (i.e. sans Date) sauf le bon virtuel
if (doc.Date.HasValue || vérificateur.KeyDoc.No == 0)
{
vérificateur.Erreur = RésultatBadRequest("CommandeEnvoyéeOuVirtuelle");
throw new VérificationException();
}
}
else
{
// Le fournisseur ne peut modifier que les bons de commande ou de livraison virtuels
if (doc.Type == TypeCLF.Facture)
{
vérificateur.Erreur = RésultatBadRequest("ModifieFacture");
throw new VérificationException();
}
if (doc.No != 0)
{
vérificateur.Erreur = RésultatBadRequest("BonNonVirtuel");
throw new VérificationException();
}
}
}
/// <summary>
/// Crée un document à envoyer avec seulement la Date.
/// </summary>
/// <param name="docCLF">document dans la bdd</param>
/// <returns></returns>
public static CLFDoc DeDate(DocCLF docCLF)
{
CLFDoc clfDoc = new CLFDoc
{
Date = docCLF.Date
};
return(clfDoc);
}
public async Task FixeSynthétisés(DocCLF docCLF, DbSet <DocCLF> docs)
{
if (docCLF.Type != TypeCLF.Commande)
{
NoBons = await docs
.Where(d => d.Id == docCLF.Id && d.NoGroupe == docCLF.No && d.Type == DocCLF.TypeBon(docCLF.Type))
.Select(d => d.No)
.ToListAsync();
}
}
/// <summary>
/// Crée un document à envoyer avec seulement le No et le Type.
/// </summary>
/// <param name="docCLF">document dans la bdd</param>
/// <returns></returns>
public static CLFDoc DeNoType(DocCLF docCLF)
{
CLFDoc clfDoc = new CLFDoc
{
No = docCLF.No,
Type = docCLF.Type
};
return(clfDoc);
}
/// <summary>
/// Crée un document à envoyer avec seulement l'Id du client et le No du document.
/// </summary>
/// <param name="docCLF">document dans la bdd</param>
/// <returns></returns>
public static CLFDoc DeKey(DocCLF docCLF)
{
CLFDoc clfDoc = new CLFDoc
{
Id = docCLF.Id,
No = docCLF.No
};
return(clfDoc);
}
/// <summary>
/// Lit le document défini par vérificateur.KeyDoc et vérifie qu'il existe. Fixe vérificateur.DocCLF avec ses lignes.
/// </summary>
protected async Task DocExiste()
{
DocCLF docCLF = await _service.DocCLFDeKey(vérificateur.KeyDoc, _type);
if (docCLF == null)
{
vérificateur.Erreur = RésultatBadRequest("DocNExistePas");
throw new VérificationException();
}
vérificateur.DocCLF = docCLF;
}
public async Task FixeSynthèse(DocCLF docCLF, DbSet <DocCLF> docs)
{
if (docCLF.NoGroupe != null)
{
NoGroupe = docCLF.NoGroupe;
DateGroupe = await docs
.Where(d => d.Id == docCLF.Id && d.No == docCLF.NoGroupe && d.Type == DocCLF.TypeSynthèse(docCLF.Type))
.Select(d => d.Date)
.FirstOrDefaultAsync();
}
}
/// <summary>
/// Vérifie que vérificateur.DocCLF est envoyé et sans synthèse.
/// Un bon virtuel est considéré comme envoyé et sans synthèse.
/// </summary>
protected void DocEstASynthétiser()
{
DocCLF doc = vérificateur.DocCLF;
bool peutEditerAFixer = doc.No == 0 || (doc.Date.HasValue && !doc.NoGroupe.HasValue);
if (!peutEditerAFixer)
{
vérificateur.Erreur = RésultatBadRequest("AFixerNonModifiable");
throw new VérificationException();
}
}
/// <summary>
/// Crée un document à envoyer avec la key, la Date, les lignes avec ou sans AFixer suivant la fonction de création de ligne.
/// </summary>
/// <param name="docCLF">document dans la bdd</param>
/// <param name="créeLigneData">transforme une ligne de la bdd en une ligne à envoyer</param>
/// <returns></returns>
public static CLFDoc AvecLignes(DocCLF docCLF, Func <LigneCLF, CLFLigneData> créeLigneData)
{
CLFDoc clfDoc = new CLFDoc
{
Id = docCLF.Id,
No = docCLF.No,
Date = docCLF.Date,
Lignes = docCLF.Lignes.Select(l => créeLigneData(l)).ToList()
};
return(clfDoc);
}
public static CLFDoc APréparer(DocCLF docCLF)
{
CLFDoc clfDoc = new CLFDoc
{
Id = docCLF.Id,
No = docCLF.No,
Date = docCLF.Date,
NbLignes = docCLF.Lignes.Count,
Incomplet = !docCLF.Lignes.All(l => l.AFixer.HasValue)
};
return(clfDoc);
}
/// <summary>
/// Crée un document à envoyer avec la key, la Date, le Type, le NbLignes, le Total et le Incomplet.
/// Si le document fait partie d'une synthèse, le CLFDoc contient aussi le NoGroupe, la DateGroupe.
/// </summary>
/// <param name="docCLF">document dans la bdd</param>
/// <returns></returns>
public static async Task <CLFDoc> Résumé(DocCLF docCLF, DbSet <DocCLF> docs)
{
CLFDoc clfDoc = new CLFDoc
{
Id = docCLF.Id,
No = docCLF.No,
Type = docCLF.Type,
Date = docCLF.Date,
NoGroupe = docCLF.NoGroupe,
NbLignes = docCLF.NbLignes,
Total = docCLF.Total,
Incomplet = docCLF.Incomplet
};
await clfDoc.FixeSynthèse(docCLF, docs);
return(clfDoc);
}
public CLFDoc CopieLignesAvecAFixer(DocCLF docCLF)
{
return(CopieLignes(docCLF, CLFLigneData.LigneDataAvecAFixer));
}
private CLFDoc CopieLignes(DocCLF docCLF, Func <LigneCLF, CLFLigneData> créeLigneData)
{
Lignes = docCLF.Lignes.Select(l => créeLigneData(l)).ToList();
return(this);
}
public CLFDoc CopieLignes(DocCLF docCLF)
{
return(CopieLignes(docCLF, CLFLigneData.LigneData));
}
/// <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>
/// Supprime toutes les modifications apportées à la bdd depuis et y compris la création du Client sur Invitation
/// </summary>
/// <param name="clientNouveau">Client qui a été créé en répondant à une Invitation</param>
/// <returns>RetourDeService d'un ClientEtatVue contenant un Client identique à celui que l'Invitation invitait à gérer s'il y en avait un, null sinon</returns>
public new async Task <RetourDeService <ClientEtatVue> > Supprime(Client clientNouveau)
{
Client rétabli = null;
ClientEtatVue vue = null;
List <ArchiveClient> archives = await _context.ArchiveClient
.Where(a => a.Id == clientNouveau.Id)
.OrderBy(a => a.Date)
.ToListAsync();
// index de l'archive ayant enregiistré le
int indexCréation = archives.FindIndex(a => a.Etat == EtatRole.Nouveau);
if (indexCréation != 0)
{
// le compte existait avant le rattachement au client, il faut le rétablir
rétabli = new Client
{
Id = clientNouveau.Id,
SiteId = clientNouveau.SiteId
};
// date du dernier changement d'état à fixer à partir des archives
DateTime dateEtat = archives.ElementAt(0).Date;
// Fixe les champs du Role à rétablir avec les champs non nuls de l'archive
// Si l'archive a un Etat fixe la date de changement d'état
ArchiveClient rétablitArchive(ArchiveClient archive)
{
Client.CopieDataSiPasNull(archive, rétabli);
ArchiveClient archiveRétablie = new ArchiveClient
{
Id = clientNouveau.Id
};
Client.CopieData(archive, archiveRétablie);
archiveRétablie.Date = archive.Date;
if (archive.Etat != null)
{
rétabli.Etat = archive.Etat.Value;
dateEtat = archive.Date;
}
return(archiveRétablie);
}
// transforme un RetourDeService avec erreur en RetourDeService<ClientEtatVue> avec la même erreur
RetourDeService <ClientEtatVue> transformeErreur(RetourDeService retour)
{
// on copie l'erreur dans RetourDeService de ClientEtatVue
RetourDeService <ClientEtatVue> retourVue = new RetourDeService <ClientEtatVue>(retour.Type);
if (retour.IdentityError)
{
retourVue.Objet = retour.Objet;
}
return(retourVue);
}
// on doit attribuer au client créé les archives antérieures au passage à l'état nouveau
// et rétablir ses champs en fonction de ces archives
List <ArchiveClient> archivesRétablies = archives
.GetRange(0, indexCréation)
.Select(a => rétablitArchive(a))
.ToList();
// on ajoute seulement à la table Role
_context.Client.Add(rétabli);
// il faut sauvegarder pour pouvoir ajouter les élément dépendants
RetourDeService retour = await SaveChangesAsync();
if (!retour.Ok)
{
return(transformeErreur(retour));
}
vue = new ClientEtatVue
{
Id = rétabli.Id,
Etat = EtatRole.Actif,
DateEtat = dateEtat
};
Client.CopieData(rétabli, vue);
// on ajoute les archives
_context.ArchiveClient.AddRange(archivesRétablies);
// date du passage à l'état nouveau
DateTime dateCréation = archives.ElementAt(indexCréation).Date;
// on doit attribuer au client créé les documents et les lignes du client créés avant le passage à l'état nouveau
List <DocCLF> anciensDocs = await _context.Docs
.Where(d => d.Id == clientNouveau.Id && d.Date < dateCréation)
.ToListAsync();
// s'il n'y a pas de documents, il n'y a rien à réattribuer
if (anciensDocs.Count != 0)
{
List <LigneCLF> anciennesLignes = await _context.Lignes
.Where(l => l.Id == clientNouveau.Id && anciensDocs.Where(d => d.No == l.No).Any())
.ToListAsync();
// s'il n'y a pas de lignes, il n'y a rien à réattribuer
if (anciennesLignes.Count != 0)
{
vue.AvecDocuments = true;
List <DocCLF> nouveauxDocs = anciensDocs
.Select(d => DocCLF.Clone(rétabli.Id, d))
.ToList();
List <LigneCLF> nouvellesLignes = anciennesLignes
.Select(l => LigneCLF.Clone(rétabli.Id, l))
.ToList();
_context.Docs.AddRange(nouveauxDocs);
retour = await SaveChangesAsync();
if (retour.Ok)
{
_context.Lignes.AddRange(nouvellesLignes);
retour = await SaveChangesAsync();
}
if (!retour.Ok)
{
return(transformeErreur(retour));
}
}
}
}
_context.Client.Remove(clientNouveau);
return(await SaveChangesAsync(vue));
}
/// <summary>
///
/// </summary>
/// <param name="paramsClient"></param>
/// <param name="copieLignes"></param>
/// <returns></returns>
protected async Task <IActionResult> CréeBon(ParamsKeyClient paramsClient, bool copieLignes)
{
vérificateur.Initialise(paramsClient);
try
{
await ClientDeLAction();
await UtilisateurEstClientActifOuNouveauOuFournisseur();
ContexteCatalogue();
}
catch (VérificationException)
{
return(vérificateur.Erreur);
}
uint noBon;
DocCLF docACopier = null;
if (vérificateur.EstClient)
{
if (_type != TypeCLF.Commande)
{
return(RésultatInterdit("Un client ne peut créer que des bons de commande."));
}
DocCLF dernièreCommande = await _service.DernierDoc(vérificateur.IdClient, TypeCLF.Commande);
if (copieLignes)
{
// la dernière commande doit exister et être envoyée
if (dernièreCommande == null || !dernièreCommande.Date.HasValue)
{
return(RésultatBadRequest("DerniereCommandeAbsenteOuPasEnvoyée"));
}
docACopier = dernièreCommande;
}
else
{
// la dernière commande doit ne pas exister ou être envoyée.
if (!(dernièreCommande == null || dernièreCommande.Date.HasValue))
{
return(RésultatBadRequest("DerniereCommandePrésenteEtPasEnvoyée"));
}
}
noBon = dernièreCommande == null ? 1 : dernièreCommande.No + 1;
}
else
{
// key du bon virtuel du client
KeyDocSansType key = new KeyDocSansType
{
Id = vérificateur.IdClient,
No = 0
};
DocCLF bonVirtuel = await _service.DocCLFDeKey(key, _type);
if (bonVirtuel != null)
{
// il ne peut y avoir qu'un seul bon virtuel d'un type donné
return(RésultatBadRequest("BonVirtuelPrésent"));
}
if (copieLignes)
{
// on ne peut copier les lignes que si la synthèse précédente a été réalisée à partir du seul bon virtuel
// c'est le cas s'il n'y a pas de bon ayant pour NoGroupe le No de cette synthèse
docACopier = await _service.DernierDoc(vérificateur.IdClient, DocCLF.TypeSynthèse(_type));
if (docACopier == null)
{
return(RésultatBadRequest("PasDeDernièreSynthèse"));
}
if (!(await _service.EstSynthèseSansBons(docACopier)))
{
return(RésultatBadRequest("DernièreSynthèseAvecBons"));
}
}
noBon = 0;
}
RetourDeService <DocCLF> retour = await _service.AjouteBon(vérificateur.IdClient, vérificateur.Site, _type, noBon);
if (!retour.Ok)
{
return(SaveChangesActionResult(retour));
}
if (docACopier != null)
{
RetourDeService retour1 = await _service.CopieLignes(retour.Entité, docACopier, vérificateur.Site.DateCatalogue.Value);
if (!retour1.Ok)
{
return(SaveChangesActionResult(retour1));
}
}
return(RésultatCréé(CLFDoc.DeNo(noBon)));
}
/// <summary>
/// Crée un document à envoyer avec la key, la Date, les lignes avec AFixer.
/// </summary>
/// <param name="docCLF">document dans la bdd</param>
/// <returns></returns>
public static CLFDoc AvecLignesAvecAFixer(DocCLF docCLF)
{
CLFDoc clfDoc = CLFDoc.AvecLignes(docCLF, CLFLigneData.LigneDataAvecAFixer);
return(clfDoc);
}
/// <summary>
/// Crée un document de synthèse à partir des documents d'un client dont le No est dans une liste.
/// L'objet retourné contient un DocCLF contenant uniquement le No et la Date de la synthèse créée.
/// 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>
/// <returns></returns>
protected async Task <IActionResult> Synthèse(ParamsSynthèse paramsSynthèse)
{
vérificateur.Initialise(paramsSynthèse.Id);
try
{
await ClientDeLAction();
await UtilisateurEstFournisseur();
ContexteCatalogue();
}
catch (VérificationException)
{
return(vérificateur.Erreur);
}
if (paramsSynthèse.NoDocs == null || paramsSynthèse.NoDocs.Count == 0)
{
return(RésultatBadRequest("PasDeNosDeDocuments"));
}
// 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 <DocCLF> retour = await _service.Synthèse(vérificateur.Site, paramsSynthèse.Id, docs, _type);
if (retour.Ok)
{
return(Ok(retour.Entité));
}
return(SaveChangesActionResult(retour));
}
/// <summary>
/// Crée un nouveau Client et si il y a un ancien Client attribue ses archives et ses documents au client créé.
/// </summary>
/// <param name="idSite">Id du Site</param>
/// <param name="idUtilisateur">Id de l'Utilisateur</param>
/// <param name="vue">Données du Client à créer</param>
/// <param name="clientInvité">Client créé par le fournisseur que le nouveau Client va prendre en charge</param>
/// <returns></returns>
public async Task <RetourDeService> CréeClient(uint idSite, string idUtilisateur, IClientData vue, Client clientInvité)
{
// on crée le Client
Client client = new Client
{
UtilisateurId = idUtilisateur,
SiteId = idSite,
Etat = EtatRole.Nouveau
};
Client.CopieData(vue, client);
if (clientInvité == null)
{
// il n'y a ni archives ni documents à récupérer
// on ajoute aux tables Client et ArchiveClient
return(await Ajoute(client));
}
// il y a des archives et peut-être des documents à réattribuer
// on ajoute seulement à la table Client (sans utiliser Ajoute)
_context.Client.Add(client);
RetourDeService <Client> retour = await SaveChangesAsync(client);
if (!retour.Ok)
{
return(retour);
}
// on doit attribuer au client créé les archives du Client existant
List <ArchiveClient> archives = await _context.ArchiveClient
.Where(a => a.Id == clientInvité.Id)
.ToListAsync();
archives = archives
.Select(a => ArchiveClient.Clone(client.Id, a))
.ToList();
// et ajouter une archive enregistrant le passage à l'état Nouveau
ArchiveClient archive = new ArchiveClient
{
Id = client.Id,
Etat = EtatRole.Nouveau,
Date = DateTime.Now
};
archives.Add(archive);
_context.ArchiveClient.AddRange(archives);
// on doit attribuer au client créé les documents et les lignes du client existant et supprimer celui-ci
List <DocCLF> anciensDocs = await _context.Docs
.Where(d => d.Id == clientInvité.Id)
.ToListAsync();
// s'il n'y a pas de documents, il n'y a rien à réattribuer
if (anciensDocs.Count != 0)
{
List <LigneCLF> anciennesLignes = await _context.Lignes
.Where(l => l.Id == clientInvité.Id)
.ToListAsync();
// s'il n'y a pas de lignes, il n'y a rien à réattribuer
if (anciennesLignes.Count != 0)
{
List <DocCLF> nouveauxDocs = anciensDocs
.Select(d => DocCLF.Clone(client.Id, d))
.ToList();
List <LigneCLF> nouvellesLignes = anciennesLignes
.Select(l => LigneCLF.Clone(client.Id, l))
.ToList();
_context.Docs.AddRange(nouveauxDocs);
var r = await SaveChangesAsync();
if (r.Ok)
{
_context.Lignes.AddRange(nouvellesLignes);
r = await SaveChangesAsync();
}
}
}
// supprime l'ancien client et en cascade ses archives, ses documents et ses lignes
SupprimeSansSauver(clientInvité);
_context.Client.Remove(clientInvité);
await SaveChangesAsync();
return(retour);
}
