NonInventPurchasingSystem/CPRNIMS.Domain/UIServices/Canvass/Canvass.cs

using CPRNIMS.Domain.UIContracts.Canvass;
using CPRNIMS.Domain.UIContracts.Common;
using CPRNIMS.Infrastructure.Dto.Common;
using CPRNIMS.Infrastructure.Helper;
using CPRNIMS.Infrastructure.Models.Account;
using CPRNIMS.Infrastructure.Models.Common;
using CPRNIMS.Infrastructure.ViewModel.Canvass;
using CPRNIMS.Infrastructure.ViewModel.PR;
using Microsoft.Extensions.Configuration;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

namespace CPRNIMS.Domain.UIServices.Canvass
{
    public class Canvass : ICanvass
    {
        private readonly IConfiguration _configuration;
        private readonly TokenHelper _tokenHelper;
        private readonly IApiConfigurationService _apiConfigurationService;
        public Canvass(IConfiguration configuration, TokenHelper tokenHelper,
            IApiConfigurationService apiConfigurationService)
        {
            _configuration = configuration;
            _tokenHelper = tokenHelper;
            _apiConfigurationService = apiConfigurationService;
        }
        #region SendRequest service     
        public async Task<CanvassVM> SendPostApiRequest(User user,
            CanvassVM viewModel, string apiEndpoint)
        {
            var token = await _tokenHelper.GetValidTokenAsync();

            try
            {
                if (string.IsNullOrEmpty(token))
                {
                    return null;
                }

                viewModel.UserId = user.UserId;
                viewModel.FullName = user.FullName;
                var jsonContent = JsonSerializer.Serialize(viewModel);
                var content = new StringContent(jsonContent, Encoding.UTF8, "application/json");

                using (var httpClient = _apiConfigurationService.CreateHttpClientWithDefaultHeaders(token))
                {
                    HttpResponseMessage response;

                    response = await httpClient.PostAsync(apiEndpoint, content);
                    var responseObject = JsonSerializer.Deserialize<ResponseObject>(await response.Content.ReadAsStringAsync());

                    if (response.IsSuccessStatusCode)
                    {
                        viewModel.messCode =1;
                        viewModel.StatusResponse = responseObject.statusResponse;                   
                        return viewModel;
                    }
                    else
                    {
                        viewModel.errMessage = responseObject.message;
                        viewModel.messCode = responseObject.messCode;
                        return viewModel;
                    }
                }
            }
            catch (Exception ex)
            {
                ex.ToString();
                throw;
            }
        }
        public async Task<List<CanvassVM>> SendGetApiRequest(User user,
          CanvassVM viewModel,
         string apiEndpoint)
        {
            var token = await _tokenHelper.GetValidTokenAsync();

            try
            {
                if (string.IsNullOrEmpty(token))
                {
                    // Handle token retrieval failure
                    return null;
                }

                viewModel.UserId = user.UserId;
                var jsonContent = JsonSerializer.Serialize(viewModel);
                var content = new StringContent(jsonContent, Encoding.UTF8, "application/json");

                using (var httpClient = _apiConfigurationService.CreateHttpClientWithDefaultHeaders(token))
                {
                    HttpResponseMessage response;

                    response = await httpClient.PostAsync(apiEndpoint, content);

                    if (response.IsSuccessStatusCode)
                    {
                        var jsonResponse = await response.Content.ReadAsStringAsync();

                        var options = new JsonSerializerOptions
                        {
                            PropertyNamingPolicy = JsonNamingPolicy.CamelCase
                        };
                        var myArtWork = JsonSerializer.Deserialize<List<CanvassVM>>(jsonResponse, options);
                        if(myArtWork.Count > 0)
                        {
                            myArtWork[0].URL = _configuration["CommonEndpoints:ApiDefaultHeaders:ItemImages"];
                        }
                        return myArtWork;
                    }
                    else
                    {
                        // Handle API request failure
                        return null;
                    }
                }
            }
            catch (Exception ex)
            {
                throw;
            }
        }
        public async Task<PagedResult<CanvassVM>> SendGetPageListApiRequest
       (User user, CanvassVM viewModel, string apiEndpoint)
        {
            var token = await _tokenHelper.GetValidTokenAsync();

            try
            {
                if (string.IsNullOrEmpty(token))
                {
                    return null;
                }

                viewModel.UserId = user.UserId;
                var jsonContent = JsonSerializer.Serialize(viewModel);
                var content = new StringContent(jsonContent, Encoding.UTF8, "application/json");

                using (var httpClient = _apiConfigurationService.CreateHttpClientWithDefaultHeaders(token))
                {
                    HttpResponseMessage response;

                    response = await httpClient.PostAsync(apiEndpoint, content);
                    var jsonResponse = await response.Content.ReadAsStringAsync();

                    if (response.IsSuccessStatusCode)
                    {
                        var options = new JsonSerializerOptions
                        {
                            PropertyNamingPolicy = JsonNamingPolicy.CamelCase
                        };
                        viewModel.messCode = 1;
                        var result = JsonSerializer.Deserialize<PagedResult<CanvassVM>>(jsonResponse, options);
                        return result;
                    }
                    else
                    {

                        var result = JsonSerializer.Deserialize<PagedResult<CanvassVM>>(jsonResponse);
                        viewModel.messCode = 0;
                        viewModel.errMessage = "Bad request";
                        return result;
                    }
                }
            }
            catch (Exception ex)
            {
                throw;
            }
        }
        #endregion

        #region Get
        public async Task<List<CanvassVM>> GetSupplierBid(User user, CanvassVM viewModel)
        {
            return await SendGetApiRequest(user, viewModel,
           _configuration["LLI:NonInvent:CanvassMgmt:GetSupplierBid"]);
        }
        public async Task<List<CanvassVM>> GetSupplierBidByItem(User user, CanvassVM viewModel)
        {
            return await SendGetApiRequest(user, viewModel,
         _configuration["LLI:NonInvent:CanvassMgmt:GetSupplierBidByItem"]);
        }       
        public async Task<List<CanvassVM>> GetCanvassPerSupplierEmail(User user, CanvassVM viewModel)
        {
            return await SendGetApiRequest(user, viewModel,
           _configuration["LLI:NonInvent:CanvassMgmt:GetCanvassPerSupplierEmail"]);
        }
        public async Task<List<CanvassVM>> GetCanvassById(User user, CanvassVM viewModel)
        {
            return await SendGetApiRequest(user, viewModel,
           _configuration["LLI:NonInvent:CanvassMgmt:GetCanvassById"]);
        }
        public async Task<List<CanvassVM>> GetPRItemList(User user, CanvassVM viewModel)
        {
            return await SendGetApiRequest(user, viewModel,
           _configuration["LLI:NonInvent:CanvassMgmt:GetPRItemList"]);
        }
        public async Task<List<CanvassVM>> GetPRItem(User user, CanvassVM viewModel)
        {
            return await SendGetApiRequest(user, viewModel,
           _configuration["LLI:NonInvent:CanvassMgmt:GetPRItem"]);
        }
        public async Task<List<CanvassVM>> GetCanvassWOResponse(User user, CanvassVM viewModel)
        {
            return await SendGetApiRequest(user, viewModel,
            _configuration["LLI:NonInvent:CanvassMgmt:GetCanvassWOResponse"]);
        }
        public async Task<List<CanvassVM>> GetCanvassByPRNo(User user, CanvassVM viewModel)
        {
            return await SendGetApiRequest(user, viewModel,
           _configuration["LLI:NonInvent:CanvassMgmt:GetCanvassByPRNo"]);
        }   
        public async Task<List<CanvassVM>> GetItemSupplierWOEmail(User user, CanvassVM viewModel)
        {
            return await SendGetApiRequest(user, viewModel,
            _configuration["LLI:NonInvent:CanvassMgmt:GetItemSupplierWOEmail"]);
        }
        public async Task<List<CanvassVM>> GetSupplierItemWOEmail(User user, CanvassVM viewModel)
        {
            return await SendGetApiRequest(user, viewModel,
          _configuration["LLI:NonInvent:CanvassMgmt:GetSupplierItemWOEmail"]);
        }
        public async Task<List<CanvassVM>> GetSupplierById(User user, CanvassVM viewModel)
        {
            return await SendGetApiRequest(user, viewModel,
          _configuration["LLI:NonInvent:CanvassMgmt:GetSupplierById"]);
        }
        public async Task<List<CanvassVM>> GetSupplierBidById(User user, CanvassVM viewModel)
        {
            return await SendGetApiRequest(user, viewModel,
            _configuration["LLI:NonInvent:CanvassMgmt:GetSupplierBidById"]);
        }
        public async Task<List<CanvassVM>> GetWOResponseBySuppId(User user, CanvassVM viewModel)
        {
            return await SendGetApiRequest(user, viewModel,
            _configuration["LLI:NonInvent:CanvassMgmt:GetWOResponseBySuppId"]);
        }
        public async Task<List<CanvassVM>> GetForCanvassPerItem(User user, CanvassVM viewModels)
        {
            return await SendGetApiRequest(user, viewModels,
           _configuration["LLI:NonInvent:CanvassMgmt:GetForCanvassPerItem"]);
        }
        public async Task<List<CanvassVM>?> GetPRListByPRNo(User user, CanvassVM viewModel)
        {
            return await SendGetApiRequest(user, viewModel,
            _configuration["LLI:NonInvent:CanvassMgmt:GetPRListByPRNo"]);
        }
        public async Task<List<CanvassVM>?> GetMySuppliers(User user, CanvassVM viewModel)
        {
            return await SendGetApiRequest(user, viewModel,
            _configuration["LLI:NonInvent:CanvassMgmt:GetMySuppliers"]);
        }
        public async Task<List<CanvassVM>?> GetMyPRWOCanvass(User user, CanvassVM viewModel)
        {
            return await SendGetApiRequest(user, viewModel,
             _configuration["LLI:NonInvent:CanvassMgmt:GetMyPRWOCanvass"]);
        }
        public async Task<List<CanvassVM>?> GetCanvassPerSupplierId(User user, CanvassVM viewModel)
        {
            return await SendGetApiRequest(user, viewModel,
            _configuration["LLI:NonInvent:CanvassMgmt:GetCanvassPerSupplierId"]);
        }
        public async Task<List<CanvassVM>?> GetCanvassGroupByPRNo(User user, CanvassVM viewModel)
        {
            return await SendGetApiRequest(user, viewModel,
            _configuration["LLI:NonInvent:CanvassMgmt:GetCanvassGroupByPRNo"]);
        }
        public async Task<List<CanvassVM>?> GetIndexCard(User user, CanvassVM viewModel)
        {
            return await SendGetApiRequest(user, viewModel,
            _configuration["LLI:NonInvent:CanvassMgmt:GetIndexCard"]);
        }
        public async Task<List<CanvassVM>?> GetAlternativeOfferByPRDetailId(User user, CanvassVM viewModel)
        {
            return await SendGetApiRequest(user, viewModel,
           _configuration["LLI:NonInvent:CanvassMgmt:GetAlternativeOfferByPRDetailId"]);
        }
        public async Task<PagedResult<CanvassVM>> GetCanvassPerSupplier(User user, CanvassVM viewModel)
        {
            return await SendGetPageListApiRequest(user, viewModel,
            _configuration["LLI:NonInvent:CanvassMgmt:GetCanvassPerSupplier"]);
        }
        public async Task<PagedResult<CanvassVM>> GetItemsForTagging(User user, CanvassVM viewModel)
        {
            return await SendGetPageListApiRequest(user, viewModel,
            _configuration["LLI:NonInvent:CanvassMgmt:GetItemsForTagging"]);
        }
        #endregion
        #region Post Put
        public async Task<CanvassVM> PostCanvass(User user, CanvassVM viewModel)
        {
            return await SendPostApiRequest(user, viewModel,
           _configuration["LLI:NonInvent:CanvassMgmt:PostCanvass"]);
        }
        public async Task<CanvassVM> PostPutSupplier(User user, CanvassVM viewModel)
        {
            return await SendPostApiRequest(user, viewModel,
           _configuration["LLI:NonInvent:CanvassMgmt:PostPutSupplier"]);
        }
        public async Task<CanvassVM> PostApprovedSupp(User user, CanvassVM viewModel)
        {
            return await SendPostApiRequest(user, viewModel,
           _configuration["LLI:NonInvent:CanvassMgmt:PostApprovedSupp"]);
        }
        public async Task<CanvassVM> PostSuggestedSupp(User user, CanvassVM viewModel)
        {
            return await SendPostApiRequest(user, viewModel,
           _configuration["LLI:NonInvent:CanvassMgmt:PostSuggestedSupp"]);
        }
        public async Task<CanvassVM> PostTaggingSupplier(User user, CanvassVM viewModel)
        {
            return await SendPostApiRequest(user, viewModel,
            _configuration["LLI:NonInvent:CanvassMgmt:PostTaggingSupplier"]);
        }
        public async Task<CanvassVM> PutSuppUnitPrice(User user, CanvassVM viewModel)
        {
            return await SendPostApiRequest(user, viewModel,
           _configuration["LLI:NonInvent:CanvassMgmt:PutSuppUnitPrice"]);
        }
        public async Task<CanvassVM> PutSuppBidDetails(User user, CanvassVM viewModel)
        {
            return await SendPostApiRequest(user, viewModel,
            _configuration["LLI:NonInvent:CanvassMgmt:PutSuppBidDetails"]);
        }
        public async Task<CanvassVM> PostPutMySupplier(User user, CanvassVM viewModel)
        {
            return await SendPostApiRequest(user, viewModel,
             _configuration["LLI:NonInvent:CanvassMgmt:PostPutMySupplier"]);
        }
        public async Task<CanvassVM> PostPutItemTagging(User user, CanvassVM viewModel)
        {
            return await SendPostApiRequest(user, viewModel,
           _configuration["LLI:NonInvent:CanvassMgmt:PostPutItemTagging"]);
        }
        public async Task<CanvassVM> UnlockFormLink(User user, CanvassVM viewModel)
        {
            return await SendPostApiRequest(user, viewModel,
           _configuration["LLI:NonInvent:CanvassMgmt:UnlockFormLink"]);
        }

        public async Task<CanvassVM> StartCanvass(User user, CanvassVM viewModel)
        {
            return await SendPostApiRequest(user, viewModel,
            _configuration["LLI:NonInvent:CanvassMgmt:StartCanvass"]);
        }

        public async Task<CanvassVM> PostSupplierForCanvass(User user, CanvassVM viewModel)
        {
            return await SendPostApiRequest(user, viewModel,
            _configuration["LLI:NonInvent:CanvassMgmt:PostSupplierForCanvass"]);
        }

        #endregion
    }
}