//------------------------------------------------------------------------------------
public void GetInfosPopup(IDonneeNotification donnee, ref bool bShouldDisplay, ref string strLibelle, ref Image image)
{
bShouldDisplay = false;
CDonneeNotificationWorkflow dw = donnee as CDonneeNotificationWorkflow;
if (dw == null)
{
return;
}
string[] strCodesInteressants = CUtilSession.GetCodesAffectationsEtapeConcernant(CSc2iWin32DataClient.ContexteCourant);
bool bPourMoi = false;
foreach (string strCode in strCodesInteressants)
{
if (dw.CodesAffectations.Contains("~" + strCode + "~"))
{
bPourMoi = true;
break;
}
}
if (bPourMoi)
{
strLibelle = dw.Libelle;
image = Resources._1346738948_task;
bShouldDisplay = true;
}
}
private static void m_recepteurNotifications_OnReceiveNotification(IDonneeNotification donnee)
{
lock (typeof(CLockerCacheRegistre))
{
m_cacheDonnees.Clear();
}
}
/// /////////////////////////////////////////////////////////////////////////////////
private static void OnModifSurDonnees(IDonneeNotification donnee)
{
if (donnee is CDonneeNotificationModificationContexteDonnee)
{
CDonneeNotificationModificationContexteDonnee donneeContexte = (CDonneeNotificationModificationContexteDonnee)donnee;
foreach (CDonneeNotificationModificationContexteDonnee.CInfoEnregistrementModifie info in donneeContexte.ListeModifications)
{
if (info.NomTable == CEvenement.c_nomTable)
{
m_bEvenementsChanged = true;
lock (typeof(CLockerCacheEvenements))
{
m_tableTypeToEvenements.Clear();
}
break;
}
}
}
if (donnee is CDonneeNotificationAjoutEnregistrement)
{
CDonneeNotificationAjoutEnregistrement donneeAjout = (CDonneeNotificationAjoutEnregistrement)donnee;
if (donneeAjout.NomTable == CEvenement.c_nomTable)
{
m_bEvenementsChanged = true;
lock (typeof(CLockerCacheEvenements))
{
m_tableTypeToEvenements.Clear();
}
}
}
}
/// ///////////////////////////////////////////////////////
public void RecoitNotification(IDonneeNotification donnee)
{
if (Enabled && OnReceiveNotification != null)
{
OnReceiveNotification(donnee);
}
}
//------------------------------------------------------------------------------------
private void OnChangementDansObjets(IDonneeNotification donnee)
{
if (donnee is CDonneeNotificationModificationContexteDonnee)
{
CDonneeNotificationModificationContexteDonnee modif = (CDonneeNotificationModificationContexteDonnee)donnee;
foreach (CDonneeNotificationModificationContexteDonnee.CInfoEnregistrementModifie info in modif.ListeModifications)
{
if (m_datasetRecherche.Tables[info.NomTable] != null)
{
lock ( m_datasetRecherche )
{
m_datasetRecherche.Tables.Remove(info.NomTable);
}
}
}
}
if (donnee is CDonneeNotificationAjoutEnregistrement)
{
string strNomTable = ((CDonneeNotificationAjoutEnregistrement)donnee).NomTable;
if (m_datasetRecherche.Tables[strNomTable] != null)
{
lock ( m_datasetRecherche )
{
m_datasetRecherche.Tables.Remove(strNomTable);
}
}
}
}
public CMessageNotification(
string strMessage,
Image image,
IDonneeNotification donneeNotification)
{
m_strMessage = strMessage;
m_donnee = donneeNotification;
m_image = image;
m_DateExpiration = DateTime.Now.AddSeconds(CParametresNotification.DureeAffichage);
}
//------------------------------------------------------------------------------------
public void ExecuteNotification(IDonneeNotification donnee)
{
CDonneeNotificationBesoinIntervention db = donnee as CDonneeNotificationBesoinIntervention;
if (db != null)
{
int nId = db.IdBesoinUtilisateur;
ExecuteBesoinInterventionProcess(nId);
}
}
void m_recepteurWorkflow_OnReceiveNotification(IDonneeNotification donnee)
{
CDonneeNotificationWorkflow dw = donnee as CDonneeNotificationWorkflow;
if (dw == null)
{
return;
}
string[] strCodesInteressants = CUtilSession.GetCodesAffectationsEtapeConcernant(CSc2iWin32DataClient.ContexteCourant);
bool bPourMoi = false;
foreach (string strCode in strCodesInteressants)
{
if (dw.CodesAffectations.Contains("~" + strCode + "~"))
{
bPourMoi = true;
break;
}
}
if (bPourMoi)
{
CSessionClient session = CSessionClient.GetSessionForIdSession(dw.IdSessionEnvoyeur);
CSousSessionClient sousSession = session as CSousSessionClient;
if (sousSession != null)
{
session = sousSession.RootSession;
}
if (session != null &&
session.IdSession == CTimosApp.SessionClient.IdSession &&
dw.ExecutionAutomatique
)
{
m_nIdEtapeToLaunch = dw.IdEtapeSource;
}
m_nNbClignotementsWorkflowsRestant += c_nNbClignotementsWorkflow;
CDonneesActeurUtilisateur user = CUtilSession.GetUserForSession(CSc2iWin32DataClient.ContexteCourant);
if (user != null)
{
CListeObjetsDonnees lstPourActeur = user.Acteur.GetEtapeWorkflowsEnCours();
m_nNbEtapesEnCours = lstPourActeur.Count;
if (m_nNbEtapesEnCours > 0)
{
m_lblNbToDo.Text = m_nNbEtapesEnCours.ToString();
m_lblNbToDo.Visible = true;
}
else
{
m_lblNbToDo.Text = "0";
m_lblNbToDo.Visible = false;
}
}
}
}
/// //////////////////////////////////////////////////////////////////
protected void OnNotificationChangementDroit(IDonneeNotification donnee)
{
if (!(donnee is CDonneeNotificationChangementDroitUtilisateur))
{
return;
}
if (((CDonneeNotificationChangementDroitUtilisateur)donnee).KeyUtilisateur == m_keyUtilisateur)
{
m_bReload = true;
}
}
//-----------------------------------------------------------------------------
private static void m_recepteurAjout_OnReceiveNotification(IDonneeNotification donnee)
{
lock (typeof(CFournisseurConstantesEntitesNommees))
{
CDonneeNotificationAjoutEnregistrement ajout = donnee as CDonneeNotificationAjoutEnregistrement;
if (ajout.NomTable == CNommageEntite.c_nomTable)
{
m_listeExpression = null;
}
}
}
//----------------------------------------------------------------------------------------------
// Réception des notifications d'alarmes ici
void m_recepteurAlarme_Notification(IDonneeNotification donnee)
{
CDonneeNotificationAlarmes donneeAlarme = donnee as CDonneeNotificationAlarmes;
if (donneeAlarme == null)
{
return;
}
CEvenementAlarm[] lstAlarmes = donneeAlarme.Alarmes;
foreach (CEvenementAlarm evAlarme in lstAlarmes)
{
if (evAlarme is CEvenementAlarmStartStop)
{
CEvenementAlarmStartStop evtAlarmStartStop = (CEvenementAlarmStartStop)evAlarme;
if (evtAlarmStartStop.Gravite == EGraviteAlarmeAvecMasquage.EndAlarm)
{
if (evtAlarmStartStop.IdAlarmData > 0)
{
int nIdAlarmeData = evtAlarmStartStop.IdAlarmData;
StopAlarme(nIdAlarmeData);
}
}
else
{
StartAlarme(new CInfoAlarmeAffichee(evtAlarmStartStop));
}
}
else if (evAlarme is CEvenementAlarmMasqueeParUneAutre)
{
CEvenementAlarmMasqueeParUneAutre evenementAlarm =
(CEvenementAlarmMasqueeParUneAutre)evAlarme;
//if (evenementAlarm.AlarmStartId > 0)
// StopAlarme(evenementAlarm.AlarmStartId);
if (evenementAlarm.IdAlarmeData > 0)
{
StopAlarme(evenementAlarm.IdAlarmeData);
}
}
else if (evAlarme is CEvenementAlarmMask)
{
CEvenementAlarmMask evenementAlarm = (CEvenementAlarmMask)evAlarme;
if (evenementAlarm.IdLienAccesAlarme > 0)
{
MaskAlarme(evenementAlarm);
}
}
}
List <CInfoElementDeSchemaSupervise> lstConcernes = new List <CInfoElementDeSchemaSupervise>();
OnChangementDansLaBase(lstConcernes);
}
//-----------------------------------------------------
public void ShowMessage(string strMessage, Image img, IDonneeNotification donnee)
{
if (!IsHandleCreated)
{
CreateHandle();
}
Invoke(new MethodInvoker(delegate
{
PrivateShowMessage(strMessage, img, donnee);
}));
}
//-----------------------------------------------------------------------------------
void OnReceiveNotification(IDonneeNotification donnee)
{
CNotificationModificationsAlarme notification = donnee as CNotificationModificationsAlarme;
if (notification == null)
{
return;
}
lock (typeof(CLockerNotificationAlarmes))
{
TraiteNotification(notification);
}
}
//-----------------------------------------------------
private void PrivateShowMessage(string strMessage, Image img, IDonneeNotification donnee)
{
lock (m_listeMessages)
{
if (donnee != null)
{
CMessageNotification m = new CMessageNotification(strMessage, img, donnee);
m_listeMessages.Add(m);
CParametresNotification.PlaySound();
}
AfficheMessages();
}
}
//------------------------------------------------------------------------------------
public void ExecuteNotification(IDonneeNotification donnee)
{
CDonneeNotificationWorkflow dw = donnee as CDonneeNotificationWorkflow;
if (dw != null)
{
int nId = dw.IdEtapeSource;
CEtapeWorkflow etape = new CEtapeWorkflow(CSc2iWin32DataClient.ContexteCourant);
if (etape.ReadIfExists(nId))
{
CGestionnaireWorkflowsEnCours.Instance.AfficheEtape(etape);
}
}
}
//------------------------------------------------------
private void m_link_Click(object sender, EventArgs e)
{
CFormNotificationPopup.CMessageNotification m = CurrentItem != null ?
CurrentItem.Tag as CFormNotificationPopup.CMessageNotification :
null;
if (m != null)
{
IDonneeNotification donnee = m.DonneeNotification;
CGestionnaireNotificationsPopup.ExecuteNotification(donnee);
if (OnNotificationExecuted != null)
{
OnNotificationExecuted(m, null);
}
}
}
/// ///////////////////////////////////////
private void OnNotification(IDonneeNotification donneeNotification)
{
if (donneeNotification is CDonneeNotificationBesoinIntervention)
{
CDonneeNotificationBesoinIntervention dnbi = (CDonneeNotificationBesoinIntervention)donneeNotification;
if (dnbi.KeyUtilisateurConcerne == CTimosApp.SessionClient.GetInfoUtilisateur().KeyUtilisateur)
{
BeginInvoke((MethodInvoker) delegate
{
UpdateInterventions();
});
//CAppeleurFonctionAvecDelai.CallFonctionAvecDelai(this, "UpdateInterventions", 5000);
//UpdateInterventions();
}
}
}
void m_recepteurMessage_OnReceiveNotification(IDonneeNotification donnee)
{
if (donnee is CDonneeNotificationMessageInstantane)
{
CDonneeNotificationMessageInstantane message = (CDonneeNotificationMessageInstantane)donnee;
try
{
if (message.KeyUtilisateurDestinataire == CTimosApp.SessionClient.GetInfoUtilisateur().KeyUtilisateur)
{
}
}
catch
{
}
}
}
//------------------------------------------------------
private void m_recepteurMessage_OnReceiveNotification(IDonneeNotification donnee)
{
if (donnee is CDonneeNotificationMessageInstantane)
{
CDonneeNotificationMessageInstantane message = (CDonneeNotificationMessageInstantane)donnee;
try
{
if (message.KeyUtilisateurDestinataire == CTimosApp.SessionClient.GetInfoUtilisateur().KeyUtilisateur)
{
m_controleChat.OnMessage(message.IdEnvoyeur, message.Message);
}
}
catch
{
}
}
}
//--------------------------------------------------------------------------------------
public static void ExecuteNotification(IDonneeNotification d)
{
if (d == null)
{
return;
}
IExecuteurNotificationPopup executeur = null;
if (m_dicTypeNotificationToExecuteur.TryGetValue(d.GetType(), out executeur))
{
try
{
executeur.ExecuteNotification(d);
}
catch { }
}
}
//-----------------------------------------------------------------------------------
static void m_recepteurAjouts_OnReceiveNotification(IDonneeNotification donnee)
{
if (m_tableIdUserEtTypeToFiltre.Count > 0)
{
if (donnee is CDonneeNotificationAjoutEnregistrement)
{
CDonneeNotificationAjoutEnregistrement dataAjout = (CDonneeNotificationAjoutEnregistrement)donnee;
if (dataAjout.NomTable == CProfilUtilisateur.c_nomTable ||
dataAjout.NomTable == CProfilUtilisateur_Restriction.c_nomTable ||
dataAjout.NomTable == CRelationUtilisateur_Profil.c_nomTable ||
dataAjout.NomTable == CRelationUtilisateur_Profil_EO.c_nomTable ||
dataAjout.NomTable == CProfilUtilisateur_Inclusion.c_nomTable)
{
m_tableIdUserEtTypeToFiltre.Clear();
}
}
}
}
//-----------------------------------------------------------------------------
private static void m_recepteurModification_OnReceiveNotification(IDonneeNotification donnee)
{
lock (typeof(CFournisseurConstantesEntitesNommees))
{
CDonneeNotificationModificationContexteDonnee modif = donnee as CDonneeNotificationModificationContexteDonnee;
if (modif == null)
{
return;
}
foreach (sc2i.data.CDonneeNotificationModificationContexteDonnee.CInfoEnregistrementModifie info in modif.ListeModifications)
{
if (info.NomTable == CNommageEntite.c_nomTable)
{
m_listeExpression = null;
break;
}
}
}
}
//------------------------------------------------------------------------------------
public void GetInfosPopup(IDonneeNotification donnee, ref bool bShouldDisplay, ref string strLibelle, ref Image image)
{
bShouldDisplay = false;
CDonneeNotificationBesoinIntervention db = donnee as CDonneeNotificationBesoinIntervention;
if (db == null)
{
return;
}
if (!db.IsDelete)
{
//TESTDBKEYOK
IInfoUtilisateur info = CTimosApp.SessionClient.GetInfoUtilisateur();
if (info != null && info.KeyUtilisateur == db.KeyUtilisateurConcerne)
{
strLibelle = db.Libelle;
image = Resources.alerte;
bShouldDisplay = true;
}
}
}
//--------------------------------------------------------------------------------------
public static void recepteur_OnReceiveNotification(IDonneeNotification donnee)
{
if (donnee == null)
{
return;
}
IExecuteurNotificationPopup executeur = null;
if (m_dicTypeNotificationToExecuteur.TryGetValue(donnee.GetType(), out executeur))
{
bool bShouldDisplay = true;
string strLibelle = "";
Image img = null;
executeur.GetInfosPopup(donnee, ref bShouldDisplay, ref strLibelle, ref img);
if (bShouldDisplay)
{
CFormNotificationPopup.Instance.ShowMessage(
strLibelle, img, donnee);
}
}
}
////////////////////////////////////////////////////////////////////////////
protected static void OnReceiveNotificationModif(IDonneeNotification donnee)
{
if (!(donnee is CDonneeNotificationModificationContexteDonnee))
{
return;
}
//Marque tous les éléments comme étant à relire depuis la base de données
CDonneeNotificationModificationContexteDonnee donneeModif = (CDonneeNotificationModificationContexteDonnee)donnee;
foreach (CDonneeNotificationModificationContexteDonnee.CInfoEnregistrementModifie info in donneeModif.ListeModifications)
{
if (info.NomTable == CTypeActiviteActeur.c_nomTable)
{
lock (typeof(CLockerArbres))
{
m_arbreVocabulaire = null;
}
return;
}
}
}
//-----------------------------------------------------------------------------------
static void m_recepteurModifs_OnReceiveNotification(IDonneeNotification donnee)
{
if (m_tableIdUserEtTypeToFiltre.Count > 0)
{
if (donnee is CDonneeNotificationModificationContexteDonnee)
{
CDonneeNotificationModificationContexteDonnee dataModif = (CDonneeNotificationModificationContexteDonnee)donnee;
foreach (CDonneeNotificationModificationContexteDonnee.CInfoEnregistrementModifie info in dataModif.ListeModifications)
{
if (info.NomTable == CProfilUtilisateur.c_nomTable ||
info.NomTable == CProfilUtilisateur_Restriction.c_nomTable ||
info.NomTable == CRelationUtilisateur_Profil.c_nomTable ||
info.NomTable == CRelationUtilisateur_Profil_EO.c_nomTable ||
info.NomTable == CProfilUtilisateur_Inclusion.c_nomTable)
{
m_tableIdUserEtTypeToFiltre.Clear();
break;
}
}
}
}
}
////////////////////////////////////////////////////////////////////////////
protected static void OnReceiveNotificationAjout(IDonneeNotification donnee)
{
try
{
if (!(donnee is CDonneeNotificationAjoutEnregistrement))
{
return;
}
//Marque tous les éléments comme étant à relire depuis la base de données
CDonneeNotificationAjoutEnregistrement donneeAjout = (CDonneeNotificationAjoutEnregistrement)donnee;
if (donneeAjout.NomTable == CTypeActiviteActeur.c_nomTable)
{
lock (typeof(CLockerArbres))
{
m_arbreVocabulaire = null;
}
}
}
catch
{
}
}
//------------------------------------------------------
public static void recepteur_OnReceiveNotification(IDonneeNotification donnee)
{
CGestionnaireUnites.Refresh();
}
void OnReceiveNotificationAlarmEnCours(IDonneeNotification donnee)
{
CDonneeNotificationAlarmes donneeAlarme = donnee as CDonneeNotificationAlarmes;
if (donneeAlarme == null)
{
return;
}
CEvenementAlarm[] lstAlarmes = donneeAlarme.Alarmes;
foreach (CEvenementAlarm evAl in lstAlarmes)
{
if (evAl is CEvenementAlarmStartStop)
{
CEvenementAlarmStartStop evAlarme = (CEvenementAlarmStartStop)evAl;
if (IsFrequentAlarm(evAlarme))
{
MAJFrequentButtonText();
continue;
}
CInfoAlarmeAffichee infoAlarm = new CInfoAlarmeAffichee(evAlarme);
if (m_consultationEnCours.Parametres.FormuleFiltre != null)
{
CContexteEvaluationExpression contexte = new CContexteEvaluationExpression(infoAlarm);
CResultAErreur result = m_consultationEnCours.Parametres.FormuleFiltre.Eval(contexte);
if (!Convert.ToBoolean(result.Data))
{
continue;
}
}
if (evAlarme.Gravite == EGraviteAlarmeAvecMasquage.EndAlarm &&
evAlarme.IdAlarmeDebut > 0)
{
for (int i = 0; i < m_lstViewEnCours.GetCount(); i++)
{
infoAlarm = (CInfoAlarmeAffichee)m_lstViewEnCours.GetObjectFromList(i);
if (infoAlarm != null && infoAlarm.IdSpvEvtAlarme == evAlarme.IdAlarmeDebut)
{
if (m_consultationEnCours.Parametres.DelaiMasquageTerminnees > 0)
{
infoAlarm.DateEffacement = DateTime.Now.AddMinutes(m_consultationEnCours.Parametres.DelaiMasquageTerminnees);
}
m_lstViewEnCours.RemoveObjet(infoAlarm);
infoAlarm.DateFin = evAlarme.DateEvenementAlarme;
m_lstViewRetombe.AddObject(infoAlarm, CSpvWin32Registre.TriConsultationAlarmeCroissant);
break;
}
}
}
else
{
m_lstViewEnCours.AddObject(new CInfoAlarmeAffichee(evAlarme),
CSpvWin32Registre.TriConsultationAlarmeCroissant);
SetVoyantAlarme();
}
}
else if (evAl is CEvenementAlarmMasqueeParUneAutre)
{
for (int i = 0; i < m_lstViewEnCours.GetCount(); i++)
{
CInfoAlarmeAffichee infoAlarm = (CInfoAlarmeAffichee)m_lstViewEnCours.GetObjectFromList(i);
if (infoAlarm != null && infoAlarm.IdSpvEvtAlarme ==
((CEvenementAlarmMasqueeParUneAutre)evAl).AlarmStartId)
{
m_lstViewEnCours.RemoveObjet(infoAlarm);
// infoAlarm.DateFin = evAlarme.EventAlarmRetombee.StopAlarmDate;
// m_lstViewRetombe.AddObject(infoAlarm);
break;
}
}
}
else if (evAl is CEvenementAlarmMask)
{
CEvenementAlarmMask evAlarme = (CEvenementAlarmMask)evAl;
if (evAlarme.NiveauMasquage != EMasquage.NonMasque)
{
if (evAlarme.LocalName == (new CMaskedBy(EMaskedBy.Administrateur)).Libelle)
{
m_NbMaskAdm++;
}
else
{
m_NbMaskBrig++;
}
}
else
{
if (evAlarme.LocalName == (new CMaskedBy(EMaskedBy.Administrateur)).Libelle)
{
m_NbMaskAdm--;
}
else
{
m_NbMaskBrig--;
}
}
MAJAdminButtonText();
MAJBrigButtonText();
}
else if (evAl is CEvenementAlarmAcknowledge)
{
CEvenementAlarmAcknowledge evAlarme = (CEvenementAlarmAcknowledge)evAl;
if (evAlarme.IdAlarmeAcquittee == 0) // Acquittement de liste
{
if (evAlarme.IdListeAlarmeAcquittee == m_consultationEnCours.Id) // Cette liste
{
TraiteAquitteAlarmes();
}
}
else
{ // Acquittement d'une alarme précise
bool bTrouve = false;
for (int i = 0; i < m_lstViewEnCours.GetCount(); i++)
{
CInfoAlarmeAffichee infoAlarm = (CInfoAlarmeAffichee)m_lstViewEnCours.GetObjectFromList(i);
if (infoAlarm != null && infoAlarm.IdSpvEvtAlarme == evAlarme.IdAlarmeAcquittee)
{
infoAlarm.EstAcquittee = true;
bTrouve = true;
break;
}
}
if (!bTrouve) // l'alarme doit être dans les retombées
{
for (int i = 0; i < m_lstViewRetombe.GetCount(); i++)
{
CInfoAlarmeAffichee infoAlarm = (CInfoAlarmeAffichee)m_lstViewRetombe.GetObjectFromList(i);
if (infoAlarm != null && infoAlarm.IdSpvEvtAlarme == evAlarme.IdAlarmeAcquittee)
{
infoAlarm.EstAcquittee = true;
if (m_consultationEnCours.Parametres.DelaiMasquageTerminnees > 0)
{
infoAlarm.DateEffacement = DateTime.Now.AddMinutes(m_consultationEnCours.Parametres.DelaiMasquageTerminnees);
}
break;
}
}
}
}
}
}
}
void m_recepteurConnexion_OnReceiveNotification(IDonneeNotification donnee)
{
throw new Exception("The method or operation is not implemented.");
}