jinko.yikatong/Src/Dlhis.ScheduledTask/Jobs/MealSupplementHandlerJob.cs

using Dlhis.Canteen.Api;
using Dlhis.Canteen.Api.Request;
using Dlhis.Entity.Basic.Entity;
using Dlhis.Entity.Basic.Enums;
using Dlhis.Entity.Canteen.Entities;
using Dlhis.ScheduledTask.SyncSapInfo;
using Dlhis.ScheduledTask.SyncSapInfo.Services;
using Kurisu.AspNetCore.UnifyResultAndValidation;
using Kurisu.AspNetCore.Utils.Extensions;
using Kurisu.Scheduled;
using Kurisu.Scheduled.Attributes;
using SqlSugar;

namespace Dlhis.ScheduledTask.Jobs;

/// <summary>
/// 餐补核算
/// </summary>
[RecurringJob(nameof(MealSupplementHandlerJob), "0 0/30 * * * ?", Name = "餐补核算")]
public class MealSupplementHandlerJob : BaseJob
{
    private readonly IHainingMealSupplementApi _hainingMealSupplementApi;
    private readonly IJinkoJIPService _jinkoJIPService;

    public MealSupplementHandlerJob(IServiceProvider serviceProvider, IHainingMealSupplementApi hainingMealSupplementApi, IJinkoJIPService jinkoJIPService) : base(serviceProvider)
    {
        _hainingMealSupplementApi = hainingMealSupplementApi;
        _jinkoJIPService = jinkoJIPService;
    }

    public override async Task RunAsync(IServiceProvider serviceProvider)
    {
        //查询待处理餐补
        var mealSupplements = await DbContext.Queryable<MealSupplementRecordEntity>()
            .Where(x => (x.Status == MealSupplementStatusEnumtype.Wait || x.Status == MealSupplementStatusEnumtype.Error) && !x.Sync)
            .ToListAsync();

        foreach (var item in mealSupplements)
        {
            GainfoMealEntity mealUser = null;
            var gainfo = await DbContext.Queryable<GainfoEntity>().Where(x => x.Code == item.Code).SingleAsync();
            //档案不存在
            if (gainfo == null)
            {
                await DbContext.Updateable<MealSupplementRecordEntity>()
                            .SetColumns(x => x.Status == MealSupplementStatusEnumtype.Error)
                            .SetColumns(x => x.Result == "人员档案不存在")
                            .SetColumns(x => x.ModifiedTime == DateTime.Now)
                            .Where(x => x.UniqueId == item.UniqueId)
                            .ExecuteCommandAsync();
                continue;
            }
            else
            {
                //创建余额数据
                mealUser = await DbContext.Queryable<GainfoMealEntity>().Where(x => x.UserCode == gainfo.Code).SingleAsync();
                if (mealUser == null)
                {
                    mealUser = new GainfoMealEntity
                    {
                        Balance = 0,
                        BalanceOfRecharge = 0,
                        BalanceOfSubsidies = 0,
                        UserNo = gainfo.No,
                        UserCode = gainfo.Code,
                        Version = 0,
                        TenantId = gainfo.Factory,
                    };

                    await DbContext.InsertAsync(mealUser);
                }
            }

            if (item.Workplace == "5")
            {
                await SetHainingMealSupplementAsync(item);
            }
            else
            {
                await SetMealSupplementAsync(item);
            }
        }
    }

    private async Task SetMealSupplementAsync(MealSupplementRecordEntity mealSupplement)
    {
        await DbContext.Client.Ado.BeginTranAsync();
        try
        {
            await ContinueUpdateAsync(async () =>
            {
                var mealUser = await DbContext.Queryable<GainfoMealEntity>().Where(x => x.UserCode == mealSupplement.Code).FirstAsync();
                var b = mealUser.Balance += mealSupplement.Amount;

                var effect = await DbContext.Updateable<GainfoMealEntity>()
                    .SetColumns(x => x.Balance == b)
                    .SetColumns(x => x.ModifiedTime == DateTime.Now)
                    .Where(x => x.UserCode == mealUser.UserCode && x.Version == mealUser.Version)
                    .ExecuteCommandAsync();

                if (effect <= 0)
                {
                    throw new VersionExceptions("餐补写入错误");
                }

            }, 5);

            //更新餐补信息为成功(同步成功)
            await DbContext.Updateable<MealSupplementRecordEntity>()
                .SetColumns(x => x.Status == MealSupplementStatusEnumtype.Sucess)
                .SetColumns(x => x.Sync == true)
                .SetColumns(x => x.ModifiedTime == DateTime.Now)
                .Where(x => x.UniqueId == mealSupplement.UniqueId)
                .ExecuteCommandAsync();

            var r = await _jinkoJIPService.SyncMealSupplementRecordsAsync(new List<SyncMealSupplementRecordRequest>
            {
                new()
                {
                     UniqueId = mealSupplement.UniqueId,
                     Status = "SUCCESS",
                     Msg = "操作成功"
                }
            });

            await DbContext.Updateable<MealSupplementRecordEntity>()
                .SetColumns(x => x.Result == r)
                .SetColumns(x => x.ModifiedTime == DateTime.Now)
                .Where(x => x.UniqueId == mealSupplement.UniqueId)
                .ExecuteCommandAsync();

            await DbContext.Client.Ado.CommitTranAsync();
        }
        catch (Exception ex)
        {
            await DbContext.Client.Ado.RollbackTranAsync();

            await DbContext.Updateable<MealSupplementRecordEntity>()
                .SetColumns(x => x.Status == MealSupplementStatusEnumtype.Error)
                .SetColumns(x => x.Result == ex.Message)
                .SetColumns(x => x.ModifiedTime == DateTime.Now)
                .Where(x => x.UniqueId == mealSupplement.UniqueId)
                .ExecuteCommandAsync();
        }
    }


    private async Task SetHainingMealSupplementAsync(MealSupplementRecordEntity mealSupplement)
    {
        await DbContext.Client.Ado.BeginTranAsync();
        try
        {
            var hnResponse = await _hainingMealSupplementApi.AddMealSupplementAsync(new AddHainingMealSupplementRequest
            {
                Code = mealSupplement.Code,
                Amount = mealSupplement.Amount,
                Date = mealSupplement.Date,
                Remark = mealSupplement.Remark,
                UniqueId = mealSupplement.UniqueId,
            });

            (hnResponse == null || hnResponse.Code != 200).ThrowIfTrue("海宁餐补写入失败:" + hnResponse?.Message);

            //更新餐补信息为成功(同步成功)
            await DbContext.Updateable<MealSupplementRecordEntity>()
                .SetColumns(x => x.Status == MealSupplementStatusEnumtype.Sucess)
                .SetColumns(x => x.Sync == true)
                .SetColumns(x => x.ModifiedTime == DateTime.Now)
                .Where(x => x.UniqueId == mealSupplement.UniqueId)
                .ExecuteCommandAsync();

            var r = await _jinkoJIPService.SyncMealSupplementRecordsAsync(new List<SyncMealSupplementRecordRequest>
            {
                new()
                {
                     UniqueId = mealSupplement.UniqueId,
                     Status = "SUCCESS",
                     Msg = "操作成功"
                }
            });

            await DbContext.Updateable<MealSupplementRecordEntity>()
                .SetColumns(x => x.Result == r)
                .SetColumns(x => x.ModifiedTime == DateTime.Now)
                .Where(x => x.UniqueId == mealSupplement.UniqueId)
                .ExecuteCommandAsync();

            await DbContext.Client.Ado.CommitTranAsync();
        }
        catch (Exception ex)
        {
            await DbContext.Client.Ado.RollbackTranAsync();

            await DbContext.Updateable<MealSupplementRecordEntity>()
                .SetColumns(x => x.Status == MealSupplementStatusEnumtype.Error)
                .SetColumns(x => x.Result == ex.Message)
                .SetColumns(x => x.ModifiedTime == DateTime.Now)
                .Where(x => x.UniqueId == mealSupplement.UniqueId)
                .ExecuteCommandAsync();
        }
    }

    private async Task ContinueUpdateAsync(Func<Task> func, int retry, string errorMessage = null)
    {
        for (int i = 0; i < retry; i++)
        {
            try
            {
                await func();
                return;
            }
            catch (Exception ex) when (ex is VersionExceptions)
            {
                Logger.LogWarning(ex, ex.Message);
            }
            catch (Exception)
            {
                throw;
            }
        }

        throw new UserFriendlyException(errorMessage ?? "操作失败,请重试");
    }
}