Пример #1
0
        //-------------------------------------------------------------------
        public override CResultAErreur TraitementAvantSauvegarde(CContexteDonnee contexte)
        {
            CResultAErreur result = CResultAErreur.True;
            DataTable      table  = contexte.Tables[GetNomTable()];

            foreach (DataRow row in table.Rows)
            {
                if (row.RowState == DataRowState.Modified || row.RowState == DataRowState.Added)
                {
                    //Vérifie que tous les éléments ne sont ajoutés qu'une seule fois
                    CListeEntites       liste     = new CListeEntites(row);
                    CListeObjetsDonnees relations = liste.RelationsEntites;
                    relations.Tri = CRelationListeEntites_Entite.c_champIdElement;
                    int nLastVal = -1;
                    foreach (CRelationListeEntites_Entite rel in relations)
                    {
                        if (rel.IdElement == nLastVal)
                        {
                            rel.Delete();
                        }
                        else
                        {
                            nLastVal = rel.IdElement;
                        }
                    }
                }
            }
            return(result);
        }
Пример #2
0
 /// //////////////////////////////////////////////////////
 public CDefinitionProprieteDynamiqueListeEntites(CListeEntites liste)
     : base(
         liste.Libelle.Replace(" ", "_"),
         liste.Id.ToString(),
         new CTypeResultatExpression(liste.TypeElements, true),
         true,
         true)
 {
     m_dbKeyListeEntite = liste.DbKey;
 }
Пример #3
0
        //-------------------------------------------------------------------
        public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
        {
            CResultAErreur result = CResultAErreur.True;

            try
            {
                CListeEntites listeEntites = (CListeEntites)objet;

                if (listeEntites.Libelle.Trim() == "")
                {
                    result.EmpileErreur(I.T("Indicate a name for this list|125"));
                }


                if (listeEntites.TypeElements == null)
                {
                    result.EmpileErreur(I.T("The entities list must be associated with an entity type|126"));
                }

                //Controler que le libellé est unique pour le type
                CFiltreData filtre = new CFiltreData(
                    CListeEntites.c_champId + "<>@1 and " +
                    CListeEntites.c_champLibelle + "=@2",
                    listeEntites.Id, listeEntites.Libelle);
                if (CountRecords(GetNomTable(), filtre) != 0)
                {
                    result.EmpileErreur(I.T("Another list has this label|127"));
                }

                if (listeEntites.Code.Trim() != "")
                {
                    //Controler que le code est unique pour le type
                    filtre = new CFiltreData(
                        CListeEntites.c_champId + "<>@1 and " +
                        CListeEntites.c_champCode + "=@2",
                        listeEntites.Id, listeEntites.Code);
                    if (CountRecords(GetNomTable(), filtre) != 0)
                    {
                        result.EmpileErreur(I.T("Another list has this code|128"));
                    }
                }
            }
            catch (Exception e)
            {
                result.EmpileErreur(new CErreurException(e));
            }
            return(result);
        }
Пример #4
0
        //------------------------------------------------------------
        public CResultAErreur GetValue(object objet, string strPropriete)
        {
            CResultAErreur result      = CResultAErreur.True;
            CObjetDonnee   objetDonnee = objet as CObjetDonnee;

            if (objetDonnee == null)
            {
                return(result);
            }

            int nIdListe = -1;

            try
            {
                nIdListe = Int32.Parse(strPropriete);
            }
            catch
            {
                result.EmpileErreur(I.T("Bad entity list property format (@1)|20028", strPropriete));
                return(result);
            }
            CListeEntites liste = new CListeEntites(objetDonnee.ContexteDonnee);

            try
            {
                if (liste.ReadIfExists(nIdListe))
                {
                    CListeObjetsDonnees resultListe = liste.GetElementsLiesFor(objetDonnee);
                    if (resultListe != null)
                    {
                        result.Data = resultListe.ToArray(liste.TypeElements);
                    }
                }
                else
                {
                    result.EmpileErreur(I.T("Entity list @1 doesn't exists|20029", strPropriete));
                    return(result);
                }
            }
            catch (Exception e)
            {
                result.EmpileErreur(new CErreurException(e));
            }
            return(result);
        }
Пример #5
0
        public IOptimiseurGetValueDynamic GetOptimiseur(Type tp, string strPropriete)
        {
            int  nId = -1;
            Type tp2 = null;

            try
            {
                nId = Int32.Parse(strPropriete);
                CListeEntites liste = new CListeEntites(CContexteDonneeSysteme.GetInstance());
                if (liste.ReadIfExists(nId))
                {
                    tp2 = liste.TypeElements;
                }
            }
            catch
            {
            }
            return(new COptimiseurProprieteDynamiqueListeEntite(nId, tp2));
        }
Пример #6
0
            public object GetValue(object objet)
            {
                CObjetDonnee objetDonnee = objet as CObjetDonnee;

                if (objetDonnee == null || m_nIdList < 0)
                {
                    return(null);
                }

                CListeEntites liste = new CListeEntites(objetDonnee.ContexteDonnee);

                try
                {
                    if (liste.ReadIfExists(m_nIdList))
                    {
                        CListeObjetsDonnees resultListe = liste.GetElementsLiesFor(objetDonnee);
                        return(resultListe);
                    }
                }
                catch
                {
                }
                return(null);
            }
Пример #7
0
        /// ///////////////////////////////////////////////////////////
        public object GetValue(object objetInterroge, CDefinitionProprieteDynamique propriete)
        {
            //Récupère l'objet à interroger
            string strProp = propriete.NomPropriete;
            object valeur  = m_cache.GetValeurCache(objetInterroge, strProp);

            if (valeur != null)
            {
                return(valeur);
            }

            CContexteDonnee contexteForObjets = ContexteDonneeCache;

            if (objetInterroge is IObjetAContexteDonnee)
            {
                contexteForObjets = ((IObjetAContexteDonnee)objetInterroge).ContexteDonnee;
            }
            if (contexteForObjets == null)
            {
                contexteForObjets = ContexteDonneeCache;
            }


            object objetFinal = objetInterroge;
            int    nPos       = strProp.LastIndexOf('.');

            if (nPos > 0 && !(propriete is CDefinitionProprieteDynamiqueDonneeCumulee) &&
                !(propriete is CDefinitionProprieteDynamiqueChampCustom) &&
                !(propriete is CDefinitionProprieteDynamiqueChampCustomFils) &&
                !(propriete is CDefinitionProprieteDynamiqueFormule))
            {
                string strPropDebut;
                strPropDebut = strProp.Substring(0, nPos);
                strProp      = strProp.Substring(nPos + 1);
                objetFinal   = m_cache.GetValeurCache(objetInterroge, strPropDebut);
                if (objetFinal == null)
                {
                    objetFinal = GetValue(objetInterroge, strPropDebut);

                    /*object objetAInterroger = null;
                     * MemberInfo membre = null;
                     * CInterpreteurTexteProptVariete.GetObjetFinalEtMemberInfo ( objetInterroge, strPropDebut, ref objetAInterroger, ref membre );
                     * if ( membre != null )
                     * {
                     *      objetFinal = CInterpreteurTextePropriete.GetValue ( objetAInterroger, membre );
                     * }
                     * else
                     * {
                     *      //On n'a pas trouvé le membre, il s'agit donc d'autre chose, il faut donc décomposer
                     *      //Le champ
                     * }*/
                    //objetFinal = CInterpreteurTextePropriete.GetValue(objetInterroge, strPropDebut);
                    m_cache.StockeValeurEnCache(objetInterroge, strPropDebut, objetFinal);
                }
                if (objetFinal == null)
                {
                    return(null);
                }
                valeur = m_cache.GetValeurCache(objetFinal, strProp);
                if (valeur != null)
                {
                    return(valeur);
                }
            }


            if (propriete is CDefinitionProprieteDynamiqueChampCustom)
            {
                if (!(objetFinal is IElementAChamps))
                {
                    valeur = null;
                }

                else
                {
                    //TESTDBKEYTODO qui ne peut pas marche
                    valeur = ((IElementAChamps)objetFinal).GetValeurChamp(((CDefinitionProprieteDynamiqueChampCustom)propriete).DbKeyChamp.InternalIdNumeriqueANeJamaisUtiliserSaufDansCDbKeyAddOn.Value, System.Data.DataRowVersion.Default);

                    /*if (m_bValeurAfficheeDeChampsCustom)
                     * {
                     *      CChampCustom champ = new CChampCustom(ContexteDonneeCache);
                     *      if (champ.ReadIfExists(((CDefinitionProprieteDynamiqueChampCustom)propriete).IdChamp))
                     *      {
                     *              object valTmp = champ.DisplayFromValue(valeur);
                     *              if (valTmp != null)
                     *                      valeur = valTmp;
                     *      }
                     * }*/
                }
            }
            else if (propriete is CDefinitionProprieteDynamiqueChampCustomFils && objetInterroge is CObjetDonneeAIdNumerique)
            {
                CChampCustom champ = new CChampCustom(ContexteDonneeCache);
                if (champ.ReadIfExists(((CDefinitionProprieteDynamiqueChampCustomFils)propriete).KeyChamp))
                {
                    Type tp = champ.Role.TypeAssocie;

                    try
                    {
                        IObjetDonneeAChamps elt = (IObjetDonneeAChamps)Activator.CreateInstance(tp, new object[] { contexteForObjets });
                        CRelationElementAChamp_ChampCustom rel = elt.GetNewRelationToChamp();
                        CListeObjetsDonnees liste = new CListeObjetsDonnees(contexteForObjets, tp);
                        liste.Filtre = new CFiltreDataAvance(
                            elt.GetNomTable(),
                            rel.GetNomTable() + "." +
                            CRelationElementAChamp_ChampCustom.c_champValeurString + "=@1 and " +
                            rel.GetNomTable() + "." +
                            CRelationElementAChamp_ChampCustom.c_champValeurInt + "=@2 and " +
                            rel.GetNomTable() + "." +
                            CChampCustom.c_champId + "=@3",
                            objetInterroge.GetType().ToString(),
                            ((CObjetDonneeAIdNumerique)objetInterroge).Id,
                            champ.Id);
                        valeur = liste.ToArray(tp);
                    }
                    catch
                    {
                        valeur = null;
                    }
                }
            }
            else if (propriete is CDefinitionProprieteDynamiqueListeEntites)
            {
                CListeEntites liste = new CListeEntites(contexteForObjets);
                try
                {
                    if (liste.ReadIfExists(((CDefinitionProprieteDynamiqueListeEntites)propriete).DbKeyListeEntite))
                    {
                        CListeObjetsDonnees resultListe = liste.GetElementsLiesFor(objetInterroge);
                        if (resultListe != null)
                        {
                            valeur = resultListe.ToArray(liste.TypeElements);
                        }
                    }
                }
                catch
                {
                    valeur = null;
                }
            }


            else if (propriete is CDefinitionProprieteDynamiqueRelationTypeId)
            {
                if (!(objetFinal is CObjetDonneeAIdNumerique))
                {
                    valeur = null;
                }
                else
                {
                    CDefinitionProprieteDynamiqueRelationTypeId defRel = (CDefinitionProprieteDynamiqueRelationTypeId)propriete;
                    return(((CObjetDonneeAIdNumerique)objetFinal).GetDependancesRelationTypeId(
                               defRel.Relation.TableFille,
                               defRel.Relation.ChampType,
                               defRel.Relation.ChampId,
                               false));
                }
            }
            else if (propriete is CDefinitionProprieteDynamiqueDonneeCumulee)
            {
                if (!(objetFinal is CObjetDonneeAIdNumerique))
                {
                    valeur = null;
                }
                else
                {
                    CDefinitionProprieteDynamiqueDonneeCumulee defType = (CDefinitionProprieteDynamiqueDonneeCumulee)propriete;
                    CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)objetFinal;
                    CTypeDonneeCumulee       type  = new CTypeDonneeCumulee(contexteForObjets);
                    if (type.ReadIfExists(defType.DbKeyTypeDonnee))
                    {
                        valeur = type.GetDonneesCumuleesForObjet(objet);
                    }
                    else
                    {
                        valeur = null;
                    }
                }
            }
            else if (propriete is CDefinitionProprieteDynamiqueChampCalcule)
            {
                CChampCalcule champ = new CChampCalcule(contexteForObjets);
                if (champ.ReadIfExists(((CDefinitionProprieteDynamiqueChampCalcule)propriete).DbKeyChamp))
                {
                    valeur = champ.Calcule(objetFinal, new CFournisseurPropDynStd(true));
                }
                else
                {
                    valeur = null;
                }
            }
            else if (propriete is CDefinitionProprieteDynamiqueFormule)
            {
                CContexteEvaluationExpression contexte = new CContexteEvaluationExpression(objetInterroge);
                contexte.AttacheObjet(typeof(CContexteDonnee), contexteForObjets);
                CResultAErreur result = ((CDefinitionProprieteDynamiqueFormule)propriete).Formule.Eval(contexte);
                if (result)
                {
                    return(result.Data);
                }
            }
            else if (propriete is CDefinitionProprieteDynamiqueVariableDynamique && objetFinal is IElementAVariables)
            {
                valeur = ((IElementAVariables)objetFinal).GetValeurChamp(((CDefinitionProprieteDynamiqueVariableDynamique)propriete).IdChamp);
            }
            else
            {
                valeur = CInterpreteurTextePropriete.GetValue(objetFinal, strProp);
            }
            m_cache.StockeValeurEnCache(objetInterroge, propriete.Nom, valeur);
            if (objetFinal != objetInterroge)
            {
                m_cache.StockeValeurEnCache(objetFinal, strProp, valeur);
            }
            return(valeur);
        }