public void chargeDr(TreeView _tvFull, TreeView _tvGr, GroupeUtil _gr)
{
var lstBrut = rGroupeUtilSQL.getAllDroit();
foreach (tblDroit item in lstBrut)
{
Droit tmp = new Droit(item);
TreeNode nod = new TreeNode(tmp.descDroit);
nod.Name = tmp.codeDroit;
nod.Tag = tmp;
_tvFull.Nodes.Add(nod);
lstDroit.Add(tmp);
}
_tvFull.Tag = lstDroit;
if (_gr != null)
{
foreach (Droit monDr in _gr.lstGroupeDroit)
{
TreeNode nod = new TreeNode(monDr.descDroit);
nod.Name = monDr.codeDroit;
nod.Tag = monDr;
_tvGr.Nodes.Add(nod);
_tvFull.Nodes.RemoveByKey(monDr.codeDroit);
}
_tvGr.Tag = _gr.lstGroupeDroit;
}
}
public static bool VerifyHabilitations()
{
bool habilitate = true;
foreach (String s in userConnected.GetHabilitations())
{
if (habilitate)
{
Droit d = dataUtils.GetListDroits().Find(x => x.Libelle == s);
if (d != null)
{
habilitate = CheckInDatabase(userConnected, d);
}
else
{
MessageBox.Show("Une erreur est survenue", "Espi Community", MessageBoxButton.OK, MessageBoxImage.Error);
habilitate = false;
}
}
else
{
break;
}
}
return(habilitate);
}
/// <summary>
/// construit un utilisateur vide qui n'a pas de droits
/// </summary>
public User()
{
this.nom = "";
this.prenom = "";
this.tel = "";
this.agence = "";
//pas de droit par defaut
this.droits = Droit.None;
}
Droit ConvertToDroit(DroitResource resource)
{
Droit droit = new Droit(resource.ResourceName);
foreach (int right in resource.RightValue.ToFlags())
{
droit.AddAccessCode(new AccessCode(right));
}
return(droit);
}
public void Update(Droit droit, string user = "")
{
_droitRepository.Update(droit);
_applicationTraceService.create(new ApplicationTrace
{
utilisateur = user,
action = Parametres.Action.Modification.ToString(),
description = String.Format("Mise à jour d'un type de droit utilisateur droit_id = {0}", droit.id),
});
}
public void Create(Droit droit, string user = "")
{
_droitRepository.Insert(droit);
_applicationTraceService.create(new ApplicationTrace
{
utilisateur = user,
action = Parametres.Action.Creation.ToString(),
description = "Création d'un nouveau droit utilisateur",
});
}
private static bool CheckInDatabase(User u, Droit d)
{
if (dataUtils.GetListRestrictionDroit().Count > 0)
{
RestrictionDroit rd = dataUtils.GetListRestrictionDroit().Find(x => (x.IdUser == u.Id) && (x.IdDroit == d.Id));
if (rd != null)
{
DateTime fullDate = DateTime.Now;
int _d = fullDate.Day < 10 ? Int32.Parse("0" + fullDate.Day.ToString()) : Int32.Parse(fullDate.Day.ToString());
int _m = fullDate.Month < 10 ? Int32.Parse("0" + fullDate.Month.ToString()) : Int32.Parse(fullDate.Month.ToString());
int _y = Int32.Parse(fullDate.Year.ToString());
if (_y < Int32.Parse(rd.DateFinSanction.Split('/')[2]))
{
return(true);
}
else
{
if (_m < Int32.Parse(rd.DateFinSanction.Split('/')[1]))
{
return(false);
}
else if (_m == Int32.Parse(rd.DateFinSanction.Split('/')[1]))
{
if (_d == Int32.Parse(rd.DateFinSanction.Split('/')[0]) || _d > Int32.Parse(rd.DateFinSanction.Split('/')[0]))
{
return(true);
}
else
{
return(false);
}
}
else
{
return(true);
}
}
}
else
{
return(true);
}
}
else
{
return(true);
}
}
public GroupeUtil(tblGroupe gp)
{
IdGroupe = gp.IdGroupe;
NomGroupe = gp.NomGroupe;
ListGroupeUser = new List<Utilisateur>();
foreach (tblUtilisateur user in gp.tblUtilisateur)
{
Utilisateur temp = new Utilisateur(user);
ListGroupeUser.Add(temp);
}
ListGroupeDroit = new List<Droit>();
foreach (tblDroit d in gp.tblDroit)
{
Droit tempD = new Droit(d);
ListGroupeDroit.Add(tempD);
}
}
public static void TestEnumeration()
{
Droit monDroit = Droit.ALL;
switch (monDroit) // Switch ou If
{
case Droit.ALL:
System.Console.Write("Droit maximal : {0} ", monDroit.ToString());
break;
default:
System.Console.Write("Vous n'avez pas tous les droits");
break;
}
// Sortie : Droit maximal : ALL
int codeMonDroit = (int)monDroit;
System.Console.Write("Code de mon droit : {0} ", codeMonDroit);
// Sortie : Code de mon droit : 3
}
/// <summary>
/// constructeur
/// </summary>
public WPFCodeRegimeViewModel(IDialogService dialogService)
{
//déclaration du Dialog dans le constructeur
_dialogService = dialogService;
//*******************************************************************************************************************************************
// GESTION DE LA PAGE WPFCodeRegime
//*******************************************************************************************************************************************
LoadedPage = new RelayCommand(() =>
{
////////////////////////
// Gestion des Droits
////////////////////////
CbxChecked = false;
// vérification des droits
using (ProgetEntities pg = new ProgetEntities())
{
Droit droitUtilisateur = pg.Droits.Where(a => a.Matricule == ParamGlobaux.Matricule && a.IDEtablissement == ParamGlobaux.IDEtablissement &&
a.Fonctions == "Gestion des codes Régime").SingleOrDefault();
//On s'assure de ne pas avoir de "Null Pointer Exception"
if (droitUtilisateur != null && droitUtilisateur.Droit1 == "CT")
{
ControleDroit = true;
}
else
{
ControleDroit = false;
}
}
ChargementListView();
});
////////////////////////////////////
// Gestion des boutons de WPFCaisse
////////////////////////////////////
//------------------
// Bouton Quitter
//------------------
CodeRegimeQuitter = new RelayCommand <Window>(FermetureFenetre);
//-----------------
// Bouton Ajouter
//-----------------
Ajouter = new RelayCommand(() =>
{
// instanciation d'un objet vide pour repartir de 0 pour le nouvel ajout
ObsCodeRegime = new CodeRegimeObservable();
checkCode = true;
// on met la couleur de fond du colorpicker à blanc
couleurSelectionnee = Color.FromRgb(255, 255, 255);
//on envoit vers la fenetre
_dialogService.ShowDialog <WPFCodeRegimeAjouter>(this, this);
});
//------------------
// Evenement Modifier
//------------------
Modifier = new RelayCommand <CodeRegimeObservable>((item) =>
{
if (item != null)
{
checkCode = false;
//on envoit vers la fenetre
_dialogService.ShowDialog <WPFCodeRegimeAjouter>(this, this);
}
else
{
System.Windows.MessageBox.Show("aucune ligne selectionnée");
}
});
//------------------
// Bouton Aide
//------------------
Aide = new RelayCommand(() =>
{
AffichageAide("AideAjouterGrandRegime.pdf");
});
//---------------------
// CheckBox Supprimer
//---------------------
CbxSupprimerListView = new RelayCommand <CodeRegimeObservable>((item) =>
{
// connexion à la base
using (ProgetEntities pg = new ProgetEntities())
{
// création d'un nouveau Code regime avec les données recueillies
CodeRegime codeRegime = pg.CodeRegimes.Where(a => a.IDCodeRegime == item.id).SingleOrDefault();
// recherche si ce Code est utilisée dans la table Usager
List <Usager> pu = pg.Usagers.Where(a => a.IDCodeRegime == codeRegime.IDCodeRegime).ToList();
if (pu.Count == 0)
{
// dans ce cas, ce Code n'existe pas dans la table PlanningUsager, il est dont totalement inutile et va donc être supprimé définitivement
pg.CodeRegimes.Remove(codeRegime);
pg.SaveChanges();
}
else
{
//on met à Code Régime la valeur de item.supprimer (objet porteur de la valeur changée)
codeRegime.SUPPRIMER_CodeRegime = item.supprimer;
//on sauvegarde les changements
pg.SaveChanges();
}
ChargementListView();
}
});
//----------------------------
// CheckBox "Tous les Grands Régimes"
//----------------------------
CbkCodeRegime = new RelayCommand(() =>
{
using (ProgetEntities pg = new ProgetEntities())
{
//création de la liste de Caisse qui va recevoir toutes les données de la requête Entity
List <CodeRegime> ListeCodes = pg.CodeRegimes.ToList();
// récupérons la liste générée par WPFCodeRegime
ObservableCollection <CodeRegime> ListViewListeRecup = new ObservableCollection <CodeRegime>(ListeCodes);
// on instancie la listViewList
ListViewListe = new ObservableCollection <CodeRegimeObservable>();
// parcourons la liste pour en extraire les éléments
foreach (CodeRegime item in ListViewListeRecup)
{
//on passe les données à la ListView
ListViewListe.Add(new CodeRegimeObservable(item.IDCodeRegime, item.LIBELLE_CodeRegime, item.COULEUR_CodeRegime, item.SUPPRIMER_CodeRegime));
}
}
});
//gestion du Unchecked de la CheckBox "tous les codes régimes"
CbkCodeRegimeUnchecked = new RelayCommand(() =>
{
ChargementListView();
});
//---------------------
// Bouton Supprimer
//---------------------
CMSupprimerListView = new RelayCommand <CodeRegimeObservable>((item) =>
{
if (item != null)
{
// connexion à la base
using (ProgetEntities pg = new ProgetEntities())
{
// création d'un nouveau Code regime avec les données recueillies
CodeRegime codeRegime = pg.CodeRegimes.Where(a => a.IDCodeRegime == item.id).SingleOrDefault();
// recherche si ce Code est utilisée dans la table Usager
List <Usager> pu = pg.Usagers.Where(a => a.IDCodeRegime == codeRegime.IDCodeRegime).ToList();
if (pu.Count == 0)
{
// dans ce cas, ce Code n'existe pas dans la table PlanningUsager, il est dont totalement inutile et va donc être supprimé définitivement
pg.CodeRegimes.Remove(codeRegime);
pg.SaveChanges();
}
else
{
//on met à Code Régime la valeur de item.supprimer (objet porteur de la valeur changée)
codeRegime.SUPPRIMER_CodeRegime = !item.supprimer;
//on sauvegarde les changements
pg.SaveChanges();
}
ChargementListView();
}
}
else
{
System.Windows.MessageBox.Show("aucune ligne selectionnée");
}
});
//*******************************************************************************************************************************************
// GESTION DE LA PAGE WPFCodeRegimeuAjouter
//*******************************************************************************************************************************************
////////////////////////////////////////////////
// Gestion des boutons de WPFCodeRegimeAjouter
////////////////////////////////////////////////
//------------------
// Bouton Quitter
//------------------
//Si aucune modification n'est en cours, ou on vient de valider notre ajout, on quitte directement
//Autrement on affiche un message d'avertissement
CodeRegimeAjouterQuitter = new RelayCommand <Window>((WPFCodeRegimeAjouter) =>
{
if (ObsCodeRegime.AllowExit)
{
//Si notre booleen est vrai, pas de modif en attente
FermetureFenetre(WPFCodeRegimeAjouter);
//On ferme la page
}
else
{
//Si notre booleen est faux, nous avons des nouvelles modifications
if (MessageBox.Show("Vous allez perdre vos modifications en cours", "Attention", MessageBoxButton.OKCancel) == MessageBoxResult.OK)
{
//Si l'utilisateur appuie sur "OK" la page est fermée
ObsCodeRegime.AllowExit = true;
FermetureFenetre(WPFCodeRegimeAjouter);
//Lorsque l'ont ferme la page on passe notre booleen a vrai
}
}
});
//------------------------
// Bouton BtnCodeRegimeAjouter
//------------------------
CodeRegimeAjouterValider = new RelayCommand(() =>
{
try
{
//on initialise l'accès à la base de donnée (Projet3Entities est le nom de la classe porteuse du dbcontxt dans Projet3BDD.Context.cs)
using (ProgetEntities pg = new ProgetEntities())
{
// recherche dans la BDD s'il existe déja une Caisse identique
CodeRegime existe = pg.CodeRegimes.Where(a => a.IDCodeRegime == ObsCodeRegime.id).SingleOrDefault();
// nous sommes en "Ajouter"
if (checkCode == true)
{
//Verification caractères spéciaux del'id
if (!Regex.IsMatch(ObsCodeRegime.id.ToString(), @"^[0-9]+$") == false)
{
//s'il n'existe pas d'objet en bas ayant la même id
if (existe == null)
{
if (ObsCodeRegime.id == "" || ObsCodeRegime.libelle == "" || ObsCodeRegime.couleur == 0)
{
System.Windows.MessageBox.Show("Veuillez remplir l'ensemble des champs avec une étoile * ");
}
else if (!Regex.IsMatch(ObsCodeRegime.id.ToString(), @"^[a-zA-Z 0-9]+$") == true || !Regex.IsMatch(ObsCodeRegime.libelle.ToString(), @"^[a-zA-Z 0-9]+$") == true)
{
System.Windows.MessageBox.Show("caractère spéciaux interdits (lettres et chiffres uniquement)");
}
// on insère la Caisse dans la BDD
else if (ObsCodeRegime.id != "" && ObsCodeRegime.libelle != "" && ObsCodeRegime.couleur != 0 && !Regex.IsMatch(ObsCodeRegime.libelle.ToString(), @"^[a-zA-Z 0-9]+$") == false)
{
pg.CodeRegimes.Add(CodeRegimeObservable.ConversionEnCodeRegime(ObsCodeRegime));
// on sauvegarde les changements dans la BDD
pg.SaveChanges();
val = false;
//on met à jour la listeView
ListViewListe.Add(ObsCodeRegime);
System.Windows.MessageBox.Show("Nouveau Grand Regime Ajouté");
ObsCodeRegime.AllowExit = true;
}
}
else
{
System.Windows.MessageBox.Show("Il existe déja une Caisse portant ce code");
}
}
else
{
System.Windows.MessageBox.Show("Chiffres uniquement");
}
}
// nous sommes en "Modifier"
if (checkCode == false)
{
//Debug.WriteLine( ObsCodeRegime.libelle.ToString() );
//Debug.WriteLine( !Regex.IsMatch( ObsCodeRegime.libelle.ToString(), @"^[a-zA-Z 0-9]+$" ) );
// si libellé n'est pas vide et que couleur n'est pas égale à 0
if (ObsCodeRegime.libelle == "" || ObsCodeRegime.couleur == 0)
{
System.Windows.MessageBox.Show("Veuillez remplir l'ensemble des champs avec une étoile * ");
}
else if (!Regex.IsMatch(ObsCodeRegime.libelle.ToString(), @"^[a-zA-Z 0-9]+$") == true)
{
System.Windows.MessageBox.Show("caractère spéciaux interdits (lettres et chiffres uniquement)");
}
else if (ObsCodeRegime.libelle != "" && ObsCodeRegime.couleur != 0 && !Regex.IsMatch(ObsCodeRegime.libelle.ToString(), @"^[a-zA-Z 0-9]+$") == false)
{
existe.LIBELLE_CodeRegime = ObsCodeRegime.libelle;
existe.COULEUR_CodeRegime = ObsCodeRegime.couleur;
pg.SaveChanges();
ObsCodeRegime.AllowExit = true;
val = false;
System.Windows.MessageBox.Show("Modifications enregistrées");
}
}
}
}
catch (DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
Debug.WriteLine("DEBUG :Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
Debug.WriteLine(" DEBUG:- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
}
}
}
});
// commande gérant la reception du changement de couleur de WPFCodeRegimeAjouter
couleurChange = new RelayCommand(() =>
{
ObsCodeRegime.couleur = ColorToBase(couleurSelectionnee);
});
}
/// <summary>Constructeur pour EFCore. Ne pas utiliser directement.</summary>
/// <param name="droitDAcces"></param>
internal Acces(Droit droitDAcces) : this(null, null, droitDAcces)
{
}
/// <param name="utilisateur">L'utilisateur pouvant accéder au projet.</param>
/// <param name="projet">Le projet auquel l'utilisateur peut accéder.</param>
/// <param name="droit">Le droit d'accès.</param>
public Acces([NotNull] Projet projet, [NotNull] Utilisateur utilisateur, Droit droit)
{
Projet = projet;
Utilisateur = utilisateur;
DroitDAcces = droit;
}
/*
* Méthode qui permet de retourner la totalité
* des notifications de la base de données
* en fonction du Droit qui y a accés
* */
public List <Notification> ConsulterNotification(Droit droit)
{
return(null);
}
private void OkButton_Click(object sender, EventArgs e)
{
#region CLIENTS READ PERMISSION
if (readClients.Checked)
{
if (_permissionsList.Find(d => d.Libelle_Droit == "readClients") == null)
{
Droit droit = _db.Droit.FirstOrDefault(d => d.Libelle_Droit == "readClients");
_concernedEmployee.Personne.Droit.Add(droit);
}
}
else
{
if (_permissionsList.Find(d => d.Libelle_Droit == "readClients") != null)
{
_concernedEmployee.Personne.Droit.Remove(
_concernedEmployee.Personne.Droit.FirstOrDefault(d => d.Libelle_Droit == "readClients"));
}
}
#endregion
#region ISSUES READ PERMISSION
if (readIssues.Checked)
{
if (_permissionsList.Find(d => d.Libelle_Droit == "readIssues") == null)
{
Droit droit = _db.Droit.FirstOrDefault(d => d.Libelle_Droit == "readIssues");
_concernedEmployee.Personne.Droit.Add(droit);
}
}
else
{
if (_permissionsList.Find(d => d.Libelle_Droit == "readIssues") != null)
{
_concernedEmployee.Personne.Droit.Remove(
_concernedEmployee.Personne.Droit.FirstOrDefault(d => d.Libelle_Droit == "readIssues")
);
}
}
#endregion
#region EMPLOYEES READ PERMISSION
if (readEmployees.Checked)
{
if (_permissionsList.Find(d => d.Libelle_Droit == "readEmployees") == null)
{
Droit droit = _db.Droit.FirstOrDefault(d => d.Libelle_Droit == "readEmployees");
_concernedEmployee.Personne.Droit.Add(droit);
}
}
else
{
if (_permissionsList.Find(d => d.Libelle_Droit == "readEmployees") != null)
{
_concernedEmployee.Personne.Droit.Remove(
_concernedEmployee.Personne.Droit.FirstOrDefault(d => d.Libelle_Droit == "readEmployees")
);
}
}
#endregion
#region PROVIDERS READ PERMISSION
if (readProviders.Checked)
{
if (_permissionsList.Find(d => d.Libelle_Droit == "readProviders") == null)
{
Droit droit = _db.Droit.FirstOrDefault(d => d.Libelle_Droit == "readProviders");
_concernedEmployee.Personne.Droit.Add(droit);
}
}
else
{
if (_permissionsList.Find(d => d.Libelle_Droit == "readProviders") != null)
{
_concernedEmployee.Personne.Droit.Remove(
_concernedEmployee.Personne.Droit.FirstOrDefault(d => d.Libelle_Droit == "readProviders")
);
}
}
#endregion
#region STOCKS READ PERMISSION
if (readStocks.Checked)
{
if (_permissionsList.Find(d => d.Libelle_Droit == "readStocks") == null)
{
Droit droit = _db.Droit.FirstOrDefault(d => d.Libelle_Droit == "readStocks");
_concernedEmployee.Personne.Droit.Add(droit);
}
}
else
{
if (_permissionsList.Find(d => d.Libelle_Droit == "readStocks") != null)
{
_concernedEmployee.Personne.Droit.Remove(
_concernedEmployee.Personne.Droit.FirstOrDefault(d => d.Libelle_Droit == "readStocks")
);
}
}
#endregion
#region MAP READ PERMISSION
if (readMap.Checked)
{
if (_permissionsList.Find(d => d.Libelle_Droit == "readMap") == null)
{
Droit droit = _db.Droit.FirstOrDefault(d => d.Libelle_Droit == "readMap");
_concernedEmployee.Personne.Droit.Add(droit);
}
}
else
{
if (_permissionsList.Find(d => d.Libelle_Droit == "readMap") != null)
{
_concernedEmployee.Personne.Droit.Remove(
_concernedEmployee.Personne.Droit.FirstOrDefault(d => d.Libelle_Droit == "readMap")
);
}
}
#endregion
#region STATS READ PERMISSION
if (readStats.Checked)
{
if (_permissionsList.Find(d => d.Libelle_Droit == "readStats") == null)
{
Droit droit = _db.Droit.FirstOrDefault(d => d.Libelle_Droit == "readStats");
_concernedEmployee.Personne.Droit.Add(droit);
}
}
else
{
if (_permissionsList.Find(d => d.Libelle_Droit == "readStats") != null)
{
_concernedEmployee.Personne.Droit.Remove(
_concernedEmployee.Personne.Droit.FirstOrDefault(d => d.Libelle_Droit == "readStats")
);
}
}
#endregion
#region CLIENTS WRITE PERMISSION
if (writeClients.Checked)
{
if (_permissionsList.Find(d => d.Libelle_Droit == "writeClients") == null)
{
Droit droit = _db.Droit.FirstOrDefault(d => d.Libelle_Droit == "writeClients");
_concernedEmployee.Personne.Droit.Add(droit);
}
}
else
{
if (_permissionsList.Find(d => d.Libelle_Droit == "writeClients") != null)
{
_concernedEmployee.Personne.Droit.Remove(
_concernedEmployee.Personne.Droit.FirstOrDefault(d => d.Libelle_Droit == "writeClients")
);
}
}
#endregion
#region ISSUES WRITE PERMISSION
if (writeIssues.Checked)
{
if (_permissionsList.Find(d => d.Libelle_Droit == "writeIssues") == null)
{
Droit droit = _db.Droit.FirstOrDefault(d => d.Libelle_Droit == "writeIssues");
_concernedEmployee.Personne.Droit.Add(droit);
}
}
else
{
if (_permissionsList.Find(d => d.Libelle_Droit == "writeIssues") != null)
{
_concernedEmployee.Personne.Droit.Remove(
_concernedEmployee.Personne.Droit.FirstOrDefault(d => d.Libelle_Droit == "writeIssues")
);
}
}
#endregion
#region EMPLOYEES WRITE PERMISSION
if (writeEmployees.Checked)
{
if (_permissionsList.Find(d => d.Libelle_Droit == "writeEmployees") == null)
{
Droit droit = _db.Droit.FirstOrDefault(d => d.Libelle_Droit == "writeEmployees");
_concernedEmployee.Personne.Droit.Add(droit);
}
}
else
{
if (_permissionsList.Find(d => d.Libelle_Droit == "writeEmployees") != null)
{
_concernedEmployee.Personne.Droit.Remove(
_concernedEmployee.Personne.Droit.FirstOrDefault(d => d.Libelle_Droit == "writeEmployees")
);
}
}
#endregion
#region PROVIDERS WRITE PERMISSION
if (writeProviders.Checked)
{
if (_permissionsList.Find(d => d.Libelle_Droit == "writeProviders") == null)
{
Droit droit = _db.Droit.FirstOrDefault(d => d.Libelle_Droit == "writeProviders");
_concernedEmployee.Personne.Droit.Add(droit);
}
}
else
{
if (_permissionsList.Find(d => d.Libelle_Droit == "writeProviders") != null)
{
_concernedEmployee.Personne.Droit.Remove(
_concernedEmployee.Personne.Droit.FirstOrDefault(d => d.Libelle_Droit == "writeProviders")
);
}
}
#endregion
#region STOCKS WRITE PERMISSION
if (writeStocks.Checked)
{
if (_permissionsList.Find(d => d.Libelle_Droit == "writeStocks") == null)
{
Droit droit = _db.Droit.FirstOrDefault(d => d.Libelle_Droit == "writeStocks");
_concernedEmployee.Personne.Droit.Add(droit);
}
}
else
{
if (_permissionsList.Find(d => d.Libelle_Droit == "writeStocks") != null)
{
_concernedEmployee.Personne.Droit.Remove(
_concernedEmployee.Personne.Droit.FirstOrDefault(d => d.Libelle_Droit == "writeStocks")
);
}
}
#endregion
#region MAP WRITE PERMISSION
if (writeMap.Checked)
{
if (_permissionsList.Find(d => d.Libelle_Droit == "writeMap") == null)
{
Droit droit = _db.Droit.FirstOrDefault(d => d.Libelle_Droit == "writeMap");
_concernedEmployee.Personne.Droit.Add(droit);
}
}
else
{
if (_permissionsList.Find(d => d.Libelle_Droit == "writeMap") != null)
{
_concernedEmployee.Personne.Droit.Remove(
_concernedEmployee.Personne.Droit.FirstOrDefault(d => d.Libelle_Droit == "writeMap")
);
}
}
#endregion
Close();
}
public void updateDroit(Droit dr)
{
db.Droit.Attach(db.Droit.Single(x => x.code == dr.code));
db.Entry(db.Droit.Single(x => x.code == dr.code)).CurrentValues.SetValues(dr);
db.SaveChanges();
}
public void deleteuser(Droit dr)
{
db.Droit.Remove(dr);
}
/*
* Méthode qui permet de créer une Notifiation a destination
* des users avec un droit.
* */
public void CreerNotification(Droit droitDest, int typeNotif)
{
}
public void addUser(Droit dr)
{
db.Droit.Add(dr);
db.SaveChanges();
}
public void ChangeInfo(int id, Droit role)
{
_service.Update(id, role);
}
public List <Notification> ConsulterNotification(Droit droit)
{
return(userManager.ConsulterNotification(droit));
}
public virtual IPermission Intersect(IPermission target)
{
if (target == null)
return null;
if (!(target is BzurePermission))
throw new ArgumentException("target type must is GTCodePermission");
BzurePermission permission = target as BzurePermission;
if (this._droit.Guid.CompareTo(permission._droit.Guid) != 0)
throw new ArgumentException("Must same droit resource");
if (IsUnrestricted())
return permission.Copy();
if (permission.IsUnrestricted())
return Copy();
IDroit droit = new Droit(this._droit.Guid.ToString());
foreach (IAccessCode at in permission._droit.AccessCodes)
if (this._droit.Contains(at))
droit.AddAccessCode(at.Copy());
return new BzurePermission(droit);
}
public virtual void FromXml(SecurityElement e)
{
if (e == null)
throw new ArgumentNullException("e");
if (e.Tag != "BzurePermission")
{
throw new ArgumentException("invalid tag type");
}
if (!(e.Attributes["class"] as string).StartsWith("Bzure.Security.Permissions.CAS.BzurePermission"))
{
throw new ArgumentException("invalid type");
}
if ((e.Attributes["version"] as string) != "1")
{
throw new ArgumentException("invalid version");
}
IDroit droit = new Droit(e.Attributes["guid"] as string);
if (e.Children != null)
{
foreach (SecurityElement se in e.Children)
{
switch (se.Tag)
{
case "accessType":
droit.AddAccessCode(new AccessCode(Convert.ToInt32(se.Text)));
break;
default:
break;
}
}
}
this._droit = droit;
}
public void CreerNotification(Droit droitDest, int typeNotif)
{
userManager.CreerNotification(droitDest, typeNotif);
}
