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(); }