public async Task <IActionResult> Create(Book book)
{
if (ModelState.IsValid)
{
_unityOfWork.Books.Add(book);
var result = await _unityOfWork.CompleteAsync();
TempData["CreateSuccess"] = $"Book {book.Name} has been created";
return(RedirectToAction(nameof(Index)));
}
return(View(book));
}
public async Task <UserResponse> SaveAsync(User user)
{
try
{
await _userRepository.AddAsync(user);
await _unityOfWork.CompleteAsync();
return(new UserResponse(user));
}
catch (Exception e)
{
return(new UserResponse($"An error occurred {e.Message}"));
}
}
public async Task <ProductResponse> SaveAsync(Product product)
{
try
{
await _productRepository.AddAsync(product);
await _unityOfWork.CompleteAsync();
return(new ProductResponse(product));
}
catch (Exception e)
{
return(new ProductResponse($"An error occurred {e.Message}"));
}
}
public async Task <PurchaseResponse> SaveAsync(Purchase purchase)
{
try
{
await _purchaseRepository.AddAsync(purchase);
await _unityOfWork.CompleteAsync();
return(new PurchaseResponse(purchase));
}
catch (Exception e)
{
return(new PurchaseResponse($"An error ocurred {e.Message}"));
}
}
public async Task <GenericResponse <Mode> > DeleteAsync(int id)
{
var existMode = await modeRepository.FindByIdAsync(id);
if (existMode == null)
{
return(new GenericResponse <Mode>("Mode doesn't exist!"));
}
try{
modeRepository.Delete(existMode);
await unityOfWork.CompleteAsync();
return(new GenericResponse <Mode>(existMode));
}
catch (Exception ex) {
return(new GenericResponse <Mode>($"Error with deleting mode: {ex.Message}"));
}
}
public async Task <GenericResponse <Player> > DeleteAsync(int id)
{
var isExist = await playerRepository.FindByIdAsync(id);
if (isExist == null)
{
return(new GenericResponse <Player>("Player doesn't exist!"));
}
try{
playerRepository.Delete(isExist);
await unityOfWork.CompleteAsync();
return(new GenericResponse <Player>(isExist));
}
catch (Exception ex) {
return(new GenericResponse <Player>($"Error with deleting player: {ex.Message}"));
}
}
public async Task <GenericResponse <LobbyGame> > DeleteAsync(int id)
{
var isExist = await lobbyGameRepository.FindByIdAsync(id);
if (isExist == null)
{
return(new GenericResponse <LobbyGame>("Lobby Game doesn't exist!"));
}
try{
lobbyGameRepository.Delete(isExist);
await unityOfWork.CompleteAsync();
return(new GenericResponse <LobbyGame>(isExist));
}
catch (Exception ex) {
return(new GenericResponse <LobbyGame>($"Error with deleting lobby game: {ex.Message}"));
}
}
public async Task <GenericResponse <PlayerLobbyGame> > DeleteAsync(PlayerLobbyGame playerLobbyGame)
{
var isExist = await playerLobbyGameRepository.
FindByCompatibleKeyAsync(playerLobbyGame.PlayerId, playerLobbyGame.LobbyGameId);
if (isExist == null)
{
return(new GenericResponse <PlayerLobbyGame>("PlayerLobbyGame doesn't exist!"));
}
try{
playerLobbyGameRepository.Delete(isExist);
await unityOfWork.CompleteAsync();
return(new GenericResponse <PlayerLobbyGame>(isExist));
}
catch (Exception ex) {
return(new GenericResponse <PlayerLobbyGame>($"Error with deleting PlayerLobbyGame: {ex.Message}"));
}
}
public async Task <SaveCategoryResponse> AddAsync(Category category)
{
try
{
await _categoryRepository.AddAsync(category);
await _unityOfWork.CompleteAsync();
return(new SaveCategoryResponse(category));
}
catch (Exception ex)
{
return(new SaveCategoryResponse($"Error to save the category: {ex.Message}"));
}
}
