OnlineSalesAutoCrop/Api/OnlineSalesAutoCrop.CoreAPI.Services/Services/MobileApp/MobileMasterDataService.cs

using Ease.NetCore.DataAccess;
using Ease.NetCore.DataAccess.SQL;
using Microsoft.Data.SqlClient;
using Microsoft.Extensions.Options;
using MySqlX.XDevAPI.Common;
using OnlineSalesAutoCrop.CoreAPI.Models.Global;
using OnlineSalesAutoCrop.CoreAPI.Models.Requests.MobileApp;
using OnlineSalesAutoCrop.CoreAPI.Models.Responses;
using OnlineSalesAutoCrop.CoreAPI.Models.Responses.Integrations;
using OnlineSalesAutoCrop.CoreAPI.Models.Responses.MobileApp;
using OnlineSalesAutoCrop.CoreAPI.Services.Contracts.MobileApp;
using OnlineSalesAutoCrop.CoreAPI.Services.Contracts.Systems;
using System;
using System.Collections.Generic;
using System.Data;
using System.Threading.Tasks;

namespace OnlineSalesAutoCrop.CoreAPI.Services.Services.MobileApp;

public class MobileMasterDataService : IMobileMasterDataService
{
    private readonly AppSettings _settings;
    private readonly IUserService _userService;

    public MobileMasterDataService(IOptions<AppSettings> options, IUserService userService)
    {
        _settings = options.Value;
        _userService = userService;
    }

    public async Task<MarketHeirarchyByEmpResponse> GetMarketHeirarchiesByEmpAsync(GetMarketHeirarchyByEmpRequest request)
    {

        MarketHeirarchyByEmpResponse response = new();
        try
        {
            using TransactionContext tc = await TransactionContext.BeginAsync(_settings.DefaultConnection.ConnectionNode);
            try
            {
                string employeeNumber = request.EmployeeNumber;

                response.Companies = await GetCompaniesByEmployeeNumberAsync(tc, employeeNumber);
                response.SalesOrgs = await GetSalesOrgsByEmployeeNumberAsync(tc, employeeNumber);
                response.DistributionChannels = await GetDistributionChannelsByEmployeeNumberAsync(tc, employeeNumber);
                response.Regions = await GetRegionsByEmployeeNumberAsync(tc, employeeNumber);
                response.Areas = await GetAreasByEmployeeNumberAsync(tc, employeeNumber);
                response.Teritories = await GetTerritoriesByEmployeeNumberAsync(tc, employeeNumber);
                response.Plants = await GetPlantsByEmployeeNumberAsync(tc, employeeNumber);

                tc.End();
            }
            catch (Exception ie)
            {
                tc?.HandleError();

                throw DBCustomError.GenerateCustomError(ie);
            }
        }
        catch (Exception ex)
        {
            throw;
        }

        return response;
    }

    public async Task<PagedResult<GetBrandResponse>> GetBrandsAsync(GetBrandsRequest request)
    {
        PagedResult<GetBrandResponse> response = new();
        try
        {
            using TransactionContext tc = await TransactionContext.BeginAsync(_settings.DefaultConnection.ConnectionNode);
            try
            {
                SqlParameter[] p =
                [
                     SqlHelperExtension.CreateInParam(pName: "@BrandCode", pType: SqlDbType.VarChar, pValue: request.BrandCode),
                     SqlHelperExtension.CreateInParam(pName: "@PageNumber", pType: SqlDbType.Int, pValue: request.PageNumber),
                     SqlHelperExtension.CreateInParam(pName: "@PageSize", pType: SqlDbType.Int, pValue: request.PageSize)
                ];

                using (IDataReader dr = await tc.ExecuteReaderSpAsync("dbo.GetBrandsPaginated", parameterValues: p))
                {
                    if (dr.Read())
                    {
                        response.TotalCount = dr.GetInt32(0);
                        response.PageNumber = request.PageNumber;
                        response.PageSize = request.PageSize;
                    }

                    // Second result set: paginated brand data
                    dr.NextResult();


                    while (dr.Read())
                    {
                        response.Items.Add(new GetBrandResponse
                        {
                            BrandCode = dr.GetString(0),
                            BrandName = dr.GetString(1)
                        });
                    }
                    dr.Close();

                }
                tc.End();
            }
            catch (Exception ie)
            {
                tc?.HandleError();

                throw DBCustomError.GenerateCustomError(ie);
            }
        }
        catch (Exception ex)
        {
            throw;
        }

        return response;
    }


    public async Task<PagedResult<GetMaterialResponse>> GetMaterialsAsync(GetMaterialsRequest request)
    {
        PagedResult<GetMaterialResponse> response = new();
        try
        {
            using TransactionContext tc = await TransactionContext.BeginAsync(_settings.DefaultConnection.ConnectionNode);
            try
            {
                SqlParameter[] p =
                [
                     SqlHelperExtension.CreateInParam(pName: "@BrandCode", pType: SqlDbType.VarChar, pValue: request.BrandCode),
                     SqlHelperExtension.CreateInParam(pName: "@MaterialCode", pType: SqlDbType.VarChar, pValue: request.MaterialCode),
                     SqlHelperExtension.CreateInParam(pName: "@PageNumber", pType: SqlDbType.Int, pValue: request.PageNumber),
                     SqlHelperExtension.CreateInParam(pName: "@PageSize", pType: SqlDbType.Int, pValue: request.PageSize)
                ];

                using (IDataReader dr = await tc.ExecuteReaderSpAsync("dbo.GetMaterialsPaginated", parameterValues: p))
                {
                    if (dr.Read())
                    {
                        response.TotalCount = dr.GetInt32(0);
                        response.PageNumber = request.PageNumber;
                        response.PageSize = request.PageSize;
                    }

                    // Second result set: paginated brand data
                    dr.NextResult();


                    while (dr.Read())
                    {
                        response.Items.Add(new GetMaterialResponse
                        {
                            Code = dr.GetString(0),
                            Name = dr.GetString(1),
                            TypeCode = dr.GetString(2),
                            TypeName = dr.GetString(3),
                            GroupCode = dr.GetString(4),
                            GroupName = dr.GetString(5),
                            BaseUnitMeasurement = dr.GetString(6),
                            SalesUnitMeasurement = dr.GetString(7),
                            UnitConversionValue = dr.GetDecimal(8),
                            BrandCode = dr.GetString(9),
                            BrandName = dr.GetString(10),
                            SalesOrg = dr.GetString(11),
                            BasePrice = dr.GetDecimal(12)
                        });
                    }
                    dr.Close();

                }
                tc.End();
            }
            catch (Exception ie)
            {
                tc?.HandleError();

                throw DBCustomError.GenerateCustomError(ie);
            }
        }
        catch (Exception ex)
        {
            throw;
        }

        return response;
    }

    public async Task<PagedResult<GetCustomerResponse>> GetCustomersAsync(GetCustomersRequest request)
    {
        PagedResult<GetCustomerResponse> response = new();
        try
        {
            using TransactionContext tc = await TransactionContext.BeginAsync(_settings.DefaultConnection.ConnectionNode);
            try
            {
                SqlParameter[] p =
                [
                     SqlHelperExtension.CreateInParam(pName: "@TeritoryCode", pType: SqlDbType.VarChar, pValue: request.TeritoryCode),
                     SqlHelperExtension.CreateInParam(pName: "@CustomerCode", pType: SqlDbType.VarChar, pValue: request.CustomerCode),
                     SqlHelperExtension.CreateInParam(pName: "@PageNumber", pType: SqlDbType.Int, pValue: request.PageNumber),
                     SqlHelperExtension.CreateInParam(pName: "@PageSize", pType: SqlDbType.Int, pValue: request.PageSize)
                ];

                using (IDataReader dr = await tc.ExecuteReaderSpAsync("dbo.GetCustomersPaginated", parameterValues: p))
                {
                    if (dr.Read())
                    {
                        response.TotalCount = dr.GetInt32(0);
                        response.PageNumber = request.PageNumber;
                        response.PageSize = request.PageSize;
                    }

                    // Second result set: paginated brand data
                    dr.NextResult();


                    while (dr.Read())
                    {
                        response.Items.Add(new GetCustomerResponse
                        {
                            Code = dr.GetString(0),
                            Name = dr.GetString(1),
                            AccountGroupCode = dr.GetString(2),
                            AccountGroupDescription = dr.GetString(3),
                            DistributionChannelCode = dr.GetString(4),
                            DistributionChannelName = dr.GetString(5),
                            DivisionCode = dr.GetString(6),
                            DivisionName = dr.GetString(7),
                            MobileNumber = dr.GetString(8),
                            EmailAddress = dr.GetString(9),
                            TaxNumber = dr.GetString(10),
                            SalesGroupCode = dr.GetString(11),
                            SalesGroupName = dr.GetString(12),
                            CustomerGroupCode = dr.GetString(13),
                            CustomerGroupName = dr.GetString(14),
                            CustomerPriceGroupCode = dr.GetString(15),
                            CustomerPriceGroupName = dr.GetString(16),
                            PaymentTermCode = dr.GetString(17),
                            TeritoryCode = dr.GetString(18),
                            PlantCode = dr.GetString(19)
                        });
                    }
                    dr.Close();

                }
                tc.End();
            }
            catch (Exception ie)
            {
                tc?.HandleError();

                throw DBCustomError.GenerateCustomError(ie);
            }
        }
        catch (Exception ex)
        {
            throw;
        }

        return response;
    }

    private async Task<List<EmpCompanyResponse>> GetCompaniesByEmployeeNumberAsync(TransactionContext tc, string employeeNumber)
    {
        List<EmpCompanyResponse> response = [];

        try
        {
            SqlParameter[] p =
            [
                SqlHelperExtension.CreateInParam(pName: "@EmployeeNumber", pType: SqlDbType.NVarChar, pValue: employeeNumber)
            ];

            using (IDataReader dr = await tc.ExecuteReaderSpAsync("dbo.GetCompaniesByEmployeeNumber", parameterValues: p))
            {
                while (dr.Read())
                {
                    response.Add(new EmpCompanyResponse
                    {
                        Code = dr.GetString(0),
                        Name = dr.GetString(1)
                    });
                }
                dr.Close();
            }
        }
        catch (Exception ex)
        {
            throw DBCustomError.GenerateCustomError(ex);
        }

        return response;
    }

    private async Task<List<SalesOrgResponse>> GetSalesOrgsByEmployeeNumberAsync(TransactionContext tc, string employeeNumber)
    {
        List<SalesOrgResponse> response = [];

        try
        {
            SqlParameter[] p =
            [
                SqlHelperExtension.CreateInParam(pName: "@EmployeeNumber", pType: SqlDbType.NVarChar, pValue: employeeNumber)
            ];

            using (IDataReader dr = await tc.ExecuteReaderSpAsync("dbo.GetSalesOrgsByEmployeeNumber", parameterValues: p))
            {
                while (dr.Read())
                {
                    response.Add(new SalesOrgResponse
                    {
                        CompanyCode = dr.GetString(0),
                        Code = dr.GetString(1),
                        Name = dr.GetString(2)
                    });
                }
                dr.Close();
            }
        }
        catch (Exception ex)
        {
            throw DBCustomError.GenerateCustomError(ex);
        }

        return response;
    }

    private async Task<List<DistibutionChannleResponse>> GetDistributionChannelsByEmployeeNumberAsync(TransactionContext tc, string employeeNumber)
    {
        List<DistibutionChannleResponse> response = [];

        try
        {
            SqlParameter[] p =
            [
                SqlHelperExtension.CreateInParam(pName: "@EmployeeNumber", pType: SqlDbType.NVarChar, pValue: employeeNumber)
            ];

            using (IDataReader dr = await tc.ExecuteReaderSpAsync("dbo.GetDistributionChannelsByEmployeeNumber", parameterValues: p))
            {
                while (dr.Read())
                {
                    response.Add(new DistibutionChannleResponse
                    {
                        CompanyCode = dr.GetString(0),
                        SalesOrgCode = dr.GetString(1),
                        Code = dr.GetString(2),
                        Name = dr.GetString(3)
                    });
                }
                dr.Close();
            }
        }
        catch (Exception ex)
        {
            throw DBCustomError.GenerateCustomError(ex);
        }

        return response;
    }

    private async Task<List<RegionResponse>> GetRegionsByEmployeeNumberAsync(TransactionContext tc, string employeeNumber)
    {
        List<RegionResponse> response = [];

        try
        {
            SqlParameter[] p =
            [
                SqlHelperExtension.CreateInParam(pName: "@EmployeeNumber", pType: SqlDbType.NVarChar, pValue: employeeNumber)
            ];

            using (IDataReader dr = await tc.ExecuteReaderSpAsync("dbo.GetRegionsByEmployeeNumber", parameterValues: p))
            {
                while (dr.Read())
                {
                    response.Add(new RegionResponse
                    {
                        CompanyCode = dr.GetString(0),
                        SalesOrgCode = dr.GetString(1),
                        Code = dr.GetString(2),
                        Name = dr.GetString(3)
                    });
                }
                dr.Close();
            }
        }
        catch (Exception ex)
        {
            throw DBCustomError.GenerateCustomError(ex);
        }

        return response;
    }

    private async Task<List<AreaResponse>> GetAreasByEmployeeNumberAsync(TransactionContext tc, string employeeNumber)
    {
        List<AreaResponse> response = [];

        try
        {
            SqlParameter[] p =
            [
                SqlHelperExtension.CreateInParam(pName: "@EmployeeNumber", pType: SqlDbType.NVarChar, pValue: employeeNumber)
            ];

            using (IDataReader dr = await tc.ExecuteReaderSpAsync("dbo.GetAreasByEmployeeNumber", parameterValues: p))
            {
                while (dr.Read())
                {
                    response.Add(new AreaResponse
                    {
                        CompanyCode = dr.GetString(0),
                        SalesOrgCode = dr.GetString(1),
                        RegionCode = dr.GetString(2),
                        Code = dr.GetString(3),
                        Name = dr.GetString(4)
                    });
                }
                dr.Close();
            }
        }
        catch (Exception ex)
        {
            throw DBCustomError.GenerateCustomError(ex);
        }

        return response;
    }

    private async Task<List<TeritoryResponse>> GetTerritoriesByEmployeeNumberAsync(TransactionContext tc, string employeeNumber)
    {
        List<TeritoryResponse> response = [];

        try
        {
            SqlParameter[] p =
            [
                SqlHelperExtension.CreateInParam(pName: "@EmployeeNumber", pType: SqlDbType.NVarChar, pValue: employeeNumber)
            ];

            using (IDataReader dr = await tc.ExecuteReaderSpAsync("dbo.GetTerritoriesByEmployeeNumber", parameterValues: p))
            {
                while (dr.Read())
                {
                    response.Add(new TeritoryResponse
                    {
                        CompanyCode = dr.GetString(0),
                        SalesOrgCode = dr.GetString(1),
                        RegionCode = dr.GetString(2),
                        AreaCode = dr.GetString(3),
                        Code = dr.GetString(4),
                        Name = dr.GetString(5)
                    });
                }
                dr.Close();
            }
        }
        catch (Exception ex)
        {
            throw DBCustomError.GenerateCustomError(ex);
        }

        return response;
    }

    private async Task<List<PlantResponse>> GetPlantsByEmployeeNumberAsync(TransactionContext tc, string employeeNumber)
    {
        List<PlantResponse> response = [];

        try
        {
            SqlParameter[] p =
            [
                SqlHelperExtension.CreateInParam(pName: "@EmployeeNumber", pType: SqlDbType.NVarChar, pValue: employeeNumber)
            ];

            using (IDataReader dr = await tc.ExecuteReaderSpAsync("dbo.GetPlantsByEmployeeNumber", parameterValues: p))
            {
                while (dr.Read())
                {
                    response.Add(new PlantResponse
                    {
                        CompanyCode = dr.GetString(0),
                        SalesOrgCode = dr.GetString(1),
                        Code = dr.GetString(2),
                        Name = dr.GetString(3)
                    });
                }
                dr.Close();
            }
        }
        catch (Exception ex)
        {
            throw DBCustomError.GenerateCustomError(ex);
        }

        return response;
    }

}