/// <summary>
/// 订单取消回调
/// </summary>
/// <param name="result"></param>
public static void CancelOrderCallback(OrderCancelResultCallBack result)
{
try
{
Guid orderId;
Guid.TryParse(result.orderId, out orderId);
LogHelper.Debug("进入 YXOrderHelper.CancelOrderCallback，Input:" + JsonConvert.SerializeObject(result));
OrderSV.UnLockOrder(orderId);
if (result.cancelStatus == 0)
{
var optResult = OrderHelper.RejectOrderRefund(orderId, result.rejectReason);
if (optResult.ResultCode != 0)
{
LogHelper.Error("YXOrderHelper.CancelOrderCallback 取消订单失败，RejectOrderRefund返回：" + JsonConvert.SerializeObject(optResult));
}
}
else if (result.cancelStatus == 1)
{
var optResult = OrderHelper.ApproveCancelOrder(orderId);
if (optResult.ResultCode != 0)
{
LogHelper.Error("YXOrderHelper.CancelOrderCallback 取消订单失败，ApproveCancelOrder返回：" + JsonConvert.SerializeObject(optResult));
}
}
else
{
LogHelper.Error("YXOrderHelper.CancelOrderCallback 取消订单失败，严选回调为待客服审核：" + JsonConvert.SerializeObject(result));
}
}
catch (Exception ex)
{
LogHelper.Error("YXOrderHelper.CancelOrderCallback 异常，Input:" + JsonConvert.SerializeObject(result), ex);
}
}
/// <summary>
/// 处理 未成团退款
/// </summary>
public void DealUnDiyGroupRefundExt()
{
try
{
ContextSession contextSession = ContextFactory.CurrentThreadContext;
var diyGroupOrders = (from diyg in DiyGroup.ObjectSet()
join diyGroupOrder in DiyGroupOrder.ObjectSet() on diyg.Id equals diyGroupOrder.DiyGroupId
where diyg.State == 5 && diyGroupOrder.State == 1
select diyGroupOrder).ToList();
LogHelper.Debug("开始进入DealUnDiyGroupRefundExt，diyOrderDictionary：" + JsonHelper.JsSerializer(diyGroupOrders));
foreach (var diyGroupOrder in diyGroupOrders)
{
bool isOk = OrderSV.RefundOrderDiyGroup(diyGroupOrder.OrderId);
if (isOk)
{
var diy = DiyGroup.FindByID(diyGroupOrder.DiyGroupId);
diy.State = 6;
diy.FailTime = DateTime.Now;
diy.ModifiedOn = DateTime.Now;
diy.EntityState = EntityState.Modified;
contextSession.SaveObject(diy);
}
}
contextSession.SaveChanges();
}
catch (Exception ex)
{
LogHelper.Error("DealUnDiyGroupRefundExt异常：", ex);
}
}
/// <summary>
/// 导入自营商家未设置结算价时的金币支付订单
/// </summary>
public static void ImportNotSettleGoldOrder()
{
LogHelper.Info("SettleAccountHelper.ImportNotSettleGoldOrder 开始导入未设置结算价的金币支付订单");
try
{
ContextSession contextSession = ContextFactory.CurrentThreadContext;
// 查询商城下APP
var mallQuery = MallApply.ObjectSet().Where(m => m.Type == 0 && (m.State.Value == 2 || m.State.Value == 4));
//var startDate = new DateTime(2017, 9, 1);
var hadAddOrderQuery = SettleAccountsDetails.ObjectSet().AsQueryable();
ContextDTO contextDTO = AuthorizeHelper.CoinInitAuthorizeInfo();
// 生成结算项
List <object> saveList = new List <object>();
foreach (var mall in mallQuery.ToList())
{
var orderQuery = CommodityOrder.ObjectSet().Where(o =>
o.AppId == mall.AppId &&
o.EsAppId == mall.EsAppId &&
o.PaymentTime > mall.SubTime &&
o.Payment == 0);
var orders = orderQuery.Join(CommodityOrderService.ObjectSet()
.Where(s => (s.State == 15)), o => o.Id, s => s.Id, (o, s) => o)
.Where(o => !hadAddOrderQuery.Where(h => h.EsAppId == mall.EsAppId && h.AppId == mall.AppId && h.OrderId == o.Id)
.Any(h => h.Id == o.Id))
.ToList();
if (orders.Count > 0)
{
foreach (var o in orders)
{
LogHelper.Info("ImportNotSettleGoldOrder,导入自营商家未设置结算价时的金币支付订单，开始生成结算单，OrderId：" + o.Id);
var sa = SettleAccountHelper.CreateSettleAccount(contextSession, o, mall);
if (sa != null)
{
Jinher.AMP.App.Deploy.CustomDTO.AppIdOwnerIdTypeDTO applicationDTO = APPSV.Instance.GetAppOwnerInfo(o.AppId, contextDTO);
// 打款
var confirmDto = OrderSV.BuildConfirmPayDTOAfterSales(contextSession, o, out saveList, applicationDTO, isSaveObject: false);
LogHelper.Info("导入自营商家未设置结算价时的金币支付订单，开始打款，OrderId:" + o.Id + "ConfirmPayDTO: " + JsonHelper.JsonSerializer(confirmDto));
var goldPayResult = Jinher.AMP.BTP.TPS.FSPSV.Instance.ConfirmPay(confirmDto);
if (goldPayResult.Code != 0)
{
// 打款失败
sa.IsPaySuccess = false;
LogHelper.Info("导入自营商家未设置结算价时的金币支付订单，结束打款，失败，OrderId:" + o.Id);
var errorInfo = JsonHelper.JsonSerializer(goldPayResult);
LogHelper.Error("OrderSV.CreateSettleAccount 生成结算单，打款异常，OrderId: " + o.Id + " ReturnInfoDTO: " + errorInfo);
SettleAccountsException exception = new SettleAccountsException();
exception.Id = sa.Id;
exception.OrderId = o.Id;
exception.OrderCode = o.Code;
exception.OrderRealPrice = o.RealPrice;
exception.ClearingPrice = sa.SellerAmount;
exception.ExceptionInfo = errorInfo;
exception.AppId = sa.AppId;
exception.AppName = sa.AppName;
exception.EntityState = EntityState.Added;
contextSession.SaveObject(exception);
}
else
{
// 打款成功
sa.IsPaySuccess = true;
LogHelper.Info("导入自营商家未设置结算价时的金币支付订单，结束打款，成功，OrderId:" + o.Id);
}
LogHelper.Info("ImportNotSettleGoldOrder,导入自营商家未设置结算价时的金币支付订单，结束生成结算单，OrderId：" + o.Id);
}
}
}
}
if (saveList != null && saveList.Any())
{
foreach (var o in saveList)
{
contextSession.SaveObject(o);
}
}
contextSession.SaveChanges();
}
catch (Exception ex)
{
LogHelper.Error(string.Format("SettleAccountHelper.ImportNotSettleGoldOrder 异常", ex));
}
LogHelper.Info("SettleAccountHelper.ImportNotSettleGoldOrder 结束导入未设置结算价的金币支付订单");
}
/// <summary>
/// 打印订单状态变为2（已发货）
/// </summary>
/// <param name="ucopDto">参数</param>
/// <param name="commodityOrder">订单信息</param>
/// <returns></returns>
private ResultDTO UpdateOrderStateTo2(UpdateCommodityOrderParamDTO ucopDto, CommodityOrder commodityOrder, UpdatePrintDTO orders)
{
try
{
ContextSession contextSession = ContextFactory.CurrentThreadContext;
DateTime now = DateTime.Now;
int oldState = commodityOrder.State;
int newState = ucopDto.targetState;
#region 退款
var orderRefund = new CommodityOrderBP().getOrderRefund(ucopDto.orderId);
if (orderRefund != null)
{
orderRefund.State = 2;
orderRefund.ModifiedOn = now;
}
#endregion
if (!OrderSV.CanChangeState(newState, commodityOrder, orderRefund, null, null))
{
return(new ResultDTO()
{
ResultCode = 1, Message = "订单状态修改错误"
});
}
#region 订单
string shipExpCo = orders.ShipName;
string expOrderNo = orders.Orders.Find(r => r.OrderId == ucopDto.orderId).ExpressOrder;
commodityOrder.ShipExpCo = string.IsNullOrWhiteSpace(shipExpCo) ? "" : shipExpCo.Trim();
commodityOrder.ExpOrderNo = string.IsNullOrWhiteSpace(expOrderNo) ? "" : expOrderNo.Trim();
commodityOrder.ExpOrderNo = commodityOrder.ExpOrderNo.Replace("+", "");
commodityOrder.State = ucopDto.targetState;
//更新发货时间
commodityOrder.ShipmentsTime = now;
if (commodityOrder.IsRefund == true)
{
commodityOrder.IsRefund = false;
}
commodityOrder.EntityState = EntityState.Modified;
commodityOrder.ModifiedOn = now;
#endregion
#region 保存物流子表
//保存物流子表
OrderShipping orderShipping = OrderShipping.CreateOrderShipping();
orderShipping.OrderId = ucopDto.orderId;
orderShipping.ShipExpCo = commodityOrder.ShipExpCo;
orderShipping.ExpOrderNo = commodityOrder.ExpOrderNo;
contextSession.SaveObject(orderShipping);
#endregion
#region 订单日志
Journal journal = Journal.CreateJournal(ucopDto, commodityOrder, oldState, "商家已发货");
contextSession.SaveObject(journal);
#endregion
return(new ResultDTO()
{
ResultCode = 0, Message = "设置一个订单成功"
});
}
catch (Exception ex)
{
LogHelper.Error(string.Format("打印订单状态变为2（已发货）。UpdateOrderStateTo2：{0}", JsonHelper.JsonSerializer(ucopDto)), ex);
}
return(new ResultDTO()
{
ResultCode = 1, Message = "设置一个订单失败"
});
}
/// <summary>
/// 第三方电商订单取消审核结果回调
/// </summary>
/// <param name="result"></param>
public static ThirdResponse CancelOrderCallback(string resultJsonStr)
{
LogHelper.Debug("ThirdECommerceOrderHelper.CancelOrderCallback第三方电商订单取消审核结果回调，Input:" + resultJsonStr);
if (string.IsNullOrEmpty(resultJsonStr))
{
return new ThirdResponse {
Code = 10200, Msg = "缺少参数orderCancelResult"
}
}
;
var result = new ThirdResponse {
Code = 200, Msg = "ok"
};
try
{
var cancelResult = JsonConvert.DeserializeObject <ThirdOrderCancelResultCallBack>(resultJsonStr);
if (cancelResult == null)
{
return new ThirdResponse {
Code = 10201, Msg = "非法参数orderCancelResult"
}
}
;
Guid orderId;
DateTime auditTime;
Guid.TryParse(cancelResult.OrderId, out orderId);
DateTime.TryParse(cancelResult.AuditTime, out auditTime);
if (orderId == Guid.Empty)
{
return new ThirdResponse {
Code = 10202, Msg = "非法参数OrderId"
}
}
;
if (!new List <int> {
0, 1
}.Contains(cancelResult.CancelStatus))
{
return new ThirdResponse {
Code = 10203, Msg = "非法参数CancelStatus"
}
}
;
if (cancelResult.CancelStatus == 0 && string.IsNullOrEmpty(cancelResult.RejectReason))
{
return new ThirdResponse {
Code = 10204, Msg = "非法参数RejectReason"
}
}
;
if (auditTime == DateTime.MinValue)
{
return new ThirdResponse {
Code = 10205, Msg = "非法参数CancelStatus"
}
}
;
#region 判断是否第三方电商订单及获取订单信息
var order = ThirdECOrder.ObjectSet().FirstOrDefault(o => o.OrderId == orderId);
if (order == null)
{
return new ThirdResponse {
Code = 10206, Msg = "未找到此订单"
}
}
;
if (order.CancelCallBackTime.HasValue)
{
return(result);
}
#endregion
#region 处理退款
var errorMessage = string.Empty;
OrderSV.UnLockOrder(orderId);
if (cancelResult.CancelStatus == 0)
{
var optResult = OrderHelper.RejectOrderRefund(orderId, cancelResult.RejectReason);
if (optResult.ResultCode != 0)
{
errorMessage = optResult.Message;
LogHelper.Error("ThirdECommerceOrderHelper.CancelOrderCallback 取消订单失败，RejectOrderRefund返回：" + JsonConvert.SerializeObject(optResult));
result = new ThirdResponse {
Code = 10207, Msg = "内部异常"
};
}
else
{
order.StateName = "不允许取消";
order.CancelCallBackTime = auditTime;
order.StateDesc = "订单取消审核结果回调:不允许取消," + cancelResult.RejectReason;
}
}
else
{
order.StateName = "允许取消";
var optResult = OrderHelper.ApproveCancelOrder(orderId);
if (optResult.ResultCode != 0)
{
errorMessage = optResult.Message;
LogHelper.Error("ThirdECommerceOrderHelper.CancelOrderCallback 取消订单失败，ApproveCancelOrder返回：" + JsonConvert.SerializeObject(optResult));
result = new ThirdResponse {
Code = 10208, Msg = "内部异常"
};
}
else
{
order.StateName = "允许取消";
order.CancelCallBackTime = auditTime;
order.StateDesc = "订单取消审核结果回调:允许取消";
}
}
#endregion
#region 保存ThirdECOrderJournal
var thirdOrderJournal = new ThirdECOrderJournal
{
Id = Guid.NewGuid(),
OrderId = order.OrderId,
OrderCode = order.OrderCode,
SubTime = DateTime.Now,
SubId = order.SubId,
Name = "取消订单审核结果回调",
Details = result.Successed ? order.StateDesc : errorMessage,
Json = resultJsonStr,
EntityState = EntityState.Added
};
ContextFactory.CurrentThreadContext.SaveObject(thirdOrderJournal);
#endregion
int count = ContextFactory.CurrentThreadContext.SaveChanges();
if (count == 0)
{
LogHelper.Error(string.Format("ThirdECommerceOrderHelper.CancelOrderCallback第三方电商订单取消审核结果回调数据保存失败,入参:{0}", resultJsonStr));
return(new ThirdResponse {
Code = 10209, Msg = "内部异常"
});
}
}
catch (JsonReaderException ex)
{
LogHelper.Error("ThirdECommerceOrderHelper.CancelOrderCallback第三方电商订单取消审核结果回调反序列化异常，Input:" + resultJsonStr, ex);
return(new ThirdResponse <ThirdOrderCancelResult> {
Msg = "反序列化异常"
});
}
catch (Exception ex)
{
LogHelper.Error("ThirdECommerceOrderHelper.CancelOrderCallback第三方电商订单取消审核结果回调异常，Input:" + resultJsonStr, ex);
return(new ThirdResponse {
Code = 10210, Msg = "内部异常"
});
}
return(result);
}
