예제 #1
0
        /// ///////////////////////////////////////////
        public override CResultAErreur Serialize(C2iSerializer serializer)
        {
            int            nVersion = GetNumVersion();
            CResultAErreur result   = serializer.TraiteVersion(ref nVersion);

            if (!result)
            {
                return(result);
            }

            result = base.Serialize(serializer);
            if (!result)
            {
                return(result);
            }
            I2iSerializable objet = (I2iSerializable)m_filtreDynamique;

            result = serializer.TraiteObject(ref objet);
            if (!result)
            {
                return(result);
            }
            m_filtreDynamique = (CFiltreDynamique)objet;
            return(result);
        }
        /// //////////////////////////////////////////////////
        public override CResultAErreur GetComposantExpression(CFiltreDynamique filtreDynamique)
        {
            CResultAErreur result             = CResultAErreur.True;
            CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(filtreDynamique);

            if (ConditionApplication != null)
            {
                result = ConditionApplication.Eval(ctx);
                if (!result)
                {
                    result.EmpileErreur(I.T("Error while evaluation of @1|143", ConditionApplication.GetString()));
                    return(result);
                }

                if (!((result.Data is bool && (bool)result.Data) || result.Data.ToString() == "1"))
                {
                    result.Data = null;
                    return(result);
                }
            }
            C2iExpressionChamp expChamp         = new C2iExpressionChamp(m_champ);
            C2iExpression      expressionIsNull = new C2iExpressionEstNull();

            expressionIsNull.Parametres.Add(expChamp);
            result.Data = expressionIsNull;
            if (!TestNull)
            {
                C2iExpression expNon = new C2iExpressionNon();
                expNon.Parametres.Add(expressionIsNull);
                result.Data = expNon;
            }
            return(result);
        }
예제 #3
0
        public CListeObjetsDonnees GetElementsLiesFor(Object obj)
        {
            if (obj == null)
            {
                return(null);
            }
            if (obj.GetType() != TypeElementsSourceRecherche)
            {
                return(null);
            }

            //Calcule le filtre
            try
            {
                CFiltreDynamique filtreDyn = FiltreDynamique;
                IElementAVariablesDynamiquesAvecContexteDonnee eltAVariables = GetElementAVariableSource(obj);
                filtreDyn.ElementAVariablesExterne = eltAVariables;
                if (filtreDyn != null)
                {
                    CResultAErreur result = filtreDyn.GetFiltreData();
                    if (result && result.Data is CFiltreData)
                    {
                        CListeObjetsDonnees liste = new CListeObjetsDonnees(ContexteDonnee, TypeElements, (CFiltreData)result.Data);
                        return(liste);
                    }
                }
            }
            catch { }
            return(null);
        }
 /// //////////////////////////////////////////////////
 public override void OnChangeVariable(CFiltreDynamique filtre, CVariableDynamique variable)
 {
     foreach (CComposantFiltreDynamique composant in m_listeComposantsFils)
     {
         composant.OnChangeVariable(filtre, variable);
     }
 }
        /// ///////////////////////////////////////////////////
        public override CResultAErreur GetComposantExpression(CFiltreDynamique filtre)
        {
            CResultAErreur result         = CResultAErreur.True;
            C2iExpression  expressionPrec = null;

            foreach (CComposantFiltreDynamique cp in ComposantsFils)
            {
                result = cp.GetComposantExpression(filtre);
                if (result)
                {
                    C2iExpression exp = result.Data as C2iExpression;
                    if (exp != null)
                    {
                        if (expressionPrec != null)
                        {
                            C2iExpression expLogique = GetExpressionOperateurLogique();
                            expLogique.Parametres.Add(expressionPrec);
                            expLogique.Parametres.Add(exp);
                            expressionPrec = expLogique;
                        }
                        else
                        {
                            expressionPrec = exp;
                        }
                    }
                }
                else
                {
                    return(result);
                }
            }
            result.Data = expressionPrec;
            return(result);
        }
        //---------------------------------------
        private void InitFiltres()
        {
            CTypeDonneeCumulee typeDonnee = GetTypeDonneeCumulee(CContexteDonneeSysteme.GetInstance());

            if (typeDonnee == null)
            {
                m_listeFiltresDeBase.Clear();
                m_listeFiltresUser.Clear();
                return;
            }
            CParametreDonneeCumulee   parametre   = typeDonnee.Parametre;
            Dictionary <string, bool> dicToDelete = new Dictionary <string, bool>();

            foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresDeBase)
            {
                dicToDelete[filtre.ChampAssocie] = true;
            }
            foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresUser)
            {
                dicToDelete[filtre.ChampAssocie] = true;
            }
            foreach (CCleDonneeCumulee cle in parametre.ChampsCle)
            {
                if (cle.TypeLie != null)
                {
                    CFiltreDonneePrecalculee filtre = m_listeFiltresDeBase.FirstOrDefault(f => f.ChampAssocie == cle.Champ);
                    if (filtre != null)
                    {
                        dicToDelete[filtre.ChampAssocie] = false;
                    }
                    if (m_listeFiltresDeBase.Count(f => f.ChampAssocie == cle.Champ) == 0)
                    {
                        CFiltreDynamique filtreTmp = new CFiltreDynamique();
                        filtreTmp.TypeElements = cle.TypeLie;
                        m_listeFiltresDeBase.Add(new CFiltreDonneePrecalculee(cle.Champ, cle.Champ, filtreTmp));
                    }
                    if (m_listeFiltresUser.Count(f => f.ChampAssocie == cle.Champ) == 0)
                    {
                        CFiltreDynamique filtreTmp = new CFiltreDynamique();
                        filtreTmp.TypeElements = cle.TypeLie;
                        m_listeFiltresUser.Add(new CFiltreDonneePrecalculee(cle.Champ, cle.Champ, filtreTmp));
                    }
                }
            }
            foreach (KeyValuePair <string, bool> kv in dicToDelete)
            {
                if (kv.Value)
                {
                    foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresUser.FindAll(f => f.ChampAssocie == kv.Key).ToArray())
                    {
                        m_listeFiltresUser.Remove(filtre);
                    }
                    foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresDeBase.FindAll(f => f.ChampAssocie == kv.Key).ToArray())
                    {
                        m_listeFiltresDeBase.Remove(filtre);
                    }
                }
            }
        }
예제 #7
0
 public CFiltreDonneePrecalculee(string strChampAssocie,
                                 string strLibelle,
                                 CFiltreDynamique filtre)
 {
     m_filtre          = filtre;
     m_strChampAssocie = strChampAssocie;
     m_strLibelle      = strLibelle;
 }
        /// ///////////////////////////////////////////////////
        public override CResultAErreur GetComposantFiltreData(CFiltreDynamique filtre, CFiltreData filtreData)
        {
            CResultAErreur result = CResultAErreur.True;

            try
            {
                if (m_listeComposantsFils.Count < 1)
                {
                    return(result);
                }
                result = ((CComposantFiltreDynamique)m_listeComposantsFils[0]).GetComposantFiltreData(filtre, filtreData);
                if (!result)
                {
                    result.EmpileErreur(I.T("Error in element @1|136", ((CComposantFiltreDynamique)m_listeComposantsFils[0]).Description));
                    result.Data = null;
                    return(result);
                }
                CComposantFiltre composantAvant = (CComposantFiltre)result.Data;
                for (int nComposant = 1; nComposant < m_listeComposantsFils.Count; nComposant++)
                {
                    CComposantFiltreDynamique composantDynamique = (CComposantFiltreDynamique)m_listeComposantsFils[nComposant];
                    result = composantDynamique.GetComposantFiltreData(filtre, filtreData);
                    if (!result)
                    {
                        result.EmpileErreur(I.T("Error in element @1|136", ((CComposantFiltreDynamique)m_listeComposantsFils[nComposant]).Description));
                        result.Data = null;
                        return(result);
                    }
                    if (result.Data != null)
                    {
                        if (composantAvant != null)
                        {
                            CComposantFiltreOperateur parenthesesNew = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurParentheses);
                            CComposantFiltreOperateur parenthesesOld = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurParentheses);
                            parenthesesNew.Parametres.Add(result.Data);
                            parenthesesOld.Parametres.Add(composantAvant);
                            CComposantFiltreOperateur operateur = new CComposantFiltreOperateur(GetIdComposantFiltreOperateur());
                            operateur.Parametres.Add(parenthesesOld);
                            operateur.Parametres.Add(parenthesesNew);
                            composantAvant = operateur;
                        }
                        else
                        {
                            composantAvant = (CComposantFiltre)result.Data;
                        }
                    }
                }
                result.Data = composantAvant;
                return(result);
            }
            catch (Exception e)
            {
                result.EmpileErreur(new CErreurException(e));
                return(result);
            }
        }
예제 #9
0
        //----------------------------------------------------------------------------------
        public CResultAErreur Serialize(C2iSerializer serialiser)
        {
            int            nVersion = GetNumVersion();
            CResultAErreur result   = serialiser.TraiteVersion(ref nVersion);

            if (!result)
            {
                return(result);
            }
            serialiser.TraiteString(ref m_strNomTable);

            I2iSerializable obj = ChampOrigine;

            result = serialiser.TraiteObject(ref obj);
            if (!result)
            {
                return(result);
            }
            ChampOrigine = (CDefinitionProprieteDynamique)obj;

            obj    = m_requete;
            result = serialiser.TraiteObject(ref obj);
            if (!result)
            {
                return(result);
            }
            m_requete = (C2iRequeteAvancee)obj;
            if (m_requete == null)
            {
                m_requete = new C2iRequeteAvancee(null);
            }

            obj    = m_filtreAAppliquer;
            result = serialiser.TraiteObject(ref obj);
            if (!result)
            {
                return(result);
            }
            m_filtreAAppliquer = (CFiltreDynamique)obj;

            if (nVersion >= 1)
            {
                obj    = m_tableauCroise;
                result = serialiser.TraiteObject(ref obj);
                if (!result)
                {
                    return(result);
                }
                m_tableauCroise = (CTableauCroise)obj;
            }
            if (nVersion >= 2)
            {
                serialiser.TraiteBool(ref m_bNePasCalculer);
            }
            return(result);
        }
예제 #10
0
        /// //////////////////////////////////////////////////
        public override CResultAErreur VerifieIntegrite(CFiltreDynamique filtre)
        {
            CResultAErreur result = CResultAErreur.True;

            if (m_champTeste == null)
            {
                result.EmpileErreur(I.T("Field not defined|144"));
            }
            return(result);
        }
예제 #11
0
        ////////////////////////////////////////////////////////////////////////
        public static CFiltreDynamique GetFiltreDynamiqueSynchro(Type type)
        {
            CFiltreDynamique filtre = new CFiltreDynamique();

            filtre.TypeElements = type;
            CVariableDynamiqueListeTypeSimple variable = new CVariableDynamiqueListeTypeSimple(filtre);

            variable.TypeDonnee2i = new C2iTypeDonnee(TypeDonnee.tEntier);
            variable.Nom          = c_nomVariableListeUtilisateurs;
            filtre.AddVariable(variable);
            return(filtre);
        }
예제 #12
0
        ////////////////////////////////////////////////////////////////////////
        public CResultAErreur Serialize(C2iSerializer serializer)
        {
            int            nVersion = GetNumVersion();
            CResultAErreur result   = serializer.TraiteVersion(ref nVersion);

            if (!result)
            {
                return(result);
            }

            serializer.TraiteString(ref m_strNomTable);

            I2iSerializable objet = m_filtreDynamique;

            result = serializer.TraiteObject(ref objet);
            if (!result)
            {
                return(result);
            }
            m_filtreDynamique = (CFiltreDynamique)objet;

            objet  = m_relationToParent;
            result = serializer.TraiteObject(ref objet);
            if (!result)
            {
                return(result);
            }
            m_relationToParent = (CInfoRelation)objet;

            serializer.TraiteBool(ref m_bTouteLaTable);

            result = serializer.TraiteArrayListOf2iSerializable(m_listeFils);
            if (!result)
            {
                return(result);
            }
            if (serializer.Mode == ModeSerialisation.Lecture)
            {
                NettoieFiltresFils();
                foreach (CFiltreSynchronisation filtre in m_listeFils)
                {
                    filtre.DefinitParent(this, filtre.RelationToParent);
                }
            }

            if (nVersion >= 1)
            {
                serializer.TraiteBool(ref m_bIsAutoAdd);
            }
            return(result);
        }
        ////////////////////////////////////////////////////////////////////////
        public CFiltreDynamique GetFiltreDynamiqueForTable(string strNomTable, ref bool bShouldSynchroniseTable)
        {
            ArrayList lst = (ArrayList)m_tableTableToFiltreSynchronisation[strNomTable];
            Type      tp  = CContexteDonnee.GetTypeForTable(strNomTable);

            if (tp != null && tp.GetCustomAttributes(typeof(FullTableSyncAttribute), true).Length > 0)
            {
                bShouldSynchroniseTable = true;
                return(null);
            }
            if (lst == null || lst.Count == 0)
            {
                bShouldSynchroniseTable = false;
                return(null);
            }
            bShouldSynchroniseTable = true;
            CFiltreDynamique filtreDynamique = CFiltreSynchronisation.GetFiltreDynamiqueSynchro(CContexteDonnee.GetTypeForTable(strNomTable));

            CComposantFiltreDynamiqueOu composantOu = new CComposantFiltreDynamiqueOu();

            foreach (CFiltreSynchronisation filtreSynchro in lst)
            {
                if (filtreSynchro.TouteLaTable || filtreSynchro.FiltreDynamique == null)
                {
                    return(null);
                }
                CFiltreDynamique filtreLocal = filtreSynchro.GetFiltreToElementPrincipal();
                if (filtreLocal != null && filtreLocal.ComposantPrincipal != null)
                {
                    composantOu.AddComposantFils(filtreLocal.ComposantPrincipal);
                }
                if (filtreLocal == null)
                {
                    return(null);
                }
            }
            if (composantOu.GetNbComposantsFils() == 0)
            {
                return(null);
            }
            if (composantOu.GetNbComposantsFils() == 1)
            {
                filtreDynamique.ComposantPrincipal = composantOu.ComposantsFils[0];
            }
            else
            {
                filtreDynamique.ComposantPrincipal = composantOu;
            }
            return(filtreDynamique);
        }
예제 #14
0
        //----------------------------------------------------------------------------------
        public object Clone()
        {
            /*CStringSerializer serializer = new CStringSerializer(ModeSerialisation.Ecriture);
             * Serialize ( serializer );
             * string strData = serializer.String;
             *
             * serializer = new CStringSerializer ( strData, ModeSerialisation.Lecture );
             * filtreCopie.Serialize ( serializer );
             * return filtreCopie;*/
            CFiltreDynamique filtreCopie = new CFiltreDynamique(m_elementAVariablesExterne, ContexteDonnee);

            C2iSerializer.CloneTo(this, filtreCopie);
            return(filtreCopie);
        }
        /// //////////////////////////////////////////////////
        public override CResultAErreur VerifieIntegrite(CFiltreDynamique filtre)
        {
            CResultAErreur result = CResultAErreur.True;

            if (m_champ == null)
            {
                result.EmpileErreur(I.T("Field not defined|144"));
            }
            if (m_strIdOperateur == null)
            {
                result.EmpileErreur(I.T("Operator not defined|158"));
            }
            if (m_champValeur is CDefinitionProprieteDynamiqueChampCustom &&
                m_champ is CDefinitionProprieteDynamiqueChampCustom)
            {
                result.EmpileErreur(I.T("Test function not supported : Custom field = Custom field|159"));
                return(result);
            }
            if (ExpressionValeur == null && m_champValeur == null)
            {
                result.EmpileErreur(I.T("Value formula is incorrect|145"));
            }
            else if (ExpressionValeur != null)
            {
                ArrayList lstChamps = ExpressionValeur.ExtractExpressionsType(typeof(C2iExpressionChamp));
                foreach (C2iExpressionChamp expChamp in lstChamps)
                {
                    CDefinitionProprieteDynamique def = expChamp.DefinitionPropriete;
                    if (def == null)
                    {
                        result.EmpileErreur(I.T("Null field in value formula|160"));
                    }
                    else
                    {
                        if (def is CDefinitionProprieteDynamiqueVariableDynamique)
                        {
                            CDefinitionProprieteDynamiqueVariableDynamique defVar = (CDefinitionProprieteDynamiqueVariableDynamique)def;
                            CVariableDynamique variable = filtre.GetVariable(defVar.IdChamp);
                            if (variable == null)
                            {
                                result.EmpileErreur(I.T("The variable @1 doesn't exist|147", defVar.Nom));
                            }
                        }
                    }
                }
            }
            return(result);
        }
        /// //////////////////////////////////////////////////
        public override CResultAErreur VerifieIntegrite(CFiltreDynamique filtre)
        {
            CResultAErreur result = CResultAErreur.True;

            if (m_champ == null)
            {
                result.EmpileErreur(I.T("Field not defined|144"));
            }

            else if (!typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(m_champ.TypeDonnee.TypeDotNetNatif))
            {
                result.EmpileErreur(I.T("Cannot apply static selection on field @1|151", m_champ.Nom));
            }

            return(result);
        }
예제 #17
0
        /// ///////////////////////////////////////////////
        public override CResultAErreur Serialize(C2iSerializer serializer)
        {
            int            nVersion = GetNumVersion();
            CResultAErreur result   = serializer.TraiteVersion(ref nVersion);

            if (!result)
            {
                return(result);
            }
            result = base.Serialize(serializer);

            I2iSerializable obj = m_expressionAffichee;

            result = serializer.TraiteObject(ref obj);
            m_expressionAffichee = (C2iExpression)obj;

            obj    = m_expressionRetournee;
            result = serializer.TraiteObject(ref obj);
            m_expressionRetournee = (C2iExpression)obj;

            obj               = m_filtreSelection;
            result            = serializer.TraiteObject(ref obj);
            m_filtreSelection = (CFiltreDynamique)obj;

            if (nVersion > 0)
            {
                serializer.TraiteBool(ref m_bCanBeNull);
                serializer.TraiteString(ref m_strTextNull);
            }
            else
            {
                m_bCanBeNull  = false;
                m_strTextNull = "";
            }

            if (nVersion >= 2)
            {
                serializer.TraiteBool(ref m_bRechercheRapide);
            }
            else
            {
                m_bRechercheRapide = false;
            }
            return(result);
        }
예제 #18
0
 /// //////////////////////////////////////////////////
 protected void OnChangeVariable(CFiltreDynamique filtre, C2iExpression expression, CVariableDynamique variable)
 {
     if (expression == null)
     {
         return;
     }
     foreach (C2iExpressionChamp exp in expression.ExtractExpressionsType(typeof(C2iExpressionChamp)))
     {
         if (exp.DefinitionPropriete is CDefinitionProprieteDynamiqueVariableDynamique)
         {
             CDefinitionProprieteDynamiqueVariableDynamique def = (CDefinitionProprieteDynamiqueVariableDynamique)exp.DefinitionPropriete;
             if (def.IdChamp == variable.IdVariable)
             {
                 def = new CDefinitionProprieteDynamiqueVariableDynamique(variable);
                 exp.DefinitionPropriete = def;
             }
         }
     }
 }
        /// /////////////////////////////////////////////////////////////////////////
        public override CResultAErreur VerifieIntegrite(CFiltreDynamique filtre)
        {
            CResultAErreur result = CResultAErreur.True;

            if (m_listeComposantsFils.Count == 0)
            {
                result.EmpileErreur(I.T("The component @1 has no sub-component|138", Description));
                return(result);
            }
            foreach (CComposantFiltreDynamique composant in m_listeComposantsFils)
            {
                CResultAErreur resultTmp = composant.VerifieIntegrite(filtre);
                if (!resultTmp)
                {
                    result.Erreur.EmpileErreurs(resultTmp.Erreur);
                    result.EmpileErreur(I.T("Error in component '@1'|137", composant.Description));
                }
            }
            return(result);
        }
예제 #20
0
        /// /////////////////////////////////////////
        public CResultAErreur Serialize(C2iSerializer serializer)
        {
            int            nVersion = GetNumVersion();
            CResultAErreur result   = serializer.TraiteVersion(ref nVersion);

            if (!result)
            {
                return(result);
            }
            I2iSerializable objet = m_structure;

            result      = serializer.TraiteObject(ref objet);
            m_structure = (C2iStructureExport)objet;

            objet    = m_filtre;
            result   = serializer.TraiteObject(ref objet);
            m_filtre = (CFiltreDynamique)objet;

            return(result);
        }
예제 #21
0
        //----------------------------------------------------------------------------------
        public override CResultAErreur Serialize(C2iSerializer serialiser)
        {
            int            nVersion = GetNumVersion();
            CResultAErreur result   = serialiser.TraiteVersion(ref nVersion);

            if (!result)
            {
                return(result);
            }
            if (nVersion < 4)
            {
                return(SerializeAvantC2iTableExportATableFille(serialiser, nVersion));
            }

            result = base.Serialize(serialiser);
            if (!result)
            {
                return(result);
            }

            I2iSerializable obj = ChampOrigine;

            result = serialiser.TraiteObject(ref obj);
            if (!result)
            {
                return(result);
            }
            ChampOrigine = (CDefinitionProprieteDynamique)obj;

            result = serialiser.TraiteListe <C2iChampExport>(m_listeChamps);
            if (!result)
            {
                return(result);
            }

            obj                = m_filtreAAppliquer;
            result             = serialiser.TraiteObject(ref obj);
            m_filtreAAppliquer = (CFiltreDynamique)obj;

            return(result);
        }
예제 #22
0
        /// /////////////////////////////////////////////////////////////
        public CFiltreData GetFiltrePourListe()
        {
            CFiltreData filtre = new CFiltreData();

            if (IsDynamique)
            {
                CFiltreDynamique filtreDyn = FiltreDynamique;
                CResultAErreur   result    = filtreDyn.GetFiltreData();
                if (result.Data is CFiltreData)
                {
                    filtre = (CFiltreData)result.Data;
                }
            }
            else
            {
                string          strChampId = "";
                StringBuilder   bl         = new StringBuilder();
                CStructureTable structure  = CStructureTable.GetStructure(TypeElements);
                strChampId = structure.ChampsId[0].NomChamp;
                foreach (CRelationListeEntites_Entite rel in RelationsEntites)
                {
                    bl.Append(rel.IdElement);
                    bl.Append(',');
                }
                if (bl.Length > 0)
                {
                    bl.Remove(bl.Length - 1, 1);
                }
                if (bl.Length > 0)
                {
                    filtre = new CFiltreData(strChampId + " in (" + bl.ToString() + ")");
                }
                else
                {
                    filtre = new CFiltreDataImpossible();
                }
            }
            return(filtre);
        }
예제 #23
0
        /// //////////////////////////////////////////////////
        public override CResultAErreur GetComposantExpression(CFiltreDynamique filtre)
        {
            CResultAErreur result = CResultAErreur.False;

            return(result);
        }
예제 #24
0
 /// //////////////////////////////////////////////////
 public override void OnChangeVariable(CFiltreDynamique filtre, CVariableDynamique variable)
 {
     OnChangeVariable(filtre, m_expressionValeur, variable);
     OnChangeVariable(filtre, m_expressionConditionApplication, variable);
 }
예제 #25
0
        /// //////////////////////////////////////////////////
        public override CResultAErreur GetComposantFiltreData(CFiltreDynamique filtre, CFiltreData filtreData)
        {
            CResultAErreur result = CResultAErreur.True;
            //Vérifie que l'expression condition est OK
            CContexteEvaluationExpression contexteEvaluation = new CContexteEvaluationExpression(filtre);

            result = ConditionApplication.Eval(contexteEvaluation);
            if (!result)
            {
                result.EmpileErreur(I.T("Error while evaluation of @1|143", ConditionApplication.GetString()));
                return(result);
            }

            if (result.Data == null || !((result.Data is bool && (bool)result.Data) || result.Data.ToString() == "1"))
            {
                result.Data = null;
                return(result);
            }

            CComposantFiltreOperateur opPrincipal = null;
            string strNomChamp = m_champ.NomPropriete;

            if (m_champ is CDefinitionProprieteDynamiqueChampCustom)
            {
                CDbKey keyChamp = ((CDefinitionProprieteDynamiqueChampCustom)m_champ).DbKeyChamp;
                strNomChamp = m_champ.NomPropriete;
                string strAcces = "";
                //Trouve le nom du champ et le chemin d'accès
                int nPos = strNomChamp.LastIndexOf(".");
                if (nPos != -1)
                {
                    strAcces    = strNomChamp.Substring(0, nPos + 1);
                    strNomChamp = strNomChamp.Substring(nPos + 1);
                }
                strAcces += "RelationsChampsCustom.";

                CComposantFiltreOperateur operateurIdChamp = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEgal);
                // TESTDBKEYOK
                if (keyChamp.IsNumericalId())
                {
                    operateurIdChamp.Parametres.Add(new CComposantFiltreChamp(strAcces + CChampCustom.c_champId, CContexteDonnee.GetNomTableForType(filtre.TypeElements)));
                }
                else
                {
                    operateurIdChamp.Parametres.Add(new CComposantFiltreChamp(strAcces + CObjetDonnee.c_champIdUniversel, CContexteDonnee.GetNomTableForType(filtre.TypeElements)));
                }

                operateurIdChamp.Parametres.Add(new CComposantFiltreConstante(keyChamp.GetValeurInDb()));
                opPrincipal = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt);
                opPrincipal.Parametres.Add(operateurIdChamp);
                Type typeChamp = m_champ.TypeDonnee.TypeDotNetNatif;
                if (typeChamp == typeof(double))
                {
                    strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurDouble;
                }
                else if (typeChamp == typeof(int))
                {
                    strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurInt;
                }
                else if (typeChamp == typeof(DateTime) || typeChamp == typeof(CDateTimeEx))
                {
                    strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurDate;
                }
                else if (typeChamp == typeof(bool))
                {
                    strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurBool;
                }
                else
                {
                    strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurString;
                }
                strNomChamp = strAcces + strNomChamp;
            }
            CComposantFiltreChamp composantChamp = new CComposantFiltreChamp(strNomChamp, CContexteDonnee.GetNomTableForType(filtre.TypeElements));

            CComposantFiltre composantRecherche = new CComposantFiltreRechercheAvancee();

            CComposantFiltre composantValeur = null;

            result = ExpressionValeur.Eval(contexteEvaluation);
            if (!result)
            {
                result.EmpileErreur(I.T("Error while evaluation of @1|143", ExpressionValeur.GetString()));
                result.Data = null;
                return(result);
            }
            composantValeur = new CComposantFiltreConstante(result.Data.ToString());
            composantRecherche.Parametres.Add(composantChamp);
            composantRecherche.Parametres.Add(composantValeur);

            if (opPrincipal != null)
            {
                opPrincipal.Parametres.Add(composantRecherche);
                composantRecherche = opPrincipal;
            }


            result.Data = composantRecherche;
            return(result);
        }
 /// //////////////////////////////////////////////////
 public override void OnChangeVariable(CFiltreDynamique filtre, CVariableDynamique variable)
 {
 }
        /// //////////////////////////////////////////////////
        public override CResultAErreur GetComposantFiltreData(CFiltreDynamique filtre, CFiltreData filtreData)
        {
            CResultAErreur result = CResultAErreur.True;
            //Vérifie que l'expression condition est OK
            CContexteEvaluationExpression contexteEvaluation = new CContexteEvaluationExpression(filtre);

            result = ConditionApplication.Eval(contexteEvaluation);
            if (!result)
            {
                result.EmpileErreur(I.T("Error while evaluation of @1|143", ConditionApplication.GetString()));
                return(result);
            }

            if (result.Data == null || !((result.Data is bool && (bool)result.Data) || result.Data.ToString() == "1"))
            {
                result.Data = null;
                return(result);
            }


            string strNomChamp      = m_champ.NomPropriete;
            CDbKey dbKeyChampCustom = null;

            if (m_champ is CDefinitionProprieteDynamiqueChampCustom)
            {
                CComposantFiltreOperateur opPrincipal = null;
                dbKeyChampCustom = ((CDefinitionProprieteDynamiqueChampCustom)m_champ).DbKeyChamp;
                strNomChamp      = m_champ.NomPropriete;
                string strAcces = "";
                //Trouve le nom du champ et le chemin d'accès
                int nPos = strNomChamp.LastIndexOf(".");
                if (nPos != -1)
                {
                    strAcces    = strNomChamp.Substring(0, nPos + 1);
                    strNomChamp = strNomChamp.Substring(nPos + 1);
                }
                strAcces += "RelationsChampsCustom.";

                int nIdChamp = CChampCustom.GetIdFromDbKey(dbKeyChampCustom);

                CComposantFiltreOperateur operateurIdChamp = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEgal);
                CComposantFiltreChamp     compo1           = new CComposantFiltreChamp(strAcces + CChampCustom.c_champId, CContexteDonnee.GetNomTableForType(filtre.TypeElements));
                compo1.IdChampCustom = nIdChamp;
                operateurIdChamp.Parametres.Add(compo1);
                operateurIdChamp.Parametres.Add(new CComposantFiltreConstante(nIdChamp));
                opPrincipal = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt);
                opPrincipal.Parametres.Add(operateurIdChamp);
                //Stef, 28072008 : pour tester si un champ est null, on vérifie CRelationElementAChamp_ChampCustom.c_champValeurNull
                //et non pas les valeurs suivant le type

                /*if ( typeChamp == typeof(double))
                 *      strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurDouble;
                 * else if ( typeChamp == typeof(int))
                 *      strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurInt;
                 * else if ( typeChamp == typeof(DateTime) || typeChamp == typeof(CDateTimeEx) )
                 *      strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurDate;
                 * else if ( typeChamp == typeof(bool))
                 *      strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurBool;
                 * else
                 *      strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurString;
                 */
                strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurNull;

                strNomChamp = strAcces + strNomChamp;

                CComposantFiltreChamp composantChamp = new CComposantFiltreChamp(strNomChamp, CContexteDonnee.GetNomTableForType(filtre.TypeElements));
                composantChamp.IdChampCustom = nIdChamp;
                CComposantFiltre composantOperateur = new CComposantFiltreOperateur(
                    m_bTestNull ? CComposantFiltreOperateur.c_IdOperateurDifferent : CComposantFiltreOperateur.c_IdOperateurEgal);
                composantOperateur.Parametres.Add(composantChamp);
                composantOperateur.Parametres.Add(new CComposantFiltreConstante(0));

                opPrincipal.Parametres.Add(composantOperateur);
                composantOperateur = opPrincipal;
                result.Data        = composantOperateur;
                //Stef 28072008, fin modif
            }
            else
            {
                CComposantFiltreChamp composantChamp = new CComposantFiltreChamp(strNomChamp, CContexteDonnee.GetNomTableForType(filtre.TypeElements));
                composantChamp.IdChampCustom = CChampCustom.GetIdFromDbKey(dbKeyChampCustom);
                CComposantFiltre composantOperateur;

                if (!m_bTestNull)
                {
                    composantOperateur = new CComposantFiltreHas();
                }
                else
                {
                    composantOperateur = new CComposantFiltreHasNo();
                }

                composantOperateur.Parametres.Add(composantChamp);
                result.Data = composantOperateur;
            }
            return(result);
        }
예제 #28
0
 ////////////////////////////////////////////////////////////////////////
 public void InitFiltreDynamique()
 {
     m_filtreDynamique = GetFiltreDynamiqueSynchro(CContexteDonnee.GetTypeForTable(NomTable));
 }
예제 #29
0
        ////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Retourne un filtre dynamique pour la table associée en
        /// prenant en compte les filtres des parents
        /// </summary>
        /// <returns></returns>
        public CFiltreDynamique GetFiltreToElementPrincipal()
        {
            if (TouteLaTable)
            {
                return(null);
            }
            CFiltreDynamique filtreDynamiqueParent = null;

            if (FiltreParent != null)
            {
                filtreDynamiqueParent = FiltreParent.GetFiltreToElementPrincipal();
            }

            Type            typeElements = CContexteDonnee.GetTypeForTable(NomTable);
            CStructureTable structure    = CStructureTable.GetStructure(typeElements);

            CFiltreDynamique filtreFinal = (CFiltreDynamique)FiltreDynamique.Clone();

            CDefinitionProprieteDynamique defToParent = null;

            //Trouve la propriété qui amène sur le parent
            if (RelationToParent != null)
            {
                if (RelationToParent.TableFille == NomTable)
                {
                    if (filtreDynamiqueParent != null && filtreDynamiqueParent.ComposantPrincipal != null)
                    {
                        Type   tp = CContexteDonnee.GetTypeForTable(RelationToParent.TableParente);
                        string strNomConvivial = DynamicClassAttribute.GetNomConvivial(tp);
                        //Nous somme dans une relation fille
                        foreach (CInfoRelation relationParente in structure.RelationsParentes)
                        {
                            if (relationParente.RelationKey == RelationToParent.RelationKey)
                            {
                                defToParent = new CDefinitionProprieteDynamiqueDotNet(
                                    strNomConvivial,
                                    relationParente.Propriete,
                                    new CTypeResultatExpression(CContexteDonnee.GetTypeForTable(relationParente.TableParente), false),
                                    true,
                                    true,
                                    "");
                                break;
                            }
                        }
                        if (defToParent == null)
                        {
                            defToParent = new CDefinitionProprieteDynamique(
                                strNomConvivial,
                                RelationToParent.RelationKey,
                                new CTypeResultatExpression(tp, false),
                                true,
                                true,
                                "");
                        }
                    }
                }
                else
                {
                    //Nous sommes dans une relation parente
                    foreach (CInfoRelation relationFille in structure.RelationsFilles)
                    {
                        if (relationFille.RelationKey == RelationToParent.RelationKey)
                        {
                            defToParent = new CDefinitionProprieteDynamiqueDotNet(
                                relationFille.NomConvivial,
                                relationFille.Propriete,
                                new CTypeResultatExpression(CContexteDonnee.GetTypeForTable(relationFille.TableFille), true),
                                true,
                                true,
                                "");
                            break;
                        }
                    }
                    if (defToParent == null)
                    {
                        Type tp = CContexteDonnee.GetTypeForTable(RelationToParent.TableFille);
                        defToParent = new CDefinitionProprieteDynamique(
                            DynamicClassAttribute.GetNomConvivial(tp) + "(" + RelationToParent.NomConvivial + ")",
                            RelationToParent.RelationKey,
                            new CTypeResultatExpression(tp, false),
                            true, true);
                    }

                    if (filtreDynamiqueParent == null)
                    {
                        filtreDynamiqueParent = new CFiltreDynamiqueParentTablePleine(NomTable, RelationToParent);
                    }
                }
            }
            if (filtreDynamiqueParent != null && filtreDynamiqueParent.ComposantPrincipal != null)
            {
                filtreDynamiqueParent.ComposantPrincipal.InsereDefinitionToObjetFinal(defToParent);

                if (FiltreDynamique == null || FiltreDynamique.ComposantPrincipal == null)
                {
                    return(filtreDynamiqueParent);
                }

                CComposantFiltreDynamique composantEt = null;
                if (!(filtreDynamiqueParent.ComposantPrincipal is CComposantFiltreDynamiqueEt))
                {
                    composantEt = new CComposantFiltreDynamiqueEt();
                    composantEt.AddComposantFils(filtreDynamiqueParent.ComposantPrincipal);
                }
                else
                {
                    composantEt = (CComposantFiltreDynamiqueEt)filtreDynamiqueParent.ComposantPrincipal;
                }
                composantEt.AddComposantFils(filtreFinal.ComposantPrincipal);
                filtreFinal.ComposantPrincipal = composantEt;
            }

            if (filtreFinal.ComposantPrincipal == null)
            {
                return(null);
            }
            return(filtreFinal);
        }
예제 #30
0
        //----------------------------------------------------------------------------------
        #region SerializeAvantC2iTableExportATableFille
        private CResultAErreur SerializeAvantC2iTableExportATableFille(C2iSerializer serialiser, int nOldVersion)
        {
            CResultAErreur result = CResultAErreur.True;

            if (serialiser.Mode == ModeSerialisation.Ecriture)
            {
                //Pas la peine de traduire, ça n'arrive jamais
                result.EmpileErreur("Cannot write the old version of C2iTableExport");
                return(result);
            }
            string strTmp = NomTable;

            serialiser.TraiteString(ref strTmp);
            NomTable = strTmp;

            I2iSerializable obj = ChampOrigine;

            result = serialiser.TraiteObject(ref obj);
            if (!result)
            {
                return(result);
            }
            ChampOrigine = (CDefinitionProprieteDynamique)obj;

            serialiser.AttacheObjet(typeof(ITableExport), this);

            ArrayList lstTables = new ArrayList();

            result = serialiser.TraiteArrayListOf2iSerializable(lstTables);
            serialiser.DetacheObjet(typeof(ITableExport), this);
            if (!result)
            {
                return(result);
            }
            ClearTablesFilles();
            foreach (ITableExport table in lstTables)
            {
                AddTableFille(table);
            }

            ArrayList lstChamps = new ArrayList();

            result = serialiser.TraiteArrayListOf2iSerializable(lstChamps);
            if (!result)
            {
                return(result);
            }
            m_listeChamps.Clear();
            foreach (C2iChampExport champ in lstChamps)
            {
                AddChamp(champ);
            }
            if (nOldVersion >= 1)
            {
                obj                = m_filtreAAppliquer;
                result             = serialiser.TraiteObject(ref obj);
                m_filtreAAppliquer = (CFiltreDynamique)obj;
            }

            return(result);
        }