public ActionResult Atualiza(int id)
{
var dao = new RevendedorDAO();
Revendedor revendedor = dao.BuscaPorId(id);
return(View(revendedor));
}
public async Task RevendedorServiceTests_Obter_Sucesso_AprovacaoAutomatica()
{
//Arrange
var autoMocker = new AutoMocker();
var revendedorService = autoMocker.CreateInstance <RevendedorService>();
var revendedor = new Revendedor
{
CPF = "15350946056",
Email = "*****@*****.**",
Senha = "$Senha0002"
};
var revRepMock = autoMocker.GetMock <IRevendedorRepository>();
revRepMock.Setup((foo) => foo.Buscar(revendedor.CPF)).ReturnsAsync(revendedor);
//Act
var retorno = await revendedorService.Obter(revendedor.CPF);
//Assert
Assert.True(retorno.Successo);
Assert.True(retorno.Revendedor.CompraAutoAprovada);
Assert.Empty(retorno.Messagem);
Assert.True(retorno.CodigoRetorno == 200);
}
public async Task <ActionResult <Revendedor> > Register(Revendedor revendedor)
{
const string endpointName = nameof(Register);
string header = $"POST | {revendedor.Email} | {controllerName}: {endpointName}";
try
{
logger.LogInformation((int)LogEventEnum.Events.InsertItem,
$"{header} - {MessageLog.Start.Value}");
Revendedor result = await service.Register(revendedor);
logger.LogInformation((int)LogEventEnum.Events.InsertItem,
$"{header} - {MessageLog.Stop.Value}");
return(Ok(result));
}
catch (Exception ex)
{
logger.LogError((int)LogEventEnum.Events.InsertItemError, ex,
$"{header} - {MessageLog.Error.Value} | Exception: {ex.Message}");
return(StatusCode(StatusCodes.Status500InternalServerError,
new { message = MessageError.InternalError.Value, error = ex.Message }));
}
}
public async Task <RegistrarRevendedorResponse> Adicionar(Revendedor revendedor)
{
try
{
if (!ValidarEmail(revendedor.Email))
{
return(new RegistrarRevendedorResponse("Email Invalido", 400));
}
revendedor.CPF = LimparCPF(revendedor.CPF);
if (!ValidarCPF(revendedor.CPF))
{
return(new RegistrarRevendedorResponse("CPF Invalido", 400));
}
var token = await _autenticacaoService.Registrar(revendedor.CPF, revendedor.Email, revendedor.Senha);
if (!token.Successo)
{
return(new RegistrarRevendedorResponse(token.Messagem, token.CodigoRetorno));
}
await _revendedorRepository.Inserir(revendedor);
var response = new RegistrarRevendedorResponse(token.Token);
return(response);
}
catch (Exception exception)
{
_logger.LogError(exception, exception.Message);
throw exception;
}
}
public async Task <IActionResult> PutRevendedor(long id, Revendedor revendedor)
{
if (id != revendedor.id)
{
return(BadRequest());
}
_context.Entry(revendedor).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RevendedorExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <Revendedor> > PostRevendedor(Revendedor revendedor)
{
_context.Revendedores.Add(revendedor);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetRevendedor", new { id = revendedor.id }, revendedor));
}
public async Task <Response> Handle(CadastrarRevendedorCommand request, CancellationToken cancellationToken)
{
var response = new Response();
if (request.Invalid)
{
response.AddNotifications(request.Notifications);
return(response);
}
var revendedor = await _repositorio.ObterPorEmailAsync(request.Email);
if (revendedor != null)
{
response.AddNotification("Jà existe um Revendedor com esse e-mail");
return(response);
}
revendedor = new Revendedor(request.Nome, request.Cpf, request.Email, request.Senha);
await _repositorio.InserirAsync(revendedor);
response.AddValue(revendedor);
return(response);
}
public async Task <IHttpActionResult> PutRevendedor(int id, Revendedor revendedor)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != revendedor.Id)
{
return(BadRequest());
}
db.Entry(revendedor).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RevendedorExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public ActionResult Remover(int id)
{
var dao = new RevendedorDAO();
Revendedor revendedor = dao.BuscaPorId(id);
dao.Remover(revendedor);
return(RedirectToAction("Index"));
}
public void Adicionar(Revendedor revendedor)
{
using (var contexto = new EcommerceContext())
{
contexto.Revendedores.Add(revendedor);
contexto.SaveChanges();
}
}
//UPDATE
public void Atualizar(Revendedor revendedor)
{
using (var contexto = new EcommerceContext())
{
contexto.Revendedores.Update(revendedor);
contexto.SaveChanges();
}
}
public Compra(int id, DateTime dataCompra, double valorCompra, StatusCompra statusCompra, Revendedor revendedor)
{
Id = id;
DataCompra = dataCompra;
ValorCompra = valorCompra;
StatusCompra = statusCompra;
Revendedor = revendedor;
}
public ActionResult Alterar(int id)
{
var dao = new RevendedorDAO();
Revendedor revendedor = dao.BuscaPorId(id);
var revendedorViewModel = Mapper.Map <Revendedor, RevendedorViewModel>(revendedor);
ViewBag.Revendedor = revendedorViewModel;
return(View(revendedorViewModel));
}
public RevendedorServiceTests()
{
_revendedorMock = new Revendedor
{
CPF = "57246534008",
Email = "*****@*****.**",
Senha = "$Senha0002",
Id = 999
};
}
public async Task <IActionResult> Incluir(Revendedor revendedor)
{
if (!ModelState.IsValid)
{
return(View(revendedor));
}
await _revendedorServico.IncluirAsync(revendedor);
return(RedirectToAction(nameof(Index)));
}
public async Task <IHttpActionResult> GetRevendedor(int id)
{
Revendedor revendedor = await db.Revendedors.FindAsync(id);
if (revendedor == null)
{
return(NotFound());
}
return(Ok(revendedor));
}
public IActionResult Cadastrar(Revendedor revendedor)
{
try
{
_revendedor.CadastrarRevendedor(revendedor);
return(new ObjectResult("Revendedor cadastrado com sucesso!"));
}
catch (Exception e)
{
return(new ObjectResult(e.Message));
}
}
public async Task <IHttpActionResult> PostRevendedor(Revendedor revendedor)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Revendedors.Add(revendedor);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = revendedor.Id }, revendedor));
}
private static ClaimsIdentity GetClaimsIdentity(Revendedor usuario)
{
var identity = new ClaimsIdentity
(
new GenericIdentity(usuario.Email),
new[] {
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Sub, usuario.Nome),
}
);
return(identity);
}
public async Task <ActionResult> RegistrarRevendedor(AdicionarRevendedorRequest adicionarRequest)
{
var Revendedor = new Revendedor
{
CPF = adicionarRequest.CPF,
Email = adicionarRequest.Email,
Nome = adicionarRequest.Nome,
Senha = adicionarRequest.Senha
};
return(TratarRetorno <RegistrarRevendedorResponse>(
await _revendedorService.Adicionar(Revendedor),
nameof(RegistrarRevendedor)));
}
public async Task <IHttpActionResult> DeleteRevendedor(int id)
{
Revendedor revendedor = await db.Revendedors.FindAsync(id);
if (revendedor == null)
{
return(NotFound());
}
db.Revendedors.Remove(revendedor);
await db.SaveChangesAsync();
return(Ok(revendedor));
}
private async Task HandleJwt(Response response, Revendedor revendedor)
{
var jwt = _jwtService.CreateJsonWebToken(revendedor);
await _refreshTokenRepository.Salvar(jwt.RefreshToken);
response.AddValue(new
{
access_token = jwt.AccessToken,
refresh_token = jwt.RefreshToken.Token,
token_type = jwt.TokenType,
expires_in = jwt.ExpiresIn,
id = revendedor.Id,
nome = revendedor.Nome,
});
}
public async Task <IActionResult> Editar(int id, Revendedor revendedor)
{
if (!ModelState.IsValid)
{
return(View(revendedor));
}
if (id != revendedor.Id)
{
return(RedirectToAction(nameof(Error), new { message = "Mensagem personalizada BadRequest" }));
}
await _revendedorServico.EditarAsync(revendedor);
return(RedirectToAction(nameof(Index)));
}
public async void ShouldInsertRevendedor()
{
var revendedor = new Revendedor()
{
NomeCompleto = "Nome",
CPF = "111.222.333-00",
Email = "*****@*****.**",
Senha = "1234"
};
var command = await _service.InsertAsync(revendedor);
Assert.NotNull(command);
var resultado = await _repository.FindAsync(command.Id);
Assert.NotNull(resultado);
}
public async void ShouldNotInsertWhenNotExistCpf()
{
var revendedor = new Revendedor()
{
NomeCompleto = "Nome",
CPF = "045.441.233-98",
Email = "*****@*****.**",
Senha = "1234",
};
await _revendedorService.InsertAsync(revendedor);
var compra = new Compra(1, 1200);
Func <Task> serviceCall = async() => { await _service.InsertAsync(compra, "045.441.233-00"); };
serviceCall.Should().Throw <NotFoundException>();
}
public void CadastrarRevendedor(Revendedor revendedor)
{
if (_context.Revendedor.Any(r => r.Email == revendedor.Email || r.CPF == revendedor.CPF))
{
throw new Exception("Revendedor já existe.");
}
try
{
_context.Add(revendedor);
_context.SaveChanges();
}
catch (Exception e)
{
throw e;
}
}
public async Task EditarAsync(Revendedor obj)//tratar exceções
{
bool hasAny = await _contexto.Revendedor.AnyAsync(x => x.Id == obj.Id);
if (!hasAny)
{
throw new NotFoundException("Id não encontrado");
}
try
{
_contexto.Revendedor.Update(obj);
await _contexto.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException e)
{
throw new DbConcurrencyException(e.Message);
}
}
public void Seed()
{
if (_context.Compra.Any() ||
_context.Revendedor.Any()
)
{
return;
}
Revendedor revendedor = new Revendedor(1, "Ari", 00009990912, "*****@*****.**", "abcd1234");
Compra compra = new Compra(1, new DateTime(2020, 08, 16), 300.00, StatusCompra.Pendente, revendedor);
_context.Revendedor.AddRange(revendedor);
_context.Compra.AddRange(compra);
_context.SaveChanges();
}
public async void ShouldInsertWithSucess()
{
var revendedor = new Revendedor()
{
NomeCompleto = "Nome",
CPF = "111.222.333-00",
Email = "*****@*****.**",
Senha = "1234",
};
await _revendedorService.InsertAsync(revendedor);
var compra = new Compra(1, 1200);
var command = await _service.InsertAsync(compra, revendedor.CPF);
Assert.NotNull(command);
var compraBd = await _repository.FindAsync(command.Id);
Assert.NotNull(compraBd);
}
public async Task <ActionResult <Compra> > PostCompra(Compra compra)
{
Revendedor revendedor = _context.Revendedores.Where(r => r.cpf.Equals(compra.cpf)).FirstOrDefault();
if (compra.cpf.Equals("153.509.460-56"))
{
compra.status = "Aprovado";
}
compra.cashbackPorcentagem = Cashback.getPercentual(compra.valor).ToString("P", CultureInfo.InvariantCulture);
compra.cashbackValor = Cashback.getValor(compra.valor);
_context.Compras.Add(compra);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetCompra", new { id = compra.id }, compra));
}
