//--------------------------------------------------------------------
private void itemHistorique_Click(object sender, EventArgs e)
{
if (sender is CMenuItemAHistorique)
{
CHistoriqueDocumentGencod historique = ((CMenuItemAHistorique)sender).Historique;
CDocumentGED doc = new CDocumentGED(CSc2iWin32DataClient.ContexteCourant);
if (!doc.ReadIfExists(historique.IdDocumentGed))
{
CFormAlerte.Afficher(
I.T("The document|866") + " "
+ historique.LibelleDocument + " " +
I.T("does not exist any more|867"), EFormAlerteType.Erreur);
return;
}
doc.BeginEdit();
doc.AssocieA((CObjetDonneeAIdNumerique)m_objetForGED);
CResultAErreur result = doc.CommitEdit();
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
InitPanel();
}
}
/// ///////////////////////////////////////////
public override sc2i.common.CResultAErreur RunService(object parametre)
{
CResultAErreur result = CResultAErreur.True;
CActionCopieDocumentGed.CParametreCopierLocalDansGed parametreCopie = parametre as CActionCopieDocumentGed.CParametreCopierLocalDansGed;
if (parametreCopie == null)
{
result.EmpileErreur(I.T("Bad parameter value for service SetLocalFile|20125"));
return(result);
}
using (CContexteDonnee contexte = new CContexteDonnee(CTimosApp.SessionClient.IdSession, true, false))
{
CDocumentGED document = new CDocumentGED(contexte);
if (!document.ReadIfExists(parametreCopie.IdDocumentGed))
{
result.EmpileErreur(I.T("Document @1 doesn't exists|20126"));
return(result);
}
try
{
using (CProxyGED proxy = new CProxyGED(CTimosApp.SessionClient.IdSession, document.ReferenceDoc))
{
result = proxy.CopieFichierEnLocal();
if (!result)
{
return(result);
}
File.Copy(proxy.NomFichierLocal, parametreCopie.NomFichier, true);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
}
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);
}
/// ////////////////////////////////////////////////////////////////
public CResultAErreur SendMail(CMailSC2I mail)
{
CResultAErreur result = CResultAErreur.True;
MailMessage message = new MailMessage();
message.From = new MailAddress(mail.Expediteur);
message.Subject = mail.Sujet;
message.Body = mail.Message;
message.IsBodyHtml = mail.IsFormatHTML;
// Destinataires To
if (mail.Destinataires != null)
{
foreach (string strDest in mail.Destinataires)
{
message.To.Add(new MailAddress(strDest));
}
}
// Destinataires CC
if (mail.DestinatairesCC != null)
{
foreach (string strDest in mail.DestinatairesCC)
{
message.CC.Add(new MailAddress(strDest));
}
}
// Destinataires BCC
if (mail.DestinatairesBCC != null)
{
foreach (string strDest in mail.DestinatairesBCC)
{
message.Bcc.Add(new MailAddress(strDest));
}
}
ArrayList lstProxy = new ArrayList();
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
foreach (int nIdDoc in mail.DocumentsGED)
{
CDocumentGED doc = new CDocumentGED(contexte);
if (doc.ReadIfExists(nIdDoc) && doc.ReferenceDoc != null)
{
CProxyGED proxy = new CProxyGED(IdSession, doc.ReferenceDoc);
// Ajouter un paramètre optionnel CopieFichierEnLocal(doc.Libelle)
if (proxy.CopieFichierEnLocal(mail.UseDocLabelAsFileName ? doc.Libelle : ""))
{
lstProxy.Add(proxy);
Attachment att = new Attachment(proxy.NomFichierLocal);
message.Attachments.Add(att);
}
}
}
}
try
{
string strServeur = "";
string strUser = "";
string strPass = "";
int nPort = 0;
if (mail.SMTPServer != String.Empty)
{
strServeur = mail.SMTPServer;
nPort = mail.SMTPPort;
strUser = mail.SMTPUser;
strPass = mail.SMTPPassword;
}
else
{
strServeur = CTimosServeurRegistre.SMTPServer;
nPort = CTimosServeurRegistre.SMTPPort;
strUser = CTimosServeurRegistre.SMTPUser;
strPass = CTimosServeurRegistre.SMTPPassword;
}
using (SmtpClient clientSmtp = new SmtpClient())
{
clientSmtp.Host = strServeur;
if (nPort > 0)
{
clientSmtp.Port = nPort;
}
if (strUser != "" || strPass != "")
{
clientSmtp.Credentials = new NetworkCredential(strUser, strPass);
}
else
{
clientSmtp.Credentials = System.Net.CredentialCache.DefaultNetworkCredentials;
}
clientSmtp.Send(message);
}
}
catch (Exception e)
{
result.EmpileErreur(e.ToString());
result.EmpileErreur(I.T("Error while sending mail|30000"));
}
finally
{
message.Dispose();
}
foreach (CProxyGED proxy in lstProxy)
{
proxy.Dispose();
}
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);
}
public void InsérerMibEnGed(int nModuleId)
{
CSpvMibmodule module = new CSpvMibmodule(m_contexteDonnees);
Console.WriteLine("Lecture du module MIB");
Assert.IsTrue(module.ReadIfExists(nModuleId));
CResultAErreur result = CResultAErreur.True;
if (File.Exists(module.FichierModule))
{
Console.WriteLine("le fichier existe");
CDocumentGED doc = module.DocumentGEDModuleMib;
CProxyGED proxy = new CProxyGED(m_contexteDonnees.IdSession,
doc == null ? null : doc.ReferenceDoc);
proxy.AttacheToLocal(module.FichierModule);
result = proxy.UpdateGed();
if (result)
{
if (doc == null)
{
Console.WriteLine("doc null :création d'un nouveau document GED");
doc = new CDocumentGED(m_contexteDonnees);
doc.CreateNewInCurrentContexte();
doc.Descriptif = "";
doc.DateCreation = DateTime.Now;
doc.Libelle = "MIB file " + module.NomModuleUtilisateur;
doc.ReferenceDoc = (CReferenceDocument)result.Data;
doc.DateMAJ = DateTime.Now;
doc.NumVersion++;
doc.IsFichierSysteme = true;
module.DocumentGEDModuleMib = doc;
}
}
Console.WriteLine("vérification des donnéees");
result = module.VerifieDonnees(false);
if (!result)
{
System.Console.WriteLine(result.MessageErreur);
}
Assert.IsTrue(result.Result);
Console.WriteLine("enregistrement des donnéées");
m_contexteDonnees.SaveAll(true);
if (!result)
{
System.Console.WriteLine(result.MessageErreur);
}
Assert.IsTrue(result.Result);
int nDocId = doc.Id;
CDocumentGED doctest = new CDocumentGED(m_contexteDonnees);
Console.WriteLine("lecture du document GED");
Assert.IsTrue(doctest.ReadIfExists(nDocId));
Console.WriteLine(doctest.Id);
Console.WriteLine(doctest.Libelle);
}
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
if (ExpressionListeDocuments == null)
{
result.EmpileErreur(I.T("Document list formula is null|20051"));
return(result);
}
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
result = ExpressionListeDocuments.Eval(contexteEval);
if (!result)
{
return(result);
}
IEnumerable enDocs = result.Data as IEnumerable;
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);
}
if (enDocs == null)
{
result.EmpileErreur(I.T("Document list formul returns an incorrect value|20052"));
return(result);
}
List <CDocumentGED> lstDocs = new List <CDocumentGED>();
try
{
foreach (CDocumentGED doc in enDocs)
{
if (doc.Cle != strCle)
{
lstDocs.Add(doc);
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error in document list|20053"));
}
MemoryStream stream = new MemoryStream();
ZipOutputStream zipStream = new ZipOutputStream(stream);
zipStream.SetLevel(9);
HashSet <string> lstNomsDocuments = new HashSet <string>();
foreach (CDocumentGED doc in lstDocs)
{
CContexteEvaluationExpression ctxDoc = new CContexteEvaluationExpression(doc);
string strNomFichier = "";
if (ExpressionNomsFichiers != null)
{
result = ExpressionNomsFichiers.Eval(ctxDoc);
if (result && result.Data != null)
{
strNomFichier = result.Data.ToString();
}
}
if (strNomFichier == "")
{
strNomFichier = I.T("File|20054");
}
foreach (char c in "\"/\\*?<>|:")
{
if (strNomFichier.Contains(c.ToString()))
{
strNomFichier = strNomFichier.Replace(c, '_');
}
}
if (lstNomsDocuments.Contains(strNomFichier.ToUpper()))
{
int nIndex = 1;
string strTmp = strNomFichier + "_" + nIndex;
while (lstNomsDocuments.Contains(strTmp.ToUpper()))
{
nIndex++;
strTmp = strNomFichier + "_" + nIndex;
}
strNomFichier = strTmp.ToUpper();
}
lstNomsDocuments.Add(strNomFichier.ToUpper());
strNomFichier += "." + doc.ReferenceDoc.GetExtension();
using (CProxyGED proxy = new CProxyGED(contexte.IdSession, doc.ReferenceDoc))
{
result = proxy.CopieFichierEnLocal();
if (result)
{
ZipEntry entry = new ZipEntry(ZipEntry.CleanName(strNomFichier));
try
{
FileStream fstream = new FileStream(proxy.NomFichierLocal, FileMode.Open, FileAccess.Read);
entry.DateTime = DateTime.Now;
entry.Size = fstream.Length;
int nBufLength = 1024 * 1024;
byte[] buffer = new byte[nBufLength];
int nRead = 0;
zipStream.PutNextEntry(entry);
while ((nRead = fstream.Read(buffer, 0, nBufLength)) != 0)
{
zipStream.Write(buffer, 0, nRead);
}
fstream.Close();
zipStream.CloseEntry();
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
return(result);
}
}
}
}
zipStream.Finish();
stream.Seek(0, SeekOrigin.Begin);
CSourceDocumentStream sourceDoc = new CSourceDocumentStream(stream, "zip");
//On a notre stream zippé, création du document
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 docZip = 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 (!docZip.ReadIfExists(filtre))
{
docZip.CreateNew();
}
else
{
docZip.BeginEdit();
}
}
else
{
docZip.CreateNew();
}
docZip.Libelle = strLibelle;
docZip.Descriptif = strDescriptif;
docZip.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(docZip);
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(docZip.ContexteDonnee);
if (cat.ReadIfExists(dbKey))
{
CRelationDocumentGED_Categorie rel = new CRelationDocumentGED_Categorie(docZip.ContexteDonnee);
rel.CreateNewInCurrentContexte();
rel.Categorie = cat;
rel.Document = docZip;
}
}
result = CDocumentGED.SaveDocument(contexte.IdSession, sourceDoc, sourceDoc.TypeReference, docZip.ReferenceDoc, true);
if (sourceDoc != null)
{
sourceDoc.Dispose();
}
zipStream.Close();
zipStream.Dispose();
stream.Dispose();
if (!result)
{
return(result);
}
CReferenceDocument refDoc = result.Data as CReferenceDocument;
docZip.ReferenceDoc = refDoc;
result = docZip.CommitEdit();
if (!result)
{
return(result);
}
if (VariableResultat != null)
{
Process.SetValeurChamp(VariableResultat, docZip);
}
return(result);
}
private CResultAErreur ImportRep(CProjet projetNominal,
CProjet projetCandidat,
CRepertoire rep,
string strPathGed)
{
CResultAErreur result = CResultAErreur.True;
rep.ImportDone = true;
strPathGed += "\\" + rep.Nom;
CMappingRepToDocSetup map = CMappingRepToDocSetup.GetMapping(rep.Nom);
foreach (CFichier fichier in rep.GetChilds <CFichier>())
{
if (map == null)
{
fichier.InfoImport = "No mapping for this directory";
}
else
{
CObjetDonneeAIdNumerique objet = map.GetObjet(projetNominal,
projetCandidat,
fichier.Nom);
if (objet == null)
{
fichier.InfoImport = "Can not find associated objet for this file";
}
else
{
CCategorieGED cat = map.GetCatégorie(projetNominal.ContexteDonnee);
if (cat == null)
{
fichier.InfoImport = "Can not find EDM category for this file";
}
else
{
string strCode = objet.IdUniversel + "/" + fichier.Nom;
CDocumentGED doc = new CDocumentGED(projetNominal.ContexteDonnee);
if (!doc.ReadIfExists(new CFiltreData(CDocumentGED.c_champCle + "=@1", strCode)))
{
doc.CreateNewInCurrentContexte();
}
doc.Libelle = fichier.Nom;
doc.Cle = strCode;
CReferenceDocument refDoc = new CReferenceDocument();
refDoc.TypeReference = new CTypeReferenceDocument(CTypeReferenceDocument.TypesReference.Fichier);
refDoc.NomFichier = strPathGed + "\\" + fichier.Nom;
doc.ReferenceDoc = refDoc;
doc.AddCategory(cat);
doc.AssocieA(objet);
fichier.SetObjetAssocie(objet);
}
}
}
}
foreach (CRepertoire child in rep.GetChilds <CRepertoire>())
{
result = ImportRep(projetNominal, projetCandidat, child, strPathGed);
if (!result)
{
return(result);
}
}
return(result);
}