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;
}
}
}
}
///////////////////////////////////////////
/// <summary>
/// Retourne l'id de la session qui gère les transaction pour cette session
/// </summary>
/// <param name="nIdSession"></param>
/// <returns></returns>
private int GetIdSessionForDb(int nIdSession)
{
CSessionClient session = CSessionClient.GetSessionForIdSession(nIdSession);
CSousSessionClient sousSession = session as CSousSessionClient;
if (sousSession != null)
{
return(sousSession.RootSession.IdSession);
}
return(nIdSession);
}
//----------------------------------------------------------------------
public CResultAErreur UpdateValeurs(CContexteDonnee contexteDeBasePasEnEdition, IIndicateurProgression indicateurProgression)
{
if (Count == 0)
{
return(CResultAErreur.True);
}
CConteneurIndicateurProgression progress = CConteneurIndicateurProgression.GetConteneur(indicateurProgression);
CResultAErreur result = CResultAErreur.True;
//Lecture entite par entité pour optimiser la lecture
Dictionary <CEntiteSnmp, HashSet <CChampCustom> > lstChamps = new Dictionary <CEntiteSnmp, HashSet <CChampCustom> >();
progress.SetBornesSegment(0, Count);
foreach (CCoupleEntiteSnmp_Champ couple in this)
{
HashSet <CChampCustom> set = null;
if (!lstChamps.TryGetValue(couple.Entite, out set))
{
set = new HashSet <CChampCustom>();
lstChamps[couple.Entite] = set;
}
set.Add(couple.ChampCustom);
}
CSessionClient session = CSousSessionClient.GetNewSousSession(this[0].Entite.ContexteDonnee.IdSession);
session.OpenSession(new CAuthentificationSessionSousSession(this[0].Entite.ContexteDonnee.IdSession),
"SNMP", ETypeApplicationCliente.Service);
using (CContexteDonnee ctxModif = new CContexteDonnee(session.IdSession, true, false))
{
int nIndex = 1;
foreach (KeyValuePair <CEntiteSnmp, HashSet <CChampCustom> > kv in lstChamps)
{
CEntiteSnmp entite = kv.Key.GetObjetInContexte(ctxModif) as CEntiteSnmp;
CInterrogateurSnmp dynamicAgent = new CInterrogateurSnmp();
dynamicAgent.Connexion = entite.AgentSnmp.GetNewSnmpConnexion();
CEntiteSnmpPourSupervision ettSup = null;
foreach (CChampCustom champ in kv.Value)
{
int nIdChamp = champ.Id;
if (entite.ReadChampSnmp(nIdChamp, dynamicAgent, ref ettSup))
{
entite.CopieValeurSnmpDansValeurChamp(nIdChamp);
}
progress.SetValue(nIndex++);
}
}
progress.SetValue(Count);
ctxModif.SaveAll(true);
System.Threading.Thread.Sleep(2000);
session.CloseSession();
}
return(result);
}
/// //////////////////////////////////////////////////
///Démarre une étape dans un thread séparé
public void RunEtapeInThread(int nIdEtape)
{
Thread th = new Thread(StartEtapeInThread);
int nIdSession = IdSession;
//Lance l'étape dans la session root, car la sousSEssion peut être fermée avant que
//L'étape ne soit lancée !
CSousSessionClient session = CSessionClient.GetSessionForIdSession(IdSession) as CSousSessionClient;
if (session != null)
{
nIdSession = session.RootSession.IdSession;
}
th.Start(new CParametresStartEtape(nIdSession, nIdEtape));
}
/// //////////////////////////////////////////////////
///Démarre une étape dans un thread séparé
public static void CalcElementsInThread(CElementsProjetARecalculer lstElements)
{
Thread th = new Thread(DoCalcInThread);
int nIdSession = lstElements.IdSession;
//Lance l'étape dans la session root, car la sousSEssion peut être fermée avant que
//L'étape ne soit lancée !
CSousSessionClient session = CSessionClient.GetSessionForIdSession(lstElements.IdSession) as CSousSessionClient;
if (session != null)
{
nIdSession = session.RootSession.IdSession;
}
th.Start(lstElements);
}
/// //////////////////////////////////////////////////
public override CResultAErreur TraitementApresSauvegarde(sc2i.data.CContexteDonnee contexte, bool bOperationReussie)
{
CResultAErreur result = CResultAErreur.True;
result = base.TraitementApresSauvegarde(contexte, bOperationReussie);
if (!result)
{
return(result);
}
DataTable table = contexte.Tables[GetNomTable()];
List <DataRow> lstRowsEtapesADemarrer = table == null ? null : table.ExtendedProperties[c_constEtapesADemarre] as List <DataRow>;
if (lstRowsEtapesADemarrer != null && lstRowsEtapesADemarrer.Count > 0)
{
int? nIdSessionMain = IdSession;
CDbKey keyUtilisateur = null;
CSessionClient session = CSessionClient.GetSessionForIdSession(IdSession);
if (session != null)
{
IInfoUtilisateur info = session.GetInfoUtilisateur();
//TESTDBKEYOK
if (info != null)
{
keyUtilisateur = info.KeyUtilisateur;
}
CSousSessionClient sousSession = session as CSousSessionClient;
if (sousSession != null)
{
nIdSessionMain = sousSession.RootSession.IdSession;
}
}
List <CParametresStartEtapeInPile> lstToStart = new List <CParametresStartEtapeInPile>();
foreach (DataRow row in lstRowsEtapesADemarrer)
{
//Ancien mode, avant 13/9/2013
//RunEtapeInThread ( (int)row[CEtapeWorkflow.c_champId]);
//TESTDBKEYOK
lstToStart.Add(new CParametresStartEtapeInPile(
nIdSessionMain, (int)row[CEtapeWorkflow.c_champId], keyUtilisateur));
}
CPileExecutionEtapes.AddEtapesADemarrer(lstToStart.ToArray());
}
return(result);
}
/// //////////////////////////////////////////////////////////////////////////
internal static CGestionnaireTransactionsNotification GetGestionnaireTransaction(int nIdSession)
{
CGestionnaireTransactionsNotification gestionnaire = (CGestionnaireTransactionsNotification)m_tableGestionnairesTransaction[nIdSession];
if (gestionnaire == null)
{
//Stef, le 03102008, gestion des sous sessions
CSousSessionClient sousSession = CSessionClient.GetSessionForIdSession(nIdSession) as CSousSessionClient;
if (sousSession != null) //C'est une sous session, donc utilise le gestionnaire de transactions de sa session principale
{
gestionnaire = GetGestionnaireTransaction(sousSession.RootSession.IdSession);
//Ne stocke pas dans le cache, car
//le gestionnaire n'est pas attaché à la sous session,
//donc, il ne sera pas supprimé par le OnCloseSession
//m_tableGestionnairesTransaction[nIdSession] = gestionnaire;
}
else
{
gestionnaire = new CGestionnaireTransactionsNotification(nIdSession);
m_tableGestionnairesTransaction[nIdSession] = gestionnaire;
}
}
return(gestionnaire);
}
/// //////////////////////////////////////////////////
public CResultAErreur RepriseProcess(int nIdProcessEnExecution,
int nIdAction,
IIndicateurProgression indicateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Register(indicateur);
CResultAErreur result = CResultAErreur.True;
///Stef, 290808 : ouvre une session spécifique pour le process
///Pour pouvoir gérer le changement d'utilisateur proprement
CSousSessionClient session = CSousSessionClient.GetNewSousSession(IdSession);
session.OpenSession(new CAuthentificationSessionSousSession(IdSession), "Continue process " + nIdProcessEnExecution, ETypeApplicationCliente.Process);
CSessionClient sessionOriginale = CSessionClient.GetSessionForIdSession(IdSession);
//TESTDBKEYTODO
if (sessionOriginale.GetInfoUtilisateur() != null)
{
session.ChangeUtilisateur(sessionOriginale.GetInfoUtilisateur().KeyUtilisateur);
}
try
{
//Stef 08/12/2007 : le contexte ne reçoit plus les notifications
using (CContexteDonnee contexteDonnee = new CContexteDonnee(session.IdSession, true, false))
{
CProcessEnExecutionInDb processEnExecution = new CProcessEnExecutionInDb(contexteDonnee);
if (!processEnExecution.ReadIfExists(nIdProcessEnExecution))
{
result.EmpileErreur(I.T("Current action @1 doesn't exist|30012", nIdProcessEnExecution.ToString()));
return(result);
}
result = contexteDonnee.SetVersionDeTravail(processEnExecution.IdVersionExecution, true);
if (!result)
{
return(result);
}
CBrancheProcess branche = processEnExecution.BrancheEnCours;
CContexteExecutionAction contexteExecution = new CContexteExecutionAction(
processEnExecution, branche, branche.Process.GetValeurChamp(CProcess.c_strIdVariableElement), contexteDonnee, indicateur);
CAction action = branche.Process.GetActionFromId(nIdAction);
if (action == null)
{
result.EmpileErreur(I.T("Impossible to resume the processing : the action @1 doesn't exist|30013", nIdAction.ToString()));
return(result);
}
bool bTrans = false;
if (branche.Process.ModeTransactionnel)
{
session.BeginTrans();
bTrans = true;
}
try
{
result = branche.ExecuteAction(action, contexteExecution, true);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
if (bTrans)
{
if (result)
{
result = session.CommitTrans();
if (result)
{
contexteExecution.OnEndProcess();
}
}
else
{
session.RollbackTrans();
}
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
try
{
session.CloseSession();
}
catch { }
}
return(result);
}
}
/// //////////////////////////////////////////////////
public CResultAErreur StartProcessMultiples(CValise2iSerializable valiseProcess,
CReferenceObjetDonnee[] refsCible,
int?nIdVersion,
IIndicateurProgression indicateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Register(indicateur);
CResultAErreur result = CResultAErreur.True;
//Stef 08/12/2007 : le contexte ne reçoit plus les notifications
using (CContexteDonnee contexteDeSession = new CContexteDonnee(IdSession, true, false))
{
result = valiseProcess.GetObjet(typeof(CContexteDonnee), contexteDeSession);
if (!result)
{
result.EmpileErreur(I.T("Error while process recovering|30014"));
return(result);
}
CProcess leProcessAExecuter = (CProcess)result.Data;
CObjetDonneeAIdNumerique objetCible = null;
///Stef, 290808 : ouvre une session spécifique pour le process
///Pour pouvoir gérer le changement d'utilisateur proprement
CSousSessionClient session = CSousSessionClient.GetNewSousSession(contexteDeSession.IdSession);
session.OpenSession(new CAuthentificationSessionSousSession(contexteDeSession.IdSession), leProcessAExecuter.Libelle, ETypeApplicationCliente.Process);
CSessionClient sessionOriginale = CSessionClient.GetSessionForIdSession(contexteDeSession.IdSession);
//TESTDBKEYOK
if (sessionOriginale.GetInfoUtilisateur() != null)
{
session.ChangeUtilisateur(sessionOriginale.GetInfoUtilisateur().KeyUtilisateur);
}
try
{
//Charge les éléments pour la nouvelle session;
//Stef 08/12/2007 : le contexte ne reçoit plus les notifications
using (CContexteDonnee contexte = new CContexteDonnee(session.IdSession, true, false))
{
result = contexte.SetVersionDeTravail(nIdVersion, true);
if (!result)
{
return(result);
}
if (leProcessAExecuter.SurTableauDeTypeCible)
{
ArrayList lst = new ArrayList();
foreach (CReferenceObjetDonnee refCibleTmp in refsCible)
{
object tmp = refCibleTmp.GetObjet(contexte);
if (tmp != null)
{
lst.Add(tmp);
}
}
return(ExecuteProcess(session, lst, leProcessAExecuter, contexte, false, indicateur));
}
try
{
if (!leProcessAExecuter.ModeAsynchrone)
{
session.BeginTrans(IsolationLevel.ReadCommitted);
}
foreach (CReferenceObjetDonnee refCible in refsCible)
{
bool bShouldStart = true;
if (refCible != null)
{
objetCible = (CObjetDonneeAIdNumerique)refCible.GetObjet(contexte);
if (objetCible == null)
{
///Stef 26/1//2009 : si l'objet n'existe pas, c'est qu'il n'y a rien à déclenché.
///cela résoud un problème : si un process avant celui-ci a supprimé le targetElement
///il ne faut pas lancer ce process là !
/*result.EmpileErreur(I.T("Target object @1 does not exist|30015", refCible.ToString()));
* return result;*/
bShouldStart = false;
}
}
if (bShouldStart)
{
result = ExecuteProcess(
session,
objetCible,
leProcessAExecuter,
contexte, true, indicateur);
if (!result)
{
result.EmpileErreur(I.T("Execution error on element @1|30016", objetCible.DescriptionElement));
return(result);
}
}
}
if (result)
{
result = contexte.SaveAll(true);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
if (result)
{
result = session.CommitTrans();
}
if (!result)
{
session.RollbackTrans();
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
try
{
session.CloseSession();
}
catch
{
}
}
return(result);
}
}
}
/// //////////////////////////////////////////////////
///LE data du result contient la valeur de retour
public CResultAErreur StartProcess(CValise2iSerializable valiseProcess,
CReferenceObjetDonnee refCible,
int?nIdVersion,
IIndicateurProgression indicateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Register(indicateur);
CResultAErreur result = CResultAErreur.True;
//Stef 08/12/2007 : le contexte ne reçoit plus les notifications
using (CContexteDonnee contexteDeSession = new CContexteDonnee(IdSession, true, false))
{
result = valiseProcess.GetObjet(typeof(CContexteDonnee), contexteDeSession);
if (!result)
{
result.EmpileErreur(I.T("Error while recovering process|30014"));
return(result);
}
CProcess leProcessAExecuter = (CProcess)result.Data;
CObjetDonneeAIdNumerique objetCible = null;
///Stef, 290808 : ouvre une session spécifique pour le process
///Pour pouvoir gérer le changement d'utilisateur proprement
CSousSessionClient session = CSousSessionClient.GetNewSousSession(contexteDeSession.IdSession);
session.OpenSession(new CAuthentificationSessionSousSession(contexteDeSession.IdSession), leProcessAExecuter.Libelle, ETypeApplicationCliente.Process);
CSessionClient sessionOriginale = CSessionClient.GetSessionForIdSession(contexteDeSession.IdSession);
if (sessionOriginale.GetInfoUtilisateur() != null)
{
session.ChangeUtilisateur(sessionOriginale.GetInfoUtilisateur().KeyUtilisateur);
}
try
{
//Charge les éléments pour la nouvelle session;
//Stef 08/12/2007 : le contexte ne reçoit plus les notifications
//Stef le 9/2/2011, si, le contexte reçoit les notifications,
//sinon, si un sous process modifie quelque chose, on ne le sait pas
//et on a des problèmes de violation d'accès concurentiel
using (CContexteDonnee contexte = new CContexteDonnee(session.IdSession, true, true))
{
result = contexte.SetVersionDeTravail(nIdVersion, true);
if (!result)
{
return(result);
}
if (refCible != null)
{
objetCible = (CObjetDonneeAIdNumerique)refCible.GetObjet(contexte);
if (objetCible == null)
{
///Stef 26/1//2009 : si l'objet n'existe pas, c'est qu'il n'y a rien à déclencher.
///cela résoud un problème : si un process avant celui-ci a supprimé le targetElement
///il ne faut pas lancer ce process là !
//result.EmpileErreur(I.T("Target object @1 does not exist|30015",refCible.ToString()));
return(result);
}
}
result = ExecuteProcess(
session,
objetCible,
leProcessAExecuter,
contexte, false,
indicateur);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
try
{
session.CloseSession();
}
catch { }
}
}
return(result);
}
}
