public async Task Connecte(CarteUtilisateur carteUtilisateur)
{
Utilisateur utilisateur = carteUtilisateur.Utilisateur;
// persistant est false car l'utilisateur doit s'authentifier à chaque accès
await _signInManager.SignInAsync(utilisateur, false);
// lit et augmente le sessionId de l'utilisateur
int sessionId = utilisateur.SessionId;
if (sessionId < 0)
{
// l'utilisateur s'est déconnecté lors de sa dernière session
// et son SessionId a été changé en son opposé
sessionId = -sessionId;
}
sessionId = sessionId + 1;
// fixe le sessionId de l'utilisateur et de la carte
utilisateur.SessionId = sessionId;
_context.Utilisateur.Update(utilisateur);
ArchiveUtilisateur archive = new ArchiveUtilisateur
{
Id = utilisateur.Id,
Date = DateTime.Now,
SessionId = sessionId
};
_context.ArchiveUtilisateur.Add(archive);
await _context.SaveChangesAsync();
carteUtilisateur.SessionId = sessionId;
}
public async Task ArchiveDernierSite(uint idSite)
{
ArchiveUtilisateur archive = Utilisateur.Archives
.Where(a => a.IdDernierSite != null)
.LastOrDefault();
if (archive == null || archive.IdDernierSite.Value != idSite)
{
ArchiveUtilisateur nouveau = new ArchiveUtilisateur
{
Id = Utilisateur.Id,
Date = DateTime.Now,
IdDernierSite = idSite
};
_context.ArchiveUtilisateur.Add(nouveau);
await _context.SaveChangesAsync();
}
}
public async Task Déconnecte(CarteUtilisateur carteUtilisateur)
{
Utilisateur utilisateur = carteUtilisateur.Utilisateur;
await _signInManager.SignOutAsync();
// change le sessionId de l'utilisateur en son opposé
utilisateur.SessionId = -utilisateur.SessionId;
_context.Utilisateur.Update(utilisateur);
ArchiveUtilisateur archive = new ArchiveUtilisateur
{
Id = utilisateur.Id,
Date = DateTime.Now,
SessionId = utilisateur.SessionId,
IdDernierSite = carteUtilisateur.IdDernierSite
};
_context.ArchiveUtilisateur.Add(archive);
await _context.SaveChangesAsync();
}
/// <summary>
/// Ajoute à la bdd un nouvel Utilisateur à partir de son Email et de son mot de passe.
/// </summary>
/// <param name="vue">objet ayant l'Email et le Password de l'utilisateur à créer</param>
/// <returns></returns>
public async Task <RetourDeService <Utilisateur> > CréeUtilisateur(ICréeCompteVue vue)
{
Utilisateur applicationUser = new Utilisateur
{
UserName = vue.Email,
Email = vue.Email,
Etat = EtatUtilisateur.Nouveau
};
try
{
IdentityResult identityResult = await _userManager.CreateAsync(applicationUser, vue.Password);
if (!identityResult.Succeeded)
{
return(new RetourDeService <Utilisateur>(identityResult));
}
ArchiveUtilisateur archive = new ArchiveUtilisateur
{
Id = applicationUser.Id,
Email = applicationUser.Email,
Etat = EtatUtilisateur.Nouveau,
Date = DateTime.Now
};
_context.ArchiveUtilisateur.Add(archive);
await SaveChangesAsync();
return(new RetourDeService <Utilisateur>(applicationUser));
}
catch (DbUpdateConcurrencyException)
{
return(new RetourDeService <Utilisateur>(TypeRetourDeService.ConcurrencyError));
}
catch (Exception)
{
return(new RetourDeService <Utilisateur>(TypeRetourDeService.Indéterminé));
}
}
public async Task <Identifiant> Identifiant()
{
Identifiant identifiant = new Identifiant(Utilisateur);
if (EstAdministrateur)
{
return(identifiant);
}
// listes des Id des sites de l'utilisateur dans l'ordre inverse de leurs dernières visites
IEnumerable <uint> idSites = Utilisateur.Archives
.Where(a => a.IdDernierSite != null)
.GroupBy(a => a.IdDernierSite.Value)
.Select(g => new { idSite = g.Key, date = g.OrderBy(a => a.Date).Last().Date })
.OrderByDescending(x => x.date)
.Select(x => x.idSite);
foreach (uint idSite in idSites)
{
Fournisseur fournisseur = Utilisateur.Fournisseurs.Where(f => f.Id == idSite).FirstOrDefault();
if (fournisseur != null)
{
identifiant.Sites.Add(new SiteDIdentifiant(fournisseur));
}
else
{
Client client = Utilisateur.Clients.Where(c => c.SiteId == idSite).FirstOrDefault();
identifiant.Sites.Add(new SiteDIdentifiant(client));
}
}
DateTime?dateDernièreDéconnection = null;
int sessionId = Utilisateur.SessionId; // > 0 car l'utilisateur est connecté
sessionId--; // id de la session précédente
if (sessionId > 0)
{
// si l'utilisateur s'est déconnecté de la session précédente, une archive
// avec un SessionId opposé à celui de la session précédente a été enregistrée
ArchiveUtilisateur dernièreDéconnection = Utilisateur.Archives
.Where(archive => archive.SessionId == -sessionId)
.FirstOrDefault();
if (dernièreDéconnection != null)
{
dateDernièreDéconnection = dernièreDéconnection.Date;
// on inscrit l'Id du dernier Site ou 0 si l'utilisateur était sur l'AppSite
identifiant.IdDernierSite = dernièreDéconnection.IdDernierSite.Value;
}
}
IQueryable <DocCLF> queryNouveauxDocs = null;
Func <DocCLF, CLFDoc> nouveauCLFDoc = null;
foreach (SiteDIdentifiant site in identifiant.Sites)
{
if (site.Client == null)
{
// c'est un site où l'utilisateur est Fournisseur
List <Produit> produits = await _context.Produit
.Where(produit => produit.SiteId == site.Id && produit.Disponible)
.ToListAsync();
int nbCatégories = produits.GroupBy(produit => produit.CategorieId).Count();
List <Client> clients = await _context.Client
.Where(client => client.SiteId == site.Id)
.ToListAsync();
site.Bilan = new BilanSite
{
Catalogue = new BilanCatalogue
{
Catégories = nbCatégories,
Produits = produits.Count()
},
Clients = new BilanClients
{
Actifs = clients.Where(client => client.Etat == EtatRole.Actif).Count(),
Nouveaux = clients.Where(client => client.Etat == EtatRole.Nouveau).Count()
}
};
queryNouveauxDocs = _context.Docs
.Where(docCLF => docCLF.SiteId == site.Id && docCLF.Type == TypeCLF.Commande);
nouveauCLFDoc = (DocCLF docCLF) => CLFDoc.DeKey(docCLF);
}
else
{
queryNouveauxDocs = _context.Docs
.Where(docCLF => docCLF.SiteId == site.Id && (docCLF.Type == TypeCLF.Livraison || docCLF.Type == TypeCLF.Facture));
nouveauCLFDoc = (DocCLF docCLF) => CLFDoc.DeNoType(docCLF);
}
if (sessionId == 0)
{
// c'est la première connection
site.NouveauxDocs = new List <CLFDoc>();
}
else
{
// on ne joint les nouveaux docs que s'il y a eu déconnection
if (dateDernièreDéconnection != null)
{
List <DocCLF> nouveauxDocCLFs = await queryNouveauxDocs
.Where(docCLF => docCLF.Date >= dateDernièreDéconnection)
.ToListAsync();
site.NouveauxDocs = nouveauxDocCLFs
.Select(docCLF => nouveauCLFDoc(docCLF))
.ToList();
}
}
}
DemandeSite demandeSite = await _context.DemandeSite.Where(ns => ns.Email == identifiant.Email).FirstOrDefaultAsync();
if (demandeSite != null)
{
identifiant.NouveauSite = demandeSite;
}
return(identifiant);
}
