public bool UtilisateurExiste(UTILISATEUR user)
{
using (var db = new DataBaseIShopEntities())
{
return(db.UTILISATEUR.Any(utilisateur => string.Compare(utilisateur.EMAIL_UTILISATEUR, user.EMAIL_UTILISATEUR, StringComparison.CurrentCultureIgnoreCase) == 0));
}
}
public async Task <IActionResult> Edit(int id, [Bind("UTILISATEURID,UTI_UTILISATEURID,DESIGNATION,EMAIL,TYPEUTILISATEUR")] UTILISATEUR uTILISATEUR)
{
if (id != uTILISATEUR.UTILISATEURID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(uTILISATEUR);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UTILISATEURExists(uTILISATEUR.UTILISATEURID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(uTILISATEUR));
}
/*pour aller a la page de modification du mot de passe*/
public ActionResult UpdatePassword(Guid?token)
{
redactapplicationEntities db = new Models.redactapplicationEntities();
UTILISATEUR utilisateur = db.UTILISATEURs.SingleOrDefault(x => x.token == token);
/*l'utilisateur est null si le token n'existe pas/plus dans la base de donnees*/
if (utilisateur == null)
{
return(RedirectToAction("ExpiredLink", "Login"));
}
else
{
DateTime now = DateTime.Now;
if (utilisateur.dateToken != null)
{
DateTime dateToken = (DateTime)utilisateur.dateToken;
double nbrTime = (now - dateToken).TotalMinutes;
if (nbrTime > 60.0)
{
return(RedirectToAction("ExpiredLink", "Login"));
}
}
}
Session["tokenPass"] = token;
return(View());
}
// PUT api/Utilisateurs/5
public HttpResponseMessage PutUTILISATEUR(int id, UTILISATEUR utilisateur)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
if (id != utilisateur.ID_UTILISATEUR)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
UTILISATEUR existing = GetUTILISATEUR(id);
((IObjectContextAdapter)db).ObjectContext.Detach(existing);
db.Entry(utilisateur).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, ex));
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
public JsonResult GetInfoUser()
{
UTILISATEUR user = new UTILISATEUR();
user = GetSessionUser();
if (user.E_MAIL == null)
{
user = null;
}
if (user != null)
{
return(Json(new
{
email = user.E_MAIL,
statut = user.STATUT,
},
JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new
{
email = "",
statut = "",
},
JsonRequestBehavior.AllowGet));
}
}
public ActionResult CONSULTERINFOSGROUPECIBLE(GroupeCibleVM2 gcvm2)
{
using (IDAL dal = new Dal())
{
if (dal.VerifierAccesParUtilisateurIdParPrivilegePeut(HttpContext.User.Identity.Name, "CONSULTER_INFOS_GROUPECIBLE"))
{
//if (ModelState.IsValid)
//{
UTILISATEUR currentUser = dal.ObtenirUtilisateurParId(HttpContext.User.Identity.Name);
if (currentUser.UtilisateurID == gcvm2.Admin.Id) //ou est un administrateur
{
GROUPECIBLE tempG = new GROUPECIBLE();
tempG.GroupeCibleID = gcvm2.Id;
tempG.Intitule = gcvm2.Intitule;
tempG.Objet = gcvm2.Objet;
tempG.DateClotureGroupe = gcvm2.DateClotureGroupe;
tempG.Administrateur = dal.ObtenirUtilisateurParId(gcvm2.Administrateur);
tempG.Type = dal.ObtenirTypeGroupeParId(gcvm2.type);
if (tempG.Administrateur != null && tempG.Type != null)
{
dal.ModifierGroupeCible(tempG);
}
}
//}
return(RedirectToAction("CONSULTERINFOSGROUPECIBLE", new { id = gcvm2.Id }));
}
else
{
ViewBag.ErrorMessage = dal.getErrorMessageFailedAuthorization();
return(View("Error"));
}
}
}
public ActionResult test(int id, string nom, string prenom, string email, int id_ROLE, string motDePasse)
{
UTILISATEUR listUTILISATEUR = new UTILISATEUR();
using (var dada = new Context())
{
//Hash MotDepasseHash = new Hash();
//string PhraseCles = "ATOSPROJECT" + motDePasse + "DOTNET";
listUTILISATEUR = dada.UTILISATEUR.Where((client) => client.id == id).First();
listUTILISATEUR.nom = nom;
listUTILISATEUR.prenom = prenom;
listUTILISATEUR.nomDeCompte = email;
listUTILISATEUR.id_ROLE = id_ROLE;
listUTILISATEUR.motDePasse = motDePasse;
dada.SaveChanges();
}
List <UTILISATEUR> newUser = new List <UTILISATEUR>();
using (var dada = new Context())
{
newUser = dada.UTILISATEUR.ToList();
}
// PartialView("TableauUtilisateur", newUser);
return(PartialView("TableauUtilisateur", newUser));
//return RedirectToAction("Index", newUser); ;
}
public ActionResult MANAGEACCOUNT(UtilisateurVM5 user)
{
using (IDAL dal = new Dal())
{
if (dal.VerifierAccesParUtilisateurIdParPrivilegePeut(HttpContext.User.Identity.Name, "GERER_COMPTE_UTILISATEUR"))
{
UTILISATEUR u = dal.ObtenirUtilisateurParId(CRYPTAGE.StringHelpers.Encrypt(user.Id));
if (u != null)
{
if (!String.IsNullOrEmpty(user.Password) && !String.IsNullOrWhiteSpace(user.Password))
{
u.Password = user.Password;
}
if (!String.IsNullOrEmpty(user.Login) && !String.IsNullOrWhiteSpace(user.Login))
{
u.Login = user.Login;
}
u.Role = dal.ObtenirRoleParId(user.RoleID);
u.Actif = user.Actif;
if (u.Role != null && !u.Role.IsDeleted)
{
dal.EnregistrerUtilisateur(u);
}
}
return(RedirectToAction("CONSULTERLISTEUTILISATEUR"));
}
else
{
ViewBag.NomUtilisateur = user.NomUtilisateur;
ViewBag.ErrorMessage = dal.getErrorMessageFailedAuthorization();
return(View("Error"));
}
}
}
/*pour envoyer un mail de reset password a un utilisateur*/
public ActionResult SendMail(UTILISATEURViewModel model)
{
redactapplicationEntities db = new Models.redactapplicationEntities();
UTILISATEUR utilisateur = db.UTILISATEURs.FirstOrDefault(x => x.userMail == model.userMail);
Guid TemporaryIdUser = Guid.NewGuid();
if (utilisateur == null)
{
return(View("ErrorUserNotExist"));
}
if (Request.Url != null)
{
var url = Request.Url.Scheme;
if (Request.Url != null)
{
string callbackurl = Request.Url.Host != "localhost"
? Request.Url.Host
: Request.Url.Authority;
var port = Request.Url.Port;
if (!string.IsNullOrEmpty(port.ToString()) && Request.Url.Host != "localhost")
{
callbackurl += ":" + port;
}
url += "://" + callbackurl;
}
ViewBag.mailRecepteur = model.userMail;
//var body = "<p>Email From: {0} ({1})</p><p>Message:</p><p>{2}</p>";
StringBuilder mailBody = new StringBuilder();
mailBody.AppendFormat(CultureInfo.CurrentCulture.TextInfo.ToTitleCase(utilisateur.userNom.ToLower()) + ",");
mailBody.AppendFormat("<br />");
mailBody.AppendFormat("<p>Votre avez récemment demandé de réinitialiser votre mot de passe pour le compte " + CultureInfo.CurrentCulture.TextInfo.ToTitleCase(utilisateur.userNom.ToLower()) + " .Cliquez sur le lien ci-dessous pour le réinitialiser.</p>");
mailBody.AppendFormat("<br />");
mailBody.AppendFormat(url + "/Login/UpdatePassword?token=" + TemporaryIdUser);
mailBody.AppendFormat("<br />");
mailBody.AppendFormat("<p> Si vous n'avez pas demandé la réinitialisation du mot de passe, ignorez cet e-mail. </p>");
mailBody.AppendFormat("<br />");
mailBody.AppendFormat("Codialement.");
mailBody.AppendFormat("<br />");
mailBody.AppendFormat("Media click App .");
bool isSendMail = MailClient.SendMail(model.userMail, mailBody.ToString(), "Media click App - réinitialisation du mot de passe oublié.");
if (isSendMail)
{
utilisateur.token = TemporaryIdUser;
utilisateur.dateToken = DateTime.Now;
int result = db.SaveChanges();
if (result <= 0)
{
return(View("ErrorConfiguration"));
}
return(View("SendMailSuccess", model));
}
}
return(View("ErrorConfiguration"));
}
/*pour envoyer un mail de reset password a un utilisateur*/
public ActionResult SendMail(UTILISATEURViewModel model)
{
redactapplicationEntities db = new Models.redactapplicationEntities();
UTILISATEUR utilisateur = db.UTILISATEURs.FirstOrDefault(x => x.userMail == model.userMail);
Guid TemporaryIdUser = Guid.NewGuid();
if (utilisateur == null)
{
return(View("ErrorUserNotExist"));
}
if (Request.Url != null)
{
var url = Request.Url.Scheme;
if (Request.Url != null)
{
string callbackurl = Request.Url.Host != "localhost"
? Request.Url.Host
: Request.Url.Authority;
var port = Request.Url.Port;
if (!string.IsNullOrEmpty(port.ToString()) && Request.Url.Host != "localhost")
{
callbackurl += ":" + port;
}
url += "://" + callbackurl;
}
ViewBag.mailRecepteur = model.userMail;
//var body = "<p>Email From: {0} ({1})</p><p>Message:</p><p>{2}</p>";
StringBuilder mailBody = new StringBuilder();
mailBody.AppendFormat("Dear " + CultureInfo.CurrentCulture.TextInfo.ToTitleCase(utilisateur.userNom.ToLower()));
mailBody.AppendFormat("<br />");
mailBody.AppendFormat("<p>Your recently requested to reset your password for your " + CultureInfo.CurrentCulture.TextInfo.ToTitleCase(utilisateur.userNom.ToLower()) + " account. Click the link bellow to reset it.</p>");
mailBody.AppendFormat("<br />");
mailBody.AppendFormat(url + "/Login/UpdatePassword?token=" + TemporaryIdUser);
mailBody.AppendFormat("<br />");
mailBody.AppendFormat("<p>If you did not request a password reset, please ignore this email. </p>");
mailBody.AppendFormat("<br />");
mailBody.AppendFormat("Thanks.");
mailBody.AppendFormat("<br />");
mailBody.AppendFormat("Mediaclick Company.");
bool isSendMail = MailClient.SendResetPasswordMail(model.userMail, mailBody.ToString(), "Redact application - forgotten password.");
if (isSendMail)
{
utilisateur.token = TemporaryIdUser;
utilisateur.dateToken = DateTime.Now;
int result = db.SaveChanges();
if (result <= 0)
{
return(View("ErrorConfiguration"));
}
return(View("SendMailSuccess", model));
}
}
return(View("ErrorConfiguration"));
}
public ActionResult DeleteConfirmed(int id)
{
UTILISATEUR user = db.UTILISATEURs.Find(id);
db.UTILISATEURs.Remove(user);
db.SaveChanges();
return(RedirectToAction("_Index"));
}
public ActionResult DeleteConfirmed(short id)
{
UTILISATEUR uTILISATEUR = db.UTILISATEUR.Find(id);
db.UTILISATEUR.Remove(uTILISATEUR);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "UTILISATEURID,DESIGNATION,EMAIL,TYPEUTILISATEUR")] UTILISATEUR uTILISATEUR)
{
if (ModelState.IsValid)
{
db.Entry(uTILISATEUR).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(uTILISATEUR));
}
public SOCIETE TrouveSociete(short idUtilisateur)
{
UTILISATEUR utilisateur = new UTILISATEUR();
SOCIETE societe = new SOCIETE();
utilisateur = dal.bdd.UTILISATEUR.FirstOrDefault(u => u.ID_UTILISATEUR == idUtilisateur);
societe = dal.bdd.SOCIETE.FirstOrDefault(s => s.ID_SOCIETE == utilisateur.ID_SOCIETE);
return(societe);
}
public ActionResult CreerCompte(UTILISATEUR utilisateur)
{
if (ModelState.IsValid)
{
int id = utilisateurModel.AjouterUtilisateur(utilisateur);
FormsAuthentication.SetAuthCookie(id.ToString(), false);
return(Redirect("/"));
}
return(View(utilisateur));
}
public ActionResult ENREGISTRERREGLEMENT(String Id)
{
using (IDAL dal = new Dal())
{
if (dal.VerifierAccesParUtilisateurIdParPrivilegePeut(HttpContext.User.Identity.Name, "ENREGISTRER_REGLEMENT"))
{
CAISSE CaisseOuverte = dal.CaisseOuverteParCaissierId(HttpContext.User.Identity.Name);
if (CaisseOuverte != null)
{
ReglementVM RVM = new ReglementVM();
FACTURE fact = dal.ObtenirFactureParId(CRYPTAGE.StringHelpers.Encrypt(Id));
if (fact != null)
{
FactureVM2 FVM = dal.ConvertirFactureFactureVM2(fact);
RVM.FactureId = FVM.Id;
RVM.Patient = FVM.Patient;
RVM.ReferenceFacture = FVM.Reference;
RVM.Montant = FVM.Montant;
RVM.Reste = FVM.Montant - dal.SommeTotalePayeeParFacture(fact);
RVM.CaisseId = CaisseOuverte.CaisseID;
RVM.Caisse = CRYPTAGE.StringHelpers.Decrypt(CaisseOuverte.Nom);
UTILISATEUR GerantCaisse = dal.ObtenirUtilisateurParId(HttpContext.User.Identity.Name);
if (GerantCaisse != null)
{
RVM.CaissierId = GerantCaisse.UtilisateurID;
RVM.Caissier = CRYPTAGE.StringHelpers.Decrypt(GerantCaisse.Personne.Nom) + " " + CRYPTAGE.StringHelpers.Decrypt(GerantCaisse.Personne.Prenom);
}
ViewBag.ListeModePaiement = dal.ObtenirTousLesModePaiements();
return(View("FormulaireAjoutReglement", RVM));
}
else
{
ViewBag.ErrorMessage = "Rassurez-vous que cette facture existe.";
return(View("Error"));
}
}
else
{
ViewBag.ErrorMessage = "Rassurez-vous que votre Caisse est OUVERTE et qu'elle vous a été affectée.";
return(View("Error"));
}
}
else
{
ViewBag.ErrorMessage = dal.getErrorMessageFailedAuthorization();
return(View("Error"));
}
}
}
public ActionResult Create([Bind(Include = "UTILISATEURID,DESIGNATION,EMAIL,TYPEUTILISATEUR")] UTILISATEUR uTILISATEUR)
{
if (ModelState.IsValid)
{
db.UTILISATEURs.Add(uTILISATEUR);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(uTILISATEUR));
}
public UTILISATEUR GetSessionUser()
{
UTILISATEUR User = new UTILISATEUR();
User.E_MAIL = GetUserEmail();
User.NOM = GetUserNom();
User.PRENOM = GetUserPrenom();
User.STATUT = GetUserStatut();
_user = User;
return(_user);
}
public async Task <IActionResult> Create([Bind("UTILISATEURID,UTI_UTILISATEURID,DESIGNATION,EMAIL,PWD,TYPEUTILISATEUR")] UTILISATEUR uTILISATEUR)
{
if (ModelState.IsValid)
{
_context.Add(uTILISATEUR);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(uTILISATEUR));
}
public UTILISATEUR Login(UTILISATEUR user)
{
using (var db = new DataBaseIShopEntities())
{
utilisateur = db.UTILISATEUR.Where(u => u.EMAIL_UTILISATEUR == user.EMAIL_UTILISATEUR)
.Where(u => u.MDP_UTILISATEUR == user.MDP_UTILISATEUR).First();
//utilisateur = db.UTILISATEUR.FirstOrDefault(u => u.EMAIL_UTILISATEUR == user.EMAIL_UTILISATEUR);
return(utilisateur);
}
}
// GET api/Utilisateurs/5
public UTILISATEUR GetUTILISATEUR(int id)
{
UTILISATEUR utilisateur = db.UTILISATEURs.Find(id);
if (utilisateur == null)
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
}
return(utilisateur);
}
// GET: Panier
public ActionResult Index()
{
UTILISATEUR utilisateur = (UTILISATEUR)Session["CurrentUSer"];
if (utilisateur != null)
{
//COMMANDE panier = panierModel.listeProduitPanier(utilisateur.ID_UTILISATEUR);
List <PRODUIT> panier = panierModel.listeProduitPanier(utilisateur.ID_UTILISATEUR);
return(View(panier));
}
return(View());
}
public ActionResult Edit([Bind(Include = "ID_UTILISATEUR,ID_SOCIETE,ID_VILLE,NOM_UTILISATEUR,PRENOM_UTILISATEUR,EMAIL_UTILISATEUR,MDP_UTILISATEUR,DATE_NAISSANCE_UTILISATEUR,ADR_UTILISATEUR,TYPE_UTILISATEUR,DROIT_UTILISATEUR")] UTILISATEUR uTILISATEUR)
{
if (ModelState.IsValid)
{
db.Entry(uTILISATEUR).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ID_SOCIETE = new SelectList(db.SOCIETE, "ID_SOCIETE", "LIBELLE_SOCIETE", uTILISATEUR.ID_SOCIETE);
ViewBag.ID_VILLE = new SelectList(db.VILLE, "ID_VILLE", "NOM_VILLE", uTILISATEUR.ID_VILLE);
return(View(uTILISATEUR));
}
public ActionResult edit(int editeur)
{
UTILISATEUR listUTILISATEUR = new UTILISATEUR();
using (var dada = new Context())
{
listUTILISATEUR = dada.UTILISATEUR.Where((client) => client.id == editeur).First();
}
return(PartialView("EditModal", listUTILISATEUR));
//return View(listUTILISATEUR);
}
public void CreerUtilisateur(UTILISATEUR user)
{
using (var db = new DataBaseIShopEntities())
{
db.UTILISATEUR.Add(new UTILISATEUR {
NOM_UTILISATEUR = user.NOM_UTILISATEUR, PRENOM_UTILISATEUR = user.PRENOM_UTILISATEUR,
EMAIL_UTILISATEUR = user.EMAIL_UTILISATEUR, MDP_UTILISATEUR = user.MDP_UTILISATEUR, TYPE_UTILISATEUR = "Client",
ADR_UTILISATEUR = user.ADR_UTILISATEUR
});
db.SaveChanges();
}
}
public static D.UTILISATEUR ToDAL(this UTILISATEUR u)
{
return(new D.UTILISATEUR
{
UserId = u.UserId,
Login = u.Login,
Password = u.Password,
isAdmin = u.isAdmin,
isPromo = u.isPromo,
isFinanceur = u.isFinanceur,
isActive = u.isActive
});
}
// GET: Course/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
UTILISATEUR user = db.UTILISATEURs.Find(id);
if (user == null)
{
return(HttpNotFound());
}
return(View(user));
}
// GET: Administration/Utilisateur/Details/5
public ActionResult Details(short?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
UTILISATEUR uTILISATEUR = db.UTILISATEUR.Find(id);
if (uTILISATEUR == null)
{
return(HttpNotFound());
}
return(View(uTILISATEUR));
}
public ActionResult SupprimerPanier(short?id)
{
//short id = (short)Session["CurrentProdId"];
PRODUIT p1 = panierModel.getProduit(id);
UTILISATEUR utilisateur = (UTILISATEUR)Session["CurrentUSer"];
if (utilisateur != null)
{
panierModel.SupprimerProduitPanier(p1.ID_PRODUIT, utilisateur.ID_UTILISATEUR);
return(RedirectToAction("Index"));
}
return(View("Index"));
}
public ActionResult getUser(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
UTILISATEUR utilisateur = db.UTILISATEURs.Find(id);
if (utilisateur == null)
{
return(HttpNotFound());
}
return(View(utilisateur));
}
