public static async Task <OrderCountResponse> SetUserCreateFlashOrderCountCacheAsync(
OrderCountCacheRequest request)
{
var keyModels = SetKeys(request);
var flashSale = await DalFlashSale.FetchFlashSaleProductModel(new OrderItems()
{
PID = request.Pid,
ActivityId = new Guid(request.ActivityId)
});
var response = new OrderCountResponse();
using (var client = CacheHelper.CreateCounterClient(ClientName))
{
//Queryable<int> personSorts = new Queryable[4, 5, 6];
//个人限购
if (flashSale.MaxQuantity.HasValue)
{
foreach (var key in keyModels.OrderBy(r => r.Sort).Where(r => r.Sort == 4 || r.Sort == 5 || r.Sort == 6))
{
response = await SetCountValue(response, key.Key, request.PerSonalNum, client);
if (response.RedisField)
{
break;
}
}
}
//会场限购
if (flashSale.PlaceQuantity.HasValue && flashSale.PlaceQuantity.Value > 0)
{
var saleProducts = (await DalFlashSale.SelectFlashSaleFromDBAsync(new Guid(request.ActivityId))).Products.ToList();
var salePids = saleProducts.Where(r => r.IsJoinPlace).Select(r => r.PID).ToList();
if (salePids.Contains(request.Pid))
{
foreach (var key in keyModels.OrderBy(r => r.Sort).Where(r => r.Sort == 1 || r.Sort == 2 || r.Sort == 3))
{
response = await SetCountValue(response, key.Key, request.PlaceNum, client);
if (response.RedisField)
{
break;
}
}
}
}
}
if (response.RedisField)
{
return(response);
}
return(await GetUserCreateFlashOrderCountCacheAsync(request));
}
private static async Task <OrderCountResponse> SetCountValue(OrderCountResponse model, string key, int num, CounterClient client)
{
var getcount = await client.CountAsync(key);
if (!getcount.Success && !getcount.Message.Equals("Key不存在"))
{
model.RedisField = true;
model.RedisMsg = getcount.Message;
return(model);
}
else
{
IResult <long> setcount;
if (getcount.Message != null && getcount.Message.Equals("Key不存在"))
{
setcount = await client.IncrementAsync(key, num);
if (!setcount.Success)
{
model.RedisField = true;
model.RedisMsg = getcount.Message;
return(model);
}
}
else
{
var discountcounter = await client.DecrementAsync(key, getcount.Value);
if (!discountcounter.Success)
{
model.RedisField = true;
model.RedisMsg = getcount.Message;
return(model);
}
else
{
setcount = await client.IncrementAsync(key, num);
if (!setcount.Success)
{
model.RedisField = true;
model.RedisMsg = getcount.Message;
return(model);
}
}
}
}
return(model);
}
public static async Task <OrderCountResponse> GetUserCreateFlashOrderCountCacheAsync(
OrderCountCacheRequest request)
{
var responseModel = new OrderCountResponse();
var keyModels = SetKeys(request);
using (var client = CacheHelper.CreateCounterClient(ClientName))
{
foreach (var key in keyModels.OrderBy(r => r.Sort))
{
await GetCountValue(responseModel, key.Type, key.Key, client);
//if(result.RedisField)
// break;
}
}
var flashsale = (await DalFlashSale.SelectFlashSaleFromDBAsync(new Guid(request.ActivityId)));
if (flashsale == null)
{
return(responseModel);
}
var saleProducts = flashsale.Products.ToList();
var salePids = saleProducts.Where(r => r.IsJoinPlace).Select(r => r.PID).ToList();
var saleproduct = saleProducts.FirstOrDefault(r => r.PID == request.Pid);
var records = (await DalFlashSale.SelectOrderActivityProductOrderRecordsAsync(
new Guid(request.UserId), request.DeviceId,
new Guid(request.ActivityId), request.UserTel)).ToList();
var personQty = records?.Where(r => r.PID == request.Pid).Sum(r => r.Quantity) ?? 0;
var placeQty = records.Where(r => salePids.Contains(r.PID)).Sum(r => r.Quantity);
responseModel.UserDbPersonLimitQty = personQty;
responseModel.UserDbPlaceLimitQty = placeQty;
responseModel.PersonConfigLimitQty = saleproduct?.MaxQuantity;
responseModel.PlaceConfigLimitQty = saleproduct?.PlaceQuantity;
responseModel.TotalConfigQty = saleproduct?.TotalQuantity;
return(responseModel);
}
private static async Task <OrderCountResponse> GetCountValue(OrderCountResponse model, KeyType type, string key, CounterClient client)
{
switch (type)
{
case KeyType.PlaceUserIdKey:
var counterpu = await client.CountAsync(key);
if (counterpu.Success)
{
model.PlaceUserIdCountCacheNum = (int)counterpu.Value;
}
else
{
model.RedisField = true;
model.RedisMsg = $"{counterpu.Message}key==>{key},";
// return model;
}
break;
case KeyType.PlaceDeviceIdKey:
var counterpd = await client.CountAsync(key);
if (counterpd.Success)
{
model.PlaceDeviceCountCacheNum = (int)counterpd.Value;
}
else
{
model.RedisField = true;
model.RedisMsg += $"{counterpd.Message}key==>{key},";
// return model;
}
break;
case KeyType.PlaceUserTelKey:
var counterpt = await client.CountAsync(key);
if (counterpt.Success)
{
model.PlaceUserTelCountCacheNum = (int)counterpt.Value;
}
else
{
model.RedisField = true;
model.RedisMsg += $"{counterpt.Message}key==>{key},";
// return model;
}
break;
case KeyType.PersonUserIdKey:
var counterpu2 = await client.CountAsync(key);
if (counterpu2.Success)
{
model.PersonUserIdCountCacheNum = (int)counterpu2.Value;
}
else
{
model.RedisField = true;
model.RedisMsg += $"{counterpu2.Message}key==>{key},";
return(model);
}
break;
case KeyType.PersonDeviceIdKey:
var counterpd2 = await client.CountAsync(key);
if (counterpd2.Success)
{
model.PersonDeviceCountCacheNum = (int)counterpd2.Value;
}
else
{
model.RedisField = true;
model.RedisMsg += $"{counterpd2.Message}key==>{key},";
// return model;
}
break;
case KeyType.PersonUserTelKey:
var counterpt2 = await client.CountAsync(key);
if (counterpt2.Success)
{
model.PersonUserTelCountCacheNum = (int)counterpt2.Value;
}
else
{
model.RedisField = true;
model.RedisMsg += $"{counterpt2.Message}key==>{key}";
// return model;
}
break;
default:
return(model);
}
return(model);
}
