Beispiel #1
0
        /// ////////////////////////////////////////////////////////
        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);
        }
Beispiel #2
0
        /// ////////////////////////////////////////////////////////
        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);
        }
Beispiel #3
0
        /// ////////////////////////////////////////////////////////
        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);
        }