예제 #1
0
        public static void OnModificationSchemaReseau(CContexteDonnee contexte, Hashtable tableData, ref CResultAErreur result)
        {
            DataTable table = contexte.Tables[CElementDeSchemaReseau.c_nomTable];

            if (table == null)
            {
                return;
            }
            //Id de schéma->true si modifié
            Dictionary <int, bool> dicSchemasModifies = new Dictionary <int, bool>();

            foreach (DataRow row in table.Rows)
            {
                switch (row.RowState)
                {
                case DataRowState.Added:
                case DataRowState.Modified:
                    if (row[CElementDeSchemaReseau.c_champIdSchemaReseauAuquelJappartiens] != DBNull.Value)
                    {
                        dicSchemasModifies[(int)row[CElementDeSchemaReseau.c_champIdSchemaReseauAuquelJappartiens]] = true;
                    }
                    break;

                case DataRowState.Deleted:
                    if (row[CElementDeSchemaReseau.c_champIdSchemaReseauAuquelJappartiens, DataRowVersion.Original] != DBNull.Value)
                    {
                        dicSchemasModifies[(int)row[CElementDeSchemaReseau.c_champIdSchemaReseauAuquelJappartiens, DataRowVersion.Original]] = true;
                    }
                    break;
                }
            }
            foreach (int nIdSchema in dicSchemasModifies.Keys)
            {
                CSchemaReseau schema = new CSchemaReseau(contexte);
                if (schema.ReadIfExists(nIdSchema))
                {
                    if (schema.LienReseau != null)
                    {
                        if (CSpvLiai.CanSupervise(schema.LienReseau))
                        {
                            CSpvLiai spvLien = CSpvLiai.GetSpvLiaiFromLienReseauAvecCreation(schema.LienReseau);
                            if (spvLien != null)
                            {
                                result = spvLien.UpdateCablages();
                                if (result)
                                {
                                    spvLien.UpdateSupportants();
                                }

                                if (!result)
                                {
                                    return;
                                }
                            }
                        }
                    }
                }
            }
            return;
        }
예제 #2
0
        //-------------------------------------------------------------------
        //-------------------------------------------------------------------
        public void TiagSetSchemaContenantKeys(object[] lstKeys)
        {
            CSchemaReseau schema = new CSchemaReseau(ContexteDonnee);

            if (schema.ReadIfExists(lstKeys))
            {
                SchemaReseau = schema;
            }
        }/// <summary>
예제 #3
0
        //-------------------------------------------------------------------
        public void TiagSetIncludedDiagramKeys(object[] lstKeys)
        {
            CSchemaReseau schema = new CSchemaReseau(ContexteDonnee);

            if (schema.ReadIfExists(lstKeys))
            {
                SchemaReseauInclus = schema;
            }
        }
예제 #4
0
        //-------------------------------------------------------------------
        public void TiagSetRepresentedDiagramKeys(object[] lstKeys)
        {
            CSchemaReseau schema = new CSchemaReseau(ContexteDonnee);

            if (schema.ReadIfExists(lstKeys))
            {
                SchemaReseauContenu = schema;
            }
        }
        /// <summary>
        /// Le data du result contient l'élément de cablage ou null
        /// </summary>
        /// <param name="sens"></param>
        /// <param name="contexteDonnee"></param>
        /// <returns></returns>
        public CResultAErreur GetElementCablage(
            ESensAllerRetourLienReseau?sens,
            CContexteDonnee contexteDonnee)
        {
            CResultAErreur result = CResultAErreur.True;

            CNoeudDeGrapheReseauSite noeudSite = Composant as CNoeudDeGrapheReseauSite;

            if (noeudSite == null || !noeudSite.IsCable)//Pas un site ou pas cablé
            {
                return(result);
            }

            CSchemaReseau schema = new CSchemaReseau(contexteDonnee);

            if (!schema.ReadIfExists(Composant.IdSchemaReseau))
            {
                result.EmpileErreur(I.T("Can not find network diagram @1|20051", Composant.IdSchemaReseau.ToString()));
                return(result);
            }

            CSchemaReseau schemaCablage = schema.GetSousSchemas().FirstOrDefault(s =>
                                                                                 s.SiteApparenance != null &&
                                                                                 s.SiteApparenance.Id == noeudSite.IdSite);


            CGrapheReseau grapheCablage = new CGrapheReseau(null);

            result = grapheCablage.CalculeGraphe(schemaCablage, sens);
            if (!result)
            {
                return(result);
            }
            CArbreOperationnel arbreGraphe = new CArbreOperationnel();

            result = arbreGraphe.CalculArbreRedondanceAuto(schemaCablage, grapheCablage);
            if (result)
            {
                result.Data = arbreGraphe.ElementRacine;
            }
            return(result);
        }
        //-----------------------------------------------------------
        protected override CResultAErreur MyFillFromElementDeGraphe(CElementDeArbreOperationnel element)
        {
            CResultAErreur result = CResultAErreur.True;
            CElementDeArbreOperationnelSousSchema eltSousSchema = element as CElementDeArbreOperationnelSousSchema;

            if (eltSousSchema == null)
            {
                result.EmpileErreur(I.T("Bad element type|20030"));
                return(result);
            }
            CSchemaReseau schema = new CSchemaReseau(ContexteDonnee);

            if (!schema.ReadIfExists(eltSousSchema.IdSchema))
            {
                result.EmpileErreur(I.T("Can not find schema @1|20032", eltSousSchema.IdSchema.ToString()));
                return(result);
            }
            SmtSchema            = schema;
            _sys_CleNoeudArrivee = GetKeyNoeud(eltSousSchema.NoeudArrive);
            _sys_CleNoeudDepart  = GetKeyNoeud(eltSousSchema.NoeudDepart);
            return(result);
        }
예제 #7
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;
                        }
                    }
                }
            }
        }