public async Task <ApiResult <OrderBuyOutput> > Buy([FromBody] UserRightsOrderInput parameter)
{
if (!this.IsFormValid())
{
return(ApiResult.Failure <OrderBuyOutput>(this.FormInvalidReason(),
MessageCodes.ParameterValidationFailure));
}
// var usr = Resolve<IUserService>().GetByIdNoTracking(parameter.UserId);
var result = await Resolve <IUserRightsService>().Buy(parameter);
if (!result.Item1.Succeeded)
{
return(ApiResult.Failure <OrderBuyOutput>(result.Item1.ToString(), MessageCodes.ServiceFailure));
}
var user = Resolve <IUserService>().GetSingle(s => s.Mobile == parameter.Mobile);
//如果该用户推荐人为空 则直接绑定当前登陆的账户
if (user != null && user.ParentId <= 0)
{
user.ParentId = parameter.UserId;
Resolve <IUserService>().Update(user);
}
return(ApiResult.Success(result.Item2));
}
/// <summary>
/// 商家服务订购
/// </summary>
/// <param name="orderBuyInput"></param>
/// <returns></returns>
public async Task <Tuple <ServiceResult, OrderBuyOutput> > Buy(UserRightsOrderInput orderBuyInput)
{
#region 安全验证
var result = ServiceResult.Success;
var orderBuyOutput = new OrderBuyOutput();
var user = Resolve <IUserService>().GetNomarlUser(orderBuyInput.UserId);
if (user == null)
{
return(Tuple.Create(ServiceResult.Failure("用户不存在，或状态不正常"), orderBuyOutput));
}
orderBuyInput.BuyUser = user; // 购买用户等于当前用户
user.Detail = null; // 减少体积保存
user.Map = null;
if (orderBuyInput.GradeId.IsGuidNullOrEmpty())
{
return(Tuple.Create(ServiceResult.Failure("等级Id不能为空"), orderBuyOutput));
}
orderBuyInput.User = user;
var userGrades = Resolve <IAutoConfigService>().GetList <UserGradeConfig>();
var buyGrade = userGrades.FirstOrDefault(r => r.Id == orderBuyInput.GradeId);
if (buyGrade == null)
{
return(Tuple.Create(ServiceResult.Failure("购买的等级不存在"), orderBuyOutput));
}
var userRightConfig = Resolve <IAutoConfigService>().GetList <UserRightsConfig>()
.FirstOrDefault(c => c.GradeId == buyGrade.Id);
if (userRightConfig != null && !userRightConfig.IsOpen)
{
return(Tuple.Create(ServiceResult.Failure("该等级暂未开放"), orderBuyOutput));
}
orderBuyInput.BuyGrade = buyGrade;
orderBuyInput.CurrentGrade = userGrades.FirstOrDefault(r => r.Id == user.GradeId);
if (orderBuyInput.CurrentGrade == null)
{
return(Tuple.Create(ServiceResult.Failure("您的等级不存在"), orderBuyOutput));
}
// 准营销中心，和营销中心的开通只能是管理员 动态配置,不用写死
//if (orderBuyInput.GradeId == Guid.Parse("f2b8d961-3fec-462d-91e8-d381488ea972") || orderBuyInput.GradeId == Guid.Parse("cc873faa-749b-449b-b85a-c7d26f626feb"))
//{
if (orderBuyInput.OpenType == UserRightOpenType.AdminOpenHightGrade)
{
if (!Resolve <IUserService>().IsAdmin(user.Id))
{
return(Tuple.Create(ServiceResult.Failure("您不是管理员无权开通"), orderBuyOutput));
}
if (orderBuyInput.Parent.IsNullOrEmpty())
{
return(Tuple.Create(ServiceResult.Failure("推荐人不能为空"), orderBuyOutput));
}
orderBuyInput.ParnetUser = Resolve <IUserService>().GetSingleByUserNameOrMobile(orderBuyInput.Parent);
if (orderBuyInput.ParnetUser == null)
{
return(Tuple.Create(ServiceResult.Failure("推荐人不能为空，不能开通营销中心"), orderBuyOutput));
}
}
//}
if (orderBuyInput.OpenType == UserRightOpenType.OpenToOtherByPay ||
orderBuyInput.OpenType == UserRightOpenType.AdminOpenHightGrade ||
orderBuyInput.OpenType == UserRightOpenType.OpenToOtherByRight)
{
if (orderBuyInput.Mobile.IsNullOrEmpty())
{
return(Tuple.Create(ServiceResult.Failure("请输入手机号码"), orderBuyOutput));
}
if (orderBuyInput.Name.IsNullOrEmpty())
{
return(Tuple.Create(ServiceResult.Failure("请输入公司名称或姓名"), orderBuyOutput));
}
// 查找是否为注册用户
var find = Resolve <IUserService>().GetSingleByUserNameOrMobile(orderBuyInput.Mobile);
if (find != null)
{
var findUserGrade = userGrades.FirstOrDefault(r => r.Id == find.GradeId);
if (findUserGrade == null)
{
return(Tuple.Create(ServiceResult.Failure("激活的用户等级不存在"), orderBuyOutput));
}
if (findUserGrade.Price > 0.01m)
{
return(Tuple.Create(ServiceResult.Failure("该用户已激活"), orderBuyOutput));
}
//var records = Resolve<IRecordService>().GetListNoTracking(s => s.Type == typeof(UserDetail).FullName);
//var findRecord = records.FirstOrDefault(s => s.UserId == user.Id);
//var findUser = findRecord?.Value?.ToObject<RegInput>();
//if (findUser != null)
// orderBuyInput.RegInfo = findUser;
//else
//{
orderBuyInput.RegInfo = new RegInput {
Mobile = find.Mobile,
UserName = find.Mobile,
Name = find.Name,
Password = "******",
PayPassword = "******",
ParentId = find.ParentId
};
// }
}
else
{
if (!RegexHelper.CheckMobile(orderBuyInput.Mobile))
{
return(Tuple.Create(ServiceResult.Failure("手机号码格式不正确"), orderBuyOutput));
}
// 注册新用户
var password = RandomHelper.PassWord();
var payPassword = RandomHelper.PayPassWord();
var regInput = new RegInput {
Mobile = orderBuyInput.Mobile,
UserName = orderBuyInput.Mobile,
Name = orderBuyInput.Name,
Password = password,
PayPassword = payPassword,
ParentId = orderBuyInput.UserId
};
orderBuyInput.RegInfo = regInput;
// 如果是管理员，则推荐人Id改为输入的推荐人Id
if (orderBuyInput.OpenType == UserRightOpenType.AdminOpenHightGrade)
{
regInput.ParentId = orderBuyInput.ParnetUser.Id;
}
//
var userRegResult = Resolve <IUserBaseService>().Reg(regInput);
if (!userRegResult.Item1.Succeeded)
{
return(Tuple.Create(ServiceResult.Failure("新会员注册失败" + userRegResult),
orderBuyOutput));
}
// await Resolve<IRecordService>().AddAsync(new Record() { Type = typeof(UserDetail).FullName, Value = regInput.ToJsons() });
find = Resolve <IUserService>().GetSingle(orderBuyInput.Mobile);
var message =
$"恭喜您，您的账号已注册成功。您的登录账号为：{regInput.Mobile},初始登录密码：{password} 初始支付密码：{payPassword} 请妥善保管.";
Resolve <ISmsService>().SendRaw(find.Mobile, message);
message =
$"您推荐的商家已注册成功.登录账号：{regInput.Mobile},初始登录密码：{password} 初始支付密码：{payPassword} 请尽快让商家悉知,第一时间指导商家使用系统.";
var userDetail = Resolve <IUserDetailService>().GetSingle(u => u.UserId == user.Id);
userDetail.RegionId = orderBuyInput.RegionId.ToInt64();
Resolve <IUserDetailService>().Update(userDetail);
Resolve <ISmsService>().SendRaw(user.Mobile, message);
}
orderBuyInput.BuyUser = find;
}
#endregion 安全验证
orderBuyInput.UserRightList = GetList(r => r.UserId == user.Id);
// 如果是帮别人开通
if (orderBuyInput.OpenType == UserRightOpenType.OpenToOtherByRight)
{
return(await OpenToOther(orderBuyInput));
}
// 其他三种情况都需要支付 +或者管理员帮他们开通
return(await OpenSelfOrUpgrade(orderBuyInput));
}
public async Task <Tuple <ServiceResult, OrderBuyOutput> > OpenSelfOrUpgrade(UserRightsOrderInput orderInput)
{
var result = ServiceResult.Success;
var orderBuyOutput = new OrderBuyOutput();
//if (orderInput.GradeId == Guid.Parse("72be65e6-3000-414d-972e-1a3d4a366001"))
//{
// result = ServiceResult.Failure("标准商家不能自己支付开通");
// new Tuple<ServiceResult, OrderBuyOutput>(result, orderBuyOutput);
//}
var payPrice = GetPayPrice(orderInput);
if (!payPrice.Item1.Succeeded)
{
return(Tuple.Create(payPrice.Item1, orderBuyOutput));
}
var context = Repository <IUserRightsRepository>().RepositoryContext;
try {
context.BeginTransaction();
var order = new Order {
UserId = orderInput.BuyUser.Id,
StoreId = string.Empty,
OrderStatus = OrderStatus.WaitingBuyerPay,
OrderType = OrderType.VirtualOrder,
TotalAmount = payPrice.Item2,
TotalCount = 1,
PayId = 0,
PaymentAmount = payPrice.Item2
};
// 订单扩展数据
var userRightOrder = AutoMapping.SetValue <UserRightsOrderInput>(orderInput);
order.OrderExtension = new OrderExtension {
// 价格信息
OrderAmount = new OrderAmount {
TotalProductAmount = payPrice.Item2, // 商品总价
ExpressAmount = 0m, // 邮费
FeeAmount = 0m // 服务费
},
AttachContent = userRightOrder.ToJsons(),
User = orderInput.BuyUser, // 下单用户
Store = null
};
order.AccountPay = order.AccountPayPair.ToJsons();
order.Extension = order.OrderExtension.ToJsons();
// 如果发货人不为空
Resolve <IOrderService>().Add(order);
var orderList = new List <Order>
{
order
};
var singlePayInput = new SinglePayInput {
Orders = orderList,
User = orderInput.User,
OrderUser = orderInput.BuyUser,
ExcecuteSqlList = new BaseServiceMethod {
Method = "ExcecuteSqlList",
ServiceName = typeof(IUserRightsService).Name,
Parameter = order.Id
},
AfterSuccess = new BaseServiceMethod {
Method = "AfterPaySuccess",
ServiceName = typeof(IUserRightsService).Name,
Parameter = order.Id
},
TriggerType = TriggerType.Other,
BuyerCount = 1,
RedirectUrl = "/pages/index?path=successful_opening"
};
var payResult = Resolve <IOrderAdminService>().AddSinglePay(singlePayInput);
if (!payResult.Item1.Succeeded)
{
// 支付记录添加失败，回滚
context.RollbackTransaction();
return(Tuple.Create(payResult.Item1, new OrderBuyOutput()));
}
//更新人民币支付记录Id
var orderIds = orderList.Select(e => e.Id).ToList();
Resolve <IOrderService>().Update(r => { r.PayId = payResult.Item2.Id; }, e => orderIds.Contains(e.Id));
// 输出赋值
orderBuyOutput.PayAmount = payResult.Item2.Amount;
orderBuyOutput.PayId = payResult.Item2.Id;
orderBuyOutput.OrderIds = orderList.Select(r => r.Id).ToList();
//开通成功修改UserDetail表地址
var buyUserDetail = Resolve <IUserDetailService>().GetSingle(u => u.UserId == orderInput.BuyUser.Id);
if (buyUserDetail.RegionId <= 0)
{
buyUserDetail.RegionId = orderInput.RegionId.ToInt64();
Resolve <IUserDetailService>().Update(buyUserDetail);
}
context.SaveChanges();
context.CommitTransaction();
//var buyUser = Resolve<IUserService>().GetSingle(u => u.Mobile == orderInput.BuyUser.Mobile);
orderBuyOutput.RegUser = orderInput.RegInfo;
orderBuyOutput.BuyGrade =
orderInput
.BuyGrade; // Resolve<IAutoConfigService>().GetList<UserGradeConfig>().FirstOrDefault(s => s.Id == orderInput.BuyUser.GradeId);
} catch (Exception ex) {
context.RollbackTransaction();
result = ServiceResult.Failure(ex.Message);
} finally {
context.DisposeTransaction();
}
// 删除缓存
Resolve <IUserService>().DeleteUserCache(orderInput.User.Id, orderInput.User.UserName);
Resolve <IUserService>().DeleteUserCache(orderInput.BuyUser.Id, orderInput.BuyUser.UserName);
return(new Tuple <ServiceResult, OrderBuyOutput>(result, orderBuyOutput));
}
/// <summary>
/// 帮别人开通
/// </summary>
/// <param name="orderBuyInput"></param>
/// <returns></returns>
public async Task <Tuple <ServiceResult, OrderBuyOutput> > OpenToOther(UserRightsOrderInput orderBuyInput)
{
var result = ServiceResult.Success;
var orderBuyOutput = new OrderBuyOutput();
// 检查用户的名额
var userGrades = Resolve <IAutoConfigService>().GetList <UserGradeConfig>();
var userRight = GetSingle(r => r.UserId == orderBuyInput.User.Id && r.GradeId == orderBuyInput.GradeId);
if (userRight == null)
{
return(Tuple.Create(ServiceResult.Failure($"您无{orderBuyInput.BuyGrade?.Name}名额端口"),
orderBuyOutput));
}
if (userRight.TotalCount - userRight.TotalUseCount < 1)
{
return(Tuple.Create(ServiceResult.Failure($"您{orderBuyInput.BuyGrade?.Name}名额端口，已用完"),
orderBuyOutput));
}
if (orderBuyInput.BuyUser == null)
{
return(Tuple.Create(ServiceResult.Failure("新会员未注册成功"), orderBuyOutput));
}
var context = Repository <IUserRightsRepository>().RepositoryContext;
try {
context.BeginTransaction();
var kpi = new Kpi {
ModuleId = orderBuyInput.GradeId,
UserId = orderBuyInput.UserId,
Type = TimeType.NoLimit,
Value = 1
};
var lastKpiSingle = Resolve <IKpiService>()
.GetSingle(r => r.ModuleId == orderBuyInput.GradeId && r.Type == TimeType.NoLimit);
if (lastKpiSingle != null)
{
kpi.TotalValue = lastKpiSingle.TotalValue + kpi.Value;
}
// 新增Kpi记录，使用Kpi 记录表保存记录数据
Resolve <IKpiService>().Add(kpi);
// 使用数+1
userRight.TotalUseCount += 1;
Update(userRight);
// 修改等级
var updateUser = Resolve <IUserService>().GetSingle(r => r.Id == orderBuyInput.BuyUser.Id);
updateUser.GradeId = orderBuyInput.GradeId;
Resolve <IUserService>().Update(updateUser);
// 增加相关权益
// 添加用户权益
var userRightConfigList = Resolve <IAutoConfigService>().GetList <UserRightsConfig>();
var userRightConfig = userRightConfigList.FirstOrDefault(r => r.GradeId == orderBuyInput.GradeId);
if (userRightConfig != null)
{
var addList = new List <UserRights>();
foreach (var rightItem in userRightConfig.UserRightItems)
{
var addItem = new UserRights {
GradeId = rightItem.GradeId,
TotalCount = rightItem.Count,
UserId = orderBuyInput.BuyUser.Id
};
addList.Add(addItem);
}
if (addList.Count > 0)
{
AddMany(addList);
}
}
//开通成功修改UserDetail表地址
var buyUserDetail = Resolve <IUserDetailService>().GetSingle(u => u.UserId == orderBuyInput.BuyUser.Id);
if (buyUserDetail.RegionId <= 0)
{
buyUserDetail.RegionId = orderBuyInput.RegionId.ToInt64();
Resolve <IUserDetailService>().Update(buyUserDetail);
}
context.SaveChanges();
context.CommitTransaction();
//orderBuyOutput.RegUser = orderBuyInput.RegInfo;
//orderBuyOutput.BuyGrade = orderBuyInput.BuyGrade;
//var buyUser = Resolve<IUserService>().GetSingle(u => u.Mobile == orderBuyInput.BuyUser.Mobile);
orderBuyOutput.RegUser = orderBuyInput.RegInfo;
orderBuyOutput.BuyGrade =
orderBuyInput
.BuyGrade; // Resolve<IAutoConfigService>().GetList<UserGradeConfig>().FirstOrDefault(s => s.Id == orderBuyInput.BuyUser.GradeId);
} catch (Exception ex) {
context.RollbackTransaction();
result = ServiceResult.Failure(ex.Message);
} finally {
context.DisposeTransaction();
}
SendMessage(orderBuyInput.BuyUser, orderBuyInput.GradeId);
return(Tuple.Create(result, orderBuyOutput));
}
/// <summary>
/// 获取需要支付的价格
/// </summary>
public Tuple <ServiceResult, decimal> GetPayPrice(UserRightsOrderInput orderInput)
{
var result = ServiceResult.Success;
if (orderInput.OpenType == UserRightOpenType.OpenToOtherByRight)
{
return(Tuple.Create(ServiceResult.Failure("帮他购买时无价格计算"), 0m));
}
if (orderInput.OpenType == UserRightOpenType.OpenToOtherByPay)
{
if (orderInput.User.Id == orderInput.BuyUser.Id)
{
return(Tuple.Create(ServiceResult.Failure("不能帮自己购买"), 0m));
}
var price = orderInput.BuyGrade.Price;
return(Tuple.Create(result, price));
}
else
{
if (orderInput.BuyGrade.Price <= orderInput.CurrentGrade.Price &&
orderInput.OpenType != UserRightOpenType.AdminOpenHightGrade)
{
return(Tuple.Create(ServiceResult.Failure("购买的等级不能低于当前等级"), 0m));
}
var findRight = orderInput.UserRightList.FirstOrDefault(r => r.GradeId == orderInput.BuyGrade.Id);
if (findRight != null && orderInput.OpenType != UserRightOpenType.AdminOpenHightGrade)
{
return(Tuple.Create(ServiceResult.Failure("用户当前等级权益已存在，不能重复购买"), 0m));
}
var userRightsConfigs = Resolve <IAutoConfigService>().GetList <UserRightsConfig>();
var userGrades = Resolve <IAutoConfigService>().GetList <UserGradeConfig>();
// 如果包含，则为升级
if (userRightsConfigs.Select(r => r.GradeId).Contains(orderInput.User.GradeId))
{
if (orderInput.OpenType != UserRightOpenType.Upgrade &&
orderInput.OpenType != UserRightOpenType.AdminOpenHightGrade)
{
return(Tuple.Create(ServiceResult.Failure("开通方式有错,应该为自身升级"), 0m));
}
}
else
{
if (orderInput.OpenType != UserRightOpenType.OpenSelf)
{
return(Tuple.Create(ServiceResult.Failure("开通方式有错,应该为自身购买"), 0m));
}
}
// 计算价格
var price = orderInput.BuyGrade.Price;
if (orderInput.OpenType == UserRightOpenType.Upgrade)
{
price = orderInput.BuyGrade.Price - orderInput.CurrentGrade.Price;
}
if (price <= 0)
{
return(Tuple.Create(ServiceResult.Failure("购买等级价格设置为0"), 0m));
}
if (price != orderInput.Price)
{
return(Tuple.Create(ServiceResult.Failure("前后台计算价格不一样"), 0m));
}
return(Tuple.Create(result, price));
}
}
