731 lines
30 KiB
C#
731 lines
30 KiB
C#
using Dlhis.Basic.Api;
|
|
using Dlhis.Canteen.Order.Request;
|
|
using Dlhis.Canteen.Order.Response;
|
|
using Dlhis.Canteen.Setting.Services;
|
|
using Dlhis.Entity.Basic.Entity;
|
|
using Dlhis.Entity.Canteen.Entities;
|
|
using Dlhis.Entity.Canteen.Enums;
|
|
using Dlhis.Entity.Device;
|
|
using Dlhis.Entity.Device.Entities;
|
|
using Dlhis.Entity.Device.Enums;
|
|
using Dlhis.Sys.Api;
|
|
using Kurisu.AspNetCore;
|
|
using Kurisu.AspNetCore.Authentication.Abstractions;
|
|
using Kurisu.AspNetCore.CustomClass;
|
|
using Kurisu.AspNetCore.DataAccess.Dto;
|
|
using Kurisu.AspNetCore.DataAccess.SqlSugar.Extensions;
|
|
using Kurisu.AspNetCore.DataAccess.SqlSugar.Services;
|
|
using Kurisu.AspNetCore.Utils;
|
|
using Kurisu.AspNetCore.Utils.Extensions;
|
|
using Mapster;
|
|
using SqlSugar;
|
|
|
|
namespace Dlhis.Canteen.Order.Services.Implements;
|
|
|
|
public class BalanceService : IBalanceService
|
|
{
|
|
private readonly IDbContext _dbContext;
|
|
private readonly ICurrentUser _currentUser;
|
|
private readonly ITenantApi _tenantApi;
|
|
private readonly ICanteenSettingService _canteenSettingService;
|
|
private readonly IBusinessPlacePermissionsApi _businessPlacePermissionsApi;
|
|
|
|
public BalanceService(IDbContext dbContext,
|
|
ICurrentUser currentUser,
|
|
ITenantApi tenantApi,
|
|
ICanteenSettingService canteenSettingService,
|
|
IBusinessPlacePermissionsApi businessPlacePermissionsApi)
|
|
{
|
|
_dbContext = dbContext;
|
|
_currentUser = currentUser;
|
|
_tenantApi = tenantApi;
|
|
_canteenSettingService = canteenSettingService;
|
|
_businessPlacePermissionsApi = businessPlacePermissionsApi;
|
|
}
|
|
|
|
public async Task<Pagination<BalanceRecordResponse>> GetPageAsync(BalanceRecordPageRequest request)
|
|
{
|
|
var page = await _dbContext.Queryable<BalanceRecordEntity>()
|
|
.LeftJoin<GainfoEntity>((record, ga) => record.UserNo == ga.No)
|
|
//.LeftJoinIF<GainfoEntity>(request.GainfoStatus == GainfoStatusEnumType.Working, (record, ga) => record.UserNo == ga.No)
|
|
//.LeftJoinIF<GainfoLeaveEntity>(request.GainfoStatus == GainfoStatusEnumType.Leave, (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)
|
|
.LeftJoin<CanteenOrderEntity>((record, ga, department, bPlace, order) => record.No == order.No)
|
|
.WhereIF(request.Factory.IsPresent(), record => record.TenantId == request.Factory)
|
|
.WhereIF(request.Type.HasValue, record => record.Type == request.Type)
|
|
.WhereIF(request.SearchDateTimePeriod.HasValue(), record => record.CostDate >= request.SearchDateTimePeriod.Start && record.CostDate <= request.SearchDateTimePeriod.End)
|
|
.WhereIF(request.ShiftTypes.IsPresent(), record => request.ShiftTypes.Contains(record.ShiftType))
|
|
.WhereIF(request.Search.IsPresent(), (record, ga) => ga.Code == request.Search || ga.Name == request.Search)
|
|
.OrderBy(record => record.CreateTime, OrderByType.Desc)
|
|
.Select((record, ga, department, bPlace, order) => new BalanceRecordResponse
|
|
{
|
|
Id = record.Id,
|
|
No = record.No,
|
|
IsOffline = order.IsOffline,
|
|
Amount = record.Amount,
|
|
CostDate = record.CostDate,
|
|
CostId = record.CostId,
|
|
DepartmentNo = record.DepartmentNo,
|
|
DeviceInfo = record.DeviceUniqueNo,
|
|
UserNo = record.UserNo,
|
|
UserCode = record.UserCode,
|
|
Type = record.Type,
|
|
Status = record.Status,
|
|
Source = record.Source,
|
|
OriginTenantId = record.OriginTenantId,
|
|
Name = record.Name,
|
|
DepartmentName = department.Name,
|
|
BusinessPlaceName = bPlace.Name,
|
|
CostDateTime = record.CostDateTime,
|
|
Factory = record.TenantId,
|
|
ShiftType = record.ShiftType,
|
|
Remark = record.Remark,
|
|
Werks = record.Werks
|
|
})
|
|
.ToPageListAsync(request);
|
|
|
|
try
|
|
{
|
|
var tenantResult = await _tenantApi.GetTenantsInternalAsync();
|
|
var tenants = tenantResult.Data;
|
|
|
|
page.Data.ForEach(item =>
|
|
{
|
|
item.OriginTenantId = tenants.FirstOrDefault(x => x.Code == item.OriginTenantId)?.Name;
|
|
item.Factory = tenants.FirstOrDefault(x => x.Code == item.Factory)?.Name;
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//ignore
|
|
}
|
|
|
|
return page;
|
|
}
|
|
|
|
public async Task<OrderResultResponse> RefundAsync(string no)
|
|
{
|
|
var cache = App.GetServiceProvider().GetService<RedisCache>();
|
|
var balanceRecord = await _dbContext.Queryable<BalanceRecordEntity>().Where(x => x.No == no).SingleAsync();
|
|
balanceRecord.ThrowIfNull("数据不存在");
|
|
|
|
(balanceRecord.Status != BalanceRecordStatusEnumType.Valid).ThrowIfTrue("无法退款");
|
|
|
|
await using var handler = await cache.LockAsync($"balance:refund:{no}", TimeSpan.FromSeconds(9));
|
|
if (handler.Acquired)
|
|
{
|
|
if (balanceRecord is { Status: BalanceRecordStatusEnumType.Valid, Type: BalanceRecordTypeEnumType.Out })
|
|
{
|
|
balanceRecord.Status = BalanceRecordStatusEnumType.Obsolute;
|
|
balanceRecord.Remark = "退款";
|
|
await _dbContext.UpdateAsync(balanceRecord);
|
|
|
|
if (balanceRecord.Source is BalanceRecordSourceEnumType.Face or BalanceRecordSourceEnumType.QrCode)
|
|
{
|
|
await ReCalcAsync(balanceRecord.UserCode);
|
|
}
|
|
}
|
|
}
|
|
|
|
//获取人员余额
|
|
return await _dbContext.Queryable<GainfoMealEntity>()
|
|
.LeftJoin<GainfoEntity>((x, ga) => x.UserCode == ga.Code)
|
|
.LeftJoin<DepartmentEntity>((x, ga, department) => ga.DepartmentNo == department.No)
|
|
.Where(x => x.UserCode == balanceRecord.UserCode)
|
|
.Select((x, ga, department) => new OrderResultResponse
|
|
{
|
|
UserCode = ga.Code,
|
|
UserName = ga.Name,
|
|
DepartmentNo = ga.DepartmentNo,
|
|
DepartmentName = department.Name,
|
|
CurrentBalance = x.Balance
|
|
})
|
|
.SingleAsync();
|
|
}
|
|
|
|
|
|
public async Task<Pagination<BalanceRecordDeviceResponse>> GetPageByDeviceUniqueNoAsync(BalanceRecordPageByDeviceUniqueNoRequest request)
|
|
{
|
|
var device = await _dbContext.Queryable<DeviceEntity>()
|
|
.Where(x => x.UniqueNo == request.DeviceUniqueNo)
|
|
.SingleAsync();
|
|
|
|
if (device == null)
|
|
{
|
|
return new Pagination<BalanceRecordDeviceResponse>
|
|
{
|
|
Data = new List<BalanceRecordDeviceResponse>()
|
|
};
|
|
}
|
|
|
|
if (request.SearchDate.HasValue)
|
|
{
|
|
request.Start = request.SearchDate;
|
|
request.End = request.SearchDate;
|
|
}
|
|
|
|
|
|
var switchTime = await _canteenSettingService.GetBusinessSwitchTimeAsync(device.TenantId);
|
|
if (switchTime.HasValue)
|
|
{
|
|
var setTime = request.Start!.Value.Add(switchTime.Value.ToTimeSpan());
|
|
if (DateTime.Now < setTime)
|
|
{
|
|
request.Start = request.Start.Value.AddDays(-1);
|
|
request.End = request.End!.Value.AddDays(-1);
|
|
}
|
|
}
|
|
|
|
var page = 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)
|
|
.LeftJoin<ImageRecordEntity>((record, ga, department, bPlace, imageRecord) => imageRecord.No == record.No)
|
|
.Where(record => record.DeviceUniqueNo == device.UniqueNo)
|
|
.Where(record => record.CostDate >= request.Start && record.CostDate <= request.End)
|
|
.Where(record => record.Type == BalanceRecordTypeEnumType.Out
|
|
&& (record.Status == BalanceRecordStatusEnumType.Valid || (record.Status == BalanceRecordStatusEnumType.Obsolute && record.Remark == "退款")))
|
|
.WhereIF(request.UserCode.IsPresent(), record => record.UserCode == request.UserCode)
|
|
.OrderBy(record => record.CostDateTime, OrderByType.Desc)
|
|
.Select((record, ga, department, bPlace, imageRecord) => new BalanceRecordDeviceResponse
|
|
{
|
|
Id = record.Id,
|
|
Amount = SqlFunc.Abs(record.Amount),
|
|
CostDate = record.CostDate,
|
|
DepartmentNo = record.DepartmentNo,
|
|
UserNo = record.UserNo,
|
|
UserCode = record.UserCode,
|
|
Type = record.Type,
|
|
Status = record.Status,
|
|
Source = record.Source,
|
|
No = record.No,
|
|
Name = record.Name,
|
|
DepartmentName = department.Name,
|
|
BusinessPlaceName = bPlace.Name,
|
|
ShiftType = record.ShiftType,
|
|
CostDateTime = record.CostDateTime,
|
|
TenantId = record.TenantId,
|
|
Image = imageRecord.Image
|
|
})
|
|
.ToPageListAsync(request);
|
|
|
|
//消费总金额
|
|
var sum = await _dbContext.Queryable<BalanceRecordEntity>()
|
|
.Where(record => record.CostDate >= request.Start && record.CostDate <= request.End)
|
|
.Where(record => record.DeviceUniqueNo == device.UniqueNo)
|
|
.Where(record => record.Type == BalanceRecordTypeEnumType.Out && record.Status == BalanceRecordStatusEnumType.Valid)
|
|
.SumAsync(record => SqlFunc.Abs(SqlFunc.IsNull(record.Amount, 0)));
|
|
|
|
page.Data.ForEach(x => x.Sum = sum);
|
|
|
|
return page;
|
|
}
|
|
|
|
|
|
public async Task<BalanceRecordByBusinessPlaceResponse> RecordPageDetailsAsync(BalanceRecordPageDetailRequest request)
|
|
{
|
|
var myCodes = (await _businessPlacePermissionsApi.GetMyAsync()).Data.Select(x => (Guid?)x.Code).ToList();
|
|
if (request.BusinessplaceCodes.IsPresent())
|
|
{
|
|
myCodes = myCodes.Where(x => request.BusinessplaceCodes.Contains(x)).ToList();
|
|
}
|
|
|
|
var queryable = _dbContext.Queryable<BalanceRecordEntity>()
|
|
.LeftJoin<DepartmentEntity>((record, department) => record.DepartmentNo == department.No)
|
|
.LeftJoin<BusinessPlaceEntity>((record, department, bPlace) => record.BusinessPlaceCode == bPlace.Code)
|
|
.LeftJoin<GainfoEntity>((record, department, bPlace, gainfo) => record.UserNo == gainfo.No)
|
|
.Where(record => record.Type == BalanceRecordTypeEnumType.Out && record.Status == BalanceRecordStatusEnumType.Valid)
|
|
.Where(record => myCodes.Contains(record.BusinessPlaceCode))
|
|
.WhereIF(request.SearchDateTimePeriod.HasValue(), record => record.CostDate >= request.SearchDateTimePeriod.Start && record.CostDate <= request.SearchDateTimePeriod.End)
|
|
.WhereIF(request.ShiftType.HasValue, record => record.ShiftType == request.ShiftType)
|
|
.WhereIF(request.Search.IsPresent(), record => record.UserCode == request.Search || record.Name == request.Search);
|
|
|
|
var page = await queryable
|
|
.OrderBy(record => record.CostDateTime, OrderByType.Desc)
|
|
.Select((record, department, bPlace, gainfo) => new BalanceRecordDetailPageResponse
|
|
{
|
|
Id = record.Id,
|
|
No = record.No,
|
|
CurrentAmount = SqlFunc.Abs(record.Amount),
|
|
CostDate = record.CostDate,
|
|
UserNo = record.UserNo,
|
|
UserCode = record.UserCode,
|
|
Source = record.Source,
|
|
UserName = record.Name,
|
|
DepartmentName = department.Name,
|
|
BusinessPlaceName = bPlace.Name,
|
|
CostDateTime = record.CostDateTime,
|
|
ShiftType = record.ShiftType,
|
|
Werks = gainfo.Werks,
|
|
Factory = record.TenantId,
|
|
Remark = record.Remark,
|
|
})
|
|
.ToPageListAsync(request);
|
|
|
|
try
|
|
{
|
|
var tenantResult = await _tenantApi.GetTenantsInternalAsync();
|
|
var tenants = tenantResult.Data;
|
|
|
|
page.Data.ForEach(item => { item.Factory = tenants.FirstOrDefault(x => x.Code == item.Factory)?.Name; });
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//ignore
|
|
}
|
|
|
|
|
|
var amount = await queryable.SumAsync(record => SqlFunc.Abs(record.Amount));
|
|
var total = await queryable.GroupBy(record => record.UserNo).Select(record => record.UserNo).CountAsync();
|
|
|
|
return new BalanceRecordByBusinessPlaceResponse
|
|
{
|
|
Amount = amount,
|
|
Total = total,
|
|
Pagination = page,
|
|
};
|
|
}
|
|
|
|
|
|
public async Task SupplementBalanceAsync(BalanceSupplementRequest request)
|
|
{
|
|
var balanceInfo = await _dbContext.Queryable<BalanceRecordEntity>().Where(x => x.No == request.No).SingleAsync();
|
|
balanceInfo.ThrowIfNull("明细数据不存在");
|
|
(balanceInfo.Status != BalanceRecordStatusEnumType.Valid || balanceInfo.Type != BalanceRecordTypeEnumType.Out).ThrowIfTrue("消费明细状态有误");
|
|
|
|
balanceInfo.Status = BalanceRecordStatusEnumType.Obsolute;
|
|
balanceInfo.Remark += request.Reason;
|
|
|
|
await _dbContext.Client.Ado.BeginTranAsync();
|
|
try
|
|
{
|
|
await _dbContext.UpdateAsync(balanceInfo);
|
|
|
|
//不为空则插入记录
|
|
if (request.Amount != 0)
|
|
{
|
|
var newBalanceRecord = balanceInfo.Adapt<BalanceRecordEntity>();
|
|
newBalanceRecord.Id = 0;
|
|
newBalanceRecord.No = SnowFlakeHelper.Instance.NextId().ToString();
|
|
newBalanceRecord.Amount = request.Amount;
|
|
newBalanceRecord.Remark = balanceInfo.No + ":" + request.Reason;
|
|
newBalanceRecord.Status = BalanceRecordStatusEnumType.Valid;
|
|
await _dbContext.InsertAsync(newBalanceRecord);
|
|
}
|
|
|
|
await _dbContext.Client.Ado.CommitTranAsync();
|
|
}
|
|
catch (Exception)
|
|
{
|
|
await _dbContext.Client.Ado.RollbackTranAsync();
|
|
throw;
|
|
}
|
|
|
|
await CommonHelper.RetryAsync(async () =>
|
|
{
|
|
var gainfoMeal = await _dbContext.Queryable<GainfoMealEntity>().Where(x => x.UserCode == balanceInfo.UserCode).SingleAsync();
|
|
var balance = gainfoMeal.Balance + Math.Abs(balanceInfo.Amount) + request.Amount;
|
|
|
|
await _dbContext.Updateable<GainfoMealEntity>()
|
|
.SetColumns(x => x.Balance == balance)
|
|
.SetColumns(x => x.Version == x.Version + 1)
|
|
.SetColumns(x => x.ModifiedTime == DateTime.Now)
|
|
.Where(x => x.UserCode == balanceInfo.UserCode && x.Version == gainfoMeal.Version)
|
|
.ExecuteCommandThrowVersionAsync();
|
|
}, 10);
|
|
}
|
|
|
|
public async Task<BalanceRecordUserResultResponse> GetPageByUserAsync(BalanceRecordUserPageRequest request)
|
|
{
|
|
var jinkoCode = _currentUser.GetUserClaim("jinko-code") ?? string.Empty;
|
|
|
|
var page = 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, ga) => record.UserCode == jinkoCode)
|
|
.Where(record => record.Status == BalanceRecordStatusEnumType.Valid && record.Type == BalanceRecordTypeEnumType.Out)
|
|
.Where(record => record.Source != BalanceRecordSourceEnumType.EMealVoucher) //不展示电子餐券信息
|
|
.WhereIF(request.SearchDateTimePeriod.HasValue(), record => record.CostDate >= request.SearchDateTimePeriod.Start && record.CostDate <= request.SearchDateTimePeriod.End)
|
|
.WhereIF(request.ApplicationType.HasValue, record => record.ApplicationType == request.ApplicationType)
|
|
.OrderBy(record => record.CostDateTime)
|
|
.Select((record, ga, department, bPlace) => new BalanceRecordUserPageResponse
|
|
{
|
|
Id = record.Id,
|
|
CurrentAmount = SqlFunc.Abs(record.Amount),
|
|
Source = record.Source,
|
|
No = record.No,
|
|
BusinessPlaceName = bPlace.Name,
|
|
ShiftType = record.ShiftType,
|
|
CostDateTime = record.CostDateTime,
|
|
ApplicationType = record.ApplicationType,
|
|
})
|
|
.ToPageListAsync(request);
|
|
|
|
var now = DateTime.Now;
|
|
var monthStart = new DateTime(now.Year, now.Month, 1);
|
|
var monthEnd = monthStart.AddMonths(1).AddSeconds(-1);
|
|
|
|
var monthSum = await _dbContext.Queryable<BalanceRecordEntity>()
|
|
.Where(x => x.CostDateTime >= monthStart && x.CostDateTime <= monthEnd)
|
|
.Where(x => x.Status == BalanceRecordStatusEnumType.Valid && x.Type == BalanceRecordTypeEnumType.Out)
|
|
.Where(x => x.Source != BalanceRecordSourceEnumType.EMealVoucher)
|
|
.Where(x => x.UserCode == jinkoCode)
|
|
.SumAsync(x => SqlFunc.Abs(x.Amount));
|
|
|
|
return new BalanceRecordUserResultResponse
|
|
{
|
|
CurrentMonthSum = monthSum,
|
|
Items = page
|
|
};
|
|
}
|
|
|
|
public async Task<Pagination<BalanceRecordUserPageResponse>> GetUserBalanceGroupAsync(BalanceRecordUserGroupPageRequest request)
|
|
{
|
|
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, ga) => record.UserCode == request.UserCode)
|
|
.Where(record => record.Status == BalanceRecordStatusEnumType.Valid && record.Type == BalanceRecordTypeEnumType.Out)
|
|
.Where(record => record.Source != BalanceRecordSourceEnumType.EMealVoucher) //不展示电子餐券信息
|
|
.WhereIF(request.SearchDateTimePeriod.HasValue(), record => record.CostDate >= request.SearchDateTimePeriod.Start && record.CostDate <= request.SearchDateTimePeriod.End)
|
|
.OrderBy(record => record.CostDateTime)
|
|
.Select((record, ga, department, bPlace) => new BalanceRecordUserPageResponse
|
|
{
|
|
Id = record.Id,
|
|
CurrentAmount = SqlFunc.Abs(record.Amount),
|
|
Source = record.Source,
|
|
No = record.No,
|
|
BusinessPlaceName = bPlace.Name,
|
|
ShiftType = record.ShiftType,
|
|
CostDateTime = record.CostDateTime,
|
|
ApplicationType = record.ApplicationType,
|
|
})
|
|
.ToPageListAsync(request);
|
|
}
|
|
|
|
|
|
public async Task<ConsumeNumberResponse> GetConsumeNumberAsync()
|
|
{
|
|
var devices = await _dbContext.Queryable<DeviceEntity>()
|
|
.Where(x => x.Type == DeviceTypeEnumType.Meal)
|
|
.ToListAsync();
|
|
|
|
var offCount = await GetOfflineDevicesCount(devices);
|
|
|
|
var places = await _dbContext.Queryable<BusinessPlaceEntity>()
|
|
.Where(x => x.Status == CanteenBusinessPlaceStatusEnumType.Opened)
|
|
.ToListAsync();
|
|
|
|
//所有消费数据
|
|
var bs = await _dbContext.Queryable<BalanceRecordEntity>()
|
|
.Where(x => x.Type == BalanceRecordTypeEnumType.Out)
|
|
.Where(x => x.Status == BalanceRecordStatusEnumType.Valid)
|
|
.ToListAsync();
|
|
|
|
//可消费人数
|
|
var consumerable = bs.DistinctBy(x => x.UserCode).Count();
|
|
|
|
//消费走势
|
|
var months = await GetConsumptionTrendsAsync(1);
|
|
var days = await GetConsumptionTrendsAsync(2);
|
|
|
|
return new ConsumeNumberResponse
|
|
{
|
|
Total = devices.Count,
|
|
OffNumber = offCount.Count,
|
|
PlaceNumber = places.Count,
|
|
ConsumerableNumber = consumerable,
|
|
DailyNumber = 0,
|
|
Days = days,
|
|
Months = months
|
|
};
|
|
}
|
|
|
|
public async Task<Pagination<SpendingDetailResponse>> GetSpendingDetailsAsync(SpendingDetailRequest request)
|
|
{
|
|
return await _dbContext
|
|
.Queryable<BalanceRecordEntity>()
|
|
.Where(x => x.Type == BalanceRecordTypeEnumType.Out)
|
|
.Where(x => x.Status == BalanceRecordStatusEnumType.Valid)
|
|
.Select<SpendingDetailResponse>()
|
|
.Distinct()
|
|
.ToPageListAsync(request);
|
|
}
|
|
|
|
public async Task<Pagination<AverageDailyResponse>> AverageDailyAsync(AverageDailyRequest request)
|
|
{
|
|
return await _dbContext.Queryable<BalanceRecordEntity>()
|
|
.Where(x => x.Type == BalanceRecordTypeEnumType.Out)
|
|
.Where(x => x.Status == BalanceRecordStatusEnumType.Valid)
|
|
.GroupBy(x => new
|
|
{
|
|
x.UserNo, x.Name, x.UserCode, x.CostDate
|
|
})
|
|
.Select(x => new AverageDailyResponse
|
|
{
|
|
UserNo = x.UserNo,
|
|
Name = x.Name,
|
|
UserCode = x.UserCode,
|
|
AverageAmount = SqlFunc.AggregateSum(SqlFunc.Abs(x.Amount)) / SqlFunc.AggregateDistinctCount(x.CostDate)
|
|
})
|
|
.ToPageListAsync(request);
|
|
}
|
|
|
|
|
|
/// <inheritdoc />
|
|
public async Task ManuallyImportBalanceAndReCalcAsync(List<BalanceManuallyImportRequest> requests)
|
|
{
|
|
foreach (var request in requests)
|
|
{
|
|
var gainfo = await _dbContext.Queryable<GainfoEntity>()
|
|
.Where(x => x.Code == request.UserCode)
|
|
.SingleAsync()
|
|
?? await _dbContext.Queryable<GainfoEntity>().AS("GainfoLeave")
|
|
.Where(x => x.Code == request.UserCode)
|
|
.SingleAsync();
|
|
|
|
gainfo.ThrowIfNull($"工号{request.UserCode}不存在");
|
|
|
|
await _dbContext.InsertAsync(new BalanceRecordEntity
|
|
{
|
|
No = "M" + SnowFlakeHelper.Instance.NextId(),
|
|
UserNo = gainfo.No,
|
|
Name = gainfo.Name,
|
|
UserCode = gainfo.Code,
|
|
DepartmentNo = gainfo.DepartmentNo,
|
|
Source = BalanceRecordSourceEnumType.OtherTenantSubsidies,
|
|
Type = BalanceRecordTypeEnumType.In,
|
|
Amount = request.Balance,
|
|
BusinessPlaceCode = null,
|
|
BusinessShiftCode = null,
|
|
ShiftType = null,
|
|
CostDate = DateTime.Now.Date,
|
|
DeviceUniqueNo = null,
|
|
IP = null,
|
|
CostId = gainfo.CostId,
|
|
OriginTenantId = gainfo.Factory,
|
|
IsCostCrossTenant = false,
|
|
Status = BalanceRecordStatusEnumType.Valid,
|
|
CostDateTime = DateTime.Now,
|
|
Remark = "手动写入余额",
|
|
ApplicationType = CanteenApplicationTypeEnumType.Manually,
|
|
TenantId = gainfo.Factory,
|
|
Werks = gainfo.Werks,
|
|
IsDeleted = false
|
|
});
|
|
|
|
await CommonHelper.RetryAsync(async () =>
|
|
{
|
|
var gainfoMeal = await _dbContext.Queryable<GainfoMealEntity>().Where(x => x.UserCode == gainfo.Code).FirstAsync();
|
|
if (gainfoMeal == null)
|
|
{
|
|
gainfoMeal = new GainfoMealEntity
|
|
{
|
|
UserCode = gainfo.Code,
|
|
Balance = 0,
|
|
BalanceOfRecharge = 0,
|
|
BalanceOfSubsidies = 0,
|
|
Version = 0
|
|
};
|
|
|
|
await _dbContext.InsertAsync(gainfoMeal);
|
|
}
|
|
|
|
//重新核算
|
|
var balance = await _dbContext.Queryable<BalanceRecordEntity>()
|
|
.Where(x => x.UserCode == gainfo.Code)
|
|
.Where(x => x.Status == BalanceRecordStatusEnumType.Valid)
|
|
.SumAsync(x => x.Amount);
|
|
|
|
await _dbContext.Updateable<GainfoMealEntity>()
|
|
.SetColumns(x => x.Version == x.Version + 1)
|
|
.SetColumns(x => x.Balance == balance)
|
|
.SetColumns(x => x.ModifiedTime == DateTime.Now)
|
|
.Where(x => x.UserCode == gainfoMeal.UserCode && x.Version == gainfoMeal.Version)
|
|
.ExecuteCommandThrowVersionAsync();
|
|
}, 5);
|
|
}
|
|
}
|
|
|
|
|
|
public async Task ReCalcAsync(string userCode)
|
|
{
|
|
await CommonHelper.RetryAsync(async () =>
|
|
{
|
|
var gainfo = await _dbContext.Queryable<GainfoEntity>().Where(x => x.Code == userCode).SingleAsync();
|
|
gainfo.ThrowIfNull("档案不存在");
|
|
|
|
var gainfoMeal = await _dbContext.Queryable<GainfoMealEntity>().Where(x => x.UserCode == gainfo.Code).FirstAsync();
|
|
if (gainfoMeal == null)
|
|
{
|
|
gainfoMeal = new GainfoMealEntity
|
|
{
|
|
UserCode = gainfo.Code,
|
|
Balance = 0,
|
|
BalanceOfRecharge = 0,
|
|
BalanceOfSubsidies = 0,
|
|
Version = 0
|
|
};
|
|
|
|
await _dbContext.InsertAsync(gainfoMeal);
|
|
}
|
|
|
|
//重新核算
|
|
var balance = await _dbContext.Queryable<BalanceRecordEntity>()
|
|
.Where(x => x.UserCode == gainfo.Code)
|
|
.Where(x => x.Status == BalanceRecordStatusEnumType.Valid)
|
|
.SumAsync(x => x.Amount);
|
|
|
|
await _dbContext.Updateable<GainfoMealEntity>()
|
|
.SetColumns(x => x.Version == x.Version + 1)
|
|
.SetColumns(x => x.Balance == balance)
|
|
.SetColumns(x => x.ModifiedTime == DateTime.Now)
|
|
.Where(x => x.UserCode == gainfoMeal.UserCode && x.Version == gainfoMeal.Version)
|
|
.ExecuteCommandThrowVersionAsync();
|
|
}, 5);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 获取离线设备
|
|
/// </summary>
|
|
/// <param name="devices"></param>
|
|
/// <returns></returns>
|
|
private async Task<List<DeviceEntity>> GetOfflineDevicesCount(List<DeviceEntity> devices)
|
|
{
|
|
var now = DateTime.Now;
|
|
|
|
var deviceUniqueNos = devices.Select(x => x.UniqueNo).ToList();
|
|
|
|
var deviceRegistries = await _dbContext.Queryable<DeviceRegistryEntity>()
|
|
.LeftJoin<DeviceEntity>((x, d) => x.DeviceUniqueNo == d.UniqueNo)
|
|
.Where(x => deviceUniqueNos.Contains(x.DeviceUniqueNo))
|
|
.Select((x, d) => new
|
|
{
|
|
d.UniqueNo,
|
|
d.HeartbeatInterval,
|
|
x.LastHeartbeatTime
|
|
})
|
|
.ToListAsync();
|
|
|
|
var onlineDevices = deviceRegistries
|
|
.Where(x =>
|
|
{
|
|
if (x.HeartbeatInterval <= 0)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return x.LastHeartbeatTime.AddSeconds(x.HeartbeatInterval * 3) >= now;
|
|
})
|
|
.Select(x => new
|
|
{
|
|
x.UniqueNo,
|
|
})
|
|
.ToList();
|
|
var onlineUniqueNos = new List<string>();
|
|
onlineDevices.ForEach(x => onlineUniqueNos.Add(x.UniqueNo));
|
|
|
|
var offUniqueNos = deviceUniqueNos.Except(onlineUniqueNos).ToList();
|
|
var list = devices.Where(x => offUniqueNos.Contains(x.UniqueNo)).ToList();
|
|
return list;
|
|
}
|
|
|
|
private async Task<List<ConsumptionTrendResponse>> GetConsumptionTrendsAsync(int type)
|
|
{
|
|
var bs = await _dbContext.Queryable<BalanceRecordEntity>()
|
|
.Where(x => x.Type == BalanceRecordTypeEnumType.Out)
|
|
.ToListAsync();
|
|
//消费总额
|
|
var totalAmount = Math.Round(Math.Abs(bs.Sum(x => x.Amount)), 2);
|
|
|
|
var list = new List<ConsumptionTrendResponse>();
|
|
if (type == 1)
|
|
{
|
|
//月与总额对比
|
|
var months = GetMonthsOfYear();
|
|
|
|
foreach (var month in months)
|
|
{
|
|
var currentAmount = Math.Round(Math.Abs(bs.Where(x => x.CostDateTime.ToString("yyyy-MM") == month)
|
|
.Sum(x => x.Amount)), 2);
|
|
|
|
var res = new ConsumptionTrendResponse
|
|
{
|
|
DateTime = month,
|
|
CurrentAmount = currentAmount,
|
|
TotalAmount = totalAmount
|
|
};
|
|
list.Add(res);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//日与总额对比
|
|
var days = GetDaysOfMonth();
|
|
|
|
foreach (var day in days)
|
|
{
|
|
var currentAmount = Math.Round(Math.Abs(bs.Where(x => x.CostDateTime.ToString("yyyy-MM-dd") == day)
|
|
.Sum(x => x.Amount)), 2);
|
|
|
|
var res = new ConsumptionTrendResponse
|
|
{
|
|
DateTime = day,
|
|
CurrentAmount = currentAmount,
|
|
TotalAmount = totalAmount
|
|
};
|
|
list.Add(res);
|
|
}
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取当前年所有月
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private List<string> GetMonthsOfYear()
|
|
{
|
|
var months = new List<string>();
|
|
// 获取当前年份
|
|
int year = DateTime.Now.Year;
|
|
// 遍历12个月份并添加到列表中
|
|
for (int month = 1; month <= 12; month++)
|
|
{
|
|
var monthDate = new DateTime(year, month, 1);
|
|
months.Add(monthDate.ToString("yyyy-MM"));
|
|
}
|
|
|
|
return months;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取当前月所有天
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private List<string> GetDaysOfMonth()
|
|
{
|
|
var days = new List<string>();
|
|
|
|
// 获取当前年份和月份
|
|
int year = DateTime.Now.Year;
|
|
int month = DateTime.Now.Month;
|
|
|
|
// 获取当前月份的第一天和最后一天
|
|
var firstDayOfMonth = new DateTime(year, month, 1);
|
|
var lastDayOfMonth = firstDayOfMonth.AddMonths(1).AddDays(-1);
|
|
|
|
// 遍历当前月的所有日期并添加到列表中
|
|
for (DateTime date = firstDayOfMonth; date <= lastDayOfMonth; date = date.AddDays(1))
|
|
{
|
|
days.Add(date.ToString("yyyy-MM-dd"));
|
|
}
|
|
|
|
return days;
|
|
}
|
|
} |