public CDefinitionProprieteDynamique[] GetDefinitionsChamps(CObjetPourSousProprietes objet, CDefinitionProprieteDynamique defParente)
        {
            List <CDefinitionProprieteDynamique> lstProps = new List <CDefinitionProprieteDynamique>();

            if (objet == null)
            {
                return(lstProps.ToArray());
            }
            Type tp = objet.TypeAnalyse;

            if (tp == null)
            {
                return(lstProps.ToArray());
            }
            CDefinitionProprieteDynamique[] defCache = null;
            if (m_cache.TryGetValue(tp, out defCache))
            {
                return(defCache);
            }

            //Relations TypeID
            foreach (RelationTypeIdAttribute relation in CContexteDonnee.RelationsTypeIds)
            {
                if (relation.NomConvivialPourParent != "" && relation.IsAppliqueToType(tp))
                {
                    CDefinitionProprieteDynamiqueRelationTypeId def = new CDefinitionProprieteDynamiqueRelationTypeId(relation);
                    lstProps.Add(def);
                }
            }
            defCache    = lstProps.ToArray();
            m_cache[tp] = defCache;
            return(defCache);
        }
        public CDefinitionProprieteDynamique GetProprieteInverse(Type typePortantLaPropriete, CDefinitionProprieteDynamique def)
        {
            CDefinitionProprieteDynamiqueRelationTypeId defId = def as CDefinitionProprieteDynamiqueRelationTypeId;

            if (defId == null)
            {
                return(null);
            }
            return(new CDefinitionProprieteDynamiqueRelationTypeIdToParent(defId.Relation, typePortantLaPropriete));
        }
Пример #3
0
        /// ///////////////////////////////////////////////////////////
        protected virtual void GetDefinitionsChamps(
            Type tp,
            int nProfondeur,
            ArrayList lstProps,
            string strCheminConvivial,
            string strCheminReel,
            CDefinitionProprieteDynamique definitionParente
            )
        {
            /*ITraducteurNomChamps traducteur = null;
             * if ( definitionParente is ITraducteurNomChamps )
             *      traducteur = (ITraducteurNomChamps)definitionParente;*/
            if (nProfondeur < 0)
            {
                return;
            }
            if (tp == null)
            {
                return;
            }

            //Proprietes
            foreach (PropertyInfo info in tp.GetProperties())
            {
                object[] attribs = info.GetCustomAttributes(typeof(DynamicFieldAttribute), true);
                if (attribs.Length == 1)
                {
                    DynamicFieldAttribute attrib = (DynamicFieldAttribute)attribs[0];
                    bool bReadOnly = info.GetSetMethod() == null;
                    Type tpProp    = info.PropertyType;
                    bool bIsArray  = tpProp.IsArray;
                    if (bIsArray)
                    {
                        tpProp = tpProp.GetElementType();
                    }
                    bool bHasSubProprietes = HasSubProperties(tpProp);
                    if (m_bAvecReadOnly || !bReadOnly || bHasSubProprietes)
                    {
                        CDefinitionProprieteDynamique def = new CDefinitionProprieteDynamiqueDotNet(
                            strCheminConvivial + attrib.NomConvivial,
                            strCheminReel + info.Name,
                            new CTypeResultatExpression(tpProp, bIsArray),
                            bHasSubProprietes,
                            bReadOnly,
                            attrib.Rubrique);
                        if (AddDefinition(lstProps, def /*, traducteur*/))
                        {
                            GetDefinitionsChamps(info.PropertyType, nProfondeur - 1, lstProps, strCheminConvivial + attrib.NomConvivial + ".", strCheminReel + info.Name + ".", def);
                        }
                    }
                }
                attribs = info.GetCustomAttributes(typeof(DynamicChildsAttribute), true);
                {
                    if (attribs.Length == 1)
                    {
                        DynamicChildsAttribute        attrib = (DynamicChildsAttribute)attribs[0];
                        CDefinitionProprieteDynamique def    = new CDefinitionProprieteDynamiqueDotNet(
                            strCheminConvivial + attrib.NomConvivial,
                            strCheminReel + info.Name,
                            new CTypeResultatExpression(attrib.TypeFils, true)
                            , true,
                            true,
                            attrib.Rubrique);
                        if (AddDefinition(lstProps, def /*, traducteur*/))
                        {
                            GetDefinitionsChamps(attrib.TypeFils, nProfondeur - 1, lstProps, strCheminConvivial + attrib.NomConvivial + ".", strCheminReel + info.Name + ".", def);
                        }
                    }
                }
            }

            //Champs custom
            CRoleChampCustom role = CRoleChampCustom.GetRoleForType(tp);

            if (role != null)
            {
                CListeObjetsDonnees listeChamps = CChampCustom.GetListeChampsForRole(ContexteDonneeCache, role.CodeRole);
                foreach (CChampCustom champ in listeChamps)
                {
                    CDefinitionProprieteDynamiqueChampCustom def = new CDefinitionProprieteDynamiqueChampCustom(champ);
                    if (champ.Categorie.Trim() != "")
                    {
                        def.Rubrique = champ.Categorie;
                    }
                    else
                    {
                        def.Rubrique = I.T("Complementary informations|59");
                    }
                    AddDefinition(lstProps, def /*, traducteur*/);
                }
            }

            //Champs calculés
            if (AvecReadOnly)
            {
                CListeObjetsDonnees liste = new CListeObjetsDonnees(ContexteDonneeCache, typeof(CChampCalcule));
                liste.Filtre = new CFiltreData(CChampCalcule.c_champTypeObjets + "=@1", tp.ToString());
                foreach (CChampCalcule champ in liste)
                {
                    CDefinitionProprieteDynamiqueChampCalcule def = new CDefinitionProprieteDynamiqueChampCalcule(champ);
                    def.HasSubProperties = HasSubProperties(def.TypeDonnee.TypeDotNetNatif);
                    def.Rubrique         = I.T("Complementary informations|59");
                    AddDefinition(lstProps, def /*, traducteur*/);
                }
            }

            //Méthodes
            if (m_bAvecMethodes && AvecReadOnly)
            {
                //Va chercher les propriétés
                foreach (MethodInfo methode in tp.GetMethods())
                {
                    object[] attribs = methode.GetCustomAttributes(typeof(DynamicMethodAttribute), true);
                    if (attribs.Length == 1)
                    {
                        DynamicMethodAttribute  attrib  = (DynamicMethodAttribute)attribs[0];
                        CTypeResultatExpression typeRes = new CTypeResultatExpression(methode.ReturnType, false);
                        if (methode.ReturnType.HasElementType)
                        {
                            typeRes = new CTypeResultatExpression(methode.ReturnType.GetElementType(), true);
                        }
                        CDefinitionProprieteDynamique def = new CDefinitionMethodeDynamique(
                            strCheminConvivial + methode.Name,
                            strCheminReel + methode.Name,
                            typeRes,
                            HasSubProperties(methode.ReturnType),
                            attrib.Descriptif,
                            attrib.InfosParametres);
                        def.Rubrique = I.T("Methods|58");
                        lstProps.Add(def);
                        GetDefinitionsChamps(methode.ReturnType, nProfondeur - 1, lstProps, strCheminConvivial + methode.Name + ".", strCheminReel + methode.Name + ".", def);
                    }
                }
                foreach (CMethodeSupplementaire methode in CGestionnaireMethodesSupplementaires.GetMethodsForType(tp))
                {
                    CDefinitionProprieteDynamique def = new CDefinitionMethodeDynamique(
                        strCheminConvivial + methode.Name,
                        strCheminReel + methode.Name,
                        new CTypeResultatExpression(methode.ReturnType, methode.ReturnArrayOfReturnType),
                        HasSubProperties(methode.ReturnType));
                    def.Rubrique = I.T("Methods|58");
                    lstProps.Add(def);
                    GetDefinitionsChamps(methode.ReturnType, nProfondeur - 1, lstProps, strCheminConvivial + methode.Name + ".", strCheminReel + methode.Name + ".", def);
                }
            }

            //Relations TypeID
            foreach (RelationTypeIdAttribute relation in CContexteDonnee.RelationsTypeIds)
            {
                if (relation.NomConvivialPourParent != "" && relation.IsAppliqueToType(tp))
                {
                    CDefinitionProprieteDynamiqueRelationTypeId def = new CDefinitionProprieteDynamiqueRelationTypeId(relation);
                    AddDefinition(lstProps, def /*, traducteur*/);
                }
            }

            //Données ucmulées
            if (m_bAvecReadOnly)
            {
                CTypeDonneeCumulee[] donnees = GetTypesDonneesPourType(tp);
                foreach (CTypeDonneeCumulee typeDonnee in donnees)
                {
                    int nCle = 0;
                    foreach (CCleDonneeCumulee cle in typeDonnee.Parametre.ChampsCle)
                    {
                        if (cle.TypeLie == tp)
                        {
                            CDefinitionProprieteDynamiqueDonneeCumulee def =
                                new CDefinitionProprieteDynamiqueDonneeCumulee(
                                    typeDonnee,
                                    nCle);
                            AddDefinition(lstProps, def /*, traducteur*/);
                            break;
                        }
                    }
                }
            }

            //Liens sur champs custom fils
            if (m_bAvecReadOnly)
            {
                //Liens sur champs custom
                CListeObjetsDonnees listeChamps = new CListeObjetsDonnees(ContexteDonneeCache, typeof(CChampCustom));
                listeChamps.Filtre = new CFiltreData(
                    CChampCustom.c_champTypeObjetDonnee + "=@1",
                    tp.ToString());
                foreach (CChampCustom champ in listeChamps)
                {
                    CDefinitionProprieteDynamiqueChampCustomFils def = new CDefinitionProprieteDynamiqueChampCustomFils(
                        champ);
                    if (champ.Categorie.Trim() != "")
                    {
                        def.Rubrique = champ.Categorie;
                    }
                    else
                    {
                        def.Rubrique = I.T("Complementary informations|59");
                    }
                    AddDefinition(lstProps, def /*, traducteur*/);
                }
            }

            //Liens par CListeEntite
            if (m_bAvecReadOnly)
            {
                CListeObjetsDonnees listeEntites = new CListeObjetsDonnees(ContexteDonneeCache, typeof(CListeEntites));
                listeEntites.Filtre = new CFiltreData(
                    CListeEntites.c_champTypeElementSourceDeRecherche + "=@1",
                    tp.ToString());
                foreach (CListeEntites liste in listeEntites)
                {
                    CDefinitionProprieteDynamiqueListeEntites def = new CDefinitionProprieteDynamiqueListeEntites(liste);
                    def.Rubrique = I.T("Lists|60");
                    AddDefinition(lstProps, def /*, traducteur*/);
                }
            }
        }
Пример #4
0
        //----------------------------------------------------------------------------------
        public virtual CResultAErreur InsertDataInDataSet(
            IEnumerable list,
            DataSet ds,
            ITableExport tableParente,
            int[] nValeursCle,
            RelationAttribute relationToObjetParent,
            IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablePourFiltres,
            CCacheValeursProprietes cacheValeurs,
            ITableExport tableFilleANePasCharger,
            bool bAvecOptimisation,
            CConteneurIndicateurProgression indicateur)
        {
            CResultAErreur result = CResultAErreur.True;

            if (NePasCalculer)
            {
                return(result);
            }
            if (tableParente != null && nValeursCle.Length == 0)
            {
                return(result);
            }
            DataTable table = ds.Tables[NomTable];

            if (table == null)
            {
                result.EmpileErreur(I.T("Table @1 doesn't exist|116", NomTable));
                return(result);
            }
            indicateur.SetInfo(I.T("Table @1|115", NomTable));
            if (nValeursCle.Length > 1 &&
                relationToObjetParent == null)
            {
                result.EmpileErreur(I.T("Error: Multiple child table loading without knowing the relation indicating how the parental link is established|117"));
                return(result);
            }



            DataColumn colFilleDeContrainte   = null;
            DataTable  tableFilleDeContrainte = null;

            if (tableParente != null)
            {
                if (ChampOrigine.TypeDonnee.IsArrayOfTypeNatif || !bAvecOptimisation ||
                    ChampOrigine is CDefinitionProprieteDynamiqueThis)
                {
                    //On est dans une relation fille
                    foreach (Constraint constraint in table.Constraints)
                    {
                        if (constraint is ForeignKeyConstraint)
                        {
                            ForeignKeyConstraint fkConst = (ForeignKeyConstraint)constraint;
                            if (fkConst.RelatedTable.TableName == tableParente.NomTable)
                            {
                                colFilleDeContrainte = fkConst.Columns[0];
                                break;
                            }
                        }
                    }
                    tableFilleDeContrainte = table;
                }
                else
                {
                    //On est dans une relation parente
                    DataTable tblP = ds.Tables[tableParente.NomTable];
                    foreach (Constraint contraint in tblP.Constraints)
                    {
                        if (contraint is ForeignKeyConstraint)
                        {
                            ForeignKeyConstraint fk = (ForeignKeyConstraint)contraint;
                            if (fk.RelatedTable.TableName == table.TableName)
                            {
                                colFilleDeContrainte   = fk.Columns[0];
                                tableFilleDeContrainte = tblP;
                                break;
                            }
                        }
                    }
                }
            }

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


            //Désactive les ids auto sur les objetDonneeAIdNumerique.
            //Car on utilise alors les valeurs de clé des éléments
            bool bUtiliserIdObjets = false;

            if (bAvecOptimisation && (ChampOrigine == null || ChampOrigine.NomPropriete.IndexOf('.') < 0 || !ChampOrigine.TypeDonnee.IsArrayOfTypeNatif))
            {
                if (list is CListeObjetsDonnees && (tableParente == null || colFilleDeContrainte == null))
                {
                    if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(((CListeObjetsDonnees)list).TypeObjets))
                    {
                        table.PrimaryKey[0].AutoIncrement = false;
                        bUtiliserIdObjets = true;
                    }
                }
                if (list is ArrayList)
                {
                    ArrayList arrL = (ArrayList)list;
                    if (arrL.Count > 0 &&
                        typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(arrL[0].GetType()))
                    {
                        table.PrimaryKey[0].AutoIncrement = false;
                        bUtiliserIdObjets = true;
                    }
                }
            }

            if (FiltreAAppliquer != null)
            {
                CListeObjetsDonnees listeObjetsDonnee = list as CListeObjetsDonnees;
                if (listeObjetsDonnee == null)//Tente de convertir en liste d'objets
                {
                    //Récupère le contexte de données
                    CContexteDonnee ctx = null;
                    foreach (object obj in list)
                    {
                        IObjetAContexteDonnee objACtx = obj as IObjetAContexteDonnee;
                        if (objACtx != null)
                        {
                            ctx = objACtx.ContexteDonnee;
                            break;
                        }
                    }
                    listeObjetsDonnee = CListeObjetsDonnees.CreateListFrom(ctx, list);
                }
                if (listeObjetsDonnee != null)
                {
                    list   = listeObjetsDonnee;
                    result = GetFiltreDataAAppliquer(elementAVariablePourFiltres);
                    if (!result)
                    {
                        result.EmpileErreur(I.T("Error in the filter of the table @1|119", NomTable));
                        return(result);
                    }
                    try
                    {
                        if (result.Data != null)
                        {
                            listeObjetsDonnee.Filtre = CFiltreData.GetAndFiltre(listeObjetsDonnee.Filtre, (CFiltreData)result.Data);
                        }
                    }
                    catch (Exception e)
                    {
                        result.EmpileErreur(new CErreurException(e));
                        result.EmpileErreur(I.T("Error during combination of table @1 filter|120", NomTable));
                        return(result);
                    }
                }
            }

            //Table fille->
            //si relation : Attribut relation (parente) représentant le lien entre la relation fille et cette tablle
            //Si donnée cumulée : true
            Hashtable tableTablesFillesToDependanceDirecte = new Hashtable();

            //Table parente->Champ fille contenant l'id
            Hashtable tableParentsCharges = new Hashtable();

            #region Optimisations des CListeObjetsDonnees


            if (bAvecOptimisation && list is CListeObjetsDonnees)
            {
                CListeObjetsDonnees listeObjets = (CListeObjetsDonnees)list;

                if (bUtiliserIdObjets)
                {
                    #region Identifie les tables filles qui peuvent être remplies en une seule requête.
                    //Identifie les sous tables qui peuvent être chargées en une seule fois :
                    //Il s'agit des sous tables liée directement à une propriété par
                    //des relations (attribut RelationFille ou Relation).
                    foreach (ITableExport tableFille in TablesFilles)
                    {
                        Type tpAnalyse = listeObjets.TypeObjets;
                        if (tableFille != tableFilleANePasCharger && (tableFille is C2iTableExportATableFille || tableFille is C2iTableExportCumulee))
                        {
                            if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueDonneeCumulee)
                            {
                                tableTablesFillesToDependanceDirecte[tableFille] = true;
                            }
                            else if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueRelationTypeId)
                            {
                                tableTablesFillesToDependanceDirecte[tableFille] = true;
                            }
                            else if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueThis)
                            {
                                tableTablesFillesToDependanceDirecte[tableFille] = true;
                            }
                            else if (tableFille.ChampOrigine != null)
                            {
                                string strPropOrigine = tableFille.ChampOrigine.NomProprieteSansCleTypeChamp;
                                if (strPropOrigine.IndexOf('.') < 0)
                                {
                                    //Seules les propriétés directes sont optimisées (pour le moment et peut être que ça suffit)
                                    PropertyInfo info = tpAnalyse.GetProperty(strPropOrigine);
                                    if (info != null)
                                    {
                                        object[] attribs = info.GetCustomAttributes(typeof(RelationFilleAttribute), true);
                                        if (attribs.Length > 0)
                                        {
                                            RelationFilleAttribute attrFille = (RelationFilleAttribute)attribs[0];
                                            tpAnalyse = attrFille.TypeFille;
                                            if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpAnalyse))
                                            {
                                                info = tpAnalyse.GetProperty(attrFille.ProprieteFille);
                                                if (info != null)
                                                {
                                                    attribs = info.GetCustomAttributes(typeof(RelationAttribute), true);
                                                    if (attribs.Length > 0)
                                                    {
                                                        RelationAttribute attrParent = (RelationAttribute)attribs[0];
                                                        if (attrParent.ChampsFils.Length == 1)
                                                        {
                                                            tableTablesFillesToDependanceDirecte[tableFille] = attrParent;
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }

                    #endregion

                    #region Charges les tables parentes qui peuvent être chargées
                    if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(listeObjets.TypeObjets))
                    {
                        string strNomTableFille = listeObjets.NomTable;
                        foreach (ITableExport tableParenteAOptimiser in TablesFilles)
                        {
                            if (tableParenteAOptimiser != tableFilleANePasCharger && tableParenteAOptimiser.ChampOrigine != null && !tableParenteAOptimiser.ChampOrigine.TypeDonnee.IsArrayOfTypeNatif)
                            {
                                if (IsOptimisable(tableParenteAOptimiser, TypeSource))
                                {
                                    CListeObjetsDonnees listeMere = listeObjets.GetDependances(tableParenteAOptimiser.ChampOrigine.NomProprieteSansCleTypeChamp);
                                    if (listeMere != null)
                                    {
                                        result = tableParenteAOptimiser.InsertDataInDataSet(
                                            listeMere,
                                            ds,
                                            null,
                                            0,
                                            elementAVariablePourFiltres,
                                            cacheValeurs,
                                            this,
                                            true,
                                            indicateur);
                                        if (!result)
                                        {
                                            return(result);
                                        }
                                        //Trouve le champ fille de lien
                                        foreach (Constraint contrainte in table.Constraints)
                                        {
                                            if (contrainte is ForeignKeyConstraint)
                                            {
                                                ForeignKeyConstraint fk = (ForeignKeyConstraint)contrainte;
                                                if (fk.RelatedTable.TableName == tableParenteAOptimiser.NomTable)
                                                {
                                                    tableParentsCharges[tableParenteAOptimiser] = fk.Columns[0].ColumnName;
                                                    break;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    #endregion
                }

                #region Identification des dépendances
                if (m_strDependancesToOptim == null)
                {
                    Hashtable tableDependances = new Hashtable();
                    AddProprietesOrigineDesChampsToTable(tableDependances, "", listeObjets.ContexteDonnee);
                    foreach (ITableExport tableFille in TablesFilles)
                    {
                        if (tableFille != tableFilleANePasCharger &&
                            !tableTablesFillesToDependanceDirecte.Contains(tableFille) &&
                            !tableParentsCharges.Contains(tableFille))
                        {
                            string strChemin = "";
                            if (ChampOrigine != null)
                            {
                                strChemin = ChampOrigine.NomPropriete;
                            }
                            if (tableFille.FiltreAAppliquer == null)
                            {
                                tableFille.AddProprietesOrigineDesChampsToTable(tableDependances, strChemin, listeObjets.ContexteDonnee);
                            }
                        }
                    }
                    m_strDependancesToOptim = new string[tableDependances.Count];
                    int nDep = 0;
                    foreach (string strOrigine in tableDependances.Keys)
                    {
                        m_strDependancesToOptim[nDep++] = strOrigine;
                    }
                }
                #endregion
            }


            #endregion

            indicateur.SetInfo(I.T("Table @1|115", NomTable));


            CFiltreData filtreDeBase = null;
            if (list is CListeObjetsDonnees)
            {
                filtreDeBase = ((CListeObjetsDonnees)list).Filtre;
            }

            ArrayList listeIds      = new ArrayList();
            string    strColonneCle = table.PrimaryKey[0].ColumnName;

            indicateur.SetBornesSegment(0, nValeursCle.Length);
            indicateur.SetValue(0);

            //Lecture par paquets de 1000 clés
            for (int n = 0; n < nValeursCle.Length; n += c_nNbLectureParLotFils)
            {
                if (bAvecOptimisation && (list is CListeObjetsDonnees) && relationToObjetParent != null)
                {
                    CListeObjetsDonnees listeObjets = (CListeObjetsDonnees)list;
                    StringBuilder       blCles      = new StringBuilder();
                    char cSepIn = ',';
                    if (filtreDeBase is CFiltreDataAvance)
                    {
                        cSepIn = ';';
                    }
                    for (int nCle = n; nCle < Math.Min(n + c_nNbLectureParLotFils, nValeursCle.Length); nCle++)
                    {
                        blCles.Append(nValeursCle[nCle]);
                        blCles.Append(cSepIn);
                    }
                    if (blCles.Length > 0)
                    {
                        blCles.Remove(blCles.Length - 1, 1);
                        string strCles = blCles.ToString();
                        if (filtreDeBase is CFiltreDataAvance)
                        {
                            listeObjets.Filtre = CFiltreData.GetAndFiltre(
                                filtreDeBase, new CFiltreDataAvance(
                                    listeObjets.NomTable,
                                    relationToObjetParent.ChampsFils[0] + " in {" + strCles + "}"));
                        }
                        else
                        {
                            listeObjets.Filtre = CFiltreData.GetAndFiltre(
                                filtreDeBase,
                                new CFiltreData(
                                    relationToObjetParent.ChampsFils[0] + " in (" + strCles.Replace(';', ',') + ")"));
                        }
                    }
                }
                if (indicateur.CancelRequest)
                {
                    result.EmpileErreur(I.T("Execution cancelled by the user|118"));
                    return(result);
                }
                if (list is CListeObjetsDonnees && m_strDependancesToOptim != null && m_strDependancesToOptim.Length > 0)
                {
                    ((CListeObjetsDonnees)list).ReadDependances(m_strDependancesToOptim);
                }
                int nCountTotal = 1;
                if (list is IList)
                {
                    nCountTotal = ((IList)list).Count;
                }
                else if (list is Array)
                {
                    nCountTotal = ((Array)list).Length;
                }
                indicateur.PushSegment(n, Math.Min(n + c_nNbLectureParLotFils, nValeursCle.Length));

                int nNbElements = 0;
                indicateur.SetBornesSegment(0, nCountTotal);
                int nFrequence = Math.Min(nCountTotal / 20, 500) + 1;

                CSessionClient   session  = CSessionClient.GetSessionUnique();
                IInfoUtilisateur infoUser = session != null?session.GetInfoUtilisateur() : null;


                ///AJOUT DES LIGNES DANS LA TABLE
                foreach (object obj in list)
                {
                    CRestrictionUtilisateurSurType restriction = null;
                    if (infoUser != null && obj != null)
                    {
                        restriction = infoUser.GetRestrictionsSur(obj.GetType(), obj is IObjetAContexteDonnee?((IObjetAContexteDonnee)obj).ContexteDonnee.IdVersionDeTravail:null);
                    }

                    nNbElements++;
                    if (nNbElements % nFrequence == 0)
                    {
                        indicateur.SetValue(nNbElements);
                        if (indicateur.CancelRequest)
                        {
                            result.EmpileErreur(I.T("Execution cancelled by the user|118"));
                            return(result);
                        }
                    }
                    bool bShouldImporte = true;

                    DataRow row = null;

                    if (bUtiliserIdObjets)
                    {
                        row            = table.Rows.Find(((CObjetDonneeAIdNumerique)obj).Id);
                        bShouldImporte = row == null;
                    }
                    if (bShouldImporte)
                    {
                        row = table.NewRow();
                        if (bUtiliserIdObjets)
                        {
                            int nId = ((CObjetDonneeAIdNumerique)obj).Id;
                            row[strColonneCle] = nId;
                            listeIds.Add(nId);
                        }

                        //Ajoute les valeurs de champs propres à cette table
                        result = InsereValeursChamps(obj, row, cacheValeurs, restriction);

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

                        if (colFilleDeContrainte != null && nValeursCle.Length > 0)
                        {
                            DataRow rowFille = row;
                            if (tableFilleDeContrainte == table)
                            {
                                if (relationToObjetParent == null)
                                {
                                    rowFille[colFilleDeContrainte] = nValeursCle[0];
                                }
                                else
                                {
                                    rowFille[colFilleDeContrainte] = ((CObjetDonnee)obj).Row[relationToObjetParent.ChampsFils[0]];
                                }
                            }
                        }
                        table.Rows.Add(row);
                    }
                    //Dans tous les cas, met à jour la table dépendante si besoin est !
                    if (colFilleDeContrainte != null && nValeursCle.Length > 0)
                    {
                        DataRow rowFille = row;
                        if (tableFilleDeContrainte != table)
                        {
                            rowFille = tableFilleDeContrainte.Rows.Find(nValeursCle[0]);
                            rowFille[colFilleDeContrainte] = row[strColonneCle];
                        }
                    }
                    if (bShouldImporte)
                    {
                        //AJout des données des sous tables non optimisées
                        foreach (ITableExport tbl in TablesFilles)
                        {
                            if (tbl.ChampOrigine != null && !tableTablesFillesToDependanceDirecte.Contains(tbl) && tbl != tableFilleANePasCharger)
                            {
                                bool bChildIsOptimisable = IsOptimisable(tbl, TypeSource);
                                //Impossible de lire en direct
                                object objet = null;
                                if (tbl.ChampOrigine is CDefinitionProprieteDynamiqueThis)
                                {
                                    objet = obj;
                                }
                                else
                                {
                                    objet = CInterpreteurProprieteDynamique.GetValue(obj, tbl.ChampOrigine, cacheValeurs).Data;
                                }
                                string strNomCol = (string)tableParentsCharges[tbl];
                                if (strNomCol != null)
                                {
                                    if (objet != null)
                                    {
                                        row[strNomCol] = ((CObjetDonneeAIdNumerique)objet).Id;
                                    }
                                    else
                                    {
                                        row[strNomCol] = DBNull.Value;
                                    }
                                }
                                else
                                {
                                    indicateur.PushSegment(nNbElements, nNbElements + 1);
                                    if (objet != null)
                                    {
                                        IEnumerable tempList;
                                        if (objet is IEnumerable)
                                        {
                                            tempList = (IEnumerable)objet;
                                        }
                                        else
                                        {
                                            ArrayList listeObjetUnique = new ArrayList();
                                            listeObjetUnique.Add(objet);
                                            tempList = listeObjetUnique;
                                        }
                                        if (tempList != null)
                                        {
                                            result = tbl.InsertDataInDataSet(
                                                tempList,
                                                ds,
                                                this,
                                                (int)row[table.PrimaryKey[0]],
                                                elementAVariablePourFiltres,
                                                cacheValeurs,
                                                this,
                                                bChildIsOptimisable,
                                                indicateur);
                                            if (!result)
                                            {
                                                return(result);
                                            }
                                        }
                                    }
                                    indicateur.PopSegment();
                                }
                            }
                        }
                        //vide le cache après chaque objet de la table principale
                        if (tableParente == null)
                        {
                            cacheValeurs.ResetCache();
                        }
                    }
                }
                indicateur.PopSegment();
            }
            indicateur.SetValue(nValeursCle.Length);

            ///Chargement des relations optimisées
            int nTable = 0;
            foreach (DictionaryEntry entry in tableTablesFillesToDependanceDirecte)
            {
                nTable++;
                ITableExport tableFille = (ITableExport)entry.Key;
                if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueDonneeCumulee)
                {
                    CDefinitionProprieteDynamiqueDonneeCumulee defCum = (CDefinitionProprieteDynamiqueDonneeCumulee)tableFille.ChampOrigine;
                    //Trouve les données cumulées correspondants aux éléments
                    CListeObjetsDonnees listeInit  = (CListeObjetsDonnees)list;
                    CTypeDonneeCumulee  typeCumule = new CTypeDonneeCumulee(listeInit.ContexteDonnee);
                    if (!typeCumule.ReadIfExists(
                            defCum.DbKeyTypeDonnee))
                    {
                        result.EmpileErreur(I.T("The cumulated data type @1 doesn't exist|122", defCum.DbKeyTypeDonnee.ToString()));
                        return(result);
                    }
                    RelationAttribute attr = typeCumule.GetRelationAttributeToType(listeInit.TypeObjets);
                    string            strChampIdOuDbKey = "";
                    if (defCum.DbKeyTypeDonnee.IsNumericalId())
                    {
                        strChampIdOuDbKey = CTypeDonneeCumulee.c_champId;
                    }
                    else
                    {
                        strChampIdOuDbKey = CObjetDonnee.c_champIdUniversel;
                    }

                    CListeObjetsDonnees listeFils = new CListeObjetsDonnees(
                        listeInit.ContexteDonnee,
                        typeof(CDonneeCumulee),
                        new CFiltreData(strChampIdOuDbKey + " = @1 ", defCum.DbKeyTypeDonnee.GetValeurInDb()));


                    listeFils.ModeSansTri = true;                    //Optimisation pour ne pas utiliser de dataview
                    result = tableFille.InsertDataInDataSet(
                        listeFils,
                        ds,
                        this,
                        (int[])listeIds.ToArray(typeof(int)),
                        attr,
                        elementAVariablePourFiltres,
                        cacheValeurs,
                        this,
                        true,
                        indicateur);
                    if (!result)
                    {
                        return(result);
                    }
                }
                else if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueRelationTypeId)
                {
                    CDefinitionProprieteDynamiqueRelationTypeId defTypeId = (CDefinitionProprieteDynamiqueRelationTypeId)tableFille.ChampOrigine;
                    RelationTypeIdAttribute relTpIdAttr = defTypeId.Relation;

                    //Trouve les données cumulées correspondants aux éléments
                    CListeObjetsDonnees listeInit = (CListeObjetsDonnees)list;
                    if (listeInit.Count != 0)
                    {
                        CListeObjetsDonnees listeFils = new CListeObjetsDonnees(
                            listeInit.ContexteDonnee,
                            CContexteDonnee.GetTypeForTable(relTpIdAttr.TableFille),
                            new CFiltreData(relTpIdAttr.ChampType + "=@1", listeInit.TypeObjets.ToString()));
                        listeFils.ModeSansTri = true;                        //Optimisation pour ne pas utiliser de dataview
                        RelationAttribute attrTmp = new RelationAttribute(
                            listeInit.NomTable,
                            ((CObjetDonneeAIdNumerique)listeInit[0]).GetChampId(),
                            relTpIdAttr.ChampId, false, false);
                        result = tableFille.InsertDataInDataSet(
                            listeFils,
                            ds,
                            this,
                            (int[])listeIds.ToArray(typeof(int)),
                            attrTmp,
                            elementAVariablePourFiltres,
                            cacheValeurs,
                            this,
                            true,
                            indicateur);
                        if (!result)
                        {
                            return(result);
                        }
                    }
                }
                else if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueThis)
                {
                    CListeObjetsDonnees listeInit = new CListeObjetsDonnees(
                        ((CListeObjetsDonnees)list).ContexteDonnee,
                        tableFille.ChampOrigine.TypeDonnee.TypeDotNetNatif, true);
                    listeInit.ModeSansTri = true;                    //Optimisation pour ne pas utiliser de dataview
                    string            strChampId = listeInit.ContexteDonnee.GetTableSafe(CContexteDonnee.GetNomTableForType(listeInit.TypeObjets)).PrimaryKey[0].ColumnName;
                    RelationAttribute attrTmp    = new RelationAttribute(
                        listeInit.NomTable,
                        strChampId,
                        strChampId,
                        false, false);
                    //Copie les clés dans la clé et dans la valeur de champ externe
                    result = tableFille.InsertDataInDataSet(
                        listeInit,
                        ds,
                        this,
                        (int[])listeIds.ToArray(typeof(int)),
                        attrTmp,
                        elementAVariablePourFiltres,
                        cacheValeurs,
                        this,
                        true,
                        indicateur);
                    if (!result)
                    {
                        return(result);
                    }
                }
                else if (tableFille.ChampOrigine != null)
                {
                    RelationAttribute   attr      = (RelationAttribute)entry.Value;
                    CListeObjetsDonnees listeFils = new CListeObjetsDonnees(
                        ((CListeObjetsDonnees)list).ContexteDonnee,
                        tableFille.ChampOrigine.TypeDonnee.TypeDotNetNatif, true);
                    listeFils.ModeSansTri = true;                    //Optimisation pour ne pas utiliser de dataview
                    result = tableFille.InsertDataInDataSet(
                        listeFils,
                        ds,
                        this,
                        (int[])listeIds.ToArray(typeof(int)),
                        attr,
                        elementAVariablePourFiltres,
                        cacheValeurs,
                        this,
                        true,
                        indicateur);
                    if (!result)
                    {
                        return(result);
                    }
                }
                else
                {
                    result = tableFille.InsertDataInDataSet(
                        null,
                        ds,
                        this,
                        (int[])listeIds.ToArray(typeof(int)),
                        null,
                        elementAVariablePourFiltres,
                        cacheValeurs,
                        this,
                        true,
                        indicateur);
                    if (!result)
                    {
                        return(result);
                    }
                }
            }

            return(result);
        }
Пример #5
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);
        }