//-------------------------------------------------------------------
/// <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);
}
/// ////////////////////////////////////////////////////////
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);
}
//-------------------------------------------------------------------
public CResultAErreur SaveDocument(CSourceDocument source,
CTypeReferenceDocument typeReference,
CReferenceDocument versionPrecedente,
bool bIncrementeVersionFichier)
{
CResultAErreur result = CResultAErreur.True;
//Copie du fichier
try
{
switch (typeReference.Code)
{
case CTypeReferenceDocument.TypesReference.Fichier:
if (!(source is CSourceDocumentStream))
{
result.EmpileErreur(I.T("Document type '@1' source not supported|109", source.GetType().Name));
return(result);
}
string strNomFichier = "";
if (versionPrecedente != null)
{
strNomFichier = versionPrecedente.NomFichier;
strNomFichier = strNomFichier.Replace("..", "."); //Correction erreurs passées
if (bIncrementeVersionFichier)
{
strNomFichier = IncNomFichier(strNomFichier);
}
string strExt = ((CSourceDocumentStream)source).Extension;
if (strExt.ToUpper() != "DAT")
{
strNomFichier = ChangeExtension(strNomFichier, ((CSourceDocumentStream)source).Extension);
}
}
else
{
string strPath = DateTime.Now.Year.ToString() + "\\";
strPath += DateTime.Now.Month.ToString() + "\\";
strPath += DateTime.Now.Day.ToString() + "\\";
strNomFichier = strPath + CGenerateurStringUnique.GetNewNumero(m_nIdSession) + "_0.";
strNomFichier += ((CSourceDocumentStream)source).Extension;
}
//S'assure que le chemin du fichier existe
string[] strChemins = strNomFichier.Split('\\');
int nChemin = 0;
string strTemp = m_strPath;
foreach (string strChemin in strChemins)
{
if (nChemin < strChemins.Length - 1)
{
if (!Directory.Exists(m_strPath + strChemin))
{
Directory.CreateDirectory(strTemp + strChemin);
}
strTemp += strChemin + "\\";
}
nChemin++;
}
if (strNomFichier.LastIndexOf('.') < 0)
{
strNomFichier += ((CSourceDocumentStream)source).Extension;
}
if (File.Exists(m_strPath + strNomFichier))
{
File.Delete(m_strPath + strNomFichier);
}
FileStream stream = new FileStream(m_strPath + strNomFichier, FileMode.CreateNew);
Stream sourceStream = ((CSourceDocumentStream)source).SourceStream;
result = CStreamCopieur.CopyStream(sourceStream, stream, 32000);
if (!result)
{
File.Delete(strNomFichier);
return(result);
}
CReferenceDocument referenceFinale = new CReferenceDocument();
referenceFinale.NomFichier = strNomFichier;
referenceFinale.CodeTypeReference = CTypeReferenceDocument.TypesReference.Fichier;
referenceFinale.TailleFichier = (int)new FileInfo(m_strPath + strNomFichier).Length;
m_listeReferencesTemporaires.Add(new CReferenceTemporaire(referenceFinale));
if (m_timerNettoyage == null && C2iAppliServeur.GetValeur(c_cleDesactivationNettoyage) != null)
{
m_timerNettoyage = new Timer(new TimerCallback(NettoyageTemporaires), null, 1000 * 60 * 30, 1000 * 60 * 30);
}
result.Data = referenceFinale;
break;
case CTypeReferenceDocument.TypesReference.LienDirect:
//Vérifie que le lien est accessible depuis le serveur
CSourceDocumentLienDirect sourceDirecte = source as CSourceDocumentLienDirect;
if (sourceDirecte == null)
{
result.EmpileErreur(I.T("Document type '@1' source not supported|109", source.GetType().Name));
return(result);
}
CReferenceDocument referenceFinaleLien = new CReferenceDocument();
referenceFinaleLien.NomFichier = sourceDirecte.NomFichier;
referenceFinaleLien.CodeTypeReference = CTypeReferenceDocument.TypesReference.LienDirect;
referenceFinaleLien.TailleFichier = (int)new FileInfo(sourceDirecte.NomFichier).Length;
if (!File.Exists(sourceDirecte.NomFichier))
{
result.EmpileErreur("File @1 cannot be stored in EDM, it can not be reached from server|20000", sourceDirecte.NomFichier);
return(result);
}
result.Data = referenceFinaleLien;
break;
default:
result.EmpileErreur(I.T("File reference type @1 not supported|110", typeReference.ToString()));
return(result);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error while saving EDM |111"));
}
return(result);
}
