/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
result = ExpressionUtilisateur.Eval(contexteEval);
if (!result)
{
return(result);
}
else
{
CDbKey keyUtilisateur = null;
try
{
//TESTDBKEYOK
int nId = Convert.ToInt32(result.Data);
keyUtilisateur = CDbKey.GetNewDbKeyOnIdAUtiliserPourCeuxQuiNeGerentPasLeDbKey(nId);
}
catch
{
//TESTDBKEYTODO
if (result.Data != null)
{
keyUtilisateur = CDbKey.CreateFromStringValue(result.Data.ToString());
}
else
{
result.EmpileErreur(I.T("The user expression doesn't return an integer number|381"));
return(result);
}
}
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(contexte.ContexteDonnee);
if (!user.ReadIfExists(keyUtilisateur))
{
result.EmpileErreur(I.T("The user @1 doesn't exist|382", keyUtilisateur.StringValue));
return(result);
}
contexte.Branche.KeyUtilisateur = keyUtilisateur;
CSessionClient session = CSessionClient.GetSessionForIdSession(contexte.ContexteDonnee.IdSession);
if (session != null)
{
session.ChangeUtilisateur(keyUtilisateur);
}
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
result = Parametre.CreateEntree(contexte.ContexteDonnee,
new CContexteEvaluationExpression(Process));
if (!result)
{
return(result);
}
if (VariableResultat != null)
{
Process.SetValeurChamp(VariableResultat, result.Data);
}
result.Data = null;
CLienAction[] liens = GetLiensSortantHorsErreur();
if (liens.Length > 0)
{
result.Data = liens[0];
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
//Si la session qui execute est une session de l'utilisateur associé à la branche,
//Tente d'afficher le EditerElement sur cette session,
//Sinon, enregistre une Intervention sur l'utilisateur
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (sessionClient != null)
{
//TESTDBKEYOK
if (sessionClient.GetInfoUtilisateur().KeyUtilisateur == contexte.Branche.KeyUtilisateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
CServiceSurClient service = sessionClient.GetServiceSurClient(c_idServiceClientEditerElement);
if (service != null)
{
sponsor.Register(service);
//Evalue l'élément à éditer
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
if (m_expressionElementAEditer == null)
{
result.EmpileErreur(I.T("Incorrect formula for Edited element|385"));
return(result);
}
result = m_expressionElementAEditer.Eval(contexteEval);
if (!result)
{
return(result);
}
CObjetDonnee objet = result.Data as CObjetDonnee;
string strCodeFormulaire = "";
if (m_expressionCodeFormulaire != null)
{
result = m_expressionCodeFormulaire.Eval(contexteEval);
if (!result)
{
return(result);
}
strCodeFormulaire = result.Data as string;
}
result = service.RunService(
new CParametreEditionElement(
contexte.IdSession,
new CReferenceObjetDonnee(objet),
DansNavigateurPrincipal,
DansNouvelOnglet,
strCodeFormulaire,
contexte.ContexteDonnee.IdVersionDeTravail));
//Fin du process
result.Data = null;
if (result)
{
foreach (CLienAction lien in this.GetLiensSortantHorsErreur())
{
if (!(lien is CLienUtilisateurAbsent))
{
result.Data = lien;
}
}
}
return(result);
}
}
}
}
//Utilisateur pas accessible
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienUtilisateurAbsent)
{
result.Data = lien;
return(result);
}
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
//Préparation du filtre
C2iRapportCrystal rapport = new C2iRapportCrystal(contexte.ContexteDonnee);
if (!rapport.ReadIfExists(IdEtatCrystal))
{
result.EmpileErreur(I.T("The report @1 does not exist|30046", IdEtatCrystal.ToString()));
return(result);
}
CContexteEvaluationExpression contexteEvaluation = new CContexteEvaluationExpression(Process);
CMultiStructureExport multiStructure = rapport.MultiStructure;
if (multiStructure == null)
{
result.EmpileErreur(I.T("The report does not have a data structure|30044"));
return(result);
}
foreach (IVariableDynamique variable in multiStructure.ListeVariables)
{
if (variable.IsChoixUtilisateur())
{
C2iExpression expressionVariable = GetExpressionForVariableFiltre(variable.IdVariable);
if (expressionVariable != null)
{
result = expressionVariable.Eval(contexteEvaluation);
if (!result)
{
result.EmpileErreur(I.T("Error in variable '@1' assignment|30047", variable.Nom));
return(result);
}
multiStructure.SetValeurChamp(variable, result.Data);
}
}
}
ReportDocument report = null;
try
{
result = rapport.CreateFichierExport(multiStructure, m_formatExport, ref report);
if (!result)
{
result.EmpileErreur(I.T("Error while creating the report|30048"));
return(result);
}
CFichierLocalTemporaire fichierPDF = (CFichierLocalTemporaire)result.Data;
#region Impression de l'état
if (m_bImprimerEtat)
{
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
CConfigurationsImpression configuration = sessionClient.ConfigurationsImpression;
if (configuration.NomImprimanteSurServeur != "")
{
report.PrintOptions.PrinterName = configuration.NomImprimanteSurServeur;
}
try
{
report.PrintToPrinter(1, false, 0, 0);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Printing error|30049"));
return(result);
}
/*if ( sessionClient != null )
* {
* if ( sessionClient.GetInfoUtilisateur().IdUtilisateur == contexte.Branche.IdUtilisateur )
* {
* if ( sessionClient.ConfigurationsImpression.NomImprimanteSurClient != "" )
* report.PrintOptions.PrinterName = sessionClient.ConfigurationsImpression.NomImprimanteSurClient;
* CServiceSurClient service = sessionClient.GetServiceSurClient ( CActionImprimerEtat.c_idServiceClientImprimerEtat );
* if ( service != null )
* {
* result = service.RunService ( report );
* }
* }
* }*/
/*
* using ( CFichierLocalTemporaire fichierRpt = new CFichierLocalTemporaire("rpt") )
* {
* fichierRpt.CreateNewFichier();
* try
* {
* report.Refresh();
* report.SaveAs (fichierRpt.NomFichier, ReportFileFormat.VSNetFileFormat );
* }
* catch ( Exception e )
* {
* result.EmpileErreur ( new CErreurException ( e ) );
* }
* if ( result )
* {
* //Stocke le fichier dans la ged pour pouvoir l'envoyer sur le client
* using ( CProxyGED proxy = new CProxyGED ( Process.IdSession, null ) )
* {
* proxy.CreateNewFichier();
* proxy.AttacheToLocal ( fichierRpt.NomFichier );
*
* proxy.UpdateGed();
*
* CReferenceDocument refDoc = proxy.ReferenceAttachee;
* result = service.RunService ( refDoc );
* if ( !result )
* {
* result.EmpileErreur("Erreur à l'impression du document");
* return result;
* }
* }
* }
* }
* }
* }
* }*/
}
#endregion
#region Stockage dans la ged
if (m_bStockerGed)
{
//On a notre fichier PDF, création du document
string strCle = "";
string strDescriptif = "";
string strLibelle = "";
result = ExpressionCle.Eval(contexteEvaluation);
if (result)
{
strCle = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("Document key could not be evaluated|30050"));
return(result);
}
result = ExpressionLibelle.Eval(contexteEvaluation);
if (result)
{
strLibelle = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("Document label could not be evaluated|30051"));
return(result);
}
result = ExpressionDescriptif.Eval(contexteEvaluation);
if (result)
{
strDescriptif = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("Document description could not be evaluated|30052"));
return(result);
}
CDocumentGED doc = new CDocumentGED(contexte.ContexteDonnee);
//Si la clé n'est pas nulle, cherche un document avec cette clé
if (strCle.Trim() != "")
{
CFiltreData filtre = new CFiltreData(CDocumentGED.c_champCle + "=@1", strCle);
if (!doc.ReadIfExists(filtre))
{
doc.CreateNew();
}
else
{
doc.BeginEdit();
}
}
else
{
doc.CreateNew();
}
doc.Libelle = strLibelle;
doc.Descriptif = strDescriptif;
doc.Cle = strCle;
ArrayList lstToCreate = (ArrayList)ListeIdsCategoriesStockage.Clone();
ArrayList lstToDelete = new ArrayList();
//Affecte les catégories
CListeObjetsDonnees listeCategoriesExistantes = CRelationDocumentGED_Categorie.GetRelationsCategoriesForDocument(doc);
foreach (CRelationDocumentGED_Categorie rel in listeCategoriesExistantes)
{
if (!lstToCreate.Contains(rel.Categorie.Id))
{
lstToDelete.Add(rel);
}
lstToCreate.Remove(rel.Categorie.Id);
}
foreach (CRelationDocumentGED_Categorie rel in lstToDelete)
{
rel.Delete();
}
foreach (int nId in lstToCreate)
{
CCategorieGED cat = new CCategorieGED(doc.ContexteDonnee);
if (cat.ReadIfExists(nId))
{
CRelationDocumentGED_Categorie rel = new CRelationDocumentGED_Categorie(doc.ContexteDonnee);
rel.CreateNewInCurrentContexte();
rel.Categorie = cat;
rel.Document = doc;
}
}
CProxyGED proxy = new CProxyGED(Process.IdSession, doc.IsNew()?null:doc.ReferenceDoc);
proxy.AttacheToLocal(fichierPDF.NomFichier);
result = proxy.UpdateGed();
if (!result)
{
return(result);
}
doc.ReferenceDoc = (CReferenceDocument)result.Data;
result = doc.CommitEdit();
fichierPDF.Dispose();
if (VariableResultat != null)
{
Process.SetValeurChamp(VariableResultat, doc);
}
}
#endregion
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
if (report != null)
{
report.Close();
}
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
//Si la session qui execute est une session de l'utilisateur associé à la branche,
//Tente d'afficher le formulaire sur cette session,
//Sinon, enregistre une Intervention sur l'utilisateur
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (sessionClient != null)
{
//TESTDBKEYOK
if (sessionClient.GetInfoUtilisateur().KeyUtilisateur == contexte.Branche.KeyUtilisateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Label = "Execute Action serveur";
CServiceSurClient service = sessionClient.GetServiceSurClient(c_idServiceClientFormulaire);
if (service != null)
{
sponsor.Register(service);
result = service.RunService(this);
if (!result)
{
return(result);
}
E2iDialogResult dResult = (E2iDialogResult)result.Data;
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienFromDialog &&
((CLienFromDialog)lien).ResultAssocie == dResult)
{
result.Data = lien;
return(result);
}
}
result.Data = null;
return(result);
}
else
{
//Utilisateur pas accessible
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienUtilisateurAbsent)
{
result.Data = lien;
return(result);
}
}
}
}
}
}
//Utilisateur pas accessible
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienUtilisateurAbsent)
{
result.Data = lien;
return(result);
}
}
return(result);
}
/// /////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
string strMessage = "";
ArrayList lstDestinataires = new ArrayList();
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
if (m_formuleMessage == null)
{
result.EmpileErreur(I.T("The message formula is false|393"));
return(result);
}
result = m_formuleMessage.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during sms content evaluation|20110"));
return(result);
}
strMessage = result.Data.ToString();
// Traite les destinataires To
foreach (C2iExpression exp in m_listeFormulesDestinataires)
{
if (exp != null)
{
result = exp.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error while evaluating one of the recipients|402"));
return(result);
}
object res = result.Data;
if (res is string)
{
res = ((string)res).Split(new char[] { ';', ',' });
}
if (res is IList)
{
foreach (object obj in ((IList)res))
{
lstDestinataires.Add(obj.ToString());
}
}
else if (res.ToString().Trim() != "")
{
lstDestinataires.Add(res.ToString());
}
}
}
// Genere le SMS
CMessageSMS message = new CMessageSMS(contexte.ContexteDonnee);
message.CreateNewInCurrentContexte();
message.Texte = strMessage;
foreach (string strDest in lstDestinataires)
{
message.AddDestinataire(strDest);
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CFamilleEquipement famille = new CFamilleEquipement(contexte.ContexteDonnee);
if (!famille.ReadIfExists(m_nIdFamilleEquipement))
{
result.EmpileErreur(I.T("Equipment type family @1 doesn't exists|20027", m_nIdFamilleEquipement.ToString()));
return(result);
}
CListeObjetsDonnees lstTypes = new CListeObjetsDonnees(contexte.ContexteDonnee, typeof(CSpvTypeq));
lstTypes.Filtre = new CFiltreData(CSpvTypeq.c_champSmtTypeEquipement_Id + " is null");
foreach (CSpvTypeq typeEq in lstTypes.ToArrayList())
{
CTypeEquipement type = new CTypeEquipement(contexte.ContexteDonnee);
type.CreateNewInCurrentContexte();
type.Libelle = typeEq.Libelle;
type.Famille = famille;
typeEq.TypeEquipementSmt = type;
}
CListeObjetsDonnees lstObjets = new CListeObjetsDonnees(contexte.ContexteDonnee, typeof(CSpvEquip));
lstObjets.Filtre = new CFiltreDataAvance(CSpvEquip.c_nomTable,
"HasNo(" + CSpvEquip.c_champSmtEquipementLogique_Id + ") and " +
"Has(TypeEquipement." + CSpvTypeq.c_champSmtTypeEquipement_Id + ") and " +
"has(" + CSpvSite.c_nomTable + "." + CSpvSite.c_champSmtSite_Id + ")");
int nNbEquips = lstObjets.Count;
int nEquip = 0;
if (contexte.IndicateurProgression != null)
{
contexte.IndicateurProgression.PushSegment(9, nNbEquips);
contexte.SetInfoProgression(I.T("Transfering discovered equipments|20221"));
}
ArrayList lstEquips = lstObjets.ToArrayList();
foreach (CSpvEquip equipSpv in lstEquips)
{
nEquip++;
if (nEquip % 20 == 0 && contexte.IndicateurProgression != null)
{
contexte.IndicateurProgression.SetValue(nEquip / 2);
contexte.SetInfoProgression((int)(nEquip / 2) + "/" + nNbEquips);
}
CSpvSite siteSpv = equipSpv.SpvSite;
CSpvTypeq typeEqSpv = equipSpv.TypeEquipement;
if (siteSpv != null && typeEqSpv != null)
{
CTypeEquipement typeTimos = typeEqSpv.TypeEquipementSmt;
CSite siteTimos = siteSpv.ObjetTimosAssocie;
if (typeTimos != null && siteTimos != null)
{
CEquipementLogique equipementTimos = new CEquipementLogique(contexte.ContexteDonnee);
equipementTimos.TypeEquipement = typeTimos;
equipementTimos.Site = siteTimos;
equipementTimos.Libelle = equipSpv.CommentairePourSituer;
equipSpv.ObjetTimosAssocie = equipementTimos;
}
}
}
foreach (CSpvEquip equipSpv in lstEquips)
{
nEquip++;
if (nEquip % 20 == 0 && contexte.IndicateurProgression != null)
{
contexte.IndicateurProgression.SetValue(nEquip / 2);
contexte.SetInfoProgression((int)(nEquip / 2) + "/" + nNbEquips);
}
CEquipementLogique equip = equipSpv.ObjetTimosAssocie;
if (equipSpv.EquipementEnglobant != null)
{
CEquipementLogique englobant = equipSpv.EquipementEnglobant.ObjetTimosAssocie;
if (englobant == null)
{
result = equipSpv.Delete(true);
if (!result)
{
return(result);
}
}
else
{
equip.EquipementLogiqueContenant = englobant;
}
}
}
if (contexte.IndicateurProgression != null)
{
contexte.IndicateurProgression.PopSegment();
}
return(result);
}
/// //////////////////////////////////////////////////
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);
}
}
//Le data du result contient la valeur de retour du process
protected CResultAErreur ExecuteProcess(
CSessionClient session,
object objetCible,
CProcess leProcessAExecuter,
CContexteDonnee contexte,
bool bSauvegardeDuContexteExecutionExterne,
IIndicateurProgression indicateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Register(indicateur);
/// Stef, le 2/4/08 : pb rencontré : leProcessAExecuter peut être
/// lié à un autre CContexteDonnee que celui dans lequel on execute l'action
/// en effet, il est alloué dans un CContexteDonnee, mais un autre CContexteDonnee
/// peut être recréé pour que l'execution.
/// OR, dans ce cas, les variables calculées évaluées par le CProcess se trouvent dans
/// le contexte du process, donc, pas dans le contexte d'execution et les modifs
/// sur ces variables ne sont donc pas sauvegardées !
/// d'où la ligne suivante : leProcessAExecuter.ContexteDonnee = contexte
leProcessAExecuter.ContexteDonnee = contexte;
//Fin Stef 2/4/08
CResultAErreur result = CResultAErreur.True;
CProcessEnExecutionInDb processEnExec = new CProcessEnExecutionInDb(contexte);
processEnExec.CreateNewInCurrentContexte();
if (objetCible is CObjetDonneeAIdNumerique)
{
processEnExec.ElementLie = (CObjetDonneeAIdNumerique)objetCible;
}
else
{
processEnExec.ElementLie = null;
}
processEnExec.Libelle = leProcessAExecuter.Libelle;
processEnExec.DbKeyEvennementDeclencheur = leProcessAExecuter.InfoDeclencheur.DbKeyEvenementDeclencheur;
processEnExec.IdVersionExecution = contexte.IdVersionDeTravail;
CBrancheProcess branche = new CBrancheProcess(leProcessAExecuter);
branche.IsModeAsynchrone = leProcessAExecuter.ModeAsynchrone;
CSessionClient sessionSource = CSessionClient.GetSessionForIdSession(IdSession);
//TESTDBKEYTODO
branche.KeyUtilisateur = sessionSource.GetInfoUtilisateur().KeyUtilisateur;
branche.ConfigurationImpression = sessionSource.ConfigurationsImpression;
CContexteExecutionAction contexteExecution = new CContexteExecutionAction(
processEnExec,
branche,
objetCible,
contexte,
leProcessAExecuter.ModeAsynchrone ? null : indicateur);
contexteExecution.SauvegardeContexteExterne = bSauvegardeDuContexteExecutionExterne;
//Mode synchrone
if (!leProcessAExecuter.ModeAsynchrone)
{
bool bTrans = false;
if (!bSauvegardeDuContexteExecutionExterne && leProcessAExecuter.ModeTransactionnel)
{
contexte.SaveAll(true);//Sauve le contexte en execution avant démarrage
session.BeginTrans();
bTrans = true;
}
try
{
result = branche.ExecuteAction(leProcessAExecuter.GetActionDebut(), 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();
}
}
}
if (!result)
{
result.EmpileErreur(I.T("Erreur in @1 process|20001", leProcessAExecuter.Libelle));
}
if (leProcessAExecuter.VariableDeRetour != null)
{
result.Data = leProcessAExecuter.GetValeurChamp(leProcessAExecuter.VariableDeRetour.IdVariable);
}
return(result);
}
else
{
//Ouvre une nouvelle session pour éxecuter le process
if (leProcessAExecuter.ModeAsynchrone)
{
CSessionProcessServeurSuivi sessionAsync = new CSessionProcessServeurSuivi();
result = sessionAsync.OpenSession(new CAuthentificationSessionProcess(),
"Process " + leProcessAExecuter.Libelle,
session);
if (!result)
{
return(result);
}
session = sessionAsync;
}
contexteExecution.ChangeIdSession(session.IdSession);
contexteExecution.HasSessionPropre = true;
m_brancheToExecute = branche;
m_actionToExecute = leProcessAExecuter.GetActionDebut();
m_contexteExecutionProcess = contexteExecution;
Thread th = new Thread(new ThreadStart(DemarreProcess));
th.Start();
return(result);
}
}
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
if (FormuleDocument == null)
{
result.EmpileErreur(I.T("Incorrect document formula|363"));
return(result);
}
result = FormuleDocument.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during Document evaluation|367"));
return(result);
}
if (!(result.Data is CDocumentGED))
{
result.EmpileErreur(I.T("The document formula must return an EDM document|364"));
return(result);
}
CDocumentGED document = (CDocumentGED)result.Data;
if (FormuleNomFichier == null)
{
result.EmpileErreur(I.T("Incorrect file name formula|365"));
return(result);
}
result = FormuleNomFichier.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during the destination file name of document evaluation|368"));
return(result);
}
if (!(result.Data is string))
{
result.EmpileErreur(I.T("File name formula doesn't return a file name string|369"));
return(result);
}
string strNomFichier = result.Data.ToString();
if (strNomFichier.ToUpper().StartsWith("FTP://"))
{
string strUser = "";
string strPassword = "";
if (FormuleUser != null)
{
result = FormuleUser.Eval(contexteEval);
}
if (!result)
{
result.EmpileErreur(I.T("Error in User formula|20250"));
return(result);
}
else
{
strUser = result.Data != null?result.Data.ToString() : "";
}
if (FormulePassword != null)
{
result = FormulePassword.Eval(contexteEval);
}
if (!result)
{
result.EmpileErreur(I.T("Error in password formula|20250"));
return(result);
}
else
{
strPassword = result.Data != null?result.Data.ToString() : "";
}
return(CopyToFtp(contexte.IdSession, document, strNomFichier, strUser, strPassword));
}
else if (CopierDepuisLePosteClient)
{
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (sessionClient != null)
{
//TESTDBKEYOK
if (sessionClient.GetInfoUtilisateur().KeyUtilisateur == contexte.Branche.KeyUtilisateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
CServiceSurClient service = sessionClient.GetServiceSurClient(c_idServiceClientSetFichier);
if (service != null)
{
sponsor.Register(service);
CParametreCopierLocalDansGed parametre = new CParametreCopierLocalDansGed(
document.Id,
strNomFichier);
result = service.RunService(parametre);
return(result);
}
}
}
}
}
if (File.Exists(strNomFichier))
{
#region renommage du fichier existant
if (FormuleNomFichierRenommage != null)
{
result = FormuleNomFichierRenommage.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error in the renaming file name|370"));
return(result);
}
if (!(result.Data is string))
{
result.EmpileErreur(I.T("The renaming formula doesn't return text|371"));
return(result);
}
int nIndex = 0;
string strRename = result.Data.ToString();
string strExt = "";
nIndex = strNomFichier.LastIndexOf('.');
string strNom = strRename;
if (nIndex >= 0)
{
strNom = strRename.Substring(0, nIndex);
strExt = strRename.Substring(nIndex);
strRename = strNom;
}
nIndex = 0;
while (File.Exists(strNom + strExt))
{
nIndex++;
strNom = strRename + "_" + nIndex;
}
try
{
if (strExt != "")
{
strNom = strNom + strExt;
}
File.Copy(strNomFichier, strNom, true);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("New name : '@1'|372", strNom));
result.EmpileErreur(I.T("Error during file renaming|373"));
return(result);
}
}
#endregion
}
try
{
using (CProxyGED proxy = new CProxyGED(contexte.IdSession, document.ReferenceDoc))
{
result = proxy.CopieFichierEnLocal();
if (!result)
{
return(result);
}
//Si le fichier existe, il est renommé
File.Copy(proxy.NomFichierLocal, strNomFichier, true);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
return(result);
}
return(result);
}
/// /////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
string strExpediteur = "";
string strSujet = "";
string strMessage = "";
ArrayList lstDestinataires = new ArrayList();
ArrayList lstDestinatairesCC = new ArrayList();
ArrayList lstDestinatairesBCC = new ArrayList();
ArrayList lstIdsDocs = new ArrayList();
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
if (m_formuleAdresseExpediteur == null)
{
result.EmpileErreur(I.T("Incorrect Sender adress formula|389"));
return(result);
}
result = m_formuleAdresseExpediteur.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during evaluation of the recipient address|399"));
return(result);
}
strExpediteur = GetMail(result.Data);
if (m_formuleSujet == null)
{
result.EmpileErreur(I.T("Incorrect subject formula|391"));
return(result);
}
result = m_formuleSujet.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during mail subject evaluation|400"));
return(result);
}
strSujet = result.Data.ToString();
if (m_formuleMessage == null)
{
result.EmpileErreur(I.T("The message formula is false|393"));
return(result);
}
result = m_formuleMessage.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during mail content evaluation|401"));
return(result);
}
strMessage = result.Data.ToString();
// Traite les destinataires To
foreach (C2iExpression exp in m_listeFormulesMailsDestinatairesTo)
{
if (exp != null)
{
result = exp.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error while evaluating one of the recipients|402"));
return(result);
}
object res = result.Data;
if (res is string)
{
res = ((string)res).Split(new char[] { ';', ',' });
}
if (res is IList)
{
foreach (object obj in ((IList)res))
{
string strMail = GetMail(obj);
if (strMail.Trim() != "")
{
lstDestinataires.Add(strMail);
}
}
}
else if (res.ToString().Trim() != "")
{
string strMail = GetMail(res);
if (strMail.Trim() != "")
{
lstDestinataires.Add(strMail);
}
}
}
}
// Traite les destinataires CC
foreach (C2iExpression exp in m_listeFormulesMailsDestinatairesCC)
{
if (exp != null)
{
result = exp.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error while evaluating one of the recipients|402"));
return(result);
}
object res = result.Data;
if (res is string)
{
res = ((string)res).Split(new char[] { ';', ',' });
}
if (res is IList)
{
foreach (object obj in ((IList)res))
{
string strMail = GetMail(obj);
if (strMail.Trim() != "")
{
lstDestinatairesCC.Add(strMail);
}
}
}
else if (res.ToString().Trim() != "")
{
string strMail = GetMail(res);
if (strMail.Trim() != "")
{
lstDestinatairesCC.Add(strMail);
}
}
}
}
// Traite les destinataires BCC
foreach (C2iExpression exp in m_listeFormulesMailsDestinatairesBCC)
{
if (exp != null)
{
result = exp.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error while evaluating one of the recipients|402"));
return(result);
}
object res = result.Data;
if (res is string)
{
res = ((string)res).Split(new char[] { ';', ',' });
}
if (res is IList)
{
foreach (object obj in ((IList)res))
{
string strMail = GetMail(obj);
if (strMail.Trim() != "")
{
lstDestinatairesBCC.Add(strMail);
}
}
}
else if (res.ToString().Trim() != "")
{
string strMail = GetMail(res);
if (strMail.Trim() != "")
{
lstDestinatairesBCC.Add(strMail);
}
}
}
}
// Traite les pièces jointes
foreach (C2iExpression exp in m_listeFormulesPiecesJointes)
{
if (exp != null)
{
result = exp.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error while evaluating one of the recipients|402"));
return(result);
}
if (result.Data is IEnumerable)
{
foreach (object obj in ((IList)result.Data))
{
if (obj is CDocumentGED)
{
lstIdsDocs.Add(((CDocumentGED)obj).Id);
}
}
}
else if (result.Data is CDocumentGED)
{
lstIdsDocs.Add(((CDocumentGED)result.Data).Id);
}
}
}
// Genere le Mail
string[] destArray = (string[])lstDestinataires.ToArray(typeof(string));
string[] destCCArray = (string[])lstDestinatairesCC.ToArray(typeof(string));
string[] destBCCArray = (string[])lstDestinatairesBCC.ToArray(typeof(string));
int[] docsArray = (int[])lstIdsDocs.ToArray(typeof(int));
CMailSC2I mail = new CMailSC2I(
strExpediteur,
strSujet,
strMessage,
destArray,
destCCArray,
destBCCArray,
docsArray,
IsFormatHTML,
UseDocLabelAsFileName,
SMTPserver,
SMTPort,
SMTPUser,
SMTPPassword);
// Envoi le mail
IExpediteurMail expediteur = (IExpediteurMail)C2iFactory.GetNewObjetForSession("CExpediteurMail", typeof(IExpediteurMail), contexte.IdSession);
result = expediteur.SendMail(mail);
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
//Si la session qui execute est une session de l'utilisateur associé à la branche,
//Tente d'ImprimerModeleTexte sur cette session,
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (sessionClient != null)
{
//TESTDBKEYOK
if (sessionClient.GetInfoUtilisateur().KeyUtilisateur == contexte.Branche.KeyUtilisateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
CServiceSurClient service = sessionClient.GetServiceSurClient(c_idServiceClientImprimerModeleTexte);
if (service != null)
{
sponsor.Register(service);
//Evalue l'élément à éditer
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
if (m_expressionElementSource == null)
{
result.EmpileErreur(I.T("Incorrect formula for Edited element|385"));
return(result);
}
result = m_expressionElementSource.Eval(contexteEval);
if (!result)
{
return(result);
}
CObjetDonnee objet = result.Data as CObjetDonnee;
if (m_formuleParametresImpression == null)
{
result.EmpileErreur(I.T("Print setup formula is not correct|20041"));
return(result);
}
result = m_formuleParametresImpression.Eval(contexteEval);
if (!result || !(result.Data is string))
{
result.EmpileErreur(I.T("Print setup formula is not correct|20041"));
return(result);
}
string strParametresImpression = result.Data.ToString();
result = service.RunService(
new CParametreImpressionModeleTexte(
new CReferenceObjetDonnee(objet),
m_nIdModeleAImprimer,
strParametresImpression));
//Fin du process
result.Data = null;
if (result)
{
foreach (CLienAction lien in this.GetLiensSortantHorsErreur())
{
if (!(lien is CLienUtilisateurAbsent))
{
result.Data = lien;
}
}
}
return(result);
}
}
}
}
//Utilisateur pas accessible
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienUtilisateurAbsent)
{
result.Data = lien;
return(result);
}
}
return(result);
}
/// /////////////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
//Si la session qui execute est une session de l'utilisateur associé à la branche,
//Tente d'afficher le EditerElement sur cette session,
//Sinon, enregistre une Intervention sur l'utilisateur
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (sessionClient != null)
{
//TESTDBKEYOK
if (sessionClient.GetInfoUtilisateur().KeyUtilisateur == contexte.Branche.KeyUtilisateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
CServiceSurClient service = sessionClient.GetServiceSurClient(c_idServiceVisualisationListeObjetsDonnee);
if (service != null)
{
sponsor.Register(service);
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(Process);
string strContexte = "";
string strTitre = "";
if (ExpressionContexteFenetre != null)
{
result = ExpressionContexteFenetre.Eval(ctxEval);
if (!result)
{
return(result);
}
if (result.Data != null)
{
strContexte = result.Data.ToString();
}
}
if (ExpressionTitreFenetre != null)
{
result = ExpressionTitreFenetre.Eval(ctxEval);
if (!result)
{
return(result);
}
if (result.Data != null)
{
strTitre = result.Data.ToString();
}
}
if (Filtre.TypeElements == null)
{
result.EmpileErreur(I.T("The object type is not defined|418"));
return(result);
}
CFiltreData filtre = null;
if (m_filtreDynamique != null)
{
m_filtreDynamique.ContexteDonnee = contexte.ContexteDonnee;
m_filtreDynamique.ElementAVariablesExterne = Process;
result = m_filtreDynamique.GetFiltreData();
if (!result)
{
result.EmpileErreur(I.T("Error while calculating the filter|419"));
return(result);
}
filtre = (CFiltreData)result.Data;
}
CParametreServiceVisuListeObjets parametre = new CParametreServiceVisuListeObjets(
Filtre.TypeElements,
filtre,
m_bAppliquerFiltreParDefaut,
strTitre,
strContexte);
if (result)
{
result = service.RunService(parametre);
}
//Fin du process
result.Data = null;
if (result)
{
foreach (CLienAction lien in this.GetLiensSortantHorsErreur())
{
if (!(lien is CLienUtilisateurAbsent))
{
result.Data = lien;
}
}
}
return(result);
}
}
}
}
//Utilisateur pas accessible
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienUtilisateurAbsent)
{
result.Data = lien;
return(result);
}
}
return(result);
}
