//Penser à garder la reference vers la variable objet initialFormattedValue > le pointeur est important
public override void InitializeEditingControl(int rowIndex, object initialFormattedValue, DataGridViewCellStyle dataGridViewCellStyle)
{
base.InitializeEditingControl(rowIndex, initialFormattedValue, dataGridViewCellStyle);
m_controleEdition = DataGridView.EditingControl as CControlEncapsuleWndControl;
m_controleEdition.Initialiser(
m_datas,
m_nColumnIndex,
m_2iWndForGrid, m_fournisseur);
DataGridView grid = DataGridView;
if (grid != null)
{
Control parent = grid.Parent;
while (parent != null && !(parent is CDataGridForFormulaire))
{
parent = parent.Parent;
}
if (parent is CDataGridForFormulaire)
{
m_listeRestrictions = ((CDataGridForFormulaire)parent).ListeRestrictions;
}
}
m_controleEdition.InitRestrictions(m_listeRestrictions);
}
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);
}
//-------------------------------------------------------------------------------------
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)
{
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;
}
}
}
//---------------------------------------------
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 CListeRestrictionsUtilisateurSurType GetRestrictions(CObjetDonnee objet)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(objet);
CListeRestrictionsUtilisateurSurType restrictions = new CListeRestrictionsUtilisateurSurType();
foreach (CCoupleFormuleToGroupeRestrictions couple in m_listeCouples)
{
if (couple.Formule != null)
{
CResultAErreur result = couple.Formule.Eval(ctx);
if (result && result.Data is bool)
{
if ((bool)result.Data)
{
CGroupeRestrictionSurType groupe = new CGroupeRestrictionSurType(objet.ContexteDonnee);
if (groupe.ReadIfExists(couple.IdGroupeRestriction))
{
restrictions.Combine(groupe.ListeRestrictions);
}
}
}
}
}
return(restrictions);
}
/// ///////////////////////////////////////////////////
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 InitRestrictions(CListeRestrictionsUtilisateurSurType lstRestrictions)
{
m_listeRestrictions = lstRestrictions;
if (m_controleEdition != null)
{
m_controleEdition.InitRestrictions(lstRestrictions);
}
}
/// ////////////////////////////////////////////////
public CContexteSauvegardeObjetsDonnees(
CContexteDonnee contexte,
CDonneeNotificationModificationContexteDonnee donneeNotification,
CListeRestrictionsUtilisateurSurType listeRestrictions)
{
m_contexteDonnees = contexte;
m_donneeNotification = donneeNotification;
m_restrictions = listeRestrictions;
}
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;
}
//---------------------------------------------------------------------
protected override void MyAppliqueRestriction(
CRestrictionUtilisateurSurType restrictionSurObjetEdite,
CListeRestrictionsUtilisateurSurType listeRestrictions,
IGestionnaireReadOnlySysteme gestionnaireReadOnly)
{
if (m_panelListeSpeedStd != null)
{
m_panelListeSpeedStd.AppliqueRestrictions(listeRestrictions, gestionnaireReadOnly);
}
}
/////////////////////////////////////////////////////////////////////////
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);
}
}
//---------------------------------------------
protected override void MyAppliqueRestriction(
CRestrictionUtilisateurSurType restrictionSurObjetEdite,
CListeRestrictionsUtilisateurSurType listeRestrictions,
IGestionnaireReadOnlySysteme gestionnaireReadOnly)
{
if (m_grid != null)
{
m_grid.InitRestrictions(listeRestrictions);
}
}
//---------------------------------------------------
public void AppliqueRestrictions(
CRestrictionUtilisateurSurType restrictionSurObjetEdite,
CListeRestrictionsUtilisateurSurType listeRestrictions,
IGestionnaireReadOnlySysteme gestionnaireReadOnly)
{
m_panelSousFormulaire.AppliqueRestrictions(
restrictionSurObjetEdite,
listeRestrictions,
gestionnaireReadOnly);
}
//--------------------------------------------------------------
public void InitRestrictions(CListeRestrictionsUtilisateurSurType lstRestrictions)
{
if (lstRestrictions != null)
{
m_listeRestrictions = lstRestrictions.Clone() as CListeRestrictionsUtilisateurSurType;
}
else
{
m_listeRestrictions = null;
}
}
public static void AjouteRestrictions(string strCle, CListeRestrictionsUtilisateurSurType restrictions)
{
CListeRestrictionsUtilisateurSurType liste = (CListeRestrictionsUtilisateurSurType)m_tableRestrictions[strCle];
if (liste == null)
{
liste = new CListeRestrictionsUtilisateurSurType();
m_tableRestrictions[strCle] = liste;
}
liste.Combine(restrictions);
}
//---------------------------------------------
/// <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;
}
}
}
}
}
}
//---------------------------------------------
protected override void MyAppliqueRestriction(
CRestrictionUtilisateurSurType restrictionSurObjetEdite,
CListeRestrictionsUtilisateurSurType restrictions,
IGestionnaireReadOnlySysteme gestionnaireReadOnly)
{
if (m_wndChamp != null)
{
m_wndChamp.AppliqueRestriction(restrictionSurObjetEdite,
restrictions,
gestionnaireReadOnly);
}
}
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);
}
private CListeRestrictionsUtilisateurSurType GetListeRestrictionsModulesClient()
{
if (m_listeRestricitionsFromProfil == null)
{
m_listeRestricitionsFromProfil = new CListeRestrictionsUtilisateurSurType();
if (ConfigModules != null)
{
m_listeRestricitionsFromProfil.Combine(CModuleRestrictionProvider.GetRestrictionsClient(ConfigModules));
}
}
return(m_listeRestricitionsFromProfil);
}
//---------------------------------------------
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;
}
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 CInfosRestriction(
CListeRestrictionsUtilisateurSurType listeRestrictions,
ReadOnlyCollection <Type> listeTypesARestrictionsSurObjets)
{
m_listeRestrictions = listeRestrictions;
if (m_listeRestrictions == null)
{
m_listeRestrictions = new CListeRestrictionsUtilisateurSurType();
}
m_listeTypesARestrictionsSurObjets = listeTypesARestrictionsSurObjets;
if (m_listeTypesARestrictionsSurObjets == null)
{
m_listeTypesARestrictionsSurObjets = new ReadOnlyCollection <Type>(new List <Type>());
}
}
//-------------------------------------------------------------------
public CListeRestrictionsUtilisateurSurType GetRestrictions(int?nIdVersion)
{
//Récupère les profils a restriction globales
CListeObjetsDonnees listeProfils = RelationsProfils;
bool bIsAdmin = false;
CListeRestrictionsUtilisateurSurType listeRestrictions = new CListeRestrictionsUtilisateurSurType(bIsAdmin);
foreach (CRelationUtilisateur_Profil rel in listeProfils)
{
listeRestrictions = CListeRestrictionsUtilisateurSurType.Combine(listeRestrictions, rel.Profil.GetRestrictionsGlobales(nIdVersion));
}
return(listeRestrictions);
}
//---------------------------------------------------------------
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);
}
//---------------------------------------------------
public void AppliqueRestrictions(
CRestrictionUtilisateurSurType restrictionSurObjetEdite,
CListeRestrictionsUtilisateurSurType listeRestrictions,
IGestionnaireReadOnlySysteme gestionnaireReadOnly)
{
if (m_controlePrincipal != null)
{
if (gestionnaireReadOnly != null)
{
gestionnaireReadOnly.AddControl(m_controlePrincipal);
}
m_controlePrincipal.AppliqueRestriction(
restrictionSurObjetEdite,
listeRestrictions,
gestionnaireReadOnly);
}
}
public void ReinitialiserRestrictions(CConfigModulesTimos config)
{
//CConfigurationRestrictions.ClearRestrictions();
CListeRestrictionsUtilisateurSurType restrictionsModules = CModuleRestrictionProvider.GetRestrictionsApp(config);
CConfigurationRestrictions.AjouteRestrictions(CTimosServeur.c_keyRestrictionAllUsers, restrictionsModules);
foreach (CSessionClientSurServeur session in CGestionnaireSessionsTimos.ListeSessionsServeur)
{
if (session is CSessionClientSurServeurTimos)
{
CSessionClientSurServeurTimos sessionTimos = (CSessionClientSurServeurTimos)session;
sessionTimos.SetNewConfigModules(config);
}
}
}
//----------------------------------------------------------------------------------
public CListeRestrictionsUtilisateurSurType GetRestrictionsGlobales(int?nIdVersion)
{
if (ShouldApply(nIdVersion))
{
CListeRestrictionsUtilisateurSurType listeRestrictions = ProfilFils.GetRestrictionsGlobales(nIdVersion);
if (ProfilFils.EntiteOrganisationnelle == null) //Ce n'est que dans ce cas qu'on applique les restrictions globales des
//profils inclus
{
foreach (CProfilUtilisateur_Inclusion inclusion in InclusionsFilles)
{
listeRestrictions = CListeRestrictionsUtilisateurSurType.Combine(listeRestrictions, inclusion.GetRestrictionsGlobales(nIdVersion));
}
}
return(listeRestrictions);
}
return(new CListeRestrictionsUtilisateurSurType());
}
