public void Salvar(IEspecificidade especificidade, BancoDeDados banco)
        {
            TermoCPFARLC termo = especificidade as TermoCPFARLC;

            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                bancoDeDados.IniciarTransacao();

                _da.Salvar(termo, bancoDeDados);

                bancoDeDados.Commit();
            }
        }
        public ActionResult TermoCPFARLC(EspecificidadeVME especificidade)
        {
            TermoCPFARLCBus            bus = new TermoCPFARLCBus();
            List <Protocolos>          lstProcessosDocumentos = _busTitulo.ObterProcessosDocumentos(especificidade.ProtocoloId);
            List <AtividadeSolicitada> lstAtividades          = new List <AtividadeSolicitada>();

            Titulo       titulo = new Titulo();
            TituloModelo modelo = _tituloModeloBus.Obter(especificidade.ModeloId ?? 0);
            TermoCPFARLC termo  = new TermoCPFARLC();

            int atividadeSelecionada = 0;

            if (especificidade.TituloId > 0)
            {
                titulo                = _busTitulo.ObterSimplificado(especificidade.TituloId);
                titulo.Atividades     = _busTitulo.ObterAtividades(especificidade.TituloId);
                titulo.Condicionantes = _busTitulo.ObterCondicionantes(especificidade.TituloId);

                if (titulo.Atividades.Count > 0)
                {
                    atividadeSelecionada = titulo.Atividades.First().Id;
                }

                if (titulo.Situacao.Id == (int)eTituloSituacao.Cadastrado)
                {
                    termo = bus.Obter(especificidade.TituloId) as TermoCPFARLC;
                }

                especificidade.AtividadeProcDocReq = _busTitulo.ObterProcDocReqEspecificidade(especificidade.TituloId);
            }

            if (especificidade.ProtocoloId > 0)
            {
                if (_busEspecificidade.ExisteProcDocFilhoQueFoiDesassociado(especificidade.TituloId))
                {
                    lstAtividades     = new List <AtividadeSolicitada>();
                    titulo.Atividades = new List <Atividade>();
                }
                else
                {
                    lstAtividades = _busAtividade.ObterAtividadesLista(especificidade.AtividadeProcDocReq.ToProtocolo());
                }

                if (!especificidade.IsVisualizar)
                {
                    _busEspecificidade.PossuiAtividadeEmAndamento(especificidade.ProtocoloId);
                }
            }

            if (!Validacao.EhValido)
            {
                return(Json(new { Msg = Validacao.Erros, EhValido = Validacao.EhValido, @Html = string.Empty }, JsonRequestBehavior.AllowGet));
            }

            TermoCPFARLCVM vm = new TermoCPFARLCVM(
                lstProcessosDocumentos,
                lstAtividades,
                titulo.Condicionantes,
                termo,
                especificidade.AtividadeProcDocReqKey,
                especificidade.IsVisualizar,
                atividadeSelecionada);

            if (especificidade.TituloId > 0)
            {
                EmpreendimentoBus empreendimentoBus = new EmpreendimentoBus();
                DominialidadeBus  dominialidadeBus  = new DominialidadeBus();
                vm.Atividades.Atividades = titulo.Atividades;

                vm.CedenteDominios = ViewModelHelper.CriarSelectList(dominialidadeBus.ObterDominiosLista(especificidade.EmpreendimentoId), selecionado: termo.CedenteDominioID.ToString());
                vm.CedenteReservas = ViewModelHelper.CriarSelectList(dominialidadeBus.ObterARLCompensacaoDominio(termo.CedenteDominioID));
                vm.CedenteResponsaveisEmpreendimento = ViewModelHelper.CriarSelectList(empreendimentoBus.ObterResponsaveisComTipo(especificidade.EmpreendimentoId));

                vm.ReceptorEmpreendimentos = ViewModelHelper.CriarSelectList(
                    new List <Lista>()
                {
                    new Lista()
                    {
                        Id = termo.ReceptorEmpreendimentoID.ToString(), Texto = termo.ReceptorEmpreendimentoDenominador
                    }
                },
                    selecionado: termo.ReceptorEmpreendimentoID.ToString());
                vm.ReceptorDominios = ViewModelHelper.CriarSelectList(dominialidadeBus.ObterDominiosLista(termo.ReceptorEmpreendimentoID), selecionado: termo.ReceptorDominioID.ToString());
                vm.ReceptorResponsaveisEmpreendimento = ViewModelHelper.CriarSelectList(empreendimentoBus.ObterResponsaveisComTipo(termo.ReceptorEmpreendimentoID));
            }

            vm.IsCondicionantes = modelo.Regra(eRegra.Condicionantes) || (titulo.Condicionantes != null && titulo.Condicionantes.Count > 0);

            string htmlEspecificidade = ViewModelHelper.RenderPartialViewToString(ControllerContext, "~/Areas/Especificidades/Views/Termo/TermoCPFARLC.ascx", vm);

            return(Json(new { Msg = Validacao.Erros, EhValido = Validacao.EhValido, @Html = htmlEspecificidade }, JsonRequestBehavior.AllowGet));
        }
        internal void Salvar(TermoCPFARLC especificidade, BancoDeDados banco = null)
        {
            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                bancoDeDados.IniciarTransacao();

                #region Cadastro da Especificidade

                eHistoricoAcao acao;
                object         id;

                // Verifica a existencia da especificidade
                Comando comando = bancoDeDados.CriarComando(@"select e.id from {0}esp_termo_cpfarlc e where e.titulo = :titulo", EsquemaBanco);
                comando.AdicionarParametroEntrada("titulo", especificidade.Titulo.Id, DbType.Int32);
                id = bancoDeDados.ExecutarScalar(comando);

                if (id != null && !Convert.IsDBNull(id))
                {
                    comando = bancoDeDados.CriarComando(@"
					update {0}esp_termo_cpfarlc e set e.tid = :tid, e.protocolo = :protocolo, e.dominio_cedente = :dominio_cedente, e.emp_receptor = :emp_receptor, 
					e.dominio_receptor = :dominio_receptor, e.dominialidade = :dominialidade, e.dominialidade_tid = (select d.tid from crt_dominialidade d where d.id = :dominialidade) 
					where e.titulo = :titulo"                    , EsquemaBanco);

                    acao = eHistoricoAcao.atualizar;
                    especificidade.ID = Convert.ToInt32(id);
                }
                else
                {
                    comando = bancoDeDados.CriarComando(@"
					insert into esp_termo_cpfarlc (id, tid, titulo, protocolo, dominio_cedente, emp_receptor, dominio_receptor, dominialidade, dominialidade_tid) values 
					({0}seq_esp_termo_cpfarlc.nextval, :tid, :titulo, :protocolo, :dominio_cedente, :emp_receptor, :dominio_receptor, :dominialidade, 
					(select d.tid from crt_dominialidade d where d.id = :dominialidade)) returning id into :id"                    , EsquemaBanco);

                    acao = eHistoricoAcao.criar;
                    comando.AdicionarParametroSaida("id", DbType.Int32);
                }

                comando.AdicionarParametroEntrada("titulo", especificidade.Titulo.Id, DbType.Int32);
                comando.AdicionarParametroEntrada("protocolo", especificidade.Titulo.Protocolo.Id, DbType.Int32);
                comando.AdicionarParametroEntrada("dominio_cedente", especificidade.CedenteDominioID, DbType.Int32);
                comando.AdicionarParametroEntrada("emp_receptor", especificidade.ReceptorEmpreendimentoID, DbType.Int32);
                comando.AdicionarParametroEntrada("dominio_receptor", especificidade.ReceptorDominioID, DbType.Int32);
                comando.AdicionarParametroEntrada("dominialidade", especificidade.DominialidadeID, DbType.Int32);
                comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());

                bancoDeDados.ExecutarNonQuery(comando);

                if (id == null || Convert.IsDBNull(id))
                {
                    especificidade.ID = Convert.ToInt32(comando.ObterValorParametro("id"));
                }

                #endregion

                #region Reservas Cedente

                comando = bancoDeDados.CriarComando("delete from {0}esp_tcpfarlc_ced_rese t ", EsquemaBanco);
                comando.DbCommand.CommandText += String.Format("where t.especificidade = :especificidade {0}",
                                                               comando.AdicionarNotIn("and", "t.id", DbType.Int32, especificidade.CedenteARLCompensacao.Select(x => x.IDRelacionamento).ToList()));
                comando.AdicionarParametroEntrada("especificidade", especificidade.ID, DbType.Int32);

                bancoDeDados.ExecutarNonQuery(comando);

                foreach (var item in especificidade.CedenteARLCompensacao)
                {
                    if (item.IDRelacionamento > 0)
                    {
                        comando = bancoDeDados.CriarComando(@"update {0}esp_tcpfarlc_ced_rese t set t.reserva = :reserva, t.tid = :tid where t.id = :id", EsquemaBanco);
                        comando.AdicionarParametroEntrada("id", item.IDRelacionamento, DbType.Int32);
                    }
                    else
                    {
                        comando = bancoDeDados.CriarComando(@"
						insert into {0}esp_tcpfarlc_ced_rese (id, especificidade, reserva, tid) 
						values ({0}seq_esp_tcpfarlc_ced_rese.nextval, :especificidade, :reserva, :tid)"                        , EsquemaBanco);
                        comando.AdicionarParametroEntrada("especificidade", especificidade.ID, DbType.Int32);
                    }

                    comando.AdicionarParametroEntrada("reserva", item.Id, DbType.Int32);
                    comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());

                    bancoDeDados.ExecutarNonQuery(comando);
                }

                #endregion

                #region Responsáveis do empreendimento cendente

                comando = bancoDeDados.CriarComando("delete from {0}esp_tcpfarlc_ced_resp t ", EsquemaBanco);
                comando.DbCommand.CommandText += String.Format("where t.especificidade = :especificidade {0}",
                                                               comando.AdicionarNotIn("and", "t.id", DbType.Int32, especificidade.CedenteResponsaveisEmpreendimento.Select(x => x.IdRelacionamento).ToList()));
                comando.AdicionarParametroEntrada("especificidade", especificidade.ID, DbType.Int32);

                bancoDeDados.ExecutarNonQuery(comando);

                foreach (var item in especificidade.CedenteResponsaveisEmpreendimento)
                {
                    if (item.IdRelacionamento > 0)
                    {
                        comando = bancoDeDados.CriarComando(@"update {0}esp_tcpfarlc_ced_resp t set t.responsavel = :responsavel, t.tid = :tid where t.id = :id", EsquemaBanco);
                        comando.AdicionarParametroEntrada("id", item.IdRelacionamento, DbType.Int32);
                    }
                    else
                    {
                        comando = bancoDeDados.CriarComando(@"
						insert into {0}esp_tcpfarlc_ced_resp (id, especificidade, responsavel, tid) 
						values ({0}seq_esp_tcpfarlc_ced_resp.nextval, :especificidade, :responsavel, :tid)"                        , EsquemaBanco);
                        comando.AdicionarParametroEntrada("especificidade", especificidade.ID, DbType.Int32);
                    }

                    comando.AdicionarParametroEntrada("responsavel", item.Id, DbType.Int32);
                    comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());

                    bancoDeDados.ExecutarNonQuery(comando);
                }

                #endregion

                #region Responsáveis do empreendimento receptor

                comando = bancoDeDados.CriarComando("delete from {0}esp_tcpfarlc_rec_resp t ", EsquemaBanco);
                comando.DbCommand.CommandText += String.Format("where t.especificidade = :especificidade {0}",
                                                               comando.AdicionarNotIn("and", "t.id", DbType.Int32, especificidade.ReceptorResponsaveisEmpreendimento.Select(x => x.IdRelacionamento).ToList()));
                comando.AdicionarParametroEntrada("especificidade", especificidade.ID, DbType.Int32);

                bancoDeDados.ExecutarNonQuery(comando);

                foreach (var item in especificidade.ReceptorResponsaveisEmpreendimento)
                {
                    if (item.IdRelacionamento > 0)
                    {
                        comando = bancoDeDados.CriarComando(@"update {0}esp_tcpfarlc_rec_resp t set t.responsavel = :responsavel, t.tid = :tid where t.id = :id", EsquemaBanco);
                        comando.AdicionarParametroEntrada("id", item.IdRelacionamento, DbType.Int32);
                    }
                    else
                    {
                        comando = bancoDeDados.CriarComando(@"
						insert into {0}esp_tcpfarlc_rec_resp (id, especificidade, responsavel, tid) 
						values ({0}seq_esp_tcpfarlc_rec_resp.nextval, :especificidade, :responsavel, :tid)"                        , EsquemaBanco);
                        comando.AdicionarParametroEntrada("especificidade", especificidade.ID, DbType.Int32);
                    }

                    comando.AdicionarParametroEntrada("responsavel", item.Id, DbType.Int32);
                    comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());

                    bancoDeDados.ExecutarNonQuery(comando);
                }

                #endregion

                Historico.Gerar(especificidade.Titulo.Id, eHistoricoArtefatoEspecificidade.termocpfarlc, acao, bancoDeDados);

                bancoDeDados.Commit();
            }
        }
        internal Termo ObterDadosPDF(int titulo, BancoDeDados banco = null)
        {
            Termo        termo        = new Termo();
            TermoCPFARLC termoCPFARLC = Obter(titulo, banco);

            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                Comando comando = null;

                #region Título

                DadosPDF      dados = DaEsp.ObterDadosTitulo(titulo, bancoDeDados);
                Dominialidade dominialidadeCedente   = new DominialidadeBus().ObterPorEmpreendimento(dados.Empreendimento.Id.GetValueOrDefault());
                Dominialidade dominialidadeReceptora = new DominialidadeBus().ObterPorEmpreendimento(termoCPFARLC.ReceptorEmpreendimentoID);

                termo.Titulo = dados.Titulo;
                termo.Titulo.SetorEndereco = DaEsp.ObterEndSetor(termo.Titulo.SetorId);
                termo.Protocolo            = dados.Protocolo;
                termo.Empreendimento       = dados.Empreendimento;
                termo.Dominialidade        = new DominialidadePDF();

                #endregion

                #region Especificidade

                #region Empreendimento Cedente

                termo.Interessados = new List <PessoaPDF>();
                foreach (var interessado in termoCPFARLC.CedenteResponsaveisEmpreendimento)
                {
                    termo.Interessados.Add(new PessoaPDF()
                    {
                        NomeRazaoSocial = interessado.NomeRazao.Remove(0, interessado.NomeRazao.LastIndexOf('-') + 1).Trim(),
                        TipoTexto       = interessado.TipoTexto
                    });
                }

                #endregion

                #region Empreendimento Receptor

                comando = bancoDeDados.CriarComando(@"
					select e.denominador, e.codigo, tee.logradouro, tee.numero, tee.distrito, lm.texto endMunicipio, d.croqui_area from {0}tab_empreendimento e, {0}tab_empreendimento_endereco tee,
					{0}lov_municipio lm, {0}esp_termo_cpfarlc c, {0}crt_dominialidade d where tee.empreendimento = e.id and lm.id = tee.municipio and e.id = c.emp_receptor 
					and d.empreendimento = c.emp_receptor and c.titulo = :titulo"                    , EsquemaBanco);

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

                using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
                {
                    if (reader.Read())
                    {
                        termo.Empreendimento2.Denominador      = reader.GetValue <string>("denominador");
                        termo.Empreendimento2.Codigo           = reader.GetValue <string>("codigo");
                        termo.Empreendimento2.EndLogradouro    = reader.GetValue <string>("logradouro");
                        termo.Empreendimento2.EndNumero        = reader.GetValue <string>("numero");
                        termo.Empreendimento2.EndDistrito      = reader.GetValue <string>("distrito");
                        termo.Empreendimento2.EndMunicipio     = reader.GetValue <string>("endMunicipio");
                        termo.Empreendimento2.ATPCroquiDecimal = reader.GetValue <decimal>("croqui_area");
                    }

                    reader.Close();
                }

                termo.Interessados2 = new List <PessoaPDF>();
                foreach (var interessado in termoCPFARLC.ReceptorResponsaveisEmpreendimento)
                {
                    termo.Interessados2.Add(new PessoaPDF()
                    {
                        NomeRazaoSocial = interessado.NomeRazao.Remove(0, interessado.NomeRazao.LastIndexOf('-') + 1).Trim(),
                        TipoTexto       = interessado.TipoTexto
                    });
                }

                #endregion

                #region Matricula/Posse

                DominioPDF dominioCedentePDF = new DominioPDF(dominialidadeCedente.Dominios.SingleOrDefault(d => d.Id == termoCPFARLC.CedenteDominioID));
                dominioCedentePDF.TipoCompensacao = "Cedente";
                termo.Dominialidade.Dominios.Add(dominioCedentePDF);

                DominioPDF dominioReceptorPDF = new DominioPDF(dominialidadeReceptora.Dominios.SingleOrDefault(x => x.Id == termoCPFARLC.ReceptorDominioID));
                dominioReceptorPDF.TipoCompensacao = "Receptor";
                termo.Dominialidade.Dominios.Add(dominioReceptorPDF);

                #endregion

                #region ARL

                termo.RLPreservada = new List <AreaReservaLegalPDF>();
                termo.RLFormacao   = new List <AreaReservaLegalPDF>();

                List <ReservaLegal> reservas = dominialidadeCedente.Dominios.SelectMany(x => x.ReservasLegais).Where(x => termoCPFARLC.CedenteARLCompensacao.Select(y => y.Id).Any(y => y == x.Id)).ToList();

                reservas.ForEach(x =>
                {
                    AreaReservaLegalPDF areaARLPdf = new AreaReservaLegalPDF()
                    {
                        Tipo          = x.SituacaoVegetalId.GetValueOrDefault(),
                        AreaCroqui    = x.ARLCroqui.ToStringTrunc(),
                        Identificacao = x.Identificacao,
                        CoordenadaE   = x.Coordenada.EastingUtm.ToString(),
                        CoordenadaN   = x.Coordenada.NorthingUtm.ToString()
                    };

                    if (areaARLPdf.Tipo == (int)eReservaLegalSituacaoVegetal.Preservada)
                    {
                        termo.RLPreservada.Add(areaARLPdf);
                    }
                    else if (areaARLPdf.Tipo == (int)eReservaLegalSituacaoVegetal.EmRecuperacao)
                    {
                        termo.RLFormacao.Add(areaARLPdf);
                    }
                });

                termo.RLTotalPreservada = termo.RLPreservada.Sum(x => Convert.ToDecimal(x.AreaCroqui)).ToStringTrunc();
                termo.RLTotalFormacao   = termo.RLFormacao.Sum(x => Convert.ToDecimal(x.AreaCroqui)).ToStringTrunc();
                termo.Empreendimento2.ARLRecebidaDecimal = termo.Dominialidade.ARLCedente;

                #endregion

                #endregion
            }

            return(termo);
        }
        internal TermoCPFARLC Obter(int titulo, BancoDeDados banco = null)
        {
            TermoCPFARLC especificidade = new TermoCPFARLC();

            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                #region Dados da Especificidade

                Comando comando = bancoDeDados.CriarComando(@"
				select e.id, e.tid, e.titulo, e.protocolo, p.protocolo protocolo_tipo, p.requerimento, n.numero, n.ano, e.dominio_cedente, e.dominio_receptor, e.emp_receptor, 
				(select t.denominador from tab_empreendimento t where t.id = e.emp_receptor) denominador, e.dominialidade, e.dominialidade_tid 
				from {0}esp_termo_cpfarlc e, {0}tab_protocolo p, {0}tab_titulo_numero n 
				where n.titulo(+) = e.titulo and e.protocolo = p.id and e.titulo = :titulo"                , EsquemaBanco);

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

                using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
                {
                    if (reader.Read())
                    {
                        especificidade.Titulo.Id                   = titulo;
                        especificidade.ID                          = reader.GetValue <int>("id");
                        especificidade.TID                         = reader.GetValue <string>("tid");
                        especificidade.ProtocoloReq.Id             = reader.GetValue <int>("protocolo");
                        especificidade.ProtocoloReq.IsProcesso     = reader.GetValue <int>("protocolo_tipo") == 1;
                        especificidade.ProtocoloReq.RequerimentoId = reader.GetValue <int>("requerimento");
                        especificidade.Titulo.Numero.Inteiro       = reader.GetValue <int>("numero");
                        especificidade.Titulo.Numero.Ano           = reader.GetValue <int>("ano");

                        especificidade.CedenteDominioID                  = reader.GetValue <int>("dominio_cedente");
                        especificidade.ReceptorDominioID                 = reader.GetValue <int>("dominio_receptor");
                        especificidade.ReceptorEmpreendimentoID          = reader.GetValue <int>("emp_receptor");
                        especificidade.ReceptorEmpreendimentoDenominador = reader.GetValue <string>("denominador");

                        especificidade.DominialidadeID  = reader.GetValue <int>("dominialidade");
                        especificidade.DominialidadeTID = reader.GetValue <string>("dominialidade_tid");
                    }

                    reader.Close();
                }

                #endregion

                #region Reservas Cedente

                comando = bancoDeDados.CriarComando(@"
				select r.dominialidade_reserva_id Id, t.id IDRelacionamento, r.identificacao Identificacao, r.arl_croqui ARLCroqui 
				from esp_tcpfarlc_ced_rese t, esp_termo_cpfarlc e, hst_crt_dominialidade_reserva r 
				where t.especificidade = e.id and r.dominialidade_reserva_id = t.reserva 
				and r.id_hst in (select d.id from hst_crt_dominialidade_dominio d where d.dominialidade_id = e.dominialidade 
				and d.dominialidade_tid = e.dominialidade_tid) and e.titulo = :titulo"                , EsquemaBanco);

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

                especificidade.CedenteARLCompensacao = bancoDeDados.ObterEntityList <ReservaLegal>(comando);

                #endregion

                #region Responsáveis do empreendimento cendente

                comando = bancoDeDados.CriarComando(@"
					select p.id Id, t.id IdRelacionamento,(case when lv.id != 9 /*Outro*/ then lv.texto else ter.especificar end) TipoTexto, (case when lv.id != 9 /*Outro*/ then lv.texto
					else ter.especificar end)  || ' - ' || nvl(p.nome, p.razao_social) NomeRazao from {0}esp_tcpfarlc_ced_resp t, {0}esp_termo_cpfarlc e, {0}tab_titulo tt, {0}tab_pessoa p,
					{0}tab_empreendimento_responsavel ter, {0}lov_empreendimento_tipo_resp lv where t.especificidade = e.id and tt.id = e.titulo and p.id = t.responsavel and ter.responsavel = t.responsavel
					and ter.empreendimento(+) = tt.empreendimento and lv.id(+) = ter.tipo and e.titulo = :titulo"                    , EsquemaBanco);

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

                especificidade.CedenteResponsaveisEmpreendimento = bancoDeDados.ObterEntityList <Responsavel>(comando);

                #endregion

                #region Responsáveis do empreendimento receptor

                comando = bancoDeDados.CriarComando(@"
					select p.id Id, t.id IdRelacionamento, (case when lv.id != 9 /*Outro*/ then lv.texto else ter.especificar end) TipoTexto, 
					(case when lv.id != 9 /*Outro*/ then lv.texto else ter.especificar end) || ' - ' || nvl(p.nome, p.razao_social) NomeRazao
					from esp_tcpfarlc_rec_resp t, esp_termo_cpfarlc e, tab_pessoa p, tab_empreendimento_responsavel ter, lov_empreendimento_tipo_resp lv
					where t.especificidade = e.id and p.id = t.responsavel and ter.responsavel = t.responsavel and ter.empreendimento(+) = e.emp_receptor
					and lv.id(+) = ter.tipo and e.titulo = :titulo"                    , EsquemaBanco);

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

                especificidade.ReceptorResponsaveisEmpreendimento = bancoDeDados.ObterEntityList <Responsavel>(comando);

                #endregion
            }

            return(especificidade);
        }
Exemple #6
0
        public bool Salvar(IEspecificidade especificidade)
        {
            TermoCPFARLC          esp                   = especificidade as TermoCPFARLC;
            TermoCPFARLCDa        termoCPFARLCDa        = new TermoCPFARLCDa();
            CaracterizacaoBus     caracterizacaoBus     = new CaracterizacaoBus();
            CaracterizacaoValidar caracterizacaoValidar = new CaracterizacaoValidar();
            DominialidadeDa       dominialidadeDa       = new DominialidadeDa();
            EspecificidadeDa      especificidadeDa      = new EspecificidadeDa();
            GerenciadorConfiguracao <ConfiguracaoCaracterizacao> caracterizacaoConfig = new GerenciadorConfiguracao <ConfiguracaoCaracterizacao>(new ConfiguracaoCaracterizacao());
            string           caracterizacaoTipo = caracterizacaoConfig.Obter <List <CaracterizacaoLst> >(ConfiguracaoCaracterizacao.KeyCaracterizacoes).Single(x => x.Id == (int)eCaracterizacao.Dominialidade).Texto;
            List <PessoaLst> responsaveis       = new List <PessoaLst>();

            RequerimentoAtividade(esp, jaAssociado: false);

            #region Básicas

            if (esp.CedenteDominioID <= 0)
            {
                Validacao.Add(Mensagem.TermoCPFARLC.CedenteDominioObrigatorio);
            }

            if (esp.CedenteARLCompensacao == null || esp.CedenteARLCompensacao.Count <= 0)
            {
                Validacao.Add(Mensagem.TermoCPFARLC.CedenteARLCompensacaoObrigatoria);
            }
            else
            {
                if (esp.CedenteARLCompensacao.Any(x => esp.CedenteARLCompensacao.Count(y => y.Id == x.Id && y.Id > 0) > 1))
                {
                    Validacao.Add(Mensagem.TermoCPFARLC.CedenteARLCompensacaoDuplicada);
                }
            }

            if (esp.CedenteResponsaveisEmpreendimento == null || esp.CedenteResponsaveisEmpreendimento.Count <= 0)
            {
                Validacao.Add(Mensagem.TermoCPFARLC.ResponsavelEmpreendimentoObrigatorio("Cedente", "cedente"));
            }
            else
            {
                if (esp.CedenteResponsaveisEmpreendimento.Any(x => esp.CedenteResponsaveisEmpreendimento.Count(y => y.Id == x.Id && y.Id > 0) > 1))
                {
                    Validacao.Add(Mensagem.TermoCPFARLC.ResponsavelEmpreendimentoDuplicado("Cedente", "cedente"));
                }
            }

            if (esp.ReceptorEmpreendimentoID <= 0)
            {
                Validacao.Add(Mensagem.TermoCPFARLC.ReceptorEmpreendimentoObrigatorio);
            }

            if (esp.ReceptorDominioID <= 0)
            {
                Validacao.Add(Mensagem.TermoCPFARLC.ReceptorDominioObrigatorio);
            }

            if (esp.ReceptorResponsaveisEmpreendimento == null || esp.ReceptorResponsaveisEmpreendimento.Count <= 0)
            {
                Validacao.Add(Mensagem.TermoCPFARLC.ResponsavelEmpreendimentoObrigatorio("Receptor", "receptor"));
            }
            else
            {
                if (esp.ReceptorResponsaveisEmpreendimento.Any(x => esp.ReceptorResponsaveisEmpreendimento.Count(y => y.Id == x.Id && y.Id > 0) > 1))
                {
                    Validacao.Add(Mensagem.TermoCPFARLC.ResponsavelEmpreendimentoDuplicado("Receptor", "receptor"));
                }
            }

            #endregion Básicas

            if (esp.Atividades.First().Id != ConfiguracaoAtividade.ObterId((int)eAtividadeCodigo.ReservaLegal))
            {
                Validacao.Add(Mensagem.TermoCPFARLC.AtividadeInvalida(esp.Atividades[0].NomeAtividade));
            }

            if (!Validacao.EhValido)
            {
                return(false);
            }

            #region Cedente

            Dominialidade dominialidadeCedente = dominialidadeDa.ObterPorEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(0));
            dominialidadeCedente.Dependencias = caracterizacaoBus.ObterDependencias(dominialidadeCedente.Id, eCaracterizacao.Dominialidade, eCaracterizacaoDependenciaTipo.Caracterizacao);

            if (esp.CedenteARLCompensacao.Exists(x => x.SituacaoVegetalId.Equals((int)eReservaLegalSituacaoVegetal.NaoCaracterizada) ||
                                                 x.SituacaoVegetalId.Equals((int)eReservaLegalSituacaoVegetal.EmUso)))
            {
            }


            if (dominialidadeCedente == null || dominialidadeCedente.Id <= 0)
            {
                Validacao.Add(Mensagem.TermoCPFARLC.DominialidadeInexistente("cedente", caracterizacaoTipo));
            }
            else
            {
                string retorno = caracterizacaoValidar.DependenciasAlteradas(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(), (int)eCaracterizacao.Dominialidade,
                                                                             eCaracterizacaoDependenciaTipo.Caracterizacao, dominialidadeCedente.Dependencias);

                if (!string.IsNullOrEmpty(retorno))
                {
                    Validacao.Add(Mensagem.TermoCPFARLC.CaracterizacaoDeveEstarValida("cedente", caracterizacaoTipo));
                }
                else
                {
                    List <ReservaLegal> reservas = dominialidadeCedente.Dominios.SelectMany(x => x.ReservasLegais).Where(x => esp.CedenteARLCompensacao.Select(y => y.Id).Any(y => y == x.Id)).ToList();

                    if (reservas.Any(x => !x.Compensada))
                    {
                        Validacao.Add(Mensagem.TermoCPFARLC.ARLCedenteTipoInvalida);
                    }

                    if (reservas.Any(x => x.SituacaoId != (int)eReservaLegalSituacao.Proposta))
                    {
                        Validacao.Add(Mensagem.TermoCPFARLC.ARLCedenteSituacaoInvalida);
                    }

                    if (reservas.Any(x => x.SituacaoVegetalId != (int)eReservaLegalSituacaoVegetal.Preservada && x.SituacaoVegetalId != (int)eReservaLegalSituacaoVegetal.EmRecuperacao))
                    {
                        Validacao.Add(Mensagem.TermoCPFARLC.ARLCedenteSituacaoVegetalInvalida);
                    }

                    if (!dominialidadeCedente.Dominios.Any(x => x.Id.GetValueOrDefault() == esp.CedenteDominioID))
                    {
                        Validacao.Add(Mensagem.TermoCPFARLC.DominioDessassociado("cedente"));
                    }

                    esp.CedenteARLCompensacao.ForEach(reserva =>
                    {
                        ReservaLegal aux = reservas.SingleOrDefault(x => x.Id == reserva.Id);

                        if (aux == null || aux.Id <= 0)
                        {
                            Validacao.Add(Mensagem.TermoCPFARLC.ReservaLegalDessassociadoCedente(reserva.Identificacao));
                        }
                        else
                        {
                            if (aux.MatriculaId != esp.ReceptorDominioID)
                            {
                                Validacao.Add(Mensagem.TermoCPFARLC.ReservaLegalDessassociadoReceptorDominio(reserva.Identificacao));
                            }
                        }
                    });
                }
            }

            responsaveis = especificidadeDa.ObterEmpreendimentoResponsaveis(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(0));
            esp.CedenteResponsaveisEmpreendimento.ForEach(resp =>
            {
                PessoaLst aux = responsaveis.SingleOrDefault(x => x.Id == resp.Id);

                if (aux == null || aux.Id <= 0)
                {
                    Validacao.Add(Mensagem.TermoCPFARLC.ResponsavelDessassociado("cedente", resp.NomeRazao));
                }
            });

            #endregion Cedente

            #region Receptor

            Dominialidade dominialidadeReceptor = dominialidadeDa.ObterPorEmpreendimento(esp.ReceptorEmpreendimentoID);
            dominialidadeReceptor.Dependencias = caracterizacaoBus.ObterDependencias(dominialidadeReceptor.Id, eCaracterizacao.Dominialidade, eCaracterizacaoDependenciaTipo.Caracterizacao);

            if (dominialidadeReceptor == null || dominialidadeReceptor.Id <= 0)
            {
                Validacao.Add(Mensagem.TermoCPFARLC.DominialidadeInexistente("receptor", caracterizacaoTipo));
            }
            else
            {
                string retorno = caracterizacaoValidar.DependenciasAlteradas(esp.ReceptorEmpreendimentoID, (int)eCaracterizacao.Dominialidade,
                                                                             eCaracterizacaoDependenciaTipo.Caracterizacao, dominialidadeReceptor.Dependencias);

                if (!string.IsNullOrEmpty(retorno))
                {
                    Validacao.Add(Mensagem.TermoCPFARLC.CaracterizacaoDeveEstarValida("receptor", caracterizacaoTipo));
                }
                else
                {
                    if (!dominialidadeReceptor.Dominios.Any(x => x.Id.GetValueOrDefault() == esp.ReceptorDominioID))
                    {
                        Validacao.Add(Mensagem.TermoCPFARLC.DominioDessassociado("receptor"));
                    }

                    List <ReservaLegal> reservas = dominialidadeReceptor.Dominios.SelectMany(x => x.ReservasLegais).Where(x => esp.CedenteARLCompensacao.Select(y => y.Id).Any(y => y == x.IdentificacaoARLCedente)).ToList();

                    esp.CedenteARLCompensacao.ForEach(reserva =>
                    {
                        if (!reservas.Any(x => x.IdentificacaoARLCedente == reserva.Id))
                        {
                            Validacao.Add(Mensagem.TermoCPFARLC.ReservaLegalDessassociadoReceptor(reserva.Identificacao));
                        }
                    });
                }
            }

            responsaveis = especificidadeDa.ObterEmpreendimentoResponsaveis(esp.ReceptorEmpreendimentoID);
            esp.ReceptorResponsaveisEmpreendimento.ForEach(resp =>
            {
                PessoaLst aux = responsaveis.SingleOrDefault(x => x.Id == resp.Id);

                if (aux == null || aux.Id <= 0)
                {
                    Validacao.Add(Mensagem.TermoCPFARLC.ResponsavelDessassociado("receptor", resp.NomeRazao));
                }
            });

            #endregion Receptor

            List <TituloModeloLst> lista = termoCPFARLCDa.ObterTitulosCedenteReceptor(esp.CedenteDominioID, esp.ReceptorDominioID);
            lista.ForEach(titulo =>
            {
                if (titulo.Id != esp.Titulo.Id)
                {
                    if (string.IsNullOrEmpty(titulo.Texto))
                    {
                        Validacao.Add(Mensagem.TermoCPFARLC.DominioPossuiTituloCadastrado(titulo.Situacao));
                    }
                    else
                    {
                        Validacao.Add(Mensagem.TermoCPFARLC.DominioPossuiTituloConcluido(titulo.Sigla, titulo.Texto, titulo.Situacao));
                    }
                }
            });

            return(Validacao.EhValido);
        }
Exemple #7
0
        public TermoCPFARLCVM(List <Protocolos> processosDocumentos, List <AtividadeSolicitada> atividades, List <TituloCondicionante> condicionantes, TermoCPFARLC especificidade,
                              string processoDocumentoSelecionado, bool isVisualizar, int atividadeSelecionada)
        {
            IsVisualizar   = isVisualizar;
            Especificidade = especificidade ?? new TermoCPFARLC();

            Atividades = new AtividadeEspecificidadeVM(processosDocumentos, atividades, processoDocumentoSelecionado, atividadeSelecionada, isVisualizar);
            Atividades.MostrarBotoes = false;

            #region Remover depois

            Condicionantes = Condicionantes ?? new TituloCondicionanteVM();

            CedenteDominios = ViewModelHelper.CriarSelectList(new List <Lista>(), true, true);
            CedenteReservas = ViewModelHelper.CriarSelectList(new List <Lista>(), true, true);
            CedenteResponsaveisEmpreendimento = ViewModelHelper.CriarSelectList(new List <Lista>(), true, true);
            ReceptorEmpreendimentos           = ViewModelHelper.CriarSelectList(new List <Lista>(), true, true);
            ReceptorDominios = ViewModelHelper.CriarSelectList(new List <Lista>(), true, true);
            ReceptorResponsaveisEmpreendimento = ViewModelHelper.CriarSelectList(new List <Lista>(), true, true);

            #endregion

            Condicionantes.MostrarBotoes  = !isVisualizar;
            Condicionantes.Condicionantes = condicionantes ?? new List <TituloCondicionante>();
        }