Пример #1
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 "; "
        }
Пример #2
0
 public void SelecionarServicosPublicos(Laudo laudo)
 {
     foreach (var servico in laudo.ListaServicoPublicoComunitario)
         SelecionarOpcao(((EnumServicoPublicoComunitario)servico.TipoServicoPublicoComunitario).ToString());
 }
Пример #3
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();
                }
            }
        }
Пример #4
0
 public void SelecionarInfraEstruturasUrbanas(Laudo laudo)
 {
     foreach (var infra in laudo.ListaInfraEstruturaUrbana)
         SelecionarOpcao(((EnumInfraEstruturaUrbana)infra.TipoInfraEstruturaUrbana).ToString());
 }
Пример #5
0
        private void RemoverOuAdicionarServicosPublicos(Laudo laudo, LaudoViewModel model)
        {
            var listaServicosLaudo = laudo.ListaServicoPublicoComunitario.ToList();
            var listaServicosSelecionados = ObterListaOpcoesAPartirString(model.ServicosSelecionados);

            var listaServicosARemover = new List<ServicoPublicoComunitario>(
                from servico in listaServicosLaudo
                where listaServicosSelecionados.All(s => s.Value != ((EnumServicoPublicoComunitario)servico.TipoServicoPublicoComunitario).ToString())
                select servico).ToList();

            var listaServicosAAdicionar = (from servico in listaServicosSelecionados
                                           where listaServicosLaudo.All(s => ((EnumServicoPublicoComunitario) s.TipoServicoPublicoComunitario).ToString() != servico.Value)
                                           select servico).ToList();

            foreach (var servico in listaServicosARemover)
                laudo.ListaServicoPublicoComunitario.Remove(servico);

            foreach (var servico in listaServicosAAdicionar)
            {
                var valorEnum = EnumHelper.ParseEnumValueDescription<EnumServicoPublicoComunitario>(servico.Value);
                laudo.ListaServicoPublicoComunitario.Add(new ServicoPublicoComunitario
                                                             {
                                                                 Descricao = EnumHelper.GetDescription(valorEnum),
                                                                 TipoServicoPublicoComunitario = (int) valorEnum,
                                                                 Laudo = laudo
                                                             });
            }
        }
Пример #6
0
 private void VerificarStatusLaudo(Laudo laudo)
 {
     if (laudo.ListaServicoPublicoComunitario != null && laudo.ListaServicoPublicoComunitario.Any() &&
         laudo.ListaInfraEstruturaUrbana != null && laudo.ListaInfraEstruturaUrbana.Any() &&
         laudo.MedidaAreaTerreno > 0 &&
         laudo.FracaoIdealTerreno > 0 &&
         laudo.SomatorioAreas > 0)
         laudo.Status = (int)EnumStatusLaudo.EmAndamento;
 }
Пример #7
0
        private void RemoverOuAdicionarInfraEstruturaUrbana(Laudo laudo, LaudoViewModel model)
        {
            var listaInfrasLaudo = laudo.ListaInfraEstruturaUrbana.ToList();
            var listaInfras = ObterListaOpcoesAPartirString(model.InfrasSelecionadas);

            var listaInfrasARemover = new List<InfraEstruturaUrbana>(
                    from infra in listaInfrasLaudo
                    where listaInfras.All(i => i.Value != ((EnumInfraEstruturaUrbana)infra.TipoInfraEstruturaUrbana).ToString())
                    select infra
                );

            var listaInfrasAAdicionar = (from infra in listaInfras
                                        where listaInfrasLaudo.All(i => ((EnumInfraEstruturaUrbana) i.TipoInfraEstruturaUrbana).ToString() != infra.Value)
                                        select infra).ToList();

            foreach (var infra in listaInfrasARemover)
                laudo.ListaInfraEstruturaUrbana.Remove(infra);

            foreach (var infra in listaInfrasAAdicionar)
            {
                var valorEnum = EnumHelper.ParseEnumValueDescription<EnumInfraEstruturaUrbana>(infra.Value);

                laudo.ListaInfraEstruturaUrbana.Add(new InfraEstruturaUrbana
                {
                    Descricao = EnumHelper.GetDescription(valorEnum),
                    TipoInfraEstruturaUrbana = (int)valorEnum,
                    Laudo = laudo
                });
            }
        }
Пример #8
0
        private LaudoViewModel PreencherViewModel(Laudo laudo)
        {
            var opcoesHelper = new OpcoesHelper(laudo);

            var viewModel = new LaudoViewModel
            {
                Laudo = laudo,
                LaudoId = laudo.LaudoID,
                StatusLaudo = ((EnumStatusLaudo)laudo.Status).ToString(),
                MetodoDefinicaoValor = RadioButtonHelper.ParseEnumToRadioButtonList((EnumMetodoDefinicaoValor)laudo.MetodoDefinicaoValor),
                DesempenhoMercado = RadioButtonHelper.ParseEnumToRadioButtonList((EnumDesempenhoMercado)laudo.DesempenhoMercado),
                AbsorcaoMercado = RadioButtonHelper.ParseEnumToRadioButtonList((EnumAbsorcaoMercado)laudo.AbsorcaoMercado),
                NumeroOfertas = RadioButtonHelper.ParseEnumToRadioButtonList((EnumNivelImobiliario)laudo.NivelOfertas),
                NivelDemanda = RadioButtonHelper.ParseEnumToRadioButtonList((EnumNivelImobiliario)laudo.NivelDemanda),
                FatoresLiquidezValorImovel = RadioButtonHelper.ParseEnumToRadioButtonList((EnumFatoresLiquidezValorImovel)laudo.FatoresLiquidezValorImovel),
                EstabilidadeSolidez = RadioButtonHelper.ParseEnumToRadioButtonList((EnumEstabilidadeSimOuNao)laudo.EstabilidadeSolidez),
                ViciosConstrucao = RadioButtonHelper.ParseEnumToRadioButtonList((EnumVicioSimOuNao)laudo.ViciosConstrucao),
                CondicoesHabitabilidade = RadioButtonHelper.ParseEnumToRadioButtonList((EnumHabitabilidadeSimOuNao)laudo.Habitabilidade),
                AceitoComoGarantia = RadioButtonHelper.ParseEnumToRadioButtonList((EnumGarantiaSimOuNao)laudo.AceitoComoGarantia),
                ConformidadeDocumentacao = RadioButtonHelper.ParseEnumToRadioButtonList((EnumConformidadeDocumentacaoSimOuNao)laudo.ConformidadeDocumentacao),
                // Identificação
                ListaEstados = opcoesHelper.ObterOpcoesEstado(EstadoRepositorio.BuscarTodos(WorkLifetimeManager.Value)),
                ListaCidades = opcoesHelper.ObterOpcoesCidade(CidadeRepositorio.BuscarTodasEstado(WorkLifetimeManager.Value, laudo.Imovel.Cidade.Estado.Sigla)),
                ListaTiposLogradouro = opcoesHelper.ObterOpcoesTipoLogradouro(TipoLogradouroRepositorio.BuscarTodos(WorkLifetimeManager.Value)),
                ListaFontes = opcoesHelper.ObterOpcoesFonte(FonteRepositorio.BuscarTodos(WorkLifetimeManager.Value)),
                ListaLinhas = opcoesHelper.ObterOpcoesLinha(LinhaRepositorio.BuscarTodos(WorkLifetimeManager.Value)),
                ListaProdutos = opcoesHelper.ObterOpcoesProduto(ProdutoRepositorio.BuscarTodos(WorkLifetimeManager.Value)),
                // Caracterização da Região
                ListaServicosPublicosComunitarios = opcoesHelper.ObterOpcoesEnum<EnumServicoPublicoComunitario>(),
                ListaInfraEstruturasUrbanas = opcoesHelper.ObterOpcoesEnum<EnumInfraEstruturaUrbana>(),
                // Final
                ListaComarcas = opcoesHelper.ObterOpcoesCidade(CidadeRepositorio.BuscarTodasEstado(WorkLifetimeManager.Value, laudo.Imovel.Cidade.Estado.Sigla)),
                ListaResponsaveisTecnicos = opcoesHelper.ObterOpcoesResponsaveisTecnicos(UsuarioRepositorio.BuscarPorPerfil(WorkLifetimeManager.Value, EnumPerfil.UsuarioComum)),
                ListaRepresentantesLegais = opcoesHelper.ObterOpcoesRepresentantesLegais(UsuarioRepositorio.BuscarPorPerfil(WorkLifetimeManager.Value, EnumPerfil.Administrador)),
            };

            MarcarServicosPublicosComunitarios(viewModel.ListaServicosPublicosComunitarios, laudo.ListaServicoPublicoComunitario);
            MarcarInfraEstruturasUrbanas(viewModel.ListaInfraEstruturasUrbanas, laudo.ListaInfraEstruturaUrbana);

            if (laudo.DataHoraVistoria.HasValue)
            {
                viewModel.DataVistoria = laudo.DataHoraVistoria.Value.Date.ToString("dd/MM/yyyy");
                viewModel.HoraVistoria = laudo.DataHoraVistoria.Value.ToString("HH:mm");
            }

            return viewModel;
        }
Пример #9
0
        private void AtualizarLaudo(Laudo laudo, LaudoViewModel model)
        {
            #region Identificação
            if (laudo.Imovel.Cidade.Estado.EstadoID != model.Laudo.Imovel.Cidade.Estado.EstadoID)
                laudo.Imovel.Cidade.Estado = EstadoRepositorio.Obter(WorkLifetimeManager.Value, model.Laudo.Imovel.Cidade.Estado.EstadoID);
            if (laudo.Imovel.Cidade.CidadeID != model.Laudo.Imovel.Cidade.CidadeID)
                laudo.Imovel.Cidade = CidadeRepositorio.Obter(WorkLifetimeManager.Value, model.Laudo.Imovel.Cidade.CidadeID);
            if (laudo.Imovel.TipoLogradouro.TipoLogradouroID != model.Laudo.Imovel.TipoLogradouro.TipoLogradouroID)
                laudo.Imovel.TipoLogradouro = TipoLogradouroRepositorio.Obter(WorkLifetimeManager.Value, model.Laudo.Imovel.TipoLogradouro.TipoLogradouroID);

            laudo.Imovel.Endereco = model.Laudo.Imovel.Endereco;
            laudo.Imovel.Numero = model.Laudo.Imovel.Numero;
            laudo.Imovel.Complemento = model.Laudo.Imovel.Complemento;
            laudo.Produto = model.Laudo.Produto;
            laudo.Linha = model.Laudo.Linha;
            laudo.Fonte = model.Laudo.Fonte;
            laudo.Imovel.NomeCliente = model.Laudo.Imovel.NomeCliente;
            #endregion

            #region Caracterização da Região
            laudo.UsosPredominantes = model.Laudo.UsosPredominantes;

            RemoverOuAdicionarServicosPublicos(laudo, model);

            RemoverOuAdicionarInfraEstruturaUrbana(laudo, model);
            #endregion

            #region Terreno
            laudo.FormaTerreno = model.Laudo.FormaTerreno;
            laudo.CotaGreideTerreno = model.Laudo.CotaGreideTerreno;
            laudo.InclinacaoTerreno = model.Laudo.InclinacaoTerreno;
            laudo.SituacaoTerreno = model.Laudo.SituacaoTerreno;
            laudo.SuperficieTerreno = model.Laudo.SuperficieTerreno;
            laudo.MedidaAreaTerreno = model.Laudo.MedidaAreaTerreno;
            laudo.MedidaFrenteTerreno = model.Laudo.MedidaFrenteTerreno;
            laudo.MedidaFundosTerreno = model.Laudo.MedidaFundosTerreno;
            laudo.MedidaDireitaTerreno = model.Laudo.MedidaDireitaTerreno;
            laudo.MedidaEsquerdaTerreno = model.Laudo.MedidaEsquerdaTerreno;
            laudo.FracaoIdealTerreno = model.Laudo.FracaoIdealTerreno;
            #endregion

            #region Edificação
            laudo.TipoEdificacao = model.Laudo.TipoEdificacao;
            laudo.UsoEdificacao = model.Laudo.UsoEdificacao;
            laudo.NumeroPavimentos = model.Laudo.NumeroPavimentos;
            laudo.IdadeEdificio = model.Laudo.IdadeEdificio;
            laudo.PosicaoEdificacao = model.Laudo.PosicaoEdificacao;
            laudo.PadraoAcabamento = model.Laudo.PadraoAcabamento;
            laudo.EstadoConservacao = model.Laudo.EstadoConservacao;
            laudo.Tetos = model.Laudo.Tetos;
            laudo.FechamentoParedes = model.Laudo.FechamentoParedes;
            laudo.NumeroVagasCobertas = model.Laudo.NumeroVagasCobertas;
            laudo.NumeroVagasDescobertas = model.Laudo.NumeroVagasDescobertas;
            laudo.AreaUnidadePrivativa = model.Laudo.AreaUnidadePrivativa;
            laudo.AreaUnidadeComum = model.Laudo.AreaUnidadeComum;
            laudo.AreaUnidadeTotal = model.Laudo.AreaUnidadeTotal;
            laudo.AreaEstacionamentoPrivativa = model.Laudo.AreaEstacionamentoPrivativa;
            laudo.AreaEstacionamentoComum = model.Laudo.AreaEstacionamentoComum;
            laudo.AreaEstacionamentoTotal = model.Laudo.AreaEstacionamentoTotal;
            laudo.AreaOutrosPrivativa = model.Laudo.AreaOutrosPrivativa;
            laudo.AreaOutrosComum = model.Laudo.AreaOutrosComum;
            laudo.AreaOutrosTotal = model.Laudo.AreaOutrosTotal;
            laudo.AreaTotalPrivativa = model.Laudo.AreaTotalPrivativa;
            laudo.AreaTotalComum = model.Laudo.AreaTotalComum;
            laudo.AreaTotalAverbada = model.Laudo.AreaTotalAverbada;
            laudo.AreaTotalNaoAverbada = model.Laudo.AreaTotalNaoAverbada;
            laudo.SomatorioAreas = model.Laudo.SomatorioAreas;
            laudo.NumeroQuartos = model.Laudo.NumeroQuartos;
            laudo.NumeroSalas = model.Laudo.NumeroSalas;
            laudo.NumeroCirculacao = model.Laudo.NumeroCirculacao;
            laudo.NumeroBanheiros = model.Laudo.NumeroBanheiros;
            laudo.NumeroSuites = model.Laudo.NumeroSuites;
            laudo.NumeroClosets = model.Laudo.NumeroClosets;
            laudo.NumeroCopas = model.Laudo.NumeroCopas;
            laudo.NumeroCozinhas = model.Laudo.NumeroCozinhas;
            laudo.NumeroAreasServico = model.Laudo.NumeroAreasServico;
            laudo.NumeroVarandas = model.Laudo.NumeroVarandas;
            laudo.NumeroTerracosCobertos = model.Laudo.NumeroTerracosCobertos;
            laudo.NumeroTerracosDescobertos = model.Laudo.NumeroTerracosDescobertos;
            laudo.UsoPredio = model.Laudo.UsoPredio;
            laudo.NumeroPavimentosPredio = model.Laudo.NumeroPavimentosPredio;
            laudo.NumeroUnidadesPredio = model.Laudo.NumeroUnidadesPredio;
            laudo.NumeroElevadoresPredio = model.Laudo.NumeroElevadoresPredio;
            laudo.PosicaoPredio = model.Laudo.PosicaoPredio;
            laudo.PadraoConstrutivoPredio = model.Laudo.PadraoConstrutivoPredio;
            laudo.EstadoConservacaoPredio = model.Laudo.EstadoConservacaoPredio;
            laudo.IdentificacaoPavimentosPredio = model.Laudo.IdentificacaoPavimentosPredio;
            laudo.IdadeAparentePredio = model.Laudo.IdadeAparentePredio;
            #endregion

            #region Avaliação
            laudo.ValorAvaliacao = model.Laudo.ValorAvaliacao;
            laudo.ValorAvaliacaoExtenso = model.Laudo.ValorAvaliacaoExtenso;
            laudo.MetodoDefinicaoValor = (int)model.MetodoDefinicaoValor.SelectedValue;
            laudo.AreaGlobal = model.Laudo.AreaGlobal;
            laudo.ValorMetroQuadradoGlobal = model.Laudo.ValorMetroQuadradoGlobal;
            laudo.ValorTotalGlobal = model.Laudo.ValorTotalGlobal;
            laudo.AreaTerreno = model.Laudo.AreaTerreno;
            laudo.AreaEdificacao = model.Laudo.AreaEdificacao;
            laudo.AreaBenfeitorias = model.Laudo.AreaBenfeitorias;
            laudo.ValorMetroQuadradoTerreno = model.Laudo.ValorMetroQuadradoTerreno;
            laudo.ValorMetroQuadradoEdificacao = model.Laudo.ValorMetroQuadradoEdificacao;
            laudo.ValorMetroQuadradoBenfeitorias = model.Laudo.ValorMetroQuadradoBenfeitorias;
            laudo.ProdutoTerreno = model.Laudo.ProdutoTerreno;
            laudo.ProdutoEdificacao = model.Laudo.ProdutoEdificacao;
            laudo.ProdutoBenfeitorias = model.Laudo.ProdutoBenfeitorias;
            laudo.ValorTotalItemizada = model.Laudo.ValorTotalItemizada;
            laudo.PrecisaoFundamentacao = model.Laudo.PrecisaoFundamentacao;
            laudo.MetodologiaAvaliacao = model.Laudo.MetodologiaAvaliacao;
            laudo.DesempenhoMercado = (int)model.DesempenhoMercado.SelectedValue;
            laudo.AbsorcaoMercado = (int)model.AbsorcaoMercado.SelectedValue;
            laudo.NivelOfertas = (int)model.NumeroOfertas.SelectedValue;
            laudo.NivelDemanda = (int)model.NivelDemanda.SelectedValue;
            laudo.ObservacoesAvaliacao = model.Laudo.ObservacoesAvaliacao;
            #endregion

            #region Informações Complementares
            laudo.EstabilidadeSolidez = model.Laudo.EstabilidadeSolidez;
            laudo.EstabilidadeSolidezJustificativa = model.Laudo.EstabilidadeSolidezJustificativa;
            laudo.ViciosConstrucao = model.Laudo.ViciosConstrucao;
            laudo.ViciosConstrucaoRelacao = model.Laudo.ViciosConstrucaoRelacao;
            laudo.Habitabilidade = model.Laudo.Habitabilidade;
            laudo.HabitabilidadeJustificativa = model.Laudo.HabitabilidadeJustificativa;
            laudo.FatoresLiquidezValorImovel = (int)model.FatoresLiquidezValorImovel.SelectedValue;
            laudo.FatoresLiquidezExplicitacao = model.Laudo.FatoresLiquidezExplicitacao;
            #endregion

            #region Garantia, Documentação Apresentada
            laudo.AceitoComoGarantia = (int)model.AceitoComoGarantia.SelectedValue;

            laudo.MatriculaRGI = model.Laudo.MatriculaRGI;
            laudo.Oficio = model.Laudo.Oficio;

            if (model.Laudo.Comarca == null || model.Laudo.Comarca.CidadeID == 0)
                laudo.Comarca = null;
            else if (laudo.Comarca == null || laudo.Comarca.CidadeID != model.Laudo.Comarca.CidadeID)
                laudo.Comarca = CidadeRepositorio.Obter(WorkLifetimeManager.Value, model.Laudo.Comarca.CidadeID);

            laudo.OutrosDocumentos = model.Laudo.OutrosDocumentos;
            laudo.ConformidadeDocumentacao = (int)model.ConformidadeDocumentacao.SelectedValue;
            laudo.Divergencia = model.Laudo.Divergencia;
            #endregion

            #region Observações Finais
            laudo.ObservacoesFinais = model.Laudo.ObservacoesFinais;
            laudo.LocalEmissaoLaudo = model.Laudo.LocalEmissaoLaudo;

            if (model.Laudo.ResponsavelTecnico == null || model.Laudo.ResponsavelTecnico.UsuarioId == 0)
                laudo.ResponsavelTecnico = null;
            else if (laudo.ResponsavelTecnico == null || laudo.ResponsavelTecnico.UsuarioId != model.Laudo.ResponsavelTecnico.UsuarioId)
                laudo.ResponsavelTecnico = UsuarioRepositorio.Obter(WorkLifetimeManager.Value, model.Laudo.ResponsavelTecnico.UsuarioId);

            if (model.Laudo.RepresentanteLegalEmpresa == null || model.Laudo.RepresentanteLegalEmpresa.UsuarioId == 0)
                laudo.RepresentanteLegalEmpresa = null;
            else if (laudo.RepresentanteLegalEmpresa == null || laudo.RepresentanteLegalEmpresa.UsuarioId != model.Laudo.RepresentanteLegalEmpresa.UsuarioId)
                laudo.RepresentanteLegalEmpresa = UsuarioRepositorio.Obter(WorkLifetimeManager.Value, model.Laudo.RepresentanteLegalEmpresa.UsuarioId);
            #endregion

            if (laudo.Status == (int) EnumStatusLaudo.AFazer)
                VerificarStatusLaudo(laudo);
        }
Пример #10
0
 public void Salvar(IUnitOfWork unitOfWork, Laudo laudo)
 {
     PersistenceBroker.Salvar(unitOfWork, laudo);
 }
Пример #11
0
 public void Atualizar(IUnitOfWork unitOfWork, Laudo laudo)
 {
     PersistenceBroker.Atualizar(unitOfWork, laudo);
 }