private void FillDicsForNode(CElementDeArbreOperationnel node,
CDictionnaireElementToNoeudArbre dicEquipementToNoeudArbreOp,
CDictionnaireElementToNoeudArbre dicSiteToNoeudArbreOp,
CDictionnaireElementToNoeudArbre dicLiaisonToNoeudArbreOp,
CDictionnaireElementToNoeudArbre dicServiceToNoeudArbreOp)
{
CElementDeArbreOperationnelEntite noeudEntite = node as CElementDeArbreOperationnelEntite;
if (noeudEntite != null)
{
try
{
IElementDeSchemaReseau eltAssocie = noeudEntite.Composant.GetElementAssocie(m_base.ContexteDonnee);
if (eltAssocie is CEquipementLogique)
{
CSpvEquip equipement = CSpvEquip.GetObjetSpvFromObjetTimos((CEquipementLogique)eltAssocie);
if (equipement != null)
{
dicEquipementToNoeudArbreOp.Add(equipement.Id, noeudEntite);
}
}
else if (eltAssocie is CSite)
{
CSpvSite site = CSpvSite.GetObjetSpvFromObjetTimos((CSite)eltAssocie);
if (site != null)
{
dicSiteToNoeudArbreOp.Add(site.Id, noeudEntite);
}
}
else if (eltAssocie is CLienReseau)
{
CSpvLiai liaison = CSpvLiai.GetObjetSpvFromObjetTimos((CLienReseau)eltAssocie);
if (liaison != null)
{
dicLiaisonToNoeudArbreOp.Add(liaison.Id, noeudEntite);
}
}
else if (eltAssocie is CSchemaReseau)
{
CSpvSchemaReseau schema = CSpvSchemaReseau.GetObjetSpvFromObjetTimos((CSchemaReseau)eltAssocie);
if (schema != null)
{
dicServiceToNoeudArbreOp.Add(schema.Id, noeudEntite);
}
}
}
catch { }
}
// Fonction récursive sur les noeuds fils
foreach (CElementDeArbreOperationnel nodeFils in node.Fils)
{
FillDicsForNode(nodeFils,
dicEquipementToNoeudArbreOp,
dicSiteToNoeudArbreOp,
dicLiaisonToNoeudArbreOp,
dicServiceToNoeudArbreOp);
}
}
public static void ShowArbreSpv(CSpvSchemaReseau spvSchema)
{
CFormTestSpvGraph form = new CFormTestSpvGraph();
form.m_spvSchema = spvSchema;
form.ShowDialog();
form.Dispose();
}
private void m_btnTestArbre_Click(object sender, EventArgs e)
{
CSpvSchemaReseau spvSchema = CSpvSchemaReseau.GetObjetSpvFromObjetTimos(SchemaReseau);
if (spvSchema != null)
{
CFormTestSpvGraph.ShowArbreSpv(spvSchema);
}
}
public CSpvSchemaReseau GetSpvServiceByName(CContexteDonnee ctx)
{
CFiltreData filtre = new CFiltreData(CSpvSchemaReseau.c_champLibelle + "=@1",
Name);
CSpvSchemaReseau spvService = new CSpvSchemaReseau(ctx);
if (spvService.ReadIfExists(filtre))
{
return(spvService);
}
return(null);
}
public CSpvSchemaReseau GetSpvService(CContexteDonnee contexteDonnee)
{
if (m_nId == 0 && Name.Length > 0)
{
return(GetSpvServiceByName(contexteDonnee));
}
CSpvSchemaReseau service = new CSpvSchemaReseau(contexteDonnee);
if (service.ReadIfExists(m_nId))
{
return(service);
}
return(null);
}
private void OnLstServicesDoubleClick(object sender, EventArgs e)
{
if (m_lstServices.SelectedIndices.Count > 0)
{
int index = m_lstServices.SelectedIndices[0];
CSpvSchemaReseau serviceSpv = ((CInfoServiceAlarmeAffichee)m_lstServices.Items[index]).GetSpvServiceByName(m_ctxDonnee);
if (serviceSpv != null)
{
CSchemaReseau schema = serviceSpv.ObjetTimosAssocie;
if (schema != null)
{
CReferenceTypeForm refTypeForm = CFormFinder.GetRefFormToEdit(schema.GetType());
if (refTypeForm != null)
{
IFormNavigable frm = refTypeForm.GetForm(schema) as IFormNavigable;
Navigateur.AffichePage(frm);
}
}
}
}
}
private void ReadData()
{
using (CContexteDonnee contexte = new CContexteDonnee(0, true, false))
{
CSpvEvenementReseau evt;
if (m_spvAlarm == null) // Init. à partir de l'événement réseau
{
evt = new CSpvEvenementReseau(contexte);
if (evt.ReadIfExists(m_nIdSpvEvtAlarme))
{
m_spvAlarm = evt.SpvAlarme;
}
else
{
return;
}
}
else
{
evt = m_spvAlarm.EvenementDebut;
}
CDivers div = new CDivers();
m_lstTrapInfo = new List <string>();
m_lstInfoClients = new List <CInfoClientAlarmeAffichee>();
m_lstInfoServices = new List <CInfoServiceAlarmeAffichee>();
m_nIdAlarmData = m_spvAlarm.Id;
m_InfoAlarmGeree = new CInfoAlarmeGereeAffichee();
if (evt.SpvAlarmgeree != null)
{
m_InfoAlarmGeree.Id = (int)evt.SpvAlarmgeree.Id;
m_InfoAlarmGeree.Name = evt.SpvAlarmgeree.Alarmgeree_Name;
}
if (m_spvAlarm.SpvSite != null)
{
if (m_InfoSite == null)
{
m_InfoSite = new CInfoSiteAlarmeAffichee();
}
m_InfoSite.Id = (int)m_spvAlarm.SpvSite.Id;
m_InfoSite.Name = m_spvAlarm.SpvSite.SiteNom;
if (m_spvAlarm.SpvSite.TypeSite != null)
{
m_InfoSite.TypeName = m_spvAlarm.SpvSite.TypeSite.TypeSiteNom;
}
}
else if (m_spvAlarm.SpvEquip != null)
{
m_InfoEquip = new CInfoEquipementAlarmeAffichee();
m_InfoEquip.Id = (int)m_spvAlarm.EquipId;
m_InfoEquip.TypeName = m_spvAlarm.SpvEquip.TypeEquipement.Libelle;
m_InfoEquip.Name = m_spvAlarm.SpvEquip.CommentairePourSituer;
}
else if (m_spvAlarm.SpvLiai != null)
{
m_InfoLiai = new CInfoLiaiAlarmeAffichee();
m_InfoLiai.Id = (int)m_spvAlarm.LiaiId;
m_InfoLiai.TypeName = m_spvAlarm.SpvLiai.Typeliaison.Libelle;
m_InfoLiai.Name = m_spvAlarm.SpvLiai.NomComplet;
}
//if (m_InfoSite == null)
// m_InfoSite = new CInfoSiteAlarmeAffichee();
m_nIddeb = evt.Id;
m_stAlarmCl = evt.AlarmCategory;
m_nNumObj = evt.AlarmNumObj;
m_InfoAlarmGeree.CodeAlarmEvent = (EAlarmEvent)m_spvAlarm.CodeEvenementX733;
if (evt.TypeEvenementReseau == ETypeEvenementReseau.DebutAlarme)
{
m_AlarmDate = m_spvAlarm.DateDebut;
m_StartAlarmDate = m_AlarmDate;
}
else
{
m_AlarmDate = (System.DateTime)m_spvAlarm.DateFin;
m_StopAlarmDate = m_AlarmDate;
m_StartAlarmDate = m_spvAlarm.DateDebut;
}
m_nGrave = m_spvAlarm.CodeGravite;
m_stNSeuil = m_spvAlarm.NomSeuilAlarme;
m_nVSeuil = m_spvAlarm.ValeurSeuilAlarme;
m_stNumal = evt.AlarmNumAl;
m_nTexte = evt.CodeAlarmNature;
m_stCommentaire = m_spvAlarm.Commententaire;
m_stInfo = evt.AlarmInfo;
if (m_spvAlarm.SpvLienAccesAlarme != null)
{
m_bAAcquitter = (bool)m_spvAlarm.SpvLienAccesAlarme.Acquitter;
m_bSonne = (bool)m_spvAlarm.SpvLienAccesAlarme.SonActive;
}
if (evt.SpvAlarmgeree != null)
{
m_InfoAlarmGeree.CodeRingType = evt.SpvAlarmgeree.CodeAlarmgereeTypeSon;
}
m_bCommut = evt.AlarmCommut;
m_nIdSpvEvtAlarme = evt.Id;
if (evt.ElementGereNomSite != null && evt.ElementGereNomSite.Length > 0)
{
if (m_InfoSite == null)
{
m_InfoSite = new CInfoSiteAlarmeAffichee();
}
m_InfoSite.Name = evt.ElementGereNomSite;
}
m_InfoAlarmGeree.Name = m_spvAlarm.NomAlarmeGeree;
//string stProgConcNom = m_spvAlarm.ProgrammesConcernes;
if (m_spvAlarm.ServicesConcernes != null)
{
foreach (System.Int32 nServiceId in m_spvAlarm.ServicesConcernes)
{
CInfoServiceAlarmeAffichee serviceAff = new CInfoServiceAlarmeAffichee();
serviceAff.Id = nServiceId;
CSpvSchemaReseau service = serviceAff.GetSpvService(contexte);
serviceAff.Name = service.Libelle;
m_lstInfoServices.Add(serviceAff);
}
}
if (m_spvAlarm.ClientsConcernes != null)
{
foreach (System.Int32 nClientId in m_spvAlarm.ClientsConcernes)
{
CInfoClientAlarmeAffichee clientAff = new CInfoClientAlarmeAffichee();
clientAff.Id = nClientId;
CSpvClient client = clientAff.GetSpvClient(contexte);
clientAff.Name = client.CLIENT_NOM;
m_lstInfoClients.Add(clientAff);
}
}
if (m_spvAlarm.ProgsOper != null)
{
CInfoServiceAlarmeAffichee infoService;
for (int i = 0; i < m_lstInfoServices.Count; i++)
{
infoService = m_lstInfoServices[i];
if (m_spvAlarm.ProgsOper.Length > i)
{
infoService.EtatOper = m_spvAlarm.ProgsOper[i];
}
}
}
m_stBindingVarInfo = m_spvAlarm.GetBindingVarInfo();
FillTrapInfo();
//m_bAcquittee = (m_spvAlarm.Acquittee == null) ? false : m_spvAlarm.Acquittee;
m_bAcquittee = m_spvAlarm.Acquittee;
m_bLectureFaite = 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;
}
}
}
}
}
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();
}
//-------------------------------------------------------------------------
public CFormEditSpvProg(CSpvSchemaReseau prog, CListeObjetsDonnees liste)
: base(prog, liste)
{
// Cet appel est requis par le Concepteur Windows Form.
InitializeComponent();
}
//-------------------------------------------------------------------------
public CFormEditSpvProg(CSpvSchemaReseau prog)
: base(prog)
{
// Cet appel est requis par le Concepteur Windows Form.
InitializeComponent();
}
