private void btnAdd_Click(object sender, EventArgs e)
{
if((Processos.Count() + 1) > ProcessosPorMinuto)
{
MessageBox.Show(string.Format("Você não pode adicionar mais que {0} processos", ProcessosPorMinuto));
return;
}
TimeSpan ts;
TimeSpan.TryParse(this.txtTempoVidaProcessoAdd.Text, out ts);
if (string.IsNullOrEmpty(txtNomeProcessoAdd.Text) || !TimeSpan.TryParse(this.txtTempoVidaProcessoAdd.Text, out ts))
return;
var tipoSelected = Enum.GetValues(typeof(Processo.ProcessoTipo))
.Cast<Processo.ProcessoTipo>()
.Where(x => x.ToString() == (string)cbTipoProcessoAdd.SelectedItem)
.FirstOrDefault();
var processo = new Processo
{
TempoVida = ts,
Tipo = tipoSelected,
Nome = txtNomeProcessoAdd.Text
};
Processos.Add(processo);
atualizarTela();
}
private void btnExcluir_Click(object sender, EventArgs e)
{
Processo p = new Processo();
p.Id_processo = txbID;
ProcessoController ctrl = new ProcessoController();
ctrl.ExecutarOpBD('e', p);
this.Close();
}
public void Processar(Processo processo, ConfiguracaoDeFases configuracaoDeFases)
{
var fases = this.fasesDeProcesso.Obter();
foreach (var fase in fases)
{
fase.Processar(processo, configuracaoDeFases);
}
this.SalvarProcesso(processo);
}
public async Task <IActionResult> Create([Bind("Id,Id_cliente,Numero_do_processo,Status,Foro,Valor_da_acao,Competencia,Classe,Assunto_principal,Outros_asssuntos,Grau,Re,Autor,Testemunha,Advogado,Vara,Portal")] Processo processo)
{
if (ModelState.IsValid)
{
_context.Add(processo);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(processo));
}
public async Task <ActionResult> Index(Processo processo)
{
if (ModelState.IsValid)
{
var service = new MateriasService();
var materia = await service.RecuperarMateriaPeloCodigo(processo);
return(View(materia));
}
return(View("Index", "Home"));
}
private void frmListarProcesso_Load(object sender, EventArgs e)
{
Processo p = new Processo();
ProcessoController ctrl = new ProcessoController();
List <Processo> listaProcessos = ctrl.ExecutarOpBD('t', p);
foreach (Processo o in listaProcessos.Values)
{
dgvProcesso.Rows.Add(o.Id_processo, o.Cliente.Nome_cli, o.Advogado.Nome_adv, o.Tipo_processo, o.Situacao_processo);
}
}
public int Run(Processo processo)
{
int fistIn = 0;
int trocas = 0;
int indice = 0;
foreach (var pagina in processo.Paginas)
{
// Console.WriteLine($"pagina = {page}");
// INÍCIO parte inicial - moldura vazia/semi preenchida, página nova
if (processo.Molduras.Count < processo.NumeroMolduras && !processo.Molduras.Contains(pagina))
{
processo.Molduras.Insert(indice, pagina);
indice++;
trocas++;
}
// FIM parte inicial - moldura vazia/semi preenchida, página nova
// INÍCIO parte inicial - moldura semi preenchida, página repetida
else if (processo.Molduras.Contains(pagina))
{
continue;
}
// FIM parte inicial - moldura semi preenchida, página repetida
// INÍCIO moldura preenchida, usar índice da primeira página a entrar na moldura
else
{
processo.Molduras.RemoveAt(fistIn);
processo.Molduras.Insert(fistIn, pagina);
fistIn++;
indice = 0;
trocas++;
}
// FIM moldura preenchida, usar índice da primeira página a entrar na moldura
// reseta o índice para a primeira posição da moldura
if (fistIn == processo.NumeroMolduras)
{
fistIn = 0;
}
//foreach (var mold in processo.Molduras)
//{
// Console.WriteLine($"Moldura: { mold }");
//}
//Console.WriteLine("=============");
}
return(trocas);
}
public override void Handle(Processo processo)
{
Console.WriteLine("O processo está inativo. Deseja ativá-lo?");
string texto = Console.ReadLine();
char resposta;
char.TryParse(texto, out resposta);
if (resposta == 'S' || resposta == 's')
{
processo.Estado = new ativo();
}
}
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 ActionResult Edit([Bind(Include = "ProcessoId,ClienteId,NaturezaAcaoId,Ativo,Comentario,ResumoDoCaso,NumeroProcesso,LinkProcesso,Vara, Enderecamento")] Processo processo)
{
if (ModelState.IsValid)
{
db.Entry(processo).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ClienteId = new SelectList(db.Clientes, "ClienteId", "Nome", processo.ClienteId);
ViewBag.NaturezaAcaoId = new SelectList(db.NaturezaAcaos, "NaturezaAcaoID", "Nome", processo.NaturezaAcaoId);
return(View(processo));
}
public Processo Salvar(Processo processo)
{
var agora = DateTime.Now;
processo.UltimaModificacao = agora;
var autor = _pessoaRepository.Find(processo.Autor.Id);
processo.Autor = autor;
if (processo.Destinatario.Tipo.Equals(new OrgaoUnidade().GetType().Name))
{
processo.OrgaoUnidadeDestino = new OrgaoUnidade
{
IdOrgaoUnidade = processo.Destinatario.Id,
DsOrgaoUnidade = processo.Destinatario.Descricao
};
}
else if (processo.Destinatario.Tipo.Equals(new Pessoa().GetType().Name))
{
processo.PessoaDestino = new Pessoa
{
Matricula = processo.Destinatario.Id,
Nome = processo.Destinatario.Descricao
};
}
else
{
throw new NotImplementedException("Destinatário inválido.");
}
_processoRepository.AddOrUpdate(processo);
var processoMovimentoEncaminhamento = new ProcessoMovimento
{
Data = agora,
PessoaOrigem = autor,
OrgaoUnidadeOrigem = autor.OrgaoUnidadeLotacao,
PessoaDestino = processo.PessoaDestino,
OrgaoUnidadeDestino = processo.OrgaoUnidadeDestino,
Autor = autor,
Processo = processo,
Movimento = _movimentoRepository.Get(_processoSettings.CodigoMovimentoEncaminhamentoOrgaoInterno)
};
_processoMovimentoRepository.Add(processoMovimentoEncaminhamento);
processo.UltimoMovimento = processoMovimentoEncaminhamento;
_processoRepository.AddOrUpdate(processo);
return(processo);
}
public bool ValidarNaoExistenteNaHierarquia(Processo processo)
{
if (processo?.ProcessoVinculadoId == null || processo?.ProcessoVinculado == null)
{
return(true);
}
var processoPai = this.processoRepository.ObterPorId(processo.ProcessoVinculadoId.Value);
var processoFilho = this.processoRepository.Obter(p => p.ProcessoVinculadoId == processoPai.Id);
return(processoFilho == null);
}
public CadastrarResponse Cadastrar(CadastrarRequest request)
{
if (!Autenticar(Credenciais))
{
return(RetornaErroCadastro(null, "Falha durante a autenticação. Verifique credenciais."));
}
try
{
var model = new Processo(
request.Id_Processo,
request.Tipo_Processo,
request.Id_Workflow,
request.Id_Etapa,
request.Acao);
if (!model.ValidationResult.IsValid)
{
return(RetornaErroCadastro(model, "Parâmetros incorretos. Verifique mensagens de erros"));
}
var existeProcesso = _filaRepository.ConsultarPorProcesso(model)
.GetAwaiter()
.GetResult();
if (existeProcesso != null)
{
return(RetornaErroCadastro(model, $"Já existe um outro processo com protocolo nº {existeProcesso.Id} pendente"));
}
var processoBusca = _filaRepository.ExisteProcesso(model);
if (processoBusca == null)
{
return(RetornaErroCadastro(model, $"Processo ID {model.Id_Processo} não encontrado"));
}
var protocolo = _filaRepository.Cadastrar(model)
.GetAwaiter()
.GetResult();
return(new CadastrarResponse
{
Sucesso = true,
Mensagem = "Operação realizada com sucesso!",
Protocolo = protocolo.ToString()
});
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public Documento Criar(Processo processo, TipoDocumento tipoDocumento, string cpf)
{
return(new Documento
{
Lote = processo.Lote,
Processo = processo,
Status = DocumentoStatus.TransmissaoOk,
TipoDocumento = tipoDocumento,
TipoDocumentoOriginal = tipoDocumento,
Cpf = cpf
});
}
private static void Print(Processo processo)
{
Console.WriteLine($"{processo.Descricao}");
/*
* foreach (var objFila in processo.ObjetoFilas)
* {
* var fila = objFila.Fila;
* Console.WriteLine($" - {fila.Descricao} ({objFila.Data})");
* }
*/
}
protected void CarregarDevolver(FunMod fmp)
{
Processo pro = ProcessoDB.Select(Convert.ToInt32(lblCodProcesso.Text));
string matricula = TramitacaoDB.SelectDevolver();
if (matricula == fmp.Funcionario.Fun_matricula && pro.Status.Sta_valor != "Finalizado")
{
lnkDevolver.Visible = true;
Page.ClientScript.RegisterStartupScript(this.GetType(), "script", "<script>AtivarCompose();</script>", false);
}
}
public async Task <IActionResult> Create([Bind("ProcessoID,ClienteID,Numero,Estado,Valor,Data,Estaativo")] Processo processo)
{
if (ModelState.IsValid)
{
_context.Add(processo);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
PopularClientesDropDownList(processo.ClienteID);
return(View(processo));
}
public void SetProcesso(Processo processo, List <ResponsavelFuncoes> responsavelFuncoes)
{
this.Processo = processo;
processo.Requerimento.Atividades = processo.Atividades;
processo.Requerimento.Interessado = processo.Interessado;
processo.Requerimento.Responsaveis = processo.Responsaveis;
processo.Requerimento.Empreendimento = processo.Empreendimento;
this.RequerimentoVM.CarregarListas(responsavelFuncoes);
this.RequerimentoVM.CarregarRequerimentoVM(processo.Requerimento);
}
private IEnumerable <ProcessoViewModel> ProcessoHierarcky(Processo father, IEnumerable <Processo> processos)
{
var children = new List <ProcessoViewModel>();
foreach (var processo in processos.Where(a => a.ProcessoPaiID == father.ID))
{
var viewModel = processo.ToViewModel();
viewModel.ProcessosFilhos = ProcessoHierarcky(processo, processos);
children.Add(viewModel);
}
return(children);
}
public bool inserirProcessosSemAndamentoTramitar()
{
string select = @"
SELECT pan.fk_cod_processo_pro, pan.dat_cadastro_pan,
(
SELECT uef.fk_cod_unidade_exercicio_uex
FROM adm_licitar.tb_unidade_exercicio_funcao_pessoa_efp efp
INNER JOIN adm_licitar.tb_unidade_exercicio_funcao_uef uef ON uef.pk_cod_unidade_exercicio_funcao_uef = efp.fk_cod_unidade_exercicio_funcao_uef
WHERE efp.fk_cod_pessoa_pes = pan.fk_cod_pessoa_cadastrante_pes
AND (dat_fim_efp = '-infinity' OR dat_fim_efp is null)
ORDER BY dat_inicio_efp DESC
LIMIT 1
) as unidade_cadastrante
FROM adm_licitar.tb_processo_andamento_pan pan
WHERE pan.fk_cod_processo_pro not in
(
SELECT DISTINCT pan.fk_cod_processo_pro
FROM adm_licitar.tb_processo_andamento_pan pan
INNER JOIN adm_licitar.tb_fluxo_andamento_fan fan ON fan.pk_cod_fluxo_andamento_fan = pan.fk_cod_fluxo_andamento_fan
INNER JOIN adm_licitar.tb_atividade_ati ati ON ati.pk_cod_atividade_ati = fan.fk_cod_atividade_ati
WHERE ati.txt_descricao_ati = 'TRAMITAR'
ORDER BY pan.fk_cod_processo_pro
)
AND pan.pk_cod_processo_andamento_pan =
(
SELECT pan2.pk_cod_processo_andamento_pan
FROM adm_licitar.tb_processo_andamento_pan pan2
WHERE pan2.fk_cod_processo_pro = pan.fk_cod_processo_pro
ORDER BY pan2.dat_cadastro_pan DESC, pan2.pk_cod_processo_andamento_pan DESC
LIMIT 1
)
AND (pan.dat_cadastro_pan is not null AND pan.dat_cadastro_pan <> '-infinity')
" ;
DataTable dt = Consultar(select);
TramitacaoUnidadeExercicio objTUE;
foreach (DataRow row in dt.Rows)
{
int unidade = Convert.ToInt32(row["unidade_cadastrante"].ToString());
int processo = Convert.ToInt32(row["fk_cod_processo_pro"].ToString());
string data = row["dat_cadastro_pan"].ToString();
objTUE = new TramitacaoUnidadeExercicio();
objTUE.DataEntradaUnidade = Convert.ToDateTime(data);
objTUE.UnidadeExercicio = UnidadeExercicio.Find(unidade);
objTUE.Processo = Processo.Find(processo);
objTUE.Save();
}
return(true);
}
public ResultadoCondicaoDeRegra Validar(Processo processo, Regra regra, RegraCondicional condicao)
{
var processadorBinarios = this.criadorDeProcessadorDeBinario.Obter(condicao.Binario);
if (processadorBinarios == null)
{
Log.Application.DebugFormat(
"Não foi encontrado processador do binario {0}",
condicao.Binario);
}
return(processadorBinarios.Processar(processo, regra, condicao));
}
public ActionResult Edit([Bind(Include = "ProcessoID,NumeroProcesso,DataAbertura,DataConclusao,Situacao,PessoaID,VaraID,Descricao")] Processo processo)
{
if (ModelState.IsValid)
{
db.Entry(processo).State = EntityState.Modified;
db.SaveChanges();
TempData["Mensagem"] = "Processo Atualizado Com Sucesso!";
return(RedirectToAction("Index"));
}
ViewBag.PessoaID = new SelectList(db.Pessoas, "PessoaID", "Nome", processo.PessoaID);
ViewBag.VaraID = new SelectList(db.Varas, "VaraID", "Descricao", processo.VaraID);
return(View(processo));
}
public void Salvar(Processo model)
{
//demanda #3587
var obter = ObterPorFiltro(model).FirstOrDefault(p => p.ID != model.ID);
if (obter != null)
{
throw new AcademicoException("Já existe no banco de dados um registro com esse nome.");
}
//fim demanda #3587
repositorio.Salvar(model);
}
public void InserirOuAtualizar(Processo processo)
{
var registros = dbConnection.QueryFirstOrDefault <int>("SELECT COUNT(Identificador) FROM Processos WHERE Identificador = @Identificador", new { processo.Identificador });
if (registros > 0)
{
Atualizar(processo);
}
else
{
Inserir(processo);
}
}
public IActionResult Post(Processo value)
{
try
{
_gerenciadorFila.IncluirProcesso(value);
return(Ok());
}
catch (ArgumentException ex)
{
return(BadRequest(ex.Message));
}
}
protected void gdvProcesso_RowCommand(object sender, GridViewCommandEventArgs e)
{
Processo processo = new Processo();
ProcessoDB ageDB = new ProcessoDB();
switch (e.CommandName)
{
case "Detalhes":
CarregaDetalhesProcesso(Convert.ToInt32(e.CommandArgument));
modalDetalhes.Show();
break;
}
}
public ActionResult Create([Bind(Include = "Id,NumeroProcesso,Autor,Reu,UltimaMovimentacao,Situacao")] ProcessoViewModel viewModel)
{
if (ModelState.IsValid)
{
Processo processo = Mapper.Map <ProcessoViewModel, Processo>(viewModel);
processo.DataConsulta = DateTime.Now;
db.Processos.Add(processo);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(viewModel));
}
public ActionResult Create([Bind(Include = "ProcessoId,ClienteId,NaturezaAcaoId,Ativo,Comentario,ResumoDoCaso,NumeroProcesso,LinkProcesso,Vara")] Processo processo)
{
if (ModelState.IsValid)
{
db.Processoes.Add(processo);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ClienteId = new SelectList(db.Clientes, "ClienteId", "Nome", processo.ClienteId);
ViewBag.NaturezaAcaoId = new SelectList(db.NaturezaAcaos, "NaturezaAcaoID", "Nome", processo.NaturezaAcaoId);
return(View(processo));
}
public void Montar(Processo processo)
{
Log.Application.Info("Montando processo #" + processo.Id);
foreach (var documento in processo.Documentos)
{
this.documentoRepositorio.ConcluirMontagemDocumento(
documento.Id,
documento.Templates);
}
this.processoRepositorio.AlterarStatus(processo.Id, ProcessoStatus.Montado);
}
public void IncluirProcesso(Processo model)
{
try
{
ValidarProcesso(model);
this.PreencherInformacoesDeAuditoria(model);
bmProcesso.Salvar(model);
}
catch (AcademicoException ex)
{
throw ex;
}
}
public object CreateProcesso([FromBody] Processo processo)
{
try
{
db.Processos.Add(processo);
db.SaveChanges();
return(Ok(new { text = "Processo cadastrado com sucesso!", type = true }));
}
catch (Exception ex)
{
return(Ok(new { text = ex.Message, type = false }));
}
}
private void CriarProcesso(string nome, TipoProcessoEnum tipoEnum)
{
TiposDeProcesso tipos = new TiposDeProcesso();
var tipo = tipos.ObterPor(tipoEnum);
var processo = new Processo()
{
Departamento = this.departamento,
Nome = nome,
TipoProcesso = tipo
};
processos.Add(processo);
}
public void TesteProcessoCliente()
{
Usuario usuario = new Usuario();
usuario.Login = "******";
usuario.Senha = "12345";
usuario.Nome = "Conrado Adevany Clarke";
usuario.Inserir();
Assert.AreEqual(usuario.OrigemDados, OrigemDados.Banco);
usuario.Logar();
Assert.AreEqual(usuario.OrigemDados, OrigemDados.Banco);
Cliente cliente = new Cliente();
cliente.Nome = "Mila Kunis";
cliente.Inserir();
Assert.AreEqual(cliente.OrigemDados, OrigemDados.Banco);
TipoAcao tipoAcao = new TipoAcao();
tipoAcao.Descricao = "Danos morais por duelo na lama";
tipoAcao.Inserir();
Assert.AreEqual(tipoAcao.OrigemDados, OrigemDados.Banco);
Processo processo = new Processo();
processo.Cabeca.Nome = "Cameron Diaz";
processo.Reu = "Jessica Rabbit";
processo.TipoAcao = tipoAcao;
processo.Inserir();
Processo processo2 = new Processo();
processo2.Id = processo.Id;
processo2.Obter();
Assert.AreEqual(tipoAcao.Id, processo2.TipoAcao.Id);
processo.Clientes.Add(cliente);
processo.Salvar();
//Verifica sincronização entre coleções
Assert.IsTrue(cliente == processo.Clientes[0]);
Assert.IsTrue(processo == cliente.Processos[0]);
ProcessoCliente processoCliente = new ProcessoCliente(processo, cliente);
Assert.IsTrue(processoCliente.Obter());
Recorte recorte = new Recorte(processo, Sessao.UsuarioAtual);
processo.Recortes.Add(recorte);
Assert.IsTrue(processo.Recortes[0] == recorte);
processo.Salvar();
Processo processo3 = new Processo();
processo3.Id = processo.Id;
processo3.Obter();
Assert.IsNotNull(processo3.Recortes.FirstOrDefault((rec) => rec.DataInclusao == recorte.DataInclusao && rec.Processo.Id == recorte.Processo.Id));
processo.Recortes.Clear();
processo.Clientes.Clear();
processo.Salvar();
Assert.IsFalse(processoCliente.Obter());
processo.Remover();
Assert.IsNull(processo.Id);
Assert.AreEqual(processo.OrigemDados, OrigemDados.Local);
cliente.Remover();
Assert.IsNull(cliente.Id);
Assert.AreEqual(cliente.OrigemDados, OrigemDados.Local);
tipoAcao.Remover();
Assert.IsNull(tipoAcao.Id);
Assert.AreEqual(tipoAcao.OrigemDados, OrigemDados.Local);
usuario.Remover();
Assert.AreEqual(usuario.OrigemDados, OrigemDados.Local);
}
private void LerExcel()
{
try
{
processo = new Processo();
var reader = processo.InicializarCarga(carga);
if (reader == null)
carga.AdicionarDetalhe("Nao foi possivel Ler o excel", "Nao foi possivel Ler o excel por favor verifique o layout.", 0, TipoDetalheEnum.erroLeituraExcel);
else
LerExcel(estruturaOrcamentariaExcel, carga, reader);
}
catch (Exception ex)
{
carga.AdicionarDetalhe("Nao foi possivel Ler o excel", "Nao foi possivel Ler o excel por favor verifique o layout.", 0, TipoDetalheEnum.erroLeituraExcel, ex.Message);
}
finally
{
processo.FinalizarCarga();
}
}
private void LerExcel(Carga carga, List<FuncionarioExcel> funcionarios)
{
processo = new Processo();
OleDbDataReader reader = processo.InicializarCarga(carga);
if (reader == null)
carga.AdicionarDetalhe("Nao foi possivel Ler o excel",
"Nao foi possivel Ler o excel por favor verifique o layout.", 0,
TipoDetalheEnum.erroLeituraExcel);
else
LerExcel(carga, funcionarios, reader);
processo.FinalizarCarga();
}
