public async Task AtualizarAsync(Vendedor obj)
{
//Any serve para verificar se existe algum registro do banco de dados com a condicao que for colocado como parametro
bool temAlgum = await _context.Vendedor.AnyAsync(x => x.Id == obj.Id);
if (!temAlgum)
{
throw new NaoEncontrouExcecao("Id nao Encontrado");
}
try
{
_context.Update(obj);
await _context.SaveChangesAsync();
}
// intercepta uma excecao do nivel de acesso a dados.
catch (DbExcecaoSimultaniedade e)
{
/*relanca a excecao usando(DbExcecaoSimultaniedade) em nivel de servico. Importante pra segrega as camadas a camada de servico ela nao
* propaga uma execao de acesso a dados, se uma excecao de nivel de acesso a dados acontece a camada de servico vai lanca uma excecao da
* camada dela(DbExcecaoSimultaniedade) e ai o controlador no caso o VendedorController ele vai ter que lidar somente com excecoes da
* camada de servico.*/
throw new DbExcecaoSimultaniedade(e.Message);
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Nome")] Departamento departamento)
{
if (id != departamento.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(departamento);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DepartamentoExists(departamento.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(departamento));
}
public void Update(Vendedor obj)
{
if (!_context.Vendedor.Any(x => x.Id == obj.Id))
{
throw new NotFoundException("Id não encontrado");
}
try
{
_context.Update(obj);
_context.SaveChanges();
}
catch (DbUpdateConcurrencyException e)
{
throw new DbConcurrencyException(e.Message);
}
}
public void Update(Seller obj)
{
if (!_context.Seller.Any(x => x.Id == obj.Id))
{
throw new NotFoundException("ID not found.");
}
try
{
_context.Update(obj);
_context.SaveChanges();
}
catch (DbUpdateConcurrencyException e)
{
throw new DbConcurrencyException(e.Message);
}
}
public async Task UpdateAsync(Vendedor obj)
{
bool hasAny = await _context.Vendedor.AnyAsync(x => x.Id == obj.Id);
if (!hasAny)
{
throw new NotFoundException("Id Not Found");
}
try
{
_context.Update(obj);
await _context.SaveChangesAsync();
}catch (DbUpdateConcurrencyException e)
{
throw new DbConcurrencyException(e.Message);
}
}
public async Task AtualizarAsync(Vendedor obj)
{
//Any serve para falar se existe um registro no banco com a condição que for colocado
bool temAlgum = await _context.Vendedor.AnyAsync(v => v.Id == obj.Id);
if (!temAlgum)
{
throw new NotFoundException("Id não encontrado");
}
try
{
_context.Update(obj);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException e)
{
throw new DbConcurrencyException(e.Message);
}
}
public async Task UpdateAsync(Vendedor obj)
{
// a exclamação na frente da condição quer dizer que "Se a condição NÃO FOR VERDADEIRA"
bool hasAny = await _context.Vendedor.AnyAsync(vendedor => vendedor.Id == obj.Id);
if (!hasAny)
{
throw new NotFoundException("Id não Encontrado");
}
try
{
_context.Update(obj);
await _context.SaveChangesAsync();
}
catch (DbConcurrencyException e)
{
throw new DbConcurrencyException(e.Message);
}
}
public async Task UpdateAsync(SalesRecord obj) // recebe um objeto do tipo Seller. Assincrono
{
bool hasAny = await _context.SalesRecord.AnyAsync(x => x.Id == obj.Id); // Modificado por causa de método sincrono. O teste é feito antes do if.
// if (!_context.SalesRecordr.Any(x => x.Id == obj.Id)) // Verificar se na Base de Dados não existe um vendedor igual ao do objeto recebido no método.
if (!hasAny)
{
throw new NotFoundException("Id não encontrado");
}
try
{
_context.Update(obj); // Atualiza o objeto SalesRecord na Base de Dados
await _context.SaveChangesAsync(); // Guarda as alterações. Assincrono.
}
catch (DbConcurrencyException e) // Intercepta a exceção do nível de acesso a dados e relanço-a através da que criei a nível de serviço.
// Organização por camadas. Tratamento a nível se serviço. O Controlador(SalesRecordController) só trata a exceção lançada pelo serviço.
{
throw new DbConcurrencyException(e.Message);
}
}
public async Task UpdateAsync(Seller obj) // recebe um objeto do tipo Seller. Assincrono
{
bool hasAny = await _context.Seller.AnyAsync(x => x.Id == obj.Id); // Modificado por causa de método sincrono. O teste é feito antes do if.
// if (!_context.Seller.Any(x => x.Id == obj.Id)) // Verificar se na Base de Dados não existe um vendedor igual ao do objeto recebido no método.
if (!hasAny)
{
throw new NotFoundException("Id not found");
}
try
{
_context.Update(obj); // Atualiza o objeto Seller na Base de Dados
await _context.SaveChangesAsync(); // Guarda as alterações. Assincrono.
}
catch (DbConcurrencyException e) // Intercepta a exceção de conflito de concorrencia gerada pela Base de Dados que gera uma exceção com o nome DdConcurren, do nível de acesso a dados e relanço-a através da que criei a nível de serviço.
// Organização por camadas. Tratamento a nível se serviço. O Controlador(SellersController) só trata a exceção lançada pelo serviço.
{
throw new DbConcurrencyException(e.Message); // Lança a exceção a nível de serviço ( a que criamos ) e envia a mensagem recebida da Base de Dados..
// Aqui intercetamos uma exceção do nível de acesso a dados e relancamo-la na exceção a nível de serviço e assim o controller lida apenas com a exceção de serviço.
}
}
// Operacao assincrona
public async Task UpdateAsync(Vendedor obj)
{
// Operacao realizada no banco
// Código movido de dentro fo If para fora do mesmo e atribuido a variável booleana hasAny
bool hasAny = await _context.Vendedor.AnyAsync(x => x.Id == obj.Id);
if (!hasAny)
{
throw new NotFoundException("Id não encontrado");
}
try
{
// Operacao realizada em memoria
_context.Update(obj);
// Operacao realizada no banco
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException e)
{
throw new DbConcurrencyException(e.Message);
}
}
public void Atualizar(Vendedor vendedor)
{
_context.Update(vendedor);
_context.SaveChanges();
}