public static CListeRestrictionsUtilisateurSurType GetRestrictionsClient(CConfigModulesTimos configModules)
{
CListeRestrictionsUtilisateurSurType liste = new CListeRestrictionsUtilisateurSurType();
if (configModules == null)
{
return(liste);
}
List <Type> tps = new List <Type>(CContexteDonnee.GetAllTypes());
foreach (Type tp in tps)
{
object[] atts = tp.GetCustomAttributes(typeof(AModulesClient), false);
if (atts.Length == 1)
{
AModulesClient att = (AModulesClient)atts[0];
List <CLicenceModuleClientPrtct> modulesDuType = new List <CLicenceModuleClientPrtct>();
foreach (string strIdModule in att.IdsModulesClient)
{
CLicenceModuleClientPrtct modulePresent = configModules.GetModuleClient(strIdModule);
if (modulePresent != null)
{
modulesDuType.Add(modulePresent);
}
}
if (modulesDuType.Count == 0)
{
CRestrictionUtilisateurSurType restriction = new CRestrictionUtilisateurSurType(tp);
foreach (string strIdModule in att.IdsModulesClient)
{
CRestrictionUtilisateurSurType restric = new CRestrictionUtilisateurSurType(tp);
restric.RestrictionSysteme = configModules.GetRestrictionSiModuleAbsent(strIdModule);
restriction.Combine(restric);
}
liste.AddRestriction(restriction);
}
else
{
CRestrictionUtilisateurSurType restriction = new CRestrictionUtilisateurSurType(tp);
foreach (CLicenceModuleClientPrtct module in modulesDuType)
{
CRestrictionUtilisateurSurType restric = new CRestrictionUtilisateurSurType(tp);
restric.RestrictionSysteme = module.Restriction;
restriction.Combine(restric);
}
if (!restriction.HasRestrictions)
{
restriction = new CRestrictionUtilisateurSurType(restriction.TypeAssocie);
restriction.RestrictionUtilisateur = restriction.RestrictionGlobale;
}
liste.AddRestriction(restriction);
}
}
}
CompleteRestrictionsClient(configModules, liste);
return(liste);
}
//---------------------------------------------------------------
private static void CompleteRestrictionsProcessEtAutres(CConfigModulesTimos configModules, CListeRestrictionsUtilisateurSurType listeRestrictions)
{
CLicenceModuleClientPrtct module = configModules.GetModuleClient(CConfigModulesTimos.c_clientModule_ProcessEtAutres_ID);
ERestriction rest = ERestriction.Hide;
if (module != null)
{
rest = module.Restriction;
}
if (rest != ERestriction.Aucune)
{
CRestrictionUtilisateurSurType restriction = new CRestrictionUtilisateurSurType(typeof(CVariableSurObjet), rest);
listeRestrictions.AddRestriction(restriction);
restriction = new CRestrictionUtilisateurSurType(typeof(CEvenement), rest);
listeRestrictions.AddRestriction(restriction);
restriction = new CRestrictionUtilisateurSurType(typeof(CGroupeParametrage), rest);
listeRestrictions.AddRestriction(restriction);
restriction = new CRestrictionUtilisateurSurType(typeof(CProcessInDb), rest);
listeRestrictions.AddRestriction(restriction);
restriction = new CRestrictionUtilisateurSurType(typeof(CRelationDefinisseurComportementInduit), rest);
listeRestrictions.AddRestriction(restriction);
restriction = new CRestrictionUtilisateurSurType(typeof(CRelationElementComportement), rest);
listeRestrictions.AddRestriction(restriction);
restriction = new CRestrictionUtilisateurSurType(typeof(CComportementGenerique), rest);
listeRestrictions.AddRestriction(restriction);
}
}
/// ///////////////////////////////////////////////////
public CListeRestrictionsUtilisateurSurType GetListeRestrictions(int?nIdVersion)
{
CListeRestrictionsUtilisateurSurType liste = new CListeRestrictionsUtilisateurSurType();
CConfigurationRestrictions.AppliqueRestrictions(CTimosServeur.c_keyRestrictionAllUsers, liste);
CDonneesActeurUtilisateur user = Utilisateur;
//C'est pas une session système
if (user != null)
{
liste.Combine(user.GetRestrictions(nIdVersion));
}
liste.Combine(GetListeRestrictionsModulesClient());
CConfigurationRestrictions.AppliqueRestrictions(CTimosServeur.c_keyRestrictionAllUsers, liste);
if (UserLicence != null && UserLicence.IsReadOnly)
{
foreach (Type tp in CContexteDonnee.GetAllTypes())
{
CRestrictionUtilisateurSurType rest = liste.GetRestriction(tp);
CRestrictionUtilisateurSurType restRO = new CRestrictionUtilisateurSurType(tp);
restRO.RestrictionSysteme = ERestriction.ReadOnly;
rest.Combine(restRO);
liste.AddRestriction(rest);
}
}
return(liste);
}
public void CompleteRestriction(CRestrictionUtilisateurSurType restriction)
{
if (m_relationsEOProvider != null)
{
m_relationsEOProvider.CompleteRestriction(this, restriction);
}
}
//---------------------------------------------
protected override void MyAppliqueRestriction(
CRestrictionUtilisateurSurType restrictionSurObjetEdite,
CListeRestrictionsUtilisateurSurType listeRestrictions,
IGestionnaireReadOnlySysteme gestionnaireReadOnly)
{
if (EditedElement != null && m_textBoxNumerique != null)
{
ERestriction rest = restrictionSurObjetEdite.RestrictionGlobale;
C2iWndTextBoxEntier wndTxt = WndAssociee as C2iWndTextBoxEntier;
if (wndTxt != null)
{
CDefinitionProprieteDynamique def = wndTxt.Property;
if (def != null)
{
rest = def.GetRestrictionAAppliquer(restrictionSurObjetEdite);
}
}
switch (rest)
{
case ERestriction.ReadOnly:
case ERestriction.Hide:
{
gestionnaireReadOnly.SetReadOnly(m_textBoxNumerique, true);
break;
}
default: break;
}
}
}
//-------------------------------------------------------------------------------------
public void AppliqueRestrictions(
CListeRestrictionsUtilisateurSurType lstRestrictions,
CGestionnaireReadOnlySysteme gestionnaire)
{
if (SourceType == null)
{
return;
}
CRestrictionUtilisateurSurType restriction = lstRestrictions.GetRestriction(SourceType);
if (restriction != null)
{
foreach (KeyValuePair <object, CInfoControle> kv in m_dicControleToInfo)
{
CInfoControle info = kv.Value;
if (info.Field.Length > 0)
{
ERestriction rest = restriction.GetRestriction(info.Field);
Control ctrl = kv.Key as Control;
if (ctrl != null)
{
if ((rest & ERestriction.ReadOnly) == ERestriction.ReadOnly)
{
gestionnaire.SetReadOnly(ctrl, true);
}
else
{
gestionnaire.SetReadOnly(ctrl, false);
}
}
}
}
}
}
//---------------------------------------------
protected override void MyAppliqueRestriction(
CRestrictionUtilisateurSurType restrictionSurObjetEdite,
CListeRestrictionsUtilisateurSurType listeRestrictions,
IGestionnaireReadOnlySysteme gestionnaireReadOnly)
{
bool bShowPictureRestriction = false;
if (listeRestrictions != null && EditedElement != null)
{
CChampCustom champ = WndVariable.Variable as CChampCustom;
if (champ != null && restrictionSurObjetEdite != null && m_controleForVariable.Control != null)
{
ERestriction rest = restrictionSurObjetEdite.GetRestriction(champ.CleRestriction);
if ((rest & ERestriction.ReadOnly) == ERestriction.ReadOnly)
{
gestionnaireReadOnly.SetReadOnly(m_controleForVariable.Control, true);
bShowPictureRestriction = true;
}
}
}
if (VisualiseurReadOnly != null)
{
if (bShowPictureRestriction)
{
VisualiseurReadOnly.Visible = true;
}
else
{
VisualiseurReadOnly.Visible = false;
}
}
}
/////////////////////////////////////////////////////////////
public void CompleteRestrictions(CRestrictionUtilisateurSurType restriction)
{
AssureRelations();
if (!restriction.HasRestrictions)
{
return;
}
foreach (CInfoChampTable info in m_listeChamps)
{
if (!restriction.CanModify(info.Propriete))
{
info.ReadOnly = true;
}
}
foreach (CInfoRelation relation in m_listeRelationsParentes)
{
if (!restriction.CanModify(relation.Propriete))
{
foreach (CInfoChampTable info in m_listeChamps)
{
foreach (string strChamp in relation.ChampsFille)
{
if (info.NomChamp == strChamp)
{
info.ReadOnly = true;
}
}
}
}
}
}
//----------------------------------------------------------------------------
public void CompleteRestriction(CRestrictionUtilisateurSurType restriction)
{
CObjetDonnee objet = GetObjet();
if (objet is IObjetARestrictionSurEntite)
{
((IObjetARestrictionSurEntite)objet).CompleteRestriction(restriction);
}
}
public void Init(CListeRestrictionsUtilisateurSurType liste)
{
m_listeRestrictions = liste;
CInfoClasseDynamique[] classes = DynamicClassAttribute.GetAllDynamicClass(typeof(TableAttribute));
m_cmbType.Init(classes);
FillListeTypes();
m_restrictionAffichee = null;
m_panelDetailType.Visible = false;
}
//------------------------------------------------------------------------
public void AppliqueRestriction(CRestrictionUtilisateurSurType restrictionSurElementEdite, CListeRestrictionsUtilisateurSurType listeRestriction, sc2i.common.Restrictions.IGestionnaireReadOnlySysteme gestionnaire)
{
if (m_controleAlloue != null)
{
m_controleAlloue.AppliqueRestriction(restrictionSurElementEdite,
listeRestriction,
gestionnaire);
}
}
//---------------------------------------------------
public void AppliqueRestrictions(
CRestrictionUtilisateurSurType restrictionSurObjetEdite,
CListeRestrictionsUtilisateurSurType listeRestrictions,
IGestionnaireReadOnlySysteme gestionnaireReadOnly)
{
m_panelSousFormulaire.AppliqueRestrictions(
restrictionSurObjetEdite,
listeRestrictions,
gestionnaireReadOnly);
}
public static void SetRestriction(IElementAEO element, CRestrictionUtilisateurSurType rest)
{
if (m_tableElementToRestriction.Count > 100)
{
m_tableElementToRestriction.Clear();
}
CCacheRestriction cache = new CCacheRestriction(rest, element.CodesEntitesOrganisationnelles);
m_tableElementToRestriction[element] = cache;
}
//---------------------------------------------------------------------
protected override void MyAppliqueRestriction(
CRestrictionUtilisateurSurType restrictionSurObjetEdite,
CListeRestrictionsUtilisateurSurType listeRestrictions,
IGestionnaireReadOnlySysteme gestionnaireReadOnly)
{
if (m_panelListeSpeedStd != null)
{
m_panelListeSpeedStd.AppliqueRestrictions(listeRestrictions, gestionnaireReadOnly);
}
}
//---------------------------------------------
protected override void MyAppliqueRestriction(
CRestrictionUtilisateurSurType restrictionSurObjetEdite,
CListeRestrictionsUtilisateurSurType listeRestrictions,
IGestionnaireReadOnlySysteme gestionnaireReadOnly)
{
if (m_grid != null)
{
m_grid.InitRestrictions(listeRestrictions);
}
}
/////////////////////////////////////////////////////////////////////////
public static void AppliqueRestriction(string strCle, CRestrictionUtilisateurSurType restriction)
{
CListeRestrictionsUtilisateurSurType liste = (CListeRestrictionsUtilisateurSurType)m_tableRestrictions[strCle];
if (liste != null)
{
CRestrictionUtilisateurSurType rest = liste.GetRestriction(restriction.TypeAssocie);
restriction.Combine(rest);
}
}
//-------------------------------------------------------------------------
private void FillListeChamps(CRestrictionUtilisateurSurType restriction)
{
m_wndListeChamps.BeginUpdate();
m_wndListeChamps.Items.Clear();
CInfoStructureDynamique info = CInfoStructureDynamique.GetStructure(restriction.TypeAssocie, 0);
List <ListViewItem> lstItems = new List <ListViewItem>();
foreach (CInfoChampDynamique champ in info.Champs)
{
string strTmp = "";
CDefinitionProprieteDynamique def = CConvertisseurInfoStructureDynamiqueToDefinitionChamp.GetDefinitionProprieteDynamique(champ.NomPropriete, ref strTmp);
//Uniquement les propriétés "classiques"
//voir CTimosApp.GetStructure
if (def != null && typeof(CDefinitionProprieteDynamiqueDotNet).IsAssignableFrom(def.GetType()))
{
ListViewItem item = new ListViewItem();
item.Text = champ.NomChamp;
item.Tag = def.NomProprieteSansCleTypeChamp;
item.ImageIndex = GetIndexImage(restriction.GetRestriction(def.NomProprieteSansCleTypeChamp));
lstItems.Add(item);
}
}
lstItems.Sort((x, y) => x.Text.CompareTo(y.Text));
if (typeof(IElementAChamps).IsAssignableFrom(restriction.TypeAssocie))
{
CRoleChampCustom role = CRoleChampCustom.GetRoleForType(restriction.TypeAssocie);
if (role != null)
{
CListeObjetsDonnees listeChampsCustom = CChampCustom.GetListeChampsForRole(CContexteDonneeSysteme.GetInstance(), role.CodeRole);
foreach (CChampCustom champ in listeChampsCustom)
{
ListViewItem item = new ListViewItem();
item.Text = champ.Nom;
item.Tag = champ.CleRestriction;
item.ImageIndex = GetIndexImage(restriction.GetRestriction(champ.CleRestriction));
lstItems.Add(item);
}
lstItems.Sort((x, y) => x.Text.CompareTo(y.Text));
CListeObjetsDonnees listeFormulaires = new CListeObjetsDonnees(CContexteDonneeSysteme.GetInstance(), typeof(CFormulaire));
listeFormulaires.Filtre = CFormulaire.GetFiltreFormulairesForRole(role.CodeRole);
foreach (CFormulaire formulaire in listeFormulaires)
{
ListViewItem item = new ListViewItem();
item.Text = "{" + formulaire.Libelle + "}";
item.Tag = formulaire.CleRestriction;
item.ImageIndex = GetIndexImage(restriction.GetRestriction(formulaire.CleRestriction));
lstItems.Add(item);
}
}
}
m_wndListeChamps.Items.AddRange(lstItems.ToArray());
m_wndListeChamps.EndUpdate();
}
//---------------------------------------------
protected override void MyAppliqueRestriction(
CRestrictionUtilisateurSurType restrictionSurObjetEdite,
CListeRestrictionsUtilisateurSurType restrictions,
IGestionnaireReadOnlySysteme gestionnaireReadOnly)
{
if (m_wndChamp != null)
{
m_wndChamp.AppliqueRestriction(restrictionSurObjetEdite,
restrictions,
gestionnaireReadOnly);
}
}
//---------------------------------------------
/// <summary>
/// Applique les restrictions
/// </summary>
/// <param name="listeRestriction"></param>
public void AppliqueRestriction(
CRestrictionUtilisateurSurType restrictionSurObjetEdite,
CListeRestrictionsUtilisateurSurType listeRestrictions,
IGestionnaireReadOnlySysteme gestionnaireReadOnly
)
{
MyAppliqueRestriction(restrictionSurObjetEdite, listeRestrictions, gestionnaireReadOnly);
foreach (IControleWndFor2iWnd child in Childs)
{
child.AppliqueRestriction(restrictionSurObjetEdite, listeRestrictions, gestionnaireReadOnly);
}
}
public void AppliqueRestriction(
CRestrictionUtilisateurSurType restrictionSurObjetEdite,
CListeRestrictionsUtilisateurSurType listeRestriction,
IGestionnaireReadOnlySysteme gestionnaireReadOnly)
{
if (listeRestriction == null || gestionnaireReadOnly == null)
{
return;
}
m_listeRestrictionsAppliquées = listeRestriction.Clone() as CListeRestrictionsUtilisateurSurType;
m_restrictionSurObjetEditeParent = restrictionSurObjetEdite;
m_gestionnaireReadOnly = gestionnaireReadOnly;
bool bAllReadOnly = false;
if ((restrictionSurObjetEdite.RestrictionGlobale & ERestriction.ReadOnly) == ERestriction.ReadOnly)
{
gestionnaireReadOnly.SetReadOnly(this, true);
bAllReadOnly = true;
}
//Récupère la restriction sur le type des éléments
if (m_zoneMultiple != null && m_zoneMultiple.SourceFormula != null)
{
C2iExpression source = m_zoneMultiple.SourceFormula;
Type tp = source.TypeDonnee.TypeDotNetNatif;
if (tp != null)
{
//Chope la restriction et l'envoie à tous ses fils
CRestrictionUtilisateurSurType rest = listeRestriction.GetRestriction(tp);
if (bAllReadOnly)//Si readonly forcé sur toute la zone
{
rest.RestrictionUtilisateur |= ERestriction.ReadOnly;
}
m_bPreventAddFromRestriction = (rest.RestrictionGlobale & ERestriction.NoCreate) == ERestriction.NoCreate;
m_bPreventDeleteFromRestriction = (rest.RestrictionGlobale & ERestriction.NoDelete) == ERestriction.NoDelete;
m_lnkAdd.Visible = !m_bPreventAddFromRestriction && m_zoneMultiple.HasAddButton;
m_panelTop.Visible = m_nbPages > 1 || m_zoneMultiple.HasAddButton;
foreach (Control ctrl in m_panelSousFormulaires.Controls)
{
CPanelChildElement sousFormulaire = ctrl as CPanelChildElement;
if (sousFormulaire != null)
{
sousFormulaire.AppliqueRestrictions(rest,
listeRestriction,
gestionnaireReadOnly);
if (m_bPreventDeleteFromRestriction)
{
sousFormulaire.DelegueSuppression = null;
}
}
}
}
}
}
//-------------------------------------------------------------------------
private ListViewItem GetItemForType(Type tp)
{
foreach (ListViewItem item in m_wndListeTypes.Items)
{
CRestrictionUtilisateurSurType rest = item.Tag as CRestrictionUtilisateurSurType;
if (rest != null && rest.TypeAssocie == tp)
{
return(item);
}
}
return(null);
}
public static CListeRestrictionsUtilisateurSurType GetRestrictionsApp(CConfigModulesTimos configModules)
{
CListeRestrictionsUtilisateurSurType liste = new CListeRestrictionsUtilisateurSurType();
if (configModules == null)
{
return(liste);
}
List <Type> tps = new List <Type>(CContexteDonnee.GetAllTypes());
if (tps.Count == 0)
{
throw new Exception("No type loaded for licences");
}
foreach (Type tp in tps)
{
object[] atts = tp.GetCustomAttributes(typeof(AModulesApp), false);
if (atts.Length == 1)
{
AModulesApp att = (AModulesApp)atts[0];
List <CLicenceModuleAppPrtct> modulesDuType = new List <CLicenceModuleAppPrtct>();
foreach (string strIdModule in att.IdsModulesApplicatif)
{
CLicenceModuleAppPrtct modulePresent = configModules.GetModuleApp(strIdModule);
if (modulePresent != null)
{
modulesDuType.Add(modulePresent);
}
}
if (modulesDuType.Count == 0)
{
CRestrictionUtilisateurSurType restriction = new CRestrictionUtilisateurSurType(tp, ERestriction.Hide);
liste.AddRestriction(restriction);
}
else
{
CRestrictionUtilisateurSurType restriction = new CRestrictionUtilisateurSurType(tp);
foreach (CLicenceModuleAppPrtct module in modulesDuType)
{
CRestrictionUtilisateurSurType restric = new CRestrictionUtilisateurSurType(tp);
restric.RestrictionSysteme = module.Restriction;
restriction.Combine(restric);
}
liste.AddRestriction(restriction);
}
}
}
CompleteRestrictionsApp(configModules, liste);
return(liste);
}
//---------------------------------------------
public void AppliqueRestriction(
CRestrictionUtilisateurSurType restriction,
CListeRestrictionsUtilisateurSurType listeRestriction,
IGestionnaireReadOnlySysteme gestionnaireReadOnly)
{
foreach (IControleWndFor2iWnd ctrl in m_controlesFils)
{
ctrl.AppliqueRestriction(
restriction,
listeRestriction,
gestionnaireReadOnly);
}
}
//---------------------------------------------------
public void AppliqueRestrictions(
CRestrictionUtilisateurSurType restrictionSurObjetEdite,
CListeRestrictionsUtilisateurSurType listeRestrictions,
IGestionnaireReadOnlySysteme gestionnaireReadOnly)
{
m_panelSousFormulaire.AppliqueRestrictions(
restrictionSurObjetEdite,
listeRestrictions,
gestionnaireReadOnly);
m_restriction = restrictionSurObjetEdite.Clone() as CRestrictionUtilisateurSurType;;
m_listeRestrictions = listeRestrictions.Clone() as CListeRestrictionsUtilisateurSurType;
m_gestionnaireReadonlySystem = gestionnaireReadOnly;
}
private void m_wndSupprimer_LinkClicked(object sender, EventArgs e)
{
foreach (ListViewItem itemSel in new ArrayList(m_wndListeTypes.SelectedItems))
{
CRestrictionUtilisateurSurType restSel = itemSel.Tag as CRestrictionUtilisateurSurType;
if (restSel != null)
{
itemSel.Tag = null;
m_wndListeTypes.Items.Remove(itemSel);
ShowRestriction(null);
}
}
}
public static void AjouteRestriction(string strCle, CRestrictionUtilisateurSurType restriction)
{
CListeRestrictionsUtilisateurSurType liste = (CListeRestrictionsUtilisateurSurType)m_tableRestrictions[strCle];
if (liste == null)
{
liste = new CListeRestrictionsUtilisateurSurType();
m_tableRestrictions[strCle] = liste;
}
CRestrictionUtilisateurSurType rest = liste.GetRestriction(restriction.TypeAssocie);
rest.Combine(restriction);
}
//---------------------------------------------------------------
public CListeRestrictionsUtilisateurSurType GetListeRestrictions()
{
ValideRestrictionEnCours();
m_listeRestrictions = new CListeRestrictionsUtilisateurSurType();
//m_listeRestrictions.SeuilAnnulationPriorites = m_txtSeuil.IntValue;
foreach (ListViewItem item in m_wndListeTypes.Items)
{
CRestrictionUtilisateurSurType rest = item.Tag as CRestrictionUtilisateurSurType;
if (rest != null)
{
m_listeRestrictions.AddRestriction(rest);
}
}
return(m_listeRestrictions);
}
private void m_wndListeTypes_SelectedIndexChanged(object sender, EventArgs e)
{
if (m_wndListeTypes.SelectedItems.Count == 1)
{
ListViewItem item = m_wndListeTypes.SelectedItems[0];
if (item != null)
{
CRestrictionUtilisateurSurType rest = item.Tag as CRestrictionUtilisateurSurType;
if (rest != null)
{
ShowRestriction(rest);
}
}
}
}
//---------------------------------------------------------------
private static void CompleteRestrictionsStructuresExport(CConfigModulesTimos configModules, CListeRestrictionsUtilisateurSurType listeRestrictions)
{
CLicenceModuleClientPrtct module = configModules.GetModuleClient(CConfigModulesTimos.c_clientModule_StructuresExport_ID);
ERestriction rest = ERestriction.Hide;
if (module != null)
{
rest = module.Restriction;
}
if (rest != ERestriction.Aucune)
{
CRestrictionUtilisateurSurType restriction = new CRestrictionUtilisateurSurType(typeof(C2iStructureExportInDB), rest);
listeRestrictions.AddRestriction(restriction);
}
}
//---------------------------------------------------------------
private static void CompleteRestrictionsChampsCalcules(CConfigModulesTimos configModules, CListeRestrictionsUtilisateurSurType listeRestrictions)
{
CLicenceModuleClientPrtct module = configModules.GetModuleClient(CConfigModulesTimos.c_clientModule_ChampsCalc_Id);
ERestriction rest = ERestriction.Hide;
if (module != null)
{
rest = module.Restriction;
}
if (rest != ERestriction.Aucune)
{
CRestrictionUtilisateurSurType restriction = new CRestrictionUtilisateurSurType(typeof(CChampCalcule), rest);
listeRestrictions.AddRestriction(restriction);
}
}
