jinko.yikatong/Src/Dlhis.Canteen/Order/Services/Implements/HainingBalanceService.cs

using Dlhis.Canteen.Order.Request;
using Dlhis.Canteen.Order.Response;
using Dlhis.Entity.Basic.Entity;
using Dlhis.Entity.Canteen.Entities;
using Dlhis.Entity.Canteen.Enums;
using Kurisu.AspNetCore.DataAccess.SqlSugar.Extensions;
using Kurisu.AspNetCore.DataAccess.SqlSugar.Services;
using Kurisu.AspNetCore.Utils.Extensions;
using SqlSugar;

namespace Dlhis.Canteen.Order.Services.Implements;

public class HainingBalanceService : IHainingBalanceService
{
    private readonly IDbContext _dbContext;

    public HainingBalanceService(IDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public async Task HainingImportAsync(BalanceHainingImportRequest request)
    {
        var gainfo = await _dbContext.Queryable<GainfoEntity>().Where(x => x.Code == request.UserCode).SingleAsync()
                     ?? await _dbContext.Queryable<GainfoLeaveEntity>().Where(x => x.Code == request.UserCode).SingleAsync();

        gainfo.ThrowIfNull($"工号{request.UserCode}不存在");
        var gainfoMeal = await _dbContext.Queryable<GainfoMealEntity>().Where(x => x.UserCode == request.UserCode).SingleAsync();
        if (gainfoMeal == null)
        {
            gainfoMeal = new GainfoMealEntity
            {
                UserNo = gainfo.No,
                UserCode = gainfo.Code,
                Balance = 0,
                BalanceOfRecharge = 0,
                BalanceOfSubsidies = 0,
                Version = 0
            };

            await _dbContext.InsertAsync(gainfoMeal);
        }

        var businessPlaceInfo = await _dbContext.Queryable<BusinessPlaceEntity>()
            .LeftJoin<BusinessPlaceShiftRelationshipEntity>((a, b) => a.Code == b.PlaceCode)
            .LeftJoin<BusinessShiftEntity>((a, b, c) => b.ShiftCode == c.Code)
            .Where((a, b, c) => a.CustomCode == request.BusinessPlaceCode)
            .Select((a, b, c) => new
            {
                a.Code,
                ShiftCode = c.Code,
                a.TenantId
            })
            .SingleAsync();

        if (request.Type == BalanceRecordTypeEnumType.Out)
        {
            businessPlaceInfo.ThrowIfNull($"营业点{request.BusinessPlaceCode}不存在");
        }

        await _dbContext.InsertAsync(new BalanceRecordEntity
        {
            Amount = request.Amount,
            ApplicationType = request.ApplicationType,
            Type = request.Type,
            BusinessPlaceCode = businessPlaceInfo?.Code,
            BusinessShiftCode = businessPlaceInfo?.ShiftCode,
            ShiftType = request.ShiftType,
            CostDate = request.CostDate,
            CostDateTime = request.CostDateTime,
            UserNo = gainfo.No,
            No = request.No,
            UserCode = gainfo.Code,
            Status = BalanceRecordStatusEnumType.Valid,
            Source = request.Source,
            Remark = request.Remark,
            CostId = gainfo.CostId,
            TenantId = businessPlaceInfo?.TenantId ?? request.Factory,
            OriginTenantId = gainfo.Factory,
            Werks = gainfo.Werks,
            Name = gainfo.Name,
            IsCostCrossTenant = false,
            DepartmentNo = gainfo.DepartmentNo,
            DeviceUniqueNo = request.DeviceUniqueNo,

            IsDeleted = false,
        });

        var newBalance = gainfoMeal.Balance += request.Amount;

        await _dbContext.Updateable<GainfoMealEntity>()
            .SetColumns(x => x.Balance == newBalance)
            .SetColumns(x => x.ModifiedBy == 1)
            .SetColumns(x => x.ModifiedTime == DateTime.Now)
            .SetColumns(x => x.Version == x.Version + 1)
            .Where(x => x.UserCode == request.UserCode && x.Version == gainfoMeal.Version)
            .ExecuteCommandThrowVersionAsync("写入失败,正在消费中");
    }

    public async Task<List<BalanceHainingDownloadResponse>> HainingDownloadAsync(string userCode)
    {
        return await _dbContext.Queryable<BalanceRecordEntity>()
            .LeftJoin<GainfoEntity>((record, ga) => record.UserNo == ga.No)
            .LeftJoin<DepartmentEntity>((record, ga, department) => ga.DepartmentNo == department.No)
            .LeftJoin<BusinessPlaceEntity>((record, ga, department, bPlace) => record.BusinessPlaceCode == bPlace.Code)
            .Where(record => record.Status == BalanceRecordStatusEnumType.Valid)
            .Where((record, ga) => ga.Code == userCode)
            .OrderBy(record => record.CreateTime, OrderByType.Desc)
            .Select((record, ga, department, bPlace) => new BalanceHainingDownloadResponse
            {
                No = record.No,
                Factory = record.TenantId,
                OriginFactory = record.OriginTenantId,
                Werks = record.Werks,
                DepartmentNo = record.DepartmentNo,
                DepartmentName = department.Name,
                CostDate = record.CostDate,
                CostDateTime = record.CostDateTime,
                Remark = record.Remark,
                Amount = SqlFunc.Abs(record.Amount),
                Type = record.Type,
                Source = record.Source,
                BusinessPlaceCode = bPlace.CustomCode,
                DeviceUniqueNo = record.DeviceUniqueNo
            })
            .ToListAsync();
    }
}