public CNoeudRecherche_Evenementc(CEvenement evenement)
{
if (evenement != null)
{
m_nIdEvenement = evenement.Id;
m_strLibelle = I.T("Event @1|20025", evenement.Libelle);
}
}
private CResultAErreur EditeEvenementPopup(CObjetDonnee objet)
{
CEvenement evenement = objet as CEvenement;
if (evenement != null)
{
CFormEditionEvenementPopup.EditeEvenement(evenement);
}
return(CResultAErreur.True);
}
//------------------------------------------------------------
public static bool EditeEvenement(CEvenement evenement)
{
CFormEditionEvenementPopup form = new CFormEditionEvenementPopup();
form.m_evenement = evenement;
bool bResult = form.ShowDialog() == DialogResult.OK;
form.Dispose();
return(bResult);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CEvenement evt = (CEvenement)objet;
if (evt.Libelle.Trim() == string.Empty)
{
result.EmpileErreur(I.T("The Event label could not be empty|114"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(evt, CEvenement.c_champLibelle, evt.Libelle))
{
result.EmpileErreur("An Event with the same label already exist|116");
}
if (evt.TypeCible == null)
{
result.EmpileErreur(I.T("Target Type incorrect|107"));
}
if (evt.TypeEvenement == TypeEvenement.Date)
{
if (evt.ProprieteSurveillee == null)
{
result.EmpileErreur(I.T("The supervised property is not valid|108"));
}
else
{
if (evt.ProprieteSurveillee.TypeDonnee.TypeDotNetNatif != typeof(DateTime) &&
evt.ProprieteSurveillee.TypeDonnee.TypeDotNetNatif != typeof(CDateTimeEx) &&
evt.ProprieteSurveillee.TypeDonnee.TypeDotNetNatif != typeof(DateTime?))
{
result.EmpileErreur(I.T("The supervised property must be of the Date/Time type|109"));
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// //////////////////////////////////////////////////////////////////////////
public CResultAErreur DeclencheEvenementStatiques(Type typeObjet, CDbKey dbKeyObjet)
{
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)Activator.CreateInstance(typeObjet, new object[] { contexte });
if (!objet.ReadIfExists(dbKeyObjet))
{
result.EmpileErreur(I.T("The @1 object with id @2 doesn't exist|106", DynamicClassAttribute.GetNomConvivial(typeObjet), dbKeyObjet.StringValue));
return(result);
}
IDeclencheurAction[] declencheurs = CRecuperateurDeclencheursActions.GetDeclencheursAssocies(objet);
foreach (IDeclencheurAction declencheur in declencheurs)
{
if (declencheur is CEvenement)
{
CEvenement evt = (CEvenement)declencheur;
CInfoDeclencheurProcess infoDeclencheur = new CInfoDeclencheurProcess();
bool bShouldDeclenche = false;
if (!evt.DejaDeclenchePourEntite(objet))
{
bShouldDeclenche = evt.ParametreDeclencheur.ShouldDeclenche(
objet,
false,
true,
ref infoDeclencheur);
}
if (bShouldDeclenche)
{
evt.EnregistreDeclenchementEvenement(objet, infoDeclencheur);
}
if (!result)
{
return(result);
}
}
}
}
return(result);
}
private CResultAErreur CreeEvenementPopup(CListeObjetsDonnees lstEvenements)
{
CResultAErreur result = CResultAErreur.True;
CEvenement evenement = new CEvenement(m_definisseur.ContexteDonnee);
evenement.CreateNew();
evenement.Definisseur = m_definisseur;
evenement.TypeCible = m_definisseur.TypesCibleEvenement[0];
if (!CFormEditionEvenementPopup.EditeEvenement(evenement))
{
evenement.CancelCreate();
}
else
{
result = evenement.CommitEdit();
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
}
InitPanelEvenements();
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur TraitementAvantSauvegarde(CContexteDonnee contexte)
{
CResultAErreur result = base.TraitementAvantSauvegarde(contexte);
if (!result)
{
return(result);
}
DataTable table = contexte.Tables[GetNomTable()];
if (table == null)
{
return(result);
}
ArrayList lst = new ArrayList(table.Rows);
foreach (DataRow row in new ArrayList(table.Rows))
{
if (row.RowState == DataRowState.Added || row.RowState == DataRowState.Modified)
{
CEvenement evt = new CEvenement(row);
if (evt.TypeEvenement == TypeEvenement.Suppression)
{
if (!evt.DeclencherSurContexteClient)
{
evt.DeclencherSurContexteClient = true;
}
if (!evt.DeclencherSurContexteClient)
{
result.EmpileErreur(I.T("Event @1 contains not compatible with 'Delete' event elements|20002", evt.Libelle));
return(result);
}
}
}
}
return(result);
}
/// //////////////////////////////////////////////////////////////////
protected static CResultAErreur ExecuteActionProcess(CActionSur2iLinkExecuterProcess action, object objetCible)
{
CResultAErreur result = CResultAErreur.True;
CProcessInDb process = new CProcessInDb(CSc2iWin32DataClient.ContexteCourant);
if (process.ReadIfExists(action.IdProcessInDb))
{
CProcess processToExecute = process.Process;
result = AffecteVariablesToProcess(action, processToExecute, objetCible);
if (!result)
{
return(result);
}
CInfoDeclencheurProcess infoDecl = new CInfoDeclencheurProcess(TypeEvenement.Manuel);
CReferenceObjetDonnee refObj = null;
object cibleProcess = objetCible;
if (cibleProcess is CDefinitionMultiSourceForExpression)
{
cibleProcess = ((CDefinitionMultiSourceForExpression)cibleProcess).ObjetPrincipal;
}
if (cibleProcess != null && process.TypeCible != null)
{
if (cibleProcess.GetType().IsArray)
{
ArrayList lstRefs = new ArrayList();
foreach (object cible in (Array)cibleProcess)
{
if (process.TypeCible.IsAssignableFrom(cible.GetType()) && cible is CObjetDonnee)
{
lstRefs.Add(new CReferenceObjetDonnee((CObjetDonnee)cible));
}
}
if (lstRefs.Count == 0)
{
result.EmpileErreur(I.T("No element selected for requested action|30085"));
}
else
{
result = CFormExecuteProcess.StartProcessMultiples(processToExecute,
(CReferenceObjetDonnee[])lstRefs.ToArray(typeof(CReferenceObjetDonnee)),
CTimosApp.SessionClient.IdSession,
CSc2iWin32DataClient.ContexteCourant.IdVersionDeTravail,
action.MasquerProgressProcess);
return(result);
}
}
else
{
if (process.TypeCible.IsAssignableFrom(cibleProcess.GetType()) && cibleProcess is CObjetDonnee)
{
refObj = new CReferenceObjetDonnee((CObjetDonnee)cibleProcess);
}
}
}
result = CFormExecuteProcess.StartProcess(processToExecute,
refObj,
CTimosApp.SessionClient.IdSession,
CSc2iWin32DataClient.ContexteCourant.IdVersionDeTravail,
action.MasquerProgressProcess);
}
else
{
CEvenement evt = new CEvenement(CSc2iWin32DataClient.ContexteCourant);
CInfoDeclencheurProcess infoDecl = new CInfoDeclencheurProcess(TypeEvenement.Manuel);
object cibleProcess = objetCible;
if (cibleProcess is CDefinitionMultiSourceForExpression)
{
cibleProcess = ((CDefinitionMultiSourceForExpression)cibleProcess).ObjetPrincipal;
}
if (evt.ReadIfExists(action.IdEvenement))
{
if (cibleProcess == null)
{
result.EmpileErreur(I.T("Impossible to execute the requested event|30086"));
return(result);
}
if (cibleProcess.GetType().IsArray)
{
ArrayList lstRefs = new ArrayList();
foreach (object cible in (Array)cibleProcess)
{
if (!(cible is CObjetDonneeAIdNumerique) || !evt.ShouldDeclenche((CObjetDonneeAIdNumerique)cible, ref infoDecl))
{
result.EmpileErreur(I.T("The requested action cannot be executed on at least one of the requested elements|30087"));
return(result);
}
lstRefs.Add(cible);
}
if (lstRefs.Count == 0)
{
result.EmpileErreur(I.T("No element selected for execution|30088"));
return(result);
}
result = CFormExecuteProcess.RunEventMultiple(
evt,
(CObjetDonneeAIdNumeriqueAuto[] )lstRefs.ToArray(typeof(CObjetDonneeAIdNumeriqueAuto)),
action.MasquerProgressProcess);
}
else
{
if (!evt.ShouldDeclenche((CObjetDonneeAIdNumerique)cibleProcess, ref infoDecl))
{
result.EmpileErreur(I.T("Impossible to trigger the requested event on this object|30089"));
return(result);
}
result = CFormExecuteProcess.RunEvent(evt, (CObjetDonneeAIdNumerique)cibleProcess, action.MasquerProgressProcess);
}
}
else
{
result.EmpileErreur(I.T("The requested action does not exist|30090"));
}
}
return(result);
}
public CCoupleEvenementObjet(CEvenement evt, CObjetDonneeAIdNumerique obj, CInfoDeclencheurProcess infoDeclencheur)
: base(obj, infoDeclencheur)
{
Evenement = evt;
}
/// ///////////////////////////////////////////////
public void AddCoupleEvenementObjet(CEvenement evt, CObjetDonneeAIdNumerique obj, CInfoDeclencheurProcess infoDeclencheur)
{
m_listeCoupesEvtObj.Add(new CCoupleEvenementObjet(evt, obj, infoDeclencheur));
}
//-------------------------------------------------------------------------
public CFormEditionEvenement(CEvenement evenement, CListeObjetsDonnees liste)
: base(evenement, liste)
{
InitializeComponent();
}
//-------------------------------------------------------------------------
public CFormEditionEvenement(CEvenement evenement)
: base(evenement)
{
InitializeComponent();
}
//-----------------------------------------------------------------------------------------------------
public void InitChamps(CActionSur2iLink action, CObjetPourSousProprietes objetPourSousProprietes)
{
m_actionEditee = action as CActionSur2iLinkExecuterProcess;
if (m_actionEditee == null)
{
Visible = false;
return;
}
Visible = true;
m_objetPourSousProprietes = objetPourSousProprietes;
CObjetPourSousProprietes objetPourFiltreActions = m_objetPourSousProprietes;
CDefinitionMultiSourceForExpression multi = m_objetPourSousProprietes.ElementAVariableInstance as CDefinitionMultiSourceForExpression;
if (multi != null)
{
objetPourFiltreActions = multi.DefinitionObjetPrincipal;
}
CFiltreData filtre = null;
if (objetPourFiltreActions == null || objetPourFiltreActions.TypeAnalyse == null)
{
filtre = new CFiltreData(CProcessInDb.c_champTypeCible + "=@1", "");
}
else
{
filtre = new CFiltreData(CProcessInDb.c_champTypeCible + "=@1 or " +
CProcessInDb.c_champTypeCible + "=@2 or " +
CProcessInDb.c_champTypeCible + "=@3",
"",
objetPourFiltreActions.TypeAnalyse.ToString(),
typeof(CObjetDonneeAIdNumerique).ToString());
}
m_selectionneurProcess.InitAvecFiltreDeBase <CProcessInDb>("Libelle", filtre, true);
CProcessInDb process = new CProcessInDb(CSc2iWin32DataClient.ContexteCourant);
CProcess processPourParametres = null;
if (process.ReadIfExists(((CActionSur2iLinkExecuterProcess)m_actionEditee).IdProcessInDb))
{
m_selectionneurProcess.ElementSelectionne = process;
processPourParametres = process.Process;
}
if (objetPourFiltreActions != null && objetPourFiltreActions.TypeAnalyse != null)
{
m_panelEvenementManuel.Visible = true;
CFiltreData filtreDeBase = new CFiltreData(
CEvenement.c_champTypeEvenement + "=@1 and " +
CEvenement.c_champTypeCible + "=@2",
(int)TypeEvenement.Manuel,
objetPourFiltreActions.TypeAnalyse.ToString());
m_selectionneurEvenementManuel.InitAvecFiltreDeBase <CEvenement>(
"Libelle",
filtreDeBase, true);
CEvenement evt = new CEvenement(CSc2iWin32DataClient.ContexteCourant);
if (evt.ReadIfExists(((CActionSur2iLinkExecuterProcess)m_actionEditee).IdEvenement))
{
m_selectionneurEvenementManuel.ElementSelectionne = evt;
processPourParametres = null;
}
}
else
{
m_panelEvenementManuel.Visible = false;
m_selectionneurEvenementManuel.ElementSelectionne = null;
}
m_chkHideProgress.Checked = ((CActionSur2iLinkExecuterProcess)m_actionEditee).MasquerProgressProcess;
InitListeFormulesParametres(processPourParametres, m_actionEditee);
}