Step 1. Now that we have our local database set up, let's use it to store game reviews.
Step 1.1. Code:
using System.ComponentModel.DataAnnotations;
namespace Models.DTOs;
public class DTOBase
{
[Key]
public int? Id { get; set; }
public int? ExternalId { get; set; }
public DateTime CreatedAt { get; set; }
public DateTime UpdatedAt { get; set; }
public bool Inactive { get; set; }
}
Step 1.2. In the same folder, let's create GameDTO.
namespace Models.DTOs;
[Microsoft.EntityFrameworkCore.Index(nameof(IGDBId), IsUnique = true)]
public class GameDTO : DTOBase
{
public int? IGDBId { get; set; }
public int UserId { get; set; }
public required string Name { get; set; }
public string? ReleaseDate { get; set; }
public string? Platforms { get; set; }
public string? Summary { get; set; }
public string? CoverUrl { get; set; }
public required GameStatus Status { get; set; }
public int? Rate { get; set; }
}
public enum GameStatus
{
Want,
Playing,
Played
}
Step 2. In DbCtx.cs, add the Games table
Step 2.1. Code:
public virtual required DbSet<GameDTO> Games { get; set; }
Step 3. In the repo project, create the GameRepo.cs.
Step 4. In the repo project, create the GameRepo.cs:
using Microsoft.EntityFrameworkCore;
using Models.DTOs;
namespace Repo
{
public class GameRepo(IDbContextFactory<DbCtx> DbCtx)
{
public async Task<int> CreateAsync(GameDTO game)
{
using var context = DbCtx.CreateDbContext();
await context.Games.AddAsync(game);
return await context.SaveChangesAsync();
}
}
}
Step 4.1. Extract the interface from this class.
Step 5. Save the image locally so that, after adding the game, we can retrieve it without relying on an internet connection. In the ApiRepo project, inside the IGDBGamesAPIRepo class, create the GetGameImageAsync function.
public static async Task<byte[]> GetGameImageAsync(string imageUrl)
{
try
{
using HttpClient httpClient = new();
var response = await httpClient.GetAsync(imageUrl);
if (!response.IsSuccessStatusCode)
throw new Exception($"Exception downloading image URL: {imageUrl}");
return await response.Content.ReadAsByteArrayAsync();
}
catch (Exception ex)
{
throw new Exception($"Error fetching image: {ex.Message}", ex);
}
}
Step 5.1. In the Services project, inside the IGDBGamesApiService class, create the SaveImageAsync function.
public static async Task SaveImageAsync(string imageUrl, string fileName)
{
try
{
byte[] imageBytes = await IGDBGamesAPIRepo.GetGameImageAsync(imageUrl);
string filePath = Path.Combine(GameService.ImagesPath, fileName);
if (File.Exists(filePath))
return;
await File.WriteAllBytesAsync(filePath, imageBytes);
}
catch (Exception)
{
throw; // Consider logging the exception instead of rethrowing it blindly
}
}
Step 6. Create a function to add the repositories in MauiProgram.
public static IServiceCollection Repositories(this IServiceCollection services)
{
services.AddScoped<IGameRepo, GameRepo>();
return services;
}
Step 7. Call this function inside CreateMauiApp()
Step 7.1. Add a function to create the image path.
Step 7.2. Code:
if (!System.IO.Directory.Exists(GameService.ImagesPath))
System.IO.Directory.CreateDirectory(GameService.ImagesPath);
Step 8. In Models.Resps, create an object to handle the service response for the mobile project.
Step 8.1. Code:
namespace Models.Resps;
public class ServiceResp
{
public bool Success { get; set; }
public object? Content { get; set; }
}
Step 9. Create the GameService.
Step 9.1. Code:
using Models.DTOs;
using Models.Resps;
using Repo;
namespace Services
{
public static readonly string ImagesPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Inventory");
public class GameService(IGameRepo GameRepo)
{
public async Task<ServiceResp> CreateAsync(GameDTO game)
{
game.CreatedAt = game.UpdatedAt = DateTime.Now;
//User id fixed to 1
game.UserId = 1;
await GameRepo.CreateAsync(game);
return new ServiceResp(true);
}
}
}
Step 9.2. Press [Ctrl + .] to extract the interface, then add the service to the Dependency Injection (DI). In MauiProgram, inside the Services function, add the line.
Step 9.3. Code:
services.AddScoped<IGameService, GameService>();
Step 10. In AddGameVM, add a variable to control the accessibility of the confirm button:
Step 10.1. Code:
private bool confirmIsEnabled = true;
public bool ConfirmIsEnabled
{
get => confirmIsEnabled;
set => SetProperty(ref confirmIsEnabled, value);
}
Step 11. Remove gameStatus from AddGameVM so that it uses the one from the DTO model.
Step 12. Add IGameService to the AddGameVM constructor.
Step 13. Create the command that adds the game to the local database with the information that will be displayed in the app. Simultaneously attempts to save the image for local use. After insertion, displays a message and returns to the search screen.
[RelayCommand]
public async Task Confirm()
{
// Disable button to prevent multiple requests
ConfirmIsEnabled = false;
string displayMessage;
int? _rate = null;
try
{
if (GameSelectedStatus == GameStatus.Played)
{
displayMessage = "Game and rate added successfully!";
_rate = Rate;
}
else
{
displayMessage = "Game added successfully!";
}
if (IsOn && CoverUrl is not null)
{
_ = IGDBGamesApiService.SaveImageAsync(CoverUrl, $"{IgdbId}.jpg");
}
GameDTO game = new()
{
IGDBId = int.Parse(Id),
Name = Name,
ReleaseDate = ReleaseDate,
CoverUrl = CoverUrl,
Platforms = Platforms,
Summary = Summary,
Status = GameSelectedStatus.Value,
Rate = _rate
};
var resp = await gameService.CreateAsync(game);
if (!resp.Success) displayMessage = "Error adding game";
// Display message and navigate back
bool displayResp = await Application.Current.Windows[0].Page.DisplayAlert("Aviso", displayMessage, null, "Ok");
if (!displayResp)
{
await Shell.Current.GoToAsync("..");
}
}
catch (Microsoft.EntityFrameworkCore.DbUpdateException)
{
bool displayResp = await Application.Current.Windows[0].Page.DisplayAlert("Error", "Game already added!", null, "Ok");
if (!displayResp)
{
await Shell.Current.GoToAsync("..");
}
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}");
throw;
}
finally
{
ConfirmIsEnabled = true;
}
}
Step 14. Bind the command to the button:
Step 14.1. Code:
Command="{Binding ConfirmCommand}"
Step 15. Update the database version to be recreated with the current structure.
Step 16. Run the system and add a game, then return to the search:
If the same game is saved again, display a message notifying that it has already been added.
Now, our game is successfully saved in the local database without duplication.