private void AddUtilisateur()
{
Models.Utilisateur u = new Models.Utilisateur();
u.Email = email;
u.Login = login;
u.MotPasse = motpasse;
u.PersonnelId = personnelid;
u.EstActif = estactif;
_serviceutil = new UtilisateurRepository();
_serviceutil.Create(new UIGestmetModelsClient.Utilisateur(u.Email, u.Login, u.MotPasse, u.PersonnelId, u.EstActif));
// tester avec try catch si la connection avec la db s'est bien faite et if si il y a bien eu un enrgistrement de creer
// UtilisateurList.Add(u);
//UtilisateurList.Clear();
UtilisateurList = new ObservableCollection <Models.Utilisateur>(_serviceutil.GetAll().Select(ug => new Models.Utilisateur
{
Id = ug.Id,
Email = ug.Email,
Login = ug.Login,
MotPasse = ug.MotPasse,
PersonnelId = ug.PersonnelId,
EstActif = ug.EstActif
}));
// AddCommand = new RelayCommand(AddUtilisateur);
// RemoveCommand = new RelayCommand<Models.Utilisateur>(RemoveUtilisateur);
}
private void OpenListeCompteClient()
{
Models.Utilisateur client = DBContext.Utilisateurs.Where(c => (c.Id.Equals(this.Compte.ClientId))).FirstOrDefault();
Views.ListeCompteClient listeCompteClient = new Views.ListeCompteClient(client);
listeCompteClient.Show();
_window.Close();
}
public PageGestionnaireViewModel(Window window, int idGestionnaire)
{
this._window = window;
DBContext = new DatabaseContext.GestionRelationClient_DBContext();
this.Gestionnaire = DBContext.Utilisateurs.Where(u => (u.Id.Equals(idGestionnaire))).FirstOrDefault();
this.LoginGestionnaire = Gestionnaire.Login;
// Navigation
GoToAccueilCommand = new RelayCommand(
o => true,
o => OpenAccueil()
);
GoToPageGestionnaire = new RelayCommand(
o => true,
o => OpenPageGestionnaire()
);
GoToAjoutServiceCommand = new RelayCommand(
o => true,
o => OpenPageAjoutService()
);
GoToAjoutProduitCommand = new RelayCommand(
o => true,
o => OpenPageAjoutProduit()
);
GoToListeArticleGestionnaire = new RelayCommand(
o => true,
o => OpenListeArticleGestionnaire()
);
}
[ValidateAntiForgeryToken]//très important à mettre pour la securite a mettre egalement dans la view correspondante
public ActionResult Connection(Models.Utilisateur T)
{
try
{
UIGestmetModelsClient.Utilisateur utilisateur =
_serviceutilisateur.GetConnect(new UIGestmetModelsClient.Utilisateur(T.Email, T.Login, T.MotPasse, T.PersonnelId, T.EstActif));
if (utilisateur.EstActif)
{
SessionManager.SessionUser = new Models.Utilisateur()
{
Id = utilisateur.Id,
Email = utilisateur.Email,
Login = utilisateur.Login,
MotPasse = utilisateur.MotPasse,
PersonnelId = utilisateur.PersonnelId,
EstActif = utilisateur.EstActif
};
return(RedirectToAction("../Home/Index"));
}
else
{
ViewBag.Message = "Vous devez vous inscrire avant de vous connecter : retour à l'accueil";
return(View());
//return RedirectToAction("../Home/Index");
}
}
catch (Exception e)
{
return(Content(e.ToString()));
//return View();
}
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
Utilisateur modelUser = new Models.Utilisateur();
modelUser.Nom = model.Nom;
modelUser.Prenom = model.Prenom;
modelUser.Email = model.Email;
modelUser.Institution = model.institution;
var x = context.AspNetUsers.Where(p => p.Email == model.Email).First();
modelUser.UserId = x.Id;
modelUser.Telephone = model.Telephone;
modelUser.Statu = false;
context.Utilisateur.Add(modelUser);
context.SaveChanges();
//// Send Password in Gmail///////////
string recipient = model.Email;
string subject = "MEF Espace Mot de Passe";
string body = "Bonjour,<br>Merci pour l'intérêt que vous témoignez envers l'espace MEF Maroc.<br> Votre Inscription est en cours de Validation.Vous pourrez accéder à votre espace en tant que Bailleurs de Fonds dès que votre compte sera validée.Pour cela, vous devrez utiliser votre email : " + model.Email + " comme login et le password suivant:<strong> " + model.Password + " </strong> Votre compte vous donne accès aux fonctionnalités réservées aux participants à l'espace MEF<br>Vous pourrez à tout moment modifier votre mot de passe à partir de votre espace personnel.<br> Pour tout besoin,<br> vous pouvez nous contacter via l'email suivant: [email protected]";
WebMail.SmtpServer = "smtp.gmail.com";
WebMail.SmtpPort = 587;
WebMail.SmtpUseDefaultCredentials = false;
WebMail.EnableSsl = true;
WebMail.UserName = "******";
WebMail.Password = "******";
WebMail.Send(to: recipient, subject: subject, body: body, isBodyHtml: true);
///////////////////////////////
AspNetUserRoles userRoles = new AspNetUserRoles();
userRoles.RoleId = "2";
userRoles.UserId = x.Id;
context.AspNetUserRoles.Add(userRoles);
context.SaveChanges();
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Login", "Account"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
/* Navigation */
private void OpenAccueil()
{
Models.Utilisateur gestionnaire = DBContext.Utilisateurs.Where(c => (c.Id.Equals(this.idGestionnaire))).FirstOrDefault();
gestionnaire.Deconnexion();
DBContext.SaveChanges();
Views.Accueil accueil = new Views.Accueil();
accueil.Show();
_window.Close();
}
/* Navigation */
private void OpenAccueil()
{
Models.Utilisateur client = DBContext.Utilisateurs.Where(c => (c.Id.Equals(this.Compte.ClientId))).FirstOrDefault();
client.Deconnexion();
DBContext.SaveChanges();
Views.Accueil accueil = new Views.Accueil();
accueil.Show();
_window.Close();
}
private void OpenPageGestionnaire(Models.Utilisateur gestionnaire)
{
// On change le status Login de l'Utilisateur
gestionnaire.Connexion();
DBContext.SaveChanges();
Views.PageGestionnaire pageGestionnaire = new Views.PageGestionnaire(gestionnaire.Id);
pageGestionnaire.Show();
_window.Close();
}
private void OpenListeCompteClient(Models.Utilisateur client)
{
// On change le status Login de l'Utilisateur
client.Connexion();
DBContext.SaveChanges();
Views.ListeCompteClient listeCompteClient = new Views.ListeCompteClient(client);
listeCompteClient.Show();
_window.Close();
}
public ListeComptesViewModel(Window window, Models.Utilisateur client)
{
this._window = window;
DBContext = new DatabaseContext.GestionRelationClient_DBContext();
this.Client = client;
this.nomClient = this.Client.Login;
this._addedCompte = new Models.Compte();
// Initialisation du compte
ObservableCollection <Models.Compte> comptesATrouver = Models.Utilitaire.ToObservableCollection <Models.Compte>(DBContext.Comptes.Where(c => c.ClientId.Equals(Client.Id)));
if (comptesATrouver == null)
{
this.Comptes = new ObservableCollection <Models.Compte>();
}
else
{
this.Comptes = comptesATrouver;
}
// Inscription
AjoutCompteCommand = new RelayCommand(
o => _isValid_addedCompte,
o => AddCompte()
);
// Sélection compte
SelectionnerCompteCommand = new RelayCommand(
o => (p_SelectedItem != null),
o => SelectionnerCompte()
);
// Navigation
GoToAccueilCommand = new RelayCommand(
o => true,
o => OpenAccueil()
);
GoToModificationClientCommand = new RelayCommand(
o => true,
o => OpenModificationClient()
);
GoToListeCompteClientCommand = new RelayCommand(
o => true,
o => OpenListeCompteClient(this.Client)
);
}
// Connexion
public void ConnectClient()
{
// TODO : trouver un moyen pour faire un Where sur la table Client (qui n'est pas dans le DBContext)
Models.Utilisateur clientATrouver = DBContext.Utilisateurs.Where(c => (c.Login.Equals(_connectingClient.Login) && c.MotDePasse.Equals(_connectingClient.MotDePasse))).FirstOrDefault();
if (clientATrouver == null)
{
MessageBox.Show("Information de connexion invalides", "Erreur", MessageBoxButton.OK, MessageBoxImage.Error);
}
else
{
this.OpenListeCompteClient(clientATrouver);
}
}
public ActionResult Edit(int id, Models.Utilisateur utilisateur)
{
try
{
_serviceutilisateur.Update(id, new UIGestmetModelsClient.Utilisateur(
utilisateur.Email, utilisateur.Login, utilisateur.MotPasse, utilisateur.PersonnelId, true));
return(RedirectToAction("../Home/Index"));
}
catch
{
return(View());
}
}
public PageCompteClientViewModel(Window window, int idCompte)
{
this._window = window;
DBContext = new DatabaseContext.GestionRelationClient_DBContext();
this.Compte = DBContext.Comptes.Where(c => (c.CompteId.Equals(idCompte))).FirstOrDefault();
this.Client = DBContext.Utilisateurs.Where(c => (c.Id.Equals(this.Compte.ClientId))).FirstOrDefault();
this.NomClient = this.Client.Login;
this.NomCompte = this.Compte.NomCompte;
// Modification nom Compte
ModificationNomCompteCommand = new RelayCommand(
o => InformationsModificationNomCompteValides(),
o => ModifieNomClient(LoginModificationCompte, MotDePasseModificationCompte, NouveauNomModificationCompte)
);
// Navigation
GoToAccueilCommand = new RelayCommand(
o => true,
o => OpenAccueil()
);
GoToModificationCompteCommand = new RelayCommand(
o => true,
o => OpenModificationCompte()
);
GoToListeCompteClientCommand = new RelayCommand(
o => true,
o => OpenListeCompteClient()
);
GoToListArticleCommand = new RelayCommand(
o => true,
o => OpenListeArticle()
);
GoToPanierCommand = new RelayCommand(
o => true,
o => OpenPanier()
);
}
public async Task <ActionResult> AddCM(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
Utilisateur modelUser = new Models.Utilisateur();
modelUser.Nom = model.Nom;
modelUser.Prenom = model.Prenom;
modelUser.Email = model.Email;
modelUser.Institution = model.institution;
var x = context.AspNetUsers.Where(p => p.Email == model.Email).First();
modelUser.UserId = x.Id;
modelUser.Telephone = model.Telephone;
modelUser.Statu = false;
context.Utilisateur.Add(modelUser);
context.SaveChanges();
AspNetUserRoles userRoles = new AspNetUserRoles();
userRoles.RoleId = "3";
userRoles.UserId = x.Id;
context.AspNetUserRoles.Add(userRoles);
context.SaveChanges();
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("index", "Utilisateurs", null));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
[ValidateAntiForgeryToken]//très important à mettre pour la securite a mettre egalement dans la view correspondante
public ActionResult UpdateUtilisateur(Models.Utilisateur T)
{
try
{
UIGestmetModelsClient.Utilisateur utilisateur =
_serviceutilisateur.GetConnect(new UIGestmetModelsClient.Utilisateur(T.Email, T.Login, T.MotPasse, T.PersonnelId, T.EstActif));
Models.Utilisateur ur = new Models.Utilisateur()
{
Id = utilisateur.Id,
Email = utilisateur.Email,
Login = utilisateur.Login,
MotPasse = utilisateur.MotPasse,
PersonnelId = utilisateur.PersonnelId,
EstActif = utilisateur.EstActif
};
if (ur.Id == 0)
{
ViewBag.Message = "Votre Login et/ou mot de passe est incorrect";
// return RedirectToAction("../Home/Index");
return(View());
}
if (ur.EstActif)
{
ViewBag.Message = "Vous êtes déjà inscrit";
return(View());
// return RedirectToAction("../Home/Index");
}
else
{
return(RedirectToAction("Edit", new { id = ur.Id }));
}
}
catch (Exception e)
{
return(Content(e.ToString()));
//return View();
}
}
public AjoutArticleViewModel(Window window, int idGestionnaire)
{
this._window = window;
DBContext = new DatabaseContext.GestionRelationClient_DBContext();
this.Gestionnaire = DBContext.Utilisateurs.Where(u => (u.Id.Equals(idGestionnaire))).FirstOrDefault();
// Service à ajouter, on ne gère pas encore les abonnements donc on lui affecte celui par défaut ; on lui affecte aussi un panier bidon
this._addedService = new Models.Service()
{
AbonnementId = 1,
PanierId = 1
};
// Produit à ajouter, on ne gère pas encore les abonnements donc on lui affecte celui par défaut ; on lui affecte aussi un panier bidon
this._addedProduit = new Models.Produit()
{
AbonnementId = 1,
PanierId = 1,
//StockId = // On ne peut pas récupérer le stock Id puisque il n'est que dans la table Gestionnaire, hors nous n'avons accès qu'à la table Utilisateur
};
// Navigation
GoToAccueilCommand = new RelayCommand(
o => true,
o => OpenAccueil()
);
GoToPageGestionnaireCommand = new RelayCommand(
o => true,
o => OpenPageGestionnaire()
);
AjouterServiceCommand = new RelayCommand(
o => _isValid_addedService,
o => AddService()
);
AjouterProduitCommand = new RelayCommand(
o => _isValid_addedProduit,
o => AddProduit()
);
}
private void RemoveUtilisateur(Models.Utilisateur param)
{
_serviceutil = new UtilisateurRepository();
_serviceutil.Delete(param.Id);
UtilisateurList.Remove(param);
}
public GestmetModelsClient.Utilisateur GetConnect(Models.Utilisateur utilisateur)
{
return(_service.GetConnect(new GestmetModelsClient.Utilisateur(utilisateur.Id, utilisateur.Email, utilisateur.Login, utilisateur.MotPasse, utilisateur.PersonnelId, utilisateur.EstActif)));
}
public void Update(int id, Models.Utilisateur utilisateur)
{
_service.Update(id, new GestmetModelsClient.Utilisateur(utilisateur.Id, utilisateur.Email, utilisateur.Login, utilisateur.MotPasse, utilisateur.PersonnelId, utilisateur.EstActif));
}
public ListeCompteClient(Models.Utilisateur client)
{
InitializeComponent();
DataContext = new ViewModels.ListeComptesViewModel(this, client);
}
public int Create(Models.Utilisateur utilisateur)
{
return(_service.Create(new GestmetModelsClient.Utilisateur(utilisateur.Email, utilisateur.Login, utilisateur.MotPasse, utilisateur.PersonnelId, utilisateur.EstActif)));
}
private void OpenListeCompteClient(Models.Utilisateur client)
{
Views.ListeCompteClient listeCompteClient = new Views.ListeCompteClient(client);
listeCompteClient.Show();
_window.Close();
}
//Valider l'action (création ou modification)
public void Valider()
{
_action.Importance = ImportanceSelected;
_action.Famille = FamilleSelected;
_action.Site = SiteSelected;
_action.Questionnaire = QuestionnaireSelected;
//action associée
if (ActionSelected.description == "Aucune")
{
_action.Action2 = null;
}
else
{
_action.Action2 = ActionSelected;
}
_action.Utilisateur = Resp1Selected;
_action.Utilisateur1 = Resp2Selected;
_action.statut = false;
_action.Taches = (ICollection <Models.Tache>)_ListeTaches;
//Calcul du nombre de tâches terminées. Si toutes les tâches sont terminées, on envoi un mail au responsable 2 pr qu'il remplisse le questionnaire
int nbreTaches = _action.Taches.Count;
int nbreTachesFinish = 0;
foreach (Models.Tache t in _action.Taches)
{
if (t.statut == true)
{
nbreTachesFinish++;
}
}
if (nbreTachesFinish == nbreTaches && nbreTaches > 0)
{
var queryDest = from U in _context.Utilisateurs where U.id == _action.Utilisateur1.id select U;
Models.Utilisateur Dest = queryDest.FirstOrDefault();
try
{
String objet = "PYRENACTION: Action terminée, questionnaire à remplir.";
String contenu = "Toutes les tâches de l'action: \n" + _action.description + "\n\n ont étés validées. Merci de vous connecter à l'application pour répondre au questionnaire";
MailMessage mail = new MailMessage("*****@*****.**", Dest.email, objet, contenu);
SmtpClient stpc = new SmtpClient("smtp.gmail.com", 587);
stpc.Credentials = new System.Net.NetworkCredential("*****@*****.**", "Cesi1234%");
stpc.EnableSsl = true;
stpc.Send(mail);
}
catch (Exception ex)
{
Console.WriteLine("L'email n'a pu être envoyé : {0}.", ex.Message);
}
}
_action.Liens = (ICollection <Models.Lien>)_ListeLiens;
//Test si l'action existe déjà en base de données. Si non, on l'ajoute. Si oui, on modifie.
Models.Action testExist = (from T in _context.Actions where T.id == _action.id select T).FirstOrDefault();
if (testExist == null)
{
_context.Actions.Add(_action);
}
_context.SaveChanges();
}
//Chargement des Combobox
private void loadFields()
{
_ListeImportances = new ObservableCollection <Models.Importance>();
var query = from U in _context.Importances select U;
List <Models.Importance> listeImportances = query.ToList();
foreach (Models.Importance imp in listeImportances)
{
_ListeImportances.Add(imp);
}
//définition de la collection view
_importanceCollectionView = CollectionViewSource.GetDefaultView(_ListeImportances);
if (_importanceCollectionView == null)
{
throw new NullReferenceException("_importanceCollectionView");
}
//ajout de l'événement à déclencher quand la vue courante change
_importanceCollectionView.CurrentChanged += OnCollectionViewImportanceCurrentChanged;
//Si on est sur une action existante à modifier, on selectionne l'item correspondant
if (_action.Importance != null)
{
Models.Importance imp = _action.Importance;
_importanceCollectionView.MoveCurrentTo(imp);
NotifyPropertyChanged("Importances");
}
_ListeFamilles = new ObservableCollection <Models.Famille>();
var queryFam = from U in _context.Familles select U;
List <Models.Famille> listeFamilles = queryFam.ToList();
foreach (Models.Famille fam in listeFamilles)
{
_ListeFamilles.Add(fam);
}
//définition de la collection view
_familleCollectionView = CollectionViewSource.GetDefaultView(_ListeFamilles);
if (_familleCollectionView == null)
{
throw new NullReferenceException("_familleCollectionView");
}
//ajout de l'événement à déclencher quand la vue courante change
_familleCollectionView.CurrentChanged += OnCollectionViewFamilleCurrentChanged;
//Si on est sur une action existante à modifier, on selectionne l'item correspondant
if (_action.Famille != null)
{
Models.Famille fam = _action.Famille;
_familleCollectionView.MoveCurrentTo(fam);
NotifyPropertyChanged("Familles");
}
_ListeSites = new ObservableCollection <Models.Site>();
var querySite = from U in _context.Sites select U;
List <Models.Site> listeSites = querySite.ToList();
foreach (Models.Site site in listeSites)
{
_ListeSites.Add(site);
}
//définition de la collection view
_siteCollectionView = CollectionViewSource.GetDefaultView(_ListeSites);
if (_siteCollectionView == null)
{
throw new NullReferenceException("_siteCollectionView");
}
//ajout de l'événement à déclencher quand la vue courante change
_siteCollectionView.CurrentChanged += OnCollectionViewSiteCurrentChanged;
//Si on est sur une action existante à modifier, on selectionne l'item correspondant
if (_action.Site != null)
{
Models.Site site = _action.Site;
_siteCollectionView.MoveCurrentTo(site);
NotifyPropertyChanged("Sites");
}
_ListeQuestionnaires = new ObservableCollection <Models.Questionnaire>();
var queryQuest = from U in _context.Questionnaires select U;
List <Models.Questionnaire> listeQuestionnaires = queryQuest.ToList();
foreach (Models.Questionnaire quest in listeQuestionnaires)
{
_ListeQuestionnaires.Add(quest);
}
//définition de la collection view
_questionnaireCollectionView = CollectionViewSource.GetDefaultView(_ListeQuestionnaires);
if (_questionnaireCollectionView == null)
{
throw new NullReferenceException("_questionnaireCollectionView");
}
//ajout de l'événement à déclencher quand la vue courante change
_questionnaireCollectionView.CurrentChanged += OnCollectionViewQuestionnaireCurrentChanged;
//Si on est sur une action existante à modifier, on selectionne l'item correspondant
if (_action.Questionnaire != null)
{
Models.Questionnaire quest = _action.Questionnaire;
_questionnaireCollectionView.MoveCurrentTo(quest);
NotifyPropertyChanged("Questionnaires");
}
_ListeActions = new ObservableCollection <Models.Action>();
var queryAct = from U in _context.Actions select U;
List <Models.Action> listeActions = queryAct.ToList();
foreach (Models.Action act in listeActions)
{
_ListeActions.Add(act);
}
Models.Action actNull = new Models.Action();
//ajout d'une action vide pour que l'utilisateur puisse séléctionner "Aucune" action associée.
actNull.description = "Aucune";
_ListeActions.Add(actNull);
//définition de la collection view
_actionCollectionView = CollectionViewSource.GetDefaultView(_ListeActions);
if (_actionCollectionView == null)
{
throw new NullReferenceException("_actionCollectionView");
}
//ajout de l'événement à déclencher quand la vue courante change
_actionCollectionView.CurrentChanged += OnCollectionViewActionCurrentChanged;
//Si on est sur une action existante à modifier, on selectionne l'item correspondant
if (_action.Action2 != null)
{
Models.Action act = _action.Action2;
_actionCollectionView.MoveCurrentTo(act);
NotifyPropertyChanged("Actions");
}
else
{
_actionCollectionView.MoveCurrentTo(actNull);
NotifyPropertyChanged("Actions");
}
_ListeUtilisateurs1 = new ObservableCollection <Models.Utilisateur>();
var queryUt1 = from U in _context.Utilisateurs select U;
List <Models.Utilisateur> listeUt1 = queryUt1.ToList();
foreach (Models.Utilisateur ut in listeUt1)
{
_ListeUtilisateurs1.Add(ut);
}
//définition de la collection view
_utilisateurCollectionView1 = CollectionViewSource.GetDefaultView(_ListeUtilisateurs1);
if (_utilisateurCollectionView1 == null)
{
throw new NullReferenceException("_utilisateurCollectionView1");
}
//ajout de l'événement à déclencher quand la vue courante change
_utilisateurCollectionView1.CurrentChanged += OnCollectionViewResp1CurrentChanged;
//Si on est sur une action existante à modifier, on selectionne l'item correspondant
if (_action.Utilisateur != null)
{
Models.Utilisateur ut1 = _action.Utilisateur;
_utilisateurCollectionView1.MoveCurrentTo(ut1);
NotifyPropertyChanged("Resp1");
}
_ListeUtilisateurs2 = new ObservableCollection <Models.Utilisateur>();
var queryUt2 = from U in _context.Utilisateurs select U;
List <Models.Utilisateur> listeUt2 = queryUt2.ToList();
foreach (Models.Utilisateur ut in listeUt2)
{
_ListeUtilisateurs2.Add(ut);
}
//définition de la collection view
_utilisateurCollectionView2 = CollectionViewSource.GetDefaultView(_ListeUtilisateurs2);
if (_utilisateurCollectionView2 == null)
{
throw new NullReferenceException("_utilisateurCollectionView2");
}
//ajout de l'événement à déclencher quand la vue courante change
_utilisateurCollectionView2.CurrentChanged += OnCollectionViewResp2CurrentChanged;
//Si on est sur une action existante à modifier, on selectionne l'item correspondant
if (_action.Utilisateur1 != null)
{
Models.Utilisateur ut2 = _action.Utilisateur1;
_utilisateurCollectionView2.MoveCurrentTo(ut2);
NotifyPropertyChanged("Resp2");
}
_ListeTaches = new ObservableCollection <Models.Tache>();
var queryTach = from U in _context.Taches select U;
List <Models.Tache> listeTach = queryTach.ToList();
//Si on est sur une action existante à modifier, on selectionne l'item correspondant
foreach (Models.Tache t in listeTach)
{
if (t.id_Action == _action.id)
{
_ListeTaches.Add(t);
}
}
//définition de la collection view
_tacheCollectionView = CollectionViewSource.GetDefaultView(_ListeTaches);
if (_tacheCollectionView == null)
{
throw new NullReferenceException("_tacheCollectionView");
}
//ajout de l'événement à déclencher quand la vue courante change
_tacheCollectionView.CurrentChanged += OnCollectionViewTacheCurrentChanged;
_ListeLiens = new ObservableCollection <Models.Lien>();
var queryLiens = from U in _context.Liens select U;
List <Models.Lien> listeLiens = queryLiens.ToList();
//Si on est sur une action existante à modifier, on selectionne l'item correspondant
foreach (Models.Lien l in listeLiens)
{
if (l.id_Action == _action.id)
{
_ListeLiens.Add(l);
}
}
//définition de la collection view
_lienCollectionView = CollectionViewSource.GetDefaultView(_ListeLiens);
if (_lienCollectionView == null)
{
throw new NullReferenceException("_lienCollectionView");
}
//ajout de l'événement à déclencher quand la vue courante change
_lienCollectionView.CurrentChanged += OnCollectionViewLienCurrentChanged;
}
