Exemple #1
0
        public override CComposantFiltre GetComposantFiltre(CComposantFiltreChamp champ)
        {
            CComposantFiltre gauche = null;
            CComposantFiltre droite = null;

            if (Parametres.Length > 0 && Parametres[0] != null)
            {
                gauche = Parametres[0].GetComposantFiltre(champ);
            }
            if (Parametres.Length > 1 && Parametres[1] != null)
            {
                droite = Parametres[1].GetComposantFiltre(champ);
            }
            if (gauche != null && droite != null)
            {
                CComposantFiltreOperateur op = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurOu);
                op.Parametres.Add(gauche);
                op.Parametres.Add(droite);
                return(op);
            }
            if (gauche == null && droite != null)
            {
                return(droite);
            }
            if (gauche != null && droite == null)
            {
                return(gauche);
            }
            return(null);
        }
Exemple #2
0
        ////////////////////////////////////////////////////////////////////////////
        public override CComposantFiltre GetComposantFiltre(CComposantFiltreChamp champ)
        {
            string strSeparateursMots = " ,;:!.?()-*+/\'";
            string strTexte           = MotUtilise;

            //Remplace les caractères accentuables par leurs équivalents
            strTexte = Regex.Replace(strTexte, "[éèêëe]", "[éèêëe]");
            strTexte = Regex.Replace(strTexte, "[aàäâ]", "[aàäâ]");
            strTexte = Regex.Replace(strTexte, "[iîï]", "[iîï]");
            strTexte = Regex.Replace(strTexte, "[oôö]", "[oôö]");
            strTexte = Regex.Replace(strTexte, "[uüûù]", "[uüûù]");
            strTexte = Regex.Replace(strTexte, "[cç]", "[cç]");

            CComposantFiltre ou = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurOu);

            CComposantFiltre like = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurLike);

            like.Parametres.Add(champ);
            like.Parametres.Add(new CComposantFiltreConstante(strTexte + "%"));
            ou.Parametres.Add(like);

            like = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurLike);
            like.Parametres.Add(champ);
            like.Parametres.Add(new CComposantFiltreConstante("%[" + strSeparateursMots + "]" + strTexte + "%"));
            ou.Parametres.Add(like);

            return(ou);
        }
 //--------------------------------------------------------
 public void InitComposant(CComposantFiltreChamp champTeste,
                           string strNomTableSousFiltre,
                           CComposantFiltreChamp champDeSousFiltre,
                           CFiltreDataAvance filtre)
 {
     m_champTeste         = champTeste;
     m_strTableSousFiltre = strNomTableSousFiltre;
     m_champSousFiltre    = champDeSousFiltre;
     m_filtre             = filtre;
     m_bIsInterprete      = true;
 }
        /// <summary>
        /// Le data du result contient un CArbreTable
        /// </summary>
        /// <returns></returns>
        public CResultAErreur CalculeArbre(CArbreTable arbre)
        {
            CResultAErreur result = CResultAErreur.True;
            //Identifie les relations à mettre en jeu
            ArrayList lstChamps = new ArrayList();

            if (m_strTableInterrogee == "")
            {
                result.EmpileErreur(I.T("Request table is not defined|106"));
                return(result);
            }
            if (arbre == null)
            {
                arbre = new CArbreTableParente(m_strTableInterrogee);
            }
            foreach (C2iChampDeRequete champ in ListeChamps)
            {
                try
                {
                    foreach (CSourceDeChampDeRequete source in champ.Sources)
                    {
                        CComposantFiltreChamp composant    = new CComposantFiltreChamp(source.Source, m_strTableInterrogee);
                        CArbreTable           arbreEnCours = arbre;
                        foreach (CInfoRelationComposantFiltre relation in composant.Relations)
                        {
                            //Stef 08/08/2013 : toutes les relations sont integrées
                            //en leftouter : en effet, on doit prendre toutes les valeurs
                            //de la table source, même si elles n'ont pas de valeur liées dans la
                            //table fille
                            arbreEnCours = arbreEnCours.IntegreRelation(relation, true, composant.IdChampCustom);
                            if (arbreEnCours == null)
                            {
                                result.EmpileErreur(I.T("Itegration error of the relation @1|107", relation.RelationKey));
                                return(result);
                            }
                        }
                        source.ChampDeTable = composant.NomChamp;
                        source.Alias        = arbreEnCours.Alias;
                    }
                }
                catch (Exception e)
                {
                    result.EmpileErreur(new CErreurException(e));
                    result.EmpileErreur(I.T("Error in field @1|108", champ.NomChamp));
                    return(result);
                }
            }
            result.Data = arbre;
            return(result);
        }
Exemple #5
0
        public override CComposantFiltre GetComposantFiltre(CComposantFiltreChamp champ)
        {
            CComposantFiltre droite = null;

            if (Parametres.Length > 0 && Parametres[0] != null)
            {
                droite = Parametres[0].GetComposantFiltre(champ);
            }
            if (droite != null)
            {
                CComposantFiltreOperateur op = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurNot);
                op.Parametres.Add(droite);
                return(op);
            }
            return(null);
        }
        /// ////////////////////////////////////////////////////////////////
        private CResultAErreur IntegreRelationsChamps(CArbreTable arbre, CComposantFiltreChamp champ, bool bIsLeftOuter)
        {
            CResultAErreur result       = CResultAErreur.True;
            CArbreTable    arbreEnCours = arbre;

            foreach (CInfoRelationComposantFiltre relation in champ.Relations)
            {
                arbreEnCours = arbreEnCours.IntegreRelation(relation, bIsLeftOuter, champ.IdChampCustom);
                if (arbreEnCours == null)
                {
                    result.EmpileErreur(I.T("Error while integrating relation @1|107", relation.RelationKey));
                    return(result);
                }
            }
            return(result);
        }
        //// ////////////////////////////////////////////////////////////////
        private CResultAErreur GetRelations(CComposantFiltre composant, CArbreTable arbre, bool bFillesLeftOuter)
        {
            CResultAErreur result = CResultAErreur.True;
            bool           bIsComposantLocalLeftOuter = false;

            //Le ou entraine des left outers
            if (composant is CComposantFiltreOperateur)
            {
                CComposantFiltreOperateur op = (CComposantFiltreOperateur)composant;
                if (op.Operateur.Id == CComposantFiltreOperateur.c_IdOperateurOu)
                {
                    bIsComposantLocalLeftOuter = true;
                }
            }
            if (composant is CComposantFiltreHasNo)
            {
                bIsComposantLocalLeftOuter = true;
            }
            if (composant is CComposantFiltreChamp)
            {
                CComposantFiltreChamp champ = (CComposantFiltreChamp)composant;
                result = IntegreRelationsChamps(arbre, champ, bIsComposantLocalLeftOuter || bFillesLeftOuter);
                if (!result)
                {
                    return(result);
                }
            }
            foreach (CComposantFiltre composantFils in composant.Parametres)
            {
                result = GetRelations(composantFils, arbre, bIsComposantLocalLeftOuter || bFillesLeftOuter);
                if (!result)
                {
                    return(result);
                }
            }
            return(result);
        }
        /// //////////////////////////////////////////////////
        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);
        }
Exemple #9
0
        ////////////////////////////////////////////////////////
        public string GetStringExpression(IExpression expression, CFiltreData filtre)
        {
            string strRetour = "";

            if (expression is CComposantFiltre)
            {
                expression = ((CComposantFiltre)expression).GetComposantFiltreFinal(filtre);
            }

            if (expression is CComposantFiltreChamp)
            {
                CComposantFiltreChamp champ = (CComposantFiltreChamp)expression;
                if (champ.Alias != "")
                {
                    strRetour += champ.Alias + ".";
                }
                strRetour += champ.NomChamp;
            }


            else if (expression is CComposantFiltreVariable)
            {
                strRetour = ((CComposantFiltreVariable)expression).GetString();
            }



            else if (expression is CComposantFiltreConstante)
            {
                CComposantFiltreConstante constante = (CComposantFiltreConstante)expression;
                strRetour = CConvertisseurObjetToSqlServeur.ConvertToSql(constante.Valeur);
            }



            else if (expression is CComposantFiltreHasNo)
            {
                strRetour += GetStringExpression((IExpression)expression.Parametres[0], filtre);
                strRetour += " is null";
            }

            else if (expression is CComposantFiltreHas)
            {
                strRetour += GetStringExpression((IExpression)expression.Parametres[0], filtre);
                strRetour += " is not null";
            }



            else if (expression is CComposantFiltreListe)
            {
                CComposantFiltreListe liste = (CComposantFiltreListe)expression;
                strRetour = "";
                foreach (IExpression expInListe in liste.Liste)
                {
                    strRetour += GetStringExpression(expInListe, filtre) + ",";
                }
                if (strRetour.Length > 0)
                {
                    strRetour = strRetour.Substring(0, strRetour.Length - 1);
                }
                strRetour = "(" + strRetour + ")";
            }

            else if (expression is CComposantFiltreSousFiltre && m_connexion != null)
            {
                CComposantFiltreSousFiltre compo  = (CComposantFiltreSousFiltre)expression;
                CResultAErreur             result = compo.InterpreteParametres();
                if (result)
                {
                    string strWhere      = "";
                    string strJoin       = "";
                    string strPrefixFrom = "";
                    bool   bDistinct     = false;
                    compo.Filtre.Parametres.Clear();
                    compo.Filtre.AddChampAAjouterAArbreTable(compo.ChampSousFiltre);
                    foreach (object parametre in filtre.Parametres)
                    {
                        compo.Filtre.Parametres.Add(parametre);
                    }
                    CComposantFiltreOperateur compoEt = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt);
                    compoEt.Parametres.Add(compo.Filtre.ComposantPrincipal);
                    CComposantFiltreHas compoNotNull = new CComposantFiltreHas();
                    compoNotNull.Parametres.Add(compo.ChampSousFiltre);
                    compoEt.Parametres.Add(compoNotNull);
                    compo.Filtre.ComposantPrincipal = compoEt;
                    IEnumerable <C2iDbDatabaseConnexion.CParametreRequeteDatabase> parametres = null;
                    result = m_connexion.PrepareRequeteFromFiltre(
                        compo.Filtre,
                        ref strWhere,
                        ref strJoin,
                        ref bDistinct,
                        ref strPrefixFrom,
                        ref parametres);
                    if (result)
                    {
                        strRetour += " ";
                        if (compo.ChampTeste.Alias != "")
                        {
                            strRetour += compo.ChampTeste.Alias + ".";
                        }
                        strRetour += compo.ChampTeste.NomChamp;

                        if (compo is CComposantFiltreInSousFiltre)
                        {
                            strRetour += " in (";
                        }
                        else
                        {
                            strRetour += " not in (";
                        }
                        string strSelect = "select ";
                        if (compo.ChampSousFiltre.Alias != "")
                        {
                            strSelect += compo.ChampSousFiltre.Alias + ".";
                        }
                        strSelect += compo.ChampSousFiltre.NomChamp;
                        strSelect += " from " + CContexteDonnee.GetNomTableInDbForNomTable(compo.TableSousFiltre);
                        strRetour += m_connexion.GetSql(strSelect, strPrefixFrom, strJoin, strWhere);
                        strRetour += ")";
                    }
                }
            }



            else if (expression is CComposantFiltreOperateur)
            {
                COperateurAnalysable operateur = ((CComposantFiltreOperateur)expression).Operateur;
                string strTexteOperateur       = operateur.Texte;
                if (operateur.Texte.Length > 3 && operateur.Texte.Substring(0, 3).ToUpper() == "NOT")
                {
                    strTexteOperateur = operateur.Texte.Substring(0, 3) + " " + operateur.Texte.Substring(3);
                }
                if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains)
                {
                    strTexteOperateur = "like";
                }
                if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout)
                {
                    strTexteOperateur = "not like";
                }
                if (operateur.Niveau > 0 && operateur.Niveau != 4)
                {
                    string str1, str2, str3;
                    str1 = GetStringExpression((IExpression)expression.Parametres[0], filtre);
                    str2 = strTexteOperateur;
                    str3 = GetStringExpression((IExpression)expression.Parametres[1], filtre);
                    string[] valeurs = new string[] { str3 };
                    if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains ||
                        operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout)
                    {
                        str3 = "'%'+" + str3 + "+'%'";
                    }
                    if (operateur.Niveau >= 4)
                    {
                        str1 = "(" + str1 + ")";
                        str3 = "(" + str3 + ")";
                    }
                    bool bChercheVide = false;
                    if (strTexteOperateur.ToUpper() == "LIKE")
                    {
                        bChercheVide = str3 == "%%";
                        if (!bChercheVide && str3.Contains("@"))
                        {
                            try
                            {
                                int nParam = Int32.Parse(str3.Substring("@PARAM".Length));
                                if (filtre.Parametres[nParam - 1].ToString() == "%%")
                                {
                                    bChercheVide = true;
                                }
                            }
                            catch
                            {
                            }
                        }
                    }

                    if (bChercheVide)
                    {
                        strRetour += str3 + "=" + str3;
                    }
                    else
                    {
                        strRetour = str1 + " " + str2 + " " + str3;

                        if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurLike ||
                            operateur.Id == CComposantFiltreOperateur.c_IdOperateurNotLike)
                        {
                            strRetour += " ESCAPE '\\'";
                        }
                    }
                }
                else
                {
                    strRetour = strTexteOperateur + "(";
                    foreach (IExpression exp in expression.Parametres)
                    {
                        strRetour += GetStringExpression(exp, filtre) + ",";
                    }
                    if (expression.Parametres.Count > 0)
                    {
                        strRetour = strRetour.Substring(0, strRetour.Length - 1);
                    }
                    strRetour += ")";
                }
            }
            return(strRetour);
        }
Exemple #10
0
        ////////////////////////////////////////////////////////
        public string GetStringExpression(IExpression expression, CFiltreData filtre)
        {
            string strRetour = "";

            if (expression is CComposantFiltre)
            {
                expression = ((CComposantFiltre)expression).GetComposantFiltreFinal(filtre);
            }

            if (expression is CComposantFiltreChamp)
            {
                CComposantFiltreChamp champ = (CComposantFiltreChamp)expression;
                if (champ.Alias != "")
                {
                    strRetour += champ.Alias + ".";
                }
                strRetour += champ.NomChamp;

                /*if ( champ.Relations.Length > 0 )
                 * {
                 *      if (champ.Relations[champ.Relations.Length-1].IsRelationFille)
                 *              strRetour = champ.Relations[champ.Relations.Length-1].TableFille+".";
                 *      else
                 *              strRetour = champ.Relations[champ.Relations.Length-1].TableParente+".";
                 * }
                 * strRetour += champ.NomChamp;*/
            }


            else if (expression is CComposantFiltreVariable)
            {
                strRetour = ((CComposantFiltreVariable)expression).GetString();
            }



            else if (expression is CComposantFiltreConstante)
            {
                CComposantFiltreConstante constante = (CComposantFiltreConstante)expression;
                strRetour = CConvertisseurObjetToSqlServeur.ConvertToSql(constante.Valeur);
            }



            else if (expression is CComposantFiltreHasNo)
            {
                strRetour += GetStringExpression((IExpression)expression.Parametres[0], filtre);
                strRetour += " is null";
            }

            else if (expression is CComposantFiltreHas)
            {
                strRetour += GetStringExpression((IExpression)expression.Parametres[0], filtre);
                strRetour += " is not null";
            }



            else if (expression is CComposantFiltreListe)
            {
                CComposantFiltreListe liste = (CComposantFiltreListe)expression;
                strRetour = "";
                foreach (IExpression expInListe in liste.Liste)
                {
                    strRetour += GetStringExpression(expInListe, filtre) + ",";
                }
                if (strRetour.Length > 0)
                {
                    strRetour = strRetour.Substring(0, strRetour.Length - 1);
                }
                strRetour = "(" + strRetour + ")";
            }



            else if (expression is CComposantFiltreOperateur)
            {
                COperateurAnalysable operateur = ((CComposantFiltreOperateur)expression).Operateur;
                string strTexteOperateur       = operateur.Texte;
                if (operateur.Texte.Length > 3 && operateur.Texte.Substring(0, 3).ToUpper() == "NOT")
                {
                    strTexteOperateur = operateur.Texte.Substring(0, 3) + " " + operateur.Texte.Substring(3);
                }
                if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains)
                {
                    strTexteOperateur = "like";
                }
                if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout)
                {
                    strTexteOperateur = "not like";
                }
                if (operateur.Niveau > 0 && operateur.Niveau != 4)
                {
                    string str1, str2, str3;
                    str1 = GetStringExpression((IExpression)expression.Parametres[0], filtre);
                    str2 = strTexteOperateur;
                    str3 = GetStringExpression((IExpression)expression.Parametres[1], filtre);
                    string[] valeurs = new string[] { str3 };
                    if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains ||
                        operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout)
                    {
                        str3 = "'%'+" + str3 + "+'%'";
                    }
                    if (operateur.Niveau >= 4)
                    {
                        str1 = "(" + str1 + ")";
                        str3 = "(" + str3 + ")";
                    }
                    bool bChercheVide = false;
                    if (strTexteOperateur.ToUpper() == "LIKE")
                    {
                        bChercheVide = str3 == "%%";
                        if (!bChercheVide && str3.Contains("@"))
                        {
                            try
                            {
                                int nParam = Int32.Parse(str3.Substring("@PARAM".Length));
                                if (filtre.Parametres[nParam - 1].ToString() == "%%")
                                {
                                    bChercheVide = true;
                                }
                            }
                            catch
                            {
                            }
                        }
                    }

                    if (bChercheVide)
                    {
                        strRetour += str3 + "=" + str3;
                    }
                    else
                    {
                        strRetour = str1 + " " + str2 + " " + str3;

                        /*if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurLike ||
                         *   operateur.Id == CComposantFiltreOperateur.c_IdOperateurNotLike)
                         *   strRetour += " ESCAPE '\\'";*/
                    }
                }
                else
                {
                    strRetour = strTexteOperateur + "(";
                    foreach (IExpression exp in expression.Parametres)
                    {
                        strRetour += GetStringExpression(exp, filtre) + ",";
                    }
                    if (expression.Parametres.Count > 0)
                    {
                        strRetour = strRetour.Substring(0, strRetour.Length - 1);
                    }
                    strRetour += ")";
                }
            }
            return(strRetour);
        }
 public abstract CComposantFiltre GetComposantFiltre(CComposantFiltreChamp champ);
        //--------------------------------------------------------
        public CResultAErreur InterpreteParametres()
        {
            CResultAErreur result = CResultAErreur.True;

            if (m_bIsInterprete)
            {
                return(result);
            }
            //Paramètre 1 : champ
            //Paramètre 2 : sous type
            //Parametre 3 : champ de sous type retourné
            //Paramètre 4 : Filtre
            if (Parametres.Count < 4)
            {
                result.EmpileErreur(GetOperateurSousFiltre() + " " +
                                    I.T("Require 4 parameters : field, type, source field, sub filter|20008"));
                return(result);
            }

            m_champTeste = Parametres[0] as CComposantFiltreChamp;
            if (m_champTeste == null)
            {
                result.EmpileErreur(GetOperateurSousFiltre() + " : " + I.T("First parameter is invalid (field requiered|20070"));
            }

            Type tp = null;

            m_strTableSousFiltre = null;
            CComposantFiltreConstante compoCst = Parametres[1] as CComposantFiltreConstante;

            if (compoCst != null && compoCst.Valeur != null)
            {
                tp = CActivatorSurChaine.GetType(compoCst.Valeur.ToString(), true);
                if (tp != null)
                {
                    m_strTableSousFiltre = CContexteDonnee.GetNomTableForType(tp);
                }
                if (m_strTableSousFiltre == null)
                {
                    result.EmpileErreur(I.T("Invalid type reference (@1)|20009", compoCst.Valeur.ToString()));
                }
            }
            else
            {
                result.EmpileErreur(GetOperateurSousFiltre() + " : " + I.T("Second parameter is invalid (type requiered)|20010"));
            }

            if (result)
            {
                CComposantFiltreConstante compoFiltre = Parametres[3] as CComposantFiltreConstante;
                if (compoFiltre == null || compoFiltre.Valeur == null)
                {
                    result.EmpileErreur(GetOperateurSousFiltre() + " : " + I.T("4th parameter is invalid (filtre requiered)|20012"));
                    return(result);
                }
                m_filtre = new CFiltreDataAvance(m_strTableSousFiltre, compoFiltre.Valeur.ToString());
                if (m_filtre.ComposantPrincipal == null)
                {
                    result.EmpileErreur(I.T("Sub filter is invalide|20014"));
                    return(result);
                }
            }
            if (result)
            {
                CComposantFiltreConstante compoSousChamp = Parametres[2] as CComposantFiltreConstante;
                if (compoSousChamp == null || compoSousChamp.Valeur == null)
                {
                    result.EmpileErreur(GetOperateur() + " : " + I.T("3rd parameter is invalide (field requiered)|20013"));
                    return(result);
                }
                m_champSousFiltre = new CComposantFiltreChamp(compoSousChamp.Valeur.ToString(), m_strTableSousFiltre);
            }
            m_bIsInterprete = result.Result;

            return(result);
        }
        /// //////////////////////////////////////////////////
        public override CResultAErreur GetComposantFiltreData(CFiltreDynamique filtre, CFiltreData filtreData)
        {
            CResultAErreur result = CResultAErreur.True;

            if (m_listeIdentifiantsSelectionnes.Count == 0)
            {
                return(result);
            }
            //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;

            if (m_champ is CDefinitionProprieteDynamiqueThis)
            {
                strNomChamp = "";
            }
            else
            {
                strNomChamp = strNomChamp + ".";
            }

            bool bIdNumericId = m_listeIdentifiantsSelectionnes[0].IsNumericalId();

            //TESTDBKEYTODO

            if (bIdNumericId)
            {
                //Trouve le nom du champ identifiant
                Type     tp      = m_champ.TypeDonnee.TypeDotNetNatif;
                object[] attribs = tp.GetCustomAttributes(typeof(TableAttribute), true);
                if (attribs.Length > 0)
                {
                    TableAttribute tf = (TableAttribute)attribs[0];
                    if (tf.ChampsId.Length != 1)
                    {
                        result.EmpileErreur(I.T("Cannot apply selection on field @1|150", strNomChamp));
                        return(result);
                    }
                    strNomChamp += tf.ChampsId[0];
                }
                else
                {
                    result.EmpileErreur(I.T("Cannot apply selection on field @1|150", strNomChamp));
                    return(result);
                }
            }
            else
            {
                strNomChamp += CObjetDonnee.c_champIdUniversel;
            }

            CComposantFiltreChamp composantChamp = new CComposantFiltreChamp(strNomChamp, CContexteDonnee.GetNomTableForType(filtre.TypeElements));
            CComposantFiltre      composantOperateur;

            if (m_bExclure)
            {
                composantOperateur = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurNotIn);
            }
            else
            {
                composantOperateur = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurIn);
            }
            composantOperateur.Parametres.Add(composantChamp);

            ArrayList lst = new ArrayList();

            foreach (CDbKey key in m_listeIdentifiantsSelectionnes)
            {
                lst.Add(new CComposantFiltreConstante(key.GetValeurInDb()));
            }
            composantOperateur.Parametres.Add(new CComposantFiltreListe((IExpression[])lst.ToArray(typeof(IExpression))));

            if (m_bExclure)
            {
                //Si not in->Peut aussi être null !!!
                CComposantFiltre      compoOu    = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurOu);
                CComposantFiltreHasNo compoHasNo = new CComposantFiltreHasNo();
                compoHasNo.Parametres.Add(new CComposantFiltreChamp(strNomChamp, CContexteDonnee.GetNomTableForType(filtre.TypeElements)));
                compoOu.Parametres.Add(compoHasNo);
                compoOu.Parametres.Add(composantOperateur);
                composantOperateur = compoOu;
            }

            result.Data = composantOperateur;
            return(result);
        }
        ////////////////////////////////////////////////////////
        protected string GetStringExpression(IExpression expression, Dictionary <string, object> valeursParametres)
        {
            string strRetour = "";

            if (expression is CComposantFiltreChamp)
            {
                CComposantFiltreChamp champ = (CComposantFiltreChamp)expression;
                if (champ.Alias != "")
                {
                    strRetour += champ.Alias + ".";
                }
                strRetour += champ.NomChamp;

                /*if ( champ.Relations.Length > 0 )
                 * {
                 *      if (champ.Relations[champ.Relations.Length-1].IsRelationFille)
                 *              strRetour = champ.Relations[champ.Relations.Length-1].TableFille+".";
                 *      else
                 *              strRetour = champ.Relations[champ.Relations.Length-1].TableParente+".";
                 * }
                 * strRetour += champ.NomChamp;*/
            }


            else if (expression is CComposantFiltreVariable)
            {
                strRetour = ((CComposantFiltreVariable)expression).GetString();
            }



            else if (expression is CComposantFiltreConstante)
            {
                CComposantFiltreConstante constante = (CComposantFiltreConstante)expression;
                strRetour = CConvertisseurObjetToSqlServeur.ConvertToSql(constante.Valeur);
            }



            else if (expression is CComposantFiltreHasNo)
            {
                strRetour += GetStringExpression((IExpression)expression.Parametres[0], valeursParametres);
                strRetour += " is null";
            }

            else if (expression is CComposantFiltreHas)
            {
                strRetour += GetStringExpression((IExpression)expression.Parametres[0], valeursParametres);
                strRetour += " is not null";
            }



            else if (expression is CComposantFiltreListe)
            {
                CComposantFiltreListe liste = (CComposantFiltreListe)expression;
                strRetour = "";
                foreach (IExpression expInListe in liste.Liste)
                {
                    strRetour += GetStringExpression(expInListe, valeursParametres) + ",";
                }
                if (strRetour.Length > 0)
                {
                    strRetour = strRetour.Substring(0, strRetour.Length - 1);
                }
                strRetour = "(" + strRetour + ")";
            }



            else if (expression is CComposantFiltreOperateur)
            {
                COperateurAnalysable operateur = ((CComposantFiltreOperateur)expression).Operateur;
                string strTexteOperateur       = operateur.Texte;
                //Remplacement du not par not espace operateur
                bool bToUpper = false;
                if (operateur.Texte.Length > 3 && operateur.Texte.Substring(0, 3).ToUpper() == "NOT")
                {
                    strTexteOperateur = operateur.Texte.Substring(0, 3) + " " + operateur.Texte.Substring(3);
                }
                if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains)
                {
                    strTexteOperateur = "like";
                }
                if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout)
                {
                    strTexteOperateur = "not like";
                }
                if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurLike ||
                    operateur.Id == CComposantFiltreOperateur.c_IdOperateurNotLike ||
                    operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains ||
                    operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout)
                {
                    bToUpper = true;
                }


                if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurEtBinaire)
                {
                    string str1, str2;
                    str1      = GetStringExpression((IExpression)expression.Parametres[0], valeursParametres);
                    str2      = GetStringExpression((IExpression)expression.Parametres[1], valeursParametres);
                    strRetour = "BitAnd(" + str1 + "," + str2 + ")";
                }
                else if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurOuBinaire)
                {
                    string str1, str2;
                    str1      = GetStringExpression((IExpression)expression.Parametres[0], valeursParametres);
                    str2      = GetStringExpression((IExpression)expression.Parametres[1], valeursParametres);
                    strRetour = "BitOr(" + str1 + "," + str2 + ")";
                }

                else if (operateur.Niveau > 0 && operateur.Niveau != 4)
                {
                    string str1, str2, str3;
                    str1 = GetStringExpression((IExpression)expression.Parametres[0], valeursParametres);
                    if (bToUpper)
                    {
                        str1 = "Upper(" + str1 + ")";
                    }
                    str2 = strTexteOperateur;
                    str3 = GetStringExpression((IExpression)expression.Parametres[1], valeursParametres);

                    object val = null;

                    if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurEgal &&
                        valeursParametres != null &&
                        valeursParametres.TryGetValue(str3, out val) &&
                        val == c_null)
                    {
                        //Obligé d'ajouter une référence au nom de la variable, sinon, MySql fait la gueule
                        //d'où or str3 is null qui ne sert à rien
                        strRetour = "(" + str1 + " is null or " + str3 + " is null)";
                    }
                    else if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurDifferent &&
                             valeursParametres != null &&
                             valeursParametres.TryGetValue(str3, out val) &&
                             val == c_null)
                    {
                        //Obligé d'ajouter une référence au nom de la variable, sinon, MySql fait la gueule
                        //d'où or str3 is null qui ne sert à rien
                        strRetour = "(" + str1 + " is not null or " + str3 + " is null)";
                    }
                    else
                    {
                        if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains ||
                            operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout)
                        {
                            str3 = "Concat('%',concat(" + str3 + ",'%'))";
                        }
                        if (bToUpper)
                        {
                            str3 = "Upper(" + str3 + ")";
                        }

                        if (operateur.Niveau >= 4)
                        {
                            str1 = "(" + str1 + ")";
                            str3 = "(" + str3 + ")";
                        }
                        strRetour = str1 + " " + str2 + " " + str3;
                    }
                }
                else
                {
                    strRetour = strTexteOperateur + "(";
                    foreach (IExpression exp in expression.Parametres)
                    {
                        strRetour += GetStringExpression(exp, valeursParametres) + ",";
                    }
                    if (expression.Parametres.Count > 0)
                    {
                        strRetour = strRetour.Substring(0, strRetour.Length - 1);
                    }
                    strRetour += ")";
                }
            }
            return(strRetour);
        }
Exemple #15
0
        ////////////////////////////////////////////////////////
        protected string GetStringExpression(
            IExpression expression,
            CFiltreData filtre,
            Dictionary <string, object> valeursParametres)
        {
            string strRetour = "";

            if (expression is CComposantFiltreChamp)
            {
                CComposantFiltreChamp champ = (CComposantFiltreChamp)expression;
                if (champ.Alias != "")
                {
                    strRetour += champ.Alias + ".";
                }
                strRetour += champ.NomChamp;

                /*if ( champ.Relations.Length > 0 )
                 * {
                 *      if (champ.Relations[champ.Relations.Length-1].IsRelationFille)
                 *              strRetour = champ.Relations[champ.Relations.Length-1].TableFille+".";
                 *      else
                 *              strRetour = champ.Relations[champ.Relations.Length-1].TableParente+".";
                 * }
                 * strRetour += champ.NomChamp;*/
            }


            else if (expression is CComposantFiltreVariable)
            {
                strRetour = ((CComposantFiltreVariable)expression).GetString();
            }



            else if (expression is CComposantFiltreConstante)
            {
                CComposantFiltreConstante constante = (CComposantFiltreConstante)expression;
                strRetour = CConvertisseurObjetToSqlServeur.ConvertToSql(constante.Valeur);
            }



            else if (expression is CComposantFiltreHasNo)
            {
                strRetour += GetStringExpression((IExpression)expression.Parametres[0], filtre, valeursParametres);
                strRetour += " is null";
            }

            else if (expression is CComposantFiltreHas)
            {
                strRetour += GetStringExpression((IExpression)expression.Parametres[0], filtre, valeursParametres);
                strRetour += " is not null";
            }



            else if (expression is CComposantFiltreListe)
            {
                CComposantFiltreListe liste = (CComposantFiltreListe)expression;
                strRetour = "";
                foreach (IExpression expInListe in liste.Liste)
                {
                    strRetour += GetStringExpression(expInListe, filtre, valeursParametres) + ",";
                }
                if (strRetour.Length > 0)
                {
                    strRetour = strRetour.Substring(0, strRetour.Length - 1);
                }
                strRetour = "(" + strRetour + ")";
            }

            else if (expression is CComposantFiltreSousFiltre && m_connexion != null)
            {
                CComposantFiltreSousFiltre compo  = (CComposantFiltreSousFiltre)expression;
                CResultAErreur             result = compo.InterpreteParametres();
                if (result)
                {
                    string strWhere      = "";
                    string strJoin       = "";
                    string strPrefixFrom = "";
                    bool   bDistinct     = false;
                    compo.Filtre.Parametres.Clear();
                    compo.Filtre.AddChampAAjouterAArbreTable(compo.ChampSousFiltre);
                    foreach (object parametre in filtre.Parametres)
                    {
                        compo.Filtre.Parametres.Add(parametre);
                    }
                    CComposantFiltreOperateur compoEt = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt);
                    compoEt.Parametres.Add(compo.Filtre.ComposantPrincipal);
                    CComposantFiltreHas compoNotNull = new CComposantFiltreHas();
                    compoNotNull.Parametres.Add(compo.ChampSousFiltre);
                    compoEt.Parametres.Add(compoNotNull);
                    compo.Filtre.ComposantPrincipal = compoEt;
                    IEnumerable <C2iDbDatabaseConnexion.CParametreRequeteDatabase> parametres = null;
                    result = m_connexion.PrepareRequeteFromFiltre(
                        compo.Filtre,
                        ref strWhere,
                        ref strJoin,
                        ref bDistinct,
                        ref strPrefixFrom,
                        ref parametres);
                    if (result)
                    {
                        strRetour += " ";
                        if (compo.ChampTeste.Alias != "")
                        {
                            strRetour += compo.ChampTeste.Alias + ".";
                        }
                        strRetour += compo.ChampTeste.NomChamp;

                        if (compo is CComposantFiltreInSousFiltre)
                        {
                            strRetour += " in (";
                        }
                        else
                        {
                            strRetour += " not in (";
                        }
                        string strSelect = "select ";
                        if (compo.ChampSousFiltre.Alias != "")
                        {
                            strSelect += compo.ChampSousFiltre.Alias + ".";
                        }
                        strSelect += compo.ChampSousFiltre.NomChamp;
                        strSelect += " from " + CContexteDonnee.GetNomTableInDbForNomTable(compo.TableSousFiltre);
                        strRetour += m_connexion.GetSql(strSelect, strPrefixFrom, strJoin, strWhere);
                        strRetour += ")";
                    }
                }
            }



            else if (expression is CComposantFiltreOperateur)
            {
                COperateurAnalysable operateur = ((CComposantFiltreOperateur)expression).Operateur;
                string strTexteOperateur       = operateur.Texte;
                //Remplacement du not par not espace operateur
                bool bToUpper = false;
                if (operateur.Texte.Length > 3 && operateur.Texte.Substring(0, 3).ToUpper() == "NOT")
                {
                    strTexteOperateur = operateur.Texte.Substring(0, 3) + " " + operateur.Texte.Substring(3);
                }
                if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains)
                {
                    strTexteOperateur = "like";
                }
                if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout)
                {
                    strTexteOperateur = "not like";
                }
                if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurLike ||
                    operateur.Id == CComposantFiltreOperateur.c_IdOperateurNotLike ||
                    operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains ||
                    operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout)
                {
                    bToUpper = true;
                }


                if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurEtBinaire)
                {
                    string str1, str2;
                    str1      = GetStringExpression((IExpression)expression.Parametres[0], filtre, valeursParametres);
                    str2      = GetStringExpression((IExpression)expression.Parametres[1], filtre, valeursParametres);
                    strRetour = "BitAnd(" + str1 + "," + str2 + ")";
                }
                else if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurOuBinaire)
                {
                    string str1, str2;
                    str1      = GetStringExpression((IExpression)expression.Parametres[0], filtre, valeursParametres);
                    str2      = GetStringExpression((IExpression)expression.Parametres[1], filtre, valeursParametres);
                    strRetour = "BitOr(" + str1 + "," + str2 + ")";
                }

                else if (operateur.Niveau > 0 && operateur.Niveau != 4)
                {
                    string str1, str2, str3;
                    str1 = GetStringExpression((IExpression)expression.Parametres[0], filtre, valeursParametres);
                    if (bToUpper)
                    {
                        str1 = "Upper(" + str1 + ")";
                    }
                    str2 = strTexteOperateur;
                    str3 = GetStringExpression((IExpression)expression.Parametres[1], filtre, valeursParametres);

                    object val = null;

                    if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurEgal &&
                        valeursParametres != null &&
                        valeursParametres.TryGetValue(str3, out val) &&
                        val == c_null)
                    {
                        //Obligé d'ajouter une référence au nom de la variable, sinon, oracle fait la gueule
                        //d'où or str3 is null qui ne sert à rien
                        strRetour = "(" + str1 + " is null or " + str3 + " is null)";
                    }
                    else if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurDifferent &&
                             valeursParametres != null &&
                             valeursParametres.TryGetValue(str3, out val) &&
                             val == c_null)
                    {
                        //Obligé d'ajouter une référence au nom de la variable, sinon, oracle fait la gueule
                        //d'où or str3 is null qui ne sert à rien
                        strRetour = "(" + str1 + " is not null or " + str3 + " is null)";
                    }
                    else
                    {
                        if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains ||
                            operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout)
                        {
                            str3 = "Concat('%',concat(" + str3 + ",'%'))";
                        }
                        if (bToUpper)
                        {
                            str3 = "Upper(" + str3 + ")";
                        }

                        if (operateur.Niveau >= 4)
                        {
                            str1 = "(" + str1 + ")";
                            str3 = "(" + str3 + ")";
                        }
                        strRetour = str1 + " " + str2 + " " + str3;
                    }
                }
                else
                {
                    strRetour = strTexteOperateur + "(";
                    foreach (IExpression exp in expression.Parametres)
                    {
                        strRetour += GetStringExpression(exp, filtre, valeursParametres) + ",";
                    }
                    if (expression.Parametres.Count > 0)
                    {
                        strRetour = strRetour.Substring(0, strRetour.Length - 1);
                    }
                    strRetour += ")";
                }
            }
            return(strRetour);
        }
Exemple #16
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_champTeste.NomPropriete;

            if (m_champTeste is CDefinitionProprieteDynamiqueChampCustom)
            {
                CDbKey dbKeyChamp = ((CDefinitionProprieteDynamiqueChampCustom)m_champTeste).DbKeyChamp;
                strNomChamp = m_champTeste.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);
                operateurIdChamp.Parametres.Add(new CComposantFiltreChamp(strAcces + CChampCustom.c_champId, CContexteDonnee.GetNomTableForType(filtre.TypeElements)));
                operateurIdChamp.Parametres.Add(new CComposantFiltreConstante(dbKeyChamp));
                opPrincipal = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt);
                opPrincipal.Parametres.Add(operateurIdChamp);
                Type typeChamp = m_champTeste.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));

            CComposantFiltreSousFiltre composantSousFiltre = IsNotInTest ?
                                                             new CComposantFiltreNotInSousFiltre() as CComposantFiltreSousFiltre :
                                                             new CComposantFiltreInSousFiltre() as CComposantFiltreSousFiltre;


            m_sousFiltre.ElementAVariablesExterne = filtre;
            result = m_sousFiltre.GetFiltreData();
            CFiltreDataAvance filtreAvance = null;

            if (result && result.Data is CFiltreDataAvance)
            {
                filtreAvance = result.Data as CFiltreDataAvance;
            }
            else
            {
                return(result);
            }
            filtreAvance.RenumerotteParameters(filtreData.Parametres.Count + 1);
            foreach (object parametre in filtreAvance.Parametres)
            {
                filtreData.Parametres.Add(parametre);
            }
            CComposantFiltreChamp champDeSousFiltre = new CComposantFiltreChamp(m_champRetourneParSousFiltre.NomPropriete, filtreAvance.TablePrincipale);

            composantSousFiltre.InitComposant(composantChamp, filtreAvance.TablePrincipale, champDeSousFiltre, filtreAvance);

            composantSousFiltre.Parametres.Add(composantChamp);
            composantSousFiltre.Parametres.Add(new CComposantFiltreConstante(CContexteDonnee.GetTypeForTable(filtreAvance.TablePrincipale).ToString()));
            composantSousFiltre.Parametres.Add(new CComposantFiltreConstante(champDeSousFiltre.ChaineInitiale));
            composantSousFiltre.Parametres.Add(new CComposantFiltreConstante(filtreAvance.ComposantPrincipal.GetString()));

            CComposantFiltre composantRecherche = composantSousFiltre;

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


            result.Data = composantRecherche;
            return(result);
        }
 /// ////////////////////////////////////////////////////////////////
 public void AddChampAAjouterAArbreTable(CComposantFiltreChamp champ)
 {
     m_listeChampsAAjouterAArbreTable.Add(champ);
 }
Exemple #18
0
        ////////////////////////////////////////////////////////
        public string GetStringExpression(IExpression expression, CFiltreData filtre)
        {
            string strRetour = "";

            if (expression is CComposantFiltre)
            {
                expression = ((CComposantFiltre)expression).GetComposantFiltreFinal(filtre);
            }

            if (expression is CComposantFiltreChamp)
            {
                CComposantFiltreChamp champ = (CComposantFiltreChamp)expression;
                foreach (CInfoRelationComposantFiltre info in champ.Relations)
                {
                    strRetour += "Parent(" + info.RelationKey + ").";
                }
                strRetour += champ.NomChamp;
            }


            else if (expression is CComposantFiltreConstante)
            {
                CComposantFiltreConstante constante = (CComposantFiltreConstante)expression;
                if (constante.Valeur is String)
                {
                    strRetour = "'" + constante.Valeur.ToString().Replace("'", "''") + "'";
                }
                else if (constante.Valeur is DateTime)
                {
                    strRetour += ((DateTime)constante.Valeur).ToShortDateString();
                }
                else
                {
                    strRetour += constante.Valeur.ToString();
                }
            }


            else if (expression is CComposantFiltreListe)
            {
                CComposantFiltreListe liste = (CComposantFiltreListe)expression;
                strRetour = "";
                foreach (IExpression expDeListe in liste.Liste)
                {
                    strRetour += GetStringExpression(expDeListe, filtre) + ",";
                }
                if (strRetour.Length > 0)
                {
                    strRetour = strRetour.Substring(0, strRetour.Length - 1);
                }
                strRetour = "(" + strRetour + ")";
            }


            else if (expression is CComposantFiltreOperateur)
            {
                COperateurAnalysable operateur = ((CComposantFiltreOperateur)expression).Operateur;
                string strTexteOperateur       = operateur.Texte;
                if (operateur.Niveau > 0 && operateur.Niveau != 4)
                {
                    if (operateur.Texte.Length > 3 && operateur.Texte.Substring(0, 3).ToUpper() == "NOT")
                    {
                        strTexteOperateur = operateur.Texte.Substring(0, 3) + " " + operateur.Texte.Substring(3);
                    }

                    strRetour = GetStringExpression((IExpression)expression.Parametres[0], filtre) +
                                " " + strTexteOperateur +
                                " " + GetStringExpression((IExpression)expression.Parametres[1], filtre);
                }
                else
                {
                    strRetour = strTexteOperateur + "(";
                    foreach (IExpression exp in expression.Parametres)
                    {
                        strRetour += GetStringExpression(exp, filtre) + ",";
                    }
                    if (expression.Parametres.Count > 0)
                    {
                        strRetour = strRetour.Substring(0, strRetour.Length - 1);
                    }
                    strRetour += ")";
                }
            }

            return(strRetour);
        }
Exemple #19
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 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() == "0")
            {
                result.Data = null;
                return(result);
            }
            if (m_champValeur is CDefinitionProprieteDynamiqueChampCustom)
            {
                if (m_champ is CDefinitionProprieteDynamiqueChampCustom)
                {
                    result.EmpileErreur(I.T("Operation not supported: Field = Field|156"));
                    return(result);
                }
                else
                {
                    CDefinitionProprieteDynamique defTmp = m_champ;
                    m_champ       = m_champValeur;
                    m_champValeur = defTmp;
                }
            }

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

            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.";
                dbKeyChampCustom = ((CDefinitionProprieteDynamiqueChampCustom)m_champ).DbKeyChamp;
                //Stef, 12/10/2009, le test de l'id du champ custom est
                //Maintenant gerée par le CInfoRelationChampCustom et non
                //Plus directement dans la clause where. Ca va beaucoup plus vite sous SqlServer

                /*CComposantFiltreOperateur operateurIdChamp = new CComposantFiltreOperateur ( CComposantFiltreOperateur.c_IdOperateurEgal );
                 * CComposantFiltreChamp compo1 = new CComposantFiltreChamp ( strAcces+CChampCustom.c_champId, CContexteDonnee.GetNomTableForType (filtre.TypeElements));
                 * compo1.IdChampCustom = nIdChampCustom;
                 * operateurIdChamp.Parametres.Add ( compo1 );
                 * operateurIdChamp.Parametres.Add ( new CComposantFiltreConstante ( nIdChamp ) );
                 * 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;
                opPrincipal = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt);
                CComposantFiltreChamp composantChampNull = new CComposantFiltreChamp(strAcces + CRelationElementAChamp_ChampCustom.c_champValeurNull, CContexteDonnee.GetNomTableForType(filtre.TypeElements));
                composantChampNull.IdChampCustom = CChampCustom.GetIdFromDbKey(dbKeyChampCustom);
                CComposantFiltreOperateur opEgal = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEgal);
                opEgal.Parametres.Add(composantChampNull);
                opEgal.Parametres.Add(new CComposantFiltreConstante(0));
                opPrincipal.Parametres.Add(opEgal);
            }
            CComposantFiltreChamp composantChamp = new CComposantFiltreChamp(strNomChamp, CContexteDonnee.GetNomTableForType(filtre.TypeElements));

            composantChamp.IdChampCustom = CChampCustom.GetIdFromDbKey(dbKeyChampCustom);
            CComposantFiltreOperateur composantOperateur = new CComposantFiltreOperateur(IdOperateur);


            CComposantFiltre composantValeur = null;

            if (ExpressionValeur == null)
            {
                if (m_champValeur != null)
                {
                    composantValeur = new CComposantFiltreChamp(m_champValeur.NomPropriete, composantChamp.TableDeBase);
                }
                else
                {
                    result.EmpileErreur(I.T("Value is not defined for element @1|157", Description));
                    result.Data = null;
                    return(result);
                }
            }
            else
            {
                result = ExpressionValeur.Eval(contexteEvaluation);
                if (!result)
                {
                    result.EmpileErreur(I.T("Error while evaluation of @1|143", ExpressionValeur.GetString()));
                    result.Data = null;
                    return(result);
                }
                CComposantFiltreVariable composantVariable = new CComposantFiltreVariable("@" + (filtreData.Parametres.Count + 1).ToString());
                filtreData.Parametres.Add(result.Data);
                composantValeur = composantVariable;
            }
            composantOperateur.Parametres.Add(composantChamp);
            composantOperateur.Parametres.Add(composantValeur);

            if (IdOperateur == CComposantFiltreOperateur.c_IdOperateurDifferent)
            {
                //Ajoute ou null
                CComposantFiltreOperateur ou = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurOu);
                ou.Parametres.Add(composantOperateur);

                CComposantFiltreHasNo hasNo = new CComposantFiltreHasNo();
                hasNo.Parametres.Add(new CComposantFiltreChamp(strNomChamp, composantChamp.TableDeBase));
                ou.Parametres.Add(hasNo);
                composantOperateur = ou;
            }
            if (opPrincipal != null)
            {
                opPrincipal.Parametres.Add(composantOperateur);
                composantOperateur = opPrincipal;
            }
            result.Data = composantOperateur;
            return(result);
        }