Ejemplo n.º 1
0
        internal override void InitFromElementDeSchema(CElementDeSchemaReseau elementDeSchema)
        {
            base.InitFromElementDeSchema(elementDeSchema);
            CLienReseau lien = elementDeSchema.LienReseau;

            if (lien == null)
            {
                throw new Exception("Bad element for supervision data ");
            }
            m_nIdLienSmt = lien.Id;
            CSpvLiai liaisonSpv = CSpvLiai.GetObjetSpvFromObjetTimos(lien);

            if (liaisonSpv != null)
            {
                m_dicLiaisonsSpvConcernant[liaisonSpv.Id] = true;
                m_nIdLienSpv = liaisonSpv.Id;
            }
            /* */
            CSchemaReseau schemaDeLiaison = lien.SchemaReseau;

            if (schemaDeLiaison != null)
            {
                CInfoSchemaDeSchemaSupervise info = new CInfoSchemaDeSchemaSupervise(this, null, m_base, NiveauProfondeur + 1);
                m_listeFils.Add(info);
                info.InitFromSchema(schemaDeLiaison);
            }

            //Si pas de schéma ou que le schéma ne contient pas les sites
            bool bHasElement1         = false;
            bool bHasElement2         = false;
            IElementALiensReseau elt1 = lien.Element1;
            IElementALiensReseau elt2 = lien.Element2;

            if (schemaDeLiaison != null)
            {
                foreach (CElementDeSchemaReseau elt in schemaDeLiaison.ElementsDeSchema)
                {
                    IElementALiensReseau eltAssocie = elt.ElementAssocie as IElementALiensReseau;
                    if (eltAssocie != null && eltAssocie.Equals(elt1))
                    {
                        bHasElement1 = true;
                    }
                    if (eltAssocie != null && eltAssocie.Equals(elt2))
                    {
                        bHasElement2 = true;
                    }
                    if (bHasElement1 && bHasElement2)
                    {
                        break;
                    }
                }
            }
            CSpvSite  site  = new CSpvSite(m_base.ContexteDonnee);
            CSpvEquip equip = new CSpvEquip(m_base.ContexteDonnee);

            if (!bHasElement1)
            {
                if (elt1 is CSite)
                {
                    if (site.ReadIfExists(new CFiltreData(CSpvSite.c_champSmtSite_Id + "=@1", elt1.Id), false))
                    {
                        m_dicSitesSpvConcernant[site.Id] = true;
                    }
                }
                else if (elt1 is CEquipementLogique)
                {
                    if (equip.ReadIfExists(new CFiltreData(CSpvEquip.c_champSmtEquipementLogique_Id + "=@1", elt1.Id), false))
                    {
                        m_dicEquipementsSpvConcernant[equip.Id] = true;
                    }
                }
            }
            if (!bHasElement2)
            {
                if (elt2 is CSite)
                {
                    if (site.ReadIfExists(new CFiltreData(CSpvSite.c_champSmtSite_Id + "=@1", elt2.Id), false))
                    {
                        m_dicSitesSpvConcernant[site.Id] = true;
                    }
                }
                else if (elt2 is CEquipementLogique)
                {
                    if (equip.ReadIfExists(new CFiltreData(CSpvEquip.c_champSmtEquipementLogique_Id + "=@1", elt2.Id), false))
                    {
                        m_dicEquipementsSpvConcernant[equip.Id] = true;
                    }
                }
            }
        }
Ejemplo n.º 2
0
        //////////////////////////////////////////////////////////////////
        private static void SynchroSchemaToSpv(
            CContexteDonnee contexte,
            Hashtable tableData,
            ref CResultAErreur result)
        {
            if (!result)
            {
                return;
            }
            //Empèche de passer plusieurs fois
            if (tableData.ContainsKey(typeof(CSynchroniseurSchemaEtGraphe)))
            {
                return;
            }
            //Pour empecher de passer plusieurs fois
            tableData[typeof(CSynchroniseurSchemaEtGraphe)] = true;

            //S'assure que les liens sont biens créés et que leurs schémas aussi !
            CSpvLiaiServeur.PropagerCLienReseau(contexte, tableData, ref result);
            if (!result)
            {
                return;
            }
            //Crée les services correspondants aux schémas modifiés

            //Toute modification d'un schéma est une modification du schéma auquel il appartient
            CListeObjetsDonnees lstSchemas = new CListeObjetsDonnees(contexte, typeof(CSchemaReseau), false);

            lstSchemas.InterditLectureInDB = true;
            foreach (CSchemaReseau schema in lstSchemas.ToArrayList())
            {
                CSchemaReseau tmp = schema;
                while (tmp != null && tmp.Row.RowState == DataRowState.Modified)
                {
                    tmp = tmp.SchemaParent;
                    if (tmp != null)
                    {
                        tmp.ForceChangementSyncSession();
                    }
                }
            }

            DataTable table = contexte.Tables[CSchemaReseau.c_nomTable];

            if (table == null)
            {
                //S'il n'y a pas de schéma, mais qu'il y a des éléments de schéma,
                //force la vérification des schémas

                if (contexte.Tables.Contains(CElementDeSchemaReseau.c_nomTable))
                {
                    table = contexte.GetTableSafe(CSchemaReseau.c_nomTable);
                }
            }
            if (table != null)
            {
                #region Recherche des schémas modifiés
                ArrayList lst = new ArrayList(table.Rows);
                //Cherche les schémas à vérifier
                Dictionary <DataRow, bool> dicSchemasAVerifier = new Dictionary <DataRow, bool>();
                foreach (DataRow row in lst)
                {
                    if (row.RowState == DataRowState.Modified || row.RowState == DataRowState.Added)
                    {
                        dicSchemasAVerifier[row] = true;
                    }
                }
                DataTable tableElts = contexte.Tables[CElementDeSchemaReseau.c_nomTable];
                if (tableElts != null)
                {
                    lst = new ArrayList(tableElts.Rows);
                    foreach (DataRow row in lst)
                    {
                        if (row.RowState == DataRowState.Added || row.RowState == DataRowState.Modified || row.RowState == DataRowState.Deleted)
                        {
                            CElementDeSchemaReseau elt = new CElementDeSchemaReseau(row);
                            if (row.RowState == DataRowState.Deleted)
                            {
                                elt.VersionToReturn = DataRowVersion.Original;
                            }
                            CSchemaReseau schema = elt.SchemaReseau;
                            if (schema != null && schema.IsValide())
                            {
                                dicSchemasAVerifier[schema.Row] = true;
                            }
                            while (schema != null && schema.IsValide() && schema.SchemaParent != null)
                            {
                                dicSchemasAVerifier[schema.SchemaParent.Row] = true;
                                schema = schema.SchemaParent;
                            }
                        }
                    }
                }
                #endregion

                //Passe sur tous les schémas modifiés
                foreach (DataRow row in dicSchemasAVerifier.Keys)
                {
                    #region Création du service, création des cablages
                    CSchemaReseau schema = new CSchemaReseau(row);
                    //Synchronisation du service avec le schéma
                    CSpvSchemaReseau spvSchema = CSpvSchemaReseau.GetObjetSpvFromObjetTimosAvecCreation(schema);

                    //Si le schéma correspond à un lien, force la modification de ce lien
                    //Pour passer dans le traitement avant sauvegarde du lien
                    if (schema.LienReseau != null)
                    {
                        if (schema.LienReseau.Row.RowState == DataRowState.Unchanged)
                        {
                            schema.LienReseau.ForceChangementSyncSession();//Force la modification du lien pour qu'il soit resynchronisé
                        }
                    }
                    #endregion
                }
            }



            //Pour tous les schémas qui ont des éléments modifiés, s'assure que les
            //Graphes des services concernés sont à jour
            //Id de schéma -> true
            Dictionary <int, bool> schemasAGrapheObsolete = new Dictionary <int, bool>();
            table = contexte.Tables[CElementDeSchemaReseau.c_nomTable];
            if (table != null)
            {
                ArrayList lstRows = new ArrayList(table.Rows);
                foreach (DataRow row in lstRows)
                {
                    if (row.RowState == DataRowState.Added || row.RowState == DataRowState.Deleted)
                    {
                        CElementDeSchemaReseau elt     = new CElementDeSchemaReseau(row);
                        DataRowVersion         version = DataRowVersion.Current;
                        if (row.RowState == DataRowState.Deleted)
                        {
                            version = DataRowVersion.Original;
                        }
                        schemasAGrapheObsolete[(int)row[CElementDeSchemaReseau.c_champIdSchemaReseauAuquelJappartiens, version]] = true;
                    }
                }
            }
            table = contexte.Tables[CSchemaReseau.c_nomTable];
            if (table != null)
            {
                ArrayList lstRows = new ArrayList(table.Rows);
                foreach (DataRow row in lstRows)
                {
                    if (row.RowState == DataRowState.Added || row.RowState == DataRowState.Modified)
                    {
                        schemasAGrapheObsolete[(int)row[CSchemaReseau.c_champId]] = true;
                    }
                }
            }

            CBaseGraphesReseau baseGraphes = new CBaseGraphesReseau();
            foreach (int nIdSchema in schemasAGrapheObsolete.Keys)
            {
                CSchemaReseau schema = new CSchemaReseau(contexte);
                if (
                    schema.ReadIfExists(nIdSchema) &&
                    schema.IsValide() &&
                    (schema.SchemaParent == null || schema.SiteApparenance != null)) //Ne calcule pas les graphes des schémas fils, ils sont déjà integrés dans le graphe du schéma parent!
                {
                    CSpvSchemaReseau spvSchema = CSpvSchemaReseau.GetObjetSpvFromObjetTimosAvecCreation(schema);
                    if (spvSchema != null)
                    {
                        result = spvSchema.RecalculeArbreOperationnelInContexte(baseGraphes);
                        if (!result)
                        {
                            return;
                        }
                    }
                }
            }
        }
Ejemplo n.º 3
0
        internal override void InitFromElementDeSchema(CElementDeSchemaReseau elementDeSchema)
        {
            base.InitFromElementDeSchema(elementDeSchema);
            CLienReseau lien = elementDeSchema.LienReseau;

            if (lien == null)
            {
                throw new Exception("Bad element for supervision data ");
            }
            m_dbKeyLien = lien.DbKey;

            CSchemaReseau schemaDeLiaison = lien.SchemaReseau;

            if (schemaDeLiaison != null)
            {
                CInfoSchemaDeSchemaSupervise info = new CInfoSchemaDeSchemaSupervise(this, null, m_base, NiveauProfondeur + 1);
                m_listeFils.Add(info);
                info.InitFromSchema(schemaDeLiaison);
            }

            //Si pas de schéma ou que le schéma ne contient pas les sites
            bool bHasElement1         = false;
            bool bHasElement2         = false;
            IElementALiensReseau elt1 = lien.Element1;
            IElementALiensReseau elt2 = lien.Element2;

            if (schemaDeLiaison != null)
            {
                foreach (CElementDeSchemaReseau elt in schemaDeLiaison.ElementsDeSchema)
                {
                    IElementALiensReseau eltAssocie = elt.ElementAssocie as IElementALiensReseau;
                    if (eltAssocie != null && eltAssocie.Equals(elt1))
                    {
                        bHasElement1 = true;
                    }
                    if (eltAssocie != null && eltAssocie.Equals(elt2))
                    {
                        bHasElement2 = true;
                    }
                    if (bHasElement1 && bHasElement2)
                    {
                        break;
                    }
                }
            }
            IElementALiensReseau extremite = lien.Element1;

            if (extremite is CSite)
            {
                m_dicSitesConcernant[extremite.DbKey] = true;
            }
            if (extremite is CEquipementLogique)
            {
                m_dicEquipementsConcernant[extremite.DbKey] = true;
            }
            extremite = lien.Element2;
            if (extremite is CSite)
            {
                m_dicSitesConcernant[extremite.DbKey] = true;
            }
            if (extremite is CEquipement)
            {
                m_dicEquipementsConcernant[extremite.DbKey] = true;
            }
            m_dicLiaisonsConcernant[lien.DbKey] = true;
        }
Ejemplo n.º 4
0
 //-------------------------------------------------------------------------
 public CFormEditionSchemaReseau(CSchemaReseau type_lien)
     : base(type_lien)
 {
     // Cet appel est requis par le Concepteur Windows Form.
     InitializeComponent();
 }
Ejemplo n.º 5
0
 //-------------------------------------------------------------------------
 public CFormEditionSchemaReseau(CSchemaReseau type_lien, CListeObjetsDonnees liste)
     : base(type_lien, liste)
 {
     // Cet appel est requis par le Concepteur Windows Form.
     InitializeComponent();
 }
Ejemplo n.º 6
0
 //---------------------------------------------------
 public C2iSchemaReseau(CSchemaReseau schema)
 {
     m_schema = schema;
 }
Ejemplo n.º 7
0
        protected void PrepareSupervisionEtatOperationnel(CSchemaReseau schema)
        {
            m_listeGraphes.Clear();
            m_baseChemins.Clear();
            List <ESensAllerRetourLienReseau?> lstToCalcul = new List <ESensAllerRetourLienReseau?>();

            if (schema.LienReseau != null)
            {
                lstToCalcul.Add(null);
            }
            else
            {
                lstToCalcul.Add(ESensAllerRetourLienReseau.Forward);
                lstToCalcul.Add(ESensAllerRetourLienReseau.Backward);
            }
            foreach (ESensAllerRetourLienReseau?sens in lstToCalcul)
            {
                CGrapheReseau graphe = m_base.BaseGraphes.GetGrapheExistant(schema, sens);
                if (graphe == null)
                {
                    graphe = new CGrapheReseau(m_base.BaseGraphes);
                    graphe.IntegreLiaison = IntegreLienInGraphe;
                    if (graphe.CalculeGraphe(schema, sens))
                    {
                        m_listeGraphes.Add(graphe);
                    }
                }
                else
                {
                    m_listeGraphes.Add(graphe);
                }
            }
            if (m_listeGraphes.Count == 2)
            {
                //Si l'un des graphes a des liens et pas l'autre, supprime ce graphe
                int nNbLiens1 = m_listeGraphes[0].GetLiensNiveau0().Length;
                int nNbLiens2 = m_listeGraphes[1].GetLiensNiveau0().Length;
                if (nNbLiens1 == 0 && nNbLiens2 != 0)
                {
                    m_listeGraphes.RemoveAt(0);
                }
                else if (nNbLiens2 == 0)
                {
                    m_listeGraphes.RemoveAt(1);
                }
            }


            //Calcule tous les chemins de point d'entrée à point de sortie.
            m_baseChemins.Clear();
            m_dicNoeudsIsoles = new Dictionary <CNoeudDeGrapheReseau, bool>();
            if (m_listeGraphes.Count > 0)
            {
                foreach (CNoeudDeGrapheReseau noeud in m_listeGraphes[0].GetNoeudsIsoles())
                {
                    m_dicNoeudsIsoles[noeud] = true;
                }
            }
            int nIndex = 0;

            foreach (CGrapheReseau graphe in m_listeGraphes)
            {
                List <CNoeudDeGrapheReseau> noeudsDepart;
                List <CNoeudDeGrapheReseau> noeudsArrive;
                if (schema.LienReseau != null)
                {
                    noeudsDepart = new List <CNoeudDeGrapheReseau>();
                    noeudsArrive = new List <CNoeudDeGrapheReseau>();
                    CLienReseau                 lien = schema.LienReseau;
                    CNoeudDeGrapheReseau        noeud;
                    List <EDirectionLienReseau> lstCodes = new List <EDirectionLienReseau>();
                    if (lien.Direction.Code == EDirectionLienReseau.Bidirectionnel)
                    {
                        lstCodes.Add(EDirectionLienReseau.UnVersDeux);
                        lstCodes.Add(EDirectionLienReseau.DeuxVersUn);
                    }
                    else
                    {
                        lstCodes.Add(lien.Direction.Code);
                    }
                    foreach (EDirectionLienReseau direction in lstCodes)
                    {
                        switch (direction)
                        {
                        case EDirectionLienReseau.UnVersDeux:
                            noeud = graphe.GetNoeudForElement(lien.Element1, schema);
                            if (noeud != null)
                            {
                                noeudsDepart.Add(noeud);
                            }
                            noeud = graphe.GetNoeudForElement(lien.Element2, schema);
                            if (noeud != null)
                            {
                                noeudsArrive.Add(noeud);
                            }
                            break;

                        case EDirectionLienReseau.DeuxVersUn:
                            noeud = graphe.GetNoeudForElement(lien.Element2, schema);
                            if (noeud != null)
                            {
                                noeudsDepart.Add(noeud);
                            }
                            noeud = graphe.GetNoeudForElement(lien.Element1, schema);
                            if (noeud != null)
                            {
                                noeudsArrive.Add(noeud);
                            }
                            break;
                        }
                    }
                }
                else
                {
                    noeudsDepart = new List <CNoeudDeGrapheReseau>(graphe.GetNoeudsEntreeNiveau0());
                    noeudsArrive = new List <CNoeudDeGrapheReseau>(graphe.GetNoeudsSortieNiveau0());
                }

                foreach (CNoeudDeGrapheReseau noeudDepart in noeudsDepart)
                {
                    foreach (CNoeudDeGrapheReseau noeudArrivee in noeudsArrive)
                    {
                        CPointAPointDeGraphe         pap     = new CPointAPointDeGraphe(noeudDepart, noeudArrivee);
                        List <CCheminDeGrapheReseau> chemins = graphe.GetChemins(noeudDepart, noeudArrivee);
                        m_baseChemins.AddChemins(pap, chemins);
                        if (chemins.Count != 0)
                        {
                            if (m_dicNoeudsIsoles.ContainsKey(noeudDepart))
                            {
                                m_dicNoeudsIsoles.Remove(noeudDepart);
                            }
                            if (m_dicNoeudsIsoles.ContainsKey(noeudArrivee))
                            {
                                m_dicNoeudsIsoles.Remove(noeudArrivee);
                            }
                        }
                    }
                }
            }
        }
Ejemplo n.º 8
0
        /// <summary>
        /// Calcule un graphe pour un schéma donné
        /// </summary>
        /// <param name="schema"></param>
        /// <param name="sens"></param>
        /// <returns></returns>
        public CResultAErreur CalculeGraphe(
            CSchemaReseau schema,
            ESensAllerRetourLienReseau?sens)
        {
            CResultAErreur result = CResultAErreur.True;

            m_baseDeGraphes.AddGrapheReseau(schema.Id, sens, this);
            m_sensGraphe            = sens;
            m_nIdSchemaReseauRacine = schema.Id;
            m_baseLiens.Clear();
            m_baseNoeuds.Clear();
            m_dicSuccesseurs.Clear();
            m_dicPredecesseurs.Clear();
            Dictionary <int, CNoeudDeGrapheReseauSite>       dicIdSiteToNoeud       = new Dictionary <int, CNoeudDeGrapheReseauSite>();
            Dictionary <int, CNoeudDeGrapheReseauEquipement> dicIdEquipementToNoeud = new Dictionary <int, CNoeudDeGrapheReseauEquipement>();

            foreach (CElementDeSchemaReseau elt in schema.ElementsDeSchema)//Ne prend que les éléments de premier niveau
            {
                CSite site = elt.ElementAssocie as CSite;
                if (site != null)
                {
                    CNoeudDeGrapheReseauSite noeud = new CNoeudDeGrapheReseauSite(site.Id, schema.Id, elt.IsCableALinterieur);
                    if (!m_baseNoeuds.Contains(noeud))
                    {
                        if (IntegreNoeud == null || IntegreNoeud(noeud))
                        {
                            m_baseNoeuds.Add(noeud);
                            dicIdSiteToNoeud[site.Id] = noeud;
                        }
                    }
                }
                else
                {
                    CEquipementLogique eqpt = elt.ElementAssocie as CEquipementLogique;
                    if (eqpt != null)
                    {
                        CNoeudDeGrapheReseauEquipement noeud = new CNoeudDeGrapheReseauEquipement(eqpt.Id, schema.Id);
                        if (!m_baseNoeuds.Contains(noeud))
                        {
                            if (IntegreNoeud == null || IntegreNoeud(noeud))
                            {
                                m_baseNoeuds.Add(noeud);
                                dicIdEquipementToNoeud[eqpt.Id] = noeud;
                            }
                        }
                    }
                }
            }

            Dictionary <int, CGrapheReseau> dicGraphesCalcules = new Dictionary <int, CGrapheReseau>();

            foreach (CElementDeSchemaReseau elt in schema.GetElementsForType <CLienReseau>())
            {
                if (elt.SchemaReseau.Id == schema.Id) //Ne prend pas les sous schémas
                {
                    CLienReseau lien = elt.ElementAssocie as CLienReseau;
                    if (lien != null)
                    {
                        if (m_sensGraphe != null)
                        {
                            CDonneeDessinLienDeSchemaReseau donneeDessin = elt.DonneeDessin as CDonneeDessinLienDeSchemaReseau;
                            if (donneeDessin == null)
                            {
                                continue;
                            }
                            if (m_sensGraphe.Value != donneeDessin.Forward_Backward)
                            {
                                continue;
                            }
                        }
                        EDirectionLienReseau[] directions = new EDirectionLienReseau[]
                        {
                            EDirectionLienReseau.UnVersDeux,
                            EDirectionLienReseau.DeuxVersUn
                        };
                        foreach (EDirectionLienReseau direction in directions)
                        {
                            if (direction == lien.Direction.Code || lien.Direction == EDirectionLienReseau.Bidirectionnel)
                            {
                                int nSigne = direction == EDirectionLienReseau.UnVersDeux ? 1 : -1;
                                IElementALiensReseau elt1    = null;
                                IElementALiensReseau elt2    = null;
                                CCheminLienReseau    chemin1 = null;
                                CCheminLienReseau    chemin2 = null;
                                if (direction == EDirectionLienReseau.UnVersDeux)
                                {
                                    elt1    = lien.Element1;
                                    chemin1 = elt.RacineChemin1;
                                    elt2    = lien.Element2;
                                    chemin2 = elt.RacineChemin2;
                                }
                                else if (direction == EDirectionLienReseau.DeuxVersUn)
                                {
                                    elt1    = lien.Element2;
                                    chemin1 = elt.RacineChemin2;
                                    elt2    = lien.Element1;
                                    chemin2 = elt.RacineChemin2;
                                }
                                if (!(elt1 is CSite) && !(elt1 is CEquipementLogique))
                                {
                                    elt1 = null;
                                }
                                if (!(elt2 is CSite) && !(elt2 is CEquipementLogique))
                                {
                                    elt2 = null;
                                }
                                if (elt1 != null && elt2 != null)
                                {
                                    CNoeudDeGrapheReseau noeud1 = null;
                                    if (chemin1 != null)
                                    {
                                        result = GetNoeudDansSousSchema(elt1, chemin1);//Result testé ensuite avec noeud1 = null;
                                        noeud1 = result.Data as CNoeudDeGrapheReseau;
                                    }
                                    else
                                    {
                                        if (elt1 is CSite)
                                        {
                                            CNoeudDeGrapheReseauSite noeudSite = null;
                                            dicIdSiteToNoeud.TryGetValue(elt1.Id, out noeudSite);
                                            noeud1 = noeudSite;
                                        }
                                        else if (elt1 is CEquipementLogique)
                                        {
                                            CNoeudDeGrapheReseauEquipement noeudEqpt = null;
                                            dicIdEquipementToNoeud.TryGetValue(elt1.Id, out noeudEqpt);
                                            noeud1 = noeudEqpt;
                                        }
                                    }
                                    if (noeud1 == null)
                                    {
                                        result.EmpileErreur(I.T("Can not find link @1 extremity|20043", lien.Libelle));
                                        return(result);
                                    }

                                    CNoeudDeGrapheReseau noeud2 = null;
                                    if (chemin2 != null)
                                    {
                                        result = GetNoeudDansSousSchema(elt2, chemin2);//Result testé ensuite avec noeud2= null;
                                        noeud2 = result.Data as CNoeudDeGrapheReseau;
                                    }
                                    else
                                    {
                                        if (elt2 is CSite)
                                        {
                                            CNoeudDeGrapheReseauSite noeudSite = null;
                                            dicIdSiteToNoeud.TryGetValue(elt2.Id, out noeudSite);
                                            noeud2 = noeudSite;
                                        }
                                        else if (elt2 is CEquipementLogique)
                                        {
                                            CNoeudDeGrapheReseauEquipement noeudEquip = null;
                                            dicIdEquipementToNoeud.TryGetValue(elt2.Id, out noeudEquip);
                                            noeud2 = noeudEquip;
                                        }
                                    }
                                    if (noeud2 == null)
                                    {
                                        result.EmpileErreur(I.T("Can not find link @1 extremity|20043", lien.Libelle));
                                        return(result);
                                    }

                                    CLienDeGrapheReseau lienDeGraphe = m_baseLiens.GetObjet(typeof(CLienDeGrapheReseau), nSigne * lien.Id, schema.Id);
                                    if (lienDeGraphe == null)
                                    {
                                        CEtapesExtremiteLienDeGraphe etapes1 = null;
                                        if (chemin1 != null)
                                        {
                                            etapes1 = new CEtapesExtremiteLienDeGraphe(chemin1);
                                        }
                                        CEtapesExtremiteLienDeGraphe etapes2 = null;
                                        if (chemin2 != null)
                                        {
                                            etapes2 = new CEtapesExtremiteLienDeGraphe(chemin2);
                                        }

                                        lienDeGraphe = new CLienDeGrapheReseau(
                                            nSigne * lien.Id,
                                            schema.Id,
                                            noeud1,
                                            noeud2,
                                            etapes1,
                                            etapes2);
                                        if (IntegreLiaison == null || IntegreLiaison(lienDeGraphe))
                                        {
                                            m_baseLiens.Add(lienDeGraphe);
                                            m_dicSuccesseurs.AddSuccesseur(noeud1, lienDeGraphe);
                                            m_dicPredecesseurs.AddPredecesseur(noeud2, lienDeGraphe);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return(result);
        }
Ejemplo n.º 9
0
 public CNoeudDeGrapheReseauEquipement GetNoeudForEquipement(CEquipementLogique equipement, CSchemaReseau schema)
 {
     if (equipement == null || schema == null)
     {
         return(null);
     }
     return(m_baseNoeuds.GetObjet(typeof(CNoeudDeGrapheReseauEquipement), equipement.Id, schema.Id) as CNoeudDeGrapheReseauEquipement);
 }
Ejemplo n.º 10
0
        public C2iSchemaReseau GetSchemaReseauADessiner(bool bCreationAutorisee)
        {
            C2iSchemaReseau schemaADessiner;

            if (SchemaReseau != null)
            {
                if (SchemaReseau.GetSchema(bCreationAutorisee) != null)
                {
                    schemaADessiner = SchemaReseau.GetSchema(bCreationAutorisee);
                }
                else
                {
                    schemaADessiner = new C2iSchemaReseau(SchemaReseau);
                }
            }
            else if (bCreationAutorisee)
            {
                CSchemaReseau schema = GetSchemaReseauCreateIfNull();
                schema.CreateNewInCurrentContexte();
                schema.LienReseau = this;
                schema.Libelle    = this.Libelle;

                schemaADessiner = schema.GetSchema(bCreationAutorisee);
            }
            else
            {
                return(null);
            }

            bool bFindObjet1 = false;
            bool bFindObjet2 = false;

            foreach (C2iObjetDeSchema objet in schemaADessiner.Childs)
            {
                if (objet.ElementDeSchema != null && objet.ElementDeSchema.ElementAssocie != null)
                {
                    if (objet.ElementDeSchema.ElementAssocie.Equals(Element1))
                    {
                        bFindObjet1 = true;
                    }

                    if (objet.ElementDeSchema.ElementAssocie.Equals(Element2))
                    {
                        bFindObjet2 = true;
                    }
                }
            }

            if (!bFindObjet1 && Element1 != null)
            {
                CElementDeSchemaReseau elt1 = new CElementDeSchemaReseau(ContexteDonnee);
                elt1.CreateNewInCurrentContexte();
                elt1.SchemaReseau   = SchemaReseau;
                elt1.ElementAssocie = Element1;
                C2iObjetDeSchema objet1 = elt1.ObjetDeSchema;
                schemaADessiner.AddChild(objet1);
                objet1.Parent   = schemaADessiner;
                objet1.Position = new Point(10, 10);
                elt1.X          = objet1.Position.X;
                elt1.Y          = objet1.Position.Y;
            }

            if (!bFindObjet2 && Element2 != null)
            {
                CElementDeSchemaReseau elt2 = new CElementDeSchemaReseau(ContexteDonnee);
                elt2.CreateNewInCurrentContexte();
                elt2.SchemaReseau   = SchemaReseau;
                elt2.ElementAssocie = Element2;
                C2iObjetDeSchema objet2 = elt2.ObjetDeSchema;
                schemaADessiner.AddChild(objet2);
                objet2.Parent   = schemaADessiner;
                objet2.Position = new Point(10, 400);
                elt2.X          = objet2.Position.X;
                elt2.Y          = objet2.Position.Y;
            }

            C2iLienDeSchemaReseauNoDelete lienGraphiqueEdite = new C2iLienDeSchemaReseauNoDelete();

            lienGraphiqueEdite.LienReseau = this;
            schemaADessiner.AddChild(lienGraphiqueEdite);
            lienGraphiqueEdite.Parent = schemaADessiner;
            schemaADessiner.FrontToBack(lienGraphiqueEdite);



            return(schemaADessiner);
        }
Ejemplo n.º 11
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.º 12
0
        //-------------------------------------------------
        /// <summary>
        /// Calcule l'arbre entre deux noeuds pour un schéma
        /// </summary>
        /// <param name="schema"></param>
        /// <param name="graphe"></param>
        /// <param name="noeudDepart"></param>
        /// <param name="noeudArrivee"></param>
        /// <returns></returns>
        public CResultAErreur CalculArbreRedondanceAuto(
            CSchemaReseau schema,
            CGrapheReseau graphe,
            CNoeudDeGrapheReseau noeudDepart,
            CNoeudDeGrapheReseau noeudArrivee)
        {
            CResultAErreur result = CResultAErreur.True;

            CNoeudDeGrapheReseau[] noeudsEntree;
            if (noeudDepart != null)
            {
                noeudsEntree = new CNoeudDeGrapheReseau[] { noeudDepart }
            }
            ;
            else if (schema.LienReseau == null)  //Ce n'est pas un schéma de lien
            {
                noeudsEntree = graphe.GetNoeudsEntreeNiveau0();
            }
            else
            {
                noeudsEntree = new CNoeudDeGrapheReseau[] {
                    graphe.GetNoeudForElement(schema.LienReseau.Element1, schema)
                };
            }
            CNoeudDeGrapheReseau[] noeudsSortie;
            if (noeudArrivee != null)
            {
                noeudsSortie = new CNoeudDeGrapheReseau[] { noeudArrivee }
            }
            ;
            else if (schema.LienReseau == null)  //Ce n'est pas un schéma de lien
            {
                noeudsSortie = graphe.GetNoeudsSortieNiveau0();
            }
            else
            {
                noeudsSortie = new CNoeudDeGrapheReseau[] {
                    graphe.GetNoeudForElement(schema.LienReseau.Element2, schema)
                };
            }

            CElementDeArbreOperationnelOperateurEt eltSource = new CElementDeArbreOperationnelOperateurEt(null);

            m_elementRacine = eltSource;

            //Ajoute les éléments seuls
            foreach (CNoeudDeGrapheReseau noeud in graphe.GetNoeudsIsoles())
            {
                if (schema.LienReseau == null || noeud.Equals(noeudsEntree[0]) || noeud.Equals(noeudsSortie[0]))
                //si c'est un schéma de lien n'ajoute que les noeuds isolé correspondant à l'entrée ou à la sortie
                {
                    CElementDeArbreOperationnelEntite composant = new CElementDeArbreOperationnelEntite(eltSource, noeud);
                    eltSource.AddFils(composant);
                    result = composant.GetElementCablage(graphe.SensDuGraphe, schema.ContexteDonnee);
                    if (!result)
                    {
                        return(result);
                    }
                    CElementDeArbreOperationnel elementCablage = result.Data as CElementDeArbreOperationnel;
                    if (elementCablage != null)
                    {
                        eltSource.AddFils(elementCablage);
                    }
                }
            }

            foreach (CNoeudDeGrapheReseau noeudEntree in noeudsEntree)
            {
                foreach (CNoeudDeGrapheReseau noeudSortie in noeudsSortie)
                {
                    List <CCheminDeGrapheReseau> chemins = graphe.GetChemins(noeudEntree, noeudSortie);
                    if (chemins.Count() > 0)
                    {
                        CElementDeArbreOperationnelOperateurOu ouPourExtremites = new CElementDeArbreOperationnelOperateurOu(eltSource);
                        eltSource.AddFils(ouPourExtremites);
                        foreach (CCheminDeGrapheReseau chemin in chemins) //parcours tous les chemins en mettant un ou dessus
                        {
                            Stack <CRacineDeSchema> lstRacines = new Stack <CRacineDeSchema>();
                            CRacineDeSchema         racine     = new CRacineDeSchema(schema.Id, null, new CElementDeArbreOperationnelOperateurEt(ouPourExtremites));
                            ouPourExtremites.AddFils(racine.ElementRacine);
                            lstRacines.Push(racine);
                            int nLien = 0;
                            foreach (CLienDeGrapheReseau lien in chemin.Liens)
                            {
                                CRacineDeSchema racineEnCours = lstRacines.Peek();
                                if (lien.EtapesNoeudDepart != null)
                                {
                                    int[] idsSchemas = lien.EtapesNoeudDepart.IdsSchemas;
                                    //Dépile les sous schémas
                                    for (int nEtape = idsSchemas.Count() - 1; nEtape >= 0; nEtape--)
                                    {
                                        int nIdSchema = idsSchemas[nEtape];
                                        if (racineEnCours.IdSchema != nIdSchema)
                                        {
                                            result.EmpileErreur(I.T("Bad path for link @1 in graph for @2 diagram|20050",
                                                                    lien.IdLienReseau.ToString(), lien.IdSchemaReseau.ToString()));
                                            return(result);
                                        }
                                        if (racineEnCours.ElementSousSchema != null)
                                        {
                                            racineEnCours.ElementSousSchema.NoeudArrive = lien.NoeudDepart;
                                        }
                                        lstRacines.Pop();
                                        racineEnCours = lstRacines.Peek();
                                    }
                                }
                                //Si les extremités du lien sont cablées, le lien est dans un et, sinon,
                                //il est directement sous la racine en cours
                                CElementDeArbreOperationnelOperateur elementParentDeLien = racineEnCours.ElementRacine;

                                //Si ce n'est pas le dernier lien, on ajoute que les cablages des noeuds de départ,
                                //Puisque le cablage du noeud d'arrivé sera le cablage du noeud de départ du prochain lien
                                //Par contre, si c'est le dernier lien du chemin, il faut ajouter ce cablage

                                if ((lien.NoeudDepart is CNoeudDeGrapheReseauSite && ((CNoeudDeGrapheReseauSite)lien.NoeudDepart).IsCable) ||
                                    (nLien == chemin.Liens.Count() - 1 && (lien.NoeudArrive is CNoeudDeGrapheReseauSite && ((CNoeudDeGrapheReseauSite)lien.NoeudArrive).IsCable)))
                                {
                                    elementParentDeLien = new CElementDeArbreOperationnelOperateurEt(racineEnCours.ElementRacine);
                                    racineEnCours.ElementRacine.AddFils(elementParentDeLien);
                                }
                                elementParentDeLien.AddFils(new CElementDeArbreOperationnelEntite(elementParentDeLien, lien));

                                //Cablage du site entrée
                                CNoeudDeGrapheReseauSite noeudSite = lien.NoeudDepart as CNoeudDeGrapheReseauSite;
                                if (noeudSite != null && noeudSite.IsCable)
                                {
                                    //Le noeud correspondant à l'élément est déjà dans le schéma du lien
                                    CElementDeArbreOperationnelEntite elementNoeud = new CElementDeArbreOperationnelEntite(null, noeudSite);
                                    result = elementNoeud.GetElementCablage(graphe.SensDuGraphe, schema.ContexteDonnee);
                                    if (!result)
                                    {
                                        return(result);
                                    }
                                    CElementDeArbreOperationnel elementCablage = result.Data as CElementDeArbreOperationnel;
                                    if (elementCablage != null)
                                    {
                                        elementParentDeLien.AddFils(elementCablage);
                                    }
                                }
                                //Cablage du site sortie
                                noeudSite = lien.NoeudArrive as CNoeudDeGrapheReseauSite;
                                if (noeudSite != null && noeudSite.IsCable && nLien == chemin.Liens.Count() - 1)
                                {
                                    CElementDeArbreOperationnelEntite elementNoeud = new CElementDeArbreOperationnelEntite(null, noeudSite);
                                    result = elementNoeud.GetElementCablage(graphe.SensDuGraphe, schema.ContexteDonnee);
                                    if (!result)
                                    {
                                        return(result);
                                    }
                                    CElementDeArbreOperationnel elementCablage = result.Data as CElementDeArbreOperationnel;
                                    if (elementCablage != null)
                                    {
                                        elementParentDeLien.AddFils(elementCablage);
                                    }
                                }

                                if (lien.EtapesNoeudArrivee != null)
                                {
                                    int[] idsSchemas = lien.EtapesNoeudArrivee.IdsSchemas;
                                    foreach (int nIdSchema in idsSchemas)
                                    {
                                        CElementDeArbreOperationnelSousSchema eltSousSchema = new CElementDeArbreOperationnelSousSchema(racineEnCours.ElementRacine);
                                        eltSousSchema.NoeudDepart    = lien.NoeudArrive;
                                        eltSousSchema.ElementDeArbre = new CElementDeArbreOperationnelOperateurEt(racine.ElementRacine);
                                        eltSousSchema.IdSchema       = nIdSchema;
                                        CRacineDeSchema newRacine = new CRacineDeSchema(
                                            nIdSchema,
                                            eltSousSchema,
                                            eltSousSchema.ElementDeArbre as CElementDeArbreOperationnelOperateur);
                                        lstRacines.Push(newRacine);
                                        racineEnCours.ElementRacine.AddFils(eltSousSchema);
                                        racineEnCours = newRacine;
                                    }
                                }
                                nLien++;
                            }
                        }
                    }
                }
            }
            eltSource.Simplifier();
            return(result);
        }