Merge branch 'QueryController'

API_SQLuedo/API/API.csproj

@@ -21,6 +21,7 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
     <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="8.0.0" />
     <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
   </ItemGroup>

API_SQLuedo/API/Controllers/QueryController.cs

@@ -0,0 +1,65 @@
+using Dto;
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Shared;
+using Model.OrderCriteria;
+
+namespace API.Controllers
+{
+    [Route("api/v{version:apiVersion}/[controller]")]
+    [Authorize]
+    [ApiVersion("1.0")]
+    [ApiController]
+    public class QueryController(ILogger<QueryController> logger, IQueryService<QueryDto> queryService) : ControllerBase
+    {
+        [HttpPost("{database}/execute")]
+        [ProducesResponseType(typeof(QueryDto), 200)]
+        [ProducesResponseType(typeof(string), 204)]
+        public IActionResult ExecuteQuery([FromBody]string query, string database)
+        {
+            var queryResult = queryService.ExecuteQuery(query, database);
+            if (queryResult == null)
+            {
+                logger.LogError("[ERREUR] La requête n'a rien renvoyé.");
+                return StatusCode(204);
+            }
+
+            logger.LogInformation("[INFORMATION] La requête a renvoyé : {result} ", queryResult);
+            return Ok(queryResult);
+        }
+
+        [HttpGet("{database}/Tables")]
+        [ProducesResponseType(typeof(QueryDto), 200)]
+        [ProducesResponseType(typeof(string), 204)]
+        public IActionResult GetTables(string database)
+        {
+            var queryResult = queryService.GetTables(database);
+            if (queryResult == null)
+            {
+                logger.LogError("[ERREUR] La requête n'a rien renvoyé.");
+                return StatusCode(204);
+            }
+
+            logger.LogInformation("[INFORMATION] La requête a renvoyé : {result} ", queryResult);
+            return Ok(queryResult);
+        }
+
+
+        [HttpGet("{database}/{table}/Columns")]
+        [ProducesResponseType(typeof(QueryDto), 200)]
+        [ProducesResponseType(typeof(string), 204)]
+        public IActionResult GetColumns(string database,string table)
+        {
+            var queryResult = queryService.GetColumns(database,table);
+            if (queryResult == null)
+            {
+                logger.LogError("[ERREUR] La requête n'a rien renvoyé.");
+                return StatusCode(204);
+            }
+
+            logger.LogInformation("[INFORMATION] La requête a renvoyé : {result} ", queryResult);
+            return Ok(queryResult);
+        }
+    }
+}

API_SQLuedo/API/Program.cs

@@ -19,6 +19,8 @@ builder.Services.AddControllers();
 builder.Services.AddEndpointsApiExplorer();
 builder.Services.AddSwaggerGen();
 
+builder.Services.AddScoped<IQueryService<QueryDto>, QueryDataServiceApi>();
+
 builder.Services.AddScoped<IUserService<UserEntity>, UserDataService>();
 builder.Services.AddScoped<IUserService<UserDto>, UserDataServiceApi>();
 
@@ -102,6 +104,13 @@ builder.Services.AddCors(options =>
         });
 });
 
+var configuration = new ConfigurationBuilder()
+    .SetBasePath(Directory.GetCurrentDirectory())
+    .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
+    .Build();
+
+builder.Services.AddSingleton(configuration);
+
 
 var app = builder.Build();
 

API_SQLuedo/API/Service/QueryDataServiceApi.cs

@@ -0,0 +1,177 @@
+using Dto;
+using Entities;
+using Model.OrderCriteria;
+using Npgsql;
+using Shared;
+using Shared.Mapper;
+using Microsoft.Extensions.Configuration;
+using System.Text;
+using Newtonsoft.Json;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
+
+namespace API.Service;
+
+public class QueryDataServiceApi : IQueryService<QueryDto>{
+    private readonly IConfiguration _configuration;
+
+    public QueryDataServiceApi(IConfiguration configuration)
+    {
+        _configuration = configuration;
+    }
+    public QueryDto ExecuteQuery(string query, string database)
+    {
+        string connectionString = _configuration.GetConnectionString("DefaultConnection");
+        connectionString = connectionString.Replace("{database}", database);
+
+        if (string.IsNullOrEmpty(database))
+        {
+            return new QueryDto { Result = "Le nom de la base de données est requis." };
+        }
+
+        try
+        {
+            using (NpgsqlConnection connection = new NpgsqlConnection(connectionString))
+            {
+                connection.Open();
+                using (NpgsqlCommand command = new NpgsqlCommand(query, connection))
+                {
+                    using (NpgsqlDataReader reader = command.ExecuteReader())
+                    {
+                        List<Dictionary<string, object>> resultList = new List<Dictionary<string, object>>();
+
+
+                        List<string> columnNames = new List<string>();
+                        for (int i = 0; i < reader.FieldCount; i++)
+                        {
+                            columnNames.Add(reader.GetName(i));
+                        }
+
+                        while (reader.Read())
+                        {
+                            Dictionary<string, object> row = new Dictionary<string, object>();
+                            for (int i = 0; i < reader.FieldCount; i++)
+                            {
+                                row[columnNames[i]] = reader[i].ToString();
+                            }
+
+                            resultList.Add(row);
+                        }
+
+                        string resultJson = JsonConvert.SerializeObject(resultList);
+
+                        QueryDto queryDto = new QueryDto { Result = resultJson };
+                        return queryDto;
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            return new QueryDto { Result = ex.Message };
+        }
+    }
+
+    public QueryDto GetTables(string database)
+    {
+        string connectionString = _configuration.GetConnectionString("DefaultConnection");
+        connectionString = connectionString.Replace("{database}", database);
+
+        try
+        {
+            using (NpgsqlConnection connection = new NpgsqlConnection(connectionString))
+            {
+                connection.Open();
+                using (NpgsqlCommand command = new NpgsqlCommand())
+                {
+                    command.Connection = connection;
+                    // Donner et exclure les bonnes permissions au rôle en question
+
+                    // GRANT SELECT ON TABLE information_schema.tables TO votre_utilisateur;
+
+                    // GRANT SELECT ON TABLE information_schema.columns TO votre_utilisateur;
+
+                    // REVOKE ALL ON SCHEMA information_schema FROM PUBLIC;
+
+                    command.CommandText =
+                        "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public';";
+
+                    using (NpgsqlDataReader reader = command.ExecuteReader())
+                    {
+                        List<string> tableNames = new List<string>();
+
+                        while (reader.Read())
+                        {
+                            tableNames.Add(reader["table_name"].ToString());
+                        }
+
+                        Dictionary<string, string> tablesDict = new Dictionary<string, string>();
+                        foreach (string tableName in tableNames)
+                        {
+                            tablesDict[tableName] = tableName;
+                        }
+
+                        string tablesJson = JsonConvert.SerializeObject(tablesDict);
+
+                        QueryDto queryDto = new QueryDto { Result = tablesJson };
+                        return queryDto;
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            return new QueryDto { Result = ex.Message };
+        }
+    }
+
+    public QueryDto GetColumns(string database, string table)
+    {
+        string connectionString = _configuration.GetConnectionString("DefaultConnection");
+        connectionString = connectionString.Replace("{database}", database);
+
+        using (NpgsqlConnection connection = new NpgsqlConnection(connectionString))
+            {
+                connection.Open();
+                using (NpgsqlCommand command = new NpgsqlCommand())
+                {
+                    command.Connection = connection;
+                    // Donner et exclure les bonnes permissions au rôle en question
+
+                    //GRANT SELECT ON TABLE information_schema.tables TO votre_utilisateur;
+
+                    //GRANT SELECT ON TABLE information_schema.columns TO votre_utilisateur;
+
+                    //REVOKE ALL ON SCHEMA information_schema FROM PUBLIC;
+
+                    command.CommandText =
+                        $"SELECT column_name FROM information_schema.columns WHERE table_name = '{table}';";
+
+                    Console.WriteLine(command.CommandText);
+
+                    using (NpgsqlDataReader reader = command.ExecuteReader())
+                    {
+                        List<string> columnsNames = new List<string>();
+
+                        while (reader.Read())
+                        {
+                            columnsNames.Add(reader["column_name"].ToString());
+                        }
+
+                        Dictionary<string, string> columnsDict = new Dictionary<string, string>();
+                        foreach (string colName in columnsNames)
+                        {
+                            columnsDict[colName] = colName;
+                        }
+
+                        string tablesJson = JsonConvert.SerializeObject(columnsDict);
+
+                        Console.WriteLine(tablesJson);
+
+                        QueryDto queryDto = new QueryDto { Result = tablesJson };
+                        return queryDto;
+                    }
+                }
+            }
+        
+    }
+}

API_SQLuedo/API/appsettings.json

@@ -5,5 +5,8 @@
       "Microsoft.AspNetCore": "Warning"
     }
   },
-  "AllowedHosts": "*"
+  "AllowedHosts": "*",
+  "ConnectionStrings": {
+    "DefaultConnection": "Host=localhost;Username=admin;Password=motdepasse;Database={database}"
+  }
 }

API_SQLuedo/Dto/QueryDTO.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Dto
+{
+    public class QueryDto
+    {
+        public string Result { get; set; }
+    }
+}

API_SQLuedo/Shared/IQueryService.cs

@@ -0,0 +1,18 @@
+using Microsoft.AspNetCore.Mvc;
+using Model.OrderCriteria;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Dto;
+
+namespace Shared
+{
+    public interface IQueryService<TQuery>
+    {
+        public TQuery ExecuteQuery(string query, string database);
+        public QueryDto GetTables(string database);
+        public QueryDto GetColumns(string database,string table);
+    }
+}

API_SQLuedo/Shared/Mapper/LessonMapper.cs

@@ -16,10 +16,6 @@ public static class LessonMapper
         return new LessonDto(model.Id, model.Title, model.LastPublisher, model.LastEdit, model.Content.Select(c => c.FromEntityToDto()).ToList());
     }
     
-    public static LessonDto FromEntityToDtoPost(this LessonEntity model)
-    {
-        return new LessonDto(model.Id, model.Title, model.LastPublisher, model.LastEdit);
-    }
 
     public static LessonEntity FromModelToEntity(this Lesson model)
     {

API_SQLuedo/TestAPI/BlackListUnitTest.cs

@@ -153,7 +153,24 @@ public class BlackListUnitTest
             Assert.True(GetBlackList().SequenceEqual(valeur as IEnumerable<BlackListDto>, new BlackListDtoEqualityComparer()));
         }
     }
-    
+
+    [Fact]
+    public void Get_0_BannedUsers_OrderedByNone()
+    {
+        _blackListService.Setup(x => x.GetBannedUsers(1, 10, BlackListOdrerCriteria.None))
+            .Returns(new List<BlackListDto>());
+        var blackListController = new BlackListController(new NullLogger<UsersController>(), _blackListService.Object);
+
+        var result = blackListController.GetBannedUsers(1, 10, BlackListOdrerCriteria.None);
+        Assert.Equal(typeof(StatusCodeResult), result.GetType());
+        if (result is NotFoundObjectResult notFoundObjectResult)
+        {
+            var valeur = notFoundObjectResult.Value;
+
+            Assert.NotNull(valeur);
+        }
+    }
+
     [Fact]
     public void GetNbBannedUsers()
     {

API_SQLuedo/TestAPI/LessonUnitTest.cs

@@ -5,6 +5,7 @@ using Microsoft.Extensions.Logging.Abstractions;
 using Moq;
 using Shared;
 using TestAPI.Extensions;
+using Xunit.Sdk;
 
 namespace TestAPI;
 
@@ -101,6 +102,22 @@ public class LessonUnitTest
         }
     }
 
+    [Fact]
+    public void GetLessonIdFail_Argument_Exception()
+    {
+        _lessonService.Setup(x => x.GetLessonById(10000))
+            .Throws<ArgumentException>();
+        var lessonsController = new LessonsController(_lessonService.Object, new NullLogger<LessonsController>());
+
+        var result = lessonsController.GetLessonById(10000);
+
+        if (result is NotFoundObjectResult nfObjectResult)
+        {
+            Assert.NotNull(nfObjectResult);
+        }
+    }
+
+
     [Fact]
     public void GetLessonTitleSuccess()
     {
@@ -145,6 +162,21 @@ public class LessonUnitTest
         }
     }
 
+    [Fact]
+    public void GetLessonTitleFail_Argument_Exception()
+    {
+        _lessonService.Setup(x => x.GetLessonByTitle("title"))
+            .Throws<ArgumentException>();
+        var lessonsController = new LessonsController(_lessonService.Object, new NullLogger<LessonsController>());
+
+        var result = lessonsController.GetLessonByTitle("title");
+
+        if (result is NotFoundObjectResult nfObjectResult)
+        {
+            Assert.NotNull(nfObjectResult);
+        }
+    }
+
     [Fact]
     public void DeleteLessonSuccess()
     {
@@ -213,6 +245,21 @@ public class LessonUnitTest
         }
     }
 
+    [Fact]
+    public void CreateLessonFail_Argument_Exception()
+    {
+        _lessonService.Setup(x => x.CreateLesson(35672653, "duehduheudheu nouveau titre", "Le deudhe éditeur", new DateOnly(2024, 03, 16)))
+            .Throws<ArgumentException>();
+        var lessonsController = new LessonsController(_lessonService.Object, new NullLogger<LessonsController>());
+
+        var result = lessonsController.CreateLesson(new LessonDto(35672653, "duehduheudheu nouveau titre", "Le deudhe éditeur", new DateOnly(2024, 03, 16)));
+
+        if (result is NotFoundObjectResult nfObjectResult)
+        {
+            Assert.NotNull(nfObjectResult);
+        }
+    }
+
     [Fact]
     public void UpdateLessonSuccess()
     {

API_SQLuedo/TestAPI/QueryUnitTest.cs

@@ -0,0 +1,206 @@
+using API.Controllers;
+using Castle.Components.DictionaryAdapter.Xml;
+using Dto;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Shared;
+using TestAPI.Extensions;
+
+namespace TestAPI;
+
+public class QueryUnitTest
+{
+    private readonly Mock<IQueryService<QueryDto>> _queryService;
+
+    public QueryUnitTest()
+    {
+        _queryService = new Mock<IQueryService<QueryDto>>();
+    }
+
+    [Fact]
+    public void Select_Users_Success()
+    {
+        var userList = GetUsersData();
+        _queryService.Setup(x => x.ExecuteQuery("Select * from \"User\";","SQLuedo"))
+            .Returns(new QueryDto{Result = userList.ToString()});
+        var queryController = new QueryController(new NullLogger<QueryController>(), _queryService.Object);
+
+        var queryResult = queryController.ExecuteQuery("Select * from \"User\";", "SQLuedo");
+
+        if (queryResult is OkObjectResult okObjectResult)
+        {
+            
+            Assert.NotNull(okObjectResult);
+        }
+    }
+
+    [Fact]
+    public void Select_Users_Failed_Cause_Database_Doesnt_Exists()
+    {
+        var userList = GetUsersData();
+        _queryService.Setup(x => x.ExecuteQuery("Select * from \"User\";", "SQLuedo"))
+            .Returns(new QueryDto { Result = userList.ToString() });
+        var queryController = new QueryController(new NullLogger<QueryController>(), _queryService.Object);
+
+        var queryResult = queryController.ExecuteQuery("Select * from \"User\";", "LABASEDEDONNEES");
+
+        if (queryResult is StatusCodeResult statusCodeResult && statusCodeResult.StatusCode == 204)
+
+        {
+            Assert.IsNotType<OkObjectResult>(queryResult);
+        }
+    }
+
+    [Fact]
+    public void Get_Tables_Success()
+    {
+        var tablesList = GetTables();
+        _queryService.Setup(x => x.GetTables("SQLuedo"))
+            .Returns(new QueryDto { Result = tablesList.ToString() });
+        var queryController = new QueryController(new NullLogger<QueryController>(), _queryService.Object);
+
+        var queryResult = queryController.GetTables("SQLuedo");
+
+        if (queryResult is OkObjectResult okObjectResult)
+        {
+
+            Assert.NotNull(okObjectResult);
+        }
+    }
+
+    [Fact]
+    public void Get_Tables_Failed_Cause_Database_Doesnt_Exist()
+    {
+        var tablesList = GetTables();
+        _queryService.Setup(x => x.GetTables("SQLuedo"))
+            .Returns(new QueryDto { Result = tablesList.ToString() });
+        var queryController = new QueryController(new NullLogger<QueryController>(), _queryService.Object);
+
+        var queryResult = queryController.GetTables("LABSEEEEEEEEEEEEEEEEEEEE");
+
+        if (queryResult is OkObjectResult okObjectResult)
+        {
+
+            Assert.NotNull(okObjectResult);
+        }
+    }
+
+
+    [Fact]
+    public void Get_Columns_Success()
+    {
+        var tablesList = GetColumns();
+        _queryService.Setup(x => x.GetColumns("SQLuedo","User"))
+            .Returns(new QueryDto { Result = tablesList.ToString() });
+        var queryController = new QueryController(new NullLogger<QueryController>(), _queryService.Object);
+
+        var queryResult = queryController.GetColumns("SQLuedo","User");
+
+        if (queryResult is OkObjectResult okObjectResult)
+        {
+
+            Assert.NotNull(okObjectResult);
+        }
+    }
+
+    [Fact]
+    public void Get_Columns_Failed_Cause_Database_Doesnt_Exist()
+    {
+        var tablesList = GetColumns();
+        _queryService.Setup(x => x.GetColumns("SQLuedo", "User"))
+            .Returns(new QueryDto { Result = tablesList.ToString() });
+        var queryController = new QueryController(new NullLogger<QueryController>(), _queryService.Object);
+
+        var queryResult = queryController.GetColumns("UDHUE", "User");
+
+        if (queryResult is OkObjectResult okObjectResult)
+        {
+
+            Assert.NotNull(okObjectResult);
+        }
+    }
+
+    [Fact]
+    public void Get_Columns_Failed_Cause_Table_Doesnt_Exist()
+    {
+        var tablesList = GetColumns();
+        _queryService.Setup(x => x.GetColumns("SQLuedo", "User"))
+            .Returns(new QueryDto { Result = tablesList.ToString() });
+        var queryController = new QueryController(new NullLogger<QueryController>(), _queryService.Object);
+
+        var queryResult = queryController.GetColumns("SQLuedo", "GEGEIU");
+
+        if (queryResult is OkObjectResult okObjectResult)
+        {
+
+            Assert.NotNull(okObjectResult);
+        }
+    }
+
+
+    private List<UserDto> GetUsersData()
+    {
+        List<UserDto> usersData = new List<UserDto>(4)
+        {
+            new(
+                0,
+                "Useruser",
+                "motdepasse",
+                "adressemail@gmail.com",
+                true
+            ),
+            new
+            (
+                1,
+                "Leuser",
+                "motdepasse",
+                "deuxadresse@gmail.com",
+                false
+            ),
+            new
+            (
+                2,
+                "gygyggyg",
+                "ennodlavehc",
+                "thirdadress@gmail.com",
+                false
+            ),
+            new
+            (
+                "ferferf",
+                "h_nh_78",
+                "fourthadress@gmail.com",
+                false
+            ),
+        };
+        return usersData;
+    }
+
+
+    private List<string> GetColumns()
+    {
+        List<string> columns = new List<string>(4)
+        {
+            "Id",
+            "Name",
+            "Password",
+            "IsAdmin"
+        };
+        return columns;
+    }
+
+
+
+    private List<string> GetTables()
+    {
+        List<string> columns = new List<string>(4)
+        {
+            "User",
+            "Solution",
+            "Inquiry",
+            "Success"
+        };
+        return columns;
+    }
+}

API_SQLuedo/TestAPI/SuccessesUnitTest.cs

@@ -145,6 +145,23 @@ public class SuccessesUnitTest
         }
     }
 
+    [Fact]
+    public void GetSuccessInquiryIdFail_Argument_Exception()
+    {
+        _successService.Setup(x => x.GetSuccessesByInquiryId(1000))
+            .Throws<ArgumentException>();
+        var successesController =
+            new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
+
+        var sucessesResult = successesController.GetSuccessByInquiryId(1000);
+        if (sucessesResult is NotFoundObjectResult nfObjectResult)
+        {
+            var valeur = nfObjectResult.Value;
+
+            Assert.NotNull(valeur);
+        }
+    }
+
     [Fact]
     public void GetSuccessUserIdSuccess()
     {
@@ -217,6 +234,23 @@ public class SuccessesUnitTest
         }
     }
 
+    [Fact]
+    public void GetSuccessUserIdFail_Argument_Exception()
+    {
+        _successService.Setup(x => x.GetSuccessesByUserId(1000))
+            .Throws<ArgumentException>();
+        var successesController =
+            new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
+
+        var sucessesResult = successesController.GetSuccessByUserId(1000);
+        if (sucessesResult is NotFoundObjectResult nfObjectResult)
+        {
+            var valeur = nfObjectResult.Value;
+
+            Assert.NotNull(valeur);
+        }
+    }
+
     [Fact]
     public void DeleteSuccessSuccess()
     {
@@ -318,6 +352,22 @@ public class SuccessesUnitTest
         }
     }
 
+    [Fact]
+    public void CreateSuccessFail_Exception()
+    {
+        _successService.Setup(x => x.CreateSuccess(89889, 82837, true))
+            .Throws<Exception>();
+        var successesController =
+            new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
+
+        var successesResult = successesController.CreateSuccess(new SuccessDto(89889, 82837, true));
+
+        if (successesResult is NotFoundObjectResult notFoundObjectResult)
+        {
+            Assert.NotNull(notFoundObjectResult);
+        }
+    }
+
     [Fact]
     public void UpdateSuccessSuccess()
     {
@@ -386,6 +436,22 @@ public class SuccessesUnitTest
         }
     }
 
+    [Fact]
+    public void UpdateSuccessFail_Throw_Exception()
+    {
+        _successService.Setup(x => x.UpdateSuccess(108871, 117683, new SuccessDto(1, 2, true)))
+            .Throws<Exception>();
+        var successesController =
+            new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
+
+        var successesResult = successesController.UpdateSuccess(108871, 117683, new SuccessDto(1, 2, true));
+
+        if (successesResult is NotFoundObjectResult notFoundObjectResult)
+        {
+            Assert.NotNull(notFoundObjectResult);
+        }
+    }
+
 
 
     private List<SuccessDto> GetSuccessesData()

API_SQLuedo/TestAPI/TestAPI.csproj

@@ -11,6 +11,7 @@
 
   <ItemGroup>
     <PackageReference Include="Asp.Versioning.Mvc" Version="8.0.0" />
+    <PackageReference Include="Docker.DotNet" Version="3.125.15" />
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.2" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="8.0.2">
       <PrivateAssets>all</PrivateAssets>

API_SQLuedo/TestAPI/UserUnitTest.cs

@@ -171,7 +171,7 @@ public class UserUnitTest
 
 
     [Fact]
-    public void GetUserIdFail__Argument_Exception_Negative_Id()
+    public void GetUserIdFail_Negative_Id()
     {
         var userList = GetUsersData();
         _userService.Setup(x => x.GetUserById(1))
@@ -189,6 +189,22 @@ public class UserUnitTest
         }
     }
 
+    [Fact]
+    public void GetUserIdFail_Argument_Exception()
+    {
+        _userService.Setup(x => x.GetUserById(10000))
+            .Throws<ArgumentException>();
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.GetUserById(10000);
+        if (userResult is NotFoundObjectResult nfObjectResult)
+        {
+            var valeur = nfObjectResult.Value;
+
+            Assert.NotNull(valeur);
+        }
+    }
+
     [Fact]
     public void GetUserUsernameSuccess()
     {
@@ -212,6 +228,22 @@ public class UserUnitTest
         }
     }
 
+    [Fact]
+    public void GetUserUsernameFail_Argument_Exception()
+    {
+        _userService.Setup(x => x.GetUserByUsername("Usererererrere"))
+            .Throws<ArgumentException>();
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.GetUserByUsername("Usererererrere");
+        if (userResult is NotFoundObjectResult nfObjectResult)
+        {
+            var valeur = nfObjectResult.Value;
+
+            Assert.NotNull(valeur);
+        }
+    }
+
     [Fact]
     public void GetUserEmailSuccess()
     {
@@ -308,6 +340,34 @@ public class UserUnitTest
         }
     }
 
+    [Fact]
+    public void DeleteUser_By_Username_Success()
+    {
+        _userService.Setup(x => x.DeleteUserByUsername("Damn"))
+            .Returns(true);
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.DeleteUserByUsername("Damn");
+        if (userResult is OkObjectResult okObjectResult)
+        {
+            Assert.Null(okObjectResult.Value);
+        }
+    }
+
+    [Fact]
+    public void DeleteUser_By_Username_Failed()
+    {
+        _userService.Setup(x => x.DeleteUserByUsername("IUDHEIUHDEHUDH"))
+            .Returns(false);
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.DeleteUserByUsername("IUDHEIUHDEHUDH");
+        if (userResult is NotFoundObjectResult notFoundObjectResult)
+        {
+            Assert.Null(notFoundObjectResult.Value);
+        }
+    }
+
     [Fact]
     public void CreateUserSuccess()
     {

API_SQLuedo/TestEF/Mapper/InquiryMapperUnitTest.cs

@@ -78,10 +78,10 @@ namespace TestEF.Mapper
         public void TestDtoToModel()
         {
             InquiryDto inquiry = new InquiryDto(_id, _title, _description, _isUser);
-            var inquiryMod = inquiry.FromDtoToEntity();
+            var inquiryMod = inquiry.FromDtoToModel();
 
             Assert.NotNull(inquiryMod);
-            Assert.IsType<InquiryEntity>(inquiryMod);
+            Assert.IsType<Inquiry>(inquiryMod);
             Assert.Equal(1, inquiryMod.Id);
             Assert.Equal(_title, inquiryMod.Title);
             Assert.Equal(_description, inquiryMod.Description);

API_SQLuedo/TestEF/Service/TestBlackListDataService.cs

@@ -109,7 +109,7 @@ public class TestBlackListDataService
     }
 
     [Fact]
-    public void GetBannedUser_Success_Positive_Value()
+    public void GetBannedUser_Success_Positive_Value_Ordered_None()
     {
         _dbContext.BlackLists.Add(new BlackListEntity { Email = "email@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
         _dbContext.BlackLists.Add(new BlackListEntity { Email = "eemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
@@ -119,6 +119,42 @@ public class TestBlackListDataService
         Assert.Equal(3, banResult.Count());
     }
 
+    [Fact]
+    public void GetBannedUser_Success_Positive_Value_Ordered_Email()
+    {
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "email@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eeemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.SaveChanges();
+        var banResult = _blackListDataService.GetBannedUsers(1, 3, BlackListOdrerCriteria.ByEmail);
+        Assert.Equal(3, banResult.Count());
+    }
+
+
+    [Fact]
+    public void GetBannedUser_Success_Positive_Value_Ordered_ExpirationDate()
+    {
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "email@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eeemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.SaveChanges();
+        var banResult = _blackListDataService.GetBannedUsers(1, 3, BlackListOdrerCriteria.ByExpirationDate);
+        Assert.Equal(3, banResult.Count());
+    }
+
+    [Fact]
+    public void GetBannedUser_Success_Positive_Value_Ordered_Default()
+    {
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "email@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eeemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.SaveChanges();
+        var banResult = _blackListDataService.GetBannedUsers(1, 3,default);
+        Assert.Equal(3, banResult.Count());
+    }
+
+
+
     [Fact]
     public void GetBannedUser_Success_Negative_Value()
     {

API_SQLuedo/TestEF/Service/TestInquiryDataService.cs

@@ -89,6 +89,45 @@ public class TestInquiryDataService
         Assert.Equal(2, result.Count());
     }
 
+    [Fact]
+    public void GetInquiries_OrderedById_ReturnsCorrectNumberOfInquiries()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 1, Title = "Test1", Description = "Desc1", IsUser = true });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 2, Title = "Test2", Description = "Desc2", IsUser = false });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 3, Title = "Test3", Description = "Desc3", IsUser = true });
+        _dbContext.SaveChanges();
+
+        var result = _inquiryDataService.GetInquiries(1, 2, InquiryOrderCriteria.ById);
+
+        Assert.Equal(2, result.Count());
+    }
+
+    [Fact]
+    public void GetInquiries_OrderedByDefault_ReturnsCorrectNumberOfInquiries()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 1, Title = "Test1", Description = "Desc1", IsUser = true });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 2, Title = "Test2", Description = "Desc2", IsUser = false });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 3, Title = "Test3", Description = "Desc3", IsUser = true });
+        _dbContext.SaveChanges();
+
+        var result = _inquiryDataService.GetInquiries(1, 2, default);
+
+        Assert.Equal(2, result.Count());
+    }
+
+    [Fact]
+    public void GetInquiries_OrderedDefault_ReturnsCorrectNumberOfInquiries()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 1, Title = "Test1", Description = "Desc1", IsUser = true });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 2, Title = "Test2", Description = "Desc2", IsUser = false });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 3, Title = "Test3", Description = "Desc3", IsUser = true });
+        _dbContext.SaveChanges();
+
+        var result = _inquiryDataService.GetInquiries(1, 2, default);
+
+        Assert.Equal(2, result.Count());
+    }
+
     [Fact]
     public void GetInquiryById_ReturnsCorrectInquiry()
     {