public void ApplyToObjet(object objet) { CRestrictionUtilisateurSurType rest = GetRestriction(objet.GetType()).Clone() as CRestrictionUtilisateurSurType; rest.ApplyToObjet(objet); SetRestriction(rest); }
/// ///////////////////////////////////////////////////////// private void AddRestrictionsHorsPriorites(Type tp, CRestrictionUtilisateurSurType rest) { CRestrictionUtilisateurSurType restO = GetRestriction(tp); restO.AddRestrictionsHorsPriorite(rest); m_tableRestrictions[tp] = restO; }
/// ///////////////////////////////////////////////////////// public CRestrictionUtilisateurSurType GetRestriction(Type tp) { if (m_bIsAdministrateur) { return(new CRestrictionUtilisateurSurType(tp)); } CRestrictionUtilisateurSurType rest = (CRestrictionUtilisateurSurType)m_tableRestrictions[tp]; if (rest == null) { rest = new CRestrictionUtilisateurSurType(tp); } object[] attribs = tp.GetCustomAttributes(typeof(RestrictionHeriteeAttribute), true); CRestrictionUtilisateurSurType restClone = (CRestrictionUtilisateurSurType)rest.Clone(); if (attribs != null && attribs.Length > 0) { Type newTp = tp.BaseType; if (tp != null) { restClone.Combine(GetRestriction(newTp)); } } if (SeuilAnnulationPriorites != null) { restClone.SurchageComplete = true; restClone.Priorite = (int)SeuilAnnulationPriorites; } return(restClone); }
/// <summary> /// Retourne une indication sur se qu'il faut faire pour la combinaison /// </summary> /// <param name="x"></param> /// <param name="y"></param> /// <returns></returns> public static int EstCeQuiYaUnPlusFortEtSiOuiCestQui(CRestrictionUtilisateurSurType x, CRestrictionUtilisateurSurType y) { if (x == null && y == null) { return(0); } else if (x == null) { return(-1); } else if (y == null) { return(1); } if (x.TypeAssocie != y.TypeAssocie) { return(0); } if (x.Priorite == y.Priorite) { if (!x.SurchageComplete && y.SurchageComplete) { return(-1); } else if (x.SurchageComplete && !y.SurchageComplete) { return(1); } else { return(0); } } else if (x.Priorite > y.Priorite) { if (x.SurchageComplete) { return(1); } else { return(0); } } else { if (y.SurchageComplete) { return(-1); } else { return(0); } } }
/// /////////////////////////////////////////// public void AddRestrictionsHorsPriorite(CRestrictionUtilisateurSurType restriction) { m_restrictionHorsPriorité |= restriction.RestrictionGlobale; foreach (DictionaryEntry entry in restriction.m_tableRestrictions) { SetRestrictionHorsPriorite((string)entry.Key, GetRestrictionHorsPriorite((string)entry.Key) | restriction.GetRestriction((string)entry.Key)); } }
/// /////////////////////////////////////////// public object Clone() { CRestrictionUtilisateurSurType restriction = new CRestrictionUtilisateurSurType(m_type); foreach (string strKey in m_tableRestrictions.Keys) { restriction.m_tableRestrictions[strKey] = (ERestriction)m_tableRestrictions[strKey]; } foreach (string strKey in m_tableRestrictionsHorsPriorites.Keys) { restriction.m_tableRestrictionsHorsPriorites[strKey] = m_tableRestrictionsHorsPriorites[strKey]; } restriction.RestrictionUtilisateur = RestrictionUtilisateur; restriction.RestrictionSysteme = RestrictionSysteme; restriction.m_restrictionHorsPriorité = m_restrictionHorsPriorité; restriction.m_nPriorite = Priorite; restriction.m_bSurchageComplete = SurchageComplete; restriction.ContextesException = ContextesException; return(restriction); }
/// ///////////////////////////////////////////////////////// public void AddRestriction(CRestrictionUtilisateurSurType restriction) { if (restriction == null) { return; } Type tp = restriction.TypeAssocie; CRestrictionUtilisateurSurType resEx = GetRestriction(tp); if (SeuilAnnulationPriorites == null || resEx.Priorite >= (int)SeuilAnnulationPriorites) { if (resEx != null && resEx.HasRestrictions) { m_tableRestrictions[tp] = CRestrictionUtilisateurSurType.Combine(resEx, restriction); } else { m_tableRestrictions[tp] = (CRestrictionUtilisateurSurType)restriction.Clone(); } } }
/// /////////////////////////////////////////// public static CRestrictionUtilisateurSurType Combine(CRestrictionUtilisateurSurType restriction1, CRestrictionUtilisateurSurType restriction2) { CRestrictionUtilisateurSurType rest = null; if (restriction1 == null && restriction2 == null || restriction1.TypeAssocie != restriction2.TypeAssocie) { return(null); } if (restriction1 == null) { return((CRestrictionUtilisateurSurType)restriction2.Clone()); } if (restriction2 == null) { return((CRestrictionUtilisateurSurType)restriction1.Clone()); } rest = (CRestrictionUtilisateurSurType)restriction1.Clone(); rest.Combine(restriction2); return(rest); }
/// /////////////////////////////////////////// public void Combine(CRestrictionUtilisateurSurType rest) { if (rest == null || rest.TypeAssocie != TypeAssocie) { return; } //Les restrictions d'affichage se combinent toujours m_restrictionHorsPriorité |= rest.m_restrictionHorsPriorité; foreach (DictionaryEntry entry in rest.m_tableRestrictionsHorsPriorites) { SetRestrictionHorsPriorite((string)entry.Key, GetRestrictionHorsPriorite((string)entry.Key) | rest.GetRestrictionHorsPriorite((string)entry.Key)); } //Dans le cas d'une restriction système les 2 restrictions doivent //se "fusionner" quelque soit leur priorité ex: //Une restriction système est créé au lancement d'une application mais //l'utilisateur à ajouté d'autres restriction int nCompare = EstCeQuiYaUnPlusFortEtSiOuiCestQui(this, rest); if (nCompare == 1) //c'est moi le plus fort { RestrictionSysteme |= rest.RestrictionSysteme; return; } else if (nCompare == -1) //C'est l'autre le plus fort { m_tableRestrictions.Clear(); foreach (string strKey in rest.m_tableRestrictions.Keys) { SetRestrictionLocale(strKey, rest.GetRestrictionLocale(strKey)); } Priorite = rest.Priorite; SurchageComplete = true; RestrictionUtilisateur = rest.RestrictionUtilisateur; RestrictionSysteme |= rest.RestrictionSysteme; ContextesException = rest.ContextesException; return; } else //Il n'y a pas de plus fort { //Les lignes suivantes fusionnent les restrictions : SurchageComplete = (SurchageComplete && Priorite >= rest.Priorite) || (rest.SurchageComplete && rest.Priorite >= Priorite); Priorite = Math.Max(Priorite, rest.Priorite); RestrictionUtilisateur = rest.RestrictionUtilisateur | RestrictionUtilisateur; RestrictionSysteme |= rest.RestrictionSysteme; foreach (string strKey in rest.m_tableRestrictions.Keys) { ERestriction rest1 = GetRestrictionLocale(strKey); ERestriction rest2 = rest.GetRestrictionLocale(strKey); SetRestrictionLocale(strKey, rest1 | rest2); } // On passe par une liste tampon car la tables parcourue peut être modifiée ArrayList listeKeysDeLaTablesDesRestrictions = new ArrayList(m_tableRestrictions.Keys); foreach (string strKey in listeKeysDeLaTablesDesRestrictions) { ERestriction rest1 = GetRestrictionLocale(strKey); ERestriction rest2 = rest.GetRestrictionLocale(strKey); SetRestrictionLocale(strKey, rest1 | rest2); } Dictionary <string, bool> dicContextes = new Dictionary <string, bool>(); foreach (string strContexte in ContextesException) { dicContextes[strContexte] = true; } foreach (string strContexte in rest.ContextesException) { dicContextes[strContexte] = true; } string[] strContextes = new string[dicContextes.Count]; int nContexte = 0; foreach (string strcontexte in dicContextes.Keys) { strContextes[nContexte] = strcontexte; } ContextesException = strContextes; } }
///-------------------------------------------------------------------- /// <summary> /// remplace la restriction en cours /// </summary> /// <param name="restriction"></param> public void SetRestriction(CRestrictionUtilisateurSurType restriction) { m_tableRestrictions[restriction.TypeAssocie] = restriction; }