Пример #1
0
        //-------------------------------------------------------------------------
        protected override CResultAErreur MyInitChamps()
        {
            CResultAErreur result = base.MyInitChamps();

            AffecterTitre(I.T("Data structure |100") + StructureExport.Libelle);

            CMultiStructureExport multiStructure = StructureExport.MultiStructure;

            if (multiStructure == null)
            {
                multiStructure = new CMultiStructureExport(StructureExport.ContexteDonnee);
            }
            m_panelMultiStructure.Init(multiStructure);

            m_cmbGroupeParametrage.Init(
                typeof(CGroupeParametrage),
                null,
                "Libelle",
                typeof(CFormEditionGroupeParametrage),
                false);
            m_cmbGroupeParametrage.ElementSelectionne = StructureExport.GroupeParametrage;

            if (!result)
            {
                return(result);
            }

            return(result);
        }
Пример #2
0
        public override sc2i.common.CResultAErreur RunService(object parametre)
        {
            CResultAErreur result = CResultAErreur.True;

            m_actionExport = parametre as CActionExporterDonnees;
            if (m_actionExport == null)
            {
                result.EmpileErreur(I.T("Parameter type incompatible with 'Data Export' service|10045"));
                return(result);
            }

            m_structure = m_actionExport.StructureEnExecution;
            if (m_structure.Formulaire != null && m_structure.Formulaire.Childs.Length > 0)
            {
                Thread th = new Thread(new ThreadStart(ShowFormulaire));
                th.SetApartmentState(ApartmentState.STA);
                th.Start();
                th.Join();
            }

            if (!m_resultForm)
            {
                result.EmpileErreur(I.T("Error or cancel in the form|10047"));
                return(result);
            }

            return(m_resultForm);
        }
Пример #3
0
        //----------------------------------------------------------------------
        private void ChargerPanelFiltre()
        {
            CMultiStructureExport multiStructure = m_rapport.MultiStructure;

            if (multiStructure != null && multiStructure.Formulaire != null)
            {
                m_panelFiltre.InitPanel(multiStructure.Formulaire, multiStructure);
                m_panelFiltre.Height = multiStructure.Formulaire.Size.Height;
                m_panelFiltre.Show();
                m_btnFiltrer.Show();
                return;
            }

            /*else
             * {
             *      if ( m_rapport.Requete != null )
             *      {
             *              C2iRequete requete = m_rapport.Requete;
             *              m_panelFiltre.InitPanel( requete.FormulaireEdition, requete );
             *              m_panelFiltre.Height = requete.FormulaireEdition.Size.Height;
             *              m_panelFiltre.Show();
             *              m_btnFiltrer.Show();
             *              return;
             *      }
             * }*/

            m_panelFiltre.Hide();
            m_btnFiltrer.Hide();
        }
Пример #4
0
        private void m_btnOK_Click(object sender, System.EventArgs e)
        {
            CResultAErreur result = CResultAErreur.True;

            IDestinationExport destination = m_panelOptionsExport.DestinationExport;

            if (destination == null || !destination.EstValidePourExport())
            {
                result.EmpileErreur(I.T("Export destination is not valid|227"));
                CFormAlerte.Afficher(result);
                return;
            }
            m_destinationExport = destination;

            m_exporteur = Exporteur;


            //C2iStructureExportInDB structure = (C2iStructureExportInDB)m_cmbStructures.SelectedValue;
            m_multistructure = m_panelMultiStructure.MultiStructure;
            if (m_multistructure == null)
            {
                result.EmpileErreur(I.T("Invalid structure|228"));
                CFormAlerte.Afficher(result);
                return;
            }
            m_multistructure.ContexteDonnee = CSc2iWin32DataClient.ContexteCourant;


            CFormProgression.StartThreadWithProgress(I.T("Exporting data|229"), new System.Threading.ThreadStart(StartExport));

            /*
             *
             * result = structure.GetDataSet ( false, m_listeObjets, null );
             *
             * //result = structure.Export(m_listeObjets.ContexteDonnee.IdSession, m_listeObjets, ref ds, null);
             *
             * if (!result)
             * {
             *      CFormAlerte.Afficher(result);
             *      return;
             * }
             *
             * DataSet ds = (DataSet)result.Data;
             *
             * CDestinationExportFile dest = new CDestinationExportFile(m_panelOptions.FileName);
             *
             * result = Exporteur.Export(ds, dest);
             * if (!result)
             *      CFormAlerte.Afficher(result);
             * else
             *      CFormAlerte.Afficher("Exportation des données réussie");
             *
             * ds.Dispose();*/
            Close();
        }
        //-------------------------------------------------------------------------
        public static bool EditeElement(CElementMultiStructureExport element, CMultiStructureExport multiStructure)
        {
            CFormEditeElementDeMultiStructure form = new CFormEditeElementDeMultiStructure();

            form.m_multiStructure = multiStructure;
            form.m_element        = element;
            form.InitChamps();
            bool bResult = form.ShowDialog( ) == DialogResult.OK;

            form.Dispose();
            return(bResult);
        }
Пример #6
0
        //-------------------------------------------------------------------------
        protected override CResultAErreur MAJ_Champs()
        {
            CResultAErreur result = base.MAJ_Champs();

            if (result)
            {
                CMultiStructureExport structure = m_panelMultiStructure.MultiStructure;
                StructureExport.MultiStructure    = structure;
                StructureExport.GroupeParametrage = (CGroupeParametrage)m_cmbGroupeParametrage.ElementSelectionne;
            }

            return(result);
        }
Пример #7
0
        /// ////////////////////////////////////////////////////////
        public override CResultAErreur VerifieDonnees()
        {
            CResultAErreur result = base.VerifieDonnees();

            using (CContexteDonnee contexte = new CContexteDonnee(Process.IdSession, true, false))
            {
                C2iRapportCrystal etat = new C2iRapportCrystal(contexte);
                if (!etat.ReadIfExists(m_nIdEtatCrystal))
                {
                    result.EmpileErreur("Incorrect report model|30042");
                    return(result);
                }

                if (m_listeIdsCategorieStockage.Count < 1 && m_bStockerGed)
                {
                    result.EmpileErreur("The report must be stored at least in one EDM category|30043");
                }

                CMultiStructureExport multiStruct = etat.MultiStructure;
                if (multiStruct == null)
                {
                    result.EmpileErreur("The report does not have a data structure|30044");
                    return(result);
                }
                foreach (IVariableDynamique variable in multiStruct.ListeVariables)
                {
                    C2iExpression exp = GetExpressionForVariableFiltre(variable.IdVariable);
                    if (exp != null && !exp.TypeDonnee.Equals(variable.TypeDonnee))
                    {
                        result.EmpileErreur("The value of the variable @1 is not compatible with the variable type|30045", variable.Nom);
                    }
                }
            }

            return(result);
        }
Пример #8
0
        private void UpdateListeVariables()
        {
            m_bListeVariablesRemplie     = false;
            m_variableEnCoursEdition     = null;
            m_txtFormuleVariable.Visible = false;
            if (!(m_comboModeleEtat.SelectedValue is C2iRapportCrystal))
            {
                m_wndListeVariables.Enabled  = false;
                m_txtFormuleVariable.Visible = false;
                return;
            }
            m_wndListeVariables.Enabled  = true;
            m_txtFormuleVariable.Visible = true;

            C2iRapportCrystal     etat           = (C2iRapportCrystal)m_comboModeleEtat.SelectedValue;
            CMultiStructureExport multiStructure = etat.MultiStructure;

            if (multiStructure == null)
            {
                m_wndListeVariables.Enabled  = false;
                m_txtFormuleVariable.Visible = false;
                return;
            }
            IElementAVariablesDynamiques element = multiStructure;
            ArrayList lst = new ArrayList(element.ListeVariables);

            for (int nVar = lst.Count - 1; nVar >= 0; nVar--)
            {
                if (!((IVariableDynamique)lst[nVar]).IsChoixUtilisateur())
                {
                    lst.RemoveAt(nVar);
                }
            }
            m_wndListeVariables.Remplir(lst, false);
            m_bListeVariablesRemplie = true;
        }
Пример #9
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);
        }
Пример #10
0
        /// //////////////////////////////////////////
        protected override void InitChamps()
        {
            base.InitChamps();
            m_wndAideFormule.FournisseurProprietes = ObjetEdite.Process;
            m_wndAideFormule.ObjetInterroge        = typeof(CProcess);

            m_txtFormuleCle.Init(m_wndAideFormule.FournisseurProprietes, m_wndAideFormule.ObjetInterroge);
            m_txtFormuleDescriptif.Init(m_wndAideFormule.FournisseurProprietes, m_wndAideFormule.ObjetInterroge);
            m_txtFormuleLibelle.Init(m_wndAideFormule.FournisseurProprietes, m_wndAideFormule.ObjetInterroge);
            m_txtFormuleVariable.Init(m_wndAideFormule.FournisseurProprietes, m_wndAideFormule.ObjetInterroge);

            CListeObjetsDonnees liste = new CListeObjetsDonnees(CSc2iWin32DataClient.ContexteCourant, typeof(CCategorieGED));

            m_wndListeCategories.Remplir(liste, false);
            foreach (ListViewItem item in m_wndListeCategories.Items)
            {
                CCategorieGED cat = (CCategorieGED)item.Tag;
                if (ActionGenererEtat.ListeIdsCategoriesStockage.Contains(cat.Id))
                {
                    item.Checked = true;
                }
                else
                {
                    item.Checked = false;
                }
            }

            liste = new CListeObjetsDonnees(CSc2iWin32DataClient.ContexteCourant, typeof(sc2i.documents.C2iRapportCrystal));
            m_comboModeleEtat.ListDonnees = liste;
            C2iRapportCrystal rapport = new C2iRapportCrystal(CSc2iWin32DataClient.ContexteCourant);

            m_tableIdVariableToFormule.Clear();
            if (rapport.ReadIfExists(ActionGenererEtat.IdEtatCrystal))
            {
                m_comboModeleEtat.SelectedValue = rapport;
                CMultiStructureExport multiStructure = rapport.MultiStructure;
                if (multiStructure != null)
                {
                    foreach (IVariableDynamique variable in multiStructure.ListeVariables)
                    {
                        m_tableIdVariableToFormule[variable.IdVariable] = ActionGenererEtat.GetExpressionForVariableFiltre(variable.IdVariable);
                    }
                }
            }
            else
            {
                m_comboModeleEtat.SelectedValue = null;
            }

            UpdateListeVariables();

            m_txtFormuleCle.Text        = ActionGenererEtat.ExpressionCle.GetString();
            m_txtFormuleDescriptif.Text = ActionGenererEtat.ExpressionDescriptif.GetString();
            m_txtFormuleLibelle.Text    = ActionGenererEtat.ExpressionLibelle.GetString();

            m_cmbFormat.DisplayMember = "Libelle";
            m_cmbFormat.ValueMember   = "Valeur";
            m_cmbFormat.DataSource    = CUtilSurEnum.GetCouplesFromEnum(typeof(TypeFormatExportCrystal));

            m_cmbFormat.SelectedValue = (int)ActionGenererEtat.FormatExport;

            m_chkStocker.Checked  = ActionGenererEtat.StockerDansLaGed;
            m_chkImprimer.Checked = ActionGenererEtat.ImprimerSurClient;
        }
Пример #11
0
        /// ////////////////////////////////////////////////////////
        protected override CResultAErreur MySerialize(C2iSerializer serializer)
        {
            int            nVersion = GetNumVersion();
            CResultAErreur result   = serializer.TraiteVersion(ref nVersion);

            if (!result)
            {
                return(result);
            }
            result = base.MySerialize(serializer);
            if (!result)
            {
                return(result);
            }

            I2iSerializable objet = m_structureExport;

            result = serializer.TraiteObject(ref objet);
            if (!result)
            {
                return(result);
            }
            m_structureExport = (CMultiStructureExport)objet;

            objet  = m_expressionCleGED;
            result = serializer.TraiteObject(ref objet);
            if (!result)
            {
                return(result);
            }
            m_expressionCleGED = (C2iExpression )objet;

            objet  = m_expressionDescriptifDocument;
            result = serializer.TraiteObject(ref objet);
            if (!result)
            {
                return(result);
            }
            m_expressionDescriptifDocument = (C2iExpression )objet;

            objet  = m_expressionLibelleDocument;
            result = serializer.TraiteObject(ref objet);
            if (!result)
            {
                return(result);
            }
            m_expressionLibelleDocument = (C2iExpression )objet;


            int nNbCategories = m_listeIdsCategorieStockage.Count;

            serializer.TraiteInt(ref nNbCategories);
            switch (serializer.Mode)
            {
            case ModeSerialisation.Ecriture:
                foreach (int nIdCat in m_listeIdsCategorieStockage)
                {
                    int nTmp = nIdCat;
                    serializer.TraiteInt(ref nTmp);
                }
                break;

            case ModeSerialisation.Lecture:
                m_listeIdsCategorieStockage.Clear();
                for (int nVal = 0; nVal < nNbCategories; nVal++)
                {
                    int nTmp = 0;
                    serializer.TraiteInt(ref nTmp);
                    m_listeIdsCategorieStockage.Add(nTmp);
                }
                break;
            }

            objet  = (I2iSerializable)m_exporteur;
            result = serializer.TraiteObject(ref objet, new object[0]);
            if (!result)
            {
                return(result);
            }
            m_exporteur = (IExporteurDataset)objet;

            if (nVersion >= 1)
            {
                serializer.TraiteBool(ref m_bUtiliserFormule);
                result = serializer.TraiteObject <C2iExpression>(ref m_expressionSelectedStructure);
                if (!result)
                {
                    return(result);
                }
            }

            AssureVariableProcessDansStructure();
            return(result);
        }
Пример #12
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);
        }
Пример #13
0
        //----------------------------------------------------------------------
        private void Filtrer()
        {
            CResultAErreur result = CResultAErreur.True;

            using (new CWaitCursor())
            {
                CMultiStructureExport structure = m_rapport.MultiStructure;
                if (structure != null && m_panelFiltre.Visible == true)
                {
                    result = m_panelFiltre.AffecteValeursToElement();
                    if (!result)
                    {
                        CFormAlerte.Afficher(result.Erreur);
                    }
                    if (m_panelFiltre.ElementEdite != null)
                    {
                        structure = (CMultiStructureExport)m_panelFiltre.ElementEdite;
                    }
                }
                result = m_rapport.CreateReport(structure, m_fichierDonnees);

                /*
                 *      if ( m_rapport.Requete != null )
                 *      {
                 *              m_panelFiltre.AffecteValeursToElement();
                 *              C2iRequete requete = (C2iRequete)m_panelFiltre.ElementEdite;
                 *              result = m_rapport.CreateReport ( requete, m_fichierDonnees );
                 *      }
                 *      else
                 *      {
                 *              using ( CContexteDonnee contexte = new CContexteDonnee ( CSc2iWin32DataClient.ContexteCourant.IdSession, true, false) )
                 *              {
                 *                      contexte.EnforceConstraints = false;
                 *                      CListeObjetsDonnees liste = new CListeObjetsDonnees(contexte, m_rapport.TypeObjet );
                 *
                 *                      if (m_panelFiltre.Visible && m_panelFiltre.ElementEdite !=null)
                 *                      {
                 *                              m_panelFiltre.AffecteValeursToElement();
                 *                              CFiltreDynamique filtre  = (CFiltreDynamique)m_panelFiltre.ElementEdite;
                 *                              result = filtre.GetFiltreData();
                 *                              if (!result)
                 *                                      liste.Filtre = null;
                 *                              else
                 *                                      liste.Filtre = (CFiltreData) result.Data;
                 *                      }
                 *                      else
                 *                              liste.Filtre = null;
                 *
                 *                      result = m_rapport.CreateReport ( liste, (IElementAVariablesDynamiques)m_panelFiltre.ElementEdite, m_fichierDonnees );
                 *              }
                 *      }*/
                if (result)
                {
                    m_viewer.ReportSource = (ReportDocument)result.Data;
                    m_viewer.Refresh();
                }
                if (!result)
                {
                    CFormAlerte.Afficher(result.Erreur);
                }
            }
        }