exlude some code from code coverage

Backend/Diligent.WebAPI.Business/HelperModels/DeleteCustomerRequest.cs

-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Diligent.WebAPI.Business.HelperModels
 {
+    [ExcludeFromCodeCoverage]
     public class DeleteCustomerRequest
     {
         public string? Id { get; set; }

Backend/Diligent.WebAPI.Business/Services/AuthorizationService.cs

 using MongoDB.Driver;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace Diligent.WebAPI.Business.Services
 {
+    [ExcludeFromCodeCoverage]
     public class AuthorizationService : BaseMongo<Customer>
     {
         public AuthorizationService(IOptions<WebApiDatabaseSettings> webApiDatabaseSettings) :

Backend/Diligent.WebAPI.Business/Services/BaseMongo.cs

 using Diligent.WebAPI.Data;
 using Microsoft.Extensions.Options;
 using MongoDB.Driver;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Diligent.WebAPI.Business.MongoServices
 {
+    [ExcludeFromCodeCoverage]
     public class BaseMongo<T> where T : class
     {
         protected readonly IMongoCollection<T> _mongoCollection;

Backend/Diligent.WebAPI.Data/DbContext/MongoDBContext.cs

 using MongoDB.Driver;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Diligent.WebAPI.Data
 {
+    [ExcludeFromCodeCoverage]
     public class MongoDBContext : IMongoDBContext
     {
         private readonly IConfiguration _configuration;

Backend/Diligent.WebAPI.Data/Entities/BaseMongo.cs

 using MongoDB.Bson;
 using MongoDB.Bson.Serialization.Attributes;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Diligent.WebAPI.Data.Entities
 {
+    [ExcludeFromCodeCoverage]
     public class BaseMongo
     {
         [BsonId]

Backend/Diligent.WebAPI.Data/WebApiDatabaseSettings.cs

 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace Diligent.WebAPI.Data
 {
+    [ExcludeFromCodeCoverage]
     public class WebApiDatabaseSettings
     {
         public string ConnectionString { get; set; } = null!;

Backend/Diligent.WebAPI.Host/Controllers/AuthenticationController.cs

 using Diligent.WebAPI.Host.Mediator.Authentication.Queries;
 using MediatR;
 using Microsoft.AspNetCore.Mvc;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Diligent.WebAPI.Host.Controllers
 {
     [ApiVersion("1.0")]
     [ApiController]
     [Route("v{version:apiVersion}/[controller]")]
+    [ExcludeFromCodeCoverage]
     public class AuthenticationController : ControllerBase
     {
         // password for every user in database is "Nekasifra123!"

Backend/Diligent.WebAPI.Host/Controllers/NotificationController.cs

 using Diligent.WebAPI.Host.Mediator.Notifications.Queries;
 using MediatR;
 using Microsoft.AspNetCore.Mvc;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Diligent.WebAPI.Host.Controllers
 {
     [ApiVersion("1.0")]
     [ApiController]
     [Route("v{version:apiVersion}/[controller]")]
+    [ExcludeFromCodeCoverage]
     public class NotificationController : ControllerBase
     {
         private readonly IMediator _mediator;

Backend/Diligent.WebAPI.Host/Controllers/RequestController.cs

 using Diligent.WebAPI.Host.Mediator.Request.Queries;
 using MediatR;
 using Microsoft.AspNetCore.Mvc;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Diligent.WebAPI.Host.Controllers
 {
     [ApiVersion("1.0")]
     [ApiController]
     [Route("v{version:apiVersion}/[controller]")]
+    [ExcludeFromCodeCoverage]
     public class RequestController:ControllerBase
     {
         private readonly IMediator _mediator;

Backend/Diligent.WebAPI.Host/Controllers/RoomController.cs

 using MediatR;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Diligent.WebAPI.Host.Controllers
 {
     [ApiVersion("1.0")]
     [ApiController]
     [Route("v{version:apiVersion}/[controller]")]
+    [ExcludeFromCodeCoverage]
     public class RoomController : ControllerBase
     {
         private readonly IMediator _mediator;

Backend/Diligent.WebAPI.Host/DTOs/Chat/LeaveChatRoomDTO.cs

-namespace Diligent.WebAPI.Host.DTOs.Chat
+using System.Diagnostics.CodeAnalysis;
+
+namespace Diligent.WebAPI.Host.DTOs.Chat
 {
+    [ExcludeFromCodeCoverage]
     public class LeaveChatRoomDTO
     {
         public string ConnId { get; set; }

Backend/Diligent.WebAPI.Host/DTOs/Notification/NotificationReadDTO.cs

-namespace Diligent.WebAPI.Host.DTOs.Notification
+using System.Diagnostics.CodeAnalysis;
+
+namespace Diligent.WebAPI.Host.DTOs.Notification
 {
+    [ExcludeFromCodeCoverage]
     public class NotificationReadDTO
     {
         public string RoomId { get; set; }

Backend/Diligent.WebAPI.Host/DTOs/Request/AcceptCustomerDTO.cs

-namespace Diligent.WebAPI.Host.DTOs.Request
+using System.Diagnostics.CodeAnalysis;
+
+namespace Diligent.WebAPI.Host.DTOs.Request
 {
+    [ExcludeFromCodeCoverage]
     public class AcceptCustomerDTO
     {
         public string customerId { get; set; }

Backend/Diligent.WebAPI.Host/Exceptions/BaseException.cs

-using System.Runtime.Serialization;
-
-namespace Diligent.WebAPI.Host.Exceptions
+namespace Diligent.WebAPI.Host.Exceptions
 {
     public class BaseException : Exception
     {
         public BaseException() { }
         public BaseException(string? message) : base(message) { }
-        public BaseException(string message, Exception innerException) : base(message, innerException) { }
-        public BaseException(SerializationInfo info, StreamingContext context) : base(info, context) { }
-
     }
 }

Backend/Diligent.WebAPI.Host/Exceptions/NotFoundException.cs

 {
     public class NotFoundException : BaseException
     {
-
         public NotFoundException() { }
         public NotFoundException(string? message) : base(message) { }
-        public NotFoundException(string message, Exception innerException) : base(message, innerException) { }
-        public NotFoundException(SerializationInfo info, StreamingContext context) : base(info, context) { }
-
     }
 }

Backend/Diligent.WebAPI.Host/Extensions/ApiConfiguration.cs

 using Microsoft.AspNetCore.Mvc;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Diligent.WebAPI.Host.Extensions
 {
+    [ExcludeFromCodeCoverage]
     public static class ApiConfiguration
     {
         public static void ConfigureServices(IServiceCollection services)

Backend/Diligent.WebAPI.Host/Extensions/ExceptionHandlingMiddlewareExtensions.cs

 using Diligent.WebAPI.Host.Middlewares;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Diligent.WebAPI.Host.Extensions
 {
+    [ExcludeFromCodeCoverage]
     public static class ExceptionHandlingMiddlewareExtensions
     {
         public static void ConfigureCustomExceptionMiddleware(this IApplicationBuilder app)

Backend/Diligent.WebAPI.Host/Extensions/WebApp.cs

 
+using System.Diagnostics.CodeAnalysis;
+
 namespace Diligent.WebAPI.Host.Extensions;
 
+[ExcludeFromCodeCoverage]
 public static class WebApp
 {
+
+    [ExcludeFromCodeCoverage]
     public static void SetupData(this WebApplication app)
     {
         app.ConfigureCustomExceptionMiddleware();

Backend/Diligent.WebAPI.Host/Extensions/WebAppBuilder.cs

 using Diligent.WebAPI.Business.Services;
 using Diligent.WebAPI.Host.Middlewares;
 using Diligent.WebAPI.Business.Interfaces;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Diligent.WebAPI.Host.Extensions;
 
+[ExcludeFromCodeCoverage]
 public static class WebAppBuilder
 {
+
     public static void ConfigureData(this WebApplicationBuilder builder, IConfiguration configuration)
     {
         // database configuration

Backend/Diligent.WebAPI.Host/Mapper/NotificationMappingProfile.cs

 using AutoMapper;
 using Diligent.WebAPI.Data.Entities;
 using Diligent.WebAPI.Host.DTOs.Notification;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Diligent.WebAPI.Host.Mapper
 {
+    [ExcludeFromCodeCoverage]
     public class NotificationMappingProfile : Profile
     {
         public NotificationMappingProfile()

Backend/Diligent.WebAPI.Host/Mediator/Authentication/Handlers/AddRoleHandler.cs

 using Diligent.WebAPI.Host.Mediator.Authentication.Commands;
 using MediatR;
 using Microsoft.AspNetCore.Identity;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Diligent.WebAPI.Host.Mediator.Authentication.Handlers
 {
+    [ExcludeFromCodeCoverage]
     public class AddRoleHandler : IRequestHandler<AddRoleCommand, Unit>
     {
         private readonly RoleManager<Roles> _roleManager;

Backend/Diligent.WebAPI.Host/Mediator/Authentication/Handlers/LoginUserHandler.cs

 
             Customer customer = await _customerService.GetCustomer(customerLoginDTO.Username);
             var customerReadDTO = _mapper.Map<CustomerReadDTO>(customer);
-            customerReadDTO.Token = await _authenticationService.GenerateToken();
+            customerReadDTO.Token = await _authenticationService.GenerateToken() ?? "";
             customerReadDTO.Roles = (List<string>)await _customerManager.GetRolesAsync(customer);
             return customerReadDTO;
         }