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;
}
}
}
}
//////////////////////////////////////////////////////////////////
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;
}
}
}
}
}
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;
}
//-------------------------------------------------------------------------
public CFormEditionSchemaReseau(CSchemaReseau type_lien)
: base(type_lien)
{
// Cet appel est requis par le Concepteur Windows Form.
InitializeComponent();
}
//-------------------------------------------------------------------------
public CFormEditionSchemaReseau(CSchemaReseau type_lien, CListeObjetsDonnees liste)
: base(type_lien, liste)
{
// Cet appel est requis par le Concepteur Windows Form.
InitializeComponent();
}
//---------------------------------------------------
public C2iSchemaReseau(CSchemaReseau schema)
{
m_schema = schema;
}
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);
}
}
}
}
}
}
/// <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);
}
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);
}
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);
}
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();
}
//-------------------------------------------------
/// <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);
}