Files
KJD_WebService/KJD_WebService/Services/Users/UserService.OEM.cs
T

552 lines
26 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
using FreeSql.Internal.Model;
using KJD_Web.Model.WxModel;
using KJD_Web.Requests.Users;
using KJD_Web.Responses.Users;
using MAX.Core.DependencyInjection;
using Store.Contracts.User.Entitys;
using Store.Contracts.User.Enums;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Web;
namespace KJD_Web.Services.Users;
public partial class UserService
{
private static List<OEMEntity> OEMData = null;
public OEMEntity GetOEMByUserName(string userName, bool isCache = true)
{
if (string.IsNullOrEmpty(userName)) return null;
if (isCache)
{
if (OEMData == null)
{
OEMData = _freeSql.Select<OEMEntity>().ToList();
}
return OEMData.FirstOrDefault(a => a.OemOwner == userName && a.IsDel == 0);
}
else
{
return _freeSql.Select<OEMEntity>().Where(a => a.OemOwner == userName && a.IsDel == 0).First();
}
}
public OEMEntity GetOEMByOemId(string oemId, bool isCache = true)
{
if (string.IsNullOrEmpty(oemId)) return null;
if (isCache)
{
if (OEMData == null)
{
OEMData = _freeSql.Select<OEMEntity>().ToList();
}
return OEMData.FirstOrDefault(a => a.OemId == oemId);
}
else
{
return _freeSql.Select<OEMEntity>().Where(a => a.OemId == oemId).First();
}
}
/// <summary>
/// 获取所有OEM用户包含子用户
/// </summary>
/// <param name="oemId"></param>
/// <returns></returns>
public List<UserEntity> GetOEMUsers(string oemId, bool includeSu = true)
{
// 1. 该 oem 下的主账号
string s = _freeSql.Select<UserEntity>().Where(u => u.OemId == oemId).ToSql();
var mainUsers = _freeSql.Select<UserEntity>()
.Where(u => u.OemId == oemId)
.ToList();
var allUsers = mainUsers;
if (includeSu)
{
// 2. 主账号的 UserName
var mainUserNames = mainUsers.Select(u => u.UserName).ToList();
// 3. 这些主账号对应的子账号
var subUsers = mainUserNames.Count == 0
? new List<UserEntity>()
: _freeSql.Select<UserEntity>()
.Where(u => mainUserNames.Contains(u.ParentUserName))
.ToList();
// 4. 合并,去重
allUsers = mainUsers
.Concat(subUsers)
.Distinct()
.ToList();
}
return allUsers;
}
/// <summary>
/// 获取返利记录
/// </summary>
public (List<RebateRecordResponse> List, long Total) GetRebateRecords(RebateRecordRequest request)
{
long total = 0;
List<RebateRecordResponse> list = new List<RebateRecordResponse>();
var oem = GetOEMByUserName(request.UserName);
if (oem == null)
throw new Exception("无权限");
if (request.Type == 0) //运费流水
{
var users = GetOEMUsers(oem.OemId);
request.StartTime = oem.AddTime;
if (request.StartTime > request.EndTime)
request.EndTime = DateTime.Now;
var userNames = users.Select(u => u.UserName).ToList();
int[] positiveTypes = [16, 20, 26, 31, 35, 39, 55];
int[] negativeTypes = [34, 23, 38, 32, 36, 40];
var paymentTypes = positiveTypes.Concat(negativeTypes).ToArray();
var query = _freeSql.Select<UserPaymentRecordEntity>()
.Where(a => paymentTypes.Contains(a.Type))
.Where(a => userNames.Contains(a.UserName))
.Where(a => a.CreateTime >= request.StartTime && a.CreateTime <= request.EndTime)
.OrderByDescending(a => a.CreateTime)
.Count(out total)
.Page(request.PageIndex, request.PageSize);
string sq = query.ToSql();
var data = query.ToList();
// shortcut: 仅按当前页退款流水移除订单;需要准确总数和跨页匹配时改为分页前过滤。
var refundedOrders = data.Where(a => negativeTypes.Contains(a.Type))
.Select(a => new { a.UserName, a.OrderId }).ToHashSet();
data.RemoveAll(a => negativeTypes.Contains(a.Type) ||
refundedOrders.Contains(new { a.UserName, a.OrderId }));
foreach (var item in data)
{
list.Add(new RebateRecordResponse
{
OrderId = item.OrderId,
UserName = item.UserName,
Amount = (long)Math.Round((item.Amount ?? 0) * 100m),
Rebate = (long)Math.Round((item.OemAmount ?? 0) * 100m),
CreateTime = item.CreateTime
});
}
}
else
{
DateTime splitTime = DateTime.Parse("2026-09-16 15:25:07");
if (request.StartTime <= splitTime) request.StartTime = splitTime;
var users = GetOEMUsers(oem.OemId, false);
var userNames = users.Select(u => u.UserName).ToList();
var data = _freeSql.Select<UserPointsRecordEntity>()
.Where(a => a.OptionType == "续费")
.Where(a => userNames.Contains(a.UserName))
.Where(a => a.AddTime >= request.StartTime && a.AddTime <= request.EndTime)
.OrderByDescending(a => a.AddTime)
.Count(out total)
.Page(request.PageIndex, request.PageSize)
.ToList();
foreach (var item in data)
{
list.Add(new RebateRecordResponse
{
UserName = item.UserName,
Amount = (long)Math.Round(item.DeltaPoints * 100m),
Rebate = (long)Math.Round((item.DeltaPoints - 15m) * 100m),
CreateTime = item.AddTime
});
}
}
return (list, total);
}
/// <summary>
/// 获取父代理
/// </summary>
/// <param name="oemId"></param>
/// <param name="isCache"></param>
/// <returns></returns>
/// <exception cref="Exception"></exception>
public OEMEntity GetParentOem(string oemId, bool isCache = true)
{
if (string.IsNullOrEmpty(oemId)) throw new ArgumentNullException(nameof(oemId));
var oem = GetOEMByOemId(oemId, isCache);
if (oem == null) throw new Exception("错误的OEM");
if (string.IsNullOrEmpty(oem.ParentOemId)) return oem;
return GetOEMByOemId(oem.ParentOemId, isCache);
}
/// <summary>
/// 获取所有子代理
/// </summary>
/// <param name="oemId"></param>
/// <param name="isCache"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public List<OEMEntity> GetSubOems(string oemId, bool isCache = true)
{
if (string.IsNullOrEmpty(oemId)) throw new ArgumentNullException(nameof(oemId));
return OEMData.Where(a => a.ParentOemId == oemId).ToList();
}
#region 加价规则
private const string DefaultMarkupOemId = "00000000";
private static string GetMarkupOemId(string oemId) =>
string.IsNullOrWhiteSpace(oemId) ? DefaultMarkupOemId : oemId;
/// <summary>
/// 兼容旧版查询字符串:id 为目标用户ID,user_name 为操作人,费用单位为元。
/// 四个费用字段依次对应交易类型 20、26、16、55;二级加价为费用转分后减去基础费及一级 OEM 加价,未传字段不修改。
/// </summary>
/// <param name="inputData">旧版表单字符串;调用方须先完成签名和身份校验。</param>
public void SetMarkupRule(string inputData)
{
var (userId, actorUserName, fees) = ParseLegacyMarkupInput(inputData);
var requests = new List<SetMarkupRuleRequest>();
foreach (var (paymentType, amount) in fees)
{
int markup = amount - GetDefaultFloorPrice(paymentType);
if (markup < 0) throw new ArgumentException($"交易类型 {(int)paymentType} 的费用不能低于基础费");
requests.Add(new SetMarkupRuleRequest
{
UserName = actorUserName,
TargetType = OEMMarkupTargetType.User,
PaymentType = paymentType,
Markup = markup
});
}
if (requests.Count == 0) return;
_freeSql.Transaction(() =>
{
var user = _freeSql.Select<UserEntity>().Where(a => a.Id == userId).ForUpdate().First()
?? throw new InvalidOperationException("目标用户不存在");
var oemId = GetMarkupOemId(user.OemId);
var paymentTypes = requests.Select(a => a.PaymentType).ToArray();
var oemRules = _freeSql.Select<OEMMarkupRuleEntity>()
.Where(a => a.TargetType == OEMMarkupTargetType.OEM && a.TargetId == oemId
&& paymentTypes.Contains(a.PaymentType)).ForUpdate().ToList();
// 先校验所有消费类型,避免后面的金额不足时已保存前面的规则。
DeductOemMarkup(requests, oemRules, oemId);
foreach (var request in requests)
{
request.TargetId = user.UserName;
SetMarkupRule(request);
}
});
}
/// <summary>从已扣除基础费的金额中扣除一级 OEM 加价,得到要保存的二级用户加价。</summary>
private static void DeductOemMarkup(List<SetMarkupRuleRequest> requests, List<OEMMarkupRuleEntity> oemRules, string oemId)
{
foreach (var request in requests)
{
int oemMarkup = GetMarkup(oemRules, null, OEMMarkupTargetType.OEM, oemId, request.PaymentType);
int markup = checked(request.Markup.Value - oemMarkup);
if (markup < 0)
throw new ArgumentException($"交易类型 {request.PaymentType} 的费用不能低于基础费用");
request.Markup = markup;
}
}
private static (int UserId, string ActorUserName, List<(UserPaymentTypes PaymentType, int Amount)> Fees) ParseLegacyMarkupInput(string inputData)
{
if (string.IsNullOrWhiteSpace(inputData)) throw new ArgumentException("输入不能为空", nameof(inputData));
var values = HttpUtility.ParseQueryString(inputData);
if (!int.TryParse(values["id"], NumberStyles.None, CultureInfo.InvariantCulture, out int userId) || userId <= 0)
throw new ArgumentException("id 必须为有效的用户ID");
var actorUserName = values["user_name"];
if (string.IsNullOrWhiteSpace(actorUserName) || values.GetValues("user_name")?.Length != 1)
throw new ArgumentException("操作人 user_name 必须传入且只能传入一次");
var fields = new[]
{
("postage_per_order", UserPaymentTypes.中转仓扣费支出),
("refund_postage_per_order", UserPaymentTypes.退货包裹扣费支出),
("gift_oem_amount_per_order", UserPaymentTypes.礼物单支出),
("sync_logistics_per_order", UserPaymentTypes.同步物流)
};
var fees = new List<(UserPaymentTypes PaymentType, int Amount)>();
foreach (var (key, paymentType) in fields)
{
var value = values[key];
if (value == null) continue;
if (!decimal.TryParse(value, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out decimal amount)
|| amount < 0 || amount > int.MaxValue / 100m || decimal.Truncate(amount * 100m) != amount * 100m)
throw new ArgumentException($"{key} 必须为非负金额,单位:元,精确到分且不能超出范围");
fees.Add((paymentType, (int)(amount * 100m)));
}
return (userId, actorUserName, fees);
}
/// <summary>
/// 校验操作权限,并新增或更新指定主用户、下级 OEM 的加价规则。
/// OEM 管理人只能设置自己直属主用户的规则;管理员可以设置指定主用户或下级 OEM 的规则。
/// </summary>
/// <param name="request">
/// UserName 为操作人用户名,调用方须先完成身份认证;TargetId 为目标主用户的用户名或目标 OEM ID。
/// PaymentType 为交易类型,Markup 为加价金额(分),必须传入非负整数,0 表示不加价。
/// </param>
/// <remarks>
/// setter_oem_id 根据目标归属关系确定,不使用管理员身份作为设置者。
/// 保存时会在事务中再次检查目标与设置者的直属关系。
/// </remarks>
/// <exception cref="ArgumentException">请求为空、必填参数缺失、类型不支持或金额不合法。</exception>
/// <exception cref="UnauthorizedAccessException">操作人不存在或无权设置目标规则。</exception>
/// <exception cref="InvalidOperationException">目标或所属 OEM 无效、目标不是主用户、直属关系不符或保存失败。</exception>
public void SetMarkupRule(SetMarkupRuleRequest request)
{
if (request == null) throw new ArgumentNullException(nameof(request));
if (string.IsNullOrWhiteSpace(request.UserName)) throw new ArgumentException("操作人不能为空");
if (string.IsNullOrWhiteSpace(request.TargetId)) throw new ArgumentException("设置目标不能为空");
if (request.TargetType != OEMMarkupTargetType.User && request.TargetType != OEMMarkupTargetType.OEM)
throw new ArgumentException("不支持的加价目标类型");
if (!request.Markup.HasValue || request.Markup < 0) throw new ArgumentException("加价金额必须为非负整数,单位:分");
GetDefaultFloorPrice(request.PaymentType);
var actor = _freeSql.Select<UserEntity>().Where(a => a.UserName == request.UserName).First()
?? throw new UnauthorizedAccessException("操作人不存在");
var actorOem = actor.SaLevel == 1 ? null : GetOEMByUserName(actor.UserName, false);
var targetUser = request.TargetType == OEMMarkupTargetType.User
? _freeSql.Select<UserEntity>().Where(a => a.UserName == request.TargetId).First() : null;
var targetOem = request.TargetType == OEMMarkupTargetType.OEM ? GetOEMByOemId(request.TargetId, false) : null;
var setterOemId = ResolveMarkupSetter(request.TargetType, actor, actorOem, targetUser, targetOem);
if (request.TargetType == OEMMarkupTargetType.User)
SetUserMarkup(setterOemId, request.TargetId, request.PaymentType, request.Markup.Value);
else
SetOEMMarkup(setterOemId, request.TargetId, request.PaymentType, request.Markup.Value);
}
/// <summary>
/// 根据操作人权限和目标归属,确定加价规则的收益方 OEM(setter_oem_id)
/// </summary>
/// <param name="targetType">目标类型:主用户或下级 OEM。</param>
/// <param name="actor">已查询到的操作人;SaLevel 为 1 时按管理员处理,不能为空。</param>
/// <param name="actorOem">操作人作为管理人拥有的 OEM;管理员场景可为空。</param>
/// <param name="targetUser">用户规则的目标主用户;OEM 规则场景可为空。</param>
/// <param name="targetOem">OEM 规则的目标 OEM;用户规则场景可为空。</param>
/// <returns>
/// 用户规则返回目标用户的 OemId,未挂载时返回 00000000;OEM 规则仅允许管理员设置,返回目标 OEM 的 ParentOemId。
/// </returns>
/// <exception cref="ArgumentException">目标类型不支持。</exception>
/// <exception cref="UnauthorizedAccessException">非管理员设置其他 OEM 的用户,或尝试设置 OEM 规则。</exception>
/// <exception cref="InvalidOperationException">目标用户不存在、不是主用户;目标 OEM 不存在、已删除或没有上级。</exception>
private static string ResolveMarkupSetter(OEMMarkupTargetType targetType, UserEntity actor,
OEMEntity actorOem, UserEntity targetUser, OEMEntity targetOem)
{
if (targetType == OEMMarkupTargetType.User)
{
if (targetUser == null) throw new InvalidOperationException("目标用户不存在");
if (!targetUser.IsMainUser) throw new InvalidOperationException("只能设置主用户的加价规则");
var setterOemId = GetMarkupOemId(targetUser.OemId);
if (actor.SaLevel != 1 && (actorOem == null || actorOem.IsDel != 0
|| actorOem.OemOwner != actor.UserName || actorOem.OemId != setterOemId))
throw new UnauthorizedAccessException("只能设置自己OEM下主用户的加价规则");
return setterOemId;
}
if (targetType != OEMMarkupTargetType.OEM) throw new ArgumentException("不支持的加价目标类型");
if (actor.SaLevel != 1) throw new UnauthorizedAccessException("只有管理员可以设置OEM加价规则");
if (targetOem == null || targetOem.IsDel != 0) throw new InvalidOperationException("目标OEM不存在或已删除");
if (string.IsNullOrWhiteSpace(targetOem.ParentOemId)) throw new InvalidOperationException("目标OEM没有上级OEM");
return targetOem.ParentOemId;
}
/// <summary>获取交易类型的默认地板价,单位:分。</summary>
public int GetDefaultFloorPrice(UserPaymentTypes paymentType) => OEMMarkupBaseFeeSettings.GetBaseFee(paymentType);
/// <summary>设置直属主用户的加价(分),0 表示不加价,不允许传入子账号。</summary>
public void SetUserMarkup(string setterOemId, string userName, UserPaymentTypes paymentType, int markup)
{
ValidateMarkup(setterOemId, paymentType, markup);
if (string.IsNullOrWhiteSpace(userName)) throw new ArgumentException("用户名不能为空", nameof(userName));
var user = _freeSql.Select<UserEntity>().Where(a => a.UserName == userName).First()
?? throw new InvalidOperationException("用户不存在");
if (!user.IsMainUser) throw new InvalidOperationException("只能设置主用户的加价规则");
SaveMarkup(setterOemId, OEMMarkupTargetType.User, user.UserName, paymentType, markup);
}
/// <summary>设置直属下级 OEM 的加价,单位:分,0 表示不加价。</summary>
public void SetOEMMarkup(string setterOemId, string oemId, UserPaymentTypes paymentType, int markup)
{
ValidateMarkup(setterOemId, paymentType, markup);
if (string.IsNullOrWhiteSpace(oemId)) throw new ArgumentException("OEM不能为空", nameof(oemId));
if (setterOemId == oemId) throw new ArgumentException("不能设置自身的OEM加价", nameof(oemId));
SaveMarkup(setterOemId, OEMMarkupTargetType.OEM, oemId, paymentType, markup);
}
private void ValidateMarkup(string setterOemId, UserPaymentTypes paymentType, int markup)
{
if (string.IsNullOrWhiteSpace(setterOemId)) throw new ArgumentException("设置者OEM不能为空", nameof(setterOemId));
GetDefaultFloorPrice(paymentType);
if (markup < 0) throw new ArgumentOutOfRangeException(nameof(markup), "加价金额不能为负数");
}
private void SaveMarkup(string setterOemId, OEMMarkupTargetType targetType, string targetId, UserPaymentTypes paymentType, int markup)
{
_freeSql.Transaction(() =>
{
// 无归属用户使用平台默认标识,不要求存在对应的 OEM 记录。
if (!(targetType == OEMMarkupTargetType.User && setterOemId == DefaultMarkupOemId)
&& !_freeSql.Select<OEMEntity>().Where(a => a.OemId == setterOemId && a.IsDel == 0).Any())
throw new InvalidOperationException("设置者OEM不存在或已删除");
// 锁定目标行,使不同进程首次设置同一目标时也不会重复插入规则。
if (targetType == OEMMarkupTargetType.User)
{
var user = _freeSql.Select<UserEntity>().Where(a => a.UserName == targetId).ForUpdate().First();
if (user == null || !user.IsMainUser || GetMarkupOemId(user.OemId) != setterOemId)
throw new InvalidOperationException("只能设置直属主账号的加价");
}
else
{
var oem = _freeSql.Select<OEMEntity>().Where(a => a.OemId == targetId).ForUpdate().First();
if (oem == null || oem.IsDel != 0 || oem.ParentOemId != setterOemId)
throw new InvalidOperationException("只能设置直属下级OEM的加价");
}
var rule = _freeSql.Select<OEMMarkupRuleEntity>()
.Where(a => a.SetterOemId == setterOemId && a.TargetType == targetType
&& a.TargetId == targetId && a.PaymentType == paymentType).First();
if (rule != null && rule.Markup == markup) return;
var now = DateTime.Now;
int affected = rule == null
? _freeSql.Insert(new OEMMarkupRuleEntity
{
SetterOemId = setterOemId,
TargetType = targetType,
TargetId = targetId,
PaymentType = paymentType,
Markup = markup,
UpdatedAt = now
}).ExecuteAffrows()
: _freeSql.Update<OEMMarkupRuleEntity>().Where(a => a.Id == rule.Id)
.Set(a => a.Markup, markup).Set(a => a.UpdatedAt, now).ExecuteAffrows();
if (affected != 1) throw new InvalidOperationException("保存加价规则失败");
});
}
/// <summary>查询用户最终价格(分):地板价 + A对B的加价 + B对主账号的加价。</summary>
public int GetUserFinalPrice(string userName, UserPaymentTypes paymentType)
{
int price = GetDefaultFloorPrice(paymentType);
if (string.IsNullOrWhiteSpace(userName)) throw new ArgumentException("用户名不能为空", nameof(userName));
var user = GetUserByUserName(userName) ?? throw new InvalidOperationException("用户不存在");
return CalculateUserPrice(GetUserMarkupRules(user, paymentType), user, paymentType, price);
}
/// <summary>
/// 批量计算用户四种最终价格(分),返回用户名到消费类型、价格的映射。
/// 复用已查询的用户列表;加价规则只查一次,子账号的主账号归属另作一次批量查询,不使用缓存。
/// </summary>
public Dictionary<string, Dictionary<UserPaymentTypes, int>> GetUserFinalPrices(IEnumerable<UserEntity> users)
{
if (users == null) throw new ArgumentNullException(nameof(users));
var userList = users.ToList();
if (userList.Any(a => a == null || string.IsNullOrWhiteSpace(a.UserName)))
throw new ArgumentException("用户及用户名不能为空", nameof(users));
if (userList.Select(a => a.UserName).Distinct().Count() != userList.Count)
throw new ArgumentException("用户列表中存在重复用户名", nameof(users));
if (userList.Count == 0) return new();
var parentNames = userList.Where(a => !a.IsMainUser).Select(a => a.ParentUserName).Distinct().ToList();
if (parentNames.Count > 0)
{
var parents = _freeSql.Select<UserEntity>().Where(a => parentNames.Contains(a.UserName))
.ToList().ToDictionary(a => a.UserName);
// 与单用户查询一致:子账号继承主账号的 OEM,但仍按自己的用户名匹配规则。
userList = userList.Select(a => new UserEntity
{
UserName = a.UserName,
OemId = !a.IsMainUser && parents.TryGetValue(a.ParentUserName, out var parent) ? parent.OemId : a.OemId
}).ToList();
}
userList = userList.Select(a => new UserEntity { UserName = a.UserName, OemId = GetMarkupOemId(a.OemId) }).ToList();
UserPaymentTypes[] paymentTypes = [UserPaymentTypes.中转仓扣费支出, UserPaymentTypes.退货包裹扣费支出,
UserPaymentTypes.礼物单支出, UserPaymentTypes.同步物流];
var floorPrices = paymentTypes.ToDictionary(a => a, GetDefaultFloorPrice);
var oemIds = userList.Select(a => a.OemId).Where(a => !string.IsNullOrWhiteSpace(a)).Distinct().ToList();
var userNames = userList.Where(a => !string.IsNullOrWhiteSpace(a.OemId)).Select(a => a.UserName).ToList();
var rules = oemIds.Count == 0 ? new List<OEMMarkupRuleEntity>() : _freeSql.Select<OEMMarkupRuleEntity>()
.Where(a => paymentTypes.Contains(a.PaymentType) &&
((a.TargetType == OEMMarkupTargetType.User && userNames.Contains(a.TargetId) && oemIds.Contains(a.SetterOemId))
|| (a.TargetType == OEMMarkupTargetType.OEM && oemIds.Contains(a.TargetId))))
.ToList();
return CalculateUserPrices(userList, rules, floorPrices);
}
private static Dictionary<string, Dictionary<UserPaymentTypes, int>> CalculateUserPrices(List<UserEntity> users,
List<OEMMarkupRuleEntity> rules, Dictionary<UserPaymentTypes, int> floorPrices)
{
var rulesByTarget = rules.ToLookup(a => (a.TargetType, a.TargetId));
var result = new Dictionary<string, Dictionary<UserPaymentTypes, int>>();
foreach (var user in users)
{
var userRules = rulesByTarget[(OEMMarkupTargetType.User, user.UserName)]
.Concat(rulesByTarget[(OEMMarkupTargetType.OEM, GetMarkupOemId(user.OemId))]).ToList();
result.Add(user.UserName, floorPrices.ToDictionary(a => a.Key,
a => CalculateUserPrice(userRules, user, a.Key, a.Value)));
}
return result;
}
/// <summary>实时查询用户两级代理加价(分),按一级、二级返回,未设置的级别金额为 0。</summary>
public UserMarkupResponse[] GetUserMarkups(string userName, UserPaymentTypes paymentType)
{
GetDefaultFloorPrice(paymentType);
if (string.IsNullOrWhiteSpace(userName)) throw new ArgumentException("用户名不能为空", nameof(userName));
var user = GetMainUser(userName) ?? throw new InvalidOperationException("用户不存在");
var rules = GetUserMarkupRules(user, paymentType);
var parentOemId = string.IsNullOrWhiteSpace(user.OemId)
? null : GetOEMByOemId(user.OemId, false)?.ParentOemId;
return BuildUserMarkups(rules, user, paymentType, parentOemId);
}
private List<OEMMarkupRuleEntity> GetUserMarkupRules(UserEntity user, UserPaymentTypes paymentType)
{
var oemId = GetMarkupOemId(user.OemId);
return _freeSql.Select<OEMMarkupRuleEntity>()
.Where(a => a.PaymentType == paymentType &&
((a.TargetType == OEMMarkupTargetType.User && a.SetterOemId == oemId && a.TargetId == user.UserName)
|| (a.TargetType == OEMMarkupTargetType.OEM && a.TargetId == oemId))).ToList();
}
private static UserMarkupResponse[] BuildUserMarkups(List<OEMMarkupRuleEntity> rules, UserEntity user, UserPaymentTypes paymentType, string parentOemId)
{
int oemMarkup = GetMarkup(rules, null, OEMMarkupTargetType.OEM, GetMarkupOemId(user.OemId), paymentType);
var oemRule = rules.FirstOrDefault(a => a.TargetType == OEMMarkupTargetType.OEM
&& a.TargetId == GetMarkupOemId(user.OemId) && a.PaymentType == paymentType);
// 已有规则时,代理 ID 与金额必须来自同一条规则。
var oemId = oemRule == null ? parentOemId : oemRule.SetterOemId;
return
[
new() { Level = 1, OemId = string.IsNullOrWhiteSpace(oemId) ? null : oemId, Markup = oemMarkup },
new() { Level = 2, OemId = GetMarkupOemId(user.OemId),
Markup = GetMarkup(rules, GetMarkupOemId(user.OemId), OEMMarkupTargetType.User, user.UserName, paymentType) }
];
}
private static int CalculateUserPrice(List<OEMMarkupRuleEntity> rules, UserEntity user, UserPaymentTypes paymentType, int floorPrice)
{
// 按当前OEM筛选用户规则,避免用户换OEM后使用旧设置者的加价。
int userMarkup = GetMarkup(rules, GetMarkupOemId(user.OemId), OEMMarkupTargetType.User, user.UserName, paymentType);
int oemMarkup = GetMarkup(rules, null, OEMMarkupTargetType.OEM, GetMarkupOemId(user.OemId), paymentType);
return checked(floorPrice + userMarkup + oemMarkup);
}
private static int GetMarkup(List<OEMMarkupRuleEntity> rules, string setterOemId, OEMMarkupTargetType targetType, string targetId, UserPaymentTypes paymentType)
{
var matches = rules.Where(a => (setterOemId == null || a.SetterOemId == setterOemId) && a.TargetType == targetType
&& a.TargetId == targetId && a.PaymentType == paymentType).ToList();
if (matches.Count > 1) throw new InvalidOperationException("存在重复的加价规则,请检查数据");
int markup = matches.FirstOrDefault()?.Markup ?? 0;
if (markup < 0) throw new InvalidOperationException("加价规则金额不能为负数");
return markup;
}
#endregion
}