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-15 11:25:15 +08:00
parent b697520cb4
commit ce682409d4
18 changed files with 95 additions and 340 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
Src/Dlhis.Canteen/Order/Controllers/BalanceSummaryController.cs
View File

@@ -32,4 +32,13 @@ public class BalanceSummaryController : ControllerBase
{
return await _balanceSummaryService.BalanceRecordAnalysisAsync(request);
}
}
/// <summary>
/// 用餐分析(成本中心)
/// </summary>
[HttpGet("analysis/cost")]
public async Task<Pagination<BalanceRecordAnalysisByCostResponse>> BalanceRecordAnalysisByCostIdAsync()
{
return await _balanceSummaryService.BalanceRecordAnalysisByCostIdAsync();
}
}

11
Src/Dlhis.Canteen/Order/Controllers/BalancesController.cs
View File

@@ -126,17 +126,6 @@ public class BalancesController : ControllerBase
return await _balanceService.AverageDailyAsync(request);
}
/// <summary>
/// 获取消费机详情
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
[HttpGet("consumeDevices")]
public async Task<Pagination<DevicePageResponse>> GetConsumeDeviceAsync([FromQuery] GetConsumeDeviceRequest request)
{
return await _balanceService.GetConsumeDeviceAsync(request);
}
/// <summary>
/// 海宁餐补数据写入
/// </summary>

14
Src/Dlhis.Canteen/Order/Controllers/OrdersController.cs
View File

@@ -40,20 +40,6 @@ public class OrdersController : ControllerBase
return await _orderService.AddAsync(request);
}
[IgnoreTenant]
[HttpPost("ReCalcOffline")]
public async Task ReCalcOfflineAsync(ReCalcOfflineRequest request)
{
await _orderService.ReCalcOfflineAsync(request);
}
[IgnoreTenant]
[HttpPost("UpdateOffline")]
public async Task UpdateOffline(UpdateOfflineRequest outRequest)
{
await _orderService.UpdateOffline(outRequest);
}
/// <summary>
/// 设备发起订单
/// </summary>

2
Src/Dlhis.Canteen/Order/Request/BalanceRecordAnalysisRequest.cs
View File

@@ -15,7 +15,7 @@ public class BalanceRecordAnalysisRequest : PageDto, IValidatableObject
public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
{
if (SearchDateTimePeriod != null && SearchDateTimePeriod.End.HasValue)
if (SearchDateTimePeriod is { End: not null })
{
SearchDateTimePeriod.End = SearchDateTimePeriod.End.Value.AddDays(1).AddSeconds(-1);
}

8
Src/Dlhis.Canteen/Order/Request/BalanceRecordPageDetailRequest.cs
View File

@@ -23,14 +23,12 @@ public class BalanceRecordPageDetailRequest : PageDto, IValidatableObject
[EnumDataType(typeof(ShiftEnumType))]
public ShiftEnumType? ShiftType { get; set; }
public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
{
if (SearchDateTimePeriod != null)
if (SearchDateTimePeriod?.End != null)
{
if (SearchDateTimePeriod.End.HasValue)
{
SearchDateTimePeriod.End = SearchDateTimePeriod.End.Value.AddDays(1).AddSeconds(-1);
}
SearchDateTimePeriod.End = SearchDateTimePeriod.End.Value.AddDays(1).AddSeconds(-1);
}
yield break;

12
Src/Dlhis.Canteen/Order/Request/ConsumptionTrendRequest.cs
View File

@@ -1,12 +0,0 @@
using Dlhis.Entity.Canteen.Enums;
using System.ComponentModel.DataAnnotations;
namespace Dlhis.Canteen.Dishes.Request
{
public class ConsumptionTrendRequest
{
[Required]
[EnumDataType(typeof(ConsumptionTrendEnumType))]
public ConsumptionTrendEnumType Type { get; set; }
}
}

10
Src/Dlhis.Canteen/Order/Request/ReCalcOfflineRequest.cs
View File

@@ -1,10 +0,0 @@
using System.ComponentModel.DataAnnotations;
namespace Dlhis.Canteen.Order.Request
{
public class ReCalcOfflineRequest
{
[Required]
public string UserCode { get; set; }
}
}

7
Src/Dlhis.Canteen/Order/Request/UpdateOfflineRequest.cs
View File

@@ -1,7 +0,0 @@
namespace Dlhis.Canteen.Order.Request
{
public class UpdateOfflineRequest
{
public string No { get; set; }
}
}

2
Src/Dlhis.Canteen/Order/Response/AverageDailyResponse.cs
View File

@@ -20,5 +20,5 @@ public class AverageDailyResponse
/// <summary>
/// 日消费均额
/// </summary>
public int AverageAmount { get; set; }
public decimal AverageAmount { get; set; }
}

6
Src/Dlhis.Canteen/Order/Response/BalanceRecordAnalysisByCostResponse.cs Normal file
View File

@@ -0,0 +1,6 @@
namespace Dlhis.Canteen.Order.Response;
public class BalanceRecordAnalysisByCostResponse
{
}

2
Src/Dlhis.Canteen/Order/Services/IBalanceService.cs
View File

@@ -28,8 +28,6 @@ public interface IBalanceService : IScopeDependency
Task<Pagination<AverageDailyResponse>> AverageDailyAsync(AverageDailyRequest request);
Task<Pagination<DevicePageResponse>> GetConsumeDeviceAsync(GetConsumeDeviceRequest request);
Task HainingImportAsync(BalanceHainingImportRequest request);

2
Src/Dlhis.Canteen/Order/Services/IBalanceSummaryService.cs
View File

@@ -7,4 +7,6 @@ namespace Dlhis.Canteen.Order.Services;
public interface IBalanceSummaryService : IScopeDependency
{
Task<Pagination<BalanceRecordAnalysisResponse>> BalanceRecordAnalysisAsync(BalanceRecordAnalysisRequest request);
Task<Pagination<BalanceRecordAnalysisByCostResponse>> BalanceRecordAnalysisByCostIdAsync();
}

4
Src/Dlhis.Canteen/Order/Services/IOrderService.cs
View File

@@ -8,10 +8,6 @@ namespace Dlhis.Canteen.Order.Services;
public interface IOrderService : IScopeDependency
{
Task<DefaultApiResult<OrderResultResponse>> AddAsync(OrderAddRequest request);
Task ReCalcOfflineAsync(ReCalcOfflineRequest request);
Task UpdateOffline(UpdateOfflineRequest outRequest);
/// <summary>
/// 设备消费

156
Src/Dlhis.Canteen/Order/Services/Implements/BalanceService.cs
View File

@@ -9,6 +9,7 @@ using Dlhis.Entity.Device.Entities;
using Dlhis.Entity.Device.Enums;
using Dlhis.Sys.Api;
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;
@@ -187,10 +188,9 @@ public class BalanceService : IBalanceService
.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 => record.Type == BalanceRecordTypeEnumType.Out && record.Status == BalanceRecordStatusEnumType.Valid)
.Where(record => myCodes.Contains(record.BusinessPlaceCode))
.WhereIF(request.SearchDateTimePeriod?.Start.HasValue == true, record => record.CostDate >= request.SearchDateTimePeriod.Start)
.WhereIF(request.SearchDateTimePeriod?.End.HasValue == true, record => record.CostDate <= request.SearchDateTimePeriod.End)
.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);
@@ -348,157 +348,59 @@ public class BalanceService : IBalanceService
.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.Select(x => x.UserCode).Distinct().Count();
var dailyNumber = SameDay(bs, "");
var consumerable = bs.DistinctBy(x => x.UserCode).Count();
//消费走势
var months = await GetConsumptionTrendsAsync(ConsumptionTrendEnumType.Month);
var days = await GetConsumptionTrendsAsync(ConsumptionTrendEnumType.Day);
var months = await GetConsumptionTrendsAsync(1);
var days = await GetConsumptionTrendsAsync(2);
var res = new ConsumeNumberResponse
return new ConsumeNumberResponse
{
Total = devices.Count,
OffNumber = offCount.Count,
PlaceNumber = places.Count,
ConsumerableNumber = consumerable,
DailyNumber = dailyNumber,
DailyNumber = 0,
Days = days,
Months = months
};
return res;
}
/// <summary>
/// 获取单日消费数据
/// </summary>
/// <param name="bs"></param>
/// <param name="userCode"></param>
/// <returns></returns>
private static int SameDay(List<BalanceRecordEntity> bs, string userCode)
{
var time = DateTime.Now.ToString("yyyy-MM-dd");
var b = userCode.IsEmpty();
//当日消费数据
var monthbs = bs
.Where(x => x.CostDateTime.ToString("yyyy-MM-dd") == time)
.WhereIF(!userCode.IsEmpty(), x => x.UserCode == userCode);
//当日消费额
var monthlySpending = monthbs.Sum(x => x.Amount);
//当日消费人数
var monthlyCount = monthbs.Select(x => x.UserCode).Distinct().Count();
var dailyNumber = monthlyCount != 0 ? Math.Abs((int)Math.Ceiling(monthlySpending / monthlyCount)) : 0;
return dailyNumber;
}
public async Task<Pagination<SpendingDetailResponse>> GetSpendingDetailsAsync(SpendingDetailRequest request)
{
var brs = await _dbContext
return await _dbContext
.Queryable<BalanceRecordEntity>()
.Where(x => x.Type == BalanceRecordTypeEnumType.Out)
.ToListAsync();
var codes = brs.Select(x => x.UserCode).ToList().Distinct().ToList();
var lst = new List<SpendingDetailResponse>();
foreach (var code in codes)
{
var br = brs.Where(x => x.UserCode == code).FirstOrDefault();
var res = br.Adapt<SpendingDetailResponse>();
lst.Add(res);
}
// 分页操作
var startIndex = (request.PageIndex - 1) * request.PageSize;
var pagedData = lst.Skip(startIndex).Take(request.PageSize).ToList();
var pagination = new Pagination<SpendingDetailResponse>
{
PageIndex = request.PageIndex,
PageSize = request.PageSize,
Total = lst.Count, // 使用原始列表的总数进行分页
Data = pagedData
};
return pagination;
.Where(x => x.Status == BalanceRecordStatusEnumType.Valid)
.Select<SpendingDetailResponse>()
.Distinct()
.ToPageListAsync(request);
}
public async Task<Pagination<AverageDailyResponse>> AverageDailyAsync(AverageDailyRequest request)
{
//所有消费数据
var brs = await _dbContext.Queryable<BalanceRecordEntity>()
return await _dbContext.Queryable<BalanceRecordEntity>()
.Where(x => x.Type == BalanceRecordTypeEnumType.Out)
.ToListAsync();
var codes = brs.Select(x => x.UserCode).ToList().Distinct().ToList();
var lst = new List<AverageDailyResponse>();
foreach (var code in codes)
{
var br = brs.FirstOrDefault(x => x.UserCode == code);
var res = br.Adapt<AverageDailyResponse>();
var dailyNumber = SameDay(brs, code);
res.AverageAmount = dailyNumber;
lst.Add(res);
}
// 分页操作
var startIndex = (request.PageIndex - 1) * request.PageSize;
var pagedData = lst.Skip(startIndex).Take(request.PageSize).ToList();
var pagination = new Pagination<AverageDailyResponse>
{
PageIndex = request.PageIndex,
PageSize = request.PageSize,
Total = lst.Count, // 使用原始列表的总数进行分页
Data = pagedData
};
return pagination;
}
public async Task<Pagination<DevicePageResponse>> GetConsumeDeviceAsync(GetConsumeDeviceRequest request)
{
if (request.IsOff)
{
//消费机离线设备
var devices = await _dbContext.Queryable<DeviceEntity>()
.Where(x => x.Type == DeviceTypeEnumType.Meal)
.ToListAsync();
var offs = await GetOfflineDevicesCount(devices);
var offUniqueNos = offs.Select(x => x.UniqueNo).ToList();
var offpage = await _dbContext.Queryable<DeviceEntity>()
.LeftJoin<DeviceTemplateEntity>((d, dt) => d.TemplateCode == dt.Code)
.Where(d => offUniqueNos.Contains(d.UniqueNo))
.Select((d, dt) => new DevicePageResponse
{
FuncsStr = d.Funcs.ToString(),
Brand = dt.Brand,
Type = d.Type,
}, true)
.ToPageListAsync(request);
return offpage;
}
//消费机总数
var page = await _dbContext.Queryable<DeviceEntity>()
.LeftJoin<DeviceTemplateEntity>((d, dt) => d.TemplateCode == dt.Code)
.Where(d => d.Type == DeviceTypeEnumType.Meal)
.Select((d, dt) => new DevicePageResponse
.Where(x => x.Status == BalanceRecordStatusEnumType.Valid)
.GroupBy(x => new
{
FuncsStr = d.Funcs.ToString(),
Brand = dt.Brand,
Type = d.Type,
}, true)
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);
return page;
}
public async Task HainingImportAsync(BalanceHainingImportRequest request)
@@ -772,7 +674,7 @@ public class BalanceService : IBalanceService
return list;
}
private async Task<List<ConsumptionTrendResponse>> GetConsumptionTrendsAsync(ConsumptionTrendEnumType type)
private async Task<List<ConsumptionTrendResponse>> GetConsumptionTrendsAsync(int type)
{
var bs = await _dbContext.Queryable<BalanceRecordEntity>()
.Where(x => x.Type == BalanceRecordTypeEnumType.Out)
@@ -781,7 +683,7 @@ public class BalanceService : IBalanceService
var totalAmount = Math.Round(Math.Abs(bs.Sum(x => x.Amount)), 2);
var list = new List<ConsumptionTrendResponse>();
if (type == ConsumptionTrendEnumType.Month)
if (type == 1)
{
//月与总额对比
var months = GetMonthsOfYear();

47
Src/Dlhis.Canteen/Order/Services/Implements/BalanceSummaryService.cs
View File

@@ -21,11 +21,11 @@ public class BalanceSummaryService : IBalanceSummaryService
public async Task<Pagination<BalanceRecordAnalysisResponse>> BalanceRecordAnalysisAsync(BalanceRecordAnalysisRequest request)
{
var list = await _dbContext.Queryable<BalanceRecordEntity>()
.WhereIF(request.SearchDateTimePeriod?.Start.HasValue == true && request.SearchDateTimePeriod?.End.HasValue == true,
record => record.CostDate >= request.SearchDateTimePeriod.Start && record.CostDate <= request.SearchDateTimePeriod.End)
.WhereIF(request.BusinessPlaceCode.HasValue, record => record.BusinessPlaceCode == request.BusinessPlaceCode)
.Where(record => record.Type == BalanceRecordTypeEnumType.Out && record.Status == BalanceRecordStatusEnumType.Valid)
.ToListAsync();
.WhereIF(request.SearchDateTimePeriod.HasValue(),
record => record.CostDate >= request.SearchDateTimePeriod.Start && record.CostDate <= request.SearchDateTimePeriod.End)
.WhereIF(request.BusinessPlaceCode.HasValue, record => record.BusinessPlaceCode == request.BusinessPlaceCode)
.Where(record => record.Type == BalanceRecordTypeEnumType.Out && record.Status == BalanceRecordStatusEnumType.Valid)
.ToListAsync();
var shifts = Enum.GetValues<ShiftEnumType>().ToList();
@@ -44,10 +44,39 @@ public class BalanceSummaryService : IBalanceSummaryService
}).ToList(),
Total = grp.Where(x => x.CostDate == grp.Key).Select(x => x.UserNo).Distinct().Count()
};
})
.OrderByDescending(x => x.Date)
.ToPage(request);
}).OrderByDescending(x => x.Date).ToPage(request);
return page;
}
}
public async Task<Pagination<BalanceRecordAnalysisByCostResponse>> BalanceRecordAnalysisByCostIdAsync()
{
var list = await _dbContext.Queryable<BalanceRecordEntity>()
// .WhereIF(request.SearchDateTimePeriod?.Start.HasValue == true && request.SearchDateTimePeriod?.End.HasValue == true,
// record => record.CostDate >= request.SearchDateTimePeriod.Start && record.CostDate <= request.SearchDateTimePeriod.End)
//.WhereIF(request.BusinessPlaceCode.HasValue, record => record.BusinessPlaceCode == request.BusinessPlaceCode)
.Where(record => record.Type == BalanceRecordTypeEnumType.Out && record.Status == BalanceRecordStatusEnumType.Valid)
.ToListAsync();
var shifts = Enum.GetValues<ShiftEnumType>().ToList();
var page = list.GroupBy(record => record.CostDate.Date).Select(grp =>
{
return new BalanceRecordAnalysisResponse
{
Date = DateOnly.FromDateTime(grp.Key),
Items = shifts.Select(shift =>
{
return new KeyValueDto<ShiftEnumType, int>
{
Key = shift,
Value = grp.Where(x => x.ShiftType == shift).Select(x => x.UserNo).Distinct().Count()
};
}).ToList(),
Total = grp.Where(x => x.CostDate == grp.Key).Select(x => x.UserNo).Distinct().Count()
};
}).OrderByDescending(x => x.Date);
return null;
}
}

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

@@ -430,68 +430,6 @@ public class OrderService : BaseOrderService, IOrderService
return pageResult;
}
public async Task UpdateOffline(UpdateOfflineRequest outRequest)
{
var orders = await DbContext.Queryable<CanteenOrderEntity>().Where(x => x.IsOffline)
.Where(x => x.Status == BalanceRecordStatusEnumType.Valid)
.Where(x => x.OrderStatus == CanteenOrderStatusEnumType.Success)
.Where(x => x.ApplicationType == CanteenApplicationTypeEnumType.Device)
.Where(x => SqlFunc.IsNullOrEmpty(x.BusinessShiftCode))
.WhereIF(outRequest.No.IsPresent(), x => x.No == outRequest.No)
.ToListAsync();
foreach (var item in orders)
{
var request = item.RequestJson.ToObject<ConsumeRequest>();
var registry = await DbContext.Queryable<DeviceRegistryEntity>()
.Where(x => x.DeviceUniqueNo == request.DeviceUniqueNo)
.FirstAsync();
var businessPlaceInfo = await DbContext.Queryable<BusinessPlaceEntity>()
.LeftJoin<BusinessPlaceShiftRelationshipEntity>((x, sr) => x.Code == sr.PlaceCode)
.Where(x => x.Code == registry.BusinessPlaceCode)
.Select((x, sr) => new
{
x.Code,
sr.ShiftCode,
x.TenantId
})
.FirstAsync();
//获取当前消费餐次
var shifts = await DbContext.Queryable<BusinessShiftMealRelationshipEntity>().Where(x => x.ShiftCode == businessPlaceInfo.ShiftCode).ToListAsync();
var shift = shifts.FirstOrDefault(x => new TimePeriod()
{
Start = x.Start,
End = x.End
}.IsPresent1(request.CostDateTime));
var costDate = await GetCostDateAsync(shift, request.CostDateTime);
var shiftType = shift?.ShiftType;
await DbContext.Updateable<CanteenOrderEntity>()
.SetColumns(x => x.BusinessShiftCode == businessPlaceInfo.ShiftCode)
.SetColumns(x => x.CostDate == costDate)
.SetColumns(x => x.CostDateTime == request.CostDateTime)
.SetColumns(x => x.ShiftType == shiftType)
.Where(x => x.No == item.No)
.ExecuteCommandAsync();
await DbContext.Updateable<BalanceRecordEntity>()
.SetColumns(x => x.BusinessShiftCode == businessPlaceInfo.ShiftCode)
.SetColumns(x => x.CostDate == costDate)
.SetColumns(x => x.CostDateTime == request.CostDateTime)
.SetColumns(x => x.ShiftType == shiftType)
.Where(x => x.No == item.No)
.ExecuteCommandAsync();
}
}
//******************************************************* help methods ************************************************************/
/// <summary>
@@ -637,56 +575,6 @@ public class OrderService : BaseOrderService, IOrderService
// }
}
public async Task ReCalcOfflineAsync(ReCalcOfflineRequest request)
{
var gainfo = await DbContext.Queryable<GainfoEntity>().Where(x => x.Code == request.UserCode).FirstAsync();
var nos = await DbContext.Queryable<BalanceRecordEntity>().Where(x => x.UserCode == request.UserCode).Select(x => x.No).ToListAsync();
var orders = await DbContext.Queryable<CanteenOrderEntity>()
.Where(x => x.IsOffline)
.Where(x => !nos.Contains(x.No))
.Where(x => x.UserCode == request.UserCode)
.ToListAsync();
var gainfoMeal = await DbContext.Queryable<GainfoMealEntity>().Where(x => x.UserNo == gainfo.No).FirstAsync();
if (gainfoMeal == null)
{
gainfoMeal = new GainfoMealEntity
{
Balance = 0,
BalanceOfRecharge = 0,
BalanceOfSubsidies = 0,
Version = 0,
UserNo = gainfo.No,
UserCode = gainfo.Code,
};
await DbContext.InsertAsync(gainfoMeal);
}
foreach (var order in orders)
{
await CommonHelper.RetryAsync(async () =>
{
var currentGainfoMeal = await DbContext.Queryable<GainfoMealEntity>().Where(x => x.UserNo == order.UserNo).FirstAsync();
//金额+-
currentGainfoMeal.Balance += order.Amount;
await DbContext.Updateable<GainfoMealEntity>()
.SetColumns(x => x.Balance == currentGainfoMeal.Balance)
.SetColumns(x => x.Version == x.Version + 1)
.SetColumns(x => x.ModifiedTime == DateTime.Now)
.Where(x => x.UserNo == order.UserNo && x.Version == currentGainfoMeal.Version) //必须与查询时的version一致
.ExecuteCommandThrowVersionAsync();
//写入记录
var balanceRecord = order.Adapt<BalanceRecordEntity>();
balanceRecord.Id = 0;
await DbContext.InsertAsync(balanceRecord);
}, 5);
}
}
/// <summary>
/// 根据二维码获取消费用户
/// </summary>

5
Src/Dlhis.Entity/Canteen/Enums/BalanceRecordSourceEnumType.cs
View File

@@ -32,6 +32,11 @@ public enum BalanceRecordSourceEnumType
[Description("现场支付")]
Cash,
/// <summary>
/// 电子餐券
/// </summary>
[Description("电子餐券")]
EVoucher,
//*********************************************************************************************************
/// <summary>

24
Src/Dlhis.Entity/Canteen/Enums/ConsumptionTrendEnumType.cs
View File

@@ -1,24 +0,0 @@
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Dlhis.Entity.Canteen.Enums
{
public enum ConsumptionTrendEnumType
{
/// <summary>
/// 日
/// </summary>
[Description("日")]
Day = 1,
/// <summary>
/// 月
/// </summary>
[Description("月")]
Month = 2,
}
}