/// ///////////////////////////////////////////////////////////
protected virtual void GetDefinitionsChamps(
Type tp,
int nProfondeur,
ArrayList lstProps,
string strCheminConvivial,
string strCheminReel,
CDefinitionProprieteDynamique definitionParente
)
{
/*ITraducteurNomChamps traducteur = null;
* if ( definitionParente is ITraducteurNomChamps )
* traducteur = (ITraducteurNomChamps)definitionParente;*/
if (nProfondeur < 0)
{
return;
}
if (tp == null)
{
return;
}
//Proprietes
foreach (PropertyInfo info in tp.GetProperties())
{
object[] attribs = info.GetCustomAttributes(typeof(DynamicFieldAttribute), true);
if (attribs.Length == 1)
{
DynamicFieldAttribute attrib = (DynamicFieldAttribute)attribs[0];
bool bReadOnly = info.GetSetMethod() == null;
Type tpProp = info.PropertyType;
bool bIsArray = tpProp.IsArray;
if (bIsArray)
{
tpProp = tpProp.GetElementType();
}
bool bHasSubProprietes = HasSubProperties(tpProp);
if (m_bAvecReadOnly || !bReadOnly || bHasSubProprietes)
{
CDefinitionProprieteDynamique def = new CDefinitionProprieteDynamiqueDotNet(
strCheminConvivial + attrib.NomConvivial,
strCheminReel + info.Name,
new CTypeResultatExpression(tpProp, bIsArray),
bHasSubProprietes,
bReadOnly,
attrib.Rubrique);
if (AddDefinition(lstProps, def /*, traducteur*/))
{
GetDefinitionsChamps(info.PropertyType, nProfondeur - 1, lstProps, strCheminConvivial + attrib.NomConvivial + ".", strCheminReel + info.Name + ".", def);
}
}
}
attribs = info.GetCustomAttributes(typeof(DynamicChildsAttribute), true);
{
if (attribs.Length == 1)
{
DynamicChildsAttribute attrib = (DynamicChildsAttribute)attribs[0];
CDefinitionProprieteDynamique def = new CDefinitionProprieteDynamiqueDotNet(
strCheminConvivial + attrib.NomConvivial,
strCheminReel + info.Name,
new CTypeResultatExpression(attrib.TypeFils, true)
, true,
true,
attrib.Rubrique);
if (AddDefinition(lstProps, def /*, traducteur*/))
{
GetDefinitionsChamps(attrib.TypeFils, nProfondeur - 1, lstProps, strCheminConvivial + attrib.NomConvivial + ".", strCheminReel + info.Name + ".", def);
}
}
}
}
//Champs custom
CRoleChampCustom role = CRoleChampCustom.GetRoleForType(tp);
if (role != null)
{
CListeObjetsDonnees listeChamps = CChampCustom.GetListeChampsForRole(ContexteDonneeCache, role.CodeRole);
foreach (CChampCustom champ in listeChamps)
{
CDefinitionProprieteDynamiqueChampCustom def = new CDefinitionProprieteDynamiqueChampCustom(champ);
if (champ.Categorie.Trim() != "")
{
def.Rubrique = champ.Categorie;
}
else
{
def.Rubrique = I.T("Complementary informations|59");
}
AddDefinition(lstProps, def /*, traducteur*/);
}
}
//Champs calculés
if (AvecReadOnly)
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(ContexteDonneeCache, typeof(CChampCalcule));
liste.Filtre = new CFiltreData(CChampCalcule.c_champTypeObjets + "=@1", tp.ToString());
foreach (CChampCalcule champ in liste)
{
CDefinitionProprieteDynamiqueChampCalcule def = new CDefinitionProprieteDynamiqueChampCalcule(champ);
def.HasSubProperties = HasSubProperties(def.TypeDonnee.TypeDotNetNatif);
def.Rubrique = I.T("Complementary informations|59");
AddDefinition(lstProps, def /*, traducteur*/);
}
}
//Méthodes
if (m_bAvecMethodes && AvecReadOnly)
{
//Va chercher les propriétés
foreach (MethodInfo methode in tp.GetMethods())
{
object[] attribs = methode.GetCustomAttributes(typeof(DynamicMethodAttribute), true);
if (attribs.Length == 1)
{
DynamicMethodAttribute attrib = (DynamicMethodAttribute)attribs[0];
CTypeResultatExpression typeRes = new CTypeResultatExpression(methode.ReturnType, false);
if (methode.ReturnType.HasElementType)
{
typeRes = new CTypeResultatExpression(methode.ReturnType.GetElementType(), true);
}
CDefinitionProprieteDynamique def = new CDefinitionMethodeDynamique(
strCheminConvivial + methode.Name,
strCheminReel + methode.Name,
typeRes,
HasSubProperties(methode.ReturnType),
attrib.Descriptif,
attrib.InfosParametres);
def.Rubrique = I.T("Methods|58");
lstProps.Add(def);
GetDefinitionsChamps(methode.ReturnType, nProfondeur - 1, lstProps, strCheminConvivial + methode.Name + ".", strCheminReel + methode.Name + ".", def);
}
}
foreach (CMethodeSupplementaire methode in CGestionnaireMethodesSupplementaires.GetMethodsForType(tp))
{
CDefinitionProprieteDynamique def = new CDefinitionMethodeDynamique(
strCheminConvivial + methode.Name,
strCheminReel + methode.Name,
new CTypeResultatExpression(methode.ReturnType, methode.ReturnArrayOfReturnType),
HasSubProperties(methode.ReturnType));
def.Rubrique = I.T("Methods|58");
lstProps.Add(def);
GetDefinitionsChamps(methode.ReturnType, nProfondeur - 1, lstProps, strCheminConvivial + methode.Name + ".", strCheminReel + methode.Name + ".", def);
}
}
//Relations TypeID
foreach (RelationTypeIdAttribute relation in CContexteDonnee.RelationsTypeIds)
{
if (relation.NomConvivialPourParent != "" && relation.IsAppliqueToType(tp))
{
CDefinitionProprieteDynamiqueRelationTypeId def = new CDefinitionProprieteDynamiqueRelationTypeId(relation);
AddDefinition(lstProps, def /*, traducteur*/);
}
}
//Données ucmulées
if (m_bAvecReadOnly)
{
CTypeDonneeCumulee[] donnees = GetTypesDonneesPourType(tp);
foreach (CTypeDonneeCumulee typeDonnee in donnees)
{
int nCle = 0;
foreach (CCleDonneeCumulee cle in typeDonnee.Parametre.ChampsCle)
{
if (cle.TypeLie == tp)
{
CDefinitionProprieteDynamiqueDonneeCumulee def =
new CDefinitionProprieteDynamiqueDonneeCumulee(
typeDonnee,
nCle);
AddDefinition(lstProps, def /*, traducteur*/);
break;
}
}
}
}
//Liens sur champs custom fils
if (m_bAvecReadOnly)
{
//Liens sur champs custom
CListeObjetsDonnees listeChamps = new CListeObjetsDonnees(ContexteDonneeCache, typeof(CChampCustom));
listeChamps.Filtre = new CFiltreData(
CChampCustom.c_champTypeObjetDonnee + "=@1",
tp.ToString());
foreach (CChampCustom champ in listeChamps)
{
CDefinitionProprieteDynamiqueChampCustomFils def = new CDefinitionProprieteDynamiqueChampCustomFils(
champ);
if (champ.Categorie.Trim() != "")
{
def.Rubrique = champ.Categorie;
}
else
{
def.Rubrique = I.T("Complementary informations|59");
}
AddDefinition(lstProps, def /*, traducteur*/);
}
}
//Liens par CListeEntite
if (m_bAvecReadOnly)
{
CListeObjetsDonnees listeEntites = new CListeObjetsDonnees(ContexteDonneeCache, typeof(CListeEntites));
listeEntites.Filtre = new CFiltreData(
CListeEntites.c_champTypeElementSourceDeRecherche + "=@1",
tp.ToString());
foreach (CListeEntites liste in listeEntites)
{
CDefinitionProprieteDynamiqueListeEntites def = new CDefinitionProprieteDynamiqueListeEntites(liste);
def.Rubrique = I.T("Lists|60");
AddDefinition(lstProps, def /*, traducteur*/);
}
}
}
//----------------------------------------------------------------------------
public CDefinitionProprieteDynamique[] GetDefinitionsChamps(Type typeInterroge, int nNbNiveaux, CDefinitionProprieteDynamique defParente)
{
return(GetDefinitionsChamps(new CObjetPourSousProprietes(typeInterroge), defParente));
}
public CDefinitionProprieteDynamique[] GetDefinitionsChamps(CObjetPourSousProprietes objet, CDefinitionProprieteDynamique defParente)
{
List <CDefinitionProprieteDynamique> lstProps = new List <CDefinitionProprieteDynamique>();
if (objet == null)
{
return(lstProps.ToArray());
}
Type tp = objet.TypeAnalyse;
if (tp == null)
{
return(lstProps.ToArray());
}
if (!C2iFactory.IsInit())
{
return(lstProps.ToArray());
}
//Champs custom
CRoleChampCustom role = CRoleChampCustom.GetRoleForType(tp);
CRestrictionUtilisateurSurType rest = null;
CSessionClient session = CSessionClient.GetSessionUnique();
if (session != null)
{
IInfoUtilisateur info = session.GetInfoUtilisateur();
if (info != null)
{
rest = info.GetRestrictionsSur(tp, null);
}
}
if (role != null)
{
CContexteDonnee contexte = CContexteDonneeSysteme.GetInstance();
CListeObjetsDonnees listeChamps = CChampCustom.GetListeChampsForRole(contexte, role.CodeRole);
foreach (CChampCustom champ in listeChamps)
{
if (rest != null)
{
ERestriction restChamp = rest.GetRestriction(champ.CleRestriction);
if ((restChamp & ERestriction.Hide) == ERestriction.Hide)
{
continue;
}
}
if (champ.ListeValeurs.Count > 0)
{
CDefinitionProprieteDynamiqueChampCustomDisplayValue def = new CDefinitionProprieteDynamiqueChampCustomDisplayValue(champ);
if (champ.Categorie.Trim() != "")
{
def.Rubrique = champ.Categorie;
}
else
{
def.Rubrique = I.T("Complementary informations|59");
}
lstProps.Add(def);
}
}
}
return(lstProps.ToArray());
}
/// //////////////////////////////////////////////////////////////
public C2iTableExportTableauCroise(CDefinitionProprieteDynamique champOrigine)
: base()
{
NomTable = I.T("Cross table @1|20009", DynamicClassAttribute.GetNomConvivial(champOrigine.TypeDonnee.TypeDotNetNatif));
m_champOrigine = champOrigine;
}
//------------------------------------------------------------------
public CDefinitionProprieteDynamique[] GetDefinitionsChamps(CObjetPourSousProprietes objet, CDefinitionProprieteDynamique defParente)
{
List <CDefinitionProprieteDynamique> lstDefs = new List <CDefinitionProprieteDynamique>();
lstDefs.AddRange(new CFournisseurGeneriqueProprietesDynamiques().GetDefinitionsChamps(objet));
if (objet.TypeAnalyse != null && objet.TypeAnalyse == typeof(CTrapInstance))
{
foreach (CTrapField field in FieldsFromTrap)
{
lstDefs.Add(new CDefinitionProprieteDynamiqueTrapField(field));
}
foreach (CTrapFieldSupplementaire field in FieldsSupplementaires)
{
lstDefs.Add(new CDefinitionProprieteDynamiqueTrapFieldSupplementaire(field));
}
lstDefs.Add(new CDefinitionProprieteDynamiqueInterrogateurSnmp(InterrogateurSNMP));
}
if (objet.TypeAnalyse != null && objet.TypeAnalyse == typeof(CAgentSnmpPourSupervision))
{
//Ajoute les requêtes
foreach (IRunnableEasyQuery query in TypeAgent.Queries)
{
CDefinitionProprieteDynamiqueRunnableEasyQuery def = new CDefinitionProprieteDynamiqueRunnableEasyQuery(query);
def.Rubrique = "Queries";
lstDefs.Add(def);
}
//Ajoute les listes de types d'entités
foreach (CTypeEntiteSnmpPourSupervision typeEntite in TypeAgent.TypesEntites)
{
CDefinitionProprieteDynamiqueListeEntitesSnmp def = new CDefinitionProprieteDynamiqueListeEntitesSnmp(typeEntite);
def.Rubrique = "Entities";
lstDefs.Add(def);
}
}
if (objet.TypeAnalyse == typeof(CEntiteSnmpPourSupervision))
{
if (defParente is CDefinitionProprieteDynamiqueListeEntitesSnmp)
{
CDefinitionProprieteDynamiqueListeEntitesSnmp defListe = defParente as CDefinitionProprieteDynamiqueListeEntitesSnmp;
CTypeEntiteSnmpPourSupervision typeEntite = new CTypeEntiteSnmpPourSupervision(Database);
if (typeEntite.ReadIfExist(defListe.NomProprieteSansCleTypeChamp))
{
foreach (IChampEntiteSNMP champ in typeEntite.Champs)
{
lstDefs.Add(new CDefinitionProprieteDynamiqueChampEntiteSnmp(champ));
}
}
}
else
{
foreach (IChampEntiteSNMP champ in TypeAgent.TousLesChampsSNMPDefinis)
{
lstDefs.Add(new CDefinitionProprieteDynamiqueChampEntiteSnmp(champ));
}
}
}
return(lstDefs.ToArray());
}
public CDefinitionProprieteDynamique[] GetDefinitionsChamps(CObjetPourSousProprietes objet, CDefinitionProprieteDynamique defParente)
{
List <CDefinitionProprieteDynamique> lstProps = new List <CDefinitionProprieteDynamique>();
if (objet == null)
{
return(lstProps.ToArray());
}
Type tp = objet.TypeAnalyse;
if (tp == null)
{
return(lstProps.ToArray());
}
//Données ucmulées
CTypeDonneeCumulee[] donnees = GetTypesDonneesPourType(tp);
foreach (CTypeDonneeCumulee typeDonnee in donnees)
{
int nCle = 0;
foreach (CCleDonneeCumulee cle in typeDonnee.Parametre.ChampsCle)
{
if (cle.TypeLie == tp)
{
CDefinitionProprieteDynamiqueDonneeCumulee def =
new CDefinitionProprieteDynamiqueDonneeCumulee(
typeDonnee,
nCle);
lstProps.Add(def);
break;
}
}
}
return(lstProps.ToArray());
}
//-------------------------------------------------
public CDefinitionProprieteDynamique[] GetDefinitionsChamps(CObjetPourSousProprietes objet, CDefinitionProprieteDynamique defParente)
{
if (objet != null)
{
Type tp = objet.TypeAnalyse;
if (tp.IsSubclassOf(GetType()) || tp == GetType())
{
return(GetProprietesInstance());
}
;
CFournisseurPropDynStd four = new CFournisseurPropDynStd(true);
IFournisseurProprietesDynamiques fourDeVariable = GetFournisseurPourDefinitionChamp(defParente, objet.TypeAnalyse);
if (fourDeVariable == null)
{
fourDeVariable = four;
}
return(fourDeVariable.GetDefinitionsChamps(objet, defParente));
}
return(new CDefinitionProprieteDynamique[0]);
}
/// //////////////////////////////////////////////////////
private void Init(C2iChampDeRequete champ, Type typeSource, CDefinitionProprieteDynamique defRacineDeChamps)
{
m_champ = champ;
m_defRacineDeChamps = defRacineDeChamps;
m_typeSource = typeSource;
}
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteType(ref m_typeCible);
int nTmp = (int)m_typeEvenement;
serializer.TraiteInt(ref nTmp);
m_typeEvenement = (TypeEvenement)nTmp;
I2iSerializable objet = m_proprieteASurveiller;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_proprieteASurveiller = (CDefinitionProprieteDynamique)objet;
objet = m_formuleValeurAvant;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_formuleValeurAvant = (C2iExpression)objet;
objet = m_formuleValeurApres;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_formuleValeurApres = (C2iExpression)objet;
objet = m_formuleConditionDeclenchement;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_formuleConditionDeclenchement = (C2iExpression)objet;
objet = m_formuleDateProgramme;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_formuleDateProgramme = (C2iExpression)objet;
serializer.TraiteString(ref m_strCodeHandler);
if (nVersion >= 1)
{
serializer.TraiteString(ref m_strMenuManuel);
if (nVersion < 6 && serializer.Mode == ModeSerialisation.Lecture)
{
//TESTDBKEYOK les groupes pour exécution manuelle ne sont plus exploités (Avril 2014)
IList lst = new ArrayList();
serializer.TraiteListeObjetsSimples(ref lst);
List <CDbKey> lstIdsTemp = new List <CDbKey>();
foreach (int nId in lst)
{
lstIdsTemp.Add(CDbKey.GetNewDbKeyOnIdAUtiliserPourCeuxQuiNeGerentPasLeDbKey(nId));
}
m_lstKeysGroupesManuels = lstIdsTemp.ToArray();
}
else
{
//TESTDBKEYTODO
IList lstKeysString = new ArrayList();
foreach (CDbKey key in m_lstKeysGroupesManuels)
{
if (key != null)
{
lstKeysString.Add(key.StringValue);
}
}
serializer.TraiteListeObjetsSimples(ref lstKeysString);
if (serializer.Mode == ModeSerialisation.Lecture)
{
List <CDbKey> lstKeys = new List <CDbKey>();
foreach (string strKey in lstKeysString)
{
int nId;
if (int.TryParse(strKey, out nId))
{
lstKeys.Add(CDbKey.GetNewDbKeyOnIdAUtiliserPourCeuxQuiNeGerentPasLeDbKey(nId));
}
else
{
lstKeys.Add(CDbKey.CreateFromStringValue(strKey));
}
m_lstKeysGroupesManuels = lstKeys.ToArray();
}
}
}
}
if (nVersion >= 2)
{
serializer.TraiteInt(ref m_nOrdreExecution);
}
if (nVersion >= 3)
{
serializer.TraiteString(ref m_strIdEvenementSpecifique);
}
if (nVersion >= 4)
{
serializer.TraiteBool(ref m_bHideProgress);
}
else
{
m_bHideProgress = false;
}
if (nVersion >= 5)
{
int nNbContextes = m_contextesException.Count;
serializer.TraiteInt(ref nNbContextes);
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
foreach (string strContexte in m_contextesException)
{
string strCtx = strContexte;
serializer.TraiteString(ref strCtx);
}
break;
case ModeSerialisation.Lecture:
m_contextesException = new HashSet <string>();
for (int i = 0; i < nNbContextes; i++)
{
string strCtx = "";
serializer.TraiteString(ref strCtx);
m_contextesException.Add(strCtx);
}
break;
}
}
return(result);
}
//-----------------------------
public CDefinitionProprieteDynamique[] GetDefinitionsChamps(Type typeInterroge, int nNbNiveaux, CDefinitionProprieteDynamique defParente)
{
return(GetDefinitionsChamps(typeInterroge, null));
}
public CTagMenu(Type typeSource, CDefinitionProprieteDynamique defProp, CSmartField smartField)
{
TypeSource = typeSource;
DefProp = defProp;
SmartField = smartField;
}
//----------------------------------------------------------------------------
public CDefinitionProprieteDynamique[] GetDefinitionsChamps(CObjetPourSousProprietes objet, CDefinitionProprieteDynamique defParente)
{
List <CDefinitionProprieteDynamique> lstDefs = new List <CDefinitionProprieteDynamique>();
if (typeof(CLocalAlarme).IsAssignableFrom(objet.TypeAnalyse))
{
CLocalTypeAlarme typeAlarme = this;
while (typeAlarme != null)
{
foreach (CLocalRelationTypeAlarmeChampAlarme rel in typeAlarme.RelationsChamps)
{
lstDefs.Add(new CDefinitionProprieteDynamiqueChampAlarme(rel.Champ));
}
typeAlarme = typeAlarme.TypeParent;
}
}
lstDefs.AddRange(new CFournisseurGeneriqueProprietesDynamiques().GetDefinitionsChamps(objet));
return(lstDefs.ToArray());
}
/// ////////////////////////////////////////////////// public abstract void InsereDefinitionToObjetFinal(CDefinitionProprieteDynamique def);
/// ///////////////////////////////////////////////////////////
public virtual CDefinitionProprieteDynamique[] GetDefinitionsChamps(Type tp, int nProfondeur, CDefinitionProprieteDynamique defParente)
{
CFournisseurGeneriqueProprietesDynamiques fournisseur = new CFournisseurGeneriqueProprietesDynamiques();
fournisseur.AvecReadOnly = AvecReadOnly;
return(fournisseur.GetDefinitionsChamps(tp, nProfondeur, defParente));
/*
* ArrayList lstProprietes = new ArrayList();
* GetDefinitionsChamps ( tp, nProfondeur, lstProprietes, "", "", defParente );
* lstProprietes.Sort();
* return (CDefinitionProprieteDynamique[])lstProprietes.ToArray(typeof(CDefinitionProprieteDynamique));*/
}
public CTreeViewData(object source, CDefinitionProprieteDynamique definition, int?nIndex)
{
m_source = source;
m_propriete = definition;
m_nIndex = nIndex;
}
/// <summary>
/// Indique si l'évenement doit se déclencher
/// </summary>
/// <param name="objet"></param>
/// <param name="bModeAvecInterface">
/// si vrai, les évenements de type Manuel ou Ouverture retournent vrai,
/// sinon, ils retournent systématiquement faux
/// </param>
/// <param name="bModeStatique">
/// Si vrai, les évenements de création sont vrai et les évenements
/// de modif sans valeur initiale retournent vrai si la valeur de fin est verifiée
/// </param>
/// <returns></returns>
public bool ShouldDeclenche(CObjetDonneeAIdNumerique objet, bool bModeAvecInterface, bool bModeStatique, ref CInfoDeclencheurProcess infoDeclencheur)
{
CResultAErreur result = CResultAErreur.True;
if (ContextesException.Contains(objet.ContexteDeModification))
{
return(false);
}
//CObjetDonneeAIdNumeriqueAuto objetToEval = objet;
CDefinitionProprieteDynamique defPropriete = ProprieteASurveiller;
if (objet is CRelationElementAChamp_ChampCustom)
{
if (!(defPropriete is CDefinitionProprieteDynamiqueChampCustom))
{
return(false);
}
CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)objet;
if (rel.ChampCustom.DbKey != ((CDefinitionProprieteDynamiqueChampCustom)defPropriete).DbKeyChamp)
{
return(false);
}
}
CObjetDonneeAIdNumerique objetToTest = GetObjetToRun(objet);
if (objetToTest == null)
{
return(false);
}
DataRowVersion versionToReturnOriginal = objetToTest.VersionToReturn;
try
{
if (objetToTest.Row.RowState == DataRowState.Deleted)
{
objetToTest.VersionToReturn = DataRowVersion.Original;
}
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(objetToTest);
object valeurAvant;
object valeurApres;
infoDeclencheur = new CInfoDeclencheurProcess();
infoDeclencheur.TypeDeclencheur = TypeEvenement;
switch (TypeEvenement)
{
case TypeEvenement.Manuel:
if (!bModeAvecInterface)
{
return(false);
}
break;
case TypeEvenement.Creation:
if (objet.Row.RowState != DataRowState.Added && !bModeStatique)
{
return(false);
}
break;
case TypeEvenement.Date:
//Vérifie si la date a changé
if (defPropriete != null)
{
if (!bModeStatique)
{
valeurAvant = GetValeur(objet, defPropriete, DataRowVersion.Original);
valeurApres = GetValeur(objet, defPropriete, DataRowVersion.Current);
if (TestEgalite(valeurApres, valeurAvant))
{
return(false);
}
}
}
break;
case TypeEvenement.Modification:
if (objet.Row.RowState == DataRowState.Modified || objet.Row.RowState == DataRowState.Added || bModeStatique)
{
if (defPropriete != null)
{
try
{
valeurAvant = null;
if (objet.Row.RowState == DataRowState.Modified)
{
valeurAvant = GetValeur(objet, defPropriete, DataRowVersion.Original);
}
valeurApres = GetValeur(objet, defPropriete, DataRowVersion.Current);
if (objet.Row.RowState == DataRowState.Modified && TestEgalite(valeurApres, valeurAvant))
{
return(false);
}
if (FormuleValeurAvant != null)
{
if (bModeStatique)
{
return(false);
}
result = FormuleValeurAvant.Eval(contexteEval);
if (!result)
{
return(false);
}
if (!TestEgalite(result.Data, valeurAvant))
{
return(false);
}
}
if (FormuleValeurApres != null)
{
result = FormuleValeurApres.Eval(contexteEval);
if (!result)
{
return(false);
}
if (!TestEgalite(result.Data, valeurApres))
{
return(false);
}
}
infoDeclencheur.ValeurOrigine = valeurAvant;
}
catch
{
return(false);
}
}
}
else
{
return(false);
}
break;
case TypeEvenement.Specifique:
if (objet.Table.Columns.Contains(EvenementAttribute.c_champEvenements))
{
if (!EvenementAttribute.HasEvent(objet, IdEvenementSpecifique))
{
return(false);
}
}
//Stef 110309 : Si on annule l'évenement là, et qu'il y a d'autres
//Hanlder sur cet évenement, les autres handler ne se déclencheront pas
//il faut donc annuler l'evenement quand on a parcouru tous les évenements
//Donc, dans le CGestionnaireEvenements
//EvenementAttribute.AnnuleEvenement(objet, IdEvenementSpecifique);
break;
case TypeEvenement.Suppression:
if (objet.Row.RowState != DataRowState.Deleted)
{
return(false);
}
break;
}
//Evalue la condition
if (FormuleConditionDeclenchement != null)
{
result = FormuleConditionDeclenchement.Eval(contexteEval);
if (!result)
{
return(result);
}
if (result.Data is bool)
{
if (!(bool)result.Data)
{
return(false);
}
}
else if (result.Data.ToString() == "" || result.Data.ToString() == "0")
{
return(false);
}
}
}
catch
{
}
finally
{
objetToTest.VersionToReturn = versionToReturnOriginal;
}
return(true);
}
public override void CopyTo(CDefinitionProprieteDynamique def)
{
base.CopyTo(def);
((CDefinitionProprieteDynamiqueRelationTypeIdToParent)def).m_relation = (RelationTypeIdAttribute)CCloner2iSerializable.Clone(m_relation);
((CDefinitionProprieteDynamiqueRelationTypeIdToParent)def).m_typeParent = m_typeParent;
}
/// /////////////////////////////////////////////////////////
public static object GetValeur(CObjetDonnee objet, CDefinitionProprieteDynamique prop, DataRowVersion version)
{
if (prop is CDefinitionProprieteDynamiqueChampCustom)
{
//Evaluation d'un champ custom
if (objet is CRelationElementAChamp_ChampCustom)
{
CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)objet;
return(rel.GetValeur(version));
}
if (objet is IElementAChamps)
{
return(((IElementAChamps)objet).GetValeurChamp(((CDefinitionProprieteDynamiqueChampCustom)prop).DbKeyChamp, version));
}
}
else
{
#region Evaluation d'un champ
PropertyInfo info = objet.GetType().GetProperty(prop.NomProprieteSansCleTypeChamp);
object[] attribs = info.GetCustomAttributes(typeof(TableFieldPropertyAttribute), true);
if (attribs.Length != 0)
{
TableFieldPropertyAttribute attrTable = (TableFieldPropertyAttribute)attribs[0];
try
{
object val = objet.Row[attrTable.NomChamp, version];
if (val == DBNull.Value)
{
val = null;
}
return(val);
}
catch
{
return(null);
}
}
else
{
attribs = info.GetCustomAttributes(typeof(RelationAttribute), true);
if (attribs.Length != 0)
{
RelationAttribute attrRel = (RelationAttribute)attribs[0];
try
{
object val = objet.Row[attrRel.ChampsFils[0], version];
if (val == DBNull.Value)
{
val = null;
}
return(val);
}
catch
{
return(null);
}
}
}
#endregion
}
return(null);
}
public override void CopyTo(CDefinitionProprieteDynamique def)
{
base.CopyTo(def);
((CDefinitionProprieteDynamiqueDonneeCumulee)def).m_dbKeyTypeDonneeCumulee = m_dbKeyTypeDonneeCumulee;
}
/// //////////////////////////////////////////////////////////////
public C2iOrigineChampExportChamp(CDefinitionProprieteDynamique champOrigine)
{
m_champOrigine = champOrigine;
}
/// /////////////////////////////////////////////
/// Implémentation du IFournisseurProprietesDynamiques
public CDefinitionProprieteDynamique[] GetDefinitionsChamps(Type tp, int nNbNiveaux, CDefinitionProprieteDynamique defParente)
{
CDefinitionProprieteDynamique[] defs = new CDefinitionProprieteDynamique[0];
if (!tp.IsSubclassOf(GetType()) && tp != GetType())
{
return(GetDefinitionsChamps(new CObjetPourSousProprietes(tp), defParente));
}
return(GetProprietesInstance());
}
/// /////////////////////////////////////////////////////////////////
public override void Init(CObjetPourSousProprietes objetPourSousProprietes, IFournisseurProprietesDynamiques fournisseur, CDefinitionProprieteDynamique definitionRacineDeChamps)
{
if (fournisseur == null)
{
fournisseur = new CFournisseurPropDynStd(false);
}
base.Init(objetPourSousProprietes, fournisseur, definitionRacineDeChamps);
}
//------------------------------------------------------------------
public CDefinitionProprieteDynamique[] GetDefinitionsChamps(CObjetPourSousProprietes objet, CDefinitionProprieteDynamique defParente)
{
List <CDefinitionProprieteDynamique> lstDefs = new List <CDefinitionProprieteDynamique>();
if (TrapHandler != null)
{
lstDefs.AddRange(TrapHandler.GetDefinitionsChamps(objet, defParente));
}
if (objet.TypeAnalyse != null && objet.TypeAnalyse == typeof(CLocalAlarme) && TypeAlarme != null)
{
lstDefs.AddRange(TypeAlarme.GetDefinitionsChamps(objet, defParente));
}
return(lstDefs.ToArray());
}
public CTagNode(Type typeAssocie, CDefinitionProprieteDynamique def)
{
TypeAssocie = typeAssocie;
Definition = def;
}
//------------------------------------------
private void InitChamps()
{
m_txtNomTable.Text = m_tableExport.NomTable;
//Indicateur de filtre
m_imageFiltre.Image = m_imagesFiltre.Images[m_tableExport.FiltreAAppliquer == null ? 1 : 0];
m_wndListeChamps.Items.Clear();
m_wndListeChamps.BeginUpdate();
if (m_tableExport.ChampOrigine is CDefinitionProprieteDynamiqueFormule)
{
m_imageFormuleTable.Visible = true;
}
else
{
m_imageFormuleTable.Visible = false;
}
m_imageFiltre.Visible = m_imageFiltre.Visible && !m_imageFormuleTable.Visible;
foreach (C2iChampExport champ in m_tableExport.Champs)
{
ListViewItem item = new ListViewItem();
FillItemForChamp(item, champ);
m_wndListeChamps.Items.Add(item);
}
m_wndListeChamps.EndUpdate();
//Peut-on appliquer un filtre sur cette table ?
m_imageFiltre.Visible = false;
if (m_structureExport.IsStructureComplexe && m_tableExport.ChampOrigine != null &&
m_tableExport.ChampOrigine is CDefinitionProprieteDynamiqueDonneeCumulee ||
m_tableExport.ChampOrigine is CDefinitionProprieteDynamiqueRelationTypeId)
{
m_imageFiltre.Visible = true;
}
if (!m_imageFiltre.Visible && m_tableParente != null)
{
Type typeParent = m_structureExport.TypeSource;
if (m_tableParente != null && m_tableParente.ChampOrigine != null)
{
typeParent = m_tableParente.ChampOrigine.TypeDonnee.TypeDotNetNatif;
}
string strProp = m_tableExport.ChampOrigine.NomPropriete;
string[] strProps = strProp.Split('.');
PropertyInfo info = null;
string strTmp = "";
foreach (string strSousProp in strProps)
{
string strSousPropDecomposee = strSousProp;
CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(strSousProp, ref strTmp, ref strSousPropDecomposee);
info = typeParent.GetProperty(strSousPropDecomposee);
if (info != null)
{
typeParent = info.PropertyType;
}
else
{
break;
}
}
if (info != null)
{
m_imageFiltre.Visible = typeof(CListeObjetsDonnees).IsAssignableFrom(info.PropertyType);
}
}
// Est-ce une structure simple ?
if (!m_structureExport.IsStructureComplexe)
{
m_imageFiltre.Visible = false;
Type tp = m_structureExport.TypeSource;
if (m_tableExport.ChampOrigine != null)
{
tp = m_tableExport.ChampOrigine.TypeDonnee.TypeDotNetNatif;
}
CStructureTable structure = CStructureTable.GetStructure(tp);
m_wndListeChamps.BeginUpdate();
foreach (CInfoChampTable info in structure.Champs)
{
ListViewItem item = new ListViewItem(info.NomChamp);
item.Tag = info;
m_wndListeChamps.Items.Add(item);
}
m_wndListeChamps.EndUpdate();
}
}
/// /////////////////////////////////////////////////////////////////
public virtual void Init(CObjetPourSousProprietes objetPourSousProprietes, IFournisseurProprietesDynamiques fournisseur, CDefinitionProprieteDynamique definitionRacineDeChamps)
{
m_objetPourSousProprietes = objetPourSousProprietes;
m_definitionRacineDeChamp = definitionRacineDeChamps;
m_fournisseur = fournisseur;
m_remplisseur = new CRemplisseurArbreStructureDynamique(m_arbre, m_objetPourSousProprietes, m_fournisseur, null, definitionRacineDeChamps);
m_remplisseur.m_beforeAddNode += new BeforeAddNode(m_remplisseur_m_beforeAddNode);
}
//----------------------------------------------------------------------------
public CDefinitionProprieteDynamique[] GetDefinitionsChamps(CObjetPourSousProprietes objet, CDefinitionProprieteDynamique defParente)
{
List <CDefinitionProprieteDynamique> lst = new List <CDefinitionProprieteDynamique>();
if (FournisseurPrincipal != null)
{
lst.AddRange(FournisseurPrincipal.GetDefinitionsChamps(objet, defParente));
}
foreach (CParametreFonctionDynamique parametre in Parametres)
{
CDefinitionProprieteDynamiqueVariableFormule def = new CDefinitionProprieteDynamiqueVariableFormule(
parametre.Nom,
parametre.TypeResultatExpression,
true);
def.Rubrique = I.T("Parameters|20128");
lst.Add(def);
}
return(lst.ToArray());
}
public CDefinitionProprieteDynamique SelectPropriete(
CDefinitionProprieteDynamique propSelectionnee
)
{
return(SelectPropriete(propSelectionnee, null));
}
/// //////////////////////////////////////////////////////
public override void CopyTo(CDefinitionProprieteDynamique def)
{
base.CopyTo(def);
((CDefinitionProprieteDynamiqueChampCustomDisplayValue)def).m_dbKeyChamp = m_dbKeyChamp;
}
//-------------------------------------------------
public CDefinitionProprieteDynamique[] GetDefinitionsChamps(CObjetPourSousProprietes objet, CDefinitionProprieteDynamique defParente)
{
CFournisseurGeneriqueProprietesDynamiques fournisseur = new CFournisseurGeneriqueProprietesDynamiques();
fournisseur.AvecReadOnly = AvecReadOnly;
return(fournisseur.GetDefinitionsChamps(objet, defParente));
/*
* List<CDefinitionProprieteDynamique> lst = new List<CDefinitionProprieteDynamique>();
* if (objet != null)
* {
* lst.AddRange(GetDefinitionsChamps(objet.TypeAnalyse, 0, defParente));
* if (objet.ElementAVariableInstance != null)
* lst.AddRange(objet.ElementAVariableInstance.GetProprietesInstance());
* }
* return lst.ToArray();
*/
}
