//-------------------------------------------------------------
public static CResultAErreur IntegreReleves(C2iSessionInventaire session,
CMemoryDb db)
{
CResultAErreur result = CResultAErreur.True;
try
{
DateTime dt = DateTime.Now;
CListeEntitesDeMemoryDb <TID.releve.CReleveSite> lstReleves = new CListeEntitesDeMemoryDb <TID.releve.CReleveSite>(db);
using (CContexteDonnee ctx = new CContexteDonnee(session.Session.IdSession, true, false))
{
foreach (TID.releve.CReleveSite releve in lstReleves)
{
result = IntegreReleve(releve, ctx);
if (!result)
{
return(result);
}
}
TimeSpan sp = DateTime.Now - dt;
Console.WriteLine(sp.TotalMilliseconds);
dt = DateTime.Now;
result = ctx.SaveAll(false);
sp = DateTime.Now - dt;
Console.WriteLine(sp.TotalMilliseconds);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
private void CControlePourInventaire_Load(object sender, EventArgs e)
{
CListeEntitesDeMemoryDb <CChampCustom> lstChamps = new CListeEntitesDeMemoryDb <CChampCustom>(CTimosInventoryDb.GetTimosDatas());
lstChamps.Filtre = CChampCustom.GetFiltreChampsForRole(CReleveEquipement.c_roleChampCustom);
if (lstChamps.Count() == 0)
{
m_panelChampsCustom.Visible = false;
}
else
{
m_panelChampsCustom.Visible = true;
foreach (CChampCustom champOrg in lstChamps)
{
CChampCustom champ = new CChampCustom(CTimosInventoryDb.GetInventaireDatas());
if (!champ.ReadIfExist(champOrg.Id))
{
champ = champOrg.GetChampInMemoryDb(CTimosInventoryDb.GetInventaireDatas());
}
if (champ != null)
{
CControleForCustomFieldReleve ctrl = new CControleForCustomFieldReleve();
m_panelChampsCustom.Controls.Add(ctrl);
ctrl.Dock = DockStyle.Left;
ctrl.Init(champ);
ctrl.OnValueChanged += new EventHandler(ctrlCustom_OnValueChanged);
}
}
}
Height = m_panelTop.Height + m_lblLigneBas.Height +
(m_panelChampsCustom.Controls.Count > 0 ? m_panelChampsCustom.Height : 0);
}
//-------------------------------------------------------
public void NettoyageDB()
{
lock (typeof(CLockerDatabase))
lock (typeof(CLockListeAlarmes))
{
List <CLocalAlarme> listeATraiter = new List <CLocalAlarme>();
CListeEntitesDeMemoryDb <CLocalAlarme> lst = new CListeEntitesDeMemoryDb <CLocalAlarme>(Database);
lst.Filtre = new CFiltreMemoryDb(CLocalAlarme.c_champIdParent + " is null");
foreach (CLocalAlarme alarme in lst)
{
if (!m_listeAlarmesATransmettre.Contains(alarme))
{
listeATraiter.Add(alarme);
}
}
while (listeATraiter.Count > 0)
{
List <CLocalAlarme> nextList = new List <CLocalAlarme>();
foreach (CLocalAlarme alrm in listeATraiter)
{
if (alrm.EtatCode == EEtatAlarme.Close)
{
CLocalAlarme parent = alrm.Parent;
if (parent != null && !m_listeAlarmesATransmettre.Contains(parent))
{
nextList.Add(parent);
}
}
DeleteAlarme(alrm);
}
listeATraiter = nextList;
}
}
}
private void InitListeSites()
{
DateTime?dt = CTimosInventoryRegistre.DateDonneesTimos;
if (dt != null)
{
m_lblDateData.Text = I.T("Last data sync : @1|20048", dt.Value.ToShortDateString() + " " +
dt.Value.ToString("HH:mm"));
}
else
{
m_lblDateData.Text = "";
}
CMemoryDb db = CTimosInventoryDb.GetTimosDatas();
CListeEntitesDeMemoryDb <CSite> lst = new CListeEntitesDeMemoryDb <CSite>(db);
m_wndListeSites.BeginUpdate();
m_wndListeSites.Items.Clear();
lst.Filtre = new CFiltreMemoryDb(CSite.c_champIdSiteParent + " is null");
lst.Sort = CSite.c_champLibelle;
foreach (CSite site in lst)
{
ListViewItem item = new ListViewItem(site.Libelle);
item.Tag = site;
m_wndListeSites.Items.Add(item);
}
m_wndListeSites.EndUpdate();
}
//-------------------------------------------------------------------
public void UpdateArbre(CFormWaiting waiter)
{
if (m_dbDeconnectee == null)
{
RecupereListeSites(waiter);
}
if (m_dbDeconnectee == null)
{
return;
}
waiter.ReportProgress(I.T("Loading data...|20012"));
CListeEntitesDeMemoryDb <CSite> lstSites = new CListeEntitesDeMemoryDb <CSite>(m_dbDeconnectee);
lstSites.Filtre = new CFiltreMemoryDb(CSite.c_champIdSiteParent + " is null");
lstSites.Sort = CSite.c_champLibelle;
Invoke((MethodInvoker) delegate
{
m_arbreSites.BeginUpdate();
m_arbreSites.Nodes.Clear();
});
List <TreeNode> lstNodes = new List <TreeNode>();
foreach (CSite site in lstSites)
{
TreeNode node = CreateNodeSite(site);
lstNodes.Add(node);
}
Invoke((MethodInvoker) delegate
{
m_arbreSites.Nodes.AddRange(lstNodes.ToArray());
m_arbreSites.EndUpdate();
});
}
public void RemplirListeAlarmes()
{
BeginUpdate();
m_dicAlarmeNode.Clear();
Nodes.Clear();
CListeEntitesDeMemoryDb <CLocalAlarme> listeAlarmes = new CListeEntitesDeMemoryDb <CLocalAlarme>(m_database, m_filtreAlarmes);
foreach (CLocalAlarme alarme in listeAlarmes)
{
if (alarme.Parent == null)
{
if (m_bTraiteAlarmesEnCours && alarme.DateFin == null)
{
UpdateNode(new CLocalAlarmeAffichee(alarme.Row.Row));
}
if (!m_bTraiteAlarmesEnCours && alarme.DateFin != null && alarme.DateFin.Value.AddMinutes(m_nDurreePersistanceRetombees) > DateTime.Now)
{
UpdateNode(new CLocalAlarmeAffichee(alarme.Row.Row));
}
}
}
EndUpdate();
}
//-------------------------------------
private void m_lnkReset_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
if (MessageBox.Show(I.T("This action will reset the entire survey. Are you sure ?|20042"),
"",
MessageBoxButtons.YesNo,
MessageBoxIcon.Question) == DialogResult.Yes)
{
CListeEntitesDeMemoryDb <CReleveEquipement> lstEqpts = m_releve.RelevesEquipement;
lstEqpts.Filtre = new CFiltreMemoryDb(CReleveEquipement.c_champIdContenant + " is null");
CResultAErreur result = CResultAErreur.True;
foreach (CReleveEquipement releve in lstEqpts.ToArray())
{
result = releve.Delete();
if (!result)
{
break;
}
}
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
}
else
{
m_releve.DateReleve = DateTime.Now;
m_releve.InitEquipementsReleves();
InitForm();
}
}
}
//----------------------------------------------------------
public IEnumerable <CAgentSnmpPourSupervision> GetAgents(CTypeAgentPourSupervision typeAgent)
{
CListeEntitesDeMemoryDb <CAgentSnmpPourSupervision> lst = new CListeEntitesDeMemoryDb <CAgentSnmpPourSupervision>(DataBase,
new CFiltreMemoryDb(CTypeAgentPourSupervision.c_champId + "=@1", typeAgent.Id));
return(lst);
}
//----------------------------------------------------------------
public IEnumerable <string> GetEntities(string strIdTable, DateTime dataStart, DateTime dataEnd)
{
HashSet <string> setIds = new HashSet <string>();
COptimizedDataRoomTable table = m_optimizedDb.GetTable(strIdTable);
if (table != null)
{
strIdTable = table.TableId;
}
CListeEntitesDeMemoryDb <CDataRoom> lstRooms = new CListeEntitesDeMemoryDb <CDataRoom>(m_database);
foreach (CDataRoom room in lstRooms)
{
try
{
IDataRoomServer srv = GetRoomServer(room);
if (srv != null)
{
IEnumerable <string> lst = srv.GetEntitiesDirect(strIdTable, dataStart, dataEnd);
if (lst != null)
{
foreach (string strId in lst)
{
setIds.Add(strId);
}
}
}
}
catch { }
}
return(setIds);
}
private int CompareAdresse(string strAdresse1, string strAdresse2, int nNiveau, bool bEgalSiVide)
{
CListeEntitesDeMemoryDb <CRelationSystemeCoordonnees_FormatNumerotation> lstFormats = RelationFormatsNumerotation;
if (nNiveau >= lstFormats.Count())
{
return(0);
}
CRelationSystemeCoordonnees_FormatNumerotation relFormat = (CRelationSystemeCoordonnees_FormatNumerotation)lstFormats.ElementAt(nNiveau);
if (strAdresse2 == "" || strAdresse1 == "")
{
if (bEgalSiVide)
{
return(0);
}
else
{
return(strAdresse1.CompareTo(strAdresse2));
}
}
int nPos1 = strAdresse1.IndexOf(c_separateurNumerotations);
int nPos2 = strAdresse2.IndexOf(c_separateurNumerotations);
string strDebut1, strFin1;
string strDebut2, strFin2;
if (nPos1 > 0)
{
strDebut1 = strAdresse1.Substring(0, nPos1);
strFin1 = strAdresse1.Substring(nPos1 + 1);
}
else
{
strDebut1 = strAdresse1;
strFin1 = "";
}
if (nPos2 > 0)
{
strDebut2 = strAdresse2.Substring(0, nPos2);
strFin2 = strAdresse2.Substring(nPos2 + 1);
}
else
{
strDebut2 = strAdresse2;
strFin2 = "";
}
int nResult = relFormat.Compare(strDebut1, strDebut2);
if (nResult != 0)
{
return(nResult);
}
return(CompareAdresse(strFin1, strFin2, nNiveau + 1, bEgalSiVide));
}
//--------------------------------------------------------------
private void CFormCreerEquipement_Load(object sender, EventArgs e)
{
m_lblSite.Text = m_releveEqpt.ReleveSite.Site.Libelle;
if (m_releveEqpt.ReleveEquipementParent != null)
{
m_panelEqptParent.Visible = true;
m_lblEqptParent.Text = m_releveEqpt.ReleveEquipementParent.NumeroSerie + " " +
m_releveEqpt.ReleveEquipementParent.TypeEquipement.Libelle + " (" +
m_releveEqpt.ReleveEquipementParent.CoordonneeComplete + ")";
}
else
{
m_panelEqptParent.Visible = false;
}
m_txtSerial.Text = m_releveEqpt.NumeroSerie;
m_selectTypeEquipement.Init(m_releveEqpt, true);
m_panelCoordonnee.Init(m_releveEqpt, true);
CListeEntitesDeMemoryDb <CChampCustom> lstChamps = new CListeEntitesDeMemoryDb <CChampCustom>(CTimosInventoryDb.GetTimosDatas());
lstChamps.Filtre = CChampCustom.GetFiltreChampsForRole(CReleveEquipement.c_roleChampCustom);
if (lstChamps.Count() == 0)
{
m_panelChampsCustom.Visible = false;
}
else
{
m_panelChampsCustom.Visible = true;
foreach (CChampCustom champOrg in lstChamps)
{
CChampCustom champ = new CChampCustom(CTimosInventoryDb.GetInventaireDatas());
if (!champ.ReadIfExist(champOrg.Id))
{
champ = champOrg.GetChampInMemoryDb(CTimosInventoryDb.GetInventaireDatas());
}
if (champ != null)
{
CControleForCustomFieldReleve ctrl = new CControleForCustomFieldReleve();
m_panelChampsCustom.Controls.Add(ctrl);
ctrl.Dock = DockStyle.Left;
ctrl.Init(champ);
}
}
}
foreach (Control ctrl in m_panelChampsCustom.Controls)
{
CControleForCustomFieldReleve c = ctrl as CControleForCustomFieldReleve;
if (c != null)
{
c.InitChamps(m_releveEqpt);
}
}
}
//-------------------------------------------------------
public void ClearRelevesEquipements()
{
CListeEntitesDeMemoryDb <CReleveEquipement> lst = RelevesEquipement;
lst.Filtre = new CFiltreMemoryDb(CReleveEquipement.c_champIdContenant + " is null");
foreach (CReleveEquipement releve in lst.ToArray())
{
releve.Delete();
}
}
//----------------------------------------------------------
public IEnumerable <CAgentSnmpPourSupervision> GetAgentsForIp(string strIp)
{
CListeEntitesDeMemoryDb <CAgentSnmpPourSupervision> lst = new CListeEntitesDeMemoryDb <CAgentSnmpPourSupervision>(DataBase,
new CFiltreMemoryDb(CAgentSnmpPourSupervision.c_champIp + "=@1 or " +
CAgentSnmpPourSupervision.c_champTrapsIp + " like @2",
strIp,
"%," + strIp + ",%"));
return(lst);
}
//-------------------------------------------------------
public void RedescendAlarmes(CMemoryDb dbContenantLesAlarmesARedescendre)
{
CListeEntitesDeMemoryDb <CLocalAlarme> lst = new CListeEntitesDeMemoryDb <CLocalAlarme>(dbContenantLesAlarmesARedescendre);
foreach (CLocalAlarme alrm in lst)
{
CLocalAlarme myAlarm = new CLocalAlarme(m_database);
if (myAlarm.ReadIfExist(alrm.Id))
{
GereAlarme(alrm, EModeRemonteeAlarmes.NePasRemonter);
}
}
}
//----------------------------------------------------------------
private static void UpdateOptimizedDb()
{
CDataHotel hotel = null;
if (m_database != null)
{
CListeEntitesDeMemoryDb <CDataHotel> lst = new CListeEntitesDeMemoryDb <CDataHotel>(m_database);
if (lst.Count() > 0)
{
hotel = lst.ElementAt(0);
}
}
m_optimizedDb = new CDataRoomOptimizedDataBase(hotel);
}
//-------------------------------------------------------------------------------------
private HashSet <string> UpdateNombreAlarmesNonAcquittees()
{
HashSet <string> tableIdAlarmes = new HashSet <string>();
int nHashCode = 0;
// Affiche le nombre d'Alarmes non aqcuittées
if (m_dataBase != null)
{
CListeEntitesDeMemoryDb <CLocalTypeAlarme> listeTypesAlarme = new CListeEntitesDeMemoryDb <CLocalTypeAlarme>(m_dataBase);
listeTypesAlarme.Filtre = new CFiltreMemoryDb(
CLocalTypeAlarme.c_champAAcquitter + " = @1",
true);
List <string> lstIdString = new List <string>();
foreach (CLocalTypeAlarme typeAlarme in listeTypesAlarme)
{
lstIdString.Add(typeAlarme.Id);
}
string strListeIdTypes = string.Join(",", lstIdString.ToArray());
CListeEntitesDeMemoryDb <CLocalAlarme> listeAlarmes = new CListeEntitesDeMemoryDb <CLocalAlarme>(m_dataBase);
CFiltreMemoryDb filtre = new CFiltreMemoryDb(
CLocalAlarme.c_champIdParent + " is null and " +
CLocalAlarme.c_champDateFin + " is null and " +
CLocalAlarme.c_champDateAcquittement + " is null and " +
CLocalAlarme.c_champIdMasquageHerite + " is null");
if (strListeIdTypes != "")
{
filtre = CFiltreMemoryDb.GetAndFiltre(filtre, new CFiltreMemoryDb(
CLocalTypeAlarme.c_champId + " in(" + strListeIdTypes + ")"));
}
else
{
filtre = new CFiltreMemoryDBImpossible();
}
listeAlarmes.Filtre = filtre;
listeAlarmes.Sort = CLocalAlarme.c_champId;
int nCompteur = listeAlarmes.Count();
m_lblCompteurNouvellesAlarmes.Text = nCompteur.ToString();
// Calcul du Hash Code
StringBuilder sb = new StringBuilder();
foreach (CLocalAlarme alarme in listeAlarmes)
{
tableIdAlarmes.Add(alarme.Id);
}
}
return(tableIdAlarmes);
}
//------------------------------------------------------------------------
public static CIndexIdTimos <T> GetIdTimosIndex(CMemoryDb db)
{
CIndexIdTimos <T> dic = new CIndexIdTimos <T>();
CListeEntitesDeMemoryDb <T> lst = new CListeEntitesDeMemoryDb <T>(db);
foreach (T entite in lst)
{
if (entite.IdTimos != null)
{
dic[entite.IdTimos.Value] = entite;
}
}
return(dic);
}
//----------------------------------------------
private void AddChildren(CItemInventaire item)
{
CReleveEquipement relEq = item.ReleveEquipement;
int nIndex = item.Index;
CListeEntitesDeMemoryDb <CReleveEquipement> lstFils = relEq.RelevesContenus;
lstFils.Sort = CEquipement.c_champCoordonnee;
foreach (CReleveEquipement fils in lstFils)
{
CItemInventaire itemFils = new CItemInventaire(item, fils);
InsertItem(nIndex + 1, itemFils, false);
nIndex++;
}
Refresh();
}
//----------------------------------------------
public void Init(CReleveSite releve)
{
CListeEntitesDeMemoryDb <CReleveEquipement> lstEqpts = releve.RelevesEquipement;
lstEqpts.Filtre = new CFiltreMemoryDb(CReleveEquipement.c_champIdContenant + " is null");
lstEqpts.Sort = CEquipement.c_champCoordonnee;
List <CItemInventaire> lstItems = new List <CItemInventaire>();
foreach (CReleveEquipement relEq in lstEqpts)
{
CItemInventaire item = new CItemInventaire(null, relEq);
lstItems.Add(item);
}
Items = lstItems.ToArray();
}
//-------------------------------------------------------
public void InitEquipementsReleves( )
{
//Prépare les équipements
CListeEntitesDeMemoryDb <CEquipement> lstEqpts = Site.Equipements;
lstEqpts.Filtre = new CFiltreMemoryDb(CEquipement.c_champIdEquipementContenant + " is null");
lstEqpts.Sort = CEquipement.c_champCoordonnee;
foreach (CEquipement eqpt in lstEqpts)
{
CReleveEquipement relEqpt = new CReleveEquipement(Database as CReleveDb);
relEqpt.CreateNew();
relEqpt.ReleveSite = this;
relEqpt.FillFromEquipement(eqpt, null);
}
}
private void m_arbreEquipements_BeforeExpand(object sender, TreeViewCancelEventArgs e)
{
if (e.Node.Nodes.Count == 1 && e.Node.Nodes[0].Tag == null)
{
e.Node.Nodes.Clear();
CEquipement eqpt = e.Node.Tag as CEquipement;
List <TreeNode> lstNodes = new List <TreeNode>();
CListeEntitesDeMemoryDb <CEquipement> eqpts = eqpt.EquipementsContenus;
eqpts.Sort = CEquipement.c_champCoordonnee;
foreach (CEquipement fils in eqpts)
{
TreeNode node = CreateNodeEquipement(fils);
lstNodes.Add(node);
}
e.Node.Nodes.AddRange(lstNodes.ToArray());
}
}
//----------------------------------------------
public void CalculeEtatFromChilds()
{
CListeEntitesDeMemoryDb <CLocalAlarme> lstFils = Childs;
if (TypeAlarme == null || lstFils.Count() == 0)
{
return;
}
switch (TypeAlarme.ModeCalculEtat)
{
case EModeCalculEtatParent.AllChildsClosed:
bool bAllClose = true;
foreach (CLocalAlarme alrm in lstFils)
{
if (alrm.Etat.Code == EEtatAlarme.Open)
{
bAllClose = false;
break;
}
}
if (bAllClose)
{
EtatCode = EEtatAlarme.Close;
}
break;
case EModeCalculEtatParent.OneChildClosed:
foreach (CLocalAlarme alrm in lstFils)
{
if (alrm.Etat.Code == EEtatAlarme.Close)
{
EtatCode = EEtatAlarme.Close;
break;
}
}
break;
case EModeCalculEtatParent.Manual:
break;
default:
break;
}
}
//-----------------------------------------------------------------------------------
private void TraiteNotification(CNotificationModificationsAlarme notification)
{
HashSet <string> tableAlarmeAvant = UpdateNombreAlarmesNonAcquittees();
// Mise à jour des Alarmes
CListeEntitesDeMemoryDb <CLocalAlarme> listeAlaremsMaj = new CListeEntitesDeMemoryDb <CLocalAlarme>(notification.MemoryDb);
m_dataBase.AcceptChanges();
foreach (CLocalAlarme alarmeAjoutModif in listeAlaremsMaj)
{
if (alarmeAjoutModif.Parent == null)
{
CLocalAlarme alrm = m_dataBase.ImporteObjet(alarmeAjoutModif, true, true) as CLocalAlarme;
/*if (alrm != null)
* alrm.Row.Row.SetModified();*/
}
}
m_tableauAlarmesEnCours.UpdateDataBase(m_dataBase);
m_tableauAlarmesRetombees.UpdateDataBase(m_dataBase);
HashSet <string> tableAlarmeApres = UpdateNombreAlarmesNonAcquittees();
bool bSonnerie = false;
foreach (string strIdAlarme in tableAlarmeApres)
{
if (!tableAlarmeAvant.Contains(strIdAlarme))
{
bSonnerie = true;
break;
}
}
if (bSonnerie)
{
StartSonnerie();
}
else
{
StopSonnerie();
}
}
private void FillEquipements()
{
m_arbreEquipements.BeginUpdate();
m_arbreEquipements.Nodes.Clear();
CListeEntitesDeMemoryDb <CEquipement> lstEqts = m_site.Equipements;
lstEqts.Sort = CEquipement.c_champCoordonnee;
lstEqts.Filtre = new CFiltreMemoryDb(CEquipement.c_champIdEquipementContenant + " is null");
lstEqts.Sort = CEquipement.c_champCoordonnee + ", " + CTypeEquipement.c_champId;
List <TreeNode> lstNodes = new List <TreeNode>();
foreach (CEquipement eqpt in lstEqts)
{
TreeNode node = CreateNodeEquipement(eqpt);
lstNodes.Add(node);
}
m_arbreEquipements.Nodes.AddRange(lstNodes.ToArray());
m_arbreEquipements.EndUpdate();
}
//-------------------------------------------------------------
private static CResultAErreur IntegreReleve(TID.releve.CReleveSite releve,
CContexteDonnee ctx)
{
CResultAErreur result = CResultAErreur.True;
CReleveSite releveTimos = new CReleveSite(ctx);
releveTimos.CreateNewInCurrentContexte();
CSite site = GetObjetTimos <CSite>(releve.Row[TID.CSite.c_champId], ctx);
if (site == null)
{
result.EmpileErreur("Site doesn't exists");
return(result);
}
try
{
//Précharge les données
CListeObjetsDonnees lst = new CListeObjetsDonnees(ctx, typeof(CTypeEquipement));
lst.AssureLectureFaite();
lst = new CListeObjetsDonnees(ctx, typeof(CRelationTypeEquipement_Constructeurs));
lst.AssureLectureFaite();
lst = site.Equipements;
releveTimos.Site = site;
releveTimos.DateReleve = releve.DateReleve;
CListeEntitesDeMemoryDb <TID.releve.CReleveEquipement> lstEqpts = releve.RelevesEquipement;
lstEqpts.Filtre = new CFiltreMemoryDb(TID.releve.CReleveEquipement.c_champIdContenant + " is null");
foreach (TID.releve.CReleveEquipement relEq in lstEqpts)
{
result = IntegreReleveEquipement(relEq, null, releveTimos);
if (!result)
{
return(result);
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
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);
}
/// <summary>
/// Ajoute à la coordonnée nNbToAdd et retourne la nouvelle
/// coordonnée (string dans le data), ou une erreur si ce n'est pas possible
/// </summary>
/// <param name="strCoordonnee"></param>
/// <param name="nNbToAdd"></param>
/// <returns></returns>
public CResultAErreur AjouteDansNiveau(string strCoordonnee, int nNbToAdd)
{
CResultAErreur result = CResultAErreur.True;
string[] strNiveaux = strCoordonnee.Split(c_separateurNumerotations);
int nNiveauFinal = strNiveaux.Length - 1;
//récupère le la système de numérotation de ce niveau
CListeEntitesDeMemoryDb <CRelationSystemeCoordonnees_FormatNumerotation> listeNiveaux = RelationFormatsNumerotation;
listeNiveaux.Sort = CRelationSystemeCoordonnees_FormatNumerotation.c_champPosition;
if (nNiveauFinal > listeNiveaux.Count())
{
//plus de paramétrage pour ce niveau
result.EmpileErreur(I.T("The coordinate has too many levels for the defined system|253"));
return(result);
}
//Ajoute le nombre au dernier niveau
CRelationSystemeCoordonnees_FormatNumerotation rel = (CRelationSystemeCoordonnees_FormatNumerotation)listeNiveaux.ElementAt(nNiveauFinal);
result = rel.Ajoute(strNiveaux[strNiveaux.Length - 1], nNbToAdd);
if (!result)
{
return(result);
}
//Reconstruit la coordonnée
string strCoord = "";
for (int nNiveau = 0; nNiveau < nNiveauFinal; nNiveau++)
{
strCoord += strNiveaux[nNiveau] + c_separateurNumerotations;
}
strCoord += (string)result.Data;
result.Data = strCoord;
return(result);
}
//------------------------------------------------------------------
public CAgentSnmpPourSupervision[] GetAgentsFromKey(CTrapInstance trap)
{
CListeEntitesDeMemoryDb <CAgentSnmpPourSupervision> lstAgents =
new CListeEntitesDeMemoryDb <CAgentSnmpPourSupervision>(Database);
if (FormuleCleSpecifique != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(trap);
CResultAErreur result = FormuleCleSpecifique.Eval(ctx);
if (result && result.Data != null && result.Data is string)
{
lstAgents.Filtre = new CFiltreMemoryDb(
CAgentSnmpPourSupervision.c_champTrapsIp + " like @1",
"%," + (string)result.Data + ",%");
return(lstAgents.ToArray());
}
}
return(new CAgentSnmpPourSupervision[] { });
}
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();
}
/// <summary>
/// Analyse une coordonnée donnée avec une unité pour voir si le dernier niveau<br/>
/// de la coordonnée correspond bien avec fournie
/// </summary>
/// <param name="strCoordonnee">coordonnée à vérifier</param>
/// <param name="unite">Unite</param>
/// <returns>Retourne vrai ou faux avec des erreurs en cas de problème syntaxique ou autre sur la coordonnée</returns>
public CResultAErreur VerifieUnite(string strCoordonnee, CUniteCoordonnee unite)
{
CResultAErreur result = CResultAErreur.True;
string[] strNiveaux = strCoordonnee.Split(c_separateurNumerotations);
int nNiveauFinal = strNiveaux.Length - 1;
//récupère le la système de numérotation de ce niveau
CListeEntitesDeMemoryDb <CRelationSystemeCoordonnees_FormatNumerotation> listeNiveaux = RelationFormatsNumerotation;
listeNiveaux.Sort = CRelationSystemeCoordonnees_FormatNumerotation.c_champPosition;
if (nNiveauFinal > listeNiveaux.Count())
{
//plus de paramétrage pour ce niveau
result.EmpileErreur(I.T("The coordinate has too many levels for the defined system|253"));
return(result);
}
CRelationSystemeCoordonnees_FormatNumerotation rel = (CRelationSystemeCoordonnees_FormatNumerotation)listeNiveaux.ElementAt(nNiveauFinal);
return(rel.VerifieUnite(unite));
}
