//---------------------------------------
        public DataTable GetDataTableModelePourParametrage(CContexteDonnee contexte)
        {
            if (m_nIdTypeDonneeCumulee == null)
            {
                return(null);
            }
            CTypeDonneeCumulee typeDonnee = GetTypeDonneeCumulee(contexte);

            if (typeDonnee == null)
            {
                return(null);
            }
            DataTable table = new DataTable();
            CParametreDonneeCumulee parametreDonnee = typeDonnee.Parametre;

            if (parametreDonnee == null)
            {
                return(null);
            }
            foreach (CCleDonneeCumulee cle in parametreDonnee.ChampsCle)
            {
                if (cle.Champ != "")
                {
                    DataColumn col = new DataColumn(cle.Champ, typeof(string));
                    col.AllowDBNull = true;
                    table.Columns.Add(col);
                }
            }
            foreach (CParametreDonneeCumulee.CNomChampCumule champ in parametreDonnee.NomChampsDecimaux)
            {
                string strChamp = parametreDonnee.GetValueField(champ.NumeroChamp);
                if (strChamp != null && strChamp != "")
                {
                    DataColumn col = new DataColumn(champ.NomChamp, typeof(double));
                    col.AllowDBNull = true;
                    table.Columns.Add(col);
                }
            }
            foreach (CParametreDonneeCumulee.CNomChampCumule champ in parametreDonnee.NomChampsDates)
            {
                string strChamp = parametreDonnee.GetDateField(champ.NumeroChamp);
                if (strChamp != null && strChamp != "")
                {
                    DataColumn col = new DataColumn(champ.NomChamp, typeof(DateTime));
                    col.AllowDBNull = true;
                    table.Columns.Add(col);
                }
            }
            foreach (CParametreDonneeCumulee.CNomChampCumule champ in parametreDonnee.NomChampsTextes)
            {
                string strChamp = parametreDonnee.GetTextField(champ.NumeroChamp);
                if (strChamp != null && strChamp != "")
                {
                    DataColumn col = new DataColumn(champ.NomChamp, typeof(string));
                    col.AllowDBNull = true;
                    table.Columns.Add(col);
                }
            }
            return(table);
        }
        //---------------------------------------
        private void InitFiltres()
        {
            CTypeDonneeCumulee typeDonnee = GetTypeDonneeCumulee(CContexteDonneeSysteme.GetInstance());

            if (typeDonnee == null)
            {
                m_listeFiltresDeBase.Clear();
                m_listeFiltresUser.Clear();
                return;
            }
            CParametreDonneeCumulee   parametre   = typeDonnee.Parametre;
            Dictionary <string, bool> dicToDelete = new Dictionary <string, bool>();

            foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresDeBase)
            {
                dicToDelete[filtre.ChampAssocie] = true;
            }
            foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresUser)
            {
                dicToDelete[filtre.ChampAssocie] = true;
            }
            foreach (CCleDonneeCumulee cle in parametre.ChampsCle)
            {
                if (cle.TypeLie != null)
                {
                    CFiltreDonneePrecalculee filtre = m_listeFiltresDeBase.FirstOrDefault(f => f.ChampAssocie == cle.Champ);
                    if (filtre != null)
                    {
                        dicToDelete[filtre.ChampAssocie] = false;
                    }
                    if (m_listeFiltresDeBase.Count(f => f.ChampAssocie == cle.Champ) == 0)
                    {
                        CFiltreDynamique filtreTmp = new CFiltreDynamique();
                        filtreTmp.TypeElements = cle.TypeLie;
                        m_listeFiltresDeBase.Add(new CFiltreDonneePrecalculee(cle.Champ, cle.Champ, filtreTmp));
                    }
                    if (m_listeFiltresUser.Count(f => f.ChampAssocie == cle.Champ) == 0)
                    {
                        CFiltreDynamique filtreTmp = new CFiltreDynamique();
                        filtreTmp.TypeElements = cle.TypeLie;
                        m_listeFiltresUser.Add(new CFiltreDonneePrecalculee(cle.Champ, cle.Champ, filtreTmp));
                    }
                }
            }
            foreach (KeyValuePair <string, bool> kv in dicToDelete)
            {
                if (kv.Value)
                {
                    foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresUser.FindAll(f => f.ChampAssocie == kv.Key).ToArray())
                    {
                        m_listeFiltresUser.Remove(filtre);
                    }
                    foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresDeBase.FindAll(f => f.ChampAssocie == kv.Key).ToArray())
                    {
                        m_listeFiltresDeBase.Remove(filtre);
                    }
                }
            }
        }
Пример #3
0
        //--------------------------------------------------
        /// <summary>
        /// retourne la liste des champs qui ont un nom
        /// </summary>
        /// <returns></returns>
        public IEnumerable <CChampDonneeCumulee> GetChampsRenseignes()
        {
            List <CChampDonneeCumulee> lstChamps = new List <CChampDonneeCumulee>();
            CParametreDonneeCumulee    parametre = Parametre;
            int nIndex = 0;

            foreach (CCleDonneeCumulee cle in parametre.ChampsCle)
            {
                if (cle.Champ.Length > 0)
                {
                    CChampDonneeCumulee champ = new CChampDonneeCumulee();
                    champ.NumeroChamp = nIndex;
                    champ.TypeChamp   = ETypeChampDonneeCumulee.Cle;
                    lstChamps.Add(champ);
                }
                nIndex++;
            }
            nIndex = 0;
            foreach (CParametreDonneeCumulee.CNomChampCumule nom in parametre.NomChampsDecimaux)
            {
                if (nom.NomChamp.Length > 0)
                {
                    CChampDonneeCumulee champ = new CChampDonneeCumulee();
                    champ.NumeroChamp = nIndex;
                    champ.TypeChamp   = ETypeChampDonneeCumulee.Decimal;
                    lstChamps.Add(champ);
                }
                nIndex++;
            }
            nIndex = 0;
            foreach (CParametreDonneeCumulee.CNomChampCumule nom in parametre.NomChampsDates)
            {
                if (nom.NomChamp.Length > 0)
                {
                    CChampDonneeCumulee champ = new CChampDonneeCumulee();
                    champ.NumeroChamp = nIndex;
                    champ.TypeChamp   = ETypeChampDonneeCumulee.Date;
                    lstChamps.Add(champ);
                }
                nIndex++;
            }
            nIndex = 0;
            foreach (CParametreDonneeCumulee.CNomChampCumule nom in parametre.NomChampsTextes)
            {
                if (nom.NomChamp.Length > 0)
                {
                    CChampDonneeCumulee champ = new CChampDonneeCumulee();
                    champ.NumeroChamp = nIndex;
                    champ.TypeChamp   = ETypeChampDonneeCumulee.Texte;
                    lstChamps.Add(champ);
                }
                nIndex++;
            }
            return(lstChamps.AsReadOnly());
        }
Пример #4
0
        /*//-------------------------------------------------------
         * private object GetObjetPourFormuleHeader(
         *  object valeur)
         * {
         *  string strNomChamp = m_champFinal.NomChamp;
         *  if (m_para != null)
         *  {
         *      CChampFinalDeTableauCroiseDonnee champFinal = ChampFinal as CChampFinalDeTableauCroiseDonnee;
         *      if (champFinal != null && champFinal.Pivot != null)
         *      {
         *          CCleDonneeCumulee cle = parametreDonnee.GetChampCle(champFinal.Pivot.NomChamp);
         *          if (cle != null && cle.TypeLie != null)
         *          {
         *              CObjetDonneeAIdNumerique obj = Activator.CreateInstance(cle.TypeLie, new object[] { ctx }) as CObjetDonneeAIdNumerique;
         *              try
         *              {
         *                  int nVal = Int32.Parse(valeur.ToString());
         *                  if (obj.ReadIfExists(nVal))
         *                      return new CDummyForHeaderFormula(obj);
         *              }
         *              catch
         *              {
         *              }
         *          }
         *      }
         *  }
         *  CChampFinalDeTableauCroiseDonnee champDonnee = m_champFinal as CChampFinalDeTableauCroiseDonnee;
         *  if (champDonnee == null || champDonnee.Pivot == null)
         *      return null;
         *  return new CDummyForHeaderFormula(valeur);
         * }*/

        //-------------------------------------------------------
        public CDummyForDataFormula GetObjetPourFormuleData(CParametreDonneeCumulee parametreDonnee)
        {
            CChampFinalDeTableauCroiseCle champFinalCle = ChampFinal as CChampFinalDeTableauCroiseCle;

            if (champFinalCle != null)
            {
                CCleDonneeCumulee cle = parametreDonnee.GetChampCle(champFinalCle.NomChamp);
                if (cle != null && cle.TypeLie != null)
                {
                    return(new CDummyForDataFormula(cle.TypeLie));
                }
            }
            return(new CDummyForDataFormula(m_champFinal.TypeDonnee));
        }
        /// ///////////////////////////////////////////////////////////
        private static void UpdateTableDonneesCumulees()
        {
            int nIdSession = 0;

            try
            {
                nIdSession = CSessionClient.GetSessionUnique().IdSession;
            }
            catch
            { }
            if (m_recepteurNotificationModifTypeDonneeCumulee == null)
            {
                m_recepteurNotificationModifTypeDonneeCumulee = new CRecepteurNotification(nIdSession, typeof(CDonneeNotificationModificationContexteDonnee));
                m_recepteurNotificationModifTypeDonneeCumulee.OnReceiveNotification += new NotificationEventHandler(m_recepteurNotificationTypeDonneeCumulee_OnReceiveNotification);
            }
            if (m_recepteurNotificationAjoutTypeDonneeCumulee == null)
            {
                m_recepteurNotificationAjoutTypeDonneeCumulee = new CRecepteurNotification(nIdSession, typeof(CDonneeNotificationAjoutEnregistrement));
                m_recepteurNotificationAjoutTypeDonneeCumulee.OnReceiveNotification += new NotificationEventHandler(m_recepteurNotificationTypeDonneeCumulee_OnReceiveNotification);
            }
            if (m_tableTypeToDonneesCumulees != null)
            {
                m_tableTypeToDonneesCumulees.Clear();
            }
            else
            {
                m_tableTypeToDonneesCumulees = new Dictionary <Type, List <CTypeDonneeCumulee> >();
            }
            CContexteDonnee     contexte = CContexteDonneeSysteme.GetInstance();
            CListeObjetsDonnees liste    = new CListeObjetsDonnees(contexte, typeof(CTypeDonneeCumulee));

            foreach (CTypeDonneeCumulee type in liste)
            {
                CParametreDonneeCumulee parametre = type.Parametre;
                foreach (CCleDonneeCumulee cle in parametre.ChampsCle)
                {
                    if (cle.TypeLie != null)
                    {
                        List <CTypeDonneeCumulee> lst = null;
                        if (!m_tableTypeToDonneesCumulees.TryGetValue(cle.TypeLie, out lst))
                        {
                            lst = new List <CTypeDonneeCumulee>();
                            m_tableTypeToDonneesCumulees[cle.TypeLie] = lst;
                        }
                        lst.Add(type);
                    }
                }
            }
        }
Пример #6
0
        /// ///////////////////////////////////////////////////////////
        private static void UpdateTableDonneesCumulees()
        {
            int nIdSession = 0;

            try
            {
                nIdSession = CSessionClient.GetSessionUnique().IdSession;
            }
            catch
            {}
            if (m_recepteurNotificationModifTypeDonneeCumulee == null)
            {
                m_recepteurNotificationModifTypeDonneeCumulee = new CRecepteurNotification(nIdSession, typeof(CDonneeNotificationModificationContexteDonnee));
                m_recepteurNotificationModifTypeDonneeCumulee.OnReceiveNotification += new NotificationEventHandler(m_recepteurNotificationTypeDonneeCumulee_OnReceiveNotification);
            }
            if (m_recepteurNotificationAjoutTypeDonneeCumulee == null)
            {
                m_recepteurNotificationAjoutTypeDonneeCumulee = new CRecepteurNotification(nIdSession, typeof(CDonneeNotificationAjoutEnregistrement));
                m_recepteurNotificationAjoutTypeDonneeCumulee.OnReceiveNotification += new NotificationEventHandler(m_recepteurNotificationTypeDonneeCumulee_OnReceiveNotification);
            }
            if (m_tableTypeToDonneesCumulees != null)
            {
                m_tableTypeToDonneesCumulees.Clear();
            }
            else
            {
                m_tableTypeToDonneesCumulees = new Hashtable();
            }
            CListeObjetsDonnees liste = new CListeObjetsDonnees(ContexteDonneeCache, typeof(CTypeDonneeCumulee));

            foreach (CTypeDonneeCumulee type in liste)
            {
                CParametreDonneeCumulee parametre = type.Parametre;
                foreach (CCleDonneeCumulee cle in parametre.ChampsCle)
                {
                    if (cle.TypeLie != null)
                    {
                        ArrayList lst = (ArrayList)m_tableTypeToDonneesCumulees[cle.TypeLie];
                        if (lst == null)
                        {
                            lst = new ArrayList();
                            m_tableTypeToDonneesCumulees[cle.TypeLie] = lst;
                        }
                        lst.Add(type);
                    }
                }
            }
        }
 /// ////////////////////////////////////////
 private void CreateTableConversionNoms()
 {
     m_tableConversionNoms = new Hashtable();
     using (CContexteDonnee contexte = new CContexteDonnee(sc2i.multitiers.client.CSessionClient.GetSessionUnique().IdSession, true, false))
     {
         CTypeDonneeCumulee type = new CTypeDonneeCumulee(contexte);
         if (type.ReadIfExists(m_dbKeyTypeDonneeCumulee))
         {
             CParametreDonneeCumulee parametre = type.Parametre;
             foreach (CParametreDonneeCumulee.CNomChampCumule cle in parametre.Cles)
             {
                 if (cle.NomChamp != "")
                 {
                     m_tableConversionNoms[I.T("Key|45") + cle.NumeroChamp.ToString()] = cle.NomChamp;
                 }
             }
             foreach (CParametreDonneeCumulee.CNomChampCumule valeur in parametre.NomChampsDecimaux)
             {
                 if (valeur.NomChamp != "")
                 {
                     m_tableConversionNoms[I.T("Value|40") + valeur.NumeroChamp.ToString()] = valeur.NomChamp;
                 }
             }
             foreach (CParametreDonneeCumulee.CNomChampCumule valeur in parametre.NomChampsDates)
             {
                 if (valeur.NomChamp != "")
                 {
                     m_tableConversionNoms[I.T("Date|245") + valeur.NumeroChamp.ToString()] = valeur.NomChamp;
                 }
             }
             foreach (CParametreDonneeCumulee.CNomChampCumule valeur in parametre.NomChampsTextes)
             {
                 if (valeur.NomChamp != "")
                 {
                     m_tableConversionNoms[I.T("Text|246") + valeur.NumeroChamp.ToString()] = valeur.NomChamp;
                 }
             }
         }
     }
 }
        /// <summary>
        /// Prépare le paramètre de visu pour afficher les données demandées
        /// fait les chargements à faire, et tout et tout
        /// </summary>
        /// <param name="table"></param>
        public CResultAErreur PrepareAffichageDonnees(
            DataTable table,
            CContexteDonnee contexte)
        {
            CResultAErreur     result     = CResultAErreur.True;
            CTypeDonneeCumulee typeDonnee = GetTypeDonneeCumulee(contexte);

            if (typeDonnee == null)
            {
                result.EmpileErreur(I.T("Can not find Cumulated data type|20041"));
            }
            CParametreDonneeCumulee parametreDonnee = typeDonnee.Parametre;

            foreach (CParametreVisuChampTableauCroise paramVisu in ParametresChamps)
            {
                result = paramVisu.PrepareAffichageDonnees(table, contexte, parametreDonnee, this);
                if (!result)
                {
                    return(result);
                }
            }
            return(result);
        }
Пример #9
0
        /// /////////////////////////////////////////////////////////////
        public CListeObjetsDonnees GetDonneesCumuleesForObjet(CObjetDonneeAIdNumerique objet)
        {
            //Trouve le champ du paramètre qui est lié au type de l'objet lié
            CParametreDonneeCumulee parametre = Parametre;
            int    nCle        = 0;
            string strChampCle = "";

            foreach (CCleDonneeCumulee cle in parametre.ChampsCle)
            {
                if (cle.TypeLie != null && cle.TypeLie == objet.GetType())
                {
                    strChampCle = CDonneeCumulee.GetNomChampCle(nCle);
                    break;
                }
                else
                {
                    nCle++;
                }
            }
            CListeObjetsDonnees listeVide = new CListeObjetsDonnees(objet.ContexteDonnee, typeof(CDonneeCumulee));

            listeVide.Filtre = new CFiltreDataImpossible();
            if (strChampCle == "")
            {
                return(listeVide);
            }

            CFiltreData filtre = new CFiltreData(
                CTypeDonneeCumulee.c_champId + "=@1 and " +
                strChampCle + "=@2",
                this.Id,
                objet.Id.ToString());
            CListeObjetsDonnees liste = new CListeObjetsDonnees(objet.ContexteDonnee, typeof(CDonneeCumulee));

            liste.Filtre = filtre;
            return(liste);
        }
Пример #10
0
        //-------------------------------------------------------
        public CDummyForHeaderFormula GetObjetPourFormuleHeader(CParametreDonneeCumulee parametreDonnee)
        {
            string strNomChamp = m_champFinal.NomChamp;
            //regarde si c'est un champ clé

            CChampFinalDeTableauCroiseDonnee champDonnee = m_champFinal as CChampFinalDeTableauCroiseDonnee;

            if (champDonnee == null || champDonnee.Pivot == null)
            {
                return(null);
            }
            if (parametreDonnee != null)
            {
                CCleDonneeCumulee cle = parametreDonnee.GetChampCle(champDonnee.Pivot.NomChamp);
                if (cle != null && cle.TypeLie != null)
                {
                    if (cle.TypeLie != null)
                    {
                        return(new CDummyForHeaderFormula(cle.TypeLie));
                    }
                }
            }
            return(new CDummyForHeaderFormula(""));
        }
        /// //////////////////////////////////////////
        public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] listeParametres)
        {
            CResultAErreur result = CResultAErreur.True;

            try
            {
                CContexteDonnee contexteDonnee = (CContexteDonnee)ctx.GetObjetAttache(typeof(CContexteDonnee));
                if (contexteDonnee == null)
                {
                    if (ctx.ObjetSource != null && ctx.ObjetSource is IObjetAContexteDonnee)
                    {
                        contexteDonnee = ((IObjetAContexteDonnee)ctx.ObjetSource).ContexteDonnee;
                    }
                    else
                    {
                        contexteDonnee = new CContexteDonnee(CSessionClient.GetSessionUnique().IdSession, true, false);
                    }
                    ctx.AttacheObjet(typeof(CContexteDonnee), contexteDonnee);
                }

                /*//Cherche un objet donnée dans le contexte d'évaluation pour pouvoir
                 * //avoir un contexte de donnee;
                 * if ( !(ctx.ObjetSource is CObjetDonnee) )
                 * {
                 *  result.EmpileErreur("Impossible de récupérer une donnée de production si la source de la formule n'est pas un objet donnee");
                 *  return result;
                 * }
                 * CContexteDonnee contexte = ((CObjetDonnee)ctx.ObjetSource).ContexteDonnee;*/
                bool bHasNoReadInDb           = listeParametres[0] is bool;
                bool bNePasLireEnBase         = bHasNoReadInDb ? (bool)listeParametres[0] : false;
                int  nStartParam              = bHasNoReadInDb ? 1 : 0;
                CTypeDonneeCumulee typeDonnee = new CTypeDonneeCumulee(contexteDonnee);
                if (!typeDonnee.ReadIfExists(new CFiltreData(CTypeDonneeCumulee.c_champCode + "=@1",
                                                             listeParametres[0 + nStartParam].ToString())))
                {
                    result.EmpileErreur(I.T("The cumulated data type @1 does not exist|218", listeParametres[0 + nStartParam].ToString()));
                    return(result);
                }
                CListeObjetsDonnees liste  = new CListeObjetsDonnees(contexteDonnee, typeof(CDonneeCumulee));
                CFiltreData         filtre = new CFiltreData(
                    CTypeDonneeCumulee.c_champId + "=@1", typeDonnee.Id);
                //Indice de la clé
                int nCle = 0;
                CParametreDonneeCumulee parametre = typeDonnee.Parametre;
                for (int nParam = nStartParam + 2; nParam < listeParametres.Length; nParam++)
                {
                    if (listeParametres[nParam] != null)
                    {
                        CCleDonneeCumulee cle = parametre.GetChampCle(nCle);
                        while ((cle == null || cle.Champ == "") && nCle < CParametreDonneeCumulee.c_nbChampsCle)
                        {
                            nCle++;
                            cle = parametre.GetChampCle(nCle);
                        }
                        if (nCle > CParametreDonneeCumulee.c_nbChampsCle)
                        {
                            break;
                        }
                        else
                        {
                            if (cle.Champ != "")
                            {
                                filtre.Filtre += " and " + CDonneeCumulee.c_baseChampCle + nCle.ToString() + "=@" +
                                                 (filtre.Parametres.Count + 1).ToString();
                                filtre.Parametres.Add(listeParametres[nParam].ToString());
                            }
                            nCle++;
                        }
                    }
                }
                liste.Filtre = filtre;
                liste.InterditLectureInDB = bNePasLireEnBase;
                if (liste.Count > 0)
                {
                    CDonneeCumulee donnee = (CDonneeCumulee)liste[0];
                    int            nParam = Convert.ToInt32(listeParametres[nStartParam + 1]);
                    if (nParam < 0 || nParam > CParametreDonneeCumulee.c_nbChampsValeur)
                    {
                        result.EmpileErreur(I.T("The cumulated data has no value @1|219", nParam.ToString()));
                        return(result);
                    }
                    result.Data = (double)donnee.Row[CDonneeCumulee.c_baseChampValeur + nParam.ToString()];
                }
                else
                {
                    result.Data = (double)0;
                }
            }
            catch (Exception e)
            {
                result.EmpileErreur(new CErreurException(e));
                return(result);
            }
            return(result);
        }
Пример #12
0
        /// <summary>
        /// récupère un objet pour formule liée à la cellule
        ///
        /// </summary>
        /// <param name="paramVisu"></param>
        /// <param name="row">Ligne contenant les données (peut être nul en design)</param>
        /// <param name="nCol">Numéro de colonne où se trouve la donnée (peut être null en design)</param>
        /// <returns></returns>
        public CElementAVariablesDynamiques GetObjetPourFormuleCellule
        (
            CParametreVisuDonneePrecalculee paramVisu,
            DataRow row,
            int?nCol)
        {
            CElementAVariablesDynamiques eltAVariables = new CElementAVariablesDynamiques();
            CTypeDonneeCumulee           typeDonnee    = paramVisu.GetTypeDonneeCumulee(CContexteDonneeSysteme.GetInstance());

            if (typeDonnee == null)
            {
                return(null);
            }
            CParametreDonneeCumulee parametreDonnee = typeDonnee.Parametre;

            //Ajoute les clés
            CChampFinalDeTableauCroise[] champsFinaux = paramVisu.TableauCroise.ChampsFinaux;
            int nIdVariable = 0;

            foreach (CChampFinalDeTableauCroise champFinal in champsFinaux)
            {
                CChampFinalDeTableauCroiseCle champCle = champFinal as CChampFinalDeTableauCroiseCle;
                if (champCle != null)
                {
                    CCleDonneeCumulee cle = parametreDonnee.GetChampCle(champCle.NomChamp);
                    if (cle != null)
                    {
                        CVariableDynamiqueSysteme variable = new CVariableDynamiqueSysteme(eltAVariables);
                        variable.Nom        = champCle.NomChamp;
                        variable.IdVariable = nIdVariable.ToString();
                        nIdVariable++;
                        if (cle.TypeLie != null)
                        {
                            variable.SetTypeDonnee(new CTypeResultatExpression(cle.TypeLie, false));
                        }
                        else
                        {
                            variable.SetTypeDonnee(new CTypeResultatExpression(typeof(int), false));
                        }
                        eltAVariables.AddVariable(variable);
                        if (row != null && row.Table.Columns.Contains(champCle.NomChamp))
                        {
                            object val = row[champCle.NomChamp];;
                            if (cle.TypeLie != null)
                            {
                                try
                                {
                                    if (val != DBNull.Value)
                                    {
                                        val = paramVisu.GetFromCache(cle.TypeLie, Int32.Parse((val.ToString())));
                                    }
                                }
                                catch { }
                            }
                            else
                            if (val != DBNull.Value)
                            {
                                val = val.ToString();
                            }
                            //TESTDBKEYOK (SC)
                            eltAVariables.SetValeurChamp(variable.IdVariable, val);
                        }
                    }
                }
            }
            //Ajoute la valeur de colonne pivot (s'il y a lieu )
            CChampFinalDeTableauCroiseDonnee champAvecPivot = ChampFinal as CChampFinalDeTableauCroiseDonnee;

            if (champAvecPivot != null && champAvecPivot.Pivot != null)
            {
                CCleDonneeCumulee cle = parametreDonnee.GetChampCle(champAvecPivot.Pivot.NomChamp);
                if (cle != null)
                {
                    CVariableDynamiqueSysteme variable = new CVariableDynamiqueSysteme(eltAVariables);
                    variable.Nom        = champAvecPivot.Pivot.NomChamp;
                    variable.IdVariable = nIdVariable.ToString();
                    nIdVariable++;
                    if (cle.TypeLie != null)
                    {
                        variable.SetTypeDonnee(new CTypeResultatExpression(cle.TypeLie, false));
                    }
                    else
                    {
                        variable.SetTypeDonnee(new CTypeResultatExpression(typeof(string), false));
                    }
                    eltAVariables.AddVariable(variable);
                    if (row != null && nCol != null)
                    {
                        DataColumn col = row.Table.Columns[nCol.Value];
                        CChampFinalDetableauCroiseDonneeAvecValeur cv = col.ExtendedProperties[CTableauCroise.c_ExtendedPropertyToColumnKey] as CChampFinalDetableauCroiseDonneeAvecValeur;
                        if (cv != null)
                        {
                            object val = cv.ValeurPivot;
                            if (cle.TypeLie != null)
                            {
                                try
                                {
                                    if (val != null)
                                    {
                                        val = paramVisu.GetFromCache(cle.TypeLie, Int32.Parse(val.ToString()));
                                    }
                                }
                                catch
                                {
                                }
                            }
                            else
                            if (val != null)
                            {
                                val = val.ToString();
                            }
                            eltAVariables.SetValeurChamp(variable.IdVariable, val);
                        }
                    }
                }
            }

            //Ajoute la valeur de la colonne
            CVariableDynamiqueSysteme variableValue = new CVariableDynamiqueSysteme(eltAVariables);

            variableValue.Nom        = c_nomVariableValue;
            variableValue.IdVariable = nIdVariable.ToString();
            nIdVariable++;
            variableValue.SetTypeDonnee(new CTypeResultatExpression(typeof(double), false));
            eltAVariables.AddVariable(variableValue);
            try
            {
                eltAVariables.SetValeurChamp(variableValue.IdVariable, Convert.ToDouble(row[nCol.Value]));
            }
            catch
            {
            }

            //Ajoute les variables de filtre
            foreach (CFiltreDonneePrecalculee filtreDonnee in paramVisu.FiltresUtilisateur)
            {
                foreach (IVariableDynamique variable in filtreDonnee.Filtre.ListeVariables)
                {
                    CVariableDeFiltreDeportee v = new CVariableDeFiltreDeportee(eltAVariables);
                    v.Nom = variable.Nom;
                    v.SetTypeDonnee(variable.TypeDonnee);
                    v.ChampAssocieAuFiltre = filtreDonnee.ChampAssocie;
                    eltAVariables.AddVariable(v);
                    eltAVariables.SetValeurChamp(v.IdVariable, filtreDonnee.Filtre.GetValeurChamp(variable.IdVariable));
                }
            }
            return(eltAVariables);
        }
Пример #13
0
        /*
         * //-------------------------------------------------------
         * private object GetObjetPourFormuleData(object valeur)
         * {
         *  CChampFinalDeTableauCroiseCle champFinalCle = ChampFinal as CChampFinalDeTableauCroiseCle;
         *  if (champFinalCle != null)
         *  {
         *      CCleDonneeCumulee cle = parametreDonnee.GetChampCle(champFinalCle.NomChamp);
         *      if (cle != null && cle.TypeLie != null)
         *      {
         *          CObjetDonnee objet = Activator.CreateInstance(cle.TypeLie, new object[] { contexte }) as CObjetDonnee;
         *          if (objet.ReadIfExists(new object[] { valeur }))
         *              valeur = objet;
         *          else
         *              valeur = null;
         *      }
         *  }
         *  return new CDummyForDataFormula(valeur);
         * }*/

        public CResultAErreur PrepareAffichageDonnees(
            System.Data.DataTable table,
            CContexteDonnee contexte,
            CParametreDonneeCumulee parametreDonnee,
            CParametreVisuDonneePrecalculee parametreVisu)
        {
            CResultAErreur result = CResultAErreur.True;

            m_dummyForData   = null;
            m_dummyForHeader = null;

            m_dummyForHeader = GetObjetPourFormuleHeader(parametreDonnee) as CDummyForHeaderFormula;
            CCleDonneeCumulee cle = null;

            #region Précharge les données nécéssaires pour les entetes de colonnes
            if (FormuleHeader != null)
            {
                //regarde si c'est un champ clé
                CChampFinalDeTableauCroiseDonnee champDonnee = m_champFinal as CChampFinalDeTableauCroiseDonnee;
                if (champDonnee != null && champDonnee.Pivot != null && parametreDonnee != null)
                {
                    cle = parametreDonnee.GetChampCle(champDonnee.Pivot.NomChamp);
                    if (cle != null && cle.TypeLie != null)
                    {
                        if (cle.TypeLie != null)
                        {
                            m_typeObjetDonneeHeader = cle.TypeLie;
                            List <int> lstCles = new List <int>();
                            //Précharge les éléments correspondants. On trouve les valeurs
                            //des éléments dans les données étendues de chaque colonne
                            StringBuilder bl = new StringBuilder();
                            foreach (DataColumn col in table.Columns)
                            {
                                CChampFinalDetableauCroiseDonneeAvecValeur champFinalDeCol = col.ExtendedProperties[CTableauCroise.c_ExtendedPropertyToColumnKey] as CChampFinalDetableauCroiseDonneeAvecValeur;
                                if (champFinalDeCol != null && champFinalDeCol.NomChamp == ChampFinal.NomChamp)
                                {
                                    bl.Append(champFinalDeCol.ValeurPivot);
                                    bl.Append(',');
                                }
                            }
                            if (bl.Length > 0)
                            {
                                bl.Remove(bl.Length - 1, 1);
                                CListeObjetsDonnees lst = new CListeObjetsDonnees(contexte, cle.TypeLie);
                                //trouve la clé
                                CObjetDonneeAIdNumerique obj = Activator.CreateInstance(cle.TypeLie, new object[] { contexte }) as CObjetDonneeAIdNumerique;
                                lst.Filtre = new CFiltreData(obj.GetChampId() + " in (" +
                                                             bl.ToString() + ")");
                                foreach (CObjetDonneeAIdNumerique objTmp in lst)
                                {
                                    parametreVisu.PutElementInCache(objTmp);
                                }
                            }
                        }
                    }
                }
            }
            #endregion

            m_dummyForData = GetObjetPourFormuleData(parametreDonnee);
            //Si le champ final correspond à une clé, précharge toutes les valeurs
            //de clé si la clé correspond à un type
            cle = parametreDonnee.GetChampCle(ChampFinal.NomChamp);
            if (cle != null && FormuleData != null && cle.TypeLie != null)
            {
                m_typeObjetDonneeData = cle.TypeLie;
                StringBuilder bl = new StringBuilder();
                if (table.Columns.Contains(ChampFinal.NomChamp))
                {
                    foreach (DataRow row in table.Rows)
                    {
                        try
                        {
                            int nId = Int32.Parse(row[ChampFinal.NomChamp].ToString());
                            bl.Append(nId);
                            bl.Append(',');
                        }
                        catch { }
                    }
                    if (bl.Length > 0)
                    {
                        bl.Remove(bl.Length - 1, 1);
                        CObjetDonneeAIdNumerique obj = Activator.CreateInstance(cle.TypeLie, new object[] { contexte }) as CObjetDonneeAIdNumerique;
                        CListeObjetsDonnees      lst = new CListeObjetsDonnees(contexte, cle.TypeLie);
                        lst.Filtre = new CFiltreData(obj.GetChampId() + " in (" + bl.ToString() + ")");
                        foreach (CObjetDonneeAIdNumerique objTmp in lst)
                        {
                            parametreVisu.PutElementInCache(objTmp);
                        }
                    }
                }
            }
            return(result);
        }
        //-----------------------------------------------------------------
        /// <summary>
        /// Le data du result contient le datatable correspondant à ce paramètre de visu
        /// </summary>
        /// <returns></returns>
        public CResultAErreur GetDataTable(CContexteDonnee contexteDonnee)
        {
            CResultAErreur     result     = CResultAErreur.True;
            CTypeDonneeCumulee typeDonnee = GetTypeDonneeCumulee(contexteDonnee);

            if (typeDonnee == null)
            {
                result.EmpileErreur(I.T("Unable to load Precalculated data type|20041"));
                return(result);
            }
            CListeObjetsDonnees lstDatas = new CListeObjetsDonnees(
                contexteDonnee,
                typeof(CDonneeCumulee),
                new CFiltreData(CTypeDonneeCumulee.c_champId + "=@1", m_nIdTypeDonneeCumulee));

            CParametreDonneeCumulee parametre = typeDonnee.Parametre;

            #region Filtrage des données
            CFiltreData filtreDonnees = null;
            int         nCle          = 0;
            foreach (CCleDonneeCumulee cle in parametre.ChampsCle)
            {
                if (cle.Champ != null && cle.Champ != "")
                {
                    CFiltreDonneePrecalculee filtreBase    = m_listeFiltresDeBase.FirstOrDefault(f => f.ChampAssocie == cle.Champ);
                    CFiltreDonneePrecalculee filtreUser    = m_listeFiltresUser.FirstOrDefault(f => f.ChampAssocie == cle.Champ);
                    CFiltreDynamique         filtreDynBase = filtreBase != null ? filtreBase.Filtre : null;
                    CFiltreDynamique         filtreDynUser = filtreUser != null ? filtreUser.Filtre : null;
                    CFiltreData filtre = null;
                    if (filtreDynUser != null && filtreDynUser.ComposantPrincipal != null)
                    {
                        result = filtreDynUser.GetFiltreData();
                        if (result)
                        {
                            filtre = result.Data as CFiltreData;
                        }
                    }
                    if (filtreDynBase != null && filtreDynBase.ComposantPrincipal != null)
                    {
                        result = filtreDynBase.GetFiltreData();
                        if (result)
                        {
                            filtre = CFiltreData.GetAndFiltre(filtre, result.Data as CFiltreData);
                        }
                    }
                    if (filtre != null && filtre.HasFiltre)
                    {
                        //Crée une liste d'objets correspondant au filtre
                        CListeObjetsDonnees lst = new CListeObjetsDonnees(contexteDonnee, cle.TypeLie);
                        lst.Filtre = filtre;
                        StringBuilder bl = new StringBuilder();
                        foreach (CObjetDonneeAIdNumerique obj in lst)
                        {
                            bl.Append(obj.Id);
                            bl.Append(',');
                        }
                        filtre = null;
                        if (bl.Length == 0)
                        {
                            filtre        = new CFiltreDataImpossible();
                            filtreDonnees = new CFiltreDataImpossible();
                        }
                        else
                        {
                            bl.Remove(bl.Length - 1, 1);
                            filtre        = new CFiltreData(CDonneeCumulee.GetNomChampCle(nCle) + " in (" + bl.ToString() + ")");
                            filtreDonnees = CFiltreData.GetAndFiltre(filtreDonnees, filtre);
                        }
                    }
                }
                nCle++;
            }
            #endregion
            if (filtreDonnees != null)
            {
                lstDatas.Filtre = filtreDonnees;
            }


            //Crée le datatable de base
            DataTable table = new DataTable();

            Dictionary <string, string> dicChampsACopier = new Dictionary <string, string>();
            nCle = 0;
            foreach (CCleDonneeCumulee cle in parametre.ChampsCle)
            {
                if (cle.Champ != "")
                {
                    DataColumn col = new DataColumn(cle.Champ, typeof(string));
                    table.Columns.Add(col);
                    dicChampsACopier[CDonneeCumulee.GetNomChampCle(nCle)] = col.ColumnName;
                }
                nCle++;
            }
            foreach (CParametreDonneeCumulee.CNomChampCumule nom in parametre.NomChampsDecimaux)
            {
                if (nom.NomChamp != "")
                {
                    DataColumn col = new DataColumn(nom.NomChamp, typeof(double));
                    table.Columns.Add(col);
                    dicChampsACopier[CDonneeCumulee.GetNomChampValeur(nom.NumeroChamp)] = nom.NomChamp;
                }
            }
            foreach (CParametreDonneeCumulee.CNomChampCumule nom in parametre.NomChampsDates)
            {
                if (nom.NomChamp != "")
                {
                    DataColumn col = new DataColumn(nom.NomChamp, typeof(DateTime));
                    table.Columns.Add(col);
                    dicChampsACopier[CDonneeCumulee.GetNomChampDate(nom.NumeroChamp)] = nom.NomChamp;
                }
            }
            foreach (CParametreDonneeCumulee.CNomChampCumule nom in parametre.NomChampsTextes)
            {
                if (nom.NomChamp != "")
                {
                    DataColumn col = new DataColumn(nom.NomChamp, typeof(string));
                    table.Columns.Add(col);
                    dicChampsACopier[CDonneeCumulee.GetNomChampTexte(nom.NumeroChamp)] = nom.NomChamp;
                }
            }

            foreach (CDonneeCumulee donnee in lstDatas)
            {
                DataRow rowSource = donnee.Row.Row;
                DataRow rowDest   = table.NewRow();
                foreach (KeyValuePair <string, string> kv in dicChampsACopier)
                {
                    rowDest[kv.Value] = rowSource[kv.Key];
                }
                table.Rows.Add(rowDest);
            }
            result = m_tableauCroise.CreateTableCroisee(table);

            if (OperationCumul != OperationsAgregation.None)
            {
                DataTable tableFinale = result.Data as DataTable;
                DataRow   row         = tableFinale.NewRow();
                bool      bHeaderFait = false;
                foreach (DataColumn col in tableFinale.Columns)
                {
                    CChampFinalDeTableauCroiseDonnee champDonnee = col.ExtendedProperties[CTableauCroise.c_ExtendedPropertyToColumnKey] as CChampFinalDeTableauCroiseDonnee;
                    if (champDonnee != null)
                    {
                        CDonneeAgregation donnee = CDonneeAgregation.GetNewDonneeForOperation(OperationCumul);
                        donnee.PrepareCalcul();
                        foreach (DataRow rowTmp in tableFinale.Rows)
                        {
                            donnee.IntegreDonnee(rowTmp[col]);
                        }
                        row[col] = donnee.GetValeurFinale();
                    }
                    else if (!bHeaderFait)
                    {
                        row[col]    = m_strLibelleTotal;
                        bHeaderFait = true;
                    }
                }
                tableFinale.Rows.Add(row);
            }
            return(result);
        }