public async Task <Result> ConfirmApply([FromBody] AdminRefundConfirmApplyRequest 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, "当前申请不允许修改状态"));
}
var address = await _addressRepository.Query()
.Include(e => e.Province)
.Include(e => e.City)
.Include(e => e.Area)
.FirstOrDefaultAsync(e => e.Id == request.RefundAddressId);
if (address == null)
{
return(Result.Fail(ResultCodes.RequestParamError, "无效地址"));
}
var returnAddress = new ReturnAddress
{
ReturnApplyId = returnApply.Id,
AreaName = address.Area.Name,
CityName = address.City.Name,
Createat = DateTime.Now,
DetailInfo = address.DetailInfo,
PostalCode = address.PostalCode.ToString(),
ProvinceName = address.Province.Name,
Remarks = request.Remarks,
TelNumber = address.TelNumber,
UserName = address.UserName,
};
returnApply.Status = ReturnAuditStatus.Agree;
returnApply.AuditMessage = request.Remarks;
returnApply.AuditTime = DateTime.Now;
returnApply.OrderItem.Status = OrderItemStatus.ConfirmApply;
_returnApplyRepository.Update(returnApply, false);
using (var transaction = _returnApplyRepository.BeginTransaction())
{
await _returnApplyRepository.SaveAsync();
await _refundAddressRepository.InsertAsync(returnAddress);
transaction.Commit();
}
return(Result.Ok());
}
public async Task <Result> Cancel([FromBody] AdminWithdrawalCancelRequest request)
{
var apply = await _withdrawalHistoryRepository.FirstOrDefaultAsync(request.Id);
if (apply == null)
{
return(Result.Fail(ResultCodes.IdInvalid));
}
if (apply.Status != WithdrawalStatus.Apply)
{
return(Result.Fail(ResultCodes.RequestParamError, "当前申请状态不允许确认"));
}
apply.Status = WithdrawalStatus.Failed;
apply.Description = request.Message;
apply.Message = request.Message;
_withdrawalHistoryRepository.Update(apply, false);
using (var transaction = _withdrawalHistoryRepository.BeginTransaction())
{
await _withdrawalHistoryRepository.SaveAsync();
await _customerManager.UpdateAssets(apply.CustomerId, 0, apply.Total, -apply.ReservedAmount, "提现失败返回金额");
transaction.Commit();
}
return(Result.Ok());
}
/// <summary>
/// 确认收货
/// </summary>
/// <param name="shipmentId"></param>
/// <returns></returns>
public async Task <Result> Confirm(int shipmentId)
{
var shipment = await _shipmentRepository.Query()
.Include(e => e.ShipmentOrderItems).ThenInclude(e => e.OrderItem).ThenInclude(e => e.CommissionHistory)
.FirstOrDefaultAsync(e => e.Id == shipmentId);
if (shipment == null)
{
return(Result.Fail(ResultCodes.IdInvalid));
}
if (shipment.ShippingStatus == ShippingStatus.Complete)
{
return(Result.Fail(ResultCodes.RequestParamError, "当前订单已完成确认收货"));
}
if (shipment.ShippingStatus != ShippingStatus.Shipped)
{
return(Result.Fail(ResultCodes.RequestParamError, "当前订单状态不允许确认收货"));
}
shipment.ShippingStatus = ShippingStatus.Complete;
shipment.CompleteTime = DateTime.Now;
var orderItems = shipment.ShipmentOrderItems.Select(e => e.OrderItem);
var totalCommission = 0;
var states = new[] { OrderItemStatus.ApplyFaild, OrderItemStatus.Shipped };
foreach (var item in orderItems)
{
if (!states.Contains(item.Status))
{
continue;
}
item.Status = OrderItemStatus.Complete;
item.CompleteTime = DateTime.Now;
item.WarrantyDeadline = DateTime.Now.AddYears(1);
if (item.CommissionHistory != null)
{
item.CommissionHistory.Status = CommissionStatus.Complete;
totalCommission += item.CommissionHistory.Commission;
}
}
_shipmentRepository.Update(shipment, false);
using (var transaction = _shipmentRepository.BeginTransaction())
{
await _shipmentRepository.SaveAsync();
if (totalCommission > 0)
{
var parentUser = await _customerRelationRepository.Query().FirstOrDefaultAsync(e => e.ChildrenId == shipment.CustomerId && e.Level == 1);
if (parentUser != null)
{
await _customerManager.UpdateAssets(parentUser.ParentId, -totalCommission, totalCommission, "返佣金");
}
}
transaction.Commit();
}
return(Result.Ok());
}
public async Task <Result> Edit(int id, [FromBody] AdminGoodsCreateRequest request)
{
var goods = await _goodsRepository.Query()
.Include(e => e.GoodsMedias)
.Include(e => e.Childrens).ThenInclude(e => e.OptionCombinations)
.Include(e => e.Childrens)
.Include(e => e.OptionValues).ThenInclude(e => e.Option)
.FirstOrDefaultAsync(e => e.Id == id);
if (goods == null)
{
return(Result.Fail(ResultCodes.IdInvalid));
}
var goodsMedias = new List <GoodsMedia>();
if (request.GoodsMediaIds != null && request.GoodsMediaIds.Count > 0)
{
foreach (var mediaId in request.GoodsMediaIds)
{
goodsMedias.Add(new GoodsMedia(mediaId));
}
}
goods.Name = request.Name;
goods.Description = request.Description;
goods.Price = request.Price;
goods.ThumbnailImageId = request.ThumbnailImageId;
goods.DisplayOrder = request.DisplayOrder;
goods.CityDiscount = request.CityDiscount;
goods.BranchDiscount = request.BranchDiscount;
goods.GoodsMedias = goodsMedias;
if (request.IsPublished)
{
if (!goods.IsPublished)
{
goods.IsPublished = request.IsPublished;
goods.PublishedOn = DateTime.Now;
}
}
else
{
goods.PublishedOn = null;
goods.IsPublished = false;
}
var optionValues = new List <GoodsOptionValue>();
var options = request.Options.Distinct();
foreach (var option in options)
{
foreach (var item in option.Values.Distinct())
{
var ov = goods.OptionValues.FirstOrDefault(c => c.OptionId == option.Id && c.Value == item.Value);
if (ov == null)
{
optionValues.Add(new GoodsOptionValue(option.Id, item.Value, item.DisplayOrder));
}
else
{
ov.DisplayOrder = item.DisplayOrder;
optionValues.Add(ov);
}
}
}
goods.OptionValues = optionValues;
var variations = request.Variations.Distinct();
var childrens = new List <Goods>();
foreach (var variation in variations)
{
Goods child = null;
if (variation.Id > 0)
{
child = goods.Childrens.FirstOrDefault(e => e.Id == variation.Id);
}
if (child == null)
{
var optionCombinations = new List <GoodsOptionCombination>();
var coms = variation.OptionCombinations.Distinct();
foreach (var combination in coms)
{
if (!goods.OptionValues.Any(c => c.OptionId == combination.OptionId))
{
return(Result.Fail(ResultCodes.RequestParamError, "商品组合中的选项不存在"));
}
if (!goods.OptionValues.Any(c => c.Value == combination.Value))
{
return(Result.Fail(ResultCodes.RequestParamError, "商品组合中的选项值不存在"));
}
if (optionCombinations.Any(c => c.OptionId == combination.OptionId && c.Value == combination.Value))
{
continue;
}
optionCombinations.Add(new GoodsOptionCombination
{
OptionId = combination.OptionId,
Value = combination.Value,
DisplayOrder = combination.DisplayOrder,
Createat = DateTime.Now
});
}
child = new Goods
{
Name = goods.Name + variation.NormalizedName,
NormalizedName = variation.NormalizedName,
Price = variation.Price,
HasOptions = false,
IsVisible = true,
StockQuantity = variation.StockQuantity,
Createat = DateTime.Now,
OptionCombinations = optionCombinations
};
}
else
{
child.Name = request.Name + variation.NormalizedName;
child.NormalizedName = variation.NormalizedName;
child.Price = variation.Price;
child.StockQuantity = variation.StockQuantity;
}
childrens.Add(child);
}
var deleteChildrens = goods.Childrens.Where(x => variations.All(c => c.Id != x.Id));
foreach (var deleteChild in deleteChildrens)
{
_goodsRepository.Remove(deleteChild, false);
}
goods.Childrens = childrens;
if (!goods.IsPublished)
{
foreach (var item in goods.Childrens.Where(e => e.IsPublished))
{
item.IsPublished = false;
item.PublishedOn = null;
}
}
_goodsRepository.Update(goods, false);
using (var transaction = _goodsRepository.BeginTransaction())
{
await _goodsRepository.SaveAsync();
transaction.Commit();
}
return(Result.Ok());
}
public async Task <Result> Edit([FromBody] AdminOrderEditRequest request)
{
var order = await _orderRepository.Query()
.Include(e => e.OrderItems).ThenInclude(e => e.CommissionHistory)
.FirstOrDefaultAsync(e => e.Id == request.Id);
if (order == null)
{
return(Result.Fail(ResultCodes.IdInvalid));
}
var status = new[] { OrderStatus.Closed, OrderStatus.PaymentReceived, OrderStatus.Complete };
if (status.Contains(order.OrderStatus))
{
return(Result.Fail(ResultCodes.RequestParamError, "当前订单状态不允许修改"));
}
var totalCommission = 0;
var totalAmount = 0;
var commissions = order.OrderItems.Where(e => e.CommissionHistory != null).Select(e => e.CommissionHistory);
if (commissions.Count() > 0)
{
foreach (var item in commissions)
{
if (order.IsFirstOrder)
{
totalAmount += item.Commission;
item.Status = CommissionStatus.Complete;
item.SettlementTime = DateTime.Now;
}
else
{
item.Status = CommissionStatus.PendingSettlement;
totalCommission += item.Commission;
}
}
}
order.PaymentType = request.PaymentType;
order.PaymentMethod = request.PaymentMethod;
order.PaymentTime = DateTime.Now;
order.PaymentFee = order.ActuallyAmount;
order.OrderStatus = OrderStatus.PaymentReceived;
_orderRepository.Update(order, false);
using (var transaction = _orderRepository.BeginTransaction())
{
await _orderRepository.SaveAsync();
if (totalCommission > 0 || totalAmount > 0)
{
var parentId = commissions.Select(e => e.CustomerId).FirstOrDefault();
await _customerManager.UpdateAssets(parentId, totalCommission, totalAmount, "下级首单返佣金");
}
if (!string.IsNullOrEmpty(order.ExtendParams))
{
var result = Enum.TryParse <PartnerRole>(order.ExtendParams, true, out var role);
if (result)
{
await _customerRepository.UpdateProperyAsync(new Customer
{
Id = order.CustomerId,
Role = role
}, nameof(Customer.Role));
}
}
transaction.Commit();
}
return(Result.Ok());
}
public async Task <Result> Address(ShipmentAddressRequest request)
{
var shipment = await _shipmentRepository.Query()
.Include(e => e.ShipmentOrderItems).ThenInclude(e => e.OrderItem)
.FirstOrDefaultAsync(e => e.Id == request.Id);
if (shipment == null)
{
return(Result.Fail(ResultCodes.IdInvalid));
}
ShippingAddress shippingAddress = null;
if (request.ShippingAddressId > 0)
{
var address = await _customerAddressRepository.Query()
.Include(e => e.Province)
.Include(e => e.City)
.Include(e => e.Area)
.FirstOrDefaultAsync(e => e.Id == request.ShippingAddressId);
if (address == null)
{
return(Result.Fail(ResultCodes.RequestParamError, "送货地址不存在"));
}
shippingAddress = new ShippingAddress
{
ShipmentId = request.Id,
PostalCode = address.PostalCode.ToString(),
ProvinceName = address.Province.Name,
CityName = address.City.Name,
AreaName = address.Area.Name,
DetailInfo = address.DetailInfo,
TelNumber = address.TelNumber,
UserName = address.UserName,
Createat = DateTime.Now
};
}
else if (request.ShippingAddress != null && !string.IsNullOrEmpty(request.ShippingAddress.UserName))
{
shippingAddress = new ShippingAddress
{
ShipmentId = request.Id,
PostalCode = request.ShippingAddress.PostalCode,
ProvinceName = request.ShippingAddress.ProvinceName,
CityName = request.ShippingAddress.CityName,
AreaName = request.ShippingAddress.CountyName,
DetailInfo = request.ShippingAddress.DetailInfo,
TelNumber = request.ShippingAddress.TelNumber,
UserName = request.ShippingAddress.UserName,
Createat = DateTime.Now
};
}
else
{
return(Result.Fail(ResultCodes.RequestParamError, "请选择送货地址"));
}
var orderItems = shipment.ShipmentOrderItems.Select(e => e.OrderItem);
var goodsIds = orderItems.Select(e => e.GoodsItemId);
var goodses = await _goodsRepository.Query().Where(e => goodsIds.Contains(e.Id)).ToListAsync();
foreach (var item in orderItems)
{
var goods = goodses.FirstOrDefault(e => e.Id == item.GoodsItemId);
if (goods == null)
{
return(Result.Fail(ResultCodes.RequestParamError, "商品不存在"));
}
if (goods.ParentId == null)
{
return(Result.Fail(ResultCodes.RequestParamError, "选择的商品不是有效的商品"));
}
if (goods.StockQuantity <= 0)
{
return(Result.Fail(ResultCodes.RequestParamError, $"商品{goods.Name} {goods.NormalizedName} 库存不足"));
}
//减库存
goods.StockQuantity -= item.Quantity;
item.Status = OrderItemStatus.PendingShipment;
}
shipment.IsValid = true;
shipment.Remarks = request.Remarks;
shipment.ShippingAddress = shippingAddress;
_shipmentRepository.Update(shipment, false);
using (var transaction = _shipmentRepository.BeginTransaction())
{
await _shipmentRepository.SaveAsync();
await _goodsRepository.UpdateRangeAsync(goodses);
transaction.Commit();
}
var notify = new ShippingApplyNotify
{
Name = shippingAddress.UserName,
Tel = shippingAddress.TelNumber,
};
await _adminUserManager.WarehouseNotify(notify);
return(Result.Ok());
}
public async Task <Result> Apply(ReturnApplyRequest request)
{
var item = await _orderItemRepository.Query()
.Include(e => e.ShipmentOrderItems).ThenInclude(e => e.Shipment)
.Include(e => e.ReturnApply)
.FirstOrDefaultAsync(e => e.Id == request.Id);
if (item == null)
{
return(Result.Fail(ResultCodes.IdInvalid));
}
if (item.IsFirstBatchGoods)
{
return(Result.Fail(ResultCodes.RequestParamError, "首批商品不允许退货"));
}
if (item.Status != OrderItemStatus.Shipped)
{
return(Result.Fail(ResultCodes.RequestParamError, "当前商品状态不允许退货"));
}
if (item.Status == OrderItemStatus.RefundApply)
{
return(Result.Fail(ResultCodes.RequestParamError, "当前商品已申请退货"));
}
var user = await _customerManager.GetUserAsync();
if (item.ReturnApply == null)
{
var shipment = item.ShipmentOrderItems.Where(e => e.Shipment.IsValid).Select(e => e.Shipment).FirstOrDefault();
item.ReturnApply = new ReturnApply
{
CustomerId = user.Id,
Createat = DateTime.Now,
Reason = request.Reason,
Description = string.Empty,
LogisticsStatus = request.LogisticsStatus,
ReturnType = request.ReturnType,
PaymentAmount = item.DiscountAmount,
RefundAmount = item.DiscountAmount,
Status = ReturnAuditStatus.NotAudit,
ShipmentId = shipment.Id
};
}
else
{
var returnApply = item.ReturnApply;
returnApply.Createat = DateTime.Now;
returnApply.Reason = request.Reason;
returnApply.LogisticsStatus = request.LogisticsStatus;
returnApply.ReturnType = request.ReturnType;
returnApply.Status = ReturnAuditStatus.NotAudit;
}
item.Status = OrderItemStatus.RefundApply;
_orderItemRepository.Update(item, false);
using (var transaction = _orderItemRepository.BeginTransaction())
{
await _orderItemRepository.SaveAsync();
transaction.Commit();
}
await _adminUserManager.AccountingNotify(new ReturnNotify
{
UserName = user.NickName
});
return(Result.Ok());
}
public async Task <Result> Edit([FromBody] AdminPartnerApplyEditRequest request)
{
var partnerApply = await _partnerApplyRepository.Query()
.Include(e => e.PartnerApplyGoods)
.FirstOrDefaultAsync(e => e.Id == request.Id);
if (partnerApply == null)
{
return(Result.Fail(ResultCodes.IdInvalid));
}
if (request.Goods == null || request.Goods.Count == 0)
{
return(Result.Fail(ResultCodes.RequestParamError, "请选择商品"));
}
if (request.TotalAmount == 0)
{
return(Result.Fail(ResultCodes.RequestParamError, "总金额不能为0"));
}
if (partnerApply.PartnerRole != request.PartnerRole)
{
var anyPartnerType = _partnerApplyRepository.Query().Any(e => e.Id != request.Id && e.PartnerRole == request.PartnerRole);
return(Result.Fail(ResultCodes.RequestParamError, "当前合伙人类型已设置申请条件"));
}
partnerApply.ReferralCommissionRatio = request.ReferralCommissionRatio;
partnerApply.RepurchaseCommissionRatio = request.RepurchaseCommissionRatio;
partnerApply.PartnerRole = request.PartnerRole;
partnerApply.ApplyType = request.ApplyType;
partnerApply.TotalQuantity = request.TotalQuantity;
partnerApply.TotalAmount = request.TotalAmount;
partnerApply.OriginalPrice = request.OriginalPrice;
var partnerApplyGoods = new List <PartnerApplyGoods>();
foreach (var goods in request.Goods)
{
var first = partnerApply.PartnerApplyGoods.FirstOrDefault(e => e.GoodsId == goods.GoodsId);
if (first == null)
{
partnerApplyGoods.Add(new PartnerApplyGoods(goods.GoodsId, goods.Quantity, goods.Price));
}
else
{
first.Quantity = goods.Quantity;
first.Price = goods.Price;
partnerApplyGoods.Add(first);
}
}
partnerApply.PartnerApplyGoods = partnerApplyGoods;
_partnerApplyRepository.Update(partnerApply, false);
using (var transaction = _partnerApplyRepository.BeginTransaction())
{
await _partnerApplyRepository.SaveAsync();
transaction.Commit();
}
return(Result.Ok());
}
/// <summary>
/// 支付接收
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task PaymentReceived(PaymentReceivedRequest request)
{
var order = await _orderRepository.Query()
.Include(e => e.OrderItems)
.ThenInclude(e => e.CommissionHistory)
.FirstOrDefaultAsync(e => e.OrderNo == request.OrderNo);
if (order == null)
{
return;
}
var status = new OrderStatus[] { OrderStatus.PendingPayment, OrderStatus.PaymentFailed };
if (!status.Contains(order.OrderStatus))
{
return;
}
var roleResult = false;
PartnerRole role = PartnerRole.Default;
if (!string.IsNullOrEmpty(order.ExtendParams))
{
roleResult = Enum.TryParse <PartnerRole>(order.ExtendParams, true, out role);
}
var totalCommission = 0;
var totalAmount = 0;
var commissions = order.OrderItems.Where(e => e.CommissionHistory != null).Select(e => e.CommissionHistory);
if (commissions.Count() > 0)
{
foreach (var item in commissions)
{
if (order.IsFirstOrder)
{
totalAmount += item.Commission;
item.Status = CommissionStatus.Complete;
item.SettlementTime = DateTime.Now;
}
else
{
totalCommission += item.Commission;
item.Status = CommissionStatus.PendingSettlement;
}
}
}
order.OrderStatus = OrderStatus.PaymentReceived;
order.PaymentMethod = request.PaymentMethod;
order.PaymentTime = request.PaymentTime;
order.PaymentFee = request.PaymentFee;
_orderRepository.Update(order, false);
using (var transaction = _orderRepository.BeginTransaction())
{
await _orderRepository.SaveAsync();
if (roleResult)
{
await _customerRepository.UpdateProperyAsync(new Customer
{
Id = order.CustomerId,
Role = role
}, nameof(Customer.Role));
}
if (totalCommission > 0 || totalAmount > 0)
{
var parentId = commissions.Select(e => e.CustomerId).FirstOrDefault();
await _customerManager.UpdateAssets(parentId, totalCommission, totalAmount, "下级首单返佣金");
}
if (order.WalletAmount > 0)
{
await _customerManager.UpdateAssets(order.CustomerId, 0, 0, -order.WalletAmount, "商品抵扣金额");
}
transaction.Commit();
}
}
public async Task <Result> SetTrackingNumber(AdminShipmentSetTrackingNumberRequest request)
{
var shipment = await _shipmentRepository.Query()
.Include(e => e.ShipmentOrderItems).ThenInclude(e => e.OrderItem)
.Include(e => e.ShippingAddress)
.FirstOrDefaultAsync(e => e.Id == request.Id);
if (shipment == null)
{
return(Result.Fail(ResultCodes.IdInvalid));
}
var status = new[] { ShippingStatus.PendingShipment, ShippingStatus.Shipped };
if (!status.Contains(shipment.ShippingStatus))
{
return(Result.Fail(ResultCodes.RequestParamError, "当前订单不允许修改状态"));
}
if (string.IsNullOrEmpty(request.CourierCompany))
{
shipment.CourierCompany = CourierCompanyHelper.GetCompanyName(request.CourierCompanyCode);
}
else
{
shipment.CourierCompany = request.CourierCompany;
}
shipment.TrackingNumber = request.TrackingNumber;
shipment.CourierCompanyCode = request.CourierCompanyCode;
if (shipment.ShippingStatus != ShippingStatus.Shipped)
{
shipment.ShippingStatus = ShippingStatus.Shipped;
shipment.ShippingTime = DateTime.Now;
var orderItems = shipment.ShipmentOrderItems.Select(e => e.OrderItem);
foreach (var item in orderItems)
{
item.Status = OrderItemStatus.Shipped;
}
var message = new AutoReceivedShippingEvent
{
ShipmentId = shipment.Id
};
var headers = new Dictionary <string, object>()
{
{ "x-delay", 10 * 24 * 60 * 60 * 1000 } // 延迟10天自动收货
};
var properties = _client.CreateProperties();
properties.Headers = headers;
_client.PushMessage(MQConstants.Exchange, MQConstants.AutoReceivedShippingKey, message, properties);
var address = shipment.ShippingAddress;
var notify = new ShippingNotify
{
TrackingNumber = request.TrackingNumber,
UserName = address.UserName,
CourierCompany = shipment.CourierCompany
};
await _smsService.SendAsync(address.TelNumber, notify);
}
_shipmentRepository.Update(shipment, false);
using (var transaction = _shipmentRepository.BeginTransaction())
{
await _shipmentRepository.SaveAsync();
transaction.Commit();
}
return(Result.Ok());
}
