seyounth.hyosung.ty/Seyounth.Hyosung.Data/Services/VarietyService.cs

using System.Collections.Concurrent;
using Microsoft.Extensions.DependencyInjection;
using Seyounth.Hyosung.Data.Entities;
using Seyounth.Hyosung.Data.Models;
using Seyounth.Hyosung.Data.Repositories;

namespace Seyounth.Hyosung.Data.Services;

public class VarietyService : IVarietyService
{
    private readonly IRepository<VarietyEntity> _varietyRepository;
    private readonly IRepository<PalletEntity> _palletRepository;
    private readonly List<VarietyEntity> _varietiesCache;
    private readonly List<PalletEntity> _palletsCache;

    public VarietyService(IServiceProvider provider)
    {
        try
        {
            _varietyRepository =
                provider.CreateScope().ServiceProvider.GetRequiredService<IRepository<VarietyEntity>>();
             _palletRepository = provider.CreateScope().ServiceProvider.GetRequiredService<IRepository<PalletEntity>>();
            //_varietyRepository = provider.GetService<IRepository<VarietyEntity>>();
           // _palletRepository = provider.GetService<IRepository<PalletEntity>>();
             _varietiesCache = new List<VarietyEntity>(_varietyRepository.GetList());
            _palletsCache = new List<PalletEntity>(_palletRepository.GetList());
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
    }

    public async Task<Variety?> GetVarietyByCodeAsync(string code, int? layers = null)
    {
        var entity = layers != null
            ? _varietiesCache.FirstOrDefault(p => p.Code == code && p.StackingLayers == layers)
            : _varietiesCache.FirstOrDefault(v => v.Code == code);
        return entity is null ? null : Variety.Create(entity, _palletsCache.ToList());
    }

    public Task<Variety> GetById(int id)
    {
        var entity = _varietiesCache.FirstOrDefault(p => p.Id == id);
        return Task.FromResult(Variety.Create(entity, _palletsCache.ToList()));
    }

    public async Task AddVarietyAsync(Variety variety)
    {
        try
        {
            var entity = await _varietyRepository.InsertReturnEntityAsync(variety.ToEntity());
            _varietiesCache.Add(entity);
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
      
    }

    public async Task UpdateVarietyAsync(Variety variety)
    {
        await _varietyRepository.UpdateAsync(variety.ToEntity());
        _varietiesCache[_varietiesCache.IndexOf(variety.ToEntity())] = variety.ToEntity();
    }

    public async Task DeleteVarietyAsync(Variety variety)
    {
        await _varietyRepository.DeleteAsync(variety.ToEntity());
        _varietiesCache.Remove(variety.ToEntity());
    }

    public async Task<List<Pallet>> GetPalletsAsync()
    {
        return _palletsCache.Select(Pallet.FromEntity).ToList();
    }

    public async Task AddPalletAsync(Pallet pallet)
    {
        var entity = await _palletRepository.InsertReturnEntityAsync(pallet);
        _palletsCache.Add(entity);
    }

    public List<Variety> GetAll()
    {
        return _varietiesCache.Select(v => Variety.Create(v, _palletsCache.ToList())).ToList();
    }

    public async Task<int?> GetLastNo(int varietyId)
    {
        var variety = await (_varietyRepository.CopyNew().GetFirstAsync(x=>x.Id==varietyId));
        return variety.LastNo;
    }

    public async Task SetLastNo(int varietyId,int lastNo)
    {
        await _varietyRepository.CopyNew().AsUpdateable()
            .Where(x => x.Id == varietyId)
            .SetColumns(x => x.LastNo , lastNo)
            .ExecuteCommandAsync();
    }
}