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/BudgetController.cs

@@ -0,0 +1,139 @@
+using Application.Features.BudgetManager.Commands;
+using Application.Features.BudgetManager.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 BudgetController : BaseApiController
+{
+    public BudgetController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateBudget")]
+    public async Task<ActionResult<ApiSuccessResult<CreateBudgetResult>>> CreateBudgetAsync(CreateBudgetRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateBudgetResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateBudgetAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateBudget")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateBudgetResult>>> UpdateBudgetAsync(UpdateBudgetRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateBudgetResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateBudgetAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteBudget")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteBudgetResult>>> DeleteBudgetAsync(DeleteBudgetRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteBudgetResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteBudgetAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetBudgetList")]
+    public async Task<ActionResult<ApiSuccessResult<GetBudgetListResult>>> GetBudgetListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetBudgetListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetBudgetListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetBudgetListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetBudgetStatusList")]
+    public async Task<ActionResult<ApiSuccessResult<GetBudgetStatusListResult>>> GetBudgetStatusListAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetBudgetStatusListRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetBudgetStatusListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetBudgetStatusListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetBudgetSingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetBudgetSingleResult>>> GetBudgetSingleAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string id
+    )
+    {
+        var request = new GetBudgetSingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetBudgetSingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetBudgetSingleAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetBudgetByCampaignIdList")]
+    public async Task<ActionResult<ApiSuccessResult<GetBudgetByCampaignIdListResult>>> GetBudgetByCampaignIdListAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string campaignId
+    )
+    {
+        var request = new GetBudgetByCampaignIdListRequest { CampaignId = campaignId };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetBudgetByCampaignIdListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetBudgetByCampaignIdListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+
+
+

Presentation/ASPNET/BackEnd/Controllers/CampaignController.cs

@@ -0,0 +1,121 @@
+using Application.Features.CampaignManager.Commands;
+using Application.Features.CampaignManager.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 CampaignController : BaseApiController
+{
+    public CampaignController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateCampaign")]
+    public async Task<ActionResult<ApiSuccessResult<CreateCampaignResult>>> CreateCampaignAsync(CreateCampaignRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateCampaignResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateCampaignAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateCampaign")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateCampaignResult>>> UpdateCampaignAsync(UpdateCampaignRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateCampaignResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateCampaignAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteCampaign")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteCampaignResult>>> DeleteCampaignAsync(DeleteCampaignRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteCampaignResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteCampaignAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetCampaignList")]
+    public async Task<ActionResult<ApiSuccessResult<GetCampaignListResult>>> GetCampaignListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetCampaignListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetCampaignListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetCampaignListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetCampaignStatusList")]
+    public async Task<ActionResult<ApiSuccessResult<GetCampaignStatusListResult>>> GetCampaignStatusListAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetCampaignStatusListRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetCampaignStatusListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetCampaignStatusListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetCampaignSingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetCampaignSingleResult>>> GetCampaignSingleAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string id
+    )
+    {
+        var request = new GetCampaignSingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetCampaignSingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetCampaignSingleAsync)}",
+            Content = response
+        });
+    }
+
+
+
+}
+
+
+
+

Presentation/ASPNET/BackEnd/Controllers/CompanyController.cs

@@ -0,0 +1,73 @@
+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,83 @@
+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,101 @@
+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,83 @@
+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,83 @@
+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,170 @@
+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("GetCRMDashboard")]
+    public async Task<ActionResult<ApiSuccessResult<GetCRMDashboardResult>>> GetCRMDashboardAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetCRMDashboardRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetCRMDashboardResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetCRMDashboardAsync)}",
+            Content = response
+        });
+    }
+
+
+
+
+    [Authorize]
+    [HttpGet("GetLeadPipelineFunnel")]
+    public async Task<ActionResult<ApiSuccessResult<GetLeadPipelineFunnelResult>>> GetLeadPipelineFunnelAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetLeadPipelineFunnelRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetLeadPipelineFunnelResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetLeadPipelineFunnelAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetSalesTeamLeadClosing")]
+    public async Task<ActionResult<ApiSuccessResult<GetSalesTeamLeadClosingResult>>> GetSalesTeamLeadClosingAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetSalesTeamLeadClosingRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetSalesTeamLeadClosingResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetSalesTeamLeadClosingAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetCampaignByStatus")]
+    public async Task<ActionResult<ApiSuccessResult<GetCampaignByStatusResult>>> GetCampaignByStatusAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetCampaignByStatusRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetCampaignByStatusResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetCampaignByStatusAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetLeadActivityByType")]
+    public async Task<ActionResult<ApiSuccessResult<GetLeadActivityByTypeResult>>> GetLeadActivityByTypeAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetLeadActivityByTypeRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetLeadActivityByTypeResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetLeadActivityByTypeAsync)}",
+            Content = response
+        });
+    }
+
+
+    [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
+        });
+    }
+
+
+
+
+}
+
+
+
+

Presentation/ASPNET/BackEnd/Controllers/ExpenseController.cs

@@ -0,0 +1,139 @@
+using Application.Features.ExpenseManager.Commands;
+using Application.Features.ExpenseManager.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 ExpenseController : BaseApiController
+{
+    public ExpenseController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateExpense")]
+    public async Task<ActionResult<ApiSuccessResult<CreateExpenseResult>>> CreateExpenseAsync(CreateExpenseRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateExpenseResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateExpenseAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateExpense")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateExpenseResult>>> UpdateExpenseAsync(UpdateExpenseRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateExpenseResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateExpenseAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteExpense")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteExpenseResult>>> DeleteExpenseAsync(DeleteExpenseRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteExpenseResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteExpenseAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetExpenseList")]
+    public async Task<ActionResult<ApiSuccessResult<GetExpenseListResult>>> GetExpenseListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetExpenseListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetExpenseListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetExpenseListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetExpenseStatusList")]
+    public async Task<ActionResult<ApiSuccessResult<GetExpenseStatusListResult>>> GetExpenseStatusListAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetExpenseStatusListRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetExpenseStatusListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetExpenseStatusListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetExpenseSingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetExpenseSingleResult>>> GetExpenseSingleAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string id
+    )
+    {
+        var request = new GetExpenseSingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetExpenseSingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetExpenseSingleAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetExpenseByCampaignIdList")]
+    public async Task<ActionResult<ApiSuccessResult<GetExpenseByCampaignIdListResult>>> GetExpenseByCampaignIdListAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string campaignId
+    )
+    {
+        var request = new GetExpenseByCampaignIdListRequest { CampaignId = campaignId };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetExpenseByCampaignIdListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetExpenseByCampaignIdListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+
+
+

Presentation/ASPNET/BackEnd/Controllers/FileDocumentController.cs

@@ -0,0 +1,93 @@
+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,93 @@
+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/LeadActivityController.cs

@@ -0,0 +1,140 @@
+using Application.Features.DeliveryOrderManager.Queries;
+using Application.Features.LeadActivityManager.Commands;
+using Application.Features.LeadActivityManager.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 LeadActivityController : BaseApiController
+{
+    public LeadActivityController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateLeadActivity")]
+    public async Task<ActionResult<ApiSuccessResult<CreateLeadActivityResult>>> CreateLeadActivityAsync(CreateLeadActivityRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateLeadActivityResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateLeadActivityAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateLeadActivity")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateLeadActivityResult>>> UpdateLeadActivityAsync(UpdateLeadActivityRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateLeadActivityResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateLeadActivityAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteLeadActivity")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteLeadActivityResult>>> DeleteLeadActivityAsync(DeleteLeadActivityRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteLeadActivityResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteLeadActivityAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetLeadActivityList")]
+    public async Task<ActionResult<ApiSuccessResult<GetLeadActivityListResult>>> GetLeadActivityListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetLeadActivityListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetLeadActivityListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetLeadActivityListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetLeadActivitySingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetLeadActivitySingleResult>>> GetLeadActivitySingleAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string id
+    )
+    {
+        var request = new GetLeadActivitySingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetLeadActivitySingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetLeadActivitySingleAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetLeadActivityByLeadIdList")]
+    public async Task<ActionResult<ApiSuccessResult<GetLeadActivityByLeadIdListResult>>> GetLeadActivityByLeadIdListAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string leadId
+    )
+    {
+        var request = new GetLeadActivityByLeadIdListRequest { LeadId = leadId };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetLeadActivityByLeadIdListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetLeadActivityByLeadIdListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetLeadActivityTypeList")]
+    public async Task<ActionResult<ApiSuccessResult<GetLeadActivityTypeListResult>>> GetLeadActivityTypeListAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetLeadActivityTypeListRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetLeadActivityTypeListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetLeadActivityTypeListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+
+
+

Presentation/ASPNET/BackEnd/Controllers/LeadContactController.cs

@@ -0,0 +1,121 @@
+using Application.Features.LeadContactManager.Commands;
+using Application.Features.LeadContactManager.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 LeadContactController : BaseApiController
+{
+    public LeadContactController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateLeadContact")]
+    public async Task<ActionResult<ApiSuccessResult<CreateLeadContactResult>>> CreateLeadContactAsync(CreateLeadContactRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateLeadContactResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateLeadContactAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateLeadContact")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateLeadContactResult>>> UpdateLeadContactAsync(UpdateLeadContactRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateLeadContactResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateLeadContactAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteLeadContact")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteLeadContactResult>>> DeleteLeadContactAsync(DeleteLeadContactRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteLeadContactResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteLeadContactAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetLeadContactList")]
+    public async Task<ActionResult<ApiSuccessResult<GetLeadContactListResult>>> GetLeadContactListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetLeadContactListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetLeadContactListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetLeadContactListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetLeadContactSingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetLeadContactSingleResult>>> GetLeadContactSingleAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string id
+    )
+    {
+        var request = new GetLeadContactSingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetLeadContactSingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetLeadContactSingleAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetLeadContactByLeadIdList")]
+    public async Task<ActionResult<ApiSuccessResult<GetLeadContactByLeadIdListResult>>> GetLeadContactByLeadIdListAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string leadId
+    )
+    {
+        var request = new GetLeadContactByLeadIdListRequest { LeadId = leadId };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetLeadContactByLeadIdListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetLeadContactByLeadIdListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+
+
+

Presentation/ASPNET/BackEnd/Controllers/LeadController.cs

@@ -0,0 +1,160 @@
+using Application.Features.CampaignManager.Queries;
+using Application.Features.LeadManager.Commands;
+using Application.Features.LeadManager.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 LeadController : BaseApiController
+{
+    public LeadController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateLead")]
+    public async Task<ActionResult<ApiSuccessResult<CreateLeadResult>>> CreateLeadAsync(CreateLeadRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateLeadResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateLeadAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateLead")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateLeadResult>>> UpdateLeadAsync(UpdateLeadRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateLeadResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateLeadAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteLead")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteLeadResult>>> DeleteLeadAsync(DeleteLeadRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteLeadResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteLeadAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetLeadList")]
+    public async Task<ActionResult<ApiSuccessResult<GetLeadListResult>>> GetLeadListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetLeadListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetLeadListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetLeadListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetLeadSingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetLeadSingleResult>>> GetLeadSingleAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string id
+    )
+    {
+        var request = new GetLeadSingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetLeadSingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetLeadSingleAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetLeadByCampaignIdList")]
+    public async Task<ActionResult<ApiSuccessResult<GetLeadByCampaignIdListResult>>> GetLeadByCampaignIdListAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string id
+    )
+    {
+        var request = new GetLeadByCampaignIdListRequest { CampaignId = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetLeadByCampaignIdListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetLeadByCampaignIdListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetPipelineStageList")]
+    public async Task<ActionResult<ApiSuccessResult<GetPipelineStageListResult>>> GetPipelineStageListAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetPipelineStageListRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetPipelineStageListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetPipelineStageListAsync)}",
+            Content = response
+        });
+    }
+
+
+
+
+    [Authorize]
+    [HttpGet("GetClosingStatusList")]
+    public async Task<ActionResult<ApiSuccessResult<GetClosingStatusListResult>>> GetClosingStatusListAsync(
+        CancellationToken cancellationToken
+        )
+    {
+        var request = new GetClosingStatusListRequest { };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetClosingStatusListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetClosingStatusListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+
+
+

Presentation/ASPNET/BackEnd/Controllers/NumberSequenceController.cs

@@ -0,0 +1,41 @@
+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/ProductController.cs

@@ -0,0 +1,83 @@
+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,83 @@
+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,119 @@
+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,101 @@
+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/SalesOrderController.cs

@@ -0,0 +1,118 @@
+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,101 @@
+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/SalesRepresentativeController.cs

@@ -0,0 +1,121 @@
+using Application.Features.SalesRepresentativeManager.Commands;
+using Application.Features.SalesRepresentativeManager.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 SalesRepresentativeController : BaseApiController
+{
+    public SalesRepresentativeController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateSalesRepresentative")]
+    public async Task<ActionResult<ApiSuccessResult<CreateSalesRepresentativeResult>>> CreateSalesRepresentativeAsync(CreateSalesRepresentativeRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateSalesRepresentativeResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateSalesRepresentativeAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateSalesRepresentative")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateSalesRepresentativeResult>>> UpdateSalesRepresentativeAsync(UpdateSalesRepresentativeRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateSalesRepresentativeResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateSalesRepresentativeAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteSalesRepresentative")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteSalesRepresentativeResult>>> DeleteSalesRepresentativeAsync(DeleteSalesRepresentativeRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteSalesRepresentativeResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteSalesRepresentativeAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetSalesRepresentativeList")]
+    public async Task<ActionResult<ApiSuccessResult<GetSalesRepresentativeListResult>>> GetSalesRepresentativeListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetSalesRepresentativeListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetSalesRepresentativeListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetSalesRepresentativeListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetSalesRepresentativeSingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetSalesRepresentativeSingleResult>>> GetSalesRepresentativeSingleAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string id
+    )
+    {
+        var request = new GetSalesRepresentativeSingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetSalesRepresentativeSingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetSalesRepresentativeSingleAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetSalesRepresentativeBySalesTeamIdList")]
+    public async Task<ActionResult<ApiSuccessResult<GetSalesRepresentativeBySalesTeamIdListResult>>> GetSalesRepresentativeBySalesTeamIdListAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string id
+    )
+    {
+        var request = new GetSalesRepresentativeBySalesTeamIdListRequest { SalesTeamId = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetSalesRepresentativeBySalesTeamIdListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetSalesRepresentativeBySalesTeamIdListAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+
+
+

Presentation/ASPNET/BackEnd/Controllers/SalesTeamController.cs

@@ -0,0 +1,102 @@
+using Application.Features.SalesTeamManager.Commands;
+using Application.Features.SalesTeamManager.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 SalesTeamController : BaseApiController
+{
+    public SalesTeamController(ISender sender) : base(sender)
+    {
+    }
+
+    [Authorize]
+    [HttpPost("CreateSalesTeam")]
+    public async Task<ActionResult<ApiSuccessResult<CreateSalesTeamResult>>> CreateSalesTeamAsync(CreateSalesTeamRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<CreateSalesTeamResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(CreateSalesTeamAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("UpdateSalesTeam")]
+    public async Task<ActionResult<ApiSuccessResult<UpdateSalesTeamResult>>> UpdateSalesTeamAsync(UpdateSalesTeamRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<UpdateSalesTeamResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(UpdateSalesTeamAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpPost("DeleteSalesTeam")]
+    public async Task<ActionResult<ApiSuccessResult<DeleteSalesTeamResult>>> DeleteSalesTeamAsync(DeleteSalesTeamRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<DeleteSalesTeamResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(DeleteSalesTeamAsync)}",
+            Content = response
+        });
+    }
+
+    [Authorize]
+    [HttpGet("GetSalesTeamList")]
+    public async Task<ActionResult<ApiSuccessResult<GetSalesTeamListResult>>> GetSalesTeamListAsync(
+        CancellationToken cancellationToken,
+        [FromQuery] bool isDeleted = false
+        )
+    {
+        var request = new GetSalesTeamListRequest { IsDeleted = isDeleted };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetSalesTeamListResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetSalesTeamListAsync)}",
+            Content = response
+        });
+    }
+
+
+    [Authorize]
+    [HttpGet("GetSalesTeamSingle")]
+    public async Task<ActionResult<ApiSuccessResult<GetSalesTeamSingleResult>>> GetSalesTeamSingleAsync(
+    CancellationToken cancellationToken,
+    [FromQuery] string id
+    )
+    {
+        var request = new GetSalesTeamSingleRequest { Id = id };
+        var response = await _sender.Send(request, cancellationToken);
+
+        return Ok(new ApiSuccessResult<GetSalesTeamSingleResult>
+        {
+            Code = StatusCodes.Status200OK,
+            Message = $"Success executing {nameof(GetSalesTeamSingleAsync)}",
+            Content = response
+        });
+    }
+
+
+}
+
+
+
+

Presentation/ASPNET/BackEnd/Controllers/SecurityController.cs

@@ -0,0 +1,356 @@
+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;
+
+namespace ASPNET.BackEnd.Controllers;
+
+
+[Route("api/[controller]")]
+public class SecurityController : BaseApiController
+{
+    private readonly IConfiguration _configuration;
+    public SecurityController(ISender sender, IConfiguration configuration) : base(sender)
+    {
+        _configuration = configuration;
+    }
+
+    [AllowAnonymous]
+    [HttpPost("Login")]
+    public async Task<ActionResult<ApiSuccessResult<LoginResult>>> LoginAsync(LoginRequest request, CancellationToken cancellationToken)
+    {
+        var response = await _sender.Send(request, cancellationToken);
+
+        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);
+
+        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);
+
+        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]
+    [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]
+    [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]
+    [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]
+    [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]
+    [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]
+    [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]
+    [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/TaxController.cs

@@ -0,0 +1,84 @@
+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,101 @@
+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,101 @@
+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/UnitMeasureController.cs

@@ -0,0 +1,83 @@
+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,83 @@
+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,100 @@
+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,83 @@
+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,83 @@
+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
+        });
+    }
+
+
+}
+
+
+
+