public bool ValidarAssociar(IProtocolo protocolo, int funcionarioId)
{
if (!_busProtocolo.EmPosse(protocolo.Id.GetValueOrDefault(0), funcionarioId))
{
if (protocolo.IsProcesso)
{
Validacao.Add(Mensagem.Processo.PosseProcessoNecessaria);
}
else
{
Validacao.Add(Mensagem.Documento.PosseDocumentoNecessaria);
}
return(Validacao.EhValido);
}
if (protocolo.Requerimento.Id <= 0)
{
Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoRequerimentoObrigatorio);
}
if (protocolo.Empreendimento.Id <= 0)
{
Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoEmpreendimentoObrigatorio);
}
return(Validacao.EhValido);
}
public bool VerificarApensarProcesso(string numero, int procPaiId)
{
if (String.IsNullOrWhiteSpace(numero))
{
Validacao.Add(Mensagem.Tramitacao.JuntarApensarProcessoNumeroObrigatorio);
}
else if (!ValidacoesGenericasBus.ValidarMaskNumeroBarraAno(numero))
{
Validacao.Add(Mensagem.Tramitacao.JuntarApensarProcessoNumeroInvalido);
}
if (Validacao.EhValido)
{
IProtocolo prot = _busProtocolo.ObterSimplificado(_busProtocolo.ExisteProtocolo(numero), true);
if (prot == null || prot.Id <= 0 || !prot.IsProcesso)
{
Validacao.Add(Mensagem.Processo.Inexistente);
return(Validacao.EhValido);
}
VerificarApensarProcesso(prot, procPaiId);
}
return(Validacao.EhValido);
}
public ActionResult ObterProtocolo(int id, bool isProcesso)
{
List <PessoaLst> lista = _busProtocolo.ObterInteressadoRepresentantes(id);
IProtocolo protocolo = _busProtocolo.ObterSimplificado(id);
if (lista.Count == 0)
{
lista.Add(new PessoaLst()
{
Id = protocolo.Interessado.Id
});
}
return(Json(new
{
@EhValido = Validacao.EhValido,
@Msg = Validacao.Erros,
@Objeto = new
{
@Id = id,
@Numero = protocolo.Numero,
@EmpreendimentoId = protocolo.Empreendimento.Id,
@EmpreendimentoNome = protocolo.Empreendimento.Denominador,
@Interessado = protocolo.Interessado,
@Representantes = lista
}
}));
}
public ActionResult Visualizar(int id)
{
IProtocolo protocolo = _bus.Obter(id, validarPosse: false);
if (!Validacao.EhValido)
{
return(RedirectToAction("Index", Validacao.QueryParamSerializer()));
}
if (protocolo.IsProcesso)
{
Processo processo = protocolo as Processo;
ProcessoVM vm = new ProcessoVM(ListaCredenciadoBus.TiposProcesso, processo.Tipo.Id);
vm.RequerimentoVM.IsVisualizar = true;
vm.RequerimentoVM.IsRequerimentoProcesso = true;
vm.SetProcesso(processo, ListaCredenciadoBus.ResponsavelFuncoes);
vm.IsEditar = false;
vm.RequerimentoVM.IsEditar = false;
return(View("ProcessoVisualizar", vm));
}
else
{
Documento documento = protocolo as Documento;
DocumentoVM vm = new DocumentoVM(ListaCredenciadoBus.TiposDocumento, documento.Tipo.Id);
vm.SetDocumento(documento, ListaCredenciadoBus.ResponsavelFuncoes);
vm.RequerimentoVM.IsVisualizar = true;
return(View("DocumentoVisualizar", vm));
}
}
public ActionResult ObterProcessosDocumentos(int protocoloId)
{
List <Protocolos> lstProcessosDocumentos = _busTitulo.ObterProcessosDocumentos(protocoloId);
IProtocolo proc = _busProtocolo.Obter(protocoloId);
if (!_bus.ValidarAssociar(proc, Usuario.EtramiteIdentity.FuncionarioId))
{
return(Json(new
{
@EhValido = Validacao.EhValido,
@Msg = Validacao.Erros
},
JsonRequestBehavior.AllowGet));
}
Empreendimento emp = new EmpreendimentoBus().Obter(proc.Empreendimento.Id);
return(Json(new
{
@EhValido = Validacao.EhValido,
@Msg = Validacao.Erros,
@ProcessosDocumentos = lstProcessosDocumentos,
@Empreendimento = emp,
@DeclaranteLst = _bus.ObterResponsaveis(emp.Id)
},
JsonRequestBehavior.AllowGet));
}
public IProtocolo Obter(int id)
{
IProtocolo protocolo = null;
try
{
protocolo = _da.Obter(id);
//if ((protocolo.Id ?? 0) <= 0)
//{
// Validacao.Add(Mensagem.Processo.Inexistente);
//}
//else
//{
// if (protocolo.Arquivo != null && protocolo.Arquivo.Id > 0)
// {
// ArquivoDa _arquivoDa = new ArquivoDa();
// protocolo.Arquivo = _arquivoDa.Obter(protocolo.Arquivo.Id.Value);
// }
//}
//if (protocolo.Arquivo != null && protocolo.Arquivo.Id > 0)
//{
// ArquivoDa _arquivoDa = new ArquivoDa();
// protocolo.Arquivo = _arquivoDa.Obter(protocolo.Arquivo.Id.Value);
//}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(protocolo);
}
public Cobranca(Fiscalizacao fiscalizacao, IProtocolo protocolo, Notificacao notificacao)
{
FiscalizacaoId = fiscalizacao.Id;
NumeroFiscalizacao = fiscalizacao.Id;
NumeroIUF = fiscalizacao.Multa.NumeroIUF ?? fiscalizacao.Infracao.NumeroAutoInfracaoBloco ?? fiscalizacao.NumeroAutos.ToString();
SerieId = fiscalizacao.Multa.SerieId;
SerieTexto = fiscalizacao.Multa.SerieTexto;
DataEmissaoIUF = fiscalizacao.Multa.DataLavratura;
AutuadoPessoa = fiscalizacao.AutuadoPessoa;
AutuadoPessoaId = fiscalizacao.AutuadoPessoa.Id;
CodigoReceitaId = fiscalizacao.Multa.CodigoReceitaId ?? 0;
if (protocolo?.Id > 0)
{
ProcessoNumero = protocolo.Numero;
NumeroAutuacao = protocolo.NumeroAutuacao;
}
if (notificacao.Id > 0)
{
Notificacao = notificacao;
DataIUF = notificacao.DataIUF;
DataJIAPI = notificacao.DataJIAPI;
DataCORE = notificacao.DataCORE;
}
Parcelamentos = new List <CobrancaParcelamento>();
Parcelamentos.Add(new CobrancaParcelamento(fiscalizacao));
}
public ListarAtividadesSolicitadasVME(IProtocolo protocolo, bool isEncerrar)
{
ProtocoloId = protocolo.Id;
Requerimento = protocolo.Requerimento;
Atividades = protocolo.Atividades;
IsEncerrar = isEncerrar;
IsProcesso = protocolo.IsProcesso;
}
public ProtocoloLocalizacao ObterLocalizacao(int protocoloId, ProtocoloLocalizacao localizacao = null)
{
ProtocoloLocalizacao loc = localizacao == null ? new ProtocoloLocalizacao() : localizacao;
IProtocolo protocolo = ObterSimplificado(protocoloId);
if (loc.ProcessoPaiId <= 0)
{
int ApensadoEmProcessoId = ProcessoApensado(protocoloId);
if (ApensadoEmProcessoId > 0)
{
loc.ProcessoPaiId = ApensadoEmProcessoId;
loc.ProcessoPaiNumero = ObterSimplificado(loc.ProcessoPaiId).Numero;
return(ObterLocalizacao(loc.ProcessoPaiId, loc));
}
}
TramitacaoBus _busTramitacao = new TramitacaoBus(new TramitacaoValidar());
loc.Tramitacao.Id = _busTramitacao.ObterTramitacaoProtocolo(protocoloId);
if (loc.Tramitacao.Id > 0)
{
loc.Tramitacao = _busTramitacao.Obter(loc.Tramitacao.Id);
if (loc.Tramitacao.SituacaoId == (int)eTramitacaoSituacao.Arquivado)
{
loc.Localizacao = eLocalizacaoProtocolo.Arquivado;
ArquivarBus _arquivarBus = new ArquivarBus();
Arquivar arquivamento = _arquivarBus.ObterArquivamento(loc.Tramitacao.Id);
loc.ArquivoNome = arquivamento.ArquivoNome;
}
else if (loc.Tramitacao.SituacaoId == (int)eTramitacaoSituacao.ParaOrgaoExterno)
{
loc.Localizacao = eLocalizacaoProtocolo.OrgaoExterno;
loc.OrgaoExternoNome = loc.Tramitacao.OrgaoExterno.Texto;
}
else if (loc.Tramitacao.SituacaoId == (int)eTramitacaoSituacao.Tramitando)
{
if (loc.Tramitacao.Destinatario.Id == 0)
{
loc.Localizacao = eLocalizacaoProtocolo.EnviadoParaSetor;
}
else
{
loc.Localizacao = eLocalizacaoProtocolo.EnviadoParaFuncionario;
loc.FuncionarioDestinatarioNome = loc.Tramitacao.Destinatario.Nome;
}
}
}
else // se não existir tramitação, ele está na posse de algum funcionário
{
loc.Localizacao = eLocalizacaoProtocolo.PosseFuncionario;
TramitacaoPosse posse = _busTramitacao.ObterProtocoloPosse(protocoloId);
loc.FuncionarioDestinatarioNome = posse.FuncionarioNome;
loc.SetorDestinatarioNome = posse.SetorNome;
}
return(loc);
}
public ActionResult AtividadesSolicitadas(RequerimentoAnaliseVME requerimento)
{
IProtocolo protocolo = _protocoloBus.ObterAtividadesProtocolo(requerimento.ProtocoloId) as IProtocolo;
ListarAtividadesSolicitadasVM vm = new ListarAtividadesSolicitadasVM(_busLista.TiposProcesso, _busLista.TiposDocumento, protocolo, protocolo.Tipo.Id);
vm.Protocolo = protocolo;
vm.IsEncerrar = false;
return(PartialView("AtividadesSolicitadaAnalise", vm));
}
public ActionResult Analisar(int protocoloId = 0, int requerimentoId = 0)
{
AnaliseItemVM vm = new AnaliseItemVM();
if (protocoloId == 0 || requerimentoId == 0)
{
return(View(vm));
}
IProtocolo protocolo = _protocoloBus.Obter(protocoloId);
AnaliseItem analise = _bus.VerificarProtocolo(protocolo.Numero);
if (!Validacao.EhValido)
{
return(RedirectToAction("Analisar", "AnaliseItens", Validacao.QueryParamSerializer()));
}
vm.Requerimentos = analise.Requerimentos;
vm.RequerimentoSelecionado = requerimentoId;
vm.ProjetoDigitalId = _busProjetoDigitalCredenciado.ObterProjetoDigitalId(requerimentoId);
vm.ProtocoloId = protocoloId;
vm.ProtocoloNumero = protocolo.Numero;
Requerimento req = vm.Requerimentos.FirstOrDefault(x => x.Id == requerimentoId);
AnaliseItem analiseAux = _bus.ObterPorChecagem(req.Checagem);
if (analiseAux != null && analiseAux.Id > 0)
{
analise.Id = analiseAux.Id;
analise.Situacao = analiseAux.Situacao;
}
if (_validar.ValidarProtocoloAnalisar(req.Checagem, req.Id, protocolo.IsProcesso))
{
if (_validar.Analise(analise))
{
// Caso não exista a analise na entrada no metodo abaixo a mesma vai ser criada
analise = _bus.ObterAnaliseProtocolo(req, protocolo.Id.GetValueOrDefault(), false);
vm.AnaliseId = analise.Id;
vm.CheckListId = req.Checagem;
vm.Atualizado = false;
vm.Roteiros = analise.Roteiros;
analise.Itens.ForEach(x => x.Analista = string.Empty);
vm.ListarItens = analise.Itens;
}
}
vm.Situacao = analise.Situacao;
vm.UrlsCaracterizacoes = ObterUrlsCaracterizacoes(_busCaracterizacao.ObterCaracterizacoes(vm.ProjetoDigitalId));
return(View(vm));
}
public bool Salvar(PecaTecnica pecaTecnica)
{
if (pecaTecnica.Elaborador <= 0)
{
Validacao.Add(Mensagem.AnaliseItem.PecaTecnicaElaboradorObrigatorio);
}
if (pecaTecnica.Atividade <= 0)
{
Validacao.Add(Mensagem.AnaliseItem.PecaTecnicaAtividadeObrigatorio);
}
if (pecaTecnica.ResponsaveisEmpreendimento.Count <= 0)
{
Validacao.Add(Mensagem.AnaliseItem.PecaTecnicaRespEmpreendimentoObrigatorio);
}
if (pecaTecnica.ElaboradorTipoEnum == eElaboradorTipo.TecnicoIdaf && pecaTecnica.SetorCadastro <= 0)
{
Validacao.Add(Mensagem.AnaliseItem.PecaTecnicaSetorObrigatorio);
}
if (!Validacao.EhValido)
{
return(false);
}
IProtocolo protocolo = _busProtocolo.ObterSimplificado(pecaTecnica.Protocolo.Id.GetValueOrDefault());
if (protocolo.Empreendimento.Id <= 0)
{
Validacao.Add(Mensagem.AnaliseItem.PecaTecnicaNaoPossuiEmpreendimento);
return(false);
}
List <Requerimento> requerimentos = _busProtocolo.ObterProtocoloRequerimentos(pecaTecnica.ProtocoloPai.GetValueOrDefault());
if (!requerimentos.Exists(x => x.ProtocoloId == pecaTecnica.Protocolo.Id))
{
Validacao.Add(Mensagem.AnaliseItem.PecaTecnicaRequerimentoNaoAssociado);
return(false);
}
ProjetoGeograficoBus busProjetoGeo = new ProjetoGeograficoBus();
int projetoGeoId = busProjetoGeo.ExisteProjetoGeografico(pecaTecnica.Protocolo.Empreendimento.Id, (int)eCaracterizacao.Dominialidade);
if (busProjetoGeo.ObterSitacaoProjetoGeografico(projetoGeoId) != (int)eProjetoGeograficoSituacao.Finalizado)
{
Validacao.Add(Mensagem.AnaliseItem.PecaTecnicaProjetoDeveSerFinalizado);
}
return(Validacao.EhValido);
}
public bool VerificarApensarProcesso(IProtocolo protocolo, int procPaiId)
{
if (!_validarProcesso.Numero(protocolo.Numero))
{
return(Validacao.EhValido);
}
Processo procPai = _busProcesso.ObterSimplificado(procPaiId, true);
if (protocolo.Id == procPai.Id)
{
Validacao.Add(Mensagem.Processo.NaoPodeApensarASiProprio);
return(Validacao.EhValido);
}
if (!_validarProcesso.EmPosse(procPai.Id.Value))
{
Validacao.Add(Mensagem.Processo.ProcessoNaoPodeApensarPoisNaoPossuiPosse);
return(Validacao.EhValido);
}
// valida se o processo já está apensado
string apensadoEmProcessoNumero = _busProtocolo.ObterNumeroProcessoPai(protocolo.Id);
if (!String.IsNullOrEmpty(apensadoEmProcessoNumero) && apensadoEmProcessoNumero != procPai.Numero)
{
Validacao.Add(Mensagem.Processo.ProcessoNaoPodeApensarPoisEstaApensado(apensadoEmProcessoNumero));
return(Validacao.EhValido);
}
if (String.IsNullOrEmpty(apensadoEmProcessoNumero) && !_validarProcesso.EmPosse(protocolo.Id.Value))
{
Validacao.Add(Mensagem.Processo.ProcessoNaoPodeSerApensadoPoisNaoPossuiPosse);
return(Validacao.EhValido);
}
// Valida se o processo filho já é pai de algo (documento, processo)
Processo procPaiFilhos = _busProtocolo.ObterProcessosDocumentos(protocolo.Id.Value) as Processo;
if (procPaiFilhos.Processos.Count > 0 || procPaiFilhos.Documentos.Count > 0)
{
Validacao.Add(Mensagem.Processo.ProcessoNaoPodeApensarPoisTemFilhos);
return(Validacao.EhValido);
}
if (String.IsNullOrEmpty(apensadoEmProcessoNumero) && protocolo.SetorId != procPai.SetorId)
{
Validacao.Add(Mensagem.Processo.ProcessoNaoPodeApensarPoisNaoEstaNoMesmoSetor);
return(Validacao.EhValido);
}
return(Validacao.EhValido);
}
public void ObterProtocolo(int id, bool isProcesso, Titulo titulo)
{
IProtocolo protocolo = BusProtocolo.ObterSimplificado(id);
if (protocolo.IsProcesso)
{
titulo.Protocolo = protocolo as Processo;
}
else
{
titulo.Protocolo = protocolo as Documento;
}
}
public IProtocolo ObterProcessosDocumentos(int id, BancoDeDados banco = null)
{
Processo processo = null;
IProtocolo protocolo = ObterAtividades(id, banco);
if (protocolo.IsProcesso)
{
processo = protocolo as Processo;
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
{
#region Processos Apensados/Documentos Juntados
Comando comando = bancoDeDados.CriarComando(@"select p.id, p.protocolo, p.associado, p.tipo, p.tid, r.id from
{0}tab_protocolo_associado p, {0}tab_protocolo pa, {0}tab_requerimento r where p.protocolo = :protocolo and p.associado = pa.id
and pa.requerimento = r.id(+) order by r.data_criacao" , EsquemaBanco);
comando.AdicionarParametroEntrada("protocolo", processo.Id, DbType.Int32);
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
Processo proc;
Documento doc;
while (reader.Read())
{
if (Convert.ToInt32(reader["tipo"]) == 1)
{
proc = ObterAtividades(Convert.ToInt32(reader["associado"]), bancoDeDados) as Processo;
processo.Processos.Add(proc);
}
else
{
doc = ObterAtividades(Convert.ToInt32(reader["associado"]), bancoDeDados) as Documento;
processo.Documentos.Add(doc);
}
}
reader.Close();
}
#endregion
}
return(processo);
}
else
{
return(protocolo as Documento);
}
}
public IProtocolo ObterSimplificado(int id)
{
IProtocolo protocolo = null;
try
{
protocolo = _busInterno.ObterSimplificado(id);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(protocolo);
}
public IProtocolo Obter(string numero)
{
IProtocolo protocolo = null;
try
{
protocolo = _da.Obter(_da.ExisteProtocolo(numero));
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(protocolo);
}
public bool ValidarRedirecionamentoEnviar(IProtocolo protocolo, bool permissaoTramitar)
{
bool registro = false;
_validar.RegraSetor(protocolo.SetorId, permissaoTramitar);
if (_da.ObterTipoSetor(protocolo.SetorId) == (int)eTramitacaoTipo.Registro)
{
if (_da.Registrador(User.FuncionarioId, protocolo.SetorId))
{
registro = true;
}
}
return(registro);
}
public ActionResult Visualizar(int id)
{
IProtocolo protocolo = _bus.Obter(id);
if (!Validacao.EhValido)
{
return(RedirectToAction("Index", Validacao.QueryParamSerializer()));
}
if (protocolo.IsProcesso)
{
Processo processo = protocolo as Processo;
ProcessoVM vm = new ProcessoVM(_busLista.TiposProcesso, processo.Tipo.Id);
vm.RequerimentoVM.IsVisualizar = true;
vm.RequerimentoVM.IsRequerimentoProcesso = true;
vm.SetProcesso(processo, _busLista.ResponsavelFuncoes);
vm.IsEditar = false;
vm.RequerimentoVM.IsEditar = false;
if (Request.IsAjaxRequest())
{
return(PartialView("ProcessoVisualizarModal", vm));
}
else
{
return(View("ProcessoVisualizar", vm));
}
}
else
{
Documento documento = protocolo as Documento;
DocumentoVM vm = new DocumentoVM(_busLista.TiposDocumento, documento.Tipo.Id);
vm.SetDocumento(documento, _busLista.ResponsavelFuncoes);
vm.RequerimentoVM.IsVisualizar = true;
if (Request.IsAjaxRequest())
{
return(PartialView("DocumentoVisualizarModal", vm));
}
else
{
return(View("DocumentoVisualizar", vm));
}
}
}
public IProtocolo ObterProtocoloAtividadesSolicitadas(int id)
{
ProtocoloInternoBus protocoloBus = new ProtocoloInternoBus();
IProtocolo protocolo = null;
Processo processo = null;
try
{
if (protocoloBus.ExisteProtocolo(id))
{
protocolo = protocoloBus.ObterProcessosDocumentos(id);
if (protocolo.IsProcesso)
{
processo = protocolo as Processo;
//remove os processos que não tem atividade
for (var i = 0; i < processo.Processos.Count; i++)
{
processo.Processos[i] = (protocoloBus.ExisteAtividade(processo.Processos[i].Id.Value)) ? processo.Processos[i] : null;
}
processo.Processos.RemoveAll(x => x == null);
//remove os documentos que não tem atividade
for (var i = 0; i < processo.Documentos.Count; i++)
{
processo.Documentos[i] = (protocoloBus.ExisteAtividade(processo.Documentos[i].Id.Value)) ? processo.Documentos[i] : null;
}
processo.Documentos.RemoveAll(x => x == null);
return(processo);
}
else
{
return(protocolo as Documento);
}
}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(null);
}
public bool PreDesarquivar(ListarTramitacaoFiltro filtros)
{
if (filtros.ArquivoId <= 0)
{
Validacao.Add(Mensagem.Arquivamento.DesarquivarArquivoObrigatorio);
return(Validacao.EhValido);
}
if (String.IsNullOrWhiteSpace(filtros.Protocolo.NumeroTexto))
{
Validacao.Add(Mensagem.Arquivamento.DesarquivarProtocoloNumeroObrigatorio);
return(Validacao.EhValido);
}
else
{
if (!filtros.Protocolo.IsValido)
{
Validacao.Add(Mensagem.Arquivamento.DesarquivarProtocoloNumeroInvalido);
return(Validacao.EhValido);
}
}
IProtocolo proc = _busProtocolo.Obter(filtros.Protocolo.NumeroTexto);
if (proc == null || proc.Id.GetValueOrDefault() <= 0)
{
Validacao.Add(Mensagem.Arquivamento.DesarquivarProtocoloNaoCadastrado);
}
else
{
if (filtros.Protocolo.IsValido)
{
return(Validacao.EhValido);
}
int setorProtocolo = proc.SetorId > 0 ? proc.SetorId : proc.SetorCriacaoId;
if (setorProtocolo != filtros.RemetenteSetorId)
{
Validacao.Add(Mensagem.Arquivamento.DesarquivarProtocoloEmOutroSetor);
}
}
return(Validacao.EhValido);
}
public IProtocolo ObterAtividades(int id)
{
IProtocolo protocolo = null;
try
{
protocolo = _da.ObterAtividades(id);
if ((protocolo.Id ?? 0) <= 0)
{
Validacao.Add(Mensagem.Processo.Inexistente);
}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(protocolo);
}
public Empreendimento EmpreendimentoProcDocAlterado(Titulo titulo, bool gerarMsg = true, eTipoMensagem tipoMsg = eTipoMensagem.Advertencia)
{
ProtocoloDa _protocoloDa = new ProtocoloDa();
IProtocolo protocolo = _protocoloDa.ObterSimplificado(titulo.Protocolo.Id.Value);
if (protocolo != null && (titulo.EmpreendimentoId.GetValueOrDefault(0) != protocolo.Empreendimento.Id))
{
if (gerarMsg)
{
Mensagem msg = Mensagem.Titulo.EmpreendimentoAlterado(protocolo.IsProcesso);
msg.Tipo = tipoMsg;
Validacao.Add(msg);
}
return(protocolo.Empreendimento);
}
return(null);
}
public IProtocolo ObterSimplificado(int id, bool suprimirMensagemInexistente = false)
{
IProtocolo protocolo = null;
try
{
protocolo = _da.ObterSimplificado(id);
if (!suprimirMensagemInexistente && (protocolo.Id ?? 0) <= 0)
{
Validacao.Add(Mensagem.Processo.Inexistente);
}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(protocolo);
}
public ListarAtividadesSolicitadasVM(List <ProtocoloTipo> processosTipos, List <ProtocoloTipo> documentosTipos, IProtocolo protocolo, int?tipoId = null)
{
Protocolo = protocolo;
IsProcesso = protocolo.IsProcesso;
TituloTela = protocolo.IsProcesso ? "Processo" : "Documento";
if (protocolo != null)
{
if (protocolo.IsProcesso)
{
Tipos = ViewModelHelper.CriarSelectList(processosTipos, true, selecionado: protocolo.Tipo.Id.ToString());
}
else
{
Tipos = ViewModelHelper.CriarSelectList(documentosTipos, true, selecionado: protocolo.Tipo.Id.ToString());
}
ProtocoloId = protocolo.Id;
Numero = protocolo.Numero;
}
IsProcesso = true;
}
public bool EmPosse(IProtocolo protocolo)
{
CredenciadoBus _bus = new CredenciadoBus();
var credenciado = _bus.Obter(User.FuncionarioId);
bool credenciadoInteressado = credenciado.Pessoa.InternoId == protocolo.Interessado.Id;
bool credenciadoResponsavel = protocolo.Responsaveis.Exists(x => x.Id == credenciado.Pessoa.InternoId);
if (!credenciadoInteressado && !credenciadoResponsavel)
{
if (protocolo.IsProcesso)
{
Validacao.Add(Mensagem.Processo.PosseCredenciado);
}
else
{
Validacao.Add(Mensagem.Documento.PosseCredenciado);
}
}
return(Validacao.EhValido);
}
public IProtocolo Obter(int id, bool validarPosse = true)
{
IProtocolo protocolo = null;
try
{
protocolo = _busInterno.Obter(id);
if (validarPosse)
{
if (!_validar.EmPosse(protocolo))
{
return(null);
}
}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(protocolo);
}
