/// <summary>
/// Méthode qui transforme un administrateur DTO en administrateur POCO
/// </summary>
/// <param name="dto">administrateur DTO à transormer</param>
/// <param name="listeJeux">liste de jeux qui permet de verifier quels jeux vont devoir être ajouté à la liste de favoris de l'administrateur</param>
/// <returns>renvoie l'administrateur construis à partir de dto</returns>
public static Administrateur ToPOCO(this AdministrateurDTO dto, IEnumerable <JeuVidéo> listeJeux)
{
List <JeuVidéo> listeJeuxfav = new List <JeuVidéo>();
foreach (string nom in dto.ListeFavoris)
{
foreach (JeuVidéo jeu in listeJeux)
{
if (jeu.Nom == nom)
{
listeJeuxfav.Add(jeu); // si le nom d'un jeu de la liste de jeux et un nom de la liste de noms des jeux favoris sont égaux alors ajout du jeu à la liste de favoris de l'administrateur POCO créé
}
}
}
Administrateur user = new Administrateur(dto.Nom, dto.Prénom, dto.DateNaissance, dto.Pseudo, dto.MotDePasse, dto.Mail, listeJeuxfav);
return(user);
}
public ActionResult AddAvis(string titre, string avis)
{
Administrateur user = (Administrateur)Session["user"];
if (titre.Equals("directeur"))
{
Annonce directeur = _annonceService.GetAll().FirstOrDefault(o => o.Titre.Equals("directeur"));
if (directeur != null)
{
directeur.Contenu = avis;
directeur = _annonceService.Edit(directeur);
}
else
{
directeur = new Annonce
{
Titre = titre,
AdministrateurId = user.AdministrateurId,
DateAjout = DateTime.Now,
Contenu = avis
};
directeur = _annonceService.Add(directeur);
}
return(RedirectToAction("Index", "Administrateur"));
}
Annonce annonce = new Annonce
{
Titre = titre,
AdministrateurId = user.AdministrateurId,
DateAjout = DateTime.Now,
Contenu = avis
};
annonce = _annonceService.Add(annonce);
if (annonce == null)
{
return(RedirectToAction("Index", "Administrateur"));
}
return(RedirectToAction("Index", "Annonce"));
}
public ActionResult UserProfile(string email, string telephone)
{
Administrateur user = (Administrateur)Session["user"];
if (email == null || email.Equals(""))
{
return(View(user));
}
user.Email = email;
user.Telephone = telephone;
user = _administrateurService.Edit(user);
if (user == null)
{
user = _administrateurService.Get(user.AdministrateurId);
Session["user"] = user;
return(View(user));
}
Session["user"] = user;
return(View(user));
}
public ActionResult Avatar(HttpPostedFileBase image)
{
Administrateur user = (Administrateur)Session["user"];
if (image != null && image.ContentLength > 0)
{
var extension = Path.GetExtension(image.FileName);
if (!extension.ToLower().Equals(".jpg") && !extension.ToLower().Equals(".jpeg") && !extension.ToLower().Equals(".png"))
{
return(RedirectToAction("UserProfile"));
}
var path = "~/Resources/Profiles/" + user.Login.ToLower() + extension.ToLower();
user.ProfilePath = path;
user = _administrateurService.Edit(user);
if (user != null)
{
image.SaveAs(Path.Combine(Server.MapPath("~/Resources/Profiles"), user.Login.ToLower() + extension.ToLower()));
}
}
Session["user"] = _administrateurService.Get(user.AdministrateurId);
return(RedirectToAction("UserProfile"));
}
/// <summary>
/// Méthode qui sauvegarde les données dans un fichier de sauvegarde
/// </summary>
/// <param name="jeuVidéos">Liste de jeux à sauvegarder</param>
/// <param name="utilisateursConnectés">Liste d'utilisateurs à sauvegarder</param>
public void SauvegardeDonnées(IEnumerable <JeuVidéo> jeuVidéos, IEnumerable <UtilisateurConnecté> utilisateursConnectés)
{
if (!Directory.Exists(FilePath)) // vérification que le dossier de sauvegarde existe
{
Directory.CreateDirectory(FilePath); // Si non-existant alors on le crée
}
DataToPersist dataToPersist = new DataToPersist(); // initialisation des collections DTO
dataToPersist.ListeJeux.AddRange(jeuVidéos.ToDTOs()); // Ajouts des jeux POCO en jeux DTO pour être persistés
foreach (UtilisateurConnecté user in utilisateursConnectés) // Enumère tous les utilisateurs POCO de la liste d'utilisateur
{
if (user is Administrateur)
{
Administrateur admin = user as Administrateur;
dataToPersist.ListeAdministrateurs.Add(admin.ToDTO()); // Ajouts des administrateurs POCO en administrateurs DTO pour être persistés
continue; // Si user est un admin alors on recommence pour ne pas ajouter le user deux fois dans le XML
}
if (user is UtilisateurConnecté)
{
dataToPersist.ListeUtilisateurs.Add(user.ToDTO()); // Ajouts des utlisateurs POCO en utilisateurs DTO pour être persistés
}
}
var paramètres = new XmlWriterSettings()
{
Indent = true
}; // instancie une classe qui permet de choisir des paramètres pour l'écriture dans le fichier de sauvegarde
using (TextWriter tw = File.CreateText(DataFile)) // instanciation du flux de donnée t en écriture -> on utilise using pour pas oublier de fermer le fichier car appel implicite et automatique de dispose() pour nettoyer données non-managées
{
using (XmlWriter writer = XmlWriter.Create(tw, paramètres)) // using qui permet d'écrire la liste de jeux vidéos dans le fichier voulu à l'aide de serializer. Le writer permet de donner des paramètres (indentation)
{
Serializer.WriteObject(writer, dataToPersist); // sérialisation des données dans le fichier voulu avec les paramètres voulus
}
}
}
private void button1_Click(object sender, EventArgs e)
{
string Insertion1 = "delete from compte where Pwd=?";
MySqlCommand cmd1 = new MySqlCommand(Insertion1, ManipulationBD.Cnn);
MySqlParameter p1 = new MySqlParameter("Pwd", Pwd.Text);
cmd1.Parameters.Add(p1);
try
{
Administrateur admin = new Administrateur();
ManipulationBD.ConnectionDataBase();
cmd1.ExecuteNonQuery();
MessageBox.Show("Suppression effectuez");
}
catch (Exception r)
{
MessageBox.Show(r.Message);
}
finally
{
ManipulationBD.DecoonectionDataBase();
}
}
//Obtention de tous les administrateurs
public static List <Administrateur> GetAll()
{
//Obtention de la dataTable
OdawaDS.administrateursDataTable dt = DataProvider.GetAdministrateurs();
//Création d'une liste vide
List <Administrateur> lst = new List <Administrateur>();
//Pour chaque administrateur dans la dataTable
foreach (OdawaDS.administrateursRow adminRow in dt.Rows)
{
Administrateur a = new Administrateur();
a.id = adminRow.id;
a.nom = adminRow.nom;
a.prenom = adminRow.prenom;
a.username = adminRow.username;
a.password = adminRow.password;
a.email = adminRow.email;
a.phone = adminRow.phone;
//Ajout à la liste
lst.Add(a);
}
//retourne la liste
return(lst);
}
//Création administrateur avec l'objet "a" passé en paramètre
public static bool Create(Administrateur a)
{
//Création d'une administrateursRow et remplissage avec les attributs de "a"
OdawaDS.administrateursRow newRow = DataProvider.odawa.administrateurs.NewadministrateursRow();
newRow.nom = a.nom.ToUpper();
newRow.prenom = a.prenom;
newRow.username = a.username.ToLower();
newRow.password = a.password;
newRow.email = a.email.ToLower();
newRow.phone = a.phone;
//Envoi à la DAL
try
{
DataProvider.CreateAdministrateur(newRow);
//si ok, renvoie true
return(true);
}
catch (System.Data.SqlClient.SqlException e)
{
//si SQLException, log et renvoie false
LogManager.LogSQLException(e.Message);
return(false);
}
}
public Administrateur CreationCompteAdmin(Administrateur a)
{
return(idao.CreationCompteAdmin(a));
}
void IUserService.CreateAdministrateur(Administrateur a)
{
utOfWork.UserRepository.Add(a);
}
public void AddAdministrateur(Administrateur entity)
{
_contextAdmin.Add(entity);
}
public void TestAdmin_Creation()
{
var personne = new Administrateur("Jean", "Admin", "jp", "pj");
Assert.AreEqual(personne.Nom, "Jean");
}
public void RemoveAdministrateur(Administrateur entity)
{
_contextAdmin.Remove(entity);
}
public ActionResult AjouterAdministrateur(Administrateur a)
{
Iadministrateur.CreationCompteAdmin(a);
return(RedirectToAction("ListerAdministrateur"));
}
public void Entry(Administrateur e)
{
this.context.Entry(e).State = System.Data.EntityState.Modified;
}
public void Edit(Administrateur e)
{
this.context.Entry(e).State = EntityState.Modified;
}
private bool Validate(Administrateur a)
{
//Expression régulière pour nom et prénom: caractères maj-min + (- espace '), longueur entre 2 et 30
var nomRegex = new Regex(@"^[-'a-zA-Z ]{2,30}$");
//Expression régulière pour nom d'utilisateur: caractères maj-min uniquement, longueur entre 3 et 30
var usernameRegex = new Regex(@"^[a-zA-Z]{3,30}$");
//Expression régulière pour email: "caractère(s) et/ou tiret(s) et point(s) + @ + caractère(s) et/ou tiret(s) + point + 2-3 caractères
var emailRegex = new Regex(@"^\w+[\w-\.]*\@\w+((-\w+)|(\w*))\.[a-z]{2,3}$");
//Expression régulière pour numéro de téléphone: commence par 0 + [1-9] + [0-9] * 7 ou 8 (fixe ou mobile)
var phoneRegex = new Regex(@"^0[1-9][0-9]{7,8}$");
//Initialisation de la couleur des labels à "par défaut"
labelNom.ForeColor = Color.Empty;
labelPrenom.ForeColor = Color.Empty;
labelUsername.ForeColor = Color.Empty;
labelPassword.ForeColor = Color.Empty;
labelEmail.ForeColor = Color.Empty;
labelPhone.ForeColor = Color.Empty;
//Initialisation de la validité à "vrai"
bool valid = true;
//Initialisation du message d'erreur
string message = "";
//Si le nom ne correspond pas à l'expression régulière nomRegex
if (!nomRegex.IsMatch(a.nom))
{
labelNom.ForeColor = Color.Red;
valid = false;
message += "- Nom invalide\n";
}
//Si le prénom ne correspond pas à l'expression régulière nomRegex
if (!nomRegex.IsMatch(a.prenom))
{
labelPrenom.ForeColor = Color.Red;
valid = false;
message += "- Prénom invalide\n";
}
//Si le nom d'utilisateur ne correspond pas à l'expression régulière usernameRegex
if (!usernameRegex.IsMatch(a.username))
{
labelUsername.ForeColor = Color.Red;
valid = false;
message += "- Nom d'utilisateur invalide\n";
}
//Si le nom d'utilisateur existe déjà et que c'est une création
if (AdministrateurManager.GetAll().Find(x => x.username == a.username) != null && a.id == -1)
{
labelUsername.ForeColor = Color.Red;
valid = false;
message += "- Nom d'utilisateur déjà existant\n";
}
//Si le mot de passe est plus court que 4 ou plus long que 30
if (a.password.Length < 4 || a.password.Length > 30)
{
labelPassword.ForeColor = Color.Red;
valid = false;
message += "- Mot de passe invalide\n";
}
//Si l'email ne correspond pas à l'expression régulière usernameRegex
if (!emailRegex.IsMatch(a.email))
{
labelEmail.ForeColor = Color.Red;
valid = false;
message += "- Email invalide\n";
}
//Si l'email existe déjà et que c'est une création
if (AdministrateurManager.GetAll().Find(x => x.email == a.email) != null && a.id == -1)
{
labelEmail.ForeColor = Color.Red;
valid = false;
message += "- Email déjà existant\n";
}
//Si le numéro de téléphone ne correspond pas à l'expression régulière phoneRegex
if (!phoneRegex.IsMatch(a.phone))
{
labelPhone.ForeColor = Color.Red;
valid = false;
message += "- Numéro de téléphone invalide\n";
}
//Si l'administrateur envoyé par le form est invalide
if (!valid)
{
//Affichage du message d'erreur
string caption = "Erreur";
MessageBoxButtons buttons = MessageBoxButtons.OK;
MessageBoxIcon icon = MessageBoxIcon.Error;
MessageBox.Show(message, caption, buttons, icon);
}
//retourne valid
return(valid);
}
public Administrateur modifierCompteAdmin(Administrateur a)
{
return(idao.modifierCompteAdmin(a));
}
public void Initialize()
{
_admin = new Administrateur(_nom, _type, _login, _mdp);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
//Gestion de l'héritage : modèle-per-hierarchy
modelBuilder.Entity <Utilisateur>()
.HasDiscriminator <string>("Type_Utilisateur")
.HasValue <Client>("est_client")
.HasValue <Gestionnaire>("est_gestionnaire")
.HasValue <Administrateur>("est_administrateur")
.HasValue <Utilisateur>("est_utilisateur");
modelBuilder.Entity <Article>()
.HasDiscriminator <string>("Type_Article")
.HasValue <Service>("est_service")
.HasValue <Produit>("est_produit")
.HasValue <Article>("est_article");
// Ajout de rôles
Role role1 = new Role()
{
RoleId = 1, Title = "Role1"
};
Role role2 = new Role()
{
RoleId = 2, Title = "Role2"
};
Role role3 = new Role()
{
RoleId = 3, Title = "Role3"
};
Role role4 = new Role()
{
RoleId = 4, Title = "Role4"
};
modelBuilder.Entity <Role>().HasData(
role1,
role2,
role3,
role4
);
// Ajout de stocks
Stock stock1 = new Stock()
{
StockId = 1, Titre = "stockClassique"
};
Stock stock2 = new Stock()
{
StockId = 2, Titre = "stockNouveautes"
};
Stock stock3 = new Stock()
{
StockId = 3, Titre = "stockAncien"
};
modelBuilder.Entity <Stock>().HasData(
stock1,
stock2,
stock3
);
// Ajout de gestionnaires
Gestionnaire gestionnaire1 = new Gestionnaire()
{
UtilisateurId = 1,
Login = "******",
Email = "*****@*****.**",
NomGestionnaire = "McCormick",
RoleId = role1.RoleId,
StockId = stock3.StockId,
MotDePasse = Utilitaire.HashPassword("gsnPsw1")
};
Gestionnaire gestionnaire2 = new Gestionnaire()
{
UtilisateurId = 2,
Login = "******",
Email = "*****@*****.**",
NomGestionnaire = "Marsh",
RoleId = role2.RoleId,
StockId = stock1.StockId,
MotDePasse = Utilitaire.HashPassword("gsnPsw2")
};
Gestionnaire gestionnaire3 = new Gestionnaire()
{
UtilisateurId = 3,
Login = "******",
Email = "*****@*****.**",
NomGestionnaire = "Broslovsky",
RoleId = role2.RoleId,
StockId = stock2.StockId,
MotDePasse = Utilitaire.HashPassword("gsnPsw3")
};
modelBuilder.Entity <Gestionnaire>().HasData(
gestionnaire1,
gestionnaire2,
gestionnaire3
);
// Ajout d'administrateur
Administrateur administrateur1 = new Administrateur()
{
UtilisateurId = 4,
Login = "******",
NomAdministrateur = "Butters",
Mail = "*****@*****.**",
MotDePasse = Utilitaire.HashPassword("adminPsw1")
};
modelBuilder.Entity <Administrateur>().HasData(
administrateur1
);
// Ajout d'un abonnement nul
Abonnement abonnement1 = new Abonnement()
{
AbonnementId = 1,
DureeAbonnement = 0
};
modelBuilder.Entity <Abonnement>().HasData(
abonnement1
);
// Ajout d'un client nul
Client client1 = new Client()
{
UtilisateurId = 5,
Login = "******",
Nom = "Defaut",
Mail = "*****@*****.**",
GestionnaireAssocieId = gestionnaire1.UtilisateurId,
MotDePasse = Utilitaire.HashPassword("azegaze684qs3dqsd!:sdfàçzqè_"),
};
modelBuilder.Entity <Client>().HasData(
client1
);
// Ajout d'un compte nul
Compte compte1 = new Compte()
{
CompteId = 1,
NomCompte = "CompteDefaut",
ClientId = client1.UtilisateurId
};
modelBuilder.Entity <Compte>().HasData(
compte1
);
// Ajout d'un panier nul
Panier panier1 = new Panier()
{
PanierId = 1,
CompteId = compte1.CompteId
};
modelBuilder.Entity <Panier>().HasData(
panier1
);
}
public Administrateur Post(Administrateur a)
{
return(AdministrateurDAO.Create(a));
}
public ActionResult Login(ViewModels.LoginViewModel login)
{
using (ApplicationDbContext db = new ApplicationDbContext())
{
var usr = db.Users.SingleOrDefault(u => u.email.Equals(login.email) && u.password.Equals(login.password));
if (usr != null)
{
if (usr.type == login.selectedType)
{
SessionHelper session = new SessionHelper();
switch (usr.type)
{
case "Enseignant":
Enseignant enseignant = (Enseignant)usr;
session.enseignant = enseignant;
return(RedirectToAction("Index", "Enseignant", new { area = "" }));
case "Parent":
Parent parent = (Parent)usr;
session.parent = parent;
return(RedirectToAction("Index", "Parent", new { area = "" }));
case "Administration":
Administration administration = (Administration)usr;
session.administration = administration;
return(RedirectToAction("Index", "Administration", new { area = "" }));
case "Administrateur":
Administrateur administrateur = (Administrateur)usr;
session.administrateur = administrateur;
return(RedirectToAction("Index", "Administrateur", new { area = "" }));
case "Coordinateur":
Coordinateur coordinateur = (Coordinateur)usr;
session.coordinateur = coordinateur;
return(RedirectToAction("Index", "Coordinateur", new { area = "" }));
}
}
}
else
{
ModelState.AddModelError("", "Informations invalides");
}
}
ViewModels.LoginViewModel loginvm = new ViewModels.LoginViewModel();
loginvm.type = new List <SelectListItem>
{
new SelectListItem {
Text = "Administrateur", Value = "Administrateur"
},
new SelectListItem {
Text = "Enseignant", Value = "Enseignant"
},
new SelectListItem {
Text = "Parent", Value = "Parent"
},
new SelectListItem {
Text = "Coordinateur", Value = "Coordinateur"
},
new SelectListItem {
Text = "Administration", Value = "Administration"
}
};
ModelState.AddModelError("error_user", "Utilisateur non trouvé");
return(View(loginvm));
}
public void UpdateAdministrateur(Administrateur entity)
{
_contextAdmin.Update(entity);
}
void IUserService.UpdateAdministrateurDetached(Administrateur e)
{
utOfWork.UserRepository.UpdateAdministrateurDetached(e);
}
public ActionResult ajouterAdministrateur(Administrateur a)
{
iadmin.creationCompteAdmin(a);
return(RedirectToAction("listerAdministrateur"));
}
public static void Initialize(gestionAPI_DBContext context)
{
//On s'assure que la BDD a bien été créée
context.Database.EnsureCreated();
if (context.Roles.Any())
{
return;
}
// Ajout de rôles
Role role1 = new Role()
{
Title = "Role1"
};
Role role2 = new Role()
{
Title = "Role2"
};
Role role3 = new Role()
{
Title = "Role3"
};
Role role4 = new Role()
{
Title = "Role4"
};
context.Roles.Add(role1);
context.Roles.Add(role2);
context.Roles.Add(role3);
context.Roles.Add(role4);
// Ajout de gestionnaires
Gestionnaire gestionnaire1 = new Gestionnaire()
{
Login = "******",
Email = "*****@*****.**",
NomGestionnaire = "McCormick",
Role = role2,
MotDePasse = Utilitaire.HashPassword("gsnPsw1")
};
Gestionnaire gestionnaire2 = new Gestionnaire()
{
Login = "******",
Email = "*****@*****.**",
NomGestionnaire = "Marsh",
Role = role3,
MotDePasse = Utilitaire.HashPassword("gsnPsw2")
};
Gestionnaire gestionnaire3 = new Gestionnaire()
{
Login = "******",
Email = "*****@*****.**",
NomGestionnaire = "Broslovsky",
Role = role1,
MotDePasse = Utilitaire.HashPassword("gsnPsw3")
};
context.Gestionnaires.Add(gestionnaire1);
context.Gestionnaires.Add(gestionnaire2);
context.Gestionnaires.Add(gestionnaire3);
// Ajout de stocks
Stock stock1 = new Stock()
{
Titre = "stockClassique", ResponsableStock = gestionnaire2
};
Stock stock2 = new Stock()
{
Titre = "stockNouveautes", ResponsableStock = gestionnaire3
};
Stock stock3 = new Stock()
{
Titre = "stockAncien", ResponsableStock = gestionnaire1
};
context.Stocks.Add(stock1);
context.Stocks.Add(stock2);
context.Stocks.Add(stock3);
// Ajout d'administrateur
Administrateur administrateur1 = new Administrateur()
{
Login = "******",
NomAdministrateur = "Butters",
Mail = "*****@*****.**",
MotDePasse = Utilitaire.HashPassword("adminPsw1")
};
context.Administrateurs.Add(administrateur1);
// Ajout d'un abonnement nul
Abonnement abonnement1 = new Abonnement()
{
DureeAbonnement = 0
};
context.Abonnements.Add(abonnement1);
// Ajout d'un client nul
Client client1 = new Client()
{
Login = "******",
Nom = "Defaut",
Mail = "*****@*****.**",
MotDePasse = Utilitaire.HashPassword("azegaze684qs3dqsd!:sdfàçzqè_"),
};
context.Clients.Add(client1);
// Ajout d'un compte nul
Compte compte1 = new Compte()
{
NomCompte = "CompteDefaut",
ClientId = 2,
};
context.Comptes.Add(compte1);
// Ajout d'un panier nul
Panier panier1 = new Panier()
{
Compte = compte1
};
context.Paniers.Add(panier1);
context.SaveChanges();
}
