private async Task <RetourDeService <ClientEtatVue> > ChangeEtat(Client client, EtatRole état)
{
DateTime date = ChangeEtatSansSauver(client, état);
ClientEtatVue vue = new ClientEtatVue
{
Id = client.Id,
DateEtat = date
};
return(await SaveChangesAsync(vue));
}
private async Task <ClientEtatVue> ClientEtatVue(Client client, long maintenant, int joursInactifAvantExclu)
{
ArchiveClient archive = client.Archives.Where(a => a.Etat != null).OrderBy(a => a.Date).Last();
ClientEtatVue vue = new ClientEtatVue
{
Id = client.Id,
Date0 = client.Archives.First().Date,
Email = client.Utilisateur?.Email,
};
Client.CopieData(client, vue);
if (archive.Etat == EtatRole.Inactif)
{
TimeSpan timeSpan = new TimeSpan(maintenant - archive.Date.Ticks);
if (timeSpan.TotalDays > joursInactifAvantExclu)
{
// changer l'état
await ChangeEtat(client, EtatRole.Fermé);
vue.Etat = EtatRole.Fermé;
vue.DateEtat = DateTime.Now;
}
}
else
{
vue.Etat = client.Etat;
vue.DateEtat = archive.Date;
if (archive.Etat == EtatRole.Actif)
{
bool avecDocuments = await _context.Docs
.Where(d => d.Id == archive.Id)
.Include(d => d.Lignes)
.Where(d => d.Lignes.Any())
.AnyAsync();
vue.AvecDocuments = avecDocuments;
}
}
return(vue);
}
/// <summary>
/// Retourne la liste des vues contenant les donnéees d'état des clients d'un site ayant un Etat permis
/// et n'ayant pas d'Utilisateur ou ayant un Utilisateur d'Etat permis.
/// </summary>
/// <param name="idSite">Id du site</param>
/// <param name="étatsClientPermis">Array des EtatClient permis</param>
/// <param name="étatsUtilisateurPermis">Array des EtatUtilisateur permis</param>
/// <returns></returns>
public async Task <List <ClientEtatVue> > ClientsDuSite(uint idSite, EtatRole[] étatsClientPermis, EtatUtilisateur[] étatsUtilisateurPermis)
{
List <Client> clients = await _context.Client
.Where(client => client.SiteId == idSite)
.Include(client => client.Archives)
.Include(client => client.Utilisateur)
.ToListAsync();
List <ClientEtatVue> vues = new List <ClientEtatVue>();
long maintenant = DateTime.Now.Ticks;
int joursInactifAvantExclu = Client.JoursInactifAvantExclu();
foreach (Client client in clients)
{
ClientEtatVue vue = await ClientEtatVue(client, maintenant, joursInactifAvantExclu);
if ((client.Utilisateur == null || étatsUtilisateurPermis.Contains(client.Utilisateur.Etat)) &&
étatsClientPermis.Contains(client.Etat))
{
vues.Add(vue);
}
}
return(vues);
}
/// <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));
}