public async Task <ActionResult> Create([Bind(Include = "NOME_CLINICA,NOME_MEDICO,SITE_CLINICA,ATRASO_MEDIO,NUMERO_OCORRENCIAS,DATA,Endereco")] OcorrenciasViewModel ocorrenciaVM)
        {
            if (ModelState.IsValid)
            {
                Ocorrencia ocorrencia = new Ocorrencia()
                {
                    Endereco = new Endereco()
                    {
                        BAIRRO              = ocorrenciaVM.Endereco.BAIRRO,
                        CEP                 = ocorrenciaVM.Endereco.CEP,
                        CIDADE              = ocorrenciaVM.Endereco.CIDADE,
                        ESTADO              = ocorrenciaVM.Endereco.ESTADO,
                        RUA                 = ocorrenciaVM.Endereco.RUA,
                        TELEFONE_PRIMARIO   = ocorrenciaVM.Endereco.TELEFONE_PRIMARIO,
                        TELEFONE_SECUNDARIO = ocorrenciaVM.Endereco.TELEFONE_SECUNDARIO
                    },
                    NOME_CLINICA       = ocorrenciaVM.NOME_CLINICA,
                    NOME_MEDICO        = ocorrenciaVM.NOME_MEDICO,
                    SITE_CLINICA       = ocorrenciaVM.SITE_CLINICA,
                    ATRASO_MEDIO       = ocorrenciaVM.ATRASO_MEDIO,
                    NUMERO_OCORRENCIAS = ocorrenciaVM.NUMERO_OCORRENCIAS,
                    DATA    = ocorrenciaVM.DATA,
                    ID_USER = User.Identity.GetUserId()
                };
                db.Ocorrencia.Add(ocorrencia);
                await db.SaveChangesAsync();

                return(RedirectToAction("Index"));
            }

            return(View(ocorrenciaVM));
        }
Example #2
0
        public void Executar(Ocorrencia ocorrencia)
        {
            if (ocorrencia == null || ocorrencia.Tipo == null)
            {
                return;
            }

            var tipoOcorrencia = this.ocorrenciaTipoRepositorio.ObterPorId(ocorrencia.TipoId);

            if (tipoOcorrencia == null || tipoOcorrencia.TipoOcorrenciaParaFilhos < 1)
            {
                return;
            }

            if (ocorrencia.PacoteId < 1 || ocorrencia.DossieEsperadoId > 0)
            {
                Log.Application.InfoFormat("Não foi gravado ocorrência para os filhos pois a ocorrência atual possui dossiê esperado. Ocorrência:{0}", ocorrencia.Id);
                return;
            }

            var dossies = this.dossieEsperadoRepositorio.ObterPorPacote(ocorrencia.Pacote);

            foreach (var dossieEsperado in dossies)
            {
                var ocorrenciaNova = this.GerarOcorrencia(dossieEsperado, ocorrencia);
                this.ocorrenciaRepositorio.Salvar(ocorrenciaNova);

                this.gravaLogDoDossieEsperadoServico.Executar(LogDossieEsperado.AcaoAdicionarLogOcorrenciaDossie, ocorrenciaNova.DossieEsperado,
                                                              "Registrado ocorrência para o dossie [" + ocorrenciaNova.DossieEsperadoId + "]");
            }
        }
Example #3
0
        public FacadeOcorrencia(IPluginExecutionContext contexto)
        {
            var entidade = PluginHelper.GetDynamicEntity(contexto);

            if (entidade.Properties.Contains("statuscode"))
            {
                alteracaoDoStatus = true;
            }

            this.Organizacao = contexto.OrganizationName;
            this.Id          = PluginHelper.GetEntityId(contexto);
            this.MessageName = contexto.MessageName;

            var factory = new FactoryOcorrencia(this.Organizacao, this.Id);

            if (contexto.PreEntityImages.Contains("preImage") && contexto.PreEntityImages["preImage"] is DynamicEntity)
            {
                ocorrencia = factory.CriarOcorrencia(entidade, contexto.PreEntityImages["preImage"] as DynamicEntity);
            }
            else if (contexto.PostEntityImages.Contains("postImage") && contexto.PostEntityImages["postImage"] is DynamicEntity)
            {
                ocorrencia = factory.CriarOcorrencia(entidade, contexto.PostEntityImages["postImage"] as DynamicEntity);
            }
            else
            {
                ocorrencia = factory.CriarOcorrencia(entidade);
            }


            service = new OcorrenciaService(ocorrencia);
        }
Example #4
0
        protected void ModeloEmailIsol(ref Domain.Model.Email email)
        {
            if (email.ReferenteA != null && email.ReferenteA.Type == "incident" && !string.IsNullOrEmpty(email.Mensagem))
            {
                if (email.Mensagem.Contains("{link_ocorrencia_isol}"))
                {
                    string link = string.Format("<a href=\"{0}\">Clique Aqui</a>", SDKore.Configuration.ConfigurationManager.GetSettingValue("LINK_ISOL_FECHAMENTO") + email.ReferenteA.Id.ToString());
                    email.Mensagem     = email.Mensagem.Replace("{link_ocorrencia_isol}", link);
                    email.MensagemErro = "ALTERADO";
                }

                if (email.Mensagem.Contains("{link_ocorrencia_impressao}"))
                {
                    string link = string.Format("<a href=\"{0}\">Clique Aqui</a>", SDKore.Configuration.ConfigurationManager.GetSettingValue("LINK_ISOL_OS") + email.ReferenteA.Id.ToString());
                    email.Mensagem     = email.Mensagem.Replace("{link_ocorrencia_impressao}", link);
                    email.MensagemErro = "ALTERADO";
                }

                if (email.Mensagem.Contains("{valor_linha_contrato}"))
                {
                    var ocorrencia = new Ocorrencia()
                    {
                        Id = email.ReferenteA.Id
                    };
                    var linhaDeContrato = (new Domain.Servicos.RepositoryService()).LinhaDoContrato.ObterPor(ocorrencia, "new_valor_pago");

                    string valorPago = (linhaDeContrato != null && linhaDeContrato.PrecoPago.HasValue) ? linhaDeContrato.PrecoPago.Value.ToString("F") : "0,00";

                    email.Mensagem     = email.Mensagem.Replace("{valor_linha_contrato}", valorPago);
                    email.MensagemErro = "ALTERADO";
                }
            }
        }
Example #5
0
        public IActionResult Create([FromBody] Ocorrencia item)
        {
            if (item == null)
            {
                return(BadRequest());
            }

            Console.WriteLine("");
            Console.WriteLine("verificarVeiculo: " + verificarVeiculo(item.placaVeiculo));
            Console.WriteLine("");

            if (verificarVeiculo(item.placaVeiculo) == 1)
            {
                item.veiculoCadastrado = true;
            }
            else
            {
                item.veiculoCadastrado = false;
            }

            _context.ocorrencia.Add(item);
            _context.SaveChanges();

            return(CreatedAtRoute("GetOcorrencia", new { numero = item.numero }, item));
        }
Example #6
0
        public void AlterarStatusDaOcorrenciaParaOMenorStatusDosDiagnosticosRelacionados()
        {
            List <Diagnostico> statusDiagnosticos = RepositoryService.Diagnostico.ObterOsStatusDeDiagnoticoPorOcorrencia(Ocorrencia.Id);

            ocorrencia = RepositoryService.Ocorrencia.Retrieve(ocorrencia.Id);


            var statusOcorrencia = ObterStatusDaOcorrenciaPorDiagnosticos(statusDiagnosticos, ocorrencia);

            if (statusOcorrencia != 0)
            {
                if (this.Ocorrencia.RazaoStatus.Value == statusOcorrencia)
                {
                    return;
                }

                if (this.Ocorrencia.RazaoStatus == (int)StatusDaOcorrencia.Aguardando_Analise ||
                    this.Ocorrencia.RazaoStatus == (int)StatusDaOcorrencia.Aguardando_Peça ||
                    this.Ocorrencia.RazaoStatus == (int)StatusDaOcorrencia.Pedido_Solicitado ||
                    this.Ocorrencia.RazaoStatus == (int)StatusDaOcorrencia.Aguardando_Conserto ||
                    this.Ocorrencia.RazaoStatus == (int)StatusDaOcorrencia.Conserto_Realizado ||
                    this.Ocorrencia.RazaoStatus == (int)StatusDaOcorrencia.Aberta)
                {
                    this.Ocorrencia.RazaoStatus = statusOcorrencia;
                    RepositoryService.Ocorrencia.Update(this.ocorrencia);
                }
            }
        }
Example #7
0
        // POST: api/ExecutaPOST
        public RetornoWS Post([FromBody] Ocorrencia ocorrencia)
        {
            var verificaSeExiste = repoMat.Listar().Where(x => x.Aluno.Renach == ocorrencia.numProcesso).FirstOrDefault();

            try
            {
                if (verificaSeExiste != null)
                {
                    return(new RetornoWS
                    {
                        codStatus = 0,
                        mensagem = "Transação ok"
                    });
                }
                else
                {
                    return(new RetornoWS
                    {
                        codStatus = 1,
                        mensagem = "Nao Existe"
                    });
                }
            }
            catch (Exception ex)
            {}
            return(new RetornoWS
            {
                codStatus = 1,
                mensagem = "Nao Existe"
            });
        }
Example #8
0
        public void InsertOcorrencia(Ocorrencia ocorrencia)
        {
            try
            {
                string sql = "Insert into tb_ocorrencia (id_cliente, data_oco, tipo, descricao) values (@id,@data,@tipo,@desc)";
                con = new MySqlConnection(_conexaoMySql);
                MySqlCommand cmd = new MySqlCommand(sql, con);
                cmd.Parameters.AddWithValue("@id", ocorrencia.IdCliente);
                cmd.Parameters.AddWithValue("data", ocorrencia.Data);
                cmd.Parameters.AddWithValue("@tipo", ocorrencia.Tipo);
                cmd.Parameters.AddWithValue("@desc", ocorrencia.Descricao);

                con.Open();

                cmd.ExecuteNonQuery();
                MessageBox.Show("Ocorrencia registrada");
            }
            catch (Exception erro)
            {
                throw erro;
            }
            finally
            {
                con.Close();
            }
        }
        public List <T> PesquisarAutorizacaoPostagemCorreiosPor(Ocorrencia ocorrencia)
        {
            //NÃO IMPLANTADO
            var query = GetQueryExpression <T>(true);

            return((List <T>) this.RetrieveMultiple(query).List);
        }
        public void AddOcorrencia(Ocorrencia ocorrencia, string projetoId, string responsavelId)
        {
            var projeto = ProjetosController.GetInstance().Projetos.FirstOrDefault(x => x.Id == projetoId);

            if (projeto == null)
            {
                throw new ApplicationException($"Projeto com ID = '{projetoId}' não foi encontrado");
            }

            var responsavel = FuncionariosController.GetInstance().Funcionarios.FirstOrDefault(x => x.Id == responsavelId);

            if (responsavel == null)
            {
                throw new ApplicationException($"Funcionario com ID = '{responsavelId}' não foi encontrado");
            }

            if (responsavel.Ocorrencias.Where(x => x.Estado == EstadoOcorrenciaEnum.ABERTA).Count() == 10)
            {
                throw new ApplicationException($"Funcionario com ID = '{responsavelId}' pode ter no máximo 10 ocorrências abertas");
            }

            ocorrencia.Estado = EstadoOcorrenciaEnum.ABERTA;

            ocorrencia.Responsavel = responsavel;
            projeto.Ocorrencias.Add(ocorrencia);
            responsavel.Ocorrencias.Add(ocorrencia);

            Ocorrencias.Add(ocorrencia);
        }
Example #11
0
        public void IncluirIntervencao(Ocorrencia ocorrencia, List <IntervencaoTecnica> colecaoIntervencoes, Diagnostico servico, string nome)
        {
            var inclui = true;

            foreach (var inter in colecaoIntervencoes)
            {
                if (inter.Nome.Contains(servico.Produto.Codigo + " Peça solicitada em intervenção técnica"))
                {
                    inclui = false;
                    break;
                }
            }

            if (inclui && (ocorrencia.StatusDaOcorrencia == StatusDaOcorrencia.Aguardando_Analise || ocorrencia.StatusDaOcorrencia == StatusDaOcorrencia.Aguardando_Peça))
            {
                ocorrencia.EmIntervencaoTecnica = true;

                IntervencaoTecnica intervencao = new IntervencaoTecnica(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline);
                intervencao.OcorrenciaId = new Lookup(this.Id, "incident");
                intervencao.Nome         = servico.Produto.Codigo + " Peça solicitada em intervenção técnica";
                intervencao.RazaoStatus  = 1;

                RepositoryService.Intervencao.Create(intervencao);
            }
        }
Example #12
0
        private bool ValidaOcorrencia(Ocorrencia ocorrencia)
        {
            ResponseService = new ResponseService();

            if (string.IsNullOrEmpty(ocorrencia.Descricao))
            {
                ResponseService.FieldsInvalids.Add("Descricao");
            }
            if (ocorrencia.TipoOcorrencia == TipoOcorrenciaEnum.None)
            {
                ResponseService.FieldsInvalids.Add("TipoOcorrencia");
            }
            if (ocorrencia.TipoOcorrencia == TipoOcorrenciaEnum.Assalto && ocorrencia.TipoItem == TipoItemEnum.None)
            {
                ResponseService.FieldsInvalids.Add("TipoItem");
            }

            if (ResponseService.FieldsInvalids.Count > 0)
            {
                ResponseService.Message += "Informe os dados corretamente.";
            }
            ResponseService.Type =
                string.IsNullOrEmpty(ResponseService.Message) ?
                ResponseTypeEnum.Success :
                ResponseTypeEnum.Warning;
            return(ResponseService.Type == ResponseTypeEnum.Success);
        }
        public void Atualizar(OcorrenciaTO to)
        {
            _Contexto = ControladorAcesso.ObterContexto();

            if (to.Identificador == 0 || to == null)
            {
                to.Valido   = false;
                to.Mensagem = Mensagem.Atualizacao("Ocorrencia", false);

                return;
            }

            Ocorrencia entidade = _Contexto.Ocorrencia.FirstOrDefault(x => x.Identificador == to.Identificador);

            if (entidade == null)
            {
                to.Valido   = false;
                to.Mensagem = Mensagem.Obter("Ocorrencia", false);

                return;
            }

            to.PreencherEntidade(entidade);

            _Contexto.SaveChanges();

            to.PreencherTO(entidade);
            to.Valido   = true;
            to.Mensagem = Mensagem.Atualizacao("Ocorrencia", true);

            return;
        }
Example #14
0
        public static void EditarOcorrencia(ValidarJustificativaPontoView tela)
        {
            int    codigoPonto      = Convert.ToInt32(tela.tfCodPonto.Text);
            int    codigoOcorrencia = Convert.ToInt32(tela.tfCodOcorrencia.Text);
            string Justificativa    = tela.tfJustificativa.Text;
            int    status           = Convert.ToInt32(tela.cbStatus.SelectedValue);

            Ocorrencia o = new Ocorrencia();

            o.SetCodOcorrencia(codigoOcorrencia);
            o.SetCodPonto(codigoPonto);
            o.SetJustificativa(Justificativa);
            o.SetStatus(status);

            OcorrenciaDAO obj = new OcorrenciaDAO();
            int           rs  = obj.EditarOcorrencia(o);

            if (rs == 1)
            {
                MessageBox.Show("A ocorrencia foi alterada com sucesso.");
            }
            else
            {
                MessageBox.Show("Houve algum erro ao justificar a ocorrencia.");
            }
        }
Example #15
0
        public void Executar(Ocorrencia ocorrencia, string observacao, string novoTipoDocumento, int grupoId)
        {
            var ocorrenciaBanco = this.ocorrenciaRepositorio.ObterPorIdComDocumento(ocorrencia.Id);

            ocorrenciaBanco.Status = ocorrencia.Status;

            if (string.IsNullOrEmpty(observacao) == false)
            {
                this.gravaLogDaOcorrenciaServico.Executar(this.ObterAcao(ocorrencia), ocorrenciaBanco, observacao);
            }

            this.ocorrenciaRepositorio.Salvar(ocorrenciaBanco);

            if (ocorrenciaBanco.TipoId != OcorrenciaTipo.TipoDocumentoNaoEncontrado ||
                novoTipoDocumento == null)
            {
                return;
            }

            this.GravarTipoDeDocumento(novoTipoDocumento, ocorrenciaBanco.Id, grupoId);

            if (ocorrenciaBanco.Status == OcorrenciaStatus.Finalizada)
            {
                this.AtualizarDocumento(ocorrenciaBanco.Documento);
            }
        }
Example #16
0
        public ActionResult Incluir([DataSourceRequest] DataSourceRequest request, OcorrenciaViewModel item)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    Ocorrencia dados = Mapper.Map <Ocorrencia>(item);
                    _repositorio.Inserir(dados);
                    _contexto.SaveChanges();
                    item.OcorrenciaId = dados.OcorrenciaId;
                }
                catch (Exception erro)
                {
                    if (erro.InnerException.InnerException.Message.Contains("IdxNome"))
                    {
                        ModelState.AddModelError("", "O nome já foi incluído.");
                    }

                    _contexto.Rollback();
                    return(Json(ModelState.ToDataSourceResult()));
                }
            }

            return(Json(new[] { item }.ToDataSourceResult(request)));
        }
Example #17
0
 /// <summary>
 /// Insere ocorrencia na lista de ocorrencias
 /// </summary>
 /// <param name="o"></param>
 /// <returns></returns>
 public static int InsereOcorrencia(Ocorrencia o)
 {
     try
     {
         if (Distritos.ProcuraDistrito(o.IdDistrito) == null)
         {
             o.IdDistrito = 0;
         }
         if (Catastrofes.ProcuraCatastrofe(o.IdCatastrofe) == null)
         {
             o.IdCatastrofe = 0;
         }
         totalOcorrencias++;
         auxOcorrencia = new OcorrenciaDB(totalOcorrencias, o.Data, o.Descricao, o.IdCatastrofe, o.IdDistrito);
         if (ocorrencias == null)
         {
             ocorrencias = new List <OcorrenciaDB>();
         }
         ocorrencias.Add(auxOcorrencia);
         return(totalOcorrencias);
     }
     catch (Exception e)
     {
         throw e;
     }
 }
Example #18
0
        public IActionResult Edit(long id, [Bind("Id,DataHora,Descricao,TipoComportamento")] Ocorrencia ocorrencia)
        {
            if (id != ocorrencia.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    repositorio.Update(ocorrencia);
                    repositorio.SaveChanges();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!OcorrenciaExists(ocorrencia.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(ocorrencia));
        }
Example #19
0
 public static void AdicionarOcorrencia(this List <Ocorrencia> ocorrencias, Ocorrencia ocorrencia)
 {
     if (ocorrencia != null && ocorrencia.ExibirOcorrenciaNoXml())
     {
         ocorrencias.Add(ocorrencia);
     }
 }
Example #20
0
        public List <T> ListarPor(Ocorrencia ocorrencia)
        {
            var query = GetQueryExpression <T>(true);

            query.Criteria.Conditions.Add(new Microsoft.Xrm.Sdk.Query.ConditionExpression("new_ocorrenciaid", Microsoft.Xrm.Sdk.Query.ConditionOperator.Equal, ocorrencia.Id));
            return((List <T>) this.RetrieveMultiple(query).List);
        }
Example #21
0
 public ActionResult AcessarOcorrencia(int Codigo, int IdCliente, string NomeCliente)
 {
     Session["CodigoCliente"] = IdCliente;
     Session["NomeCliente"]   = NomeCliente;
     Ocorrencia = Ocorrencia.BuscarOcorrencia(Codigo);
     return(View("AcessarOcorrencia", Ocorrencia));
 }
Example #22
0
        public OcorrenciaListaItemViewModel(Ocorrencia ocorrencia, long?atendimentoId, string possuiLaudo,
                                            bool vincularManual, bool possuiVinculoComAtendimentoId, long?pessoaFisicaId, long?pessoaJuridicaId,
                                            bool finalizada)
        {
            Id      = ocorrencia.Id;
            Cliente = ocorrencia.PessoaFisica != null
                ? ocorrencia.PessoaFisica.Nome.ToUpper()
                : (ocorrencia.PessoaJuridica != null
                    ? ocorrencia.PessoaJuridica.NomeFantasia.ToUpper()
                    : "Não informado");

            CriadoEm = ocorrencia.CriadoEm;
            Tipo     = ocorrencia.OcorrenciaTipo != null ? ocorrencia.OcorrenciaTipo.NomeExibicao : "Não informado";
            Status   = ocorrencia.StatusEntidade != null?ocorrencia.StatusEntidade.nome.ToUpper() : "Não informado";

            Responsavel = ocorrencia.Usuario != null?ocorrencia.Usuario.Nome.ToUpper() : "Não indentificado";

            DataUltimaAtualizacao         = ocorrencia.FinalizadoEm;
            AtendimentoId                 = atendimentoId;
            PossuiLaudo                   = possuiLaudo;
            VincularManual                = vincularManual;
            PossuiVinculoComAtendimentoId = possuiVinculoComAtendimentoId;
            PessoaFisicaId                = pessoaFisicaId;
            PessoaJuridicaId              = pessoaJuridicaId;
            Finalizada = finalizada;
        }
 internal void PreencherEntidade(Ocorrencia entidade)
 {
     entidade.IdMorador      = IdMorador;
     entidade.DataOcorrencia = DataOcorrencia;
     entidade.Motivo         = Motivo;
     entidade.Descricao      = Descricao;
 }
        public int CadastraOcorrencia(Ocorrencia o)
        {
            string sql = "INSERT INTO ocorrencia ([justificativa], [status], [codPonto]) VALUES (@justificativa, @status, @codPonto);";

            int result;

            SqlConnection conn   = new SqlConnection(strConnection);
            SqlCommand    sqlcmd = new SqlCommand(sql, conn);

            sqlcmd.Parameters.AddWithValue("@justificativa", o.GetJustificativa());
            sqlcmd.Parameters.AddWithValue("@status", o.GetStatus());
            sqlcmd.Parameters.AddWithValue("@codPonto", o.GetCodPonto());

            try
            {
                conn.Open();

                //verifica se possui algum resultado na consulta
                result = sqlcmd.ExecuteNonQuery();
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {
                conn.Close();
            }
            return(result);
        }
        public int EditarOcorrencia(Ocorrencia o)
        {
            string sql    = "UPDATE ocorrencia SET status = @status WHERE [codOcorrencia ] = @codOcorrencia;";
            int    result = 0;

            SqlConnection conn   = new SqlConnection(strConnection);
            SqlCommand    sqlcmd = new SqlCommand(sql, conn);

            sqlcmd.Parameters.AddWithValue("@status", o.GetStatus());
            sqlcmd.Parameters.AddWithValue("@codOcorrencia", o.GetCodOcorrencia());

            try
            {
                conn.Open();
                //verifica se possui algum resultado na consulta
                result = sqlcmd.ExecuteNonQuery();
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {
                conn.Close();
            }
            return(result);
        }
Example #26
0
        public void Add(Ocorrencia ocorrencia)
        {
            using (var dataContext = _dataContext)
            {
                try
                {
                    dataContext.BeginTransaction();
                    if (ValidaOcorrencia(ocorrencia))
                    {
                        ocorrencia.Data = DateTime.Now;
                        _ocorrenciaRepository.Add(ocorrencia);

                        dataContext.Commit();
                    }
                }
                catch (Exception ex)
                {
                    dataContext.Rollback();
                    ResponseService = new ResponseService(ResponseTypeEnum.Error, "Erro ao cadastrar a operação.");
                }
                finally
                {
                    dataContext.Finally();
                }
            }
        }
Example #27
0
        private void btnAtualizar_Click(object sender, RoutedEventArgs e) //Atualiza Cadastro ####
        {
            ControllerOcorrencia controllerOcorrencia = new ControllerOcorrencia();

            Ocorrencia ocorrencia = new Ocorrencia();

            ocorrencia.Bairro       = boxBairro.Text;
            ocorrencia.Natureza     = boxNatureza.Text;
            ocorrencia.Hora         = Convert.ToDouble(boxHora.Text);
            ocorrencia.OcorrenciaID = Convert.ToInt32(boxID.Text);

            bool ver;

            ver = controllerOcorrencia.Atualizar(ocorrencia);

            if (ver == true)
            {
                MessageBox.Show("Atualizado com sucesso");

                boxBairro.Clear();
                boxNatureza.Clear();
                boxID.Clear();
                boxHora.Clear();
            }
        }
Example #28
0
        public async Task <IActionResult> PutOcorrencia([FromRoute] int id, [FromBody] Ocorrencia ocorrencia)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != ocorrencia.OcorrenciaId)
            {
                return(BadRequest());
            }

            _context.Entry(ocorrencia).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!OcorrenciaExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Example #29
0
        public ActionResult Excluir(long id)
        {
            ViewBag.Setor = setores;
            ViewBag.Loja  = lojas;
            int        user_id    = HttpContext.Session.GetInt32("ID") ?? 0;
            Ocorrencia ocorrencia = _db.Int_DP_Ocorrencias.Find(id);

            Log log = new Log();

            try
            {
                //_db.Int_DP_Ocorrencias.Remove(ocorrencia);
                ocorrencia.Ativo = 0;
                _db.SaveChanges();

                TempData["ErroRelat"] = "Ocorrencia #" + id + " excluida!";

                log.ExcluirOcorrencia(user_id, id);
                _db.Int_DP_Logs.Add(log);
            }
            catch (Exception exp)
            {
                log.ExcluirOcorrencia_Erro(user_id, id, exp);
                _db.Int_DP_Logs.Add(log);
                TempData["ErroRelat"] = "Ocorreu um erro ao tentar excluir o registro!";
            }
            finally
            {
                _db.SaveChanges();
            }

            return(RedirectToAction("Index"));
        }
Example #30
0
 public void AtualizarUltimaOcorrencia(int dossieEsperadoId, Ocorrencia ocorrenciaParaSalvar)
 {
     this.Session
     .CreateQuery("update DossieEsperado set UltimaOcorrencia = :ocorrenciaParaSalvar where Id = :id")
     .SetParameter("ocorrenciaParaSalvar", ocorrenciaParaSalvar)
     .SetParameter("id", dossieEsperadoId)
     .ExecuteUpdate();
 }
        /// <summary>
        /// evento disparado pelo botão salvar
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btnSalvar_Click(object sender, EventArgs e)
        {
            try
            {
                //cria o objeto ocorrência
                Ocorrencia ocorrencia = new Ocorrencia();

                //atribui os dados da página no objeto
                ocorrencia.Usuario = base.UsuarioLogado;
                ocorrencia.TipoOcorrencia = ddlTipoOcorencia.SelectedItem.Text;
                ocorrencia.Detalhes = txtDetalhes.Text;
                ocorrencia.Status = Ocorrencia.StatusOcorrencia.Aberta;
                //salva a ocorrencia no banco
                ocorrencia.SaveAndFlush();
            }
            catch (Exception ex)
            {
                //grava a mensagem de erro no arquivo de log
                Logger.Error(ex.Message);
                base.ExibirMensagemErro();
            }
            base.ExibirMensagemSucesso(Funcionalidade.Ocorrencia, Operacao.Inclusao);
        }
Example #32
0
        public static AnaliseCreditoResult Analisar(IMovimento movimento)
        {
            AnaliseCreditoResult result = new AnaliseCreditoResult();

            //-------------------------------------------------------------------------
            // Buscar todos os movimentos em abertos que existem para este cliente
            //-------------------------------------------------------------------------

            Connection connection = null;
            ICliente cliente = movimento.DadoPessoa.Cliente as ICliente;

            if (movimento.New)
            {
                if (cliente != null)
                {
                    IOcorrencia ocorrencia = null;
                    IList<IOcorrencia> ocorrencias = cliente.Ocorrencias.Where(k => k.TipoOcorrencia == Enuns.Cadastro.Pessoa.TipoOcorrencia.AnaliseCredito).ToList();

                    try
                    {
                        if (cliente.Situacao == Enuns.Cadastro.Pessoa.Situacao.Bloqueado)
                        {
                            ocorrencia = new Ocorrencia();
                            ocorrencia.TipoOcorrencia = Enuns.Cadastro.Pessoa.TipoOcorrencia.AnaliseCredito;
                            ocorrencia.AcaoOcorrencia = Enuns.Cadastro.Pessoa.AcaoOcorrencia.Bloqueio;
                            ocorrencia.Descricao = "Análise de Crédito - Cliente com restrição - Faturamento: " + movimento.EGUID.ToString();
                            ocorrencia.Data = DateTime.Now;
                            cliente.Ocorrencias.Add(ocorrencia);
                            cliente.Save();
                            return new AnaliseCreditoResult
                            {
                                Status = Enuns.Financeiro.StatusAnaliseResult.Bloqueado,
                            };
                        }

                        double total = movimento.ValorTotalLiquido;
                        if (movimento is IVendaCF)
                        {
                            IVendaCF cf = movimento as IVendaCF;
                            IList<IBaixaForma> bxs = cf.Baixa.Formas.Where(i => (i.FormaPagamento.TipoForma == Enuns.Cadastro.TipoForma.Parcelado ||
                                           i.FormaPagamento.TipoForma == Enuns.Cadastro.TipoForma.CreditoConsumidor ||
                                           i.FormaPagamento.TipoForma == Enuns.Cadastro.TipoForma.Cheque)).ToList();
                            if (bxs.Count > 0)
                                total = bxs.Sum(i => i.ValorLiquido);
                            else
                            {
                                result.Status = Enuns.Financeiro.StatusAnaliseResult.Aprovado;
                                return result;
                            }
                        }
                        double limite = cliente.ValorLimiteCredto - cliente.ValorDocumentoAberto;
                        double risco = cliente.PercentualRisco > 0 ? (cliente.ValorLimiteCredto * ((cliente.PercentualRisco / 100))) : 0;

                        if (limite > total)
                        {
                            if (cliente.Situacao == Enuns.Cadastro.Pessoa.Situacao.AAutorizar)
                            {
                                ocorrencia = new Ocorrencia();
                                ocorrencia.TipoOcorrencia = Enuns.Cadastro.Pessoa.TipoOcorrencia.AnaliseCredito;
                                ocorrencia.AcaoOcorrencia = Enuns.Cadastro.Pessoa.AcaoOcorrencia.Nenhuma;
                                ocorrencia.Descricao = "Análise de Crédito - Cliente a autorizar - Faturamento: " + movimento.EGUID.ToString();
                                ocorrencia.Data = DateTime.Now;

                                result.Status = Enuns.Financeiro.StatusAnaliseResult.AguardarAnalise;
                            }
                            else if (cliente.Situacao == Enuns.Cadastro.Pessoa.Situacao.ComRestricao ||
                                cliente.Situacao == Enuns.Cadastro.Pessoa.Situacao.SemCredito)
                            {
                                ocorrencia = new Ocorrencia();
                                ocorrencia.TipoOcorrencia = Enuns.Cadastro.Pessoa.TipoOcorrencia.AnaliseCredito;
                                ocorrencia.AcaoOcorrencia = Enuns.Cadastro.Pessoa.AcaoOcorrencia.Bloqueio;
                                ocorrencia.Descricao = "Análise de Crédito - Cliente permitido faturamento somente a vista";
                                ocorrencia.Data = DateTime.Now;

                                result.Status = Enuns.Financeiro.StatusAnaliseResult.AprovadoSomenteAVista;
                            }
                            else
                            {
                                result.Status = Enuns.Financeiro.StatusAnaliseResult.Aprovado;
                            }
                        }
                        else
                        {
                            if ((limite + risco) > total)
                            {
                                result.Status = Enuns.Financeiro.StatusAnaliseResult.AprovadoComRisco;
                            }
                            else
                            {
                                result.Status = Enuns.Financeiro.StatusAnaliseResult.AguardarAnalise;
                                ocorrencia = new Ocorrencia();
                                ocorrencia.TipoOcorrencia = Enuns.Cadastro.Pessoa.TipoOcorrencia.AnaliseCredito;
                                ocorrencia.AcaoOcorrencia = Enuns.Cadastro.Pessoa.AcaoOcorrencia.Nenhuma;
                                ocorrencia.Descricao = "Análise de Crédito - Cliente a autorizar - Faturamento: " + movimento.EGUID.ToString();
                                ocorrencia.Data = DateTime.Now;
                            }
                        }
                        if (ocorrencia != null)
                            cliente.Ocorrencias.Add(ocorrencia);

                        cliente.Save();
                    }
                    finally
                    {
                        if (connection != null)
                            connection.Close();
                    }
                }
                else
                {
                    result.Status = Enuns.Financeiro.StatusAnaliseResult.ClienteNaoIdentificado;
                }
            }

            return result;
        }