localhost modif

# Conflicts:
#	Knots/obj/Debug/net8.0/Knots.assets.cache
#	Knots/obj/Debug/net8.0/Knots.csproj.AssemblyReference.cache
#	Knots/obj/project.nuget.cache
#	Knots/obj/project.packagespec.json
#	Knots/obj/rider.project.model.nuget.info
#	Knots/obj/rider.project.restore.info

.idea/.idea.Knots/.idea/dataSources.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="DataSourceManagerImpl" format="xml" multifile-model="true">
+    <data-source source="LOCAL" name="@romaric-thibault.fr" uuid="6e1760b6-e554-4516-9799-154d6f998f71">
+      <driver-ref>sqlserver.jb</driver-ref>
+      <synchronize>true</synchronize>
+      <jdbc-driver>com.jetbrains.jdbc.sqlserver.SqlServerDriver</jdbc-driver>
+      <jdbc-url>Server=romaric-thibault.fr,1433</jdbc-url>
+      <jdbc-additional-properties>
+        <property name="com.intellij.clouds.kubernetes.db.host.port" />
+        <property name="com.intellij.clouds.kubernetes.db.enabled" value="false" />
+        <property name="com.intellij.clouds.kubernetes.db.container.port" />
+      </jdbc-additional-properties>
+      <working-dir>$ProjectFileDir$</working-dir>
+    </data-source>
+  </component>
+</project>

Knots/DTO/Discussion/CreateDiscussionDto.cs

@@ -0,0 +1,6 @@
+namespace Knots.DTO.Discussion;
+
+public class CreateDiscussionDto
+{
+    public int Id { get; set; }
+}

Knots/DTO/Discussion/DeleteDiscussionDto.cs

@@ -0,0 +1,6 @@
+namespace Knots.DTO.Discussion;
+
+public class DeleteDiscussionDto
+{
+    public int Id { get; set; }
+}

Knots/DTO/Discussion/GetDiscussionDto.cs

@@ -0,0 +1,6 @@
+namespace Knots.DTO.Discussion;
+
+public class GetDiscussionDto
+{
+    public int Id { get; set; }
+}

Knots/DTO/Group/CreateGroupDto.cs

@@ -0,0 +1,8 @@
+namespace Knots.DTO.Group;
+
+public class CreateGroupDto
+{
+    public string? Nom { get; set; }
+    public int NombreMembres { get; set; }
+    public string? ProfilePicture { get; set; }
+}

Knots/DTO/Group/DeleteGroupDto.cs

@@ -0,0 +1,6 @@
+namespace Knots.DTO.Group;
+
+public class DeleteGroupDto
+{
+    public int? Id { get; set; }
+}

Knots/DTO/Group/GetGroupDetailsDto.cs

@@ -0,0 +1,9 @@
+namespace Knots.DTO.Group;
+
+public class GetGroupDetailsDto
+{
+    public int Id { get; set; }
+    public string? Nom { get; set; }
+    public int NombreMembres { get; set; }
+    public string? ProfilePicture { get; set; }
+}

Knots/DTO/Group/GetGroupDto.cs

@@ -0,0 +1,6 @@
+namespace Knots.DTO.Group;
+
+public class GetGroupDto
+{
+    public int Id { get; set; }
+}

Knots/DTO/Group/UpdateGroupDto.cs

@@ -0,0 +1,9 @@
+namespace Knots.DTO.Group;
+
+public class UpdateGroupDto
+{
+    public int Id { get; set; }
+    public string? Nom { get; set; }
+    public int NombreMembres { get; set; }
+    public string? ProfilePicture { get; set; }
+}

Knots/DTO/Group/UpdateGroupMembersAmountDto.cs

@@ -0,0 +1,7 @@
+namespace Knots.DTO.Group;
+
+public class UpdateGroupMembersAmountDto
+{
+    public int Id { get; set; }
+    public int MembersAmount { get; set; }
+}

Knots/DTO/Group/UpdateGroupNameDto.cs

@@ -0,0 +1,7 @@
+namespace Knots.DTO.Group;
+
+public class UpdateGroupNameDto
+{
+    public int Id { get; set; }
+    public string? Name { get; set; }
+}

Knots/DTO/Group/UpdateGroupProfilePictureDto.cs

@@ -0,0 +1,7 @@
+namespace Knots.DTO.Group;
+
+public class UpdateGroupProfilePictureDto
+{
+    public int Id { get; set; }
+    public string? ProfilePicture { get; set; }
+}

Knots/DTO/Key/CreateKeyDto.cs

@@ -0,0 +1,6 @@
+namespace Knots.DTO.Key;
+
+public class CreateKeyDto
+{
+    public string? EnKey { get; set; }
+}

Knots/DTO/Key/DeleteKeyDto.cs

@@ -0,0 +1,6 @@
+namespace Knots.DTO.Key;
+
+public class DeleteKeyDto
+{
+    public int Id { get; set; }
+}

Knots/DTO/Key/GetKeyDetailsDto.cs

@@ -0,0 +1,7 @@
+namespace Knots.DTO.Key;
+
+public class GetKeyDetailsDto
+{
+    public int Id { get; set; }
+    public string? EnKey { get; set; }
+}

Knots/DTO/Key/GetKeyDto.cs

@@ -0,0 +1,6 @@
+namespace Knots.DTO.Key;
+
+public class GetKeyDto
+{
+    public int Id { get; set; }
+}

Knots/DTO/Message/CreateMessageDto.cs

@@ -0,0 +1,8 @@
+namespace Knots.DTO.Message;
+
+public class CreateMessageDto
+{
+    public string? Contenu { get; set; }
+    public DateTime Date { get; set; }
+    public Boolean Type { get; set; }
+}

Knots/DTO/Message/DeleteMessageDto.cs

@@ -0,0 +1,6 @@
+namespace Knots.DTO.Message;
+
+public class DeleteMessageDto
+{
+    public int Id { get; set; }
+}

Knots/DTO/Message/GetMessageDetailsDto.cs

@@ -0,0 +1,9 @@
+namespace Knots.DTO.Message;
+
+public class GetMessageDetailsDto
+{
+    public int Id { get; set; }
+    public string? Contenu { get; set; }
+    public DateTime Date { get; set; }
+    public Boolean Type { get; set; }
+}

Knots/DTO/Message/GetMessageDto.cs

@@ -0,0 +1,6 @@
+namespace Knots.DTO.Message;
+
+public class GetMessageDto
+{
+   public int Id { get; set; }
+}

Knots/DTO/Role/CreateRoleDto.cs

@@ -0,0 +1,6 @@
+namespace Knots.DTO.Role;
+
+public class CreateRoleDto
+{
+    public string? Libelle  { get; set; }
+}

Knots/DTO/Role/DeleteRoleDto.cs

@@ -0,0 +1,6 @@
+namespace Knots.DTO.Role;
+
+public class DeleteRoleDto
+{
+    public int Id  { get; set; }
+}

Knots/DTO/Role/GetRoleDto.cs

@@ -0,0 +1,6 @@
+namespace Knots.DTO.Role;
+
+public class GetRoleDto
+{
+    public string? Libelle { get; set; }
+}

Knots/DTO/User/CreateUserDto.cs

@@ -0,0 +1,11 @@
+namespace Knots.DTO.User;
+
+public class CreateUserDto
+{
+    public string? Username { get; set; }
+    public string? Description {get; set;}
+    public string? Password { get; set; }
+    public string? Email { get; set; }
+    public string? Tel { get; set; }
+    public string? ProfilePicture { get; set; }
+}

Knots/DTO/User/DeleteUserDto.cs

@@ -0,0 +1,6 @@
+namespace Knots.DTO.User;
+
+public class DeleteUserDto
+{
+    public string? Username { get; set; }
+}

Knots/DTO/User/GetUserDetailsDto.cs

@@ -0,0 +1,11 @@
+namespace Knots.DTO.User;
+
+public class GetUserDetailsDto
+{
+    public string? Username { get; set; }
+    public string? Description {get; set;}
+    public string? Password { get; set; }
+    public string? Email { get; set; }
+    public string? Tel { get; set; }
+    public string? ProfilePicture { get; set; }
+}

Knots/DTO/User/GetUserDto.cs

@@ -0,0 +1,6 @@
+namespace Knots.DTO.User;
+
+public class GetUserDto
+{
+    public string? Username { get; set; }
+}

Knots/DTO/User/UpdateUserContactDto.cs

@@ -0,0 +1,8 @@
+namespace Knots.DTO.User;
+
+public class UpdateUserContactDto
+{
+    public int Id { get; set; }
+    public string? Email { get; set; }
+    public string? Tel { get; set; }
+}

Knots/DTO/User/UpdateUserDescriptionDto.cs

@@ -0,0 +1,7 @@
+namespace Knots.DTO.User;
+
+public class UpdateUserDescriptionDto
+{
+    public int Id { get; set; }
+    public string? Description {get; set;}
+}

Knots/DTO/User/UpdateUserDto.cs

@@ -0,0 +1,6 @@
+namespace Knots.DTO.User;
+
+public class UpdateUserDto
+{
+    public int Id { get; set; }
+}

Knots/DTO/User/UpdateUserPasswordDto.cs

@@ -0,0 +1,7 @@
+namespace Knots.DTO.User;
+
+public class UpdateUserPasswordDto
+{
+    public int Id { get; set; }
+    public string? Password { get; set; }
+}

Knots/DTO/User/UpdateUserProfilePictureDto.cs

@@ -0,0 +1,7 @@
+namespace Knots.DTO.User;
+
+public class UpdateUserProfilePictureDto
+{
+    public int Id { get; set; }
+    public string? ProfilePicture { get; set; }
+}

Knots/DTO/User/UpdateUsernameDto.cs

@@ -0,0 +1,7 @@
+namespace Knots.DTO.User;
+
+public class UpdateUsernameDto
+{
+    public int Id { get; set; }
+    public string? Username { get; set; }
+}

Knots/Endpoints/Discussion/CreateDiscussionEndpoint.cs

@@ -0,0 +1,21 @@
+using FastEndpoints;
+using Knots.DTO.Discussion;
+
+namespace Knots.Endpoints.Discussion;
+
+public class CreateDiscussionEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint<CreateDiscussionDto>
+{
+    public override void Configure()
+    {
+        Post("/discussions");
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(CreateDiscussionDto req, CancellationToken ct)
+    {
+        Models.Discussion? discussion = mapper.Map<Models.Discussion>(req);
+        db.Discussions.Add(discussion);
+        await db.SaveChangesAsync(ct);
+        await Send.NoContentAsync(ct);
+    }
+}

Knots/Endpoints/Discussion/DeleteDiscussionEndpoint.cs

@@ -0,0 +1,21 @@
+using FastEndpoints;
+using Knots.DTO.Discussion;
+
+namespace Knots.Endpoints.Discussion;
+
+public class DeleteDiscussionEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint<DeleteDiscussionDto>
+{
+    public override void Configure()
+    {
+        Delete("/discussions");
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(DeleteDiscussionDto req, CancellationToken ct)
+    {
+        Models.Discussion? discussion = mapper.Map<Models.Discussion>(req);
+        db.Discussions.Remove(discussion);
+        await db.SaveChangesAsync(ct);
+        await Send.NoContentAsync(ct);
+    }
+}

Knots/Endpoints/Discussion/GetDiscussionEndpoint.cs

@@ -0,0 +1,29 @@
+using Knots.DTO.Discussion;
+using Knots.DTO.Key;
+using Microsoft.EntityFrameworkCore;
+using FastEndpoints;
+
+namespace Knots.Endpoints.Discussion;
+
+public class GetDiscussionEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint<GetDiscussionDto>
+{
+    public override void Configure()
+    {
+        Get("/discussions");
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(GetDiscussionDto req, CancellationToken ct)
+    {
+        Models.Discussion? databaseDiscussion = await db.Discussions.SingleOrDefaultAsync(x => x.Id == req.Id, cancellationToken: ct);     
+        
+        if (databaseDiscussion == null)
+        {
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+        
+        var keyDto = mapper.Map<GetKeyDetailsDto>(databaseDiscussion);
+        await Send.OkAsync(keyDto, ct);
+    }
+}

Knots/Endpoints/Group/CreateGroupEndpoint.cs

@@ -0,0 +1,21 @@
+using Knots.DTO.Group;
+using FastEndpoints;
+
+namespace Knots.Endpoints.Group;
+
+public class CreateGroupEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint<CreateGroupDto>
+{
+    public override void Configure()
+    {
+        Post("/groups");
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(CreateGroupDto req, CancellationToken ct)
+    {
+        Models.Group? group = mapper.Map<Models.Group>(req);
+        db.Groups.Add(group);
+        await db.SaveChangesAsync(ct);
+        await Send.NoContentAsync(ct);
+    }
+}

Knots/Endpoints/Group/DeleteGroupEndpoint.cs

@@ -0,0 +1,21 @@
+using FastEndpoints;
+using Knots.DTO.Group;
+
+namespace Knots.Endpoints.Group;
+
+public class DeleteGroupEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint<DeleteGroupDto>
+{
+    public override void Configure()
+    {
+        Delete("/groups");
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(DeleteGroupDto req, CancellationToken ct)
+    {
+        Models.Group? group = mapper.Map<Models.Group>(req);
+        db.Groups.Remove(group);
+        await db.SaveChangesAsync(ct);
+        await Send.NoContentAsync(ct);
+    }
+}

Knots/Endpoints/Group/GetGroupEndpoint.cs

@@ -0,0 +1,29 @@
+using FastEndpoints;
+using Knots.DTO.Group;
+using Knots.DTO.Key;
+using Microsoft.EntityFrameworkCore;
+
+namespace Knots.Endpoints.Group;
+
+public class GetGroupEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint<GetGroupDetailsDto>
+{
+    public override void Configure()
+    {
+        Get("/groups");
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(GetGroupDetailsDto req, CancellationToken ct)
+    {
+        Models.Group? databaseGroup = await db.Groups.SingleOrDefaultAsync(x => x.Id == req.Id, cancellationToken: ct);     
+        
+        if (databaseGroup == null)
+        {
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+        
+        var keyDto = mapper.Map<GetKeyDetailsDto>(databaseGroup);
+        await Send.OkAsync(keyDto, ct);
+    }
+}

Knots/Endpoints/Group/PatchGroupMembersAmountEndpoint.cs

@@ -0,0 +1,29 @@
+using FastEndpoints;
+using Knots.DTO.Group;
+using Microsoft.EntityFrameworkCore;
+
+namespace Knots.Endpoints.Group;
+
+public class PatchGroupMembersAmountEndpoint(KnotsDbContext knotsDbContext) : Endpoint<UpdateGroupMembersAmountDto>
+{
+    public override void Configure()
+    {
+        Patch("/groups/{@Id}/membersAmount/", x => new {x.Id});
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(UpdateGroupMembersAmountDto req, CancellationToken ct)
+    {
+        Models.Group? databaseGroup = await knotsDbContext.Groups.SingleOrDefaultAsync(x => x.Id == req.Id, cancellationToken: ct);
+
+        if (databaseGroup is null)
+        {
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+        
+        databaseGroup.MembersAmount = req.MembersAmount;
+        await knotsDbContext.SaveChangesAsync(ct);
+        await Send.NoContentAsync(ct);
+    }
+}

Knots/Endpoints/Group/PatchGroupNameEndpoint.cs

@@ -0,0 +1,29 @@
+using FastEndpoints;
+using Knots.DTO.Group;
+using Microsoft.EntityFrameworkCore;
+
+namespace Knots.Endpoints.Group;
+
+public class PatchGroupNameEndpoint(KnotsDbContext knotsDbContext) : Endpoint<UpdateGroupNameDto>
+{
+    public override void Configure()
+    {
+        Patch("/groups/{@Id}/name/", x => new {x.Id});
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(UpdateGroupNameDto req, CancellationToken ct)
+    {
+        Models.Group? databaseGroup = await knotsDbContext.Groups.SingleOrDefaultAsync(x => x.Id == req.Id, cancellationToken: ct);
+
+        if (databaseGroup is null)
+        {
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+        
+        databaseGroup.Name = req.Name;
+        await knotsDbContext.SaveChangesAsync(ct);
+        await Send.NoContentAsync(ct);
+    }
+}

Knots/Endpoints/Group/PatchGroupProfilePictureEndpoint.cs

@@ -0,0 +1,29 @@
+using FastEndpoints;
+using Knots.DTO.Group;
+using Microsoft.EntityFrameworkCore;
+
+namespace Knots.Endpoints.Group;
+
+public class PatchGroupProfilePictureEndpoint(KnotsDbContext knotsDbContext) : Endpoint<UpdateGroupProfilePictureDto>
+{
+    public override void Configure()
+    {
+        Patch("/groups/{@Id}/profilePicture/", x => new {x.Id});
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(UpdateGroupProfilePictureDto req, CancellationToken ct)
+    {
+        Models.Group? databaseGroup = await knotsDbContext.Groups.SingleOrDefaultAsync(x => x.Id == req.Id, cancellationToken: ct);
+
+        if (databaseGroup is null)
+        {
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+        
+        databaseGroup.ProfilePicture = req.ProfilePicture;
+        await knotsDbContext.SaveChangesAsync(ct);
+        await Send.NoContentAsync(ct);
+    }
+}

Knots/Endpoints/Key/CreateKeyEndpoint.cs

@@ -0,0 +1,21 @@
+using Knots.DTO.Key;
+using FastEndpoints;
+
+namespace Knots.Endpoints.Key;
+
+public class CreateKeyEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint<CreateKeyDto>
+{
+    public override void Configure()
+    {
+        Post("/keys");
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(CreateKeyDto req, CancellationToken ct)
+    {
+        Models.Key? key = mapper.Map<Models.Key>(req);
+        db.Keys.Add(key);
+        await db.SaveChangesAsync(ct);
+        await Send.NoContentAsync(ct);
+    }
+}

Knots/Endpoints/Key/DeleteKeyEndpoint.cs

@@ -0,0 +1,21 @@
+using FastEndpoints;
+using Knots.DTO.Key;
+
+namespace Knots.Endpoints.Key;
+
+public class DeleteKeyEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint<DeleteKeyDto>
+{
+    public override void Configure()
+    {
+        Delete("/keys");
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(DeleteKeyDto req, CancellationToken ct)
+    {
+        Models.Key? key = mapper.Map<Models.Key>(req);
+        db.Keys.Remove(key);
+        await db.SaveChangesAsync(ct);
+        await Send.NoContentAsync(ct);
+    }
+}

Knots/Endpoints/Key/GetKeyEndpoint.cs

@@ -0,0 +1,29 @@
+using FastEndpoints;
+using Knots.DTO.Key;
+using Knots.DTO.User;
+using Microsoft.EntityFrameworkCore;
+
+namespace Knots.Endpoints.Key;
+
+public class GetKeyEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint <GetKeyDetailsDto>
+{
+    public override void Configure()
+    { 
+        Get("/keys/{@Id}");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(GetKeyDetailsDto req, CancellationToken ct)
+    {
+        Models.Key? databaseKey = await db.Keys.SingleOrDefaultAsync(x => x.Id == req.Id, cancellationToken: ct);     
+        
+        if (databaseKey == null)
+        {
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+        
+        var keyDto = mapper.Map<GetKeyDetailsDto>(databaseKey);
+        await Send.OkAsync(keyDto, ct);
+    }
+}

Knots/Endpoints/Message/CreateMessageEndpoint.cs

@@ -0,0 +1,21 @@
+using FastEndpoints;
+using Knots.DTO.Message;
+
+namespace Knots.Endpoints.Message;
+
+public class CreateMessageEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint<CreateMessageDto>
+{
+    public override void Configure()
+    {
+        Post("/messages");
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(CreateMessageDto req, CancellationToken ct)
+    {
+        Models.Message? message = mapper.Map<Models.Message>(req);
+        db.Messages.Add(message);
+        await db.SaveChangesAsync(ct);
+        await Send.NoContentAsync(ct);
+    }
+}

Knots/Endpoints/Message/DeleteMessageEndpoint.cs

@@ -0,0 +1,21 @@
+using FastEndpoints;
+using Knots.DTO.Message;
+
+namespace Knots.Endpoints.Message;
+
+public class DeleteMessageEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint<DeleteMessageDto>
+{
+    public override void Configure()
+    {
+        Delete("/messages");
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(DeleteMessageDto req, CancellationToken ct)
+    {
+        Models.Message? message = mapper.Map<Models.Message>(req);
+        db.Messages.Remove(message);
+        await db.SaveChangesAsync(ct);
+        await Send.NoContentAsync(ct);
+    }
+}

Knots/Endpoints/Message/GetMessageEndpoint.cs

@@ -0,0 +1,29 @@
+using FastEndpoints;
+using Knots.DTO.Message;
+using Knots.DTO.User;
+using Microsoft.EntityFrameworkCore;
+
+namespace Knots.Endpoints.Message;
+
+public class GetMessageEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint <GetMessageDetailsDto>
+{
+    public override void Configure()
+    { 
+        Get("/messages/{@Id}");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(GetMessageDetailsDto req, CancellationToken ct)
+    {
+        Models.Message? databaseMessage = await db.Messages.SingleOrDefaultAsync(x => x.Id == req.Id, cancellationToken: ct);     
+        
+        if (databaseMessage == null)
+        {
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+        
+        var messageDto = mapper.Map<GetMessageDetailsDto>(databaseMessage);
+        await Send.OkAsync(messageDto, ct);
+    }
+}

Knots/Endpoints/Role/CreateRoleEndpoint.cs

@@ -0,0 +1,22 @@
+using FastEndpoints;
+using Knots.DTO.Role;
+using Knots.DTO.User;
+
+namespace Knots.Endpoints.Role;
+
+public class CreateRoleEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint<CreateRoleDto>
+{
+    public override void Configure()
+    {
+        Post("/roles");
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(CreateRoleDto req, CancellationToken ct)
+    {
+        Models.Role? role = mapper.Map<Models.Role>(req);
+        db.Roles.Add(role);
+        await db.SaveChangesAsync(ct);
+        await Send.NoContentAsync(ct);
+    }
+}

Knots/Endpoints/Role/DeleteRoleEndpoint.cs

@@ -0,0 +1,21 @@
+using FastEndpoints;
+using Knots.DTO.Role;
+
+namespace Knots.Endpoints.Role;
+
+public class DeleteRoleEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint<DeleteRoleDto>
+{
+    public override void Configure()
+    {
+        Delete("/roles");
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(DeleteRoleDto req, CancellationToken ct)
+    {
+        Models.Role? role = mapper.Map<Models.Role>(req);
+        db.Roles.Remove(role);
+        await db.SaveChangesAsync(ct);
+        await Send.NoContentAsync(ct);
+    }
+}

Knots/Endpoints/Role/GetRoleEndpoint.cs

@@ -0,0 +1,29 @@
+using FastEndpoints;
+using Knots.DTO.Role;
+using Knots.DTO.User;
+using Microsoft.EntityFrameworkCore;
+
+namespace Knots.Endpoints.Role;
+
+public class GetRoleEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint <GetRoleDto>
+{
+    public override void Configure()
+    { 
+        Get ("/roles/{@Id}", x => new { x.Libelle });
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(GetRoleDto req, CancellationToken ct)
+    {
+        Models.Role? databaseRole = await db.Roles.SingleOrDefaultAsync(x => x.Libelle == req.Libelle, cancellationToken: ct);     
+        
+        if (databaseRole == null)
+        {
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+        
+        var roleDto = mapper.Map<GetRoleDto>(databaseRole);
+        await Send.OkAsync(roleDto, ct);
+    }
+}

Knots/Endpoints/User/CreateUserEndpoint.cs

@@ -0,0 +1,21 @@
+using FastEndpoints;
+using Knots.DTO.User;
+
+namespace Knots.Endpoints.User;
+
+public class CreateUserEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint<CreateUserDto, GetUserDto>
+{
+    public override void Configure()
+    {
+        Post("/users");
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(CreateUserDto req, CancellationToken ct)
+    {
+        Models.User? user = mapper.Map<Models.User>(req);
+        db.Users.Add(user);
+        await db.SaveChangesAsync(ct);
+        await Send.NoContentAsync(ct);
+    }
+}

Knots/Endpoints/User/DeleteUserEndpoint.cs

@@ -0,0 +1,21 @@
+using FastEndpoints;
+using Knots.DTO.User;
+using Microsoft.EntityFrameworkCore;
+
+namespace Knots.Endpoints.User;
+
+public class DeleteUserEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint <DeleteUserDto>
+{
+    public override void Configure()
+    { 
+        Delete ("/users/{@Id}");
+    }
+
+    public override async Task HandleAsync(DeleteUserDto req, CancellationToken ct)
+    {
+        Models.User? user = mapper.Map<Models.User>(req);
+        db.Users.Add(user);
+        await db.SaveChangesAsync(ct);
+        await Send.NoContentAsync(ct);
+    }
+}

Knots/Endpoints/User/GetAllUsersEndpoint.cs

@@ -0,0 +1,24 @@
+using AutoMapper.QueryableExtensions;
+using FastEndpoints;
+using Knots.DTO.User;
+using Microsoft.EntityFrameworkCore;
+
+namespace Knots.Endpoints.User;
+
+public class GetAllUsersEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : EndpointWithoutRequest<List<GetUserDetailsDto>>
+{
+    public override void Configure()
+    { 
+        Get ("/users");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(CancellationToken ct)
+    {
+        var users = await db.Users
+            .ProjectTo<GetUserDetailsDto>(mapper.ConfigurationProvider)
+            .ToListAsync(ct);
+        
+        await Send.OkAsync(users, ct);
+    }
+}

Knots/Endpoints/User/GetUserEndpoint.cs

@@ -0,0 +1,28 @@
+using FastEndpoints;
+using Knots.DTO.User;
+using Microsoft.EntityFrameworkCore;
+
+namespace Knots.Endpoints.User;
+
+public class GetUserEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint <GetUserDetailsDto>
+{
+    public override void Configure()
+    { 
+        Get ("/users/{@Id}", x => new { x.Username });
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(GetUserDetailsDto req, CancellationToken ct)
+    {
+        Models.User? databaseUser = await db.Users.SingleOrDefaultAsync(x => x.Username == req.Username, cancellationToken: ct);     
+        
+        if (databaseUser == null)
+        {
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+        
+        var userDto = mapper.Map<GetUserDetailsDto>(databaseUser);
+        await Send.OkAsync(userDto, ct);
+    }
+}

Knots/Endpoints/User/PatchUserContactEndpoint.cs

@@ -0,0 +1,47 @@
+using FastEndpoints;
+using Knots.DTO.User;
+using Microsoft.EntityFrameworkCore;
+
+namespace Knots.Endpoints.User;
+
+public class PatchUserContactEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint<UpdateUserContactDto>
+{
+    public override void Configure()
+    {
+        Patch("/users/{@Id}/contact/", x => new {x.Id});
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(UpdateUserContactDto req, CancellationToken ct)
+    {
+        Models.User? databaseUser = await db.Users.SingleOrDefaultAsync(x => x.Id == req.Id, cancellationToken: ct);
+
+        if (databaseUser is null)
+        {
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+
+        if (databaseUser.Email != req.Email)
+        {
+            databaseUser.Email = req.Email;
+        }
+        else
+        {
+            databaseUser.Email = databaseUser.Email;
+        }
+
+        if (databaseUser.Tel != req.Tel)
+        {
+            databaseUser.Tel = req.Tel;
+        }else
+        {
+            databaseUser.Tel = databaseUser.Tel;
+        }
+        
+        mapper.Map(req, databaseUser);
+
+        await db.SaveChangesAsync(ct);
+        await Send.NoContentAsync(ct);
+    }
+}

Knots/Endpoints/User/PatchUserDescriptionEndpoint.cs

@@ -0,0 +1,30 @@
+using FastEndpoints;
+using Knots.DTO.User;
+using Microsoft.EntityFrameworkCore;
+
+namespace Knots.Endpoints.User;
+
+public class PatchUserDescriptionEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint<UpdateUserDescriptionDto>
+{
+    public override void Configure()
+    {
+        Patch("/users/{@Id}/description/");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(UpdateUserDescriptionDto req, CancellationToken ct)
+    {
+        Models.User? databaseUser = await db.Users.SingleOrDefaultAsync(x => x.Id == req.Id, cancellationToken: ct);
+
+        if (databaseUser is null)
+        {
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+        
+        mapper.Map(req, databaseUser);
+
+        await db.SaveChangesAsync(ct);
+        await Send.NoContentAsync(ct);
+    }
+}

Knots/Endpoints/User/PatchUserPasswordEndpoint.cs

@@ -0,0 +1,30 @@
+using FastEndpoints;
+using Knots.DTO.User;
+using Microsoft.EntityFrameworkCore;
+
+namespace Knots.Endpoints.User;
+
+public class PatchUserPasswordEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint<UpdateUserPasswordDto>
+{
+    public override void Configure()
+    {
+        Patch("/users/{@Id}/password/", x => new {x.Id});
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(UpdateUserPasswordDto req, CancellationToken ct)
+    {
+        Models.User? databaseUser = await db.Users.SingleOrDefaultAsync(x => x.Id == req.Id, cancellationToken: ct);
+
+        if (databaseUser is null)
+        {
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+        
+        mapper.Map(req, databaseUser);
+
+        await db.SaveChangesAsync(ct);
+        await Send.NoContentAsync(ct);
+    }
+}

Knots/Endpoints/User/PatchUserProfilePictureEndpoint.cs

@@ -0,0 +1,30 @@
+using FastEndpoints;
+using Knots.DTO.User;
+using Microsoft.EntityFrameworkCore;
+
+namespace Knots.Endpoints.User;
+
+public class PatchUserProfilePictureEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint<UpdateUserProfilePictureDto>
+{
+    public override void Configure()
+    {
+        Patch("/users/{@Id}/profilepicture/");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(UpdateUserProfilePictureDto req, CancellationToken ct)
+    {
+        Models.User? databaseUser = await db.Users.SingleOrDefaultAsync(x => x.Id == req.Id, cancellationToken: ct);
+
+        if (databaseUser is null)
+        {
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+        
+        mapper.Map(req, databaseUser);
+
+        await db.SaveChangesAsync(ct);
+        await Send.NoContentAsync(ct);
+    }
+}

Knots/Endpoints/User/PatchUsernameEndpoint.cs

@@ -0,0 +1,31 @@
+using FastEndpoints;
+using Knots.DTO.User;
+using Microsoft.EntityFrameworkCore;
+
+namespace Knots.Endpoints.User;
+
+
+public class PatchUsernameEndpoint(KnotsDbContext db, AutoMapper.IMapper mapper) : Endpoint<UpdateUsernameDto>
+{
+    public override void Configure()
+    {
+        Patch("/users/{@Id}/username/");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(UpdateUsernameDto req, CancellationToken ct)
+    {
+        Models.User? databaseUser = await db.Users.SingleOrDefaultAsync(x => x.Id == req.Id, cancellationToken: ct);
+
+        if (databaseUser is null)
+        {
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+        
+        mapper.Map(req, databaseUser);
+
+        await db.SaveChangesAsync(ct);
+        await Send.NoContentAsync(ct);
+    }
+}

Knots/Knots.csproj

@@ -1,19 +1,28 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
     <PropertyGroup>
-        <TargetFramework>net9.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
         <Nullable>enable</Nullable>
         <ImplicitUsings>enable</ImplicitUsings>
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="9.0.8"/>
+        <PackageReference Include="AutoMapper" Version="16.1.1" />
+        <PackageReference Include="FastEndpoints" Version="8.0.1" />
+        <PackageReference Include="FastEndpoints.Swagger" Version="8.0.1" />
+        <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="8.0.25" />
+        <PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.25" />
+        <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="8.0.25">
+          <PrivateAssets>all</PrivateAssets>
+          <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+        <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="8.0.25" />
+        <PackageReference Include="Swashbuckle.AspNetCore" Version="10.1.7" />
     </ItemGroup>
 
     <ItemGroup>
-      <Folder Include="DTO\" />
       <Folder Include="Endpoints\" />
-      <Folder Include="Validators\" />
+      <Folder Include="Migrations\" />
     </ItemGroup>
 
 </Project>

Knots/KnotsDbContext.cs

@@ -0,0 +1,33 @@
+using Knots.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace Knots;
+
+public class KnotsDbContext : DbContext
+{
+    public DbSet<Discussion> Discussions { get; set; }
+    public DbSet<Group> Groups { get; set; }
+    public DbSet<Key> Keys { get; set; }
+    public DbSet<Message> Messages { get; set; }
+    public DbSet<Role> Roles { get; set; }
+    public DbSet<User> Users { get; set; }
+
+    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+    {
+        //Infos de connexion à la base de données
+        string connectionString =
+            "Server=romaric-thibault.fr;" +
+            "Database=knots;" +
+            "User Id=knots;" +
+            "Password=knots;" +
+            "TrustServerCertificate=true;";
+
+        optionsBuilder.UseSqlServer(connectionString);
+    }
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+
+    {
+        //Données à insérer
+    }
+}

Knots/Migrations/20260505083044_InitialDatabase.Designer.cs

@@ -0,0 +1,232 @@
+// <auto-generated />
+using System;
+using Knots;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Knots.Migrations
+{
+    [DbContext(typeof(KnotsDbContext))]
+    [Migration("20260505083044_InitialDatabase")]
+    partial class InitialDatabase
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.25")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("Knots.Models.Discussion", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("KeyId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Discussions");
+                });
+
+            modelBuilder.Entity("Knots.Models.Group", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("KeyId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("MembersAmount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("ProfilePicture")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Groups");
+                });
+
+            modelBuilder.Entity("Knots.Models.Key", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("EnKey")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Keys");
+                });
+
+            modelBuilder.Entity("Knots.Models.Message", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Contenu")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("DiscussionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("GroupId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("KeyId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("Type")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DiscussionId");
+
+                    b.HasIndex("GroupId");
+
+                    b.HasIndex("KeyId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Messages");
+                });
+
+            modelBuilder.Entity("Knots.Models.Role", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Libelle")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Roles");
+                });
+
+            modelBuilder.Entity("Knots.Models.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasMaxLength(70)
+                        .HasColumnType("nvarchar(70)");
+
+                    b.Property<string>("Password")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ProfilePicture")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Tel")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("Knots.Models.Message", b =>
+                {
+                    b.HasOne("Knots.Models.Discussion", null)
+                        .WithMany("Messages")
+                        .HasForeignKey("DiscussionId");
+
+                    b.HasOne("Knots.Models.Group", "Group")
+                        .WithMany()
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Knots.Models.Key", "Key")
+                        .WithMany()
+                        .HasForeignKey("KeyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Knots.Models.User", "User")
+                        .WithMany("Messages")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Group");
+
+                    b.Navigation("Key");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Knots.Models.Discussion", b =>
+                {
+                    b.Navigation("Messages");
+                });
+
+            modelBuilder.Entity("Knots.Models.User", b =>
+                {
+                    b.Navigation("Messages");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Knots/Migrations/20260505083044_InitialDatabase.cs

@@ -0,0 +1,172 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Knots.Migrations
+{
+    /// <inheritdoc />
+    public partial class InitialDatabase : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Discussions",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    KeyId = table.Column<int>(type: "int", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Discussions", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Groups",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    Name = table.Column<string>(type: "nvarchar(50)", maxLength: 50, nullable: false),
+                    MembersAmount = table.Column<int>(type: "int", nullable: false),
+                    ProfilePicture = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    KeyId = table.Column<int>(type: "int", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Groups", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Keys",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    EnKey = table.Column<string>(type: "nvarchar(50)", maxLength: 50, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Keys", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Roles",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    Libelle = table.Column<string>(type: "nvarchar(50)", maxLength: 50, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Roles", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Users",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    Username = table.Column<string>(type: "nvarchar(50)", maxLength: 50, nullable: false),
+                    Description = table.Column<string>(type: "nvarchar(200)", maxLength: 200, nullable: true),
+                    Password = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    Email = table.Column<string>(type: "nvarchar(70)", maxLength: 70, nullable: false),
+                    Tel = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    ProfilePicture = table.Column<string>(type: "nvarchar(max)", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Users", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Messages",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    Contenu = table.Column<string>(type: "nvarchar(1000)", maxLength: 1000, nullable: false),
+                    Date = table.Column<DateTime>(type: "datetime2", nullable: false),
+                    Type = table.Column<bool>(type: "bit", nullable: false),
+                    GroupId = table.Column<int>(type: "int", nullable: false),
+                    KeyId = table.Column<int>(type: "int", nullable: false),
+                    UserId = table.Column<int>(type: "int", nullable: false),
+                    DiscussionId = table.Column<int>(type: "int", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Messages", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Messages_Discussions_DiscussionId",
+                        column: x => x.DiscussionId,
+                        principalTable: "Discussions",
+                        principalColumn: "Id");
+                    table.ForeignKey(
+                        name: "FK_Messages_Groups_GroupId",
+                        column: x => x.GroupId,
+                        principalTable: "Groups",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Messages_Keys_KeyId",
+                        column: x => x.KeyId,
+                        principalTable: "Keys",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Messages_Users_UserId",
+                        column: x => x.UserId,
+                        principalTable: "Users",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Messages_DiscussionId",
+                table: "Messages",
+                column: "DiscussionId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Messages_GroupId",
+                table: "Messages",
+                column: "GroupId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Messages_KeyId",
+                table: "Messages",
+                column: "KeyId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Messages_UserId",
+                table: "Messages",
+                column: "UserId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Messages");
+
+            migrationBuilder.DropTable(
+                name: "Roles");
+
+            migrationBuilder.DropTable(
+                name: "Discussions");
+
+            migrationBuilder.DropTable(
+                name: "Groups");
+
+            migrationBuilder.DropTable(
+                name: "Keys");
+
+            migrationBuilder.DropTable(
+                name: "Users");
+        }
+    }
+}

Knots/Migrations/KnotsDbContextModelSnapshot.cs

@@ -0,0 +1,229 @@
+// <auto-generated />
+using System;
+using Knots;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Knots.Migrations
+{
+    [DbContext(typeof(KnotsDbContext))]
+    partial class KnotsDbContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.25")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("Knots.Models.Discussion", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("KeyId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Discussions");
+                });
+
+            modelBuilder.Entity("Knots.Models.Group", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("KeyId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("MembersAmount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("ProfilePicture")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Groups");
+                });
+
+            modelBuilder.Entity("Knots.Models.Key", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("EnKey")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Keys");
+                });
+
+            modelBuilder.Entity("Knots.Models.Message", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Contenu")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("DiscussionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("GroupId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("KeyId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("Type")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DiscussionId");
+
+                    b.HasIndex("GroupId");
+
+                    b.HasIndex("KeyId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Messages");
+                });
+
+            modelBuilder.Entity("Knots.Models.Role", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Libelle")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Roles");
+                });
+
+            modelBuilder.Entity("Knots.Models.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasMaxLength(70)
+                        .HasColumnType("nvarchar(70)");
+
+                    b.Property<string>("Password")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ProfilePicture")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Tel")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("Knots.Models.Message", b =>
+                {
+                    b.HasOne("Knots.Models.Discussion", null)
+                        .WithMany("Messages")
+                        .HasForeignKey("DiscussionId");
+
+                    b.HasOne("Knots.Models.Group", "Group")
+                        .WithMany()
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Knots.Models.Key", "Key")
+                        .WithMany()
+                        .HasForeignKey("KeyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Knots.Models.User", "User")
+                        .WithMany("Messages")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Group");
+
+                    b.Navigation("Key");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Knots.Models.Discussion", b =>
+                {
+                    b.Navigation("Messages");
+                });
+
+            modelBuilder.Entity("Knots.Models.User", b =>
+                {
+                    b.Navigation("Messages");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Knots/Models/Discussion.cs

@@ -0,0 +1,11 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Knots.Models;
+
+public class Discussion
+{
+    [Key] public int Id { get; set; }
+    
+    public List<Message> Messages { get; set; }
+    public int KeyId { get; set; }
+}

Knots/Models/Group.cs

@@ -0,0 +1,15 @@
+using System.ComponentModel.DataAnnotations;
+using System.Net.Mime;
+
+namespace Knots.Models;
+
+public class Group
+{
+    [Key] public int Id { get; set; }
+    [Required, MaxLength(50)] public string? Name { get; set; }
+    [Required] public int MembersAmount { get; set; }
+    public string? ProfilePicture { get; set; }
+    public int KeyId { get; set; }
+    List<Message> Messages { get; set; }
+    List<User> Users { get; set; }
+}

Knots/Models/Key.cs

@@ -0,0 +1,10 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Knots.Models;
+
+public class Key
+{
+    [Key] public int Id { get; set; }
+    [Required, MaxLength(50)] public string? EnKey { get; set; }
+    List<Message> Messages { get; set; }
+}

Knots/Models/Message.cs

@@ -0,0 +1,14 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Knots.Models;
+
+public class Message
+{
+    [Key] public int Id { get; set; }
+    [Required, MaxLength(1000)] public string? Contenu { get; set; }
+    [Required] public DateTime Date { get; set; }
+    [Required] public Boolean Type { get; set; }
+    public Group Group { get; set; }
+    public Key Key { get; set; }
+    public User User { get; set; }
+}

Knots/Models/Role.cs

@@ -0,0 +1,9 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Knots.Models;
+
+public class Role
+{
+    public int Id { get; set; }
+    [Required, MaxLength(50)] public string? Libelle { get; set; }
+}

Knots/Models/User.cs

@@ -0,0 +1,15 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Knots.Models;
+
+public class User
+{
+      public int Id { get; set; }
+      [Required, MaxLength(50)] public string? Username { get; set; }
+      [MaxLength(200)] public string? Description {get; set;}
+      [Required, Length(12, 50)] public string? Password { get; set; }
+      [Required, MaxLength(70)] public string? Email { get; set; }
+      [Required, Length(10, 10)] public string? Tel { get; set; }
+      public string? ProfilePicture { get; set; }
+      public List<Message> Messages { get; set; }
+}

Knots/Profiles/DiscussionProfile.cs

@@ -0,0 +1,17 @@
+using AutoMapper;
+using Knots.DTO.Discussion;
+using Knots.Models;
+
+namespace Knots.Profiles;
+
+public class DiscussionProfile : Profile
+{
+    public DiscussionProfile()
+    {
+        CreateMap<Discussion, GetDiscussionDto>();
+        CreateMap<Discussion, CreateDiscussionDto>();
+        
+        CreateMap<CreateDiscussionDto, Discussion>();
+        
+    }
+}

Knots/Profiles/GroupProfile.cs

@@ -0,0 +1,15 @@
+using AutoMapper;
+using Knots.DTO.Group;
+using Knots.Models;
+
+namespace Knots.Profiles;
+
+public class GroupProfile : Profile
+{
+    public GroupProfile()
+    {
+        CreateMap<Group, GetGroupDto>();
+        CreateMap<Group, GetGroupDetailsDto>();
+        CreateMap<CreateGroupDto, Group>();
+    }
+}

Knots/Profiles/KeyProfile.cs

@@ -0,0 +1,16 @@
+using AutoMapper;
+using Knots.DTO.Discussion;
+using Knots.DTO.Key;
+using Knots.Models;
+
+namespace Knots.Profiles;
+
+public class KeyProfile : Profile
+{
+    public KeyProfile()
+    {
+        CreateMap<Key, GetKeyDetailsDto>();
+        CreateMap<Key, CreateKeyDto>();
+        CreateMap<CreateKeyDto, Key>();
+    }
+}

Knots/Profiles/MessageProfile.cs

@@ -0,0 +1,16 @@
+using AutoMapper;
+using Knots.DTO.Discussion;
+using Knots.DTO.Message;
+using Knots.Models;
+
+namespace Knots.Profiles;
+
+public class MessageProfile : Profile
+{
+    public MessageProfile()
+    {
+        CreateMap<Message, GetMessageDetailsDto>();
+        CreateMap<Message, CreateMessageDto>();
+        CreateMap<CreateMessageDto, Message>();
+    }
+}

Knots/Profiles/RoleProfile.cs

@@ -0,0 +1,16 @@
+using AutoMapper;
+using Knots.DTO.Discussion;
+using Knots.DTO.Role;
+using Knots.Models;
+
+namespace Knots.Profiles;
+
+public class RoleProfile : Profile
+{
+    public RoleProfile()
+    {
+        CreateMap<Role, GetRoleDto>();
+        CreateMap<Role, CreateRoleDto>();
+        CreateMap<CreateRoleDto, Role>();
+    }
+}

Knots/Profiles/UserProfile.cs

@@ -0,0 +1,29 @@
+using AutoMapper;
+using Knots.DTO.Discussion;
+using Knots.DTO.User;
+using Knots.Models;
+
+namespace Knots.Profiles;
+
+public class UserProfile : Profile
+{
+    public UserProfile()
+    {
+        CreateMap<User, GetUserDetailsDto>();
+        CreateMap<User, GetUserDto>();
+        CreateMap<CreateUserDto, User>();
+        CreateMap<UpdateUserDto, User>();
+        CreateMap<UpdateUserContactDto, User>();
+        CreateMap<UpdateUserDescriptionDto, User>();
+        CreateMap<UpdateUsernameDto, User>();
+        CreateMap<UpdateUserProfilePictureDto, User>();
+        CreateMap<UpdateUserPasswordDto, User>();
+        
+        CreateMap<User, UpdateUserContactDto>();
+        CreateMap<User, UpdateUserDto>();
+        CreateMap<User, UpdateUserDescriptionDto>();
+        CreateMap<User, UpdateUserProfilePictureDto>();
+        CreateMap<User, UpdateUserPasswordDto>();
+        CreateMap<User, CreateUserDto>();
+    }
+}

Knots/Program.cs

@@ -1,23 +1,48 @@
-var builder = WebApplication.CreateBuilder(args);
+using Knots;
+using FastEndpoints;
+using FastEndpoints.Swagger;
+using Microsoft.OpenApi;
 
-// Add services to the container.
+WebApplicationBuilder builder = WebApplication.CreateBuilder(args);
 
-builder.Services.AddControllers();
-// Learn more about configuring OpenAPI at https://aka.ms/aspnet/openapi
-builder.Services.AddOpenApi();
+// On ajoute ici la configuration de la base de données
+builder.Services.AddDbContext<KnotsDbContext>();
 
-var app = builder.Build();
+//On ajoute le CORS au code
+builder.Services.AddCors(options =>
+{ options.AddDefaultPolicy(policyBuilder =>
+    {
+        policyBuilder
+            .WithOrigins("http://localhost:5250/")
+            .WithMethods("GET", "POST", "PUT", "PATCH", "DELETE")
+            .AllowAnyHeader();
+    });
+});
 
-// Configure the HTTP request pipeline.
-if (app.Environment.IsDevelopment())
-{
-    app.MapOpenApi();
-}
+builder.Services.AddFastEndpoints();
+builder.Services.SwaggerDocument();
+
+builder.Services.AddAuthentication();
+builder.Services.AddAuthorization();
+
+builder.Services.AddAutoMapper(cfg => { }, typeof(Program).Assembly);
+
+// On construit l'application en lui donnant vie
+WebApplication app = builder.Build();
+
+app.UseCors();
+
+app.UseSwaggerGen();
+
+app.UseAuthentication()
+    .UseAuthorization()
+    .UseFastEndpoints(options => 
+        { 
+            options.Endpoints.RoutePrefix = "API";
+            options.Endpoints.ShortNames = true;
+        }
+    ).UseSwaggerGen();
 
 app.UseHttpsRedirection();
 
-app.UseAuthorization();
-
-app.MapControllers();
-
 app.Run();

Knots/Validators/Discussion/CreateDiscussionDtoValidator.cs

@@ -0,0 +1,15 @@
+using FastEndpoints;
+using FluentValidation;
+using Knots.DTO.Discussion;
+
+namespace Knots.Validators.Discussion;
+
+public class CreateDiscussionDtoValidator : Validator<CreateDiscussionDto>
+{
+    public CreateDiscussionDtoValidator()
+    {
+        RuleFor(x => x.Id)
+            .NotEmpty()
+            .WithMessage("Id is required");
+    }
+}

Knots/Validators/Discussion/DeleteDiscussionDtoValidator.cs

@@ -0,0 +1,15 @@
+using FastEndpoints;
+using FluentValidation;
+using Knots.DTO.Discussion;
+
+namespace Knots.Validators.Discussion;
+
+public class DeleteDiscussionDtoValidator : Validator<DeleteDiscussionDto>
+{
+    public DeleteDiscussionDtoValidator()
+    {
+        RuleFor(x => x.Id)
+            .NotEmpty()
+            .WithMessage("Id is required");
+    }
+}

Knots/Validators/Group/CreateGroupDtoValidator.cs

@@ -0,0 +1,21 @@
+using FastEndpoints;
+using FluentValidation;
+using Knots.DTO.Group;
+
+namespace Knots.Validators.Group;
+
+public class CreateGroupDtoValidator : Validator<CreateGroupDto>
+{
+    public CreateGroupDtoValidator()
+    {
+        RuleFor(x => x.Nom)
+            .NotEmpty()
+            .WithMessage("You must enter a name for the group")
+            .MaximumLength(50)
+            .WithMessage("Maximum 50 character are required");
+
+        RuleFor(x => x.NombreMembres)
+            .NotEmpty()
+            .WithMessage("Members cannot be empty");
+    }
+}

Knots/Validators/Group/DeleteGroupDtoValidator.cs

@@ -0,0 +1,17 @@
+using FastEndpoints;
+using FluentValidation;
+using Knots.DTO.Group;
+
+namespace Knots.Validators.Group;
+
+public class DeleteGroupDtoValidator : Validator<DeleteGroupDto>
+{
+    public  DeleteGroupDtoValidator()
+    {
+        RuleFor(x => x.Id)
+            .NotEmpty()
+            .WithMessage("Id is required")
+            .GreaterThan(0)
+            .WithMessage("Id cannot be less than zero");
+    }
+}   

Knots/Validators/Group/GetGroupDtoValidator.cs

@@ -0,0 +1,15 @@
+using FastEndpoints;
+using FluentValidation;
+using Knots.DTO.Group;
+
+namespace Knots.Validators.Group;
+
+public class GetGroupDtoValidator : Validator<GetGroupDto>
+{
+    public  GetGroupDtoValidator()
+    {
+        RuleFor(x => x.Id)
+            .NotEmpty()
+            .WithMessage("Id cannot be empty");
+    }
+}

Knots/Validators/Group/UpdateGroupDtoValidator.cs

@@ -0,0 +1,9 @@
+using FastEndpoints;
+using Knots.DTO.Group;
+
+namespace Knots.Validators.Group;
+
+public class UpdateGroupDtoValidator : Validator<UpdateGroupDto>
+{
+    
+}

Knots/Validators/Group/UpdateGroupMembersAmountDtoValidator.cs

@@ -0,0 +1,21 @@
+using FastEndpoints;
+using FluentValidation;
+using Knots.DTO.Group;
+
+namespace Knots.Validators.Group;
+
+public class UpdateGroupMembersAmountDtoValidator : Validator<UpdateGroupMembersAmountDto>
+{
+    public UpdateGroupMembersAmountDtoValidator()
+    {
+        RuleFor(x => x.Id)
+            .NotEmpty()
+            .WithMessage("L'id est requis")
+            .GreaterThan(0)
+            .WithMessage("L'id doit être supérieur à 0");
+
+        RuleFor(x => x.MembersAmount)
+            .NotEmpty()
+            .WithMessage("Le nombre de membres est requis");
+    }
+}

Knots/Validators/Group/UpdateGroupNameDtoValidator.cs

@@ -0,0 +1,20 @@
+using FastEndpoints;
+using FluentValidation;
+using Knots.DTO.Group;
+
+namespace Knots.Validators.Group;
+
+public class UpdateGroupNameDtoValidator : Validator<UpdateGroupNameDto>
+{
+    public  UpdateGroupNameDtoValidator()
+    {
+        RuleFor(x => x.Id)
+            .NotNull()
+            .WithMessage("L'id doit être renseigné");
+        
+        
+        RuleFor(x => x.Name)
+            .NotEmpty()
+            .WithMessage("Le nom de groupe est requis");
+    }
+}

Knots/Validators/Key/CreateKeyDtoValidator.cs

@@ -0,0 +1,15 @@
+using FastEndpoints;
+using FluentValidation;
+using Knots.DTO.Key;
+
+namespace Knots.Validators.Key;
+
+public class CreateKeyDtoValidator : Validator<CreateKeyDto>
+{
+    public CreateKeyDtoValidator()
+    {
+        RuleFor(x => x.EnKey)
+            .NotEmpty()
+            .WithMessage("La clé de chiffrement ne doit pas être nulle.");
+    }
+}

Knots/Validators/Key/DeleteKeyDtoValidator.cs

@@ -0,0 +1,17 @@
+using FastEndpoints;
+using FluentValidation;
+using Knots.DTO.Key;
+
+namespace Knots.Validators.Key;
+
+public class DeleteKeyDtoValidator : Validator<DeleteKeyDto>
+{
+    public DeleteKeyDtoValidator()
+    {
+        RuleFor(x => x.Id)
+            .NotEmpty()
+            .WithMessage("L'id doit être renseigné")
+            .GreaterThan(0)
+            .WithMessage("L'id renseigné doit être supérieur à 0");
+    }
+}

Knots/Validators/Key/GetKeyDtoValidator.cs

@@ -0,0 +1,17 @@
+using FastEndpoints;
+using FluentValidation;
+using Knots.DTO.Key;
+
+namespace Knots.Validators.Key;
+
+public class GetKeyDtoValidator : Validator<GetKeyDto>
+{
+    public GetKeyDtoValidator()
+    {
+        RuleFor(x => x.Id)
+            .NotEmpty()
+            .WithMessage("L'id est requis")
+            .GreaterThan(0)
+            .WithMessage("L'id doit être supérieur à 0");
+    }
+}

Knots/Validators/Message/CreateMessageDtoValidator.cs

@@ -0,0 +1,26 @@
+using FastEndpoints;
+using FluentValidation;
+using Knots.DTO.Message;
+
+namespace Knots.Validators.Message;
+
+public class CreateMessageDtoValidator : Validator<CreateMessageDto>
+{
+    public CreateMessageDtoValidator()
+    {
+        RuleFor(x => x.Contenu)
+            .NotEmpty()
+            .WithMessage("Le message ne peux pas être vide")
+            .MaximumLength(1000)
+            .WithMessage("Le message ne doit pas faire plus de 1000 caractères");
+        
+        RuleFor(x => x.Date)
+            .NotEmpty()
+            .WithMessage("La date ne peut pas être vide");
+
+        RuleFor(x => x.Type)
+            .NotEmpty()
+            .WithMessage("Le type de message doit être renseigné");
+
+    }
+}

Knots/Validators/Message/DeleteMessageDtoValidator.cs

@@ -0,0 +1,6 @@
+namespace Knots.Validators.Message;
+
+public class DeleteMessageDtoValidator
+{
+    
+}

Knots/Validators/Message/GetMessageDtoValidator.cs

@@ -0,0 +1,6 @@
+namespace Knots.Validators.Message;
+
+public class GetMessageDtoValidator
+{
+    
+}

Knots/Validators/Message/UpdateMessagesDto.cs

@@ -0,0 +1,6 @@
+namespace Knots.Validators.Message;
+
+public class UpdateMessagesDto
+{
+    
+}

Knots/Validators/Role/CreateRoleDtoValidator.cs

@@ -0,0 +1,17 @@
+using FastEndpoints;
+using FluentValidation;
+using Knots.DTO.Role;
+
+namespace Knots.Validators.Role;
+
+public class CreateRoleDtoValidator : Validator<CreateRoleDto>
+{
+    public CreateRoleDtoValidator()
+    {
+        RuleFor(x => x.Libelle)
+            .NotEmpty()
+            .WithMessage("Libelle cannot be empty")
+            .MaximumLength(50)
+            .WithMessage("Libelle maximum length is 50");
+    }
+}

Knots/Validators/Role/DeleteRoleDtoValidator.cs

@@ -0,0 +1,15 @@
+using FastEndpoints;
+using FluentValidation;
+using Knots.DTO.Role;
+
+namespace Knots.Validators.Role;
+
+public class DeleteRoleDtoValidator : Validator<DeleteRoleDto>
+{
+    public DeleteRoleDtoValidator()
+    {
+        RuleFor(x => x.Id)
+            .NotEmpty()
+            .WithMessage("Id cannot be empty");
+    }
+}

Knots/Validators/Role/GetRoleDtoValidator.cs

@@ -0,0 +1,17 @@
+using FastEndpoints;
+using FluentValidation;
+using Knots.DTO.Role;
+
+namespace Knots.Validators.Role;
+
+public class GetRoleDtoValidator : Validator<GetRoleDto>
+{
+    public GetRoleDtoValidator()
+    {
+        RuleFor(x => x.Libelle)
+            .NotEmpty()
+            .WithMessage("Libelle cannot be empty")
+            .MaximumLength(50)
+            .WithMessage("Libelle maximum length is 50");
+    }
+}

Knots/Validators/User/CreateUserDtoValidator.cs

@@ -0,0 +1,6 @@
+namespace Knots.Validators.User;
+
+public class CreateUserDtoValidator
+{
+    
+}

Knots/Validators/User/DeleteUserDtoValidator.cs

@@ -0,0 +1,6 @@
+namespace Knots.Validators.User;
+
+public class DeleteUserDtoValidator
+{
+    
+}

Knots/Validators/User/GetUserDtoValidator.cs

@@ -0,0 +1,6 @@
+namespace Knots.Validators.User;
+
+public class GetUserDtoValidator
+{
+    
+}

Knots/Validators/User/UpdateUserContactDtoValidator.cs

@@ -0,0 +1,27 @@
+using FastEndpoints;
+using FluentValidation;
+using Knots.DTO.User;
+
+namespace Knots.Validators.User;
+
+public class UpdateUserContactDtoValidator : Validator<UpdateUserContactDto>
+{
+    public UpdateUserContactDtoValidator()
+    {
+        RuleFor(x => x.Id)
+            .NotEmpty()
+            .WithMessage("L'id est requis")
+            .GreaterThan(0)
+            .WithMessage("L'id doit être supérieur à 0");
+
+        RuleFor(x => x.Email)
+            .NotEmpty()
+            .WithMessage("L'email est requis")
+            .EmailAddress()
+            .WithMessage("Ce n'est pas un email valide");
+
+        RuleFor(x => x.Tel)
+            .NotEmpty()
+            .WithMessage("Le numéro de téléphone est requis");
+    }
+}