From 086b68c539c37eb21230e5e772e56170b089493d Mon Sep 17 00:00:00 2001
From: Egamorf <maxime.adler76@gmail.com>
Date: Wed, 9 Apr 2025 23:10:03 +0200
Subject: [PATCH] Add first miggration

---
 .gitea/workflows/build-pr.yaml                |   4 +-
 .gitignore                                    |   4 +-
 README.md                                     |  11 +-
 src/GameIdeas/GameIdeas.Shared/Model/Game.cs  |   2 +-
 .../Context/GameIdeasContext.cs               |  14 +-
 .../GameIdeas.WebAPI/GameIdeas.WebAPI.csproj  |   4 +
 .../20250409210640_InitialCreate.Designer.cs  | 422 ++++++++++++++++++
 .../20250409210640_InitialCreate.cs           | 325 ++++++++++++++
 .../GameIdeasContextModelSnapshot.cs          | 419 +++++++++++++++++
 .../Server/GameIdeas.WebAPI/Program.cs        |  57 ++-
 10 files changed, 1234 insertions(+), 28 deletions(-)
 create mode 100644 src/GameIdeas/Server/GameIdeas.WebAPI/Migrations/20250409210640_InitialCreate.Designer.cs
 create mode 100644 src/GameIdeas/Server/GameIdeas.WebAPI/Migrations/20250409210640_InitialCreate.cs
 create mode 100644 src/GameIdeas/Server/GameIdeas.WebAPI/Migrations/GameIdeasContextModelSnapshot.cs

diff --git a/.gitea/workflows/build-pr.yaml b/.gitea/workflows/build-pr.yaml
index 8699650..abfb2f3 100644
--- a/.gitea/workflows/build-pr.yaml
+++ b/.gitea/workflows/build-pr.yaml
@@ -1,7 +1,7 @@
 name: Game Ideas build for PR
 on:
     pull_request:
-        types: [ opened, edited, closed, reopened, synchronize ]
+        types: [ opened, edited, reopened, synchronize ]
         branches: 
           - 'feature/**'
           - main
@@ -22,4 +22,4 @@ jobs:
             run: dotnet build ./src/GameIdeas/Client/GameIdeas.BlazorApp/GameIdeas.BlazorApp.csproj
                       
           - name: Build API App
-            run: dotnet build ./src/GameIdeas/Server/GameIdeas.WebAPI/GameIdeas.WebAPI.csproj
\ No newline at end of file
+            run: dotnet build ./src/GameIdeas/Server/GameIdeas.WebAPI/GameIdeas.WebAPI.csproj 
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 2e36d2a..54842ee 100644
--- a/.gitignore
+++ b/.gitignore
@@ -436,4 +436,6 @@ FodyWeavers.xsd
 .history
 .ionide
 
-# End of https://www.toptal.com/developers/gitignore/api/visualstudiocode
\ No newline at end of file
+# End of https://www.toptal.com/developers/gitignore/api/visualstudiocode
+
+.env
\ No newline at end of file
diff --git a/README.md b/README.md
index cee14ad..9170bd2 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@ Store your favorite games, intelligent game add, store game files and data, mana
 
 ## Services
 
-| project       | Port      | Technos         | Base de données |
+| Project       | Port      | Technos         | Base de données |
 | ------------- | --------- | --------------- | --------------- |
 | WebApp        | 5172,7060 | C# (Blazor)     |                 |
 | API           | 8000      | C# (ASP.NET)    | PostgreSQL      |
@@ -29,6 +29,15 @@ Store your favorite games, intelligent game add, store game files and data, mana
     └── GameIdeas.Shared
 ```
 
+## Environment variables
+
+| Name | Value type |
+| --- | --- |
+| DB_HOST | Address IP or hostname of the database |
+| DB_USERNAME | Username for the database |
+| DB_PASSWORD | Plain password for the database |
+| DB_DATABASE | Name of the database |
+
 <!-- ## Installation
 
 ### Docker Compose
diff --git a/src/GameIdeas/GameIdeas.Shared/Model/Game.cs b/src/GameIdeas/GameIdeas.Shared/Model/Game.cs
index 038b580..a3c1e9e 100644
--- a/src/GameIdeas/GameIdeas.Shared/Model/Game.cs
+++ b/src/GameIdeas/GameIdeas.Shared/Model/Game.cs
@@ -11,7 +11,7 @@ public partial class Game
         GameDevelopers = new HashSet<GameDeveloper>();
     }
 
-    public Guid Id { get; set; }
+    public int Id { get; set; }
     public string Title { get; set; } = null!;
     public DateTime? ReleaseDate { get; set; }
     public DateTime CreationDate { get; set; }
diff --git a/src/GameIdeas/Server/GameIdeas.WebAPI/Context/GameIdeasContext.cs b/src/GameIdeas/Server/GameIdeas.WebAPI/Context/GameIdeasContext.cs
index ad2976f..87f4024 100644
--- a/src/GameIdeas/Server/GameIdeas.WebAPI/Context/GameIdeasContext.cs
+++ b/src/GameIdeas/Server/GameIdeas.WebAPI/Context/GameIdeasContext.cs
@@ -5,13 +5,9 @@ namespace GameIdeas.WebAPI.Context;
 
 public class GameIdeasContext : DbContext
 {
-    private ILoggerFactory LoggerFactory;
-
-    public GameIdeasContext(DbContextOptions<GameIdeasContext> option, ILoggerFactory loggerFactory) 
+    public GameIdeasContext(DbContextOptions<GameIdeasContext> option) 
         : base(option)
-    {
-        LoggerFactory = loggerFactory;
-    }
+    { }
 
     public virtual DbSet<User> Users { get; set; } = null!;
     public virtual DbSet<Developer> Developers { get; set; } = null!;
@@ -26,12 +22,6 @@ public class GameIdeasContext : DbContext
     public virtual DbSet<GamePublisher> GamePublishers { get; set; } = null!;
     public virtual DbSet<GameTag> GameTags { get; set; } = null!;
 
-    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
-    {
-        optionsBuilder.UseLoggerFactory(LoggerFactory);
-        base.OnConfiguring(optionsBuilder);
-    }
-
     protected override void OnModelCreating(ModelBuilder modelBuilder)
     {
         modelBuilder.Entity<User>(entity => {
diff --git a/src/GameIdeas/Server/GameIdeas.WebAPI/GameIdeas.WebAPI.csproj b/src/GameIdeas/Server/GameIdeas.WebAPI/GameIdeas.WebAPI.csproj
index 1988e33..cb257d4 100644
--- a/src/GameIdeas/Server/GameIdeas.WebAPI/GameIdeas.WebAPI.csproj
+++ b/src/GameIdeas/Server/GameIdeas.WebAPI/GameIdeas.WebAPI.csproj
@@ -13,6 +13,10 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="9.0.0" />
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.4" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="9.0.4">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
     <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="9.0.4" />
   </ItemGroup>
 
diff --git a/src/GameIdeas/Server/GameIdeas.WebAPI/Migrations/20250409210640_InitialCreate.Designer.cs b/src/GameIdeas/Server/GameIdeas.WebAPI/Migrations/20250409210640_InitialCreate.Designer.cs
new file mode 100644
index 0000000..8a8bf38
--- /dev/null
+++ b/src/GameIdeas/Server/GameIdeas.WebAPI/Migrations/20250409210640_InitialCreate.Designer.cs
@@ -0,0 +1,422 @@
+// <auto-generated />
+using System;
+using GameIdeas.WebAPI.Context;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace GameIdeas.WebAPI.Migrations
+{
+    [DbContext(typeof(GameIdeasContext))]
+    [Migration("20250409210640_InitialCreate")]
+    partial class InitialCreate
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.4")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Developer", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Developer", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Game", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+                    NpgsqlPropertyBuilderExtensions.HasIdentityOptions(b.Property<int>("Id"), 100000L, null, null, null, null, null);
+
+                    b.Property<DateTime>("CreationDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<int>("CreationUserId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<int>("Interest")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("ModificationDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("ModificationUserId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<double?>("StorageSpace")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreationUserId");
+
+                    b.HasIndex("ModificationUserId");
+
+                    b.ToTable("Game", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.GameDeveloper", b =>
+                {
+                    b.Property<int>("GameId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("DeveloperId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("GameId", "DeveloperId");
+
+                    b.HasIndex("DeveloperId");
+
+                    b.ToTable("GameDeveloper", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.GamePlatform", b =>
+                {
+                    b.Property<int>("GameId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("PlatformId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Url")
+                        .HasColumnType("text");
+
+                    b.HasKey("GameId", "PlatformId");
+
+                    b.HasIndex("PlatformId");
+
+                    b.ToTable("GamePlatform", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.GameProperty", b =>
+                {
+                    b.Property<int>("GameId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("PropertyId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("GameId", "PropertyId");
+
+                    b.HasIndex("PropertyId");
+
+                    b.ToTable("GameProperty", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.GamePublisher", b =>
+                {
+                    b.Property<int>("GameId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("PublisherId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("GameId", "PublisherId");
+
+                    b.HasIndex("PublisherId");
+
+                    b.ToTable("GamePublisher", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.GameTag", b =>
+                {
+                    b.Property<int>("GameId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TagId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("GameId", "TagId");
+
+                    b.HasIndex("TagId");
+
+                    b.ToTable("GameTag", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Platform", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Libelle")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Platform", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Property", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Property", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Publisher", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Publisher", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Tag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Tag", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+                    NpgsqlPropertyBuilderExtensions.HasIdentityOptions(b.Property<int>("Id"), 100000L, null, null, null, null, null);
+
+                    b.Property<string>("Password")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Role")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("User", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Game", b =>
+                {
+                    b.HasOne("GameIdeas.Shared.Model.User", "CreationUser")
+                        .WithMany("CreationGames")
+                        .HasForeignKey("CreationUserId")
+                        .IsRequired();
+
+                    b.HasOne("GameIdeas.Shared.Model.User", "ModificationUser")
+                        .WithMany("ModificationGames")
+                        .HasForeignKey("ModificationUserId");
+
+                    b.Navigation("CreationUser");
+
+                    b.Navigation("ModificationUser");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.GameDeveloper", b =>
+                {
+                    b.HasOne("GameIdeas.Shared.Model.Developer", "Developer")
+                        .WithMany("GameDevelopers")
+                        .HasForeignKey("DeveloperId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GameIdeas.Shared.Model.Game", "Game")
+                        .WithMany("GameDevelopers")
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Developer");
+
+                    b.Navigation("Game");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.GamePlatform", b =>
+                {
+                    b.HasOne("GameIdeas.Shared.Model.Game", "Game")
+                        .WithMany("GamePlatforms")
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GameIdeas.Shared.Model.Platform", "Platform")
+                        .WithMany("GamePlatforms")
+                        .HasForeignKey("PlatformId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+
+                    b.Navigation("Platform");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.GameProperty", b =>
+                {
+                    b.HasOne("GameIdeas.Shared.Model.Game", "Game")
+                        .WithMany("GameProperties")
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GameIdeas.Shared.Model.Property", "Property")
+                        .WithMany("GameProperties")
+                        .HasForeignKey("PropertyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+
+                    b.Navigation("Property");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.GamePublisher", b =>
+                {
+                    b.HasOne("GameIdeas.Shared.Model.Game", "Game")
+                        .WithMany("GamePublishers")
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GameIdeas.Shared.Model.Publisher", "Publisher")
+                        .WithMany("GamePublishers")
+                        .HasForeignKey("PublisherId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+
+                    b.Navigation("Publisher");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.GameTag", b =>
+                {
+                    b.HasOne("GameIdeas.Shared.Model.Game", "Game")
+                        .WithMany("GameTags")
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GameIdeas.Shared.Model.Tag", "Tag")
+                        .WithMany("GameTags")
+                        .HasForeignKey("TagId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+
+                    b.Navigation("Tag");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Developer", b =>
+                {
+                    b.Navigation("GameDevelopers");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Game", b =>
+                {
+                    b.Navigation("GameDevelopers");
+
+                    b.Navigation("GamePlatforms");
+
+                    b.Navigation("GameProperties");
+
+                    b.Navigation("GamePublishers");
+
+                    b.Navigation("GameTags");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Platform", b =>
+                {
+                    b.Navigation("GamePlatforms");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Property", b =>
+                {
+                    b.Navigation("GameProperties");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Publisher", b =>
+                {
+                    b.Navigation("GamePublishers");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Tag", b =>
+                {
+                    b.Navigation("GameTags");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.User", b =>
+                {
+                    b.Navigation("CreationGames");
+
+                    b.Navigation("ModificationGames");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/GameIdeas/Server/GameIdeas.WebAPI/Migrations/20250409210640_InitialCreate.cs b/src/GameIdeas/Server/GameIdeas.WebAPI/Migrations/20250409210640_InitialCreate.cs
new file mode 100644
index 0000000..338fcf5
--- /dev/null
+++ b/src/GameIdeas/Server/GameIdeas.WebAPI/Migrations/20250409210640_InitialCreate.cs
@@ -0,0 +1,325 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace GameIdeas.WebAPI.Migrations
+{
+    /// <inheritdoc />
+    public partial class InitialCreate : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Developer",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    Name = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Developer", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Platform",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    Libelle = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Platform", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Property",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    Label = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Property", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Publisher",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    Name = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Publisher", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Tag",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    Label = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Tag", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "User",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:IdentitySequenceOptions", "'100000', '1', '', '', 'False', '1'")
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    Username = table.Column<string>(type: "text", nullable: false),
+                    Password = table.Column<string>(type: "text", nullable: false),
+                    Role = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_User", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Game",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:IdentitySequenceOptions", "'100000', '1', '', '', 'False', '1'")
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    Title = table.Column<string>(type: "text", nullable: false),
+                    ReleaseDate = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    CreationDate = table.Column<DateTime>(type: "timestamp with time zone", nullable: false, defaultValueSql: "now()"),
+                    CreationUserId = table.Column<int>(type: "integer", nullable: false),
+                    ModificationDate = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    ModificationUserId = table.Column<int>(type: "integer", nullable: true),
+                    StorageSpace = table.Column<double>(type: "double precision", nullable: true),
+                    Description = table.Column<string>(type: "text", nullable: true),
+                    Interest = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Game", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Game_User_CreationUserId",
+                        column: x => x.CreationUserId,
+                        principalTable: "User",
+                        principalColumn: "Id");
+                    table.ForeignKey(
+                        name: "FK_Game_User_ModificationUserId",
+                        column: x => x.ModificationUserId,
+                        principalTable: "User",
+                        principalColumn: "Id");
+                });
+
+            migrationBuilder.CreateTable(
+                name: "GameDeveloper",
+                columns: table => new
+                {
+                    GameId = table.Column<int>(type: "integer", nullable: false),
+                    DeveloperId = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_GameDeveloper", x => new { x.GameId, x.DeveloperId });
+                    table.ForeignKey(
+                        name: "FK_GameDeveloper_Developer_DeveloperId",
+                        column: x => x.DeveloperId,
+                        principalTable: "Developer",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_GameDeveloper_Game_GameId",
+                        column: x => x.GameId,
+                        principalTable: "Game",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "GamePlatform",
+                columns: table => new
+                {
+                    GameId = table.Column<int>(type: "integer", nullable: false),
+                    PlatformId = table.Column<int>(type: "integer", nullable: false),
+                    Url = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_GamePlatform", x => new { x.GameId, x.PlatformId });
+                    table.ForeignKey(
+                        name: "FK_GamePlatform_Game_GameId",
+                        column: x => x.GameId,
+                        principalTable: "Game",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_GamePlatform_Platform_PlatformId",
+                        column: x => x.PlatformId,
+                        principalTable: "Platform",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "GameProperty",
+                columns: table => new
+                {
+                    GameId = table.Column<int>(type: "integer", nullable: false),
+                    PropertyId = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_GameProperty", x => new { x.GameId, x.PropertyId });
+                    table.ForeignKey(
+                        name: "FK_GameProperty_Game_GameId",
+                        column: x => x.GameId,
+                        principalTable: "Game",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_GameProperty_Property_PropertyId",
+                        column: x => x.PropertyId,
+                        principalTable: "Property",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "GamePublisher",
+                columns: table => new
+                {
+                    GameId = table.Column<int>(type: "integer", nullable: false),
+                    PublisherId = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_GamePublisher", x => new { x.GameId, x.PublisherId });
+                    table.ForeignKey(
+                        name: "FK_GamePublisher_Game_GameId",
+                        column: x => x.GameId,
+                        principalTable: "Game",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_GamePublisher_Publisher_PublisherId",
+                        column: x => x.PublisherId,
+                        principalTable: "Publisher",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "GameTag",
+                columns: table => new
+                {
+                    GameId = table.Column<int>(type: "integer", nullable: false),
+                    TagId = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_GameTag", x => new { x.GameId, x.TagId });
+                    table.ForeignKey(
+                        name: "FK_GameTag_Game_GameId",
+                        column: x => x.GameId,
+                        principalTable: "Game",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_GameTag_Tag_TagId",
+                        column: x => x.TagId,
+                        principalTable: "Tag",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Game_CreationUserId",
+                table: "Game",
+                column: "CreationUserId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Game_ModificationUserId",
+                table: "Game",
+                column: "ModificationUserId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_GameDeveloper_DeveloperId",
+                table: "GameDeveloper",
+                column: "DeveloperId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_GamePlatform_PlatformId",
+                table: "GamePlatform",
+                column: "PlatformId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_GameProperty_PropertyId",
+                table: "GameProperty",
+                column: "PropertyId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_GamePublisher_PublisherId",
+                table: "GamePublisher",
+                column: "PublisherId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_GameTag_TagId",
+                table: "GameTag",
+                column: "TagId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "GameDeveloper");
+
+            migrationBuilder.DropTable(
+                name: "GamePlatform");
+
+            migrationBuilder.DropTable(
+                name: "GameProperty");
+
+            migrationBuilder.DropTable(
+                name: "GamePublisher");
+
+            migrationBuilder.DropTable(
+                name: "GameTag");
+
+            migrationBuilder.DropTable(
+                name: "Developer");
+
+            migrationBuilder.DropTable(
+                name: "Platform");
+
+            migrationBuilder.DropTable(
+                name: "Property");
+
+            migrationBuilder.DropTable(
+                name: "Publisher");
+
+            migrationBuilder.DropTable(
+                name: "Game");
+
+            migrationBuilder.DropTable(
+                name: "Tag");
+
+            migrationBuilder.DropTable(
+                name: "User");
+        }
+    }
+}
diff --git a/src/GameIdeas/Server/GameIdeas.WebAPI/Migrations/GameIdeasContextModelSnapshot.cs b/src/GameIdeas/Server/GameIdeas.WebAPI/Migrations/GameIdeasContextModelSnapshot.cs
new file mode 100644
index 0000000..d142826
--- /dev/null
+++ b/src/GameIdeas/Server/GameIdeas.WebAPI/Migrations/GameIdeasContextModelSnapshot.cs
@@ -0,0 +1,419 @@
+// <auto-generated />
+using System;
+using GameIdeas.WebAPI.Context;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace GameIdeas.WebAPI.Migrations
+{
+    [DbContext(typeof(GameIdeasContext))]
+    partial class GameIdeasContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.4")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Developer", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Developer", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Game", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+                    NpgsqlPropertyBuilderExtensions.HasIdentityOptions(b.Property<int>("Id"), 100000L, null, null, null, null, null);
+
+                    b.Property<DateTime>("CreationDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<int>("CreationUserId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<int>("Interest")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("ModificationDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("ModificationUserId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<double?>("StorageSpace")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreationUserId");
+
+                    b.HasIndex("ModificationUserId");
+
+                    b.ToTable("Game", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.GameDeveloper", b =>
+                {
+                    b.Property<int>("GameId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("DeveloperId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("GameId", "DeveloperId");
+
+                    b.HasIndex("DeveloperId");
+
+                    b.ToTable("GameDeveloper", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.GamePlatform", b =>
+                {
+                    b.Property<int>("GameId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("PlatformId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Url")
+                        .HasColumnType("text");
+
+                    b.HasKey("GameId", "PlatformId");
+
+                    b.HasIndex("PlatformId");
+
+                    b.ToTable("GamePlatform", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.GameProperty", b =>
+                {
+                    b.Property<int>("GameId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("PropertyId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("GameId", "PropertyId");
+
+                    b.HasIndex("PropertyId");
+
+                    b.ToTable("GameProperty", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.GamePublisher", b =>
+                {
+                    b.Property<int>("GameId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("PublisherId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("GameId", "PublisherId");
+
+                    b.HasIndex("PublisherId");
+
+                    b.ToTable("GamePublisher", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.GameTag", b =>
+                {
+                    b.Property<int>("GameId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TagId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("GameId", "TagId");
+
+                    b.HasIndex("TagId");
+
+                    b.ToTable("GameTag", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Platform", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Libelle")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Platform", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Property", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Property", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Publisher", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Publisher", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Tag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Tag", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+                    NpgsqlPropertyBuilderExtensions.HasIdentityOptions(b.Property<int>("Id"), 100000L, null, null, null, null, null);
+
+                    b.Property<string>("Password")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Role")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("User", (string)null);
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Game", b =>
+                {
+                    b.HasOne("GameIdeas.Shared.Model.User", "CreationUser")
+                        .WithMany("CreationGames")
+                        .HasForeignKey("CreationUserId")
+                        .IsRequired();
+
+                    b.HasOne("GameIdeas.Shared.Model.User", "ModificationUser")
+                        .WithMany("ModificationGames")
+                        .HasForeignKey("ModificationUserId");
+
+                    b.Navigation("CreationUser");
+
+                    b.Navigation("ModificationUser");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.GameDeveloper", b =>
+                {
+                    b.HasOne("GameIdeas.Shared.Model.Developer", "Developer")
+                        .WithMany("GameDevelopers")
+                        .HasForeignKey("DeveloperId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GameIdeas.Shared.Model.Game", "Game")
+                        .WithMany("GameDevelopers")
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Developer");
+
+                    b.Navigation("Game");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.GamePlatform", b =>
+                {
+                    b.HasOne("GameIdeas.Shared.Model.Game", "Game")
+                        .WithMany("GamePlatforms")
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GameIdeas.Shared.Model.Platform", "Platform")
+                        .WithMany("GamePlatforms")
+                        .HasForeignKey("PlatformId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+
+                    b.Navigation("Platform");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.GameProperty", b =>
+                {
+                    b.HasOne("GameIdeas.Shared.Model.Game", "Game")
+                        .WithMany("GameProperties")
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GameIdeas.Shared.Model.Property", "Property")
+                        .WithMany("GameProperties")
+                        .HasForeignKey("PropertyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+
+                    b.Navigation("Property");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.GamePublisher", b =>
+                {
+                    b.HasOne("GameIdeas.Shared.Model.Game", "Game")
+                        .WithMany("GamePublishers")
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GameIdeas.Shared.Model.Publisher", "Publisher")
+                        .WithMany("GamePublishers")
+                        .HasForeignKey("PublisherId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+
+                    b.Navigation("Publisher");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.GameTag", b =>
+                {
+                    b.HasOne("GameIdeas.Shared.Model.Game", "Game")
+                        .WithMany("GameTags")
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GameIdeas.Shared.Model.Tag", "Tag")
+                        .WithMany("GameTags")
+                        .HasForeignKey("TagId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+
+                    b.Navigation("Tag");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Developer", b =>
+                {
+                    b.Navigation("GameDevelopers");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Game", b =>
+                {
+                    b.Navigation("GameDevelopers");
+
+                    b.Navigation("GamePlatforms");
+
+                    b.Navigation("GameProperties");
+
+                    b.Navigation("GamePublishers");
+
+                    b.Navigation("GameTags");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Platform", b =>
+                {
+                    b.Navigation("GamePlatforms");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Property", b =>
+                {
+                    b.Navigation("GameProperties");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Publisher", b =>
+                {
+                    b.Navigation("GamePublishers");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.Tag", b =>
+                {
+                    b.Navigation("GameTags");
+                });
+
+            modelBuilder.Entity("GameIdeas.Shared.Model.User", b =>
+                {
+                    b.Navigation("CreationGames");
+
+                    b.Navigation("ModificationGames");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/GameIdeas/Server/GameIdeas.WebAPI/Program.cs b/src/GameIdeas/Server/GameIdeas.WebAPI/Program.cs
index 108fffa..6ce21a4 100644
--- a/src/GameIdeas/Server/GameIdeas.WebAPI/Program.cs
+++ b/src/GameIdeas/Server/GameIdeas.WebAPI/Program.cs
@@ -1,38 +1,45 @@
 using GameIdeas.Resources;
 using GameIdeas.WebAPI.Context;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using System.Data;
+using System.Data.Common;
 
 var builder = WebApplication.CreateBuilder(args);
 var services = builder.Services;
-var connectionString = @"Host=myserver;Username=mylogin;Password=mypass;Database=mydatabase";
 
-Action<DbContextOptionsBuilder<GameIdeasContext>> dbContextOptions = options =>
+#if DEBUG
+Load("../../../../.env");
+#else
+    Load(".env");
+#endif
+
+Action<DbContextOptionsBuilder> dbContextOptions = options =>
 {
     options.UseNpgsql(
-        connectionString,
+        GetConnectionString(),
         npgOption =>
         {
             npgOption.CommandTimeout(60);
             npgOption.MigrationsAssembly("GameIdeas.WebAPI");
-        });
-
+        })
+        .LogTo(Console.WriteLine);
 };
 
 // Add services to the container.
-services.AddDbContext<GameIdeasContext>();
+services.AddDbContext<GameIdeasContext>(dbContextOptions);
+
+services.AddSingleton<TranslationService>();
+services.AddSingleton<Translations>();
 
 services.AddControllers();
 // Learn more about configuring OpenAPI at https://aka.ms/aspnet/openapi
 services.AddOpenApi();
 
 services.AddCors(option => option.AddDefaultPolicy(policy =>
-    policy.WithOrigins("http://localhost:5172")
+    policy.WithOrigins("http://localhost:5172", "http://localhost:7060")
         .AllowAnyHeader()
         .WithMethods("GET", "POST", "PUT", "DELETE")));
-
-services.AddSingleton<TranslationService>();
-services.AddSingleton<Translations>();
-
 var app = builder.Build();
 
 await LoadTranslations();
@@ -67,3 +74,31 @@ async Task LoadTranslations()
     ResourcesKey.Initialize(app.Services.GetRequiredService<Translations>());
 
 }
+
+string GetConnectionString()
+{
+    var host = Environment.GetEnvironmentVariable("DB_HOST");
+    var login = Environment.GetEnvironmentVariable("DB_USERNAME");
+    var pass = Environment.GetEnvironmentVariable("DB_PASSWORD");
+    var database = Environment.GetEnvironmentVariable("DB_DATABASE");
+
+    return $"Host={host};Username={login};Password={pass};Database={database}";
+}
+
+static void Load(string filePath)
+{
+    if (!File.Exists(filePath))
+        return;
+
+    foreach (var line in File.ReadAllLines(filePath))
+    {
+        var parts = line.Split(
+            '=',
+            StringSplitOptions.RemoveEmptyEntries);
+
+        if (parts.Length != 2)
+            continue;
+
+        Environment.SetEnvironmentVariable(parts[0], parts[1]);
+    }
+}