Added game and deck models

README.md

@@ -0,0 +1,54 @@
+# SDG-Backend-Barracuda
+
+This is an ASP.NET Core Web API with a PostgreSQL backend, using Dapper for high-performance data access.
+
+## Prerequisites
+
+- [.NET 10 SDK](https://dotnet.microsoft.com/download/dotnet/10.0)
+- [PostgreSQL](https://www.postgresql.org/download/)
+
+## PostgreSQL Database Setup
+
+Follow these steps to set up your local PostgreSQL database:
+
+### 1. Create Database and User
+If you haven't already, create a database and a user with appropriate permissions. You can use `psql` or a tool like pgAdmin.
+
+```sql
+
+-- Create SDG-Backend-Admin
+CREATE USER "SDG-Backend-Admin" WITH ENCRYPTED PASSWORD 'password';
+
+-- Create the database
+CREATE DATABASE "SDG-Backend" OWNER "SDG-Backend-Admin";
+```
+
+### 2. Configure Connection String
+#### Initialize User Secrets
+Run this in the project directory (`SDG-Backend-Barracuda\SDG-Backend-Barracuda`):
+```bash
+dotnet user-secrets init
+```
+
+#### Set the Connection String
+Replace `password` if you used a different one during setup:
+```bash
+dotnet user-secrets set "ConnectionStrings:DefaultConnection" "Host=localhost;Database=SDG-Backend;Username=SDG-Backend-Admin;Password=password;Maximum Pool Size=100;"
+```
+
+## Development
+
+### Installing Dependencies
+The project uses `Npgsql`, `Dapper`, and `Npgsql.DependencyInjection`.
+
+```bash
+dotnet add package Npgsql
+dotnet add package Dapper
+dotnet add package Npgsql.DependencyInjection
+```
+
+### Running the Application
+From the root directory:
+```bash
+dotnet run --project SDG-Backend-Barracuda
+```

SDG-Backend-Barracuda/Models/CardListModel.cs

@@ -0,0 +1,177 @@
+using Dapper;
+using Npgsql;
+
+namespace SDG_Backend_Barracuda.Models;
+
+public record CardList
+{
+    public int Id { get; init; }
+    public IEnumerable<Card>? Cards { get; init; }
+    public IEnumerable<CardList>? SubLists { get; init; }
+
+    public CardList() { }
+
+    public CardList(int id, IEnumerable<Card>? cards = null, IEnumerable<CardList>? subLists = null)
+    {
+        Id = id;
+        Cards = cards;
+        SubLists = subLists;
+    }
+}
+
+public record CardListInformation(IEnumerable<int>? CardIds = null, IEnumerable<int>? SubListIds = null);
+
+public interface ICardListModel : IDatabaseModel<CardList, CardListInformation>
+{}
+
+public class CardListModel(NpgsqlDataSource dataSource) : ICardListModel, IEndpointRouteHandler
+{
+    public static void MapEndpoints(IEndpointRouteBuilder router)
+    {
+        var listEndpoint = router.MapGroup("/cardlist");
+
+        // Create
+        listEndpoint.MapPost("/", async (CardListInformation input, ICardListModel model) =>
+        {
+            var newList = await model.Create(input);
+            return Results.Created($"/cardlist/{newList.Id}", newList);
+        });
+
+        // Get all
+        listEndpoint.MapGet("/", async (ICardListModel model) =>
+            Results.Ok(await model.GetAll()));
+
+        // Get one
+        listEndpoint.MapGet("/{id}", async (int id, ICardListModel model) =>
+            await model.GetById(id) is { } l ? Results.Ok(l) : Results.NotFound());
+
+        // Update
+        listEndpoint.MapPut("/{id}", async (int id, CardListInformation input, ICardListModel model) =>
+            await model.Update(id, input) is { } l ? Results.Ok(l) : Results.NotFound());
+
+        // Delete
+        listEndpoint.MapDelete("/{id}", async (int id, ICardListModel model) =>
+            await model.Delete(id) ? Results.NoContent() : Results.NotFound());
+    }
+
+    public async Task<IEnumerable<CardList>> GetAll()
+    {
+        await using var connection = await dataSource.OpenConnectionAsync();
+        var sql = """SELECT * FROM "CardList";""";
+        var cardListIds = await connection.QueryAsync<CardList>(sql);
+        
+        var result = new List<CardList>();
+        foreach (var cardListId in cardListIds)
+        {
+            result.Add(await GetById(cardListId.Id) ?? cardListId);
+        }
+        return result;
+    }
+
+    public async Task<CardList?> GetById(int id)
+    {
+        // Check if it exists
+        await using var connection = await dataSource.OpenConnectionAsync();
+        var listSql = """SELECT * FROM "CardList" WHERE "Id" = @Id;""";
+        var cardListId = await connection.QueryFirstOrDefaultAsync<CardList>(listSql, new { Id = id });
+        if (cardListId == null) return null;
+
+        // Get all associated cards
+        var cardsSql = """
+            SELECT c."Id", c."Value" 
+            FROM "Card" c
+            JOIN "CardListCard" clc ON c."Id" = clc."CardId"
+            WHERE clc."CardListId" = @Id;
+            """;
+        var cards = await connection.QueryAsync<Card>(cardsSql, new { Id = id });
+
+        // Get all child CardLists
+        var subListsSql = """
+            SELECT sl."Id"
+            FROM "CardList" sl
+            JOIN "CardListSubList" clsl ON sl."Id" = clsl."SubCardListId"
+            WHERE clsl."CardListId" = @Id;
+            """;
+        var subLists = await connection.QueryAsync<CardList>(subListsSql, new { Id = id });
+        
+        return cardListId with { Cards = cards, SubLists = subLists };
+    }
+
+    public async Task<CardList> CreateEmpty()
+    {
+        await using var connection = await dataSource.OpenConnectionAsync();
+        var sql = """INSERT INTO "CardList" DEFAULT VALUES RETURNING "Id";""";
+        return await connection.QuerySingleAsync<CardList>(sql);
+    }
+
+    public async Task<CardList> Create(CardListInformation input)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync();
+        var newList = await CreateEmpty();
+
+        if (input.CardIds != null)
+        {
+            foreach (var cardId in input.CardIds)
+            {
+                await connection.ExecuteAsync(
+                    """INSERT INTO "CardListCard" ("CardListId", "CardId") VALUES (@ListId, @CardId)""",
+                    new { ListId = newList.Id, CardId = cardId });
+            }
+        }
+
+        if (input.SubListIds != null)
+        {
+            foreach (var subListId in input.SubListIds)
+            {
+                await connection.ExecuteAsync(
+                    """INSERT INTO "CardListSubList" ("CardListId", "SubCardListId") VALUES (@ListId, @SubListId)""",
+                    new { ListId = newList.Id, SubListId = subListId });
+            }
+        }
+
+        return (await GetById(newList.Id))!;
+    }
+
+    public async Task<CardList?> Update(int id, CardListInformation input)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync();
+        
+        // Verify list exists
+        var exists = await connection.ExecuteScalarAsync<bool>("""SELECT EXISTS(SELECT 1 FROM "CardList" WHERE "Id" = @Id)""", new { Id = id });
+        if (!exists) return null;
+
+        // Sync Cards - Maybe think through a better way to do this that isn't "wipe it, then start over"
+        await connection.ExecuteAsync("""DELETE FROM "CardListCard" WHERE "CardListId" = @Id""", new { Id = id });
+        if (input.CardIds != null)
+        {
+            foreach (var cardId in input.CardIds)
+            {
+                await connection.ExecuteAsync(
+                    """INSERT INTO "CardListCard" ("CardListId", "CardId") VALUES (@Id, @CardId)""",
+                    new { Id = id, CardId = cardId });
+            }
+        }
+
+        // Sync SubLists - Maybe think through a better way to do this that isn't "wipe it, then start over"
+        await connection.ExecuteAsync("""DELETE FROM "CardListSubList" WHERE "CardListId" = @Id""", new { Id = id });
+        if (input.SubListIds != null)
+        {
+            foreach (var subListId in input.SubListIds)
+            {
+                await connection.ExecuteAsync(
+                    """INSERT INTO "CardListSubList" ("CardListId", "SubCardListId") VALUES (@Id, @SubListId)""",
+                    new { Id = id, SubListId = subListId });
+            }
+        }
+
+        return await GetById(id);
+    }
+
+    public async Task<bool> Delete(int id)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync();
+        var sql = """DELETE FROM "CardList" WHERE "Id" = @Id;""";
+        var rowsAffected = await connection.ExecuteAsync(sql, new { Id = id });
+        return rowsAffected > 0;
+    }
+}

SDG-Backend-Barracuda/Models/CardModel.cs

@@ -0,0 +1,73 @@
+using Dapper;
+using Npgsql;
+
+namespace SDG_Backend_Barracuda.Models;
+
+public record Card(int Id, string Value);
+public record CardInformation(string Value);
+
+public interface ICardModel : IDatabaseModel<Card, CardInformation>
+{
+}
+
+public class CardModel(NpgsqlDataSource dataSource) : ICardModel, IEndpointRouteHandler
+{
+    public static void MapEndpoints(IEndpointRouteBuilder router)
+    {
+        var cardEndpoint = router.MapGroup("/card");
+
+        cardEndpoint.MapPost("/", async (CardInformation input, ICardModel model) =>
+        {
+            var newCard = await model.Create(input);
+            return Results.Created($"/card/{newCard.Id}", newCard);
+        });
+
+        cardEndpoint.MapGet("/", async (ICardModel model) =>
+            Results.Ok(await model.GetAll()));
+
+        cardEndpoint.MapGet("/{id}", async (int id, ICardModel model) =>
+            await model.GetById(id) is { } c ? Results.Ok(c) : Results.NotFound());
+
+        cardEndpoint.MapPut("/{id}", async (int id, CardInformation input, ICardModel model) =>
+            await model.Update(id, input) is { } c ? Results.Ok(c) : Results.NotFound());
+
+        cardEndpoint.MapDelete("/{id}", async (int id, ICardModel model) =>
+            await model.Delete(id) ? Results.NoContent() : Results.NotFound());
+    }
+    
+    public async Task<IEnumerable<Card>> GetAll()
+    {
+        await using var connection = await dataSource.OpenConnectionAsync();
+        var sql = """SELECT "Id", "Value" FROM "Card";""";
+        return await connection.QueryAsync<Card>(sql);
+    }
+
+    public async Task<Card?> GetById(int id)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync();
+        var sql = """SELECT "Id", "Value" FROM "Card" WHERE "Id" = @Id;""";
+        return await connection.QueryFirstOrDefaultAsync<Card>(sql, new { Id = id });
+    }
+
+    public async Task<Card> Create(CardInformation input)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync();
+        var sql = """INSERT INTO "Card" ("Value") VALUES (@Value) RETURNING "Id", "Value";""";
+        return await connection.QuerySingleAsync<Card>(sql, input);
+    }
+
+    public async Task<Card?> Update(int id, CardInformation input)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync();
+        var sql = """UPDATE "Card" SET "Value" = @Value WHERE "Id" = @Id RETURNING "Id", "Value";""";
+        return await connection.QueryFirstOrDefaultAsync<Card>(sql, new { Id = id, input.Value });
+    }
+
+    public async Task<bool> Delete(int id)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync();
+        var sql = """DELETE FROM "Card" WHERE "Id" = @Id;""";
+        var rowsAffected = await connection.ExecuteAsync(sql, new { Id = id });
+        return rowsAffected > 0;
+    }
+}

SDG-Backend-Barracuda/Models/DeckModel.cs

@@ -0,0 +1,148 @@
+using Dapper;
+using Npgsql;
+
+namespace SDG_Backend_Barracuda.Models;
+
+public record Deck
+{
+    public int Id { get; init; }
+    public string Name { get; init; } = string.Empty;
+    public int CardListId { get; init; }
+    public IEnumerable<Game>? GameList { get; init; }
+
+    public Deck() { }
+
+    public Deck(int id, string name, int cardListId, IEnumerable<Game>? gameList = null)
+    {
+        Id = id;
+        Name = name;
+        CardListId = cardListId;
+        GameList = gameList;
+    }
+}
+
+public record DeckInformation(string Name, int CardListId, IEnumerable<int>? GameIds = null);
+
+public interface IDeckModel : IDatabaseModel<Deck, DeckInformation>
+{
+}
+
+public class DeckModel(NpgsqlDataSource dataSource) : IDeckModel, IEndpointRouteHandler
+{
+    public static void MapEndpoints(IEndpointRouteBuilder router)
+    {
+        var deckEndpoint = router.MapGroup("/deck");
+
+        // Create
+        deckEndpoint.MapPost("/", async (DeckInformation input, IDeckModel model) =>
+        {
+            var newDeck = await model.Create(input);
+            return Results.Created($"/deck/{newDeck.Id}", newDeck);
+        });
+
+        // Get all
+        deckEndpoint.MapGet("/", async (IDeckModel model) =>
+            Results.Ok(await model.GetAll()));
+
+        // Get one
+        deckEndpoint.MapGet("/{id}", async (int id, IDeckModel model) =>
+            await model.GetById(id) is { } d ? Results.Ok(d) : Results.NotFound());
+
+        // Update
+        deckEndpoint.MapPut("/{id}", async (int id, DeckInformation input, IDeckModel model) =>
+            await model.Update(id, input) is { } d ? Results.Ok(d) : Results.NotFound());
+
+        // Delete
+        deckEndpoint.MapDelete("/{id}", async (int id, IDeckModel model) =>
+            await model.Delete(id) ? Results.NoContent() : Results.NotFound());
+    }
+
+    public async Task<IEnumerable<Deck>> GetAll()
+    {
+        await using var connection = await dataSource.OpenConnectionAsync();
+        var sql = """SELECT * FROM "Deck";""";
+        var decks = await connection.QueryAsync<Deck>(sql);
+
+        var result = new List<Deck>();
+        foreach (var deck in decks)
+        {
+            result.Add(await GetById(deck.Id) ?? deck);
+        }
+        return result;
+    }
+
+    public async Task<Deck?> GetById(int id)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync();
+        var deckSql = """SELECT * FROM "Deck" WHERE "Id" = @Id;""";
+        var deck = await connection.QueryFirstOrDefaultAsync<Deck>(deckSql, new { Id = id });
+        if (deck == null) return null;
+
+        var gamesSql = """
+            SELECT g.* 
+            FROM "Game" g
+            JOIN "DeckGame" dg ON g."Id" = dg."GameId"
+            WHERE dg."DeckId" = @Id;
+            """;
+        var games = await connection.QueryAsync<Game>(gamesSql, new { Id = id });
+
+        return deck with { GameList = games };
+    }
+
+    public async Task<Deck> Create(DeckInformation input)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync();
+        var sql = """
+            INSERT INTO "Deck" ("Name", "CardListId") 
+            VALUES (@Name, @CardListId) 
+            RETURNING "Id", "Name", "CardListId";
+            """;
+        var newDeck = await connection.QuerySingleAsync<Deck>(sql, new { input.Name, input.CardListId });
+
+        if (input.GameIds != null)
+        {
+            foreach (var gameId in input.GameIds)
+            {
+                await connection.ExecuteAsync(
+                    """INSERT INTO "DeckGame" ("DeckId", "GameId") VALUES (@DeckId, @GameId)""",
+                    new { DeckId = newDeck.Id, GameId = gameId });
+            }
+        }
+
+        return (await GetById(newDeck.Id))!;
+    }
+
+    public async Task<Deck?> Update(int id, DeckInformation input)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync();
+
+        var sql = """
+            UPDATE "Deck" 
+            SET "Name" = @Name, "CardListId" = @CardListId 
+            WHERE "Id" = @Id 
+            RETURNING "Id", "Name", "CardListId";
+            """;
+        var updatedDeck = await connection.QueryFirstOrDefaultAsync<Deck>(sql, new { Id = id, input.Name, input.CardListId });
+        if (updatedDeck == null) return null;
+
+        await connection.ExecuteAsync("""DELETE FROM "DeckGame" WHERE "DeckId" = @Id""", new { Id = id });
+        if (input.GameIds != null)
+        {
+            foreach (var gameId in input.GameIds)
+            {
+                await connection.ExecuteAsync(
+                    """INSERT INTO "DeckGame" ("DeckId", "GameId") VALUES (@Id, @GameId)""",
+                    new { Id = id, GameId = gameId });
+            }
+        }
+
+        return await GetById(id);
+    }
+
+    public async Task<bool> Delete(int id)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync();
+        var rowsAffected = await connection.ExecuteAsync("""DELETE FROM "Deck" WHERE "Id" = @Id""", new { Id = id });
+        return rowsAffected > 0;
+    }
+}

SDG-Backend-Barracuda/Models/GameModel.cs

@@ -0,0 +1,73 @@
+using Dapper;
+using Npgsql;
+
+namespace SDG_Backend_Barracuda.Models;
+
+public record Game(int Id, string Name, string URL);
+public record GameInformation(string Name, string URL);
+
+public interface IGameModel : IDatabaseModel<Game, GameInformation>
+{
+}
+
+public class GameModel(NpgsqlDataSource dataSource) : IGameModel, IEndpointRouteHandler
+{
+    public static void MapEndpoints(IEndpointRouteBuilder router)
+    {
+        var gameEndpoint = router.MapGroup("/game");
+
+        gameEndpoint.MapPost("/", async (GameInformation input, IGameModel model) =>
+        {
+            var newGame = await model.Create(input);
+            return Results.Created($"/game/{newGame.Id}", newGame);
+        });
+
+        gameEndpoint.MapGet("/", async (IGameModel model) =>
+            Results.Ok(await model.GetAll()));
+
+        gameEndpoint.MapGet("/{id}", async (int id, IGameModel model) =>
+            await model.GetById(id) is { } g ? Results.Ok(g) : Results.NotFound());
+
+        gameEndpoint.MapPut("/{id}", async (int id, GameInformation input, IGameModel model) =>
+            await model.Update(id, input) is { } g ? Results.Ok(g) : Results.NotFound());
+
+        gameEndpoint.MapDelete("/{id}", async (int id, IGameModel model) =>
+            await model.Delete(id) ? Results.NoContent() : Results.NotFound());
+    }
+
+    public async Task<IEnumerable<Game>> GetAll()
+    {
+        await using var connection = await dataSource.OpenConnectionAsync();
+        var sql = """SELECT * FROM "Game";""";
+        return await connection.QueryAsync<Game>(sql);
+    }
+
+    public async Task<Game?> GetById(int id)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync();
+        var sql = """SELECT * FROM "Game" WHERE "Id" = @Id;""";
+        return await connection.QueryFirstOrDefaultAsync<Game>(sql, new { Id = id });
+    }
+
+    public async Task<Game> Create(GameInformation input)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync();
+        var sql = """INSERT INTO "Game" ("Name", "URL") VALUES (@Name, @URL) RETURNING "Id", "Name", "URL";""";
+        return await connection.QuerySingleAsync<Game>(sql, input);
+    }
+
+    public async Task<Game?> Update(int id, GameInformation input)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync();
+        var sql = """UPDATE "Game" SET "Name" = @Name, "URL" = @URL WHERE "Id" = @Id RETURNING "Id", "Name", "URL";""";
+        return await connection.QueryFirstOrDefaultAsync<Game>(sql, new { Id = id, input.Name, input.URL });
+    }
+
+    public async Task<bool> Delete(int id)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync();
+        var sql = """DELETE FROM "Game" WHERE "Id" = @Id;""";
+        var rowsAffected = await connection.ExecuteAsync(sql, new { Id = id });
+        return rowsAffected > 0;
+    }
+}

SDG-Backend-Barracuda/Models/IDatabaseModel.cs

@@ -0,0 +1,10 @@
+namespace SDG_Backend_Barracuda.Models;
+
+public interface IDatabaseModel<T, in TInput>
+{
+    Task<IEnumerable<T>> GetAll();
+    Task<T?> GetById(int id);
+    Task<T> Create(TInput input);
+    Task<T?> Update(int id, TInput input);
+    Task<bool> Delete(int id);
+}

SDG-Backend-Barracuda/Models/IEndpointRouteHandler.cs

@@ -0,0 +1,6 @@
+namespace SDG_Backend_Barracuda.Models;
+
+public interface IEndpointRouteHandler
+{
+    static abstract void MapEndpoints(IEndpointRouteBuilder routes);
+}

SDG-Backend-Barracuda/Program.cs

@@ -1,11 +1,65 @@
+using Dapper;
+using Npgsql;
+using SDG_Backend_Barracuda.Models;
+
 var builder = WebApplication.CreateBuilder(args);
 
 // Add services to the container.
 // Learn more about configuring OpenAPI at https://aka.ms/aspnet/openapi
 builder.Services.AddOpenApi();
 
+// Register NpgsqlDataSource
+var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
+builder.Services.AddNpgsqlDataSource(connectionString!);
+
+// Register Data Tables
+builder.Services.AddScoped<ICardModel, CardModel>();
+builder.Services.AddScoped<ICardListModel, CardListModel>();
+builder.Services.AddScoped<IGameModel, GameModel>();
+builder.Services.AddScoped<IDeckModel, DeckModel>();
+
 var app = builder.Build();
 
+// Ensure the table exists
+using (var scope = app.Services.CreateScope())
+{
+    var dataSource = scope.ServiceProvider.GetRequiredService<NpgsqlDataSource>();
+    await using var connection = await dataSource.OpenConnectionAsync();
+    await connection.ExecuteAsync(@"
+        CREATE TABLE IF NOT EXISTS ""Card"" (
+            ""Id"" SERIAL PRIMARY KEY,
+            ""Value"" TEXT NOT NULL
+        );
+        CREATE TABLE IF NOT EXISTS ""CardList"" (
+            ""Id"" SERIAL PRIMARY KEY
+        );
+        CREATE TABLE IF NOT EXISTS ""CardListCard"" (
+            ""CardListId"" INTEGER NOT NULL REFERENCES ""CardList""(""Id"") ON DELETE CASCADE,
+            ""CardId"" INTEGER NOT NULL REFERENCES ""Card""(""Id"") ON DELETE CASCADE,
+            PRIMARY KEY (""CardListId"", ""CardId"")
+        );
+        CREATE TABLE IF NOT EXISTS ""CardListSubList"" (
+            ""CardListId"" INTEGER NOT NULL REFERENCES ""CardList""(""Id"") ON DELETE CASCADE,
+            ""SubCardListId"" INTEGER NOT NULL REFERENCES ""CardList""(""Id"") ON DELETE CASCADE,
+            PRIMARY KEY (""CardListId"", ""SubCardListId"")
+        );
+        CREATE TABLE IF NOT EXISTS ""Game"" (
+            ""Id"" SERIAL PRIMARY KEY,
+            ""Name"" VARCHAR(64) NOT NULL,
+            ""URL"" TEXT NOT NULL
+        );
+        CREATE TABLE IF NOT EXISTS ""Deck"" (
+            ""Id"" SERIAL PRIMARY KEY,
+            ""Name"" TEXT NOT NULL,
+            ""CardListId"" INTEGER NOT NULL REFERENCES ""CardList""(""Id"") ON DELETE CASCADE
+        );
+        CREATE TABLE IF NOT EXISTS ""DeckGame"" (
+            ""DeckId"" INTEGER NOT NULL REFERENCES ""Deck""(""Id"") ON DELETE CASCADE,
+            ""GameId"" INTEGER NOT NULL REFERENCES ""Game""(""Id"") ON DELETE CASCADE,
+            PRIMARY KEY (""DeckId"", ""GameId"")
+        );");
+}
+
 // Configure the HTTP request pipeline.
 if (app.Environment.IsDevelopment())
 {
@@ -14,28 +68,9 @@ if (app.Environment.IsDevelopment())
 
 app.UseHttpsRedirection();
 
-var summaries = new[]
+CardModel.MapEndpoints(app);
-{
+CardListModel.MapEndpoints(app);
-    "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
+GameModel.MapEndpoints(app);
-};
+DeckModel.MapEndpoints(app);
 
-app.MapGet("/weatherforecast", () =>
+app.Run();
-    {
-        var forecast = Enumerable.Range(1, 5).Select(index =>
-                new WeatherForecast
-                (
-                    DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
-                    Random.Shared.Next(-20, 55),
-                    summaries[Random.Shared.Next(summaries.Length)]
-                ))
-            .ToArray();
-        return forecast;
-    })
-    .WithName("GetWeatherForecast");
-
-app.Run();
-
-record WeatherForecast(DateOnly Date, int TemperatureC, string? Summary)
-{
-    public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
-}

SDG-Backend-Barracuda/SDG-Backend-Barracuda.csproj

@@ -1,14 +1,18 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
+<Project Sdk="Microsoft.NET.Sdk.Web">
 
     <PropertyGroup>
         <TargetFramework>net10.0</TargetFramework>
         <Nullable>enable</Nullable>
         <ImplicitUsings>enable</ImplicitUsings>
         <RootNamespace>SDG_Backend_Barracuda</RootNamespace>
-    </PropertyGroup>
+      <UserSecretsId>7ceb2efb-dc1a-496c-aa6c-18efbd2a3411</UserSecretsId>
+  </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="10.0.1"/>
+        <PackageReference Include="Dapper" Version="2.1.66" />
+        <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="10.0.1" />
+        <PackageReference Include="Npgsql" Version="10.0.1" />
+        <PackageReference Include="Npgsql.DependencyInjection" Version="10.0.1" />
     </ItemGroup>
 
 </Project>

SDG-Backend-Barracuda/SDG-Backend-Barracuda.http

@@ -1,6 +1,62 @@
 @SDG_Backend_Barracuda_HostAddress = http://localhost:5164
 
-GET {{SDG_Backend_Barracuda_HostAddress}}/weatherforecast/
+### Get all cards
+GET {{SDG_Backend_Barracuda_HostAddress}}/card/
 Accept: application/json
 
-###
+### Create a new card
+POST {{SDG_Backend_Barracuda_HostAddress}}/card
+Content-Type: application/json
+
+{
+  "value": "Sample Card Value"
+}
+
+### Get a card by ID
+GET {{SDG_Backend_Barracuda_HostAddress}}/card/1
+Accept: application/json
+
+### Update a card
+PUT {{SDG_Backend_Barracuda_HostAddress}}/card/1
+Content-Type: application/json
+
+{
+  "value": "Updated Card Value"
+}
+
+### Delete a card
+DELETE {{SDG_Backend_Barracuda_HostAddress}}/card/1
+
+
+### Create a new empty card list
+POST {{SDG_Backend_Barracuda_HostAddress}}/cardlist/
+Content-Type: application/json
+
+### Create a new card list with cards and sub-lists
+POST {{SDG_Backend_Barracuda_HostAddress}}/cardlist
+Content-Type: application/json
+
+{
+  "cardIds": [3, 2],
+  "subListIds": [4]
+}
+
+### Get all card lists
+GET {{SDG_Backend_Barracuda_HostAddress}}/cardlist
+Accept: application/json
+
+### Get a card list by ID (includes cards and sub-lists)
+GET {{SDG_Backend_Barracuda_HostAddress}}/cardlist/1
+Accept: application/json
+
+### Update a card list
+PUT {{SDG_Backend_Barracuda_HostAddress}}/cardlist/1
+Content-Type: application/json
+
+{
+  "cardIds": [4],
+  "subListIds": []
+}
+
+### Delete a card list
+DELETE {{SDG_Backend_Barracuda_HostAddress}}/cardlist/1

SDG-Backend-Barracuda/appsettings.json

@@ -1,4 +1,7 @@
 {
+  "ConnectionStrings": {
+    "DefaultConnection": ""
+  },
   "Logging": {
     "LogLevel": {
       "Default": "Information",