Ejemplo n.º 1
0
        /// <summary>
        /// Retorna as configurações do servidor de relatório conforme o id do relatório da entidade do sistema.
        /// </summary>
        /// <param name="ent_id">Entidade em que o usuário está logado.</param>
        /// <returns>Servidor de relatório</returns>
        public CFG_ServidorRelatorio CarregarServidorRelatorioPorEntidade(Guid ent_id)
        {
            CFG_ServidorRelatorio      entity = new CFG_ServidorRelatorio();
            QuerySelectStoredProcedure qs     = new QuerySelectStoredProcedure("NEW_CFG_ServidorRelatorio_SelectBy_Entidade", _Banco);

            try
            {
                #region Parametros

                Param               = qs.NewParameter();
                Param.DbType        = DbType.Guid;
                Param.ParameterName = "@ent_id";
                Param.Size          = 16;
                Param.Value         = ent_id;
                qs.Parameters.Add(Param);

                #endregion Parametros

                qs.Execute();

                entity = (qs.Return.Rows.Count > 0) ? this.DataRowToEntity(qs.Return.Rows[0], entity, false) : null;

                return(entity);
            }
            finally
            {
                qs.Parameters.Clear();
            }
        }
Ejemplo n.º 2
0
    protected void _dgvServidor_RowCommand(object sender, GridViewCommandEventArgs e)
    {
        if (e.CommandName.Equals("Delete"))
        {
            try
            {
                int index = Convert.ToInt32(e.CommandArgument);

                if (index > 0)
                {
                    CFG_ServidorRelatorio entity = new CFG_ServidorRelatorio
                    {
                        sis_id = Convert.ToInt32(_dgvServidor.DataKeys[index]["sis_id"])
                        ,
                        ent_id = new Guid(_dgvServidor.DataKeys[index]["ent_id"].ToString())
                        ,
                        srr_id = Convert.ToInt32(_dgvServidor.DataKeys[index]["sis_id"])
                    };

                    if (CFG_ServidorRelatorioBO.Delete(entity))
                    {
                        _lblMessage.Text = UtilBO.GetErroMessage("Configurações do servidor de relatórios excluído com sucesso.", UtilBO.TipoMensagem.Sucesso);
                        ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Delete, String.Format("sis_id: {0}, ent_id: {1}, srr_id: {2}", entity.sis_id, entity.ent_id, entity.srr_id));
                    }
                }
            }
            catch (Exception ex)
            {
                _lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar excluir configurações do servidor de relatórios.", UtilBO.TipoMensagem.Erro);
                ApplicationWEB._GravaErro(ex);
            }
        }
    }
        /// <summary>
        /// Deleta todos os relatórios relacionados à um determinado servidor.
        /// </summary>
        /// <param name="srr">Servidor de relatório</param>
        /// <returns>Booleano</returns>
        public bool DeleteAll(CFG_ServidorRelatorio srr)
        {
            QuerySelectStoredProcedure qs = new QuerySelectStoredProcedure("NEW_CFG_RelatorioServidorRelatorio_DELETE_ALL", _Banco);

            try
            {
                #region Parametros

                Param               = qs.NewParameter();
                Param.DbType        = DbType.Guid;
                Param.ParameterName = "@ent_id";
                Param.Size          = 16;
                Param.Value         = srr.ent_id;
                qs.Parameters.Add(Param);

                Param               = qs.NewParameter();
                Param.DbType        = DbType.Int32;
                Param.ParameterName = "@srr_id";
                Param.Size          = 4;
                Param.Value         = srr.srr_id;
                qs.Parameters.Add(Param);

                #endregion Parametros

                qs.Execute();

                return(qs.Return.Rows.Count > 0);
            }
            finally
            {
                qs.Parameters.Clear();
            }
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Salva a configuração de servidor de relatórios
        /// </summary>
        private void Salvar()
        {
            try
            {
                CFG_ServidorRelatorio srr = new CFG_ServidorRelatorio()
                {
                    ent_id = _VS_ent_id
                    ,
                    srr_id = _VS_srr_id
                    ,
                    srr_nome = txtNomeServidor.Text
                    ,
                    srr_descricao = txtDescricaoServidor.Text
                    ,
                    srr_remoteServer = (ddlLocalProcessamento.SelectedIndex == 1)
                    ,
                    srr_usuario = txtUsuario.Text
                    ,
                    srr_dominio = txtDominio.Text
                    ,
                    srr_senha = chkAlterarSenha.Checked ? UtilBO.CriptografarSenha(txtSenha.Text, eCriptografa.TripleDES) : String.Empty
                    ,
                    srr_diretorioRelatorios = txtUrlRelatorios.Text
                    ,
                    srr_pastaRelatorios = txtPastaRelatorios.Text
                    ,
                    srr_situacao = Convert.ToInt16(ddlSituacao.SelectedIndex + 1)
                };

                List <CFG_RelatorioServidorRelatorio> relatorios =
                    (from ListItem row in chkRelatorios.Items
                     let rlt = row.Value.ToString().Split(';')
                               where row.Selected
                               select new CFG_RelatorioServidorRelatorio
                {
                    ent_id = srr.ent_id
                    ,
                    srr_id = srr.srr_id
                    ,
                    rlt_id = Convert.ToInt32(rlt[0])
                    ,
                    IsNew = true
                }
                    ).ToList();

                if (CFG_ServidorRelatorioBO.SalvarServidorRelatorio(srr, relatorios))
                {
                    lblMensagemErro.Text = UtilBO.GetErroMessage("Servidor de relatórios salvo com sucesso.", UtilBO.TipoMensagem.Sucesso);
                    AlterarCheckSenha(false);
                    ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Update, "ent_id: " + _VS_ent_id.ToString() + " , srr_id: " + _VS_srr_id);
                }
            }
            catch (Exception ex)
            {
                ApplicationWEB._GravaErro(ex);
                lblMensagemErro.Text = UtilBO.GetErroMessage("Erro ao tentar salvar o servidor de relatórios.",
                                                             UtilBO.TipoMensagem.Erro);
            }
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Deleta todos os relatórios relacionados à um determinado servidor.
        /// </summary>
        /// <param name="ent_id">Entidade do usuário logado</param>
        /// <param name="srr_id">ID Servidor de relatórios</param>
        /// <returns>Booleano</returns>
        public static bool DeletarRelatoriosPorEntidadeServidor(CFG_ServidorRelatorio srr, TalkDBTransaction banco)
        {
            CFG_RelatorioServidorRelatorioDAO dao = new CFG_RelatorioServidorRelatorioDAO()
            {
                _Banco = banco
            };

            return(dao.DeleteAll(srr));
        }
Ejemplo n.º 6
0
    /// <summary>
    /// Carrega os controles da página no caso de edição dos dados.
    /// </summary>
    protected void _LoadData()
    {
        this._VS_srr_id = PreviousPage._Param_srr_id;
        this._ddlSistema.SelectedValue = PreviousPage._Param_sis_id.ToString();
        this._ddlSistema.Enabled       = false;
        this.divSenha.Visible          = false;

        CFG_ServidorRelatorio srv = new CFG_ServidorRelatorio()
        {
            ent_id = this.__SessionWEB.__UsuarioWEB.Usuario.ent_id,
            sis_id = PreviousPage._Param_sis_id,
            srr_id = this._VS_srr_id
        };

        CFG_ServidorRelatorioBO.GetEntity(srv);
        this._txtNome.Text      = srv.srr_nome;
        this._txtDescricao.Text = srv.srr_descricao;
        if (!srv.srr_remoteServer)
        {
            this._ddlLocalProcessamento.SelectedValue = "false";
            this.divRemoteReport.Visible = false;
        }
        else
        {
            this._txtUsuario.Text       = srv.srr_usuario;
            this._txtDominio.Text       = srv.srr_dominio;
            this._txtUrlRelatorios.Text = srv.srr_diretorioRelatorios;
        }
        this._txtPastaRelatorios.Text   = srv.srr_pastaRelatorios;
        this._ddlSituacao.SelectedValue = srv.srr_situacao.ToString();
        /* Carrega a lista de relatórios selecionados para o servidor */
        this._chkRelatorios.DataBind();
        IList <CFG_RelatorioServidorRelatorio> ltRelatorioAssociados = CFG_ServidorRelatorioBO.ListarRelatorioDoServidor(srv.ent_id, srv.sis_id, srv.srr_id);

        foreach (ListItem item in this._chkRelatorios.Items)
        {
            foreach (CFG_RelatorioServidorRelatorio rel in ltRelatorioAssociados)
            {
                if (rel.rlt_id.Equals(int.Parse(item.Value)))
                {
                    item.Selected = true;
                    break;
                }
            }
        }
    }
Ejemplo n.º 7
0
        /// <summary>
        /// Retorna um objeto da classe CFG_ServidorRelatorio carregado com os dados do servidor
        /// de relatório conforme o id da entidade, id do sistema e id do relatório. Caso o relatório
        /// esteja ligado a mais de um servidor de relatório para a entidade do sistema a query
        /// seleciona randomicamente qual servidor será preenchido na instância da classe.
        /// MÉTODO(S) DEPENDENTE(S):
        /// 1 - Classe: CFG_ServidorRelatorioBO; Método: CarregarCrendencialServidorPorRelatorio
        /// </summary>
        /// <param name="ent_id">id da entidade.</param>
        /// <param name="sis_id">id do sistema.</param>
        /// <param name="rlt_id">id do relatório.</param>
        /// <returns>Retorna o objeto da classe preenchido com os dados do servidor de relatórios.</returns>
        public CFG_ServidorRelatorio CarregarPorIdRelatorioSistema(Guid ent_id, int sis_id, int rlt_id)
        {
            CFG_ServidorRelatorio      entity = new CFG_ServidorRelatorio();
            QuerySelectStoredProcedure qs     = new QuerySelectStoredProcedure("NEW_CFG_ServidorRelatorio_LOADBY_idRelatorioSistema", this._Banco);

            try
            {
                #region PARAMETROS

                Param               = qs.NewParameter();
                Param.DbType        = DbType.Guid;
                Param.ParameterName = "@ent_id";
                Param.Size          = 16;
                Param.Value         = ent_id;
                qs.Parameters.Add(Param);

                Param               = qs.NewParameter();
                Param.DbType        = DbType.Int32;
                Param.ParameterName = "@sis_id";
                Param.Size          = 4;
                Param.Value         = sis_id;
                qs.Parameters.Add(Param);

                Param               = qs.NewParameter();
                Param.DbType        = DbType.Int32;
                Param.ParameterName = "@rlt_id";
                Param.Size          = 4;
                Param.Value         = rlt_id;
                qs.Parameters.Add(Param);

                #endregion

                qs.Execute();
                if (qs.Return.Rows.Count > 0)
                {
                    entity = this.DataRowToEntity(qs.Return.Rows[0], entity, false);
                }
                return(entity);
            }
            finally
            {
                qs.Parameters.Clear();
            }
        }
Ejemplo n.º 8
0
        /// <summary>
        /// Carrega os dados do servidor de relatórios
        /// </summary>
        private void CarregarEntidade()
        {
            _VS_ent_id = __SessionWEB.__UsuarioWEB.Usuario.ent_id;

            CFG_ServidorRelatorio srr = CFG_ServidorRelatorioBO.CarregarServidorRelatorioPorEntidade(_VS_ent_id);

            if (srr != null)
            {
                _VS_srr_id                          = srr.srr_id;
                txtNomeServidor.Text                = srr.srr_nome;
                txtDescricaoServidor.Text           = srr.srr_descricao;
                ddlLocalProcessamento.SelectedIndex = srr.srr_remoteServer ? 1 : 0;
                txtUsuario.Text                     = srr.srr_usuario;
                txtDominio.Text                     = srr.srr_dominio;
                txtUrlRelatorios.Text               = srr.srr_diretorioRelatorios;
                txtPastaRelatorios.Text             = srr.srr_pastaRelatorios;
                ddlSituacao.SelectedIndex           = (srr.srr_situacao - 1);
                AlterarSelecaoComboLocalProcessamento(srr.srr_remoteServer);
            }
            else
            {
                AlterarCheckSenha(true);
            }
        }
Ejemplo n.º 9
0
        /// <summary>
        /// Configura os parametros do metodo de Alterar
        /// </summary>
        /// <param name="qs">Objeto da Store Procedure</param>
        protected override void ParamAlterar(QueryStoredProcedure qs, CFG_ServidorRelatorio entity)
        {
            Param               = qs.NewParameter();
            Param.DbType        = DbType.Guid;
            Param.ParameterName = "@ent_id";
            Param.Size          = 16;
            Param.Value         = entity.ent_id;
            qs.Parameters.Add(Param);

            Param               = qs.NewParameter();
            Param.DbType        = DbType.Int32;
            Param.ParameterName = "@srr_id";
            Param.Size          = 4;
            Param.Value         = entity.srr_id;
            qs.Parameters.Add(Param);

            Param               = qs.NewParameter();
            Param.DbType        = DbType.AnsiString;
            Param.ParameterName = "@srr_nome";
            Param.Size          = 100;
            Param.Value         = entity.srr_nome;
            qs.Parameters.Add(Param);

            Param               = qs.NewParameter();
            Param.DbType        = DbType.AnsiString;
            Param.ParameterName = "@srr_descricao";
            Param.Size          = 1000;
            if (!string.IsNullOrEmpty(entity.srr_descricao))
            {
                Param.Value = entity.srr_descricao;
            }
            else
            {
                Param.Value = DBNull.Value;
            }
            qs.Parameters.Add(Param);

            Param               = qs.NewParameter();
            Param.DbType        = DbType.Boolean;
            Param.ParameterName = "@srr_remoteServer";
            Param.Size          = 1;
            Param.Value         = entity.srr_remoteServer;
            qs.Parameters.Add(Param);

            Param               = qs.NewParameter();
            Param.DbType        = DbType.AnsiString;
            Param.ParameterName = "@srr_usuario";
            Param.Size          = 512;
            if (!string.IsNullOrEmpty(entity.srr_usuario))
            {
                Param.Value = entity.srr_usuario;
            }
            else
            {
                Param.Value = DBNull.Value;
            }
            qs.Parameters.Add(Param);

            Param               = qs.NewParameter();
            Param.DbType        = DbType.AnsiString;
            Param.ParameterName = "@srr_senha";
            Param.Size          = 512;
            if (!string.IsNullOrEmpty(entity.srr_senha))
            {
                Param.Value = entity.srr_senha;
            }
            else
            {
                Param.Value = DBNull.Value;
            }
            qs.Parameters.Add(Param);

            Param               = qs.NewParameter();
            Param.DbType        = DbType.AnsiString;
            Param.ParameterName = "@srr_dominio";
            Param.Size          = 512;
            if (!string.IsNullOrEmpty(entity.srr_dominio))
            {
                Param.Value = entity.srr_dominio;
            }
            else
            {
                Param.Value = DBNull.Value;
            }
            qs.Parameters.Add(Param);

            Param               = qs.NewParameter();
            Param.DbType        = DbType.AnsiString;
            Param.ParameterName = "@srr_diretorioRelatorios";
            Param.Size          = 1000;
            if (!string.IsNullOrEmpty(entity.srr_diretorioRelatorios))
            {
                Param.Value = entity.srr_diretorioRelatorios;
            }
            else
            {
                Param.Value = DBNull.Value;
            }
            qs.Parameters.Add(Param);

            Param               = qs.NewParameter();
            Param.DbType        = DbType.AnsiString;
            Param.ParameterName = "@srr_pastaRelatorios";
            Param.Size          = 1000;
            Param.Value         = entity.srr_pastaRelatorios;
            qs.Parameters.Add(Param);

            Param               = qs.NewParameter();
            Param.DbType        = DbType.Byte;
            Param.ParameterName = "@srr_situacao";
            Param.Size          = 1;
            Param.Value         = entity.srr_situacao;
            qs.Parameters.Add(Param);

            Param               = qs.NewParameter();
            Param.DbType        = DbType.DateTime;
            Param.ParameterName = "@srr_dataAlteracao";
            Param.Size          = 16;
            Param.Value         = DateTime.Now;
            qs.Parameters.Add(Param);
        }
Ejemplo n.º 10
0
 /// <summary>
 /// Inseri os valores da classe em um registro ja existente
 /// </summary>
 /// <param name="entity">Entidade com os dados a serem modificados</param>
 /// <returns>True - Operacao bem sucedida</returns>
 protected override bool Alterar(CFG_ServidorRelatorio entity)
 {
     this.__STP_UPDATE = "NEW_CFG_ServidorRelatorio_UPDATE";
     return(base.Alterar(entity));
 }
Ejemplo n.º 11
0
 /// <summary>
 /// Exclui um registro do banco
 /// </summary>
 /// <param name="entity">Entidade com os dados a serem apagados</param>
 /// <returns>True - Operacao bem sucedida</returns>
 public override bool Delete(CFG_ServidorRelatorio entity)
 {
     this.__STP_DELETE = "NEW_CFG_ServidorRelatorio_DELETE";
     return(base.Delete(entity));
 }
Ejemplo n.º 12
0
        public void ProcessRequest(HttpContext context)
        {
            if (context.Request.IsAuthenticated)
            {
                try
                {
                    var tipRel        = HttpUtility.UrlDecode(HttpContext.Current.Request["tipRel"]);
                    var parametrosRel = HttpUtility.UrlDecode(HttpContext.Current.Request["params"]);
                    int rlt_id;

                    if (int.TryParse(tipRel, out rlt_id))
                    {
                        string    mimeType;
                        string    encoding;
                        string    fileNameExtension;
                        Warning[] warnings;
                        string[]  streamids;
                        byte[]    exportBytes;

                        //Recebe os dados do relatório
                        CFG_Relatorio rpt = new CFG_Relatorio()
                        {
                            rlt_id = rlt_id
                        };
                        CFG_RelatorioBO.GetEntity(rpt);
                        if (rpt.IsNew)
                        {
                            throw new ValidationException("Relatório não encontrado.");
                        }
                        //Configurações do Relatório
                        CFG_ServidorRelatorio rptServer = CFG_ServidorRelatorioBO.CarregarServidorRelatorioPorEntidade(
                            this.__SessionWEB.__UsuarioWEB.Usuario.ent_id
                            , ApplicationWEB.AppMinutosCacheLongo
                            );

                        if (rptServer.IsNew)
                        {
                            throw new ValidationException("O servidor de relatório não está configurado.");
                        }

                        //Carrega os parâmetros do relatório
                        MSReportServerParameters param = new MSReportServerParameters(parametrosRel);
                        //Checa o modo de processamento do servidor
                        if (rptServer.srr_remoteServer)
                        {
                            Microsoft.Reporting.WebForms.ReportViewer ReportViewerRel = new Microsoft.Reporting.WebForms.ReportViewer();

                            //Configura o reportviewer
                            ReportViewerRel.ProcessingMode = Microsoft.Reporting.WebForms.ProcessingMode.Remote;
                            Uri urlReport = new Uri(rptServer.srr_diretorioRelatorios);
                            ReportViewerRel.ServerReport.ReportServerUrl         = urlReport;
                            ReportViewerRel.ServerReport.ReportServerCredentials = new MSReportServerCredentials(rptServer.srr_usuario, rptServer.srr_senha, rptServer.srr_dominio);
                            ReportViewerRel.ServerReport.ReportPath = String.Concat(rptServer.srr_pastaRelatorios, rpt.rlt_nome);
                            ReportViewerRel.ServerReport.SetParameters(param.getReportParameters());

                            //Carrega o relatório
                            exportBytes = ReportViewerRel.ServerReport.Render("PDF", null, out mimeType, out encoding, out fileNameExtension, out streamids, out warnings);


                            #region PDF Sharp
                            //MemoryStream fs = new MemoryStream(exportBytes);
                            //PdfDocument document = PdfReader.Open(fs, PdfDocumentOpenMode.Modify);
                            //PdfDictionary dictJS = new PdfDictionary(document);
                            //dictJS.Elements["/S"] = new PdfName("/JavaScript");
                            //dictJS.Elements["/JS"] = new PdfString("this.print(true);\r");

                            //document.Internals.AddObject(dictJS);
                            //document.Internals.Catalog.Elements["/OpenAction"] = PdfInternals.GetReference(dictJS);


                            //MemoryStream ms = new MemoryStream();
                            //document.Save(ms, false);

                            #endregion

                            #region ITextSharp

                            MemoryStream ms = new MemoryStream();

                            PdfReader reader   = new PdfReader(exportBytes);
                            Document  document = null;
                            PdfCopy   writer   = null;
                            int       n        = reader.NumberOfPages;

                            document = new Document(reader.GetPageSizeWithRotation(1));
                            writer   = new PdfCopy(document, ms);
                            document.Open();
                            PdfImportedPage page;
                            for (int i = 0; i < n;)
                            {
                                ++i;
                                page = writer.GetImportedPage(reader, i);
                                writer.AddPage(page);
                            }
                            PdfAction jAction = PdfAction.JavaScript("this.print(true);\r", writer);
                            writer.AddJavaScript(jAction);

                            document.Close();
                            writer.Close();

                            #endregion

                            HttpResponse response = HttpContext.Current.Response;
                            response.ClearContent();
                            response.ClearHeaders();
                            response.Buffer = true;
                            response.Cache.SetCacheability(HttpCacheability.Private);
                            response.ContentType = "application/pdf";

                            response.AddHeader("Content-Disposition", "inline;");
                            response.BinaryWrite(ms.ToArray());
                            ms.Close();
                            HttpContext.Current.ApplicationInstance.CompleteRequest();

                            response.End();
                        }
                    }
                }
                catch (ThreadAbortException)
                {
                }
                catch (Exception ex)
                {
                    MSTech.GestaoEscolar.Web.WebProject.ApplicationWEB._GravaErro(ex);
                }
            }
        }
Ejemplo n.º 13
0
    protected void Page_Load(object sender, EventArgs e)
    {
        try
        {
            if (!IsPostBack)
            {
                //recebe valores da sessão e grava em variáveis
                string tipoRel       = CFG_RelatorioBO.CurrentReportID;
                string parametrosRel = CFG_RelatorioBO.CurrentReportParameters;

                if (!String.IsNullOrEmpty(tipoRel))
                {
                    this.QueryStringUrlReports = "tipRel=" + HttpUtility.UrlEncode(tipoRel) + "&params=" + HttpUtility.UrlEncode(parametrosRel);

                    //remove os valores da sessão
                    CFG_RelatorioBO.ClearSessionReportParameters();
                    //Recebe os dados do relatório
                    CFG_Relatorio rpt = new CFG_Relatorio()
                    {
                        rlt_id = int.Parse(tipoRel)
                    };
                    CFG_RelatorioBO.GetEntity(rpt);
                    if (rpt.IsNew)
                    {
                        throw new ValidationException("Relatório não encontrado.");
                    }
                    //Configurações do Relatório
                    CFG_ServidorRelatorio rptServer = CFG_ServidorRelatorioBO.CarregarServidorRelatorioPorEntidade(
                        this.__SessionWEB.__UsuarioWEB.Usuario.ent_id
                        , ApplicationWEB.AppMinutosCacheLongo
                        );

                    if (rptServer.IsNew)
                    {
                        throw new ValidationException("O servidor de relatório não está configurado.");
                    }

                    VerificaAtributosReport(rpt.rlt_id);

                    //Carrega os parâmetros do relatório
                    MSReportServerParameters param = new MSReportServerParameters(parametrosRel);

                    //Verifica se está Habilitada a impressão sem activeX
                    bool bHabilitarImpressaoRel = ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.HABILITA_IMPRESSAO_RELATORIO
                                                                                                             , __SessionWEB.__UsuarioWEB.Usuario.ent_id);

                    this.HabilitarImpressaoRel      = bHabilitarImpressaoRel;
                    divPdf.Visible                  = bHabilitarImpressaoRel;
                    ReportViewerRel.ShowPrintButton = !bHabilitarImpressaoRel;

                    //Verifica se usuário vizualizará algum relatório da aba 'DOCUMENTOS'
                    if (_VS_TipoRelatorio == tipoRelatorio.Documento)
                    {
                        // Habilita ou desabilita, conforme configuração do parâmetro HABILITA_EXPORTACAO_IMPRESSAO_DOCUMENTOS, se vai ter botão de exportar documento no ReportView.
                        ReportViewerRel.ShowExportControls = ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.HABILITA_EXPORTACAO_IMPRESSAO_DOCUMENTOS
                                                                                                                        , __SessionWEB.__UsuarioWEB.Usuario.ent_id);
                    }

                    //Checa o modo de processamento do servidor
                    if (rptServer.srr_remoteServer)
                    {
                        //Configura o reportviewer
                        ReportViewerRel.ProcessingMode = Microsoft.Reporting.WebForms.ProcessingMode.Remote;
                        Uri urlReport = new Uri(rptServer.srr_diretorioRelatorios);
                        ReportViewerRel.ServerReport.ReportServerUrl         = urlReport;
                        ReportViewerRel.ServerReport.ReportServerCredentials = new MSReportServerCredentials(rptServer.srr_usuario, rptServer.srr_senha, rptServer.srr_dominio);
                        ReportViewerRel.ServerReport.ReportPath = String.Concat(rptServer.srr_pastaRelatorios, rpt.rlt_nome);
                        ReportViewerRel.ServerReport.SetParameters(param.getReportParameters());
                        //Recebe as configurações do delegate
                        ConfigRemoteRerpotViewerEvent configRemoteRerpotViewer = Events[ConfigRemoteRerpotViewerKey] as ConfigRemoteRerpotViewerEvent;
                        if (configRemoteRerpotViewer != null)
                        {
                            configRemoteRerpotViewer(ReportViewerRel);
                        }
                        //Carrega o relatório
                        ReportViewerRel.ServerReport.Refresh();
                    }
                    else
                    {
                        //Configura o reportviewer
                        ReportViewerRel.ProcessingMode         = Microsoft.Reporting.WebForms.ProcessingMode.Local;
                        ReportViewerRel.LocalReport.ReportPath = String.Concat(rptServer.srr_pastaRelatorios, rpt.rlt_nome);
                        ReportViewerRel.LocalReport.SetParameters(param.getReportParameters());
                        //Recebe as configurações do delegate
                        ConfigLocalRerpotViewerEvent configLocalRerpotViewer = Events[ConfigLocalRerpotViewerKey] as ConfigLocalRerpotViewerEvent;
                        if (configLocalRerpotViewer != null)
                        {
                            configLocalRerpotViewer(ReportViewerRel);
                        }
                        //Carrega o relatório
                        ReportViewerRel.LocalReport.Refresh();
                    }
                }
                else
                {
                    string nome = _VS_TipoRelatorio == tipoRelatorio.Relatorio ? "relatório" : "documento";
                    _lblMensagem.Text = UtilBO.GetErroMessage("Não foi possível carregar o " + nome + ". Tipo de relatório indisponível.", UtilBO.TipoMensagem.Informacao);
                }
            }

            this.Page.ClientScript.RegisterClientScriptBlock(this.Page.GetType(), "reports", " var query= '" + this.QueryStringUrlReports + "';", true);
        }
        catch (ValidationException ex)
        {
            this._TrataErro(ex, ex.Message);
        }
        catch (Exception ex)
        {
            string nome = _VS_TipoRelatorio == tipoRelatorio.Relatorio ? "relatório" : "documento";
            this._TrataErro(ex, "Recurso indisponível ao exibir o " + nome + ".");
        }
    }
Ejemplo n.º 14
0
    protected void _Salvar()
    {
        if (this._IsValid())
        {
            CFG_ServidorRelatorioDAO dal = new CFG_ServidorRelatorioDAO();
            dal._Banco.Open(IsolationLevel.RepeatableRead);
            try
            {
                /* Remove os valores dos campos exclusivo para servidores do tipo remoto */
                if (!this.divRemoteReport.Visible)
                {
                    this._txtUsuario.Text       = String.Empty;
                    this._txtSenha.Text         = String.Empty;
                    this._txtConfirmaSenha.Text = String.Empty;
                    this._txtDominio.Text       = String.Empty;
                    this._txtUrlRelatorios.Text = String.Empty;
                }
                /* Preenche o objeto a ser salvo */
                CFG_ServidorRelatorio srv = new CFG_ServidorRelatorio()
                {
                    ent_id = this.__SessionWEB.__UsuarioWEB.Usuario.ent_id,
                    sis_id = Convert.ToInt32(this._ddlSistema.SelectedValue),
                    srr_id = this._VS_srr_id
                };
                /* Caso o usuário queira alterar a senha */
                if ((!this._chkAlterarSenha.Visible) || (this._chkAlterarSenha.Checked))
                {
                    SymmetricAlgorithm encript = new SymmetricAlgorithm(CoreLibrary.Security.Cryptography.SymmetricAlgorithm.Tipo.TripleDES);
                    srv.srr_senha = encript.Encrypt(this._txtSenha.Text);
                }
                else
                {
                    CFG_ServidorRelatorioBO.GetEntity(srv);
                }

                srv.srr_nome                = this._txtNome.Text;
                srv.srr_descricao           = this._txtDescricao.Text;
                srv.srr_remoteServer        = Convert.ToBoolean(this._ddlLocalProcessamento.SelectedValue);
                srv.srr_usuario             = this._txtUsuario.Text;
                srv.srr_dominio             = this._txtDominio.Text;
                srv.srr_diretorioRelatorios = this._txtUrlRelatorios.Text;
                srv.srr_pastaRelatorios     = this._txtPastaRelatorios.Text;
                srv.srr_situacao            = Convert.ToByte(this._ddlSituacao.SelectedValue);
                srv.srr_dataCriacao         = DateTime.Now;
                srv.srr_dataAlteracao       = DateTime.Now;
                srv.IsNew = (this._VS_srr_id.Equals(-1));
                bool ret = CFG_ServidorRelatorioBO.Save(srv, dal._Banco);
                if (ret)
                {
                    /* Insere os relatório pertencentes ao servidor de relatório a uma lista */
                    IList <CFG_RelatorioServidorRelatorio> lt = (from item in this._chkRelatorios.Items.Cast <ListItem>()
                                                                 where item.Selected
                                                                 select new CFG_RelatorioServidorRelatorio()
                    {
                        sis_id = srv.sis_id, ent_id = srv.ent_id, srr_id = srv.srr_id, rlt_id = int.Parse(item.Value)
                    }).ToList();
                    if (lt.Count > 0)
                    {
                        CFG_ServidorRelatorioBO.SalvarRelatoriosDoServidor(lt, dal._Banco);
                    }
                    else
                    {
                        CFG_ServidorRelatorioBO.ApagarTodosRelatoriosServidor(srv.ent_id, srv.sis_id, srv.srr_id, dal._Banco);
                    }
                }
            }
            catch (Exception err)
            {
                dal._Banco.Close(err);
                throw;
            }
            finally
            {
                dal._Banco.Close();
                this.ConfigDivSalvarDados();
            }
        }
    }