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;
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
public void TiagSetSchemaContenantKeys(object[] lstKeys)
{
CSchemaReseau schema = new CSchemaReseau(ContexteDonnee);
if (schema.ReadIfExists(lstKeys))
{
SchemaReseau = schema;
}
}/// <summary>
//-------------------------------------------------------------------
public void TiagSetIncludedDiagramKeys(object[] lstKeys)
{
CSchemaReseau schema = new CSchemaReseau(ContexteDonnee);
if (schema.ReadIfExists(lstKeys))
{
SchemaReseauInclus = schema;
}
}
//-------------------------------------------------------------------
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);
}
//////////////////////////////////////////////////////////////////
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;
}
}
}
}
}
