//-----------------------------------------------------------------------------------
private CResultAErreur EnregistrePieceJointeEnGED(MessagePart pieceJointe)
{
CResultAErreur result = CResultAErreur.True;
if (pieceJointe != null && pieceJointe.IsAttachment)
{
int nIndex = pieceJointe.FileName.LastIndexOf(".");
string strExtension = "";
if (nIndex > 0)
{
strExtension = pieceJointe.FileName.Substring(nIndex + 1);
}
else
{
strExtension = "dat";
}
byte[] contenuPj = pieceJointe.Body;
Stream fluxPJ = new MemoryStream(contenuPj);
if (fluxPJ.Length == 0)
{
return(result);
}
CSourceDocument srcDoc = new CSourceDocumentStream(fluxPJ, strExtension);
CDocumentGED documentAttache = new CDocumentGED(ContexteDonnee);
documentAttache.CreateNewInCurrentContexte();
documentAttache.AssocieA(this);
documentAttache.Libelle = pieceJointe.FileName;
result = CDocumentGED.SaveDocument(
ContexteDonnee.IdSession,
srcDoc,
new CTypeReferenceDocument(CTypeReferenceDocument.TypesReference.Fichier),
null,
false);
srcDoc.Dispose();
if (!result)
{
return(result);
}
documentAttache.ReferenceDoc = result.Data as CReferenceDocument;
}
return(result);
}
//-------------------------------------------------------------------
/// <summary>
/// Récupère une source document pour le document demandé
/// </summary>
/// <param name="refDoc"></param>
/// <returns></returns>
public CResultAErreur GetDocument(CReferenceDocument refDoc)
{
CResultAErreur result = CResultAErreur.True;
CSourceDocument source = null;
try
{
switch (refDoc.TypeReference.Code)
{
case CTypeReferenceDocument.TypesReference.Fichier:
source = new CSourceDocumentStream(
new FileStream(m_strPath + refDoc.NomFichier
, FileMode.Open, FileAccess.Read)
);
break;
case CTypeReferenceDocument.TypesReference.LienDirect:
source = new CSourceDocumentLienDirect(refDoc.NomFichier);
break;
default:
result.EmpileErreur(I.T("Document type '@1' not supported|108", refDoc.TypeReference.Libelle));
break;
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Impossible to read the file|107"));
return(result);
}
result.Data = source;
return(result);
}
/// ///////////////////////////////////////////
public override sc2i.common.CResultAErreur RunService(object parametre)
{
MyDispose();
CResultAErreur result = CResultAErreur.True;
CActionCopierLocalDansGed.CParametresCopierLocalDansGed paramCopie = parametre as CActionCopierLocalDansGed.CParametresCopierLocalDansGed;
if (paramCopie == null)
{
result.EmpileErreur(I.T("Bad parameter value for service GetLocalFile|20121"));
return(result);
}
if (paramCopie.NomFichierLocal.ToUpper().StartsWith("FTP://"))
{
//Si FTP récupère le fichier FTP et l'envoie dans un fichier local temporaire
result = GetFileFromFtp(paramCopie);
if (!result)
{
return(result);
}
paramCopie.NomFichierLocal = m_fichierTemporaireFromFTP.NomFichier;
}
string strNomFichier = paramCopie.NomFichierLocal;
if (!File.Exists(strNomFichier))
{
result.EmpileErreur(I.T("File @1 doesn't exists|20122", strNomFichier));
return(result);
}
m_streamFichier = new FileStream(strNomFichier, FileMode.Open, FileAccess.Read);
CSourceDocumentStream source = new CSourceDocumentStream(
m_streamFichier, Path.GetExtension(strNomFichier));
result.Data = source;
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 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);
}
