public async Task <Result> ResetPwd([FromBody] AdminForgetResetPwdRequest request)
{
var user = await _adminUserRepository.Query().FirstOrDefaultAsync(e => e.Tel == request.Tel);
if (user == null)
{
return(Result.Fail(ResultCodes.UserNotExists));
}
var code = HttpContext.Session.GetString(request.Tel);
if (string.IsNullOrEmpty(code))
{
return(Result.Fail(ResultCodes.RequestParamError, "验证码已过期或未获取验证码"));
}
if (!request.Code.Equals(code, System.StringComparison.InvariantCultureIgnoreCase))
{
return(Result.Fail(ResultCodes.RequestParamError, "验证码不正确"));
}
user.Pwd = request.Password.ToMD5Base64();
await _adminUserRepository.UpdateAsync(user);
HttpContext.Session.Remove(request.Tel);
return(Result.Ok());
}
public async Task <Result> Edit([FromBody] CustomerAddressEditRequest request)
{
var address = await _addressRepository.FirstOrDefaultAsync(request.Id);
if (address == null)
{
return(Result.Fail(ResultCodes.IdInvalid));
}
if (request.IsDefault)
{
var defaultAddress = await _addressRepository.Query().FirstOrDefaultAsync(e => e.IsDefault);
if (defaultAddress != null)
{
defaultAddress.IsDefault = false;
await _addressRepository.UpdateProperyAsync(defaultAddress, nameof(defaultAddress.IsDefault));
}
}
address.DetailInfo = request.DetailInfo;
address.AreaCode = request.AreaCode;
address.CityCode = request.CityCode;
address.IsDefault = request.IsDefault;
address.PostalCode = request.PostalCode;
address.ProvinceCode = request.ProvinceCode;
address.TelNumber = request.TelNumber;
address.UserName = request.UserName;
await _addressRepository.UpdateAsync(address);
return(Result.Ok());
}
public async Task <Result> Create([FromBody] CustomerAddressCreateRequest request)
{
var userId = HttpContext.GetUserId();
var userAddress = new CustomerAddress(userId, request.IsDefault, request.PostalCode, request.ProvinceCode, request.CityCode, request.AreaCode, request.DetailInfo, request.TelNumber, request.UserName);
var defaultAddress = await _customerAddressRepository.Query().FirstOrDefaultAsync(e => e.CustomerId == userId && e.IsDefault);
if (defaultAddress != null)
{
defaultAddress.IsDefault = false;
await _customerAddressRepository.UpdateAsync(defaultAddress);
}
await _customerAddressRepository.InsertAsync(userAddress, false);
return(Result.Ok());
}
public async Task <Result> RealName([FromBody] CustomerRealNameRequest request)
{
var user = await _customerManager.GetUserAsync();
user.Name = request.Name;
user.PhoneNumber = request.PhoneNumber;
user.IsRealName = true;
await _customerRepository.UpdateAsync(user);
return(Result.Ok());
}
public async Task <Result> Edit([FromBody] AdminGoodsOptionEditRequest request)
{
var goodsOption = await _goodsOptionRepository.FirstOrDefaultAsync(request.Id);
if (goodsOption == null)
{
return(Result.Fail(ResultCodes.IdInvalid));
}
goodsOption.Name = request.Name;
await _goodsOptionRepository.UpdateAsync(goodsOption);
return(Result.Ok());
}
public async Task <Result> Cancel(int id)
{
var item = await _orderItemRepository.Query()
.Include(e => e.ReturnApply)
.FirstOrDefaultAsync(e => e.Id == id);
if (item == null)
{
return(Result.Fail(ResultCodes.IdInvalid));
}
var status = new[] { OrderItemStatus.RefundApply, OrderItemStatus.ConfirmApply };
if (!status.Contains(item.Status))
{
return(Result.Fail(ResultCodes.RequestParamError, "当前商品状态不允许取消申请"));
}
item.Status = OrderItemStatus.Shipped;
item.ReturnApply.Status = ReturnAuditStatus.Cancel;
await _orderItemRepository.UpdateAsync(item);
return(Result.Ok());
}
public async Task <Result> Edit([FromBody] AdminGoodsOptionDataEditRequest request)
{
var goodsOptionData = await _goodsOptionDataRepository.FirstOrDefaultAsync(request.Id);
if (goodsOptionData == null)
{
return(Result.Fail(ResultCodes.IdInvalid));
}
goodsOptionData.Value = request.Value;
goodsOptionData.Description = request.Description;
await _goodsOptionDataRepository.UpdateAsync(goodsOptionData);
return(Result.Ok());
}
public async Task <Result> Edit(AdminCategoryEditRequest request)
{
var category = await _categoryRepository.FirstOrDefaultAsync(request.Id);
if (category == null)
{
return(Result.Fail(ResultCodes.IdInvalid));
}
category.Name = request.Name;
category.Sort = request.Sort;
await _categoryRepository.UpdateAsync(category);
return(Result.Ok());
}
public async Task <Result> Agree(int id)
{
var apply = await _withdrawalHistoryRepository.FirstOrDefaultAsync(id);
if (apply == null)
{
return(Result.Fail(ResultCodes.IdInvalid));
}
if (apply.Status != WithdrawalStatus.Apply)
{
return(Result.Fail(ResultCodes.RequestParamError, "当前申请状态不允许确认"));
}
var openId = await _custoemrRepository.Query()
.Where(e => e.Id == apply.CustomerId)
.Select(e => e.OpenId)
.FirstOrDefaultAsync();
apply.Status = WithdrawalStatus.Success;
apply.Message = "提现成功";
var wxRequest = new WeChatPayPromotionTransfersRequest
{
PartnerTradeNo = apply.PartnerTradeNo,
OpenId = openId,
CheckName = "FORCE_CHECK",// "NO_CHECK"
ReUserName = apply.Name,
Amount = apply.Amount,
Desc = "提现"
};
var response = await _client.ExecuteAsync(wxRequest, _weChatPayOptions);
if (response.ReturnCode != WeChatPayCode.Success || response.ResultCode != WeChatPayCode.Success)
{
apply.Status = WithdrawalStatus.Failed;
apply.Message = "提现异常，请重新申请";
apply.Description = response.ErrCodeDes;
await _customerManager.UpdateAssets(apply.CustomerId, 0, apply.Total, -apply.ReservedAmount, "提现失败返回金额");
}
await _withdrawalHistoryRepository.UpdateAsync(apply);
return(Result.Ok());
}
public async Task <Result> ChangePwd([FromBody] AdminUserChangePwdRequest request)
{
var id = HttpContext.GetUserId();
var user = await _adminUserRepository.FirstOrDefaultAsync(id);
var oldEntryPwd = request.OldPwd.ToMD5Base64();
if (!user.Pwd.Equals(oldEntryPwd))
{
return(Result.Fail(ResultCodes.PasswordError));
}
var newEntryPwd = request.NewPwd.ToMD5Base64();
user.Pwd = newEntryPwd;
await _adminUserRepository.UpdateAsync(user);
return(Result.Ok());
}
public async Task<Result> Edit([FromBody] AdminEmployeeEditRequest request)
{
var user = await _repository.FirstOrDefaultAsync(request.Id);
if (user == null) return Result.Fail(ResultCodes.IdInvalid);
if (user.Tel != request.Tel)
{
var anyTel = await _repository.Query().AnyAsync(e => e.Tel == request.Tel);
if (anyTel) return Result.Fail(ResultCodes.RequestParamError, "手机号已存在");
}
user.NickName = request.NickName;
if (!user.IsAdmin)
{
user.Role = request.Role;
}
user.Tel = request.Tel;
await _repository.UpdateAsync(user);
return Result.Ok();
}
public async Task <Result> RefuseApply([FromBody] AdminRefundRefuseApplyRequest request)
{
var returnApply = await _returnApplyRepository.Query()
.Include(e => e.OrderItem)
.FirstOrDefaultAsync(e => e.Id == request.Id);
if (returnApply == null)
{
return(Result.Fail(ResultCodes.IdInvalid));
}
if (returnApply.Status != ReturnAuditStatus.NotAudit)
{
return(Result.Fail(ResultCodes.RequestParamError, "当前申请不允许拒绝"));
}
returnApply.Status = ReturnAuditStatus.Failed;
returnApply.AuditMessage = request.AuditMessage;
returnApply.OrderItem.Status = OrderItemStatus.ApplyFaild;
await _returnApplyRepository.UpdateAsync(returnApply);
return(Result.Ok());
}
public async Task <Result> Save(AdminLiteAppSaveRequest request)
{
var setting = await _repository.Query().FirstOrDefaultAsync();
if (setting == null)
{
setting = new LiteAppSetting
{
CityMembershipRights = request.CityMembershipRights,
BranchMembershipRights = request.BranchMembershipRights,
Createat = DateTime.Now
};
await _repository.InsertAsync(setting);
}
else
{
setting.CityMembershipRights = request.CityMembershipRights;
setting.BranchMembershipRights = request.BranchMembershipRights;
await _repository.UpdateAsync(setting);
}
return(Result.Ok());
}
/// <summary>
/// 修改资产
/// </summary>
/// <param name="assets"></param>
/// <param name="commission"></param>
/// <param name="amount"></param>
/// <param name="repurchase"></param>
/// <param name="message"></param>
/// <returns></returns>
public async Task UpdateAssets(Assets assets, int commission, int amount, int repurchase, string message)
{
assets.AvailableAmount += amount;
assets.TotalCommission += commission;
assets.RepurchaseAmount += repurchase;
assets.TotalAssets = assets.AvailableAmount + assets.RepurchaseAmount;
assets.UpdateTime = DateTime.Now;
await _assetsRepository.UpdateAsync(assets);
if (amount != 0)
{
var history = new AssetsHistory
{
CustomerId = assets.CustomerId,
TotalAmount = assets.AvailableAmount,
Amount = amount,
Createat = DateTime.Now,
Message = message
};
await _assetsHistoryRepository.InsertAsync(history);
}
}
public async Task <Result> Create(AdminOrderCreateRequest request)
{
var customer = await _customerRepository.Query()
.Include(e => e.Parent)
.FirstOrDefaultAsync(e => e.Id == request.CustomerId);
if (customer == null)
{
return(Result.Fail(ResultCodes.IdInvalid));
}
if (customer.Role == PartnerRole.Default && request.PartnerRole == PartnerRole.Default)
{
return(Result.Fail(ResultCodes.RequestParamError, "请选择合伙人角色"));
}
if (customer.Role != PartnerRole.Default && request.Goods.Count == 0)
{
return(Result.Fail(ResultCodes.RequestParamError, "请选择商品"));
}
var now = DateTime.Now;
var isFirstOrder = false;
var totalFee = 0;
var actuallyAmount = 0;
var extendParams = string.Empty;
var totalCommission = 0;
var commissionRatio = 0f;
var orderItems = new List <OrderItem>();
var parentUser = customer.Parent;
if (request.PartnerRole != PartnerRole.Default)
{
if (customer.Role != PartnerRole.Default)
{
return(Result.Fail(ResultCodes.RequestParamError, $"用户：{customer.NickName} 为{customer.Role.GetDescription()} 不能重复设置角色"));
}
var partner = await _partnerApplyRepository.Query()
.Include(e => e.PartnerApplyGoods).ThenInclude(e => e.Goods).ThenInclude(e => e.ThumbnailImage)
.Where(e => e.PartnerRole == request.PartnerRole)
.FirstOrDefaultAsync();
if (partner == null)
{
return(Result.Fail(ResultCodes.RequestParamError, $"角色{request.PartnerRole.GetDescription()}未设置商品"));
}
if (partner.PartnerApplyGoods.Count == 0)
{
return(Result.Fail(ResultCodes.RequestParamError, "没有商品"));
}
if (parentUser != null)
{
if (parentUser.Role == partner.PartnerRole)
{
if (partner.ReferralCommissionRatio > 0)
{
commissionRatio = partner.ReferralCommissionRatio / 100f;
}
}
else
{
var ratio = await _partnerApplyRepository.Query()
.Where(e => e.PartnerRole == parentUser.Role)
.Select(e => e.RepurchaseCommissionRatio)
.FirstOrDefaultAsync();
if (ratio > 0)
{
commissionRatio = ratio / 100f;
}
}
}
isFirstOrder = true;
customer.Role = request.PartnerRole;
extendParams = Enum.GetName(typeof(PartnerRole), request.PartnerRole);
totalFee = partner.OriginalPrice == 0 ? partner.TotalAmount : partner.OriginalPrice;
actuallyAmount = partner.TotalAmount;
var goodsQuantity = partner.PartnerApplyGoods.Sum(e => e.Quantity);
var averagePrice = partner.TotalAmount / goodsQuantity;
var quantity = 0;
foreach (var item in partner.PartnerApplyGoods)
{
quantity += item.Quantity;
if (quantity == goodsQuantity)
{
averagePrice = partner.TotalAmount - ((quantity - 1) * averagePrice);
}
var commission = (int)(averagePrice * commissionRatio);
totalCommission = item.Quantity * commission;
for (int i = 0; i < item.Quantity; i++)
{
var orderItem = new OrderItem
{
GoodsId = item.GoodsId,
GoodsName = item.Goods.Name,
GoodsPrice = item.Goods.Price,
DiscountAmount = item.Goods.Price,
GoodsMediaUrl = item.Goods.ThumbnailImage?.Url,
Quantity = 1,
Remarks = string.Empty,
Status = OrderItemStatus.Default,
Createat = now,
IsFirstBatchGoods = true
};
orderItem.SetCommissionHistory(customer.ParentId, commission, (int)(commissionRatio * 100), CommissionStatus.Complete);
orderItems.Add(orderItem);
}
}
}
else if (request.Goods.Count > 0)
{
if (customer.Role == PartnerRole.Default)
{
return(Result.Fail(ResultCodes.RequestParamError, $"用户：{customer.NickName} 为未设置合伙人角色"));
}
if (parentUser != null)
{
var ratio = await _partnerApplyRepository.Query()
.Where(e => e.PartnerRole == parentUser.Role)
.Select(e => e.RepurchaseCommissionRatio)
.FirstOrDefaultAsync();
if (ratio > 0)
{
commissionRatio = ratio / 100f;
}
}
var goodsIds = request.Goods.Select(e => e.Id).Distinct();
var goodses = await _goodsRepository.Query()
.Include(e => e.ThumbnailImage)
.Where(e => goodsIds.Contains(e.Id))
.ToListAsync();
foreach (var item in goodses)
{
var first = request.Goods.FirstOrDefault(e => e.Id == item.Id);
if (first == null)
{
return(Result.Fail(ResultCodes.RequestParamError, $"产品{item.Name}不存在"));
}
if (!item.IsPublished)
{
return(Result.Fail(ResultCodes.RequestParamError, $"产品{item.Name}未发布"));
}
var discountRate = 100f;
if (customer.Role == PartnerRole.CityPartner && item.CityDiscount > 0)
{
discountRate = item.CityDiscount;
}
else if (customer.Role == PartnerRole.BranchPartner && item.BranchDiscount > 0)
{
discountRate = item.BranchDiscount;
}
var amount = (int)(item.Price * (discountRate / 100f));
var commission = (int)(amount * commissionRatio);
totalCommission += first.Quantity * commission;
for (int i = 0; i < first.Quantity; i++)
{
var orderItem = new OrderItem
{
GoodsId = item.Id,
GoodsName = item.Name,
GoodsPrice = item.Price,
DiscountAmount = amount, //折扣
GoodsMediaUrl = item.ThumbnailImage?.Url,
Quantity = 1,
Remarks = first.Remarks,
Status = OrderItemStatus.Default,
Createat = now,
};
orderItem.SetCommissionHistory(customer.ParentId, commission, (int)(commissionRatio * 100), CommissionStatus.PendingSettlement);
orderItems.Add(orderItem);
}
}
totalFee = orderItems.Sum(e => e.Quantity * e.GoodsPrice);
actuallyAmount = orderItems.Sum(e => e.Quantity * e.DiscountAmount);
}
var order = new Orders(GenerateHelper.GenOrderNo())
{
CustomerId = customer.Id,
OrderStatus = OrderStatus.PaymentReceived,
PaymentType = request.PaymentType,
PaymentMethod = request.PaymentMethod,
PaymentFee = actuallyAmount,
PaymentTime = now,
Remarks = request.Remarks,
Createat = now,
TotalFee = totalFee,
ActuallyAmount = actuallyAmount,
ExtendParams = extendParams,
IsFirstOrder = isFirstOrder,
OrderItems = orderItems
};
_orderRepository.Insert(order, false);
using (var transaction = _orderRepository.BeginTransaction())
{
await _orderRepository.SaveAsync();
if (parentUser != null && totalCommission > 0)
{
if (isFirstOrder)
{
await _customerManager.UpdateAssets(parentUser.Id, 0, totalCommission, "下级首单返佣金");
}
else
{
await _customerManager.UpdateCommission(parentUser.Id, totalCommission);
}
}
if (isFirstOrder)
{
await _customerRepository.UpdateAsync(customer);
}
transaction.Commit();
}
return(Result.Ok());
}
