Ejemplo n.º 1
0
        //-------------------------------------------------------------------------
        public CResultAErreur Init(CObjetDeGroupe objet)
        {
            m_objet      = objet;
            m_typeGroupe = m_objet.TypeGroupe;
            using (CGroupeStructurant tempGroupe = ((CGroupeStructurant)Activator.CreateInstance(m_typeGroupe, new object[] { m_objet.ContexteDonnee })))
            {
                m_typeRelationNecessite = tempGroupe.TypeRelationNecessaire;
                m_strNomTable           = tempGroupe.GetNomTable();
                m_strChampIdGroupe      = tempGroupe.GetChampId();
            }

            CResultAErreur result = CResultAErreur.True;

            if (!m_typeGroupe.IsSubclassOf(typeof(CGroupeStructurant)))
            {
                throw new Exception("The group type must inherit from CGroupeStructurant.|30077");
            }

            Nodes.Clear();
            //Lit tous les groupes et toutes les dépendances du groupe
            m_listeTousLesGroupes = new CListeObjetsDonnees(objet.ContexteDonnee, m_typeGroupe);
            m_listeTousLesGroupes.ReadDependances("RelationsGroupesNecessitants", "RelationsGroupesNecessaires");
            FillNodes(null, null);

            return(result);
        }
Ejemplo n.º 2
0
        //----------------------------------------------------
        private CResultAErreur AssureSessionEtContexte()
        {
            CResultAErreur resErreur = CResultAErreur.True;

            System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.Lowest;
            if (m_sessionClient == null || !m_sessionClient.IsConnected)
            {
                m_sessionClient = CSessionClient.CreateInstance();
                resErreur       = m_sessionClient.OpenSession(new CAuthentificationSessionServer(),
                                                              I.T("Alarm management|20154"),
                                                              ETypeApplicationCliente.Service);
                if (!resErreur)
                {
                    resErreur.EmpileErreur(resErreur.Erreur);
                    C2iEventLog.WriteErreur(I.T("Error while open alarm management session|20155"));
                    resErreur.EmpileErreur(I.T("Error while open alarm management session|20155"));
                    return(resErreur);
                }
            }

            if (m_contexteDonnee == null)
            {
                m_contexteDonnee = new CContexteDonnee(m_sessionClient.IdSession, true, true);
                CListeObjetsDonnees lst = new CListeObjetsDonnees(m_contexteDonnee, typeof(CTypeAlarme));
                lst.AssureLectureFaite();
                lst.ReadDependances("RelationsChampsCustomListe");
                lst = new CListeObjetsDonnees(m_contexteDonnee, typeof(CSeveriteAlarme));
                lst.AssureLectureFaite();
            }

            return(resErreur);
        }
Ejemplo n.º 3
0
        //-------------------------------------------------------------------
        //S'il n'y a pas de paramètres, lit tous les champs custom
        public static void ReadChampsCustom(CListeObjetsDonnees lstObjets, params int[] idsChamps)
        {
            if (lstObjets.Count == 0)
            {
                return;
            }
            IObjetDonneeAChamps eltAChamps = lstObjets[0] as IObjetDonneeAChamps;

            if (eltAChamps == null)
            {
                return;
            }
            if (idsChamps.Length == 0)
            {
                lstObjets.ReadDependances("RelationsChampsCustom");
                foreach (IObjetDonneeAChamps eltAChamp in lstObjets)
                {
                    SetTousChampsLus(eltAChamp);
                }
                return;
            }
            List <string> lstChamps = new List <string>();

            foreach (int nIdChamp in idsChamps)
            {
                CChampCustom champ = new CChampCustom(eltAChamps.ContexteDonnee);
                if (champ.ReadIfExists(nIdChamp))
                {
                    CDefinitionProprieteDynamiqueChampCustom def = new CDefinitionProprieteDynamiqueChampCustom(champ);
                    lstChamps.Add(def.NomPropriete);
                }
            }
            lstObjets.ReadDependances(lstChamps.ToArray());
            foreach (IObjetDonneeAChamps eltAChamp in lstObjets)
            {
                foreach (int nIdChamp in idsChamps)
                {
                    SetChampsLus(eltAChamp, nIdChamp);
                }
            }
        }
Ejemplo n.º 4
0
        public void InitFromSchema(CSchemaReseau schema)
        {
            m_dbKeySchemaReseau = schema.DbKey;
            m_schema            = schema;

            CListeObjetsDonnees lstElements = schema.ElementsDeSchema;

            lstElements.ReadDependances(
                "SchemaReseauInclu",
                "SchemaReseauContenu");

            foreach (CElementDeSchemaReseau elt in lstElements)
            {
                IElementDeSchemaReseau elementFils = elt.ElementAssocie;
                if (elementFils != null)
                {
                    CInfoElementDeSchemaSupervise fils = null;
                    if (elementFils is CSite)
                    {
                        fils = new CInfoSiteDeSchemaSupervise(this, elt, m_base, NiveauProfondeur + 1);
                    }
                    if (elementFils is CLienReseau)
                    {
                        fils = new CInfoLienDeSchemaSupervise(this, elt, m_base, NiveauProfondeur + 1);
                    }
                    if (elementFils is CElementDeSchemaReseau)
                    {
                        fils = new CInfoEquipementDeSchemaSupervise(this, elt, m_base, NiveauProfondeur + 1);
                    }
                    if (elementFils is CSchemaReseau)
                    {
                        fils = new CInfoSchemaDeSchemaSupervise(this, elt, m_base, NiveauProfondeur + 1);
                    }
                    if (elementFils is CEquipementLogique)
                    {
                        fils = new CInfoEquipementDeSchemaSupervise(this, elt, m_base, NiveauProfondeur + 1);
                    }
                    if (elementFils is CEntiteSnmp)
                    {
                        fils = new CInfoEntiteSnmpDeSchemaSupervise(this, elt, m_base, NiveauProfondeur + 1);
                    }
                    if (elementFils != null)
                    {
                        fils.InitFromElementDeSchema(elt);
                        m_listeFils.Add(fils);
                    }
                }
            }

            PrepareSupervisionEtatOperationnel(schema);
            CalculArbreOperationnel();
        }
Ejemplo n.º 5
0
        //----------------------------------------------------------------
        /// <summary>
        /// Retourne la liste des Sites du Contrat, qu'ils soient définis par Profil ou par une liste de relations "manuelle"
        /// </summary>
        /// <returns></returns>
        public IList <CSite> GetTousLesSitesDuContrat()
        {
            IList <CSite> listeSites = new List <CSite>();
            StringBuilder bl         = new StringBuilder();

            if (this.TypeContrat != null && this.TypeContrat.GestionSitesManuel)
            {
                // Ajout des Sites par relation
                RelationsSites.ReadDependances("Site");
                foreach (CContrat_Site rel in RelationsSites)
                {
                    listeSites.Add(rel.Site);
                    bl.Append(rel.Site.Id);
                    bl.Append(",");
                }
                if (bl.Length > 0)
                {
                    bl.Remove(bl.Length - 1, 1);
                }
                CFiltreData filtre;
                if (bl.Length > 0)
                {
                    filtre = new CFiltreData(CSite.c_champId + " in (" + bl.ToString() + ")");
                    CListeObjetDonneeGenerique <CSite> lst = new CListeObjetDonneeGenerique <CSite>(ContexteDonnee, filtre);
                    return(lst);
                }
                else
                {
                    return(new List <CSite>());
                }
            }
            else
            {
                CProfilElement profil = ProfilSite;
                if (profil != null)
                {
                    CListeObjetsDonnees liste = profil.GetElementListForSource(this);
                    foreach (CSite site in liste)
                    {
                        listeSites.Add(site);
                    }
                }
                return(listeSites);
            }
        }
Ejemplo n.º 6
0
        //--------------------------------------------------------------------------
        public IEnumerable <CTraitementReleveEquipement> GetTraitements()
        {
            List <CTraitementReleveEquipement> traitements = new List <CTraitementReleveEquipement>();
            CListeObjetsDonnees lst = EquipementsReleves;

            //Préchargement de données
            lst.ReadDependances("Equipement", "RelevesEquipementsFils");
            new CListeObjetsDonnees(ContexteDonnee, typeof(CTypeEquipement)).AssureLectureFaite();
            new CListeObjetsDonnees(ContexteDonnee, typeof(CRelationTypeEquipement_Constructeurs)).AssureLectureFaite();
            lst.Filtre = new CFiltreData(CReleveEquipement.c_champParentEqpt + " is null");
            foreach (CReleveEquipement rel in lst)
            {
                CTraitementReleveEquipement traitement = rel.GetTraitement();
                if (traitement != null)
                {
                    traitements.Add(traitement);
                }
            }
            return(traitements.AsReadOnly());
        }
Ejemplo n.º 7
0
        //--------------------------------------------------------------------
        public void Init(CPhaseSpecifications phaseSpecifications)
        {
            CancelEdit();
            CurrentItemIndex      = null;
            Items                 = new CCustomizableListItem[0];
            m_phaseSpecifications = phaseSpecifications;

            if (m_phaseSpecifications != null)
            {
                List <CCustomizableListItem> items      = new List <CCustomizableListItem>();
                CListeObjetsDonnees          lstBesoins = m_phaseSpecifications.Besoins;
                lstBesoins.ReadDependances("BesoinsFils", "TypeProjet", "TypeEquipement", "TypeConsommable", "TypeOperation");
                CRelationBesoin_Satisfaction.PreloadBesoinsSatisfaits(lstBesoins);
                lstBesoins.Filtre = new CFiltreData(CBesoin.c_champIdBesoinParent + " is null");
                foreach (CBesoin besoin in lstBesoins)
                {
                    AddItemBesoinEtFils(null, besoin, items);
                }
                Items = items.ToArray();
            }
            m_panelResumeElementACout.Init(m_phaseSpecifications);
            Refresh();
        }
Ejemplo n.º 8
0
        public void InitFromSchema(CSchemaReseau schema)
        {
            m_nIdSchemaReseau = schema.Id;
            m_schema          = schema;

            CSpvSchemaReseau schemaSPV = CSpvSchemaReseau.GetObjetSpvFromObjetTimos(schema);

            if (schemaSPV != null)
            {
                m_nIdSchemaReseauSpv = schemaSPV.Id;
            }

            CListeObjetsDonnees lstElements = schema.ElementsDeSchema;

            lstElements.ReadDependances(
                "SchemaReseauInclu",
                "SchemaReseauContenu");
            //Charge les données SPV
            AssureRelationsToSpv();
            CListeObjetsDonnees lstTmp = lstElements.GetDependances("Site");

            lstTmp.GetDependances(m_relationFromSiteSpvToSite).AssureLectureFaite();

            lstTmp = lstElements.GetDependances("EquipementLogique");
            lstTmp.GetDependances(m_relationFromEquipementSpvToEquipement).AssureLectureFaite();

            lstTmp = lstElements.GetDependances("LienReseau");
            lstTmp.GetDependances(m_relationFromLiaisonSpvToLiaison).AssureLectureFaite();

            //CSpvService service = CSpvService.GetObjetSpvFromObjetTimos(schema);

            foreach (CElementDeSchemaReseau elt in lstElements)
            {
                IElementDeSchemaReseau elementFils = elt.ElementAssocie;
                if (elementFils != null)
                {
                    CInfoElementDeSchemaSupervise fils = null;
                    if (elementFils is CSite)
                    {
                        fils = new CInfoSiteDeSchemaSupervise(this, elt, m_base, NiveauProfondeur + 1);
                    }
                    if (elementFils is CLienReseau)
                    {
                        fils = new CInfoLienDeSchemaSupervise(this, elt, m_base, NiveauProfondeur + 1);
                    }
                    if (elementFils is CElementDeSchemaReseau)
                    {
                        fils = new CInfoEquipementDeSchemaSupervise(this, elt, m_base, NiveauProfondeur + 1);
                    }
                    if (elementFils is CSchemaReseau)
                    {
                        fils = new CInfoSchemaDeSchemaSupervise(this, elt, m_base, NiveauProfondeur + 1);
                    }
                    if (elementFils is CEquipementLogique)
                    {
                        fils = new CInfoEquipementDeSchemaSupervise(this, elt, m_base, NiveauProfondeur + 1);
                    }
                    if (elementFils != null)
                    {
                        fils.InitFromElementDeSchema(elt);
                        m_listeFils.Add(fils);
                    }
                }
            }

            PrepareSupervisionEtatOperationnel(schema);
            CalculArbreOperationnel();
        }
Ejemplo n.º 9
0
        //----------------------------------------------------------
        public List <ITranchePlanning> GetTranchesForElementsAInterventionBetween(DateTime dateDebut, DateTime dateFin)
        {
            List <ITranchePlanning> lstRetour = new List <ITranchePlanning>();

            Hashtable tableTypeToIds = new Hashtable();

            if (m_listeElementsAInterventions.Count == 0)
            {
                return(lstRetour);
            }

            //Si tous les elements à Intervention sont du même type
            foreach (IElementAIntervention elt in m_listeElementsAInterventions)
            {
                string strIds = (string)tableTypeToIds[elt.GetType()];
                if (strIds == null)
                {
                    strIds = elt.Id + "";
                }
                else
                {
                    strIds += ";" + elt.Id;
                }
                tableTypeToIds[elt.GetType()] = strIds;
            }
            dateFin = dateFin.AddDays(1);

            foreach (DictionaryEntry entry in tableTypeToIds)
            {
                Type   tp     = (Type)entry.Key;
                string strIds = (string)entry.Value;
                if (tp == typeof(CSite))
                {
                    CListeObjetsDonnees liste = new CListeObjetsDonnees(ContexteDonnee, typeof(CFractionIntervention));
                    liste.PreserveChanges = true;
                    liste.Filtre          = new CFiltreDataAvance(
                        CFractionIntervention.c_nomTable,
                        CIntervention.c_nomTable + "." + CIntervention.c_champIdElementLie + " in (" + strIds + ") and " +
                        CFractionIntervention.c_champDateDebutPlanifie + "<@1 and " +
                        CFractionIntervention.c_champDateFinPlanifiee + ">@2",
                        dateFin,
                        dateDebut
                        );
                    //Lit dans la base
                    liste.AssureLectureFaite();
                    liste.ReadDependances("Intervention");
                    m_contexteDonnee.GetTableSafe(CIntervention.c_nomTable);
                    strIds = strIds.Replace(';', ',');


                    string strNomRelation = m_contexteDonnee.GetForeignKeyName(typeof(CFractionIntervention), "Intervention");
                    //Et filtre sur les existants (pour prendre les nouveaux en compte)
                    string strFiltre = "Parent(" + strNomRelation + ")." + CIntervention.c_champIdElementLie + " in (" + strIds + ") and " +
                                       CFractionIntervention.c_champDateDebutPlanifie + "<=" + dateFin.ToString("#MM/dd/yyyy#") + " and " +
                                       CFractionIntervention.c_champDateFinPlanifiee + ">=" + dateDebut.ToString("#MM/dd/yyyy#") + "";
                    DataTable table = m_contexteDonnee.Tables[CFractionIntervention.c_nomTable];
                    DataRow[] rows  = table.Select(strFiltre);
                    foreach (DataRow row in rows)
                    {
                        lstRetour.Add(new CFractionIntervention(row));
                    }
                }
            }
            return(lstRetour);
        }
        /////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Lit les dépendances filles du type de donné
        /// </summary>
        /// <returns></returns>
        private void ReadDependanceFille(
            string strPropriete,
            CListeObjetsDonnees lstSource,
            CListeObjetsDonnees.CArbreProps arbre,
            CInfoRelation relation,
            List <string> listePaquets)
        {
            CResultAErreur result  = CResultAErreur.True;
            Type           tpFille = null;
            PropertyInfo   info    = lstSource.TypeObjets.GetProperty(strPropriete);

            if (info == null)
            {
                return;
            }

            object[] attrs = info.GetCustomAttributes(typeof(RelationFilleAttribute), true);
            if (attrs == null || attrs.Length < 0)
            {
                return;
            }
            tpFille = ((RelationFilleAttribute)attrs[0]).TypeFille;

            DataTable table = lstSource.ContexteDonnee.GetTableSafe(lstSource.NomTable);

            //S'assure que la table fille est chargée
            lstSource.ContexteDonnee.GetTableSafe(relation.TableFille);
            string     strKey        = relation.RelationKey;
            DataColumn colDependance = table.Columns[strKey];


            if (listePaquets == null)
            {
                listePaquets = lstSource.GetPaquetsPourLectureFils(relation.ChampsParent[0], colDependance);
            }
            int nNbPaquets = listePaquets.Count;

            //Lit les relations par paquet
            for (int nPaquet = 0; nPaquet < nNbPaquets; nPaquet++)
            {
                string strPaquet = (string)listePaquets[nPaquet];
                if (strPaquet.Length > 0)
                {
                    CListeObjetsDonnees listeFille = new CListeObjetsDonnees(lstSource.ContexteDonnee, tpFille);
                    listeFille.Filtre = new CFiltreData(relation.ChampsFille[0] + " in " + strPaquet);
                    if (arbre.Filtre.Length > 0)
                    {
                        listeFille.Filtre.Filtre += " and " + arbre.Filtre;
                    }
                    listeFille.ModeSansTri     = true;
                    listeFille.PreserveChanges = true;
                    listeFille.AssureLectureFaite();
                    int nMax = Math.Min(lstSource.Count, (nPaquet + 1) * CListeObjetsDonnees.c_nNbLectureParLotFils);


                    if (colDependance != null && arbre.Filtre.Length == 0)
                    {
                        //Indique que les lignes ont été lues
                        for (int nRow = nPaquet * CListeObjetsDonnees.c_nNbLectureParLotFils; nRow < nMax; nRow++)
                        {
                            DataRow      row      = lstSource.View.GetRow(nRow);
                            DataRowState oldState = row.RowState;
                            row[colDependance] = true;
                            if (oldState == DataRowState.Unchanged)
                            {
                                row.AcceptChanges();
                            }
                        }
                    }
                    listeFille.ReadDependances(arbre);
                }
            }
        }
        /////////////////////////////////////////////////////////////////////////////////////////////////
        private void ReadDependanceParente(
            string strPropriete,
            CListeObjetsDonnees lstSource,
            CListeObjetsDonnees.CArbreProps arbre,
            CInfoRelation relation)
        {
            int          nNbTotal = lstSource.Count;
            string       strKey   = relation.RelationKey;
            Type         tp       = null;
            PropertyInfo info     = lstSource.TypeObjets.GetProperty(strPropriete);

            if (info == null)
            {
                return;
            }
            tp = info.PropertyType;
            if (tp != null && typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tp))
            {
                //Crée les paquets
                ArrayList lstPaquets            = new ArrayList();
                Hashtable tableIdsParentTraites = new Hashtable();
                int       nPaquet          = 0;
                string    strChampFille    = relation.ChampsFille[0];
                string    strPaquetEnCours = "";
                int       nNbInPaquet      = 0;
                for (int n = 0; n < lstSource.View.Count; n++)
                {
                    DataRow row    = lstSource.View.GetRow(n);
                    string  strCle = row[strChampFille].ToString();
                    if (strCle != "")
                    {
                        if (tableIdsParentTraites[strCle] == null)
                        {
                            tableIdsParentTraites[strCle] = true;
                            strPaquetEnCours += strCle + ",";
                            nNbInPaquet++;
                            if (nNbInPaquet >= CListeObjetsDonnees.c_nNbLectureParLotFils)
                            {
                                strPaquetEnCours = "(" + strPaquetEnCours.Substring(0, strPaquetEnCours.Length - 1) + ")";
                                lstPaquets.Add(strPaquetEnCours);
                                strPaquetEnCours = "";
                                nNbInPaquet      = 0;
                            }
                        }
                    }
                }
                if (strPaquetEnCours.Length > 0)
                {
                    strPaquetEnCours = "(" + strPaquetEnCours.Substring(0, strPaquetEnCours.Length - 1) + ")";
                    lstPaquets.Add(strPaquetEnCours);
                }

                //Lit les relations par paquet
                int nNbPaquets = lstPaquets.Count;
                for (nPaquet = 0; nPaquet < nNbPaquets; nPaquet++)
                {
                    string strPaquet = (string)lstPaquets[nPaquet];
                    if (strPaquet != "()")
                    {
                        CListeObjetsDonnees listeParent = new CListeObjetsDonnees(lstSource.ContexteDonnee, tp);
                        listeParent.ModeSansTri     = true;
                        listeParent.PreserveChanges = true;
                        listeParent.Filtre          = new CFiltreData(relation.ChampsParent[0] + " in " + strPaquet);
                        listeParent.AssureLectureFaite();
                        //Indique que les lignes ont été lues
                        //Stef 2/12/2011 : non, on n'indique pas que c'est lu puisqu'il
                        //s'agit de dépendances parentes !
                        //Ca pose le problème suivant : si on est sur une table hiérarchique,
                        //lorsqu'on lit le parent (d'un projet par exemple), le fait de
                        //dire que les dépendances sont lues implique qu'on indique
                        //qu'on a lu les fils.
                        //De ma compréhension à ce jour, on ne gère pas de colonne
                        //indiquant si la dépendance a été chargé pour des dépendances
                        //parentes

                        /*if ( lstSource.View.Table.Columns[strKey] != null )
                         * {
                         *      for ( int nRow = 0; nRow < lstSource.View.Count; nRow++ )
                         *      {
                         *              CContexteDonnee.ChangeRowSansDetectionModification ( lstSource.View.GetRow ( nRow ), strKey, true );
                         *      }
                         * }*/
                        listeParent.ReadDependances(arbre);
                    }
                }
            }
        }
Ejemplo n.º 12
0
        // /////////////////////////////////////////////////////////
        /// <summary>
        /// Le data du result contient un IBaseGantt
        /// </summary>
        /// <returns></returns>
        public static CResultAErreur CreateGantt ( 
            CProjet projet, 
            CParametreNiveauArbreGanttGroupe groupeRacine,
            CFiltreData filtreElements )
        {
            CResultAErreur result = CResultAErreur.True;
            if (projet == null)
                return result;
            CElementDeGanttProjet elementRacine = new CElementDeGanttProjet(null, projet);
            if (!result)
                return result;
            List<CProjet> lstProjets = new List<CProjet>();
            if (!projet.IsNew())//Si le projet est nouveau, on ne peut pas filtrer
                //car les éléments ne sont pas encore en base
            {
                CFiltreData filtre = result.Data as CFiltreData;
                filtre = CFiltreData.GetAndFiltre(filtreElements,
                    new CFiltreData(CProjet.c_champCodeSystemeComplet + " like @1 and " +
                        CProjet.c_champId + "<>@2",
                        projet.CodeSystemeComplet + "%",
                        projet.Id));
                CListeObjetsDonnees lstObjetProjets = new CListeObjetsDonnees(projet.ContexteDonnee, typeof(CProjet), filtre);

                lstObjetProjets.PreserveChanges = true;
                lstObjetProjets.ModeSansTri = true;
                lstProjets.AddRange(lstObjetProjets.ToList<CProjet>());


                lstObjetProjets.ReadDependances("ProjetsFils","LiensEnTantQueProjetA", "LiensEnTantQueProjetB", "ContraintesPropres", "AnomaliesDuProjet");
                CUtilElementAChamps.ReadChampsCustom(lstObjetProjets);
            }
            //Il faut ajouter les projets qui ne sont pas encore en base et qui n'ont donc pas de code system
            List<CProjet> lstALire = new List<CProjet>();
            lstALire.Add(projet);
            DataRelation relation = null;
            foreach ( DataRelation rel in projet.ContexteDonnee.Tables[CProjet.c_nomTable].ChildRelations )
            {
                if ( rel.ChildTable.TableName == CProjet.c_nomTable )
                {
                    relation = rel;
                    break;
                }
            }
            while (lstALire.Count > 0 && relation != null)
            {
                List<CProjet> prochaineGeneration = new List<CProjet>();
                foreach (CProjet test in lstALire)
                {
                    DataRow[] rowsDeps = test.Row.Row.GetChildRows(relation);
                    foreach (DataRow row in rowsDeps)
                    {
                        if (row.RowState != DataRowState.Deleted)
                        {
                            CProjet prj = new CProjet(row);
                            if (prj.IsNew() && !lstProjets.Contains(prj) )
                            {
                                lstProjets.Add(prj);
                                
                            }
                            prochaineGeneration.Add(prj);
                        }
                    }
                }
                lstALire = prochaineGeneration;
            }
           
            

            
            //Comme on est passé par un filtre Avancé, les nouveaux éléments ne sont
            //pas dans la liste. On les ajoute donc !
            //Vérifie qu'il y a des éléments dont l'id est négatif
            CListeObjetsDonnees lstTmp = new CListeObjetsDonnees(projet.ContexteDonnee,
                typeof(CProjet));
            lstTmp.Filtre = new CFiltreData(CProjet.c_champId + "<@1", 0);
            lstTmp.InterditLectureInDB = true;
            if (lstTmp.Count > 0)//Il y a des projets tous neufs dans le contexte
            {
                foreach (CProjet projetTmp in new ArrayList(lstProjets))
                {
                    //N'utilise pas ProjetsFils pour ne pas lire dans la base
                    CListeObjetsDonnees lstFils = new CListeObjetsDonnees(projet.ContexteDonnee,
                        typeof(CProjet),
                        new CFiltreData(CProjet.c_champIdParent + "=@1", projetTmp.Id));
                    lstFils.InterditLectureInDB = true;
                    lstFils.Filtre = new CFiltreData(CProjet.c_champId + "<0");
                    foreach (CProjet projetFils in lstFils)
                        if (!lstProjets.Contains(projetFils))
                            lstProjets.Add(projetFils);
                }
                //Les nouveaux sous projet du projet principal doivent également être ajoutés
                CListeObjetsDonnees lstFilsPrincipal = projet.ProjetsFils;
                lstFilsPrincipal.Filtre = new CFiltreData(CProjet.c_champId + "<0");
                foreach (CProjet projetFils in lstFilsPrincipal)
                    if (!lstProjets.Contains(projetFils))
                        lstProjets.Add(projetFils);
            }
            CContexteDonnee contexteDeTravail = projet.ContexteDonnee;

            return PrepareGantt(groupeRacine,result, elementRacine, lstProjets, contexteDeTravail);
        }
Ejemplo n.º 13
0
        // /////////////////////////////////////////////////////////
        /// <summary>
        /// Le data du result contient un IBaseGantt
        /// </summary>
        /// <returns></returns>
        public static CResultAErreur CreateGantt(
            CMetaProjet metaProjet,
            CParametreNiveauArbreGanttGroupe groupeRacine,
            CFiltreData filtreElements)
        {
            CResultAErreur result = CResultAErreur.True;
            if (metaProjet == null)
                return result;
            CElementDeGanttMetaProjet elementRacine = new CElementDeGanttMetaProjet(null, metaProjet);
            if (!result)
                return result;
            List<CProjet> lstProjets = new List<CProjet>();

            bool bLectureDansContexteCourant = false;
            //S'il y a des éléments modifiés, ajoutés ou supprimés dans
            //les relations, charge manuellement
            DataTable table = metaProjet.ContexteDonnee.GetTableSafe(CRelationMetaProjet_Projet.c_nomTable);
            if ( table != null )
            {
                if ( table.Select ( "", "", DataViewRowState.Added | DataViewRowState.Deleted | DataViewRowState.ModifiedCurrent ).Length > 0 )
                {
                    bLectureDansContexteCourant = true;
                    //Il y a des modifs, on ne peut donc pas appliquer le filtre,
                    //et on doit aller chercher les projets manuellement
                    foreach ( CRelationMetaProjet_Projet rel in metaProjet.RelationsProjets )
                    {
                        List<CProjet> lstTmp = new List<CProjet>();
                        lstTmp.Add ( rel.Projet );
                        while ( lstTmp.Count > 0 )
                        {
                            List<CProjet> lstSuivante = new List<CProjet>();
                            foreach ( CProjet prj in lstTmp )
                            {
                                lstProjets.Add ( prj );
                                lstSuivante.AddRange ( prj.ProjetsFils.ToList<CProjet>());
                            }
                            lstTmp = lstSuivante;
                        }
                    }
                }
            }
            if (!bLectureDansContexteCourant)
            {
                CFiltreData filtre = result.Data as CFiltreData;
                filtre = CFiltreData.GetAndFiltre(filtreElements,
                    new CFiltreDataAvance(
                        CProjet.c_nomTable,
                        CRelationMetaProjet_Projet.c_nomTable + "." +
                        CMetaProjet.c_champId + "=@1",
                        metaProjet.Id));

                filtre.IntegrerFilsHierarchiques = !metaProjet.HideChildProjects;
                CListeObjetsDonnees lstObjetProjets = new CListeObjetsDonnees(metaProjet.ContexteDonnee, typeof(CProjet), filtre);
                lstObjetProjets.PreserveChanges = true;
                lstObjetProjets.ModeSansTri = true;
                lstProjets.AddRange(lstObjetProjets.ToList<CProjet>());
                if ( metaProjet.HideChildProjects )
                    lstObjetProjets.ReadDependances("LiensEnTantQueProjetA.ProjetB", "LiensEnTantQueProjetB.ProjetA", "ContraintesPropres", "AnomaliesDuProjet");
                else
                    lstObjetProjets.ReadDependances("ProjetsFils", "LiensEnTantQueProjetA.ProjetB", "LiensEnTantQueProjetB.ProjetA", "ContraintesPropres", "AnomaliesDuProjet");
                CUtilElementAChamps.ReadChampsCustom(lstObjetProjets);
            }

            CContexteDonnee contexteDeTravail = metaProjet.ContexteDonnee;

            return PrepareGantt(groupeRacine, result, elementRacine, lstProjets, contexteDeTravail);
        }
        //**********************************************************************************
        public void ReadArbre(CListeObjetsDonnees listeSource, CListeObjetsDonnees.CArbreProps arbre, List <string> lstPaquetsALire)
        {
            if (listeSource.Count == 0)
            {
                return;
            }
            CObjetDonneeAIdNumerique objExemple = listeSource[0] as CObjetDonneeAIdNumerique;

            if (objExemple == null)
            {
                return;
            }
            string strCle         = "";
            string strPropSansCle = "";

            if (!CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(arbre.ProprietePrincipale, ref strCle, ref strPropSansCle))
            {
                return;
            }
            //trouve la relation correspondante à l'identifiant de la propriété
            RelationTypeIdAttribute relation = null;

            foreach (RelationTypeIdAttribute relTest in CContexteDonnee.RelationsTypeIds)
            {
                if (relTest.IdRelation == strPropSansCle)
                {
                    relation = relTest;
                    break;
                }
            }
            if (relation == null)
            {
                return;
            }

            string     strNomColDep = relation.GetNomColDepLue();
            DataColumn col          = objExemple.Table.Columns[strNomColDep];

            if (col == null)
            {
                col = new DataColumn(strNomColDep, typeof(bool));
                col.DefaultValue = false;
                col.AllowDBNull  = false;
                objExemple.Table.Columns.Add(col);
            }

            if (lstPaquetsALire == null)
            {
                lstPaquetsALire = listeSource.GetPaquetsPourLectureFils(objExemple.GetChampId(), col);
            }

            foreach (string strPaquet in lstPaquetsALire)
            {
                if (strPaquet != null && strPaquet.Trim().Length > 0)
                {
                    CListeObjetsDonnees lst = new CListeObjetsDonnees(listeSource.ContexteDonnee,
                                                                      CContexteDonnee.GetTypeForTable(relation.TableFille));
                    lst.Filtre = new CFiltreData(
                        relation.ChampType + "=@1 and " +
                        relation.ChampId + " in " + strPaquet,
                        listeSource.TypeObjets.ToString());
                    lst.AssureLectureFaite();
                    lst.ReadDependances(arbre);
                }
            }

            foreach (CObjetDonneeAIdNumerique obj in listeSource)
            {
                CContexteDonnee.ChangeRowSansDetectionModification(obj.Row, strNomColDep, true);
            }
        }
Ejemplo n.º 15
0
        public CResultAErreur Execute(int nIdSession, Hashtable valeursParametres)
        {
            CResultAErreur result = CResultAErreur.True;

            using (CContexteDonnee contexte = new CContexteDonnee(nIdSession, true, false))
            {
                StreamReader reader = null;
                try
                {
                    CHandlerEvenementServeur.SuspendGestionnaire(true);
                    contexte.EnableTraitementsAvantSauvegarde = false;

                    // Charges tous les tickets
                    CListeObjetsDonnees listeTicketsACharger = new CListeObjetsDonnees(contexte, typeof(CTicket));
                    listeTicketsACharger.ReadDependances("RelationsChampsCustom");

                    // Lire le CSV
                    string strFichierImport = "c:\\TimosData\\IMPORT_JANVIER_MARS_2009.csv";
                    reader = new StreamReader(strFichierImport);

                    // Lit l'entête de colonnes
                    string strLine = reader.ReadLine();
                    // Lit la première ligne
                    strLine = reader.ReadLine();
                    while (strLine != null)
                    {
                        // Pour chaque ligne du ficher
                        string[] strChamps       = strLine.Split(';');
                        string   strNumeroTicket = strChamps[0];
                        string   strIdQualif     = strChamps[2];

                        // Traitement
                        CTicket ticket = new CTicket(contexte);
                        if (ticket.ReadIfExists(new CFiltreData(
                                                    CTicket.c_champNumero + " = @1",
                                                    strNumeroTicket)))
                        {
                            CQualificationTicket qualif = new CQualificationTicket(contexte);
                            if (qualif.ReadIfExists(new CFiltreData(
                                                        CQualificationTicket.c_champId + " = @1",
                                                        Int32.Parse(strIdQualif))))
                            {
                                // Affecte la valeur du champs custom 147 : Requalification
                                ticket.SetValeurChamp(147, qualif);
                            }
                        }

                        // Lit la ligne suivante
                        strLine = reader.ReadLine();
                    }

                    reader.Close();

                    result = contexte.SaveAll(true);
                    if (!result)
                    {
                        result.EmpileErreur("Erreur de sauvegarde des données");
                        return(result);
                    }
                }
                catch (Exception e)
                {
                    result.EmpileErreur(new CErreurException(e));
                }
                finally
                {
                    CHandlerEvenementServeur.SuspendGestionnaire(false);
                    if (reader != null)
                    {
                        reader.Close();
                    }
                }
            }

            return(result);
        }
Ejemplo n.º 16
0
        //----------------------------------------------------------
        public List <ITranchePlanning> GetOccupationsForRessourcesBetween(DateTime dateDebut, DateTime dateFin)
        {
            List <ITranchePlanning> lstRetour = new List <ITranchePlanning>();

            Hashtable tableTypeToIds = new Hashtable();

            if (m_listeRessources.Count == 0)
            {
                return(lstRetour);
            }

            CContexteDonnee contexte = m_listeRessources[0].ContexteDonnee;

            foreach (IRessourceEntreePlanning ressource in Ressources)
            {
                if (tableTypeToIds[ressource.GetType()] == null)
                {
                    tableTypeToIds[ressource.GetType()] = ressource.Id + "";
                }
                else
                {
                    string strId = (string)tableTypeToIds[ressource.GetType()];
                    strId += "," + ressource.Id;
                    tableTypeToIds[ressource.GetType()] = strId;
                }
            }

            dateFin = dateFin.AddDays(1);
            ///IdFraction->True si elle a déjà été ajoutée
            Hashtable tableFractions = new Hashtable();

            foreach (DictionaryEntry entry in tableTypeToIds)
            {
                Type   tp     = (Type)entry.Key;
                string strIds = (string)entry.Value;

                CListeObjetsDonnees liste;
                string strClauseRessource             = "";
                string strDependancesRessources       = "";
                string strTableLienRessource          = "";
                string strChampIdRessourceInTableLien = "";
                Type   typeLienRessource = null;
                if (tp == typeof(CActeur))
                {
                    strClauseRessource             = CIntervention_Intervenant.c_nomTable + "." + CActeur.c_champId + " in (" + strIds + ")";
                    strDependancesRessources       = "Intervention.RelationsIntervenants";
                    strTableLienRessource          = CIntervention_Intervenant.c_nomTable;
                    typeLienRessource              = typeof(CIntervention_Intervenant);
                    strChampIdRessourceInTableLien = CActeur.c_champId;
                }
                else if (tp == typeof(CRessourceMaterielle))
                {
                    strClauseRessource             = CIntervention_Ressource.c_nomTable + "." + CRessourceMaterielle.c_champId + " in (" + strIds + ")";
                    strDependancesRessources       = "Intervention.RelationsRessourcesMaterielles";
                    strTableLienRessource          = CIntervention_Ressource.c_nomTable;
                    typeLienRessource              = typeof(CIntervention_Ressource);
                    strChampIdRessourceInTableLien = CRessourceMaterielle.c_champId;
                }
                else
                {
                    throw new Exception("Type de ressource non prévu : " + tp.ToString());
                }
                liste = new CListeObjetsDonnees(contexte, typeof(CFractionIntervention));
                liste.PreserveChanges = true;
                liste.Filtre          = new CFiltreDataAvance(
                    CFractionIntervention.c_nomTable,
                    CIntervention.c_nomTable + "." +
                    strClauseRessource + " and " +
                    CFractionIntervention.c_champDateDebutPlanifie + "<@1 and " +
                    CFractionIntervention.c_champDateFinPlanifiee + ">@2",
                    dateFin,
                    dateDebut
                    );
                //Lit dans la base
                liste.AssureLectureFaite();
                liste.ReadDependances("Intervention", strDependancesRessources);
                contexte.GetTableSafe(CIntervention.c_nomTable);
                contexte.GetTableSafe(strTableLienRessource);

                string strNomRelationIntervention = contexte.GetForeignKeyName(typeof(CFractionIntervention), "Intervention");
                //Ne sélectionne que ceux qui sont liés à la ressource
                CListeObjetsDonnees listeInterventionIt = new CListeObjetsDonnees(contexte, typeLienRessource);
                listeInterventionIt.InterditLectureInDB = true;
                listeInterventionIt.Filtre = new CFiltreData(strChampIdRessourceInTableLien + " in (" + strIds + ")");
                string strIdsInterventions = "";
                foreach (IEntreePlanning_Ressource it in listeInterventionIt)
                {
                    strIdsInterventions += it.EntreePlanning.Id + ",";
                }
                if (strIdsInterventions.Length > 0)
                {
                    string strFiltre = "Parent(" + strNomRelationIntervention + ")." + CIntervention.c_champId + " in (" + strIdsInterventions + ") and " +
                                       CFractionIntervention.c_champDateDebutPlanifie + "<=" + dateFin.ToString("#MM/dd/yyyy#") + " and " +
                                       CFractionIntervention.c_champDateFinPlanifiee + ">=" + dateDebut.ToString("#MM/dd/yyyy#") + "";
                    DataTable table = contexte.Tables[CFractionIntervention.c_nomTable];
                    DataRow[] rows  = table.Select(strFiltre);
                    foreach (DataRow row in rows)
                    {
                        if (!tableFractions.Contains(row[CFractionIntervention.c_champId]))
                        {
                            lstRetour.Add(new CFractionIntervention(row));
                            tableFractions[row[CFractionIntervention.c_champId]] = true;
                        }
                    }
                }
            }

            return(lstRetour);
        }
Ejemplo n.º 17
0
        public void UpdateOnglets()
        {
            if (!LockEdition)
            {
                //valide les modifs car on va tout supprimer
                MAJ_Champs();
            }
            m_bIsInitializing = true;
            Hashtable tablePagesToHide = new Hashtable();

            foreach (Crownwood.Magic.Controls.TabPage page in TabPages)
            {
                m_tablePagesInit[page] = false;
                tablePagesToHide[page] = true;
            }

            if (m_elementEdite == null)
            {
                return;
            }

            /* YK : On obtient la session de l'objet en cours d'édition au lieur de la session par défaut */
            CSessionClient session = null;
            IObjetDonneeAIdNumeriqueAuto objetDonnee = m_elementEdite as IObjetDonneeAIdNumeriqueAuto;

            if (objetDonnee != null)
            {
                session = CSessionClient.GetSessionForIdSession(objetDonnee.ContexteDonnee.IdSession);
            }
            else
            {
                session = CSessionClient.GetSessionUnique();
            }

            ArrayList lstFormulaires = new ArrayList(m_elementEdite.GetFormulaires());

            lstFormulaires.Sort(new CSorterFormulaires());
            //Lit les champs liés et leurs valeurs
            StringBuilder bl = new StringBuilder();

            foreach (CFormulaire formulaire in lstFormulaires)
            {
                bl.Append(formulaire.Id);
                bl.Append(",");
            }
            if (bl.Length > 0)
            {
                bl.Remove(bl.Length - 1, 1);
                CListeObjetsDonnees lst = new CListeObjetsDonnees(((CFormulaire)lstFormulaires[0]).ContexteDonnee, typeof(CFormulaire));
                lst.Filtre = new CFiltreData(CFormulaire.c_champId + " in (" + bl.ToString() + ")");
                lst.AssureLectureFaite();
                lst.ReadDependances("RelationsChamps", "RelationsChamps.Champ", "RelationsChamps.Champ.ListeValeurs");
            }


            foreach (CFormulaire formulaire in lstFormulaires)
            {
                CRestrictionUtilisateurSurType restriction = new CRestrictionUtilisateurSurType(m_elementEdite.GetType());
                if (session.GetInfoUtilisateur() != null)
                {
                    int?nIdVersion = null;
                    IObjetAContexteDonnee objetAContexte = m_elementEdite as IObjetAContexteDonnee;
                    if (objetAContexte != null)
                    {
                        nIdVersion = objetAContexte.ContexteDonnee.IdVersionDeTravail;
                    }
                    restriction = session.GetInfoUtilisateur().GetRestrictionsSurObjet(m_elementEdite, nIdVersion);
                }

                ERestriction restrictionFormulaire = restriction.GetRestriction(formulaire.CleRestriction);

                if ((restrictionFormulaire & ERestriction.Hide) != ERestriction.Hide)
                {
                    Crownwood.Magic.Controls.TabPage page     = (Crownwood.Magic.Controls.TabPage)m_tableIdFormulaireToTabPage[formulaire.Id];
                    CCreateur2iFormulaire            createur = null;

                    if (page == null)
                    {
                        C2iWndFenetre wnd = formulaire.Formulaire;
                        if (wnd != null)
                        {
                            page = new Crownwood.Magic.Controls.TabPage(wnd.Text);
                            page.SuspendLayout();
                            if (wnd.Text == "")
                            {
                                page.Title = formulaire.Libelle;
                            }
                            TabPages.Add(page);
                            m_tableCreateurs[page]   = null;
                            m_tablePageTo2iWnd[page] = wnd;
                            m_tableIdFormulaireToTabPage[formulaire.Id] = page;
                        }
                    }
                    else
                    {
                        createur = (CCreateur2iFormulaire)m_tableCreateurs[page];
                    }

                    if (page != null)
                    {
                        m_tablePageToRestriction[page] = restrictionFormulaire;
                        if (!TabPages.Contains(page))
                        {
                            TabPages.Add(page);
                        }
                        tablePagesToHide.Remove(page);
                    }
                }
            }

            /*CChampCustom[] champs = ElementEdite.GetChampsHorsFormulaire();
             * if ( champs.Length != 0 )
             * {
             *      UpdatePageChamps( nRest );
             *      if ( m_pageGrid != null )
             *              tablePagesToHide.Remove(m_pageGrid);
             * }*/
            foreach (Crownwood.Magic.Controls.TabPage pageToDel in tablePagesToHide.Keys)
            {
                TabPages.Remove(pageToDel);
            }

            if (TabPages.Count == 1)
            {
                this.HideTabsMode = Crownwood.Magic.Controls.TabControl.HideTabsModes.HideAlways;
            }
            else
            {
                this.HideTabsMode = Crownwood.Magic.Controls.TabControl.HideTabsModes.ShowAlways;
            }
            if (SelectedTab != null)
            {
                InitPageWithObjetCourant(SelectedTab);
            }
            m_bIsInitializing = false;
        }
Ejemplo n.º 18
0
        //-----------------------------------
        public IEnumerable <CDocumentGED> GetDocuments(object sourceDeFormule)
        {
            Dictionary <CDocumentGED, int> dicDocs = new Dictionary <CDocumentGED, int>();

            IEnumerable <CObjetDonneeAIdNumerique> lstObjets     = GetListeAssociations(sourceDeFormule);
            IEnumerable <CCategorieGED>            lstCategories = GetListeCategories(sourceDeFormule);

            //Ne prend que les documents qui sont dans toutes les catégories
            //et communes à tous les éléments
            bool          bHasCategories = lstCategories.Count() > 0;
            HashSet <int> setCats        = new HashSet <int>();

            foreach (CCategorieGED categorie in lstCategories)
            {
                AddCategory(categorie, setCats);
            }


            foreach (CObjetDonneeAIdNumerique objet in lstObjets)
            {
                CListeObjetsDonnees lstDocs = CDocumentGED.GetListeDocumentsForElement(objet);
                if (bHasCategories)
                {
                    lstDocs.ReadDependances(CRelationDocumentGED_Categorie.c_nomTable);
                    foreach (CDocumentGED doc in lstDocs)
                    {
                        int nNbCats = 0;
                        foreach (CRelationDocumentGED_Categorie rel in doc.RelationsCategories)
                        {
                            if (setCats.Contains((int)rel.Row[CCategorieGED.c_champId]))
                            {
                                nNbCats++;
                            }
                        }
                        if (nNbCats == lstCategories.Count())
                        {
                            int nTmp = 0;
                            if (!dicDocs.ContainsKey(doc))
                            {
                                dicDocs[doc] = 1;
                            }
                            else
                            {
                                nTmp         = dicDocs[doc];
                                dicDocs[doc] = nTmp + 1;
                            }
                        }
                    }
                }
                else
                {
                    foreach (CDocumentGED doc in lstDocs)
                    {
                        if (!dicDocs.ContainsKey(doc))
                        {
                            dicDocs[doc] = 1;
                        }
                        else
                        {
                            dicDocs[doc] = dicDocs[doc] + 1;
                        }
                    }
                }
            }

            List <CDocumentGED> lstFinale = new List <CDocumentGED>();
            int nObjectif = lstObjets.Count();

            foreach (KeyValuePair <CDocumentGED, int> kv in dicDocs)
            {
                if (kv.Value == nObjectif)
                {
                    lstFinale.Add(kv.Key);
                }
            }
            lstFinale.Sort((x, y) => x.Libelle.CompareTo(y.Libelle));
            return(lstFinale.AsReadOnly());
        }
Ejemplo n.º 19
0
        //----------------------------------------------------------------------------------
        public CResultAErreur ExportSimple(int nIdSession, IEnumerable list, ref DataSet ds, IIndicateurProgression indicateur)
        {
            if (m_cacheValeurs == null)
            {
                m_cacheValeurs = new CCacheValeursProprietes();
            }
            DateTime       dt     = DateTime.Now;
            CResultAErreur result = CResultAErreur.True;

            if (list != null && !(list is CListeObjetsDonnees))
            {
                result.EmpileErreur(I.T("Impossible to use a simple export with something other than a Data Object list|102"));
                return(result);
            }
            CListeObjetsDonnees listeObjets         = (CListeObjetsDonnees)list;
            CContexteDonnee     contexteDestination = new CContexteDonnee(nIdSession, true, false);

            result = contexteDestination.SetVersionDeTravail(listeObjets.ContexteDonnee.IdVersionDeTravail, false);
            if (!result)
            {
                return(result);
            }
            contexteDestination.EnforceConstraints = false;            //Ca gagne un temps fou !!!
            ds = contexteDestination;

            //Crée la table principale
            DataTable tablePrincipale = contexteDestination.GetTableSafe(CContexteDonnee.GetNomTableForType(m_typeSource));

            if (tablePrincipale == null)
            {
                result.EmpileErreur(I.T("Error during the creation of the main table|103"));
                return(result);
            }

            if (listeObjets != null)
            {
                //Exporte les objets dans la table principale
                foreach (CObjetDonnee objet in listeObjets)
                {
                    tablePrincipale.ImportRow(objet.Row.Row);
                }
            }


            foreach (C2iChampExport champ in Table.Champs)
            //Crée les colonnes calculées et champs custom
            {
                result = CreateChampInTable(champ, tablePrincipale);
                if (!result)
                {
                    result.EmpileErreur(I.T("Error during field @1 creation|104", champ.NomChamp));
                    return(result);
                }
            }
            //Crée les autres tables
            foreach (C2iTableExport tableFille in Table.TablesFilles)
            {
                CreateTableSimpleInDataset(tableFille, contexteDestination, m_typeSource);
            }

            foreach (DataTable table in contexteDestination.Tables)
            {
                ArrayList lstColsToDelete = new ArrayList();
                foreach (DataColumn col in table.Columns)
                {
                    if (col.DataType == typeof(CDonneeBinaireInRow))
                    {
                        lstColsToDelete.Add(col);
                    }
                }
                foreach (DataColumn col in lstColsToDelete)
                {
                    table.Columns.Remove(col);
                }
            }

            if (listeObjets == null)
            {
                AddTablesCalculees(contexteDestination, null);
            }

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


            CListeObjetsDonnees listeDestination = new CListeObjetsDonnees(contexteDestination, m_typeSource, false);

            listeDestination.InterditLectureInDB = true;


            //Lit les dépendances dans le contexte
            //Récupère toutes les sous tables nécéssaires
            string[]  definitionsOrigines = GetDependancesDeTableSimple(listeObjets.ContexteDonnee);
            Hashtable tableDependances    = new Hashtable();

            foreach (string def in definitionsOrigines)
            {
                tableDependances[def] = true;
            }
            string[] strDependances = new string[tableDependances.Count];
            int      nDependance    = 0;

            foreach (string strDependance in tableDependances.Keys)
            {
                strDependances[nDependance] = strDependance;
                nDependance++;
            }

            listeDestination.ReadDependances(strDependances);
            //Et voila, le tour est joué, toutes les données sont dans le dataset de destination

            //Il manque juste les compositions des éléments nouveaux
            if (listeObjets != null)
            {
                //Exporte les compositions des objets nouveaux
                foreach (CObjetDonnee objet in listeObjets)
                {
                    if (objet.IsNew())                      //Si nouveau, charge directement toutes ses données
                    {
                        objet.ContexteDonnee.CopieRowTo(objet.Row.Row, contexteDestination, true, false, false);
                    }
                }
            }
            //S'assure que toutes les données sont lues
            foreach (DataTable table in contexteDestination.Tables)
            {
                DataView view = new DataView(table);
                view.RowFilter = CContexteDonnee.c_colIsToRead + "=1";
                foreach (DataRowView rowView in view)
                {
                    contexteDestination.ReadRow(rowView.Row);
                }
            }



            //Ramène les champs calculés
            List <ITableExport> toutesLesTables = ToutesLesTables();

            m_cacheValeurs.CacheEnabled = true;
            int nNbTotalPrincipal = tablePrincipale.Rows.Count;

            //Récupère les champs par ID
            //Id->Nom du champ
            Dictionary <int, CChampCustom> dicoChamps  = new Dictionary <int, CChampCustom>();
            CListeObjetsDonnees            listeChamps = new CListeObjetsDonnees(contexteDestination, typeof(CChampCustom));

            foreach (CChampCustom champ in listeChamps)
            {
                dicoChamps[champ.Id] = champ;
            }

            //Liste des tables à conserver au final
            Hashtable tableTablesAConserver = new Hashtable();

            foreach (C2iTableExport table in toutesLesTables)
            {
                string    strNomTable      = "";
                DataTable tableDestination = tablePrincipale;
                if (table.ChampOrigine != null)
                {
                    strNomTable      = CContexteDonnee.GetNomTableForType(table.ChampOrigine.TypeDonnee.TypeDotNetNatif);
                    tableDestination = contexteDestination.Tables[strNomTable];
                }
                if (tableDestination != null)
                {
                    tableTablesAConserver[tableDestination.TableName] = true;
                    List <C2iChampExport> champsCalcules = new List <C2iChampExport>();
                    List <C2iChampExport> champsCustoms  = new List <C2iChampExport>();
                    foreach (C2iChampExport champ in table.Champs)
                    {
                        if (champ.Origine is C2iOrigineChampExportExpression)
                        {
                            champsCalcules.Add(champ);
                        }
                        if (champ.Origine is C2iOrigineChampExportChampCustom)
                        {
                            champsCustoms.Add(champ);
                        }
                    }

                    if (champsCalcules.Count != 0)
                    {
                        Type tp = CContexteDonnee.GetTypeForTable(tableDestination.TableName);
                        foreach (DataRow row in tableDestination.Rows)
                        {
#if PDA
                            CObjetDonnee objet = (CObjetDonnee)Activator.CreateInstance(tp);
                            objet.SetRow(row);
#else
                            object objet = Activator.CreateInstance(tp, new object[] { row });
#endif
                            foreach (C2iChampExport chp in champsCalcules)
                            {
                                if (chp.Origine is C2iOrigineChampExportExpression)
                                {
                                    object valeur = chp.GetValeur(objet, m_cacheValeurs, null);
                                    if (valeur == null)
                                    {
                                        valeur = DBNull.Value;
                                    }
                                    row[chp.NomChamp] = valeur;
                                }
                            }
                            m_cacheValeurs.ResetCache(  );
                        }
                    }
                    if (champsCustoms.Count > 0)
                    {
                        Type tp = CContexteDonnee.GetTypeForTable(tableDestination.TableName);
                        if (typeof(IObjetDonneeAChamps).IsAssignableFrom(tp))
                        {
                            IObjetDonneeAChamps element  = (IObjetDonneeAChamps)Activator.CreateInstance(tp, contexteDestination);
                            string strTableValeursChamps = element.GetNomTableRelationToChamps();
                            Type   tpValeursChamps       = CContexteDonnee.GetTypeForTable(strTableValeursChamps);

                            //Travaille les valeurs de champs customs par paquet de 500;
                            int    nTaillePaquet = 500;
                            int    nMax          = tableDestination.Rows.Count;
                            string strChampId    = tableDestination.PrimaryKey[0].ColumnName;
                            for (int nPaquet = 0; nPaquet < nMax; nPaquet += nTaillePaquet)
                            {
                                StringBuilder bl   = new StringBuilder();
                                int           nFin = Math.Min(nMax, nPaquet + nTaillePaquet);
                                for (int nRow = nPaquet; nRow < nFin; nRow++)
                                {
                                    bl.Append(tableDestination.Rows[nRow][strChampId]);
                                    bl.Append(',');
                                }
                                if (bl.Length > 0)
                                {
                                    bl.Remove(bl.Length - 1, 1);
                                    string strIds = bl.ToString();
                                    foreach (C2iChampExport champACustom in champsCustoms)
                                    {
                                        C2iOrigineChampExportChampCustom origineChamp = (C2iOrigineChampExportChampCustom)champACustom.Origine;

                                        //C'est un élément à champ, donc, va requeter dans les champs customs pour avoir les
                                        //valeurs
                                        CListeObjetsDonnees listeValeurs = new CListeObjetsDonnees(contexteDestination, tpValeursChamps);
                                        StringBuilder       blIdsChamps  = new StringBuilder();
                                        foreach (int nId in origineChamp.IdsChampCustom)
                                        {
                                            blIdsChamps.Append(nId);
                                            blIdsChamps.Append(',');
                                        }
                                        if (blIdsChamps.Length > 0)
                                        {
                                            blIdsChamps.Remove(blIdsChamps.Length - 1, 1);
                                            listeValeurs.Filtre = new CFiltreData(
                                                CChampCustom.c_champId + " in (" + blIdsChamps.ToString() + ") and " +
                                                strChampId + " in (" + strIds + ")");
                                            listeValeurs.AssureLectureFaite();
                                            //On n'a plus qu'à rebasculer les valeurs dans la table
                                            foreach (CRelationElementAChamp_ChampCustom valeur in listeValeurs)
                                            {
                                                try
                                                {
                                                    DataRow rowAttachee = tableDestination.Rows.Find(valeur.Row[strChampId]);
                                                    if (rowAttachee != null)
                                                    {
                                                        object valTmp = valeur.Valeur;
                                                        if (valTmp == null)
                                                        {
                                                            valTmp = DBNull.Value;
                                                        }
                                                        rowAttachee[c_strPrefixeChampCustom + valeur.ChampCustom.Nom] = valTmp;
                                                    }
                                                }
                                                catch
                                                { }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            m_cacheValeurs.ResetCache();
            ArrayList lstTablesToDelete = new ArrayList();
            foreach (DataTable table in contexteDestination.Tables)
            {
                if (tableTablesAConserver[table.TableName] == null)
                {
                    lstTablesToDelete.Add(table);
                }
            }
            foreach (DataTable table in lstTablesToDelete)
            {
                contexteDestination.SupprimeTableEtContraintes(table);
            }

            AddTablesCalculees(contexteDestination, null);

            return(result);
        }
Ejemplo n.º 20
0
        //----------------------------------------------------------------------------------------------------
        public IDonneeSynchronisationMediation GetUpdatesForProxy(int nIdProxy, int nIdLastSyncSession)
        {
            using (CSessionClient session = CSessionClient.CreateInstance())
            {
                CResultAErreur result = session.OpenSession(new CAuthentificationSessionProcess());
                if (!result)
                {
                    return(null);
                }
                using (CContexteDonneesSynchro ctx = new CContexteDonneesSynchro(session.IdSession, true))
                {
                    CSc2iDataServer connexionManager = CSc2iDataServer.GetInstance();

                    IDatabaseConnexionSynchronisable cnxSync = connexionManager.GetDatabaseConnexion(session.IdSession, typeof(CTypeAgentSnmpServeur)) as IDatabaseConnexionSynchronisable;
                    if (cnxSync == null)
                    {
                        return(null);
                    }
                    cnxSync.IncrementeSyncSession();
                    int nIdSyncMax = cnxSync.IdSyncSession - 1;

                    CFiltresSynchronisation filtres = new CFiltresSynchronisation();
                    filtres.AddFiltreForTable(CTypeAlarme.c_nomTable, null, false);
                    filtres.AddFiltreForTable(CSeveriteAlarme.c_nomTable, null, false);
                    filtres.AddFiltreForTable(CTypeAgentSnmp.c_nomTable, null, false);
                    filtres.AddFiltreForTable(CAgentSnmp.c_nomTable,
                                              new CFiltreData(CSnmpProxyInDb.c_champId + "=@1",
                                                              nIdProxy)
                                              , false);
                    filtres.AddFiltreForTable(CTypeEntiteSnmp.c_nomTable, null, false);
                    filtres.AddFiltreForTable(CEntiteSnmp.c_nomTable, new CFiltreDataAvance(
                                                  CEntiteSnmp.c_nomTable,
                                                  CAgentSnmp.c_nomTable + "." +
                                                  CSnmpProxyInDb.c_champId + "=@1",
                                                  nIdProxy), false);
                    filtres.AddFiltreForTable(CRelationTypeEntiteSnmp_ChampCustom.c_nomTable, null, false);
                    filtres.AddFiltreForTable(CRelationEntiteSnmp_ChampCustom.c_nomTable,
                                              new CFiltreDataAvance(CRelationEntiteSnmp_ChampCustom.c_nomTable,
                                                                    CEntiteSnmp.c_nomTable + "." +
                                                                    CAgentSnmp.c_nomTable + "." +
                                                                    CSnmpProxyInDb.c_champId + "=@1",
                                                                    nIdProxy), false);
                    // Prend uniquement les Filtrages d'alarme compris entre les dates de validité et marqués Enabled
                    filtres.AddFiltreForTable(CParametrageFiltrageAlarmes.c_nomTable,
                                              new CFiltreData(
                                                  CParametrageFiltrageAlarmes.c_champIsActif + " = @1 AND " +
                                                  CParametrageFiltrageAlarmes.c_champDateDebutValidite + " <= @2 AND " +
                                                  CParametrageFiltrageAlarmes.c_champDateFinValidite + " > @2",
                                                  true,
                                                  DateTime.Now.Date), false);
                    filtres.AddFiltreForTable(CCategorieMasquageAlarme.c_nomTable, null, false);
                    DateTime dt = DateTime.Now;
                    // Créer le MemoryDB
                    bool bHasData = false;
                    result = ctx.FillWithModifsFromVersion(nIdLastSyncSession, nIdSyncMax, ref bHasData, filtres, true);
                    if (!result)
                    {
                        return(null);
                    }
                    TimeSpan sp = DateTime.Now - dt;
                    Console.WriteLine("Lecture modifs médiation : " + sp.TotalMilliseconds);
                    dt = DateTime.Now;
                    CDonneesSynchronisationMediation donneesSynchro = new CDonneesSynchronisationMediation(
                        CMemoryDbPourSupervision.GetMemoryDb(ctx), nIdSyncMax);


                    CListeObjetsDonnees lstObjets = new CListeObjetsDonnees(ctx, typeof(CSeveriteAlarme));
                    lstObjets.InterditLectureInDB = true;
                    foreach (CSeveriteAlarme severite in lstObjets)
                    {
                        severite.GetTypeForSupervision(donneesSynchro.Database);
                    }

                    lstObjets = new CListeObjetsDonnees(ctx, typeof(CTypeAlarme));
                    lstObjets.InterditLectureInDB = true;
                    foreach (CTypeAlarme type in lstObjets)
                    {
                        type.GetTypeForSupervision(donneesSynchro.Database, true);
                    }

                    lstObjets = new CListeObjetsDonnees(ctx, typeof(CTypeAgentSnmp));
                    lstObjets.InterditLectureInDB = true;
                    lstObjets.ReadDependances("TypesEntites");
                    foreach (CTypeAgentSnmp type in lstObjets)
                    {
                        type.GetTypeAgentPourSupervision(donneesSynchro.Database);
                    }

                    lstObjets = new CListeObjetsDonnees(ctx, typeof(CAgentSnmp));
                    lstObjets.InterditLectureInDB = true;
                    lstObjets.ReadDependances("EntitesSnmp", "EntitesSnmp.RelationsChampsCustom",
                                              "EntitesSnmp.SiteSupervise",
                                              "EntitesSnmp.EquipementLogiqueSupervise",
                                              "EntitesSnmp.EquipementLogiqueSupervise.Site",
                                              "EntitesSnmp.LienReseauSupervise");
                    foreach (CAgentSnmp agent in lstObjets)
                    {
                        agent.GetAgentPourSupervision(donneesSynchro.Database, true);
                    }

                    lstObjets = new CListeObjetsDonnees(ctx, typeof(CParametrageFiltrageAlarmes));
                    lstObjets.InterditLectureInDB = true;
                    foreach (CParametrageFiltrageAlarmes parametreFiltre in lstObjets)
                    {
                        parametreFiltre.GetLocalParametrageForSupervision(donneesSynchro.Database);
                    }

                    lstObjets = new CListeObjetsDonnees(ctx, typeof(CCategorieMasquageAlarme));
                    lstObjets.InterditLectureInDB = true;
                    foreach (CCategorieMasquageAlarme categorie in lstObjets)
                    {
                        categorie.GetLocalCategorieForSupervision(donneesSynchro.Database);
                    }

                    //S'assure que les entités des valeurs de champ entité sont chargés
                    lstObjets = new CListeObjetsDonnees(ctx, typeof(CRelationEntiteSnmp_ChampCustom));
                    lstObjets.InterditLectureInDB = true;
                    foreach (CRelationEntiteSnmp_ChampCustom rel in lstObjets)
                    {
                        if (rel != null && rel.ElementAChamps != null)
                        {
                            ((CObjetDonnee)rel.ElementAChamps).AssureData();
                        }
                    }

                    lstObjets = new CListeObjetsDonnees(ctx, typeof(CEntiteSnmp));
                    lstObjets.InterditLectureInDB = true;
                    foreach (CEntiteSnmp entite in lstObjets)
                    {
                        CTypeEntiteSnmp typeEntite = entite.TypeEntiteSnmp;
                        futurocom.snmp.entitesnmp.CTypeEntiteSnmpPourSupervision te = typeEntite.GetTypeEntitePourSupervision(donneesSynchro.Database, true);
                        entite.GetEntitePourSupervision(te);
                    }

                    sp = DateTime.Now - dt;
                    Console.WriteLine("Intégration modifs médiation : " + sp.TotalMilliseconds);
                    return(donneesSynchro);
                }
            }
        }
Ejemplo n.º 21
0
        //-------------------------------------
        /// <summary>
        /// Retourne tous les fils qui étaient affecté à l'objet à l'époque
        /// </summary>
        /// <param name="objet"></param>
        /// <param name="relationFille"></param>
        /// <returns></returns>
        public int[] GetIdsChildsHistoriques(CObjetDonneeAIdNumerique objet, CInfoRelation relationFille)
        {
            Type tpFils = CContexteDonnee.GetTypeForTable(relationFille.TableFille);

            if (!typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpFils))
            {
                return(new int[0]);
            }
            CChampPourVersionInDb champFille = new CChampPourVersionInDb(relationFille.ChampsFille[0], "");
            //Recherche toutes les modifications de la propriété fille
            CListeObjetsDonnees listeModifsFilles = new CListeObjetsDonnees(objet.ContexteDonnee, typeof(CVersionDonneesObjetOperation));

            listeModifsFilles.Filtre = new CFiltreDataAvance(
                CVersionDonneesObjetOperation.c_nomTable,
                CVersionDonneesObjetOperation.c_champChamp + "=@1 and " +
                CVersionDonneesObjetOperation.c_champTypeChamp + "=@2 and " +
                CVersionDonneesObjet.c_nomTable + "." +
                CVersionDonneesObjet.c_champTypeElement + "=@3 and " +
                CVersionDonneesObjet.c_nomTable + "." +
                CVersionDonnees.c_nomTable + "." +
                CVersionDonnees.c_champTypeVersion + "=@4 and " +
                CVersionDonneesObjet.c_nomTable + "." +
                CVersionDonnees.c_champId + ">=@5",
                champFille.FieldKey,
                champFille.TypeChampString,
                tpFils.ToString(),
                (int)CTypeVersion.TypeVersion.Archive,
                Id);
            listeModifsFilles.Tri = CVersionDonneesObjetOperation.c_champId + " desc";
            listeModifsFilles.ReadDependances("VersionObjet");

            ArrayList lstFils = new ArrayList();

            //Remplit la liste des fils avec les fils actuels
            //Récupère la liste de tous les fils actuels
            //et supprimés depuis. En effet, un element supprimé depuis cette version mais qui est
            //toujours lié à l'objet était donc lié à l'objet à l'époque
            C2iRequeteAvancee requete = new C2iRequeteAvancee(-1);

            requete.TableInterrogee = relationFille.TableFille;
            C2iChampDeRequete champDeRequete = new C2iChampDeRequete("ID",
                                                                     new CSourceDeChampDeRequete(objet.ContexteDonnee.GetTableSafe(relationFille.TableFille).PrimaryKey[0].ColumnName),
                                                                     typeof(int),
                                                                     OperationsAgregation.None,
                                                                     true);

            requete.ListeChamps.Add(champDeRequete);
            CFiltreData filtre = new CFiltreData(relationFille.ChampsFille[0] + "=@1 and (" +
                                                 CSc2iDataConst.c_champIdVersion + " is null or " +
                                                 CSc2iDataConst.c_champIdVersion + ">=@2)",
                                                 objet.Id,
                                                 Id);

            filtre.IgnorerVersionDeContexte = true;
            requete.FiltreAAppliquer        = filtre;
            CResultAErreur result = requete.ExecuteRequete(objet.ContexteDonnee.IdSession);

            if (result)
            {
                foreach (DataRow row in ((DataTable)result.Data).Rows)
                {
                    lstFils.Add(row[0]);
                }
            }


            foreach (CVersionDonneesObjetOperation data in listeModifsFilles)
            {
                if (data.GetValeur() is int && (int)data.GetValeur() == objet.Id)
                {
                    if (!lstFils.Contains(data.VersionObjet.IdElement))
                    {
                        lstFils.Add(data.VersionObjet.IdElement);
                    }
                }
                else
                {
                    lstFils.Remove(data.VersionObjet.IdElement);
                }
            }

            //Toutes les entités créées après la version ont également été ajoutées,
            //Donc n'y étaient pas
            if (lstFils.Count > 0)
            {
                StringBuilder builder = new StringBuilder();
                foreach (int nId in lstFils)
                {
                    builder.Append(nId.ToString());
                    builder.Append(",");
                }
                string strIds = builder.ToString();
                strIds  = strIds.Substring(0, strIds.Length - 1);
                requete = new C2iRequeteAvancee(-1);
                requete.TableInterrogee  = CVersionDonneesObjet.c_nomTable;
                requete.FiltreAAppliquer = new CFiltreData(
                    CVersionDonneesObjet.c_champIdElement + " in (" + strIds + ") and " +
                    CVersionDonneesObjet.c_champTypeElement + "=@1 and " +
                    CVersionDonneesObjet.c_champTypeOperation + "=@2 and " +
                    CVersionDonnees.c_champId + ">=@3",
                    tpFils.ToString(),
                    CTypeOperationSurObjet.TypeOperation.Ajout,
                    Id);
                requete.FiltreAAppliquer.IgnorerVersionDeContexte = true;
                requete.ListeChamps.Add(new C2iChampDeRequete("Id",
                                                              new CSourceDeChampDeRequete(CVersionDonneesObjet.c_champIdElement),
                                                              typeof(int),
                                                              OperationsAgregation.None,
                                                              true));
                result = requete.ExecuteRequete(ContexteDonnee.IdSession);
                if (result)
                {
                    foreach (DataRow row in ((DataTable)result.Data).Rows)
                    {
                        lstFils.Remove(row[0]);
                    }
                }
            }
            return((int[])lstFils.ToArray(typeof(int)));
        }
Ejemplo n.º 22
0
        public void UpdateOnglets()
        {
            this.SuspendDrawing();
            try
            {
                /*if (!LockEdition)
                 * {
                 *  //valide les modifs car on va tout supprimer
                 *  MAJ_Champs();
                 * }*/
                Crownwood.Magic.Controls.TabPage pageSelect = this.SelectedTab;
                m_bIsInitializing = true;
                Hashtable tablePagesToHide = new Hashtable();
                ArrayList pages            = new ArrayList(TabPages);
                foreach (Crownwood.Magic.Controls.TabPage page in pages)
                {
                    m_tablePagesInit[page] = false;
                    tablePagesToHide[page] = true;
                    TabPages.Remove(page);
                }

                if (m_elementEdite == null)
                {
                    return;
                }

                /* YK : On obtient la session de l'objet en cours d'édition au lieur de la session par défaut */
                CSessionClient           session     = null;
                IObjetDonneeAIdNumerique objetDonnee = m_elementEdite as IObjetDonneeAIdNumerique;
                if (objetDonnee != null)
                {
                    session = CSessionClient.GetSessionForIdSession(objetDonnee.ContexteDonnee.IdSession);
                }
                else
                {
                    session = CSessionClient.GetSessionUnique();
                }

                ArrayList lstFormulaires = new ArrayList(m_listeFormulaires);
                lstFormulaires.Sort(new CSorterFormulaires());
                //Lit les champs liés et leurs valeurs
                StringBuilder bl = new StringBuilder();
                foreach (CFormulaire formulaire in lstFormulaires)
                {
                    bl.Append(formulaire.Id);
                    bl.Append(",");
                }
                if (bl.Length > 0)
                {
                    bl.Remove(bl.Length - 1, 1);
                    CListeObjetsDonnees lst = new CListeObjetsDonnees(((CFormulaire)lstFormulaires[0]).ContexteDonnee, typeof(CFormulaire));
                    lst.Filtre = new CFiltreData(CFormulaire.c_champId + " in (" + bl.ToString() + ")");
                    lst.AssureLectureFaite();
                    lst.ReadDependances("RelationsChamps", "RelationsChamps.Champ", "RelationsChamps.Champ.ListeValeurs");
                }


                foreach (CFormulaire formulaire in lstFormulaires)
                {
                    Crownwood.Magic.Controls.TabPage page = null;
                    m_tableIdFormulaireToTabPage.TryGetValue(formulaire.Id, out page);
                    CCreateur2iFormulaireObjetDonnee createur = null;

                    if (page == null)
                    {
                        C2iWndFenetre wnd = formulaire.Formulaire;
                        if (wnd != null)
                        {
                            page      = new Crownwood.Magic.Controls.TabPage(wnd.Text);
                            page.Name = formulaire.IdUniversel;
                            if (wnd.Text == "")
                            {
                                page.Title = formulaire.Libelle;
                            }
                            TabPages.Add(page);
                            if (m_tableCreateurs.ContainsKey(page))
                            {
                                m_tableCreateurs.Remove(page);
                            }
                            m_tablePageTo2iWnd[page] = wnd;
                            m_tableIdFormulaireToTabPage[formulaire.Id] = page;
                            m_tablePageToIdFormulaire[page]             = formulaire.Id;
                        }
                    }
                    else
                    {
                        m_tableCreateurs.TryGetValue(page, out createur);
                    }

                    if (page != null)
                    {
                        if (!TabPages.Contains(page))
                        {
                            TabPages.Add(page);
                        }
                        tablePagesToHide.Remove(page);
                    }
                }


                /*CChampCustom[] champs = ElementEdite.GetChampsHorsFormulaire();
                 * if ( champs.Length != 0 )
                 * {
                 *  UpdatePageChamps( nRest );
                 *  if ( m_pageGrid != null )
                 *      tablePagesToHide.Remove(m_pageGrid);
                 * }*/
                foreach (Crownwood.Magic.Controls.TabPage pageToDel in tablePagesToHide.Keys)
                {
                    if (TabPages.Contains(pageToDel))
                    {
                        TabPages.Remove(pageToDel);
                    }
                }

                if (TabPages.Count == 1)
                {
                    this.HideTabsMode = Crownwood.Magic.Controls.TabControl.HideTabsModes.HideAlways;
                }
                else
                {
                    this.HideTabsMode = Crownwood.Magic.Controls.TabControl.HideTabsModes.ShowAlways;
                }
                if (TabPages.Contains(pageSelect))
                {
                    SelectedTab = pageSelect;
                }
                if (SelectedTab != null)
                {
                    InitPageWithObjetCourant(SelectedTab);
                }
            }
            finally
            {
                this.ResumeDrawing();
            }
            m_bIsInitializing = false;
        }
Ejemplo n.º 23
0
        public CResultAErreur Execute(int nIdSession, Hashtable valeursParametres)
        {
            CResultAErreur result = CResultAErreur.True;

            using (CContexteDonnee contexte = new CContexteDonnee(nIdSession, true, false))
            {
                try
                {
                    CHandlerEvenementServeur.SuspendGestionnaire(true);
                    contexte.EnableTraitementsAvantSauvegarde = false;

                    CListeObjetsDonnees lstInterventions = new CListeObjetsDonnees(contexte, typeof(CIntervention));
                    //*** DEBUG ***
                    //lstInterventions.Filtre = new CFiltreData(
                    //    CIntervention.c_champId + " > @1 ",
                    //    8500);
                    int compteur = lstInterventions.CountNoLoad;
                    // FIN DEBUG
                    lstInterventions.ReadDependances("PhaseTicket.Ticket.RelationsChampsCustom");
                    lstInterventions.ReadDependances("RelationsIntervenants");
                    foreach (CIntervention inter in lstInterventions)
                    {
                        compteur--;
                        CPhaseTicket phase = inter.PhaseTicket;
                        if (phase != null)
                        {
                            // Copier les compte rendu pour OTA depuis l'intervention vers le ticket
                            CTicket ticketLié = phase.Ticket;
                            // 113 = Id du champ [Compte rendu d'Intervention modifié]
                            string strCompteRendu = (string)inter.GetValeurChamp(113);
                            // 114 = Id du champ [Compte rendu résumé pour OTA]
                            ticketLié.SetValeurChamp(144, strCompteRendu);

                            // Affecter le technicien sur les Phases de ticket
                            CActeur acteur = null;
                            if (phase.GetValeurChamp(146) == null)
                            {
                                foreach (CIntervention_Intervenant rel in inter.RelationsIntervenants)
                                {
                                    acteur = rel.Intervenant;
                                    // 146 = Id du champ [Technicien affecté] sur Phase
                                    if (acteur != null)
                                    {
                                        phase.SetValeurChamp(146, acteur);
                                        break;
                                    }
                                }
                            }
                        }
                    }

                    result = contexte.SaveAll(true);
                    if (!result)
                    {
                        result.EmpileErreur("Erreur de sauvegarde des données");
                        return(result);
                    }
                }
                catch (Exception e)
                {
                    result.EmpileErreur(new CErreurException(e));
                }
                finally
                {
                    CHandlerEvenementServeur.SuspendGestionnaire(false);
                }
            }

            return(result);
        }
Ejemplo n.º 24
0
        //------------------------------------------------------------------------------------------
        public void ReadArbre(CListeObjetsDonnees listeSource, CListeObjetsDonnees.CArbreProps arbre, List <string> lstPaquetsALire)
        {
            string strIdChamp   = "";
            string strPropriete = "";
            string strCle       = "";

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

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

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

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

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

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

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

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

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

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

                lst.Filtre = new CFiltreDataAvance(
                    CContexteDonnee.GetNomTableForType(typeElementsFinaux),
                    strNomTableRelToChamp + "." + strChampCustomId + "=@1 and " +
                    strNomTableRelToChamp + "." + CRelationElementAChamp_ChampCustom.c_champValeurInt + " in " +
                    strPaquet,
                    dbKeyChamp.GetValeurInDb());
                lst.AssureLectureFaite();
                lst.ReadDependances(arbre);
            }
        }
Ejemplo n.º 25
0
        private CResultAErreur ImputeDureeSurActivite(CFractionIntervention fraction)
        {
            CResultAErreur result = CResultAErreur.True;

            if (fraction.DateDebut == null ||
                fraction.DateFin == null)
            {
                return(result);
            }
            if (fraction.TempsDeTravail == null)
            {
                return(result);
            }
            Hashtable tableToDelete = new Hashtable();

            //Stocke la liste des relations qui étaient présentes avant le travail
            //et les note comme étant à supprimer
            foreach (CIntervention_ActiviteActeur rel in fraction.RelationsActivite)
            {
                tableToDelete[rel] = true;
            }
            CTypeActiviteActeur typeActivite = fraction.Intervention.TypeIntervention.TypeActiviteActeur;
            bool bAvecSite = typeActivite.SiteObligatoire;

            if (typeActivite != null)
            {
                //Evalue les valeurs des champs custom pour l'activite
                CParametreRemplissageActiviteParIntervention parametreRemplissage = fraction.Intervention.TypeIntervention.ParametreRemplissageActivite;
                Dictionary <CChampCustom, object>            valeursChamps        = new Dictionary <CChampCustom, object>();
                CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(fraction);
                if (parametreRemplissage != null)
                {
                    foreach (CRemplisssageChampActiviteActeur remplissage in parametreRemplissage.ListeRemplissage)
                    {
                        CChampCustom champ = new CChampCustom(fraction.ContexteDonnee);

                        if (champ.ReadIfExists(remplissage.IdChampCustom))
                        {
                            C2iExpression formule = remplissage.Formule;
                            if (formule != null)
                            {
                                result = formule.Eval(ctxEval);
                                if (result)
                                {
                                    valeursChamps[champ] = result.Data;
                                }
                            }
                        }
                    }
                }

                foreach (CIntervention_Intervenant relIntervenant in fraction.Intervention.RelationsIntervenants)
                {
                    DateTime dt = ((DateTime)fraction.DateDebut).Date;

                    //Attention, si on est sur une fraction sur plusieurs jours, le
                    //pb est que la durée saisie (retenue pour l'intervention) peut
                    //ne pas être égale aux différents jours d'imputation,
                    //on réparti donc la durée de manière homogène sur les différents
                    //Jour en faisant un prorata de chaque jour
                    double fDureeAImputer = (double)fraction.TempsDeTravail;
                    double fDureeReelle   = (double)fraction.DureeReelle;


                    while (dt < (DateTime)fraction.DateFin && fDureeAImputer > 0)
                    {
                        //Cherche pour l'intervention ses activités du bon type
                        CFiltreData filtre = new CFiltreDataAvance(CActiviteActeur.c_nomTable,
                                                                   CTypeActiviteActeur.c_champId + "=@1 and " +
                                                                   CActiviteActeur.c_champDate + ">=@2 and " +
                                                                   CActiviteActeur.c_champDate + "<@3 and " +
                                                                   "Has(" + CIntervention_ActiviteActeur.c_nomTable + "." +
                                                                   CIntervention_ActiviteActeur.c_champId + ") and " +
                                                                   CActeur.c_champId + "=@4",
                                                                   typeActivite.Id,
                                                                   dt,
                                                                   dt.AddDays(1),
                                                                   relIntervenant.Intervenant.Id);
                        if (bAvecSite)
                        {
                            filtre = CFiltreData.GetAndFiltre(filtre,
                                                              new CFiltreData(CSite.c_champId + "=@1",
                                                                              fraction.Intervention.Site.Id));
                        }
                        CListeObjetsDonnees listeActivites = new CListeObjetsDonnees(fraction.ContexteDonnee, typeof(CActiviteActeur));
                        listeActivites.Filtre = filtre;
                        listeActivites.ReadDependances("RelationsInterventions");
                        CActiviteActeur activiteRetenue         = null;
                        CIntervention_ActiviteActeur relRetenue = null;
                        foreach (CActiviteActeur activite in listeActivites)
                        {
                            bool bPrendre = true;
                            foreach (KeyValuePair <CChampCustom, object> chpValeur in valeursChamps)
                            {
                                object valDeAct = activite.GetValeurChamp(chpValeur.Key.Id);
                                if (valDeAct == null && chpValeur.Value != null)
                                {
                                    bPrendre = false;
                                    break;
                                }
                                else if (chpValeur.Value == null && valDeAct != null)
                                {
                                    bPrendre = false;
                                    break;
                                }
                                else if (chpValeur.Value != null && !chpValeur.Value.Equals(valDeAct))
                                {
                                    bPrendre = false;
                                    break;
                                }
                            }
                            if (bPrendre)
                            {
                                activiteRetenue = activite;
                                relRetenue      = null;
                                foreach (CIntervention_ActiviteActeur relInter in activiteRetenue.RelationsInterventions)
                                {
                                    //Si l'activité est directement liée à cette fraction, prend celle ci de préférence
                                    if (relInter.FractionIntervention.Id == fraction.Id)
                                    {
                                        relRetenue = relInter;
                                        break;
                                    }
                                }
                            }
                        }
                        if (activiteRetenue == null)
                        {
                            //Création de l'activite
                            activiteRetenue = new CActiviteActeur(fraction.ContexteDonnee);
                            activiteRetenue.CreateNewInCurrentContexte();
                            activiteRetenue.TypeActiviteActeur = typeActivite;
                            activiteRetenue.Acteur             = relIntervenant.Intervenant;
                            activiteRetenue.Date  = dt;
                            activiteRetenue.Duree = 0;
                            if (bAvecSite)
                            {
                                activiteRetenue.Site = fraction.Intervention.Site;
                            }
                            foreach (KeyValuePair <CChampCustom, object> valChamp in valeursChamps)
                            {
                                activiteRetenue.SetValeurChamp(valChamp.Key.Id, valChamp.Value);
                            }
                        }
                        if (relRetenue == null)
                        {
                            //Création de la relation à l'interventation
                            relRetenue = new CIntervention_ActiviteActeur(fraction.ContexteDonnee);
                            relRetenue.ActiviteActeur       = activiteRetenue;
                            relRetenue.DureeImputee         = 0;
                            relRetenue.FractionIntervention = fraction;
                        }

                        //Note que cette relation ne doit pas être supprimée
                        tableToDelete[relRetenue] = false;

                        double fDureeForThis = 0;
                        if (dt == fraction.DateFin.Value.Date)
                        {
                            fDureeForThis = fDureeAImputer;                            //On affecte le reste
                        }
                        else
                        {
                            if (dt == fraction.DateDebut.Value.Date)
                            {
                                //On est sur le premier jour,
                                //Utilise comme référence le temps qui sépare la date
                                //de début de minuit
                                TimeSpan sp     = dt.AddDays(1) - fraction.DateDebut.Value;
                                double   fRatio = sp.TotalHours / fDureeReelle;
                                fDureeForThis = fRatio * fraction.TempsDeTravail.Value;
                            }
                            else
                            {
                                fDureeForThis = 24.0 / fDureeReelle * fraction.TempsDeTravail.Value;
                            }
                            //Arrondi la durée calculé à la minute
                            fDureeForThis = (int)fDureeForThis + (int)((fDureeForThis - (int)fDureeForThis) * 60.0 + .5) / 60.0;
                        }
                        fDureeAImputer -= fDureeForThis;

                        if (relRetenue.DureeImputee != fDureeForThis)
                        {
                            //Impute la durée de la fraction sur l'activité
                            relRetenue.ActiviteActeur.Duree -= relRetenue.DureeImputee;
                            relRetenue.DureeImputee          = (double)fDureeForThis;
                            relRetenue.ActiviteActeur.Duree += fDureeForThis;
                        }
                        dt = dt.AddDays(1);
                    }
                }
            }
            foreach (DictionaryEntry entry in tableToDelete)
            {
                if ((bool)entry.Value)
                {
                    //Supprime la relation
                    CIntervention_ActiviteActeur relToDelete = (CIntervention_ActiviteActeur)entry.Key;
                    if (relToDelete.Row.RowState != DataRowState.Deleted)
                    {
                        CActiviteActeur activiteAncienne = relToDelete.ActiviteActeur;
                        //SC 10/3/2014 : La désimputation du temps de l'activité se fait dans CIntervention_activiteActeurServeur.TraitementAvantSauvegardee
                        //activiteAncienne.Duree -= relToDelete.DureeImputee;
                        result = relToDelete.Delete(true);

                        /*if ( result && activiteAncienne.Duree == 0 )
                         *      result = activiteAncienne.Delete();
                         * if ( !result )
                         *      return result;*/
                    }
                }
            }
            return(result);
        }
Ejemplo n.º 26
0
        //------------------------------------------------------------------------
        public int[] GetIdsRessourcesLevant(int nIdContrainte, CFiltreDataAvance filtreParam)
        {
            Hashtable tblIdsRessourcesLevant = new Hashtable();

            using (CContexteDonnee contexteDonnee = new CContexteDonnee(IdSession, true, false))
            {
                CContrainte contrainte = new CContrainte(contexteDonnee);
                if (!contrainte.ReadIfExists(nIdContrainte))
                {
                    throw new Exception(I.T("Constraint Id @1 doesn't exist|197", nIdContrainte.ToString()));
                }


                // Liste des ressources levants de façon explicite (Relation directe)
                CListeObjetsDonnees listeRelationRessourceFiltre = contrainte.RelationRessourceListe;

                // Applique un filtre prédéfini par l'utilisateur de cette fonction
                CFiltreDataAvance filtreTmp = null;
                if (filtreParam != null)
                {
                    filtreTmp = (CFiltreDataAvance)filtreParam.GetClone();
                    filtreTmp.ChangeTableDeBase(CRelationContrainte_Ressource.c_nomTable, CRessourceMaterielle.c_nomTable);
                    listeRelationRessourceFiltre.Filtre = filtreTmp;
                }
                foreach (CRelationContrainte_Ressource rel in listeRelationRessourceFiltre)
                {
                    tblIdsRessourcesLevant[rel.Ressource.Id] = true;
                }

                if (contrainte.TypeContrainte != null)
                {
                    // Construit une filtre avancé sur les attributs de la contrainte
                    CFiltreData filtreAttributsRessources = contrainte.GetFiltreForRechercheRessourcesSurAttributs();

                    // Liste de toutes les resssources de la base
                    CListeObjetsDonnees lstRessources = new CListeObjetsDonnees(contexteDonnee, typeof(CRessourceMaterielle));
                    // Applique le filtre d'attributs à la liste
                    filtreAttributsRessources = CFiltreData.GetAndFiltre(filtreAttributsRessources, filtreParam);
                    lstRessources.Filtre      = filtreAttributsRessources;
                    // On obtient la liste des ressource ayant au moins un attribut en commun avec la Contrainte

                    // Vérifie le résultat de la recherche en fonction des options
                    // Si la ressource doit avoir au moins un des attributs de la contrainte
                    //Toutes les ressources trouvées sont bonnes !
                    if (!contrainte.TypeContrainte.OptionTousAttributsRessourceLevant)
                    {
                        foreach (CRessourceMaterielle res in lstRessources)
                        {
                            tblIdsRessourcesLevant[res.Id] = true;
                        }
                    }
                    else
                    {
                        CResultAErreur result = lstRessources.ReadDependances("AttributsListe");
                        if (!result)
                        {
                            throw new CExceptionErreur(result.Erreur);
                        }

                        // Sinon la ressource doit avoir tous les attributs de la contrainte
                        CFiltreData filtreTousLesAttributs = contrainte.GetFiltreSurAttributsRessource();

                        // Recherche dans la liste des resources possibles
                        foreach (CRessourceMaterielle res in lstRessources)
                        {
                            CListeObjetsDonnees attributsRessource = res.AttributsListe;
                            attributsRessource.InterditLectureInDB = true;
                            attributsRessource.Filtre = filtreTousLesAttributs;

                            string strRessource = res.Libelle;
                            int    nNbAttribs   = attributsRessource.Count;
                            nNbAttribs = contrainte.AttributsListe.Count;

                            // La ressource doit avoir tous les attributs de la contrainte
                            if (attributsRessource.Count == contrainte.AttributsListe.Count)
                            {
                                tblIdsRessourcesLevant[res.Id] = true;
                            }
                        }
                    }
                }

                List <int> lstRetour = new List <int>();
                foreach (int nId in tblIdsRessourcesLevant.Keys)
                {
                    lstRetour.Add(nId);
                }
                return(lstRetour.ToArray());
            }
        }