// Create A Refund For An Order
public OrderRefund Create(int orderId, OrderRefund newData)
{
return(Post(apiEndpoint: String.Format("orders/{0}/refunds", orderId), toSerialize: new OrderRefundBundle()
{
Content = newData
}).Content);
}
public Jinher.AMP.BTP.Deploy.CustomDTO.OrderRefundDTO GetOrderRefundInfoByItemIdExt(System.Guid orderItemId)
{
var a = OrderRefund.ObjectSet();
var refundInfo = (from refund in OrderRefund.ObjectSet()
join orderItem in OrderItem.ObjectSet() on refund.OrderItemId equals orderItem.Id
where refund.OrderItemId == orderItemId
orderby refund.SubTime descending
select new Deploy.CustomDTO.OrderRefundDTO
{
Id = refund.Id,
RefundType = refund.RefundType,
RefundReason = refund.RefundReason,
RefundMoney = refund.RefundMoney,
RefundDesc = refund.RefundDesc,
OrderId = refund.OrderId,
State = refund.State,
OrderRefundImgs = refund.OrderRefundImgs,
DataType = refund.DataType,
OrderItemId = refund.OrderItemId,
RefuseTime = refund.RefuseTime,
RefuseReason = refund.RefuseReason,
SubTime = refund.SubTime,
ModifiedOn = refund.ModifiedOn,
Num = orderItem.Number
}).FirstOrDefault();
return(refundInfo == null ? new Deploy.CustomDTO.OrderRefundDTO() : refundInfo);
}
/// <summary>
/// 撤销退款申请 申请中=>已撤销
/// </summary>
/// <param name="refund"></param>
public void RevokeOrderRefund(OrderRefund refund)
{
using (var dbContext = new OrderProcessDbContext())
{
//修改退款申请状态
refund.RefundStatus = RefundStatus.Revoked;
dbContext.Entry <OrderRefund>(refund).State = System.Data.Entity.EntityState.Modified;
//修改订单商品退款状态
var singleGoods = dbContext.OrderGoods.FirstOrDefault(x => x.OrderId == refund.OrderId && x.SingleGoodsId == refund.SingleGoodsId);
if (singleGoods != null)
{
singleGoods.RefundStatus = OrderRefundStatus.NoRefund;
}
//修改订单状态
var order = dbContext.Orders.FirstOrDefault(x => x.Id == refund.OrderId);
if (order != null)
{
order.RefundStatus = GetOrderRefundStatus(refund, RefundStatus.Applying);
}
dbContext.SaveChanges();
}
}
/// <summary>
/// 本示例介绍如何发起 Order 退款，以及如何查询指定 Order Refund 对象和 Refund 列表，
/// </summary>
public static void Example(string orId)
{
var reParams = new Dictionary <string, object>
{
{ "description", "Refund Reason" },
{ "refund_mode", "to_source" }, //退款模式。原路退回：to_source，退至余额：to_balance。默认为原路返回。
//{"royalty_users", new List<Dictionary<string,object>>{ //退分润的用户列表,默认为 []，不分润
// new Dictionary<string,object>{
// {"user", "user_001"},
// {"amount_refunded",1}
// },
// new Dictionary<string,object>{
// {"user", "user_002"},
// {"amount_refunded",1}
// }
// }},
};
var re = OrderRefund.Create(orId, reParams);
Console.WriteLine("****创建 order refund 对象****");
Console.WriteLine(re);
Console.WriteLine();
Console.WriteLine("****查询指定 order refund 对象****");
Console.WriteLine(OrderRefund.Retrieve(orId, "re_vjz1a1DCufb5n9erLK48SGC0"));
Console.WriteLine();
Console.WriteLine("****查询 order refund 列表****");
Console.WriteLine(OrderRefund.List(orId));
Console.WriteLine();
}
/// <summary>
/// 创建订单退款申请
/// </summary>
/// <param name="refund"></param>
public void CreateOrderRefund(OrderRefund refund)
{
using (var dbContext = new OrderProcessDbContext())
{
//修改订单退款状态为
var order = dbContext.Orders.FirstOrDefault(x => x.Id == refund.OrderId);
if (order == null)
{
throw new WebApiInnerException("0002", "订单不存在");
}
if (order.RefundStatus != OrderRefundStatus.Refunding)
{
order.RefundStatus = OrderRefundStatus.Refunding;
}
var singleGoods = dbContext.OrderGoods.FirstOrDefault(x => x.OrderId == refund.OrderId && x.SingleGoodsId == refund.SingleGoodsId);
if (singleGoods == null)
{
throw new WebApiInnerException("0006", "商品不存在");
}
singleGoods.RefundStatus = OrderRefundStatus.Refunding;
//新增退款申请
refund.Id = KeyGenerator.GetGuidKey();
refund.RefundNo = KeyGenerator.GetOrderNumber();
refund.CreateTime = DateTime.Now;
refund.RefundStatus = RefundStatus.Applying;
dbContext.OrderRefunds.Add(refund);
dbContext.SaveChanges();
}
}
public void OrderRefundController_Delete_ShouldReturnPassedOrderRefundAsModel()
{
var item = new OrderRefund();
var delete = _orderRefundController.Delete(item);
delete.Model.Should().Be(item);
}
/// <summary>
/// Update An Order Refund
/// </summary>
/// <param name="orderId">The identifier of Order Refund</param>
/// <param name="refundId">The identifier of Refund</param>
/// <param name="newData">Order Refund object to be updated</param>
/// <returns></returns>
public async Task <OrderRefund> Update(int orderId, int refundId, OrderRefund newData)
{
var endPoint = string.Format("orders/{0}/refunds/{1}", orderId, refundId);
var bundle = new OrderRefundBundle {
Content = newData
};
return((await Put(endPoint, toSerialize: bundle)).Content);
}
public ViewResult Add(int orderID)
{
var orderRefund = new OrderRefund {
Order = _orderService.Get(orderID)
};
orderRefund.Amount = orderRefund.Order.TotalAfterRefunds;
orderRefund.User = CurrentRequestData.CurrentUser;
return(View(orderRefund));
}
/// <summary>
/// 整单退款时调用
/// </summary>
/// <param name="order"></param>
/// <param name="oldState"></param>
/// <param name="refund"></param>
public static ResultDTO OnOrderRefund(CommodityOrder order, int oldState, OrderRefund refund)
{
// 网易严选和其他第三方电商只有在未发货时支持整单退款
if (oldState == 1)
{
return(ThirdECommerceHelper.CancelOrder(order));
}
return(new ResultDTO {
isSuccess = true
});
}
public RedirectToRouteResult Delete_POST(OrderRefund orderRefund)
{
if (orderRefund.Order != null)
{
_orderRefundService.Delete(orderRefund);
return(RedirectToAction("Edit", "Order", new { id = orderRefund.Order.Id }));
}
else
{
return(RedirectToAction("Index", "Order"));
}
}
public void OrderRefundController_DeletePOST_ShouldCallDeleteForThePassedOrderRefund()
{
var item = new OrderRefund();
item.Order = new Order {
Id = 1
};
var delete = _orderRefundController.Delete_POST(item);
A.CallTo(() => _orderRefundService.Delete(item)).MustHaveHappened();
}
/// <summary>
/// 取消整单退款时调用
/// </summary>
/// <param name="order"></param>
/// <param name="refund"></param>
public static ResultDTO OnCancelOrderRefund(CommodityOrder order, OrderRefund refund)
{
// 判断严选订单
if (ThirdECommerceHelper.IsWangYiYanXuan(order.AppId))
{
return(new ResultDTO {
ResultCode = 1, Message = "不支持整单取消退款。"
});
}
return(new ResultDTO {
isSuccess = true
});
}
/// <summary>
/// 添加退货物流信息时调用
/// </summary>
public static ResultDTO OnOrderRefundOfferExpress(OrderRefund refund, string trackingCompany, string trackingNum)
{
// 判断严选订单
if (ThirdECommerceHelper.IsWangYiYanXuan(refund.OrderId))
{
return(new ResultDTO {
isSuccess = false, Message = "不支持"
});
//return YXSV.ExpressOfferRefundOrder(refund.ApplyId, new List<ExpressInfo> { new ExpressInfo { trackingCompany = trackingCompany, trackingNum = trackingNum } });
}
return(new ResultDTO {
isSuccess = true
});
}
public void OrderRefundController_DeletePOST_RedirectsToEditOrderForTheIdOfOrder()
{
var orderRefund = new OrderRefund();
orderRefund.Order = new Order {
Id = 1
};
var delete = _orderRefundController.Delete_POST(orderRefund);
delete.RouteValues["action"].Should().Be("Edit");
delete.RouteValues["controller"].Should().Be("Order");
delete.RouteValues["id"].Should().Be(1);
}
public void OrderRefundService_Add_ShouldCallOrderFullyRefunded()
{
var order = new Order {
Total = 100
};
var orderRefund = new OrderRefund {
Amount = 100, Order = order
};
_orderRefundService.Add(orderRefund);
A.CallTo(
() =>
EventContext.FakeEventContext.Publish <IOnOrderFullyRefunded, OrderFullyRefundedArgs>(
A <OrderFullyRefundedArgs> .That.Matches(args => args.Order == order))).MustHaveHappened();
}
public ActionResult Add_POST(OrderRefund orderRefund)
{
if (orderRefund.Order != null)
{
if (orderRefund.Amount > orderRefund.Order.TotalAfterRefunds)
{
ModelState.AddModelError("Amount", "Refund Amount must be equal or less than Total Amount after previous refunds.");
}
if (ModelState.IsValid)
{
_orderRefundService.Add(orderRefund);
return(RedirectToAction("Edit", "Order", new { id = orderRefund.Order.Id }));
}
return(View(orderRefund));
}
return(RedirectToAction("Index", "Order"));
}
public ResultDTO <ListResult <Jinher.AMP.BTP.Deploy.CustomDTO.OrderRefundCompareDTO> > GetOrderRefundExt(Jinher.AMP.BTP.Deploy.CustomDTO.OrderRefundSearchDTO search)
{
var result = new ResultDTO <ListResult <OrderRefundCompareDTO> >();
try
{
var refunds = (from o in OrderRefund.ObjectSet()
where o.OrderRefundMoneyAndCoupun != o.RefundYJCouponMoney + o.RefundFreightPrice + o.RefundYJBMoney + o.RefundMoney
select new Deploy.CustomDTO.OrderRefundCompareDTO
{
SubTime = o.SubTime,
OrderRefundMoneyAndCoupun = o.OrderRefundMoneyAndCoupun,
RefundYJCouponMoney = o.RefundYJCouponMoney,
RefundFreightPrice = o.RefundFreightPrice,
RefundYJBMoney = o.RefundYJBMoney,
RefundMoney = o.RefundMoney,
OrderId = o.OrderId
})
.Union(from a in OrderRefundAfterSales.ObjectSet()
where a.OrderRefundMoneyAndCoupun != a.RefundYJCouponMoney + a.RefundFreightPrice + a.RefundYJBMoney + a.RefundMoney
select new Deploy.CustomDTO.OrderRefundCompareDTO
{
SubTime = a.SubTime,
OrderRefundMoneyAndCoupun = a.OrderRefundMoneyAndCoupun,
RefundYJCouponMoney = a.RefundYJCouponMoney,
RefundFreightPrice = a.RefundFreightPrice,
RefundYJBMoney = a.RefundYJBMoney,
RefundMoney = a.RefundMoney,
OrderId = a.OrderId
});
result.isSuccess = true;
var data = refunds.OrderByDescending(x => x.SubTime).Skip(search.PageSize * (search.PageIndex - 1)).Take(search.PageSize).ToList();
result.Data = new ListResult <OrderRefundCompareDTO> {
List = data, Count = refunds.Count()
};
return(result);
}
catch (Exception ex)
{
LogHelper.Error("JdCommodityBP.GetJdCommodityListExt 异常", ex);
return(new ResultDTO <ListResult <OrderRefundCompareDTO> > {
isSuccess = false, Data = null
});
}
}
/// <summary>
/// 修改退款申请状态 获取订单退款状态
/// 退款申请状态：申请中=>已撤销 （申请中1，已处理0，已完成0，申请中的申请为自身 ===>订单状态更改为无退款）
/// 退款申请状态：申请中=>已撤销 （申请中1，已处理0，已完成>0，申请中的申请为自身 ===>订单状态更改为已退款）
/// 退款申请状态：申请中=>已处理 （对订单退款状态无影响 不需处理 放回原订单退款状态）
/// 退款申请状态：申请中=>已完成 （申请中1，已处理0，已完成0，申请中的申请为自身 ===>订单状态更改为无退款）
/// 退款申请状态：申请中=>已完成 （申请中1，已处理0，已完成>0，申请中的申请为自身 ===>订单状态更改为已退款）
/// 退款申请状态：已处理=>已完成 （申请中0，已处理1，处理中的申请为自身 ===>订单状态更改为已退款）
/// </summary>
/// <param name="refund"></param>
/// <param name="oldRefundStatus"></param>
/// <returns></returns>
private OrderRefundStatus GetOrderRefundStatus(OrderRefund refund, RefundStatus oldRefundStatus)
{
var order = _currencyService.GetSingleById <Order>(refund.OrderId);
var applyingList = _currencyService.GetList <OrderRefund>(x => x.OrderId == refund.OrderId && x.RefundStatus == RefundStatus.Applying);
var processedList = _currencyService.GetList <OrderRefund>(x => x.OrderId == refund.OrderId && x.RefundStatus == RefundStatus.Processed);
var completedList = _currencyService.GetList <OrderRefund>(x => x.OrderId == refund.OrderId && x.RefundStatus == RefundStatus.Completed);
//原退款状态 申请中
if (oldRefundStatus == RefundStatus.Applying)
{
//申请数为1 已审核为0 且申请为自身
if (applyingList.Count == 1 && processedList.Count == 0 && applyingList[0].Id == refund.Id)
{
//状态更改为 已完成(审核不通过) 已撤销
if (refund.RefundStatus == RefundStatus.Revoked || (refund.RefundStatus == RefundStatus.Completed && refund.ReviewResult == ReviewResult.UnPassed))
{
if (completedList.Count == 0)
{
return(OrderRefundStatus.NoRefund);
}
else
{
return(OrderRefundStatus.Refunded);
}
}
//状态更改为 已完成（审核通过）
else if (refund.RefundStatus == RefundStatus.Completed && refund.ReviewResult == ReviewResult.Passed)
{
return(OrderRefundStatus.Refunded);
}
}
}
else if (oldRefundStatus == RefundStatus.Processed)
{
if (applyingList.Count == 0 && processedList.Count == 1 && processedList[0].Id == refund.Id)
{
if (refund.RefundStatus == RefundStatus.Completed)
{
return(OrderRefundStatus.Refunded);
}
}
}
return(order.RefundStatus);
}
public RefundApplyInfoModel(OrderRefund refund)
{
Id = refund.Id;
RefundNo = refund.RefundNo;
OrderId = refund.OrderId;
SingleGoodsId = refund.SingleGoodsId;
RefundType = refund.RefundType;
RefundStatus = refund.RefundStatus;
RefundAmount = refund.RefundAmount;
Reason = refund.Reason;
CreateTime = refund.CreateTime;
ReviewTime = refund.ReviewTime;
ReviewResult = refund.ReviewResult;
ReviemMemo = refund.ReviemMemo;
ShippingName = refund.ShippingName;
ShippingNo = refund.ShippingNo;
ShippingTime = refund.ShippingTime;
ShippingMemo = refund.ShippingMemo;
}
public void Add(OrderRefund orderRefund)
{
orderRefund.Order.OrderRefunds.Add(orderRefund);//cache
_session.Transact(session => session.Save(orderRefund));
if (orderRefund.Amount == orderRefund.Order.Total)
{
EventContext.Instance.Publish <IOnOrderFullyRefunded, OrderFullyRefundedArgs>
(new OrderFullyRefundedArgs {
Refund = orderRefund, Order = orderRefund.Order
});
}
else
{
EventContext.Instance.Publish <IOnOrderPartiallyRefunded, OrderPartiallyRefundedArgs>
(new OrderPartiallyRefundedArgs {
Refund = orderRefund, Order = orderRefund.Order
});
}
}
public RefundViewModel(OrderRefund refund)
{
Id = refund.Id;
RefundNo = refund.RefundNo;
var currencyService = HostConstObject.Container.Resolve <ICurrencyService>();
var goods = currencyService.GetSingleByConditon <OrderGoods>(a => a.OrderId == refund.OrderId && a.SingleGoodsId == refund.SingleGoodsId);
GoodsName = goods.GoodsName;
GoodsAttribute = goods.GoodsAttribute;
RefundType = refund.RefundType;
RefundStatus = refund.RefundStatus;
RefundAmount = refund.RefundAmount;
Reason = refund.Reason;
CreateTime = refund.CreateTime;
ReviewTime = refund.ReviewTime;
ReviewResult = refund.ReviewResult;
ReviemMemo = refund.ReviemMemo;
ShippingName = refund.ShippingName;
ShippingNo = refund.ShippingNo;
ShippingTime = refund.ShippingTime;
ShippingMemo = refund.ShippingMemo;
}
/// <summary>
/// Sezzle allows refunds for orders either through our Merchant Dashboard or through the API. If the refund is processed through the dashboard, a webhook will be sent to your system. In either case, Sezzle allows for either partial or complete refunds. Refund amounts are relative to the order total, not the amount that has been paid by the shopper.
/// </summary>
/// <remarks>
/// https://gateway.sezzle.com/v1/orders/{order_reference_id}/refund
/// </remarks>
/// <param name="orderReferenceId"></param>
/// <param name="orderRefund"></param>
/// <returns></returns>
public Task <OrderRefundResponse> Refund(string orderReferenceId, OrderRefund orderRefund)
{
AssertIsAuthenticated();
// TODO: In the event that a token is expired, we want to refresh the token
AssertTokenExpired();
Ensure.ArgumentNotNullOrEmptyString(orderReferenceId, nameof(orderReferenceId));
var request = Request("{order-reference-id}/refund", HttpMethod.Post);
request.AddUrlSegment("order-reference-id", orderReferenceId);
// TODO: Abstract the string payload convert into StringContent to an extension method
var stringPayload = JsonConvert.SerializeObject(orderRefund, SezzleConfig.DefaultSerializerSettings);
var httpContent = new StringContent(stringPayload, Encoding.UTF8, "application/json");
request.Content = httpContent;
return(Client.ExecuteAsync <OrderRefundResponse>(request));
}
public async Task CanRefundOrderPartially()
{
// TODO: Ignore and find a way to pipe in a valid order reference id
var orderReferenceId = "636773928435687781";
var orders = new Orders(SezzleConfig, AuthResponse);
var price = new Price(500, "USD");
var refundReason = "Customer returned item damaged.";
var refundId = Guid.NewGuid().ToString();
var orderRefund = new OrderRefund()
{
Amount = price, RefundId = refundId, RefundReason = refundReason
};
var orderRefundResponse = await orders.Refund(orderReferenceId, orderRefund);
Assert.IsNotNull(orderRefundResponse);
Console.WriteLine(JsonConvert.SerializeObject(orderRefundResponse, Formatting.Indented));
Assert.AreEqual(orderRefundResponse.HttpStatusCode, HttpStatusCode.OK);
Assert.AreEqual(orderRefundResponse.RefundId, refundId);
Assert.AreEqual(orderRefundResponse.RefundReason, refundReason);
Assert.AreEqual(orderRefundResponse.Amount.AmountInCents, price.AmountInCents);
}
public async Task CanRefundOrderFully()
{
// TODO: Ignore and find a way to pipe in a valid order reference id
var orderReferenceId = "636773935603630168";
var orders = new Orders(SezzleConfig, AuthResponse);
var refundReason = "Customer returned item.";
var refundId = Guid.NewGuid().ToString();
var orderRefund = new OrderRefund()
{
IsFullRefund = true, RefundId = refundId, RefundReason = refundReason
};
var orderRefundResponse = await orders.Refund(orderReferenceId, orderRefund);
Assert.IsNotNull(orderRefundResponse);
Console.WriteLine(JsonConvert.SerializeObject(orderRefundResponse, Formatting.Indented));
Assert.AreEqual(orderRefundResponse.HttpStatusCode, HttpStatusCode.OK);
Assert.AreEqual(orderRefundResponse.RefundId, refundId);
Assert.AreEqual(orderRefundResponse.RefundReason, refundReason);
// TODO: Pull order details and compare that total with the total refunded amount returned from refund API call
}
/// <summary>
/// 退款单详情
/// </summary>
/// <param name="user"></param>
/// <param name="no"></param>
/// <returns></returns>
public ActionResult OrderRefundForm(SysUser user, string no)
{
//退款单
OrderRefund orderRefund = ServiceIoc.Get <OrderRefundService>().Get(no);
//订单
ProductOrder order = ServiceIoc.Get <ProductOrderService>().GetById(orderRefund.order_id);
//订单发货地址
OrderDelivery delivery = ServiceIoc.Get <OrderDeliveryService>().GetByOrderId(orderRefund.order_id);
//订单详情
List <ProductOrderDetail> order_details = ServiceIoc.Get <ProductOrderDetailService>().GetListByOrderId(orderRefund.order_id);
if (order == null || order_details == null)
{
throw new Exception("订单数据异常");
}
//物流公司
ViewBag.companys = ServiceIoc.Get <LogisticsCompanyService>().GetAll();
//判断是否为跳转过来的链接
ViewBag.isUrlReferrer = Request.Headers["Referer"].FirstOrDefault() == null ? false : true;
//订单信息
ViewBag.order = order;
//订单详情
ViewBag.order_details = order_details;
//收件人信息
ViewBag.delivery = delivery;
//退款订单
ViewBag.orderRefund = orderRefund;
return(View());
}
/// <summary>
/// 众筹股东订单列表
/// </summary>
/// <param name="crowdfundingId">众筹Id</param>
/// <param name="userId">用户Id</param>
/// <param name="pageIndex">页码</param>
/// <param name="pageSize">每页数量</param>
public CommodityOrderVMDTO GetUserCrowdfundingOrdersExt(System.Guid crowdfundingId, System.Guid userId, int pageIndex, int pageSize)
{
CommodityOrderVMDTO CommodityOrderVMDTO = new CommodityOrderVMDTO();
try
{
var query = from data in CommodityOrder.ObjectSet()
join CrowdfundingData in Crowdfunding.ObjectSet()
on data.AppId equals CrowdfundingData.AppId
join data1 in OrderRefund.ObjectSet()
on data.Id equals data1.OrderId
into tempT
from tb3 in tempT.DefaultIfEmpty()
join cf in CfOrderDividend.ObjectSet()
on data.Id equals cf.CommodityOrderId into CfOrderDividends
from cfOrderDividend in CfOrderDividends.DefaultIfEmpty()
where
data.UserId == userId && data.IsCrowdfunding != 0 && data.State != 0 &&
CrowdfundingData.Id == crowdfundingId
&&
(tb3.RefundMoney == null ? 0 : tb3.RefundMoney) <
(data.IsModifiedPrice ? data.RealPrice : data.Price) &&
tb3.State != 2 && tb3.State != 3 && tb3.State != 4 && tb3.State != 13
select new CommodityOrderVM
{
AppId = data.AppId,
UserId = data.UserId,
CommodityOrderId = data.Id,
CurrentPrice = data.RealPrice,
State = data.State,
CommodityOrderCode = data.Code,
SubTime = data.SubTime,
ReceiptUserName = data.ReceiptUserName,
Payment = data.Payment,
PaymentTime = data.PaymentTime,
ShipmentsTime = data.ShipmentsTime,
ConfirmTime = data.ConfirmTime,
ModifiedOn = data.ModifiedOn,
Price = data.Price,
MessageToBuyer = data.MessageToBuyer,
IsModifiedPrice = data.IsModifiedPrice,
ReceiptPhone = data.ReceiptPhone,
RefundTime = data.RefundTime,
AgreementTime = data.AgreementTime,
Freight = data.Freight,
Commission = data.Commission,
IsCrowdfunding = true,
CfDividend = cfOrderDividend.Gold
};
var result = query.OrderByDescending(q => q.SubTime).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
#region 查询订单商品信息(优化)
//构建订单id数组
List <Guid> commodityOrderIdList = new List <Guid>();
for (int i = 0; i < result.Count; i++)
{
commodityOrderIdList.Add(result[i].CommodityOrderId);
}
CommodityCategory cc = new CommodityCategory();
//取出所有订单的所有商品
var orderItems = (from data in OrderItem.ObjectSet()
//join data1 in Commodity.ObjectSet() on data.CommodityId equals data1.Id
where commodityOrderIdList.Contains(data.CommodityOrderId)
select new
{
CommodityOrderId = data.CommodityOrderId,
CommodityId = data.CommodityId,
CommodityIdName = data.Name,
PicturesPath = data.PicturesPath,
Price = data.CurrentPrice, //取订单商品列表中的价格
Number = data.Number,
CommodityAttributes = data.CommodityAttributes,
CategoryName = data.CategoryNames,
RealPrice = data.RealPrice
}).ToList();
List <OrderItemsVM> orderItemsVMList = (from data in orderItems
select new OrderItemsVM
{
CommodityOrderId = data.CommodityOrderId,
CommodityId = data.CommodityId,
CommodityIdName = data.CommodityIdName,
PicturesPath = data.PicturesPath,
Price = data.Price, //取订单商品列表中的价格
RealPrice = data.RealPrice,
Number = data.Number,
SizeAndColorId = data.CommodityAttributes,
CommodityCategorys =
data.CategoryName == null ? new List <string>() : data.CategoryName.Split(',').ToList()
}).ToList();
Collection collect = new Collection();
//遍历订单
foreach (CommodityOrderVM v in result)
{
List <OrderItemsVM> orderItemslist = new List <OrderItemsVM>();
//遍历订单中的商品，获取每个商品对应的颜色、尺寸属性
foreach (OrderItemsVM model in orderItemsVMList)
{
if (model.CommodityOrderId == v.CommodityOrderId)
{
orderItemslist.Add(model);
}
}
v.OrderItems = orderItemslist;
}
#endregion
if (result != null && result.Count > 0)
{
CommodityOrderVMDTO.List = result;
CommodityOrderVMDTO.Total = query.Count();
}
else
{
CommodityOrderVMDTO.Total = 0;
}
return(CommodityOrderVMDTO);
}
catch (Exception ex)
{
LogHelper.Error(string.Format("获取众筹列表服务异常。crowdfundingId：{0}，userId：{1}，pageIndex：{2}，pageSize：{3}", crowdfundingId, userId, pageIndex, pageSize), ex);
return(null);
}
return(CommodityOrderVMDTO);
}
public void Delete(OrderRefund item)
{
_session.Transact(session => session.Delete(item));
}
/// <summary>
/// 单品退款时调用（售前）
/// </summary>
/// <param name="order"></param>
/// <param name="orderItem"></param>
/// <param name="refund"></param>
public static ResultDTO OnOrderItemRefund(CommodityOrder order, OrderItem orderItem, OrderRefund refund)
{
// 判断严选订单
if (ThirdECommerceHelper.IsWangYiYanXuan(order.AppId))
{
return(new ResultDTO {
isSuccess = false, ResultCode = 1, Message = "确认收货后才能申请售后~"
});
}
return(new ResultDTO {
isSuccess = true
});
}
// Update An Order Refund
public OrderRefund Update(int orderId, int refundId, OrderRefund newData)
{
return(Put(apiEndpoint: String.Format("orders/{0}/refunds/{1}", orderId, refundId), toSerialize: new OrderRefundBundle {
Content = newData
}).Content);
}
/// <summary>
/// 取消单品退款时调用（售前）
/// </summary>
public static ResultDTO OnCancelOrderItemRefund(CommodityOrder order, OrderItem orderItem, OrderRefund refund)
{
return(new ResultDTO {
isSuccess = true
});
}
