/// <summary>
/// 根据活动ID,与PID集合查询对应的活动信息与产品信息
/// </summary>
/// <param name="activityID"></param>
/// <param name="pids"></param>
/// <returns></returns>
public async Task <OperationResult <List <FlashSaleModel> > > SelectFlashSaleDataByActivityIdsAsync(List <FlashSaleDataByActivityRequest> flashSaleDataByActivityRequests)
{
if (flashSaleDataByActivityRequests.Count > 50)
{
return(OperationResult.FromError <List <FlashSaleModel> >(ErrorCode.ParameterError, "最多支持50个活动ID集合查询"));
}
return(OperationResult.FromResult(await FlashSaleManager.SelectFlashSaleDataByActivityIdsAsync(flashSaleDataByActivityRequests)));
}
/// <summary>
/// 新活动页查询活动信息接口
/// </summary>
/// <param name="flashSaleActivityPageRequest"></param>
/// <returns></returns>
public async Task <OperationResult <List <FlashSaleActivityPageModel> > > GetFlashSaleDataActivityPageByIdsAsync(List <FlashSaleActivityPageRequest> flashSaleActivityPageRequest)
{
if (flashSaleActivityPageRequest.Count > 20)
{
return(OperationResult.FromError <List <FlashSaleActivityPageModel> >(ErrorCode.ParameterError, "最多支持20个活动ID集合查询"));
}
return(OperationResult.FromResult(await FlashSaleManager.GetFlashSaleDataActivityPageByIdsAsync(flashSaleActivityPageRequest)));
}
/// <summary>
/// 查询限时抢购详情
/// </summary>
/// <param name="productId"></param>
/// <param name="variantId"></param>
/// <param name="activityId"></param>
/// <param name="channel"></param>
/// <param name="userId"></param>
/// <param name="productGroupId"></param>
/// <param name="btyQty"></param>
/// <returns></returns>
public async Task <OperationResult <FlashSaleProductDetailModel> > FetchProductDetailForFlashSaleAsync(string productId, string variantId, string activityId, string channel, string userId, string productGroupId = null, int btyQty = 1)
{
Guid result;
if (!Guid.TryParse(activityId, out result))
{
return(OperationResult.FromError <FlashSaleProductDetailModel>(ErrorCode.ParameterError, "参数无效"));
}
return(OperationResult.FromResult(await FlashSaleManager.FetchProductDetailForFlashSaleAsync(productId, variantId, activityId, channel, productGroupId, userId)));
}
/// <summary>
/// 天天秒杀数据列表缓存刷新
/// </summary>
/// <param name="activityId">活动ID</param>
/// <returns></returns>
public async Task <OperationResult <bool> > SpikeListRefreshAsync(Guid activityId)
{
if (activityId == null)
{
return(OperationResult.FromError <bool>("-1", "活动ID不可为空"));
}
else
{
return(OperationResult.FromResult(await FlashSaleManager.SpikeListRefreshAsync(activityId)));
}
}
public async Task <OperationResult <FlashSaleProductCanBuyCountModel> > GetUserCanBuyFlashSaleItemCountAsync(Guid userId, Guid activityId, string pid)
{
if (userId == Guid.Empty || activityId == Guid.Empty || string.IsNullOrWhiteSpace(pid))
{
return(OperationResult.FromError <FlashSaleProductCanBuyCountModel>("-1", "参数错误"));
}
else
{
return(OperationResult.FromResult(await FlashSaleManager.GetUserCanBuyFlashSaleItemCountAsync(userId, activityId, pid)));
}
}
/// <summary>
/// 根据时间范围查询秒杀场次信息
/// </summary>
/// <param name="activityType"></param>
/// <param name="startDate"></param>
/// <param name="endDate"></param>
/// <returns></returns>
public async Task <OperationResult <IEnumerable <FlashSaleModel> > > GetSecondsBoysAsync(int activityType, DateTime?startDate = null, DateTime?endDate = null)
{
if (startDate == null || endDate == null)
{
return(OperationResult.FromError <IEnumerable <FlashSaleModel> >("-1", "参数错误"));
}
else
{
return(OperationResult.FromResult(await FlashSaleManager.GetSecondsBoysAsync(activityType, startDate, endDate)));
}
}
/// <summary>
/// 活动页秒杀查询最新有效场次
/// </summary>
/// <param name="topNumber">场次返回条数</param>
/// <param name="isProducts">是否查询活动下的产品信息，默认为true</param>
/// <returns></returns>
public async Task <OperationResult <IEnumerable <FlashSaleModel> > > GetActivePageSecondKillAsync(int topNumber, bool isProducts = true)
{
if (topNumber <= 0)
{
return(OperationResult.FromError <IEnumerable <FlashSaleModel> >("-1", "topNumber必须大于0"));
}
else
{
return(OperationResult.FromResult(await FlashSaleManager.GetActivePageSecondKillManager(topNumber, isProducts)));
}
}
public async Task <OperationResult <FlashSaleOrderResponse> > CheckCanBuyFlashSaleOrderAsync(FlashSaleOrderRequest request)
{
if (request == null ||
request.UserId == Guid.Empty ||
string.IsNullOrWhiteSpace(request.UseTel) ||
request.Products == null ||
!request.Products.Any())
{
return(OperationResult.FromError <FlashSaleOrderResponse>("-1", "参数错误"));
}
else
{
return(OperationResult.FromResult(await FlashSaleManager.CheckCanBuyFlashSaleOrderAsync(request)));
}
}
public async Task <OperationResult <UserReminderInfo> > GetUserReminderInfoAsync(EveryDaySeckillUserInfo model)
{
return(await OperationResult.FromResultAsync(FlashSaleManager.GetUserReminderInfoAsync(model)));
}
/// <inheritdoc />
/// <summary>
/// 根据场次Id获取天天秒杀产品数据
/// </summary>
/// <param name="request">场次活动Id</param>
/// <returns></returns>
public async Task <OperationResult <List <FlashSaleProductModel> > > SelectSeckillDataByActivityIdAsync(SelectSecKillByIdRequest request)
{
return(await OperationResult.FromResultAsync(FlashSaleManager.SelectSeckillDataByActivityIdAsync(request)));
}
public Task <OperationResult <bool> > OrderCancerMaintenanceFlashSaleDataAsync(int orderId)
=> OperationResult.FromResultAsync <bool>(FlashSaleManager.OrderCancerMaintenanceFlashSaleData(orderId));
public Task <OperationResult <IEnumerable <FlashSaleProductBuyLimitModel> > > CheckFlashSaleProductBuyLimitAsync(CheckFlashSaleProductRequest request) => OperationResult.FromResultAsync(FlashSaleManager.CheckFlashSaleProductBuyLimitAsync(request));
public Task <OperationResult <List <FlashSaleModel> > > GetFlashSaleListAsync(Guid[] activityIDs) => OperationResult.FromResultAsync(FlashSaleManager.GetFlashSaleListAsync(activityIDs));
public async Task <OperationResult <FlashSaleModel> > SelectFlashSaleDataByActivityIDAsync(Guid activityID) => OperationResult.FromResult(await FlashSaleManager.SelectFlashSaleDataByActivityIDAsync(activityID));
public async Task <OperationResult <bool> > UpdateConfigSaleoutQuantityFromLogAsync(UpdateConfigSaleoutQuantityRequest request)
{
return(OperationResult.FromResult(await FlashSaleManager.UpdateConfigSaleoutQuantityFromLogAsync(request)));
}
public async Task <OperationResult <bool> > OrderCreateMaintenanceFlashSaleDbDataAsync(FlashSaleOrderRequest flashSale)
{
return(OperationResult.FromResult(await FlashSaleManager.OrderCreateMaintenanceFlashSaleDbDataAsync(flashSale)));
}
public async Task <OperationResult <List <FlashSaleWrongCacheResponse> > > SelectFlashSaleWrongCacheAsync()
{
return(OperationResult.FromResult(await FlashSaleManager.SelectFlashSaleWrongCacheAsync()));
}
public async Task <OperationResult <OrderCountResponse> > SetUserCreateFlashOrderCountCacheAsync(OrderCountCacheRequest request)
{
return(OperationResult.FromResult(await FlashSaleManager.SetUserCreateFlashOrderCountCacheAsync(request)));
}
public async Task <OperationResult <List <FlashSaleModel> > > GetFlashSaleWithoutProductsListAsync(List <Guid> activityids)
{
return(OperationResult.FromResult(await FlashSaleManager.GetFlashSaleWithoutProductsListAsync(activityids)));
}
public async Task <OperationResult <bool> > RefreshFlashSaleHashCountAsync(List <string> activtyids, bool isAllRefresh)
{
return(OperationResult.FromResult <bool>(await FlashSaleManager.RefreshFlashSaleHashCountAsync(activtyids, isAllRefresh)));
}
private static async Task <CheckFlashSaleResponseModel> CheckFlashSaleByPidAsync(OrderItems item, Guid userId, string deviceId, string userTel)
{
var hasMaxLimit = false;
var hasPlaceLimit = false;
string allPlaceLimitId = null;
try
{
if (!item.ActivityId.HasValue)
{
return new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.NoExist,
}
}
;
var flashSale = await DalFlashSale.FetchFlashSaleProductModel(item);
if (flashSale == null)
{
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.NoExist,
});
}
var model = await FlashSaleCounter.RedisHashRecord(item.PID, item);
if (model.Code == CheckFlashSaleStatus.CreateOrderFailed)
{
return new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
}
}
;
var record = model.Record;
var remainQuantity = flashSale.TotalQuantity - record;
if (remainQuantity < 0)
{
return new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.NoEnough,
}
}
;
var request = new GenerateKeyRequest
{
DeviceId = deviceId,
UserId = userId.ToString(),
UserTel = userTel,
ActivityId = item.ActivityId.ToString(),
Pid = item.PID
};
var countKey = new GenerateFlashSaleKey(request);
if (flashSale.MaxQuantity.HasValue)
{
var personLimit1 = await FlashSaleCounter.RedisCounterRecord(countKey.PersonalkeyUserId,
LimitType.PersonalLimit, CounterKeyType.UserIdKey, item, userId, deviceId, userTel, null, -1);
if (personLimit1.Code < 0)
{
return new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
}
}
;
var personLimit2 = await FlashSaleCounter.RedisCounterRecord(countKey.PersonalkeyDeviceId,
LimitType.PersonalLimit, CounterKeyType.DeviceIdKey, item, userId, deviceId, userTel, null,
personLimit1.DeviceCount);
if (personLimit2.Code < 0)
{
var orderItem = new CheckFlashSaleResponseModel
{
Num = item.Num
};
await FlashSaleCounter.DecrementCountCount(orderItem, countKey.PersonalkeyUserId);
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
});
}
var personLimit3 = await FlashSaleCounter.RedisCounterRecord(countKey.PersonalkeyUseTel,
LimitType.PersonalLimit, CounterKeyType.UserTelKey, item, userId, deviceId, userTel, null,
personLimit1.TelCount);
if (personLimit3.Code < 0)
{
var orderItem = new CheckFlashSaleResponseModel
{
Num = item.Num
};
await FlashSaleCounter.DecrementCountCount(orderItem, countKey.PersonalkeyUserId);
await FlashSaleCounter.DecrementCountCount(orderItem, countKey.PersonalkeyDeviceId);
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
});
}
if (personLimit1.Code < 0 || personLimit2.Code < 0 || personLimit3.Code < 0)
{
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
});
}
var maxLimit = Math.Max(Math.Max(personLimit1.Record, personLimit2.Record), personLimit3.Record);
hasMaxLimit = true;
if (maxLimit > flashSale.MaxQuantity)
{
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.MaxQuantityLimit,
HasQuantityLimit = true
});
}
}
if (flashSale.PlaceQuantity.HasValue && flashSale.PlaceQuantity.Value > 0)
{
var saleProducts = (await DalFlashSale.SelectFlashSaleProductsAsync(item.ActivityId.Value)).ToList();
var salePids = saleProducts.Where(r => r.IsJoinPlace).Select(r => r.PID).ToList();
if (salePids.Contains(item.PID))
{
var placeLimit1 = await FlashSaleCounter.RedisCounterRecord(countKey.PlacekeyUserId,
LimitType.PlaceLimit, CounterKeyType.UserIdKey, item, userId, deviceId, userTel, salePids,
-1);
if (placeLimit1.Code < 0)
{
return new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
}
}
;
var placeLimit2 = await FlashSaleCounter.RedisCounterRecord(countKey.PlacekeyDeviceId,
LimitType.PlaceLimit, CounterKeyType.DeviceIdKey, item, userId, deviceId, userTel, salePids,
placeLimit1.DeviceCount);
if (placeLimit2.Code < 0)
{
var orderItem = new CheckFlashSaleResponseModel
{
Num = item.Num
};
await FlashSaleCounter.DecrementCountCount(orderItem, countKey.PlacekeyUserId);
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
});
}
var placeLimit3 = await FlashSaleCounter.RedisCounterRecord(countKey.PlacekeyUseTel,
LimitType.PlaceLimit, CounterKeyType.UserTelKey, item, userId, deviceId, userTel, salePids,
placeLimit1.TelCount);
if (placeLimit3.Code < 0)
{
var orderItem = new CheckFlashSaleResponseModel
{
Num = item.Num
};
await FlashSaleCounter.DecrementCountCount(orderItem, countKey.PlacekeyUserId);
await FlashSaleCounter.DecrementCountCount(orderItem, countKey.PlacekeyDeviceId);
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
});
}
if (placeLimit1.Code < 0 || placeLimit2.Code < 0 || placeLimit3.Code < 0)
{
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
});
}
hasPlaceLimit = true;
var placeLimit = Math.Max(Math.Max(placeLimit1.Record, placeLimit2.Record), placeLimit3.Record);
if (placeLimit > flashSale.PlaceQuantity.Value)
{
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.PlaceQuantityLimit,
HasQuantityLimit = hasMaxLimit,
HasPlaceLimit = true
});
}
}
}
#region 针对618增加一个全局会场限购
if (flashSale.ActiveType == 3 && FlashSaleManager.CheckAllPlaceLimitStatrtDate())
{
var allPLimitId = GlobalConstant.AllPlaceLimitId;
item.AllPlaceLimitId = allPLimitId;
var request1 = new GenerateKeyRequest
{
DeviceId = deviceId,
UserId = userId.ToString(),
UserTel = userTel,
ActivityId = item.AllPlaceLimitId,
Pid = item.PID,
IsAllPlaceLimit = true
};
var countKeyAllLimit = new GenerateFlashSaleKey(request1);
var config = await FlashSaleManager.SelectFlashSaleDataByActivityIDAsync(new Guid(allPLimitId));
if (config.PlaceQuantity.HasValue)
{
var saleProducts = config.Products.ToList();
var salePids = saleProducts.Where(r => r.IsJoinPlace).Select(r => r.PID).ToList();
if (salePids.Contains(item.PID))
{
var placeLimit1 = await FlashSaleCounter.RedisCounterRecord(
countKeyAllLimit.PlacekeyUserId, LimitType.AllPlaceLimit, CounterKeyType.UserIdKey, item,
userId, deviceId, userTel, salePids, -1);
if (placeLimit1.Code < 0)
{
return new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
}
}
;
var placeLimit2 = await FlashSaleCounter.RedisCounterRecord(countKeyAllLimit.PlacekeyDeviceId,
LimitType.AllPlaceLimit, CounterKeyType.DeviceIdKey, item, userId, deviceId, userTel,
salePids, placeLimit1.DeviceCount);
if (placeLimit2.Code < 0)
{
var orderItem = new CheckFlashSaleResponseModel
{
Num = item.Num
};
await FlashSaleCounter.DecrementCountCount(orderItem, countKeyAllLimit.PlacekeyUserId);
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
});
}
var placeLimit3 = await FlashSaleCounter.RedisCounterRecord(countKeyAllLimit.PlacekeyUseTel,
LimitType.AllPlaceLimit, CounterKeyType.UserTelKey, item, userId, deviceId, userTel,
salePids, placeLimit1.TelCount);
if (placeLimit3.Code < 0)
{
var orderItem = new CheckFlashSaleResponseModel
{
Num = item.Num
};
await FlashSaleCounter.DecrementCountCount(orderItem, countKeyAllLimit.PlacekeyUserId);
await FlashSaleCounter.DecrementCountCount(orderItem, countKeyAllLimit.PlacekeyDeviceId);
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
});
}
if (placeLimit1.Code < 0 || placeLimit2.Code < 0 || placeLimit3.Code < 0)
{
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
});
}
var allplaceLimit = Math.Max(Math.Max(placeLimit1.Record, placeLimit2.Record),
placeLimit3.Record);
allPlaceLimitId = allPLimitId;
if (allplaceLimit > config.PlaceQuantity.Value)
{
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.PlaceQuantityLimit,
AllPlaceLimitId = allPlaceLimitId
});
}
}
#region 错误代码
//var hashRecord618 = await FlashSaleCounter.RedisAllPlaceLimitHashRecord(item.PID, item);
//if (hashRecord618 != null)
//{
// if (hashRecord618.Code == CheckFlashSaleStatus.CreateOrderFailed)
// return new CheckFlashSaleResponseModel()
// {
// Code = CheckFlashSaleStatus.CreateOrderFailed,
// };
// var saledAll = model.Record;
// var config =
// await FlashSaleManager.SelectFlashSaleDataByActivityIDAsync(
// new Guid(allPLimitId));
// var configQty = config.Products.Where(r => r.PID == item.PID).Select(r => r.TotalQuantity).FirstOrDefault();
// allPlaceLimitId = allPLimitId;
// if (configQty - saledAll < 0)
// return new CheckFlashSaleResponseModel()
// {
// Code = CheckFlashSaleStatus.NoEnough,
// AllPlaceLimitId = allPlaceLimitId
// };
//}
#endregion
}
}
#endregion
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.Succeed,
HasPlaceLimit = hasPlaceLimit,
HasQuantityLimit = hasMaxLimit,
AllPlaceLimitId = allPlaceLimitId
});
#endregion
}
catch (Exception ex)
{
Logger.Info(ex);
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
HasPlaceLimit = hasPlaceLimit,
HasQuantityLimit = hasMaxLimit
});
}
}
public async Task <OperationResult <InsertEveryDaySeckillUserInfoResponse> > InsertEveryDaySeckillUserInfoAsync(EveryDaySeckillUserInfo model)
{
return(await OperationResult.FromResultAsync(FlashSaleManager.InsertEveryDaySeckillUserInfo(model)));
}
public async Task <OperationResult <bool> > UpdateFlashSaleDataToCouchBaseByActivityIDAsync(Guid activityID) => OperationResult.FromResult(await FlashSaleManager.UpdateFlashSaleCacheAsync(activityID));
public async Task <OperationResult <bool> > RefreshSeckillDefaultDataByScheduleAsync(string schedule)
{
return(await OperationResult.FromResultAsync(FlashSaleManager.RefreshSeckillDefaultDataByScheduleAsync(schedule)));
}
public async Task <OperationResult <IEnumerable <FlashSaleModel> > > SelectSecondKillTodayDataAsync(int activityType, DateTime?scheduleDate = null, bool needProducts = true, bool excludeProductTags = false) => OperationResult.FromResult(await FlashSaleManager.SelectSecondKillTodayDataAsync(activityType, scheduleDate, needProducts, excludeProductTags));
public async Task <OperationResult <Dictionary <string, List <SeckilScheduleInfoRespnose> > > > GetSeckillScheduleInfoAsync(List <string> pids, DateTime sSchedule, DateTime eSchedule)
{
return(await OperationResult.FromResultAsync(FlashSaleManager.GetSeckillScheduleInfoAsync(pids, sSchedule, eSchedule)));
}
/// <summary> /// 获取保养活动状态 /// </summary> /// <param name="activityId"></param> /// <param name="userId"></param> /// <param name="regionId"></param> /// <returns></returns> public Task <OperationResult <FixedPriceActivityStatusResult> > GetFixedPriceActivityStatusAsync(Guid activityId, Guid userId, int regionId) => OperationResult.FromResultAsync(FlashSaleManager.GetFixedPriceActivityStatus(activityId, userId, regionId));
/// <inheritdoc />
/// <summary>
/// 查询首页天天秒杀数据
/// </summary>
/// <param name="request">查询个数</param>
/// <returns></returns>
public async Task <OperationResult <List <FlashSaleModel> > > SelectHomeSeckillDataAsync(SelectHomeSecKillRequest request)
{
return(await OperationResult.FromResultAsync(FlashSaleManager.SelectHomeSeckillDataWithMemoryAsync(request)));
}
public async Task <OperationResult <List <SeckillAvailableStockInfoResponse> > > GetSeckillAvailableStockResponseAsync(List <SeckillAvailableStockInfoRequest> request)
{
return(await OperationResult.FromResultAsync(FlashSaleManager.GetSeckillAvailableStockResponseAsync(request)));
}
/// <summary> /// 减少计数器 /// </summary> /// <param name="activityId">活动ID</param> /// <returns></returns> public Task <OperationResult <bool> > DecrementCounterAsync(int orderId) => OperationResult.FromResultAsync(FlashSaleManager.DecrementCounter(orderId));
