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));
}
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 + "]");
}
}
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);
}
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";
}
}
}
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));
}
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);
}
}
}
// 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"
});
}
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);
}
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);
}
}
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;
}
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.");
}
}
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);
}
}
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)));
}
/// <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;
}
}
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));
}
public static void AdicionarOcorrencia(this List <Ocorrencia> ocorrencias, Ocorrencia ocorrencia)
{
if (ocorrencia != null && ocorrencia.ExibirOcorrenciaNoXml())
{
ocorrencias.Add(ocorrencia);
}
}
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);
}
public ActionResult AcessarOcorrencia(int Codigo, int IdCliente, string NomeCliente)
{
Session["CodigoCliente"] = IdCliente;
Session["NomeCliente"] = NomeCliente;
Ocorrencia = Ocorrencia.BuscarOcorrencia(Codigo);
return(View("AcessarOcorrencia", Ocorrencia));
}
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);
}
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();
}
}
}
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();
}
}
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());
}
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"));
}
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);
}
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;
}