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());
}
//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 = CTypeResultatExpression.FromTypeDotNet(methode.ReturnType);
ParameterInfo[] parametres = methode.GetParameters();
StringBuilder bl = new StringBuilder();
bl.Append(methode.Name);
bl.Append("(");
foreach (ParameterInfo info in parametres)
{
bl.Append(info.Name);
bl.Append("; ");
}
if (parametres.Length > 0)
{
bl.Remove(bl.Length - 2, 2);
}
bl.Append(")");
CDefinitionProprieteDynamique def = new CDefinitionMethodeDynamique(
bl.ToString(),
methode.Name,
typeRes,
CFournisseurGeneriqueProprietesDynamiques.HasSubProperties(typeRes.TypeDotNetNatif),
attrib.Descriptif,
attrib.InfosParametres);
def.Rubrique = I.T("Methods|58");
lstProps.Add(def);
}
}
foreach (CMethodeSupplementaire methode in CGestionnaireMethodesSupplementaires.GetMethodsForType(tp))
{
CDefinitionProprieteDynamique def = new CDefinitionMethodeDynamique(
methode.Name,
methode.Name,
new CTypeResultatExpression(methode.ReturnType, methode.ReturnArrayOfReturnType),
CFournisseurGeneriqueProprietesDynamiques.HasSubProperties(methode.ReturnType));
def.Rubrique = I.T("Methods|58");
lstProps.Add(def);
}
return(lstProps.ToArray());
}
/// ///////////////////////////////////////////
public static void Autoexec()
{
CGestionnaireMethodesSupplementaires.RegisterMethode(new CMethodeEtapeWorkflowGetAssignedMembers());
}
/// ///////////////////////////////////////////
public static void Autoexec()
{
CGestionnaireMethodesSupplementaires.RegisterMethode(new CMethodeWorkflowGetCurrentProjectForStepType());
}
public static void Autoexec()
{
CGestionnaireMethodesSupplementaires.RegisterMethode(new CMethodeSupplementaireSelectEquipmentDatas());
}
public static void Autoexec()
{
CGestionnaireMethodesSupplementaires.RegisterMethode(new CMethodeSupplementaireRefreshFromSNMP());
}
public static void Autoexec()
{
CGestionnaireMethodesSupplementaires.RegisterMethode(new CMethodeSupplementaireSelectLastSiteDataAt());
}
public static void Autoexec()
{
CGestionnaireMethodesSupplementaires.RegisterMethode(new CMethodeDynamiqueEditeElementForCEncapsuleur());
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] listeParametres)
{
CResultAErreur result = CResultAErreur.True;
if (ctx.ObjetSource == null)
{
result.Data = null;
return(result);
}
try
{
if (ctx.ObjetSource is IElementAFonctionsDynamiques && m_definitionFonction != null)
{
CFonctionDynamique fTmp = ((IElementAFonctionsDynamiques)ctx.ObjetSource).GetFonctionDynamique(m_definitionFonction.IdFonction);
if (fTmp != null)
{
m_fonction = fTmp;
}
}
if (m_fonction == null && ctx.ObjetBase is IElementAFonctionsDynamiques && m_definitionFonction != null)
{
CFonctionDynamique fTmp = ((IElementAFonctionsDynamiques)ctx.ObjetBase).GetFonctionDynamique(m_definitionFonction.IdFonction);
if (fTmp != null)
{
m_fonction = fTmp;
}
}
if (FonctionDynamique != null)
{
result = FonctionDynamique.Eval(ctx, listeParametres);
}
else if (DefinitionMethode != null)
{
object source = ctx.ObjetSource;
//Compatiblité (remplacement de méthodes par fonctions
bool bHasEvalFonction = false;
if (source is IElementAFonctionsDynamiques)
{
CFonctionDynamique fTmp = ((IElementAFonctionsDynamiques)source).GetFonctionDynamique(DefinitionMethode.Nom);
if (fTmp != null)
{
result = fTmp.Eval(ctx, listeParametres);
bHasEvalFonction = true;
}
}
if (!bHasEvalFonction)
{
MethodInfo info = ctx.ObjetSource.GetType().GetMethod(DefinitionMethode.NomProprieteSansCleTypeChamp);
if (info == null)
{
IInterpreteurMethodeDynamique inter = source as IInterpreteurMethodeDynamique;
if (inter != null)
{
inter.GetMethodInfo(DefinitionMethode.NomProprieteSansCleTypeChamp, ref info, ref source);
}
}
if (info == null)
{
CMethodeSupplementaire method = CGestionnaireMethodesSupplementaires.GetMethod(ctx.ObjetSource.GetType(), DefinitionMethode.NomProprieteSansCleTypeChamp);
if (method != null)
{
result.Data = method.Invoke(source, listeParametres);
return(result);
}
result.EmpileErreur(I.T("Cannot find @1 method|124", DefinitionMethode.NomProprieteSansCleTypeChamp));
return(result);
}
result.Data = info.Invoke(source, listeParametres);
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error during @1 method evaluation|123",
DefinitionMethode != null?
DefinitionMethode.NomProprieteSansCleTypeChamp:
FonctionDynamique != null?
FonctionDynamique.Nom:
"?"));
}
return(result);
}
/// ///////////////////////////////////////////////////////////
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 static void Autoexec()
{
CGestionnaireMethodesSupplementaires.RegisterMethode(new CMethodeSupplementaireReplaceEOs());
}
public static void Autoexec()
{
CGestionnaireMethodesSupplementaires.RegisterMethode(new CMethodSetValeurVariableSurObjet());
}
public static void Autoexec()
{
CGestionnaireMethodesSupplementaires.RegisterMethode(new CIntervention_MethodePourCVersion());
}
/// ///////////////////////////////////////////
public static void Autoexec()
{
CGestionnaireMethodesSupplementaires.RegisterMethode(new CMethodeProcessGetUtilisateur());
}
public static void Autoexec()
{
CGestionnaireMethodesSupplementaires.RegisterMethode(new CMethodeSupplementaireGetCaracteristiques());
}
public static void Autoexec()
{
CGestionnaireMethodesSupplementaires.RegisterMethode(new CMethodGetStrongNamesSurObjet());
}