private static ArchiveClient ArchiveClient(Environment environment)
{
var serviceProvider = LoggingUtility.CreateServiceProviderAndSetUpLogging();
var clientConfig = new ClientConfiguration(environment, GetBringCertificate(), new Sender(BringPublicOrganizationNumber))
{
LogRequestAndResponse = true
};
var client = new ArchiveClient(clientConfig, serviceProvider.GetService <ILoggerFactory>());
return(client);
}
public DateTime ChangeEtatSansSauver(Client client, EtatRole état)
{
client.Etat = état;
_context.Client.Update(client);
DateTime date = DateTime.Now;
ArchiveClient archive = new ArchiveClient
{
Id = client.Id,
Date = date,
Etat = état
};
_context.ArchiveClient.Add(archive);
return(date);
}
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);
}
public TestHelper(ArchiveClient archiveClient)
{
_archiveClient = archiveClient;
_documentOwner = new DocumentOwner(_archiveClient.ClientConfiguration.GlobalSender.OrganizationNumber);
_document = new ArchivedDocumentId("1234");
}
/// <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>
/// 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);
}