//-------------------------------------------------------------------
public CResultAErreur RunEventMultiple(CObjetDonneeAIdNumerique[] obj, CInfoDeclencheurProcess infoDeclencheur, IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
result.EmpileErreur(I.T("Impossible to execute on multiple elements|272"));
return(result);
}
/// /////////////////////////////////////////////////////////////
public static CResultAErreur StartProcessMultiples(CProcess process,
CInfoDeclencheurProcess infoDeclencheur,
CReferenceObjetDonnee[] refsCible,
int nIdSession,
int?nIdVersion,
IIndicateurProgression indicateur)
{
process.InfoDeclencheur = infoDeclencheur;
///TODO
///Problème VersionObjet
IProcessEnExecutionInDbServeur processServeur = (IProcessEnExecutionInDbServeur)CContexteDonnee.GetTableLoader(c_nomTable, null, nIdSession);
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Register(processServeur);
CAppelleurFonctionAsynchrone appelleur = new CAppelleurFonctionAsynchrone();
CResultAErreur defaultResult = CResultAErreur.True;
defaultResult.EmpileErreur(I.T("Asynchronous call error @1|20032", "StartProcessMultiples"));
return(appelleur.StartFonctionAndWaitAvecCallback(
typeof(IProcessEnExecutionInDbServeur),
processServeur,
"StartProcessMultiples",
"",
defaultResult,
new CValise2iSerializable(process),
refsCible,
nIdVersion,
indicateur) as CResultAErreur);
}
}
//----------------------------------------------------------------------
public CResultAErreur EnregistreDeclenchementEvenementSurClient(
CObjetDonneeAIdNumerique objet,
CInfoDeclencheurProcess infoDeclencheur,
IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
result.EmpileErreur(I.T("Not available for event handlers|50000"));
return(result);
}
//-------------------------------------------------------------------
public CResultAErreur RunEvent(
CObjetDonneeAIdNumerique obj,
CInfoDeclencheurProcess infoDeclencheur,
IIndicateurProgression indicateur)
{
return(RunEvent(true,
obj,
infoDeclencheur,
indicateur));
}
//-------------------------------------------------------------------
//Retourne vrai si le handler doit déclencher son évenement
public bool ShoulDeclenche(CObjetDonneeAIdNumerique obj, ref CInfoDeclencheurProcess infoDeclencheur)
{
CParametreDeclencheurEvenement parametre = ParametreDeclencheurSiSurModification;
if (parametre == null)
{
return(false);
}
return(parametre.ShouldDeclenche(obj, false, false, ref infoDeclencheur));
}
//-------------------------------------------------------------------
public CResultAErreur RunEvent(
bool bAutoManagerHandlerTermine,
CObjetDonneeAIdNumerique obj,
CInfoDeclencheurProcess infoDeclencheur,
IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
CProcessEnExecutionInDb process = ProcessSource;
if (ProcessSource != null)
{
result = process.RepriseProcess(IdActionDeProcessToExecute, indicateur);
}
else if (EtapeWorkflowATerminer != null)
{
using (CContexteDonnee contexte = new CContexteDonnee(ContexteDonnee.IdSession, true, false))
{
CEtapeWorkflow etape = EtapeWorkflowATerminer.GetObjetInContexte(contexte) as CEtapeWorkflow;
if (etape != null)
{
result = etape.EndEtapeAndSaveIfOk();
}
if (!result)
{
//L'étape ne s'est pas terminée ? tant pis alors, c'est pas grave, elle se terminera par ailleurs
result = CResultAErreur.True;
return(result);
}
}
}
//gestion du handler faite ailleurs
if (!bAutoManagerHandlerTermine)
{
if (!result)
{
result.EmpileErreur(I.T("@1 handler error|271", Libelle));
}
return(result);
}
EndHandler(result);
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MySerialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
if (serializer.Mode == ModeSerialisation.Lecture &&
serializer.GetObjetAttache(typeof(CContexteDonnee)) != null)
{
ContexteDonnee = (CContexteDonnee)serializer.GetObjetAttache(typeof(CContexteDonnee));
}
else
{
ContexteDonnee = CContexteDonneeSysteme.GetInstance();
}
serializer.TraiteInt(ref m_nIdNextObjet);
if (nVersion > 0)
{
bool bHasType = TypeCible != null;
serializer.TraiteBool(ref bHasType);
if (bHasType)
{
serializer.TraiteType(ref m_typeCible);
}
else
{
m_typeCible = null;
}
}
else
{
m_typeCible = null;
}
//Lit les variables en premier car on en a besoin dans les actions
serializer.AttacheObjet(typeof(IElementAVariablesDynamiquesBase), this);
if (result)
{
result = serializer.TraiteArrayListOf2iSerializable(m_listeVariables, this);
}
foreach (IVariableDynamique variable in m_listeVariables)
{
if (variable.IdVariable == c_strIdVariableElement) //TESTDBKEYOK
{
m_variableCible = (CVariableProcessTypeComplexe)variable;
}
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
foreach (IVariableDynamique var in m_listeVariables)
{
if (var.IdVariable == c_strIdVariableElement && var is CVariableProcessTypeComplexe)
{
m_variableCible = (CVariableProcessTypeComplexe)var;
m_typeCible = m_variableCible.TypeDonnee.TypeDotNetNatif;
m_bSurTableauDeCible = m_variableCible.TypeDonnee.IsArrayOfTypeNatif;
}
}
}
result = serializer.TraiteArrayListOf2iSerializable(m_listeActions, this);
if (result)
{
result = serializer.TraiteArrayListOf2iSerializable(m_listeLiensActions, this);
}
serializer.DetacheObjet(typeof(IElementAVariablesDynamiquesBase), this);
//Lit les valeurs des variables
if (nVersion > 2)
{
result = SerializeValeursVariables(nVersion, serializer);
}
if (nVersion >= 3)
{
serializer.TraiteBool(ref m_bModeAsynchrone);
}
else
{
m_bModeAsynchrone = false;
}
if (nVersion >= 4)
{
serializer.TraiteString(ref m_strLibelle);
}
AssureVariableCible();
if (nVersion >= 5)
{
I2iSerializable objet = m_infoDeclencheur;
serializer.TraiteObject(ref objet);
m_infoDeclencheur = (CInfoDeclencheurProcess)objet;
}
if (nVersion >= 7)
{
serializer.TraiteBool(ref m_bSurTableauDeCible);
}
else
{
m_bSurTableauDeCible = false;
}
if (nVersion >= 9)
{
serializer.TraiteString(ref m_strLastErreur);
}
else
{
m_strLastErreur = "";
}
if (nVersion >= 10)
{
if (nVersion < 14 && serializer.Mode == ModeSerialisation.Lecture)
{
int nIdTemp = -1;
serializer.TraiteInt(ref nIdTemp);
m_strIdVariableRetour = nIdTemp.ToString();
}
else
{
serializer.TraiteString(ref m_strIdVariableRetour);
}
}
Dictionary <int, I2iObjetGraphique> dicIdToObjet = null;
if (nVersion >= 12)
{
int nbEle = m_ordreZ.Count;
serializer.TraiteInt(ref nbEle);
if (serializer.Mode == ModeSerialisation.Lecture)
{
dicIdToObjet = new Dictionary <int, I2iObjetGraphique>();
foreach (CAction action in ListeActions)
{
dicIdToObjet[action.IdObjetProcess] = action;
}
foreach (CLienAction lien in ListeLiens)
{
dicIdToObjet[lien.IdObjetProcess] = lien;
}
m_ordreZ.Clear();
for (int n = 0; n < nbEle; n++)
{
int nId = 0;
serializer.TraiteInt(ref nId);
I2iObjetGraphique objTmp = null;
if (dicIdToObjet.TryGetValue(nId, out objTmp))
{
m_ordreZ.Add((IObjetDeProcess)objTmp);
}
}
}
else if (serializer.Mode == ModeSerialisation.Ecriture)
{
foreach (IObjetDeProcess objet in m_ordreZ)
{
int nCopy = objet.IdObjetProcess;
serializer.TraiteInt(ref nCopy);
}
}
}
else
{
m_ordreZ = new List <IObjetDeProcess>();
foreach (CAction action in ListeActions)
{
m_ordreZ.Add(action);
}
foreach (CLienAction lien in ListeLiens)
{
m_ordreZ.Add(lien);
}
}
if (nVersion >= 13)
{
serializer.TraiteBool(ref m_bModeTransactionnel);
}
else
{
m_bModeTransactionnel = false;
}
return(result);
}
/// <summary>
/// Indique si l'évenement doit se déclencher
/// </summary>
/// <param name="objet"></param>
/// <param name="bModeAvecInterface">
/// si vrai, les évenements de type Manuel ou Ouverture retournent vrai,
/// sinon, ils retournent systématiquement faux
/// </param>
/// <param name="bModeStatique">
/// Si vrai, les évenements de création sont vrai et les évenements
/// de modif sans valeur initiale retournent vrai si la valeur de fin est verifiée
/// </param>
/// <returns></returns>
public bool ShouldDeclenche(CObjetDonneeAIdNumerique objet, bool bModeAvecInterface, bool bModeStatique, ref CInfoDeclencheurProcess infoDeclencheur)
{
CResultAErreur result = CResultAErreur.True;
if (ContextesException.Contains(objet.ContexteDeModification))
{
return(false);
}
//CObjetDonneeAIdNumeriqueAuto objetToEval = objet;
CDefinitionProprieteDynamique defPropriete = ProprieteASurveiller;
if (objet is CRelationElementAChamp_ChampCustom)
{
if (!(defPropriete is CDefinitionProprieteDynamiqueChampCustom))
{
return(false);
}
CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)objet;
if (rel.ChampCustom.DbKey != ((CDefinitionProprieteDynamiqueChampCustom)defPropriete).DbKeyChamp)
{
return(false);
}
}
CObjetDonneeAIdNumerique objetToTest = GetObjetToRun(objet);
if (objetToTest == null)
{
return(false);
}
DataRowVersion versionToReturnOriginal = objetToTest.VersionToReturn;
try
{
if (objetToTest.Row.RowState == DataRowState.Deleted)
{
objetToTest.VersionToReturn = DataRowVersion.Original;
}
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(objetToTest);
object valeurAvant;
object valeurApres;
infoDeclencheur = new CInfoDeclencheurProcess();
infoDeclencheur.TypeDeclencheur = TypeEvenement;
switch (TypeEvenement)
{
case TypeEvenement.Manuel:
if (!bModeAvecInterface)
{
return(false);
}
break;
case TypeEvenement.Creation:
if (objet.Row.RowState != DataRowState.Added && !bModeStatique)
{
return(false);
}
break;
case TypeEvenement.Date:
//Vérifie si la date a changé
if (defPropriete != null)
{
if (!bModeStatique)
{
valeurAvant = GetValeur(objet, defPropriete, DataRowVersion.Original);
valeurApres = GetValeur(objet, defPropriete, DataRowVersion.Current);
if (TestEgalite(valeurApres, valeurAvant))
{
return(false);
}
}
}
break;
case TypeEvenement.Modification:
if (objet.Row.RowState == DataRowState.Modified || objet.Row.RowState == DataRowState.Added || bModeStatique)
{
if (defPropriete != null)
{
try
{
valeurAvant = null;
if (objet.Row.RowState == DataRowState.Modified)
{
valeurAvant = GetValeur(objet, defPropriete, DataRowVersion.Original);
}
valeurApres = GetValeur(objet, defPropriete, DataRowVersion.Current);
if (objet.Row.RowState == DataRowState.Modified && TestEgalite(valeurApres, valeurAvant))
{
return(false);
}
if (FormuleValeurAvant != null)
{
if (bModeStatique)
{
return(false);
}
result = FormuleValeurAvant.Eval(contexteEval);
if (!result)
{
return(false);
}
if (!TestEgalite(result.Data, valeurAvant))
{
return(false);
}
}
if (FormuleValeurApres != null)
{
result = FormuleValeurApres.Eval(contexteEval);
if (!result)
{
return(false);
}
if (!TestEgalite(result.Data, valeurApres))
{
return(false);
}
}
infoDeclencheur.ValeurOrigine = valeurAvant;
}
catch
{
return(false);
}
}
}
else
{
return(false);
}
break;
case TypeEvenement.Specifique:
if (objet.Table.Columns.Contains(EvenementAttribute.c_champEvenements))
{
if (!EvenementAttribute.HasEvent(objet, IdEvenementSpecifique))
{
return(false);
}
}
//Stef 110309 : Si on annule l'évenement là, et qu'il y a d'autres
//Hanlder sur cet évenement, les autres handler ne se déclencheront pas
//il faut donc annuler l'evenement quand on a parcouru tous les évenements
//Donc, dans le CGestionnaireEvenements
//EvenementAttribute.AnnuleEvenement(objet, IdEvenementSpecifique);
break;
case TypeEvenement.Suppression:
if (objet.Row.RowState != DataRowState.Deleted)
{
return(false);
}
break;
}
//Evalue la condition
if (FormuleConditionDeclenchement != null)
{
result = FormuleConditionDeclenchement.Eval(contexteEval);
if (!result)
{
return(result);
}
if (result.Data is bool)
{
if (!(bool)result.Data)
{
return(false);
}
}
else if (result.Data.ToString() == "" || result.Data.ToString() == "0")
{
return(false);
}
}
}
catch
{
}
finally
{
objetToTest.VersionToReturn = versionToReturnOriginal;
}
return(true);
}
