initial commit

Presentation/ASPNET/BackEnd/BackEndConfiguration.cs

@@ -0,0 +1,118 @@
+using Application;
+using ASPNET.BackEnd.Common.Handlers;
+using Infrastructure;
+using Infrastructure.DataAccessManager.EFCore;
+using Infrastructure.SeedManager;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.OpenApi.Models;
+
+namespace ASPNET.BackEnd;
+
+public static class BackEndConfiguration
+{
+    public static IServiceCollection AddBackEndServices(this IServiceCollection services, IConfiguration configuration)
+    {
+        //>>> Application Layer
+        services.AddApplicationServices();
+
+        //>>> Infrastructure Layer
+        services.AddInfrastructureServices(configuration);
+
+        services.AddExceptionHandler<CustomExceptionHandler>();
+
+        //>>> Common
+
+        services.AddHttpContextAccessor();
+        services.AddCors(opt =>
+        {
+            opt.AddDefaultPolicy(builder => builder
+                .AllowAnyOrigin()
+                .AllowAnyMethod()
+                .AllowAnyHeader());
+        });
+        services.AddControllers()
+            .AddJsonOptions(options =>
+            {
+                options.JsonSerializerOptions.ReferenceHandler = System.Text.Json.Serialization.ReferenceHandler.IgnoreCycles;
+                options.JsonSerializerOptions.WriteIndented = true;
+            });
+        services.AddEndpointsApiExplorer();
+        services.AddSwaggerGen(c =>
+        {
+            c.SwaggerDoc("v1", new OpenApiInfo { Title = "Indotalent API", Version = "v1" });
+            c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
+            {
+                Name = "Authorization",
+                Type = SecuritySchemeType.ApiKey,
+                Scheme = "bearer",
+                BearerFormat = "JWT",
+                In = ParameterLocation.Header,
+                Description = "JWT Authorization header using the Bearer scheme."
+            });
+
+            c.AddSecurityRequirement(new OpenApiSecurityRequirement
+            {
+                {
+                    new OpenApiSecurityScheme
+                    {
+                        Reference = new OpenApiReference
+                        {
+                            Type = ReferenceType.SecurityScheme,
+                            Id = "Bearer"
+                        }
+                    },
+                    new string[] { }
+                }
+            });
+
+        });
+
+
+        services.Configure<ApiBehaviorOptions>(x =>
+        {
+            x.SuppressModelStateInvalidFilter = true;
+        });
+
+        return services;
+    }
+
+    public static IEndpointRouteBuilder MapBackEndRoutes(this IEndpointRouteBuilder endpoints)
+    {
+        endpoints.MapControllers();
+
+        return endpoints;
+    }
+
+    public static IApplicationBuilder RegisterBackEndBuilder(
+        this IApplicationBuilder app,
+        IWebHostEnvironment environment,
+        IHost host,
+        IConfiguration configuration
+        )
+    {
+        // >>> Create database
+        host.CreateDatabase();
+
+        //seed database with system data
+        host.SeedSystemData();
+
+        //seed database with demo data
+        if (configuration.GetValue<bool>("IsDemoVersion"))
+        {
+            host.SeedDemoData();
+        }
+
+        if (environment.IsDevelopment())
+        {
+            app.UseSwagger();
+            app.UseSwaggerUI(c =>
+            {
+                c.SwaggerEndpoint("/swagger/v1/swagger.json", "Indotalent V1");
+            });
+        }
+
+        return app;
+    }
+
+
+}

Presentation/ASPNET/BackEnd/Common/Base/BaseApiController.cs

@@ -0,0 +1,16 @@
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Common.Base;
+
+[ApiController]
+[Route("api/[controller]/[action]")]
+public abstract class BaseApiController : ControllerBase
+{
+    protected readonly ISender _sender;
+
+    protected BaseApiController(ISender sender)
+    {
+        _sender = sender;
+    }
+}

Presentation/ASPNET/BackEnd/Common/Handlers/CustomExceptionHandler.cs

@@ -0,0 +1,54 @@
+using ASPNET.BackEnd.Common.Models;
+using Microsoft.AspNetCore.Diagnostics;
+
+namespace ASPNET.BackEnd.Common.Handlers;
+
+public class CustomExceptionHandler : IExceptionHandler
+{
+    private readonly Dictionary<Type, Func<HttpContext, Exception, Task>> _exceptionHandlers;
+
+    public CustomExceptionHandler()
+    {
+        _exceptionHandlers = new()
+            {
+                { typeof(Exception), HandleException },
+            };
+    }
+    public async ValueTask<bool> TryHandleAsync(HttpContext httpContext, Exception exception, CancellationToken cancellationToken)
+    {
+        var exceptionType = exception.GetType();
+
+        if (_exceptionHandlers.ContainsKey(exceptionType))
+        {
+            await _exceptionHandlers[exceptionType].Invoke(httpContext, exception);
+            return true;
+        }
+        else
+        {
+            await HandleException(httpContext, exception);
+            return true;
+        }
+
+    }
+
+    private async Task HandleException(HttpContext httpContext, Exception ex)
+    {
+        var statusCode = httpContext.Response.StatusCode != 200
+            ? httpContext.Response.StatusCode
+            : StatusCodes.Status500InternalServerError;
+
+        var errorMessage = ex.Message;
+
+        var result = new ApiErrorResult
+        {
+            Code = statusCode,
+            Message = $"Exception: {errorMessage}",
+            Error = new Error(ex.InnerException?.Message, ex.Source, ex.StackTrace, ex.GetType().Name)
+        };
+
+        httpContext.Response.ContentType = "application/json";
+        await httpContext.Response.WriteAsJsonAsync(result);
+    }
+
+}
+

Presentation/ASPNET/BackEnd/Common/Middlewares/GlobalApiExceptionHandlerMiddleware.cs

@@ -0,0 +1,48 @@
+using Microsoft.AspNetCore.Diagnostics;
+
+namespace ASPNET.BackEnd.Common.Middlewares;
+
+public class GlobalApiExceptionHandlerMiddleware
+{
+    private readonly RequestDelegate _next;
+
+    public GlobalApiExceptionHandlerMiddleware(RequestDelegate next)
+    {
+        _next = next;
+    }
+
+    public async Task InvokeAsync(HttpContext httpContext, IExceptionHandler customExceptionHandler)
+    {
+        try
+        {
+            await _next(httpContext);
+
+            switch (httpContext.Response.StatusCode)
+            {
+                case StatusCodes.Status401Unauthorized:
+                    await customExceptionHandler.TryHandleAsync(
+                        httpContext,
+                        new UnauthorizedAccessException("Unauthorized - Token missing or invalid"),
+                        CancellationToken.None
+                    );
+                    break;
+
+                case StatusCodes.Status403Forbidden:
+                    await customExceptionHandler.TryHandleAsync(
+                        httpContext,
+                        new Exception("Forbidden - Access denied"),
+                        CancellationToken.None
+                    );
+                    break;
+
+                default:
+                    // Let other status codes pass through
+                    break;
+            }
+        }
+        catch (Exception ex)
+        {
+            await customExceptionHandler.TryHandleAsync(httpContext, ex, CancellationToken.None);
+        }
+    }
+}

Presentation/ASPNET/BackEnd/Common/Models/ApiErrorResult.cs

@@ -0,0 +1,8 @@
+namespace ASPNET.BackEnd.Common.Models;
+
+public class ApiErrorResult
+{
+    public int? Code { get; init; }
+    public string? Message { get; init; }
+    public Error? Error { get; init; }
+}

Presentation/ASPNET/BackEnd/Common/Models/ApiSuccessResult.cs

@@ -0,0 +1,8 @@
+namespace ASPNET.BackEnd.Common.Models;
+
+public class ApiSuccessResult<T>
+{
+    public int? Code { get; init; }
+    public string? Message { get; init; }
+    public T? Content { get; init; }
+}

Presentation/ASPNET/BackEnd/Common/Models/Error.cs

@@ -0,0 +1,23 @@
+namespace ASPNET.BackEnd.Common.Models;
+
+public class Error
+{
+    public Error(
+        string? innerException,
+        string? source,
+        string? stackTrace,
+        string? exceptionType)
+    {
+        Ref = "https://datatracker.ietf.org/doc/html/rfc9110";
+        InnerException = innerException;
+        Source = source?.Trim();
+        StackTrace = stackTrace?.Trim();
+        ExceptionType = exceptionType;
+    }
+    public string Ref { get; set; }
+    public string? ExceptionType { get; init; }
+    public string? InnerException { get; init; }
+    public string? Source { get; init; }
+    public string? StackTrace { get; init; }
+}
+

Presentation/ASPNET/BackEnd/Controllers/CompanyController.cs

@@ -0,0 +1,71 @@
+using Application.Features.CompanyManager.Commands;
+using Application.Features.CompanyManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class CompanyController : BaseApiController
+{
+    public CompanyController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("UpdateCompany")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateCompanyResult>>> UpdateCompanyAsync(UpdateCompanyRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateCompanyResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateCompanyAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetCompanySingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetCompanySingleResult>>> GetCompanySingleAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] string id
+        )
+    {
+        var request = new GetCompanySingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetCompanySingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetCompanySingleAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetCompanyList")]
+    public async Task<ActionResult<ApiSuccessResult<GetCompanyListResult>>> GetCompanyListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetCompanyListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetCompanyListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetCompanyListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/CustomerCategoryController.cs

@@ -0,0 +1,81 @@
+using Application.Features.CustomerCategoryManager.Commands;
+using Application.Features.CustomerCategoryManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class CustomerCategoryController : BaseApiController
+{
+    public CustomerCategoryController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateCustomerCategory")]
+    public async Task<ActionResult<ApiSuccessResult<CreateCustomerCategoryResult>>> CreateCustomerCategoryAsync(CreateCustomerCategoryRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateCustomerCategoryResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateCustomerCategoryAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateCustomerCategory")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateCustomerCategoryResult>>> UpdateCustomerCategoryAsync(UpdateCustomerCategoryRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateCustomerCategoryResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateCustomerCategoryAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteCustomerCategory")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteCustomerCategoryResult>>> DeleteCustomerCategoryAsync(DeleteCustomerCategoryRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteCustomerCategoryResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteCustomerCategoryAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetCustomerCategoryList")]
+    public async Task<ActionResult<ApiSuccessResult<GetCustomerCategoryListResult>>> GetCustomerCategoryListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetCustomerCategoryListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetCustomerCategoryListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetCustomerCategoryListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/CustomerContactController.cs

@@ -0,0 +1,99 @@
+using Application.Features.CustomerContactManager.Commands;
+using Application.Features.CustomerContactManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class CustomerContactController : BaseApiController
+{
+    public CustomerContactController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateCustomerContact")]
+    public async Task<ActionResult<ApiSuccessResult<CreateCustomerContactResult>>> CreateCustomerContactAsync(CreateCustomerContactRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateCustomerContactResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateCustomerContactAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateCustomerContact")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateCustomerContactResult>>> UpdateCustomerContactAsync(UpdateCustomerContactRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateCustomerContactResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateCustomerContactAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteCustomerContact")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteCustomerContactResult>>> DeleteCustomerContactAsync(DeleteCustomerContactRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteCustomerContactResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteCustomerContactAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetCustomerContactList")]
+    public async Task<ActionResult<ApiSuccessResult<GetCustomerContactListResult>>> GetCustomerContactListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetCustomerContactListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetCustomerContactListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetCustomerContactListAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetCustomerContactByCustomerIdList")]
+    public async Task<ActionResult<ApiSuccessResult<GetCustomerContactByCustomerIdListResult>>> GetCustomerContactByCustomerIdListAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string customerId
+    )
+    {
+        var request = new GetCustomerContactByCustomerIdListRequest { CustomerId = customerId };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetCustomerContactByCustomerIdListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetCustomerContactByCustomerIdListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/CustomerController.cs

@@ -0,0 +1,81 @@
+using Application.Features.CustomerManager.Commands;
+using Application.Features.CustomerManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class CustomerController : BaseApiController
+{
+    public CustomerController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateCustomer")]
+    public async Task<ActionResult<ApiSuccessResult<CreateCustomerResult>>> CreateCustomerAsync(CreateCustomerRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateCustomerResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateCustomerAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateCustomer")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateCustomerResult>>> UpdateCustomerAsync(UpdateCustomerRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateCustomerResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateCustomerAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteCustomer")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteCustomerResult>>> DeleteCustomerAsync(DeleteCustomerRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteCustomerResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteCustomerAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetCustomerList")]
+    public async Task<ActionResult<ApiSuccessResult<GetCustomerListResult>>> GetCustomerListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetCustomerListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetCustomerListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetCustomerListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/CustomerGroupController.cs

@@ -0,0 +1,81 @@
+using Application.Features.CustomerGroupManager.Commands;
+using Application.Features.CustomerGroupManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class CustomerGroupController : BaseApiController
+{
+    public CustomerGroupController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateCustomerGroup")]
+    public async Task<ActionResult<ApiSuccessResult<CreateCustomerGroupResult>>> CreateCustomerGroupAsync(CreateCustomerGroupRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateCustomerGroupResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateCustomerGroupAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateCustomerGroup")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateCustomerGroupResult>>> UpdateCustomerGroupAsync(UpdateCustomerGroupRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateCustomerGroupResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateCustomerGroupAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteCustomerGroup")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteCustomerGroupResult>>> DeleteCustomerGroupAsync(DeleteCustomerGroupRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteCustomerGroupResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteCustomerGroupAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetCustomerGroupList")]
+    public async Task<ActionResult<ApiSuccessResult<GetCustomerGroupListResult>>> GetCustomerGroupListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetCustomerGroupListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetCustomerGroupListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetCustomerGroupListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/DashboardController.cs

@@ -0,0 +1,93 @@
+using Application.Features.DashboardManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class DashboardController : BaseApiController
+{
+    public DashboardController(ISender sender) : base(sender)
+    {
+    }
+
+
+    [Authorize]
+    [HttpGet("GetCardsDashboard")]
+    public async Task<ActionResult<ApiSuccessResult<GetCardsDashboardResult>>> GetCardsDashboardAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetCardsDashboardRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetCardsDashboardResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetCardsDashboardAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetSalesDashboard")]
+    public async Task<ActionResult<ApiSuccessResult<GetSalesDashboardResult>>> GetSalesDashboardAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetSalesDashboardRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetSalesDashboardResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetSalesDashboardAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetPurchaseDashboard")]
+    public async Task<ActionResult<ApiSuccessResult<GetPurchaseDashboardResult>>> GetPurchaseDashboardAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetPurchaseDashboardRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetPurchaseDashboardResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetPurchaseDashboardAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetInventoryDashboard")]
+    public async Task<ActionResult<ApiSuccessResult<GetInventoryDashboardResult>>> GetInventoryDashboardAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetInventoryDashboardRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetInventoryDashboardResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetInventoryDashboardAsync)}",
+            Content = response
+        });
+    }
+
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/DeliveryOrderController.cs

@@ -0,0 +1,118 @@
+using Application.Features.DeliveryOrderManager.Commands;
+using Application.Features.DeliveryOrderManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class DeliveryOrderController : BaseApiController
+{
+    public DeliveryOrderController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateDeliveryOrder")]
+    public async Task<ActionResult<ApiSuccessResult<CreateDeliveryOrderResult>>> CreateDeliveryOrderAsync(CreateDeliveryOrderRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateDeliveryOrderResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateDeliveryOrderAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateDeliveryOrder")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateDeliveryOrderResult>>> UpdateDeliveryOrderAsync(UpdateDeliveryOrderRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateDeliveryOrderResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateDeliveryOrderAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteDeliveryOrder")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteDeliveryOrderResult>>> DeleteDeliveryOrderAsync(DeleteDeliveryOrderRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteDeliveryOrderResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteDeliveryOrderAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetDeliveryOrderList")]
+    public async Task<ActionResult<ApiSuccessResult<GetDeliveryOrderListResult>>> GetDeliveryOrderListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetDeliveryOrderListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetDeliveryOrderListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetDeliveryOrderListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetDeliveryOrderStatusList")]
+    public async Task<ActionResult<ApiSuccessResult<GetDeliveryOrderStatusListResult>>> GetDeliveryOrderStatusListAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetDeliveryOrderStatusListRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetDeliveryOrderStatusListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetDeliveryOrderStatusListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetDeliveryOrderSingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetDeliveryOrderSingleResult>>> GetDeliveryOrderSingleAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string id
+    )
+    {
+        var request = new GetDeliveryOrderSingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetDeliveryOrderSingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetDeliveryOrderSingleAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/FileDocumentController.cs

@@ -0,0 +1,91 @@
+using Application.Features.FileDocumentManager.Commands;
+using Application.Features.FileDocumentManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using Infrastructure.FileDocumentManager;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class FileDocumentController : BaseApiController
+{
+    public FileDocumentController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("UploadDocument")]
+    public async Task<ActionResult<CreateDocumentResult>> UploadDocumentAsync(IFormFile file, CancellationToken cancellationToken)
+    {
+        if (file == null || file.Length == 0)
+        {
+            return BadRequest("Invalid file.");
+        }
+
+        using (var memoryStream = new MemoryStream())
+        {
+            await file.CopyToAsync(memoryStream, cancellationToken);
+            var fileData = memoryStream.ToArray();
+            var extension = Path.GetExtension(file.FileName).TrimStart('.');
+
+            var command = new CreateDocumentRequest
+            {
+                OriginalFileName = file.FileName,
+                Extension = extension,
+                Data = fileData,
+                Size = fileData.Length
+            };
+
+            var result = await _sender.Send(command, cancellationToken);
+
+            if (result?.DocumentName == null)
+            {
+                return StatusCode(500, "An error occurred while uploading the document.");
+            }
+
+            return Ok(new ApiSuccessResult<CreateDocumentResult>
+            {
+                Code = StatusCodes.Status200OK,
+                Message = $"Success executing {nameof(UploadDocumentAsync)}",
+                Content = result
+            });
+        }
+    }
+
+
+    [Authorize]
+    [HttpGet("GetDocument")]
+    public async Task<IActionResult> GetDocumentAsync(
+        [FromQuery] string documentName,
+        CancellationToken cancellationToken)
+    {
+        if (string.IsNullOrEmpty(documentName) || Path.GetExtension(documentName) == string.Empty)
+        {
+            documentName = "nodocument.txt";
+        }
+
+        var request = new GetDocumentRequest
+        {
+            DocumentName = documentName
+        };
+
+        var result = await _sender.Send(request, cancellationToken);
+
+        if (result?.Data == null)
+        {
+            return NotFound("Document not found.");
+        }
+
+        var extension = Path.GetExtension(documentName).ToLower();
+        var mimeType = FileDocumentHelper.GetMimeType(extension);
+
+        return File(result.Data, mimeType);
+    }
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/FileImageController.cs

@@ -0,0 +1,91 @@
+using Application.Features.FileImageManager.Commands;
+using Application.Features.FileImageManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using Infrastructure.FileImageManager;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class FileImageController : BaseApiController
+{
+    public FileImageController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("UploadImage")]
+    public async Task<ActionResult<CreateImageResult>> UploadImageAsync(IFormFile file, CancellationToken cancellationToken)
+    {
+        if (file == null || file.Length == 0)
+        {
+            return BadRequest("Invalid file.");
+        }
+
+        using (var memoryStream = new MemoryStream())
+        {
+            await file.CopyToAsync(memoryStream, cancellationToken);
+            var fileData = memoryStream.ToArray();
+            var extension = Path.GetExtension(file.FileName).TrimStart('.');
+
+            var command = new CreateImageRequest
+            {
+                OriginalFileName = file.FileName,
+                Extension = extension,
+                Data = fileData,
+                Size = fileData.Length
+            };
+
+            var result = await _sender.Send(command, cancellationToken);
+
+            if (result?.ImageName == null)
+            {
+                return StatusCode(500, "An error occurred while uploading the image.");
+            }
+
+            return Ok(new ApiSuccessResult<CreateImageResult>
+            {
+                Code = StatusCodes.Status200OK,
+                Message = $"Success executing {nameof(UploadImageAsync)}",
+                Content = result
+            });
+        }
+    }
+
+
+    [Authorize]
+    [HttpGet("GetImage")]
+    public async Task<IActionResult> GetImageAsync(
+        [FromQuery] string imageName,
+        CancellationToken cancellationToken)
+    {
+        if (string.IsNullOrEmpty(imageName) || Path.GetExtension(imageName) == string.Empty)
+        {
+            imageName = "noimage.png";
+        }
+
+        var request = new GetImageRequest
+        {
+            ImageName = imageName
+        };
+
+        var result = await _sender.Send(request, cancellationToken);
+
+        if (result?.Data == null)
+        {
+            return NotFound("Image not found.");
+        }
+
+        var extension = Path.GetExtension(imageName).ToLower();
+        var mimeType = FileImageHelper.GetMimeType(extension);
+
+        return File(result.Data, mimeType);
+    }
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/GoodsReceiveController.cs

@@ -0,0 +1,118 @@
+using Application.Features.GoodsReceiveManager.Commands;
+using Application.Features.GoodsReceiveManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class GoodsReceiveController : BaseApiController
+{
+    public GoodsReceiveController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateGoodsReceive")]
+    public async Task<ActionResult<ApiSuccessResult<CreateGoodsReceiveResult>>> CreateGoodsReceiveAsync(CreateGoodsReceiveRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateGoodsReceiveResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateGoodsReceiveAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateGoodsReceive")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateGoodsReceiveResult>>> UpdateGoodsReceiveAsync(UpdateGoodsReceiveRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateGoodsReceiveResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateGoodsReceiveAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteGoodsReceive")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteGoodsReceiveResult>>> DeleteGoodsReceiveAsync(DeleteGoodsReceiveRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteGoodsReceiveResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteGoodsReceiveAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetGoodsReceiveList")]
+    public async Task<ActionResult<ApiSuccessResult<GetGoodsReceiveListResult>>> GetGoodsReceiveListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetGoodsReceiveListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetGoodsReceiveListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetGoodsReceiveListAsync)}",
+            Content = response
+        });
+    }
+
+
+
+    [Authorize]
+    [HttpGet("GetGoodsReceiveStatusList")]
+    public async Task<ActionResult<ApiSuccessResult<GetGoodsReceiveStatusListResult>>> GetGoodsReceiveStatusListAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetGoodsReceiveStatusListRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetGoodsReceiveStatusListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetGoodsReceiveStatusListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetGoodsReceiveSingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetGoodsReceiveSingleResult>>> GetGoodsReceiveSingleAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string id
+    )
+    {
+        var request = new GetGoodsReceiveSingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetGoodsReceiveSingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetGoodsReceiveSingleAsync)}",
+            Content = response
+        });
+    }
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/InventoryTransactionController.cs

@@ -0,0 +1,659 @@
+using Application.Features.InventoryTransactionManager.Commands;
+using Application.Features.InventoryTransactionManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class InventoryTransactionController : BaseApiController
+{
+    public InventoryTransactionController(ISender sender) : base(sender)
+    {
+    }
+
+
+
+    [Authorize]
+    [HttpGet("GetInventoryTransactionList")]
+    public async Task<ActionResult<ApiSuccessResult<GetInventoryTransactionListResult>>> GetInventoryTransactionListAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetInventoryTransactionListRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetInventoryTransactionListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetInventoryTransactionListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetInventoryStockList")]
+    public async Task<ActionResult<ApiSuccessResult<GetInventoryStockListResult>>> GetInventoryStockListAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetInventoryStockListRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetInventoryStockListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetInventoryStockListAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeliveryOrderCreateInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<DeliveryOrderCreateInvenTransResult>>> DeliveryOrderCreateInvenTransAsync(DeliveryOrderCreateInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeliveryOrderCreateInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeliveryOrderCreateInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeliveryOrderUpdateInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<DeliveryOrderUpdateInvenTransResult>>> DeliveryOrderUpdateInvenTransAsync(DeliveryOrderUpdateInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeliveryOrderUpdateInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeliveryOrderUpdateInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeliveryOrderDeleteInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<DeliveryOrderDeleteInvenTransResult>>> DeliveryOrderDeleteInvenTransAsync(DeliveryOrderDeleteInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeliveryOrderDeleteInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeliveryOrderDeleteInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("DeliveryOrderGetInvenTransList")]
+    public async Task<ActionResult<ApiSuccessResult<DeliveryOrderGetInvenTransListResult>>> DeliveryOrderGetInvenTransListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] string moduleId
+        )
+    {
+        var request = new DeliveryOrderGetInvenTransListRequest { ModuleId = moduleId };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeliveryOrderGetInvenTransListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeliveryOrderGetInvenTransListAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("SalesReturnCreateInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<SalesReturnCreateInvenTransResult>>> SalesReturnCreateInvenTransAsync(SalesReturnCreateInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<SalesReturnCreateInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(SalesReturnCreateInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("SalesReturnUpdateInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<SalesReturnUpdateInvenTransResult>>> SalesReturnUpdateInvenTransAsync(SalesReturnUpdateInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<SalesReturnUpdateInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(SalesReturnUpdateInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("SalesReturnDeleteInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<SalesReturnDeleteInvenTransResult>>> SalesReturnDeleteInvenTransAsync(SalesReturnDeleteInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<SalesReturnDeleteInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(SalesReturnDeleteInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("SalesReturnGetInvenTransList")]
+    public async Task<ActionResult<ApiSuccessResult<SalesReturnGetInvenTransListResult>>> SalesReturnGetInvenTransListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] string moduleId
+        )
+    {
+        var request = new SalesReturnGetInvenTransListRequest { ModuleId = moduleId };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<SalesReturnGetInvenTransListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(SalesReturnGetInvenTransListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpPost("GoodsReceiveCreateInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<GoodsReceiveCreateInvenTransResult>>> GoodsReceiveCreateInvenTransAsync(GoodsReceiveCreateInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GoodsReceiveCreateInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GoodsReceiveCreateInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("GoodsReceiveUpdateInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<GoodsReceiveUpdateInvenTransResult>>> GoodsReceiveUpdateInvenTransAsync(GoodsReceiveUpdateInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GoodsReceiveUpdateInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GoodsReceiveUpdateInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("GoodsReceiveDeleteInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<GoodsReceiveDeleteInvenTransResult>>> GoodsReceiveDeleteInvenTransAsync(GoodsReceiveDeleteInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GoodsReceiveDeleteInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GoodsReceiveDeleteInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GoodsReceiveGetInvenTransList")]
+    public async Task<ActionResult<ApiSuccessResult<GoodsReceiveGetInvenTransListResult>>> GoodsReceiveGetInvenTransListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] string moduleId
+        )
+    {
+        var request = new GoodsReceiveGetInvenTransListRequest { ModuleId = moduleId };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GoodsReceiveGetInvenTransListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GoodsReceiveGetInvenTransListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpPost("PurchaseReturnCreateInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<PurchaseReturnCreateInvenTransResult>>> PurchaseReturnCreateInvenTransAsync(PurchaseReturnCreateInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<PurchaseReturnCreateInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(PurchaseReturnCreateInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("PurchaseReturnUpdateInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<PurchaseReturnUpdateInvenTransResult>>> PurchaseReturnUpdateInvenTransAsync(PurchaseReturnUpdateInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<PurchaseReturnUpdateInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(PurchaseReturnUpdateInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("PurchaseReturnDeleteInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<PurchaseReturnDeleteInvenTransResult>>> PurchaseReturnDeleteInvenTransAsync(PurchaseReturnDeleteInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<PurchaseReturnDeleteInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(PurchaseReturnDeleteInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("PurchaseReturnGetInvenTransList")]
+    public async Task<ActionResult<ApiSuccessResult<PurchaseReturnGetInvenTransListResult>>> PurchaseReturnGetInvenTransListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] string moduleId
+        )
+    {
+        var request = new PurchaseReturnGetInvenTransListRequest { ModuleId = moduleId };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<PurchaseReturnGetInvenTransListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(PurchaseReturnGetInvenTransListAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("TransferOutCreateInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<TransferOutCreateInvenTransResult>>> TransferOutCreateInvenTransAsync(TransferOutCreateInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<TransferOutCreateInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(TransferOutCreateInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("TransferOutUpdateInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<TransferOutUpdateInvenTransResult>>> TransferOutUpdateInvenTransAsync(TransferOutUpdateInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<TransferOutUpdateInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(TransferOutUpdateInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("TransferOutDeleteInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<TransferOutDeleteInvenTransResult>>> TransferOutDeleteInvenTransAsync(TransferOutDeleteInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<TransferOutDeleteInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(TransferOutDeleteInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("TransferOutGetInvenTransList")]
+    public async Task<ActionResult<ApiSuccessResult<TransferOutGetInvenTransListResult>>> TransferOutGetInvenTransListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] string moduleId
+        )
+    {
+        var request = new TransferOutGetInvenTransListRequest { ModuleId = moduleId };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<TransferOutGetInvenTransListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(TransferOutGetInvenTransListAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("TransferInCreateInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<TransferInCreateInvenTransResult>>> TransferInCreateInvenTransAsync(TransferInCreateInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<TransferInCreateInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(TransferInCreateInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("TransferInUpdateInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<TransferInUpdateInvenTransResult>>> TransferInUpdateInvenTransAsync(TransferInUpdateInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<TransferInUpdateInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(TransferInUpdateInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("TransferInDeleteInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<TransferInDeleteInvenTransResult>>> TransferInDeleteInvenTransAsync(TransferInDeleteInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<TransferInDeleteInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(TransferInDeleteInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("TransferInGetInvenTransList")]
+    public async Task<ActionResult<ApiSuccessResult<TransferInGetInvenTransListResult>>> TransferInGetInvenTransListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] string moduleId
+        )
+    {
+        var request = new TransferInGetInvenTransListRequest { ModuleId = moduleId };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<TransferInGetInvenTransListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(TransferInGetInvenTransListAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("PositiveAdjustmentCreateInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<PositiveAdjustmentCreateInvenTransResult>>> PositiveAdjustmentCreateInvenTransAsync(PositiveAdjustmentCreateInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<PositiveAdjustmentCreateInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(PositiveAdjustmentCreateInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("PositiveAdjustmentUpdateInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<PositiveAdjustmentUpdateInvenTransResult>>> PositiveAdjustmentUpdateInvenTransAsync(PositiveAdjustmentUpdateInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<PositiveAdjustmentUpdateInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(PositiveAdjustmentUpdateInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("PositiveAdjustmentDeleteInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<PositiveAdjustmentDeleteInvenTransResult>>> PositiveAdjustmentDeleteInvenTransAsync(PositiveAdjustmentDeleteInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<PositiveAdjustmentDeleteInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(PositiveAdjustmentDeleteInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("PositiveAdjustmentGetInvenTransList")]
+    public async Task<ActionResult<ApiSuccessResult<PositiveAdjustmentGetInvenTransListResult>>> PositiveAdjustmentGetInvenTransListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] string moduleId
+        )
+    {
+        var request = new PositiveAdjustmentGetInvenTransListRequest { ModuleId = moduleId };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<PositiveAdjustmentGetInvenTransListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(PositiveAdjustmentGetInvenTransListAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("NegativeAdjustmentCreateInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<NegativeAdjustmentCreateInvenTransResult>>> NegativeAdjustmentCreateInvenTransAsync(NegativeAdjustmentCreateInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<NegativeAdjustmentCreateInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(NegativeAdjustmentCreateInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("NegativeAdjustmentUpdateInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<NegativeAdjustmentUpdateInvenTransResult>>> NegativeAdjustmentUpdateInvenTransAsync(NegativeAdjustmentUpdateInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<NegativeAdjustmentUpdateInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(NegativeAdjustmentUpdateInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("NegativeAdjustmentDeleteInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<NegativeAdjustmentDeleteInvenTransResult>>> NegativeAdjustmentDeleteInvenTransAsync(NegativeAdjustmentDeleteInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<NegativeAdjustmentDeleteInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(NegativeAdjustmentDeleteInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("NegativeAdjustmentGetInvenTransList")]
+    public async Task<ActionResult<ApiSuccessResult<NegativeAdjustmentGetInvenTransListResult>>> NegativeAdjustmentGetInvenTransListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] string moduleId
+        )
+    {
+        var request = new NegativeAdjustmentGetInvenTransListRequest { ModuleId = moduleId };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<NegativeAdjustmentGetInvenTransListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(NegativeAdjustmentGetInvenTransListAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("ScrappingCreateInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<ScrappingCreateInvenTransResult>>> ScrappingCreateInvenTransAsync(ScrappingCreateInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<ScrappingCreateInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(ScrappingCreateInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("ScrappingUpdateInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<ScrappingUpdateInvenTransResult>>> ScrappingUpdateInvenTransAsync(ScrappingUpdateInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<ScrappingUpdateInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(ScrappingUpdateInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("ScrappingDeleteInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<ScrappingDeleteInvenTransResult>>> ScrappingDeleteInvenTransAsync(ScrappingDeleteInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<ScrappingDeleteInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(ScrappingDeleteInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("ScrappingGetInvenTransList")]
+    public async Task<ActionResult<ApiSuccessResult<ScrappingGetInvenTransListResult>>> ScrappingGetInvenTransListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] string moduleId
+        )
+    {
+        var request = new ScrappingGetInvenTransListRequest { ModuleId = moduleId };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<ScrappingGetInvenTransListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(ScrappingGetInvenTransListAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("StockCountCreateInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<StockCountCreateInvenTransResult>>> StockCountCreateInvenTransAsync(StockCountCreateInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<StockCountCreateInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(StockCountCreateInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("StockCountUpdateInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<StockCountUpdateInvenTransResult>>> StockCountUpdateInvenTransAsync(StockCountUpdateInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<StockCountUpdateInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(StockCountUpdateInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("StockCountDeleteInvenTrans")]
+    public async Task<ActionResult<ApiSuccessResult<StockCountDeleteInvenTransResult>>> StockCountDeleteInvenTransAsync(StockCountDeleteInvenTransRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<StockCountDeleteInvenTransResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(StockCountDeleteInvenTransAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("StockCountGetInvenTransList")]
+    public async Task<ActionResult<ApiSuccessResult<StockCountGetInvenTransListResult>>> StockCountGetInvenTransListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] string moduleId
+        )
+    {
+        var request = new StockCountGetInvenTransListRequest { ModuleId = moduleId };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<StockCountGetInvenTransListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(StockCountGetInvenTransListAsync)}",
+            Content = response
+        });
+    }
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/NegativeAdjustmentController.cs

@@ -0,0 +1,118 @@
+using Application.Features.NegativeAdjustmentManager.Commands;
+using Application.Features.NegativeAdjustmentManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class NegativeAdjustmentController : BaseApiController
+{
+    public NegativeAdjustmentController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateNegativeAdjustment")]
+    public async Task<ActionResult<ApiSuccessResult<CreateNegativeAdjustmentResult>>> CreateNegativeAdjustmentAsync(CreateNegativeAdjustmentRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateNegativeAdjustmentResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateNegativeAdjustmentAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateNegativeAdjustment")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateNegativeAdjustmentResult>>> UpdateNegativeAdjustmentAsync(UpdateNegativeAdjustmentRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateNegativeAdjustmentResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateNegativeAdjustmentAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteNegativeAdjustment")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteNegativeAdjustmentResult>>> DeleteNegativeAdjustmentAsync(DeleteNegativeAdjustmentRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteNegativeAdjustmentResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteNegativeAdjustmentAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetNegativeAdjustmentList")]
+    public async Task<ActionResult<ApiSuccessResult<GetNegativeAdjustmentListResult>>> GetNegativeAdjustmentListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetNegativeAdjustmentListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetNegativeAdjustmentListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetNegativeAdjustmentListAsync)}",
+            Content = response
+        });
+    }
+
+
+
+    [Authorize]
+    [HttpGet("GetNegativeAdjustmentStatusList")]
+    public async Task<ActionResult<ApiSuccessResult<GetNegativeAdjustmentStatusListResult>>> GetNegativeAdjustmentStatusListAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetNegativeAdjustmentStatusListRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetNegativeAdjustmentStatusListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetNegativeAdjustmentStatusListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetNegativeAdjustmentSingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetNegativeAdjustmentSingleResult>>> GetNegativeAdjustmentSingleAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string id
+    )
+    {
+        var request = new GetNegativeAdjustmentSingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetNegativeAdjustmentSingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetNegativeAdjustmentSingleAsync)}",
+            Content = response
+        });
+    }
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/NumberSequenceController.cs

@@ -0,0 +1,39 @@
+using Application.Features.NumberSequenceManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class NumberSequenceController : BaseApiController
+{
+    public NumberSequenceController(ISender sender) : base(sender)
+    {
+    }
+
+
+    [Authorize]
+    [HttpGet("GetNumberSequenceList")]
+    public async Task<ActionResult<ApiSuccessResult<GetNumberSequenceListResult>>> GetNumberSequenceListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetNumberSequenceListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetNumberSequenceListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetNumberSequenceListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/PositiveAdjustmentController.cs

@@ -0,0 +1,118 @@
+using Application.Features.PositiveAdjustmentManager.Commands;
+using Application.Features.PositiveAdjustmentManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class PositiveAdjustmentController : BaseApiController
+{
+    public PositiveAdjustmentController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreatePositiveAdjustment")]
+    public async Task<ActionResult<ApiSuccessResult<CreatePositiveAdjustmentResult>>> CreatePositiveAdjustmentAsync(CreatePositiveAdjustmentRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreatePositiveAdjustmentResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreatePositiveAdjustmentAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdatePositiveAdjustment")]
+    public async Task<ActionResult<ApiSuccessResult<UpdatePositiveAdjustmentResult>>> UpdatePositiveAdjustmentAsync(UpdatePositiveAdjustmentRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdatePositiveAdjustmentResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdatePositiveAdjustmentAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeletePositiveAdjustment")]
+    public async Task<ActionResult<ApiSuccessResult<DeletePositiveAdjustmentResult>>> DeletePositiveAdjustmentAsync(DeletePositiveAdjustmentRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeletePositiveAdjustmentResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeletePositiveAdjustmentAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetPositiveAdjustmentList")]
+    public async Task<ActionResult<ApiSuccessResult<GetPositiveAdjustmentListResult>>> GetPositiveAdjustmentListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetPositiveAdjustmentListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetPositiveAdjustmentListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetPositiveAdjustmentListAsync)}",
+            Content = response
+        });
+    }
+
+
+
+    [Authorize]
+    [HttpGet("GetPositiveAdjustmentStatusList")]
+    public async Task<ActionResult<ApiSuccessResult<GetPositiveAdjustmentStatusListResult>>> GetPositiveAdjustmentStatusListAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetPositiveAdjustmentStatusListRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetPositiveAdjustmentStatusListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetPositiveAdjustmentStatusListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetPositiveAdjustmentSingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetPositiveAdjustmentSingleResult>>> GetPositiveAdjustmentSingleAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string id
+    )
+    {
+        var request = new GetPositiveAdjustmentSingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetPositiveAdjustmentSingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetPositiveAdjustmentSingleAsync)}",
+            Content = response
+        });
+    }
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/ProductController.cs

@@ -0,0 +1,81 @@
+using Application.Features.ProductManager.Commands;
+using Application.Features.ProductManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class ProductController : BaseApiController
+{
+    public ProductController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateProduct")]
+    public async Task<ActionResult<ApiSuccessResult<CreateProductResult>>> CreateProductAsync(CreateProductRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateProductResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateProductAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateProduct")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateProductResult>>> UpdateProductAsync(UpdateProductRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateProductResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateProductAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteProduct")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteProductResult>>> DeleteProductAsync(DeleteProductRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteProductResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteProductAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetProductList")]
+    public async Task<ActionResult<ApiSuccessResult<GetProductListResult>>> GetProductListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetProductListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetProductListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetProductListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/ProductGroupController.cs

@@ -0,0 +1,81 @@
+using Application.Features.ProductGroupManager.Commands;
+using Application.Features.ProductGroupManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class ProductGroupController : BaseApiController
+{
+    public ProductGroupController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateProductGroup")]
+    public async Task<ActionResult<ApiSuccessResult<CreateProductGroupResult>>> CreateProductGroupAsync(CreateProductGroupRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateProductGroupResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateProductGroupAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateProductGroup")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateProductGroupResult>>> UpdateProductGroupAsync(UpdateProductGroupRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateProductGroupResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateProductGroupAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteProductGroup")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteProductGroupResult>>> DeleteProductGroupAsync(DeleteProductGroupRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteProductGroupResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteProductGroupAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetProductGroupList")]
+    public async Task<ActionResult<ApiSuccessResult<GetProductGroupListResult>>> GetProductGroupListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetProductGroupListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetProductGroupListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetProductGroupListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/PurchaseOrderController.cs

@@ -0,0 +1,117 @@
+using Application.Features.PurchaseOrderManager.Commands;
+using Application.Features.PurchaseOrderManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class PurchaseOrderController : BaseApiController
+{
+    public PurchaseOrderController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreatePurchaseOrder")]
+    public async Task<ActionResult<ApiSuccessResult<CreatePurchaseOrderResult>>> CreatePurchaseOrderAsync(CreatePurchaseOrderRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreatePurchaseOrderResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreatePurchaseOrderAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdatePurchaseOrder")]
+    public async Task<ActionResult<ApiSuccessResult<UpdatePurchaseOrderResult>>> UpdatePurchaseOrderAsync(UpdatePurchaseOrderRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdatePurchaseOrderResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdatePurchaseOrderAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeletePurchaseOrder")]
+    public async Task<ActionResult<ApiSuccessResult<DeletePurchaseOrderResult>>> DeletePurchaseOrderAsync(DeletePurchaseOrderRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeletePurchaseOrderResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeletePurchaseOrderAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetPurchaseOrderList")]
+    public async Task<ActionResult<ApiSuccessResult<GetPurchaseOrderListResult>>> GetPurchaseOrderListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetPurchaseOrderListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetPurchaseOrderListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetPurchaseOrderListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetPurchaseOrderStatusList")]
+    public async Task<ActionResult<ApiSuccessResult<GetPurchaseOrderStatusListResult>>> GetPurchaseOrderStatusListAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetPurchaseOrderStatusListRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetPurchaseOrderStatusListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetPurchaseOrderStatusListAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetPurchaseOrderSingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetPurchaseOrderSingleResult>>> GetPurchaseOrderSingleAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string id
+    )
+    {
+        var request = new GetPurchaseOrderSingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetPurchaseOrderSingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetPurchaseOrderSingleAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/PurchaseOrderItemController.cs

@@ -0,0 +1,99 @@
+using Application.Features.PurchaseOrderItemManager.Commands;
+using Application.Features.PurchaseOrderItemManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class PurchaseOrderItemController : BaseApiController
+{
+    public PurchaseOrderItemController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreatePurchaseOrderItem")]
+    public async Task<ActionResult<ApiSuccessResult<CreatePurchaseOrderItemResult>>> CreatePurchaseOrderItemAsync(CreatePurchaseOrderItemRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreatePurchaseOrderItemResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreatePurchaseOrderItemAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdatePurchaseOrderItem")]
+    public async Task<ActionResult<ApiSuccessResult<UpdatePurchaseOrderItemResult>>> UpdatePurchaseOrderItemAsync(UpdatePurchaseOrderItemRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdatePurchaseOrderItemResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdatePurchaseOrderItemAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeletePurchaseOrderItem")]
+    public async Task<ActionResult<ApiSuccessResult<DeletePurchaseOrderItemResult>>> DeletePurchaseOrderItemAsync(DeletePurchaseOrderItemRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeletePurchaseOrderItemResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeletePurchaseOrderItemAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetPurchaseOrderItemList")]
+    public async Task<ActionResult<ApiSuccessResult<GetPurchaseOrderItemListResult>>> GetPurchaseOrderItemListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetPurchaseOrderItemListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetPurchaseOrderItemListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetPurchaseOrderItemListAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetPurchaseOrderItemByPurchaseOrderIdList")]
+    public async Task<ActionResult<ApiSuccessResult<GetPurchaseOrderItemByPurchaseOrderIdListResult>>> GetPurchaseOrderItemByPurchaseOrderIdListAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string purchaseOrderId
+    )
+    {
+        var request = new GetPurchaseOrderItemByPurchaseOrderIdListRequest { PurchaseOrderId = purchaseOrderId };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetPurchaseOrderItemByPurchaseOrderIdListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetPurchaseOrderItemByPurchaseOrderIdListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/PurchaseReturnController.cs

@@ -0,0 +1,118 @@
+using Application.Features.PurchaseReturnManager.Commands;
+using Application.Features.PurchaseReturnManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class PurchaseReturnController : BaseApiController
+{
+    public PurchaseReturnController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreatePurchaseReturn")]
+    public async Task<ActionResult<ApiSuccessResult<CreatePurchaseReturnResult>>> CreatePurchaseReturnAsync(CreatePurchaseReturnRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreatePurchaseReturnResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreatePurchaseReturnAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdatePurchaseReturn")]
+    public async Task<ActionResult<ApiSuccessResult<UpdatePurchaseReturnResult>>> UpdatePurchaseReturnAsync(UpdatePurchaseReturnRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdatePurchaseReturnResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdatePurchaseReturnAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeletePurchaseReturn")]
+    public async Task<ActionResult<ApiSuccessResult<DeletePurchaseReturnResult>>> DeletePurchaseReturnAsync(DeletePurchaseReturnRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeletePurchaseReturnResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeletePurchaseReturnAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetPurchaseReturnList")]
+    public async Task<ActionResult<ApiSuccessResult<GetPurchaseReturnListResult>>> GetPurchaseReturnListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetPurchaseReturnListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetPurchaseReturnListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetPurchaseReturnListAsync)}",
+            Content = response
+        });
+    }
+
+
+
+    [Authorize]
+    [HttpGet("GetPurchaseReturnStatusList")]
+    public async Task<ActionResult<ApiSuccessResult<GetPurchaseReturnStatusListResult>>> GetPurchaseReturnStatusListAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetPurchaseReturnStatusListRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetPurchaseReturnStatusListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetPurchaseReturnStatusListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetPurchaseReturnSingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetPurchaseReturnSingleResult>>> GetPurchaseReturnSingleAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string id
+    )
+    {
+        var request = new GetPurchaseReturnSingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetPurchaseReturnSingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetPurchaseReturnSingleAsync)}",
+            Content = response
+        });
+    }
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/SalesOrderController.cs

@@ -0,0 +1,116 @@
+using Application.Features.SalesOrderManager.Commands;
+using Application.Features.SalesOrderManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class SalesOrderController : BaseApiController
+{
+    public SalesOrderController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateSalesOrder")]
+    public async Task<ActionResult<ApiSuccessResult<CreateSalesOrderResult>>> CreateSalesOrderAsync(CreateSalesOrderRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateSalesOrderResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateSalesOrderAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateSalesOrder")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateSalesOrderResult>>> UpdateSalesOrderAsync(UpdateSalesOrderRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateSalesOrderResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateSalesOrderAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteSalesOrder")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteSalesOrderResult>>> DeleteSalesOrderAsync(DeleteSalesOrderRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteSalesOrderResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteSalesOrderAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetSalesOrderList")]
+    public async Task<ActionResult<ApiSuccessResult<GetSalesOrderListResult>>> GetSalesOrderListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetSalesOrderListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetSalesOrderListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetSalesOrderListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetSalesOrderStatusList")]
+    public async Task<ActionResult<ApiSuccessResult<GetSalesOrderStatusListResult>>> GetSalesOrderStatusListAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetSalesOrderStatusListRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetSalesOrderStatusListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetSalesOrderStatusListAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetSalesOrderSingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetSalesOrderSingleResult>>> GetSalesOrderSingleAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string id
+    )
+    {
+        var request = new GetSalesOrderSingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetSalesOrderSingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetSalesOrderSingleAsync)}",
+            Content = response
+        });
+    }
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/SalesOrderItemController.cs

@@ -0,0 +1,99 @@
+using Application.Features.SalesOrderItemManager.Commands;
+using Application.Features.SalesOrderItemManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class SalesOrderItemController : BaseApiController
+{
+    public SalesOrderItemController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateSalesOrderItem")]
+    public async Task<ActionResult<ApiSuccessResult<CreateSalesOrderItemResult>>> CreateSalesOrderItemAsync(CreateSalesOrderItemRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateSalesOrderItemResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateSalesOrderItemAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateSalesOrderItem")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateSalesOrderItemResult>>> UpdateSalesOrderItemAsync(UpdateSalesOrderItemRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateSalesOrderItemResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateSalesOrderItemAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteSalesOrderItem")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteSalesOrderItemResult>>> DeleteSalesOrderItemAsync(DeleteSalesOrderItemRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteSalesOrderItemResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteSalesOrderItemAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetSalesOrderItemList")]
+    public async Task<ActionResult<ApiSuccessResult<GetSalesOrderItemListResult>>> GetSalesOrderItemListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetSalesOrderItemListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetSalesOrderItemListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetSalesOrderItemListAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetSalesOrderItemBySalesOrderIdList")]
+    public async Task<ActionResult<ApiSuccessResult<GetSalesOrderItemBySalesOrderIdListResult>>> GetSalesOrderItemBySalesOrderIdListAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string salesOrderId
+    )
+    {
+        var request = new GetSalesOrderItemBySalesOrderIdListRequest { SalesOrderId = salesOrderId };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetSalesOrderItemBySalesOrderIdListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetSalesOrderItemBySalesOrderIdListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/SalesReturnController.cs

@@ -0,0 +1,118 @@
+using Application.Features.SalesReturnManager.Commands;
+using Application.Features.SalesReturnManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class SalesReturnController : BaseApiController
+{
+    public SalesReturnController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateSalesReturn")]
+    public async Task<ActionResult<ApiSuccessResult<CreateSalesReturnResult>>> CreateSalesReturnAsync(CreateSalesReturnRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateSalesReturnResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateSalesReturnAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateSalesReturn")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateSalesReturnResult>>> UpdateSalesReturnAsync(UpdateSalesReturnRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateSalesReturnResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateSalesReturnAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteSalesReturn")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteSalesReturnResult>>> DeleteSalesReturnAsync(DeleteSalesReturnRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteSalesReturnResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteSalesReturnAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetSalesReturnList")]
+    public async Task<ActionResult<ApiSuccessResult<GetSalesReturnListResult>>> GetSalesReturnListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetSalesReturnListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetSalesReturnListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetSalesReturnListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetSalesReturnStatusList")]
+    public async Task<ActionResult<ApiSuccessResult<GetSalesReturnStatusListResult>>> GetSalesReturnStatusListAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetSalesReturnStatusListRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetSalesReturnStatusListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetSalesReturnStatusListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetSalesReturnSingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetSalesReturnSingleResult>>> GetSalesReturnSingleAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string id
+    )
+    {
+        var request = new GetSalesReturnSingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetSalesReturnSingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetSalesReturnSingleAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/ScrappingController.cs

@@ -0,0 +1,118 @@
+using Application.Features.ScrappingManager.Commands;
+using Application.Features.ScrappingManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class ScrappingController : BaseApiController
+{
+    public ScrappingController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateScrapping")]
+    public async Task<ActionResult<ApiSuccessResult<CreateScrappingResult>>> CreateScrappingAsync(CreateScrappingRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateScrappingResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateScrappingAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateScrapping")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateScrappingResult>>> UpdateScrappingAsync(UpdateScrappingRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateScrappingResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateScrappingAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteScrapping")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteScrappingResult>>> DeleteScrappingAsync(DeleteScrappingRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteScrappingResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteScrappingAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetScrappingList")]
+    public async Task<ActionResult<ApiSuccessResult<GetScrappingListResult>>> GetScrappingListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetScrappingListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetScrappingListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetScrappingListAsync)}",
+            Content = response
+        });
+    }
+
+
+
+
+    [Authorize]
+    [HttpGet("GetScrappingStatusList")]
+    public async Task<ActionResult<ApiSuccessResult<GetScrappingStatusListResult>>> GetScrappingStatusListAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetScrappingStatusListRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetScrappingStatusListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetScrappingStatusListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetScrappingSingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetScrappingSingleResult>>> GetScrappingSingleAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string id
+    )
+    {
+        var request = new GetScrappingSingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetScrappingSingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetScrappingSingleAsync)}",
+            Content = response
+        });
+    }
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/SecurityController.cs

@@ -0,0 +1,392 @@
+using Application.Features.SecurityManager.Commands;
+using Application.Features.SecurityManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Infrastructure.SecurityManager.Tokens;
+using Microsoft.Extensions.Options;
+
+namespace ASPNET.BackEnd.Controllers;
+
+
+[Route("api/[controller]")]
+public class SecurityController : BaseApiController
+{
+    private readonly IConfiguration _configuration;
+    private readonly TokenSettings _tokenSettings;
+    public SecurityController(ISender sender, IConfiguration configuration, IOptions<TokenSettings> tokenSettings) : base(sender)
+    {
+        _configuration = configuration;
+        _tokenSettings = tokenSettings.Value;
+    }
+
+    [AllowAnonymous]
+    [HttpPost("Login")]
+    public async Task<ActionResult<ApiSuccessResult<LoginResult>>> LoginAsync(LoginRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        // Set HttpOnly cookie for server-side page authorization
+        if (response?.Data?.AccessToken != null)
+        {
+            Response.Cookies.Append("accessToken", response.Data.AccessToken, new CookieOptions
+            {
+                HttpOnly = true,
+                Secure = true,
+                SameSite = SameSiteMode.Lax,
+                Expires = DateTime.UtcNow.AddMinutes(_tokenSettings.ExpireInMinute)
+            });
+        }
+
+        return Ok(new ApiSuccessResult<LoginResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(LoginAsync)}",
+            Content = response
+        });
+    }
+
+    [AllowAnonymous]
+    [HttpPost("Logout")]
+    public async Task<ActionResult<ApiSuccessResult<LogoutResult>>> LogoutAsync(LogoutRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        // Clear HttpOnly cookie on logout
+        Response.Cookies.Append("accessToken", "", new CookieOptions
+        {
+            HttpOnly = true,
+            Secure = true,
+            SameSite = SameSiteMode.Lax,
+            Expires = DateTime.UtcNow.AddDays(-1)
+        });
+
+        return Ok(new ApiSuccessResult<LogoutResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(LogoutAsync)}",
+            Content = response
+        });
+    }
+
+    [AllowAnonymous]
+    [HttpPost("Register")]
+    public async Task<ActionResult<ApiSuccessResult<RegisterResult>>> RegisterAsync(
+        RegisterRequest request,
+        CancellationToken cancellationToken
+        )
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<RegisterResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(RegisterAsync)}",
+            Content = response
+        });
+    }
+
+    [AllowAnonymous]
+    [HttpGet("ConfirmEmail")]
+    public async Task<ActionResult<ApiSuccessResult<ConfirmEmailResult>>> ConfirmEmailAsync(
+        [FromQuery] string email,
+        [FromQuery] string code,
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new ConfirmEmailRequest { Email = email, Code = code };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<ConfirmEmailResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(ConfirmEmailAsync)}",
+            Content = response
+        });
+    }
+
+
+    [AllowAnonymous]
+    [HttpPost("ForgotPassword")]
+    public async Task<ActionResult<ApiSuccessResult<ForgotPasswordResult>>> ForgotPasswordAsync(
+        ForgotPasswordRequest request,
+        CancellationToken cancellationToken
+        )
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<ForgotPasswordResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(ForgotPasswordAsync)}",
+            Content = response
+        });
+    }
+
+    [AllowAnonymous]
+    [HttpGet("ForgotPasswordConfirmation")]
+    public async Task<ActionResult<ApiSuccessResult<ForgotPasswordConfirmationResult>>> ForgotPasswordConfirmationAsync(
+        [FromQuery] string email,
+        [FromQuery] string code,
+        [FromQuery] string tempPassword,
+        CancellationToken cancellationToken)
+    {
+        var request = new ForgotPasswordConfirmationRequest { Email = email, TempPassword = tempPassword, Code = code };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<ForgotPasswordConfirmationResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(ForgotPasswordConfirmationAsync)}",
+            Content = response
+        });
+    }
+
+    [AllowAnonymous]
+    [HttpPost("RefreshToken")]
+    public async Task<ActionResult<ApiSuccessResult<RefreshTokenResult>>> RefreshTokenAsync(RefreshTokenRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        // Update HttpOnly cookie with new access token
+        if (response?.Data?.AccessToken != null)
+        {
+            Response.Cookies.Append("accessToken", response.Data.AccessToken, new CookieOptions
+            {
+                HttpOnly = true,
+                Secure = true,
+                SameSite = SameSiteMode.Lax,
+                Expires = DateTime.UtcNow.AddMinutes(_tokenSettings.ExpireInMinute)
+            });
+        }
+
+        return Ok(new ApiSuccessResult<RefreshTokenResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(RefreshTokenAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("ValidateToken")]
+    public async Task<ActionResult<ApiSuccessResult<ValidateTokenResult>>> ValidateTokenAsync(
+        ValidateTokenRequest request,
+        CancellationToken cancellationToken
+        )
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<ValidateTokenResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(ValidateTokenAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetMyProfileList")]
+    public async Task<ActionResult<ApiSuccessResult<GetMyProfileListResult>>> GetMyProfileListAsync(
+        [FromQuery] string userId,
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetMyProfileListRequest { UserId = userId };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetMyProfileListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetMyProfileListAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateMyProfile")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateMyProfileResult>>> UpdateMyProfileAsync(
+        UpdateMyProfileRequest request,
+        CancellationToken cancellationToken
+        )
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateMyProfileResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateMyProfileAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateMyProfilePassword")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateMyProfilePasswordResult>>> UpdateMyProfilePasswordAsync(
+        UpdateMyProfilePasswordRequest request,
+        CancellationToken cancellationToken
+        )
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateMyProfilePasswordResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateMyProfilePasswordAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetRoleList")]
+    public async Task<ActionResult<ApiSuccessResult<GetRoleListResult>>> GetRoleListAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetRoleListRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetRoleListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetRoleListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize(Roles = "Users")]
+    [HttpGet("GetUserList")]
+    public async Task<ActionResult<ApiSuccessResult<GetUserListResult>>> GetUserListAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetUserListRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetUserListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetUserListAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize(Roles = "Users")]
+    [HttpPost("CreateUser")]
+    public async Task<ActionResult<ApiSuccessResult<CreateUserResult>>> CreateUserAsync(
+        CreateUserRequest request,
+        CancellationToken cancellationToken
+        )
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateUserResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateUserAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize(Roles = "Users")]
+    [HttpPost("UpdateUser")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateUserResult>>> UpdateUserAsync(
+        UpdateUserRequest request,
+        CancellationToken cancellationToken
+        )
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateUserResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateUserAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize(Roles = "Users")]
+    [HttpPost("DeleteUser")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteUserResult>>> DeleteUserAsync(
+    DeleteUserRequest request,
+    CancellationToken cancellationToken
+    )
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteUserResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteUserAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize(Roles = "Users")]
+    [HttpPost("UpdatePasswordUser")]
+    public async Task<ActionResult<ApiSuccessResult<UpdatePasswordUserResult>>> UpdatePasswordUserAsync(
+    UpdatePasswordUserRequest request,
+    CancellationToken cancellationToken
+    )
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdatePasswordUserResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdatePasswordUserAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize(Roles = "Users")]
+    [HttpPost("GetUserRoles")]
+    public async Task<ActionResult<ApiSuccessResult<GetUserRolesResult>>> GetUserRolesAsync(GetUserRolesRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetUserRolesResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetUserRolesAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize(Roles = "Users")]
+    [HttpPost("UpdateUserRole")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateUserRoleResult>>> UpdateUserRoleAsync(UpdateUserRoleRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateUserRoleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateUserRoleAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateMyProfileAvatar")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateMyProfileAvatarResult>>> UpdateMyProfileAvatarAsync(UpdateMyProfileAvatarRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateMyProfileAvatarResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateMyProfileAvatarAsync)}",
+            Content = response
+        });
+    }
+
+}
+

Presentation/ASPNET/BackEnd/Controllers/StockCountController.cs

@@ -0,0 +1,118 @@
+using Application.Features.StockCountManager.Commands;
+using Application.Features.StockCountManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class StockCountController : BaseApiController
+{
+    public StockCountController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateStockCount")]
+    public async Task<ActionResult<ApiSuccessResult<CreateStockCountResult>>> CreateStockCountAsync(CreateStockCountRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateStockCountResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateStockCountAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateStockCount")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateStockCountResult>>> UpdateStockCountAsync(UpdateStockCountRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateStockCountResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateStockCountAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteStockCount")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteStockCountResult>>> DeleteStockCountAsync(DeleteStockCountRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteStockCountResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteStockCountAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetStockCountList")]
+    public async Task<ActionResult<ApiSuccessResult<GetStockCountListResult>>> GetStockCountListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetStockCountListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetStockCountListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetStockCountListAsync)}",
+            Content = response
+        });
+    }
+
+
+
+
+    [Authorize]
+    [HttpGet("GetStockCountStatusList")]
+    public async Task<ActionResult<ApiSuccessResult<GetStockCountStatusListResult>>> GetStockCountStatusListAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetStockCountStatusListRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetStockCountStatusListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetStockCountStatusListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetStockCountSingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetStockCountSingleResult>>> GetStockCountSingleAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string id
+    )
+    {
+        var request = new GetStockCountSingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetStockCountSingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetStockCountSingleAsync)}",
+            Content = response
+        });
+    }
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/TaxController.cs

@@ -0,0 +1,82 @@
+using Application.Features.TaxManager.Commands;
+using Application.Features.TaxManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class TaxController : BaseApiController
+{
+    public TaxController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateTax")]
+    public async Task<ActionResult<ApiSuccessResult<CreateTaxResult>>> CreateTaxAsync(CreateTaxRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateTaxResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateTaxAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateTax")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateTaxResult>>> UpdateTaxAsync(UpdateTaxRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateTaxResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateTaxAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteTax")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteTaxResult>>> DeleteTaxAsync(DeleteTaxRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteTaxResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteTaxAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetTaxList")]
+    public async Task<ActionResult<ApiSuccessResult<GetTaxListResult>>> GetTaxListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetTaxListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetTaxListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetTaxListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/TodoController.cs

@@ -0,0 +1,99 @@
+using Application.Features.TodoManager.Commands;
+using Application.Features.TodoManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class TodoController : BaseApiController
+{
+    public TodoController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateTodo")]
+    public async Task<ActionResult<ApiSuccessResult<CreateTodoResult>>> CreateTodoAsync(CreateTodoRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateTodoResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateTodoAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateTodo")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateTodoResult>>> UpdateTodoAsync(UpdateTodoRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateTodoResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateTodoAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteTodo")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteTodoResult>>> DeleteTodoAsync(DeleteTodoRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteTodoResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteTodoAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetTodoSingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetTodoSingleResult>>> GetTodoSingleAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] string id
+        )
+    {
+        var request = new GetTodoSingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetTodoSingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetTodoSingleAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetTodoList")]
+    public async Task<ActionResult<ApiSuccessResult<GetTodoListResult>>> GetTodoListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetTodoListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetTodoListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetTodoListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/TodoItemController.cs

@@ -0,0 +1,99 @@
+using Application.Features.TodoItemManager.Commands;
+using Application.Features.TodoItemManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class TodoItemController : BaseApiController
+{
+    public TodoItemController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateTodoItem")]
+    public async Task<ActionResult<ApiSuccessResult<CreateTodoItemResult>>> CreateTodoItemAsync(CreateTodoItemRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateTodoItemResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateTodoItemAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateTodoItem")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateTodoItemResult>>> UpdateTodoItemAsync(UpdateTodoItemRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateTodoItemResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateTodoItemAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteTodoItem")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteTodoItemResult>>> DeleteTodoItemAsync(DeleteTodoItemRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteTodoItemResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteTodoItemAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetTodoItemSingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetTodoItemSingleResult>>> GetTodoItemSingleAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] string id
+        )
+    {
+        var request = new GetTodoItemSingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetTodoItemSingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetTodoItemSingleAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetTodoItemList")]
+    public async Task<ActionResult<ApiSuccessResult<GetTodoItemListResult>>> GetTodoItemListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetTodoItemListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetTodoItemListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetTodoItemListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/TransferInController.cs

@@ -0,0 +1,118 @@
+using Application.Features.TransferInManager.Commands;
+using Application.Features.TransferInManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class TransferInController : BaseApiController
+{
+    public TransferInController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateTransferIn")]
+    public async Task<ActionResult<ApiSuccessResult<CreateTransferInResult>>> CreateTransferInAsync(CreateTransferInRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateTransferInResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateTransferInAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateTransferIn")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateTransferInResult>>> UpdateTransferInAsync(UpdateTransferInRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateTransferInResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateTransferInAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteTransferIn")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteTransferInResult>>> DeleteTransferInAsync(DeleteTransferInRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteTransferInResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteTransferInAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetTransferInList")]
+    public async Task<ActionResult<ApiSuccessResult<GetTransferInListResult>>> GetTransferInListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetTransferInListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetTransferInListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetTransferInListAsync)}",
+            Content = response
+        });
+    }
+
+
+
+    [Authorize]
+    [HttpGet("GetTransferInStatusList")]
+    public async Task<ActionResult<ApiSuccessResult<GetTransferInStatusListResult>>> GetTransferInStatusListAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetTransferInStatusListRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetTransferInStatusListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetTransferInStatusListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetTransferInSingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetTransferInSingleResult>>> GetTransferInSingleAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string id
+    )
+    {
+        var request = new GetTransferInSingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetTransferInSingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetTransferInSingleAsync)}",
+            Content = response
+        });
+    }
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/TransferOutController.cs

@@ -0,0 +1,118 @@
+using Application.Features.TransferOutManager.Commands;
+using Application.Features.TransferOutManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class TransferOutController : BaseApiController
+{
+    public TransferOutController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateTransferOut")]
+    public async Task<ActionResult<ApiSuccessResult<CreateTransferOutResult>>> CreateTransferOutAsync(CreateTransferOutRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateTransferOutResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateTransferOutAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateTransferOut")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateTransferOutResult>>> UpdateTransferOutAsync(UpdateTransferOutRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateTransferOutResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateTransferOutAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteTransferOut")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteTransferOutResult>>> DeleteTransferOutAsync(DeleteTransferOutRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteTransferOutResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteTransferOutAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetTransferOutList")]
+    public async Task<ActionResult<ApiSuccessResult<GetTransferOutListResult>>> GetTransferOutListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetTransferOutListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetTransferOutListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetTransferOutListAsync)}",
+            Content = response
+        });
+    }
+
+
+
+    [Authorize]
+    [HttpGet("GetTransferOutStatusList")]
+    public async Task<ActionResult<ApiSuccessResult<GetTransferOutStatusListResult>>> GetTransferOutStatusListAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetTransferOutStatusListRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetTransferOutStatusListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetTransferOutStatusListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetTransferOutSingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetTransferOutSingleResult>>> GetTransferOutSingleAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string id
+    )
+    {
+        var request = new GetTransferOutSingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetTransferOutSingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetTransferOutSingleAsync)}",
+            Content = response
+        });
+    }
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/UnitMeasureController.cs

@@ -0,0 +1,81 @@
+using Application.Features.UnitMeasureManager.Commands;
+using Application.Features.UnitMeasureManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class UnitMeasureController : BaseApiController
+{
+    public UnitMeasureController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateUnitMeasure")]
+    public async Task<ActionResult<ApiSuccessResult<CreateUnitMeasureResult>>> CreateUnitMeasureAsync(CreateUnitMeasureRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateUnitMeasureResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateUnitMeasureAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateUnitMeasure")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateUnitMeasureResult>>> UpdateUnitMeasureAsync(UpdateUnitMeasureRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateUnitMeasureResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateUnitMeasureAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteUnitMeasure")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteUnitMeasureResult>>> DeleteUnitMeasureAsync(DeleteUnitMeasureRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteUnitMeasureResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteUnitMeasureAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetUnitMeasureList")]
+    public async Task<ActionResult<ApiSuccessResult<GetUnitMeasureListResult>>> GetUnitMeasureListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetUnitMeasureListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetUnitMeasureListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetUnitMeasureListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/VendorCategoryController.cs

@@ -0,0 +1,81 @@
+using Application.Features.VendorCategoryManager.Commands;
+using Application.Features.VendorCategoryManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class VendorCategoryController : BaseApiController
+{
+    public VendorCategoryController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateVendorCategory")]
+    public async Task<ActionResult<ApiSuccessResult<CreateVendorCategoryResult>>> CreateVendorCategoryAsync(CreateVendorCategoryRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateVendorCategoryResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateVendorCategoryAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateVendorCategory")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateVendorCategoryResult>>> UpdateVendorCategoryAsync(UpdateVendorCategoryRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateVendorCategoryResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateVendorCategoryAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteVendorCategory")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteVendorCategoryResult>>> DeleteVendorCategoryAsync(DeleteVendorCategoryRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteVendorCategoryResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteVendorCategoryAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetVendorCategoryList")]
+    public async Task<ActionResult<ApiSuccessResult<GetVendorCategoryListResult>>> GetVendorCategoryListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetVendorCategoryListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetVendorCategoryListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetVendorCategoryListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/VendorContactController.cs

@@ -0,0 +1,98 @@
+using Application.Features.VendorContactManager.Commands;
+using Application.Features.VendorContactManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class VendorContactController : BaseApiController
+{
+    public VendorContactController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateVendorContact")]
+    public async Task<ActionResult<ApiSuccessResult<CreateVendorContactResult>>> CreateVendorContactAsync(CreateVendorContactRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateVendorContactResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateVendorContactAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateVendorContact")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateVendorContactResult>>> UpdateVendorContactAsync(UpdateVendorContactRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateVendorContactResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateVendorContactAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteVendorContact")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteVendorContactResult>>> DeleteVendorContactAsync(DeleteVendorContactRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteVendorContactResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteVendorContactAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetVendorContactList")]
+    public async Task<ActionResult<ApiSuccessResult<GetVendorContactListResult>>> GetVendorContactListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetVendorContactListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetVendorContactListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetVendorContactListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetVendorContactByVendorIdList")]
+    public async Task<ActionResult<ApiSuccessResult<GetVendorContactByVendorIdListResult>>> GetVendorContactByVendorIdListAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string vendorId
+    )
+    {
+        var request = new GetVendorContactByVendorIdListRequest { VendorId = vendorId };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetVendorContactByVendorIdListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetVendorContactByVendorIdListAsync)}",
+            Content = response
+        });
+    }
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/VendorController.cs

@@ -0,0 +1,81 @@
+using Application.Features.VendorManager.Commands;
+using Application.Features.VendorManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class VendorController : BaseApiController
+{
+    public VendorController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateVendor")]
+    public async Task<ActionResult<ApiSuccessResult<CreateVendorResult>>> CreateVendorAsync(CreateVendorRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateVendorResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateVendorAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateVendor")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateVendorResult>>> UpdateVendorAsync(UpdateVendorRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateVendorResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateVendorAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteVendor")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteVendorResult>>> DeleteVendorAsync(DeleteVendorRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteVendorResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteVendorAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetVendorList")]
+    public async Task<ActionResult<ApiSuccessResult<GetVendorListResult>>> GetVendorListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetVendorListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetVendorListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetVendorListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/VendorGroupController.cs

@@ -0,0 +1,81 @@
+using Application.Features.VendorGroupManager.Commands;
+using Application.Features.VendorGroupManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class VendorGroupController : BaseApiController
+{
+    public VendorGroupController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateVendorGroup")]
+    public async Task<ActionResult<ApiSuccessResult<CreateVendorGroupResult>>> CreateVendorGroupAsync(CreateVendorGroupRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateVendorGroupResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateVendorGroupAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateVendorGroup")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateVendorGroupResult>>> UpdateVendorGroupAsync(UpdateVendorGroupRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateVendorGroupResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateVendorGroupAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteVendorGroup")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteVendorGroupResult>>> DeleteVendorGroupAsync(DeleteVendorGroupRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteVendorGroupResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteVendorGroupAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetVendorGroupList")]
+    public async Task<ActionResult<ApiSuccessResult<GetVendorGroupListResult>>> GetVendorGroupListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetVendorGroupListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetVendorGroupListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetVendorGroupListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+

Presentation/ASPNET/BackEnd/Controllers/WarehouseController.cs

@@ -0,0 +1,81 @@
+using Application.Features.WarehouseManager.Commands;
+using Application.Features.WarehouseManager.Queries;
+using ASPNET.BackEnd.Common.Base;
+using ASPNET.BackEnd.Common.Models;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ASPNET.BackEnd.Controllers;
+
+[Route("api/[controller]")]
+public class WarehouseController : BaseApiController
+{
+    public WarehouseController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateWarehouse")]
+    public async Task<ActionResult<ApiSuccessResult<CreateWarehouseResult>>> CreateWarehouseAsync(CreateWarehouseRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateWarehouseResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateWarehouseAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateWarehouse")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateWarehouseResult>>> UpdateWarehouseAsync(UpdateWarehouseRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateWarehouseResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateWarehouseAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteWarehouse")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteWarehouseResult>>> DeleteWarehouseAsync(DeleteWarehouseRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteWarehouseResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteWarehouseAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetWarehouseList")]
+    public async Task<ActionResult<ApiSuccessResult<GetWarehouseListResult>>> GetWarehouseListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetWarehouseListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetWarehouseListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetWarehouseListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+