/// ////////////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (sessionClient != null)
{
if (sessionClient.GetInfoUtilisateur().KeyUtilisateur == contexte.Branche.KeyUtilisateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
CServiceSurClient service = sessionClient.GetServiceSurClient(c_idServiceClientMessageBox);
if (service != null)
{
sponsor.Register(service);
//Calcule le message
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = FormuleMessage.Eval(contexteEval);
if (!result)
{
result = CResultAErreur.True;
m_strMessageCache = FormuleMessage.GetString();
}
else
{
m_strMessageCache = result.Data == null ? "" : result.Data.ToString();
}
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);
}
}
}
}
//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_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 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;
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (sessionClient != null)
{
if (sessionClient.GetInfoUtilisateur().KeyUtilisateur == contexte.Branche.KeyUtilisateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
CServiceSurClient service = sessionClient.GetServiceSurClient(c_idServiceSelectMultiForGed);
CServiceSurClient serviceGetFile = sessionClient.GetServiceSurClient(CActionCopierLocalDansGed.c_idServiceClientGetFichier);
if (service != null && serviceGetFile != null)
{
sponsor.Register(service);
sponsor.Register(serviceGetFile);
//Calcule la liste des ids de catégories à gérer
List <int> lstIds = new List <int>();
if (FormuleListeCategories != null)
{
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = FormuleListeCategories.Eval(contexteEval);
if (!result)
{
return(result);
}
IEnumerable lst = result.Data as IEnumerable;
if (lst != null)
{
foreach (object obj in lst)
{
if (obj is int)
{
lstIds.Add((int)obj);
}
if (obj is CCategorieGED)
{
lstIds.Add(((CCategorieGED)obj).Id);
}
}
}
}
result = service.RunService(lstIds);
if (result && result.Data is IEnumerable)
{
List <CDocumentGED> lstDocs = new List <CDocumentGED>();
foreach (object obj in (IEnumerable)result.Data)
{
CInfoFichierToGed info = obj as CInfoFichierToGed;
if (info != null)
{
string strContenu = info.FileFullName;
CSourceDocument sourceDoc = null;
result = serviceGetFile.RunService(strContenu);
if (!result)
{
return(result);
}
sourceDoc = result.Data as CSourceDocument;
if (sourceDoc == null)
{
result.EmpileErreur(I.T("Error while retrieving file @1|20020", strContenu));
return(result);
}
//On a notre fichier en local, création du document
string strCle = "";
string strLibelle = "";
info.ActiveProcess = contexte.Branche.Process;
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(info);
if (FormuleCle != null)
{
result = FormuleCle.Eval(ctxEval);
if (result && result.Data != null)
{
strCle = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("Document key could not be computed|30050"));
return(result);
}
}
if (FormuleLibelleDocument != null)
{
result = FormuleLibelleDocument.Eval(ctxEval);
if (result && result.Data != null)
{
strLibelle = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("Document label could not be computed|30051"));
return(result);
}
}
if (strLibelle.Length == 0)
{
strLibelle = info.FileName;
}
CObjetDonneeAIdNumerique associeA = null;
if (FormuleElementAssocie != null)
{
result = FormuleElementAssocie.Eval(ctxEval);
if (result)
{
associeA = result.Data as CObjetDonneeAIdNumerique;
}
}
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.Cle = strCle;
ArrayList lstToCreate = new ArrayList();
lstToCreate.Add(info.EDMCategoryId);
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;
}
}
result = CDocumentGED.SaveDocument(contexte.IdSession, sourceDoc, sourceDoc.TypeReference, doc.ReferenceDoc, true);
if (!result)
{
return(result);
}
CReferenceDocument refDoc = result.Data as CReferenceDocument;
doc.ReferenceDoc = refDoc;
if (associeA != null)
{
doc.AssocieA(associeA);
}
result = doc.CommitEdit();
if (!result)
{
return(result);
}
lstDocs.Add(doc);
}
}
if (VariableResultat != null)
{
Process.SetValeurChamp(VariableResultat, lstDocs.ToArray());
}
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;
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_idServiceClientGetFichier);
CParametresCopierLocalDansGed parametreService = new CParametresCopierLocalDansGed();
CFichierLocalTemporaire fichierLocal = null;
FileStream localStream = null;
if (service != null)
{
sponsor.Register(service);
//Calcule le contenu
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = ExpressionContenu.Eval(contexteEval);
if (!result)
{
return(result);
}
parametreService.NomFichierLocal = result.Data as string;
if (ExpressionUser != null && (result = ExpressionUser.Eval(contexteEval)))
{
if (result.Data != null)
{
parametreService.User = result.Data.ToString();
}
}
if (ExpressionPassword != null && (result = ExpressionPassword.Eval(contexteEval)))
{
if (result.Data != null)
{
parametreService.Password = result.Data.ToString();
}
}
CSourceDocument sourceDoc = null;
if (parametreService.NomFichierLocal.ToUpper().StartsWith("FTP://"))
{
CResultAErreurType <CFichierLocalTemporaire> resFic = GetFileFromFtp(
parametreService);
if (!resFic)
{
result.EmpileErreur(resFic.Erreur);
return(result);
}
fichierLocal = resFic.DataType;
localStream = new FileStream(fichierLocal.NomFichier, FileMode.Open, FileAccess.Read);
sourceDoc = new CSourceDocumentStream(localStream, "txt");
}
else if (!m_bCreerFichierTexteAPartirDeLaFormuleContenu)
{
result = service.RunService(parametreService);
if (!result)
{
return(result);
}
sourceDoc = result.Data as CSourceDocument;
if (sourceDoc == null)
{
result.EmpileErreur(I.T("Error while retrieving file @1|20020", parametreService.NomFichierLocal));
return(result);
}
}
else
{
fichierLocal = new CFichierLocalTemporaire("txt");
localStream = new FileStream(fichierLocal.NomFichier, FileMode.CreateNew, FileAccess.Write);
StreamWriter writer = new StreamWriter(localStream);
writer.Write(parametreService.NomFichierLocal);
writer.Close();
localStream.Close();
localStream = new FileStream(fichierLocal.NomFichier, FileMode.Open, FileAccess.Read);
sourceDoc = new CSourceDocumentStream(localStream, "txt");
}
//On a notre fichier en local, création du document
string strCle = "";
string strDescriptif = "";
string strLibelle = "";
result = ExpressionCle.Eval(contexteEval);
if (result)
{
strCle = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("Document key could not be computed|30050"));
return(result);
}
result = ExpressionLibelle.Eval(contexteEval);
if (result)
{
strLibelle = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("Document label could not be computed|30051"));
return(result);
}
result = ExpressionDescriptif.Eval(contexteEval);
if (result)
{
strDescriptif = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("Document description could not be computed|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;
List <CDbKey> lstToCreate = new List <CDbKey>(ListeDbKeysCategoriesStockage);
List <CRelationDocumentGED_Categorie> lstToDelete = new List <CRelationDocumentGED_Categorie>();
//Affecte les catégories
CListeObjetsDonnees listeCategoriesExistantes = CRelationDocumentGED_Categorie.GetRelationsCategoriesForDocument(doc);
foreach (CRelationDocumentGED_Categorie rel in listeCategoriesExistantes)
{
if (!lstToCreate.Contains(rel.Categorie.DbKey))
{
lstToDelete.Add(rel);
}
lstToCreate.Remove(rel.Categorie.DbKey);
}
foreach (CRelationDocumentGED_Categorie rel in lstToDelete)
{
rel.Delete();
}
foreach (CDbKey dbKey in lstToCreate)
{
CCategorieGED cat = new CCategorieGED(doc.ContexteDonnee);
if (cat.ReadIfExists(dbKey))
{
CRelationDocumentGED_Categorie rel = new CRelationDocumentGED_Categorie(doc.ContexteDonnee);
rel.CreateNewInCurrentContexte();
rel.Categorie = cat;
rel.Document = doc;
}
}
result = CDocumentGED.SaveDocument(contexte.IdSession, sourceDoc, sourceDoc.TypeReference, doc.ReferenceDoc, true);
if (sourceDoc != null)
{
sourceDoc.Dispose();
}
if (localStream != null)
{
localStream.Dispose();
}
if (fichierLocal != null)
{
fichierLocal.Dispose();
}
if (!result)
{
return(result);
}
CReferenceDocument refDoc = result.Data as CReferenceDocument;
doc.ReferenceDoc = refDoc;
result = doc.CommitEdit();
if (!result)
{
return(result);
}
if (VariableResultat != null)
{
Process.SetValeurChamp(VariableResultat, doc);
}
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;
try
{
// Récupère la structure par formule ou structure propore
m_structureUtiliseeAExecution = StructureExport;
IVariableDynamique variableProcess = AssureVariableProcessDansStructure();
m_structureUtiliseeAExecution.SetValeurChamp(variableProcess.IdVariable, Process);
m_structureUtiliseeAExecution.ContexteDonnee = contexte.ContexteDonnee;
// Si la structure possede un formulaire il faut lancer le service sur le poste client
if (m_structureUtiliseeAExecution != null && m_structureUtiliseeAExecution.Formulaire != null && m_structureUtiliseeAExecution.Formulaire.Childs.Length > 0)
{
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_idServiceClientExporterDonnees);
if (service != null)
{
sponsor.Register(service);
result = service.RunService(this);
E2iDialogResult dResult = (E2iDialogResult)result.Data;
if (dResult == E2iDialogResult.Cancel)
{
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienFromDialog &&
((CLienFromDialog)lien).ResultAssocie == dResult)
{
result.Data = lien;
return(result);
}
}
}
}
else
{
//Utilisateur pas accessible
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienUtilisateurAbsent)
{
result.Data = lien;
return(result);
}
}
}
}
}
}
else
{
//Utilisateur pas accessible
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienUtilisateurAbsent)
{
result.Data = lien;
return(result);
}
}
}
}
result = m_structureUtiliseeAExecution.GetDataSet(Exporteur.ExporteStructureOnly);
if (!result)
{
result.EmpileErreur(I.T("Error while exporting data|405"));
return(result);
}
DataSet ds = (DataSet)result.Data;
// Fichier d'export retourné
CFichierLocalTemporaire fichierExport = new CFichierLocalTemporaire(Exporteur.ExtensionParDefaut);
fichierExport.CreateNewFichier();
CDestinationExportFile dest = new CDestinationExportFile(fichierExport.NomFichier);
result = Exporteur.Export(ds, dest);
if (!result)
{
result.EmpileErreur(I.T("Error while creating export file|406"));
return(result);
}
#region Stockage dans la ged
CContexteEvaluationExpression contexteEvaluation = new CContexteEvaluationExpression(Process);
//On a notre fichier export, 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("The document key could not be calculated|407"));
return(result);
}
result = ExpressionLibelle.Eval(contexteEvaluation);
if (result)
{
strLibelle = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("The document label could not be calculated|408"));
return(result);
}
result = ExpressionDescriptif.Eval(contexteEvaluation);
if (result)
{
strDescriptif = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("The document description could not be calculated|409"));
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(fichierExport.NomFichier);
result = proxy.UpdateGed();
if (!result)
{
return(result);
}
doc.ReferenceDoc = (CReferenceDocument)result.Data;
result = doc.CommitEdit();
fichierExport.Dispose();
if (VariableResultat != null)
{
Process.SetValeurChamp(VariableResultat, doc);
}
#endregion
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienFromDialog &&
((CLienFromDialog)lien).ResultAssocie != E2iDialogResult.Cancel)
{
result.Data = lien;
return(result);
}
}
result.Data = null;
return(result);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
}
return(result);
}
private void m_lnkFermer_LinkClicked(object sender, System.Windows.Forms.LinkLabelLinkClickedEventArgs e)
{
if (m_wndListeSession.CheckedItems.Count == 0)
{
MessageBox.Show(I.T("Check sessions to close first !|20519"));
return;
}
if (MessageBox.Show(
I.T("You will send a stop message to @1 sessions. Please confirm this action|20515",
m_wndListeSession.CheckedItems.Count.ToString()),
I.T("Confirmation|20516"),
MessageBoxButtons.YesNo,
MessageBoxIcon.Question) == DialogResult.No)
{
return;
}
ArrayList lstThreads = new ArrayList();
m_listeServicesToLaunch.Clear();
m_listeThreadsEnAttente.Clear();
ThreadStart funcStart = new ThreadStart(AskForClose);
StringBuilder bl = new StringBuilder();
int nNbSessionsSysteme = 0;
foreach (ListViewItem item in m_wndListeSession.CheckedItems)
{
CInfoSessionAsDynamicClass info = item.Tag as CInfoSessionAsDynamicClass;
if (info != null && info.IsSystem)
{
nNbSessionsSysteme++;
bl.Append(info.IdSession);
bl.Append(',');
}
}
string strMessage = "";
if (nNbSessionsSysteme > 0)
{
bl.Remove(bl.Length - 1, 1);
if (nNbSessionsSysteme > 1)
{
strMessage = I.T("Sessions @1 are system sessions and will not be close|20517",
bl.ToString());
}
else
{
strMessage = I.T("@1 session is a system session and will not be closed|20518",
bl.ToString());
}
MessageBox.Show(strMessage);
}
IGestionnaireSessions gestionnaire = (IGestionnaireSessions)C2iFactory.GetNewObject(typeof(IGestionnaireSessions));
foreach (ListViewItem item in m_wndListeSession.CheckedItems)
{
CInfoSessionAsDynamicClass info = item.Tag as CInfoSessionAsDynamicClass;
if (info != null && !info.IsSystem)
{
int nIdSession = info.IdSession;
CSessionClient session = CSessionClient.GetSessionForIdSession(nIdSession);
try
{
if (!info.Invalide)
{
CServiceSurClientFermerApplication service = (CServiceSurClientFermerApplication)session.GetServiceSurClient(CServiceSurClientFermerApplication.c_idService);
if (service != null)
{
lock (m_listeServicesToLaunch)
{
m_listeServicesToLaunch.Add(service);
}
Thread th = new Thread(funcStart);
th.Start();
}
}
else
{
ISessionClientSurServeur sessionSurServeur = gestionnaire.GetSessionClientSurServeur(info.IdSession);
sessionSurServeur.CloseSession();
}
}
catch
{
}
}
}
}
private void m_lnkFermer_LinkClicked(object sender, System.Windows.Forms.LinkLabelLinkClickedEventArgs e)
{
CResultAErreur result = CResultAErreur.True;
if (MessageBox.Show("Fermer toutes les sessions sélectionnées ?", "Confirmation",
MessageBoxButtons.YesNo,
MessageBoxIcon.Question) == DialogResult.No)
{
return;
}
ArrayList lstThreads = new ArrayList();
m_listeServicesToLaunch.Clear();
m_listeThreadsEnAttente.Clear();
ThreadStart funcStart = new ThreadStart(AskForClose);
foreach (ListViewItem item in m_listView.CheckedItems)
{
int nIdSession = (int)item.Tag;
CSessionClient session = CSessionClient.GetSessionForIdSession(nIdSession);
try
{
CServiceSurClientFermerApplication service = (CServiceSurClientFermerApplication)session.GetServiceSurClient(CServiceSurClientFermerApplication.c_idService);
if (service != null)
{
lock (m_listeServicesToLaunch)
{
m_listeServicesToLaunch.Add(service);
}
Thread th = new Thread(funcStart);
th.Start();
}
}
catch (Exception ex1)
{
result.EmpileErreur(ex1.Message);
try
{
if (session != null)
{
session.CloseSession();
}
}
catch (Exception ex2)
{
result.EmpileErreur(ex2.Message);
}
}
}
if (!result)
{
MessageBox.Show(result.MessageErreur);
}
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
string strCommandLine = "";
string strArguments = "";
//Calcule le fichier ou l'url
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = FormuleFichier.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during the File name or URL evaluation|236"));
return(result);
}
strCommandLine += result.Data;
// Calcul des Arguments
result = FormuleArguments.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during the Arguments evaluation|308"));
return(result);
}
strArguments += result.Data;
if (m_bSurServeur)
{
//Lance le programme depuis le serveur
System.Diagnostics.Process process = new System.Diagnostics.Process();
process.StartInfo.FileName = strCommandLine;
process.StartInfo.Arguments = strArguments;
process.StartInfo.UseShellExecute = true;
process.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Minimized;
try
{
process.Start();
if (m_bWaitForExit)
{
process.WaitForExit();
int nRetour = process.ExitCode;
CVariableDynamique variable = VariableResultat;
if (variable != null)
{
Process.SetValeurChamp(variable, nRetour);
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error in command line @1 @2|20011",
strCommandLine, strArguments));
}
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (!(lien is CLienUtilisateurAbsent))
{
result.Data = lien;
return(result);
}
}
result.Data = null;
return(result);
}
//Execution sur le client
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(CInfoServiceClientOuvrirFichier.c_idServiceClientOuvrirFichier);
if (service != null)
{
sponsor.Register(service);
CInfoServiceClientOuvrirFichier infoService = new CInfoServiceClientOuvrirFichier(strCommandLine, strArguments, WaitForExit);
result = service.RunService(infoService);
if (!result)
{
return(result);
}
CVariableDynamique variable = VariableResultat;
if (variable != null && result.Data is int && WaitForExit)
{
Process.SetValeurChamp(variable, result.Data);
}
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (!(lien is CLienUtilisateurAbsent))
{
result.Data = lien;
return(result);
}
}
result.Data = null;
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;
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 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;
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_idServiceSelectionFichierClient);
if (service != null)
{
sponsor.Register(service);
//Calcule le message
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = FormuleMessage.Eval(contexteEval);
if (!result)
{
result = CResultAErreur.True;
result.Data = "##";
}
m_strMessageCache = result.Data as string;
result = FormuleFiltre.Eval(contexteEval);
if (!result)
{
result = CResultAErreur.True;
result.Data = "*.*";
}
m_strFiltreCache = result.Data as string;
result = FormuleRepertoireInitial.Eval(contexteEval);
if (!result)
{
result = CResultAErreur.True;
result.Data = "";
}
m_strRepertoireInitialCache = result.Data as string;
// Lance le service
result = service.RunService(this);
if (!result)
{
return(result);
}
string strNomFichier = result.Data as string;
if (VariableResultat != null)
{
Process.SetValeurChamp(VariableResultat, result.Data);
}
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienFromDialog &&
((((CLienFromDialog)lien).ResultAssocie == E2iDialogResult.Cancel && strNomFichier == "") ||
(((CLienFromDialog)lien).ResultAssocie == E2iDialogResult.OK && strNomFichier != "")))
{
result.Data = lien;
return(result);
}
}
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);
}
/// ////////////////////////////////////////////////////////
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 AfficheEtapeWorkflow 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_idServiceClientAfficheEtapeWorkflow);
if (service != null)
{
sponsor.Register(service);
//Evalue l'élément à éditer
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
if (m_expressionEtapeAAfficher == null)
{
result.EmpileErreur(I.T("Incorrect formula for workflow step to display|20157"));
return(result);
}
result = m_expressionEtapeAAfficher.Eval(contexteEval);
if (!result)
{
return(result);
}
CEtapeWorkflow etape = result.Data as CEtapeWorkflow;
contexte.AddServiceALancerALaFin(new CContexteExecutionAction.CParametreServiceALancerALaFin(
service,
new CParametreAffichageEtapeWorkflow(
contexte.IdSession,
etape.Id,
DansNouvelOnglet)));
/*
* result = service.RunService(
* new CParametreAffichageEtapeWorkflow(
* contexte.IdSession,
* etape.Id,
* DansNouvelOnglet));*/
//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);
}