You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
695 lines
30 KiB
C#
695 lines
30 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using POSV.HttpApi;
|
|
using POSV.Utils;
|
|
using POSV.Stock;
|
|
using POSV.WeiXin;
|
|
using POSV.Entity.WeiXinDc;
|
|
|
|
namespace POSV.Card
|
|
{
|
|
public class WeiXinOrderUtils
|
|
{
|
|
private static NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
|
|
|
|
protected static Dictionary<string , string> _errorDesc = new Dictionary<string , string>();
|
|
|
|
static WeiXinOrderUtils()
|
|
{
|
|
//------------------------------------------------------
|
|
//系统没有定义的错误代码
|
|
_errorDesc.Add("9999" , "应答的报文解析异常");
|
|
}
|
|
|
|
/// <summary>
|
|
/// 微信点餐商品停售
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public static Tuple<bool, string, WeiXinEntityResponse<string>> WxdcGoodsSellOut(WxdcGoodsSellOutRequest request)
|
|
{
|
|
Tuple<bool, string, WeiXinEntityResponse<string>> result = null;
|
|
|
|
try
|
|
{
|
|
OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
|
|
SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);
|
|
|
|
parameters.Add("method", "wxdc.goods.sellout");
|
|
parameters.Add("storeId", request.StoreId);
|
|
parameters.Add("productIds", request.ProductIds);
|
|
var ignoreParameters = new List<string>();
|
|
ignoreParameters.Add("productIds");
|
|
parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
|
|
string response = HttpClientUtils.PostAsync(api, api.Url, parameters);
|
|
|
|
//获取成功
|
|
if (Constant.IsSuccessful(response))
|
|
{
|
|
var data = JsonUtils.Deserialize<WeiXinEntityResponse<string>>(response);
|
|
if (data.Status == 1)
|
|
{
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<string>>(true, data.Message, data);
|
|
}
|
|
else
|
|
{
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<string>>(false, data.ErrMessage, data);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errorMessage = PaserErrors(response);
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<string>>(false, errorMessage, null);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.Error(ex, "商品停售异常");
|
|
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<string>>(false, "商品停售异常,本次操作无效", null);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 微信点餐商品开卖
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public static Tuple<bool, string, WeiXinEntityResponse<string>> WxdcGoodsSellin(WxdcGoodsSellinRequest request)
|
|
{
|
|
Tuple<bool, string, WeiXinEntityResponse<string>> result = null;
|
|
|
|
try
|
|
{
|
|
OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
|
|
SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);
|
|
|
|
parameters.Add("method", "wxdc.goods.sellin");
|
|
parameters.Add("storeId", request.StoreId);
|
|
parameters.Add("productIds", request.ProductIds);
|
|
var ignoreParameters = new List<string>();
|
|
ignoreParameters.Add("productIds");
|
|
parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
|
|
string response = HttpClientUtils.PostAsync(api, api.Url, parameters);
|
|
|
|
//获取成功
|
|
if (Constant.IsSuccessful(response))
|
|
{
|
|
var data = JsonUtils.Deserialize<WeiXinEntityResponse<string>>(response);
|
|
if (data.Status == 1)
|
|
{
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<string>>(true, data.Message, data);
|
|
}
|
|
else
|
|
{
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<string>>(false, data.ErrMessage, data);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errorMessage = PaserErrors(response);
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<string>>(false, errorMessage, null);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.Error(ex, "点餐商品开卖异常");
|
|
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<string>>(false, "点餐商品开卖异常,本次操作无效", null);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 商品分类列表
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public static Tuple<bool, string, WeiXinListResponse<WxdcGoodsCategoryEntity>> WxdcGoodsCategory(WxdcGoodsCategoryListRequest request)
|
|
{
|
|
Tuple<bool, string, WeiXinListResponse<WxdcGoodsCategoryEntity>> result = null;
|
|
|
|
try
|
|
{
|
|
OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
|
|
SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);
|
|
parameters.Add("method", "wxdc.goods.category");
|
|
parameters.Add("storeId", request.StoreId);
|
|
parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters));
|
|
string response = HttpClientUtils.PostAsync(api, api.Url, parameters);
|
|
|
|
//获取成功
|
|
if (Constant.IsSuccessful(response))
|
|
{
|
|
var data = JsonUtils.Deserialize<WeiXinListResponse<WxdcGoodsCategoryEntity>>(response);
|
|
if (data.Status == 1)
|
|
{
|
|
result = new Tuple<bool, string, WeiXinListResponse<WxdcGoodsCategoryEntity>>(true, data.Message, data);
|
|
}
|
|
else
|
|
{
|
|
result = new Tuple<bool, string, WeiXinListResponse<WxdcGoodsCategoryEntity>>(false, data.ErrMessage, data);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errorMessage = PaserErrors(response);
|
|
result = new Tuple<bool, string, WeiXinListResponse<WxdcGoodsCategoryEntity>>(false, errorMessage, null);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.Error(ex, "微信商品分类查询异常");
|
|
|
|
result = new Tuple<bool, string, WeiXinListResponse<WxdcGoodsCategoryEntity>>(false, "微信商品分类查询异常,本次操作无效", null);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 商品信息列表
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public static Tuple<bool, string, WeiXinPagerResponse<WxdcGoodsEntity>> WxdcGoods(WxdcGoodsListRequest request)
|
|
{
|
|
Tuple<bool, string, WeiXinPagerResponse<WxdcGoodsEntity>> result = null;
|
|
|
|
try
|
|
{
|
|
OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
|
|
SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);
|
|
|
|
parameters.Add("method", "wxdc.goods.list");
|
|
|
|
parameters.Add("storeId", request.StoreId);
|
|
parameters.Add("categoryId", request.CategoryId);
|
|
parameters.Add("property", request.Property);
|
|
parameters.Add("keyword", request.Keyword);
|
|
parameters.Add("pageNumber", string.Format("{0}", request.PageNumber));
|
|
parameters.Add("pageSize", string.Format("{0}", request.PageSize));
|
|
var ignoreParameters = new List<string>();
|
|
ignoreParameters.Add("categoryId");
|
|
ignoreParameters.Add("property");
|
|
ignoreParameters.Add("keyword");
|
|
ignoreParameters.Add("pageNumber");
|
|
ignoreParameters.Add("pageSize");
|
|
parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
|
|
string response = HttpClientUtils.PostAsync(api, api.Url, parameters);
|
|
|
|
//获取成功
|
|
if (Constant.IsSuccessful(response))
|
|
{
|
|
var data = JsonUtils.Deserialize<WeiXinPagerResponse<WxdcGoodsEntity>>(response);
|
|
if (data.Status == 1)
|
|
{
|
|
result = new Tuple<bool, string, WeiXinPagerResponse<WxdcGoodsEntity>>(true, data.Message, data);
|
|
}
|
|
else
|
|
{
|
|
result = new Tuple<bool, string, WeiXinPagerResponse<WxdcGoodsEntity>>(false, data.ErrMessage, data);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errorMessage = PaserErrors(response);
|
|
result = new Tuple<bool, string, WeiXinPagerResponse<WxdcGoodsEntity>>(false, errorMessage, null);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.Error(ex, "微信商品信息查询异常");
|
|
|
|
result = new Tuple<bool, string, WeiXinPagerResponse<WxdcGoodsEntity>>(false, "微信商品信息查询异常,本次操作无效", null);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 门店拒绝退款
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public static Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundRefuseResponse>> WeiXinOrderRefundRefuse(WeiXinOrderRefundRefuseRequest request)
|
|
{
|
|
Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundRefuseResponse>> result = null;
|
|
|
|
try
|
|
{
|
|
OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
|
|
SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);
|
|
|
|
parameters.Add("method", "wxdc.order.refund.store.refuse");
|
|
parameters.Add("erpStoreId", request.StoreId);
|
|
parameters.Add("ticketId", request.TicketId);
|
|
parameters.Add("refuseReason", request.RefuseReason);
|
|
var ignoreParameters = new List<string>();
|
|
ignoreParameters.Add("refuseReason");
|
|
parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
|
|
string response = HttpClientUtils.PostAsync(api, api.Url, parameters);
|
|
|
|
//获取成功
|
|
if (Constant.IsSuccessful(response))
|
|
{
|
|
var data = JsonUtils.Deserialize<WeiXinEntityResponse<WeiXinOrderRefundRefuseResponse>>(response);
|
|
if (data.Status == 1)
|
|
{
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundRefuseResponse>>(true, data.Message, data);
|
|
}
|
|
else
|
|
{
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundRefuseResponse>>(false, data.ErrMessage, data);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errorMessage = PaserErrors(response);
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundRefuseResponse>>(false, errorMessage, null);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.Error(ex, "门店拒绝退款失败");
|
|
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundRefuseResponse>>(false, "门店拒绝退款失败,本次操作无效", null);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 门店同意退款
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public static Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundAgreeResponse>> WeiXinOrderRefundAgree(WeiXinOrderRefundAgreeRequest request)
|
|
{
|
|
Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundAgreeResponse>> result = null;
|
|
|
|
try
|
|
{
|
|
OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
|
|
SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);
|
|
|
|
parameters.Add("method", "wxdc.order.refund.store.agree");
|
|
parameters.Add("erpStoreId", request.StoreId);
|
|
parameters.Add("ticketId", request.TicketId);
|
|
|
|
parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters));
|
|
string response = HttpClientUtils.PostAsync(api, api.Url, parameters);
|
|
|
|
//获取成功
|
|
if (Constant.IsSuccessful(response))
|
|
{
|
|
var data = JsonUtils.Deserialize<WeiXinEntityResponse<WeiXinOrderRefundAgreeResponse>>(response);
|
|
if (data.Status == 1)
|
|
{
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundAgreeResponse>>(true, data.Message, data);
|
|
}
|
|
else
|
|
{
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundAgreeResponse>>(false, data.ErrMessage, data);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errorMessage = PaserErrors(response);
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundAgreeResponse>>(false, errorMessage, null);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.Error(ex, "门店同意退款失败");
|
|
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundAgreeResponse>>(false, "门店同意退款失败,本次操作无效", null);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 门店营业状态修改
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public static Tuple<bool, string, WeiXinEntityResponse<WeiXinShopOpenResponse>> WeiXinShopOpen(WeiXinShopOpenRequest request)
|
|
{
|
|
Tuple<bool, string, WeiXinEntityResponse<WeiXinShopOpenResponse>> result = null;
|
|
|
|
try
|
|
{
|
|
OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
|
|
SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);
|
|
|
|
parameters.Add("method", "wxdc.store.open.status.update");
|
|
parameters.Add("erpStoreId", request.StoreId);
|
|
parameters.Add("openStatus", string.Format("{0}", request.OpenStatus));
|
|
|
|
parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters));
|
|
string response = HttpClientUtils.PostAsync(api, api.Url, parameters);
|
|
|
|
//获取成功
|
|
if (Constant.IsSuccessful(response))
|
|
{
|
|
var data = JsonUtils.Deserialize<WeiXinEntityResponse<WeiXinShopOpenResponse>>(response);
|
|
if (data.Status == 1)
|
|
{
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinShopOpenResponse>>(true, data.Message, data);
|
|
}
|
|
else
|
|
{
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinShopOpenResponse>>(false, data.ErrMessage, data);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errorMessage = PaserErrors(response);
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinShopOpenResponse>>(false, errorMessage, null);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.Error(ex, "门店营业状态变更异常");
|
|
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinShopOpenResponse>>(false, "门店营业状态变更异常,本次操作无效", null);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 门店信息
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public static Tuple<bool, string, WeiXinEntityResponse<WeiXinShopInfoResponse>> WeiXinShopInfo(WeiXinShopInfoRequest request)
|
|
{
|
|
Tuple<bool, string, WeiXinEntityResponse<WeiXinShopInfoResponse>> result = null;
|
|
|
|
try
|
|
{
|
|
OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
|
|
SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);
|
|
|
|
parameters.Add("method", "wxdc.store.info");
|
|
parameters.Add("erpStoreId", request.StoreId);
|
|
|
|
parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters));
|
|
string response = HttpClientUtils.PostAsync(api, api.Url, parameters);
|
|
|
|
//获取成功
|
|
if (Constant.IsSuccessful(response))
|
|
{
|
|
var data = JsonUtils.Deserialize<WeiXinEntityResponse<WeiXinShopInfoResponse>>(response);
|
|
if (data.Status == 1)
|
|
{
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinShopInfoResponse>>(true, data.Message, data);
|
|
}
|
|
else
|
|
{
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinShopInfoResponse>>(false, data.ErrMessage, data);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errorMessage = PaserErrors(response);
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinShopInfoResponse>>(false, errorMessage, null);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.Error(ex, "门店信息获取异常");
|
|
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinShopInfoResponse>>(false, "门店信息获取异常,本次操作无效", null);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 微信订单拒单
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public static Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderCancelResponse>> WeiXinOrderCancel(WeiXinOrderCancelRequest request)
|
|
{
|
|
Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderCancelResponse>> result = null;
|
|
|
|
try
|
|
{
|
|
OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
|
|
SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);
|
|
|
|
parameters.Add("method", "wxdc.store.order.cancel");
|
|
parameters.Add("erpStoreId", request.StoreId);
|
|
parameters.Add("ticketId", request.TicketId);
|
|
parameters.Add("cancelReason", request.CancelReason);
|
|
|
|
var ignoreParameters = new List<string>();
|
|
ignoreParameters.Add("cancelReason");
|
|
parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
|
|
string response = HttpClientUtils.PostAsync(api, api.Url, parameters);
|
|
|
|
//获取成功
|
|
if (Constant.IsSuccessful(response))
|
|
{
|
|
var data = JsonUtils.Deserialize<WeiXinEntityResponse<WeiXinOrderCancelResponse>>(response);
|
|
if (data.Status == 1)
|
|
{
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderCancelResponse>>(true, data.Message, data);
|
|
}
|
|
else
|
|
{
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderCancelResponse>>(false, data.ErrMessage, data);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errorMessage = PaserErrors(response);
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderCancelResponse>>(false, errorMessage, null);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.Error(ex, "微信订单取消异常");
|
|
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderCancelResponse>>(false, "微信订单取消异常,本次操作无效", null);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 微信订单接单
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public static Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderConfirmResponse>> WeiXinOrderConfirm(WeiXinOrderConfirmRequest request)
|
|
{
|
|
Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderConfirmResponse>> result = null;
|
|
|
|
try
|
|
{
|
|
OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
|
|
SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);
|
|
|
|
parameters.Add("method", "wxdc.store.order.confirm");
|
|
parameters.Add("erpStoreId", request.StoreId);
|
|
parameters.Add("ticketId", request.TicketId);
|
|
|
|
parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters));
|
|
string response = HttpClientUtils.PostAsync(api, api.Url, parameters);
|
|
|
|
//获取成功
|
|
if (Constant.IsSuccessful(response))
|
|
{
|
|
var data = JsonUtils.Deserialize<WeiXinEntityResponse<WeiXinOrderConfirmResponse>>(response);
|
|
if (data.Status == 1)
|
|
{
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderConfirmResponse>>(true, data.Message, data);
|
|
}
|
|
else
|
|
{
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderConfirmResponse>>(false, data.ErrMessage, data);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errorMessage = PaserErrors(response);
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderConfirmResponse>>(false, errorMessage, null);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.Error(ex, "微信订单接单异常");
|
|
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderConfirmResponse>>(false, "微信订单接单异常,本次操作无效", null);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 微信订单信息
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public static Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderResponse>> WeiXinOrder(WeiXinOrderRequest request)
|
|
{
|
|
Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderResponse>> result = null;
|
|
|
|
try
|
|
{
|
|
OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
|
|
SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);
|
|
|
|
parameters.Add("method", "wxdc.sales.order.info");
|
|
parameters.Add("erpStoreId", request.StoreId);
|
|
parameters.Add("ticketId", request.TicketId);
|
|
parameters.Add("memberId", request.MemberId);
|
|
|
|
parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters));
|
|
string response = HttpClientUtils.PostAsync(api, api.Url, parameters);
|
|
|
|
//获取成功
|
|
if (Constant.IsSuccessful(response))
|
|
{
|
|
var data = JsonUtils.Deserialize<WeiXinEntityResponse<WeiXinOrderResponse>>(response);
|
|
if (data.Status == 1)
|
|
{
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderResponse>>(true, data.Message, data);
|
|
}
|
|
else
|
|
{
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderResponse>>(false, data.ErrMessage, data);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errorMessage = PaserErrors(response);
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderResponse>>(false, errorMessage, null);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.Error(ex, "微信订单查询异常");
|
|
|
|
result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderResponse>>(false, "微信订单询异常,本次操作无效", null);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 微信历史列表查询
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public static Tuple<bool, string, WeiXinPagerResponse<WeiXinOrderListResponse>> QueryWeiXinOrder(WeiXinOrderListRequest request)
|
|
{
|
|
Tuple<bool, string, WeiXinPagerResponse<WeiXinOrderListResponse>> result = null;
|
|
|
|
try
|
|
{
|
|
OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
|
|
SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);
|
|
|
|
parameters.Add("method", "wxdc.store.order.list");
|
|
|
|
parameters.Add("erpStoreId", request.StoreId);
|
|
if (request.Status!=-1) {
|
|
parameters.Add("status", string.Format("{0}", request.Status));
|
|
}
|
|
parameters.Add("startDate", request.StartDate);
|
|
parameters.Add("endDate", request.EndDate);
|
|
parameters.Add("orderField", request.OrderField);
|
|
parameters.Add("orderType", request.OrderType);
|
|
parameters.Add("pageNumber", string.Format("{0}", request.PageNumber));
|
|
parameters.Add("pageSize", string.Format("{0}", request.PageSize));
|
|
|
|
|
|
var ignoreParameters = new List<string>();
|
|
ignoreParameters.Add("pageNumber");
|
|
ignoreParameters.Add("pageSize");
|
|
parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
|
|
string response = HttpClientUtils.PostAsync(api, api.Url, parameters);
|
|
|
|
//获取成功
|
|
if (Constant.IsSuccessful(response))
|
|
{
|
|
var data = JsonUtils.Deserialize<WeiXinPagerResponse<WeiXinOrderListResponse>>(response);
|
|
if (data.Status == 1)
|
|
{
|
|
result = new Tuple<bool, string, WeiXinPagerResponse<WeiXinOrderListResponse>>(true, data.Message, data);
|
|
}
|
|
else
|
|
{
|
|
result = new Tuple<bool, string, WeiXinPagerResponse<WeiXinOrderListResponse>>(false, data.ErrMessage, data);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errorMessage = PaserErrors(response);
|
|
result = new Tuple<bool, string, WeiXinPagerResponse<WeiXinOrderListResponse>>(false, errorMessage, null);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.Error(ex, "微信订单查询异常");
|
|
|
|
result = new Tuple<bool, string, WeiXinPagerResponse<WeiXinOrderListResponse>>(false, "微信订单询异常,本次操作无效", null);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
protected static string PaserErrors(string response)
|
|
{
|
|
string result = string.Empty;
|
|
try
|
|
{
|
|
logger.Error(response);
|
|
|
|
Errors mainError = JsonUtils.Deserialize<Errors>(response);
|
|
if (_errorDesc.ContainsKey(mainError.Code))
|
|
{
|
|
result = _errorDesc[mainError.Code];
|
|
}
|
|
else
|
|
{
|
|
result = mainError.Message;
|
|
}
|
|
|
|
List<SubErrors> subError = mainError.SubErrors;
|
|
if (subError != null && subError.Count > 0)
|
|
{
|
|
SubErrors error = subError[0];
|
|
if (_errorDesc.ContainsKey(error.Code))
|
|
{
|
|
result = _errorDesc[error.Code];
|
|
}
|
|
else
|
|
{
|
|
result = error.Message;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.Error(ex , "非法的错误信息格式");
|
|
|
|
result = _errorDesc["9999"];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|
|
}
|