Beispiel #1
0
        public DataRow GetRowObjetPourDataVersionObject(DataRow row)
        {
            Type tp = CContexteDonnee.GetTypeForTable(row.Table.TableName);

            if (!typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(tp))
            {
                return(null);
            }
            //Récupère l'objet associé
            DataRowVersion rowVersion = DataRowVersion.Current;

            if (row.RowState == DataRowState.Deleted)
            {
                if (row.HasVersion(DataRowVersion.Original))
                {
                    rowVersion = DataRowVersion.Original;
                }
                else
                {
                    return(null);
                }
            }
            CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)Activator.CreateInstance(tp, new object[] { row });

            rel.VersionToReturn = rowVersion;
            try
            {
                IElementAChamps objet = rel.ElementAChamps;
                return(((CObjetDonnee)objet).Row.Row);
            }
            catch
            {
                return(null);
            }
        }
Beispiel #2
0
        public string GetNomTableRelationToChamps()
        {
            object val = m_tableTypeElementToNomTableRelationToChamp[GetType()];

            if (val is string)
            {
                return((string)val);
            }
            CRelationElementAChamp_ChampCustom rel = GetNewRelationToChamp();

            //rel.CreateNewInCurrentContexte();
            val = rel.GetNomTable();
            //rel.CancelCreate();
            m_tableTypeElementToNomTableRelationToChamp[GetType()] = val;
            return((string)val);
        }
Beispiel #3
0
        //-------------------------------------------------------------------
        public static CRelationElementAChamp_ChampCustom GetRelationToChamp(IObjetDonneeAChamps objet,
                                                                            int nIdChamp)
        {
            string strTableValeurs = objet.GetNomTableRelationToChamps();
            string strChampId      = objet.GetChampId();
            object dummy           = null;

            if (!objet.IsDependanceChargee(strTableValeurs, strChampId))
            {
                dummy = objet.RelationsChampsCustom;
            }
            DataTable table = objet.ContexteDonnee.Tables[strTableValeurs];

            string strFiltre = CChampCustom.c_champId + "=" + nIdChamp + " and " +
                               strChampId + "=" + ((IObjetDonneeAIdNumerique)objet).Id;


            //Stef 20/07/2010 : si on fait un set avec version à -1, on modifie la version Referentiel.
            //Le pb était que si on ne fait pas ça, on utilise CContexteDonnee.c_colIsHorsVersion = 0,
            //ce qui peut ramener plus d'1 élément, du coup, applique version fonctionne de manière aléatoire
            //car parfois, on modifie bien la version référentiel, d'autres fois, on modifie
            //autre chose (suivant ce qui est dans le contexte de données).
            if (table.Columns.Contains(CSc2iDataConst.c_champIdVersion))
            {
                if (objet.ContexteDonnee.IdVersionDeTravail == null || objet.ContexteDonnee.IdVersionDeTravail == -1)
                {
                    strFiltre += " and " + CSc2iDataConst.c_champIdVersion + " is null and " +
                                 CSc2iDataConst.c_champIsDeleted + "=0";
                }
                else
                {
                    strFiltre += " and " + CContexteDonnee.c_colIsHorsVersion + "=0";
                }
            }

            DataRow[] rows = table.Select(strFiltre);
            if (rows.Length > 0)
            {
                CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)objet.ContexteDonnee.GetNewObjetForTable(table);
                rel.SetRow(rows[0]);
                return(rel);
            }
            return(null);
        }
Beispiel #4
0
        //-------------------------------------------------------------------------
        public void RepercuteModifsSurVersionFuture(
            DataRow rowReference,
            DataRow rowCopie,
            Dictionary <int, Dictionary <CReferenceChampPourVersion, bool> > dicoDesChampsModifiesParId)
        {
            Type tp = CContexteDonnee.GetTypeForTable(rowReference.Table.TableName);

            if (!typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(tp))
            {
                return;
            }
            CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)Activator.CreateInstance(tp, new object[] { rowReference });
            int nId = rel.ElementAChamps.Id;
            Dictionary <CReferenceChampPourVersion, bool> dicoDesChampsModifies = null;

            dicoDesChampsModifiesParId.TryGetValue(nId, out dicoDesChampsModifies);
            if (dicoDesChampsModifies == null)
            {
                dicoDesChampsModifies = new Dictionary <CReferenceChampPourVersion, bool>();
            }
            CReferenceChampPourVersion refChamp = new CReferenceChampPourVersion(CChampCustomPourVersion.c_typeChamp, rel.Row[CChampCustom.c_champId].ToString());

            if (!dicoDesChampsModifies.ContainsKey(refChamp))
            {
                string[] strChamps = new string[] {
                    CRelationElementAChamp_ChampCustom.c_champValeurBool,
                    CRelationElementAChamp_ChampCustom.c_champValeurDate,
                    CRelationElementAChamp_ChampCustom.c_champValeurDouble,
                    CRelationElementAChamp_ChampCustom.c_champValeurInt,
                    CRelationElementAChamp_ChampCustom.c_champValeurNull,
                    CRelationElementAChamp_ChampCustom.c_champValeurString
                };
                //Répercute la valeur
                foreach (string strChamp in strChamps)
                {
                    rowCopie[strChamp] = rowReference[strChamp];
                }
            }
        }
Beispiel #5
0
        //---------------------------------------------------------------------------------
        public static object GetValeurChamp(IObjetDonneeAChamps objet, int nIdChamp, DataRowVersion version)
        {
            string strTableValeurs = objet.GetNomTableRelationToChamps();
            string strChampId      = objet.GetChampId();

            if (!objet.IsDependanceChargee(strTableValeurs, strChampId) && !IsChampLu(objet, nIdChamp))
            {
                object dummy;
                dummy = objet.RelationsChampsCustom;
                SetTousChampsLus(objet);
            }

            DataTable table     = objet.ContexteDonnee.Tables[strTableValeurs];
            string    strFiltre = CChampCustom.c_champId + "=" + nIdChamp + " and " +
                                  strChampId + "=" + ((IObjetDonneeAIdNumerique)objet).Id;

            //Stef 20/07/2010 : si on fait un get avec version à -1, on récupère la version Referentiel.
            //Le pb était que si on ne fait pas ça, on utilise CContexteDonnee.c_colIsHorsVersion = 0,
            //ce qui peut ramener plus d'1 élément, du coup, GetValeur champ retourne
            //n'importe quelle valeur, et pas forcement celle du référentiel
            if (table.Columns.Contains(CSc2iDataConst.c_champIdVersion))
            {
                if (objet.ContexteDonnee.IdVersionDeTravail == null || objet.ContexteDonnee.IdVersionDeTravail == -1)
                {
                    strFiltre += " and " + CSc2iDataConst.c_champIdVersion + " is null and " +
                                 CSc2iDataConst.c_champIsDeleted + "=0";
                }
                else
                {
                    strFiltre += " and " + CContexteDonnee.c_colIsHorsVersion + "=0";
                }
            }
            DataRow[] rows = table.Select(strFiltre);

            if (rows.Length > 0)
            {
                CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)objet.ContexteDonnee.GetNewObjetForTable(table);
                DataRow row = rows[0];
                if (row.HasVersion(version))
                {
                    rel.SetRow(row);
                    rel.VersionToReturn = version;
                    return(rel.Valeur);
                }
                else
                {
                    return(null);
                }
            }


            /*CListeObjetsDonnees liste = GetRelationsToChamps(nIdChamp);
             *
             * if (liste.Count > 0)
             *  return ((CRelationElementAChamp_ChampCustom) liste[0]).Valeur;*/

            //Changement le 12/10/03 :

            /*Si l'objet n'a pas la relation du champ, mais qu'elle devrait (par ses groupes),
             * retourne la valeur par défaut du champ
             * si le champ ne doit pas apparaitre dans cet élément, retourne null
             * */
            // Lecture de la valeur par défaut du champ
            /* le 3/2/04 pourquoi ? ça ralentit tout !!, annule cette modif*/
            CChampCustom champ = new CChampCustom(objet.ContexteDonnee);

            if (champ.ReadIfExists(nIdChamp))
            {
                object valeurParDefaut = champ.ValeurParDefaut;

                /*if ( valeurParDefaut == null )
                 *  return null;
                 * //La valeur par défaut n'est pas null, regarde si cet élément doit avoir ce champ
                 * foreach ( CChampCustom champNormal in TousLesChamps )
                 * {
                 *      if ( champNormal == champ )
                 *          return valeurParDefaut;
                 * }*/
                return(valeurParDefaut);
            }
            return(null);
        }
Beispiel #6
0
        //-------------------------------------------------------------------
        public static CResultAErreur SetValeurChamp(IObjetDonneeAChamps objet, int nIdChamp, object valeur)
        {
            /*
             * ///Stef 18052011, passage de la recherche de l'élément sous forme de fonction
             *
             *          string strTableValeurs = objet.GetNomTableRelationToChamps();
             *          string strChampId = objet.GetChampId();
             *          object dummy = null;
             *          if (!objet.IsDependanceChargee(strTableValeurs, strChampId))
             *                  dummy = objet.RelationsChampsCustom;
             *          DataTable table = objet.ContexteDonnee.Tables[strTableValeurs];
             *
             *          string strFiltre = CChampCustom.c_champId + "=" + nIdChamp + " and " +
             *                  strChampId + "=" + ((IObjetDonneeAIdNumerique)objet).Id;
             *
             *
             * //Stef 20/07/2010 : si on fait un set avec version à -1, on modifie la version Referentiel.
             * //Le pb était que si on ne fait pas ça, on utilise CContexteDonnee.c_colIsHorsVersion = 0,
             * //ce qui peut ramener plus d'1 élément, du coup, applique version fonctionne de manière aléatoire
             * //car parfois, on modifie bien la version référentiel, d'autres fois, on modifie
             * //autre chose (suivant ce qui est dans le contexte de données).
             * if (objet.ContexteDonnee.IdVersionDeTravail == null || objet.ContexteDonnee.IdVersionDeTravail == -1)
             *          {
             *                  strFiltre += " and " + CSc2iDataConst.c_champIdVersion + " is null and " +
             *                          CSc2iDataConst.c_champIsDeleted + "=0";
             *          }
             *          else
             *          {
             *                  strFiltre += " and " + CContexteDonnee.c_colIsHorsVersion + "=0";
             *          }
             *
             *          DataRow[] rows = table.Select(strFiltre);
             *          if (rows.Length > 0)
             *          {
             *                  CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)objet.ContexteDonnee.GetNewObjetForTable(table);
             *                  rel.SetRow(rows[0]);
             *                  rel.Valeur = valeur;
             *                  return CResultAErreur.True;
             *          }*/
            CRelationElementAChamp_ChampCustom rel = GetRelationToChamp(objet, nIdChamp);

            if (rel != null)
            {
                rel.Valeur = valeur;
                return(CResultAErreur.True);
            }


            CChampCustom   champ  = new CChampCustom(objet.ContexteDonnee);
            CResultAErreur result = CResultAErreur.True;

            if (champ.ReadIfExists(nIdChamp))
            {
                CRelationElementAChamp_ChampCustom relation = objet.GetNewRelationToChamp();
                relation.CreateNewInCurrentContexte();
                relation.ElementAChamps = objet;
                relation.ChampCustom    = champ;
                relation.Valeur         = valeur;
            }
            else
            {
                result.EmpileErreur(I.T("The field n°@1 doesn't exist|234", nIdChamp.ToString()));
            }
            return(result);
        }
Beispiel #7
0
        //---------------------------------------------
        /// <summary>
        /// Retourne un dictionnaire contenant tous les champs modifiés pour
        /// des versions données et des objets donnés
        /// </summary>
        /// <returns></returns>
        public Dictionary <int, Dictionary <int, Dictionary <CReferenceChampPourVersion, bool> > > GetDictionnaireChampsModifies(
            int nIdSession,
            string strIdsVersionsConcernees,
            Type typeElements,
            DataRow[] rowsConcernees)
        {
            if (!typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(typeElements))
            {
                return(null);
            }

            if (rowsConcernees.Length == 0)
            {
                return(new Dictionary <int, Dictionary <int, Dictionary <CReferenceChampPourVersion, bool> > >());
            }

            //Récupère le type des éléments à champs
            CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)Activator.CreateInstance(typeElements, new object[] { rowsConcernees[0] });
            Type typeElementsAChamps = rel.GetTypeElementAChamps();

            //Récupère la clé des éléments à champ
            string strPrimKey = rel.ContexteDonnee.GetTableSafe(CContexteDonnee.GetNomTableForType(typeElementsAChamps)).PrimaryKey[0].ColumnName;


            //Crée la liste des ids pour lesquelles on cherche les valeurs
            Hashtable tableIds = new Hashtable();

            foreach (DataRow row in rowsConcernees)
            {
                rel = (CRelationElementAChamp_ChampCustom)Activator.CreateInstance(typeElements, new object[] { rowsConcernees[0] });
                CObjetDonnee element = (CObjetDonnee)rel.ElementAChamps;
                if (element.Row[CSc2iDataConst.c_champOriginalId] != DBNull.Value)
                {
                    tableIds[element.Row[CSc2iDataConst.c_champOriginalId]] = true;
                }
                else
                {
                    tableIds[row[strPrimKey]] = true;
                }
            }

            StringBuilder blIds = new StringBuilder();

            foreach (int nId in tableIds.Keys)
            {
                blIds.Append(nId.ToString());
                blIds.Append(",");
            }
            blIds.Remove(blIds.Length - 1, 1);


            C2iRequeteAvancee requete = new C2iRequeteAvancee(-1);

            requete.TableInterrogee = CVersionDonneesObjetOperation.c_nomTable;
            requete.ListeChamps.Add(new C2iChampDeRequete("Id",
                                                          new CSourceDeChampDeRequete(CVersionDonneesObjet.c_nomTable + "." + CVersionDonneesObjet.c_champIdElement),
                                                          typeof(int),
                                                          OperationsAgregation.None,
                                                          true));
            requete.ListeChamps.Add(new C2iChampDeRequete("Field",
                                                          new CSourceDeChampDeRequete(CVersionDonneesObjetOperation.c_champChamp),
                                                          typeof(string),
                                                          OperationsAgregation.None,
                                                          true));
            requete.ListeChamps.Add(new C2iChampDeRequete("FieldType",
                                                          new CSourceDeChampDeRequete(CVersionDonneesObjetOperation.c_champTypeChamp),
                                                          typeof(string),
                                                          OperationsAgregation.None,
                                                          true));
            requete.ListeChamps.Add(new C2iChampDeRequete("IdVersion",
                                                          new CSourceDeChampDeRequete(CVersionDonneesObjet.c_nomTable + "." + CVersionDonnees.c_champId),
                                                          typeof(int),
                                                          OperationsAgregation.None,
                                                          true));
            CFiltreData filtre = new CFiltreDataAvance(CVersionDonneesObjetOperation.c_nomTable,
                                                       CVersionDonneesObjet.c_nomTable + "." +
                                                       CVersionDonnees.c_champId + " in (" + strIdsVersionsConcernees + ") and " +
                                                       CVersionDonneesObjet.c_nomTable + "." +
                                                       CVersionDonneesObjet.c_champIdElement + " in (" + blIds + ") and " +
                                                       CVersionDonneesObjet.c_nomTable + "." +
                                                       CVersionDonneesObjet.c_champTypeElement + "=@1 and " +
                                                       CVersionDonneesObjetOperation.c_champTypeChamp + "=@2",
                                                       typeElementsAChamps.ToString(),
                                                       CChampCustomPourVersion.c_typeChamp);

            filtre.IgnorerVersionDeContexte = true;
            requete.FiltreAAppliquer        = filtre;

            Dictionary <int, Dictionary <int, Dictionary <CReferenceChampPourVersion, bool> > > dicoChampsModifies = new Dictionary <int, Dictionary <int, Dictionary <CReferenceChampPourVersion, bool> > >();
            CResultAErreur result = requete.ExecuteRequete(nIdSession);

            if (!result)
            {
                return(null);
            }
            foreach (DataRow rowModif in ((DataTable)result.Data).Rows)
            {
                int nIdVersion = (int)rowModif["IdVersion"];
                Dictionary <int, Dictionary <CReferenceChampPourVersion, bool> > dicoChampsDeVersion = null;
                if (!dicoChampsModifies.TryGetValue(nIdVersion, out dicoChampsDeVersion))
                {
                    dicoChampsDeVersion            = new Dictionary <int, Dictionary <CReferenceChampPourVersion, bool> >();
                    dicoChampsModifies[nIdVersion] = dicoChampsDeVersion;
                }
                Dictionary <CReferenceChampPourVersion, bool> dicoChampsDeId = new Dictionary <CReferenceChampPourVersion, bool>();
                if (!dicoChampsDeVersion.TryGetValue((int)rowModif["Id"], out dicoChampsDeId))
                {
                    dicoChampsDeId = new Dictionary <CReferenceChampPourVersion, bool>();
                    dicoChampsDeVersion[(int)rowModif["Id"]] = dicoChampsDeId;
                }
                dicoChampsDeId[
                    new CReferenceChampPourVersion((string)rowModif["FieldType"], (string)rowModif["Field"])] = true;
            }
            return(dicoChampsModifies);
        }
Beispiel #8
0
        //-------------------------------------------------------------------------
        public CVersionDonneesObjet JournaliseDonnees(System.Data.DataRow row, CVersionDonnees version)
        {
            if (row.RowState == DataRowState.Modified ||
                row.RowState == DataRowState.Added ||
                row.RowState == DataRowState.Deleted)
            {
                Type tp = CContexteDonnee.GetTypeForTable(row.Table.TableName);
                if (!typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(tp))
                {
                    return(null);
                }
                //Récupère l'objet associé
                DataRowVersion rowVersion = DataRowVersion.Current;
                if (row.RowState == DataRowState.Deleted)
                {
                    if (row.HasVersion(DataRowVersion.Original))
                    {
                        rowVersion = DataRowVersion.Original;
                    }
                    else
                    {
                        return(null);
                    }
                }
                CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)Activator.CreateInstance(tp, new object[] { row });
                rel.VersionToReturn = rowVersion;
                try
                {
                    IElementAChamps objet = rel.ElementAChamps;
                    //Si l'objet est ajouté, on n'archive pas !
                    if (objet is CObjetDonneeAIdNumerique &&
                        ((CObjetDonneeAIdNumerique)objet).Row.RowState != DataRowState.Added)
                    {
                        CObjetDonneeAIdNumerique objetAId = (CObjetDonneeAIdNumerique)objet;
                        if (objetAId != null)
                        {
                            //Récupère un version pour l'objet
                            CVersionDonneesObjet versionObjet = version.GetVersionObjetAvecCreation(objetAId.Row.Row);
                            if (versionObjet == null)
                            {
                                return(null);
                            }

                            //Stef 14082008 : en cas d'ajout, on ne fait rien. le datarow de l'objet n'est pas added
                            //car l'objet a déjà été sauvé quand on passe par là !
                            if (versionObjet.CodeTypeOperation == (int)CTypeOperationSurObjet.TypeOperation.Ajout)
                            {
                                return(null);
                            }

                            new CJournaliseurValeurChampCustom().JournaliseDonneeInContexte(versionObjet, rel.ChampCustom, row);
                            return(versionObjet);
                        }
                    }
                }
                catch
                {
                    return(null);
                }
            }
            return(null);
        }
Beispiel #9
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);
        }
        //---------------------------------------------------------------
        public CVersionDonneesObjetOperation JournaliseDonneeInContexte(CVersionDonneesObjet version, CChampCustom champ, DataRow row)
        {
            if (row.RowState != DataRowState.Modified && row.RowState != DataRowState.Added && row.RowState != DataRowState.Deleted)
            {
                return(null);
            }
            Type tp = CContexteDonnee.GetTypeForTable(row.Table.TableName);

            if (!typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(tp))
            {
                return(null);
            }
            CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)Activator.CreateInstance(tp, new object[] { row });
            object valeurAvant = DBNull.Value;
            object valeurApres = DBNull.Value;

            if (champ.TypeDonneeChamp.TypeDonnee == TypeDonnee.tObjetDonneeAIdNumeriqueAuto)
            {
                if (row.HasVersion(DataRowVersion.Original))
                {
                    rel.VersionToReturn = DataRowVersion.Original;
                    valeurAvant         = rel.ValeurInt;
                    rel.VersionToReturn = DataRowVersion.Current;
                }
                if (row.HasVersion(DataRowVersion.Current))
                {
                    valeurApres = rel.ValeurInt;
                }
            }
            else
            {
                valeurAvant = DBNull.Value;
                if (row.HasVersion(DataRowVersion.Original))
                {
                    rel.VersionToReturn = DataRowVersion.Original;
                    valeurAvant         = rel.Valeur;
                    rel.VersionToReturn = DataRowVersion.Current;
                }
                if (row.HasVersion(DataRowVersion.Current))
                {
                    valeurApres = rel.Valeur;
                }
            }

            CVersionDonneesObjetOperation verData = null;
            ///Stef optim 13082008 : ne passe plus par une liste pour trouver l'objet
            //Ancien code

            /*
             * CListeObjetsDonnees datas = version.Modifications;
             * datas.Filtre = new CFiltreData(CVersionDonneesObjetOperation.c_champTypeChamp + "=@1 and " +
             *      CVersionDonneesObjetOperation.c_champChamp + "=@2",
             *      CChampCustomPourVersion.c_typeChamp,
             *      champ.Id.ToString());
             * datas.InterditLectureInDB = true;
             *
             * if (datas.Count != 0)
             *      verData = (CVersionDonneesObjetOperation)datas[0];
             * */
            //Nouveau code
            object dummy = null;

            if (!version.IsDependanceChargee(CVersionDonneesObjetOperation.c_nomTable, CVersionDonneesObjet.c_champId))
            {
                dummy = version.Modifications;
            }
            DataTable     table = version.ContexteDonnee.GetTableSafe(CVersionDonneesObjetOperation.c_nomTable);
            StringBuilder bl    = new StringBuilder();

            bl.Append(CVersionDonneesObjet.c_champId);
            bl.Append("=");
            bl.Append(version.Id);
            bl.Append(" and ");
            bl.Append(CVersionDonneesObjetOperation.c_champTypeChamp);
            bl.Append("='");
            bl.Append(CChampCustomPourVersion.c_typeChamp);
            bl.Append("' and ");
            bl.Append(CVersionDonneesObjetOperation.c_champChamp);
            bl.Append("='");
            bl.Append(champ.Id);
            bl.Append("'");
            DataRow[] rows = table.Select(bl.ToString());
            if (rows.Length > 0)
            {
                verData = new CVersionDonneesObjetOperation(rows[0]);
            }
            //fin du nouveau code
            else
            {
                verData = new CVersionDonneesObjetOperation(version.ContexteDonnee);
                verData.CreateNewInCurrentContexte();
                verData.VersionObjet      = version;
                verData.CodeTypeOperation = (int)CTypeOperationSurObjet.TypeOperation.Modification;
            }
            verData.FieldKey = champ.Id.ToString();

            //Pour les prévisionnelles, stocke la nouvelle valeur
            if (version.VersionDonnees.TypeVersion.Code == CTypeVersion.TypeVersion.Previsionnelle)
            {
                verData.SetValeurStd(valeurApres);
            }
            else
            {
                //Pour les archives, stocke l'ancienne valeur
                verData.SetValeurStd(valeurAvant);
            }
            verData.TypeChamp = CChampCustomPourVersion.c_typeChamp;
            if (version != null && version.TypeOperation == CTypeOperationSurObjet.TypeOperation.Aucune)
            {
                version.CodeTypeOperation = (int)CTypeOperationSurObjet.TypeOperation.Modification;
            }
            return(verData);
        }