Exemple #1
0
        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());
 }
Exemple #5
0
 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);
        }
Exemple #9
0
        /// ///////////////////////////////////////////////////////////
        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*/);
                }
            }
        }
Exemple #10
0
 public static void Autoexec()
 {
     CGestionnaireMethodesSupplementaires.RegisterMethode(new CMethodeSupplementaireReplaceEOs());
 }
 public static void Autoexec()
 {
     CGestionnaireMethodesSupplementaires.RegisterMethode(new CMethodSetValeurVariableSurObjet());
 }
Exemple #12
0
 public static void Autoexec()
 {
     CGestionnaireMethodesSupplementaires.RegisterMethode(new CIntervention_MethodePourCVersion());
 }
Exemple #13
0
 /// ///////////////////////////////////////////
 public static void Autoexec()
 {
     CGestionnaireMethodesSupplementaires.RegisterMethode(new CMethodeProcessGetUtilisateur());
 }
 public static void Autoexec()
 {
     CGestionnaireMethodesSupplementaires.RegisterMethode(new CMethodeSupplementaireGetCaracteristiques());
 }
Exemple #15
0
 public static void Autoexec()
 {
     CGestionnaireMethodesSupplementaires.RegisterMethode(new CMethodGetStrongNamesSurObjet());
 }