yuangb/jinko.yikatong
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix 修复已知问题

Browse Source
This commit is contained in:
liguoyang
2024-07-31 10:15:17 +08:00
parent e79e7acb97
commit e0770140b4
35 changed files with 695 additions and 556 deletions
Download Patch File Download Diff File Expand all files Collapse all files

625
Src/Dlhis.Canteen/Order/Services/Implements/OrderService.cs
View File

@@ -36,88 +36,31 @@ public class OrderService : BaseOrderService, IOrderService
_serviceProvider = serviceProvider;
}
/// <summary>
/// 设备消费
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task<OrderResultResponseWithLogs> DeviceConsume(OrderAddRequest request)
{
return await AddAsync(request);
}
/// <summary>
/// 设备消费
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task<OrderResultResponseWithLogs> AddAsync(OrderAddRequest request)
{
_sw = new Stopwatch();
//尝试匹配userId
var s = long.TryParse(request.UserUniqueNo, out var userId);
//根据档案号
var gainfo = await DbContext.Queryable<GainfoEntity>()
.WhereIF(request.Source == BalanceRecordSourceEnumType.Card, x => x.CardNo == request.UserUniqueNo)
.WhereIF(request.Source != BalanceRecordSourceEnumType.Card && !request.IsUserId, x => x.Code == request.UserUniqueNo)
.WhereIF(request.Source != BalanceRecordSourceEnumType.Card && request.IsUserId && s, x => x.Id == userId)
.SingleAsync();
if (gainfo == null && request.IsOffline)
{
gainfo = await DbContext.Queryable<GainfoEntity>().AS("GainfoLeave")
.WhereIF(request.Source == BalanceRecordSourceEnumType.Card, x => x.CardNo == request.UserUniqueNo)
.WhereIF(request.Source != BalanceRecordSourceEnumType.Card && !request.IsUserId, x => x.Code == request.UserUniqueNo)
.WhereIF(request.Source != BalanceRecordSourceEnumType.Card && request.IsUserId && s, x => x.IdentityUserId == userId)
.FirstAsync();
}
var gainfo = await GetUserAsync(request);
_logs.Add("获取人员耗时:" + _sw.ElapsedMilliseconds);
_sw.Restart();
var message = string.Empty;
if (request.IsOffline)
{
if (request.ThirdNo.IsPresent())
{
var redisCache = _serviceProvider.GetService<RedisCache>();
await using var handler = await redisCache.LockAsync($"consume:device:{request.ThirdNo}");
if (handler.Acquired)
{
if (await ToCheckAsync(request.ThirdNo))
{
try
{
await HandleOfflineAsync(request.Adapt<ConsumeRequest>(), gainfo);
}
catch (Exception ex)
{
Logger.LogError(ex, "离线入库错误: 订单号:{no} .{message}", request.ThirdNo, ex.Message);
}
}
}
}
else
{
try
{
await HandleOfflineAsync(request.Adapt<ConsumeRequest>(), gainfo);
}
catch (Exception ex)
{
Logger.LogError(ex, "离线入库错误: 订单号:{no} .{message}", request.ThirdNo, ex.Message);
}
}
}
else
{
gainfo.ThrowIfNull("无消费权限");
try
{
(await DbContext.Queryable<GainfoMealEntity>().Where(x => x.UserCode == gainfo.Code).AnyAsync()).ThrowIfFalse("就餐余额不足");
await ConsumeAsync(request.Adapt<ConsumeRequest>(), gainfo);
}
catch (Exception ex)
{
message = ex.Message;
}
}
var message = await ToDoAsync(request, gainfo);
//获取人员余额
var data = await DbContext.Queryable<GainfoMealEntity>()
@@ -151,7 +94,262 @@ public class OrderService : BaseOrderService, IOrderService
};
}
private async Task<bool> ToCheckAsync(string thirdNo)
public async Task<Pagination<OrderAggregationResponse>> GetOrdersAggregationAsync(PageDto page)
{
var subjectId = CurrentUser.GetIntSubjectId();
var gainfo = await DbContext.Queryable<GainfoEntity>().Where(x => x.IdentityUserId == subjectId).FirstAsync();
var jinkoCode = CurrentUser.GetUserClaim("jinko-code") ?? string.Empty;
if (jinkoCode.IsPresent())
{
gainfo = await DbContext.Queryable<GainfoEntity>().Where(x => x.Code == jinkoCode).FirstAsync();
}
var pageResult = await DbContext.Queryable<CanteenOrderEntity>().Where(x => x.UserNo == gainfo.No)
.LeftJoin<BusinessPlaceEntity>((x, bPlace) => x.BusinessPlaceCode == bPlace.Code)
.Where(x => x.ApplicationType == CanteenApplicationTypeEnumType.Booking)
.OrderBy(x => x.CreateTime, OrderByType.Desc)
.Select((x, bPlace) => new OrderAggregationResponse
{
No = x.No,
BusinessPlaceName = bPlace.Name,
CreateTime = x.CreateTime,
Remark = x.Remark,
OrderStatus = x.OrderStatus,
})
.ToPageListAsync(page);
var nos = pageResult.Data.Select(x => x.No).ToList();
var dtos = await DbContext.Queryable<CanteenOrderDetailEntity>()
.LeftJoin<DishesEntity>((x, d) => x.DishesCode == d.CustomCode)
.Where(x => nos.Contains(x.OrderNo))
.Select((x, d) => new DishesDto
{
No = x.OrderNo,
DishesCode = x.DishesCode,
Name = d.Name,
ImageUrl = d.ImageUrl,
Number = x.Number,
Price = x.Price,
})
.ToListAsync();
pageResult.Data.ForEach(item => { item.Dishes = dtos.Where(x => x.No == item.No).ToList(); });
return pageResult;
}
//******************************************************* help methods ************************************************************/
/// <summary>
/// 获取当前消费人员
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private async Task<GainfoEntity> GetUserAsync(OrderAddRequest request)
{
//尝试匹配userId
var s = long.TryParse(request.UserUniqueNo, out var userId);
GainfoEntity gainfo = null;
if (request.Source == BalanceRecordSourceEnumType.QrCode)
{
if (request.UserUniqueNo.StartsWith("01"))
{
gainfo = await GetUserByQrCodeAsync(request.UserUniqueNo);
}
else if (request.UserUniqueNo.StartsWith("02"))
{
request.Source = BalanceRecordSourceEnumType.EVoucher;
}
}
else
{
//根据档案号
gainfo = await DbContext.Queryable<GainfoEntity>()
.WhereIF(request.Source == BalanceRecordSourceEnumType.Card, x => x.CardNo == request.UserUniqueNo)
.WhereIF(request.Source != BalanceRecordSourceEnumType.Card && !request.IsUserId, x => x.Code == request.UserUniqueNo)
.WhereIF(request.Source != BalanceRecordSourceEnumType.Card && request.IsUserId && s, x => x.Id == userId)
.SingleAsync();
}
//在线
if (!request.IsOffline)
{
gainfo.ThrowIfNull("无法识别,无权消费");
}
if (request.IsOffline)
{
//兼容hpt尚未删除人员后产生的消费数据
gainfo ??= await DbContext.Queryable<GainfoEntity>().AS("GainfoLeave")
.WhereIF(request.Source == BalanceRecordSourceEnumType.Card, x => x.CardNo == request.UserUniqueNo)
.WhereIF(request.Source != BalanceRecordSourceEnumType.Card && !request.IsUserId, x => x.Code == request.UserUniqueNo)
.WhereIF(request.Source != BalanceRecordSourceEnumType.Card && request.IsUserId && s, x => x.IdentityUserId == userId)
.FirstAsync();
}
return gainfo;
}
/// <summary>
/// 获取成本日期
/// </summary>
/// <param name="shift"></param>
/// <param name="costDateTime"></param>
/// <returns></returns>
private async Task<DateTime> GetCostDateAsync(BusinessShiftMealRelationshipEntity shift, DateTime costDateTime)
{
var switchTime = await GetSettingAsync<TimeOnly?>(string.Empty, shift.TenantId, CanteenSettingItemEnumType.BusinessSwitchTime);
var costDate = costDateTime.Date;
if (!switchTime.HasValue)
{
return costDate;
}
var beginOfDay = costDateTime.Date;
var setTime = beginOfDay.Add(switchTime.Value.ToTimeSpan());
if (costDateTime < setTime)
costDate = costDateTime.Date.AddDays(-1);
return costDate;
}
/// <summary>
/// 验证参数
/// </summary>
/// <param name="order"></param>
/// <returns></returns>
/// <exception cref="UserFriendlyException"></exception>
private async Task Verify(CanteenOrderEntity order)
{
var beginOfDay = DateTime.Today;
var endOfDay = beginOfDay.AddDays(1).AddSeconds(-1);
//今天所有消费记录
var todayAllBalanceRecords = await DbContext.Queryable<BalanceRecordEntity>()
.Where(x => x.UserNo == order.UserNo)
.Where(x => x.Type == BalanceRecordTypeEnumType.Out)
.Where(x => x.Status == BalanceRecordStatusEnumType.Valid)
.Where(x => x.CreateTime >= beginOfDay && x.CreateTime <= endOfDay)
.ToListAsync();
//超市营业点
var supermarketCodes = await DbContext.Queryable<BusinessPlaceEntity>()
.Where(x => x.Catalog == CanteenBusinessPlaceCatalogEnumType.Supermarket)
.Select(x => x.Code)
.ToListAsync();
//一天消费金额
var dayCostMax = await GetSettingAsync<decimal>(order.UserNo, order.TenantId, CanteenSettingItemEnumType.DayCostMax);
if (dayCostMax != default)
{
//消费记录一定会有营业点代码!.Value是安全用法
var cost = todayAllBalanceRecords
.Where(x => !supermarketCodes.Contains(x.BusinessPlaceCode!.Value)) //filter supermarket
.Sum(x => Math.Abs(x.Amount));
(cost + Math.Abs(order.Amount) > dayCostMax).ThrowIfTrue($"超出当天消费限制{dayCostMax}元,无法消费");
}
//一次消费金额
var onceCostMax = await GetSettingAsync<decimal>(order.UserNo, order.TenantId, CanteenSettingItemEnumType.OnceCostMax);
if (onceCostMax != default)
{
(Math.Abs(order.Amount) > onceCostMax).ThrowIfTrue($"单次消费金额不能超出{onceCostMax}元");
}
//超市消费限额
if (order.BusinessPlaceCode.HasValue && supermarketCodes.Contains(order.BusinessPlaceCode.Value))
{
var dayMarketCostMax = await GetSettingAsync<decimal>(order.UserNo, order.TenantId, CanteenSettingItemEnumType.DayMarketCostMax);
if (dayMarketCostMax != default)
{
var cost = todayAllBalanceRecords.Where(x => x.BusinessPlaceCode.HasValue)
.Where(x => supermarketCodes.Contains(x.BusinessPlaceCode.Value))
.Sum(x => Math.Abs(x.Amount));
(cost + Math.Abs(order.Amount) > dayMarketCostMax).ThrowIfTrue($"超出当天超市消费限制{dayMarketCostMax},无法消费");
}
}
//重复餐次消费
var allowRepeatInOneShift = await GetSettingAsync(order.UserNo, order.TenantId, CanteenSettingItemEnumType.AllowRepeatInOneShift, true);
if (!allowRepeatInOneShift)
{
var costCount = todayAllBalanceRecords.Count(x => x.ShiftType == order.ShiftType);
(costCount > 1).ThrowIfTrue($"{order.ShiftType?.GetDescription()}不允许多次消费");
}
}
/// <summary>
/// 生成充值记录
/// </summary>
/// <param name="orderId"></param>
/// <returns></returns>
/// <exception cref="UserFriendlyException"></exception>
/// <exception cref="VersionExceptions"></exception>
private async Task GenerateConsumeRecordAsync(long orderId)
{
var order = await DbContext.Queryable<CanteenOrderEntity>().Where(x => x.Id == orderId).SingleAsync();
//校验
await Verify(order);
_logs.Add("消费请求校验:" + _sw.ElapsedMilliseconds);
_sw.Restart();
await CommonHelper.RetryAsync(async () =>
{
var gainfoMeal = await DbContext.Queryable<GainfoMealEntity>().Where(x => x.UserNo == order.UserNo).SingleAsync();
//金额+-
gainfoMeal.Balance += order.Amount;
(gainfoMeal.Balance < 0).ThrowIfTrue("余额不足,无法消费");
await DbContext.Updateable<GainfoMealEntity>()
.SetColumns(x => x.Balance == gainfoMeal.Balance)
.SetColumns(x => x.Version == x.Version + 1)
.SetColumns(x => x.ModifiedTime == DateTime.Now)
.Where(x => x.UserNo == order.UserNo && x.Version == gainfoMeal.Version) //必须与查询时的version一致
.ExecuteCommandThrowVersionAsync();
//写入记录
var balanceRecord = order.Adapt<BalanceRecordEntity>();
await DbContext.InsertAsync(balanceRecord);
}, 5);
_logs.Add("消费写入:" + _sw.ElapsedMilliseconds);
_sw.Restart();
}
/// <summary>
/// 根据二维码获取消费用户
/// </summary>
/// <param name="qrCode"></param>
/// <returns></returns>
private async Task<GainfoEntity> GetUserByQrCodeAsync(string qrCode)
{
var gainfoQrCode = await DbContext.Queryable<GainfoQrCodeEntity>().Where(x => x.QrCode == qrCode).SingleAsync();
gainfoQrCode.ThrowIfNull("消费码已过期");
(gainfoQrCode.ModifiedTime.AddMinutes(1) > DateTime.Now).ThrowIfTrue("消费码已过期");
return await DbContext.Queryable<GainfoEntity>().Where(x => x.Code == gainfoQrCode.UserCode).SingleAsync();
}
/// <summary>
/// 检查是否可以离线消费
/// </summary>
/// <param name="thirdNo"></param>
/// <returns></returns>
private async Task<bool> ToCheckAbleOfflineConsumeAsync(string thirdNo)
{
var order = await DbContext.Queryable<CanteenOrderEntity>()
.Where(x => x.ThirdNo == thirdNo)
@@ -163,15 +361,15 @@ public class OrderService : BaseOrderService, IOrderService
return true;
}
if (!order.IsOffline && order.OrderStatus != CanteenOrderStatusEnumType.Success)
{
return true;
}
return false;
//存在在线order数据,但是状态未成功
return !order.IsOffline && order.OrderStatus != CanteenOrderStatusEnumType.Success;
}
/// <summary>
/// 离线消费处理
/// </summary>
/// <param name="request"></param>
/// <param name="gainfo"></param>
private async Task HandleOfflineAsync(ConsumeRequest request, GainfoEntity gainfo)
{
var registry = await DbContext.Queryable<DeviceRegistryEntity>()
@@ -240,34 +438,26 @@ public class OrderService : BaseOrderService, IOrderService
await DbContext.InsertReturnIdentityAsync(order);
var allowNoBalance = await GetSettingAsync<bool>(gainfo.No, businessPlaceInfo.TenantId, CanteenSettingItemEnumType.AllowNoBalance);
await CommonHelper.RetryAsync(async () =>
{
if (!allowNoBalance)
var redisCache = _serviceProvider.GetService<RedisCache>();
await using var handler = await redisCache.LockAsync($"gainfo:meal:{order.UserNo}", retryInterval: TimeSpan.FromSeconds(1));
if (handler.Acquired)
{
GainfoMealEntity gainfoMeal = null;
var redisCache = _serviceProvider.GetService<RedisCache>();
using (var handler = await redisCache.LockAsync($"gainfo:meal:{order.UserNo}", retryInterval: TimeSpan.FromSeconds(1)))
var gainfoMeal = await DbContext.Queryable<GainfoMealEntity>().Where(x => x.UserNo == order.UserNo).FirstAsync();
if (gainfoMeal == null)
{
if (handler.Acquired)
gainfoMeal = new GainfoMealEntity
{
gainfoMeal = await DbContext.Queryable<GainfoMealEntity>().Where(x => x.UserNo == order.UserNo).FirstAsync();
if (gainfoMeal == null)
{
gainfoMeal = new GainfoMealEntity
{
Balance = 0,
BalanceOfRecharge = 0,
BalanceOfSubsidies = 0,
Version = 0,
UserNo = order.UserNo,
UserCode = order.UserCode,
};
Balance = 0,
BalanceOfRecharge = 0,
BalanceOfSubsidies = 0,
Version = 0,
UserNo = order.UserNo,
UserCode = order.UserCode,
};
await DbContext.InsertAsync(gainfoMeal);
}
}
await DbContext.InsertAsync(gainfoMeal);
}
//金额+-
@@ -279,11 +469,11 @@ public class OrderService : BaseOrderService, IOrderService
.SetColumns(x => x.ModifiedTime == DateTime.Now)
.Where(x => x.UserNo == order.UserNo && x.Version == gainfoMeal.Version) //必须与查询时的version一致
.ExecuteCommandThrowVersionAsync();
}
//写入记录
var balanceRecord = order.Adapt<BalanceRecordEntity>();
await DbContext.InsertAsync(balanceRecord);
//写入记录
var balanceRecord = order.Adapt<BalanceRecordEntity>();
await DbContext.InsertAsync(balanceRecord);
}
}, 5);
}
@@ -372,7 +562,7 @@ public class OrderService : BaseOrderService, IOrderService
var orderId = await DbContext.InsertReturnIdentityAsync(order);
_logs.Add("临时order写入:" + _sw.ElapsedMilliseconds);
_sw.Restart();
try
{
await GenerateConsumeRecordAsync(orderId);
@@ -409,196 +599,63 @@ public class OrderService : BaseOrderService, IOrderService
}
}
public async Task<Pagination<OrderAggregationResponse>> GetOrdersAggregationAsync(PageDto page)
{
var subjectId = CurrentUser.GetIntSubjectId();
var gainfo = await DbContext.Queryable<GainfoEntity>().Where(x => x.IdentityUserId == subjectId).FirstAsync();
var jinkoCode = CurrentUser.GetUserClaim("jinko-code") ?? string.Empty;
if (jinkoCode.IsPresent())
{
gainfo = await DbContext.Queryable<GainfoEntity>().Where(x => x.Code == jinkoCode).FirstAsync();
}
var pageResult = await DbContext.Queryable<CanteenOrderEntity>().Where(x => x.UserNo == gainfo.No)
.LeftJoin<BusinessPlaceEntity>((x, bPlace) => x.BusinessPlaceCode == bPlace.Code)
.Where(x => x.ApplicationType == CanteenApplicationTypeEnumType.Booking)
.OrderBy(x => x.CreateTime, OrderByType.Desc)
.Select((x, bPlace) => new OrderAggregationResponse
{
No = x.No,
BusinessPlaceName = bPlace.Name,
CreateTime = x.CreateTime,
Remark = x.Remark,
OrderStatus = x.OrderStatus,
})
.ToPageListAsync(page);
var nos = pageResult.Data.Select(x => x.No).ToList();
var dtos = await DbContext.Queryable<CanteenOrderDetailEntity>()
.LeftJoin<DishesEntity>((x, d) => x.DishesCode == d.CustomCode)
.Where(x => nos.Contains(x.OrderNo))
.Select((x, d) => new DishesDto
{
No = x.OrderNo,
DishesCode = x.DishesCode,
Name = d.Name,
ImageUrl = d.ImageUrl,
Number = x.Number,
Price = x.Price,
})
.ToListAsync();
pageResult.Data.ForEach(item => { item.Dishes = dtos.Where(x => x.No == item.No).ToList(); });
return pageResult;
}
//******************************************************* help methods ************************************************************/
/// <summary>
/// 获取成本日期
/// 分支处理在线/离线消费
/// </summary>
/// <param name="shift"></param>
/// <param name="costDateTime"></param>
/// <param name="request"></param>
/// <param name="gainfo"></param>
/// <returns></returns>
private async Task<DateTime> GetCostDateAsync(BusinessShiftMealRelationshipEntity shift, DateTime costDateTime)
private async Task<string> ToDoAsync(OrderAddRequest request, GainfoEntity gainfo)
{
var switchTime = await GetSettingAsync<TimeOnly?>(string.Empty, shift.TenantId, CanteenSettingItemEnumType.BusinessSwitchTime);
var costDate = costDateTime.Date;
if (switchTime.HasValue)
var message = "消费成功";
if (request.IsOffline)
{
var beginOfDay = costDateTime.Date;
var setTime = beginOfDay.Add(switchTime.Value.ToTimeSpan());
if (costDateTime < setTime)
costDate = costDateTime.Date.AddDays(-1);
}
return costDate;
}
/// <summary>
/// 验证参数
/// </summary>
/// <param name="order"></param>
/// <returns></returns>
/// <exception cref="UserFriendlyException"></exception>
private async Task Verify(CanteenOrderEntity order)
{
var beginOfDay = DateTime.Today;
var endOfDay = beginOfDay.AddDays(1).AddSeconds(-1);
//今天所有消费记录
var todayAllBalanceRecords = await DbContext.Queryable<BalanceRecordEntity>()
.Where(x => x.UserNo == order.UserNo)
.Where(x => x.Type == BalanceRecordTypeEnumType.Out)
.Where(x => x.Status == BalanceRecordStatusEnumType.Valid)
.Where(x => x.CreateTime >= beginOfDay && x.CreateTime <= endOfDay)
.ToListAsync();
//超市营业点
var supermarketCodes = await DbContext.Queryable<BusinessPlaceEntity>()
.Where(x => x.Catalog == CanteenBusinessPlaceCatalogEnumType.Supermarket)
.Select(x => x.Code)
.ToListAsync();
//一天消费金额
var dayCostMax = await GetSettingAsync<decimal>(order.UserNo, order.TenantId, CanteenSettingItemEnumType.DayCostMax);
if (dayCostMax != default)
{
//must has business place code, use .Value is safe
var cost = todayAllBalanceRecords
.Where(x => !supermarketCodes.Contains(x.BusinessPlaceCode.Value)) //filter supermarket
.Sum(x => Math.Abs(x.Amount));
(cost + Math.Abs(order.Amount) > dayCostMax).ThrowIfTrue($"超出当天消费限制{dayCostMax}元,无法消费");
}
//一次消费金额
var onceCostMax = await GetSettingAsync<decimal>(order.UserNo, order.TenantId, CanteenSettingItemEnumType.OnceCostMax);
if (onceCostMax != default)
{
(Math.Abs(order.Amount) > onceCostMax).ThrowIfTrue($"单次消费金额不能超出{onceCostMax}元");
}
//超市消费限额
var dayMarketCostMax = await GetSettingAsync<decimal>(order.UserNo, order.TenantId, CanteenSettingItemEnumType.DayMarketCostMax);
if (dayMarketCostMax != default)
{
//current businessplace is supermarket
if (order.BusinessPlaceCode.HasValue && supermarketCodes.Contains(order.BusinessPlaceCode.Value))
if (request.ThirdNo.IsPresent())
{
var cost = todayAllBalanceRecords.Where(x => x.BusinessPlaceCode.HasValue)
.Where(x => supermarketCodes.Contains(x.BusinessPlaceCode.Value))
.Sum(x => Math.Abs(x.Amount));
var redisCache = _serviceProvider.GetService<RedisCache>();
(cost + Math.Abs(order.Amount) > dayMarketCostMax).ThrowIfTrue($"超出当天超市消费限制{dayMarketCostMax},无法消费");
await using var handler = await redisCache.LockAsync($"consume:device:{request.ThirdNo}");
if (handler.Acquired)
{
if (await ToCheckAbleOfflineConsumeAsync(request.ThirdNo))
{
try
{
await HandleOfflineAsync(request.Adapt<ConsumeRequest>(), gainfo);
}
catch (Exception ex)
{
Logger.LogError(ex, "离线入库错误: 订单号:{no} .{message}", request.ThirdNo, ex.Message);
}
}
}
}
else
{
try
{
await HandleOfflineAsync(request.Adapt<ConsumeRequest>(), gainfo);
}
catch (Exception ex)
{
Logger.LogError(ex, "离线入库错误: 订单号:{no} .{message}", request.ThirdNo, ex.Message);
}
}
}
else
{
try
{
(await DbContext.Queryable<GainfoMealEntity>().Where(x => x.UserCode == gainfo.Code).AnyAsync()).ThrowIfFalse("就餐余额不足");
await ConsumeAsync(request.Adapt<ConsumeRequest>(), gainfo);
}
catch (Exception ex)
{
message = ex.Message;
}
}
//重复餐次消费
var allowRepeatInOneShift = await GetSettingAsync(order.UserNo, order.TenantId, CanteenSettingItemEnumType.AllowRepeatInOneShift, true);
if (!allowRepeatInOneShift)
{
var costCount = todayAllBalanceRecords.Count(x => x.ShiftType == order.ShiftType);
(costCount > 1).ThrowIfTrue($"{order.ShiftType?.GetDescription()}不允许多次消费");
}
}
/// <summary>
/// 生成充值记录
/// </summary>
/// <param name="orderId"></param>
/// <returns></returns>
/// <exception cref="UserFriendlyException"></exception>
/// <exception cref="VersionExceptions"></exception>
private async Task GenerateConsumeRecordAsync(long orderId)
{
var order = await DbContext.Queryable<CanteenOrderEntity>().Where(x => x.Id == orderId).SingleAsync();
//校验
await Verify(order);
_logs.Add("消费请求校验:" + _sw.ElapsedMilliseconds);
_sw.Restart();
await CommonHelper.RetryAsync(async () =>
{
var gainfoMeal = await DbContext.Queryable<GainfoMealEntity>().Where(x => x.UserNo == order.UserNo).SingleAsync();
//金额+-
gainfoMeal.Balance += order.Amount;
(gainfoMeal.Balance < 0).ThrowIfTrue("余额不足,无法消费");
await DbContext.Updateable<GainfoMealEntity>()
.SetColumns(x => x.Balance == gainfoMeal.Balance)
.SetColumns(x => x.Version == x.Version + 1)
.SetColumns(x => x.ModifiedTime == DateTime.Now)
.Where(x => x.UserNo == order.UserNo && x.Version == gainfoMeal.Version) //必须与查询时的version一致
.ExecuteCommandThrowVersionAsync();
//写入记录
var balanceRecord = order.Adapt<BalanceRecordEntity>();
await DbContext.InsertAsync(balanceRecord);
}, 5);
_logs.Add("消费写入:" + _sw.ElapsedMilliseconds);
_sw.Restart();
}
/// <summary>
/// 根据二维码获取消费用户
/// </summary>
/// <param name="qrCode"></param>
/// <returns></returns>
private async Task<string> GetUserNoByQrCodeAsync(string qrCode)
{
var gainfoQrCode = await DbContext.Queryable<GainfoQrCodeEntity>().Where(x => x.QrCode == qrCode).SingleAsync();
gainfoQrCode.ThrowIfNull("消费码已过期");
(gainfoQrCode.ModifiedTime.AddMinutes(1) > DateTime.Now).ThrowIfTrue("消费码已过期");
return gainfoQrCode.UserCode;
return message;
}
}