Example #1
0
        //----------------------------------------------------
        public static int?GetIdFromUniverselId(Type typeElement, CDbKey key)
        {
            string            strNomTable = CContexteDonnee.GetNomTableForType(typeElement);
            CStructureTable   structure   = CStructureTable.GetStructure(typeElement);
            C2iRequeteAvancee rq          = new C2iRequeteAvancee();

            rq.TableInterrogee  = strNomTable;
            rq.FiltreAAppliquer = new CFiltreData(
                CObjetDonnee.c_champIdUniversel + "=@1", key.GetValeurInDb());
            rq.ListeChamps.Add(new C2iChampDeRequete(
                                   structure.ChampsId[0].NomChamp,
                                   new CSourceDeChampDeRequete(structure.ChampsId[0].NomChamp),
                                   typeof(string),
                                   OperationsAgregation.None,
                                   true));
            CResultAErreur result = rq.ExecuteRequete(0);

            if (result && result.Data is DataTable)
            {
                DataTable table = result.Data as DataTable;
                if (table.Rows.Count > 0)
                {
                    return((int)table.Rows[0][0]);
                }
            }
            return(null);
        }
Example #2
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);
        }
Example #3
0
        //------------------------------------------------------------------------------------------
        public void ReadArbre(CListeObjetsDonnees listeSource, CListeObjetsDonnees.CArbreProps arbre, List <string> lstPaquetsALire)
        {
            string strIdChamp   = "";
            string strPropriete = "";
            string strCle       = "";

            if (listeSource.Count == 0)
            {
                return;
            }
            bool bFromEntiteToChamp = false;

            if (!CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(arbre.ProprietePrincipale, ref strCle, ref strPropriete))
            {
                return;
            }
            if (!CInfoRelationComposantFiltreEntiteToChampEntite.DecomposeNomPropriete(strPropriete, ref strIdChamp, ref bFromEntiteToChamp))
            {
                //c'est une relation vers des valeurs de champ qui pointent sur cette valeur.
                //Ignore, et traite tout dans le composant suivant qui est un Entité to champ à l'envers
                listeSource.ReadDependances(arbre);
                return;
            }
            //On a affaire à une liste source qui contient des valeurs qui sont pointées
            //par des valeurs de champs, et on veut les éléments qui pointent sur ces valeurs de champs

            CChampCustom champ      = new CChampCustom(listeSource.ContexteDonnee);
            CDbKey       dbKeyChamp = CDbKey.CreateFromStringValue(strIdChamp);

            if (!champ.ReadIfExists(dbKeyChamp))
            {
                return;
            }
            //Vérifie que la liste source est bien du type de données du champ custom
            if (champ.TypeDonnee.TypeDotNetNatif != listeSource.TypeObjets)
            {
                return;
            }
            IObjetDonneeAIdNumerique obj = listeSource[0] as IObjetDonneeAIdNumerique;

            if (obj == null)
            {
                return;
            }
            string strChampId = obj.GetChampId();

            if (lstPaquetsALire == null)
            {
                lstPaquetsALire = listeSource.GetPaquetsPourLectureFils(strChampId, null);
            }

            //Trouve le type des éléments à champs
            Type typeElementsFinaux = champ.Role.TypeAssocie;
            //Trouve le type des relations aux elementAchamp_ChampCustom
            IObjetDonneeAChamps elt = Activator.CreateInstance(typeElementsFinaux, new object[] { listeSource.ContexteDonnee }) as IObjetDonneeAChamps;

            if (elt == null)
            {
                return;
            }
            string strNomTableRelToChamp = elt.GetNomTableRelationToChamps();
            Type   tpRelToChamp          = CContexteDonnee.GetTypeForTable(strNomTableRelToChamp);

            if (tpRelToChamp == null)
            {
                return;
            }
            foreach (string strPaquet in lstPaquetsALire)
            {
                CListeObjetsDonnees lst = new CListeObjetsDonnees(listeSource.ContexteDonnee, typeElementsFinaux);

                //TESTDBKEYTODO
                string strChampCustomId = dbKeyChamp.IsNumericalId() ? CChampCustom.c_champId : CObjetDonnee.c_champIdUniversel;

                lst.Filtre = new CFiltreDataAvance(
                    CContexteDonnee.GetNomTableForType(typeElementsFinaux),
                    strNomTableRelToChamp + "." + strChampCustomId + "=@1 and " +
                    strNomTableRelToChamp + "." + CRelationElementAChamp_ChampCustom.c_champValeurInt + " in " +
                    strPaquet,
                    dbKeyChamp.GetValeurInDb());
                lst.AssureLectureFaite();
                lst.ReadDependances(arbre);
            }
        }