diff --git a/Documentation/Architecture_du_projet.drawio b/Documentation/Architecture_du_projet.drawio index b751e8b..ae15942 100644 --- a/Documentation/Architecture_du_projet.drawio +++ b/Documentation/Architecture_du_projet.drawio @@ -1 +1 @@ -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 \ No newline at end of file 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 \ No newline at end of file diff --git a/Sources/Consoles/ConsoleDB/projet.dbloulou.db b/Sources/Consoles/ConsoleDB/projet.dbloulou.db deleted file mode 100644 index 5606563..0000000 Binary files a/Sources/Consoles/ConsoleDB/projet.dbloulou.db and /dev/null differ diff --git a/Sources/EFManager/ManagerTranslate.cs b/Sources/EFManager/ManagerTranslate.cs index 6673717..929b9d2 100644 --- a/Sources/EFManager/ManagerTranslate.cs +++ b/Sources/EFManager/ManagerTranslate.cs @@ -16,11 +16,16 @@ namespace EFManager // Skin public static EFSkin toEF(this Skin Skin) => new EFSkin { Name = Skin.Name, Description = Skin.Description, Icon = Skin.Icon, Price = Skin.Price }; - public static Skin toModel(this EFSkin EFSkin) => new Skin(EFSkin.Name, EFSkin.champion.toModel()); + public static Skin toModel(this EFSkin EFSkin) => new Skin(EFSkin.Name, EFSkin.Champion.toModel()); // Skill // Rune + // LargeImage + public static EFLargeImage toEF(this LargeImage LargeImage) => new EFLargeImage { Id = Guid.NewGuid(), Base64 = LargeImage.Base64 }; + public static LargeImage toModel(this EFLargeImage EFlargeImage) => new LargeImage(EFlargeImage.Base64); + + } } diff --git a/Sources/EFMapping/EFChampionMapper.cs b/Sources/EFMapping/EFChampionMapper.cs index c6c84d2..db8bc97 100644 --- a/Sources/EFMapping/EFChampionMapper.cs +++ b/Sources/EFMapping/EFChampionMapper.cs @@ -3,5 +3,6 @@ public class EFChampionMapper { + } } \ No newline at end of file diff --git a/Sources/EFMapping/EFRuneMapper.cs b/Sources/EFMapping/EFRuneMapper.cs new file mode 100644 index 0000000..dc273b0 --- /dev/null +++ b/Sources/EFMapping/EFRuneMapper.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace EFMapping +{ + public class EFRuneMapper + { + } +} diff --git a/Sources/EFMapping/EFRunePageMapper.cs b/Sources/EFMapping/EFRunePageMapper.cs new file mode 100644 index 0000000..4440c70 --- /dev/null +++ b/Sources/EFMapping/EFRunePageMapper.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace EFMapping +{ + public class EFRunePageMapper + { + } +} diff --git a/Sources/EFMapping/EFSkillMapper.cs b/Sources/EFMapping/EFSkillMapper.cs new file mode 100644 index 0000000..ee16ed5 --- /dev/null +++ b/Sources/EFMapping/EFSkillMapper.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace EFMapping +{ + public class EFSkillMapper + { + } +} diff --git a/Sources/EFMapping/EFSkinMapper.cs b/Sources/EFMapping/EFSkinMapper.cs new file mode 100644 index 0000000..90a260b --- /dev/null +++ b/Sources/EFMapping/EFSkinMapper.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace EFMapping +{ + public class EFSkinMapper + { + } +} diff --git a/Sources/EFlib/EFChampion.cs b/Sources/EFlib/EFChampion.cs index ff2fcfb..ec527a1 100644 --- a/Sources/EFlib/EFChampion.cs +++ b/Sources/EFlib/EFChampion.cs @@ -1,5 +1,6 @@  using Model; +using System.Collections.Generic; using System.Collections.Immutable; using System.Collections.ObjectModel; using System.ComponentModel.DataAnnotations; @@ -13,19 +14,21 @@ namespace EFlib [Key] [MaxLength(256)] public string Name { get; set; } + [MaxLength(500)] public string Bio { get; set; } public string Icon { get; set; } - public List> CharacteristicsList { get; set; } - public ReadOnlyDictionary Characteristics => new ReadOnlyDictionary(CharacteristicsList.ToDictionary(kv => kv.Key, kv => kv.Value)); + + // Propriété de navigation pour les paires clé-valeur + public ICollection Characteristics { get; set; } + [Required] public ChampionClass Class { get; set; } - public ReadOnlyCollection Skins { get; private set; } - public ImmutableHashSet Skills { get; private set; } + public ReadOnlyCollection? Skins { get; set; } + public ImmutableHashSet Skills { get; set; } + + public Guid ImageId { get; set; } [ForeignKey("ImageId")] public EFLargeImage Image { get; set; } - - - } } \ No newline at end of file diff --git a/Sources/EFlib/EFCharacteristics.cs b/Sources/EFlib/EFCharacteristics.cs new file mode 100644 index 0000000..4e07186 --- /dev/null +++ b/Sources/EFlib/EFCharacteristics.cs @@ -0,0 +1,24 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel.DataAnnotations; +using System.ComponentModel.DataAnnotations.Schema; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace EFlib +{ + public class EFCharacteristics + { + [Key] + public int Id { get; set; } + + public string Name { get; set; } + public int Value { get; set; } + + // Clé étrangère vers l'entité parente + [ForeignKey("EFChampion")] + public string EFChampionName { get; set; } + public EFChampion EFChampion { get; set; } + } +} diff --git a/Sources/EFlib/EFRune.cs b/Sources/EFlib/EFRune.cs index a158399..b220906 100644 --- a/Sources/EFlib/EFRune.cs +++ b/Sources/EFlib/EFRune.cs @@ -2,6 +2,7 @@ using System; using System.Collections.Generic; using System.ComponentModel.DataAnnotations; +using System.ComponentModel.DataAnnotations.Schema; using System.Linq; using System.Reflection.Metadata; using System.Text; @@ -11,10 +12,6 @@ namespace EFlib { public class EFRune { - [Key] - public string Name { get; set; } - public string Description { get; set; } - public RuneFamily Family { get; set; } - public EFLargeImage Image { get; set; } + } } diff --git a/Sources/EFlib/EFRunePage.cs b/Sources/EFlib/EFRunePage.cs index 9276b3e..81de5cd 100644 --- a/Sources/EFlib/EFRunePage.cs +++ b/Sources/EFlib/EFRunePage.cs @@ -1,7 +1,9 @@ -using System; +using Model; +using System; using System.Collections.Generic; using System.Collections.ObjectModel; using System.ComponentModel.DataAnnotations; +using System.ComponentModel.DataAnnotations.Schema; using System.Linq; using System.Text; using System.Threading.Tasks; @@ -10,10 +12,6 @@ using static Model.RunePage; namespace EFlib { public class EFRunePage - { - [Key] - public string Name { get; set; } - public List> RunesList { get; set; } - public ReadOnlyDictionary Runes => new ReadOnlyDictionary(RunesList.ToDictionary(kv => kv.Key, kv => kv.Value)); + { } } diff --git a/Sources/EFlib/EFSkin.cs b/Sources/EFlib/EFSkin.cs index 77d7e30..75e9b7e 100644 --- a/Sources/EFlib/EFSkin.cs +++ b/Sources/EFlib/EFSkin.cs @@ -1,5 +1,7 @@ using Model; using System.ComponentModel.DataAnnotations; +using System.ComponentModel.DataAnnotations.Schema; +using System.Diagnostics.CodeAnalysis; namespace EFlib { @@ -8,11 +10,18 @@ namespace EFlib /**** Attributs ****/ [Key] public string Name { get; set; } - public EFChampion champion { get; set; } + public string Description { get; set; } public string Icon { get; set; } public float Price { get; set; } + + public Guid ImageId { get; set; } + [ForeignKey("ImageId")] public EFLargeImage Image { get; set; } + public string NameChampion { get; set; } + [ForeignKey("NameChampion")] + public EFChampion Champion { get; set; } + } } diff --git a/Sources/EFlib/Migrations/20230318182850_myMigrations.Designer.cs b/Sources/EFlib/Migrations/20230318182850_myMigrations.Designer.cs new file mode 100644 index 0000000..30f23be --- /dev/null +++ b/Sources/EFlib/Migrations/20230318182850_myMigrations.Designer.cs @@ -0,0 +1,203 @@ +// +using System; +using EFlib; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Migrations; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; + +#nullable disable + +namespace EFlib.Migrations +{ + [DbContext(typeof(SQLiteContext))] + [Migration("20230318182850_myMigrations")] + partial class myMigrations + { + /// + protected override void BuildTargetModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder.HasAnnotation("ProductVersion", "7.0.2"); + + modelBuilder.Entity("EFlib.EFChampion", b => + { + b.Property("Name") + .HasMaxLength(256) + .HasColumnType("TEXT"); + + b.Property("Bio") + .IsRequired() + .HasMaxLength(500) + .HasColumnType("TEXT"); + + b.Property("Class") + .HasColumnType("INTEGER"); + + b.Property("Icon") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("ImageId") + .HasColumnType("TEXT"); + + b.HasKey("Name"); + + b.HasIndex("ImageId"); + + b.ToTable("Champions"); + }); + + modelBuilder.Entity("EFlib.EFCharacteristics", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER"); + + b.Property("EFChampionName") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("Name") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("Value") + .HasColumnType("INTEGER"); + + b.HasKey("Id"); + + b.HasIndex("EFChampionName"); + + b.ToTable("EFCharacteristics"); + }); + + modelBuilder.Entity("EFlib.EFLargeImage", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("TEXT"); + + b.Property("Base64") + .IsRequired() + .HasColumnType("TEXT"); + + b.HasKey("Id"); + + b.ToTable("EFLargeImage"); + }); + + modelBuilder.Entity("EFlib.EFSkill", b => + { + b.Property("Name") + .HasColumnType("TEXT"); + + b.Property("Description") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("EFChampionName") + .HasColumnType("TEXT"); + + b.Property("Type") + .HasColumnType("INTEGER"); + + b.HasKey("Name"); + + b.HasIndex("EFChampionName"); + + b.ToTable("Skills"); + }); + + modelBuilder.Entity("EFlib.EFSkin", b => + { + b.Property("Name") + .HasColumnType("TEXT"); + + b.Property("Description") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("Icon") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("ImageId") + .HasColumnType("TEXT"); + + b.Property("NameChampion") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("Price") + .HasColumnType("REAL"); + + b.HasKey("Name"); + + b.HasIndex("ImageId"); + + b.HasIndex("NameChampion"); + + b.ToTable("Skins"); + }); + + modelBuilder.Entity("EFlib.EFChampion", b => + { + b.HasOne("EFlib.EFLargeImage", "Image") + .WithMany() + .HasForeignKey("ImageId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("Image"); + }); + + modelBuilder.Entity("EFlib.EFCharacteristics", b => + { + b.HasOne("EFlib.EFChampion", "EFChampion") + .WithMany("Characteristics") + .HasForeignKey("EFChampionName") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("EFChampion"); + }); + + modelBuilder.Entity("EFlib.EFSkill", b => + { + b.HasOne("EFlib.EFChampion", null) + .WithMany("Skills") + .HasForeignKey("EFChampionName"); + }); + + modelBuilder.Entity("EFlib.EFSkin", b => + { + b.HasOne("EFlib.EFLargeImage", "Image") + .WithMany() + .HasForeignKey("ImageId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.HasOne("EFlib.EFChampion", "Champion") + .WithMany("Skins") + .HasForeignKey("NameChampion") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("Champion"); + + b.Navigation("Image"); + }); + + modelBuilder.Entity("EFlib.EFChampion", b => + { + b.Navigation("Characteristics"); + + b.Navigation("Skills"); + + b.Navigation("Skins"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/Sources/EFlib/Migrations/20230318182850_myMigrations.cs b/Sources/EFlib/Migrations/20230318182850_myMigrations.cs new file mode 100644 index 0000000..2f8838f --- /dev/null +++ b/Sources/EFlib/Migrations/20230318182850_myMigrations.cs @@ -0,0 +1,160 @@ +using System; +using Microsoft.EntityFrameworkCore.Migrations; + +#nullable disable + +namespace EFlib.Migrations +{ + /// + public partial class myMigrations : Migration + { + /// + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.CreateTable( + name: "EFLargeImage", + columns: table => new + { + Id = table.Column(type: "TEXT", nullable: false), + Base64 = table.Column(type: "TEXT", nullable: false) + }, + constraints: table => + { + table.PrimaryKey("PK_EFLargeImage", x => x.Id); + }); + + migrationBuilder.CreateTable( + name: "Champions", + columns: table => new + { + Name = table.Column(type: "TEXT", maxLength: 256, nullable: false), + Bio = table.Column(type: "TEXT", maxLength: 500, nullable: false), + Icon = table.Column(type: "TEXT", nullable: false), + Class = table.Column(type: "INTEGER", nullable: false), + ImageId = table.Column(type: "TEXT", nullable: false) + }, + constraints: table => + { + table.PrimaryKey("PK_Champions", x => x.Name); + table.ForeignKey( + name: "FK_Champions_EFLargeImage_ImageId", + column: x => x.ImageId, + principalTable: "EFLargeImage", + principalColumn: "Id", + onDelete: ReferentialAction.Cascade); + }); + + migrationBuilder.CreateTable( + name: "EFCharacteristics", + columns: table => new + { + Id = table.Column(type: "INTEGER", nullable: false) + .Annotation("Sqlite:Autoincrement", true), + Name = table.Column(type: "TEXT", nullable: false), + Value = table.Column(type: "INTEGER", nullable: false), + EFChampionName = table.Column(type: "TEXT", nullable: false) + }, + constraints: table => + { + table.PrimaryKey("PK_EFCharacteristics", x => x.Id); + table.ForeignKey( + name: "FK_EFCharacteristics_Champions_EFChampionName", + column: x => x.EFChampionName, + principalTable: "Champions", + principalColumn: "Name", + onDelete: ReferentialAction.Cascade); + }); + + migrationBuilder.CreateTable( + name: "Skills", + columns: table => new + { + Name = table.Column(type: "TEXT", nullable: false), + Description = table.Column(type: "TEXT", nullable: false), + Type = table.Column(type: "INTEGER", nullable: false), + EFChampionName = table.Column(type: "TEXT", nullable: true) + }, + constraints: table => + { + table.PrimaryKey("PK_Skills", x => x.Name); + table.ForeignKey( + name: "FK_Skills_Champions_EFChampionName", + column: x => x.EFChampionName, + principalTable: "Champions", + principalColumn: "Name"); + }); + + migrationBuilder.CreateTable( + name: "Skins", + columns: table => new + { + Name = table.Column(type: "TEXT", nullable: false), + Description = table.Column(type: "TEXT", nullable: false), + Icon = table.Column(type: "TEXT", nullable: false), + Price = table.Column(type: "REAL", nullable: false), + ImageId = table.Column(type: "TEXT", nullable: false), + NameChampion = table.Column(type: "TEXT", nullable: false) + }, + constraints: table => + { + table.PrimaryKey("PK_Skins", x => x.Name); + table.ForeignKey( + name: "FK_Skins_Champions_NameChampion", + column: x => x.NameChampion, + principalTable: "Champions", + principalColumn: "Name", + onDelete: ReferentialAction.Cascade); + table.ForeignKey( + name: "FK_Skins_EFLargeImage_ImageId", + column: x => x.ImageId, + principalTable: "EFLargeImage", + principalColumn: "Id", + onDelete: ReferentialAction.Cascade); + }); + + migrationBuilder.CreateIndex( + name: "IX_Champions_ImageId", + table: "Champions", + column: "ImageId"); + + migrationBuilder.CreateIndex( + name: "IX_EFCharacteristics_EFChampionName", + table: "EFCharacteristics", + column: "EFChampionName"); + + migrationBuilder.CreateIndex( + name: "IX_Skills_EFChampionName", + table: "Skills", + column: "EFChampionName"); + + migrationBuilder.CreateIndex( + name: "IX_Skins_ImageId", + table: "Skins", + column: "ImageId"); + + migrationBuilder.CreateIndex( + name: "IX_Skins_NameChampion", + table: "Skins", + column: "NameChampion"); + } + + /// + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropTable( + name: "EFCharacteristics"); + + migrationBuilder.DropTable( + name: "Skills"); + + migrationBuilder.DropTable( + name: "Skins"); + + migrationBuilder.DropTable( + name: "Champions"); + + migrationBuilder.DropTable( + name: "EFLargeImage"); + } + } +} diff --git a/Sources/EFlib/Migrations/SQLiteContextModelSnapshot.cs b/Sources/EFlib/Migrations/SQLiteContextModelSnapshot.cs new file mode 100644 index 0000000..0b9aaa1 --- /dev/null +++ b/Sources/EFlib/Migrations/SQLiteContextModelSnapshot.cs @@ -0,0 +1,200 @@ +// +using System; +using EFlib; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; + +#nullable disable + +namespace EFlib.Migrations +{ + [DbContext(typeof(SQLiteContext))] + partial class SQLiteContextModelSnapshot : ModelSnapshot + { + protected override void BuildModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder.HasAnnotation("ProductVersion", "7.0.2"); + + modelBuilder.Entity("EFlib.EFChampion", b => + { + b.Property("Name") + .HasMaxLength(256) + .HasColumnType("TEXT"); + + b.Property("Bio") + .IsRequired() + .HasMaxLength(500) + .HasColumnType("TEXT"); + + b.Property("Class") + .HasColumnType("INTEGER"); + + b.Property("Icon") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("ImageId") + .HasColumnType("TEXT"); + + b.HasKey("Name"); + + b.HasIndex("ImageId"); + + b.ToTable("Champions"); + }); + + modelBuilder.Entity("EFlib.EFCharacteristics", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER"); + + b.Property("EFChampionName") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("Name") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("Value") + .HasColumnType("INTEGER"); + + b.HasKey("Id"); + + b.HasIndex("EFChampionName"); + + b.ToTable("EFCharacteristics"); + }); + + modelBuilder.Entity("EFlib.EFLargeImage", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("TEXT"); + + b.Property("Base64") + .IsRequired() + .HasColumnType("TEXT"); + + b.HasKey("Id"); + + b.ToTable("EFLargeImage"); + }); + + modelBuilder.Entity("EFlib.EFSkill", b => + { + b.Property("Name") + .HasColumnType("TEXT"); + + b.Property("Description") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("EFChampionName") + .HasColumnType("TEXT"); + + b.Property("Type") + .HasColumnType("INTEGER"); + + b.HasKey("Name"); + + b.HasIndex("EFChampionName"); + + b.ToTable("Skills"); + }); + + modelBuilder.Entity("EFlib.EFSkin", b => + { + b.Property("Name") + .HasColumnType("TEXT"); + + b.Property("Description") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("Icon") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("ImageId") + .HasColumnType("TEXT"); + + b.Property("NameChampion") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("Price") + .HasColumnType("REAL"); + + b.HasKey("Name"); + + b.HasIndex("ImageId"); + + b.HasIndex("NameChampion"); + + b.ToTable("Skins"); + }); + + modelBuilder.Entity("EFlib.EFChampion", b => + { + b.HasOne("EFlib.EFLargeImage", "Image") + .WithMany() + .HasForeignKey("ImageId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("Image"); + }); + + modelBuilder.Entity("EFlib.EFCharacteristics", b => + { + b.HasOne("EFlib.EFChampion", "EFChampion") + .WithMany("Characteristics") + .HasForeignKey("EFChampionName") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("EFChampion"); + }); + + modelBuilder.Entity("EFlib.EFSkill", b => + { + b.HasOne("EFlib.EFChampion", null) + .WithMany("Skills") + .HasForeignKey("EFChampionName"); + }); + + modelBuilder.Entity("EFlib.EFSkin", b => + { + b.HasOne("EFlib.EFLargeImage", "Image") + .WithMany() + .HasForeignKey("ImageId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.HasOne("EFlib.EFChampion", "Champion") + .WithMany("Skins") + .HasForeignKey("NameChampion") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("Champion"); + + b.Navigation("Image"); + }); + + modelBuilder.Entity("EFlib.EFChampion", b => + { + b.Navigation("Characteristics"); + + b.Navigation("Skills"); + + b.Navigation("Skins"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/Sources/EFlib/SQLiteContext.cs b/Sources/EFlib/SQLiteContext.cs index 676aa6b..2898495 100644 --- a/Sources/EFlib/SQLiteContext.cs +++ b/Sources/EFlib/SQLiteContext.cs @@ -8,8 +8,6 @@ namespace EFlib public DbSet Champions { get; set; } public DbSet Skins { get; set; } public DbSet Skills { get; set; } - public DbSet Runes { get; set; } - public DbSet RunePages { get; set; } /**** Méthodes ****/ public SQLiteContext() @@ -26,10 +24,5 @@ namespace EFlib optionsBuilder.UseSqlite($"Data Source=projet.dbloulou.db"); } } - - protected override void OnModelCreating(ModelBuilder modelBuilder) - { - // TODO - } } } diff --git a/Sources/EFlib/projet.dbloulou.db b/Sources/EFlib/projet.dbloulou.db new file mode 100644 index 0000000..327bfab Binary files /dev/null and b/Sources/EFlib/projet.dbloulou.db differ diff --git a/Sources/LeagueOfLegends.sln b/Sources/LeagueOfLegends.sln index 5adde57..250b7ea 100644 --- a/Sources/LeagueOfLegends.sln +++ b/Sources/LeagueOfLegends.sln @@ -35,8 +35,6 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestManagerEF", "Tests\Test EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestAPI", "TestAPI\TestAPI.csproj", "{F7B6A3D6-6C70-49DC-9D1D-4B70071EEF25}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EFMapping", "EFMapping\EFMapping.csproj", "{33567480-B38B-4A1E-9A81-6F4136A09C15}" -EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -95,10 +93,6 @@ Global {F7B6A3D6-6C70-49DC-9D1D-4B70071EEF25}.Debug|Any CPU.Build.0 = Debug|Any CPU {F7B6A3D6-6C70-49DC-9D1D-4B70071EEF25}.Release|Any CPU.ActiveCfg = Release|Any CPU {F7B6A3D6-6C70-49DC-9D1D-4B70071EEF25}.Release|Any CPU.Build.0 = Release|Any CPU - {33567480-B38B-4A1E-9A81-6F4136A09C15}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {33567480-B38B-4A1E-9A81-6F4136A09C15}.Debug|Any CPU.Build.0 = Debug|Any CPU - {33567480-B38B-4A1E-9A81-6F4136A09C15}.Release|Any CPU.ActiveCfg = Release|Any CPU - {33567480-B38B-4A1E-9A81-6F4136A09C15}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/Sources/Tests/TestEF/UnitTestChampion.cs b/Sources/Tests/TestEF/UnitTestChampion.cs index fe4f961..59ab865 100644 --- a/Sources/Tests/TestEF/UnitTestChampion.cs +++ b/Sources/Tests/TestEF/UnitTestChampion.cs @@ -1,13 +1,90 @@ using EFlib; using Microsoft.Data.Sqlite; using Microsoft.EntityFrameworkCore; +using Model; using StubEF; +using System.Collections.Immutable; +using System.Collections.ObjectModel; +using System.Reflection.PortableExecutable; using Xunit; namespace TestEF { - /*public class UniTestChampion + public class UniTestChampion { + [Fact] + public async Task AddChampion_Test() + { + // connection must be opened to use In-memory database + var connection = new SqliteConnection("DataSource =:memory:"); + connection.Open(); + + var options = new DbContextOptionsBuilder().UseSqlite(connection).Options; + + using (var context = new SQLiteContext(options)) + { + await context.Database.EnsureCreatedAsync(); //pour créer la base si elle n'existe pas déjà + + // Arrange + EFChampion champion = new EFChampion + { + Name = "Champion 1", + Bio = "Bio Champion 1", + Icon = "aatrox_icon.jpg", + Class = ChampionClass.Assassin, + + Characteristics = new List { + new EFCharacteristics { Name = "Attack Damage", Value = 60 }, + new EFCharacteristics { Name = "Armor", Value = 38 }, + new EFCharacteristics { Name = "Magic Resist", Value = 32 } + }, + + Skills = ImmutableHashSet.Create( + new EFSkill { Name = "Skill 1", Description = "Desc Skill 1" }, + new EFSkill { Name = "Skill 2", Description = "Desc Skill 2" } + ), + + Skins = new ReadOnlyCollection(new List { + new EFSkin + { + Name = "Mecha Kingdoms Aatrox", + Description = "In a distant cyberfuture, the champion Aatrox becomes a symbol of ultimate power and glory...", + Icon = "aatrox_mecha_icon.jpg", + Price = 1350, + NameChampion = "Aatrox", + ImageId = Guid.NewGuid(), + Image = new EFLargeImage { Id = Guid.NewGuid(), Base64 = "aatrox_mecha_splash.jpg" } + } } ), + + Image = new EFLargeImage { Id = Guid.NewGuid(), Base64 = "CheminDeMonChampion" } + }; + + context.Add(champion); + await context.SaveChangesAsync(); + + // Act + await context.Champions.FirstOrDefaultAsync(c => c.Name == "Champion 1"); + + // Assert + Assert.NotNull(champion); + Assert.Equal("Bio Champion 1", champion.Bio); + Assert.Equal("aatrox_icon.jpg", champion.Icon); + Assert.NotNull(champion.Characteristics); + Assert.Equal(3, champion.Characteristics.Count); + Assert.Equal(ChampionClass.Assassin, champion.Class); + Assert.Single(champion.Skins); + if (champion.Skins.Any()) + { + Assert.Equal("Mecha Kingdoms Aatrox", champion.Skins[0].Name); + } + Assert.Equal(2, champion.Skills.Count); + Assert.Contains(champion.Skills, s => s.Name == "Skill 1"); + Assert.Contains(champion.Skills, s => s.Name == "Skill 2"); + Assert.Equal("CheminDeMonChampion", champion.Image.Base64); + } + } + + [Fact] public async Task GetChampion_Test() { @@ -21,14 +98,18 @@ namespace TestEF { //context.Database.OpenConnection(); await context.Database.EnsureCreatedAsync(); //pour créer la base si elle n'existe pas déjà - - var champs = context.Champions.SingleOrDefault(c=> c.Name == "Akali"); + + var champs = context.Champions.SingleOrDefault(c => c.Name == "Akali"); Assert.NotNull(champs); Assert.Equal("Akali", champs.Name); } - }*/ - /* + } + } + + + + /* [Fact] public void Modify_Test() { @@ -54,31 +135,31 @@ namespace TestEF context.SaveChanges(); }*/ - //uses another instance of the context to do the tests - /* using (var context = new StubEFChampions(options)) - { - context.Database.EnsureCreated(); - - string nameToFind = "ew"; - Assert.Equal(2, context.Champions.Where(n => n.Name.ToLower().Contains(nameToFind)).Count()); - nameToFind = "wo"; - Assert.Equal(1, context.Champions.Where(n => n.Name.ToLower().Contains(nameToFind)).Count()); - var ewok = context.Champions.Where(n => n.Name.ToLower().Contains(nameToFind)).First(); - ewok.Name = "Wicket"; - context.SaveChanges(); - } - - //uses another instance of the context to do the tests - using (var context = new StubEFChampions(options)) - { - context.Database.EnsureCreated(); - - string nameToFind = "ew"; - Assert.Equal(1, context.Champions.Where(n => n.Name.ToLower().Contains(nameToFind)).Count()); - nameToFind = "wick"; - Assert.Equal(1, context.Champions.Where(n => n.Name.ToLower().Contains(nameToFind)).Count()); - } - }*/ + //uses another instance of the context to do the tests + /* using (var context = new StubEFChampions(options)) + { + context.Database.EnsureCreated(); + + string nameToFind = "ew"; + Assert.Equal(2, context.Champions.Where(n => n.Name.ToLower().Contains(nameToFind)).Count()); + nameToFind = "wo"; + Assert.Equal(1, context.Champions.Where(n => n.Name.ToLower().Contains(nameToFind)).Count()); + var ewok = context.Champions.Where(n => n.Name.ToLower().Contains(nameToFind)).First(); + ewok.Name = "Wicket"; + context.SaveChanges(); + } + + //uses another instance of the context to do the tests + using (var context = new StubEFChampions(options)) + { + context.Database.EnsureCreated(); + + string nameToFind = "ew"; + Assert.Equal(1, context.Champions.Where(n => n.Name.ToLower().Contains(nameToFind)).Count()); + nameToFind = "wick"; + Assert.Equal(1, context.Champions.Where(n => n.Name.ToLower().Contains(nameToFind)).Count()); + } + }*/ /* [SetUp] public void Setup() @@ -128,4 +209,4 @@ namespace TestEF } */ -} \ No newline at end of file + } \ No newline at end of file