Beispiel #1
0
 public void Atualizar(IUnitOfWork unitOfWork, Laudo laudo)
 {
     PersistenceBroker.Atualizar(unitOfWork, laudo);
 }
Beispiel #2
0
        internal Laudo ObterDadosPDF(int titulo, BancoDeDados banco = null)
        {
            Laudo laudo = new Laudo();

            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                #region Dados do Titulo

                DadosPDF dados = DaEsp.ObterDadosTitulo(titulo, bancoDeDados);
                laudo.Titulo         = dados.Titulo;
                laudo.Protocolo      = dados.Protocolo;
                laudo.Empreendimento = dados.Empreendimento;

                #endregion

                #region Dados da Especificidade

                Comando comando = bancoDeDados.CriarComando(@"select destinatario, data_vistoria from {0}esp_laudo_vistoria_fundiaria e where e.titulo = :id", EsquemaBanco);

                comando.AdicionarParametroEntrada("id", titulo, DbType.Int32);

                using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
                {
                    if (reader.Read())
                    {
                        laudo.Destinatario.Id = Convert.ToInt32(reader["destinatario"]);

                        if (reader["data_vistoria"] != null && !Convert.IsDBNull(reader["data_vistoria"]))
                        {
                            laudo.DataVistoria = Convert.ToDateTime(reader["data_vistoria"]).ToShortDateString();
                        }
                    }

                    reader.Close();
                }

                comando = bancoDeDados.CriarComando(@"select d.id, d.numero_ccri, d.data_ultima_atualizacao, d.area_ccri, d.confrontante_norte, d.confrontante_sul, 
				d.confrontante_leste, d.confrontante_oeste from {0}esp_laudo_vistoria_fundiaria e, {0}crt_regularizacao_dominio r, {0}crt_dominialidade_dominio d
				where e.regularizacao_dominio = r.id and r.dominio = d.id and e.titulo = :titulo"                , EsquemaBanco);

                comando.AdicionarParametroEntrada("titulo", titulo, DbType.Int32);

                using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
                {
                    if (reader.Read())
                    {
                        laudo.Dominio = new DominioPDF
                        {
                            Id                = reader.GetValue <int>("id"),
                            NumeroCCIR        = reader.GetValue <long>("numero_ccri"),
                            DataAtualizacao   = reader.GetValue <string>("data_ultima_atualizacao"),
                            AreaCCIRDecimal   = reader.GetValue <decimal>("area_ccri"),
                            ConfrontacaoNorte = reader.GetValue <string>("confrontante_norte"),
                            ConfrontacaoSul   = reader.GetValue <string>("confrontante_sul"),
                            ConfrontacaoLeste = reader.GetValue <string>("confrontante_leste"),
                            ConfrontacaoOeste = reader.GetValue <string>("confrontante_oeste")
                        };
                    }

                    reader.Close();
                }

                #endregion

                laudo.Destinatario = DaEsp.ObterDadosPessoa(laudo.Destinatario.Id, laudo.Empreendimento.Id, bancoDeDados);

                laudo.AnaliseItens = DaEsp.ObterAnaliseItem(laudo.Protocolo.Id.GetValueOrDefault(), bancoDeDados);
            }

            return(laudo);
        }
Beispiel #3
0
 public void Salvar(IUnitOfWork unitOfWork, Laudo laudo)
 {
     PersistenceBroker.Salvar(unitOfWork, laudo);
 }
        public override IConfiguradorPdf ObterConfiguradorPdf(IEspecificidade especificidade)
        {
            ConfiguracaoDefault conf = new ConfiguracaoDefault();

            conf.AddLoadAcao((doc, dataSource) =>
            {
                Laudo laudo = dataSource as Laudo;
                List <Table> itenRemover = new List <Table>();
                conf.CabecalhoRodape     = CabecalhoRodapeFactory.Criar(especificidade.Titulo.SetorId);

                switch ((eCaracterizacao)laudo.CaracterizacaoTipo)
                {
                case eCaracterizacao.ExploracaoFlorestal:
                case eCaracterizacao.QueimaControlada:
                    itenRemover.Add(doc.FindTable("«Silvicultura.AreaTotalHa»"));
                    itenRemover.Add(doc.FindTable("«TableStart:QueimaControlada.TipoQueima»"));
                    break;

                case eCaracterizacao.Silvicultura:
                    //Removendo Exploracao
                    itenRemover.Add(doc.FindTable("FINALIDADE DA EXPLORAÇÃO"));

                    //Removendo Queima Controlada
                    itenRemover.Add(doc.LastTable("«TableStart:QueimaControlada.QueimasContr"));
                    break;
                }

                #region Queima Controlada

                if (laudo.CaracterizacaoTipo == (int)eCaracterizacao.QueimaControlada ||
                    (laudo.Titulo.ModeloSigla == "LVQC" && laudo.CaracterizacaoTipo == (int)eCaracterizacao.ExploracaoFlorestal))
                {
                    if (laudo.QueimaControlada.QueimasControladas.Count <= 0)
                    {
                        itenRemover.Add(doc.LastTable("«TableStart:QueimaControlada.QueimasContr"));
                    }

                    itenRemover.Add(doc.LastTable("«TableStart:ExploracaoFlorestal.CorteRaso"));
                    itenRemover.Add(doc.LastTable("«TableStart:ExploracaoFlorestal.CorteSele"));
                    itenRemover.Add(doc.FindTable("FINALIDADE DA EXPLORAÇÃO"));
                }
                #endregion

                #region Exploração Florestal

                else if (laudo.CaracterizacaoTipo == (int)eCaracterizacao.ExploracaoFlorestal)
                {
                    if (laudo.ExploracaoFlorestalList.Count <= 0)
                    {
                        itenRemover.Add(doc.LastTable("«TableStart:ExploracaoFlorestalList"));
                    }

                    if (string.IsNullOrWhiteSpace(laudo.ParecerFavoravel))
                    {
                        itenRemover.Add(doc.LastTable("«DescricaoParecer»"));
                    }

                    if (string.IsNullOrWhiteSpace(laudo.ParecerDesfavoravel))
                    {
                        itenRemover.Add(doc.LastTable("«DescricaoParecerDesfavoravel»"));
                    }
                }

                #endregion

                #region Silvicultura

                else if (laudo.CaracterizacaoTipo == (int)eCaracterizacao.Silvicultura)
                {
                    if (laudo.Silvicultura.Culturas.Count <= 0)
                    {
                        //itenRemover.Add(doc.LastTable("«TableStart:QueimaControlada.QueimasContr"));
                    }
                }

                #endregion

                if (string.IsNullOrEmpty(laudo.Restricao))
                {
                    itenRemover.Add(doc.LastTable("«Restricao»"));
                }

                if (laudo.Anexos.Count <= 0)
                {
                    doc.FindTable("«TableStart:Anexos»").RemovePageBreakAnterior();
                    itenRemover.Add(doc.FindTable("«TableStart:Anexos»"));
                }

                if (laudo.AnaliseItens.Count <= 0)
                {
                    itenRemover.Add(doc.LastTable("RESULTADO DA ANÁLISE"));
                }
                else
                {
                    itenRemover.Add(doc.LastTable("Não realizada"));
                }



                if (String.IsNullOrWhiteSpace(laudo.Responsavel.NomeRazaoSocial))
                {
                    itenRemover.Add(doc.LastTable("«Responsavel.NomeRazaoSocial»"));
                }
                else
                {
                    itenRemover.Add(doc.LastTable("Não possui responsável técnico"));
                }

                AsposeExtensoes.RemoveTables(itenRemover);
            });

            return(conf);
        }
        public override IConfiguradorPdf ObterConfiguradorPdf(IEspecificidade especificidade)
        {
            ConfiguracaoDefault conf = new ConfiguracaoDefault();

            conf.AddLoadAcao((doc, dataSource) =>
            {
                Laudo laudo = dataSource as Laudo;
                List <Table> itenRemover = new List <Table>();
                conf.CabecalhoRodape     = CabecalhoRodapeFactory.Criar(especificidade.Titulo.SetorId);

                if (laudo.AnaliseItens.Count <= 0)
                {
                    itenRemover.Add(doc.LastTable("RESULTADO DA ANÁLISE"));
                }
                else
                {
                    itenRemover.Add(doc.LastTable("Não realizada"));
                }

                foreach (var item in laudo.RegularizacaoFundiaria.Posses)
                {
                    if (item.Matriculas.Count <= 0)
                    {
                        item.Matriculas.Add(new DominioPDF()
                        {
                            Matricula = "«remover»"
                        });
                    }
                    else
                    {
                        item.NaoPossuiAreaTituladaAnexa = "«remover»";
                    }

                    if (item.Transmitentes.Count <= 0)
                    {
                        item.Transmitentes.Add(new TransmitentePDF()
                        {
                            NomeRazaoSocial = "«remover»"
                        });
                    }
                    else
                    {
                        item.NaoPossuiTransmitentes = "«remover»";
                    }

                    if (item.Edificacoes.Count <= 0)
                    {
                        item.Edificacoes.Add(new EdificacaoPDF()
                        {
                            Tipo = "«remover»"
                        });
                    }
                    else
                    {
                        item.NaoPossuiEdificacoes = "«remover»";
                    }

                    if (item.Zona == (int)eZonaLocalizacao.Rural)
                    {
                        item.Calcada = "«remover»";
                    }

                    if (item.Zona == (int)eZonaLocalizacao.Urbana)
                    {
                        item.BanhadoPorRioCorrego = "«remover»";
                    }
                }

                doc.RemovePageBreak();

                AsposeExtensoes.RemoveTables(itenRemover);
            });

            conf.AddExecutedAcao((doc, datasource) =>
            {
                Table tabela = doc.LastTable("«remover»");

                while (tabela != null)
                {
                    AsposeExtensoes.RemoveTable(tabela);
                    tabela = doc.LastTable("«remover»");
                }

                doc.RemovePageBreak();
            });

            return(conf);
        }
        public object ObterDadosPdf(IEspecificidade especificidade, BancoDeDados banco)
        {
            try
            {
                Laudo laudo = _da.ObterDadosPDF(especificidade.Titulo.Id, banco);
                DataEmissaoPorExtenso(laudo.Titulo);

                #region Anexos

                laudo.AnexosPdfs = laudo.Anexos
                                   .Select(x => x.Arquivo)
                                   .Where(x => (!String.IsNullOrEmpty(x.Nome) && new FileInfo(x.Nome).Extension.ToLower().IndexOf("pdf") > -1)).ToList();

                laudo.Anexos.RemoveAll(anexo =>
                                       String.IsNullOrEmpty(anexo.Arquivo.Extensao) ||
                                       !((new[] { ".jpg", ".gif", ".png", ".bmp" }).Any(x => anexo.Arquivo.Extensao.ToLower() == x)));

                if (laudo.Anexos != null && laudo.Anexos.Count > 0)
                {
                    foreach (AnexoPDF anexo in laudo.Anexos)
                    {
                        anexo.Arquivo.Conteudo = AsposeImage.RedimensionarImagem(
                            File.ReadAllBytes(anexo.Arquivo.Caminho),
                            11, eAsposeImageDimensao.Ambos);
                    }
                }

                #endregion

                laudo.Dominialidade = new DominialidadePDF(new DominialidadeBus().ObterPorEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault()));

                if (laudo.CaracterizacaoTipo == (int)eCaracterizacao.ExploracaoFlorestal)
                {
                    var exploracoes = new ExploracaoFlorestalBus().ObterExploracoes(especificidade.Titulo.Id, (int)eTituloModeloCodigo.LaudoVistoriaFlorestal);
                    laudo.ExploracaoFlorestalList = exploracoes.Select(x => new ExploracaoFlorestalPDF(x)).ToList();
                    var parecerFavoravel    = new ArrayList();
                    var parecerDesfavoravel = new ArrayList();
                    foreach (var exploracao in exploracoes)
                    {
                        if (exploracao.Exploracoes.Where(x => x.ParecerFavoravel == true)?.ToList().Count > 0)
                        {
                            parecerFavoravel.Add(String.Concat(exploracao.CodigoExploracaoTexto, " (", String.Join(", ", exploracao.Exploracoes.Where(x => x.ParecerFavoravel == true).Select(x => x.Identificacao)?.ToList()), ")"));
                        }
                        if (exploracao.Exploracoes.Where(x => x.ParecerFavoravel == false)?.ToList().Count > 0)
                        {
                            parecerDesfavoravel.Add(String.Concat(exploracao.CodigoExploracaoTexto, " (", String.Join(", ", exploracao.Exploracoes.Where(x => x.ParecerFavoravel == false).Select(x => x.Identificacao)?.ToList()), ")"));
                        }
                    }
                    laudo.ParecerFavoravel    = parecerFavoravel.Count > 0 ? String.Join(", ", parecerFavoravel?.ToArray()) : "";
                    laudo.ParecerDesfavoravel = parecerDesfavoravel.Count > 0 ? String.Join(", ", parecerDesfavoravel?.ToArray()) : "";
                }
                else
                {
                    laudo.ExploracaoFlorestal = new ExploracaoFlorestalPDF(new ExploracaoFlorestalBus().ObterPorEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault()));
                }
                laudo.QueimaControlada = new QueimaControladaPDF(new QueimaControladaBus().ObterPorEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault()));

                laudo.Silvicultura = new SilviculturaPDF(new SilviculturaBus().ObterPorEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault()));

                return(laudo);
            }
            catch (Exception exc)
            {
                Validacao.AddErro(exc);
            }

            return(null);
        }
        internal Laudo ObterDadosPDF(int titulo, BancoDeDados banco = null)
        {
            Laudo laudo = new Laudo();

            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                #region Dados do Titulo

                DadosPDF dados = DaEsp.ObterDadosTitulo(titulo, bancoDeDados);
                laudo.Titulo         = dados.Titulo;
                laudo.Protocolo      = dados.Protocolo;
                laudo.Empreendimento = dados.Empreendimento;

                #endregion

                #region Dados da Especificidade

                Comando comando = bancoDeDados.CriarComando(@"select e.id, e.protocolo, e.destinatario, e.data_vistoria, e.objetivo, e.plantio_app, e.plantio_app_area, 
															e.plantio_esp_flor_nativ, e.plantio_esp_flor_nativ_qtd, e.plantio_esp_flor_nativ_area, e.preparo_solo, e.preparo_solo_area, 
															e.resultado, lr.texto resultado_texto, e.resultado_quais, e.descricao_parecer, e.tid 
															from {0}esp_laudo_aud_foment_fl e, {0}lov_esp_laudo_aud_foment_resul lr where e.titulo = :id and lr.id = e.resultado"                                                            , EsquemaBanco);

                comando.AdicionarParametroEntrada("id", titulo, DbType.Int32);

                using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
                {
                    if (reader.Read())
                    {
                        laudo.Id              = Convert.ToInt32(reader["id"]);
                        laudo.Objetivo        = reader["objetivo"].ToString();
                        laudo.Destinatario.Id = Convert.ToInt32(reader["destinatario"]);

                        laudo.PlantioAPP     = Convert.ToInt32(reader["plantio_app"]) == 1 ? "Sim" : "Não";
                        laudo.PlantioAPPArea = reader["plantio_app_area"].ToString();

                        if (reader["data_vistoria"] != null && !Convert.IsDBNull(reader["data_vistoria"]))
                        {
                            laudo.DataVistoria = Convert.ToDateTime(reader["data_vistoria"]).ToShortDateString();
                        }

                        if (reader["resultado_quais"] != null && !Convert.IsDBNull(reader["resultado_quais"]))
                        {
                            laudo.ResultadoQuais = reader["resultado_quais"].ToString();
                        }

                        laudo.PlantioMudasEspeciesFlorestNativas     = Convert.ToInt32(reader["plantio_esp_flor_nativ"]) == 1 ? "Sim" : "Não";
                        laudo.PlantioMudasEspeciesFlorestNativasQtd  = reader["plantio_esp_flor_nativ_qtd"].ToString();
                        laudo.PlantioMudasEspeciesFlorestNativasArea = reader["plantio_esp_flor_nativ_area"].ToString();

                        laudo.PreparoSolo     = Convert.ToInt32(reader["preparo_solo"]) == 1 ? "Sim" : "Não";
                        laudo.PreparoSoloArea = reader["preparo_solo_area"].ToString();

                        laudo.ResultadoTipoTexto = reader["resultado_texto"].ToString();
                        laudo.DescricaoParecer   = reader["descricao_parecer"].ToString();
                    }

                    reader.Close();
                }

                #endregion

                laudo.Destinatario = DaEsp.ObterDadosPessoa(laudo.Destinatario.Id, laudo.Empreendimento.Id, bancoDeDados);

                laudo.Responsavel = DaEsp.ObterDadosResponsavel(laudo.Responsavel.Id, laudo.Protocolo.Id.GetValueOrDefault(), bancoDeDados);

                laudo.AnaliseItens = DaEsp.ObterAnaliseItem(laudo.Protocolo.Id.GetValueOrDefault(), bancoDeDados);

                laudo.Anexos = DaEsp.ObterAnexos(titulo, bancoDeDados);
            }

            return(laudo);
        }
Beispiel #8
0
        public void PreencherPlanilha(MemoryStream memoryStream, Laudo laudo, Configuracao configuracao)
        {
            using (_document = SpreadsheetDocument.Open(memoryStream, true))
            {
                try
                {
                    _wbPart           = _document.WorkbookPart;
                    _sharedStringPart = GetSharedStringPart();

                    #region Laudo fl 1
                    if (SelectSheet("Laudo fl 1"))
                    {
                        #region Cabeçalho
                        PreencherCampo("L8", laudo.Solicitante);
                        PreencherCampo("W8", laudo.Referencia);
                        #endregion

                        #region Identificação
                        if (laudo.Produto != null)
                        {
                            PreencherCampo("B12", laudo.Produto.Descricao);
                        }

                        if (laudo.Linha != null)
                        {
                            PreencherCampo("W12", laudo.Linha.Descricao);
                        }

                        if (laudo.Fonte != null)
                        {
                            PreencherCampo("B15", laudo.Fonte.Descricao);
                        }

                        PreencherCampo("B18", laudo.Imovel.NomeCliente);
                        PreencherCampo("W18", laudo.Imovel.TipoLogradouro.Descricao);

                        PreencherCampo("B21", string.Format("{0}, {1}", laudo.Imovel.Endereco, laudo.Imovel.Numero));
                        PreencherCampo("W21", laudo.Imovel.Complemento);

                        PreencherCampo("B24", laudo.Imovel.Bairro);
                        PreencherCampo("W24", laudo.Imovel.Cidade.Nome.ToUpper());
                        PreencherCampo("AH24", laudo.Imovel.Cidade.Estado.Sigla);
                        #endregion

                        #region Caracterização da Região
                        SelecionarOpcao(((EnumUsosPredominantes)laudo.UsosPredominantes).ToString());

                        SelecionarServicosPublicos(laudo);

                        SelecionarInfraEstruturasUrbanas(laudo);
                        #endregion

                        #region Terreno
                        PreencherCampo("B35", EnumHelper.GetDescription((EnumFormaTerreno)laudo.FormaTerreno));
                        PreencherCampo("G35", EnumHelper.GetDescription((EnumCotaGreide)laudo.CotaGreideTerreno));
                        PreencherCampo("P35", EnumHelper.GetDescription((EnumInclinacaoTerreno)laudo.InclinacaoTerreno));
                        PreencherCampo("W35", EnumHelper.GetDescription((EnumSituacaoTerreno)laudo.SituacaoTerreno));
                        PreencherCampo("AE3", EnumHelper.GetDescription((EnumSuperficieTerreno)laudo.SuperficieTerreno));
                        PreencherCampo("B38", laudo.MedidaAreaTerreno);
                        PreencherCampo("H38", laudo.MedidaFrenteTerreno);
                        PreencherCampo("M38", laudo.MedidaFundosTerreno);
                        PreencherCampo("R38", laudo.MedidaEsquerdaTerreno);
                        PreencherCampo("X38", laudo.MedidaDireitaTerreno);
                        PreencherCampo("AC38", laudo.FracaoIdealTerreno);
                        #endregion

                        #region Edificação
                        PreencherCampo("B43", EnumHelper.GetDescription((EnumTipoEdificacao)laudo.TipoEdificacao));
                        PreencherCampo("H43", EnumHelper.GetDescription((EnumUsosPredio)laudo.UsoEdificacao));
                        PreencherCampo("O43", laudo.NumeroPavimentos);
                        PreencherCampo("U43", laudo.IdadeEdificio);
                        PreencherCampo("AB43", EnumHelper.GetDescription((EnumPosicaoEdificacao)laudo.PosicaoEdificacao));

                        PreencherCampo("B46", EnumHelper.GetDescription((EnumPadraoAcabamento)laudo.PadraoAcabamento));
                        PreencherCampo("H46", EnumHelper.GetDescription((EnumEstadoConservacao)laudo.EstadoConservacao));
                        PreencherCampo("M46", EnumHelper.GetDescription((EnumTetos)laudo.Tetos));
                        PreencherCampo("Q46", EnumHelper.GetDescription((EnumFechamentoParedes)laudo.FechamentoParedes));
                        PreencherCampo("X46", laudo.NumeroVagasCobertas);
                        PreencherCampo("AD46", laudo.NumeroVagasDescobertas);

                        PreencherCampo("G49", laudo.AreaUnidadePrivativa);
                        PreencherCampo("L49", laudo.AreaUnidadeComum);
                        PreencherCampo("Q49", laudo.AreaUnidadeTotal);

                        PreencherCampo("G50", laudo.AreaEstacionamentoPrivativa);
                        PreencherCampo("L50", laudo.AreaEstacionamentoComum);
                        PreencherCampo("Q50", laudo.AreaEstacionamentoTotal);

                        PreencherCampo("G51", laudo.AreaOutrosPrivativa);
                        PreencherCampo("L51", laudo.AreaOutrosComum);
                        PreencherCampo("Q51", laudo.AreaOutrosTotal);

                        PreencherCampo("G52", laudo.AreaTotalPrivativa);
                        PreencherCampo("L52", laudo.AreaTotalComum);
                        PreencherCampo("Q52", laudo.AreaTotalAverbada);
                        PreencherCampo("Y52", laudo.AreaTotalNaoAverbada);
                        PreencherCampo("AE52", laudo.SomatorioAreas);

                        PreencherCampo("B56", ObterDivisaoInterna(laudo));

                        PreencherCampo("B62", EnumHelper.GetDescription((EnumUsosPredio)laudo.UsoPredio));
                        PreencherCampo("N62", laudo.NumeroPavimentosPredio);
                        PreencherCampo("S62", laudo.NumeroUnidadesPredio);
                        PreencherCampo("X62", laudo.NumeroElevadoresPredio);
                        PreencherCampo("AC62", EnumHelper.GetDescription((EnumPosicaoPredio)laudo.PosicaoPredio));

                        PreencherCampo("B65", EnumHelper.GetDescription((EnumPadraoAcabamento)laudo.PadraoAcabamento));
                        PreencherCampo("G65", EnumHelper.GetDescription((EnumEstadoConservacao)laudo.EstadoConservacaoPredio));
                        PreencherCampo("M65", laudo.IdentificacaoPavimentosPredio);
                        PreencherCampo("AF65", laudo.IdadeAparentePredio);
                        #endregion

                        #region Avaliação
                        PreencherCampo("B69", laudo.ValorAvaliacao);
                        PreencherCampo("H69", laudo.ValorAvaliacaoExtenso);

                        PreencherCampo("G73", laudo.AreaGlobal);
                        PreencherCampo("Q73", laudo.AreaTerreno);
                        PreencherCampo("W73", laudo.AreaEdificacao);
                        PreencherCampo("AD73", laudo.AreaBenfeitorias);

                        PreencherCampo("G74", laudo.ValorMetroQuadradoGlobal);
                        PreencherCampo("Q74", laudo.ValorMetroQuadradoTerreno);
                        PreencherCampo("W74", laudo.ValorMetroQuadradoEdificacao);
                        PreencherCampo("AD74", laudo.ValorMetroQuadradoBenfeitorias);

                        PreencherCampo("Q75", laudo.ProdutoTerreno);
                        PreencherCampo("W75", laudo.ProdutoEdificacao);
                        PreencherCampo("AD75", laudo.ProdutoBenfeitorias);

                        PreencherCampo("G76", laudo.ValorTotalGlobal);
                        PreencherCampo("AD76", laudo.ValorTotalItemizada);

                        PreencherCampo("B80", laudo.PrecisaoFundamentacao);
                        PreencherCampo("M80", EnumHelper.GetDescription((EnumMetodologiaAvaliacao)laudo.MetodologiaAvaliacao));

                        PreencherCampo("B83", EnumHelper.GetDescription((EnumDesempenhoMercado)laudo.DesempenhoMercado));
                        PreencherCampo("J83", EnumHelper.GetDescription((EnumAbsorcaoMercado)laudo.AbsorcaoMercado));
                        PreencherCampo("T83", EnumHelper.GetDescription((EnumNivelImobiliario)laudo.NivelOfertas));
                        PreencherCampo("AD83", EnumHelper.GetDescription((EnumNivelImobiliario)laudo.NivelDemanda));
                        #endregion

                        #region Rodapé
                        if (configuracao != null)
                        {
                            PreencherCampo("G90", string.Format("{0} / {1}", configuracao.NomeEmpresa, configuracao.CNPJEmpresa));
                        }

                        if (!string.IsNullOrEmpty(laudo.LocalEmissaoLaudo))
                        {
                            PreencherCampo("B93", string.Format("{0}  /  {1}", laudo.LocalEmissaoLaudo, DateTime.Now.Date.ToString("dd/MM/yyyy")));
                        }

                        if (laudo.ResponsavelTecnico != null)
                        {
                            PreencherCampo("E96", string.Format("{0} / {1}", laudo.ResponsavelTecnico.Nome.ToUpper(), laudo.ResponsavelTecnico.CREA));
                            PreencherCampo("E97", laudo.ResponsavelTecnico.CPF);
                        }

                        if (laudo.RepresentanteLegalEmpresa != null)
                        {
                            PreencherCampo("T96", laudo.RepresentanteLegalEmpresa.Nome.ToUpper());
                            PreencherCampo("T97", laudo.RepresentanteLegalEmpresa.CPF);
                        }
                        #endregion
                    }
                    #endregion

                    #region Laudo fl 2
                    if (SelectSheet("Laudo fl 2"))
                    {
                        #region Cabeçalho
                        PreencherCampo("L6", laudo.Solicitante);
                        PreencherCampo("W6", laudo.Referencia);
                        #endregion

                        #region Informações Complementares
                        //SelecionarOpcao(laudo.EstabilidadeSolidez ? "EstSim" : "EstNao");

                        PreencherCampo("C12", laudo.EstabilidadeSolidezJustificativa);

                        //SelecionarOpcao(laudo.ViciosConstrucao ? "VicioSim" : "VicioNao");

                        PreencherCampo("C17", laudo.ViciosConstrucaoRelacao);

                        //SelecionarOpcao(laudo.Habitabilidade ? "HabitSim" : "HabitNao");

                        PreencherCampo("C22", laudo.HabitabilidadeJustificativa);

                        switch ((EnumFatoresLiquidezValorImovel)laudo.FatoresLiquidezValorImovel)
                        {
                        case EnumFatoresLiquidezValorImovel.Val:
                            //SelecionarOpcao("Val");
                            break;

                        case EnumFatoresLiquidezValorImovel.Desval:
                            //SelecionarOpcao("Desval");
                            break;

                        case EnumFatoresLiquidezValorImovel.Nenh:
                            //SelecionarOpcao("Nenh");
                            break;
                        }

                        PreencherCampo("C28", laudo.FatoresLiquidezExplicitacao);
                        #endregion

                        #region Garantia, Documentação Apresentada e Observações
                        //SelecionarOpcao(laudo.AceitoComoGarantia == 0 ? "GarSim" : "GarNao");

                        PreencherCampo("B37", laudo.MatriculaRGI);
                        PreencherCampo("I37", laudo.Oficio);
                        PreencherCampo("T37", laudo.Comarca == null ? string.Empty : laudo.Comarca.Nome);

                        PreencherCampo("B40", laudo.OutrosDocumentos);

                        //SelecionarOpcao(laudo.Conformidade == 0 ? "DocSim" : "DocNao");

                        PreencherCampo("C45", laudo.Divergencia);

                        PreencherCampo("C49", laudo.ObservacoesFinais);
                        #endregion

                        #region Rodapé
                        if (configuracao != null)
                        {
                            PreencherCampo("G69", string.Format("{0} / {1}", configuracao.NomeEmpresa, configuracao.CNPJEmpresa));
                        }

                        if (!string.IsNullOrEmpty(laudo.LocalEmissaoLaudo))
                        {
                            PreencherCampo("B72", string.Format("{0} / {1}", laudo.LocalEmissaoLaudo, DateTime.Now.Date.ToString("dd/MM/yyyy")));
                        }

                        if (laudo.ResponsavelTecnico != null)
                        {
                            PreencherCampo("E75", string.Format("{0} / {1}", laudo.ResponsavelTecnico.Nome.ToUpper(), laudo.ResponsavelTecnico.CREA));
                            PreencherCampo("E76", laudo.ResponsavelTecnico.CPF);
                        }

                        if (laudo.RepresentanteLegalEmpresa != null)
                        {
                            PreencherCampo("T75", laudo.RepresentanteLegalEmpresa.Nome.ToUpper());
                            PreencherCampo("T76", laudo.RepresentanteLegalEmpresa.CPF);
                        }
                        #endregion
                    }
                    #endregion

                    #region Laudo fl 3
                    if (SelectSheet("Laudo fl 3"))
                    {
                        #region Cabeçalho
                        PreencherCampo("L6", laudo.Solicitante);
                        PreencherCampo("W6", laudo.Referencia);
                        #endregion

                        #region Identificação
                        if (laudo.Produto != null)
                        {
                            PreencherCampo("B10", laudo.Produto.Descricao);
                        }

                        if (laudo.Linha != null)
                        {
                            PreencherCampo("W10", laudo.Linha.Descricao);
                        }

                        if (laudo.Fonte != null)
                        {
                            PreencherCampo("B13", laudo.Fonte.Descricao);
                        }

                        PreencherCampo("B16", laudo.Imovel.NomeCliente);
                        PreencherCampo("W16", laudo.Imovel.TipoLogradouro.Descricao);

                        PreencherCampo("B19", string.Format("{0}, {1}", laudo.Imovel.Endereco, laudo.Imovel.Numero));
                        PreencherCampo("W19", laudo.Imovel.Complemento);

                        PreencherCampo("B22", laudo.Imovel.Bairro);
                        PreencherCampo("W22", laudo.Imovel.Cidade.Nome);
                        PreencherCampo("AH22", laudo.Imovel.Cidade.Estado.Sigla);
                        #endregion

                        #region Rodapé
                        if (configuracao != null)
                        {
                            PreencherCampo("G34", string.Format("{0} / {1}", configuracao.NomeEmpresa, configuracao.CNPJEmpresa));
                        }

                        if (!string.IsNullOrEmpty(laudo.LocalEmissaoLaudo))
                        {
                            PreencherCampo("B37", string.Format("{0} / {1}", laudo.LocalEmissaoLaudo, DateTime.Now.Date.ToString("dd/MM/yyyy")));
                        }

                        if (laudo.ResponsavelTecnico != null)
                        {
                            PreencherCampo("E40", string.Format("{0} / {1}", laudo.ResponsavelTecnico.Nome.ToUpper(), laudo.ResponsavelTecnico.CREA));
                            PreencherCampo("E41", laudo.ResponsavelTecnico.CPF);
                        }

                        if (laudo.RepresentanteLegalEmpresa != null)
                        {
                            PreencherCampo("T40", laudo.RepresentanteLegalEmpresa.Nome.ToUpper());
                            PreencherCampo("T41", laudo.RepresentanteLegalEmpresa.CPF);
                        }
                        #endregion
                    }
                    #endregion
                }
                catch
                {
                    throw;
                }
                finally
                {
                    _document.Close();
                }
            }
        }
Beispiel #9
0
        public string ObterDivisaoInterna(Laudo laudo)
        {
            var divisaoInterna = new StringBuilder();

            if (laudo.NumeroQuartos > 0)
            {
                divisaoInterna.Append(laudo.NumeroQuartos).Append(laudo.NumeroQuartos > 1 ? " QUARTOS" : " QUARTO").Append("; ");
            }

            if (laudo.NumeroSalas > 0)
            {
                divisaoInterna.Append(laudo.NumeroSalas).Append(laudo.NumeroSalas > 1 ? " SALAS" : " SALA").Append("; ");
            }

            if (laudo.NumeroCirculacao > 0)
            {
                divisaoInterna.Append(laudo.NumeroCirculacao).Append(laudo.NumeroCirculacao > 1 ? " CIRCULAÇÕES" : " CIRCULAÇÃO").Append("; ");
            }

            if (laudo.NumeroBanheiros > 0)
            {
                divisaoInterna.Append(laudo.NumeroBanheiros).Append(laudo.NumeroBanheiros > 1 ? " BANHEIROS" : " BANHEIRO").Append("; ");
            }

            if (laudo.NumeroSuites > 0)
            {
                divisaoInterna.Append(laudo.NumeroSuites).Append(laudo.NumeroSuites > 1 ? " SUÍTES" : " SUÍTE").Append("; ");
            }

            if (laudo.NumeroClosets > 0)
            {
                divisaoInterna.Append(laudo.NumeroClosets).Append(laudo.NumeroClosets > 1 ? " CLOSETS" : " CLOSET").Append("; ");
            }

            if (laudo.NumeroCopas > 0)
            {
                divisaoInterna.Append(laudo.NumeroCopas).Append(laudo.NumeroCopas > 1 ? " COPAS" : " COPA").Append("; ");
            }

            if (laudo.NumeroCozinhas > 0)
            {
                divisaoInterna.Append(laudo.NumeroCozinhas).Append(laudo.NumeroCozinhas > 1 ? " COZINHAS" : " COZINHA").Append("; ");
            }

            if (laudo.NumeroAreasServico > 0)
            {
                divisaoInterna.Append(laudo.NumeroAreasServico).Append(laudo.NumeroAreasServico > 1 ? " ÁREAS DE SERVIÇO" : " ÁREA DE SERVIÇO").Append("; ");
            }

            if (laudo.NumeroVarandas > 0)
            {
                divisaoInterna.Append(laudo.NumeroVarandas).Append(laudo.NumeroVarandas > 1 ? " VARANDAS" : " VARANDA").Append("; ");
            }

            if (laudo.NumeroTerracosCobertos > 0)
            {
                divisaoInterna.Append(laudo.NumeroTerracosCobertos).Append(laudo.NumeroTerracosCobertos > 1 ? " TERRAÇOS COBERTOS" : " TERRAÇO COBERTO").Append("; ");
            }

            if (laudo.NumeroTerracosDescobertos > 0)
            {
                divisaoInterna.Append(laudo.NumeroTerracosDescobertos).Append(laudo.NumeroTerracosDescobertos > 1 ? " TERRAÇOS DESCOBERTOS" : " TERRAÇO DESCOBERTO").Append("; ");
            }

            return(divisaoInterna.ToString(0, divisaoInterna.Length - 2)); // Ignora os dois últimos caracteres da string para que não acabe em "; "
        }
Beispiel #10
0
        internal Laudo ObterDadosPDF(int titulo, BancoDeDados banco = null)
        {
            Laudo laudo = new Laudo();

            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                #region Dados do Titulo

                DadosPDF dados = DaEsp.ObterDadosTitulo(titulo, bancoDeDados);
                laudo.Titulo         = dados.Titulo;
                laudo.Protocolo      = dados.Protocolo;
                laudo.Empreendimento = dados.Empreendimento;

                #endregion

                #region Dados da Especificidade

                Comando comando = bancoDeDados.CriarComando(@"select e.destinatario, e.responsavel, e.caracterizacao, lp.texto conclusao, e.data_vistoria, e.objetivo, e.consideracao, 
				e.restricao, e.descricao_parecer from {0}esp_laudo_vistoria_florestal e, {0}lov_esp_conclusao lp where e.conclusao = lp.id and e.titulo = :id"                , EsquemaBanco);

                comando.AdicionarParametroEntrada("id", titulo, DbType.Int32);

                using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
                {
                    if (reader.Read())
                    {
                        laudo.Objetivo           = reader["objetivo"].ToString();
                        laudo.Destinatario.Id    = Convert.ToInt32(reader["destinatario"]);
                        laudo.CaracterizacaoTipo = Convert.ToInt32(reader["caracterizacao"]);
                        laudo.ConclusaoTipoTexto = reader["conclusao"].ToString();
                        laudo.Consideracao       = reader["consideracao"].ToString();
                        laudo.Restricao          = reader["restricao"].ToString();
                        laudo.DescricaoParecer   = reader["descricao_parecer"].ToString();

                        if (reader["data_vistoria"] != null && !Convert.IsDBNull(reader["data_vistoria"]))
                        {
                            laudo.DataVistoria = Convert.ToDateTime(reader["data_vistoria"]).ToShortDateString();
                        }

                        if (reader["responsavel"] != null && !Convert.IsDBNull(reader["responsavel"]))
                        {
                            laudo.Responsavel.Id = Convert.ToInt32(reader["responsavel"]);
                        }
                    }

                    reader.Close();
                }

                #endregion

                laudo.Destinatario = DaEsp.ObterDadosPessoa(laudo.Destinatario.Id, laudo.Empreendimento.Id, bancoDeDados);

                laudo.Responsavel = DaEsp.ObterDadosResponsavel(laudo.Responsavel.Id, laudo.Protocolo.Id.GetValueOrDefault(), bancoDeDados);

                laudo.AnaliseItens = DaEsp.ObterAnaliseItem(laudo.Protocolo.Id.GetValueOrDefault(), bancoDeDados);

                laudo.Anexos = DaEsp.ObterAnexos(titulo, bancoDeDados);
            }

            return(laudo);
        }