public async Task DeleteAsync(int empresaId, string token)
{
try
{
await _segService.ValidateTokenAsync(token);
var telefone = _repository.GetList(t => t.EmpresaId.Equals(empresaId)).SingleOrDefault();
if (telefone != null)
{
telefone.Status = 9;
telefone.Ativo = false;
_repository.Update(telefone);
}
}
catch (ServiceException e)
{
throw e;
}
catch (InvalidTokenException e)
{
throw e;
}
catch (Exception e)
{
throw new EnderecoException("Não foi possível remover o endereço da oportunidade.", e);
}
}
public async Task <IActionResult> SaveAsync([FromRoute] string token, [FromBody] Especialidade especialidade)
{
try
{
await _service.ValidateTokenAsync(token);
var result = _domain.Save(especialidade);
return(Ok(result));
}
catch (InvalidTokenException e)
{
return(StatusCode(401, e.Message));
}
catch (ServiceException e)
{
return(StatusCode(401, e.Message));
}
catch (EspecialidadeException e)
{
return(StatusCode(400, e.Message));
}
catch (Exception e)
{
return(StatusCode(500, "Ocorreu um erro interno no servidor."));
}
}
/// <summary>
///
/// </summary>
/// <param name="oportunidade"></param>
/// <param name="token"></param>
/// <returns></returns>
/// <exception cref="OportunidadeException"></exception>
public async Task SaveAsync(Oportunidade oportunidade, string token)
{
try
{
if (oportunidade.ID == 0)
{
await _segService.ValidateTokenAsync(token);
oportunidade.DataCriacao = DateTime.UtcNow;
oportunidade.DataEdicao = DateTime.UtcNow;
oportunidade.Ativo = true;
var result = _opRepository.Add(oportunidade);
await _endService.SaveEnderecoAsync(oportunidade.Endereco, token);
}
else
{
await UpdateAsync(oportunidade, token);
}
}
catch (Exception e)
{
throw new OportunidadeException("Não foi possível salvar a oportunidade.", e);
}
}
public async Task <IActionResult> GetAllAsync([FromRoute] string token)
{
try
{
await _service.ValidateTokenAsync(token);
var result = _domain.GetAll();
return(Ok(result));
}
catch (ServiceException e)
{
return(StatusCode(401, e.Message));
}
catch (InvalidTokenException e)
{
return(StatusCode(401, e.Message));
}
catch (DadosBancariosException e)
{
return(StatusCode(400, e.Message));
}
catch (Exception e)
{
return(StatusCode(500, "Ocorreu um erro interno no servidor."));
}
}
public async Task <IActionResult> SaveAsync([FromRoute] string token, [FromBody] CheckIn checkIn)
{
try
{
await _service.ValidateTokenAsync(token);
var ci = _domain.Save(checkIn);
return(Ok(ci));
}
catch (InvalidTokenException e)
{
return(StatusCode(401, $"{ e.Message } { e.InnerException.Message }"));
}
catch (ServiceException e)
{
return(StatusCode(401, $"{ e.Message } { e.InnerException.Message }"));
}
catch (CheckInException e)
{
return(StatusCode(400, $"{ e.Message } { e.InnerException.Message }"));
}
catch (Exception e)
{
return(StatusCode(500, "Ocorreu um erro ao tentar salvar o check-in recebido. Entre em contato com o suporte."));
}
}
public async Task <IActionResult> InserirCreditoAsync([FromRoute] string token, [FromBody] IEnumerable <Extrato> extratos)
{
try
{
await _service.ValidateTokenAsync(token);
var result = _domain.Inserir(extratos);
var mainExtrato = extratos.FirstOrDefault();
await _emailHandler.EnviaEmailAsync(token, mainExtrato);
return(Ok(result));
}
catch (ServiceException e)
{
return(StatusCode(401, e.Message));
}
catch (InvalidTokenException e)
{
return(StatusCode(401, e.Message));
}
catch (ExtratoException e)
{
return(StatusCode(400, e.Message));
}
catch (Exception e)
{
return(StatusCode(500, "Ocorreu um erro interno no servidor."));
}
}
public async Task <IActionResult> BuscarPorIdsAsync([FromRoute] int idCliente, [FromRoute] string token, [FromBody] int id)
{
try
{
await _service.ValidateTokenAsync(token);
var result = _domain.GetByIdEmpresa(id);
return(Ok(result));
}
catch (ServiceException e)
{
return(StatusCode(401, e.Message));
}
catch (InvalidTokenException e)
{
return(StatusCode(401, e.Message));
}
catch (EspecialidadeException e)
{
return(StatusCode(400, e.Message));
}
catch (Exception e)
{
return(StatusCode(500, "Ocorreu um erro interno no servidor."));
}
}
public async Task EnviarEmailAsync(string token, Oportunidade oportunidade)
{
try
{
await _segService.ValidateTokenAsync(token);
var(emailConfigs, emailConstants) = GetConfiguration();
var content = await System.IO.File.ReadAllTextAsync("wwwroot/Criar-Opt.html");
foreach (var item in emailConstants)
{
var text = string.Empty;
if ("endereco".Equals(item.Key.ToLower()))
{
text = oportunidade.Endereco.GetType().GetProperty("Descricao").GetValue(oportunidade.Endereco, null).ToString();
}
else
{
text = oportunidade.GetType().GetProperty(item.Key).GetValue(oportunidade, null).ToString();
}
if (!string.IsNullOrEmpty(text))
{
content = content.Replace(item.Value, text);
}
}
var configuracoes = await _configService.GetConfiguracoesAsync(oportunidade.IdCliente, oportunidade.UsuarioCriacao);
var sender = emailConfigs.GetValue <string>("Sender");
var configuracao = configuracoes.Where(c => c.Chave.Equals(sender)).SingleOrDefault();
if (!string.IsNullOrEmpty(oportunidade.EmailEmpresa))
{
var emailToClient = new Email(content, $"Oportunidade: { oportunidade.Nome }", configuracao.Valor, oportunidade.EmailEmpresa, oportunidade.IdCliente);
await _emailService.EnviarEmailAsync(emailToClient, oportunidade.IdCliente, oportunidade.UsuarioCriacao);
}
}
catch (Exception e)
{
//Erro ao enviar e-mail não impacta no processo
}
}
public async Task <IActionResult> GenerateQrCode([FromRoute] int idCliente, [FromRoute] int idUsuario, [FromRoute] string token)
{
try
{
await _service.ValidateTokenAsync(token);
if (_domain.GetLast(idCliente, out var tokenQr))
{
tokenQr.QrCode = _handler.GenerateQr(tokenQr.Nome, 250, 250);
return(Ok(tokenQr));
}
var milliseconds = _configuration.GetValue <string>("TokenExpiration");
var options = new TokenOptions(DateTime.UtcNow, Guid.NewGuid().ToString(), milliseconds, idUsuario, idCliente);
tokenQr = new Token(options, true, string.Empty, true, 1);
var newToken = _domain.Save(tokenQr);
newToken.QrCode = _handler.GenerateQr(newToken.Nome, 250, 250);
return(Ok(newToken));
}
catch (InvalidTokenException e)
{
return(StatusCode(401, e.Message));
}
catch (TokenException e)
{
return(StatusCode(400, e.Message));
}
catch (QrCodeException e)
{
return(StatusCode(400, e.Message));
}
catch (ServiceException e)
{
return(StatusCode(401, e.Message));
}
catch (Exception e)
{
return(StatusCode(500, "Ocorreu um erro interno no servidor."));
}
}
public async Task <IEnumerable <TipoEmpresa> > GetAllAsync(int idCliente, string token)
{
try
{
await _segService.ValidateTokenAsync(token);
var result = _repository.GetList(te => te.IdCliente.Equals(idCliente) && te.Ativo);
return(result);
}
catch (InvalidTokenException e)
{
throw e;
}
catch (ServiceException e)
{
throw e;
}
catch (Exception e)
{
throw new EmpresaException("Não foi possível recuperar a lista de tipos de empresas.", e);
}
}
public async Task DeleteAsync(Contato entity, string token)
{
try
{
await _segService.ValidateTokenAsync(token);
entity.Status = 9;
entity.Ativo = false;
_repository.Update(entity);
}
catch (ServiceException e)
{
throw e;
}
catch (InvalidTokenException e)
{
throw e;
}
catch (Exception e)
{
throw new ContatoException("Não foi possível remover o contato da empresa.", e);
}
}
public async Task <IEnumerable <OportunidadeStatus> > GetAllAsync(int idCliente, string token)
{
try
{
await _segService.ValidateTokenAsync(token);
var result = _osRepository.GetList(s => s.IdCliente.Equals(idCliente));
return(result);
}
catch (InvalidTokenException e)
{
throw e;
}
catch (Exception e)
{
throw new OportunidadeException("Não foi possível recuperar a lista de status das oportunidades.", e);
}
}
public async Task DeleteAsync(Empresa entity, string token)
{
try
{
await _segService.ValidateTokenAsync(token);
var empresa = _repository.GetList(e => e.ID.Equals(entity.ID)).SingleOrDefault();
empresa.Status = 9;
empresa.Ativo = false;
_repository.Update(empresa);
}
catch (InvalidTokenException e)
{
throw e;
}
catch (ServiceException e)
{
throw e;
}
catch (Exception e)
{
throw new EmpresaException("Não foi possível remover a empresa informada.", e);
}
}
public async Task EnviaEmailAsync(string token, Extrato extrato)
{
try
{
await _service.ValidateTokenAsync(token);
var(emailConfigs, emailConstants) = GetConfiguration();
var content = await System.IO.File.ReadAllTextAsync("wwwroot/Credito.html");
foreach (var item in emailConstants)
{
var text = extrato.GetType().GetProperty(item.Key).GetValue(extrato, null).ToString();
if (!string.IsNullOrEmpty(text))
{
content = content.Replace(item.Value, text);
}
}
var configuracoes = await _configService.GetConfiguracoesAsync(extrato.IdCliente, extrato.UsuarioCriacao);
var sender = emailConfigs.GetValue <string>("Sender");
var configuracao = configuracoes.Where(c => c.Chave.Equals(sender)).SingleOrDefault();
if (!string.IsNullOrEmpty(extrato.EmailEmpresa))
{
var emailToClient = new Email(content, "Crédito em conta StaffPro", configuracao.Valor, extrato.EmailEmpresa, extrato.IdCliente);
await _emailService.EnviarEmailAsync(emailToClient, extrato.IdCliente, extrato.UsuarioCriacao);
}
}
catch (Exception e)
{
//Erro ao enviar e-mail não impacta no processo
}
}
public async Task DeleteAsync(Endereco entity, string token)
{
try
{
await _segService.ValidateTokenAsync(token);
var endereco = _edRepository.GetList(e => e.EmpresaId.Equals(entity.EmpresaId)).SingleOrDefault();
endereco.Status = 9;
endereco.Ativo = false;
_edRepository.Update(endereco);
}
catch (ServiceException e)
{
throw e;
}
catch (InvalidTokenException e)
{
throw e;
}
catch (Exception e)
{
throw new EnderecoException("Não foi possível remover o endereço da oportunidade.", e);
}
}
public async Task <Endereco> SaveAsync(Endereco entity, string token)
{
try
{
await _segService.ValidateTokenAsync(token);
if (entity.ID == 0)
{
entity.DataCriacao = DateTime.UtcNow;
entity.DataEdicao = DateTime.UtcNow;
entity.ID = _edRepository.Add(entity);
}
else
{
entity = await UpdateAsync(entity, token);
}
return(entity);
}
catch (Exception e)
{
throw new EnderecoException("Não foi possível salvar o endereço da oportunidade. Entre em contato com o suporte.", e);
}
}
/// <summary>
///
/// </summary>
/// <param name="entity"></param>
/// <param name="token"></param>
/// <returns></returns>
/// <exception cref="OportunidadeException"></exception>
/// <exception cref="InvalidTokenException"></exception>
public async Task <Oportunidade> SaveAsync(Oportunidade entity, string token)
{
try
{
await _segService.ValidateTokenAsync(token);
if (entity.ID == 0)
{
entity.DataCriacao = DateTime.UtcNow;
entity.DataEdicao = DateTime.UtcNow;
entity.Ativo = true;
var result = _opRepository.Add(entity);
entity.Endereco.OportunidadeId = result;
}
else
{
entity = await UpdateAsync(entity, token);
}
return(entity);
}
catch (InvalidTokenException e)
{
throw e;
}
catch (Exception e)
{
throw new OportunidadeException("Não foi possível completar a operação.", e);
}
}