=== .agent\skills\controller-authorization\SKILL.md ===
---
name: ControllerAuthorization
description: H����>ng d���n cA�i �`���t phA�n quy��?n (role-based authorization) chu��cn cho ASP.NET Core Controller trong d��� A�n Ladaer.BackEnd.
---

# Controller Authorization Skill

## T��ng quan

M��-i action trong Controller ph���i �`�����c g��_n attribute `[Authorize(Roles = "...")]` ��Y c���p **action**, KHA"NG ch��% dA1ng `[Authorize]` chung ��Y c���p class. �?i��?u nA�y giA�p ki���m soA�t quy��?n truy c��-p chi ti���t theo t���ng nghi���p v���.

## Quy t��_c �`���t tA�n Role

TA�n role theo format: **`{ControllerName}.{ActionName}`**

- `ControllerName`: TA�n controller **khA'ng cA3 h��-u t��` "Controller"** (vA- d���: `Premise`, `Order`, `PremiseScoring`).
- `ActionName`: TA�n method action trong controller (vA- d���: `Search`, `GetById`, `CreateOrUpdate`, `Delete`).

### VA- d���

| Controller | Action | Role |
|---|---|---|
| `OrderController` | `Search` | `Order.Search` |
| `OrderController` | `CreateOrder` | `Order.CreateOrder` |
| `PremiseController` | `Search` | `Premise.Search` |
| `PremiseController` | `CreateOrUpdate` | `Premise.CreateOrUpdate` |
| `PremiseController` | `Delete` | `Premise.Delete` |
| `PremiseScoringController` | `SearchCriteria` | `PremiseScoring.SearchCriteria` |

## C���u trA�c attribute chu��cn

```csharp
[HttpPost("Search")]
[Authorize(Roles = "ControllerName.ActionName")]
public async Task<IActionResult> Search([FromBody] SmartTableParam param)
{
    var result = await _service.Search(param);
    return Ok(result);
}
```

=== .agent\skills\service-patterns\SKILL.md ===
---
name: ServicePatterns
description: Quy t��_c chu��cn cho Service layer (Interface, Implementation, DI, Repository, Result patterns).
---

# Service Layer Patterns

TA�i li���u nA�y mA' t��� cA�c quy t��_c b��_t bu��Tc khi t���o Service trong d��� A�n LADA Backend.

## 1. File Organization (QUAN TR��ONG)

**Interface vA� Implementation ph���i n���m trong cA1ng 1 file.**

```
�o. �?AsNG:
Services/Premises/PremiseService.cs  �+' ch��ca c��� IPremiseService + PremiseService

�?O SAI:
Services/Premises/IPremiseService.cs �+' ch��% ch��ca interface
Services/Premises/PremiseService.cs  �+' ch��% ch��ca class
```

## 2. File & Class Naming

| Lo���i | Convention | VA- d��� |
|------|-----------|-------|
| File | `{Name}Service.cs` | `ExpenseService.cs` |
| Interface | `I{Name}Service` | `IExpenseService` |
| Class | `{Name}Service` | `ExpenseService` |

## 3. Standard Service Structure

```csharp
public interface IExampleService
{
    /// <summary>
    /// TA�m ki���m entity
    /// </summary>
    Task<SmartTableResult<ExampleItem>> Search(SmartTableParam param);
    

=== .agent\skills\service-search-patterns\SKILL.md ===
---
name: ServiceSearchPatterns
description: Quy t��_c chu��cn cho Search/Filter/Sort/Pagination trong Service layer (SmartTable, AutoMapper).
---

# Service Search Patterns

TA�i li���u nA�y mA' t��� quy t��_c b��_t bu��Tc khi vi���t method Search trong Service.

## 1. Search Method Pattern (CHU��"N)

```csharp
public async Task<SmartTableResult<ExampleItem>> Search(SmartTableParam param)
{
    IQueryable<Example> query = _repository.Query()
        .Include(x => x.RelatedEntity1)
        .Include(x => x.RelatedEntity2)
        .Where(x => !x.IsDeleted); // N���u cA3 soft delete

    // 1. L��?c theo t��� khA3a tA�m ki���m (PredicateObject pattern)
    if (param.Search.PredicateObject != null)
    {
        dynamic search = param.Search.PredicateObject;

        if (search.Keyword != null)
        {
            string keyword = search.Keyword;
            keyword = keyword.Trim().ToLower();
            query = query.Where(x => 
                x.Property1.Contains(keyword) ||
                x.Property2.ToLower().Contains(keyword) ||
                (x.RelatedEntity != null && x.RelatedEntity.Property.ToLower().Contains(keyword)));
        }

        // CA�c filter khA�c (enum, date range, FK filter...)
        if (search.Status != null)
        {
            MyStatus status = search.Status;
            query = query.Where(x => x.Status == status);
        }

=== .cursor\rules\service-search-patterns.md ===
# Service Search Patterns

## Search Method Pattern

T���t c��� service Search methods ph���i tuA�n th�� pattern sau:

### 1. Query Building
```csharp
public async Task<SmartTableResult<ItemType>> Search(SmartTableParam param)
{
    IQueryable<EntityType> query = _repository.Query()
        .Include(x => x.RelatedEntity1)
        .Include(x => x.RelatedEntity2)
        .Where(x => !x.IsDeleted); // N���u cA3 soft delete

    // L��?c theo t��� khA3a tA�m ki���m
    if (param.Search.PredicateObject != null)
    {
        dynamic search = param.Search.PredicateObject;

        if (search.Keyword != null)
        {
            string keyword = search.Keyword;
            keyword = keyword.Trim().ToLower();
            query = query.Where(x => 
                x.Property1.Contains(keyword) ||
                x.Property2.ToLower().Contains(keyword) ||
                (x.RelatedEntity != null && x.RelatedEntity.Property.ToLower().Contains(keyword)));
        }

        // CA�c filter khA�c...
        if (search.FilterProperty != null)
        {
            query = query.Where(x => x.FilterProperty == search.FilterProperty);
        }
    }
}
```

### 2. Sorting Pattern

=== Lada.Framework\Docs\OrderFeeCalculationService_Usage_Guide.md ===
# OrderFeeCalculationService - H����>ng d���n s��- d���ng

## T��ng quan

`OrderFeeCalculationService` lA� service t��-p trung �`��� x��- lA� tA-nh toA�n c����>c cho �`��n hA�ng, bao g��"m logic VAT vA� phA�n b�� c����>c theo lo���i thanh toA�n.

## TA-nh n��ng chA-nh

### 1. TA-nh toA�n c����>c v��-n chuy���n c�� b���n

- TA-nh c����>c d���a trA�n khA�ch hA�ng, tuy���n �`����?ng vA� tr��?ng l�����ng
- TA-ch h���p v��>i `FeeService` hi���n t���i

### 2. TA-nh toA�n VAT

- **PhA- VAT �`�����c tA-nh t��� t��ng c����>c �`A� bao g��"m VAT 8%**
- T��ng c����>c sau VAT = C����>c c�� b���n + PhA- COD + Ph��� phA- - Gi���m giA� (�`A� bao g��"m VAT)
- PhA- VAT = T��ng c����>c sau VAT \* 0.08 / 1.08
- T��ng c����>c tr����>c VAT = T��ng c����>c sau VAT - PhA- VAT

### 3. PhA�n b�� c����>c theo lo���i thanh toA�n

- **SenderPay**: Ng����?i g��-i tr��� toA�n b��T
- **ConsigneePay**: Ng����?i nh��-n tr��� toA�n b��T
- **BankTransfer**: Chuy���n kho���n cho k��� toA�n
- **SplitPay**: Chia c����>c 2 bA�n
- **COD**: C���n tr��� t��� ti��?n thu h��T

## CA�i �`���t

### 1. �?��ng kA� service trong DI Container

```csharp
// Trong Startup.cs ho���c DependencyRegister.cs
services.AddOrderFeeCalculationService();

// Ho���c �`��ng kA� th�� cA'ng
services.AddTransient<IOrderFeeCalculationService, OrderFeeCalculationService>();
services.AddTransient<OrderFeeCalculationHelper>();
```

=== Lada.Framework\Examples\ImageServiceUsage.cs ===
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO.Models.Media;
using Lada.Framework.Infrastructures.AppSettings;
using Lada.Framework.Infrastructures.Services;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;

namespace Lada.Framework.Examples
{
    /// <summary>
    /// VA- d��� s��- d���ng ImageService
    /// </summary>
    public class ImageServiceUsage
    {
        private readonly IImageService _imageService;

        public ImageServiceUsage(IImageService imageService)
        {
            _imageService = imageService;
        }

        /// <summary>
        /// VA- d��� 1: X��- lA� ���nh �`��n gi���n (ch��% tr��� v��? URL)
        /// </summary>
        public async Task<string> SimpleImageProcessing(IFormFile imageFile)
        {
            // X��- lA� ���nh avatar
            var result = await _imageService.ProcessImageAsync(imageFile, ImageType.Avatar);

            if (result.Result == Lada.Framework.DTO.Result.Success)
            {
                return result.Url; // Tr��� v��? URL �`��� hi���n th��<
            }

            throw new Exception(result.Message);
        }


=== Lada.Framework\Hangfires\HangfireBasicAuthMiddleware.cs ===
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Configuration;
using System.Net;
using System.Net.Http.Headers;
using System.Text;

namespace Lada.Framework.Hangfires
{
    public class HangfireBasicAuthMiddleware
    {
        private readonly RequestDelegate next;
        private readonly IConfiguration _config;
        public HangfireBasicAuthMiddleware(RequestDelegate next, IConfiguration configuration)
        {
            this.next = next;
            _config = configuration;
        }
        public async Task InvokeAsync(HttpContext context)
        {
            if (context.Request.Path.StartsWithSegments("/hangfire"))
            {
                string authHeader = context.Request.Headers["Authorization"];
                if (authHeader != null && authHeader.StartsWith("Basic "))
                {
                    // Get the credentials from request header
                    var header = AuthenticationHeaderValue.Parse(authHeader);
                    var inBytes = Convert.FromBase64String(header.Parameter);
                    var credentials = Encoding.UTF8.GetString(inBytes).Split(':');
                    var username = credentials[0];
                    var password = credentials[1];
                    var validUserName = _config.GetSection("Hangfire:UserName").Value;
                    var validPassword = _config.GetSection("Hangfire:Password").Value;
                    // validate credentials
                    if (username.Equals(validUserName)
                      && password.Equals(validPassword))
                    {
                        await next.Invoke(context).ConfigureAwait(false);
                        return;
                    }
                }

=== Lada.Framework\Hangfires\HangfireOAuthMiddleware.cs ===
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Http;

namespace Lada.Framework.Hangfires
{
    public class HangfireOAuthMiddleware
    {
        private readonly RequestDelegate next;
        public HangfireOAuthMiddleware(RequestDelegate next)
        {
            this.next = next;
        }
        public async Task InvokeAsync(HttpContext context)
        {
            if (IsSwaggerUI(context.Request.Path))
            {
                // if user is not authenticated
                if (!context.User.Identity.IsAuthenticated)
                {
                    await context.ChallengeAsync();
                    return;
                }
            }
            await next.Invoke(context);
        }
        public bool IsSwaggerUI(PathString pathString)
        {
            return pathString.StartsWithSegments("/hangfire");
        }
    }
}

=== Lada.Framework\Infrastructures\AppSettings\AutConfig.cs ===
namespace Lada.Framework.Infrastructures.AppSettings
{
    public class AutConfig
    {
        public string Authority { get; set; }
        public string ClientId { get; set; }
        public string ClientSecret { get; set; }
    }
}

=== Lada.Framework\Infrastructures\AppSettings\MediaProcessingSettings.cs ===
using Lada.Framework.Data.Enums;

namespace Lada.Framework.Infrastructures.AppSettings
{
    /// <summary>
    /// C���u hA�nh x��- lA� media (���nh vA� video)
    /// </summary>
    public class MediaProcessingSettings
    {
        /// <summary>
        /// �?����?ng d���n g��`c l��u tr��_ media
        /// </summary>
        public string RootPath { get; set; } = "C:\\uploads\\";

        /// <summary>
        /// Domain �`��� t���o URL hi���n th��<
        /// </summary>
        public string Domain { get; set; } = "https://localhost:5001/";

        /// <summary>
        /// Th�� m���c con ch��ca file �`A� t��`i ��u
        /// </summary>
        public string OutputFolder { get; set; } = "optimized";

        /// <summary>
        /// Th�� m���c t���m �`��� x��- lA�
        /// </summary>
        public string TempPath { get; set; } = "C:\\temp\\";

        #region Image Settings

        /// <summary>
        /// Chi��?u r��Tng t��`i �`a c��a ���nh (pixel)
        /// </summary>
        public int MaxImageWidth { get; set; } = 1200;

        /// <summary>
        /// Ch���t l�����ng ���nh (1-100)
        /// </summary>
        public int ImageQuality { get; set; } = 80;

=== Lada.Framework\Infrastructures\AppSettings\MediaSettings.cs ===
namespace Lada.Framework.Infrastructures.AppSettings
{
    public class MediaSettings
    {
        public string Drive { get; set; }
        public string RootPath { get; set; }

        //Resize settings
        public string OutputFolder { get; set; }
        public int MaxWidth { get; set; }
        public string ImageDomain { get; set; }

        /// <summary>
        /// 1: JPG
        /// 2: WEBP
        /// 3. AVIF
        /// </summary>
        public int ImageFormat { get; set; }
    }
}

=== Lada.Framework\Infrastructures\Services\BaseLocationService.cs ===
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Lada.Framework.Infrastructures.Services
{
    public class BaseLocationService
    {
    }
}

=== Lada.Framework\Infrastructures\Services\CvUploadService.cs ===
using Lada.Framework.DTO;
using Lada.Framework.DTO.Enums;
using Lada.Framework.DTO.Results;
using Lada.Framework.Infrastructures.AppSettings;
using Lada.Framework.Infrastructures.Helpers;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Options;
using System.Diagnostics;

namespace Lada.Framework.Infrastructures.Services
{
    /// <summary>
    /// Giao di?n cho d?ch v? upload CV
    /// </summary>
    public interface ICvUploadService
    {
        /// <summary>
        /// Upload file CV
        /// </summary>
        /// <param name="file">File CV</param>
        /// <param name="candidateId">ID ?ng vi�n (t�y ch?n)</param>
        /// <param name="documentType">Lo?i t�i li?u</param>
        /// <returns>K?t qu? upload</returns>
        Task<CvUploadResult> UploadCvAsync(IFormFile file, int? candidateId = null, DocumentType documentType = DocumentType.CV);

        /// <summary>
        /// X�a file CV
        /// </summary>
        /// <param name="filePath">Du?ng d?n file</param>
        /// <returns>K?t qu? x�a</returns>
        Task<BaseResult> DeleteCvAsync(string filePath);

        /// <summary>
        /// L?y URL t? du?ng d?n h? th?ng
        /// </summary>
        /// <param name="filePath">Du?ng d?n file</param>
        /// <returns>URL truy c?p</returns>
        string GetUrlFromPath(string filePath);
    }


=== Lada.Framework\Infrastructures\Services\DocumentService.cs ===
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.Models.Media;
using Lada.Framework.DTO.Results.Media;
using Lada.Framework.Infrastructures.AppSettings;
using Lada.Framework.Infrastructures.Helpers;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Options;

namespace Lada.Framework.Infrastructures.Services
{
    public interface IDocumentService
    {
        /// <summary>
        /// X��- lA� vA� l��u tA�i li���u, tr��� v��? URL
        /// </summary>
        /// <param name="file">File tA�i li���u c��n x��- lA�</param>
        /// <param name="documentType">Lo���i tA�i li���u (�`��� t�� ch��cc th�� m���c)</param>
        /// <param name="documentFormat">�?��<nh d���ng tA�i li���u</param>
        /// <returns>K���t qu��� x��- lA� tA�i li���u v��>i URL</returns>
        Task<DocumentProcessResult> ProcessDocumentAsync(IFormFile file, DocumentType documentType, DocumentFormat documentFormat);

        /// <summary>
        /// X��- lA� vA� l��u tA�i li���u v��>i metadata vA�o database (optional)
        /// </summary>
        /// <param name="file">File tA�i li���u c��n x��- lA�</param>
        /// <param name="options">TA1y ch��?n l��u tA�i li���u vA� metadata</param>
        /// <returns>K���t qu��� x��- lA� tA�i li���u v��>i metadata</returns>
        Task<DocumentProcessResult> ProcessAndSaveAsync(IFormFile file, DocumentSaveOptions options);

        /// <summary>
        /// Validate tA�i li���u b���ng header validation
        /// </summary>
        /// <param name="file">File c��n validate</param>
        /// <param name="expectedFormat">�?��<nh d���ng mong �`���i</param>
        /// <returns>True n���u lA� tA�i li���u h���p l���</returns>
        Task<bool> ValidateDocumentAsync(IFormFile file, DocumentFormat expectedFormat);

        /// <summary>

=== Lada.Framework\Infrastructures\Services\ExcelFileService.cs ===
using Lada.Framework.DTO;
using Lada.Framework.DTO.Results;
using Lada.Framework.Infrastructures.AppSettings;
using Lada.Framework.Infrastructures.Helpers;
using Microsoft.Extensions.Options;
using OfficeOpenXml;

namespace Lada.Framework.Infrastructures.Services
{
    /// <summary>
    /// Giao di���n cho d��<ch v��� qu���n lA� file Excel
    /// </summary>
    public interface IExcelFileService
    {
        /// <summary>
        /// L��u file Excel vA�o h��� th��`ng
        /// </summary>
        /// <param name="excelPackage">Excel package c��n l��u</param>
        /// <param name="fileName">TA�n file (khA'ng bao g��"m extension)</param>
        /// <param name="folderType">Lo���i th�� m���c (vA- d���: "reconciliations", "transfer-payment-bills")</param>
        /// <param name="subFolder">Th�� m���c con (tA1y ch��?n)</param>
        /// <returns>K���t qu��� l��u file</returns>
        Task<ExcelFileResult> SaveExcelFileAsync(ExcelPackage excelPackage, string fileName, string folderType, string? subFolder = null);

        /// <summary>
        /// L��u file Excel t��� byte array
        /// </summary>
        /// <param name="fileBytes">D��_ li���u file Excel</param>
        /// <param name="fileName">TA�n file (khA'ng bao g��"m extension)</param>
        /// <param name="folderType">Lo���i th�� m���c</param>
        /// <param name="subFolder">Th�� m���c con (tA1y ch��?n)</param>
        /// <returns>K���t qu��� l��u file</returns>
        Task<ExcelFileResult> SaveExcelFileAsync(byte[] fileBytes, string fileName, string folderType, string? subFolder = null);

        /// <summary>
        /// XA3a file Excel
        /// </summary>
        /// <param name="filePath">�?����?ng d���n file</param>
        /// <returns>K���t qu��� xA3a</returns>
        Task<BaseResult> DeleteExcelFileAsync(string filePath);

=== Lada.Framework\Infrastructures\Services\FeeService.cs ===
using Lada.Framework.Data.Domains.Categories;
using Lada.Framework.Data.Domains.Crm;
using Lada.Framework.Data.Domains.Finance.Quotations;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO.Models;
using Lada.Framework.DTO.Results;
using Microsoft.EntityFrameworkCore;

namespace Lada.Framework.Infrastructures.Services
{
    public interface IFeeService
    {
        /// <summary>
        /// L?y gi� theo phu?ng
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        Task<FeeResult> GetFeeByWard(FeeByWardModel model,string apiKey);

        /// <summary>
        /// L?y gi� theo kho?ng c�ch
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        Task<FeeResult> GetFee(FeeModel model);
    }


    public class FeeService : IFeeService
    {
        private readonly IRepository<Price> _priceRepository;
        private readonly IRepository<Route> _routeRepository;
        private readonly IRepository<Customer> _customerRepository;
        private readonly IRepository<Location> _locationRepository;
        private readonly IRepository<EndPoints> _endPointsRepository;
        private readonly IGoogleMapService _googleMapService;

        public FeeService(IRepository<Price> priceRepository, IRepository<Route> routeRepository,
            IRepository<Customer> customerRepository, IRepository<Location> locationRepository,

=== Lada.Framework\Infrastructures\Services\GoogleMapService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Categories;
using Lada.Framework.Data.Domains.GoogleMap.PlaceAutocomplete;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.Items.GoogleMap.PlaceAutocomplete;
using Lada.Framework.DTO.Results.GoogleMap;
using Lada.Framework.DTO.Results.GoogleMap.PlaceAutocomplete;
using Lada.Framework.Infrastructures.Helpers;
using Microsoft.AspNetCore.Http.HttpResults;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Globalization;
using System.Security.Cryptography.X509Certificates;

namespace Lada.Framework.Infrastructures.Services
{
    public interface IGoogleMapService
    {
        /// <summary>
        /// L?y ra c�c phu?ng/xa chua c� latlong d? c?p nh?t
        /// </summary>
        /// <returns></returns>
        Task UpdateWardLatLong(string apiKey);

        /// <summary>
        /// C?p nh?t kho?ng c�ch v� van b?n kho?ng c�ch c?a EndPoints.
        /// </summary>
        /// <returns></returns>
        Task UpdateEndPointsDistance(string apiKey);

        Task<int> UpdateEndPointsDistance(int endPointsId, string apiKey);

        Task<int> UpdateEndPointsDistance(int startLocation, int endLocation, string apiKey);


        #region PlaceAutocomplete
        Task<PlaceAutocompleteResult> PlaceAutocomplete(string keyword, string apiKey, string options = "");

=== Lada.Framework\Infrastructures\Services\IAppConfigService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Repositories;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Memory;

namespace Lada.Framework.Infrastructures.Services
{
    /// <summary>
    /// Interface cho service qu���n lA� c���u hA�nh ��cng d���ng
    /// </summary>
    public interface IAppConfigService
    {
        /// <summary>
        /// L���y giA� tr��< c���u hA�nh theo key
        /// </summary>
        /// <param name="key">Key c���u hA�nh</param>
        /// <returns>GiA� tr��< c���u hA�nh</returns>
        Task<string> GetConfigValueAsync(string key);

        /// <summary>
        /// L���y giA� tr��< c���u hA�nh theo key v��>i giA� tr��< m���c �`��<nh
        /// </summary>
        /// <param name="key">Key c���u hA�nh</param>
        /// <param name="defaultValue">GiA� tr��< m���c �`��<nh n���u khA'ng tA�m th���y</param>
        /// <returns>GiA� tr��< c���u hA�nh ho���c giA� tr��< m���c �`��<nh</returns>
        Task<string> GetConfigValueAsync(string key, string defaultValue);

        /// <summary>
        /// Load t���t c��� configs vA�o cache
        /// </summary>
        /// <returns></returns>
        Task LoadConfigsToCacheAsync();

        /// <summary>
        /// C��-p nh��-t giA� tr��< c���u hA�nh
        /// </summary>
        /// <param name="key">Key c���u hA�nh</param>
        /// <param name="value">GiA� tr��< m��>i</param>
        /// <returns>True n���u c��-p nh��-t thA�nh cA'ng</returns>
        Task<bool> SetConfigValueAsync(string key, string value);

=== Lada.Framework\Infrastructures\Services\ImageService.cs ===
using ImageMagick;
using Lada.Framework.Data.Enums;
using Lada.Framework.DTO;
using Lada.Framework.DTO.Results.Media;
using Lada.Framework.DTO.Models.Media;
using Lada.Framework.Infrastructures.AppSettings;
using Lada.Framework.Data.Repositories;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Options;
using Lada.Framework.Infrastructures.Helpers;

namespace Lada.Framework.Infrastructures.Services
{
    public interface IImageService
    {
        /// <summary>
        /// X��- lA� vA� l��u ���nh v��>i t��`i ��u hA3a, tr��� v��? URL
        /// </summary>
        /// <param name="file">File ���nh c��n x��- lA�</param>
        /// <param name="imageType">Lo���i ���nh (�`��� t�� ch��cc th�� m���c)</param>
        /// <returns>K���t qu��� x��- lA� ���nh v��>i URL</returns>
        Task<ImageProcessResult> ProcessImageAsync(IFormFile file, ImageType imageType);

        /// <summary>
        /// X��- lA� vA� l��u ���nh v��>i metadata vA�o database (optional)
        /// </summary>
        /// <param name="file">File ���nh c��n x��- lA�</param>
        /// <param name="options">TA1y ch��?n l��u ���nh vA� metadata</param>
        /// <returns>K���t qu��� x��- lA� ���nh v��>i metadata</returns>
        Task<ImageProcessResult> ProcessAndSaveAsync(IFormFile file, ImageSaveOptions options);

        /// <summary>
        /// X��- lA� nhi��?u ���nh cA1ng lA�c
        /// </summary>
        /// <param name="files">Danh sA�ch file ���nh</param>
        /// <param name="imageType">Lo���i ���nh</param>
        /// <returns>Danh sA�ch k���t qu��� x��- lA�</returns>
        Task<List<ImageProcessResult>> ProcessMultipleAsync(List<IFormFile> files, ImageType imageType);

        /// <summary>

=== Lada.Framework\Infrastructures\Services\OrderFeeCalculationHelper.cs ===
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.DTO;
using Lada.Framework.Infrastructures.Extensions;
using static Lada.Framework.Data.Enums.OrderFinEnum;

namespace Lada.Framework.Infrastructures.Services
{
    /// <summary>
    /// Helper class �`��� tA-ch h���p OrderFeeCalculationService vA�o cA�c service hi���n t���i
    /// </summary>
    public class OrderFeeCalculationHelper
    {
        private readonly IOrderFeeCalculationService _feeCalculationService;

        public OrderFeeCalculationHelper(IOrderFeeCalculationService feeCalculationService)
        {
            _feeCalculationService = feeCalculationService;
        }

        /// <summary>
        /// TA-nh toA�n vA� c��-p nh��-t c����>c cho �`��n hA�ng m��>i
        /// </summary>
        /// <param name="orderFin">OrderFin entity</param>
        /// <param name="customerId">ID khA�ch hA�ng</param>
        /// <param name="sourceWardId">ID ph����?ng/xA� ngu��"n</param>
        /// <param name="destWardId">ID ph����?ng/xA� �`A-ch</param>
        /// <param name="weight">Tr��?ng l�����ng (gram)</param>
        /// <param name="apiKey">API key</param>
        /// <returns>K���t qu��� tA-nh toA�n</returns>
        public async Task<OrderFeeCalculationResult> CalculateAndUpdateOrderFeeAsync(
            OrderFin orderFin,
            int customerId,
            int sourceWardId,
            int destWardId,
            decimal weight,
            string apiKey = "")
        {
            var request = orderFin.ToCalculationRequest(customerId, sourceWardId, destWardId, weight, apiKey);
            var result = await _feeCalculationService.CalculateOrderFeeAsync(request);


=== Lada.Framework\Infrastructures\Services\OrderFeeCalculationService.cs ===
using Lada.Framework.DTO;
using Lada.Framework.DTO.Models;
using Lada.Framework.DTO.Results;
using static Lada.Framework.Data.Enums.OrderFinEnum;

namespace Lada.Framework.Infrastructures.Services
{
    /// <summary>
    /// Interface cho service tA-nh toA�n c����>c �`��n hA�ng
    /// </summary>
    public interface IOrderFeeCalculationService
    {
        /// <summary>
        /// TA-nh toA�n c����>c v��-n chuy���n c�� b���n
        /// </summary>
        /// <param name="customerId">ID khA�ch hA�ng</param>
        /// <param name="sourceWardId">ID ph����?ng/xA� ngu��"n</param>
        /// <param name="destWardId">ID ph����?ng/xA� �`A-ch</param>
        /// <param name="weight">Tr��?ng l�����ng (gram)</param>
        /// <param name="apiKey">API key cho Google Maps</param>
        /// <returns>K���t qu��� tA-nh c����>c</returns>
        Task<FeeCalculationResult> CalculateBaseFeeAsync(int customerId, int sourceWardId, int destWardId, decimal weight, string apiKey);

        /// <summary>
        /// TA-nh toA�n t��ng c����>c �`��n hA�ng bao g��"m cA�c phA- ph���
        /// </summary>
        /// <param name="request">ThA'ng tin yA�u c��u tA-nh c����>c</param>
        /// <returns>K���t qu��� tA-nh c����>c chi ti���t</returns>
        Task<OrderFeeCalculationResult> CalculateOrderFeeAsync(OrderFeeCalculationRequest request);

        /// <summary>
        /// TA-nh toA�n phA- VAT t��� t��ng c����>c �`A� bao g��"m VAT (8%)
        /// </summary>
        /// <param name="totalFeeAfterVat">T��ng c����>c �`A� bao g��"m VAT</param>
        /// <returns>PhA- VAT</returns>
        decimal CalculateVatFee(decimal totalFeeAfterVat);

        /// <summary>
        /// PhA�n b�� c����>c theo lo���i thanh toA�n
        /// </summary>

=== Lada.Framework\Infrastructures\Services\PictureService.cs ===
using ImageMagick;
using Lada.Framework.Data.Enums;
using Lada.Framework.DTO;
using Lada.Framework.DTO.Results.Media;
using Lada.Framework.Infrastructures.AppSettings;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Options;

namespace Lada.Framework.Infrastructures.Services
{
    public interface IPictureService
    {
        Task<UploadPictureResult> Upload(IFormFile file,PictureType pictureType);
    }



    public class PictureService : IPictureService
    {
        private MediaSettings _mediaSettings;
        public PictureService(IOptions<MediaSettings> mediaSettings)
        {
            _mediaSettings = mediaSettings.Value;
        }

        public async Task<UploadPictureResult> Upload(IFormFile file, PictureType pictureType)
        {
            var result = new UploadPictureResult();

            #region Luu file g?c
            var originalFolderName = OriginalFolderPath(pictureType);
            var originalFileExt = Path.GetExtension(file.FileName).ToLower();
            var originalFileName = OriginalFileName(file);
            var savedOriginalFilePath = await SaveToDisk(file, originalFileName, originalFolderName); 
            #endregion

            var validFile = ValidatePicture(savedOriginalFilePath);


            if (string.IsNullOrEmpty(validFile))

=== Lada.Framework\Infrastructures\Services\UnifiedMediaService.cs ===
using Lada.Framework.Data.Enums;
using Lada.Framework.DTO.Models.Media;
using Lada.Framework.DTO.Results.Media;
using Microsoft.AspNetCore.Http;

namespace Lada.Framework.Infrastructures.Services
{
    /// <summary>
    /// Unified Media Service - Thay th��� cho PictureService vA� MediaService
    /// K���t h���p t���t c��� ��u �`i���m c��a c��� hai service c�c
    /// </summary>
    public interface IUnifiedMediaService
    {
        #region Image Processing

        /// <summary>
        /// X��- lA� ���nh �`��n gi���n (thay th��� PictureService.UploadPicture)
        /// </summary>
        /// <param name="file">File ���nh</param>
        /// <param name="imageType">Lo���i ���nh</param>
        /// <returns>K���t qu��� v��>i URL</returns>
        Task<ImageProcessResult> ProcessImageAsync(IFormFile file, ImageType imageType);

        /// <summary>
        /// X��- lA� ���nh v��>i l��u database (thay th��� MediaService image functions)
        /// </summary>
        /// <param name="file">File ���nh</param>
        /// <param name="options">TA1y ch��?n l��u</param>
        /// <returns>K���t qu��� v��>i metadata</returns>
        Task<ImageProcessResult> ProcessImageWithDatabaseAsync(IFormFile file, ImageSaveOptions options);

        /// <summary>
        /// X��- lA� nhi��?u ���nh cA1ng lA�c
        /// </summary>
        /// <param name="files">Danh sA�ch file ���nh</param>
        /// <param name="imageType">Lo���i ���nh</param>
        /// <returns>Danh sA�ch k���t qu���</returns>
        Task<List<ImageProcessResult>> ProcessMultipleImagesAsync(List<IFormFile> files, ImageType imageType);

        #endregion

=== Lada.Framework\Infrastructures\Services\VideoService.cs ===
using Lada.Framework.Data.Enums;
using Lada.Framework.DTO.Models.Media;
using Lada.Framework.DTO.Results.Media;
using Lada.Framework.Infrastructures.AppSettings;
using Lada.Framework.Data.Repositories;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Options;
using System.Diagnostics;

namespace Lada.Framework.Infrastructures.Services
{
    public interface IVideoService
    {
        /// <summary>
        /// X��- lA� vA� l��u video v��>i t��`i ��u hA3a, tr��� v��? URL
        /// </summary>
        /// <param name="file">File video c��n x��- lA�</param>
        /// <param name="videoType">Lo���i video (�`��� t�� ch��cc th�� m���c)</param>
        /// <returns>K���t qu��� x��- lA� video v��>i URL</returns>
        Task<VideoProcessResult> ProcessVideoAsync(IFormFile file, VideoType videoType);

        /// <summary>
        /// X��- lA� vA� l��u video v��>i metadata vA�o database (optional)
        /// </summary>
        /// <param name="file">File video c��n x��- lA�</param>
        /// <param name="options">TA1y ch��?n l��u video vA� metadata</param>
        /// <returns>K���t qu��� x��- lA� video v��>i metadata</returns>
        Task<VideoProcessResult> ProcessAndSaveAsync(IFormFile file, VideoSaveOptions options);

        /// <summary>
        /// X��- lA� nhi��?u video cA1ng lA�c
        /// </summary>
        /// <param name="files">Danh sA�ch file video</param>
        /// <param name="videoType">Lo���i video</param>
        /// <returns>Danh sA�ch k���t qu��� x��- lA�</returns>
        Task<List<VideoProcessResult>> ProcessMultipleAsync(List<IFormFile> files, VideoType videoType);

        /// <summary>
        /// Chuy���n �`��i SystemPath thA�nh URL hi���n th��<
        /// </summary>

=== Lada.Framework\Swaggers\SwaggerBasicAuthMiddleware.cs ===
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Configuration;
using System.Net;
using System.Net.Http.Headers;
using System.Text;

namespace Lada.Framework.Swaggers
{
    public class SwaggerBasicAuthMiddleware
    {
        private readonly RequestDelegate next;
        private readonly IConfiguration _config;
        public SwaggerBasicAuthMiddleware(RequestDelegate next, IConfiguration configuration)
        {
            this.next = next;
            _config = configuration;
        }
        public async Task InvokeAsync(HttpContext context)
        {
            if (context.Request.Path.StartsWithSegments("/swagger"))
            {
                string authHeader = context.Request.Headers["Authorization"];
                if (authHeader != null && authHeader.StartsWith("Basic "))
                {
                    // Get the credentials from request header
                    var header = AuthenticationHeaderValue.Parse(authHeader);
                    var inBytes = Convert.FromBase64String(header.Parameter);
                    var credentials = Encoding.UTF8.GetString(inBytes).Split(':');
                    var username = credentials[0];
                    var password = credentials[1];
                    var validUserName = _config.GetSection("SwaggerAuth:UserName").Value;
                    var validPassword = _config.GetSection("SwaggerAuth:Password").Value;
                    // validate credentials
                    if (username.Equals(validUserName)
                      && password.Equals(validPassword))
                    {
                        await next.Invoke(context).ConfigureAwait(false);
                        return;
                    }
                }

=== Lada.Framework\Swaggers\SwaggerOAuthMiddleware.cs ===
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Http;

namespace Lada.Framework.Swaggers
{
    public class SwaggerOAuthMiddleware
    {
        private readonly RequestDelegate next;
        public SwaggerOAuthMiddleware(RequestDelegate next)
        {
            this.next = next;
        }
        public async Task InvokeAsync(HttpContext context)
        {
            if (IsSwaggerUI(context.Request.Path))
            {
                // if user is not authenticated
                if (!context.User.Identity.IsAuthenticated)
                {
                    await context.ChallengeAsync();
                    return;
                }
            }
            await next.Invoke(context);
        }
        public bool IsSwaggerUI(PathString pathString)
        {
            return pathString.StartsWithSegments("/swagger");
        }
    }
}

=== Lada.Framework\Tests\OrderFeeCalculationServiceTests.cs ===
using Lada.Framework.DTO;
using Lada.Framework.DTO.Models;
using Lada.Framework.DTO.Results;
using Lada.Framework.Infrastructures.Services;
using static Lada.Framework.Data.Enums.OrderFinEnum;

namespace Lada.Framework.Tests
{
    /// <summary>
    /// Test examples cho OrderFeeCalculationService
    /// L��u A�: �?A�y lA� example code, c��n thA�m test framework th���c t��� (xUnit, NUnit, MSTest) �`��� ch���y
    /// </summary>
    public class OrderFeeCalculationServiceExamples
    {
        /// <summary>
        /// Mock implementation c��a IFeeService cho testing
        /// </summary>
        private class MockFeeService : IFeeService
        {
            public Task<FeeResult> GetFeeByWard(FeeByWardModel model, string apiKey)
            {
                return Task.FromResult(new FeeResult
                {
                    Result = Result.Success,
                    Fee = 50000,
                    RouteName = "Test Route"
                });
            }

            public Task<FeeResult> GetFee(FeeModel model)
            {
                return Task.FromResult(new FeeResult
                {
                    Result = Result.Success,
                    Fee = 50000,
                    RouteName = "Test Route"
                });
            }
        }


=== Ladaer.BackEnd\appsettings.Development.json ===
{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  }
}

=== Ladaer.BackEnd\Program.cs ===
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.Startup;
using OfficeOpenXml;

var builder = WebApplication.CreateBuilder(args);


builder.Logging.ClearProviders();
builder.Logging.AddConsole();
// Add services to the container.

//builder.Services.AddControllers();
//// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
//builder.Services.AddEndpointsApiExplorer();
//builder.Services.AddSwaggerGen();

builder.Services.RegisterGeneralServices(builder.Configuration);
builder.Services.RegisterSwaggerServices();
builder.Services.RegisterSecurityServices(builder.Configuration);
builder.Services.RegisterDependency(builder.Configuration);

//builder.Services.AddScoped<AuthService>();
builder.Services.AddHttpClient<GoogleMapService>();
//builder.Services.AddScoped<AuthService>();

builder.Services.AddHostedService<StartupHostedService>();

builder.Services.AddHttpContextAccessor();

var app = builder.Build();

// L?y IAppConfigService t? DI container
//var appConfigService = app.Services.GetRequiredService<IAppConfigService>();

app.ConfigAndRunApp();


=== Ladaer.BackEnd\Controllers\Cms\CategoryController.cs ===
using Lada.Framework.Data.Enums;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Cms;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Cms;
using Ladaer.BackEnd.Infrastructures.Services.Cms;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Cms
{
    /// <summary>
    /// Controller d? x? l��� c���c ho?t d?ng li���n quan d?n danh m?c.
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class CategoryController : ControllerBase
    {
        private readonly ICategoryService _categoryService;

        /// <summary>
        /// Kh��Yi t���o m��Tt instance m��>i c��a l��>p <see cref="CategoryController"/>.
        /// </summary>
        /// <param name="categoryService">D��<ch v��� x��- lA� danh m���c.</param>
        public CategoryController(ICategoryService categoryService)
        {
            _categoryService = categoryService;
        }

        #region Search
        /// <summary>
        /// TA�m ki���m cA�c danh m���c d���a trA�n cA�c tham s��` �`�����c cung c���p.
        /// </summary>
        /// <param name="param">CA�c tham s��` tA�m ki���m.</param>
        /// <returns>K���t qu��� tA�m ki���m.</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "Category.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {

=== Ladaer.BackEnd\Controllers\Cms\PostController.cs ===
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Cms;
using Ladaer.BackEnd.Infrastructures.Services.Cms;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Cms
{
    /// <summary>
    /// Controller d? x? ly c�c ho?t d?ng li�n quan d?n b�i vi?t.
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class PostController : ControllerBase
    {
        private readonly IPostService _postService;

        /// <summary>
        /// Kh?i t?o m?t instance m?i c?a l?p <see cref="PostController"/>.
        /// </summary>
        /// <param name="postService">D?ch v? x? ly b�i vi?t.</param>
        public PostController(IPostService postService)
        {
            _postService = postService;
        }

        /// <summary>
        /// T�m ki?m c�c b�i vi?t d?a tr�n c�c tham s? du?c cung c?p.
        /// </summary>
        /// <param name="param">C�c tham s? t�m ki?m.</param>
        /// <returns>K?t qu? t�m ki?m.</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "Post.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            var categories = await _postService.Search(param);

=== Ladaer.BackEnd\Controllers\Cms\ProductController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Cms;
using Ladaer.BackEnd.Infrastructures.Services.Cms;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Cms
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class ProductController : ControllerBase
    {
        private readonly IProductService _productService;

        /// <summary>
        /// Kh?i t?o m?t instance m?i c?a l?p <see cref="ProductController"/>.
        /// </summary>
        /// <param name="ProductService">D?ch v? x? ly b�i vi?t.</param>
        public ProductController(IProductService productService)
        {
            _productService = productService;
        }

        /// <summary>
        /// T�m ki?m c�c b�i vi?t d?a tr�n c�c tham s? du?c cung c?p.
        /// </summary>
        /// <param name="param">C�c tham s? t�m ki?m.</param>
        /// <returns>K?t qu? t�m ki?m.</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "Product.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            var products = await _productService.Search(param);
            return Ok(products);
        }


        /// <summary>

=== Ladaer.BackEnd\Controllers\Cms\ScriptConfigController.cs ===
using Ladaer.BackEnd.Infrastructures.Services.Cms;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Cms;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Cms;
using Lada.Framework.DTO.SmartTable;
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
using Lada.Framework.Infrastructures.Helpers;
using Microsoft.AspNetCore.Authorization;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Cms;

namespace Ladaer.BackEnd.Controllers.Cms
{
    [ApiController]
    [Route("api/[controller]")]
    [Authorize]
    public class ScriptConfigController : ControllerBase
    {
        private readonly IScriptConfigService _service;
        public ScriptConfigController(IScriptConfigService service)
        {
            _service = service;
        }

        /// <summary>
        /// TA�m ki���m c���u hA�nh script
        /// </summary>
        [HttpPost("Search")]
        [Authorize(Roles = "ScriptConfig.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            var result = await _service.Search(param);
            return Ok(result);
        }

        /// <summary>
        /// L���y thA'ng tin c���u hA�nh script theo Id
        /// </summary>
        [HttpGet("GetById")]
        [Authorize(Roles = "ScriptConfig.GetById")]
        public async Task<IActionResult> GetById(int id)

=== Ladaer.BackEnd\Controllers\Cms\TagController.cs ===
using Lada.Framework.DTO.SmartTable;
using Ladaer.BackEnd.Infrastructures.Services.Cms;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Cms
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class TagController : ControllerBase
    {
        private readonly ITagService _tagService;

        public TagController(ITagService tagService)
        {
            _tagService = tagService;
        }

        /// <summary>
        /// T? d?ng ho�n th�nh t? kh�a t�m ki?m th?
        /// </summary>
        /// <param name="keyword">T? kh�a t�m ki?m</param>
        /// <returns>Danh s�ch c�c th? g?i y</returns>
        [HttpGet("Autocomplete")]
        [Authorize(Roles = "Tag.Autocomplete")]
        public async Task<IActionResult> Autocomplete(string? keyword)
        {
            var suggests = await _tagService.TagAutocomplete(keyword);
            return Ok(suggests);
        }

        /// <summary>
        /// T�m ki?m c�c th? d?a tr�n tham s? SmartTableParam
        /// </summary>
        /// <param name="param">Tham s? t�m ki?m</param>
        /// <returns>Danh s�ch c�c th? ph� h?p</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "Tag.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)

=== Ladaer.BackEnd\Controllers\Cms\TopicController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Cms;
using Ladaer.BackEnd.Infrastructures.Services.Cms;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Cms
{    
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class TopicController : ControllerBase
    {
        private readonly ITopicService _topicService;

        public TopicController(ITopicService topicService)
        {
            _topicService = topicService;
        }

        /// <summary>
        /// T�m ki?m c�c b�i vi?t d?a tr�n c�c tham s? du?c cung c?p.
        /// </summary>
        /// <param name="param">C�c tham s? t�m ki?m.</param>
        /// <returns>K?t qu? t�m ki?m.</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "Topic.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            var topics = await _topicService.Search(param);
            return Ok(topics);
        }


        /// <summary>
        /// L?y th�ng tin chi ti?t c?a d?ch v? d?a tr�n ID.
        /// </summary>
        /// <param name="id">ID c?a d?ch v?.</param>
        /// <returns>Th�ng tin chi ti?t c?a d?ch v?.</returns>

=== Ladaer.BackEnd\Controllers\Cms\UrlRecordController.cs ===
using Ladaer.BackEnd.Infrastructures.Services.Cms;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Cms;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Cms
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class UrlRecordController : ControllerBase
    {
        private readonly IUrlRecordService _urlRecordService;

        public UrlRecordController(IUrlRecordService urlRecordService)
        {
            _urlRecordService = urlRecordService;
        }


        [HttpGet("GetById")]
        [Authorize(Roles = "UrlRecord.GetById")]
        public async Task<IActionResult> GetById(int id)
        {
            var result = await _urlRecordService.GetById(id);
            return Ok(result);
        }

        [HttpPost("search")]
        [Authorize(Roles = "UrlRecord.Search")]
        public async Task<IActionResult> Search([FromBody] Lada.Framework.DTO.SmartTable.SmartTableParam param)
        {
            var result = await _urlRecordService.Search(param);
            return Ok(result);

        }

        /// <summary>
        /// C?p nh?t th�ng tin co b?n c?a UrlRecord

=== Ladaer.BackEnd\Controllers\Crm\CallLogController.cs ===
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Crm;
using Ladaer.BackEnd.Infrastructures.Services.Crm;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Crm
{
    /// <summary>
    /// CallLog Controller - Qu���n lA� cu��Tc g��?i t��ng �`A�i
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class CallLogController : ControllerBase
    {
        private readonly ICallLogService _callLogService;

        public CallLogController(ICallLogService callLogService)
        {
            _callLogService = callLogService;
        }

        /// <summary>
        /// TA�m ki���m call log
        /// </summary>
        /// <param name="param">CA�c tham s��` tA�m ki���m</param>
        /// <returns>K���t qu��� tA�m ki���m</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "CallLog.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            var callLogs = await _callLogService.Search(param);
            return Ok(callLogs);
        }

        /// <summary>
        /// L���y thA'ng tin chi ti���t call log theo ID

=== Ladaer.BackEnd\Controllers\Crm\CustomerAddressController.cs ===
using Lada.Framework.Data.Enums;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Crm;
using Ladaer.BackEnd.Infrastructures.Services.Crm;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Crm
{
    /// <summary>
    /// Controller d? x? ly c�c ho?t d?ng li�n quan d?n d?a ch? kh�ch h�ng.
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class CustomerAddressController : ControllerBase
    {
        private readonly ICustomerAddressService _customerAddressService;

        /// <summary>
        /// Kh?i t?o m?t instance m?i c?a l?p <see cref="CustomerAddressController"/>.
        /// </summary>
        /// <param name="customerAddressService">D?ch v? x? ly d?a ch? kh�ch h�ng.</param>
        public CustomerAddressController(ICustomerAddressService customerAddressService)
        {
            _customerAddressService = customerAddressService;
        }

        /// <summary>
        /// T�m ki?m c�c d?a ch? kh�ch h�ng d?a tr�n c�c tham s? du?c cung c?p.
        /// </summary>
        /// <param name="param">C�c tham s? t�m ki?m.</param>
        /// <returns>K?t qu? t�m ki?m.</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "CustomerAddress.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            if (param.Search.PredicateObject != null)
            {

=== Ladaer.BackEnd\Controllers\Crm\CustomerBankAccountController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Crm;
using Ladaer.BackEnd.Infrastructures.Services.Crm;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Crm
{
    /// <summary>
    /// Controller qu���n lA� tA�i kho���n ngA�n hA�ng khA�ch hA�ng
    /// </summary>
    [ApiController]
    [Route("api/[controller]")]
    [Authorize]
    public class CustomerBankAccountController : ControllerBase
    {
        private readonly ICustomerBankAccountService _customerBankAccountService;

        /// <summary>
        /// Kh��Yi t���o controller
        /// </summary>
        /// <param name="customerBankAccountService">Service qu���n lA� tA�i kho���n ngA�n hA�ng</param>
        public CustomerBankAccountController(ICustomerBankAccountService customerBankAccountService)
        {
            _customerBankAccountService = customerBankAccountService;
        }

        /// <summary>
        /// L���y danh sA�ch tA�i kho���n ngA�n hA�ng c��a khA�ch hA�ng
        /// </summary>
        /// <param name="customerId">ID khA�ch hA�ng</param>
        /// <returns>Danh sA�ch tA�i kho���n ngA�n hA�ng</returns>
        [HttpGet("GetByCustomerId/{customerId}")]
        [Authorize(Roles = "CustomerBankAccount.View")]
        public async Task<IActionResult> GetByCustomerId(int customerId)
        {
            if (customerId <= 0)
            {
                return BadRequest("ID khA�ch hA�ng khA'ng h���p l���");

=== Ladaer.BackEnd\Controllers\Crm\CustomerController.cs ===
using Lada.Framework.Data.Enums;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Crm;
using Ladaer.BackEnd.Infrastructures.Services.Crm;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Crm
{
    /// <summary>
    /// Controller d��<ch v��� x��- lA� cA�c ho���t �`��Tng liA�n quan �`���n khA�ch hA�ng.
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class CustomerController : ControllerBase
    {
        private readonly ICustomerService _customerService;

        /// <summary>
        /// Kh��Yi t���o m��Tt instance m��>i c��a l��>p <see cref="CustomerController"/>.
        /// </summary>
        /// <param name="customerService">D��<ch v��� x��- lA� khA�ch hA�ng.</param>
        public CustomerController(ICustomerService customerService)
        {
            _customerService = customerService;
        }

        #region SEARCH / AUTOCOMPLETE

        /// <summary>
        /// TA�m ki���m cA�c khA�ch hA�ng d���a trA�n cA�c tham s��` �`�����c cung c���p.
        /// </summary>
        /// <param name="param">CA�c tham s��` tA�m ki���m.</param>
        /// <returns>K���t qu��� tA�m ki���m.</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "Customer.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {

=== Ladaer.BackEnd\Controllers\Crm\LeadController.cs ===
using Lada.Framework.Data.Enums;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Crm;
using Ladaer.BackEnd.Infrastructures.Services.Crm;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Crm
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class LeadController : ControllerBase
    {
        private readonly ILeadService _leadService;

        public LeadController(ILeadService leadService)
        {
            _leadService = leadService;
        }


        /// <summary>
        /// T�m ki?m lead
        /// </summary>
        /// <param name="param">C�c tham s? t�m ki?m.</param>
        /// <returns>K?t qu? t�m ki?m.</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "Lead.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            var agencies = await _leadService.Search(param);
            return Ok(agencies);
        }

        /// <summary>
        /// T?o ho?c c?p nh?t lead
        /// </summary>

=== Ladaer.BackEnd\Controllers\Crm\VatInfoController.cs ===
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Crm;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Crm;
using Ladaer.BackEnd.Infrastructures.Services.Crm;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;

namespace Ladaer.BackEnd.Controllers.Crm
{
    /// <summary>
    /// Controller qu���n lA� thA'ng tin xu���t hA3a �`��n VAT c��a khA�ch hA�ng
    /// </summary>
    [ApiController]
    [Route("api/[controller]")]
    [Authorize]
    public class VatInfoController : ControllerBase
    {
        private readonly IVatInfoService _vatInfoService;

        public VatInfoController(IVatInfoService vatInfoService)
        {
            _vatInfoService = vatInfoService;
        }

        /// <summary>
        /// L���y danh sA�ch thA'ng tin xu���t hA3a �`��n VAT
        /// </summary>
        /// <param name="searchModel">Model tA�m ki���m</param>
        /// <returns>Danh sA�ch thA'ng tin xu���t hA3a �`��n VAT</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "VatInfo.Search")]
        public async Task<ActionResult> Search([FromBody] SmartTableParam param)
        {
            var result = await _vatInfoService.Search(param);
            return Ok(result);
        }

=== Ladaer.BackEnd\Controllers\DriverApp\DriverDashboardController.cs ===
using System.Threading.Tasks;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.Services.DriverApp;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.DriverApp
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class DriverDashboardController : ControllerBase
    {
        private readonly IDriverAppService _driverAppService;

        public DriverDashboardController(IDriverAppService driverAppService)
        {
            _driverAppService = driverAppService;
        }

        /// <summary>
        /// L���y thA'ng tin dashboard cho ��cng d���ng tA�i x���
        /// </summary>
        [HttpGet("GetDashboard")]
        [Authorize(Roles = "DriverApp.GetDashboard")]
        public async Task<IActionResult> GetDashboard()
        {
            var currentUser = User.GetCurrentUser();
            if (currentUser == null)
            {
                return BadRequest("KhA'ng cA3 ng����?i dA1ng");
            }
            if (currentUser.UserId <= 0)
            {
                return BadRequest("KhA'ng xA�c �`��<nh �`�����c ng����?i dA1ng");
            }

            try
            {
                var result = await _driverAppService.GetDashboard(currentUser.UserId);

=== Ladaer.BackEnd\Controllers\DriverApp\DriverFinanceController.cs ===
using System.Threading.Tasks;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.Services.DriverApp;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.DriverApp
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class DriverFinanceController : ControllerBase
    {
        private readonly IDriverFinService _driverFinService;

        public DriverFinanceController(IDriverFinService driverFinService)
        {
            _driverFinService = driverFinService;
        }

        /// <summary>
        /// L���y thA'ng tin tA�i chA-nh c��a lA�i xe
        /// </summary>
        [HttpGet("GetFinancialInfo")]
        [Authorize(Roles = "DriverApp.GetFinancialInfo")]
        public async Task<IActionResult> GetFinancialInfo()
        {
            var currentUser = User.GetCurrentUser();
            if (currentUser == null)
            {
                return BadRequest("KhA'ng cA3 ng����?i dA1ng");
            }
            if (currentUser.UserId <= 0)
            {
                return BadRequest("KhA'ng xA�c �`��<nh �`�����c ng����?i dA1ng");
            }

            try
            {

=== Ladaer.BackEnd\Controllers\DriverApp\DriverOrderController.cs ===
using System.Threading.Tasks;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.DriverApp;
using Ladaer.BackEnd.Infrastructures.Services.DriverApp;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.DriverApp
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class DriverOrderController : ControllerBase
    {
        private readonly IDriverAppOrderService _driverAppOrderService;

        public DriverOrderController(IDriverAppOrderService driverAppOrderService)
        {
            _driverAppOrderService = driverAppOrderService;
        }

        /// <summary>
        /// TA�m ki���m danh sA�ch �`��n hA�ng c��a lA�i xe cA3 phA�n trang
        /// </summary>
        [HttpPost("SearchOrders")]
        [Authorize(Roles = "DriverApp.SearchOrders")]
        public async Task<IActionResult> SearchOrders([FromBody] SmartTableParam param)
        {
            var currentUser = User.GetCurrentUser();
            if (currentUser == null)
            {
                return BadRequest("KhA'ng cA3 ng����?i dA1ng");
            }
            if (currentUser.UserId <= 0)
            {
                return BadRequest("KhA'ng xA�c �`��<nh �`�����c ng����?i dA1ng");
            }

            try

=== Ladaer.BackEnd\Controllers\DriverApp\DriverOrderOpsController.cs ===
using System.Threading.Tasks;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.DriverApp;
using Ladaer.BackEnd.Infrastructures.Services.DriverApp;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Ladaer.BackEnd.Infrastructures.Services.OrderBusiness;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.DriverApp
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class DriverOrderOpsController : ControllerBase
    {
        private readonly IDriverAppOrderService _driverAppOrderService;
        private readonly IUserService _userService;
        private readonly IOrderFailReasonService _orderFailReasonService;

        public DriverOrderOpsController(IDriverAppOrderService driverAppOrderService, IUserService userService, IOrderFailReasonService orderFailReasonService)
        {
            _driverAppOrderService = driverAppOrderService;
            _userService = userService;
            _orderFailReasonService = orderFailReasonService;
        }

        /// <summary>
        /// C��-p nh��-t tr���ng thA�i l���y hA�ng thA�nh cA'ng
        /// </summary>
        [HttpPost("Pickup")]
        [Authorize(Roles = "DriverApp.Pickup")]
        public async Task<IActionResult> Pickup([FromForm] DriverAppPickupModel model)
        {
            var currentUser = User.GetCurrentUser();
            if (currentUser == null)
            {
                return BadRequest("KhA'ng cA3 ng����?i dA1ng");
            }
            if (currentUser.UserId <= 0)

=== Ladaer.BackEnd\Controllers\DriverApp\DriverProfileController.cs ===
using System.Threading.Tasks;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Accounts;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Hr;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Users;
using Ladaer.BackEnd.Infrastructures.Services.Hr;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Ladaer.BackEnd.Infrastructures.Services.Report.OperationReports;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.DriverApp
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class DriverProfileController : ControllerBase
    {
        private readonly IUserService _userService;
        private readonly IAttendanceService _attendanceService;
        private readonly IDriverReportService _driverReportService;

        public DriverProfileController(
            IUserService userService,
            IAttendanceService attendanceService,
            IDriverReportService driverReportService)
        {
            _userService = userService;
            _attendanceService = attendanceService;
            _driverReportService = driverReportService;
        }

        /// <summary>
        /// �?��ng nh��-p dA�nh cho tA�i x���
        /// </summary>
        [HttpPost("Login")]
        [AllowAnonymous]
        public async Task<IActionResult> Login([FromBody] LoginModel model)
        {

=== Ladaer.BackEnd\Controllers\DriverApp\DriverTruckController.cs ===
using Lada.Framework.Data.Domains.Trucks;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Data.Repositories;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Trucks;
using Ladaer.BackEnd.Infrastructures.Services.FuelCards;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Ladaer.BackEnd.Infrastructures.Services.Trucks;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.DriverApp
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class DriverTruckController : ControllerBase
    {
        private readonly ITruckService _truckService;
        private readonly ITruckActivityService _truckActivityService;
        private readonly IUserService _userService;
        private readonly IFuelRefillService _fuelRefillService;

        public DriverTruckController(
            ITruckService truckService,
            ITruckActivityService truckActivityService,
            IUserService userService,
            IFuelRefillService fuelRefillService)
        {
            _truckService = truckService;
            _truckActivityService = truckActivityService;
            _userService = userService;
            _fuelRefillService = fuelRefillService;
        }

        /// <summary>
        /// L���y danh sA�ch t���t c��� xe t���i thu��Tc chi nhA�nh c��a ng����?i dA1ng hi���n t���i
        /// </summary>
        /// <returns>Danh sA�ch t���t c��� xe t���i thu��Tc chi nhA�nh</returns>
        [HttpGet("GetTrucksByAgency")]

=== Ladaer.BackEnd\Controllers\Finance\BankAccountController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finances;
using Ladaer.BackEnd.Infrastructures.Services.Finances;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Finance
{
    /// <summary>
    /// Controller qu���n lA� tA�i kho���n ngA�n hA�ng
    /// </summary>
    [ApiController]
    [Route("api/[controller]")]
    [Authorize]
    public class BankAccountController : ControllerBase
    {
        private readonly IBankAccountService _bankAccountService;

        public BankAccountController(IBankAccountService bankAccountService)
        {
            _bankAccountService = bankAccountService;
        }

        /// <summary>
        /// TA�m ki���m tA�i kho���n ngA�n hA�ng
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m</param>
        /// <returns>Danh sA�ch tA�i kho���n ngA�n hA�ng</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "BankAccount.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            try
            {
                var result = await _bankAccountService.Search(param);
                return Ok(result);
            }
            catch (Exception ex)
            {

=== Ladaer.BackEnd\Controllers\Finance\BankController.cs ===
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Finance;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Finance
{
    /// <summary>
    /// Controller qu���n lA� thA'ng tin ngA�n hA�ng
    /// </summary>
    [ApiController]
    [Route("api/[controller]")]
    [Authorize]
    public class BankController : ControllerBase
    {
        private readonly IBankService _bankService;
        private readonly BankSeedService _bankSeedService;
        private readonly ILogger<BankController> _logger;

        public BankController(
            IBankService bankService,
            BankSeedService bankSeedService,
            ILogger<BankController> logger)
        {
            _bankService = bankService;
            _bankSeedService = bankSeedService;
            _logger = logger;
        }

        /// <summary>
        /// TA�m ki���m ngA�n hA�ng v��>i phA�n trang
        /// </summary>
        [HttpPost("Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            try
            {

=== Ladaer.BackEnd\Controllers\Finance\CashierController.cs ===
using Lada.Framework.DTO.SmartTable;
using Ladaer.BackEnd.Infrastructures.Services.Finances;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finances;

namespace Ladaer.BackEnd.Controllers.Finance
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class CashierController : ControllerBase
    {
        private readonly ICashierService _cashierService;

        public CashierController(ICashierService cashierService)
        {
            _cashierService = cashierService;
        }

        [HttpPost("Search")]
        [Authorize(Roles = "Cashier.Search")]
        public async Task<IActionResult> Search(SmartTableParam param)
        {
            var currentUser = User.GetCurrentUser();
            if (currentUser == null)
            {
                return BadRequest("KhA'ng cA3 ng����?i dA1ng");
            }
            if (currentUser.UserId <= 0 || string.IsNullOrEmpty(currentUser.UserName))
            {
                return BadRequest("KhA'ng xA�c �`��<nh �`�����c ng����?i dA1ng");
            }

            var result = await _cashierService.Search(param, currentUser.UserId);
            return Ok(result);
        }


=== Ladaer.BackEnd\Controllers\Finance\CustomerReconciliationSlipController.cs ===
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Finance
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class CustomerReconciliationSlipController : ControllerBase
    {
        private readonly ICustomerReconciliationSlipService _service;
        private readonly IUserService _userService;
        private readonly ICustomerReconciliationSlipExcelService _excelService;

        public CustomerReconciliationSlipController(
            ICustomerReconciliationSlipService service,
            IUserService userService,
            ICustomerReconciliationSlipExcelService excelService)
        {
            _service = service;
            _userService = userService;
            _excelService = excelService;
        }

        /// <summary>
        /// L���y danh sA�ch khA�ch hA�ng c��n �`��`i soA�t
        /// </summary>
        [HttpPost("GetCustomersOverview")]
        [Authorize(Roles = "CustomerReconciliationSlip.View,CustomerReconciliationSlip.Create,Founder")]
        public async Task<SmartTableResult<CustomerTransferPaymentSummaryItem>> GetCustomersOverview([FromBody] SmartTableParam param)
        {

=== Ladaer.BackEnd\Controllers\Finance\ExpenseCategoryController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Finance;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Finance
{
    /// <summary>
    /// Controller qu���n lA� danh m���c chi phA-
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class ExpenseCategoryController : ControllerBase
    {
        private readonly IExpenseCategoryService _expenseCategoryService;

        public ExpenseCategoryController(IExpenseCategoryService expenseCategoryService)
        {
            _expenseCategoryService = expenseCategoryService;
        }

        /// <summary>
        /// TA�m ki���m danh m���c chi phA- v��>i phA�n trang
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m vA� phA�n trang</param>
        /// <returns>Danh sA�ch danh m���c chi phA-</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "ExpenseCategory.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            try
            {
                var result = await _expenseCategoryService.Search(param);
                return Ok(result);
            }
            catch (Exception ex)
            {

=== Ladaer.BackEnd\Controllers\Finance\ExpenseController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finances;
using Ladaer.BackEnd.Infrastructures.Services.Finances;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Finance
{
    /// <summary>
    /// Controller qu���n lA� chi phA-
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class ExpenseController : ControllerBase
    {
        private readonly IExpenseService _expenseService;

        public ExpenseController(IExpenseService expenseService)
        {
            _expenseService = expenseService;
        }

        /// <summary>
        /// TA�m ki���m chi phA- v��>i phA�n trang
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m vA� phA�n trang</param>
        /// <returns>Danh sA�ch chi phA-</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "Expense.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            try
            {
                var currentUser = User.GetCurrentUser();
                if (currentUser == null || currentUser.UserId <= 0)
                {
                    return BadRequest("KhA'ng xA�c �`��<nh �`�����c ng����?i dA1ng");
                }

=== Ladaer.BackEnd\Controllers\Finance\ExportOrderController.cs ===
using Lada.Framework.DTO;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Finance
{
    /// <summary>
    /// Controller cho vi���c xu���t Excel thA'ng tin �`��n hA�ng
    /// </summary>
    [ApiController]
    [Route("api/[controller]")]
    [Authorize]
    public class ExportOrderController : ControllerBase
    {
        private readonly IExportOrderService _exportOrderService;
        private readonly IUserService _userService;

        public ExportOrderController(
            IExportOrderService exportOrderService,
            IUserService userService)
        {
            _exportOrderService = exportOrderService;
            _userService = userService;
        }

        /// <summary>
        /// Xu���t Excel thA'ng tin �`��n hA�ng theo danh sA�ch OrderId ho���c OrderCode
        /// </summary>
        /// <param name="model">ThA'ng tin �`��u vA�o</param>
        /// <returns>K���t qu��� xu���t file</returns>
        [HttpPost("export")]
        public async Task<ActionResult<ExportOrderResult>> ExportOrders([FromBody] ExportOrderModel model)
        {
            try
            {

=== Ladaer.BackEnd\Controllers\Finance\FinanceExcelExportController.cs ===
using Lada.Framework.DTO;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Finance;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Finance
{
    /// <summary>
    /// Controller t��ng h���p cho vi���c xu���t Excel cA�c phi���u tA�i chA-nh
    /// </summary>
    [ApiController]
    [Route("api/[controller]")]
    [Authorize]
    public class FinanceExcelExportController : ControllerBase
    {
        private readonly IReconciliationExcelService _reconciliationExcelService;
        private readonly ITransferPaymentBillExcelService _transferPaymentBillExcelService;

        public FinanceExcelExportController(
            IReconciliationExcelService reconciliationExcelService,
            ITransferPaymentBillExcelService transferPaymentBillExcelService)
        {
            _reconciliationExcelService = reconciliationExcelService;
            _transferPaymentBillExcelService = transferPaymentBillExcelService;
        }

        #region Reconciliation Excel Export

        /// <summary>
        /// Xu���t Excel danh sA�ch phi���u �`��`i soA�t
        /// </summary>
        /// <param name="model">Model xu���t Excel</param>
        /// <returns>K���t qu��� xu���t file</returns>
        [HttpPost("Reconciliation/Export")]
        [Authorize(Roles = "Reconciliation.ExportExcel")]
        public async Task<IActionResult> ExportReconciliations([FromBody] ReconciliationExcelExportModel model)
        {

=== Ladaer.BackEnd\Controllers\Finance\FuelCardController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.FuelCards;
using Ladaer.BackEnd.Infrastructures.DTO.Results.FuelCards;
using Ladaer.BackEnd.Infrastructures.Services.FuelCards;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Finance;

/// <summary>
/// Controller qu���n lA� th��� x��ng d��u (th��� tA-n d���ng), �`�� d��u vA� thanh toA�n ti��?n d��u khoA�n
/// </summary>
[Route("api/[controller]")]
[ApiController]
[Authorize]
public class FuelCardController : ControllerBase
{
    private readonly IFuelCardService _fuelCardService;
    private readonly IFuelCardTransactionService _fuelCardTransactionService;
    private readonly IFuelRefillService _fuelRefillService;
    private readonly IFuelRefillExcelService _fuelRefillExcelService;

    public FuelCardController(
        IFuelCardService fuelCardService,
        IFuelCardTransactionService fuelCardTransactionService,
        IFuelRefillService fuelRefillService,
        IFuelRefillExcelService fuelRefillExcelService)
    {
        _fuelCardService = fuelCardService;
        _fuelCardTransactionService = fuelCardTransactionService;
        _fuelRefillService = fuelRefillService;
        _fuelRefillExcelService = fuelRefillExcelService;
    }

    #region FuelCard Management

    /// <summary>
    /// TA�m ki���m th��� x��ng d��u v��>i phA�n trang
    /// </summary>

=== Ladaer.BackEnd\Controllers\Finance\IncomeCategoryController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Finance;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Finance
{
    /// <summary>
    /// Controller qu���n lA� danh m���c doanh thu
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class IncomeCategoryController : ControllerBase
    {
        private readonly IIncomeCategoryService _incomeCategoryService;

        public IncomeCategoryController(IIncomeCategoryService incomeCategoryService)
        {
            _incomeCategoryService = incomeCategoryService;
        }

        /// <summary>
        /// TA�m ki���m danh m���c doanh thu v��>i phA�n trang
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m vA� phA�n trang</param>
        /// <returns>Danh sA�ch danh m���c doanh thu</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "IncomeCategory.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            try
            {
                var result = await _incomeCategoryService.Search(param);
                return Ok(result);
            }
            catch (Exception ex)
            {

=== Ladaer.BackEnd\Controllers\Finance\IncomeController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finances;
using Ladaer.BackEnd.Infrastructures.Services.Finances;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Finance
{
    /// <summary>
    /// Controller qu���n lA� doanh thu
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class IncomeController : ControllerBase
    {
        private readonly IIncomeService _incomeService;

        public IncomeController(IIncomeService incomeService)
        {
            _incomeService = incomeService;
        }

        /// <summary>
        /// TA�m ki���m doanh thu v��>i phA�n trang
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m vA� phA�n trang</param>
        /// <returns>Danh sA�ch doanh thu</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "Income.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            try
            {
                var currentUser = User.GetCurrentUser();
                if (currentUser == null || currentUser.UserId <= 0)
                {
                    return BadRequest("KhA'ng xA�c �`��<nh �`�����c ng����?i dA1ng");
                }

=== Ladaer.BackEnd\Controllers\Finance\IncomeExpenseReportController.cs ===
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Report.Finance;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Finance
{
    /// <summary>
    /// Controller cho bA�o cA�o thu chi
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class IncomeExpenseReportController : ControllerBase
    {
        private readonly IIncomeExpenseReportService _service;

        /// <summary>
        /// Kh��Yi t���o m��Tt th��� hi���n c��a <see cref="IncomeExpenseReportController"/>.
        /// </summary>
        /// <param name="service">Service bA�o cA�o thu chi.</param>
        public IncomeExpenseReportController(IIncomeExpenseReportService service)
        {
            _service = service;
        }

        /// <summary>
        /// L���y bA�o cA�o thu chi theo kho���ng th��?i gian
        /// </summary>
        /// <param name="request">ThA'ng tin kho���ng th��?i gian bA�o cA�o</param>
        /// <returns>BA�o cA�o thu chi theo ngA�y</returns>
        [HttpPost("GetReport")]
        [Authorize(Roles = "IncomeExpenseReport.View")]
        public async Task<IActionResult> GetReport([FromBody] IncomeExpenseReportRequest request)
        {
            var currentUser = User.GetCurrentUser();
            var result = await _service.GetIncomeExpenseReportAsync(request, currentUser.UserId);
            return Ok(result);

=== Ladaer.BackEnd\Controllers\Finance\MyBankAccountController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Finance;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Finance
{
    /// <summary>
    /// Controller qu���n lA� tA�i kho���n ngA�n hA�ng cA� nhA�n c��a ng����?i dA1ng �`ang �`��ng nh��-p
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class MyBankAccountController : ControllerBase
    {
        private readonly IUserBankAccountService _userBankAccountService;

        public MyBankAccountController(IUserBankAccountService userBankAccountService)
        {
            _userBankAccountService = userBankAccountService;
        }

        /// <summary>
        /// L���y danh sA�ch tA�i kho���n ngA�n hA�ng c��a tA'i
        /// </summary>
        /// <returns>Danh sA�ch tA�i kho���n ngA�n hA�ng</returns>
        [HttpGet("GetAll")]
        public async Task<IActionResult> GetAll()
        {
            try
            {
                var currentUser = User.GetCurrentUser();
                if (currentUser == null || currentUser.UserId <= 0)
                {
                    return BadRequest("KhA'ng xA�c �`��<nh �`�����c ng����?i dA1ng");
                }

                var result = await _userBankAccountService.GetByUserId(currentUser.UserId);

=== Ladaer.BackEnd\Controllers\Finance\PriceController.cs ===
using Lada.Framework.Data.Enums;
using Lada.Framework.DTO;
using Lada.Framework.DTO.Models;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.AppSettings;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finances;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Export;
using Ladaer.BackEnd.Infrastructures.Services.Finances;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Options;

namespace Ladaer.BackEnd.Controllers.Finance
{
    /// <summary>
    /// Controller d? x? ly c�c ho?t d?ng li�n quan d?n gi� c?.
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class PriceController : ControllerBase
    {
        private readonly IPriceService _priceService;
        private readonly IBackFeeService _backFeeService;
        private readonly IWebHostEnvironment _hostEnvironment;
        private readonly IHttpContextAccessor _httpContextAccessor;
        private readonly string _mapApiKey;

        /// <summary>
        /// Kh?i t?o m?t instance m?i c?a l?p <see cref="PriceController"/>.
        /// </summary>
        /// <param name="options">T�y ch?n c?u h�nh ?ng d?ng.</param>
        /// <param name="priceService">D?ch v? x? ly gi� c?.</param>
        /// <param name="backFeeService">D?ch v? x? ly ph� tr? l?i.</param>
        /// <param name="hostEnvironment">M�i tru?ng luu tr? web.</param>
        /// <param name="httpContextAccessor">Truy c?p ng? c?nh HTTP.</param>
        public PriceController(IOptions<AppSetting> options, IPriceService priceService, IBackFeeService backFeeService,
            IWebHostEnvironment hostEnvironment, IHttpContextAccessor httpContextAccessor)
        {
            _priceService = priceService;

=== Ladaer.BackEnd\Controllers\Finance\ReconciliationController.cs ===
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finances;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Finances;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Data.Domains.Finance;

namespace Ladaer.BackEnd.Controllers.Finance
{
    /// <summary>
    /// Controller qu���n lA� �`��`i soA�t �`��n hA�ng
    /// </summary>
    [ApiController]
    [Route("api/[controller]")]
    [Authorize]
    public class ReconciliationController : ControllerBase
    {
        private readonly IReconciliationService _reconciliationService;

        /// <summary>
        /// Kh��Yi t���o controller
        /// </summary>
        /// <param name="reconciliationService">Service qu���n lA� �`��`i soA�t</param>
        public ReconciliationController(IReconciliationService reconciliationService)
        {
            _reconciliationService = reconciliationService;
        }

        /// <summary>
        /// TA�m ki���m khA�ch hA�ng c��n �`��`i soA�t v��>i phA�n trang
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m</param>
        /// <returns>K���t qu��� tA�m ki���m khA�ch hA�ng c��n �`��`i soA�t</returns>
        [HttpPost("SearchCustomersForReconciliation")]
        [Authorize(Roles = "Reconciliation.View")]

=== Ladaer.BackEnd\Controllers\Finance\TaxInvoiceController.cs ===
using Lada.Framework.DTO;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Finance;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Finance
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class TaxInvoiceController : ControllerBase
    {
        private readonly ITaxInvoiceService _service;
        private readonly ICustomerReconciliationSlipService _reconciliationService;

        public TaxInvoiceController(
            ITaxInvoiceService service,
            ICustomerReconciliationSlipService reconciliationService)
        {
            _service = service;
            _reconciliationService = reconciliationService;
        }

        /// <summary>
        /// T���o hA3a �`��n thu��� m��>i
        /// </summary>
        /// <param name="model">ThA'ng tin t���o hA3a �`��n (CustomerReconciliationSlipId, VatInfoId, Note)</param>
        /// <returns>K���t qu��� t���o hA3a �`��n</returns>
        [HttpPost("Create")]
        [Authorize(Roles = "TaxInvoice.Create,Founder")]
        public async Task<IActionResult> Create([FromBody] CreateTaxInvoiceModel model)
        {
            var currentUser = User.GetCurrentUser();
            if (currentUser == null)
            {
                return Unauthorized();

=== Ladaer.BackEnd\Controllers\Finance\TransactionController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.Services.Finances;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Finance
{
    [ApiController]
    [Route("api/[controller]")]
    [Authorize]
    public class TransactionController : ControllerBase
    {
        private readonly ITransactionService _transactionService;

        public TransactionController(ITransactionService transactionService)
        {
            _transactionService = transactionService;
        }

        /// <summary>
        /// TA�m ki���m giao d��<ch c��a vA-.
        /// Service s��� t��� �`��Tng ki���m tra quy��?n: ch��% Founder vA� Accountant m��>i xem t���t c���, user khA�c ch��% xem vA- c��a mA�nh.
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m</param>
        /// <returns>Danh sA�ch giao d��<ch v��>i t��ng thu vA� t��ng chi</returns>
        [HttpPost("SearchWalletTransactions")]
        [Authorize(Roles = "Transaction.SearchWalletTransactions")]
        public async Task<IActionResult> SearchWalletTransactions([FromBody] SmartTableParam param)
        {
            var currentUser = User.GetCurrentUser();
            if (currentUser == null)
            {
                return Unauthorized();
            }

            var result = await _transactionService.SearchWalletTransactions(param, currentUser.UserId);
            return Ok(result);
        }


=== Ladaer.BackEnd\Controllers\Finance\TransferPaymentBillController.cs ===
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Finance;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Finance
{
    /// <summary>
    /// Controller qu���n lA� hA3a �`��n thanh toA�n chuy���n kho���n
    /// </summary>
    [ApiController]
    [Route("api/[controller]")]
    [Authorize]
    public class TransferPaymentBillController : ControllerBase
    {
        private readonly ITransferPaymentBillService _transferPaymentBillService;
        private readonly ITransferPaymentBillExcelService _transferPaymentBillExcelService;

        public TransferPaymentBillController(
            ITransferPaymentBillService transferPaymentBillService,
            ITransferPaymentBillExcelService transferPaymentBillExcelService)
        {
            _transferPaymentBillService = transferPaymentBillService;
            _transferPaymentBillExcelService = transferPaymentBillExcelService;
        }

        #region Search Operations

        /// <summary>
        /// TA�m ki���m khA�ch hA�ng cA3 �`��n hA�ng c��n t���o hA3a �`��n thanh toA�n chuy���n kho���n
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m</param>
        /// <returns>Danh sA�ch khA�ch hA�ng</returns>
        [HttpPost("SearchCustomersForTransferPayment")]

=== Ladaer.BackEnd\Controllers\Finance\UserBankAccountController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Finance;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Finance
{
    /// <summary>
    /// Controller qu���n lA� tA�i kho���n ngA�n hA�ng ng����?i dA1ng
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class UserBankAccountController : ControllerBase
    {
        private readonly IUserBankAccountService _userBankAccountService;

        public UserBankAccountController(IUserBankAccountService userBankAccountService)
        {
            _userBankAccountService = userBankAccountService;
        }

        /// <summary>
        /// TA�m ki���m tA�i kho���n ngA�n hA�ng ng����?i dA1ng v��>i phA�n trang
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m vA� phA�n trang</param>
        /// <returns>Danh sA�ch tA�i kho���n ngA�n hA�ng ng����?i dA1ng</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "UserBankAccount.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            try
            {
                var result = await _userBankAccountService.Search(param);
                return Ok(result);
            }
            catch (Exception ex)
            {

=== Ladaer.BackEnd\Controllers\Finance\VatInvoiceController.cs ===
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Finances;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Finance
{
    /// <summary>
    /// Controller qu���n lA� hA3a �`��n VAT t��� T��ng c���c Thu���
    /// </summary>
    [ApiController]
    [Route("api/[controller]")]
    [Authorize]
    public class VatInvoiceController : ControllerBase
    {
        private readonly IVatInvoiceService _vatInvoiceService;
        private readonly IVatInvoiceSyncService _vatInvoiceSyncService;

        public VatInvoiceController(IVatInvoiceService vatInvoiceService, IVatInvoiceSyncService vatInvoiceSyncService)
        {
            _vatInvoiceService = vatInvoiceService;
            _vatInvoiceSyncService = vatInvoiceSyncService;
        }

        /// <summary>
        /// TA�m ki���m hA3a �`��n VAT
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m</param>
        /// <returns>Danh sA�ch hA3a �`��n VAT</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "VatInvoice.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            var result = await _vatInvoiceService.Search(param);
            return Ok(result);
        }

        /// <summary>

=== Ladaer.BackEnd\Controllers\Finance\WalletController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finances;
using Ladaer.BackEnd.Infrastructures.Services.Business;
using Ladaer.BackEnd.Infrastructures.Services.Finances;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Finance
{
    /// <summary>
    /// Controller x��- lA� cA�c yA�u c��u liA�n quan �`���n vA- �`i���n t��-.
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class WalletController : ControllerBase
    {
        private readonly IWalletService _walletService;
        private readonly IWalletTransferService _walletTransferService;
        private readonly IUserService _userService;

        public WalletController(
            IWalletService walletService,
            IWalletTransferService walletTransferService,
            IUserService userService)
        {
            _walletService = walletService;
            _walletTransferService = walletTransferService;
            _userService = userService;
        }



        /// <summary>
        /// TA�m ki���m danh sA�ch cA�c vA- �`i���n t��- d���a trA�n cA�c tham s��` �`�����c cung c���p.
        /// </summary>
        /// <param name="param">CA�c tham s��` tA�m ki���m.</param>

=== Ladaer.BackEnd\Controllers\Hr\AttendanceController.cs ===
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Hr;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Export;
using Ladaer.BackEnd.Infrastructures.Services.Hr;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Hr
{
    [ApiController]
    [Route("api/[controller]")]
    [Authorize]
    public class AttendanceController : ControllerBase
    {
        private readonly IAttendanceService _attendanceService;
        private readonly IWebHostEnvironment _hostEnvironment;

        public AttendanceController(IAttendanceService attendanceService, IWebHostEnvironment hostEnvironment)
        {
            _attendanceService = attendanceService;
            _hostEnvironment = hostEnvironment;
        }

        [HttpPost("Punch")]
        [Authorize(Roles = "Attendance.PunchAsync")]
        public async Task<IActionResult> PunchAsync([FromForm] CheckInOutModel model)
        {
            var currentUser = User.GetCurrentUser();
            model.UpdatedBy = currentUser.UserId;
            model.UpdatedByUserName = currentUser.UserName;
            if (model.UpdatedBy <= 0 || string.IsNullOrEmpty(model.UpdatedByUserName))
            {
                return BadRequest("Kh���ng x���c d?nh du?c ngu?i d���ng");
            }
            model.UserId = model.UpdatedBy;

            var result = await _attendanceService.PunchAsync(model);
            return Ok(result);

=== Ladaer.BackEnd\Controllers\Hr\CandidateController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Hr;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Users;
using Ladaer.BackEnd.Infrastructures.Services.Hr;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.ModelBinding;

namespace Ladaer.BackEnd.Controllers.Hr
{
    /// <summary>
    /// Controller d? x? ly c�c ho?t d?ng li�n quan d?n ?ng vi�n.
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class CandidateController : ControllerBase
    {
        private readonly ICandidateService _candidateService;

        /// <summary>
        /// Kh?i t?o m?t instance m?i c?a l?p <see cref="CandidateController"/>.
        /// </summary>
        /// <param name="candidateService">D?ch v? x? ly ?ng vi�n.</param>
        public CandidateController(ICandidateService candidateService)
        {
            _candidateService = candidateService;
        }

        /// <summary>
        /// T�m ki?m c�c ?ng vi�n d?a tr�n c�c tham s? du?c cung c?p.
        /// </summary>
        /// <param name="param">C�c tham s? t�m ki?m.</param>
        /// <returns>K?t qu? t�m ki?m.</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "Candidate.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {

=== Ladaer.BackEnd\Controllers\Hr\JobController.cs ===
using Lada.Framework.Data.Domains.Hr;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Hr;
using Ladaer.BackEnd.Infrastructures.Services.Hr;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Hr
{
    /// <summary>
    /// Controller d? x? ly c�c ho?t d?ng li�n quan d?n c�ng vi?c.
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class JobController : ControllerBase
    {
        private readonly IJobPostService _jobPostService;

        /// <summary>
        /// Kh?i t?o m?t instance m?i c?a l?p <see cref="JobController"/>.
        /// </summary>
        /// <param name="jobPostService">D?ch v? x? ly c�ng vi?c.</param>
        public JobController(IJobPostService jobPostService)
        {
            _jobPostService = jobPostService;
        }

        /// <summary>
        /// T�m ki?m c�c c�ng vi?c d?a tr�n c�c tham s? du?c cung c?p.
        /// </summary>
        /// <param name="param">C�c tham s? t�m ki?m.</param>
        /// <returns>K?t qu? t�m ki?m.</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "Job.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            var jobs = await _jobPostService.Search(param);
            return Ok(jobs);

=== Ladaer.BackEnd\Controllers\Hr\README_AttendanceAPI.md ===
# Attendance API Documentation

## T��ng quan

API endpoints m��>i cho bA�o cA�o ch���m cA'ng vA� tA-nh s��` cA'ng c��a nhA�n viA�n.

## Endpoints

### 1. GET `/api/Attendance/GetMonthlySummary`

**MA' t���**: L���y t��ng h���p s��` cA'ng c��a t���t c��� nhA�n viA�n theo thA�ng.

**Authorization**: Required (Role: `Attendance.GetMonthlySummary`)

**Query Parameters**:
- `month` (int, required): ThA�ng c��n bA�o cA�o (1-12)
- `year` (int, required): N��m c��n bA�o cA�o (vA- d���: 2025)

**Response Success (200 OK)**:
```json
[
  {
    "UserId": 1,
    "UserName": "johndoe",
    "FullName": "Nguy��.n V��n A",
    "TotalWorkDays": 22,
    "TotalWorkingHours": 176.5,
    "TotalWorkCredits": 21.75,
    "Month": 1,
    "Year": 2025
  },
  {
    "UserId": 2,
    "UserName": "janedoe",
    "FullName": "Tr��n Th��< B",
    "TotalWorkDays": 20,
    "TotalWorkingHours": 160.0,
    "TotalWorkCredits": 20.0,
    "Month": 1,
    "Year": 2025

=== Ladaer.BackEnd\Controllers\Identity\AccountController.cs ===
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.DTO;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Accounts;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Users;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Accounts;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Users;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using SixLabors.ImageSharp;
using System.IdentityModel.Tokens.Jwt;
namespace Ladaer.BackEnd.Controllers.Identity
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class AccountController : ControllerBase
    {
        IConfiguration _configuration;
        private int STAFF_USER_TYPE = 10;
        private readonly UserManager<User> _userManager;
        private readonly IUserService _userService;

        public AccountController(IConfiguration configuration, UserManager<User> userManager, IUserService userService)
        {
            _configuration = configuration;
            _userManager = userManager;
            _userService = userService;
        }

        [HttpPost("Login")]
        [AllowAnonymous]
        public async Task<IActionResult> Login([FromBody] LoginModel model)
        {
            var result = new LoginResult();
            if (!ModelState.IsValid)
            {

=== Ladaer.BackEnd\Controllers\Identity\PermissionController.cs ===
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Itentity;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Identity
{
    /// <summary>
    /// Controller �`��� qu���n lA� Permission Groups (t��-p h���p cA�c Role)
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize(Roles = "Founder")] // S��- d���ng pattern m��>i: Controller.Action
    public class PermissionController : ControllerBase
    {
        private readonly IPermissionService _permissionService;

        public PermissionController(IPermissionService permissionService)
        {
            _permissionService = permissionService;
        }

        [HttpGet("GetPermissions")]
        [Authorize(Roles = "Permission.Search")]
        public async Task<IActionResult> GetPermissions()
        {
            var roles = await _permissionService.GetAllPermissionsAsync();
            return Ok(roles);
        }


        /// <summary>
        /// XA3a Permission Group
        /// </summary>
        [HttpDelete("{id}")]
        [Authorize(Roles = "Permission.Delete")]

=== Ladaer.BackEnd\Controllers\Identity\RoleController.cs ===
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Identity;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Itentity;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Users;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Users;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using static IdentityServer4.IdentityServerConstants;

namespace Ladaer.BackEnd.Controllers.Identity
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class RoleController : ControllerBase
    {
        private readonly IRoleService _roleService;
        public RoleController(IRoleService roleService)
        {
            _roleService = roleService;
        }


        [HttpPost("Search")]
        [Authorize(Roles = "Role.Search")]
        public async Task<IActionResult> Search(SmartTableParam param)
        {
            var result = await _roleService.SearchAsync(param);
            return Ok(result);
        }

        [HttpGet("GetRoles")]
        [Authorize(Roles = "Role.GetRoles")]
        public async Task<IActionResult> GetRoles()

=== Ladaer.BackEnd\Controllers\Identity\RoleMigrationController.cs ===
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Identity
{
    /// <summary>
    /// Controller �`��� qu���n lA� migration t��� old role system sang new Permission system
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize(Roles = "Founder")] // Ch��% Founder m��>i cA3 quy��?n ch���y migration
    public class RoleMigrationController : ControllerBase
    {
        private readonly IRoleMigrationService _migrationService;

        public RoleMigrationController(IRoleMigrationService migrationService)
        {
            _migrationService = migrationService;
        }

        /// <summary>
        /// Ki���m tra tr���ng thA�i migration
        /// </summary>
        [HttpGet("status")]
        [Authorize(Roles = "RoleMigration.GetMigrationStatus")]
        public async Task<IActionResult> GetMigrationStatus()
        {
            var isCompleted = await _migrationService.IsMigrationCompletedAsync();
            return Ok(new { IsCompleted = isCompleted });
        }

        /// <summary>
        /// L���y danh sA�ch Role m��>i s��� �`�����c t���o
        /// </summary>
        [HttpGet("preview-roles")]
        public IActionResult PreviewNewRoles()
        {
            var roles = _migrationService.GetNewRolesToCreate();
            return Ok(roles);

=== Ladaer.BackEnd\Controllers\Identity\UserController.cs ===
using Lada.Framework.Data.Domains.Categories;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Enums;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Identity;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Users;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Users;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Controllers.Identity
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class UserController : ControllerBase
    {
        //private readonly UserManager<User> _userManager;
        private readonly IUserService _userService;

        public UserController(IUserService userService)
        {
            //_userManager = userManager;
            _userService = userService;
        }

        #region Suggestions
        [HttpGet("SugStaff")]
        [Authorize(Roles = "User.SugStaff")]
        public async Task<List<UserOptionItem>> SugStaff(string keyword = "")
        {
            return await _userService.SugUser(keyword, UserType.Staff);

=== Ladaer.BackEnd\Controllers\Medias\NewMediaController.cs ===
using Lada.Framework.Data.Enums;
using Lada.Framework.DTO.Models.Media;
using Lada.Framework.Infrastructures.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Medias
{
    /// <summary>
    /// Controller demo cho New Media Services
    /// </summary>
    [ApiController]
    [Route("api/[controller]")]
    [Authorize]
    public class NewMediaController : ControllerBase
    {
        private readonly IUnifiedMediaService _unifiedMediaService;

        public NewMediaController(IUnifiedMediaService unifiedMediaService)
        {
            _unifiedMediaService = unifiedMediaService;
        }

        #region Basic Image Processing

        /// <summary>
        /// Upload ���nh �`��n gi���n (khA'ng l��u database)
        /// </summary>
        /// <param name="file">File ���nh</param>
        /// <param name="imageType">Lo���i ���nh (avatar, product, general, etc.)</param>
        /// <returns>URL ���nh �`A� x��- lA�</returns>
        [HttpPost("upload-image")]
        [Authorize(Roles = "NewMedia.UploadImage")]
        public async Task<IActionResult> UploadImage(IFormFile file, [FromForm] string imageType = "general")
        {
            try
            {
                if (file == null || file.Length == 0)
                {
                    return BadRequest("KhA'ng cA3 file �`�����c upload");

=== Ladaer.BackEnd\Controllers\Medias\PictureController.cs ===
using Lada.Framework.Data.Enums;
using Lada.Framework.DTO.Results.Media;
using Lada.Framework.Infrastructures.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Medias
{
    /// <summary>
    /// Controller to handle operations related to pictures.
    /// Updated to use UnifiedMediaService from Framework.
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class PictureController : ControllerBase
    {
        private readonly IUnifiedMediaService _unifiedMediaService;

        /// <summary>
        /// Initializes a new instance of the <see cref="PictureController"/> class.
        /// </summary>
        /// <param name="unifiedMediaService">Unified media service from Framework.</param>
        public PictureController(IUnifiedMediaService unifiedMediaService)
        {
            _unifiedMediaService = unifiedMediaService;
        }



        /// <summary>
        /// Uploads a picture for post content.
        /// </summary>
        /// <param name="file">The picture file to upload.</param>
        /// <returns>The result of the upload operation.</returns>
        [HttpPost("UploadPostContentPicture")]
        [Authorize(Roles = "Picture.UploadPostContentPicture")]
        public async Task<IActionResult> UploadPostContentPicture(IFormFile file)
        {
            if (file == null || file.Length == 0)

=== Ladaer.BackEnd\Controllers\Monitor\OrderMonitor\OrderRiskController.cs ===
using Ladaer.BackEnd.Infrastructures.DTO.Models.Monitor;
using Ladaer.BackEnd.Infrastructures.Services.Monitor;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Monitor.OrderMonitor
{
    [Authorize]
    [ApiController]
    [Area("Monitor")]
    [Route("api/Monitor/[controller]")]
    public class OrderRiskController : ControllerBase
    {
        private readonly IOrderRiskService _orderRiskService;

        public OrderRiskController(IOrderRiskService orderRiskService)
        {
            _orderRiskService = orderRiskService;
        }

        #region Source Fee
        /// <summary>
        /// L���y danh sA�ch �`��n hA�ng thu ng����?i g��-i nh��ng khA'ng cA3 SourceCashierId
        /// </summary>
        /// <param name="fromDate">T��� ngA�y (optional)</param>
        /// <param name="toDate">�?���n ngA�y (optional)</param>
        /// <param name="page">Trang (default: 1)</param>
        /// <param name="pageSize">S��` b���n ghi/trang (default: 50)</param>
        [HttpGet("NoSourceCashier")]
        public async Task<IActionResult> GetOrdersWithoutSourceCashier(
            [FromQuery] DateTime? fromDate = null,
            [FromQuery] DateTime? toDate = null,
            [FromQuery] int page = 1,
            [FromQuery] int pageSize = 50)
        {
            try
            {
                var param = new OrderRiskSearchParam
                {
                    FromDate = fromDate,

=== Ladaer.BackEnd\Controllers\Ops\DeployController.cs ===
using Lada.Framework.Data.Enums;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Business.Deploy;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Business;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Categories;
using Ladaer.BackEnd.Infrastructures.Services.Business;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json.Linq;
using Ladaer.BackEnd.Infrastructures.DTO.Models.DriverApp;

namespace Ladaer.BackEnd.Controllers.Ops
{
    /// <summary>
    /// Controller qu���n lA� cA�c ho���t �`��Tng liA�n quan �`���n tri���n khai �`��n hA�ng.
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class DeployController : ControllerBase
    {
        private readonly IDeployService _deployService;

        /// <summary>
        /// Kh��Yi t���o m��Tt instance m��>i c��a l��>p <see cref="DeployController"/>.
        /// </summary>
        /// <param name="deployService">D��<ch v��� x��- lA� tri���n khai �`��n hA�ng.</param>
        public DeployController(IDeployService deployService)
        {
            _deployService = deployService;
        }

        /// <summary>
        /// L���y danh sA�ch cA�c �`��<a �`i���m tri���n khai.
        /// </summary>
        /// <returns>Danh sA�ch cA�c �`��<a �`i���m tri���n khai.</returns>
        [HttpGet("GetDeployLocations")]
        [Authorize(Roles = "Deploy.GetDeployLocations")]

=== Ladaer.BackEnd\Controllers\Ops\OperationController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Business.Operations;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Orders;
using Ladaer.BackEnd.Infrastructures.Services.Business;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Ops
{
    /// <summary>
    /// Controller �`��� x��- lA� cA�c ho���t �`��Tng liA�n quan t��>i quy trA�nh kinh doanh
    /// CA�c ch��cc n��ng Pickup, Delivery �`A� �`�����c di chuy���n sang DriverAppController
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class OperationController : ControllerBase
    {
        private readonly IOperationService _operationService;
        private readonly IUserService _userService;

        /// <summary>
        /// Kh��Yi t���o m��Tt instance m��>i c��a l��>p <see cref="OperationController"/>.
        /// </summary>
        /// <param name="operationService">D��<ch v��� x��- lA� cA�c ho���t �`��Tng.</param>
        /// <param name="userService">D��<ch v��� x��- lA� ng����?i dA1ng.</param>
        public OperationController(IOperationService operationService, IUserService userService)
        {
            _operationService = operationService;
            _userService = userService;
        }

        /// <summary>
        /// TA�m ki���m cA�c ho���t �`��Tng d���a trA�n cA�c tham s��` �`�����c cung c���p.
        /// </summary>
        /// <param name="param">CA�c tham s��` tA�m ki���m.</param>
        /// <returns>K���t qu��� tA�m ki���m.</returns>

=== Ladaer.BackEnd\Controllers\Ops\RouteController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finances;
using Ladaer.BackEnd.Infrastructures.Services.Finances;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Ops
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class RouteController : ControllerBase
    {
        private readonly IRouteService _routeService;
        public RouteController(IRouteService routeService)
        {
            _routeService = routeService;
        }

        #region SEARCH
        /// <summary>
        /// T���m ki?m c���c tuy?n d?a tr���n tham s? SmartTableParam
        /// </summary>
        /// <param name="param">Tham s? t���m ki?m</param>
        /// <returns>Danh s���ch c���c tuy?n ph��� h?p</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "Route.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            var routes = await _routeService.Search(param);
            return Ok(routes);
        }
        #endregion

        #region CRUD
        /// <summary>
        /// L?y th���ng tin tuy?n theo ID
        /// </summary>

=== Ladaer.BackEnd\Controllers\Ops\TruckController.cs ===
using Lada.Framework.Data.Domains.Trucks;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Trucks;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Trucks;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Ladaer.BackEnd.Infrastructures.Services.Trucks;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Ops
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class TruckController : ControllerBase
    {
        private readonly ITruckService _truckService;
        private readonly ITruckAssetService _truckAssetService;
        private readonly ITruckActivityService _truckActivityService;
        private readonly IUserService _userService;
        private readonly IRepository<Truck> _truckRepository;

        public TruckController(ITruckService truckService,
            ITruckAssetService truckAssetService,
            ITruckActivityService truckActivityService,
            IUserService userService,
            IRepository<Truck> truckRepository)
        {
            _truckService = truckService;
            _truckAssetService = truckAssetService;
            _truckActivityService = truckActivityService;
            _userService = userService;
            _truckRepository = truckRepository;
        }

        #region Truck Management

=== Ladaer.BackEnd\Controllers\OrderBusiness\OrderFailReasonController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.OrderBusiness;
using Ladaer.BackEnd.Infrastructures.Services.OrderBusiness;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.OrderBusiness
{
    /// <summary>
    /// Controller qu���n lA� lA� do th���t b���i l���y/giao hA�ng (Admin)
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class OrderFailReasonController : ControllerBase
    {
        private readonly IOrderFailReasonService _service;

        public OrderFailReasonController(IOrderFailReasonService service)
        {
            _service = service;
        }

        /// <summary>
        /// TA�m ki���m lA� do th���t b���i
        /// </summary>
        [HttpPost("Search")]
        [Authorize(Roles = "OrderFailReason.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            var result = await _service.Search(param);
            return Ok(result);
        }

        /// <summary>
        /// L���y thA'ng tin lA� do th���t b���i theo ID
        /// </summary>
        [HttpGet("GetById/{id}")]
        [Authorize(Roles = "OrderFailReason.GetById")]

=== Ladaer.BackEnd\Controllers\Orders\OrderAddressController.cs ===
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders.Shared;
using Ladaer.BackEnd.Infrastructures.Services.Crm;
using Ladaer.BackEnd.Infrastructures.Services.Orders;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Orders
{
    /// <summary>
    /// Controller x��- lA� cA�c ho���t �`��Tng liA�n quan �`���n �`��<a ch��% �`��n hA�ng.
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class OrderAddressController : ControllerBase
    {
        private readonly IOrderAddressService _orderAddressService;
        private readonly ICustomerService _customerService;
        /// <summary>
        /// Kh��Yi t���o m��Tt instance m��>i c��a l��>p <see cref="OrderAddressController"/>.
        /// </summary>
        /// <param name="orderAddressService">D��<ch v��� x��- lA� �`��<a ch��% �`��n hA�ng.</param>
        public OrderAddressController(IOrderAddressService orderAddressService, ICustomerService customerService)
        {
            _orderAddressService = orderAddressService;
            _customerService = customerService;
        }

        /// <summary>
        /// L���y thA'ng tin chi ti���t c��a m��Tt �`��<a ch��% �`��n hA�ng d���a trA�n ID.
        /// </summary>
        /// <param name="id">ID c��a �`��<a ch��% �`��n hA�ng.</param>
        /// <returns>ThA'ng tin chi ti���t c��a �`��<a ch��% �`��n hA�ng.</returns>
        [HttpGet("GetById")]
        [Authorize(Roles = "OrderAddress.GetById")]
        public async Task<IActionResult> GetById(int id)
        {

=== Ladaer.BackEnd\Controllers\Orders\OrderController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.AppSettings;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders.Updates;
using Ladaer.BackEnd.Infrastructures.DTO.Results;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Orders;
using Ladaer.BackEnd.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.Services.Orders;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Options;
using Lada.Framework.Data.Enums;
using System.ComponentModel;
using Lada.Framework.Infrastructures.Extensions;
using System.Reflection;
using Lada.Framework.DTO;

namespace Ladaer.BackEnd.Controllers.Orders
{
    /// <summary>
    /// Controller �`��� x��- lA� cA�c ho���t �`��Tng liA�n quan t��>i �`��n hA�ng
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class OrderController : ControllerBase
    {
        private readonly IOrderService _orderService;
        private readonly string _mapApiKey;

        /// <summary>
        /// Kh��Yi t���o m��Tt instance m��>i c��a l��>p <see cref="OrderController"/>.
        /// </summary>
        /// <param name="options">TA1y ch��?n c���u hA�nh ��cng d���ng.</param>
        /// <param name="orderService">D��<ch v��� x��- lA� �`��n hA�ng.</param>
        public OrderController(IOptions<AppSetting> options, IOrderService orderService)
        {
            _orderService = orderService;
            _mapApiKey = options.Value.GoogleMapsApi.ApiKey;

=== Ladaer.BackEnd\Controllers\Orders\OrderExportController.cs ===
using Lada.Framework.DTO;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Orders;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Ladaer.BackEnd.Infrastructures.Services.Orders.Exports;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Orders
{
    /// <summary>
    /// Controller cho vi���c xu���t Excel �`��n hA�ng (Generic)
    /// </summary>
    [ApiController]
    [Route("api/[controller]")]
    [Authorize]
    public class OrderExportController : ControllerBase
    {
        private readonly IOrderExportService _orderExportService;
        private readonly IUserService _userService;

        public OrderExportController(
            IOrderExportService orderExportService,
            IUserService userService)
        {
            _orderExportService = orderExportService;
            _userService = userService;
        }

        /// <summary>
        /// Xu���t Excel �`��n hA�ng v��>i template �`�����c ch��% �`��<nh
        /// </summary>
        /// <param name="model">Model xu���t Excel</param>
        /// <returns>K���t qu��� xu���t file</returns>
        [HttpPost("export")]
        public async Task<ActionResult<OrderExportResult>> ExportOrders([FromBody] OrderExportModel model)
        {
            try
            {

=== Ladaer.BackEnd\Controllers\Orders\OrderFinController.cs ===
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders.Shared;
using Ladaer.BackEnd.Infrastructures.Services.Orders;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Orders
{
    /// <summary>
    /// Controller �`��� x��- lA� cA�c ho���t �`��Tng liA�n quan �`���n tA�i chA-nh �`��n hA�ng.
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class OrderFinController : ControllerBase
    {
        private readonly IOrderFinService _orderFinService;

        /// <summary>
        /// Kh��Yi t���o m��Tt instance m��>i c��a l��>p <see cref="OrderFinController"/>.
        /// </summary>
        /// <param name="orderFinService">D��<ch v��� x��- lA� tA�i chA-nh �`��n hA�ng.</param>
        public OrderFinController(IOrderFinService orderFinService)
        {
            _orderFinService = orderFinService;
        }

        /// <summary>
        /// L���y thA'ng tin chi ti���t c��a tA�i chA-nh �`��n hA�ng d���a trA�n ID.
        /// </summary>
        /// <param name="id">ID c��a tA�i chA-nh �`��n hA�ng.</param>
        /// <returns>ThA'ng tin chi ti���t c��a tA�i chA-nh �`��n hA�ng.</returns>
        [HttpGet("GetById")]
        [Authorize(Roles = "OrderFin.GetById")]
        public async Task<IActionResult> GetById(int id)
        {
            var result = await _orderFinService.GetById(id);
            return Ok(result);

=== Ladaer.BackEnd\Controllers\Orders\OrderPackageController.cs ===
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders.Shared;
using Ladaer.BackEnd.Infrastructures.Services.Orders;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Orders
{
    /// <summary>
    /// Controller �`��� x��- lA� cA�c ho���t �`��Tng liA�n quan �`���n ki���n hA�ng �`��n hA�ng.
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class OrderPackageController : ControllerBase
    {
        private readonly IOrderPackageService _orderPackageService;

        /// <summary>
        /// Initializes a new instance of the <see cref="OrderPackageController"/> class.
        /// </summary>
        /// <param name="orderPackageService">D��<ch v��� x��- lA� ki���n hA�ng �`��n hA�ng.</param>
        public OrderPackageController(IOrderPackageService orderPackageService)
        {
            _orderPackageService = orderPackageService;
        }

        /// <summary>
        /// L���y thA'ng tin chi ti���t c��a ki���n hA�ng �`��n hA�ng d���a trA�n ID.
        /// </summary>
        /// <param name="id">ID c��a �`��n hA�ng.</param>
        /// <returns>ThA'ng tin chi ti���t c��a ki���n hA�ng �`��n hA�ng.</returns>
        [HttpGet("GetByOrderId")]
        [Authorize(Roles = "OrderPackage.GetByOrderId")]
        public async Task<IActionResult> GetByOrderId(int id)
        {
            var result = await _orderPackageService.GetByOrderId(id);
            return Ok(result);
        }

=== Ladaer.BackEnd\Controllers\Premises\PremiseController.cs ===
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Premises;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Premises;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Premises;
using Ladaer.BackEnd.Infrastructures.Services.Premises;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Premises
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class PremiseController : ControllerBase
    {
        private readonly IPremiseService _service;

        public PremiseController(IPremiseService service)
        {
            _service = service;
        }

        /// <summary>
        /// TA�m ki���m danh sA�ch m���t b���ng
        /// </summary>
        [HttpPost("Search")]
        [Authorize(Roles = "Premise.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            var result = await _service.Search(param);
            return Ok(result);
        }

        /// <summary>
        /// L���y chi ti���t m���t b���ng theo ID
        /// </summary>
        [HttpGet("GetById/{id}")]
        [Authorize(Roles = "Premise.GetById")]
        public async Task<IActionResult> GetById(int id)

=== Ladaer.BackEnd\Controllers\Premises\PremiseScoringController.cs ===
using Lada.Framework.DTO.SmartTable;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Premises;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Premises;
using Ladaer.BackEnd.Infrastructures.Services.Premises;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Premises
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class PremiseScoringController : ControllerBase
    {
        private readonly IPremiseScoringService _service;

        public PremiseScoringController(IPremiseScoringService service)
        {
            _service = service;
        }

        /// <summary>
        /// TA�m ki���m tiA�u chA- ch���m �`i���m
        /// </summary>
        [HttpPost("SearchCriteria")]
        [Authorize(Roles = "PremiseScoring.SearchCriteria")]
        public async Task<IActionResult> SearchCriteria([FromBody] SmartTableParam param)
        {
            var result = await _service.SearchCriteria(param);
            return Ok(result);
        }

        /// <summary>
        /// L���y tiA�u chA- theo ID
        /// </summary>
        [HttpGet("GetCriteriaById/{id}")]
        [Authorize(Roles = "PremiseScoring.GetCriteriaById")]
        public async Task<IActionResult> GetCriteriaById(int id)
        {
            var result = await _service.GetCriteriaById(id);

=== Ladaer.BackEnd\Controllers\Reports\ReportController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.Services.Report.Orders;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Reports
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class ReportController : ControllerBase
    {
        private readonly IOrderReportService _orderReportService;

        public ReportController(IOrderReportService orderReportService)
        {
            _orderReportService = orderReportService;
        }

        [HttpPost("OrderProduction")]
        [Authorize(Roles = "Report.OrderProduction")]
        public async Task<IActionResult> OrderProduction([FromBody] SmartTableParam param)
        {
            var currentUser = User.GetCurrentUser();

            var result = await _orderReportService.GetOrderProductionAsync(param, currentUser.UserId);
            return Ok(result);
        }

        /// <summary>
        /// L���y bA�o cA�o s��` l�����ng �`��n vA� doanh s��` theo tuy���n
        /// </summary>
        /// <param name="param">Tham s��` b���ng thA'ng minh ch��ca cA�c �`i��?u ki���n l��?c:
        /// - StartDate/EndDate: Kho���ng th��?i gian
        /// - SaleId: L��?c theo sale (ch��% Founder)
        /// - SourceCityId: L��?c theo t��%nh/thA�nh ph��` g��-i
        /// - DestCityId: L��?c theo t��%nh/thA�nh ph��` nh��-n
        /// </param>
        /// <returns>Danh sA�ch bA�o cA�o theo tuy���n vA� tr���ng thA�i</returns>

=== Ladaer.BackEnd\Controllers\Reports\FuelCards\FuelRefillReportController.cs ===
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Reports.Results;
using Ladaer.BackEnd.Infrastructures.DTO.Results.FuelCards;
using Ladaer.BackEnd.Infrastructures.Services.Report.FuelCards;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Reports.FuelCards
{
    /// <summary>
    /// Controller �`��� x��- lA� cA�c bA�o cA�o �`�� d��u
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class FuelRefillReportController : ControllerBase
    {
        private readonly IFuelRefillReportService _fuelRefillReportService;
        private readonly IFuelRefillReportExcelService _fuelRefillReportExcelService;

        /// <summary>
        /// Kh��Yi t���o m��Tt th��� hi���n c��a <see cref="FuelRefillReportController"/>.
        /// </summary>
        /// <param name="fuelRefillReportService">D��<ch v��� bA�o cA�o �`�� d��u.</param>
        /// <param name="fuelRefillReportExcelService">D��<ch v��� xu���t Excel bA�o cA�o �`�� d��u.</param>
        public FuelRefillReportController(
            IFuelRefillReportService fuelRefillReportService,
            IFuelRefillReportExcelService fuelRefillReportExcelService)
        {
            _fuelRefillReportService = fuelRefillReportService;
            _fuelRefillReportExcelService = fuelRefillReportExcelService;
        }

        /// <summary>
        /// L���y bA�o cA�o �`�� d��u theo lA�i xe
        /// </summary>
        /// <param name="param">Tham s��` b���ng thA'ng minh</param>
        /// <returns>Danh sA�ch bA�o cA�o �`�� d��u theo lA�i xe</returns>

=== Ladaer.BackEnd\Controllers\Reports\Operations\DriverReportController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.Services.Report.OperationReports;
using Ladaer.BackEnd.Infrastructures.DTO.Reports.Results;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Reports.Operations
{
    /// <summary>
    /// Controller �`��� x��- lA� cA�c bA�o cA�o ho���t �`��Tng lA�i xe
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class DriverReportController : ControllerBase
    {
        private readonly IDriverReportService _driverReportService;

        /// <summary>
        /// Kh��Yi t���o m��Tt th��� hi���n c��a <see cref="DriverReportController"/>.
        /// </summary>
        /// <param name="driverReportService">D��<ch v��� bA�o cA�o lA�i xe.</param>
        public DriverReportController(IDriverReportService driverReportService)
        {
            _driverReportService = driverReportService;
        }

        /// <summary>
        /// L���y bA�o cA�o n��ng su���t lA�i xe theo t���ng ngA�y
        /// </summary>
        /// <param name="param">Tham s��` b���ng thA'ng minh</param>
        /// <returns>Danh sA�ch bA�o cA�o n��ng su���t lA�i xe theo ngA�y</returns>
        [HttpPost("GetDriverProductivityReportByDate")]
        [Authorize(Roles = "DriverReport.GetDriverProductivityReportByDate")]
        public async Task<IActionResult> GetDriverProductivityReportByDate([FromBody] SmartTableParam param)
        {
            try
            {
                var currentUser = User.GetCurrentUser();

=== Ladaer.BackEnd\Controllers\Reports\Orders\OrderFinReportController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Data.Enums;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Reports;
using Ladaer.BackEnd.Infrastructures.DTO.StoredProcedureResults;
using Ladaer.BackEnd.Infrastructures.Services.Report.Orders;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Reports.Orders
{
    /// <summary>
    /// Controller �`��� x��- lA� cA�c bA�o cA�o tA�i chA-nh �`��n hA�ng
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class OrderFinReportController : ControllerBase
    {
        private readonly IOrderFinReportService _orderFinReportService;

        /// <summary>
        /// Kh��Yi t���o m��Tt th��� hi���n c��a <see cref="OrderFinReportController"/>.
        /// </summary>
        /// <param name="orderFinReportService">D��<ch v��� bA�o cA�o tA�i chA-nh �`��n hA�ng.</param>
        public OrderFinReportController(IOrderFinReportService orderFinReportService)
        {
            _orderFinReportService = orderFinReportService;
        }




        /// <summary>
        /// Chu��cn b��< d��_ li���u b��T l��?c: tr���ng thA�i vA� tr���ng thA�i v��-t lA�
        /// </summary>
        /// <returns>Model ch��ca danh sA�ch option tr���ng thA�i vA� tr���ng thA�i v��-t lA�</returns>
        [HttpGet("PrepareBankTransferSummaryBySaleModel")]
        [Authorize(Roles = "OrderFinReport.GetBankTransferSummaryBySale")]

=== Ladaer.BackEnd\Controllers\Reports\Sales\RevenueReportController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.Services.Report.SaleReports;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Reports.Sales
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class RevenueReportController : ControllerBase
    {
        private readonly ISaleReportService _saleReportService;

        public RevenueReportController(ISaleReportService saleReportService)
        {
            _saleReportService = saleReportService;
        }

        /// <summary>
        /// Th��`ng kA� doanh thu bA�n hA�ng
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m</param>
        /// <returns>K���t qu��� th��`ng kA� doanh thu</returns>
        [HttpPost("SaleRevenueStatistics")]
        [Authorize(Roles = "Report.SaleRevenueStatistics")]
        public async Task<IActionResult> SaleRevenueStatistics([FromBody] SmartTableParam param)
        {
            var currentUser = User.GetCurrentUser();

            var result = await _saleReportService.GetSaleRevenueStatisticsAsync(param, currentUser.UserId);
            return Ok(result);
        }

        /// <summary>
        /// Th��`ng kA� �`��n hA�ng vA� doanh thu theo ngA�y
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m</param>
        /// <returns>K���t qu��� th��`ng kA� �`��n hA�ng vA� doanh thu theo ngA�y</returns>

=== Ladaer.BackEnd\Controllers\Rewards\AutoPenaltyConfigController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.Services.Rewards;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Rewards
{
    /// <summary>
    /// Controller qu���n lA� c���u hA�nh ph���t t��� �`��Tng
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class AutoPenaltyConfigController : ControllerBase
    {
        private readonly IAutoPenaltyConfigService _configService;

        public AutoPenaltyConfigController(IAutoPenaltyConfigService configService)
        {
            _configService = configService;
        }

        /// <summary>
        /// L���y c���u hA�nh �`ang hi���u l���c
        /// </summary>
        [HttpGet]
        [Authorize(Roles = "AutoPenaltyConfig.GetCurrentConfig")]
        public async Task<IActionResult> GetCurrentConfig()
        {
            try
            {
                var result = await _configService.GetCurrentConfig();
                if (result == null)
                {
                    return NotFound("Ch��a cA3 c���u hA�nh nA�o");
                }
                return Ok(result);
            }
            catch (Exception ex)

=== Ladaer.BackEnd\Controllers\Rewards\RewardPenaltyController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Rewards;
using Ladaer.BackEnd.Infrastructures.Services.Rewards;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Rewards
{
    /// <summary>
    /// Controller qu���n lA� phi���u th����Yng/ph���t
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class RewardPenaltyController : ControllerBase
    {
        private readonly IRewardPenaltyService _rewardPenaltyService;

        public RewardPenaltyController(IRewardPenaltyService rewardPenaltyService)
        {
            _rewardPenaltyService = rewardPenaltyService;
        }

        /// <summary>
        /// TA�m ki���m phi���u th����Yng/ph���t
        /// </summary>
        [HttpPost("Search")]
        [Authorize(Roles = "RewardPenalty.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            var result = await _rewardPenaltyService.Search(param);
            return Ok(result);
        }

        /// <summary>
        /// L���y phi���u th����Yng/ph���t theo ID
        /// </summary>
        [HttpGet("{id}")]
        [Authorize(Roles = "RewardPenalty.GetById")]

=== Ladaer.BackEnd\Controllers\Systems\AgencyController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Categories;
using Ladaer.BackEnd.Infrastructures.Services.Categories;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Systems
{
    /// <summary>
    /// Controller �`��� x��- lA� cA�c ho���t �`��Tng liA�n quan �`���n �`���i lA�.
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class AgencyController : ControllerBase
    {
        private readonly IAgencyService _agencyService;

        /// <summary>
        /// Kh��Yi t���o m��Tt instance m��>i c��a l��>p <see cref="AgencyController"/>.
        /// </summary>
        /// <param name="agencyService">D��<ch v��� x��- lA� �`���i lA�.</param>
        public AgencyController(IAgencyService agencyService)
        {
            _agencyService = agencyService;
        }

        /// <summary>
        /// TA�m ki���m cA�c �`���i lA� d���a trA�n cA�c tham s��` �`�����c cung c���p.
        /// </summary>
        /// <param name="param">CA�c tham s��` tA�m ki���m.</param>
        /// <returns>K���t qu��� tA�m ki���m.</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "Agency.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            var agencies = await _agencyService.Search(param);
            return Ok(agencies);
        }

=== Ladaer.BackEnd\Controllers\Systems\AgencyLocationController.cs ===
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Categories;
using Ladaer.BackEnd.Infrastructures.Services.Categories;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Systems
{
    /// <summary>
    /// Controller �`��� x��- lA� cA�c ho���t �`��Tng liA�n quan �`���n vA1ng ph�� c��a �`���i lA�
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class AgencyLocationController : ControllerBase
    {
        private readonly IAgencyLocationService _agencyLocationService;

        /// <summary>
        /// Kh��Yi t���o m��Tt instance m��>i c��a l��>p <see cref="AgencyLocationController"/>.
        /// </summary>
        /// <param name="agencyLocationService">Service x��- lA� vA1ng ph�� c��a �`���i lA�</param>
        public AgencyLocationController(IAgencyLocationService agencyLocationService)
        {
            _agencyLocationService = agencyLocationService;
        }

        /// <summary>
        /// L���y thA'ng tin vA1ng ph�� c��a �`���i lA�
        /// </summary>
        /// <param name="agencyId">ID c��a �`���i lA�</param>
        /// <returns>ThA'ng tin vA1ng ph�� bao g��"m danh sA�ch location</returns>
        [HttpGet("GetAgencyCoverage")]
        [Authorize(Roles = "AgencyLocation.GetAgencyCoverage")]
        public async Task<IActionResult> GetAgencyCoverage(int agencyId)
        {
            if (agencyId <= 0)
            {
                return BadRequest("AgencyId khA'ng h���p l���");
            }

=== Ladaer.BackEnd\Controllers\Systems\AiController.cs ===
using Ladaer.BackEnd.Infrastructures.Services.AI;
using Ladaer.BackEnd.Infrastructures.Services.Cms;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Systems
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class AiController : ControllerBase
    {
        private readonly IOpenAiService _openAiService;
        private readonly IPostService _postService;

        public AiController(IOpenAiService openAiService, IPostService postService)
        {
            _openAiService = openAiService;
            _postService = postService;
        }

        public class PromptCallRequest
        {
            public int TemplateId { get; set; }
            public string Input { get; set; }
        }

        [HttpGet("CallPostAi")]
        [Authorize(Roles = "Ai.CallPrompt")]
        public async Task<IActionResult> CallPrompt(int id)
        {
            try
            {
                var post = await _postService.GetById(id);
                var result = await _openAiService.CallPromptTemplateAsync(1, post.Description);
                return Ok(result);
            }
            catch (Exception ex)
            {

=== Ladaer.BackEnd\Controllers\Systems\AppConfigController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.AppConfig;
using Ladaer.BackEnd.Infrastructures.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Systems
{
    /// <summary>
    /// Controller qu���n lA� c���u hA�nh ��cng d���ng (AppConfig)
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class AppConfigController : ControllerBase
    {
        private readonly IAppConfigManagementService _appConfigService;

        public AppConfigController(IAppConfigManagementService appConfigService)
        {
            _appConfigService = appConfigService;
        }

        /// <summary>
        /// TA�m ki���m AppConfig v��>i SmartTable
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m</param>
        /// <returns>K���t qu��� tA�m ki���m</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "AppConfig.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            var result = await _appConfigService.Search(param);
            return Ok(result);
        }

        /// <summary>
        /// L���y AppConfig theo Id
        /// </summary>

=== Ladaer.BackEnd\Controllers\Systems\CallPathController.cs ===

using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Settings;
using Ladaer.BackEnd.Infrastructures.Services.Settings;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Systems
{
    /// <summary>
    /// Controller �`��� x��- lA� cA�c ho���t �`��Tng liA�n quan �`���n call path.
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class CallPathController : ControllerBase
    {
        private readonly ICallPathService _callPathService;

        /// <summary>
        /// Kh��Yi t���o m��Tt instance m��>i c��a l��>p <see cref="CallPathController"/>.
        /// </summary>
        /// <param name="callPathService">D��<ch v��� x��- lA� call path.</param>
        public CallPathController(ICallPathService callPathService)
        {
            _callPathService = callPathService;
        }

        /// <summary>
        /// L���y danh sA�ch t���t c��� call path.
        /// </summary>
        /// <returns>Danh sA�ch t���t c��� call path.</returns>
        [HttpGet("GetAll")]
        public async Task<IActionResult> GetAll()
        {
            var result = await _callPathService.GetAllAsync();
            return Ok(result);
        }

=== Ladaer.BackEnd\Controllers\Systems\CallPathVersionController.cs ===

using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Settings;
using Ladaer.BackEnd.Infrastructures.Services.Settings;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Systems
{
    /// <summary>
    /// Controller �`��� qu���n lA� cA�c phiA�n b���n �`����?ng d���n (CallPathVersion).
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class CallPathVersionController : ControllerBase
    {
        private readonly ICallPathVersionService _callPathVersionService;

        public CallPathVersionController(ICallPathVersionService callPathVersionService)
        {
            _callPathVersionService = callPathVersionService;
        }

        /// <summary>
        /// L���y t���t c��� phiA�n b���n (dA1ng cho dropdown).
        /// </summary>
        [HttpGet("GetAll")]
        public async Task<IActionResult> GetAll()
        {
            var result = await _callPathVersionService.GetAllAsync();
            return Ok(result);
        }

        #region Search
        /// <summary>
        /// TA�m ki���m phiA�n b���n theo cA�c tham s��`.
        /// </summary>

=== Ladaer.BackEnd\Controllers\Systems\EndPointsController.cs ===
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Categories;
using Ladaer.BackEnd.Infrastructures.Services.Categories;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Systems
{
    /// <summary>
    /// Controller �`��� x��- lA� cA�c ho���t �`��Tng liA�n quan t��>i �`i���m �`��u cu��`i.
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class EndPointsController : ControllerBase
    {
        private readonly IEndPointsService _endPointsService;

        /// <summary>
        /// Kh��Yi t���o mA't instance m��>i c��a l��>p <see cref="EndPointsController"/>.
        /// </summary>
        /// <param name="endPointsService">D��<ch v��� x��- lA� �`i���m �`��u cu��`i.</param>
        public EndPointsController(IEndPointsService endPointsService)
        {
            _endPointsService = endPointsService;
        }

        /// <summary>
        /// TA�m ki���m cA�c �`i���m �`��u cu��`i d���a trA�n cA�c tham s��` tA�m ki���m.
        /// </summary>
        /// <param name="param">CA�c tham s��` tA�m ki���m.</param>
        /// <returns>K���t qu��� tA�m ki���m.</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "EndPoints.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            var locations = await _endPointsService.Search(param);
            return Ok(locations);
        }

=== Ladaer.BackEnd\Controllers\Systems\ErrorReportController.cs ===
using Lada.Framework.Data.Enums;
using Lada.Framework.DTO.SmartTable;
using Ladaer.BackEnd.Infrastructures.DTO.Models.ErrorReports;
using Ladaer.BackEnd.Infrastructures.Services.ErrorReports;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Systems
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class ErrorReportController : ControllerBase
    {
        private readonly IErrorReportService _errorReportService;

        public ErrorReportController(IErrorReportService errorReportService)
        {
            _errorReportService = errorReportService;
        }

        /// <summary>
        /// T���o m��>i bA�o l��-i (khA'ng c��n �`��ng nh��-p)
        /// </summary>
        /// <param name="model">ThA'ng tin bA�o l��-i</param>
        /// <returns>K���t qu��� t���o bA�o l��-i</returns>
        [HttpPost("Create")]
        [AllowAnonymous]
        public async Task<IActionResult> Create([FromForm] ErrorReportModel model)
        {
            if (!ModelState.IsValid)
            {
                var errors = ModelState.Values
                    .SelectMany(v => v.Errors)
                    .Select(e => e.ErrorMessage)
                    .ToList();

                return BadRequest(new
                {
                    success = false,

=== Ladaer.BackEnd\Controllers\Systems\GoogleMapController.cs ===
using System.Threading.Tasks;
using Hangfire;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.Services.Categories;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Systems
{
    /// <summary>
    /// Controller �`��� x��- lA� cA�c ho���t �`��Tng liA�n quan t��>i Google Maps.
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class GoogleMapController : ControllerBase
    {
        private readonly IGoogleMapService _googleMapService;
        private readonly ILocationService _locationService;

        /// <summary>
        /// Kh��Yi t���o m��Tt instance m��>i c��a l��>p <see cref="GoogleMapController"/>.
        /// </summary>
        /// <param name="googleMapService">D��<ch v��� x��- lA� Google Maps.</param>
        /// <param name="locationService">D��<ch v��� x��- lA� �`��<a �`i���m.</param>
        public GoogleMapController(IGoogleMapService googleMapService, ILocationService locationService)
        {
            _googleMapService = googleMapService;
            _locationService = locationService;
        }

        /// <summary>
        /// KA-ch ho���t cA'ng vi���c l���y t��?a �`��T (lat, long) c��a ph����?ng/xA�.
        /// </summary>
        /// <returns>ThA'ng bA�o k���t qu��� kA-ch ho���t cA'ng vi���c.</returns>
        [HttpGet("GetLatLngJob")]
        [AllowAnonymous]
        public IActionResult GetLatLngJob()

=== Ladaer.BackEnd\Controllers\Systems\LocationController.cs ===
using Hangfire;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Categories;
using Ladaer.BackEnd.Infrastructures.Services.Categories;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Systems
{
    /// <summary>
    /// Controller �`��� x��- lA� cA�c ho���t �`��Tng liA�n quan t��>i �`��<a �`i���m.
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class LocationController : ControllerBase
    {
        private readonly ILocationService _locationService;

        /// <summary>
        /// Kh��Yi t���o m��Tt instance m��>i c��a l��>p <see cref="LocationController"/>.
        /// </summary>
        /// <param name="locationService">D��<ch v��� x��- lA� �`��<a �`i���m.</param>
        public LocationController(ILocationService locationService, IGoogleMapService googleMapService)
        {
            _locationService = locationService;
        }

        #region SEARCH

        /// <summary>
        /// TA�m ki���m cA�c �`��<a �`i���m d���a trA�n cA�c tham s��` �`�����c cung c���p.
        /// </summary>
        /// <param name="param">CA�c tham s��` tA�m ki���m.</param>
        /// <returns>K���t qu��� tA�m ki���m.</returns>
        [HttpPost("Search")]

=== Ladaer.BackEnd\Controllers\Systems\MenuController.cs ===
using Lada.Framework.Data.Domains.Categories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finances;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Categories;
using Ladaer.BackEnd.Infrastructures.Services.Categories;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Systems
{
    /// <summary>
    /// Controller x��- lA� cA�c ho���t �`��Tng liA�n quan �`���n menu.
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class MenuController : ControllerBase
    {
        private readonly IMenuService _menuService;

        /// <summary>
        /// Kh��Yi t���o m��Tt instance m��>i c��a l��>p <see cref="MenuController"/>.
        /// </summary>
        /// <param name="menuService">D��<ch v��� x��- lA� menu.</param>
        public MenuController(IMenuService menuService)
        {
            _menuService = menuService;
        }

        #region Search

        /// <summary>
        /// TA�m ki���m cA�c menu d���a trA�n cA�c tham s��` �`�����c cung c���p.
        /// </summary>
        /// <param name="param">CA�c tham s��` tA�m ki���m.</param>
        /// <returns>K���t qu��� tA�m ki���m.</returns>

=== Ladaer.BackEnd\Controllers\Systems\WarehouseController.cs ===
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Business.Warehouses;
using Ladaer.BackEnd.Infrastructures.Services.Business;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Systems
{

    /// <summary>
    /// Controller x��- lA� cA�c yA�u c��u liA�n quan �`���n kho hA�ng.
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class WarehouseController : ControllerBase
    {
        private readonly IWarehouseService _warehouseService;
        private readonly IUserService _userService;

        /// <summary>
        /// Kh��Yi t���o m��Tt th��� hi���n m��>i c��a l��>p <see cref="WarehouseController"/>.
        /// </summary>
        /// <param name="userService">D��<ch v��� ng����?i dA1ng.</param>
        /// <param name="warehouseService">D��<ch v��� kho hA�ng.</param>
        public WarehouseController(IUserService userService, IWarehouseService warehouseService)
        {
            _userService = userService;
            _warehouseService = warehouseService;
        }

        /// <summary>
        /// X��- lA� yA�u c��u nh��-p kho cho m��Tt �`��n hA�ng.
        /// </summary>
        /// <param name="model">MA' hA�nh ch��ca thA'ng tin �`��n hA�ng.</param>
        /// <returns>K���t qu��� c��a quA� trA�nh nh��-p kho.</returns>
        [HttpPost("Inbound")]
        [Authorize(Roles = "Warehouse.Inbound")]
        public async Task<IActionResult> Inbound([FromBody] InboundModel model)

=== Ladaer.BackEnd\Infrastructures\AppSettings\AppSetting.cs ===
namespace Ladaer.BackEnd.Infrastructures.AppSettings
{
    public class AppSetting
    {
        public GoogleMapsApi GoogleMapsApi { get; set; }
    }

    public class GoogleMapsApi
    {
        public string ApiKey { get; set; }
    }
}

=== Ladaer.BackEnd\Infrastructures\AppSettings\CmsSetting.cs ===
namespace Ladaer.BackEnd.Infrastructures.AppSettings
{
    public class CmsSetting
    {
        public SeoSetting SeoSetting { get; set; }
    }
    public class SeoSetting
    {
        public int MetaTitleLength { get; set; }
        public int MetaDescriptionLength { get; set; }
    }
}

=== Ladaer.BackEnd\Infrastructures\AppSettings\JwtSettings.cs ===
namespace Ladaer.BackEnd.Infrastructures.AppSettings
{
    public class JwtSettings
    {
        public string Secret { get; set; }
        public string Issuer { get; set; }
        public string Audience { get; set; }
        public double ExpiryMinutes { get; set; }
    }
}

=== Ladaer.BackEnd\Infrastructures\Authorization\FounderBypassAuthorizationHandler.cs ===
using Microsoft.AspNetCore.Authorization;
using System.Security.Claims;

namespace Ladaer.BackEnd.Infrastructures.Authorization
{
    /// <summary>
    /// Custom Authorization Handler cho phAcp Founder bypass t���t c��� role checks
    /// </summary>
    public class FounderBypassAuthorizationHandler : IAuthorizationHandler
    {
        private readonly ILogger<FounderBypassAuthorizationHandler> _logger;

        public FounderBypassAuthorizationHandler(ILogger<FounderBypassAuthorizationHandler> logger)
        {
            _logger = logger;
        }

        public Task HandleAsync(AuthorizationHandlerContext context)
        {
            // Ki���m tra n���u user �`A� authenticated
            if (!context.User.Identity?.IsAuthenticated ?? true)
            {
                return Task.CompletedTask;
            }

            // Ki���m tra n���u user cA3 role "Founder"
            if (context.User.IsInRole("Founder"))
            {
                _logger.LogInformation("Founder access granted for user: {UserId} to resource: {Resource}", 
                    context.User.FindFirst(ClaimTypes.NameIdentifier)?.Value,
                    context.Resource?.ToString() ?? "Unknown");

                // Founder �`�����c phAcp truy c��-p t���t c��� - mark t���t c��� requirements lA� succeeded
                foreach (var requirement in context.Requirements)
                {
                    if (!context.HasSucceeded)
                    {
                        context.Succeed(requirement);
                    }
                }

=== Ladaer.BackEnd\Infrastructures\Extensions\MediaServiceExtensions.cs ===
using Lada.Framework.Data.Enums;
using Lada.Framework.DTO.Results.Media;
using Lada.Framework.Infrastructures.AppSettings;
using Lada.Framework.Infrastructures.Services;
using Lada.Framework.Data.Repositories;

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;

namespace Ladaer.BackEnd.Infrastructures.Extensions
{
    /// <summary>
    /// Extension methods �`��� c���u hA�nh Media Services
    /// </summary>
    public static class MediaServiceExtensions
    {
        /// <summary>
        /// �?��ng kA� t���t c��� Media Services m��>i (ImageService, VideoService, UnifiedMediaService)
        /// </summary>
        /// <param name="services">Service collection</param>
        /// <param name="configuration">Configuration</param>
        /// <returns>Service collection</returns>
        public static IServiceCollection AddNewMediaServices(this IServiceCollection services, IConfiguration configuration)
        {
            // 1. C���u hA�nh MediaProcessingSettings t��� appsettings.json
            services.Configure<MediaProcessingSettings>(configuration.GetSection("MediaProcessingSettings"));

            // 2. �?��ng kA� core services v��>i dependency injection
            services.AddScoped<IImageService>(provider =>
            {
                var settings = provider.GetRequiredService<IOptions<MediaProcessingSettings>>();
                var appConfigService = provider.GetService<IAppConfigService>();
                var mediaRepository = provider.GetService<IRepository<Lada.Framework.Data.Domains.Medias.Media>>();
                return new ImageService(settings, appConfigService, mediaRepository);
            });

            services.AddScoped<IVideoService>(provider =>
            {
                var settings = provider.GetRequiredService<IOptions<MediaProcessingSettings>>();

=== Ladaer.BackEnd\Infrastructures\Hangfires\DashboardAuthorizationFilter.cs ===
using Hangfire.Annotations;
using Hangfire.Dashboard;

namespace Ladaer.BackEnd.Infrastructures.Hangfires
{
    public class DashboardAuthorizationFilter : IDashboardAuthorizationFilter
    {
        public bool Authorize([NotNull] DashboardContext context)
        {
            return true;
            //return context.GetHttpContext().User.Identity.IsAuthenticated;
        }
    }
}

=== Ladaer.BackEnd\Infrastructures\Services\AppConfigManagementService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Items.AppConfig;
using Ladaer.BackEnd.Infrastructures.DTO.Models.AppConfig;
using Ladaer.BackEnd.Infrastructures.DTO.Profiles;
using Ladaer.BackEnd.Infrastructures.DTO.Results.AppConfig;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Memory;

namespace Ladaer.BackEnd.Infrastructures.Services
{
    /// <summary>
    /// Interface cho service qu���n lA� AppConfig
    /// </summary>
    public interface IAppConfigManagementService
    {
        /// <summary>
        /// TA�m ki���m AppConfig v��>i SmartTable
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m</param>
        /// <returns>K���t qu��� tA�m ki���m</returns>
        Task<SmartTableResult<AppConfigItem>> Search(SmartTableParam param);

        /// <summary>
        /// T���o ho���c c��-p nh��-t AppConfig
        /// </summary>
        /// <param name="model">Model AppConfig</param>
        /// <returns>K���t qu��� thao tA�c</returns>
        Task<AppConfigResult> CreateOrUpdate(CreateAppConfigModel model);

        /// <summary>
        /// L���y AppConfig theo Id
        /// </summary>
        /// <param name="id">Id c��a AppConfig</param>
        /// <returns>AppConfig model</returns>
        Task<CreateAppConfigModel> GetById(int id);


=== Ladaer.BackEnd\Infrastructures\Services\AppConfigService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Repositories;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Memory;

namespace Ladaer.BackEnd.Infrastructures.Services
{
    public interface IAppConfigService
    {
        Task<string> GetConfigValueAsync(string key);
        Task LoadConfigsToCacheAsync();
    }


    public class AppConfigService : IAppConfigService
    {
        private readonly IRepository<AppConfig> _appConfigRepository;
        private readonly IMemoryCache _memoryCache;
        private readonly string _cacheKeyPrefix = "AppConfig_";



        public AppConfigService(IRepository<AppConfig> appConfigRepository, IMemoryCache memoryCache)
        {
            _appConfigRepository = appConfigRepository;
            _memoryCache = memoryCache;
        }
        

        public async Task<string> GetConfigValueAsync(string key)
        {
            if (!_memoryCache.TryGetValue($"{_cacheKeyPrefix}{key}", out string value))
            {
                var config = await _appConfigRepository.Query().FirstOrDefaultAsync(c=>c.Key == key);
                if (config != null)
                {
                    value = config.Value;
                    _memoryCache.Set($"{_cacheKeyPrefix}{key}", value, TimeSpan.FromHours(1));
                }
            }

=== Ladaer.BackEnd\Infrastructures\Services\AppConfigServiceAdapter.cs ===
using Lada.Framework.Infrastructures.Services;

namespace Ladaer.BackEnd.Infrastructures.Services
{
    /// <summary>
    /// Adapter �`��� chuy���n �`��i Framework IAppConfigService thA�nh Backend IAppConfigService
    /// (Backward compatibility)
    /// </summary>
    public class BackendAppConfigServiceAdapter : Ladaer.BackEnd.Infrastructures.Services.IAppConfigService
    {
        private readonly Lada.Framework.Infrastructures.Services.IAppConfigService _frameworkService;

        public BackendAppConfigServiceAdapter(Lada.Framework.Infrastructures.Services.IAppConfigService frameworkService)
        {
            _frameworkService = frameworkService;
        }

        public async Task<string> GetConfigValueAsync(string key)
        {
            return await _frameworkService.GetConfigValueAsync(key);
        }

        public async Task LoadConfigsToCacheAsync()
        {
            await _frameworkService.LoadConfigsToCacheAsync();
        }
    }
}

=== Ladaer.BackEnd\Infrastructures\Services\AuthService.cs ===
using IdentityModel.Client;

namespace Ladaer.BackEnd.Infrastructures.Services
{
    public class AuthService
    {
        private readonly HttpClient _httpClient;
        public AuthService(HttpClient httpClient)
        {
            _httpClient = httpClient;
        }

        public async Task<TokenResponse> LoginAsync(string username, string password)
        {
            var disco = await _httpClient.GetDiscoveryDocumentAsync("https://id.ladaexpress.vn");
            if (disco.IsError)
            {
                throw new Exception(disco.Error);
            }

            var tokenResponse = await _httpClient.RequestPasswordTokenAsync(new PasswordTokenRequest
            {
                Address = disco.TokenEndpoint,
                ClientId = "AppClients",
                ClientSecret = "kNbPZcuUMc6nufZ2oIJN",
                Scope = "BackEnd",
                UserName = username,
                Password = password
            });

            if (tokenResponse.IsError)
            {
                throw new Exception(tokenResponse.Error);
            }

            return tokenResponse;
        }
    }
}

=== Ladaer.BackEnd\Infrastructures\Services\AI\OpenAiService.cs ===
using IdentityServer4.Models;
using Lada.Framework.Data.Domains.AI;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using OpenAI;
using OpenAI.Chat;
using OpenAI.Models;


namespace Ladaer.BackEnd.Infrastructures.Services.AI
{
    public interface IOpenAiService
    {
        Task<string> CallPromptTemplateAsync(int templateId, string input);
    }

    public class OpenAiService : IOpenAiService
    {
        private readonly OpenAIClient _openAiClient;
        private readonly IRepository<AiCallLog> _aiCalllogRepository;
        private readonly IRepository<PromptTemplate> _promptTemplateRepository;

        public OpenAiService(OpenAIClient openAiClient, IRepository<AiCallLog> aiCalllogRepository, IRepository<PromptTemplate> promptTemplateRepository)
        {
            _openAiClient = openAiClient;
            _aiCalllogRepository = aiCalllogRepository;
            _promptTemplateRepository = promptTemplateRepository;
        }




        public async Task<string> CallPromptTemplateAsync(int templateId, string input)
        {
            var promptTemplate = await _promptTemplateRepository.GetByIdAsync(templateId);
            if (promptTemplate == null)
                throw new Exception($"Prompt ID {templateId} kh�ng t�m th?y.");

            string prompt = promptTemplate.Template.Replace("{{input}}", input);


=== Ladaer.BackEnd\Infrastructures\Services\Business\DeployService.cs ===
using System.Data;
using Dapper;
using Lada.Framework.Data.Domains.Categories;
using Lada.Framework.Data.Domains.Medias;
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Business.Deploy;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Identity;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Business;
using Ladaer.BackEnd.Infrastructures.DTO.Models.DriverApp;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Business;
using Ladaer.BackEnd.Infrastructures.Services.Categories;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Ladaer.BackEnd.Infrastructures.Services.Orders;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json.Linq;

namespace Ladaer.BackEnd.Infrastructures.Services.Business
{
    /// <summary>
    /// Interface cho d?ch v? tri?n khai
    /// </summary>
    public interface IDeployService
    {
        /// <summary>
        /// L?y danh s�ch v? tr� tri?n khai
        /// </summary>
        /// <param name="status">Tr?ng th�i don h�ng</param>
        /// <param name="physicalStatus">Tr?ng th�i v?t ly don h�ng</param>
        /// <param name="addressType">Lo?i d?a ch?</param>
        /// <returns>Danh s�ch v? tr� tri?n khai</returns>
        Task<List<DeployLocationItem>> GetDeployLocations(OrderStatus status, OrderPhysicalStatus physicalStatus, AddressType addressType);

=== Ladaer.BackEnd\Infrastructures\Services\Business\OperationService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Business.Operations;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Identity;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Business.Operations;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders.Updates;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Orders;
using Ladaer.BackEnd.Infrastructures.Services.Categories;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.Services.Orders;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json.Linq;
using Xabe.FFmpeg;
using Dapper;
using System.Data;

namespace Ladaer.BackEnd.Infrastructures.Services.Business
{
    /// <summary>
    /// Interface for operation service.
    /// </summary>
    public interface IOperationService
    {
        /// <summary>
        /// Searches for orders based on the provided parameters.
        /// </summary>
        /// <param name="param">Search parameters.</param>
        /// <param name="userId">User ID.</param>
        /// <returns>Search results.</returns>
        Task<SmartTableResult<OpsOrderItem>> Search(SmartTableParam param, int userId);

        /// <summary>

=== Ladaer.BackEnd\Infrastructures\Services\Business\WarehouseService.cs ===
using Dapper;
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Business.Deploy;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Business.Warehouse;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Business.Warehouses;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Business;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.Services.Orders;
using Microsoft.EntityFrameworkCore;
using System.Data;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Identity;

namespace Ladaer.BackEnd.Infrastructures.Services.Business
{
    /// <summary>
    /// Giao di?n cho WarehouseService
    /// </summary>
    public interface IWarehouseService
    {
        /// <summary>
        /// X? ly qu� tr�nh nh?p kho cho m?t don h�ng.
        /// </summary>
        /// <param name="model">M� h�nh nh?p kho ch?a th�ng tin don h�ng.</param>
        /// <returns>K?t qu? nh?p kho ch? ra k?t qu? c?a thao t�c.</returns>
        Task<InboundResult> Inbound(InboundModel model);

        /// <summary>
        /// L?y danh s�ch t�i x? theo ID c?a d?i ly v?i t�y ch?n l?c t? kh�a v� ph�n trang.
        /// </summary>
        /// <param name="agencyId">ID c?a d?i ly.</param>
        /// <param name="keyword">T? kh�a t�y ch?n d? l?c t�i x?.</param>
        /// <param name="pageNumber">S? trang cho ph�n trang.</param>
        /// <param name="pageSize">K�ch thu?c trang cho ph�n trang.</param>

=== Ladaer.BackEnd\Infrastructures\Services\Categories\AgencyLocationService.cs ===
using Lada.Framework.Data.Domains.Categories;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Profiles;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Categories
{
    /// <summary>
    /// Interface cho service qu���n lA� vA1ng ph�� c��a �`���i lA�
    /// </summary>
    public interface IAgencyLocationService
    {
        /// <summary>
        /// L���y thA'ng tin vA1ng ph�� c��a agency
        /// </summary>
        /// <param name="agencyId">ID c��a �`���i lA�</param>
        /// <returns>ThA'ng tin vA1ng ph��</returns>
        Task<AgencyCoverageModel> GetAgencyCoverage(int agencyId);

        /// <summary>
        /// ThA�m location vA�o agency
        /// </summary>
        /// <param name="model">ThA'ng tin cA�c location c��n thA�m</param>
        /// <returns>K���t qu��� thA�m</returns>
        Task<BaseResult> AddLocationToAgency(AddLocationsToAgencyModel model);

        /// <summary>
        /// XA3a location kh��?i agency
        /// </summary>
        /// <param name="model">ThA'ng tin cA�c location c��n xA3a</param>
        /// <returns>K���t qu��� xA3a</returns>
        Task<BaseResult> RemoveLocationFromAgency(AddLocationsToAgencyModel model);

        /// <summary>
        /// L���y danh sA�ch location ch��a �`�����c ch��?n cho agency d����>i d���ng cA�y
        /// </summary>
        /// <param name="agencyId">ID c��a �`���i lA�</param>

=== Ladaer.BackEnd\Infrastructures\Services\Categories\AgencyService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Categories;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Categories;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Categories
{
    public interface IAgencyService
    {
        /// <summary>
        /// T�m ki?m d?i ly
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        Task<SmartTableResult<AgencyItem>> Search(SmartTableParam param);

        /// <summary>
        /// T?o/c?p nh?t d?i ly
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        Task<AgencyResult> CreateOrUpdate(AgencyModel model);

        /// <summary>
        /// L?y th�ng tin d?i ly
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        Task<AgencyModel> GetById(int id);

        /// <summary>
        /// X�a d?i ly

=== Ladaer.BackEnd\Infrastructures\Services\Categories\EndPointsService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Categories;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Categories;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Categories
{
    /// <summary>
    /// Interface cho d?ch v? EndPoints.
    /// </summary>
    public interface IEndPointsService
    {
        /// <summary>
        /// T�m ki?m EndPoints d?a tr�n tham s? SmartTable.
        /// </summary>
        /// <param name="param">Tham s? SmartTable.</param>
        /// <returns>K?t qu? t�m ki?m du?i d?ng SmartTableResult.</returns>
        Task<SmartTableResult<EndPointsItem>> Search(SmartTableParam param);

        /// <summary>
        /// T?o m?i ho?c c?p nh?t EndPoints.
        /// </summary>
        /// <param name="model">M� h�nh EndPoints.</param>
        /// <returns>K?t qu? c?a vi?c t?o m?i ho?c c?p nh?t.</returns>
        Task<EndpointsResult> CreateOrUpdate(EndPointsModel model);

        /// <summary>
        /// L?y EndPoints theo Id.
        /// </summary>
        /// <param name="id">Id c?a EndPoints.</param>
        /// <returns>M� h�nh EndPoints.</returns>
        Task<EndPointsModel> GetById(int id);


=== Ladaer.BackEnd\Infrastructures\Services\Categories\LocationService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Categories;
using Lada.Framework.Data.Domains.GoogleMap.PlaceAutocomplete;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.Results.GoogleMap;
using Lada.Framework.DTO.Results.GoogleMap.PlaceAutocomplete;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.AppSettings;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Categories;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Options;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using static IdentityServer4.Models.IdentityResources;

namespace Ladaer.BackEnd.Infrastructures.Services.Categories
{
    /// <summary>
    /// D?ch v? x? ly c�c thao t�c li�n quan d?n d?a di?m
    /// </summary>
    public interface ILocationService
    {
        /// <summary>
        /// T�m ki?m d?a di?m theo tham s? SmartTable
        /// </summary>
        /// <param name="param">Tham s? t�m ki?m</param>
        /// <returns>K?t qu? t�m ki?m</returns>
        Task<SmartTableResult<LocationItem>> Search(SmartTableParam param);

        /// <summary>
        /// T?o m?i ho?c c?p nh?t d?a di?m
        /// </summary>
        /// <param name="model">Th�ng tin d?a di?m</param>

=== Ladaer.BackEnd\Infrastructures\Services\Categories\MenuService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Categories;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Categories;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Categories
{
    public interface IMenuService
    {
        Task<SmartTableResult<MenuItem>> Search(SmartTableParam param);
        Task<List<MenuTreeItem>> GetTree(AppType appType, string keyword);

        Task<List<MenuTreeItem>> GetMenuList(int userId, AppType appType);
        Task<MenuResult> CreateOrUpdate(MenuModel model);
        Task<MenuModel> GetById(int menuId);
        Task<BaseResult> Delete(int menuId);
        Task<BaseResult> UpdateStatus(MenuStatusModel model, MenuStatus newStatus);
    }
    public class MenuService : IMenuService
    {
        private readonly IRepository<Menu> _menuRepository;
        private readonly IUserService _userService;
        public MenuService(IRepository<Menu> menuRepository, IUserService userService)
        {
            _menuRepository = menuRepository;
            _userService = userService;
        }

        #region SEARCH - GET
        public async Task<SmartTableResult<MenuItem>> Search(SmartTableParam param)
        {

=== Ladaer.BackEnd\Infrastructures\Services\Cms\CategoryService.cs ===

using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Categories;
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Cms;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Cms;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Cms;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Hosting;

namespace Ladaer.BackEnd.Infrastructures.Services.Cms
{
    /// <summary>
    /// Giao di?n cho d?ch v? qu?n ly danh m?c.
    /// </summary>
    public interface ICategoryService
    {
        /// <summary>
        /// T�m ki?m danh m?c.
        /// </summary>
        /// <param name="param">Th�ng s? t�m ki?m.</param>
        /// <returns>K?t qu? t�m ki?m danh m?c.</returns>
        Task<SmartTableResult<CategoryItem>> Search(SmartTableParam param);

        /// <summary>
        /// L?y c�y danh m?c.
        /// </summary>
        /// <param name="keyword">T? kh�a t�m ki?m.</param>
        /// <returns>Danh s�ch c�y danh m?c.</returns>
        Task<List<CategoryTreeItem>> GetTree(string keyword, ContentType contentType = ContentType.Post);


=== Ladaer.BackEnd\Infrastructures\Services\Cms\PostCategoryService.cs ===
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;

namespace Ladaer.BackEnd.Infrastructures.Services.Cms
{
    public interface IPostCategoryService
    {
        Task<BaseResult> RemovePostCategoryByPostIdAsync(int postId);
    }
    public class PostCategoryService: IPostCategoryService
    {
        private readonly IRepository<PostCategory> _postCategoryRepository;

        public PostCategoryService(IRepository<PostCategory> postCategoryRepository)
        {
            _postCategoryRepository = postCategoryRepository;
        }

        public async Task<BaseResult> RemovePostCategoryByPostIdAsync(int postId)
        {
            var result = new BaseResult();
            var postCategories = _postCategoryRepository.Query().Where(pt => pt.PostId == postId).ToList();
            try
            {
                if (postCategories != null && postCategories.Any())
                {
                    foreach (var postCategory in postCategories)
                    {
                        await _postCategoryRepository.RemoveAsync(postCategory);
                    }
                }
            }
            catch (Exception ex)
            {
                result.Result = Result.Failed;
                result.Message = ex.Message;
            }

            return result;

=== Ladaer.BackEnd\Infrastructures\Services\Cms\PostService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.AppSettings;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.AppSettings;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Cms;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Cms;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Cms;
using Microsoft.AspNetCore.Http.HttpResults;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Options;
using System.Drawing.Imaging;
using System.Linq;

namespace Ladaer.BackEnd.Infrastructures.Services.Cms
{
    /// <summary>
    /// Giao di?n cho d?ch v? qu?n ly b�i vi?t.
    /// </summary>
    public interface IPostService
    {
        /// <summary>
        /// T�m ki?m b�i vi?t
        /// </summary>
        /// <param name="param">Th�ng s? t�m ki?m.</param>
        /// <returns>K?t qu? t�m ki?m b�i vi?t.</returns>
        Task<SmartTableResult<PostItem>> Search(SmartTableParam param);

        /// <summary>
        /// T?o / c?p nh?t b�i vi?t
        /// </summary>
        /// <param name="model">Th�ng tin b�i vi?t.</param>
        /// <returns>K?t qu? c?a thao t�c.</returns>
        Task<PostResult> CreateOrUpdate(PostModel model);


=== Ladaer.BackEnd\Infrastructures\Services\Cms\ProductCategoryService.cs ===
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;

namespace Ladaer.BackEnd.Infrastructures.Services.Cms
{
    public interface IProductCategoryService
    {
        Task<BaseResult> RemoveProductCategoryByProductIdAsync(int productId);
    }
    public class ProductCategoryService : IProductCategoryService
    {
        private readonly IRepository<ProductCategory> _productCategoryRepository;

        public ProductCategoryService(IRepository<ProductCategory> productCategoryRepository)
        {
            _productCategoryRepository = productCategoryRepository;
        }

        public async Task<BaseResult> RemoveProductCategoryByProductIdAsync(int productId)
        {
            var result = new BaseResult();
            var productCategories = _productCategoryRepository.Query().Where(pt => pt.ProductId == productId).ToList();
            try
            {
                if (productCategories != null && productCategories.Any())
                {
                    foreach (var productCategory in productCategories)
                    {
                        await _productCategoryRepository.RemoveAsync(productCategory);
                    }
                }
            }
            catch (Exception ex)
            {
                result.Result = Result.Failed;
                result.Message = ex.Message;
            }

            return result;

=== Ladaer.BackEnd\Infrastructures\Services\Cms\ProductService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.AppSettings;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Cms;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Cms;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Cms;
using Microsoft.AspNetCore.Http.HttpResults;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Options;
using static Microsoft.Extensions.Logging.EventSource.LoggingEventSource;
namespace Ladaer.BackEnd.Infrastructures.Services.Cms
{
    /// <summary>
    /// Giao di?n cho d?ch v? qu?n ly d?ch v?.
    /// </summary>
    public interface IProductService
    {
        /// <summary>
        /// T�m ki?m d?ch v?
        /// </summary>
        /// <param name="param">Th�ng s? t�m ki?m.</param>
        /// <returns>K?t qu? t�m ki?m d?ch v?.</returns>
        Task<SmartTableResult<ProductItem>> Search(SmartTableParam param);

        /// <summary>
        /// L?y th�ng tin d?ch v? qua Id
        /// </summary>
        /// <param name="productId">Id c?a d?ch v?.</param>
        /// <returns>Th�ng tin d?ch v?.</returns>
        Task<ProductModel> GetById(int productId);
        Task<ProductResult> CreateOrUpdate(ProductModel model);

        /// <summary>
        /// X�a b�i vi?t

=== Ladaer.BackEnd\Infrastructures\Services\Cms\ProductTagService.cs ===
namespace Ladaer.BackEnd.Infrastructures.Services.Cms
{
    public class ProductTagService
    {
    }
}

=== Ladaer.BackEnd\Infrastructures\Services\Cms\ScriptConfigService.cs ===
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Cms;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Cms;
using Ladaer.BackEnd.Infrastructures.DTO;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System;
using Lada.Framework.Data.Domains;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Cms;
using Lada.Framework.Infrastructures.Helpers;


namespace Ladaer.BackEnd.Infrastructures.Services.Cms
{
    public interface IScriptConfigService
    {
        Task<List<ScriptConfig>> GetAllAsync(bool onlyActive = false);
        Task<ScriptConfig> GetByIdAsync(int id);
        Task<ScriptConfigResult> CreateOrUpdate(ScriptConfigModel model);
        Task DeleteAsync(int id);
        Task<SmartTableResult<ScriptConfigItem>> Search(SmartTableParam param);
        Task<ScriptConfigResult> Create(ScriptConfigModel model);
        Task<ScriptConfigResult> Update(ScriptConfigModel model);
    }

    public class ScriptConfigService : IScriptConfigService
    {
        private readonly IRepository<ScriptConfig> _repository;
        public ScriptConfigService(IRepository<ScriptConfig> repository)
        {
            _repository = repository;
        }

        public async Task<List<ScriptConfig>> GetAllAsync(bool onlyActive = false)
        {

=== Ladaer.BackEnd\Infrastructures\Services\Cms\TagService.cs ===
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Cms;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Cms
{
    public interface ITagService
    {

        Task<List<TagItem>> TagAutocomplete(string keyword);
        Task<SmartTableResult<TagItem>> Search(SmartTableParam param);
        Task<Tag> CreateAsync(string name, int createdBy, string createdByUserName);
        Task<List<Tag>> CreateAsync(List<string> tagNames, int createdBy, string createdByUserName);

        Task<BaseResult> RemoveProductTagByProductIdAsync(int productId);
        Task<BaseResult> RemovePostTagByPostIdAsync(int postId);
        Task<BaseResult> RemoveJobPostTagByJobPostIdAsync(int jobPostId);
    }

    public class TagService : ITagService
    {
        private readonly IRepository<Tag> _tagRepository;
        private readonly IRepository<ProductTag> _productTagRepository;
        private readonly IRepository<PostTag> _postTagRepository;
        private readonly IRepository<JobPostTag> _jobPostTagRepository;
        private readonly IUrlRecordService _urlRecordService;

        public TagService(IRepository<Tag> tagRepository, IUrlRecordService urlRecordService, IRepository<ProductTag> productTagRepository, IRepository<PostTag> postTagRepository, IRepository<JobPostTag> jobPostTagRepository)
        {
            _tagRepository = tagRepository;
            _urlRecordService = urlRecordService;
            _productTagRepository = productTagRepository;
            _postTagRepository = postTagRepository;
            _jobPostTagRepository = jobPostTagRepository;
        }

=== Ladaer.BackEnd\Infrastructures\Services\Cms\TopicService.cs ===
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Cms;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Cms;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Cms;
using Microsoft.EntityFrameworkCore;
using Lada.Framework.Data.Domains;
using Ladaer.BackEnd.Infrastructures.AppSettings;
using Microsoft.Extensions.Options;

namespace Ladaer.BackEnd.Infrastructures.Services.Cms
{
    public interface ITopicService
    {
        /// <summary>
        /// T�m ki?m topic
        /// </summary>
        /// <param name="param">Th�ng s? t�m ki?m.</param>
        /// <returns>K?t qu? t�m ki?m d?ch v?.</returns>
        Task<SmartTableResult<TopicItem>> Search(SmartTableParam param);

        Task<TopicResult> CreateOrUpdate(TopicModel model);

        Task<TopicModel> GetById(int topicId);

        /// <summary>
        /// X�a b�i vi?t
        /// </summary>
        /// <param name="topicId">Id c?a b�i vi?t.</param>
        /// <returns>K?t qu? c?a thao t�c.</returns>
        Task<BaseResult> DeleteAsync(int topicId);
    }
    public class TopicService : ITopicService
    {
        private readonly IRepository<Topic> _topicRepository;
        private readonly IUrlRecordService _urlRecordService;

=== Ladaer.BackEnd\Infrastructures\Services\Cms\UrlRecordService.cs ===
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.DTO;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Cms;
using Lada.Framework.Data.Mappings.DbContexts;
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Repositories;
using Ladaer.BackEnd.Infrastructures.DTO;
using Microsoft.EntityFrameworkCore;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Cms;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Cms;
using Lada.Framework.Data.Enums;

namespace Ladaer.BackEnd.Infrastructures.Services.Cms
{
    /// <summary>
    /// Giao di?n cho d?ch v? qu?n ly UrlRecord.
    /// </summary>
    public interface IUrlRecordService
    {
        /// <summary>
        /// L?y th�ng tin b�i vi?t qua Id.
        /// </summary>
        /// <param name="postId">Id c?a b�i vi?t.</param>
        /// <returns>Th�ng tin UrlRecord c?a b�i vi?t.</returns>
        Task<UrlRecordModel> GetByPostId(int postId);

        /// <summary>
        /// T?o ho?c c?p nh?t UrlRecord.
        /// </summary>
        /// <param name="model">Th�ng tin UrlRecord.</param>
        /// <returns>K?t qu? c?a thao t�c.</returns>
        Task<BaseResult> Update(UrlRecordModel model);

        /// <summary>
        /// T?o slug cho UrlRecord.
        /// </summary>
        /// <param name="slug">Slug c?n t?o.</param>
        /// <returns>Slug da du?c t?o.</returns>

=== Ladaer.BackEnd\Infrastructures\Services\Crm\CallLogService.cs ===
using Lada.Framework.Data.Domains.Crm;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Crm;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Crm;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Crm;
using Ladaer.BackEnd.Infrastructures.DTO.Profiles;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Crm
{
    /// <summary>
    /// Interface cho CallLog Service
    /// </summary>
    public interface ICallLogService
    {
        /// <summary>
        /// TA�m ki���m call log
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m</param>
        /// <returns>K���t qu��� tA�m ki���m</returns>
        Task<SmartTableResult<CallLogItem>> Search(SmartTableParam param);

        /// <summary>
        /// L���y call log theo ID
        /// </summary>
        /// <param name="id">ID c��a call log</param>
        /// <returns>ThA'ng tin call log</returns>
        Task<CallLogModel> GetById(int id);

        /// <summary>
        /// T���o/c��-p nh��-t call log
        /// </summary>
        /// <param name="model">ThA'ng tin call log</param>
        /// <returns>K���t qu��� c��a thao tA�c</returns>
        Task<CallLogResult> CreateOrUpdate(CallLogModel model);

=== Ladaer.BackEnd\Infrastructures\Services\Crm\CustomerAddressService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Categories;
using Lada.Framework.Data.Domains.Crm;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Crm;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Crm;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Crm;
using Ladaer.BackEnd.Infrastructures.Services.Categories;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Crm
{
    /// <summary>
    /// Giao di?n cho d?ch v? qu?n ly d?a ch? kh�ch h�ng.
    /// </summary>
    public interface ICustomerAddressService
    {
        /// <summary>
        /// T�m ki?m d?a ch? kh�ch h�ng.
        /// </summary>
        /// <param name="param">Th�ng s? t�m ki?m.</param>
        /// <returns>K?t qu? t�m ki?m d?a ch? kh�ch h�ng.</returns>
        Task<SmartTableResult<CustomerAddressItem>> Search(SmartTableParam param);

        /// <summary>
        /// G?i y d?a ch? kh�ch h�ng.
        /// </summary>
        /// <param name="keyword">T? kh�a t�m ki?m.</param>
        /// <param name="customerId">Id c?a kh�ch h�ng.</param>
        /// <param name="addressType">Lo?i d?a ch?.</param>
        /// <returns>Danh s�ch d?a ch? kh�ch h�ng g?i y.</returns>
        Task<List<CustomerAddressItem>> Suggest(string keyword, int customerId, AddressType addressType);

        /// <summary>

=== Ladaer.BackEnd\Infrastructures\Services\Crm\CustomerBankAccountService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Crm;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Profiles;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Crm;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Crm;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Crm;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Crm
{
    /// <summary>
    /// Giao di���n cho d��<ch v��� qu���n lA� tA�i kho���n ngA�n hA�ng khA�ch hA�ng.
    /// </summary>
    public interface ICustomerBankAccountService
    {
        /// <summary>
        /// L���y danh sA�ch tA�i kho���n ngA�n hA�ng c��a khA�ch hA�ng.
        /// </summary>
        /// <param name="customerId">ID khA�ch hA�ng.</param>
        /// <returns>Danh sA�ch tA�i kho���n ngA�n hA�ng.</returns>
        Task<List<CustomerBankAccountItem>> GetByCustomerId(int customerId);

        /// <summary>
        /// L���y tA�i kho���n ngA�n hA�ng m���c �`��<nh c��a khA�ch hA�ng.
        /// </summary>
        /// <param name="customerId">ID khA�ch hA�ng.</param>
        /// <returns>TA�i kho���n ngA�n hA�ng m���c �`��<nh.</returns>
        Task<CustomerBankAccountItem?> GetDefaultByCustomerId(int customerId);

        /// <summary>
        /// L���y thA'ng tin tA�i kho���n ngA�n hA�ng theo ID.
        /// </summary>
        /// <param name="id">ID tA�i kho���n.</param>
        /// <returns>ThA'ng tin tA�i kho���n ngA�n hA�ng.</returns>

=== Ladaer.BackEnd\Infrastructures\Services\Crm\CustomerService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Categories;
using Lada.Framework.Data.Domains.Crm;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Crm;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Crm;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Crm;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Crm
{
    /// <summary>
    /// Giao di?n cho d?ch v? qu?n ly kh�ch h�ng.
    /// </summary>
    public interface ICustomerService
    {
        /// <summary>
        /// T�m ki?m kh�ch h�ng.
        /// </summary>
        /// <param name="param">Th�ng s? t�m ki?m.</param>
        /// <returns>K?t qu? t�m ki?m kh�ch h�ng.</returns>
        Task<SmartTableResult<CustomerItem>> Search(SmartTableParam param);


        Task<SmartTableResult<CustomerItem>> Search(SmartTableParam param, int userId);

        /// <summary>
        /// G?i y danh s�ch kh�ch h�ng.
        /// </summary>
        /// <param name="keyword">T? kh�a t�m ki?m.</param>
        /// <returns>Danh s�ch kh�ch h�ng g?i y.</returns>

=== Ladaer.BackEnd\Infrastructures\Services\Crm\LeadService.cs ===
using Lada.Framework.Data.Domains.Categories;
using Lada.Framework.Data.Domains.Crm;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Crm;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Crm;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Hr;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Crm;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Crm
{
    public interface ILeadService
    {
        /// <summary>
        /// T�m ki?m lead
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        Task<SmartTableResult<LeadItem>> Search(SmartTableParam param);

        /// <summary>
        /// T?o/c?p nh?t d?i ly
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        Task<LeadResult> CreateOrUpdate(LeadModel model);

        /// <summary>
        /// T?o lead.
        /// </summary>
        /// <param name="model">Th�ng tin lead.</param>
        /// <returns>K?t qu? c?a thao t�c.</returns>

=== Ladaer.BackEnd\Infrastructures\Services\Crm\VatInfoService.cs ===
using Lada.Framework.Data.Domains.Crm;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Crm;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Crm;
using Ladaer.BackEnd.Infrastructures.DTO.Profiles;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Crm;
using Microsoft.EntityFrameworkCore;
using static Ladaer.BackEnd.Infrastructures.DTO.Profiles.CrmMappingExtensions;

namespace Ladaer.BackEnd.Infrastructures.Services.Crm
{
    /// <summary>
    /// Interface service qu���n lA� thA'ng tin xu���t hA3a �`��n VAT c��a khA�ch hA�ng
    /// </summary>
    public interface IVatInfoService
    {
        /// <summary>
        /// L���y danh sA�ch thA'ng tin xu���t hA3a �`��n VAT theo �`i��?u ki���n tA�m ki���m
        /// </summary>
        /// <param name="searchModel">Model tA�m ki���m</param>
        /// <returns>Danh sA�ch thA'ng tin xu���t hA3a �`��n VAT</returns>
        Task<SmartTableResult<VatInfoItem>> Search(SmartTableParam param);

        /// <summary>
        /// L���y thA'ng tin chi ti���t xu���t hA3a �`��n VAT theo ID
        /// </summary>
        /// <param name="id">ID thA'ng tin xu���t hA3a �`��n VAT</param>
        /// <returns>ThA'ng tin chi ti���t xu���t hA3a �`��n VAT</returns>
        Task<VatInfoModel> GetByIdAsync(int id);

        /// <summary>
        /// L���y thA'ng tin xu���t hA3a �`��n VAT m���c �`��<nh c��a khA�ch hA�ng
        /// </summary>
        /// <param name="customerId">ID khA�ch hA�ng</param>
        /// <returns>ThA'ng tin xu���t hA3a �`��n VAT m���c �`��<nh</returns>
        Task<VatInfoModel> GetDefaultByCustomerIdAsync(int customerId);

=== Ladaer.BackEnd\Infrastructures\Services\DriverApp\AppEnums.cs ===

=== Ladaer.BackEnd\Infrastructures\Services\DriverApp\DriverAppOrderService.cs ===
using System.Data;
using Dapper;
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Domains.Medias;
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Business.Operations;
using Ladaer.BackEnd.Infrastructures.DTO.Items.DriverApp;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Identity;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Models.DriverApp;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders.Updates;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Orders;
using Ladaer.BackEnd.Infrastructures.Services.Categories;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Ladaer.BackEnd.Infrastructures.Services.Orders;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json.Linq;
using Xabe.FFmpeg;

namespace Ladaer.BackEnd.Infrastructures.Services.DriverApp
{
    /// <summary>
    /// Interface for Driver App order service.
    /// </summary>
    public interface IDriverAppOrderService
    {
        /// <summary>
        /// Searches for orders based on the provided parameters.
        /// </summary>
        /// <param name="param">Search parameters.</param>

=== Ladaer.BackEnd\Infrastructures\Services\DriverApp\DriverAppService.cs ===
using System.Data;
using Dapper;
using Lada.Framework.Data.Domains.Hr;
using Lada.Framework.Data.Domains.Trucks;
using Lada.Framework.Data.Repositories;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.DriverApp;
using Ladaer.BackEnd.Infrastructures.Services.Hr;
using Ladaer.BackEnd.Infrastructures.Services.Trucks;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.DriverApp
{
    public interface IDriverAppService
    {
        Task<DashboardModel> GetDashboard(int userId);
    }

    public class DriverAppService : IDriverAppService
    {
        private readonly IDbConnection _dbConnection;
        private readonly IAttendanceService _attendanceService;
        private readonly ITruckActivityService _truckActivityService;
        private readonly IRepository<Attendance> _attendanceRepository;
        private readonly IRepository<TruckActivity> _truckActivityRepository;

        public DriverAppService(
            IDbConnection dbConnection,
            IAttendanceService attendanceService,
            ITruckActivityService truckActivityService,
            IRepository<Attendance> attendanceRepository,
            IRepository<TruckActivity> truckActivityRepository)
        {
            _dbConnection = dbConnection;
            _attendanceService = attendanceService;
            _truckActivityService = truckActivityService;
            _attendanceRepository = attendanceRepository;
            _truckActivityRepository = truckActivityRepository;
        }


=== Ladaer.BackEnd\Infrastructures\Services\DriverApp\DriverFinService.cs ===
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.DriverApp;
using Ladaer.BackEnd.Infrastructures.DTO.Models.DriverApp;
using Ladaer.BackEnd.Infrastructures.Services.Categories;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.DriverApp
{
    /// <summary>
    /// Interface cho d��<ch v��� qu���n lA� tA�i chA-nh c��a lA�i xe
    /// </summary>
    public interface IDriverFinService
    {
        /// <summary>
        /// L���y thA'ng tin tA�i chA-nh c��a lA�i xe
        /// </summary>
        /// <param name="userId">ID c��a lA�i xe</param>
        /// <returns>ThA'ng tin tA�i chA-nh c��a lA�i xe</returns>
        Task<DriverFinModel> GetDriverFinancialInfo(int userId);

        /// <summary>
        /// TA�m ki���m danh sA�ch �`��n hA�ng tA�i chA-nh c��a lA�i xe cA3 phA�n trang
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m vA� phA�n trang</param>
        /// <param name="userId">ID c��a lA�i xe</param>
        /// <returns>K���t qu��� tA�m ki���m cA3 phA�n trang</returns>
        Task<SmartTableResult<DriverFinOrderItem>> Search(SmartTableParam param, int userId);
    }

    /// <summary>
    /// D��<ch v��� qu���n lA� tA�i chA-nh c��a lA�i xe
    /// </summary>
    public class DriverFinService : IDriverFinService
    {
        private readonly IRepository<OrderFin> _orderFinRepository;

=== Ladaer.BackEnd\Infrastructures\Services\DriverApp\README.md ===
# DriverApp Services

## T��ng quan

Th�� m���c `DriverApp` ch��ca cA�c service liA�n quan �`���n ��cng d���ng lA�i xe (Driver App), �`�����c tA�ch bi���t kh��?i cA�c service nghi���p v��� kinh doanh (Business Operations) �`��� �`���m b���o tA-nh rA� rA�ng vA� d��. b���o trA�.

## C���u trA�c

### 1. DriverAppService

- **M���c �`A-ch**: X��- lA� logic dashboard vA� thA'ng tin t��ng quan cho lA�i xe
- **Ch��cc n��ng chA-nh**:
  - L���y thA'ng tin dashboard
  - ThA'ng tin ch���m cA'ng
  - ThA'ng tin xe �`ang ph��� trA�ch

### 2. DriverAppOrderService

- **M���c �`A-ch**: X��- lA� t���t c��� cA�c thao tA�c liA�n quan �`���n �`��n hA�ng cho lA�i xe
- **Ch��cc n��ng chA-nh**:
  - TA�m ki���m danh sA�ch �`��n hA�ng
  - L���y thA'ng tin chi ti���t �`��n hA�ng
  - C��-p nh��-t tr���ng thA�i l���y hA�ng (Pickup)
  - C��-p nh��-t tr���ng thA�i giao hA�ng (Delivery)
  - X��- lA� cA�c tr����?ng h���p th���t b���i (PickupFail, DeliveryFail)

### 3. DriverFinService

- **M���c �`A-ch**: X��- lA� cA�c v���n �`��? tA�i chA-nh liA�n quan �`���n lA�i xe
- **Ch��cc n��ng chA-nh**:
  - ThA'ng tin tA�i chA-nh c��a lA�i xe
  - TA�m ki���m �`��n hA�ng tA�i chA-nh

## LA� do tA�ch bi���t

### Tr����>c �`A�y

- `OperationService` trong th�� m���c `Business` x��- lA� c��� logic nghi���p v��� kinh doanh vA� logic lA�i xe
- GA�y khA3 kh��n trong vi���c b���o trA� vA� m��Y r��Tng
- KhA'ng rA� rA�ng v��? trA�ch nhi���m c��a t���ng service

=== Ladaer.BackEnd\Infrastructures\Services\ErrorReports\ErrorReportService.cs ===
using Lada.Framework.Data.Domains.ErrorReports;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO.Items.ErrorReports;
using Ladaer.BackEnd.Infrastructures.DTO.Models.ErrorReports;
using Ladaer.BackEnd.Infrastructures.DTO.Results.ErrorReports;
using Ladaer.BackEnd.Infrastructures.Extensions;
using Microsoft.EntityFrameworkCore;
using System.ComponentModel;

namespace Ladaer.BackEnd.Infrastructures.Services.ErrorReports
{
    public interface IErrorReportService
    {
        /// <summary>
        /// TA�m ki���m bA�o l��-i
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m</param>
        /// <returns>Danh sA�ch bA�o l��-i</returns>
        Task<SmartTableResult<ErrorReportItem>> Search(SmartTableParam param);

        /// <summary>
        /// T���o m��>i bA�o l��-i
        /// </summary>
        /// <param name="model">ThA'ng tin bA�o l��-i</param>
        /// <returns>K���t qu��� t���o bA�o l��-i</returns>
        Task<ErrorReportResult> Create(ErrorReportModel model);

        /// <summary>
        /// L���y chi ti���t bA�o l��-i
        /// </summary>
        /// <param name="id">ID bA�o l��-i</param>
        /// <returns>Chi ti���t bA�o l��-i</returns>
        Task<ErrorReportDetailResult> GetById(int id);

        /// <summary>

=== Ladaer.BackEnd\Infrastructures\Services\Finance\BankSeedService.cs ===
using Lada.Framework.Data.Domains.Finance;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Microsoft.Extensions.Logging;

namespace Ladaer.BackEnd.Infrastructures.Services.Finance
{
    /// <summary>
    /// Service �`��� seed d��_ li���u ngA�n hA�ng
    /// </summary>
    public class BankSeedService
    {
        private readonly IRepository<Bank> _bankRepository;
        private readonly ILogger<BankSeedService> _logger;

        public BankSeedService(
            IRepository<Bank> bankRepository,
            ILogger<BankSeedService> logger)
        {
            _bankRepository = bankRepository;
            _logger = logger;
        }

        /// <summary>
        /// Seed d��_ li���u ngA�n hA�ng t��� danh sA�ch cung c���p
        /// </summary>
        public async Task<bool> SeedBankDataAsync()
        {
            try
            {
                // Ki���m tra xem �`A� cA3 d��_ li���u ch��a
                var existingBanks = _bankRepository.Query();
                if (existingBanks.Any())
                {
                    _logger.LogInformation("Bank data already exists. Skipping seed.");
                    return true;
                }

                var banks = GetBankData();


=== Ladaer.BackEnd\Infrastructures\Services\Finance\BankService.cs ===
using Lada.Framework.Data.Domains.Finance;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Profiles;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Finance
{
    public interface IBankService
    {
        Task<SmartTableResult<BankItem>> Search(SmartTableParam param);
        Task<List<BankItem>> GetAll();
        Task<BankModel?> GetById(int id);
        Task<BankResult> CreateOrUpdate(BankModel model);
        Task<BankResult> Create(BankModel model);
        Task<BankResult> Update(BankModel model);
        Task<BankResult> Delete(int id);
        Task<List<BankOptionItem>> SugBank(string keyword = "", int limit = 20);
    }

    /// <summary>
    /// Service qu���n lA� ngA�n hA�ng
    /// </summary>
    public class BankService : IBankService
    {
        private readonly IRepository<Bank> _bankRepository;

        public BankService(IRepository<Bank> bankRepository)
        {
            _bankRepository = bankRepository;
        }

        /// <summary>
        /// TA�m ki���m ngA�n hA�ng v��>i phA�n trang
        /// </summary>

=== Ladaer.BackEnd\Infrastructures\Services\Finance\CustomerReconciliationSlipExcelService.cs ===
using System.Drawing;
using Lada.Framework.Data.Domains.Crm;
using Lada.Framework.Data.Domains.Finance;
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finance;
using Microsoft.EntityFrameworkCore;
using OfficeOpenXml;
using OfficeOpenXml.Style;

namespace Ladaer.BackEnd.Infrastructures.Services.Finance
{
    /// <summary>
    /// Interface cho d��<ch v��� xu���t Excel phi���u �`��`i soA�t khA�ch hA�ng
    /// </summary>
    public interface ICustomerReconciliationSlipExcelService
    {
        /// <summary>
        /// Xu���t Excel danh sA�ch phi���u �`��`i soA�t khA�ch hA�ng
        /// </summary>
        /// <param name="model">Model xu���t Excel</param>
        /// <returns>K���t qu��� xu���t file</returns>
        Task<CustomerReconciliationSlipExcelExportResult> ExportCustomerReconciliationSlipsAsync(CustomerReconciliationSlipExcelExportModel model);

        /// <summary>
        /// Xu���t Excel chi ti���t phi���u �`��`i soA�t khA�ch hA�ng
        /// </summary>
        /// <param name="slipId">ID phi���u �`��`i soA�t</param>
        /// <param name="model">Model xu���t Excel</param>
        /// <returns>K���t qu��� xu���t file</returns>
        Task<CustomerReconciliationSlipExcelExportResult> ExportCustomerReconciliationSlipDetailAsync(int slipId, CustomerReconciliationSlipExcelExportModel model);

        /// <summary>
        /// Xu���t Excel danh sA�ch �`��n hA�ng c��n �`��`i soA�t c��a khA�ch hA�ng
        /// </summary>
        /// <param name="customerId">ID khA�ch hA�ng</param>

=== Ladaer.BackEnd\Infrastructures\Services\Finance\CustomerReconciliationSlipService.cs ===
using System.Data;
using System.Linq.Dynamic.Core;
using Dapper;
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Crm;
using Lada.Framework.Data.Domains.Finance;
using Lada.Framework.Data.Domains.Finance.Wallets;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Domains.Medias;
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Extensions;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Crm;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.StoredProcedureResults;
using Ladaer.BackEnd.Infrastructures.Services.Finances;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Ladaer.BackEnd.Infrastructures.Services.Orders;
using Microsoft.EntityFrameworkCore;
using static Lada.Framework.Data.Enums.OrderFinEnum;

namespace Ladaer.BackEnd.Infrastructures.Services.Finance
{
    public class CustomerReconciliationSlipService : ICustomerReconciliationSlipService
    {
        private readonly IRepository<CustomerReconciliationSlip> _slipRepository;
        private readonly IRepository<CustomerReconciliationSlipDetail> _slipDetailRepository;
        private readonly IRepository<CustomerReconciliationLog> _logRepository;
        private readonly IRepository<Order> _orderRepository;
        private readonly IRepository<OrderFin> _orderFinRepository;
        private readonly IRepository<Customer> _customerRepository;

=== Ladaer.BackEnd\Infrastructures\Services\Finance\ExpenseCategoryService.cs ===
using Lada.Framework.Data.Domains.Finance;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Profiles;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finance;
using Microsoft.EntityFrameworkCore;
using static Ladaer.BackEnd.Infrastructures.DTO.Profiles.FinanceMappingExtensions;

namespace Ladaer.BackEnd.Infrastructures.Services.Finance
{
    /// <summary>
    /// Interface cho service qu���n lA� danh m���c chi phA-
    /// </summary>
    public interface IExpenseCategoryService
    {
        /// <summary>
        /// TA�m ki���m danh m���c chi phA- v��>i phA�n trang
        /// </summary>
        Task<SmartTableResult<ExpenseCategoryItem>> Search(SmartTableParam param);

        /// <summary>
        /// L���y danh m���c chi phA- theo ID
        /// </summary>
        Task<ExpenseCategoryItem?> GetByIdAsync(int id);

        /// <summary>
        /// T���o ho���c c��-p nh��-t danh m���c chi phA-
        /// </summary>
        Task<BaseResult> CreateOrUpdateAsync(ExpenseCategoryModel model, CurrentUser currentUser);

        /// <summary>
        /// XA3a danh m���c chi phA-
        /// </summary>
        Task<BaseResult> DeleteAsync(int id, CurrentUser currentUser);

=== Ladaer.BackEnd\Infrastructures\Services\Finance\ExportOrderService.cs ===
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Microsoft.EntityFrameworkCore;
using OfficeOpenXml;
using OfficeOpenXml.Style;
using System.Drawing;

namespace Ladaer.BackEnd.Infrastructures.Services.Finance
{
    /// <summary>
    /// Interface cho d��<ch v��� xu���t Excel thA'ng tin �`��n hA�ng
    /// </summary>
    public interface IExportOrderService
    {
        /// <summary>
        /// Xu���t Excel thA'ng tin �`��n hA�ng theo danh sA�ch OrderId ho���c OrderCode
        /// </summary>
        /// <param name="model">ThA'ng tin �`��u vA�o</param>
        /// <returns>K���t qu��� xu���t file</returns>
        Task<ExportOrderResult> ExportOrdersToExcelAsync(ExportOrderModel model);

        /// <summary>
        /// Xu���t Excel thA'ng tin �`��n hA�ng theo danh sA�ch OrderId
        /// </summary>
        /// <param name="orderIds">Danh sA�ch ID �`��n hA�ng</param>
        /// <param name="filePath">�?����?ng d���n file Excel</param>
        /// <returns>K���t qu��� xu���t file</returns>
        Task<ExportOrderResult> ExportOrdersByIdsAsync(List<int> orderIds, string filePath);

        /// <summary>
        /// Xu���t Excel thA'ng tin �`��n hA�ng theo danh sA�ch OrderCode
        /// </summary>
        /// <param name="orderCodes">Danh sA�ch mA� �`��n hA�ng</param>
        /// <param name="filePath">�?����?ng d���n file Excel</param>

=== Ladaer.BackEnd\Infrastructures\Services\Finance\ICustomerReconciliationSlipService.cs ===
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finance;

using Lada.Framework.Infrastructures;

namespace Ladaer.BackEnd.Infrastructures.Services.Finance
{
    public interface ICustomerReconciliationSlipService
    {
        /// <summary>
        /// L���y danh sA�ch khA�ch hA�ng c��n �`��`i soA�t (cA3 �`��n hA�ng ch��a �`��`i soA�t)
        /// Sale ch��% th���y khA�ch hA�ng c��a mA�nh
        /// </summary>
        Task<SmartTableResult<CustomerTransferPaymentSummaryItem>> GetCustomersOverviewAsync(SmartTableParam param, int userId);

        /// <summary>
        /// L���y danh sA�ch �`��n hA�ng cA3 th��� �`��`i soA�t c��a m��Tt khA�ch hA�ng
        /// </summary>
        Task<List<CustomerReconciliationSlipDetailItem>> GetReconciliableOrdersAsync(int customerId, int userId);

        /// <summary>
        /// T���o phi���u �`��`i soA�t m��>i
        /// </summary>
        Task<int> CreateSlipAsync(CreateCustomerReconciliationSlipModel model, CurrentUser currentUser);

        /// <summary>
        /// TA�m ki���m phi���u �`��`i soA�t
        /// </summary>
        Task<SmartTableResult<CustomerReconciliationSlipItem>> GetSlipsAsync(SmartTableParam param, int userId);

        /// <summary>
        /// L���y chi ti���t phi���u �`��`i soA�t
        /// </summary>
        Task<CustomerReconciliationSlipResult> GetSlipByIdAsync(int id, int userId);

        /// <summary>

=== Ladaer.BackEnd\Infrastructures\Services\Finance\IncomeCategoryService.cs ===
using Lada.Framework.Data.Domains.Finance;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Profiles;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finance;
using Microsoft.EntityFrameworkCore;
using static Ladaer.BackEnd.Infrastructures.DTO.Profiles.FinanceMappingExtensions;

namespace Ladaer.BackEnd.Infrastructures.Services.Finance
{
    /// <summary>
    /// Interface cho service qu���n lA� danh m���c doanh thu
    /// </summary>
    public interface IIncomeCategoryService
    {
        /// <summary>
        /// TA�m ki���m danh m���c doanh thu v��>i phA�n trang
        /// </summary>
        Task<SmartTableResult<IncomeCategoryItem>> Search(SmartTableParam param);

        /// <summary>
        /// L���y danh m���c doanh thu theo ID
        /// </summary>
        Task<IncomeCategoryItem?> GetByIdAsync(int id);

        /// <summary>
        /// T���o ho���c c��-p nh��-t danh m���c doanh thu
        /// </summary>
        Task<BaseResult> CreateOrUpdateAsync(IncomeCategoryModel model, CurrentUser currentUser);

        /// <summary>
        /// XA3a danh m���c doanh thu
        /// </summary>
        Task<BaseResult> DeleteAsync(int id, CurrentUser currentUser);

=== Ladaer.BackEnd\Infrastructures\Services\Finance\IUserBankAccountService.cs ===
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;

namespace Ladaer.BackEnd.Infrastructures.Services.Finance
{
    /// <summary>
    /// Interface service qu���n lA� tA�i kho���n ngA�n hA�ng ng����?i dA1ng
    /// </summary>
    public interface IUserBankAccountService
    {
        /// <summary>
        /// TA�m ki���m tA�i kho���n ngA�n hA�ng ng����?i dA1ng
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m</param>
        /// <returns>K���t qu��� tA�m ki���m</returns>
        Task<SmartTableResult<UserBankAccountItem>> Search(SmartTableParam param);

        /// <summary>
        /// L���y thA'ng tin chi ti���t tA�i kho���n ngA�n hA�ng theo ID
        /// </summary>
        /// <param name="id">ID tA�i kho���n ngA�n hA�ng</param>
        /// <returns>ThA'ng tin chi ti���t tA�i kho���n ngA�n hA�ng</returns>
        Task<UserBankAccountModel> GetById(int id);

        /// <summary>
        /// T���o m��>i ho���c c��-p nh��-t tA�i kho���n ngA�n hA�ng
        /// </summary>
        /// <param name="model">ThA'ng tin tA�i kho���n ngA�n hA�ng</param>
        /// <returns>K���t qu��� c��a thao tA�c</returns>
        Task<BaseResult> CreateOrUpdate(UserBankAccountModel model);

        /// <summary>
        /// XA3a tA�i kho���n ngA�n hA�ng
        /// </summary>
        /// <param name="model">ThA'ng tin tA�i kho���n ngA�n hA�ng c��n xA3a</param>
        /// <returns>K���t qu��� c��a thao tA�c</returns>
        Task<BaseResult> Delete(UserBankAccountModel model);


=== Ladaer.BackEnd\Infrastructures\Services\Finance\ReconciliationExcelService.cs ===
using Lada.Framework.DTO;
using Lada.Framework.Data.Repositories;
using Lada.Framework.Data.Domains.Finance;
using Lada.Framework.Data.Domains.Crm;
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Finance;
using Microsoft.EntityFrameworkCore;
using OfficeOpenXml;
using OfficeOpenXml.Style;
using System.Drawing;

namespace Ladaer.BackEnd.Infrastructures.Services.Finance
{
    /// <summary>
    /// Interface cho d��<ch v��� xu���t Excel phi���u �`��`i soA�t
    /// </summary>
    public interface IReconciliationExcelService
    {
        /// <summary>
        /// Xu���t Excel danh sA�ch phi���u �`��`i soA�t
        /// </summary>
        /// <param name="model">Model xu���t Excel</param>
        /// <returns>K���t qu��� xu���t file</returns>
        Task<ReconciliationExcelExportResult> ExportReconciliationsAsync(ReconciliationExcelExportModel model);

        /// <summary>
        /// Xu���t Excel chi ti���t phi���u �`��`i soA�t
        /// </summary>
        /// <param name="reconciliationId">ID phi���u �`��`i soA�t</param>
        /// <param name="model">Model xu���t Excel</param>
        /// <returns>K���t qu��� xu���t file</returns>
        Task<ReconciliationExcelExportResult> ExportReconciliationDetailAsync(int reconciliationId, ReconciliationExcelExportModel model);
    }

    /// <summary>
    /// D��<ch v��� xu���t Excel phi���u �`��`i soA�t
    /// </summary>

=== Ladaer.BackEnd\Infrastructures\Services\Finance\TaxInvoiceService.cs ===
using Lada.Framework.Data.Domains.Crm;
using Lada.Framework.Data.Domains.Finance;
using Lada.Framework.Data.Domains.Medias;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Profiles;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finance;
using Ladaer.BackEnd.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Finance
{
    /// <summary>
    /// Interface d��<ch v��� qu���n lA� hA3a �`��n thu���
    /// </summary>
    public interface ITaxInvoiceService
    {
        Task<TaxInvoiceResult> CreateTaxInvoiceAsync(CreateTaxInvoiceModel model, CurrentUser currentUser);
        Task<TaxInvoiceResult> UpdateTaxInvoiceStatusAsync(UpdateTaxInvoiceStatusModel model, CurrentUser currentUser);
        Task<TaxInvoiceItem?> GetTaxInvoiceByIdAsync(int id, CurrentUser currentUser);
        Task<TaxInvoiceItem?> GetTaxInvoiceBySlipIdAsync(int slipId, CurrentUser currentUser);
        Task<BaseResult> DeleteTaxInvoiceAsync(int id, CurrentUser currentUser);
    }

    /// <summary>
    /// D��<ch v��� qu���n lA� hA3a �`��n thu���
    /// </summary>
    public class TaxInvoiceService : ITaxInvoiceService
    {
        private readonly IRepository<TaxInvoice> _taxInvoiceRepository;
        private readonly IRepository<CustomerReconciliationSlip> _slipRepository;
        private readonly IRepository<VatInfo> _vatInfoRepository;

=== Ladaer.BackEnd\Infrastructures\Services\Finance\TransferPaymentBillExcelService.cs ===
using Lada.Framework.DTO;
using Lada.Framework.Data.Repositories;
using Lada.Framework.Data.Domains.Finance;
using Lada.Framework.Data.Domains.Crm;
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.Infrastructures.Services;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Finance;
using Microsoft.EntityFrameworkCore;
using OfficeOpenXml;
using OfficeOpenXml.Style;
using System.Drawing;
using System.IO;

namespace Ladaer.BackEnd.Infrastructures.Services.Finance
{
    /// <summary>
    /// Interface cho d?ch v? xu?t Excel phi?u chuy?n kho?n
    /// </summary>
    public interface ITransferPaymentBillExcelService
    {
        /// <summary>
        /// Xu?t Excel danh s�ch phi?u chuy?n kho?n
        /// </summary>
        /// <param name="model">Model xu?t Excel</param>
        /// <returns>K?t qu? xu?t file</returns>
        Task<TransferPaymentBillExcelExportResult> ExportTransferPaymentBillsAsync(TransferPaymentBillExcelExportModel model);

        /// <summary>
        /// Xu?t Excel chi ti?t phi?u chuy?n kho?n
        /// </summary>
        /// <param name="transferPaymentBillId">ID phi?u chuy?n kho?n</param>
        /// <param name="model">Model xu?t Excel</param>
        /// <returns>K?t qu? xu?t file</returns>
        Task<TransferPaymentBillExcelExportResult> ExportTransferPaymentBillDetailAsync(int transferPaymentBillId, TransferPaymentBillExcelExportModel model);


=== Ladaer.BackEnd\Infrastructures\Services\Finance\TransferPaymentBillService.cs ===
using Dapper;
using Lada.Framework.Data.Domains.Crm;
using Lada.Framework.Data.Domains.Finance;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Domains.Medias;
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Profiles;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.StoredProcedureResults;
using Ladaer.BackEnd.Infrastructures.Services.Crm;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Ladaer.BackEnd.Infrastructures.Services.Orders;
using Ladaer.BackEnd.Infrastructures.Services.Finances;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using System.Data;
using static Lada.Framework.Data.Enums.OrderFinEnum;
using Lada.Framework.Data.Domains.Finance.Wallets;
using Lada.Framework.Data.Domains;

namespace Ladaer.BackEnd.Infrastructures.Services.Finance
{
    public interface ITransferPaymentBillService
    {
        Task<SmartTableResult<CustomerTransferPaymentSummaryItem>> SearchCustomersForTransferPayment(SmartTableParam param, CurrentUser currentUser);
        Task<CustomerTransferableOrdersModel> GetTransferableOrdersByCustomer(int customerId, CurrentUser currentUser);
        Task<SmartTableResult<TransferPaymentBillItem>> Search(SmartTableParam param, CurrentUser currentUser);
        Task<TransferPaymentBillDetailModel?> GetById(int id, CurrentUser currentUser);
        Task<TransferPaymentBillResult> Create(CreateTransferPaymentBillModel model, CurrentUser currentUser);
        Task<TransferPaymentBillResult> Cancel(CancelTransferPaymentBillModel model);

=== Ladaer.BackEnd\Infrastructures\Services\Finance\UserBankAccountService.cs ===
using Lada.Framework.Data.Domains.Finance;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Microsoft.EntityFrameworkCore;
using static Ladaer.BackEnd.Infrastructures.DTO.Profiles.FinanceMappingExtensions;

namespace Ladaer.BackEnd.Infrastructures.Services.Finance
{
    /// <summary>
    /// Service qu���n lA� tA�i kho���n ngA�n hA�ng ng����?i dA1ng
    /// </summary>
    public class UserBankAccountService : IUserBankAccountService
    {
        private readonly IRepository<UserBankAccount> _userBankAccountRepository;
        private readonly IRepository<Bank> _bankRepository;
        private readonly IUserRepository<User> _userRepository;
        private readonly IPermissionService _permissionService;

        public UserBankAccountService(
            IRepository<UserBankAccount> userBankAccountRepository,
            IRepository<Bank> bankRepository,
            IUserRepository<User> userRepository,
            IPermissionService permissionService)
        {
            _userBankAccountRepository = userBankAccountRepository;
            _bankRepository = bankRepository;
            _userRepository = userRepository;
            _permissionService = permissionService;
        }

        /// <summary>
        /// TA�m ki���m tA�i kho���n ngA�n hA�ng ng����?i dA1ng

=== Ladaer.BackEnd\Infrastructures\Services\Finances\BackFeeService.cs ===
using Lada.Framework.Data.Domains.Categories;
using Lada.Framework.Data.Domains.Crm;
using Lada.Framework.Data.Domains.Finance.Quotations;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.Models;
using Lada.Framework.DTO.Results;
using Lada.Framework.Infrastructures.Services;
using Microsoft.EntityFrameworkCore;
using Route = Lada.Framework.Data.Domains.Finance.Quotations.Route;

namespace Ladaer.BackEnd.Infrastructures.Services.Finances
{
    /// <summary>
    /// Giao di?n cho d?ch v? t�nh ph� v?n chuy?n.
    /// </summary>
    public interface IBackFeeService
    {
        /// <summary>
        /// L?y gi� theo phu?ng.
        /// </summary>
        /// <param name="model">Th�ng tin phu?ng.</param>
        /// <param name="apiKey">API key c?a Google Maps.</param>
        /// <returns>K?t qu? t�nh ph�.</returns>
        Task<FeeResult> GetFeeByWard(FeeByWardModel model, string apiKey);

        /// <summary>
        /// L?y gi� theo kho?ng c�ch.
        /// </summary>
        /// <param name="model">Th�ng tin kho?ng c�ch.</param>
        /// <returns>K?t qu? t�nh ph�.</returns>
        Task<FeeResult> GetFee(FeeModel model);
    }


    /// <summary>
    /// Tri?n khai d?ch v? t�nh ph� v?n chuy?n.
    /// </summary>
    public class BackFeeService : IBackFeeService

=== Ladaer.BackEnd\Infrastructures\Services\Finances\BankAccountService.cs ===
using System;
using Lada.Framework.Data.Domains.Finance;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finances;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finances;
using Ladaer.BackEnd.Infrastructures.DTO;
using Microsoft.EntityFrameworkCore;
using System.Diagnostics;
using System.IO;

namespace Ladaer.BackEnd.Infrastructures.Services.Finances
{
    /// <summary>
    /// Interface cho service qu���n lA� tA�i kho���n ngA�n hA�ng
    /// </summary>
    public interface IBankAccountService
    {
        /// <summary>
        /// TA�m ki���m tA�i kho���n ngA�n hA�ng
        /// </summary>
        Task<SmartTableResult<BankAccountItem>> Search(SmartTableParam param);

        /// <summary>
        /// L���y chi ti���t tA�i kho���n ngA�n hA�ng
        /// </summary>
        Task<BankAccountDetailModel> GetById(int id);

        /// <summary>
        /// T���o ho���c c��-p nh��-t tA�i kho���n ngA�n hA�ng
        /// </summary>
        Task<BaseResult> CreateOrUpdate(BankAccountModel model);

        /// <summary>
        /// XA3a tA�i kho���n ngA�n hA�ng

=== Ladaer.BackEnd\Infrastructures\Services\Finances\BankStatementParser.cs ===
using Lada.Framework.Data.Domains.Finance;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finances;
using Microsoft.EntityFrameworkCore;
using OfficeOpenXml;
using System.Globalization;

namespace Ladaer.BackEnd.Infrastructures.Services.Finances
{
    /// <summary>
    /// Interface cho service parse sao kA� ngA�n hA�ng
    /// </summary>
    public interface IBankStatementParser
    {
        Task<BankStatementParseResult> ParseBankStatement(BankStatementImportModel model, string bankCode, int userId = 0, string userName = "System");
    }

    /// <summary>
    /// Service parse sao kA� ngA�n hA�ng
    /// </summary>
    public class BankStatementParser : IBankStatementParser
    {
        private readonly IRepository<BankTransaction> _transactionRepository;

        public BankStatementParser(IRepository<BankTransaction> transactionRepository)
        {
            _transactionRepository = transactionRepository;
        }

        public async Task<BankStatementParseResult> ParseBankStatement(BankStatementImportModel model, string bankCode, int userId = 0, string userName = "System")
        {
            var result = new BankStatementParseResult();

            try
            {
                using var stream = model.ExcelFile.OpenReadStream();
                using var package = new ExcelPackage(stream);

                if (package.Workbook.Worksheets.Count == 0)

=== Ladaer.BackEnd\Infrastructures\Services\Finances\CashierService.cs ===
using Dapper;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finances;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finances;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders.Shared;
using Newtonsoft.Json;
using System.Data;
using Lada.Framework.Data.Domains.Finance.Wallets;
using Lada.Framework.Data.Repositories;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Domains;
using Microsoft.EntityFrameworkCore;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Data.Domains.Orders;
using static Lada.Framework.Data.Enums.OrderFinEnum;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Ladaer.BackEnd.Infrastructures.Services.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders;
using Ladaer.BackEnd.Infrastructures.DTO;

namespace Ladaer.BackEnd.Infrastructures.Services.Finances
{
    public interface ICashierService
    {
        Task<SmartTableResult<CashierBalanceItem>> Search(SmartTableParam param, int userId);
        Task<BaseResult> CollectCashier(CollectCashierModel model);
    }

    public class CashierService : ICashierService
    {
        private readonly IRepository<OrderFin> _orderFinRepository;
        private readonly IRepository<Wallet> _walletRepository;
        private readonly IRepository<Transaction> _transactionRepository;
        private readonly IRepository<Order> _orderRepository;
        private readonly IDbConnection _connection;
        private readonly IUserService _userService;
        private readonly IOrderTrackService _orderTrackService;
        private readonly IOrderTimeTrackService _orderTimeTrackService;


=== Ladaer.BackEnd\Infrastructures\Services\Finances\DriverFinService.cs ===

=== Ladaer.BackEnd\Infrastructures\Services\Finances\ExpenseService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Finance;
using Lada.Framework.Data.Domains.Finance.Wallets;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finances;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finances;
using Ladaer.BackEnd.Infrastructures.DTO.Profiles;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finances;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Microsoft.EntityFrameworkCore;
using ExpenseStatus = Lada.Framework.Data.Enums.ExpenseStatus;

namespace Ladaer.BackEnd.Infrastructures.Services.Finances
{
    /// <summary>
    /// Interface cho service qu���n lA� chi phA-
    /// </summary>
    public interface IExpenseService
    {
        /// <summary>
        /// TA�m ki���m chi phA-
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m</param>
        /// <param name="currentUser">Ng����?i dA1ng hi���n t���i</param>
        /// <returns>K���t qu��� tA�m ki���m</returns>
        Task<SmartTableResult<ExpenseItem>> Search(SmartTableParam param, CurrentUser currentUser);

        /// <summary>
        /// L���y thA'ng tin chi ti���t c��a chi phA-
        /// </summary>
        /// <param name="id">ID chi phA-</param>
        /// <param name="currentUser">Ng����?i dA1ng hi���n t���i</param>
        /// <returns>ThA'ng tin chi ti���t chi phA-</returns>

=== Ladaer.BackEnd\Infrastructures\Services\Finances\IncomeService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Finance;
using Lada.Framework.Data.Domains.Finance.Wallets;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finances;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finances;
using Ladaer.BackEnd.Infrastructures.DTO.Profiles;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finances;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Microsoft.EntityFrameworkCore;
using IncomeStatus = Lada.Framework.Data.Enums.IncomeStatus;

namespace Ladaer.BackEnd.Infrastructures.Services.Finances
{
    /// <summary>
    /// Interface cho service qu���n lA� doanh thu
    /// </summary>
    public interface IIncomeService
    {
        /// <summary>
        /// TA�m ki���m doanh thu
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m</param>
        /// <param name="currentUser">Ng����?i dA1ng hi���n t���i</param>
        /// <returns>K���t qu��� tA�m ki���m</returns>
        Task<SmartTableResult<IncomeItem>> Search(SmartTableParam param, CurrentUser currentUser);

        /// <summary>
        /// L���y thA'ng tin chi ti���t c��a doanh thu
        /// </summary>
        /// <param name="id">ID doanh thu</param>
        /// <param name="currentUser">Ng����?i dA1ng hi���n t���i</param>
        /// <returns>ThA'ng tin chi ti���t doanh thu</returns>

=== Ladaer.BackEnd\Infrastructures\Services\Finances\IVatInvoiceService.cs ===
using Lada.Framework.DTO.SmartTable;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finance;

namespace Ladaer.BackEnd.Infrastructures.Services.Finances
{
    /// <summary>
    /// Service qu���n lA� hA3a �`��n VAT n��Ti b��T (CRUD)
    /// </summary>
    public interface IVatInvoiceService
    {
        /// <summary>
        /// TA�m ki���m hA3a �`��n VAT
        /// </summary>
        Task<SmartTableResult<VatInvoiceItem>> Search(SmartTableParam param);
    }
}

=== Ladaer.BackEnd\Infrastructures\Services\Finances\IVatInvoiceSyncService.cs ===
using Lada.Framework.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finance;

namespace Ladaer.BackEnd.Infrastructures.Services.Finances
{
    /// <summary>
    /// Service �`��"ng b��T hA3a �`��n VAT t��� API T��ng c���c Thu���
    /// </summary>
    public interface IVatInvoiceSyncService
    {
        /// <summary>
        /// �?��"ng b��T hA3a �`��n t��� API T��ng c���c Thu��� cho m��Tt kho���ng th��?i gian
        /// </summary>
        /// <param name="fromDate">NgA�y b��_t �`��u</param>
        /// <param name="toDate">NgA�y k���t thA�c</param>
        /// <param name="syncType">Lo���i �`��"ng b��T: Manual ho���c Auto</param>
        /// <param name="userId">User ID n���u lA� manual sync</param>
        /// <param name="invoiceDirection">Chi��?u hA3a �`��n: 1=BA�n ra, 2=Mua vA�o</param>
        /// <returns></returns>
        Task<BaseResult> SyncInvoicesFromAPI(DateTimeOffset fromDate, DateTimeOffset toDate, string syncType = "Manual", int? userId = null, int invoiceDirection = 1);

        /// <summary>
        /// �?��"ng b��T hA3a �`��n bA�n ra c��a ngA�y hA'm qua (dA1ng cho Hangfire job)
        /// </summary>
        Task<BaseResult> SyncYesterdayInvoices();

        /// <summary>
        /// �?��"ng b��T hA3a �`��n mua vA�o c��a ngA�y hA'm qua (dA1ng cho Hangfire job)
        /// </summary>
        Task<BaseResult> SyncYesterdayPurchaseInvoices();

        /// <summary>
        /// L���y thA'ng tin �`��"ng b��T g��n nh���t
        /// </summary>
        Task<VatInvoiceSyncInfo> GetLastSyncInfo();
    }
}

=== Ladaer.BackEnd\Infrastructures\Services\Finances\OrderTimeTrackService.cs ===
using Dapper;
using Lada.Framework.Data.Enums;
using Lada.Framework.DTO;
using System.Data;
using static Lada.Framework.Data.Enums.OrderFinEnum;

namespace Ladaer.BackEnd.Infrastructures.Services.Finances
{
    /// <summary>
    /// Interface cho service qu���n lA� th��?i gian nh��-n ti��?n trong OrderTimeTrack
    /// </summary>
    public interface IOrderTimeTrackService
    {
        /// <summary>
        /// C��-p nh��-t th��?i gian nh��-n ti��?n trong OrderTimeTrack
        /// </summary>
        /// <param name="orderId">ID �`��n hA�ng</param>
        /// <param name="sourceFeeStage">Stage c��a SourceFee (3=Branch, 9=Head)</param>
        /// <param name="destFeeStage">Stage c��a DestFee (3=Branch, 9=Head)</param>
        /// <param name="transferFeeStage">Stage c��a TransferFee (3=Branch, 9=Head)</param>
        /// <param name="codStage">Stage c��a COD (3=Branch, 9=Head)</param>
        /// <param name="deductCodFeeStage">Stage c��a DeductCodFee (3=Branch, 9=Head) - ch��% khi PayFeeType = COD</param>
        /// <param name="updatedBy">ID ng����?i c��-p nh��-t</param>
        /// <param name="updatedByUserName">TA�n ng����?i c��-p nh��-t</param>
        /// <param name="currentTime">Th��?i gian hi���n t���i (null = SYSDATETIMEOFFSET())</param>
        /// <returns>K���t qu��� c��-p nh��-t</returns>
        Task<BaseResult> UpdateFinancialTimesAsync(
            int orderId,
            OrderFeeStage? sourceFeeStage = null,
            OrderFeeStage? destFeeStage = null,
            OrderFeeStage? transferFeeStage = null,
            OrderCodStage? codStage = null,
            OrderFeeStage? deductCodFeeStage = null,
            int? updatedBy = null,
            string? updatedByUserName = null,
            DateTimeOffset? currentTime = null);

        /// <summary>
        /// C��-p nh��-t th��?i gian nh��-n ti��?n cho nhi��?u �`��n hA�ng
        /// </summary>

=== Ladaer.BackEnd\Infrastructures\Services\Finances\PriceService.cs ===
using Lada.Framework.Data.Domains.Crm;
using Lada.Framework.Data.Domains.Finance.Quotations;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.AppSettings;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finances;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Export;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Options;
using OfficeOpenXml;
using OfficeOpenXml.Style;
using System.Drawing;
using Route = Lada.Framework.Data.Domains.Finance.Quotations.Route;

namespace Ladaer.BackEnd.Infrastructures.Services.Finances
{
    /// <summary>
    /// Giao di?n cho d?ch v? qu?n ly gi�.
    /// </summary>
    public interface IPriceService
    {
        /// <summary>
        /// L?y danh s�ch gi� m?c d?nh theo lo?i gi�.
        /// </summary>
        /// <param name="priceType">Lo?i gi�.</param>
        /// <returns>Danh s�ch gi� m?c d?nh.</returns>
        Task<PriceListModel> GetDefaultPriceList(PriceType priceType);

        /// <summary>
        /// C?p nh?t danh s�ch gi� m?c d?nh.
        /// </summary>
        /// <param name="model">Th�ng tin danh s�ch gi�.</param>
        /// <returns>K?t qu? c?a thao t�c.</returns>
        Task<BaseResult> UpdateDefaultPriceList(PriceListModel model);

        /// <summary>
        /// Xu?t danh s�ch gi� m?c d?nh ra file.

=== Ladaer.BackEnd\Infrastructures\Services\Finances\README_OrderTimeTrackService.md ===
# OrderTimeTrackService - Service Qu���n LA� Th��?i Gian Nh��-n Ti��?n

## T��ng Quan

`OrderTimeTrackService` lA� m��Tt service chuyA�n d���ng �`��� qu���n lA� vi���c c��-p nh��-t th��?i gian nh��-n ti��?n trong b���ng `OrderTimeTrack`. Service nA�y �`�����c thi���t k��� �`��� cA3 th��� tA�i s��- d���ng ��Y nhi��?u n��i khA�c nhau trong h��� th��`ng.

## M���c �?A-ch

- **TA�i s��- d���ng**: CA3 th��� s��- d���ng trong nhi��?u service khA�c nhau (CashierService, ReconciliationService, TransferPaymentBillService, etc.)
- **T��-p trung hA3a**: T���t c��� logic c��-p nh��-t th��?i gian nh��-n ti��?n �`�����c t��-p trung vA�o m��Tt service
- **D��. b���o trA�**: Thay �`��i logic ch��% c��n s��-a ��Y m��Tt n��i
- **Batch processing**: H��- tr��� c��-p nh��-t nhi��?u �`��n hA�ng cA1ng lA�c

## CA�c Tr����?ng Th��?i Gian �?�����c Qu���n LA�

| Tr����?ng | MA' T��� | �?i��?u Ki���n C��-p Nh��-t |
|--------|-------|-------------------|
| `HeadSourceFeeTime` | Th��?i gian nh��-n ti��?n c����>c ngu��"n | Khi `SourceFeeStage = Head (9)` |
| `HeadDestFeeTime` | Th��?i gian nh��-n ti��?n c����>c �`A-ch | Khi `DestFeeStage = Head (9)` |
| `HeadTransferFeeTime` | Th��?i gian nh��-n ti��?n c����>c chuy���n kho���n | Khi `TransferFeeStage = Head (9)` |
| `HeadDeductCodFeeTime` | Th��?i gian nh��-n ti��?n c����>c c���n tr��� COD | Khi `DeductCodFeeStage = Head (9)` vA� `PayFeeType = COD` |

## Interface

### IOrderTimeTrackService

```csharp
public interface IOrderTimeTrackService
{
    /// <summary>
    /// C��-p nh��-t th��?i gian nh��-n ti��?n cho m��Tt �`��n hA�ng
    /// </summary>
    Task<BaseResult> UpdateFinancialTimesAsync(
        int orderId,
        OrderFeeStage? sourceFeeStage = null,
        OrderFeeStage? destFeeStage = null,
        OrderFeeStage? transferFeeStage = null,
        OrderCodStage? codStage = null,
        OrderFeeStage? deductCodFeeStage = null,
        int? updatedBy = null,

=== Ladaer.BackEnd\Infrastructures\Services\Finances\ReconciliationService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Crm;
using Lada.Framework.Data.Domains.Finance;
using Lada.Framework.Data.Domains.Finance.Wallets;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Crm;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finances;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finances;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Profiles;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finances;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Ladaer.BackEnd.Infrastructures.Services.Orders;
using Microsoft.EntityFrameworkCore;
using static Lada.Framework.Data.Enums.OrderFinEnum;

namespace Ladaer.BackEnd.Infrastructures.Services.Finances
{
    /// <summary>
    /// Giao di���n cho d��<ch v��� qu���n lA� �`��`i soA�t.
    /// </summary>
    public interface IReconciliationService
    {
        /// <summary>
        /// TA�m ki���m khA�ch hA�ng c��n �`��`i soA�t v��>i phA�n trang.
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m.</param>
        /// <param name="userId">ID ng����?i dA1ng hi���n t���i.</param>
        /// <returns>K���t qu��� tA�m ki���m khA�ch hA�ng c��n �`��`i soA�t.</returns>
        Task<SmartTableResult<CustomerReconciliationSummaryItem>> SearchCustomersForReconciliation(SmartTableParam param, int userId);

        /// <summary>

=== Ladaer.BackEnd\Infrastructures\Services\Finances\RouteService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finances;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finances;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finances;
using Microsoft.EntityFrameworkCore;
using Route = Lada.Framework.Data.Domains.Finance.Quotations.Route;

namespace Ladaer.BackEnd.Infrastructures.Services.Finances
{
    /// <summary>
    /// Giao di?n cho d?ch v? qu?n ly tuy?n v?n t?i.
    /// </summary>
    public interface IRouteService
    {
        /// <summary>
        /// T�m ki?m tuy?n v?n t?i.
        /// </summary>
        /// <param name="param">Th�ng s? t�m ki?m.</param>
        /// <returns>K?t qu? t�m ki?m tuy?n v?n t?i.</returns>
        Task<SmartTableResult<RouteItem>> Search(SmartTableParam param);

        /// <summary>
        /// T?o m?i ho?c c?p nh?t th�ng tin tuy?n v?n t?i.
        /// </summary>
        /// <param name="model">Th�ng tin tuy?n v?n t?i.</param>
        /// <returns>K?t qu? c?a thao t�c.</returns>
        Task<RouteResult> CreateOrUpdate(RouteModel model);

        /// <summary>
        /// L?y th�ng tin tuy?n v?n t?i theo ID.
        /// </summary>
        /// <param name="routeId">ID c?a tuy?n v?n t?i.</param>
        /// <returns>Th�ng tin tuy?n v?n t?i.</returns>
        Task<RouteModel> GetById(int routeId);


=== Ladaer.BackEnd\Infrastructures\Services\Finances\TransactionService.cs ===
using System;
using Lada.Framework.Data.Domains.Finance.Wallets;
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finances;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finances;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Finances
{
    public interface ITransactionService
    {
        Task<TransactionSearchResult> SearchWalletTransactions(SmartTableParam param, int userId);
        Task<TransactionDetailResult> GetTransactionDetail(Guid transactionId);
        Task<TransactionStatisticsResult> GetTransactionStatistics(int walletId, DateTimeOffset? startDate = null, DateTimeOffset? endDate = null);
        Task<WalletBalanceHistoryResult> GetWalletBalanceHistory(int walletId, DateTimeOffset? startDate = null, DateTimeOffset? endDate = null);
    }

    public class TransactionService : ITransactionService
    {
        private readonly IRepository<Transaction> _transactionRepository;
        private readonly IRepository<Wallet> _walletRepository;
        private readonly IRepository<TransactionOrder> _transactionOrderRepository;
        private readonly IUserService _userService;

        public TransactionService(
            IRepository<Transaction> transactionRepository,
            IRepository<Wallet> walletRepository,
            IRepository<TransactionOrder> transactionOrderRepository,
            IUserService userService)
        {
            _transactionRepository = transactionRepository;
            _walletRepository = walletRepository;
            _transactionOrderRepository = transactionOrderRepository;

=== Ladaer.BackEnd\Infrastructures\Services\Finances\VatInvoiceService.cs ===
using Lada.Framework.Data.Domains.Finance;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finance;

namespace Ladaer.BackEnd.Infrastructures.Services.Finances
{
    /// <summary>
    /// Service qu���n lA� hA3a �`��n VAT n��Ti b��T (CRUD)
    /// </summary>
    public class VatInvoiceService : IVatInvoiceService
    {
        private readonly IRepository<VatInvoice> _repository;

        public VatInvoiceService(IRepository<VatInvoice> repository)
        {
            _repository = repository;
        }

        /// <summary>
        /// TA�m ki���m hA3a �`��n VAT
        /// </summary>
        public async Task<SmartTableResult<VatInvoiceItem>> Search(SmartTableParam param)
        {
            var query = _repository.Query();

            // A?p d���ng filter t��� param
            if (param.Search.PredicateObject != null)
            {
                dynamic search = param.Search.PredicateObject;

                // TA�m ki���m theo keyword
                if (search.Keyword != null)
                {
                    string keyword = search.Keyword.ToString().Trim().ToLower();
                    query = query.Where(x =>
                        x.InvoiceNumber.ToLower().Contains(keyword) ||
                        x.SellerName.ToLower().Contains(keyword) ||

=== Ladaer.BackEnd\Infrastructures\Services\Finances\VatInvoiceSyncService.cs ===
using System.Globalization;
using System.Net;
using System.Text;
using System.Text.Json;
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Finance;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finance;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;

namespace Ladaer.BackEnd.Infrastructures.Services.Finances
{
    /// <summary>
    /// Service �`��"ng b��T hA3a �`��n VAT t��� API T��ng c���c Thu���
    /// </summary>
    public class VatInvoiceSyncService : IVatInvoiceSyncService
    {
        private readonly IRepository<VatInvoice> _repository;
        private readonly IRepository<VatInvoiceSyncHistory> _syncHistoryRepository;
        private readonly IRepository<AppConfig> _appConfigRepository;
        private readonly IHttpClientFactory _httpClientFactory;
        private readonly ILogger<VatInvoiceSyncService> _logger;

        public VatInvoiceSyncService(
            IRepository<VatInvoice> repository,
            IRepository<VatInvoiceSyncHistory> syncHistoryRepository,
            IRepository<AppConfig> appConfigRepository,
            IHttpClientFactory httpClientFactory,
            ILogger<VatInvoiceSyncService> logger)
        {
            _repository = repository;
            _syncHistoryRepository = syncHistoryRepository;
            _appConfigRepository = appConfigRepository;
            _httpClientFactory = httpClientFactory;
            _logger = logger;
        }


=== Ladaer.BackEnd\Infrastructures\Services\Finances\WalletService.cs ===
using Lada.Framework.Data.Domains.Finance.Wallets;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finances;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finances;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finances;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Finances
{
    public interface IWalletService
    {
        /// <summary>
        /// T�m ki?m v�
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        Task<SmartTableResult<WalletItem>> Search(SmartTableParam param);

        Task<WalletDetailModel> GetById(int id, int currentUserId);

        Task<WalletDetailModel> GetWalletByUserId(int userId, int currentUserId);

        Task<SmartTableResult<TransactionItem>> SearchTransactions(SmartTableParam param);

        /// <summary>
        /// Di?u ch?nh s? du v� (c�n v�)
        /// </summary>
        Task<BalanceAdjustmentResult> BalanceAdjustment(int walletId, BalanceAdjustmentModel model);

        /// <summary>
        /// L?y danh s�ch v� cho suggestion (select control)
        /// </summary>
        /// <param name="keyword">T? kh�a t�m ki?m</param>

=== Ladaer.BackEnd\Infrastructures\Services\Finances\WalletTransferService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Finance.Wallets;
using Lada.Framework.Data.Domains.Medias;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finances;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Finances
{
    /// <summary>
    /// Interface cho service chuy���n ti��?n gi��_a cA�c vA-
    /// </summary>
    public interface IWalletTransferService
    {
        /// <summary>
        /// Chuy���n ti��?n t��� vA- ngu��"n sang vA- �`A-ch
        /// </summary>
        /// <param name="sourceWalletId">ID vA- ngu��"n (vA- c��a ng����?i dA1ng �`ang �`��ng nh��-p)</param>
        /// <param name="model">ThA'ng tin chuy���n ti��?n</param>
        /// <returns>K���t qu��� chuy���n ti��?n</returns>
        Task<WalletTransferResult> Transfer(int sourceWalletId, TransferWalletModel model);
    }

    /// <summary>
    /// Service x��- lA� chuy���n ti��?n gi��_a cA�c vA- v��>i �`���m b���o toA�n v��1n giao d��<ch
    /// S��- d���ng DB Transaction + Optimistic Concurrency (RowVersion)
    /// </summary>
    public class WalletTransferService : IWalletTransferService
    {
        private readonly IRepository<Wallet> _walletRepository;
        private readonly IRepository<Transaction> _transactionRepository;
        private readonly IRepository<Media> _mediaRepository;
        private readonly IUnifiedMediaService _unifiedMediaService;
        private const int MaxRetryAttempts = 3;
        private const int RetryDelayMs = 100;

=== Ladaer.BackEnd\Infrastructures\Services\FuelCards\FuelCardService.cs ===
using Lada.Framework.Data.Domains.Finance;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Ladaer.BackEnd.Infrastructures.DTO.Items.FuelCards;
using Ladaer.BackEnd.Infrastructures.DTO.Models.FuelCards;
using Ladaer.BackEnd.Infrastructures.DTO.Results.FuelCards;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.FuelCards;

/// <summary>
/// Interface cho service qu���n lA� th��� x��ng d��u (th��� tA-n d���ng)
/// </summary>
public interface IFuelCardService
{
    /// <summary>
    /// TA�m ki���m th��� x��ng d��u v��>i phA�n trang
    /// </summary>
    Task<SmartTableResult<FuelCardItem>> Search(SmartTableParam param);

    /// <summary>
    /// L���y th��� x��ng d��u theo ID
    /// </summary>
    Task<FuelCardItem?> GetByIdAsync(int id);

    /// <summary>
    /// T���o ho���c c��-p nh��-t th��� x��ng d��u
    /// </summary>
    Task<BaseResult> CreateOrUpdateAsync(FuelCardModel model, CurrentUser currentUser);

    /// <summary>
    /// XA3a th��� x��ng d��u
    /// </summary>
    Task<BaseResult> DeleteAsync(int id, CurrentUser currentUser);

    /// <summary>
    /// L���y danh sA�ch th��� �`ang ho���t �`��Tng

=== Ladaer.BackEnd\Infrastructures\Services\FuelCards\FuelCardTransactionService.cs ===
using Lada.Framework.Data.Domains.Finance;
using Lada.Framework.Data.Domains.Trucks;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Items.FuelCards;
using Ladaer.BackEnd.Infrastructures.DTO.Models.FuelCards;
using Ladaer.BackEnd.Infrastructures.DTO.Profiles;
using Ladaer.BackEnd.Infrastructures.DTO.Results.FuelCards;
using Microsoft.EntityFrameworkCore;
using OfficeOpenXml;
using System.Globalization;

namespace Ladaer.BackEnd.Infrastructures.Services.FuelCards;

/// <summary>
/// Interface cho service qu���n lA� giao d��<ch th��� tA-n d���ng x��ng d��u
/// </summary>
public interface IFuelCardTransactionService
{
    /// <summary>
    /// Import sao kA� th��� tA-n d���ng t��� Excel
    /// </summary>
    Task<BaseResult> ImportStatementAsync(FuelCardTransactionImportModel model, CurrentUser currentUser);

    /// <summary>
    /// TA�m ki���m giao d��<ch th���
    /// </summary>
    Task<SmartTableResult<FuelCardTransactionItem>> Search(SmartTableParam param, int? fuelCardId = null);

    /// <summary>
    /// L���y chi ti���t giao d��<ch
    /// </summary>
    Task<FuelCardTransactionItem?> GetByIdAsync(Guid id);

    /// <summary>
    /// �?��`i soA�t giao d��<ch th��� v��>i l��n �`�� d��u

=== Ladaer.BackEnd\Infrastructures\Services\FuelCards\FuelRefillExcelService.cs ===
using System.Drawing;
using Lada.Framework.Data.Domains.Finance;
using Lada.Framework.Data.Domains.Trucks;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO.Results.FuelCards;
using Microsoft.EntityFrameworkCore;
using OfficeOpenXml;
using OfficeOpenXml.Style;

namespace Ladaer.BackEnd.Infrastructures.Services.FuelCards
{
    /// <summary>
    /// Interface cho d��<ch v��� xu���t Excel l��<ch s��- �`�� d��u
    /// </summary>
    public interface IFuelRefillExcelService
    {
        /// <summary>
        /// Xu���t Excel l��<ch s��- �`�� d��u
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m vA� s��_p x���p</param>
        /// <returns>K���t qu��� xu���t file</returns>
        Task<FuelRefillExcelExportResult> ExportFuelRefillsAsync(SmartTableParam param);
    }

    /// <summary>
    /// D��<ch v��� xu���t Excel l��<ch s��- �`�� d��u
    /// </summary>
    public class FuelRefillExcelService : IFuelRefillExcelService
    {
        private readonly IRepository<FuelRefill> _fuelRefillRepository;
        private readonly IExcelFileService _excelFileService;

        public FuelRefillExcelService(
            IRepository<FuelRefill> fuelRefillRepository,
            IExcelFileService excelFileService)
        {
            _fuelRefillRepository = fuelRefillRepository;

=== Ladaer.BackEnd\Infrastructures\Services\FuelCards\FuelRefillService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Finance;
using Lada.Framework.Data.Domains.Medias;
using Lada.Framework.Data.Domains.Trucks;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.FuelCards;
using Ladaer.BackEnd.Infrastructures.DTO.Models.FuelCards;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Trucks;
using Ladaer.BackEnd.Infrastructures.Services.Trucks;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.FuelCards;

/// <summary>
/// Interface cho service qu���n lA� vi���c �`�� d��u
/// </summary>
public interface IFuelRefillService
{
    /// <summary>
    /// T���o ho���c c��-p nh��-t thA'ng tin �`�� d��u
    /// </summary>
    Task<BaseResult> CreateOrUpdate(FuelRefillModel model, CurrentUser currentUser);

    /// <summary>
    /// LA�i xe �`�� d��u - Upload ���nh vA� t��� �`��Tng tA-nh chA�nh l���ch �`��<nh m��cc khoA�n
    /// </summary>
    [Obsolete("S��- d���ng CreateOrUpdate thay th���")]
    Task<BaseResult> RefillFuelAsync(FuelRefillModel model, CurrentUser currentUser);

    /// <summary>
    /// TA�m ki���m l��<ch s��- �`�� d��u
    /// </summary>
    Task<SmartTableResult<FuelRefillItem>> Search(SmartTableParam param);

=== Ladaer.BackEnd\Infrastructures\Services\Hr\AttendanceService.cs ===
using System.Data;
using Dapper;
using Lada.Framework.Data.Domains.Hr;
using Lada.Framework.Data.Domains.Medias;
using Lada.Framework.Data.Domains.Trucks;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.Models.Media;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Hr;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Hr;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Export;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Hr;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Media;
using Microsoft.EntityFrameworkCore;
using OfficeOpenXml;
using OfficeOpenXml.Style;

namespace Ladaer.BackEnd.Infrastructures.Services.Hr
{
    /// <summary>
    /// Giao di?n cho d?ch v? ch?m c�ng.
    /// </summary>
    public interface IAttendanceService
    {
        /// <summary>
        /// X? ly ch?m c�ng (Check-in ho?c Check-out) d?a tr�n tr?ng th�i hi?n t?i.
        /// </summary>
        /// <param name="model">M� h�nh CheckInOutModel ch?a th�ng tin ch?m c�ng.</param>
        /// <returns>K?t qu? ch?m c�ng v?i th�ng tin chi ti?t.</returns>
        Task<CheckInOutResult> PunchAsync(CheckInOutModel model);

        /// <summary>
        /// L?y th�ng tin ch?m c�ng hi?n t?i c?a ngu?i d�ng (chua check-out ho?c h�m nay)
        /// </summary>
        /// <param name="userId">ID ngu?i d�ng</param>

=== Ladaer.BackEnd\Infrastructures\Services\Hr\CandidateService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Hr;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Hr;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Hr;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Hr
{
    /// <summary>
    /// Giao di?n cho d?ch v? qu?n ly ?ng vi�n.
    /// </summary>
    public interface ICandidateService
    {
        /// <summary>
        /// T�m ki?m ?ng vi�n.
        /// </summary>
        /// <param name="param">Th�ng s? t�m ki?m.</param>
        /// <returns>K?t qu? t�m ki?m ?ng vi�n.</returns>
        Task<SmartTableResult<CandidateItem>> Search(SmartTableParam param);

        /// <summary>
        /// X�a ?ng vi�n theo ID.
        /// </summary>
        /// <param name="id">ID c?a ?ng vi�n.</param>
        /// <returns>K?t qu? c?a thao t�c.</returns>
        Task<BaseResult> Delete(int id);

        /// <summary>
        /// L?y th�ng tin d�nh gi� ?ng vi�n theo ID.
        /// </summary>
        /// <param name="id">ID c?a ?ng vi�n.</param>
        /// <returns>Th�ng tin d�nh gi� ?ng vi�n.</returns>
        Task<CandidateReviewModel> GetReviewModelById(int id);


=== Ladaer.BackEnd\Infrastructures\Services\Hr\CvUploadService.cs ===
using Lada.Framework.DTO;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures.AppSettings;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Hr;
using Microsoft.Extensions.Options;
using ImageMagick;
using System.Diagnostics;

namespace Ladaer.BackEnd.Infrastructures.Services.Hr
{
    

   
}

=== Ladaer.BackEnd\Infrastructures\Services\Hr\JobPostService.cs ===
using Hangfire.Common;
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Categories;
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.Data.Domains.Hr;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Hr;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Cms;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Hr;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Hr;
using Ladaer.BackEnd.Infrastructures.Services.Cms;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Hosting;

namespace Ladaer.BackEnd.Infrastructures.Services.Hr
{
    /// <summary>
    /// Giao di?n cho d?ch v? qu?n ly b�i dang tuy?n d?ng.
    /// </summary>
    public interface IJobPostService
    {
        /// <summary>
        /// T�m ki?m c�ng vi?c.
        /// </summary>
        /// <param name="param">Th�ng s? t�m ki?m.</param>
        /// <returns>K?t qu? t�m ki?m c�ng vi?c.</returns>
        Task<SmartTableResult<JobPostItem>> Search(SmartTableParam param);

        /// <summary>
        /// T?o ho?c c?p nh?t c�ng vi?c.
        /// </summary>
        /// <param name="model">Th�ng tin c�ng vi?c.</param>
        /// <returns>K?t qu? c?a thao t�c.</returns>

=== Ladaer.BackEnd\Infrastructures\Services\Identity\IPermissionService.cs ===
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Itentity;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Identity;

namespace Ladaer.BackEnd.Infrastructures.Services.Identity
{
    /// <summary>
    /// Service interface for managing Permission Groups and Role assignments
    /// </summary>
    public interface IPermissionService
    {
        /// <summary>
        /// T���o Permission Group m��>i
        /// </summary>
        /// <param name="name">TA�n Permission Group</param>
        /// <param name="description">MA' t���</param>
        /// <param name="roleIds">Danh sA�ch Role ID</param>
        /// <returns>Permission �`A� t���o</returns>
        Task<Permission> CreatePermissionAsync(string name, string? description, List<int> roleIds);

        /// <summary>
        /// C��-p nh��-t Permission Group
        /// </summary>
        /// <param name="permissionId">ID c��a Permission</param>
        /// <param name="name">TA�n m��>i</param>
        /// <param name="description">MA' t��� m��>i</param>
        /// <param name="roleIds">Danh sA�ch Role ID m��>i</param>
        /// <returns>Permission �`A� c��-p nh��-t</returns>
        Task<Permission?> UpdatePermissionAsync(int permissionId, string name, string? description, List<int> roleIds);

        /// <summary>
        /// XA3a Permission Group
        /// </summary>
        /// <param name="permissionId">ID c��a Permission</param>
        /// <returns>True n���u xA3a thA�nh cA'ng</returns>
        Task<bool> DeletePermissionAsync(int permissionId);

        /// <summary>

=== Ladaer.BackEnd\Infrastructures\Services\Identity\IRoleMigrationService.cs ===
using Lada.Framework.Data.Domains.Identity;

namespace Ladaer.BackEnd.Infrastructures.Services.Identity
{
    /// <summary>
    /// Service for migrating from old role naming convention to new Controller.Action pattern
    /// </summary>
    public interface IRoleMigrationService
    {
        /// <summary>
        /// T���o t���t c��� Role m��>i theo pattern Controller.Action
        /// </summary>
        /// <returns>Danh sA�ch Role �`A� t���o</returns>
        Task<List<string>> CreateNewRolesAsync();

        /// <summary>
        /// T���o Permission Groups m���c �`��<nh t����ng ��cng v��>i cA�c vai trA� c�c
        /// </summary>
        /// <returns>Danh sA�ch Permission �`A� t���o</returns>
        Task<List<string>> CreateDefaultPermissionGroupsAsync();

        /// <summary>
        /// Migration Users t��� old roles sang Permission Groups
        /// </summary>
        /// <returns>S��` l�����ng User �`A� migration</returns>
        Task<int> MigrateUsersToPermissionGroupsAsync();

        /// <summary>
        /// L���y danh sA�ch Role m��>i c��n t���o
        /// </summary>
        /// <returns>Dictionary v��>i key lA� role name, value lA� description</returns>
        Dictionary<string, string> GetNewRolesToCreate();

        /// <summary>
        /// L���y mapping t��� old roles sang Permission Groups
        /// </summary>
        /// <returns>Dictionary v��>i key lA� old role, value lA� Permission Group name</returns>
        Dictionary<string, string> GetOldRoleToPermissionMapping();

        /// <summary>

=== Ladaer.BackEnd\Infrastructures\Services\Identity\PermissionService.cs ===
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO.SmartTable;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Itentity;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Identity;
using Ladaer.BackEnd.Infrastructures.Extensions;
using Lada.Framework.Data.Domains;
using Lada.Framework.DTO;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Identity
{
    /// <summary>
    /// Service for managing Permission Groups and Role assignments
    /// </summary>
    public class PermissionService : IPermissionService
    {
        private readonly IRepository<Permission> _permissionRepository;
        private readonly IRepository<PermissionRole> _permissionRoleRepository;
        private readonly UserManager<User> _userManager;
        private readonly RoleManager<Role> _roleManager;
        private readonly IUserService _userService;

        public PermissionService(
            IRepository<Permission> permissionRepository,
            IRepository<PermissionRole> permissionRoleRepository,
            UserManager<User> userManager,
            RoleManager<Role> roleManager,
            IUserService userService)
        {
            _permissionRepository = permissionRepository;
            _permissionRoleRepository = permissionRoleRepository;
            _userManager = userManager;
            _roleManager = roleManager;
            _userService = userService;
        }

        public async Task<Permission> CreatePermissionAsync(string name, string? description, List<int> roleIds)
        {

=== Ladaer.BackEnd\Infrastructures\Services\Identity\RoleMigrationService.cs ===
using Lada.Framework.Data.Domains.Identity;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Identity
{
    /// <summary>
    /// Service for migrating from old role naming convention to new Controller.Action pattern
    /// </summary>
    public class RoleMigrationService : IRoleMigrationService
    {
        private readonly RoleManager<Role> _roleManager;
        private readonly UserManager<User> _userManager;
        private readonly IPermissionService _permissionService;

        public RoleMigrationService(
            RoleManager<Role> roleManager,
            UserManager<User> userManager,
            IPermissionService permissionService)
        {
            _roleManager = roleManager;
            _userManager = userManager;
            _permissionService = permissionService;
        }

        public Dictionary<string, string> GetNewRolesToCreate()
        {
            return new Dictionary<string, string>
            {
                // System Roles
                { "System.Permission.Manage", "Qu���n lA� Permission Groups" },
                { "System.Role.Manage", "Qu���n lA� Roles" },
                { "System.User.Manage", "Qu���n lA� Users" },

                // Agency Roles
                { "Agency.View", "Xem thA'ng tin �`���i lA�" },
                { "Agency.Create", "T���o �`���i lA� m��>i" },
                { "Agency.Update", "C��-p nh��-t thA'ng tin �`���i lA�" },
                { "Agency.Delete", "XA3a �`���i lA�" },


=== Ladaer.BackEnd\Infrastructures\Services\Identity\RoleService.cs ===
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Enums;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Identity;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Itentity;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Users;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Users;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Identity
{
    public interface IRoleService
    {
        Task<SmartTableResult<RoleItem>> SearchAsync(SmartTableParam param);
        Task<List<RoleItem>> GetRolesAsync(int currentUserId);
        Task<RoleModel> GetByIdAsync(int roleId);
        Task<BaseResult> CreateOrUpdateAsync(RoleModel model);
        Task<BaseResult> DeleteAsync(int roleId);
        Task<BaseResult> SetRoleAsync(SetRoleModel model);

    }

    public class RoleService : IRoleService
    {
        private readonly RoleManager<Role> _roleManager;
        private readonly UserManager<User> _userManager;
        public RoleService(RoleManager<Role> roleManager, UserManager<User> userManager)
        {
            _roleManager = roleManager;
            _userManager = userManager;
        }

        

        public async Task<RoleModel> GetByIdAsync(int roleId)
        {

=== Ladaer.BackEnd\Infrastructures\Services\Identity\UserService.cs ===
using Lada.Framework.Data.Domains.Categories;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.AppSettings;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Categories;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Identity;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Accounts;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Users;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Accounts;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Users;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using Microsoft.EntityFrameworkCore;
using Microsoft.IdentityModel.Tokens;
using System.Data;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Security.Cryptography;
using System.Text;

namespace Ladaer.BackEnd.Infrastructures.Services.Identity
{
    /// <summary>
    /// Giao di?n cho d?ch v? qu?n ly ngu?i d�ng.
    /// </summary>
    public interface IUserService
    {
        /// <summary>
        /// G?i y ngu?i d�ng d?a tr�n t? kh�a v� lo?i ngu?i d�ng.
        /// </summary>
        /// <param name="keyword">T? kh�a t�m ki?m.</param>
        /// <param name="userType">Lo?i ngu?i d�ng.</param>
        /// <param name="roleName">T�n vai tr� (t�y ch?n).</param>
        /// <returns>Danh s�ch ngu?i d�ng g?i y.</returns>

=== Ladaer.BackEnd\Infrastructures\Services\Monitor\OrderRiskService.cs ===
using System.Data;
using Dapper;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Monitor;

namespace Ladaer.BackEnd.Infrastructures.Services.Monitor
{
    public interface IOrderRiskService
    {
        Task<OrderRiskResult> GetOrdersWithoutSourceCashierAsync(OrderRiskSearchParam param);
        Task<OrderRiskOverview> GetOrderRiskOverviewAsync(DateTime? fromDate = null, DateTime? toDate = null);
        Task<OrderRiskResult> GetOrdersWithoutDestCashierAsync(OrderRiskSearchParam param);
        Task<OrderRiskOverview> GetOrderRiskOverviewForDestCashierAsync(DateTime? fromDate = null, DateTime? toDate = null);
        Task<OrderRiskResult> GetOrdersBothPayWithoutCashierAsync(OrderRiskSearchParam param);
        Task<OrderRiskOverview> GetOrderRiskOverviewForBothPayAsync(DateTime? fromDate = null, DateTime? toDate = null);
    }

    public class OrderRiskService : IOrderRiskService
    {
        private readonly IDbConnection _connection;

        public OrderRiskService(IDbConnection connection)
        {
            _connection = connection;
        }

        public async Task<OrderRiskResult> GetOrdersWithoutSourceCashierAsync(OrderRiskSearchParam param)
        {
            var parameters = new DynamicParameters();

            if (param.FromDate.HasValue)
            {
                parameters.Add("@FromDate", param.FromDate.Value);
            }

            if (param.ToDate.HasValue)
            {
                parameters.Add("@ToDate", param.ToDate.Value);
            }

            parameters.Add("@PageNumber", param.PageNumber > 0 ? param.PageNumber : 1);

=== Ladaer.BackEnd\Infrastructures\Services\OrderBusiness\OrderFailReasonService.cs ===
using Lada.Framework.Data.Domains.OrderBusiness;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.OrderBusiness;
using Ladaer.BackEnd.Infrastructures.DTO.Models.OrderBusiness;
using Ladaer.BackEnd.Infrastructures.DTO.Profiles;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.OrderBusiness
{
    /// <summary>
    /// Interface qu���n lA� lA� do th���t b���i l���y/giao hA�ng
    /// </summary>
    public interface IOrderFailReasonService
    {
        /// <summary>
        /// TA�m ki���m lA� do th���t b���i
        /// </summary>
        Task<SmartTableResult<OrderFailReasonItem>> Search(SmartTableParam param);

        /// <summary>
        /// T���o ho���c c��-p nh��-t lA� do th���t b���i
        /// </summary>
        Task<BaseResult> CreateOrUpdate(OrderFailReasonModel model);

        /// <summary>
        /// L���y thA'ng tin lA� do th���t b���i theo ID
        /// </summary>
        Task<OrderFailReasonModel> GetById(int id);

        /// <summary>
        /// XA3a lA� do th���t b���i (soft delete)
        /// </summary>
        Task<BaseResult> Delete(OrderFailReasonModel model);

        /// <summary>
        /// L���y danh sA�ch lA� do th���t b���i theo lo���i (cho Driver App)

=== Ladaer.BackEnd\Infrastructures\Services\Orders\OrderAddressService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.Infrastructures;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders.Shared;
using Ladaer.BackEnd.Infrastructures.Services.Categories;
using Ladaer.BackEnd.Infrastructures.Services.Crm;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json;

namespace Ladaer.BackEnd.Infrastructures.Services.Orders
{
    /// <summary>
    /// Giao di?n cho d?ch v? qu?n ly d?a ch? don h�ng.
    /// </summary>
    public interface IOrderAddressService
    {
        /// <summary>
        /// L?y th�ng tin d?a ch? don h�ng theo ID.
        /// </summary>
        /// <param name="id">ID c?a d?a ch? don h�ng.</param>
        /// <returns>Th�ng tin d?a ch? don h�ng.</returns>
        Task<UpdateOrderAddressModel> GetById(int id);

        /// <summary>
        /// C?p nh?t th�ng tin d?a ch? don h�ng.
        /// </summary>
        /// <param name="model">Th�ng tin d?a ch? don h�ng.</param>
        /// <returns>K?t qu? c?a thao t�c.</returns>
        Task<BaseResult> Update(UpdateOrderAddressModel model);
    }
    /// <summary>
    /// Tri?n khai d?ch v? qu?n ly d?a ch? don h�ng.
    /// </summary>
    public class OrderAddressService : IOrderAddressService
    {

=== Ladaer.BackEnd\Infrastructures\Services\Orders\OrderFinService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.Models;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.AppSettings;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Business.Operations;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders.Shared;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Ladaer.BackEnd.Infrastructures.Services.Crm;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata;
using Microsoft.Extensions.Options;
using Newtonsoft.Json;
using static Lada.Framework.Data.Enums.OrderFinEnum;

namespace Ladaer.BackEnd.Infrastructures.Services.Orders
{
    /// <summary>
    /// Interface d? d?nh nghia c�c phuong th?c x? ly t�i ch�nh don h�ng.
    /// </summary>
    public interface IOrderFinService
    {
        /// <summary>
        /// C?p nh?t t�i ch�nh don h�ng kh�ng d?ng b?.
        /// </summary>
        /// <param name="orderId">ID c?a don h�ng.</param>
        /// <param name="updatedBy">ID c?a ngu?i c?p nh?t.</param>
        /// <param name="updatedByUserName">T�n ngu?i c?p nh?t.</param>
        /// <returns>K?t qu? c?a ho?t d?ng c?p nh?t.</returns>
        Task<BaseResult> UpdateOrderFinAsync(int orderId, int updatedBy, string updatedByUserName);

        /// <summary>

=== Ladaer.BackEnd\Infrastructures\Services\Orders\OrderPackageService.cs ===
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.Enums;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders.Shared;
using Ladaer.BackEnd.Infrastructures.Services.Crm;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json;

namespace Ladaer.BackEnd.Infrastructures.Services.Orders
{
    /// <summary>
    /// Giao di?n cho d?ch v? qu?n ly ki?n h�ng trong don h�ng.
    /// </summary>
    public interface IOrderPackageService
    {
        /// <summary>
        /// L?y th�ng tin ki?n h�ng theo ID don h�ng.
        /// </summary>
        /// <param name="orderId">ID c?a don h�ng.</param>
        /// <returns>Th�ng tin ki?n h�ng.</returns>
        Task<UpdateOrderPackageModel> GetByOrderId(int orderId);

        /// <summary>
        /// L?y th�ng tin ki?n h�ng theo ID don h�ng v?i th�ng tin don v? do.
        /// </summary>
        /// <param name="orderId">ID c?a don h�ng.</param>
        /// <returns>Th�ng tin ki?n h�ng v?i don v? do.</returns>
        Task<UpdateOrderPackageWithUnitsModel> GetByOrderIdWithUnits(int orderId);

        /// <summary>
        /// C?p nh?t th�ng tin ki?n h�ng.
        /// </summary>
        /// <param name="model">Model ch?a th�ng tin ki?n h�ng.</param>
        /// <returns>K?t qu? c?a thao t�c.</returns>

=== Ladaer.BackEnd\Infrastructures\Services\Orders\OrderService.cs ===
using Dapper;
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Medias;
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.Data.Enums;
using static Lada.Framework.Data.Enums.OrderFinEnum;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.Enums;
using Lada.Framework.DTO.Models;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures.Services;
using Lada.Framework.Infrastructures.Extensions;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Identity;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Medias;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders.Detail;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders.Updates;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Filters.Orders;
using Ladaer.BackEnd.Infrastructures.Services.Categories;
using Ladaer.BackEnd.Infrastructures.Services.Crm;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json.Linq;
using System.Collections.Generic;
using System.Data;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Services;
using OfficeOpenXml;
using OfficeOpenXml.Style;
using System.Drawing;
using System.ComponentModel;
using System.Reflection;

namespace Ladaer.BackEnd.Infrastructures.Services.Orders
{

=== Ladaer.BackEnd\Infrastructures\Services\Orders\OrderTrackService.cs ===
using Hangfire.Storage.Monitoring;
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Hr;
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Orders;

namespace Ladaer.BackEnd.Infrastructures.Services.Orders
{
    /// <summary>
    /// Giao di?n cho d?ch v? qu?n ly h�nh tr�nh don h�ng.
    /// </summary>
    public interface IOrderTrackService
    {
        /// <summary>
        /// T?o m?i h�nh tr�nh don h�ng.
        /// </summary>
        /// <param name="model">Th�ng tin h�nh tr�nh don h�ng.</param>
        /// <returns>K?t qu? c?a thao t�c.</returns>
        Task<OrderTrackResult> CreateAsync(OrderTrackModel model);

        /// <summary>
        /// T?o m?i danh s�ch h�nh tr�nh don h�ng.
        /// </summary>
        /// <param name="models">Danh s�ch th�ng tin h�nh tr�nh don h�ng.</param>
        /// <returns>K?t qu? c?a thao t�c.</returns>
        Task<BaseResult> CreateAsync(List<OrderTrackModel> models);
    }
    /// <summary>
    /// Tri?n khai d?ch v? qu?n ly h�nh tr�nh don h�ng.
    /// </summary>
    public class OrderTrackService : IOrderTrackService
    {
        private readonly IRepository<OrderTrack> _orderTrackRepository;

        /// <summary>
        /// Kh?i t?o m?t th? hi?n c?a <see cref="OrderTrackService"/>.

=== Ladaer.BackEnd\Infrastructures\Services\Orders\Exports\IOrderExportTemplate.cs ===
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.DTO;
using OfficeOpenXml;

namespace Ladaer.BackEnd.Infrastructures.Services.Orders.Exports
{
    /// <summary>
    /// Interface cho template xu���t Excel �`��n hA�ng
    /// </summary>
    /// <typeparam name="TExportItem">Lo���i DTO export</typeparam>
    public interface IOrderExportTemplate<TExportItem> where TExportItem : class
    {
        /// <summary>
        /// TA�n template
        /// </summary>
        string TemplateName { get; }

        /// <summary>
        /// MA' t��� template
        /// </summary>
        string Description { get; }

        /// <summary>
        /// TA�n worksheet m���c �`��<nh
        /// </summary>
        string DefaultWorksheetName { get; }

        /// <summary>
        /// Chuy���n �`��i danh sA�ch Order thA�nh danh sA�ch DTO export
        /// </summary>
        /// <param name="orders">Danh sA�ch �`��n hA�ng</param>
        /// <returns>Danh sA�ch DTO export</returns>
        Task<List<TExportItem>> ConvertOrdersToExportItemsAsync(List<Order> orders);

        /// <summary>
        /// Thi���t l��-p header cho Excel
        /// </summary>
        /// <param name="worksheet">Worksheet</param>
        void SetupHeaders(ExcelWorksheet worksheet);


=== Ladaer.BackEnd\Infrastructures\Services\Orders\Exports\OrderExportService.cs ===
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Orders;
using Ladaer.BackEnd.Infrastructures.Services.Orders.Exports.Templates;
using Microsoft.EntityFrameworkCore;
using OfficeOpenXml;
using System.Diagnostics;

namespace Ladaer.BackEnd.Infrastructures.Services.Orders.Exports
{
    /// <summary>
    /// Interface cho d��<ch v��� xu���t Excel �`��n hA�ng (Generic)
    /// </summary>
    public interface IOrderExportService
    {
        /// <summary>
        /// Xu���t Excel �`��n hA�ng v��>i template �`�����c ch��% �`��<nh
        /// </summary>
        /// <param name="model">Model xu���t Excel</param>
        /// <returns>K���t qu��� xu���t file</returns>
        Task<OrderExportResult> ExportOrdersAsync(OrderExportModel model);

        /// <summary>
        /// Xu���t Excel �`��n hA�ng v��>i filter nA�ng cao
        /// </summary>
        /// <param name="model">Model xu���t Excel v��>i filter</param>
        /// <returns>K���t qu��� xu���t file</returns>
        Task<OrderExportResult> ExportOrdersWithFilterAsync(OrderExportWithFilterModel model);

        /// <summary>
        /// L���y danh sA�ch template cA3 s���n
        /// </summary>
        /// <returns>Danh sA�ch template</returns>
        List<OrderExportTemplateInfo> GetAvailableTemplates();

        /// <summary>

=== Ladaer.BackEnd\Infrastructures\Services\Orders\Exports\Templates\BasicOrderExportTemplate.cs ===
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.Data.Enums;
using Lada.Framework.DTO;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Orders;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using OfficeOpenXml;

namespace Ladaer.BackEnd.Infrastructures.Services.Orders.Exports.Templates
{
    /// <summary>
    /// Template xu���t Excel c�� b���n cho �`��n hA�ng
    /// </summary>
    public class BasicOrderExportTemplate : BaseOrderExportTemplate<BasicOrderExportItem>
    {
        private readonly IUserService _userService;

        public BasicOrderExportTemplate(IUserService userService)
        {
            _userService = userService;
        }

        public override string TemplateName => "Basic";
        public override string Description => "Template xu���t Excel c�� b���n cho �`��n hA�ng";
        public override string DefaultWorksheetName => "Danh sA�ch �`��n hA�ng";

        public override async Task<List<BasicOrderExportItem>> ConvertOrdersToExportItemsAsync(List<Order> orders)
        {
            var exportItems = new List<BasicOrderExportItem>();

            // L���y thA'ng tin Sale
            var saleIds = orders.Where(x => x.SaleId > 0).Select(x => x.SaleId).Distinct().ToList();
            var saleUsers = new Dictionary<int, string>();

            if (saleIds.Any())
            {
                var saleItems = await _userService.GetByListIdAsync(saleIds);
                saleUsers = saleItems.ToDictionary(s => s.Id, s => s.FullName ?? s.UserName);
            }


=== Ladaer.BackEnd\Infrastructures\Services\Orders\Exports\Templates\FinanceOrderExportTemplate.cs ===
using Lada.Framework.Data.Domains.Orders;
using Lada.Framework.Data.Enums;
using Lada.Framework.DTO;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using OfficeOpenXml;
using System.Drawing;

namespace Ladaer.BackEnd.Infrastructures.Services.Orders.Exports.Templates
{
    /// <summary>
    /// Template xu���t Excel cho m���c �`A-ch tA�i chA-nh (TransferPaymentBill)
    /// </summary>
    public class FinanceOrderExportTemplate : BaseOrderExportTemplate<TransferPaymentBillExportOrderItem>
    {
        private readonly IUserService _userService;

        public FinanceOrderExportTemplate(IUserService userService)
        {
            _userService = userService;
        }

        public override string TemplateName => "Finance";
        public override string Description => "Template xu���t Excel cho m���c �`A-ch tA�i chA-nh - TransferPaymentBill";
        public override string DefaultWorksheetName => "Danh sA�ch �`��n hA�ng - TA�i chA-nh";

        public override async Task<List<TransferPaymentBillExportOrderItem>> ConvertOrdersToExportItemsAsync(List<Order> orders)
        {
            var exportItems = new List<TransferPaymentBillExportOrderItem>();

            // L���y thA'ng tin Sale
            var saleIds = orders.Where(x => x.SaleId > 0).Select(x => x.SaleId).Distinct().ToList();
            var saleUsers = new Dictionary<int, string>();

            if (saleIds.Any())
            {
                var saleItems = await _userService.GetByListIdAsync(saleIds);
                saleUsers = saleItems.ToDictionary(s => s.Id, s => s.FullName ?? s.UserName);
            }

=== Ladaer.BackEnd\Infrastructures\Services\Premises\PremiseScoringService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Premises;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Premises;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Premises;
using Ladaer.BackEnd.Infrastructures.DTO.Profiles;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Premises
{
    public interface IPremiseScoringService
    {
        Task<SmartTableResult<PremiseScoringCriteriaItem>> SearchCriteria(SmartTableParam param);
        Task<PremiseScoringCriteriaModel> GetCriteriaById(int id);
        Task<BaseResult> CreateOrUpdateCriteria(PremiseScoringCriteriaModel model);
        Task<BaseResult> DeleteCriteria(int id);
        Task<List<PremiseScoringCriteriaItem>> GetAllActiveCriteria();
    }

    public class PremiseScoringService : IPremiseScoringService
    {
        private readonly IRepository<PremiseScoringCriteria> _criteriaRepository;
        private readonly IRepository<PremiseScoringOption> _optionRepository;

        public PremiseScoringService(
            IRepository<PremiseScoringCriteria> criteriaRepository,
            IRepository<PremiseScoringOption> optionRepository)
        {
            _criteriaRepository = criteriaRepository;
            _optionRepository = optionRepository;
        }

        public async Task<SmartTableResult<PremiseScoringCriteriaItem>> SearchCriteria(SmartTableParam param)
        {
            var query = _criteriaRepository.Query()
                .Include(x => x.Options)
                .Where(x => !x.IsDeleted);

=== Ladaer.BackEnd\Infrastructures\Services\Premises\PremiseService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Medias;
using Lada.Framework.Data.Domains.Premises;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Premises;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Premises;
using Ladaer.BackEnd.Infrastructures.DTO.Profiles;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Premises;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Premises
{
    public interface IPremiseService
    {
        Task<SmartTableResult<PremiseItem>> Search(SmartTableParam param);
        Task<BaseResult> CreateOrUpdate(PremiseModel model);
        Task<PremiseResult> GetById(int id);
        Task<BaseResult> Delete(int id);
        Task<BaseResult> ChangeStatus(PremiseStatusModel model);
        Task<BaseResult> UpdateFinancial(PremiseFinancialModel model);
        Task<BaseResult> DeleteMedia(int premiseMediaId);
    }

    public class PremiseService : IPremiseService
    {
        private readonly IRepository<Premise> _repository;
        private readonly IRepository<PremiseContact> _contactRepository;
        private readonly IRepository<PremiseScore> _scoreRepository;
        private readonly IRepository<PremiseFinancial> _financialRepository;
        private readonly IRepository<PremiseScoringOption> _scoringOptionRepository;
        private readonly IRepository<PremiseMedia> _premiseMediaRepository;
        private readonly IRepository<Media> _mediaRepository;
        private readonly IUnifiedMediaService _unifiedMediaService;

        public PremiseService(

=== Ladaer.BackEnd\Infrastructures\Services\Report\Finance\IncomeExpenseReportService.cs ===
using Dapper;
using Lada.Framework.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finance;
using System.Data;

namespace Ladaer.BackEnd.Infrastructures.Services.Report.Finance
{
    /// <summary>
    /// Interface cho service bA�o cA�o thu chi
    /// </summary>
    public interface IIncomeExpenseReportService
    {
        /// <summary>
        /// L���y bA�o cA�o thu chi theo kho���ng th��?i gian
        /// </summary>
        /// <param name="request">ThA'ng tin kho���ng th��?i gian</param>
        /// <param name="userId">ID ng����?i dA1ng</param>
        /// <returns>BA�o cA�o thu chi</returns>
        Task<IncomeExpenseReportResult> GetIncomeExpenseReportAsync(
            IncomeExpenseReportRequest request,
            int userId);
    }

    /// <summary>
    /// Service bA�o cA�o thu chi
    /// </summary>
    public class IncomeExpenseReportService : IIncomeExpenseReportService
    {
        private readonly IDbConnection _dbConnection;

        /// <summary>
        /// Kh��Yi t���o m��Tt th��� hi���n c��a <see cref="IncomeExpenseReportService"/>.
        /// </summary>
        /// <param name="dbConnection">K���t n��`i c�� s��Y d��_ li���u.</param>
        public IncomeExpenseReportService(IDbConnection dbConnection)
        {
            _dbConnection = dbConnection;
        }


=== Ladaer.BackEnd\Infrastructures\Services\Report\FuelCards\FuelRefillReportExcelService.cs ===
using System.Drawing;
using Dapper;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO.Reports.Items.FuelCards;
using Ladaer.BackEnd.Infrastructures.DTO.Results.FuelCards;
using OfficeOpenXml;
using OfficeOpenXml.Style;
using System.Data;

namespace Ladaer.BackEnd.Infrastructures.Services.Report.FuelCards
{
    /// <summary>
    /// Interface cho d��<ch v��� xu���t Excel bA�o cA�o �`�� d��u
    /// </summary>
    public interface IFuelRefillReportExcelService
    {
        /// <summary>
        /// Xu���t Excel bA�o cA�o �`�� d��u theo lA�i xe (nhA3m theo ngA�y)
        /// </summary>
        /// <param name="param">Tham s��` tA�m ki���m vA� s��_p x���p</param>
        /// <returns>K���t qu��� xu���t file</returns>
        Task<FuelRefillReportExcelResult> ExportByDriverAsync(SmartTableParam param);
    }

    /// <summary>
    /// D��<ch v��� xu���t Excel bA�o cA�o �`�� d��u
    /// </summary>
    public class FuelRefillReportExcelService : IFuelRefillReportExcelService
    {
        private readonly IDbConnection _dbConnection;
        private readonly IExcelFileService _excelFileService;

        public FuelRefillReportExcelService(
            IDbConnection dbConnection,
            IExcelFileService excelFileService)
        {
            _dbConnection = dbConnection;

=== Ladaer.BackEnd\Infrastructures\Services\Report\FuelCards\FuelRefillReportService.cs ===
using Dapper;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Reports.Items.FuelCards;
using Ladaer.BackEnd.Infrastructures.DTO.Reports.Results;
using System.Data;

namespace Ladaer.BackEnd.Infrastructures.Services.Report.FuelCards
{
    /// <summary>
    /// Interface cho d��<ch v��� bA�o cA�o �`�� d��u
    /// </summary>
    public interface IFuelRefillReportService
    {
        /// <summary>
        /// L���y bA�o cA�o �`�� d��u theo lA�i xe t��� stored procedure
        /// </summary>
        /// <param name="param">Tham s��` b���ng thA'ng minh</param>
        /// <returns>Danh sA�ch bA�o cA�o �`�� d��u theo lA�i xe</returns>
        Task<FuelRefillReportByDriverResult> GetFuelRefillReportByDriverAsync(SmartTableParam param);
    }

    /// <summary>
    /// D��<ch v��� bA�o cA�o �`�� d��u
    /// </summary>
    public class FuelRefillReportService : IFuelRefillReportService
    {
        private readonly IDbConnection _dbConnection;

        public FuelRefillReportService(IDbConnection dbConnection)
        {
            _dbConnection = dbConnection;
        }

        /// <summary>
        /// L���y bA�o cA�o �`�� d��u theo lA�i xe t��� stored procedure
        /// </summary>
        /// <param name="param">Tham s��` b���ng thA'ng minh</param>
        /// <returns>Danh sA�ch bA�o cA�o �`�� d��u theo lA�i xe</returns>
        public async Task<FuelRefillReportByDriverResult> GetFuelRefillReportByDriverAsync(SmartTableParam param)

=== Ladaer.BackEnd\Infrastructures\Services\Report\OperationReports\BranchReportService.cs ===

=== Ladaer.BackEnd\Infrastructures\Services\Report\OperationReports\DriverReportService.cs ===
using Dapper;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Reports.Items.Operations;
using Ladaer.BackEnd.Infrastructures.DTO.Reports.Results;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using System.Data;

namespace Ladaer.BackEnd.Infrastructures.Services.Report.OperationReports
{
    /// <summary>
    /// Interface cho d��<ch v��� bA�o cA�o lA�i xe
    /// </summary>
    public interface IDriverReportService
    {
        /// <summary>
        /// L���y bA�o cA�o n��ng su���t lA�i xe theo t���ng ngA�y
        /// </summary>
        /// <param name="param">Tham s��` b���ng thA'ng minh</param>
        /// <param name="userId">ID ng����?i dA1ng</param>
        /// <returns>K���t qu��� bA�o cA�o n��ng su���t lA�i xe theo ngA�y</returns>
        Task<DriverProductivityReportByDateResult> GetDriverProductivityReportByDateAsync(
            SmartTableParam param, int userId);
    }

    /// <summary>
    /// D��<ch v��� bA�o cA�o lA�i xe
    /// </summary>
    public class DriverReportService : IDriverReportService
    {
        private readonly IDbConnection _dbConnection;
        private readonly IUserService _userService;

        /// <summary>
        /// Kh��Yi t���o m��Tt th��� hi���n c��a <see cref="DriverReportService"/>.
        /// </summary>
        /// <param name="dbConnection">K���t n��`i c�� s��Y d��_ li���u.</param>
        /// <param name="userService">Service qu���n lA� ng����?i dA1ng.</param>
        public DriverReportService(IDbConnection dbConnection, IUserService userService)
        {

=== Ladaer.BackEnd\Infrastructures\Services\Report\Orders\OrderFinReportService.cs ===
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.StoredProcedureResults;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Microsoft.Data.SqlClient;
using Microsoft.EntityFrameworkCore;
using System.Data;

namespace Ladaer.BackEnd.Infrastructures.Services.Report.Orders
{
    /// <summary>
    /// Giao di���n cho d��<ch v��� bA�o cA�o tA�i chA-nh �`��n hA�ng
    /// </summary>
    public interface IOrderFinReportService
    {
        /// <summary>
        /// L���y th��`ng kA� chuy���n kho���n ngA�n hA�ng theo sale
        /// </summary>
        /// <param name="param">Tham s��` b���ng thA'ng minh</param>
        /// <param name="userId">ID ng����?i dA1ng hi���n t���i</param>
        /// <returns>Danh sA�ch th��`ng kA� chuy���n kho���n theo sale</returns>
        Task<List<BankTransferSummaryBySaleResult>> GetBankTransferSummaryBySaleAsync(
            SmartTableParam param,
            int userId);
    }

    /// <summary>
    /// D��<ch v��� bA�o cA�o tA�i chA-nh �`��n hA�ng
    /// </summary>
    public class OrderFinReportService : IOrderFinReportService
    {
        private readonly IDbConnection _dbConnection;
        private readonly IUserService _userService;

        /// <summary>
        /// Kh��Yi t���o m��Tt th��� hi���n c��a <see cref="OrderFinReportService"/>.
        /// </summary>
        /// <param name="dbConnection">K���t n��`i c�� s��Y d��_ li���u.</param>

=== Ladaer.BackEnd\Infrastructures\Services\Report\Orders\OrderReportService.cs ===
using Dapper;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Reports.Items.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Reports.Results;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using System.Data;
using System.Linq;
using static Microsoft.EntityFrameworkCore.DbLoggerCategory;

namespace Ladaer.BackEnd.Infrastructures.Services.Report.Orders
{
    public interface IOrderReportService
    {
        /// <summary>
        /// L���y th��`ng kA� �`��n hA�ng theo ngA�y t��� stored procedure
        /// </summary>
        /// <param name="param">Tham s��` b���ng thA'ng minh</param>
        /// <param name="userId">ID ng����?i dA1ng</param>
        /// <returns>Danh sA�ch th��`ng kA� �`��n hA�ng theo ngA�y</returns>
        Task<OrderProductionResult> GetOrderProductionAsync(SmartTableParam param, int userId);


        // �?A� chuy���n sang ISaleReportService

        /// <summary>
        /// L���y bA�o cA�o cA'ng n��� theo sale t��� stored procedure
        /// </summary>
        /// <param name="param">Tham s��` b���ng thA'ng minh</param>
        /// <param name="userId">ID ng����?i dA1ng</param>
        /// <returns>Danh sA�ch bA�o cA�o cA'ng n��� theo sale</returns>
        Task<SaleDebtResult> GetSaleDebtReportAsync(SmartTableParam param, int userId);

        /// <summary>
        /// L���y bA�o cA�o s��` l�����ng �`��n vA� doanh s��` theo tuy���n
        /// </summary>
        /// <param name="param">Tham s��` b���ng thA'ng minh</param>
        /// <param name="userId">ID ng����?i dA1ng</param>
        /// <returns>Danh sA�ch bA�o cA�o theo tuy���n vA� tr���ng thA�i</returns>
        Task<OrderReportByRouteResult> GetOrderReportByRouteAsync(SmartTableParam param, int userId);

=== Ladaer.BackEnd\Infrastructures\Services\Report\SaleReports\SaleReportService.cs ===
using System.Data;
using Dapper;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Reports.Items.Orders;
using Ladaer.BackEnd.Infrastructures.DTO.Reports.Results;
using Ladaer.BackEnd.Infrastructures.Services.Identity;

namespace Ladaer.BackEnd.Infrastructures.Services.Report.SaleReports
{
    /// <summary>
    /// Interface d��<ch v��� bA�o cA�o bA�n hA�ng
    /// </summary>
    public interface ISaleReportService
    {
        /// <summary>
        /// L���y th��`ng kA� doanh thu theo sale t��� stored procedure
        /// </summary>
        /// <param name="param">Tham s��` b���ng thA'ng minh</param>
        /// <param name="userId">ID ng����?i dA1ng</param>
        /// <returns>K���t qu��� th��`ng kA� doanh thu</returns>
        Task<SaleRevenueResult> GetSaleRevenueStatisticsAsync(SmartTableParam param, int userId);

        /// <summary>
        /// L���y th��`ng kA� �`��n hA�ng vA� doanh thu theo ngA�y t��� stored procedure
        /// </summary>
        /// <param name="param">Tham s��` b���ng thA'ng minh</param>
        /// <param name="userId">ID ng����?i dA1ng</param>
        /// <returns>Danh sA�ch th��`ng kA� �`��n hA�ng vA� doanh thu theo ngA�y</returns>
        Task<OrderRevenueResult> GetOrderRevenueStatisticsByDateAsync(SmartTableParam param, int userId);

        /// <summary>
        /// L���y th��`ng kA� doanh thu theo ngA�y nh��-n ti��?n t��� stored procedure
        /// </summary>
        /// <param name="param">Tham s��` b���ng thA'ng minh</param>
        /// <param name="userId">ID ng����?i dA1ng</param>
        /// <returns>Danh sA�ch th��`ng kA� doanh thu theo ngA�y nh��-n ti��?n</returns>
        Task<OrderRevenueByCollectionDateResult> GetOrderRevenueByCollectionDateAsync(SmartTableParam param, int userId);

        /// <summary>

=== Ladaer.BackEnd\Infrastructures\Services\Rewards\AutoPenaltyConfigService.cs ===
using Lada.Framework.Data.Domains.Rewards;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Ladaer.BackEnd.Infrastructures.DTO.Profiles;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Rewards;
using Microsoft.EntityFrameworkCore;
using System.Text.Json;

namespace Ladaer.BackEnd.Infrastructures.Services.Rewards
{
    public interface IAutoPenaltyConfigService
    {
        /// <summary>
        /// L���y c���u hA�nh �`ang hi���u l���c
        /// </summary>
        Task<AutoPenaltyConfigModel?> GetCurrentConfig();

        /// <summary>
        /// C��-p nh��-t c���u hA�nh (t���o version m��>i)
        /// </summary>
        Task<BaseResult> UpdateConfig(AutoPenaltyConfigModel model, CurrentUser currentUser);

        /// <summary>
        /// T���m d���ng / M��Y l���i
        /// </summary>
        Task<BaseResult> TogglePause(bool isPaused, string? pauseReason, CurrentUser currentUser);

        /// <summary>
        /// TA�m ki���m danh sA�ch c���u hA�nh
        /// </summary>
        Task<SmartTableResult<AutoPenaltyConfigItem>> Search(SmartTableParam param);

        /// <summary>
        /// L���y chi ti���t c���u hA�nh theo ID
        /// </summary>
        Task<AutoPenaltyConfigModel?> GetById(int id);


=== Ladaer.BackEnd\Infrastructures\Services\Rewards\RewardPenaltyService.cs ===
using Lada.Framework.Data.Domains.Rewards;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Ladaer.BackEnd.Infrastructures.DTO.Profiles;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Rewards;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Rewards;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Rewards
{
    public interface IRewardPenaltyService
    {
        
        Task<SmartTableResult<RewardPenaltyTicketItem>> Search(SmartTableParam param);


        /// <summary>
        /// T���o phi���u th����Yng/ph���t th�� cA'ng
        /// </summary>
        Task<BaseResult> CreateManual(RewardPenaltyTicketModel model, CurrentUser currentUser);

        /// <summary>
        /// Duy���t phi���u
        /// </summary>
        Task<BaseResult> Approve(int id, CurrentUser currentUser);

        /// <summary>
        /// T��� ch��`i phi���u
        /// </summary>
        Task<BaseResult> Reject(int id, CurrentUser currentUser);

        /// <summary>
        /// G���/h��y phi���u (cA3 gi��>i h���n amnesty n���u lA� Auto)
        /// </summary>
        Task<BaseResult> Cancel(int id, string reason, CurrentUser currentUser);

        /// <summary>

=== Ladaer.BackEnd\Infrastructures\Services\Settings\CallPathService.cs ===
using Lada.Framework.Data.Domains.Settings;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Settings;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Settings;
using Ladaer.BackEnd.Infrastructures.DTO;
using Microsoft.EntityFrameworkCore;
using Lada.Framework.Data.Domains;
using Newtonsoft.Json.Linq;
using Lada.Framework.Infrastructures.Helpers;

namespace Ladaer.BackEnd.Infrastructures.Services.Settings
{
    public interface ICallPathService
    {
        /// <summary>
        /// L���y thA'ng tin CallPath theo Id.
        /// </summary>
        /// <param name="id">Id c��a CallPath.</param>
        /// <returns>ThA'ng tin CallPath.</returns>
        Task<CallPathModel> GetByIdAsync(int id);

        /// <summary>
        /// T���o m��>i CallPath.
        /// </summary>
        /// <param name="callPath">ThA'ng tin CallPath c��n t���o.</param>
        /// <returns>K���t qu��� c��a thao tA�c.</returns>
        Task<BaseResult> CreateOrUpdateAsync(CallPathModel callPath);

        /// <summary>
        /// XA3a CallPath.
        /// </summary>
        /// <param name="id">Id c��a CallPath c��n xA3a.</param>
        /// <returns>K���t qu��� c��a thao tA�c.</returns>
        Task<BaseResult> DeleteAsync(int id);

        /// <summary>
        /// TA�m ki���m CallPath theo �`i��?u ki���n l��?c vA� phA�n trang.
        /// </summary>

=== Ladaer.BackEnd\Infrastructures\Services\Settings\CallPathVersionService.cs ===
using Lada.Framework.Data.Domains.Settings;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Settings;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Settings;
using Ladaer.BackEnd.Infrastructures.DTO.Profiles;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json.Linq;
using Lada.Framework.Data.Domains;

namespace Ladaer.BackEnd.Infrastructures.Services.Settings
{
    public interface ICallPathVersionService
    {
        /// <summary>
        /// L���y thA'ng tin CallPathVersion theo Id.
        /// </summary>
        Task<CallPathVersionModel> GetByIdAsync(int id);

        /// <summary>
        /// T���o m��>i ho���c c��-p nh��-t CallPathVersion.
        /// </summary>
        Task<BaseResult> CreateOrUpdateAsync(CallPathVersionModel model);

        /// <summary>
        /// XA3a CallPathVersion.
        /// </summary>
        Task<BaseResult> DeleteAsync(int id);

        /// <summary>
        /// TA�m ki���m CallPathVersion theo �`i��?u ki���n l��?c vA� phA�n trang.
        /// </summary>
        Task<SmartTableResult<CallPathVersionItem>> SearchAsync(SmartTableParam param);

        /// <summary>
        /// L���y t���t c��� CallPathVersion (dA1ng cho dropdown).
        /// </summary>
        Task<List<CallPathVersionItem>> GetAllAsync();
    }

=== Ladaer.BackEnd\Infrastructures\Services\Trucks\TruckActivityService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Trucks;
using Lada.Framework.Data.Domains.Medias;
using Lada.Framework.Data.Domains.Categories;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Trucks;
using Ladaer.BackEnd.Infrastructures.DTO.Models;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Trucks;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Trucks;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Media;
using Lada.Framework.Infrastructures.Services;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Trucks
{
    /// <summary>
    /// Giao di?n cho d?ch v? qu?n ly ho?t d?ng xe t?i.
    /// </summary>
    public interface ITruckActivityService
    {
        /// <summary>
        /// L?y th�ng tin ho?t d?ng xe t?i theo danh s�ch ID.
        /// </summary>
        /// <param name="param">Danh s�ch ID c?a ho?t d?ng xe t?i.</param>
        /// <returns>K?t qu? ch?a th�ng tin ho?t d?ng xe t?i.</returns>
        Task<TruckActivityResult> GetByIds(KeyModels<int> param);

        /// <summary>
        /// T?o m?i ho?c c?p nh?t th�ng tin ho?t d?ng xe t?i.
        /// </summary>
        /// <param name="param">Th�ng tin ho?t d?ng xe t?i.</param>
        /// <returns>K?t qu? c?a thao t�c.</returns>
        Task<TruckActivityResult> CreateOrUpdate(TruckActivityModel param);

        /// <summary>

=== Ladaer.BackEnd\Infrastructures\Services\Trucks\TruckAssetService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Trucks;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Models;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Trucks;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Trucks;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Trucks
{
    /// <summary>
    /// Giao di?n cho d?ch v? qu?n ly t�i s?n xe t?i.
    /// </summary>
    public interface ITruckAssetService
    {
        /// <summary>
        /// L?y th�ng tin t�i s?n xe t?i theo danh s�ch ID.
        /// </summary>
        /// <param name="param">Danh s�ch ID c?a t�i s?n xe t?i.</param>
        /// <returns>K?t qu? ch?a th�ng tin t�i s?n xe t?i.</returns>
        Task<TruckAssetResult> GetByIds(KeyModels<int> param);

        /// <summary>
        /// T?o m?i ho?c c?p nh?t th�ng tin t�i s?n xe t?i.
        /// </summary>
        /// <param name="param">Th�ng tin t�i s?n xe t?i.</param>
        /// <returns>K?t qu? c?a thao t�c.</returns>
        Task<BaseResult> CreateOrUpdate(TruckAssetModel param);

        /// <summary>
        /// X�a th�ng tin t�i s?n xe t?i.
        /// </summary>
        /// <param name="param">Th�ng tin t�i s?n xe t?i.</param>
        /// <returns>K?t qu? c?a thao t�c.</returns>
        Task<BaseResult> Delete(TruckModel param);
    }
    /// <summary>
    /// Tri?n khai d?ch v? qu?n ly t�i s?n xe t?i.

=== Ladaer.BackEnd\Infrastructures\Services\Trucks\TruckService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Categories;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Domains.Medias;
using Lada.Framework.Data.Domains.Trucks;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Trucks;
using Ladaer.BackEnd.Infrastructures.DTO.Models;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Trucks;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Trucks;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Trucks
{
    /// <summary>
    /// Giao di?n cho d?ch v? qu?n ly xe t?i.
    /// </summary>
    public interface ITruckService
    {
        #region Truck Management
        /// <summary>
        /// T?o m?i ho?c c?p nh?t th�ng tin xe t?i.
        /// </summary>
        /// <param name="param">Th�ng tin xe t?i.</param>
        /// <returns>K?t qu? c?a thao t�c.</returns>
        Task<BaseResult> CreateOrUpdate(TruckModel param);

        /// <summary>
        /// L?y danh s�ch media (?nh dang ky, dang ki?m) c?a xe t?i.
        /// </summary>
        /// <param name="truckId">ID xe t?i.</param>
        /// <returns>Danh s�ch media items.</returns>
        Task<List<TruckMediaItem>> GetTruckMediaAsync(int truckId);


=== Ladaer.BackEnd\Infrastructures\Startup\DependencyRegister.cs ===
using Lada.Framework.Data.Repositories;
using Lada.Framework.Infrastructures.AppSettings;
using Lada.Framework.Infrastructures.Extensions;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.AppSettings;
using Ladaer.BackEnd.Infrastructures.Extensions;
using Ladaer.BackEnd.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.Services.Business;
using Ladaer.BackEnd.Infrastructures.Services.Categories;
using Ladaer.BackEnd.Infrastructures.Services.Cms;
using Ladaer.BackEnd.Infrastructures.Services.Crm;
using Ladaer.BackEnd.Infrastructures.Services.DriverApp;
using Ladaer.BackEnd.Infrastructures.Services.ErrorReports;
using Ladaer.BackEnd.Infrastructures.Services.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Finances;
using Ladaer.BackEnd.Infrastructures.Services.Hr;
using Ladaer.BackEnd.Infrastructures.Services.Identity;
using Ladaer.BackEnd.Infrastructures.Services.Monitor;
using Ladaer.BackEnd.Infrastructures.Services.Orders;
using Ladaer.BackEnd.Infrastructures.Services.Orders.Exports;
using Ladaer.BackEnd.Infrastructures.Services.Report.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Report.OperationReports;
using Ladaer.BackEnd.Infrastructures.Services.Report.Orders;
using Ladaer.BackEnd.Infrastructures.Services.Report.SaleReports;
using Ladaer.BackEnd.Infrastructures.Services.Settings;
using Ladaer.BackEnd.Infrastructures.Services.Trucks;
using Ladaer.BackEnd.Infrastructures.Services.Premises;
using Ladaer.BackEnd.Infrastructures.Services.OrderBusiness;

namespace Ladaer.BackEnd.Infrastructures.Startup
{
    /// <summary>
    /// L��>p t�cnh �`��� �`��ng kA� cA�c ph��� thu��Tc cho ��cng d���ng.
    /// </summary>
    public static partial class DependencyRegister
    {
        /// <summary>
        /// �?��ng kA� cA�c ph��� thu��Tc cho ��cng d���ng.
        /// </summary>
        /// <param name="services">B��T s��u t��-p d��<ch v���.</param>

=== Ladaer.BackEnd\Infrastructures\Startup\GeneralRegister.cs ===
using AutoMapper;
using Hangfire;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Mappings.DbContexts;
using Ladaer.BackEnd.Infrastructures.AppSettings;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.Services;
using Microsoft.AspNetCore.Identity;
using Microsoft.Data.SqlClient;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using System.Data;

namespace Ladaer.BackEnd.Infrastructures.Startup
{
    /// <summary>
    /// L��>p m��Y r��Tng �`��� �`��ng kA� cA�c d��<ch v��� vA� c���u hA�nh ��cng d���ng.
    /// </summary>
    public static class GeneralRegister
    {
        private static readonly string policyName = "default";

        /// <summary>
        /// �?��ng kA� cA�c d��<ch v��� chung.
        /// </summary>
        /// <param name="services">�?��`i t�����ng IServiceCollection.</param>
        /// <param name="Configuration">�?��`i t�����ng IConfiguration.</param>
        public static void RegisterGeneralServices(this IServiceCollection services, IConfiguration Configuration)
        {
            services.AddControllers()
                .AddNewtonsoftJson(x =>
                {
                    x.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
                    x.SerializerSettings.ContractResolver = new DefaultContractResolver();
                });

            string connectionString = Configuration.GetConnectionString("LadaConnection");

            services.AddDbContext<LadaDbContext>(options =>

=== Ladaer.BackEnd\Infrastructures\Startup\SecurityRegister.cs ===
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Mappings.DbContexts;
using Lada.Framework.Infrastructures.AppSettings;
using Ladaer.BackEnd.Infrastructures.AppSettings;
using Ladaer.BackEnd.Infrastructures.Authorization;
using Ladaer.BackEnd.Infrastructures.IdentityConfigs;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore.Metadata.Internal;
using Microsoft.IdentityModel.Tokens;
using System.Security.Claims;
using System.Text;

namespace Ladaer.BackEnd.Infrastructures.Startup
{
    /// <summary>
    /// L?p m? r?ng d? dang ky c�c d?ch v? b?o m?t.
    /// </summary>
    public static class SecurityRegister
    {
        /// <summary>
        /// Dang ky c�c d?ch v? b?o m?t.
        /// </summary>
        /// <param name="services">D?i tu?ng IServiceCollection.</param>
        /// <param name="configuration">D?i tu?ng IConfiguration.</param>
        public static void RegisterSecurityServices(this IServiceCollection services, IConfiguration configuration)
        {
            var autConfig = configuration.GetSection("AutConfig").Get<AutConfig>();

            var jwtSettings = configuration.GetSection("JwtSettings").Get<JwtSettings>();
            var key = Encoding.UTF8.GetBytes(jwtSettings.Secret);


            services.AddIdentity<User, Role>(
                options =>
                {
                    #region Password settings
                    // Password settings
                    options.Password.RequireDigit = false;

=== Ladaer.BackEnd\Infrastructures\Startup\StartupHostedService.cs ===
using Ladaer.BackEnd.Infrastructures.Services;

namespace Ladaer.BackEnd.Infrastructures.Startup
{
    /// <summary>
    /// D?ch v? kh?i d?ng du?c luu tr?.
    /// </summary>
    public class StartupHostedService : IHostedService
    {
        private readonly IServiceProvider _serviceProvider;

        /// <summary>
        /// Kh?i t?o m?t th? hi?n c?a <see cref="StartupHostedService"/>.
        /// </summary>
        /// <param name="serviceProvider">D?i tu?ng IServiceProvider.</param>
        public StartupHostedService(IServiceProvider serviceProvider)
        {
            _serviceProvider = serviceProvider;
        }

        /// <summary>
        /// Phuong th?c du?c g?i khi d?ch v? kh?i d?ng.
        /// </summary>
        /// <param name="cancellationToken">D?i tu?ng CancellationToken.</param>
        /// <returns>Nhi?m v? kh�ng d?ng b?.</returns>
        public async Task StartAsync(CancellationToken cancellationToken)
        {
            using (var scope = _serviceProvider.CreateScope())
            {
                var appConfigService = scope.ServiceProvider.GetRequiredService<IAppConfigService>();
                await appConfigService.LoadConfigsToCacheAsync();
            }
        }

        /// <summary>
        /// Phuong th?c du?c g?i khi d?ch v? d?ng.
        /// </summary>
        /// <param name="cancellationToken">D?i tu?ng CancellationToken.</param>
        /// <returns>Nhi?m v? ho�n th�nh.</returns>
        public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;

=== Ladaer.BackEnd\Infrastructures\Startup\SwaggerRegister.cs ===
using Lada.Framework.Swaggers;
using Microsoft.OpenApi.Models;
using System.Reflection;

namespace Ladaer.BackEnd.Infrastructures.Startup
{
    /// <summary>
    /// L?p m? r?ng d? dang ky c�c d?ch v? v� middleware c?a Swagger.
    /// </summary>
    public static class SwaggerRegister
    {
        /// <summary>
        /// Dang ky c�c d?ch v? c?a Swagger.
        /// </summary>
        /// <param name="services">D?i tu?ng IServiceCollection.</param>
        public static void RegisterSwaggerServices(this IServiceCollection services)
        {
            var jwtScheme = new OpenApiSecurityScheme
            {
                Type = SecuritySchemeType.Http,
                Scheme = "bearer",
                BearerFormat = "JWT",
                In = ParameterLocation.Header,
                Name = "Authorization",
                Description = "Ch? d�n token (kh�ng c?n 'Bearer ').",
                Reference = new OpenApiReference { Type = ReferenceType.SecurityScheme, Id = "Bearer" }
            };


            services.AddSwaggerGen(c =>
            {
                c.SwaggerDoc("v1", new OpenApiInfo { Title = "LADAER API", Version = "v1" });

                // Set the comments path for the Swagger JSON and UI.
                var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
                var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
                c.IncludeXmlComments(xmlPath);
                c.AddSecurityDefinition("Bearer", jwtScheme);
                c.AddSecurityRequirement(new OpenApiSecurityRequirement
                {

=== ladaexpress.vn\appsettings.Development.json ===
{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  }
}

=== ladaexpress.vn\appsettings.json ===
{
  "ConnectionStrings": {
    "LadaConnection": "Server=THANGTQ1009\\SQL19;Database=Ladaer2;User Id=ladadbm;Password=0gcHVHvCyuZTbKw;MultipleActiveResultSets=true;TrustServerCertificate=true"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "SeoSettings": {
    "BaseUrl": "https://ladaexpress.vn",
    "SiteName": "LADA Express",
    "DefaultImage": "/images/logo.svg",
    "DefaultTitle": "LADA Express - D��<ch v��� g��-i hA�ng nhanh chA3ng, uy tA-n",
    "DefaultDescription": "LADA Express cung c���p d��<ch v��� g��-i hA�ng nhanh chA3ng, uy tA-n trA�n toA�n qu��`c. Cam k���t giao hA�ng �`A�ng h��1n, giA� c��� h���p lA�.",
    "DefaultKeywords": "g��-i hA�ng, chuy���n phA�t nhanh, v��-n chuy���n, LADA Express, giao hA�ng",
    "TwitterHandle": "@ladaexpress",
    "FacebookPageId": "ladaexpress"
  },
  "Media": {
    "RootPath": "C:\\uploads\\",
    "Domain": "https://ladaexpress.vn/",
    "MaxImageWidth": 1200,
    "ImageQuality": 80,
    "DefaultImageFormat": "WebP",
    "OutputFolder": "optimized",
    "TempPath": "C:\\temp\\",
    "AutoSaveToDatabase": false
  }
}

=== ladaexpress.vn\Program.cs ===
using ladaexpress.vn.Infrastructures.Startup;
using ladaexpress.vn.Infrastructures.StartupRegisters;
var builder = WebApplication.CreateBuilder(args);



builder.Services.RegisterGeneralServices(builder.Configuration);
builder.Services.RegisterDependency(builder.Configuration);

builder.Services.AddHostedService<StartupHostedService>();

var app = builder.Build();


app.ConfigAndRunApp();

=== ladaexpress.vn\Controllers\CandidateController.cs ===
using Lada.Framework.DTO;
using Lada.Framework.Infrastructures.Helpers;
using ladaexpress.vn.Infrastructures.DTO.Models.Hr;
using ladaexpress.vn.Infrastructures.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using System.Linq;

namespace ladaexpress.vn.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class CandidateController : ControllerBase
    {
        private readonly ICandidateService _candidateService;

        public CandidateController(ICandidateService candidateService)
        {
            _candidateService = candidateService;
        }


        [HttpPost("Apply")]
        public async Task<IActionResult> Apply([FromForm] ApplyModel applyModel)
        {
            var result = new BaseResult();
            if (!ModelState.IsValid)
            {
                //IEnumerable<ModelError> allErrors = ModelState.Values.SelectMany(v => v.Errors);
                var allErrors = ModelState.Values.SelectMany(v => v.Errors.Select(b => b.ErrorMessage)).ToList();
                result.Result = Result.Failed;
                result.Message = string.Join("\n", allErrors);
                return Ok(result);
            }
            result = await _candidateService.Apply(applyModel);
            return Ok(result);
        }


=== ladaexpress.vn\Controllers\CategoryController.cs ===
using ladaexpress.vn.Infrastructures.Services;
using ladaexpress.vn.Infrastructures.Services.Seo;
using Microsoft.AspNetCore.Mvc;

namespace ladaexpress.vn.Controllers
{
    public class CategoryController : Controller
    {
        private readonly ICategoryService _categoryService;
        private readonly ISeoService _seoService;
        private readonly IStructuredDataService _structuredDataService;

        public CategoryController(
            ICategoryService categoryService,
            ISeoService seoService,
            IStructuredDataService structuredDataService)
        {
            _categoryService = categoryService;
            _seoService = seoService;
            _structuredDataService = structuredDataService;
        }

        public async Task<IActionResult> Detail(int id)
        {
            var model = await _categoryService.PrepareCategoryDetail(id);
            if (model.Id > 0)
            {
                // Generate SEO data for category page
                var seoData = await _seoService.GetCategorySeoAsync(
                    categoryId: model.Id,
                    name: model.Name,
                    description: model.Description,
                    url: $"/danh-muc/{id}" // Can be improved with slug if available
                );

                // Generate structured data for collection page
                var structuredData = await _structuredDataService.GetCollectionPageStructuredDataAsync(
                    categoryId: model.Id,
                    name: model.Name,
                    description: model.Description,

=== ladaexpress.vn\Controllers\CompanyController.cs ===
using Microsoft.AspNetCore.Mvc;

namespace ladaexpress.vn.Controllers
{
    public class CompanyController : Controller
    {
        public IActionResult AboutUs()
        {
            return View();
        }
    }
}

=== ladaexpress.vn\Controllers\HomeController.cs ===
using ladaexpress.vn.Infrastructures.Services;
using ladaexpress.vn.Infrastructures.Services.Seo;
using ladaexpress.vn.Models;
using Microsoft.AspNetCore.Mvc;
using System.Diagnostics;

namespace ladaexpress.vn.Controllers
{
    public class HomeController : Controller
    {
        private readonly IHomeService _homeService;
        private readonly ISeoService _seoService;
        private readonly IStructuredDataService _structuredDataService;

        public HomeController(IHomeService homeService, ISeoService seoService, IStructuredDataService structuredDataService)
        {
            _homeService = homeService;
            _seoService = seoService;
            _structuredDataService = structuredDataService;
        }

        public async Task<IActionResult> Index()
        {
            var model = await _homeService.PrepareHomeModel();

            // Set up SEO data for home page
            var seoData = await _seoService.GetHomePageSeoAsync();
            ViewData["SeoData"] = seoData;

            // Set up structured data
            var organizationSchema = _structuredDataService.GenerateOrganizationSchema();
            var websiteSchema = _structuredDataService.GenerateWebsiteSchema();
            var breadcrumbSchema = _structuredDataService.GenerateBreadcrumbSchema(seoData.Breadcrumbs);

            var combinedSchema = _structuredDataService.CombineSchemas(organizationSchema, websiteSchema, breadcrumbSchema);
            ViewData["StructuredData"] = combinedSchema;

            return View(model);
        }


=== ladaexpress.vn\Controllers\JobPostController.cs ===
using ladaexpress.vn.Infrastructures.Services;
using ladaexpress.vn.Infrastructures.Services.Seo;
using ladaexpress.vn.Infrastructures.DTO.Models.Seo;
using Microsoft.AspNetCore.Mvc;

namespace ladaexpress.vn.Controllers
{
    public class JobPostController : Controller
    {
        private readonly IJobService _jobPostService;
        private readonly ISeoService _seoService;
        private readonly IStructuredDataService _structuredDataService;
        private readonly IBreadcrumbService _breadcrumbService;
        private readonly IContentOptimizationService _contentOptimizationService;

        public JobPostController(
            IJobService jobPostService,
            ISeoService seoService,
            IStructuredDataService structuredDataService,
            IBreadcrumbService breadcrumbService,
            IContentOptimizationService contentOptimizationService)
        {
            _jobPostService = jobPostService;
            _seoService = seoService;
            _structuredDataService = structuredDataService;
            _breadcrumbService = breadcrumbService;
            _contentOptimizationService = contentOptimizationService;
        }



        public async Task<IActionResult> Index()
        {
            var model = await _jobPostService.PrepareJobListModel();

            // Generate SEO data for job listing page
            var seoData = await _seoService.GetJobPostIndexSeoAsync();

            // Generate structured data for job listing page
            var structuredData = await _structuredDataService.GetCollectionPageStructuredDataAsync(

=== ladaexpress.vn\Controllers\LeadController.cs ===
using Lada.Framework.DTO;
using ladaexpress.vn.Infrastructures.DTO.Models.Service;
using ladaexpress.vn.Infrastructures.DTO.Results.Crm;
using ladaexpress.vn.Infrastructures.Services;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;

namespace ladaexpress.vn.Controllers
{
    public class LeadController : Controller
    {
        private readonly ILeadService _leadService;

        public LeadController(ILeadService leadService)
        {
            _leadService = leadService;
        }

        public IActionResult Index()
        {
            return View();
        }

        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<JsonResult> SendAsync(LeadModel model, string returnUrl = null)
        {
            var result = new LeadResult();
            if (!ModelState.IsValid)
            {
                var errors = ModelState
                                       .Where(x => x.Value.Errors.Count > 0)
                                       .ToDictionary(
                                           kvp => kvp.Key,
                                           kvp => kvp.Value.Errors[0].ErrorMessage
                                       );

                return Json(new { success = false, errors });
            }


=== ladaexpress.vn\Controllers\PostController.cs ===
using ladaexpress.vn.Infrastructures.Services;
using ladaexpress.vn.Infrastructures.Services.Seo;
using Microsoft.AspNetCore.Mvc;

namespace ladaexpress.vn.Controllers
{
    public class PostController : Controller
    {
        private readonly IPostService _postService;
        private readonly ISeoService _seoService;
        private readonly IStructuredDataService _structuredDataService;
        private readonly IContentOptimizationService _contentOptimizationService;

        public PostController(
            IPostService postService,
            ISeoService seoService,
            IStructuredDataService structuredDataService,
            IContentOptimizationService contentOptimizationService)
        {
            _postService = postService;
            _seoService = seoService;
            _structuredDataService = structuredDataService;
            _contentOptimizationService = contentOptimizationService;
        }

        public async Task<IActionResult> Index()
        {
            var model = await _postService.PreparePostIndex();

            // Generate SEO data for news listing page
            var seoData = await _seoService.GetCategorySeoAsync(
                categoryId: 0, // News listing page doesn't have specific category
                name: "Tin t?c",
                description: "C?p nh?t tin t?c m?i nh?t v? d?ch v? v?n chuy?n, logistics v� xu hu?ng ng�nh t? LADA Express.",
                url: "/tin-tuc"
            );

            // Generate structured data for news collection page
            var structuredData = await _structuredDataService.GetCollectionPageStructuredDataAsync(
                categoryId: 0,

=== ladaexpress.vn\Controllers\PrivacyController.cs ===
using Microsoft.AspNetCore.Mvc;

namespace ladaexpress.vn.Controllers
{
    public class PrivacyController : Controller
    {
        public IActionResult ConditionOfUse()
        {
            return View();
        }

        public IActionResult SecurityPrivacy()
        {
            return View();
        }

    }
}

=== ladaexpress.vn\Controllers\ProductController.cs ===
using Lada.Framework.Data.Enums;
using ladaexpress.vn.Infrastructures.Services;
using ladaexpress.vn.Infrastructures.Services.Seo;
using Microsoft.AspNetCore.Mvc;

namespace ladaexpress.vn.Controllers
{
    public class ProductController : Controller
    {
        private readonly IProductService _productService;
        private readonly ISeoService _seoService;
        private readonly IStructuredDataService _structuredDataService;
        private readonly IContentOptimizationService _contentOptimizationService;

        public ProductController(
            IProductService productService,
            ISeoService seoService,
            IStructuredDataService structuredDataService,
            IContentOptimizationService contentOptimizationService)
        {
            _productService = productService;
            _seoService = seoService;
            _structuredDataService = structuredDataService;
            _contentOptimizationService = contentOptimizationService;
        }


        public async Task<IActionResult> Index()
        {
            var model = await _productService.PrepareProductIndex();

            // Generate SEO data for products listing page
            var seoData = await _seoService.GetProductIndexSeoAsync();

            // Generate structured data for collection page
            var structuredData = await _structuredDataService.GetCollectionPageStructuredDataAsync(
                categoryId: 0,
                name: "D?ch v? LADA Express",
                description: "Danh s�ch c�c d?ch v? v?n chuy?n c?a LADA Express",
                url: "/dich-vu",

=== ladaexpress.vn\Controllers\ServiceController.cs ===
using ladaexpress.vn.Infrastructures.Services;
using Microsoft.AspNetCore.Mvc;

namespace ladaexpress.vn.Controllers
{
    public class ServiceController : Controller
    {
        private readonly IServiceService _serviceService;

        public ServiceController(IServiceService serviceService)
        {
            _serviceService = serviceService;
        }

        public async Task<IActionResult> Index()
        {
            var model = await _serviceService.PrepareServiceModel();
            return View(model);
        }
    }
}

=== ladaexpress.vn\Controllers\SharedController.cs ===
using Microsoft.AspNetCore.Mvc;

namespace ladaexpress.vn.Controllers
{
    public class SharedController : Controller
    {
        public IActionResult Index()
        {
            return View();
        }
    }
}

=== ladaexpress.vn\Controllers\StatusController.cs ===
using Microsoft.AspNetCore.Mvc;

namespace ladaexpress.vn.Controllers
{
    public class StatusController : Controller
    {
        public IActionResult NotFound()
        {
            return View();
        }

        [Route("/Status/HandleError/{code:int}")]
        public IActionResult HandleError(int code)
        {
            switch (code)
            {
                case 404:
                    return RedirectToAction("NotFound");
                default:
                    break;
            }
            ViewData["ErrorMessage"] = $"Error occurred. The ErrorCode is: {code}";
            return View();
        }
    }
}

=== ladaexpress.vn\Controllers\TagController.cs ===
using ladaexpress.vn.Infrastructures.Services;
using Microsoft.AspNetCore.Mvc;

namespace ladaexpress.vn.Controllers
{
    public class TagController : Controller
    {
        private readonly ITagService _tagService;

        public TagController(ITagService tagService)
        {
            _tagService = tagService;
        }

        public async Task<IActionResult> Index()
        {
            return View();


            //var model = await _tagService.PrepareTagDetail();
            //if (model.Id > 0)
            //{
            //    return View(model);
            //}
            //else
            //{
            //    return NotFound();
            //}
        }

        public async Task<IActionResult> Detail(int id)
        {
            var model = await _tagService.PrepareTagDetail(id);
            if (model.Id > 0)
            {
                return View(model);
            }
            else
            {
                return NotFound();

=== ladaexpress.vn\Controllers\TopicController.cs ===
using ladaexpress.vn.Infrastructures.Services;
using Microsoft.AspNetCore.Mvc;

namespace ladaexpress.vn.Controllers
{
    public class TopicController : Controller
    {
        private readonly ITopicService _topicService;

        public TopicController(ITopicService topicService)
        {
            _topicService = topicService;
        }

        public async Task<IActionResult> Detail(int id)
        {
            var model = await _topicService.PrepareTopicDetail(id);
            if (model.Id > 0)
            {
                return View(model);
            }
            else
            {
                return NotFound();
            }

        }
    }
}

=== ladaexpress.vn\Controllers\UrlRecordController.cs ===
using ladaexpress.vn.Infrastructures.Services;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace ladaexpress.vn.Controllers
{
    public class UrlRecordController : Controller
    {
        private readonly IUrlRecordService _urlRecordService;
        private readonly ISitemapService _sitemapService;

        public UrlRecordController(IUrlRecordService urlRecordService, ISitemapService sitemapService)
        {
            _urlRecordService = urlRecordService;
            _sitemapService = sitemapService;
        }

        [HttpGet("SiteMapXml")]
        public async Task<IActionResult> SiteMapXml()
        {
            // Use the new SitemapService with image support
            var siteMap = await _sitemapService.GenerateSitemapXmlAsync();

            // Set proper headers to prevent script injection
            Response.Headers["Cache-Control"] = "public, max-age=3600";
            Response.Headers["X-Content-Type-Options"] = "nosniff";

            return Content(siteMap, "application/xml; charset=utf-8");
        }

        [HttpGet("Robot")]
        public async Task<IActionResult> Robot()
        {
            var robots = await _urlRecordService.GenerateRobots();
            return Content(robots, "text/plain");
        }

    }
}

=== ladaexpress.vn\docs\SitemapService_Test_Results.md ===
# SitemapService Refactoring Test Results

## NgA�y th���c hi���n: 2025-08-16

## M���c tiA�u

Refactor SitemapService �`��� l���y d��_ li���u t��� b���ng UrlRecord thay vA� t��� cA�c b���ng th���c th��� (Post, Product, Category, Tag).

## Thay �`��i �`A� th���c hi���n

### 1. Thay �`��i Dependencies

- **Tr����>c:** Inject 4 repositories: `IRepository<Product>`, `IRepository<Post>`, `IRepository<Category>`, `IRepository<Tag>`
- **Sau:** Ch��% inject 1 repository: `IRepository<UrlRecord>`

### 2. ThA�m Helper Method

```csharp
private string ConvertFrequencyToString(SitemapFrequency frequency)
{
    return frequency switch
    {
        SitemapFrequency.Never => "never",
        SitemapFrequency.Yearly => "yearly",
        SitemapFrequency.Monthly => "monthly",
        SitemapFrequency.Weekly => "weekly",
        SitemapFrequency.Daily => "daily",
        SitemapFrequency.Hourly => "hourly",
        SitemapFrequency.Always => "always",
        _ => "monthly"
    };
}
```

### 3. S��-a �`��i cA�c ph����ng th��cc l���y d��_ li���u

#### GetStaticPagesSitemapAsync()

- **Tr����>c:** Hardcode danh sA�ch static pages
- **Sau:** Query t��� UrlRecord v��>i �`i��?u ki���n t���t c��� foreign keys = null

=== ladaexpress.vn\Infrastructures\DTO\Models\Service\LeadModel.cs ===
using Microsoft.AspNetCore.Mvc.ModelBinding;
using System.ComponentModel.DataAnnotations;

namespace ladaexpress.vn.Infrastructures.DTO.Models.Service
{
    [Serializable]
    public class LeadModel
    {
        [Required(ErrorMessage = "Vui l�ng nh?p h? t�n")]
        [Display(Name = "H? v� t�n")]
        [StringLength(100, MinimumLength = 2, ErrorMessage = "H? t�n ph?i c� t? 2 d?n 100 ky t?")]
        public string FullName { get; set; }

        [Required(ErrorMessage = "Vui l�ng nh?p s? di?n tho?i")]
        [Display(Name = "S? di?n tho?i")]
        [RegularExpression(@"^(0[0-9]{9,10})$", ErrorMessage = "S? di?n tho?i kh�ng h?p l? (ph?i b?t d?u b?ng s? 0 v� c� 10-11 s?)")]
        public string PhoneNumber { get; set; }

        [Required(ErrorMessage = "Vui l�ng nh?p n?i dung y�u c?u")]
        [Display(Name = "N?i dung y�u c?u")]
        [StringLength(1000, MinimumLength = 10, ErrorMessage = "N?i dung y�u c?u ph?i c� t? 10 d?n 1000 ky t?")]
        [DataType(DataType.MultilineText)]
        public string Message { get; set; }


        public string SourcePath { get; set; } = string.Empty;
    }
}

=== ladaexpress.vn\Infrastructures\DTO\Models\Service\ServiceModel.cs ===
using ladaexpress.vn.Infrastructures.DTO.Models.Post.Index.Childs;

namespace ladaexpress.vn.Infrastructures.DTO.Models.Service
{
    public class ServiceModel
    {
        public ServiceModel()
        {
            LatestPosts = new List<PostItem>();
        }

        /// <summary>
        /// C�c b�i vi?t m?i nh?t
        /// </summary>
        public List<PostItem> LatestPosts { get; set; }
    }
}

=== ladaexpress.vn\Infrastructures\Extensions\ServiceCollectionExtensions.cs ===
using ladaexpress.vn.Infrastructures.Startup;

namespace Microsoft.Extensions.DependencyInjection
{
    public static class ServiceCollectionExtensions
    {
        public static IServiceCollection AddStartupTasks(this IServiceCollection services)
        {
            services.AddTransient<ScriptConfigStartupTask>();
            services.AddTransient<IStartupTask, ScriptConfigStartupTask>();
            return services;
        }
    }
}

=== ladaexpress.vn\Infrastructures\Services\AppConfigService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Repositories;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Memory;

namespace ladaexpress.vn.Infrastructures.Services
{
    /// <summary>
    /// Implementation c��a AppConfigService cho ladaexpress.vn
    /// </summary>
    public class AppConfigService : IAppConfigService
    {
        private readonly IRepository<AppConfig> _appConfigRepository;
        private readonly IMemoryCache _memoryCache;
        private readonly string _cacheKeyPrefix = "WebAppConfig_";
        private readonly ILogger<AppConfigService> _logger;

        public AppConfigService(
            IRepository<AppConfig> appConfigRepository,
            IMemoryCache memoryCache,
            ILogger<AppConfigService> logger)
        {
            _appConfigRepository = appConfigRepository;
            _memoryCache = memoryCache;
            _logger = logger;
        }

        public async Task<string> GetConfigValueAsync(string key)
        {
            try
            {
                var cacheKey = $"{_cacheKeyPrefix}{key}";

                if (!_memoryCache.TryGetValue(cacheKey, out string? value))
                {
                    var config = await _appConfigRepository.Query()
                        .FirstOrDefaultAsync(c => c.Key == key);

                    if (config != null)
                    {

=== ladaexpress.vn\Infrastructures\Services\BreadcrumbService.cs ===
using ladaexpress.vn.Infrastructures.DTO.Models.Seo;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;

namespace ladaexpress.vn.Infrastructures.Services
{
    /// <summary>
    /// Implementation c��a IBreadcrumbService v��>i cache support
    /// </summary>
    public class BreadcrumbService : IBreadcrumbService
    {
        private readonly IAppConfigService _appConfigService;
        private readonly IMemoryCache _memoryCache;
        private readonly IConfiguration _configuration;
        private readonly ILogger<BreadcrumbService> _logger;
        private readonly string _baseUrl;
        private readonly string _cacheKeyPrefix = "Breadcrumb_";

        public BreadcrumbService(
            IAppConfigService appConfigService,
            IMemoryCache memoryCache,
            IConfiguration configuration,
            ILogger<BreadcrumbService> logger)
        {
            _appConfigService = appConfigService;
            _memoryCache = memoryCache;
            _configuration = configuration;
            _logger = logger;
            _baseUrl = _configuration["SeoSettings:BaseUrl"] ?? "https://ladaexpress.vn";
        }

        public async Task<List<BreadcrumbItem>> GetHomeBreadcrumbsAsync()
        {
            var cacheKey = $"{_cacheKeyPrefix}Home";

            if (_memoryCache.TryGetValue(cacheKey, out List<BreadcrumbItem>? cached) && cached != null)
            {
                return cached;
            }

=== ladaexpress.vn\Infrastructures\Services\CandidateService.cs ===
using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.Data.Domains.Hr;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures.Services;
using ladaexpress.vn.Infrastructures.DTO;
using ladaexpress.vn.Infrastructures.DTO.Models.Hr;
using ladaexpress.vn.Infrastructures.DTO.Results.Hr;
using Microsoft.EntityFrameworkCore;
using System;
using System.Threading.Tasks;
namespace ladaexpress.vn.Infrastructures.Services
{
    public interface ICandidateService
    {
        Task<ApplyResult> Apply(ApplyModel mode);
    }

    public class CandidateService : ICandidateService
    {
        private readonly IRepository<Candidate> _candidateRepository;
        private readonly ICvUploadService _cvUploadService;
        public CandidateService(IRepository<Candidate> candidateRepository, ICvUploadService cvUploadService)
        {
            _candidateRepository = candidateRepository;
            _cvUploadService = cvUploadService;
        }

        public async Task<ApplyResult> Apply(ApplyModel model)
        {
            var result = new ApplyResult();

            try
            {
                // Ki?m tra ?ng tuy?n tr�ng l?p (c�ng JobId v� PhoneNumber)
                var existingApplication = await _candidateRepository.Query()
                    .Include(c => c.Job)
                    .FirstOrDefaultAsync(c => c.JobId == model.JobPostId && c.PhoneNumber == model.PhoneNumber);

=== ladaexpress.vn\Infrastructures\Services\CategoryService.cs ===
using Dapper;
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.Infrastructures.Helpers;
using ladaexpress.vn.Infrastructures.DTO;
using ladaexpress.vn.Infrastructures.DTO.Models.Categories;
using ladaexpress.vn.Infrastructures.DTO.Models.Post.Index.Childs;
using ladaexpress.vn.Infrastructures.DTO.Models.Product.Index.Childs;
using Microsoft.EntityFrameworkCore;
using System.Data;
using System.Data.Common;

namespace ladaexpress.vn.Infrastructures.Services
{
    public interface ICategoryService
    {
        Task<CategoryDetailModel> PrepareCategoryDetail(int id);
    }
    public class CategoryService : ICategoryService
    {
        private readonly IRepository<Category> _categoryRepository;
        private readonly IDbConnection _dbConnection;

        public CategoryService(IRepository<Category> categoryRepository, IDbConnection dbConnection)
        {
            _categoryRepository = categoryRepository;
            _dbConnection = dbConnection;
        }

        public async Task<CategoryDetailModel> PrepareCategoryDetail(int id)
        {
            var model = new CategoryDetailModel();
            var currentTime = DateTimeHelper.CurrentTime();

            var category = await _categoryRepository.Query().FirstOrDefaultAsync(c => c.Id == id);

            if (category != null && category.Id > 0)
            {
                model.ContentType = category.ContentType;

=== ladaexpress.vn\Infrastructures\Services\ContentOptimizationService.cs ===
using ladaexpress.vn.Infrastructures.DTO.Models.Seo;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using System.Text.RegularExpressions;
using System.Text;
using System.Globalization;

namespace ladaexpress.vn.Infrastructures.Services
{
    /// <summary>
    /// Implementation c��a IContentOptimizationService
    /// </summary>
    public class ContentOptimizationService : IContentOptimizationService
    {
        private readonly IAppConfigService _appConfigService;
        private readonly IMemoryCache _memoryCache;
        private readonly IConfiguration _configuration;
        private readonly ILogger<ContentOptimizationService> _logger;
        private readonly string _cacheKeyPrefix = "ContentOpt_";

        // Common Vietnamese stop words
        private readonly HashSet<string> _vietnameseStopWords = new HashSet<string>
        {
            "vA�", "c��a", "cA3", "lA�", "�`�����c", "cA�c", "cho", "trong", "v��>i", "v��?", "t���", "�`���", "khi", "khA'ng", "nA�y", "�`A�", "s���", "c�cng", "nh��", "m��Tt", "nh��_ng", "nhi��?u", "hay", "ho���c", "nh��ng", "mA�", "n���u", "thA�", "vA�", "do", "nA�n", "r��"i", "�`A�y", "�`A3", "t���i", "theo", "sau", "tr����>c", "gi��_a", "d����>i", "trA�n", "ngoA�i", "trong", "bA�n", "c���nh"
        };

        public ContentOptimizationService(
            IAppConfigService appConfigService,
            IMemoryCache memoryCache,
            IConfiguration configuration,
            ILogger<ContentOptimizationService> logger)
        {
            _appConfigService = appConfigService;
            _memoryCache = memoryCache;
            _configuration = configuration;
            _logger = logger;
        }

        public async Task<string> GenerateOptimizedTitleAsync(string baseTitle, string contentType, string? keywords = null)

=== ladaexpress.vn\Infrastructures\Services\HomeService.cs ===
using Dapper;
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.Data.Repositories;
using ladaexpress.vn.Infrastructures.DTO.Models.Home;
using ladaexpress.vn.Infrastructures.DTO.Models.Post.Index.Childs;
using System.Data;

namespace ladaexpress.vn.Infrastructures.Services
{
    public interface IHomeService
    {
        /// <summary>
        /// Home Model
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        Task<HomeModel> PrepareHomeModel();


    }

    public class HomeService : IHomeService
    {
        private readonly IRepository<Post> _postRepository;
        private readonly IDbConnection _dbConnection;

        public HomeService(IRepository<Post> postRepository, IRepository<UrlRecord> urlRecordRepository,
            IRepository<Category> categoryRepository, IDbConnection dbConnection)
        {
            _postRepository = postRepository;
            _dbConnection = dbConnection;
        }


        public async Task<HomeModel> PrepareHomeModel()
        {
            var model = new HomeModel();
            try
            {
                model.LatestPosts = (await _dbConnection.QueryAsync<PostItem>("Home_GetLatestPosts", commandType: CommandType.StoredProcedure)).ToList();

=== ladaexpress.vn\Infrastructures\Services\IAppConfigService.cs ===
using Lada.Framework.Data.Domains;

namespace ladaexpress.vn.Infrastructures.Services
{
    /// <summary>
    /// Interface cho service qu���n lA� c���u hA�nh ��cng d���ng ladaexpress.vn
    /// </summary>
    public interface IAppConfigService
    {
        /// <summary>
        /// L���y giA� tr��< c���u hA�nh theo key
        /// </summary>
        /// <param name="key">Key c���u hA�nh</param>
        /// <returns>GiA� tr��< c���u hA�nh</returns>
        Task<string> GetConfigValueAsync(string key);

        /// <summary>
        /// L���y giA� tr��< c���u hA�nh theo key v��>i giA� tr��< m���c �`��<nh
        /// </summary>
        /// <param name="key">Key c���u hA�nh</param>
        /// <param name="defaultValue">GiA� tr��< m���c �`��<nh n���u khA'ng tA�m th���y</param>
        /// <returns>GiA� tr��< c���u hA�nh ho���c giA� tr��< m���c �`��<nh</returns>
        Task<string> GetConfigValueAsync(string key, string defaultValue);

        /// <summary>
        /// Load t���t c��� configs vA�o cache
        /// </summary>
        /// <returns></returns>
        Task LoadConfigsToCacheAsync();

        /// <summary>
        /// Reload config cache
        /// </summary>
        /// <returns></returns>
        Task ReloadConfigCacheAsync();

        /// <summary>
        /// Invalidate cache cho m��Tt key c��� th���
        /// </summary>
        /// <param name="key">Key c��n xA3a cache</param>

=== ladaexpress.vn\Infrastructures\Services\IBreadcrumbService.cs ===
using ladaexpress.vn.Infrastructures.DTO.Models.Seo;

namespace ladaexpress.vn.Infrastructures.Services
{
    /// <summary>
    /// Service chuyA�n d���ng cho qu���n lA� breadcrumb
    /// </summary>
    public interface IBreadcrumbService
    {
        /// <summary>
        /// T���o breadcrumbs cho trang ch��
        /// </summary>
        /// <returns></returns>
        Task<List<BreadcrumbItem>> GetHomeBreadcrumbsAsync();

        Task<List<BreadcrumbItem>> GetProductIndexBreadcrumbsAsync();
        Task<List<BreadcrumbItem>> GetJobPostIndexBreadcrumbsAsync();

        /// <summary>
        /// T���o breadcrumbs cho trang s���n ph��cm
        /// </summary>
        /// <param name="productId">ID s���n ph��cm</param>
        /// <param name="productName">TA�n s���n ph��cm</param>
        /// <param name="productUrl">URL s���n ph��cm</param>
        /// <param name="categoryName">TA�n danh m���c (optional)</param>
        /// <param name="categoryUrl">URL danh m���c (optional)</param>
        /// <returns></returns>
        Task<List<BreadcrumbItem>> GetProductBreadcrumbsAsync(int productId, string productName, string productUrl, string? categoryName = null, string? categoryUrl = null);

        /// <summary>
        /// T���o breadcrumbs cho trang tin t��cc
        /// </summary>
        /// <param name="postId">ID bA�i vi���t</param>
        /// <param name="postTitle">TiA�u �`��? bA�i vi���t</param>
        /// <param name="postUrl">URL bA�i vi���t</param>
        /// <param name="categoryName">TA�n danh m���c (optional)</param>
        /// <param name="categoryUrl">URL danh m���c (optional)</param>
        /// <returns></returns>
        Task<List<BreadcrumbItem>> GetPostBreadcrumbsAsync(int postId, string postTitle, string postUrl, string? categoryName = null, string? categoryUrl = null);


=== ladaexpress.vn\Infrastructures\Services\IContentOptimizationService.cs ===
using ladaexpress.vn.Infrastructures.DTO.Models.Seo;

namespace ladaexpress.vn.Infrastructures.Services
{
    /// <summary>
    /// Service �`��� t��`i ��u n��Ti dung vA� meta data
    /// </summary>
    public interface IContentOptimizationService
    {
        /// <summary>
        /// T���o meta title �`�����c t��`i ��u cho SEO
        /// </summary>
        /// <param name="baseTitle">TiA�u �`��? g��`c</param>
        /// <param name="contentType">Lo���i n��Ti dung (product, post, category, etc.)</param>
        /// <param name="keywords">T��� khA3a chA-nh (optional)</param>
        /// <returns>Meta title �`A� t��`i ��u</returns>
        Task<string> GenerateOptimizedTitleAsync(string baseTitle, string contentType, string? keywords = null);

        /// <summary>
        /// T���o meta description �`�����c t��`i ��u
        /// </summary>
        /// <param name="content">N��Ti dung g��`c</param>
        /// <param name="contentType">Lo���i n��Ti dung</param>
        /// <param name="targetLength">�?��T dA�i m���c tiA�u (default: 155)</param>
        /// <returns>Meta description �`A� t��`i ��u</returns>
        Task<string> GenerateOptimizedDescriptionAsync(string content, string contentType, int targetLength = 155);

        /// <summary>
        /// T���o keywords t��� n��Ti dung
        /// </summary>
        /// <param name="title">TiA�u �`��?</param>
        /// <param name="content">N��Ti dung</param>
        /// <param name="maxKeywords">S��` l�����ng keywords t��`i �`a</param>
        /// <returns>Danh sA�ch keywords</returns>
        Task<List<string>> ExtractKeywordsAsync(string title, string content, int maxKeywords = 10);

        /// <summary>
        /// T��`i ��u n��Ti dung cho SEO
        /// </summary>
        /// <param name="content">N��Ti dung HTML</param>

=== ladaexpress.vn\Infrastructures\Services\IRobotsService.cs ===
namespace ladaexpress.vn.Infrastructures.Services
{
    /// <summary>
    /// Service �`��� t���o vA� qu���n lA� robots.txt
    /// </summary>
    public interface IRobotsService
    {
        /// <summary>
        /// T���o n��Ti dung robots.txt
        /// </summary>
        /// <returns>N��Ti dung robots.txt</returns>
        Task<string> GenerateRobotsTxtAsync();

        /// <summary>
        /// T���o robots.txt cho development environment
        /// </summary>
        /// <returns>N��Ti dung robots.txt cho dev</returns>
        Task<string> GenerateDevRobotsTxtAsync();

        /// <summary>
        /// T���o robots.txt cho production environment
        /// </summary>
        /// <returns>N��Ti dung robots.txt cho production</returns>
        Task<string> GenerateProdRobotsTxtAsync();

        /// <summary>
        /// Validate robots.txt syntax
        /// </summary>
        /// <param name="robotsTxt">N��Ti dung robots.txt</param>
        /// <returns>Danh sA�ch l��-i</returns>
        List<string> ValidateRobotsTxt(string robotsTxt);

        /// <summary>
        /// L��u robots.txt vA�o file
        /// </summary>
        /// <param name="robotsTxt">N��Ti dung</param>
        /// <returns>�?����?ng d���n file</returns>
        Task<string> SaveRobotsTxtAsync(string robotsTxt);

        /// <summary>

=== ladaexpress.vn\Infrastructures\Services\ISitemapService.cs ===
using ladaexpress.vn.Infrastructures.DTO.Models.Seo;

namespace ladaexpress.vn.Infrastructures.Services
{
    /// <summary>
    /// Service �`��� t���o vA� qu���n lA� sitemap.xml
    /// </summary>
    public interface ISitemapService
    {
        /// <summary>
        /// T���o sitemap.xml hoA�n ch��%nh
        /// </summary>
        /// <returns>XML content c��a sitemap</returns>
        Task<string> GenerateSitemapXmlAsync();

        /// <summary>
        /// T���o sitemap index cho cA�c sitemap con
        /// </summary>
        /// <returns>XML content c��a sitemap index</returns>
        Task<string> GenerateSitemapIndexXmlAsync();

        /// <summary>
        /// T���o sitemap cho static pages
        /// </summary>
        /// <returns>Danh sA�ch SitemapItem cho static pages</returns>
        Task<List<SitemapItem>> GetStaticPagesSitemapAsync();

        /// <summary>
        /// T���o sitemap cho products/services
        /// </summary>
        /// <returns>Danh sA�ch SitemapItem cho products</returns>
        Task<List<SitemapItem>> GetProductsSitemapAsync();

        /// <summary>
        /// T���o sitemap cho posts/news
        /// </summary>
        /// <returns>Danh sA�ch SitemapItem cho posts</returns>
        Task<List<SitemapItem>> GetPostsSitemapAsync();

        /// <summary>

=== ladaexpress.vn\Infrastructures\Services\JobService.cs ===
using Dapper;
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.Data.Domains.Hr;
using Lada.Framework.Data.Repositories;
using Lada.Framework.Infrastructures.Helpers;
using ladaexpress.vn.Infrastructures.DTO;
using ladaexpress.vn.Infrastructures.DTO.Models.Hr;
using Microsoft.EntityFrameworkCore;
using System.Data;

namespace ladaexpress.vn.Infrastructures.Services
{
    public interface IJobService
    {
        public Task<JobListModel> PrepareJobListModel();
        Task<JobDetailModel> PrepareJobDetailModel(int id);
    }

    public class JobService : IJobService
    {
        private readonly IRepository<JobPost> _jobPostRepository;
        private readonly IDbConnection _dbConnection;
        private readonly IRepository<UrlRecord> _urlRecordRepository;
        public JobService(IRepository<JobPost> jobPostRepository, IDbConnection dbConnection,
            IRepository<UrlRecord> urlRecordRepository)
        {
            _jobPostRepository = jobPostRepository;
            _dbConnection = dbConnection;
            _urlRecordRepository = urlRecordRepository;
        }

        public async Task<JobListModel> PrepareJobListModel()
        {
            var model = new JobListModel();
            var currentTime = DateTimeHelper.CurrentTime();
            var newTime = currentTime.AddDays(-3);//Nh?ng b�i vi?t c� ng�y xu?t b?n 3 ng�y tr? v? d�y du?c coi l� b�i vi?t m?i


            model.JobPosts = await PrepareJobPosts();
            model.TotalJob = await PrepareTotalJobs();

=== ladaexpress.vn\Infrastructures\Services\LeadService.cs ===
using Lada.Framework.Data.Domains.Crm;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.Infrastructures.Helpers;
using ladaexpress.vn.Infrastructures.DTO;
using ladaexpress.vn.Infrastructures.DTO.Models.Service;
using ladaexpress.vn.Infrastructures.DTO.Results.Crm;

namespace ladaexpress.vn.Infrastructures.Services
{
    public interface ILeadService
    {
        /// <summary>
        /// T?o lead.
        /// </summary>
        /// <param name="model">Th�ng tin lead.</param>
        /// <returns>K?t qu? c?a thao t�c.</returns>
        Task<LeadResult> Create(LeadModel model);
    }
    public class LeadService : ILeadService
    {
        private readonly IRepository<Lead> _leadRepository;

        public LeadService(IRepository<Lead> leadRepository)
        {
            _leadRepository = leadRepository;
        }


        public async Task<LeadResult> Create(LeadModel model)
        {
            var result = new LeadResult();
            var currentTime = DateTimeHelper.CurrentTime();


            var lead = model.ToEntity();
            lead.CreatedTime = currentTime;
            lead.UpdatedTime = currentTime;
            try
            {

=== ladaexpress.vn\Infrastructures\Services\PostService.cs ===
using Dapper;
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using ladaexpress.vn.Infrastructures.DTO;
using ladaexpress.vn.Infrastructures.DTO.Models.Post.Detail;
using ladaexpress.vn.Infrastructures.DTO.Models.Post.Index;
using ladaexpress.vn.Infrastructures.DTO.Models.Post.Index.Childs;
using Microsoft.EntityFrameworkCore;
using System.Data;
using System.Text.RegularExpressions;
using static Microsoft.EntityFrameworkCore.DbLoggerCategory;

namespace ladaexpress.vn.Infrastructures.Services

{
    public interface IPostService
    {
        /// <summary>
        /// T�m ki?m b�i vi?t
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        Task<PostIndexModel> PreparePostIndex();

        Task<PostDetailModel> PreparePostDetail(int id);

        /// <summary>
        /// T?o / c?p nh?t b�i vi?t
        /// </summary>
        /// <param name="model"></param>
        /// <param name="updateBy"></param>
        /// <param name="updateByUserName"></param>
        /// <returns></returns>
        //Task<PostResult> CreateOrUpdate(PostModel model);

        /// <summary>
        /// L?y th�ng tin b�i vi?t qua Id
        /// </summary>

=== ladaexpress.vn\Infrastructures\Services\ProductService.cs ===
using Dapper;
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.Data.Repositories;
using Lada.Framework.Infrastructures.Helpers;
using ladaexpress.vn.Infrastructures.DTO;
using ladaexpress.vn.Infrastructures.DTO.Models.Post.Detail;
using ladaexpress.vn.Infrastructures.DTO.Models.Product.Index;
using ladaexpress.vn.Infrastructures.DTO.Models.Product.Index.Childs;
using ladaexpress.vn.Infrastructures.DTO.Models.Products.Detail;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Hosting;
using System.Data;
using System.Text.RegularExpressions;

namespace ladaexpress.vn.Infrastructures.Services
{
    public interface IProductService
    {
        /// <summary>
        /// T�m ki?m b�i vi?t
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        Task<ProductIndexModel> PrepareProductIndex();

        Task<ProductDetailModel> PrepareProductDetail(int id);

        /// <summary>
        /// T?o / c?p nh?t b�i vi?t
        /// </summary>
        /// <param name="model"></param>
        /// <param name="updateBy"></param>
        /// <param name="updateByUserName"></param>
        /// <returns></returns>
        //Task<ProductResult> CreateOrUpdate(ProductModel model);

        /// <summary>
        /// L?y th�ng tin b�i vi?t qua Id
        /// </summary>
        /// <param name="productId"></param>

=== ladaexpress.vn\Infrastructures\Services\RobotsService.cs ===
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using System.Text;

namespace ladaexpress.vn.Infrastructures.Services
{
    /// <summary>
    /// Implementation c��a IRobotsService
    /// </summary>
    public class RobotsService : IRobotsService
    {
        private readonly IAppConfigService _appConfigService;
        private readonly IConfiguration _configuration;
        private readonly IHostEnvironment _hostEnvironment;
        private readonly ILogger<RobotsService> _logger;
        private readonly string _baseUrl;

        public RobotsService(
            IAppConfigService appConfigService,
            IConfiguration configuration,
            IHostEnvironment hostEnvironment,
            ILogger<RobotsService> logger)
        {
            _appConfigService = appConfigService;
            _configuration = configuration;
            _hostEnvironment = hostEnvironment;
            _logger = logger;
            _baseUrl = _configuration["SeoSettings:BaseUrl"] ?? "https://ladaexpress.vn";
        }

        public async Task<string> GenerateRobotsTxtAsync()
        {
            try
            {
                if (_hostEnvironment.IsDevelopment())
                {
                    return await GenerateDevRobotsTxtAsync();
                }
                else

=== ladaexpress.vn\Infrastructures\Services\ScriptConfigService.cs ===
using System.Collections.Generic;
using System.Threading.Tasks;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.Data.Repositories;
using Microsoft.EntityFrameworkCore;
using ladaexpress.vn.Infrastructures.Stores;

namespace ladaexpress.vn.Infrastructures.Services
{
    public interface IScriptConfigService
    {
        Task<List<string>> GetScriptsByPosition(ScriptPosition position);
    }

    public class ScriptConfigService : IScriptConfigService
    {
        public Task<List<string>> GetScriptsByPosition(ScriptPosition position)
        {
            var scripts = ScriptConfigStore.AllScripts
                .Where(x => x.IsActive && x.Position == position)
                .Select(x => x.ScriptContent)
                .ToList();
            return Task.FromResult(scripts);
        }
    }
}

=== ladaexpress.vn\Infrastructures\Services\ServiceService.cs ===
using Dapper;
using ladaexpress.vn.Infrastructures.DTO.Models.Home;
using ladaexpress.vn.Infrastructures.DTO.Models.Post.Index.Childs;
using ladaexpress.vn.Infrastructures.DTO.Models.Service;
using System.Data;

namespace ladaexpress.vn.Infrastructures.Services
{
    public interface IServiceService
    {
        /// <summary>
        /// Home Model
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        Task<ServiceModel> PrepareServiceModel();


    }


    public class ServiceService : IServiceService
    {
        private readonly IDbConnection _dbConnection;

        public ServiceService(IDbConnection dbConnection)
        {
            _dbConnection = dbConnection;
        }

        public async Task<ServiceModel> PrepareServiceModel()
        {
            var model = new ServiceModel();
            try
            {
                model.LatestPosts = (await _dbConnection.QueryAsync<PostItem>("Home_GetLatestPosts", commandType: CommandType.StoredProcedure)).ToList();
            }
            catch (Exception)
            {
            }

=== ladaexpress.vn\Infrastructures\Services\SitemapService.cs ===
using ladaexpress.vn.Infrastructures.DTO.Models.Seo;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using System.Text;
using System.Xml;
using System.Xml.Linq;
using Lada.Framework.Data.Repositories;
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.Data.Domains.Hr;
using Microsoft.EntityFrameworkCore;
using Lada.Framework.Data.Enums;
using Lada.Framework.Infrastructures.Services;

namespace ladaexpress.vn.Infrastructures.Services
{
    /// <summary>
    /// Implementation c��a ISitemapService
    /// </summary>
    public class SitemapService : ISitemapService
    {
        private readonly IAppConfigService _appConfigService;
        private readonly IMemoryCache _memoryCache;
        private readonly IConfiguration _configuration;
        private readonly ILogger<SitemapService> _logger;
        private readonly IRepository<UrlRecord> _urlRecordRepository;
        private readonly IImageService _imageService;
        private readonly string _baseUrl;
        private readonly string _cacheKeyPrefix = "Sitemap_";

        public SitemapService(
            IAppConfigService appConfigService,
            IMemoryCache memoryCache,
            IConfiguration configuration,
            ILogger<SitemapService> logger,
            IRepository<UrlRecord> urlRecordRepository,
            IImageService imageService)
        {
            _appConfigService = appConfigService;
            _memoryCache = memoryCache;

=== ladaexpress.vn\Infrastructures\Services\TagService.cs ===
using Dapper;
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.Data.Repositories;
using Lada.Framework.Infrastructures.Helpers;
using ladaexpress.vn.Infrastructures.DTO;
using ladaexpress.vn.Infrastructures.DTO.Models.Categories;
using ladaexpress.vn.Infrastructures.DTO.Models.Hr;
using ladaexpress.vn.Infrastructures.DTO.Models.Post.Index.Childs;
using ladaexpress.vn.Infrastructures.DTO.Models.Product.Index.Childs;
using ladaexpress.vn.Infrastructures.DTO.Models.Tags;
using Microsoft.EntityFrameworkCore;
using System.Data;

namespace ladaexpress.vn.Infrastructures.Services
{
    public interface ITagService
    {
        Task<TagDetailModel> PrepareTagDetail(int id);
    }
    public class TagService : ITagService
    {
        private readonly IRepository<Tag> _tagRepository;
        private readonly IDbConnection _dbConnection;

        public TagService(IDbConnection dbConnection, IRepository<Tag> tagRepository)
        {
            _dbConnection = dbConnection;
            _tagRepository = tagRepository;
        }

        public async Task<TagDetailModel> PrepareTagDetail(int id)
        {
            var model = new TagDetailModel();
            var currentTime = DateTimeHelper.CurrentTime();

            var tag = await _tagRepository.Query().FirstOrDefaultAsync(c => c.Id == id);
            if (tag != null && tag.Id > 0)
            {
                model = tag.ToDetailModel();
                model.Posts = await PreparePosts(id, "TagDetail_Posts");

=== ladaexpress.vn\Infrastructures\Services\TopicService.cs ===
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.Data.Repositories;
using Lada.Framework.Infrastructures.Helpers;
using ladaexpress.vn.Infrastructures.DTO;
using ladaexpress.vn.Infrastructures.DTO.Models.Topic;
using Microsoft.EntityFrameworkCore;
using System.Data;
using System.Text.RegularExpressions;

namespace ladaexpress.vn.Infrastructures.Services
{
    public interface ITopicService
    {
        Task<TopicDetailModel> PrepareTopicDetail(int id);


        Task<TopicDetailModel> PrepareTopicDetailBySystemName(string systemName);
    }


    public class TopicService : ITopicService
    {
        private readonly IRepository<Topic> _topicRepository;
        private readonly IRepository<Category> _categoryRepository;
        private readonly IRepository<UrlRecord> _urlRecordRepository;
        private readonly IDbConnection _dbConnection;


        public TopicService(IRepository<Topic> topicRepository, IRepository<UrlRecord> urlRecordRepository,
            IRepository<Category> categoryRepository, IDbConnection dbConnection)
        {
            _topicRepository = topicRepository;
            _urlRecordRepository = urlRecordRepository;
            _categoryRepository = categoryRepository;
            _dbConnection = dbConnection;
        }
        public async Task<TopicDetailModel> PrepareTopicDetail(int id)
        {
            var model = new TopicDetailModel();
            var currentTime = DateTimeHelper.CurrentTime();

=== ladaexpress.vn\Infrastructures\Services\UrlRecordService.cs ===
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.Infrastructures.Helpers;
using Microsoft.EntityFrameworkCore;
using System.Globalization;
using System.Xml.Linq;

namespace ladaexpress.vn.Infrastructures.Services
{
    public interface IUrlRecordService
    {
        /// <summary>
        /// T?o lead
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        Task<string> GenerateSiteMapXml();

        /// <summary>
        /// Sinh n?i dung robots
        /// </summary>
        /// <returns></returns>
        Task<string> GenerateRobots();
    }


    public class UrlRecordService : IUrlRecordService
    {
        private readonly IRepository<UrlRecord> _urlRecordRepository;
        public UrlRecordService(IRepository<UrlRecord> urlRecordRepository)
        {
            _urlRecordRepository = urlRecordRepository;
        }
        public async Task<string> GenerateRobots()
        {
            var rs = string.Empty;
            rs = "User-agent: *";
            rs += "\n" + "Disallow:";
            rs += "\n\n" + "Sitemap: https://ladaexpress.vn/sitemap.xml";

=== ladaexpress.vn\Infrastructures\Services\Seo\ISeoService.cs ===
using ladaexpress.vn.Infrastructures.DTO.Models.Seo;

namespace ladaexpress.vn.Infrastructures.Services.Seo
{
    /// <summary>
    /// Interface cho SEO Service
    /// </summary>
    public interface ISeoService
    {
        /// <summary>
        /// T���o SEO model m���c �`��<nh cho trang ch��
        /// </summary>
        /// <returns></returns>
        Task<SeoModel> GetHomePageSeoAsync();

        Task<SeoModel> GetProductIndexSeoAsync();
        Task<SeoModel> GetJobPostIndexSeoAsync();

        /// <summary>
        /// T���o SEO model cho trang bA�i vi���t
        /// </summary>
        /// <param name="postId">ID bA�i vi���t</param>
        /// <param name="title">TiA�u �`��? bA�i vi���t</param>
        /// <param name="description">MA' t��� ng��_n</param>
        /// <param name="image">HA�nh ���nh</param>
        /// <param name="url">URL bA�i vi���t</param>
        /// <param name="author">TA�c gi���</param>
        /// <param name="publishedDate">NgA�y xu���t b���n</param>
        /// <param name="modifiedDate">NgA�y ch��%nh s��-a</param>
        /// <param name="keywords">T��� khA3a</param>
        /// <returns></returns>
        Task<SeoModel> GetArticleSeoAsync(int postId, string title, string description, string image, string url,
            string author, DateTime publishedDate, DateTime? modifiedDate = null, List<string>? keywords = null);

        /// <summary>
        /// T���o SEO model cho trang s���n ph��cm/d��<ch v���
        /// </summary>
        /// <param name="productId">ID s���n ph��cm</param>
        /// <param name="name">TA�n s���n ph��cm</param>
        /// <param name="description">MA' t��� s���n ph��cm</param>

=== ladaexpress.vn\Infrastructures\Services\Seo\IStructuredDataService.cs ===
using ladaexpress.vn.Infrastructures.DTO.Models.Seo;

namespace ladaexpress.vn.Infrastructures.Services.Seo
{
    /// <summary>
    /// Interface cho Structured Data Service - T���o JSON-LD markup
    /// </summary>
    public interface IStructuredDataService
    {
        /// <summary>
        /// T���o Organization schema cho trang ch��
        /// </summary>
        /// <returns></returns>
        string GenerateOrganizationSchema();

        /// <summary>
        /// T���o Website schema v��>i search action
        /// </summary>
        /// <returns></returns>
        string GenerateWebsiteSchema();

        /// <summary>
        /// T���o Article schema cho bA�i vi���t
        /// </summary>
        /// <param name="article">Article schema model</param>
        /// <returns></returns>
        string GenerateArticleSchema(ArticleSchema article);

        /// <summary>
        /// T���o Product schema cho s���n ph��cm/d��<ch v���
        /// </summary>
        /// <param name="product">Product schema model</param>
        /// <returns></returns>
        string GenerateProductSchema(ProductSchema product);

        /// <summary>
        /// T���o BreadcrumbList schema
        /// </summary>
        /// <param name="breadcrumbs">Danh sA�ch breadcrumb items</param>
        /// <returns></returns>

=== ladaexpress.vn\Infrastructures\Services\Seo\SeoService.cs ===
using ladaexpress.vn.Infrastructures.DTO.Models.Seo;
using ladaexpress.vn.Infrastructures.Services;
using Microsoft.Extensions.Configuration;
using System.Text.RegularExpressions;

namespace ladaexpress.vn.Infrastructures.Services.Seo
{
    /// <summary>
    /// Implementation c��a SEO Service
    /// </summary>
    public class SeoService : ISeoService
    {
        private readonly IConfiguration _configuration;
        private readonly IAppConfigService _appConfigService;
        private readonly IBreadcrumbService _breadcrumbService; // Added
        private readonly string _baseUrl;
        private readonly string _defaultImage;
        private readonly string _siteName;

        public SeoService(IConfiguration configuration, IAppConfigService appConfigService, IBreadcrumbService breadcrumbService) // Modified
        {
            _configuration = configuration;
            _appConfigService = appConfigService;
            _breadcrumbService = breadcrumbService; // Injected

            // Fallback to appsettings if AppConfig not available
            _baseUrl = _configuration["SeoSettings:BaseUrl"] ?? "https://ladaexpress.vn";
            _defaultImage = _configuration["SeoSettings:DefaultImage"] ?? "/images/logo.svg";
            _siteName = _configuration["SeoSettings:SiteName"] ?? "LADA Express";
        }

        public async Task<SeoModel> GetHomePageSeoAsync()
        {
            // Get SEO configs from AppConfig
            var title = await GetConfigValueAsync("SEO.HomePage.Title", "LADA Express - D��<ch v��� g��-i hA�ng nhanh chA3ng, uy tA-n");
            var description = await GetConfigValueAsync("SEO.HomePage.Description", "LADA Express cung c���p d��<ch v��� g��-i hA�ng nhanh chA3ng, uy tA-n trA�n toA�n qu��`c. Cam k���t giao hA�ng �`A�ng h��1n, giA� c��� h���p lA�. LiA�n h��� ngay �`��� �`�����c t�� v���n!");
            var keywords = await GetConfigValueAsync("SEO.HomePage.Keywords", "g��-i hA�ng, chuy���n phA�t nhanh, v��-n chuy���n, LADA Express, giao hA�ng");
            var ogTitle = await GetConfigValueAsync("SEO.HomePage.OgTitle", "LADA Express - D��<ch v��� g��-i hA�ng hA�ng �`��u Vi���t Nam");
            var ogDescription = await GetConfigValueAsync("SEO.HomePage.OgDescription", "D��<ch v��� g��-i hA�ng nhanh chA3ng, uy tA-n. Giao hA�ng toA�n qu��`c, cam k���t �`A�ng h��1n.");
            var baseUrl = await GetConfigValueAsync("SEO.BaseUrl", _baseUrl);

=== ladaexpress.vn\Infrastructures\Services\Seo\StructuredDataService.cs ===
using ladaexpress.vn.Infrastructures.DTO.Models.Seo;
using ladaexpress.vn.Infrastructures.Services;
using Microsoft.Extensions.Configuration;
using System.Text.Json;

namespace ladaexpress.vn.Infrastructures.Services.Seo
{
    /// <summary>
    /// Implementation c��a Structured Data Service
    /// </summary>
    public class StructuredDataService : IStructuredDataService
    {
        private readonly IConfiguration _configuration;
        private readonly IAppConfigService _appConfigService;
        private readonly string _baseUrl;
        private readonly string _siteName;

        public StructuredDataService(IConfiguration configuration, IAppConfigService appConfigService)
        {
            _configuration = configuration;
            _appConfigService = appConfigService;
            _baseUrl = _configuration["SeoSettings:BaseUrl"] ?? "https://ladaexpress.vn";
            _siteName = _configuration["SeoSettings:SiteName"] ?? "LADA Express";
        }

        /// <summary>
        /// T���o JsonSerializerOptions chu��cn cho structured data
        /// </summary>
        private static JsonSerializerOptions GetJsonSerializerOptions()
        {
            return new JsonSerializerOptions
            {
                PropertyNamingPolicy = null, // KhA'ng s��- d���ng camelCase �`��� gi��_ nguyA�n @context, @type
                WriteIndented = false,
                Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping
            };
        }

        public string GenerateOrganizationSchema()
        {

=== ladaexpress.vn\Infrastructures\Startup\IStartupTask.cs ===
using System.Threading;
using System.Threading.Tasks;

namespace ladaexpress.vn.Infrastructures.Startup
{
    public interface IStartupTask
    {
        Task ExecuteAsync(CancellationToken cancellationToken = default);
    }
}

=== ladaexpress.vn\Infrastructures\Startup\ScriptConfigStartupTask.cs ===
using Lada.Framework.Data.Domains.Cms;
using Lada.Framework.Data.Repositories;
using ladaexpress.vn.Infrastructures.Stores;
using Microsoft.EntityFrameworkCore;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace ladaexpress.vn.Infrastructures.Startup
{
    public class ScriptConfigStartupTask : IStartupTask
    {
        private readonly IRepository<ScriptConfig> _scriptConfigRepository;

        public ScriptConfigStartupTask(IRepository<ScriptConfig> scriptConfigRepository)
        {
            _scriptConfigRepository = scriptConfigRepository;
        }

        public async Task ExecuteAsync(CancellationToken cancellationToken = default)
        {
            ScriptConfigStore.AllScripts = await _scriptConfigRepository
                .Query()
                .Where(x => x.IsActive)
                .ToListAsync(cancellationToken);
        }
    }
}

=== ladaexpress.vn\Infrastructures\Startup\StartupHostedService.cs ===
using ladaexpress.vn.Infrastructures.Services;

namespace ladaexpress.vn.Infrastructures.Startup
{
    /// <summary>
    /// D?ch v? kh?i d?ng d? load AppConfig v�o cache
    /// </summary>
    public class StartupHostedService : IHostedService
    {
        private readonly IServiceProvider _serviceProvider;
        private readonly ILogger<StartupHostedService> _logger;

        public StartupHostedService(IServiceProvider serviceProvider, ILogger<StartupHostedService> logger)
        {
            _serviceProvider = serviceProvider;
            _logger = logger;
        }

        /// <summary>
        /// Kh?i t?o services khi ?ng d?ng start
        /// </summary>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task StartAsync(CancellationToken cancellationToken)
        {
            try
            {
                _logger.LogInformation("Starting application initialization...");

                using (var scope = _serviceProvider.CreateScope())
                {
                    // Load AppConfig into cache
                    var appConfigService = scope.ServiceProvider.GetRequiredService<IAppConfigService>();
                    await appConfigService.LoadConfigsToCacheAsync();

                    // Load ScriptConfig into cache if needed
                    var scriptConfigService = scope.ServiceProvider.GetService<IScriptConfigService>();
                    if (scriptConfigService != null)
                    {
                        // ScriptConfig c� th? c� method tuong t? n?u c?n

=== ladaexpress.vn\Infrastructures\StartupRegisters\DependencyRegister.cs ===
using Lada.Framework.Data.Repositories;
using Lada.Framework.Infrastructures.Services;
using Lada.Framework.Infrastructures.AppSettings;
using Microsoft.Extensions.Options;
using ladaexpress.vn.Infrastructures.Routes;
using ladaexpress.vn.Infrastructures.Services;
using ladaexpress.vn.Infrastructures.Services.Seo;

namespace ladaexpress.vn.Infrastructures.StartupRegisters
{
    public static class DependencyRegister
    {
        public static void RegisterDependency(this IServiceCollection services, IConfiguration configuration)
        {
            #region AppSettings
            services.Configure<MediaProcessingSettings>(options => configuration.GetSection("Media").Bind(options));
            #endregion

            #region Repositories
            services.AddTransient(typeof(IRepository<>), typeof(Repository<>));
            #endregion


            services.AddScoped<RouteTransformer>();
            services.AddScoped<TagRouteTransformer>();
            services.AddScoped<ProductRouteTransformer>();
            services.AddScoped<JobPostRouteTransformer>();

            #region Services

            services.AddTransient<IPostService, PostService>();
            services.AddTransient<IProductService, ProductService>();
            services.AddTransient<ITopicService, TopicService>();
            services.AddTransient<ICategoryService, CategoryService>();
            services.AddTransient<ITagService, TagService>();
            services.AddTransient<IJobService, JobService>();
            services.AddTransient<IHomeService, HomeService>();

            services.AddTransient<ICvUploadService, CvUploadService>();
            services.AddTransient<ICandidateService, CandidateService>();

=== ladaexpress.vn\Infrastructures\StartupRegisters\GeneralRegister.cs ===
using Lada.Framework.Data.Mappings.DbContexts;
using ladaexpress.vn.Infrastructures.DTO;
using ladaexpress.vn.Infrastructures.Routes;
using Microsoft.Data.SqlClient;
using Microsoft.EntityFrameworkCore;
using System.Data;
using WebMarkupMin.AspNetCoreLatest;
using WebMarkupMin.Core;
using WebMarkupMin.NUglify;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.AspNetCore.Mvc;
using ladaexpress.vn.Infrastructures.Startup;
namespace ladaexpress.vn.Infrastructures.StartupRegisters
{
    public static class GeneralRegister
    {
        public static void RegisterGeneralServices(this IServiceCollection services, IConfiguration Configuration)
        {
            if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Development")
            {
                services.AddControllersWithViews()
                        .AddRazorRuntimeCompilation();
            }
            else
            {
                services.AddControllersWithViews();
            }

            // �?��ng kA� d��<ch v��� ResponseCompression
            services.AddResponseCompression();

            string connectionString = Configuration.GetConnectionString("LadaConnection");

            services.AddDbContext<LadaDbContext>(options =>
                        options.UseSqlServer(connectionString, b => b.MigrationsAssembly("Ladaer.BackEnd")), ServiceLifetime.Transient);

            // Khai bA�o Dapper
            services.AddTransient<IDbConnection>((sp) => new SqlConnection(connectionString));

            services.AddWebMarkupMin(options =>