ql_apimanager_backend/Apimanager_backend/Services/PackageService.cs

using Apimanager_backend.Data;
using Apimanager_backend.Dtos;
using Apimanager_backend.Exceptions;
using Apimanager_backend.Models;
using AutoMapper;
using AutoMapper.Configuration.Annotations;
using Microsoft.EntityFrameworkCore;

namespace Apimanager_backend.Services
{
    public class PackageService : IPackageService
    {
        private readonly ApiContext apiContext;
        private readonly ILogger<PackageService> logger;
        private readonly IMapper mapper;
        public PackageService(ApiContext apiContext,ILogger<PackageService> logger,IMapper mapper)
        {
            this.apiContext = apiContext;
            this.logger = logger;
            this.mapper = mapper;
        }
        #region 新增套餐
        public async Task<PackageInfoDto> AddPackageAsync(AddPackageDto addPackageDto)
        {
            var packageInfo = mapper.Map<Apipackage>(addPackageDto);
            apiContext.Apipackages.Add(packageInfo);
            await apiContext.SaveChangesAsync();
            return mapper.Map<PackageInfoDto>(packageInfo);
        }
        #endregion
        #region 增加用户订阅套餐
        public async Task<UserPackage> AddUserPackageTimeAsync(int packageId,int userId,TimeSpan time,bool isAdmin)
        {
            await using var transaction = await apiContext.Database.BeginTransactionAsync();
            try
            {
                //查询用户名下有无对应套餐
                var userPackageInfo = await apiContext.UserPackages.FirstOrDefaultAsync(
                    x => x.PackageId == packageId && x.UserId == userId
                    );
                //查询套餐是否存在
                var packageInfo = await apiContext.Apipackages.FirstOrDefaultAsync(x => x.Id == packageId);
                if (packageInfo == null)
                {
                    throw new BaseException(4004,"套餐不存在");
                }
                //查询用户是否存在
                var user = await apiContext.Users.FirstOrDefaultAsync(x => x.Id == userId);
                if (user == null)
                {
                    throw new BaseException(2004,"用户不存在");
                }
                //如果没有对应套餐关联则新建
                if (userPackageInfo == null)
                {
                    userPackageInfo = new UserPackage
                    {
                        PackageId = packageId,
                        UserId = userId,
                        ExpiryDate = DateTime.UtcNow + time,
                    };
                    apiContext.UserPackages.Add(userPackageInfo);
                }
                else
                {
                    //否则直接在关联记录上添加有效期
                    userPackageInfo.ExpiryDate += time;
                    apiContext.UserPackages.Update(userPackageInfo);
                }
                if (!isAdmin)
                {
                    //扣除对应用户余额
                    user.Balance -= packageInfo.Price * time.Days;
                    apiContext.Users.Update(user);
                }
                await apiContext.SaveChangesAsync();
                await transaction.CommitAsync();
                return userPackageInfo;
            } catch (Exception)
            {
                await transaction.RollbackAsync();
                throw;
            }
            
        }
        #endregion
        #region 扣除用户订阅套餐

        public async Task<UserPackage> DecuteUserPackageTimeAsync(int packageId,int userId, TimeSpan time)
        {
            await using var transaction = await apiContext.Database.BeginTransactionAsync();
            try
            {
                //查询用户名下有无对应套餐
                var userPackageInfo = await apiContext.UserPackages.FirstOrDefaultAsync(
                    x => x.PackageId == packageId && x.UserId == userId
                    );
                //如果没有对应套餐则返回错误信息
                if (userPackageInfo == null)
                {
                    throw new BaseException(4004,"套餐未找到");
                }
                //否则直接在关联记录上添加有效期
                userPackageInfo.ExpiryDate -= time;
                apiContext.UserPackages.Update(userPackageInfo);
                await apiContext.SaveChangesAsync();
                await transaction.CommitAsync();
                return userPackageInfo;
            }
            catch (Exception)
            {
                await transaction.RollbackAsync();
                throw;
            }
        }
        #endregion
        #region 删除套餐
        public async Task DeletePackageAsync(int packageId)
        {
            await using var transaction = await apiContext.Database.BeginTransactionAsync();
            try
            {
                var packageInfo = await apiContext.Apipackages.FirstOrDefaultAsync(x => x.Id == packageId);
                if (packageInfo == null)
                {
                    throw new BaseException(4004, "套餐未找到");
                }
                packageInfo.IsDeleted = true;
                apiContext.Apipackages.Update(packageInfo);
                await apiContext.SaveChangesAsync();
                await transaction.CommitAsync();
            }catch(Exception)
            {
                transaction.Rollback();
                throw;
            }
        }
        #endregion
        #region 获取套餐列表
        public async Task<List<PackageInfoDto>> GetAllPackagesAsync(int pageIndex, int pageSize, bool desc)
        {
            IQueryable<Apipackage> query = apiContext.Apipackages.Include(x => x.ApiPackageItems).ThenInclude(x => x.Api).Where(x => true).OrderBy(x => x.Id);
            if(desc)
            {
                query = query.OrderDescending();
            }
            query = query.Skip((pageIndex - 1) * pageSize).Take(pageSize);
            var list = await query.ToListAsync();
            return mapper.Map<List<PackageInfoDto>>(list);
        }
        #endregion
        #region 获取用户订阅套餐列表
        public async Task<List<UserPackage>> GetUserPackagesAsync(int userId)
        {
            var userpackageInfo = await apiContext.UserPackages.Where(x => x.UserId == userId).ToListAsync();
            return userpackageInfo;
        }
        #endregion
        #region 获取套餐信息
        public async Task<PackageInfoDto> PackageInfoByIdAsync(int packageId)
        {
            var packageInfo = await apiContext.Apipackages.FirstOrDefaultAsync(x => x.Id == packageId);
            if (packageInfo == null)
            {
                throw new BaseException(4004, "套餐未找到");
            }
            return mapper.Map<PackageInfoDto>(packageInfo);
        }
        #endregion
        #region 更新套餐信息
        public async Task<PackageInfoDto> UpdatePackageAsync(int packageId, UpdatePackageDto updatePackageDto)
        {
            await using var transaction = await apiContext.Database.BeginTransactionAsync();
            try
            {
                //查询对应套餐
                var packageInfo = await apiContext.Apipackages.FirstOrDefaultAsync(x => x.Id == packageId);
                if (packageInfo == null)
                {
                    throw new BaseException(4004, "Success");
                }
                //更新字段
                packageInfo.Name = updatePackageDto.Name ?? packageInfo.Name;
                packageInfo.CallLimit = updatePackageDto.CallLimit != null ? updatePackageDto.CallLimit.Value : packageInfo.CallLimit;
                packageInfo.OneMinuteLimit = updatePackageDto.OneMinuteLimit != null ? updatePackageDto.OneMinuteLimit.Value : packageInfo.OneMinuteLimit;
                packageInfo.Price = updatePackageDto.Price != null ? updatePackageDto.Price.Value : packageInfo.Price;
                //更新
                apiContext.Apipackages.Update(packageInfo);
                await apiContext.SaveChangesAsync();
                await transaction.CommitAsync();
                return mapper.Map<PackageInfoDto>(packageInfo);
            }
            catch (Exception)
            {
                await transaction.RollbackAsync();
                throw;
            }
        }
        #endregion
        #region 设置API关联套餐
        public async Task<bool> SetApiPackageItemAsync(int apiId, int packageId)
        {
            var api = await apiContext.Apis.SingleOrDefaultAsync(x => x.Id == apiId);
            if(api == null)
            {
                throw new BaseException(1004,"API不存在");
            }
            var package = await apiContext.Apipackages.SingleOrDefaultAsync(x => x.Id == packageId);
            if(package is null)
            {
                throw new BaseException(1004,"套餐不存在");
            }
            apiContext.apiPackageItems.Add(new ApiPackageItem() { ApiPackageId = package.Id,ApiId = api.Id});
            await apiContext.SaveChangesAsync();
            return true;
        }
        #endregion
    }
}