//-------------------------------------------------------
public static bool EditeCreateur(CCreateurAlarme createur, IBaseTypesAlarmes baseAlarmes)
{
CFormEditCreateurAlarme form = new CFormEditCreateurAlarme();
CMemoryDb dbEdition = new CMemoryDb();
form.m_createur = dbEdition.ImporteObjet(createur, true, true) as CCreateurAlarme;
//form.m_createur = CCloner2iSerializable.Clone(createur) as CCreateurAlarme;
form.m_createur.TrapHandler = createur.TrapHandler;
form.m_baseTypesAlarmes = baseAlarmes;
bool bResult = false;
if (form.ShowDialog() == DialogResult.OK)
{
createur.Database.ImporteObjet(form.m_createur, true, true);
bResult = true;
}
form.Dispose();
return(bResult);
}
/// /////////////////////////////////////////////
public CResultAErreur InitEntitesFromSnmpInContexteCourant()
{
CResultAErreur result = CResultAErreur.True;
CMemoryDb database = CMemoryDbPourSupervision.GetMemoryDb(ContexteDonnee);
CAgentSnmpPourSupervision agent = GetAgentPourSupervision(database, false);
if (agent != null)
{
result = agent.FillFromSNMP(new CInterrogateurSnmp());
if (result)
{
result = MapEntitesFromSNMP(agent);
}
}
if (result)
{
LastUpdateDateFromSNMP = DateTime.Now;
}
return(result);
}
public CDefinitionProprieteDynamique[] GetDefinitionsChamps(CObjetPourSousProprietes objet, CDefinitionProprieteDynamique defParente)
{
List <CDefinitionProprieteDynamique> listeProps = new List <CDefinitionProprieteDynamique>();
if (objet.TypeAnalyse != null && objet.TypeAnalyse == typeof(CLocalAlarme))
{
CListeObjetsDonnees lstChamps = new CListeObjetsDonnees(CContexteDonneeSysteme.GetInstance(), typeof(CChampCustom));
lstChamps.Filtre = CChampCustom.GetFiltreChampsForRole(CAlarme.c_roleChampCustom);
using (CMemoryDb db = new CMemoryDb())
{
foreach (CChampCustom champ in lstChamps)
{
CLocalChampTypeAlarme localChamp = CTypeAlarme.GetChampTypeAlarme(db, champ);
listeProps.Add(new CDefinitionProprieteDynamiqueChampAlarme(localChamp));
}
}
}
return(listeProps.ToArray());
}
//------------------------------------------------------------------------
public static DataSet GetListeSitesPourReferences(C2iSessionWeb session)
{
using (CContexteDonnee ctx = new CContexteDonnee(session.Session.IdSession, true, false))
{
CMemoryDb db = new CMemoryDb();
AddTypesSitesToDb(ctx, db);
TID.CIndexIdTimos <TID.CTypeSite> dicTypesSites = TID.CIndexIdTimos <TID.CTypeSite> .GetIdTimosIndex(db);
CListeObjetDonneeGenerique <CSite> lstSites = new CListeObjetDonneeGenerique <CSite>(ctx);
lstSites.AssureLectureFaite();
lstSites.ReadDependances("SitesFils");
lstSites.ReadDependances("TypeSite");
lstSites.Filtre = new CFiltreData(CSite.c_champIdParent + " is null");
foreach (CSite site in lstSites)
{
AddSitePourReference(site, null, db, dicTypesSites);
}
return(db);
}
}
public static CEntiteDeMemoryDb SelectObjetDonnee(CMemoryDb dbMemory, string strInstructions, CListeEntitesDeMemoryDbBase liste, string strPropriete)
{
CFormSelectUneEntiteMemoryDb form = new CFormSelectUneEntiteMemoryDb();
form.m_listeObjets = liste;
form.m_strInstructions = strInstructions;
form.m_filtre = liste.Filtre;
form.TypeObjets = liste.TypeElements;
form.m_strProprieteAffichee = strPropriete;
form.m_contexteMemoire = dbMemory;
form.m_wndListeElements.Columns[0].Propriete = strPropriete;
CEntiteDeMemoryDb objet = null;
if (form.ShowDialog() == DialogResult.OK)
{
objet = form.ObjetDonnee;
}
form.Dispose();
return(objet);
}
//--------------------------------------------------------------------
public CResultAErreurType <CMappageIdsAlarmes> RemonteAlarmes(CMemoryDb dbContenantLesAlarmesARemonter)
{
CResultAErreurType <CMappageIdsAlarmes> result = new CResultAErreurType <CMappageIdsAlarmes>();
if (m_traiteurAlarme != null)
{
return(m_traiteurAlarme.Traite(dbContenantLesAlarmesARemonter));
}
else
{
foreach (CSnmpProxy proxy in CSnmpProxyConfiguration.GetInstance().GetProxiesPrecedents())
{
ISnmpConnexion connexion = proxy.GetConnexion();
return(connexion.RemonteAlarmes(dbContenantLesAlarmesARemonter));
}
}
result.EmpileErreur(I.T("Can not manage alarms"));
return(result);
}
//--------------------------------------------------------
public static CDataRoom GetRoomFor(string strIdEntite, CMemoryDb db)
{
string strRoomId = "";
if (m_cacheDispatch.TryGetValue(strIdEntite, out strRoomId))
{
CDataRoom room = new CDataRoom(db);
if (room.ReadIfExist(strRoomId))
{
return(room);
}
}
CListeEntitesDeMemoryDb <CDataDispatch> lstDispatch = new CListeEntitesDeMemoryDb <CDataDispatch>(db);
lstDispatch.Filtre = new CFiltreMemoryDb(CDataDispatch.c_champStartEntityId + " like @1", strIdEntite[0] + "%");
lstDispatch.Sort = CDataDispatch.c_champStartEntityId + " desc";
CDataRoom roomDest = null;
foreach (CDataDispatch dd in lstDispatch)
{
if (strIdEntite.StartsWith(dd.StartEntityId))
{
roomDest = dd.DestinationRoom;
}
;
}
if (roomDest == null)
{
//Cherche le dispatch vide
lstDispatch.Filtre = new CFiltreMemoryDb(CDataDispatch.c_champStartEntityId + "=@1", "");
if (lstDispatch.Count() > 0)
{
roomDest = lstDispatch.ElementAt(0).DestinationRoom;
}
}
if (roomDest != null)
{
m_cacheDispatch[strIdEntite] = roomDest.Id;
}
return(roomDest);
}
private void InitListeReleves()
{
CMemoryDb db = CTimosInventoryDb.GetInventaireDatas();
CListeEntitesDeMemoryDb <CReleveSite> lst = new CListeEntitesDeMemoryDb <CReleveSite>(db);
m_wndListeReleves.BeginUpdate();
m_wndListeReleves.Items.Clear();
lst.Sort = CReleveSite.c_champDate;
foreach (CReleveSite releve in lst)
{
CSite site = releve.Site;
if (site != null)
{
ListViewItem item = new ListViewItem(site.LibelleComplet);
item.Tag = releve;
item.Checked = true;
m_wndListeReleves.Items.Add(item);
}
}
m_wndListeReleves.EndUpdate();
}
/// /////////////////////////////////////////////////////////
public CTypeAgentPourSupervision GetTypeAgentPourSupervision(CMemoryDb database)
{
if (database == null)
{
database = CMemoryDbPourSupervision.GetMemoryDb(ContexteDonnee);
}
CTypeAgentPourSupervision typeAgent = new CTypeAgentPourSupervision(database);
if (!typeAgent.ReadIfExist(Id.ToString(), false))
{
typeAgent.CreateNew(Id.ToString());
}
else
if (!typeAgent.IsToRead())
{
return(typeAgent);
}
typeAgent.Row[CMemoryDb.c_champIsToRead] = false;
foreach (CEasyQuery query in Queries)
{
typeAgent.AddQuery(query);
}
typeAgent.Fonctions = FonctionsDynamiques;
foreach (CTrapHandler handler in TrapHandlers)
{
database.ImporteObjet(handler, true, false);
}
foreach (CTypeEntiteSnmp typeEntite in TypesEntites)
{
if (typeEntite.TypeParent == null)
{
typeEntite.GetTypeEntitePourSupervision(database, true);
}
}
foreach (CAgentFinderFromKey finder in AgentFinders)
{
database.ImporteObjet(finder, true, false);
}
return(typeAgent);
}
public static CMemoryDb GetAlarmesAAfficher(int nIdSession)
{
using (CContexteDonnee ctx = new CContexteDonnee(nIdSession, true, false))
{
CMemoryDb db = CMemoryDbPourSupervision.GetMemoryDb(ctx);
//Catégories de masquage
CListeObjetDonneeGenerique <CCategorieMasquageAlarme> lstCat = new CListeObjetDonneeGenerique <CCategorieMasquageAlarme>(ctx);
foreach (CCategorieMasquageAlarme cat in lstCat)
{
CLocalCategorieMasquageAlarme local = cat.GetLocalCategorieForSupervision(db);
}
CListeObjetDonneeGenerique <CAlarme> lst = new CListeObjetDonneeGenerique <CAlarme>(ctx);
lst.Filtre = new CFiltreData(CAlarme.c_champDateFin + " is null and " +
CAlarme.c_champIdParent + " is null");
int nCount = 0;
if (lst.Count == 0)
{
return(db);
}
CListeObjetsDonnees lstFilles = lst;
while (ctx.Tables[CAlarme.c_nomTable].Rows.Count != nCount)
{
nCount = ctx.Tables[CAlarme.c_nomTable].Rows.Count;
lstFilles = lstFilles.GetDependances("AlarmesFilles");
}
lst = new CListeObjetDonneeGenerique <CAlarme>(ctx);
lst.InterditLectureInDB = true;
lst.ReadDependances("RelationsChampsCustom");
lst.Filtre = new CFiltreData(CAlarme.c_champIdParent + " is null");
CListeObjetDonneeGenerique <CTypeAlarme> lstTypes = new CListeObjetDonneeGenerique <CTypeAlarme>(ctx);
lstTypes.AssureLectureFaite();
foreach (CAlarme alrm in lst)
{
CLocalAlarme newAlrm = alrm.GetLocalAlarme(db, true);
}
return(db);
}
}
public static DataSet GetEquipments(C2iSessionWeb sessionWeb,
int nIdSiteContenant)
{
using (CContexteDonnee ctx = new CContexteDonnee(sessionWeb.Session.IdSession, true, false))
{
CMemoryDb db = new CMemoryDb();
db.EnforceConstraints = false;
//Identifie les champs custom interessants
CListeObjetDonneeGenerique <CChampCustom> lstChamps = new CListeObjetDonneeGenerique <CChampCustom>(ctx);
lstChamps.Filtre = CChampCustom.GetFiltreChampsForRole(CReleveEquipement.c_roleChampCustom);
StringBuilder blChampsCustom = new StringBuilder();
foreach (CChampCustom champ in lstChamps)
{
blChampsCustom.Append(champ.Id);
blChampsCustom.Append(",");
AssureChampInMemoryDb(champ, db);
}
if (blChampsCustom.Length > 0)
{
blChampsCustom.Remove(blChampsCustom.Length - 1, 1);
}
//Ajout des équipements
CListeObjetDonneeGenerique <CEquipement> equipements = new CListeObjetDonneeGenerique <CEquipement>(ctx);
equipements.Filtre = new CFiltreData(CSite.c_champId + "=@1", nIdSiteContenant);
equipements.AssureLectureFaite();
equipements.ReadDependances("EquipementsContenus.ParametragesSystemesCoordonnees", "RelationsChampsCustom");
equipements.Filtre = new CFiltreData(CEquipement.c_champIdEquipementContenant + " is null");
equipements.InterditLectureInDB = true;
foreach (CEquipement eqt in equipements)
{
AddDetailEquipementToDb(eqt, null, blChampsCustom.ToString(), db);
}
return(db);
}
}
//----------------------------------------------------------------
public CResultAErreur UpdateConfig(CMemoryDb database)
{
CResultAErreur result = CResultAErreur.True;
try
{
result = SaveConfig(database);
if (!result)
{
return(result);
}
m_database = database;
UpdateOptimizedDb();
CDataDispatch.ResetDispatchCache();
return(result);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//------------------------------------------------------------------------
public static DataSet GetSites(
C2iSessionWeb sessionWeb,
int[] nIdSites)
{
using (CContexteDonnee ctx = new CContexteDonnee(sessionWeb.Session.IdSession, true, false))
{
CMemoryDb db = new CMemoryDb();
db.EnforceConstraints = false;
if (nIdSites != null && nIdSites.Length > 0)
{
StringBuilder bl = new StringBuilder();
foreach (int nIdSite in nIdSites)
{
bl.Append(nIdSite);
bl.Append(';');
}
bl.Remove(bl.Length - 1, 1);
CFiltreDataAvance filtre = new CFiltreDataAvance(CSite.c_nomTable,
CSite.c_champId + " in {" + bl.ToString() + "}");
filtre.IntegrerFilsHierarchiques = true;
CListeObjetDonneeGenerique <CSite> lstSites = new CListeObjetDonneeGenerique <CSite>(ctx);
lstSites.Filtre = filtre;
lstSites.AssureLectureFaite();
lstSites.ReadDependances("SitesFils");
lstSites.Filtre = new CFiltreData(CSite.c_champIdParent + " is null");
lstSites.InterditLectureInDB = true;
foreach (CSite site in lstSites)
{
AddDetailSiteToDb(site, null, db);
}
}
return(db);
}
}
public static CEntiteDeMemoryDb SelectObjetDonnee(CMemoryDb dbMemory, string strInstructions, Type type, CFiltreMemoryDb filtre, string strPropriete)
{
if (!type.IsSubclassOf(typeof(CEntiteDeMemoryDb)))
{
CFormAlerte.Afficher(I.T("Impossible to select an element from this type|30035"), EFormAlerteType.Erreur);
return(null);
}
CFormSelectUneEntiteMemoryDb form = new CFormSelectUneEntiteMemoryDb();
form.m_filtre = filtre;
form.m_strInstructions = strInstructions;
form.TypeObjets = type;
form.m_strProprieteAffichee = strPropriete;
form.m_contexteMemoire = dbMemory;
form.m_wndListeElements.Columns[0].Propriete = strPropriete;
CEntiteDeMemoryDb objet = null;
if (form.ShowDialog() == DialogResult.OK)
{
objet = form.ObjetDonnee;
}
form.Dispose();
return(objet);
}
//-------------------------------------------------
public static CMemoryDb GetTimosDatas()
{
if (m_dbTimos != null)
{
return(m_dbTimos);
}
m_dbTimos = new CMemoryDb();
if (File.Exists(GetNomFichierTimosData()))
{
/*try
* {
* m_dbTimos.ReadXml(GetNomFichierTimosData(), System.Data.XmlReadMode.Auto);
* }
* catch (Exception e)
* {
* CResultAErreur result = CResultAErreur.True;
* result.EmpileErreur(new CErreurException(e));
* result.EmpileErreur(I.T("Can not read data|20007"));
* CFormAlerte.Afficher(result.Erreur);
* m_dbTimos = new CMemoryDb();
* }
* }*/
DateTime dt = DateTime.Now;
CResultAErreur result = CSerializerObjetInFile.ReadFromFile(m_dbTimos, c_cleFichierTimos, GetNomFichierTimosData());
TimeSpan sp = DateTime.Now - dt;
System.Console.WriteLine("Read dbTimos : " + sp.TotalMilliseconds);
if (!result)
{
result.EmpileErreur(I.T("Can not read data|20007"));
CFormAlerte.Afficher(result.Erreur);
m_dbTimos = new CMemoryDb();
}
}
return(m_dbTimos);
}
//-------------------------------------------------
public CLocalRelationTypeAlarmeChampAlarme(CMemoryDb db)
: base(db)
{
}
//-----------------------------------------
public CTypeEquipementConstructeur(CMemoryDb db)
: base(db)
{
}
//-----------------------------------------
public CSite(CMemoryDb db)
: base(db)
{
}
//-------------------------------------------------------
public CReleveSite(CMemoryDb db)
: base(db)
{
}
public void SendAlarmes()
{
if (m_traiteurAlarmes == null)
{
return;
}
if (m_nWaitingCounter > 5)
{
return;
}
m_nWaitingCounter++;
lock (typeof(CLockTraiteurAlarmes))
{
m_nWaitingCounter--;
List <CLocalAlarme> lstToSend = null;
lock (typeof(CLockListeAlarmes))
{
if (m_listeAlarmesATransmettre.Count < 250 || m_nWaitingCounter == 0)
{
lstToSend = m_listeAlarmesATransmettre;
m_listeAlarmesATransmettre = new List <CLocalAlarme>();
}
else
{
lstToSend = new List <CLocalAlarme>();
for (int n = 0; n < 250; n++)
{
lstToSend.Add(m_listeAlarmesATransmettre[n]);
}
m_listeAlarmesATransmettre.RemoveRange(0, 250);
}
}
try
{
System.Data.DataTable tbl = Database.Tables[CLocalAlarme.c_nomTable];
Console.WriteLine("Nb in db : " + tbl.Rows.Count);
if (lstToSend.Count == 0)
{
return;
}
using (CMemoryDb memDB = new CMemoryDb())
{
memDB.EnforceConstraints = false;
lock (typeof(CLockerDatabase))
{
foreach (CLocalAlarme alrm in lstToSend)
{
try
{
if (alrm.Row.Row.RowState != System.Data.DataRowState.Detached)
{
memDB.ImporteObjet(alrm, true, false);
}
}
catch (Exception e)
{
throw e;
}
}
}
m_nNbSend += lstToSend.Count;
CResultAErreurType <CMappageIdsAlarmes> result = m_traiteurAlarmes.Traite(memDB);
if (result)
{
if (result.DataType != null)
{
foreach (KeyValuePair <string, string> kv in result.DataType)
{
if (kv.Value != kv.Key)
{
CLocalAlarme alarme = GetAlarmFromId(kv.Key);
if (alarme != null)
{
alarme.Id = kv.Key;
m_dicAlarmes.Remove(kv.Key);
m_dicAlarmes[kv.Value] = alarme;
}
}
}
}
NettoyageDB();
return;
}
if (!result)
{
m_trace.Write("Error while sending to Timos manager", ALTRACE.DEBUG);
m_trace.Write(result.Erreur.ToString(), ALTRACE.DEBUG);
}
}
}
catch (Exception exep)
{
}
lock (typeof(CLockListeAlarmes))
{
for (int n = lstToSend.Count - 1; n >= 0; n--)
{
if (lstToSend[n].Row.Row.RowState == System.Data.DataRowState.Detached)
{
lstToSend.RemoveAt(n);
}
}
m_listeAlarmesATransmettre.InsertRange(0, lstToSend);
}
}
}
//---------------------------------------------------
public CDataHotel(CMemoryDb db)
: base(db)
{
}
public CSnmpProxy(CMemoryDb db)
: base(db)
{
}
//--------------------------------------------------------
public CDataRoom(CMemoryDb db)
: base(db)
{
}
private void m_lnkEnvoyerReleves_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
DateTime dt = DateTime.Now;
List <CReleveSite> lstReleves = new List <CReleveSite>();
foreach (ListViewItem item in m_wndListeReleves.CheckedItems)
{
CReleveSite rel = item.Tag as CReleveSite;
if (rel != null)
{
lstReleves.Add(rel);
}
}
List <CReleveSite> lstTransmitted = new List <CReleveSite>();
CFormWaiting.DoWork((DoWorkDelegate) delegate(CFormWaiting waiter)
{
waiter.ReportProgress(I.T("Connecting to Timos|20009"));
InventoryService.InventoryService service = new TimosInventory.InventoryService.InventoryService();
service.Url = CTimosInventoryRegistre.TimosServiceURL;
int nIdSession;
try
{
nIdSession = service.OpenSession();
foreach (CReleveSite releve in lstReleves)
{
if (releve != null)
{
CMemoryDb db = new CMemoryDb();
db.EnforceConstraints = false;
db.ImporteObjet(releve, true, false);
waiter.ReportProgress(I.T("Send survey @1|20038",
releve.Site.Libelle));
bool bResult = service.SendSurvey(nIdSession, db);
if (bResult)
{
lstTransmitted.Add(releve);
}
}
}
foreach (CReleveSite releve in lstTransmitted)
{
releve.ClearRelevesEquipements();
releve.Delete();
}
service.CloseSession(nIdSession);
TimeSpan sp = DateTime.Now - dt;
Console.WriteLine("Transmission relevé : " + sp.TotalMilliseconds);
}
catch
{
}
});
CTimosInventoryDb.SetDbInventaire(CTimosInventoryDb.GetInventaireDatas());
if (lstTransmitted.Count != lstReleves.Count)
{
CFormAlerte.Afficher(I.T("Due to unknown error, Some surveys could not be send|20043"));
}
InitListeReleves();
}
//////////////////////////////////////////////////////////////////////////
public CRelationTypeEquipement_Heritage(CMemoryDb db)
: base(db)
{
}
//-----------------------------------------
public CTypeEquipement(CMemoryDb db)
: base(db)
{
}
//-------------------------------------------------------------------------------
public void UpdateAlarmDataBase(CMemoryDb dbMaj)
{
List <COperationSurAlarmeAffichee> listeTampon = new List <COperationSurAlarmeAffichee>();
Dictionary <CLocalAlarme, bool> dicAlarmesTraitees = new Dictionary <CLocalAlarme, bool>();
m_database = dbMaj;
CListeEntitesDeMemoryDb <CLocalAlarme> listeMaj = new CListeEntitesDeMemoryDb <CLocalAlarme>(m_database, m_filtreAlarmes);
HashSet <string> lstAlarmesNonMasquees = new HashSet <string>();
foreach (CLocalAlarme alrm in listeMaj)
{
lstAlarmesNonMasquees.Add(alrm.Id);
}
listeMaj = new CListeEntitesDeMemoryDb <CLocalAlarme>(m_database);
foreach (CLocalAlarme alarmeMaj in listeMaj)
{
// Traite uniquement les alarmes ajoutées ou modifiées
if (alarmeMaj.Row.Row.RowState == System.Data.DataRowState.Modified ||
alarmeMaj.Row.Row.RowState == System.Data.DataRowState.Added)
{
// Recherche l'alarme racine
CLocalAlarme alarmeParente = alarmeMaj;
while (alarmeParente.Parent != null)
{
alarmeParente = alarmeParente.Parent;
}
if (dicAlarmesTraitees.Keys.Contains(alarmeParente))
{
continue;
}
if (!lstAlarmesNonMasquees.Contains(alarmeMaj.Id))
{
listeTampon.Add(new COperationSurAlarmeAffichee(
new CLocalAlarmeAffichee(alarmeParente.Row.Row),
EOperationSurAlarme.Delete));
continue;
}
if (m_bTraiteAlarmesEnCours)
{
if (alarmeParente.DateFin == null)
{
//UpdateNode(new CLocalAlarmeAffichee(alarmeParente.Row.Row));
listeTampon.Add(new COperationSurAlarmeAffichee(
new CLocalAlarmeAffichee(alarmeParente.Row.Row),
EOperationSurAlarme.CreateUpdate));
}
else
{
//RemoveNode(new CLocalAlarmeAffichee(alarmeParente.Row.Row));
listeTampon.Add(new COperationSurAlarmeAffichee(
new CLocalAlarmeAffichee(alarmeParente.Row.Row),
EOperationSurAlarme.Delete));
}
}
else // Traite alarmes retombées
{
if (alarmeParente.DateFin != null)
{
//UpdateNode(new CLocalAlarmeAffichee(alarmeParente.Row.Row));
listeTampon.Add(new COperationSurAlarmeAffichee(
new CLocalAlarmeAffichee(alarmeParente.Row.Row),
EOperationSurAlarme.CreateUpdate));
}
else
{
//RemoveNode(new CLocalAlarmeAffichee(alarmeParente.Row.Row));
listeTampon.Add(new COperationSurAlarmeAffichee(
new CLocalAlarmeAffichee(alarmeParente.Row.Row),
EOperationSurAlarme.Delete));
}
}
dicAlarmesTraitees[alarmeParente] = true;
}
}
lock (m_listeOperationsSurAlarme)
{
m_listeOperationsSurAlarme.AddRange(listeTampon);
}
BeginInvoke(new EventHandler(DelayUpdate), null, null);
}
/// ///////////////////////////////////////////////////////
public CChampCustom(CMemoryDb db)
: base(db)
{
}
//-------------------------------------------
public CLocalAlarme(CMemoryDb db)
: base(db)
{
}
//-------------------------------------------------------
public CReleveEquipement(CMemoryDb db)
: base(db)
{
}
