Commit 4f11ca23 authored by liudong1993's avatar liudong1993

1

parent 5aa994d1
......@@ -187,5 +187,20 @@ namespace Mall.Model.Entity.Product
get;
set;
}
/// <summary>
/// 汇付天下支付ID 退费要使用
/// </summary>
public string Adapay_Id { get; set; }
/// <summary>
/// 汇付天下 应用AppID
/// </summary>
public string App_Id { get; set; }
/// <summary>
/// 手续费金额
/// </summary>
public decimal Fee_Amt { get; set; }
}
}
using System;
using System.Collections.Generic;
using System.Text;
using VT.FW.DB;
namespace Mall.Model.Extend.Education
{
/// <summary>
/// 汇付天下配置扩展类
/// </summary>
public class RB_Trade_Config
{
/// <summary>
/// Id
/// </summary>
public int Id { get; set; }
/// <summary>
/// 类型 1汇付天下
/// </summary>
public int Type { get; set; }
/// <summary>
/// 商户名称
/// </summary>
public string Name { get; set; }
/// <summary>
/// 平台appid
/// </summary>
public string AppId { get; set; }
/// <summary>
/// 平台Apikey
/// </summary>
public string ApiKey { get; set; }
/// <summary>
/// 平台ApiMockKey
/// </summary>
public string ApiMockKey { get; set; }
/// <summary>
/// 平台私钥
/// </summary>
public string PrivateKey { get; set; }
/// <summary>
/// 删除状态
/// </summary>
public int Status { get; set; }
/// <summary>
/// 集团ID
/// </summary>
public int GroupId { get; set; }
/// <summary>
/// 使用的校区
/// </summary>
public int SchoolId { get; set; }
/// <summary>
/// 创建人
/// </summary>
public int CreateBy { get; set; }
/// <summary>
/// 创建时间
/// </summary>
public DateTime CreateTime { get; set; }
/// <summary>
/// 修改人
/// </summary>
public int UpdateBy { get; set; }
/// <summary>
/// 修改时间
/// </summary>
public DateTime UpdateTime { get; set; }
}
}
......@@ -21,6 +21,8 @@ using Mall.Repository.BaseSetUp;
using Mall.Repository.Coffee;
using Mall.Common.Enum.User;
using Mall.Repository.Education;
using Mall.ThirdCore.Adapay.Model;
using Newtonsoft.Json.Linq;
namespace Mall.Module.User
{
......@@ -2498,5 +2500,147 @@ namespace Mall.Module.User
}
}
#endregion
#region 汇付天下支付
/// <summary>
/// 获取订单信息
/// </summary>
/// <param name="orderId"></param>
/// <param name="mallBaseId"></param>
/// <returns></returns>
public RB_Goods_Order_Extend GetAdapayOrderInfo(int orderId, int mallBaseId) {
var orderModel = goods_OrderRepository.GetEntity<RB_Goods_Order_Extend>(orderId);
if (orderModel != null)
{
orderModel.DetailList = goodsOrderDetailRepository.GetOrderDetailList(new RB_Goods_OrderDetail_Extend() { MallBaseId = mallBaseId, OrderId = orderModel.OrderId });
}
return orderModel;
}
/// <summary>
/// 回调更新支付
/// </summary>
/// <param name="payModel"></param>
public bool InsertAdapayOrderTrade(AdaPayResultModel payModel)
{
int MallbaseId = 0, OrderId = 0;
if (string.IsNullOrEmpty(payModel.description))
{
LogHelper.WriteInfo("InsertOrderTrade回调空值:" + JsonHelper.Serialize(payModel));
}
else
{
//拆分重要信息
string[] parms = payModel.description.Split('|');
MallbaseId = Convert.ToInt32(parms[0]);//集团Id
OrderId = Convert.ToInt32(parms[1]);//报价单ID
}
if (OrderId <= 0) { return false; }
string OpenId = "";
if (payModel.expend != null && !string.IsNullOrEmpty(payModel.expend.ToString()))
{
if (payModel.pay_channel.Contains("alipay"))
{
OpenId = JObject.Parse(payModel.expend.ToString()).GetStringValue("sub_open_id");
}
else if (payModel.pay_channel.Contains("wx"))
{
OpenId = JObject.Parse(payModel.expend.ToString()).GetStringValue("open_id");
}
}
//判断订单状态是否是待支付 2020-06-16 Add By:W
var oldOrder = goods_OrderRepository.GetEntity(OrderId);
if (oldOrder == null)
{
return false;
}
if (oldOrder.MallBaseId != MallbaseId) { return false; }
if (oldOrder.OrderStatus != Common.Enum.Goods.OrderStatusEnum.NonPayment)
{
return false;
}
//if (oldOrder.Income != payModel.pay_amt)
//{
// return false;
//}
var umodel = member_UserRepository.GetEntity(oldOrder.UserId);
if (umodel == null)
{
return false;
}
//获取订单商品
var orderGoodsList = goodsOrderDetailRepository.GetOrderDetailList(new RB_Goods_OrderDetail_Extend { TenantId = oldOrder.TenantId, MallBaseId = oldOrder.MallBaseId, OrderId = oldOrder.OrderId });
bool flag = goods_Online_TradeRepository.Insert(new Model.Entity.Product.RB_Goods_Online_Trade()
{
Id = 0,
User_Id = oldOrder.UserId,
FinanceId = 0,
CreateDate = DateTime.Now,
IsRefund = 2,
MallBaseId = oldOrder.MallBaseId,
Money = payModel.pay_amt,
OrderId = OrderId,
Out_Trade_No = payModel.order_no,
PayType = payModel.pay_channel,//存支付渠道
PayWay = payModel.pay_channel.Contains("alipay") ? Common.Enum.Goods.OrderPayTypeEnum.Alipay : Common.Enum.Goods.OrderPayTypeEnum.WeChatPay,
Pay_Date = DateTime.Now,
Pay_Result = 0,
RefundMoney = 0,
RefundStatus = 0,
RefundTrade_Order = OpenId,//这个存openId
Remarks = (payModel.expend != null ? payModel.expend.ToString() : "") + " and " + payModel.description, //这个存扩展参数
TenantId = oldOrder.TenantId,
Transaction_Id = payModel.out_trans_id,
Type = 1,
Adapay_Id = payModel.id,
App_Id = payModel.app_id,
Fee_Amt = payModel.fee_amt
}) > 0;
if (flag) {
//更新订单信息
Dictionary<string, object> keyValues = new Dictionary<string, object>() {
{ nameof(RB_Goods_Order_Extend.MerchantsNo),payModel.out_trans_id},
{ nameof(RB_Goods_Order_Extend.PaymentTime),DateTime.Now},
{ nameof(RB_Goods_Order_Extend.PaymentWay),Common.Enum.Goods.OrderPaymentTypeEnum.OnlinePayment},
{ nameof(RB_Goods_Order_Extend.OrderStatus), Common.Enum.Goods.OrderStatusEnum.Completed}
};
List<WhereHelper> wheres = new List<WhereHelper>() {
new WhereHelper(){
FiledName=nameof(RB_Goods_Order_Extend.OrderId),
FiledValue=OrderId,
OperatorEnum=OperatorEnum.Equal
}
};
goods_OrderRepository.Update(keyValues, wheres);
//发送订阅消息
string goodsName = orderGoodsList.FirstOrDefault().GoodsName;
if (orderGoodsList.Count > 1)
{
if (goodsName.Length > 6)
{
goodsName = goodsName.Substring(0, 6);
}
goodsName += "等" + orderGoodsList.Count + "件";
}
else
{
if (goodsName.Length > 10)
{
goodsName = goodsName.Substring(0, 10);
}
}
appletWeChatModule.SendOrderSucceedMsg(oldOrder.TenantId, oldOrder.MallBaseId, umodel.OpenId, oldOrder.OrderNo, oldOrder.CreateDate.Value.ToString("yyyy-MM-dd HH:mm:ss"), (oldOrder.Income ?? 0).ToString(), goodsName);
}
return flag;
}
#endregion
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Mall.Model.Entity.Education;
using Mall.Model.Extend.Education;
using VT.FW.DB.Dapper;
namespace Mall.Repository.Education
{
/// <summary>
/// 汇付天下配置仓储层
/// </summary>
public class RB_Trade_ConfigRepository : BaseRepository<Model.Entity.User.RB_Member_User>
{
/// <summary>
/// 获取列表
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public List<RB_Trade_Config> GetList(RB_Trade_Config query)
{
StringBuilder builder = new StringBuilder();
builder.AppendFormat(@"
SELECT *
FROM RB_Trade_Config
WHERE 1=1
");
if (query != null)
{
if (query.GroupId > 0)
{
builder.AppendFormat(" AND {0}={1} ", nameof(RB_Trade_Config.GroupId), query.GroupId);
}
if (query.Type > 0)
{
builder.AppendFormat(" AND {0}={1} ", nameof(RB_Trade_Config.Type), query.Type);
}
}
return Get<RB_Trade_Config>(builder.ToString()).ToList();
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
using System.IO;
namespace AdapayCore
{
public class CoreUtils
{
public static bool debug = false;
public static string sdk_version = "C#v1.2.0";
public static string BASE_URL = "https://api.adapay.tech";
public static string RSA_PUB_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCwN6xgd6Ad8v2hIIsQVnbt8a3JituR8o4Tc3B5WlcFR55bz4OMqrG/356Ur3cPbc2Fe8ArNd/0gZbC9q56Eb16JTkVNA/fye4SXznWxdyBPR7+guuJZHc/VW2fKH2lfZ2P3Tt0QkKZZoawYOGSMdIvO+WqK44updyax0ikK6JlNQIDAQAB";
public static string GetMD5Hash(string str)
{
//就是比string往后一直加要好的优化容器
StringBuilder sb = new StringBuilder();
using (MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider())
{
//将输入字符串转换为字节数组并计算哈希。
byte[] data = md5.ComputeHash(Encoding.UTF8.GetBytes(str));
int length = data.Length;
for (int i = 0; i < length; i++)
sb.Append(data[i].ToString("X2"));
}
return sb.ToString();
}
public static byte[] File2Bytes(string FilePath)
{
if (!System.IO.File.Exists(FilePath))
{
return new byte[0];
}
FileStream fs = new FileStream(FilePath, FileMode.Open, FileAccess.Read);
byte[] buff = new byte[fs.Length];
fs.Read(buff, 0, Convert.ToInt32(fs.Length));
fs.Close();
return buff;
}
public static string getOrignalString(Dictionary<string, object> dict) {
Dictionary<string, object> params_SortedByKey = dict.OrderBy(p => p.Key).ToDictionary(p => p.Key, o => o.Value);
StringBuilder orinalStr = new StringBuilder("");
foreach (KeyValuePair<string, object> item in params_SortedByKey)
{
orinalStr.Append(item.Key)
.Append("=")
.Append(item.Value)
.Append("&");
}
if (orinalStr.Equals(""))
{
return "";
}
else {
orinalStr.Remove(orinalStr.Length - 1, 1);
}
return orinalStr.ToString();
}
public static void Log(string message)
{
if (CoreUtils.debug) {
Console.WriteLine(message);
}
}
}
}
using System;
namespace AdapayCore
{
public class MerConfig
{
public MerConfig()
{
}
//商户rsa 私钥
public string privateKey;
public string apiKey;
public string apiMockKey;
}
}
using System;
using Newtonsoft.Json;
using System.Net;
using System.Collections.Generic;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Security;
namespace AdapayCore
{
public class NetUtils
{
public const string POST = "post";
public const string GET = "get";
public static Dictionary<string, Object> requestAdapayWithURL(Dictionary<string, object> postParams, string filePath, string fileParam, string url, string method, string apiKey, string privateKey)
{
if (null == apiKey)
{
throw new Exception("apikey 不能为空");
}
if (null == privateKey)
{
throw new Exception("privateKey 不能为空");
}
string requireUrl = url;
HttpWebRequest request = null;
if (method.Equals(GET))
{
request = CreateGetRequest(postParams, requireUrl, apiKey, privateKey);
}
else if (null != filePath)
{
request = CreateUploadRequest(postParams, filePath, fileParam, requireUrl, apiKey, privateKey);
}
else
{
request = CreatePostRequest(postParams, requireUrl, apiKey, privateKey);
}
Dictionary<string, Object> responseJson = null;
string responseText = null;
string responseSign = null;
try
{
HttpWebResponse httpResponse = (HttpWebResponse)request.GetResponse();
using (StreamReader streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
responseText = streamReader.ReadToEnd();
Dictionary<string, object> response = (Dictionary<string, object>)JsonConvert.DeserializeObject<Dictionary<string, object>>(responseText);
string data = (string)response["data"];
CoreUtils.Log("response data....." + data);
responseSign = (string)response["signature"];
if (!verfySign(responseSign, data))
{
throw new Exception("public key veryfy singnature failed");
}
responseJson = JsonConvert.DeserializeObject<Dictionary<string, Object>>(data);
CoreUtils.Log("response:" + responseText);
}
}
catch (WebException e)
{
if (e.Response != null)
{
using (var errorResponse = (HttpWebResponse)e.Response)
{
using (var reader = new StreamReader(errorResponse.GetResponseStream()))
{
responseText = reader.ReadToEnd();
Dictionary<string, object> response = (Dictionary<string, object>)JsonConvert.DeserializeObject<Dictionary<string, object>>(responseText);
string data = (string)response["data"];
responseSign = (string)response["signature"];
if (!verfySign(responseSign, data))
{
throw new Exception("public key veryfy singnature failed");
}
responseJson = JsonConvert.DeserializeObject<Dictionary<string, Object>>(data);
CoreUtils.Log("error response:" + responseText);
}
}
}
}
return responseJson;
}
public static Dictionary<string, Object> requestAdapay(Dictionary<string, object> postParams, string filePath, string fileParam, string uri, string method, string apiKey, string privateKey)
{
return requestAdapayWithURL(postParams, filePath, fileParam, CoreUtils.BASE_URL + uri, method, apiKey, privateKey);
}
public static Dictionary<string, Object> requestAdapay(Dictionary<string, object> postParams, string uri, string method, string apiKey, string privateKey)
{
return requestAdapayWithURL(postParams, null, null, CoreUtils.BASE_URL + uri, method, apiKey, privateKey);
}
//设置get请求参数
// get post 以及post 上传文件的接口,url地址以及签名方式有差别
private static HttpWebRequest CreateGetRequest(Dictionary<string, object> postParams, string requireUrl, string apiKey, string privateKey)
{
string json_params = CoreUtils.getOrignalString(postParams);
string json_string = requireUrl + json_params;
//参数中会有中文,签名前需url encode
json_string = Uri.UnescapeDataString(json_string);
string signStr = signature(privateKey, json_string);
requireUrl = requireUrl + "?" + json_params;
CoreUtils.Log("requireUrl:" + requireUrl);
HttpWebRequest request = request = (HttpWebRequest)WebRequest.Create(requireUrl);
WebHeaderCollection header = request.Headers;
header.Set("Signature", signStr);
header.Set("Authorization", apiKey);
header.Set("SDK_version", CoreUtils.sdk_version);
CoreUtils.Log("apikey..." + apiKey);
CoreUtils.Log("SDK_version..." + CoreUtils.sdk_version);
request.Method = "get";
request.ContentType = "text/html;charset=UTF-8";
return request;
}
//设置不带文件的post请求参数
private static HttpWebRequest CreatePostRequest(Dictionary<string, object> postParams, string requireUrl, string apiKey, string privateKey)
{
string json_params = JsonConvert.SerializeObject(postParams, Formatting.None);
string json_string = requireUrl + json_params;
//参数中会有中文,签名前需url encode
json_string = Uri.UnescapeDataString(json_string);
string signStr = signature(privateKey, json_string);
HttpWebRequest request = request = (HttpWebRequest)WebRequest.Create(requireUrl);
WebHeaderCollection header = request.Headers;
header.Set("Signature", signStr);
header.Set("Authorization", apiKey);
header.Set("SDK_version", CoreUtils.sdk_version);
CoreUtils.Log("apikey..." + apiKey);
CoreUtils.Log("SDK_version..." + CoreUtils.sdk_version);
request.Method = "post";
request.ContentType = "application/json";
byte[] byteData = Encoding.UTF8.GetBytes(json_params);
int length = byteData.Length;
request.ContentLength = length;
Stream writer = request.GetRequestStream();
writer.Write(byteData, 0, length);
writer.Close();
return request;
}
//设置文件上传request
private static HttpWebRequest CreateUploadRequest(Dictionary<string, object> postParams, string filePath, string fileParam, string requireUrl, string apiKey, string privateKey)
{
HttpWebRequest request = request = (HttpWebRequest)WebRequest.Create(requireUrl);
string json_params = CoreUtils.getOrignalString(postParams);
string json_string = requireUrl + json_params;
//参数中会有中文,签名前需url encode
json_string = Uri.UnescapeDataString(json_string);
string signStr = signature(privateKey, json_string);
WebHeaderCollection header = request.Headers;
header.Set("Signature", signStr);
header.Set("Authorization", apiKey);
header.Set("SDK_version", CoreUtils.sdk_version);
CoreUtils.Log("apikey..." + apiKey);
CoreUtils.Log("SDK_version..." + CoreUtils.sdk_version);
request.Method = "post";
//文件信息
byte[] UpdateFile = CoreUtils.File2Bytes(filePath);//转换为二进制
if (UpdateFile.Length == 0)
{
throw new Exception("file content cannot be null");
}
string Boundary = "--WebKitFormBoundary39B5a5e2FWoGbphs";
//构造POST请求体
StringBuilder PostContent = new StringBuilder("");
//组成普通参数信息
foreach (KeyValuePair<string, object> item in postParams)
{
PostContent.Append("--" + Boundary + "\r\n")
.Append("Content-Disposition: form-data; name=\"" + item.Key + "\"" + "\r\n\r\n" + (string)item.Value + "\r\n");
}
byte[] PostContentByte = Encoding.UTF8.GetBytes(PostContent.ToString());
//文件信息
StringBuilder FileContent = new StringBuilder();
FileContent.Append("--" + Boundary + "\r\n")
.Append("Content-Disposition:form-data; name=\"" + fileParam + "\";filename=\"" + Path.GetFileName(filePath) + "\"" + "\r\n\r\n");
byte[] FileContentByte = Encoding.UTF8.GetBytes(FileContent.ToString());
request.ContentType = "multipart/form-data;boundary=" + Boundary;
byte[] ContentEnd = Encoding.UTF8.GetBytes("\r\n--" + Boundary + "--\r\n");//请求体末尾,后面会用到
//定义请求流
Stream myRequestStream = request.GetRequestStream();
myRequestStream.Write(PostContentByte, 0, PostContentByte.Length);//写入参数
myRequestStream.Write(FileContentByte, 0, FileContentByte.Length);//写入文件信息
myRequestStream.Write(UpdateFile, 0, UpdateFile.Length);//文件写入请求流中
myRequestStream.Write(ContentEnd, 0, ContentEnd.Length);//写入结尾
myRequestStream.Close();
return request;
}
private static string bytesToHexStr(byte[] byteArray)
{
StringBuilder sb = new StringBuilder();
foreach (byte b in byteArray)
{
sb.Append(b.ToString("X2"));
}
return sb.ToString();
}
private static string signature(string signaturePrivateKey, string signatureData)
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
var privateJavaKey = signaturePrivateKey;
var privateCSharpKey = RSAPrivateKeyJava2DotNet(privateJavaKey);
rsa.FromXmlString(privateCSharpKey);
byte[] signatureBytes = rsa.SignData(Encoding.UTF8.GetBytes(signatureData), "SHA1");
return Convert.ToBase64String(signatureBytes);
}
private static string RSAPrivateKeyJava2DotNet(string privateKey)
{
byte[] keyInfoByte = Convert.FromBase64String(privateKey);
RsaPrivateCrtKeyParameters privateKeyParam = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(keyInfoByte);
return string.Format("<RSAKeyValue><Modulus>{0}</Modulus><Exponent>{1}</Exponent><P>{2}</P><Q>{3}</Q><DP>{4}</DP><DQ>{5}</DQ><InverseQ>{6}</InverseQ><D>{7}</D></RSAKeyValue>",
Convert.ToBase64String(privateKeyParam.Modulus.ToByteArrayUnsigned()),
Convert.ToBase64String(privateKeyParam.PublicExponent.ToByteArrayUnsigned()),
Convert.ToBase64String(privateKeyParam.P.ToByteArrayUnsigned()),
Convert.ToBase64String(privateKeyParam.Q.ToByteArrayUnsigned()),
Convert.ToBase64String(privateKeyParam.DP.ToByteArrayUnsigned()),
Convert.ToBase64String(privateKeyParam.DQ.ToByteArrayUnsigned()),
Convert.ToBase64String(privateKeyParam.QInv.ToByteArrayUnsigned()),
Convert.ToBase64String(privateKeyParam.Exponent.ToByteArrayUnsigned()));
}
public static bool verfySign(string signature, string content, string hashAlgorithm = "SHA1", string encoding = "UTF-8")
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
//导入公钥,准备验证签名
rsa.FromPublicKeyJavaString(CoreUtils.RSA_PUB_KEY);
//返回数据验证结果
byte[] Data = Encoding.GetEncoding(encoding).GetBytes(content);
//过滤特殊字符即可
string dummyData = signature.Trim().Replace("%", "").Replace(",", "").Replace(" ", "+");
if (dummyData.Length % 4 > 0)
{
dummyData = dummyData.PadRight(dummyData.Length + 4 - dummyData.Length % 4, '=');
}
byte[] rgbSignature = Convert.FromBase64String(dummyData);
//byte[] rgbSignature = Encoding.GetEncoding(encoding).GetBytes(signature);
return rsa.VerifyData(Data, hashAlgorithm, rgbSignature);
}
private string decrypt(string key, string str)
{
if (string.IsNullOrEmpty(str)) return null;
Byte[] toEncryptArray = HexStringToByteArray(str);
RijndaelManaged rm = new RijndaelManaged
{
Key = HexStringToByteArray(key),
Mode = CipherMode.ECB,
Padding = PaddingMode.PKCS7
};
ICryptoTransform cTransform = rm.CreateDecryptor();
Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
return Encoding.UTF8.GetString(resultArray);
}
private static byte[] HexStringToByteArray(string s)
{
s = s.Replace(" ", "");
byte[] buffer = new byte[s.Length / 2];
for (int i = 0; i < s.Length; i += 2)
{
buffer[i / 2] = (byte)Convert.ToByte(s.Substring(i, 2), 16);
}
return buffer;
}
}
public static class RSAExtensions {
public static void FromPublicKeyJavaString(this RSA rsa, string publicJavaKey)
{
RsaKeyParameters publicKeyParam = (RsaKeyParameters)PublicKeyFactory.CreateKey(Convert.FromBase64String(publicJavaKey));
string xmlpublicKey = string.Format("<RSAKeyValue><Modulus>{0}</Modulus><Exponent>{1}</Exponent></RSAKeyValue>",
Convert.ToBase64String(publicKeyParam.Modulus.ToByteArrayUnsigned()),
Convert.ToBase64String(publicKeyParam.Exponent.ToByteArrayUnsigned()));
rsa.FromXmlString(xmlpublicKey);
}
}
}
using System;
using System.Collections.Generic;
namespace AdapaySDK
{
public class StringUtils
{
public static string tryGetNotNullValue(Dictionary<string, object> dict, string key) {
object value = null;
dict.TryGetValue(key, out value);
if (String.IsNullOrWhiteSpace((string)value))
{
throw new Exception(value + " cannot be empty");
}
return (string)value;
}
/// <summary>
/// 获取时间
/// </summary>
/// <returns></returns>
public static string timeStamp()
{
DateTime startTime = new DateTime(1970, 1, 1, 0, 0, 0, 0);
DateTime localNow = DateTime.Now;
long timeStamp = (long)((localNow - startTime).TotalMilliseconds);
return "" + timeStamp;
}
/// <summary>
/// 时间戳反转为时间,有很多中翻转方法,但是,请不要使用过字符串(string)进行操作,大家都知道字符串会很慢!
/// </summary>
/// <param name="TimeStamp">时间戳</param>
/// <param name="AccurateToMilliseconds">是否精确到毫秒</param>
/// <returns>返回一个日期时间</returns>
public static DateTime GetTime(long TimeStamp, bool AccurateToMilliseconds = false)
{
System.DateTime startTime = TimeZone.CurrentTimeZone.ToLocalTime(new System.DateTime(1970, 1, 1)); // 当地时区
if (AccurateToMilliseconds)
{
return startTime.AddTicks(TimeStamp * 10000);
}
else
{
return startTime.AddTicks(TimeStamp * 10000000);
}
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AdapaySDK
{
/**
* 账户对象
*/
public class Account
{
/**
* 账户对象支付
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 查询的支付撤销对象
*/
public static Dictionary<string, Object> payment(Dictionary<string, object> requestParams)
{
return AdapayRequest.requestAdapayPageServer(requestParams, APIUrlEnum.CREATE_ACCOUNT_PAYMENT, null);
}
/**
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
*/
public static Dictionary<string, Object> payment(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.requestAdapayPageServer(requestParams, APIUrlEnum.CREATE_ACCOUNT_PAYMENT, merchantKey);
}
}
}
using System;
using System.Collections.Generic;
using AdapayCore;
namespace AdapaySDK
{
public class Adapay
{
private const string sdk_version = "C#v1.4.1";
public static string deviceId="";
public static Dictionary<string, MerConfig> merchantConfigs;
public static bool isMock = false;
private static bool _debug = false;
public static bool debug {
set {
_debug = value;
CoreUtils.debug = value;
}
get {
if (!_debug) {
return false;
}
return _debug;
}
}
public static void initWithMerConfig(MerConfig config) {
initAdapayCore();
if (null != config)
{
merchantConfigs = new Dictionary<string, MerConfig>();
merchantConfigs.Add("default", config);
}
else {
throw new Exception("configs cannot be null");
}
}
public static void initWithMerConfigs(Dictionary<string, MerConfig> configs)
{
initAdapayCore();
if (null != configs)
{
merchantConfigs = configs;
}
else
{
throw new Exception("configs cannot be null");
}
}
private static void initAdapayCore (){
CoreUtils.BASE_URL = ConfigConstant.BASE_URL;
CoreUtils.RSA_PUB_KEY = ConfigConstant.RSA_PUB_KEY;
CoreUtils.sdk_version = sdk_version;
/**
MQTT_Config.MQTT_ACCESS_KEY = MQTT_Constant.MQTT_ACCESS_KEY;
MQTT_Config.MQTT_CLIENT_ID_PREFIX = MQTT_Constant.MQTT_CLIENT_ID_PREFIX;
MQTT_Config.MQTT_END_POINT = MQTT_Constant.MQTT_END_POINT;
MQTT_Config.MQTT_INSTANCE_ID = MQTT_Constant.MQTT_INSTANCE_ID;
MQTT_Config.MQTT_TOPIC_PREFIX = MQTT_Constant.MQTT_TOPIC_PREFIX;
**/
}
}
class AdapayRequest {
public static MerConfig fetchConfig(string merchantKey)
{
if (null == merchantKey)
{
merchantKey = "default";
}
if (null == Adapay.merchantConfigs)
{
throw new Exception("Please config merchant config info at first");
}
MerConfig config = null;
Adapay.merchantConfigs.TryGetValue(merchantKey, out config);
if (null == config)
{
throw new Exception("configInfo for merchantkey-" + merchantKey + "is not configed");
}
return config;
}
public static Dictionary<string, Object> requestAdapay(Dictionary<string, object> requestParams, string uri, string merchantKey) {
MerConfig config = fetchConfig(merchantKey);
string apikey = config.apiKey;
if (Adapay.isMock)
{
apikey = config.apiMockKey;
}
return NetUtils.requestAdapay(requestParams, null, null, uri, NetUtils.POST, apikey, config.privateKey);
}
public static Dictionary<string, Object> getRequestAdapay(Dictionary<string, object> requestParams, string uri, string merchantKey)
{
MerConfig config = fetchConfig(merchantKey);
string apikey = config.apiKey;
if (Adapay.isMock)
{
apikey = config.apiMockKey;
}
return NetUtils.requestAdapay(requestParams, null, null, uri, NetUtils.GET, apikey, config.privateKey);
}
public static Dictionary<string, Object> requestAdapay(Dictionary<string, object> requestParams, string filePath, string fileParam, string uri, string merchantKey)
{
MerConfig config = fetchConfig(merchantKey);
string apikey = config.apiKey;
if (Adapay.isMock)
{
apikey = config.apiMockKey;
}
return NetUtils.requestAdapay(requestParams, filePath, fileParam, uri, NetUtils.POST, apikey, config.privateKey);
}
public static Dictionary<string, Object> requestAdapayPageServer(Dictionary<string, object> requestParams, string uri, string merchantKey)
{
MerConfig config = fetchConfig(merchantKey);
string apikey = config.apiKey;
if (Adapay.isMock)
{
apikey = config.apiMockKey;
}
return NetUtils.requestAdapayWithURL(requestParams, null, null, ConfigConstant.PAGE_SERVER_BASE_URL + uri, NetUtils.POST, apikey, config.privateKey);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using AdapayCore;
namespace AdapaySDK
{
public class AdapayTools
{
/**
* 获取银联云闪付用户标识
*/
public static Dictionary<string, Object> unionUserId(Dictionary<string, Object> requestParams, string
merchantKey)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.UNION_USER_ID_V1, merchantKey);
}
/**
* 获取银联云闪付用户标识
*/
public static Dictionary<string, Object> unionUserId(Dictionary<string, Object> requestParams)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.UNION_USER_ID_V1, null);
}
/**
* download bill file
*/
public static Dictionary<string, Object> downloadBill(Dictionary<string, object> requestParams)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.BILL_DOWNLOAD_V1, null);
}
/**
* download bill file
*/
public static Dictionary<string, Object> downloadBill(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.BILL_DOWNLOAD_V1, merchantKey);
}
/**
* 校验返回签名
*
* @param signature 签名
* @param content 报文内容
* @return 校验结果
*/
public static bool verifySign(string signature, string content)
{
return NetUtils.verfySign(signature, content);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AdapaySDK
{
public class Checkout
{
/**
* 创建收银台对象
*
* @param requestParams 创建收银台对象 AdaPay api
* @return 收银台对象
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams)
{
return AdapayRequest.requestAdapayPageServer(requestParams, APIUrlEnum.CREATE_CHECK_OUT, null);
}
/**
* 创建收银台对象
*
* @param requestParams 创建收银台对象 AdaPay api
* @param merchantKey merchantKey
* @return 收银台对象
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.requestAdapayPageServer(requestParams, APIUrlEnum.CREATE_CHECK_OUT, merchantKey);
}
/**
* 查询收银台对象列表
*
* @param requestParams 查询收银台对象列表 AdaPay api
* @param merchantKey merchantKey
* @return 收银台对象
*/
public static Dictionary<string, Object> queryList(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.requestAdapayPageServer(requestParams, APIUrlEnum.LIST_CHECK_OUT, merchantKey);
}
/**
* 查询收银台对象列表
*
* @param requestParams 查询收银台对象列表 AdaPay api
* @return 收银台对象
*/
public static Dictionary<string, Object> queryList(Dictionary<string, object> requestParams)
{
return AdapayRequest.requestAdapayPageServer(requestParams, APIUrlEnum.LIST_CHECK_OUT, null);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace AdapaySDK
{
class ConfigConstant
{
public const string BASE_URL = "https://api.adapay.tech";
public const string PAGE_SERVER_BASE_URL = "https://page.adapay.tech";
public const string RSA_PUB_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCwN6xgd6Ad8v2hIIsQVnbt8a3JituR8o4Tc3B5WlcFR55bz4OMqrG/356Ur3cPbc2Fe8ArNd/0gZbC9q56Eb16JTkVNA/fye4SXznWxdyBPR7+guuJZHc/VW2fKH2lfZ2P3Tt0QkKZZoawYOGSMdIvO+WqK44updyax0ikK6JlNQIDAQAB";
}
class APIUrlEnum
{
// 支付对象(Payment)
/**
* 支付
*/
public const string PAYMENT_V1 = "/v1/payments";
/**
* 支付查询
*/
public const string QUERY_PAYMENT_V1 = "/v1/payments/";
/**
* 支付对象列表查询
*/
public const string LIST_PAYMENT_V1 = "/v1/payments/list";
/**
* 关单
*/
public const string CLOSE_PAYMENT_V1 = "/v1/payments/";
/**
* 快捷支付支付确认
*/
public const string FAST_PAY_CONFIRM = "/v1/fast_pay/confirm";
/**
* 快捷支付短信重发
*/
public const string FAST_PAY_SMS_CODE = "/v1/fast_pay/sms_code";
// 退款对象(Refund)
/**
* 退款
*/
public const string REFUND_V1 = "/v1/payments/";
/**
* 退款查询
*/
public const string QUERY_REFUND_V1 = "/v1/payments/refunds";
// 支付确认对象(PaymentConfirm)
/**
* 支付确认
*/
public const string CONFIRM_PAYMENT_V1 = "/v1/payments/confirm";
/**
* 支付确认查询
*/
public const string QUERY_CONFIRM_PAYMENT_V1 = "/v1/payments/confirm/";
/**
* 支付确认列表查询
*/
public const string CONFIRM_PAYMENT_LIST_V1 = "/v1/payments/confirm/list";
// 支付撤销对象(PaymentConfirm)
/**
* 支付撤销
*/
public const string REVERSE_PAYMENT_V1 = "/v1/payments/reverse";
/**
* 查询支付撤销
*/
public const string QUERY_REVERSE_PAYMENT_V1 = "/v1/payments/reverse/";
/**
* 支付撤销列表查询
*/
public const string REVERSE_PAYMENT_LIST_V1 = "/v1/payments/reverse/list";
// 个人用户(Member)
/**
* 创建用户
*/
public const string MEMBER_V1 = "/v1/members";
/**
* 查询用户对象
*/
public const string QUERY_MEMBER_V1 = "/v1/members/";
/**
* 查询用户列表
*/
public const string QUERY_MEMBER_LIST_V1 = "/v1/members/list";
/**
* 更新用户
*/
public const string UPDATE_MEMBER_V1 = "/v1/members/update";
// 企业用户(CorpMember)
/**
* 创建企业用户对象
*/
public const string CORP_MEMBER_V1 = "/v1/corp_members";
/**
* 查询企业用户对象
*/
public const string QUERY_CORP_MEMBER_V1 = "/v1/corp_members/";
// 结算账户(SettleAccount)
/**
* 创建结算账户
*/
public const string SETTLE_ACCOUNT_V1 = "/v1/settle_accounts";
/**
* 查询结算账户
*/
public const string QUERY_SETTLE_ACCOUNT_V1 = "/v1/settle_accounts/";
/**
* 删除结算账户
*/
public const string DELETE_SETTLE_ACCOUNT_V1 = "/v1/settle_accounts/delete";
/**
* 修改结算账户
*/
public const string MODIFY_SETTLE_ACCOUNT_V1 = "/v1/settle_accounts/modify";
/**
* 查询结算明细列表
*/
public const string QUERY_SETTLE_DETAILS_V1 = "/v1/settle_accounts/settle_details";
// 支付转账对象
/**
* 创建转账对象
*/
public const string CREATE_TRANSFER= "/v1/settle_accounts/transfer";
/**
* 查询转账对象列表
*/
public const string TRANSFER_LIST = "/v1/settle_accounts/transfer/list";
// 账户冻结对象
/**
* 创建账户冻结对象
*/
public const string FREEZE_ACCOUNT_CREATE = "/v1/settle_accounts/freeze";
/**
* 查询账户冻结对象列表
*/
public const string FREEZE_ACCOUNT_LIST = "/v1/settle_accounts/freeze/list";
// 账户解冻对象
/**
* 创建账户解冻对象
*/
public const string UN_FREEZE_ACCOUNT_CREATE = "/v1/settle_accounts/un_freeze";
/**
* 查询账户解冻对象列表
*/
public const string UN_FREEZE_ACCOUNT_LIST = "/v1/settle_accounts/unfreeze/list";
// 银行卡对象
/**
* 快捷支付绑卡创建
*/
public const string FAST_PAY_CARD_BIND = "/v1/fast_card/apply";
/**
* 快捷支付绑卡确认
*/
public const string FAST_PAY_CARD_BIND_CONFIRM = "/v1/fast_card/confirm";
/**
* 快捷支付绑卡列表查询
*/
public const string FAST_PAY_CARD_BIND_LIST = "/v1/fast_card/list";
// 钱包
/**
* 帐户取现创建
*/
public const string DRAW_CASH = "/v1/cashs";
/**
* 查询取现状态
*/
public const string QUERY_CASHS_STAT_V1 = "/v1/cashs/stat";
/**
* 查询帐户余额
*/
public const string QUERY_BALANCE = "/v1/settle_accounts/balance";
/**
* 钱包用户登录
*/
public const string WALLET_LOGIN = "/v1/walletLogin";
/**
* 钱包账户支付
*/
public const string CREATE_ACCOUNT_PAYMENT = "/v1/account/payment";
/**
* 创建收银台对象
*/
public const string CREATE_CHECK_OUT = "/v1/checkout";
/**
* 查询收银台对象列表
*/
public const string LIST_CHECK_OUT = "/v1/checkout/list";
/**
* DOWNLOAD BILL
*/
public const string BILL_DOWNLOAD_V1 = "/v1/bill/download";
/**
* 获取银联云闪付用户标识
*/
public const string UNION_USER_ID_V1 = "/v1/union/user_identity";
/**
* 创建服务商分账对象
*/
public const string COMMISSIONS_SETTLE = "/v1/settle_accounts/commissions";
/**
* 服务商分账对象列表
*/
public const string LIST_COMMISSIONS_SETTLE = "/v1/settle_accounts/commissions/list";
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AdapaySDK
{
public class CorpMember
{
/**
* 创建企业用户对象
*
* @param params 创建企业用户对象的请求参数,参见 AdaPay api
* @param params 创建企业用户对象的附件文件参数,参见 AdaPay api
* @param merchantKey merchantKey
* @return 创建用户对象
* @ 异常
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams, string filePath, string merchantKey)
{
return AdapayRequest.requestAdapay(requestParams, filePath, "attach_file", APIUrlEnum.CORP_MEMBER_V1, merchantKey);
}
/**
* 查询企业用户对象
*
* @param params 查询企业用户对象的请求参数,参见 AdaPay api
* @return 查询的企业用户对象
* @ 异常
*/
public static Dictionary<string, Object> query(Dictionary<string, object> requestParams, string merchantKey)
{
string memberId = StringUtils.tryGetNotNullValue(requestParams, "member_id");
string uri = new StringBuilder(APIUrlEnum.QUERY_CORP_MEMBER_V1).Append(memberId).ToString();
return AdapayRequest.getRequestAdapay(requestParams, uri, merchantKey);
}
/**
* 创建企业用户对象
*
* @param params 创建企业用户对象的请求参数,参见 AdaPay api
* @param params 创建企业用户对象的附件文件参数,参见 AdaPay api
* @param merchantKey merchantKey
* @return 创建用户对象
* @ 异常
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams, string filePath)
{
return AdapayRequest.requestAdapay(requestParams, filePath, "attach_file", APIUrlEnum.CORP_MEMBER_V1, null);
}
/**
* 查询企业用户对象
*
* @param params 查询企业用户对象的请求参数,参见 AdaPay api
* @return 查询的企业用户对象
* @ 异常
*/
public static Dictionary<string, Object> query(Dictionary<string, object> requestParams)
{
string memberId = StringUtils.tryGetNotNullValue(requestParams, "member_id");
string uri = new StringBuilder(APIUrlEnum.QUERY_CORP_MEMBER_V1).Append(memberId).ToString();
return AdapayRequest.getRequestAdapay(requestParams, uri, null);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AdapaySDK
{
public class Drawcash
{
/**
* 创建取现对象
*
* @param params 创建取现对象的请求参数,参见 AdaPay api
* @return 取现对象
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.DRAW_CASH, null);
}
/**
* 创建取现对象
*
* @param params 创建取现对象的请求参数,参见 AdaPay api
* @return 取现对象
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.DRAW_CASH, merchantKey);
}
/**
* 查询取现状态
*
* @param params 查询取现状态,参见 AdaPay api
* @return 取现状态
*/
public static Dictionary<string, Object> query(Dictionary<string, object> requestParams)
{
return AdapayRequest.getRequestAdapay(requestParams, APIUrlEnum.QUERY_CASHS_STAT_V1, null);
}
/**
* 查询取现状态
*
* @param params 查询取现状态,参见 AdaPay api
* @return 取现状态
*/
public static Dictionary<string, Object> query(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.getRequestAdapay(requestParams, APIUrlEnum.QUERY_CASHS_STAT_V1, merchantKey);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AdapaySDK
{
public class FastPay
{
/**
* 创建快捷支付绑卡对象
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 快捷支付绑卡
*/
public static Dictionary<string, Object> cardBind(Dictionary<string, object> requestParams)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.FAST_PAY_CARD_BIND, null);
}
/**
* 创建快捷支付绑卡确认
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 快捷支付绑卡确认
*/
public static Dictionary<string, Object> cardBindConfirm(Dictionary<string, object> requestParams)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.FAST_PAY_CARD_BIND_CONFIRM, null);
}
/**
* 查询快捷支付绑卡对象列表
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 快捷支付绑卡
*/
public static Dictionary<string, Object> cardBindList(Dictionary<string, object> requestParams)
{
return AdapayRequest.getRequestAdapay(requestParams, APIUrlEnum.FAST_PAY_CARD_BIND_LIST, null);
}
/**
* 创建快捷支付确认
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 快捷支付确认
*/
public static Dictionary<string, Object> confirm(Dictionary<string, object> requestParams)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.FAST_PAY_CONFIRM, null);
}
/**
* 快捷支付短信重发
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 快捷支付短信重发
*/
public static Dictionary<string, Object> smsCode(Dictionary<string, object> requestParams)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.FAST_PAY_SMS_CODE, null);
}
/**
* 创建快捷支付绑卡对象
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 快捷支付绑卡
*/
public static Dictionary<string, Object> cardBind(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.FAST_PAY_CARD_BIND, merchantKey);
}
/**
* 创建快捷支付绑卡确认
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 快捷支付绑卡确认
*/
public static Dictionary<string, Object> cardBindConfirm(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.FAST_PAY_CARD_BIND_CONFIRM, merchantKey);
}
/**
* 查询快捷支付绑卡对象列表
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 快捷支付绑卡
*/
public static Dictionary<string, Object> cardBindList(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.getRequestAdapay(requestParams, APIUrlEnum.FAST_PAY_CARD_BIND_LIST, merchantKey);
}
/**
* 创建快捷支付确认
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 快捷支付确认
*/
public static Dictionary<string, Object> confirm(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.FAST_PAY_CONFIRM, merchantKey);
}
/**
* 快捷支付短信重发
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 快捷支付短信重发
*/
public static Dictionary<string, Object> smsCode(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.FAST_PAY_SMS_CODE, merchantKey);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AdapaySDK
{
public class FreezeAccount
{
/**
* 创建账户冻结对象
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 账户冻结对象
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.FREEZE_ACCOUNT_CREATE, null);
}
/**
* 创建账户冻结对象
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 账户冻结对象
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.FREEZE_ACCOUNT_CREATE, merchantKey);
}
/**
* 查询账户冻结对象列表
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 账户冻结对象
*/
public static Dictionary<string, Object> queryList(Dictionary<string, object> requestParams)
{
return AdapayRequest.getRequestAdapay(requestParams, APIUrlEnum.FREEZE_ACCOUNT_LIST, null);
}
/**
* 查询账户冻结对象列表
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 账户冻结对象
*/
public static Dictionary<string, Object> queryList(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.getRequestAdapay(requestParams, APIUrlEnum.FREEZE_ACCOUNT_LIST, merchantKey);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace AdapaySDK
{
public class Member
{
/**
* 创建用户对象
*
* @param requestParams 创建用户对象的请求参数,参见 AdaPay api
* @param merchantKey merchantKey
* @return 创建用户对象
* @ 异常
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.MEMBER_V1, merchantKey);
}
/**
* 查询用户对象
*
* @param requestParams 查询用户对象的请求参数,参见 AdaPay api
* @param merchantKey merchantKey
* @return 查询的用户对象
* @ 异常
*/
public static Dictionary<string, Object> query(Dictionary<string, object> requestParams, string merchantKey)
{
string memberId = StringUtils.tryGetNotNullValue(requestParams,"member_id");
string uri = new StringBuilder(APIUrlEnum.QUERY_MEMBER_V1).Append(memberId).ToString();
return AdapayRequest.getRequestAdapay(requestParams, uri, merchantKey);
}
/**
* 查询用户列表
*
* @param requestParams 查询用户列表的请求参数,参见 AdaPay api
* @param merchantKey merchantKey
* @return 查询的用户列表
* @ 异常
*/
public static Dictionary<string, Object> queryList(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.getRequestAdapay(requestParams, APIUrlEnum.QUERY_MEMBER_LIST_V1, merchantKey);
}
/**
* 更新用户对象
*
* @param requestParams 更新用户对象的请求参数,参见 AdaPay api
* @param merchantKey merchantKey
* @return 更新后的用户对象
* @ 异常
*/
public static Dictionary<string, Object> update(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.UPDATE_MEMBER_V1, merchantKey);
}
/**
* 创建用户对象
*
* @param requestParams 创建用户对象的请求参数,参见 AdaPay api
* @return 创建用户对象
* @ 异常
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.MEMBER_V1, null);
}
/**
* 查询用户对象
*
* @param requestParams 查询用户对象的请求参数,参见 AdaPay api
* @return 查询的用户对象
* @ 异常
*/
public static Dictionary<string, Object> query(Dictionary<string, object> requestParams)
{
string memberId = StringUtils.tryGetNotNullValue(requestParams, "member_id");
string uri = new StringBuilder(APIUrlEnum.QUERY_MEMBER_V1).Append(memberId).ToString();
return AdapayRequest.getRequestAdapay(requestParams, uri, null);
}
/**
* 查询用户列表
*
* @param requestParams 查询用户列表的请求参数,参见 AdaPay api
* @return 查询的用户列表
* @ 异常
*/
public static Dictionary<string, Object> queryList(Dictionary<string, object> requestParams)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.QUERY_MEMBER_LIST_V1, null);
}
/**
* 更新用户对象
*
* @param requestParams 更新用户对象的请求参数,参见 AdaPay api
* @return 更新后的用户对象
* @ 异常
*/
public static Dictionary<string, Object> update(Dictionary<string, object> requestParams)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.UPDATE_MEMBER_V1, null);
}
}
}
using System;
using System.Collections.Generic;
using AdapayCore;
using System.Text;
namespace AdapaySDK
{
public class Payment
{
/**
* 创建一个支付交易
*
* @param requestParams 创建支付的请求参数,参见 AdaPay api
* @param merchantKey merchantKey
* @return 创建的支付对象
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams, string merchantKey)
{
object currency = null;
requestParams.TryGetValue("currency", out currency);
if (currency == null) {
requestParams.Add("currency", "cny");
}
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.PAYMENT_V1, merchantKey);
}
/**
* create Payment
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams)
{
object currency = null;
requestParams.TryGetValue("currency", out currency);
if (currency == null)
{
requestParams.Add("currency", "cny");
}
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.PAYMENT_V1, null);
}
/**
* 关闭一个支付
*
* @param requestParams 要关闭的支付id
* @param merchantKey merchantKey
* @return 关闭的支付对象
*/
public static Dictionary<string, Object> close(Dictionary<string, object> requestParams, string merchantKey)
{
string paymentId = StringUtils.tryGetNotNullValue(requestParams, "payment_id");
string uri = new StringBuilder(APIUrlEnum.CLOSE_PAYMENT_V1).Append(paymentId).Append("/close").ToString();
//requestParams.Remove("payment_id");
return AdapayRequest.requestAdapay(requestParams, uri, merchantKey);
}
/**
* 关闭一个支付
*
* @param requestParams 要关闭的支付id
* @param merchantKey merchantKey
* @return 关闭的支付对象
*/
public static Dictionary<string, Object> close(Dictionary<string, object> requestParams)
{
string paymentId = StringUtils.tryGetNotNullValue(requestParams, "payment_id");
string uri = new StringBuilder(APIUrlEnum.CLOSE_PAYMENT_V1).Append(paymentId).Append("/close").ToString();
//requestParams.Remove("payment_id");
return AdapayRequest.requestAdapay(requestParams, uri, null);
}
/**
* 查询已有的支付信息
* @param requestParams 要查询的支付参数
* @param merchantKey merchantKey
* @return 查询的支付对象
*/
public static Dictionary<string, Object> query(Dictionary<string, object> requestParams, string merchantKey)
{
string paymentId = StringUtils.tryGetNotNullValue(requestParams, "payment_id");
string uri = new StringBuilder(APIUrlEnum.QUERY_PAYMENT_V1).Append(paymentId).ToString();
//requestParams.Remove("payment_id");
return AdapayRequest.getRequestAdapay(requestParams, uri, merchantKey);
}
/**
* 查询已有的支付信息
*
* @param requestParams 要查询的支付id
* @return 查询的支付对象
*/
public static Dictionary<string, Object> query(Dictionary<string, object> requestParams)
{
string paymentId = StringUtils.tryGetNotNullValue(requestParams, "payment_id");
string uri = new StringBuilder(APIUrlEnum.QUERY_PAYMENT_V1).Append(paymentId).ToString();
//requestParams.Remove("payment_id");
return AdapayRequest.getRequestAdapay(requestParams, uri, null);
}
/**
* 查询已有的支付信息列表
* @param requestParams
* @param merchantKey merchantKey
* @return 查询的支付对象列表
*/
public static Dictionary<string, Object> queryList(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.getRequestAdapay(requestParams, APIUrlEnum.LIST_PAYMENT_V1, merchantKey);
}
/**
* 查询已有的支付信息列表
*
* @param requestParams
* @return 查询的支付对象列表
*/
public static Dictionary<string, Object> queryList(Dictionary<string, object> requestParams)
{
return AdapayRequest.getRequestAdapay(requestParams, APIUrlEnum.LIST_PAYMENT_V1, null);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AdapaySDK
{
public class PaymentConfirm
{
/**
* 创建支付确认对象
*
* @param requestParams 创建支付确认对象参数
* @param merchantKey merchantKey
* @return 查询的支付对象
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.CONFIRM_PAYMENT_V1, merchantKey);
}
/**
* 创建支付确认对象
*
* @param requestParams 创建支付确认对象参数
* @return 查询的支付对象
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.CONFIRM_PAYMENT_V1, null);
}
/**
* 查询已有的支付确认对象列表
*
* @param requestParams 要查询的支付撤销对象参数
* @param merchantKey merchantKey
* @return 查询的支付撤销对象
*/
public static Dictionary<string, Object> queryList(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.getRequestAdapay(requestParams, APIUrlEnum.CONFIRM_PAYMENT_LIST_V1, merchantKey);
}
/**
* 查询已有的支付确认对象列表
*
* @param requestParams 要查询的支付撤销对象参数
* @param merchantKey merchantKey
* @return 查询的支付撤销对象
*/
public static Dictionary<string, Object> queryList(Dictionary<string, object> requestParams)
{
return AdapayRequest.getRequestAdapay(requestParams, APIUrlEnum.CONFIRM_PAYMENT_LIST_V1, null);
}
/**
* 查询已有的支付确认对象
*
* @param requestParams 要查询的支付确认对象参数
* @param merchantKey merchantKey
* @return 查询的支付撤销对象
*/
public static Dictionary<string, Object> query(Dictionary<string, object> requestParams, string merchantKey)
{
string paymentConfirmId = StringUtils.tryGetNotNullValue(requestParams, "payment_confirm_id");
string uri = new StringBuilder(APIUrlEnum.QUERY_CONFIRM_PAYMENT_V1).Append(paymentConfirmId).ToString();
return AdapayRequest.getRequestAdapay(requestParams, uri, merchantKey);
}
/**
* 查询已有的支付确认对象
*
* @param requestParams 要查询的支付确认对象参数
* @param merchantKey merchantKey
* @return 查询的支付撤销对象
*/
public static Dictionary<string, Object> query(Dictionary<string, object> requestParams)
{
string paymentConfirmId = StringUtils.tryGetNotNullValue(requestParams, "payment_confirm_id");
string uri = new StringBuilder(APIUrlEnum.QUERY_CONFIRM_PAYMENT_V1).Append(paymentConfirmId).ToString();
return AdapayRequest.getRequestAdapay(requestParams, uri, null);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AdapaySDK
{
public class PaymentReverse
{
/**
* 创建撤销对象
*
* @param requestParams 创建支付撤销对象参数
* @param merchantKey merchantKey
* @return 查询的支付对象
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.REVERSE_PAYMENT_V1, merchantKey);
}
/**
* 创建撤销对象
*
* @param requestParams 创建支付撤销对象参数
* @return 查询的支付对象
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.REVERSE_PAYMENT_V1, null);
}
/**
* 查询已有的支付撤销对象列表
*
* @param requestParams 要查询的支付撤销对象参数
* @param merchantKey merchantKey
* @return 查询的支付撤销对象
*/
public static Dictionary<string, Object> queryList(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.getRequestAdapay(requestParams, APIUrlEnum.REVERSE_PAYMENT_LIST_V1, merchantKey);
}
/**
* 查询已有的支付撤销对象列表
*
* @param requestParams 要查询的支付撤销对象参数
* @return 查询的支付撤销对象
*/
public static Dictionary<string, Object> queryList(Dictionary<string, object> requestParams)
{
return AdapayRequest.getRequestAdapay(requestParams, APIUrlEnum.REVERSE_PAYMENT_LIST_V1, null);
}
/**
* 查询已有的支付撤销对象
*
* @param requestParams 要查询的支付撤销对象参数
* @param merchantKey merchantKey
* @return 查询的支付撤销对象
*/
public static Dictionary<string, Object> query(Dictionary<string, object> requestParams, string merchantKey)
{
string reverseId = StringUtils.tryGetNotNullValue(requestParams, "reverse_id");
string uri = new StringBuilder(APIUrlEnum.QUERY_REVERSE_PAYMENT_V1).Append(reverseId).ToString();
return AdapayRequest.getRequestAdapay(requestParams, uri, merchantKey);
}
/**
* 查询已有的支付撤销对象
*
* @param requestParams 要查询的支付撤销对象参数
* @param merchantKey merchantKey
* @return 查询的支付撤销对象
*/
public static Dictionary<string, Object> query(Dictionary<string, object> requestParams)
{
string reverseId = StringUtils.tryGetNotNullValue(requestParams, "reverse_id");
string uri = new StringBuilder(APIUrlEnum.QUERY_REVERSE_PAYMENT_V1).Append(reverseId).ToString();
return AdapayRequest.getRequestAdapay(requestParams, uri, null);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Collections;
namespace AdapaySDK
{
public class Refund
{
/**
* create refund for multi merchant
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams, string merchantKey)
{
string id = StringUtils.tryGetNotNullValue(requestParams, "id");
string uri = new StringBuilder(APIUrlEnum.REFUND_V1).Append(id).Append("/refunds").ToString();
return AdapayRequest.requestAdapay(requestParams, uri, merchantKey);
}
/**
* create refund for multi merchant
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams)
{
string id = StringUtils.tryGetNotNullValue(requestParams, "id");
string uri = new StringBuilder(APIUrlEnum.REFUND_V1).Append(id).Append("/refunds").ToString();
return AdapayRequest.requestAdapay(requestParams, uri, null);
}
/**
* query refund for multi merchant
*/
public static Dictionary<string, Object> query(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.getRequestAdapay(requestParams,APIUrlEnum.QUERY_REFUND_V1,merchantKey);
}
/**
* query refund
*/
public static Dictionary<string, Object> query(Dictionary<string, object> requestParams )
{
return AdapayRequest.getRequestAdapay(requestParams, APIUrlEnum.QUERY_REFUND_V1, null);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AdapaySDK
{
public class SettleAccount
{
/**
* 创建结算账户对象
*
* @param params 创建结算账户对象的请求参数,参见 AdaPay api
* @param merchantKey merchantKey
* @return 创建结算账户对象
* @ 异常
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.SETTLE_ACCOUNT_V1, merchantKey);
}
/**
* 查询结算账户对象
*
* @param params 查询结算账户对象的请求参数,参见 AdaPay api
* @param merchantKey merchantKey
* @return 查询的结算账户对象
* @ 异常
*/
public static Dictionary<string, Object> query(Dictionary<string, object> requestParams, string merchantKey)
{
string settleAccountId = StringUtils.tryGetNotNullValue(requestParams, "settle_account_id");
string uri = new StringBuilder(APIUrlEnum.QUERY_SETTLE_ACCOUNT_V1).Append(settleAccountId).ToString();
return AdapayRequest.getRequestAdapay(requestParams, uri, merchantKey);
}
/**
* 删除结算账户对象
*
* @param params 删除结算账户对象的请求参数,参见 AdaPay api
* @param merchantKey merchantKey
* @return 删除的结算账户对象
* @ 异常
*/
public static Dictionary<string, Object> delete(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.DELETE_SETTLE_ACCOUNT_V1, merchantKey);
}
/**
* 查询结算明细列表
*
* @param params 查询结算明细列表的请求参数,参见 AdaPay api
* @param merchantKey merchantKey
* @return 查询的结算账户对象
* @ 异常
*/
public static Dictionary<string, Object> details(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.getRequestAdapay(requestParams, APIUrlEnum.QUERY_SETTLE_DETAILS_V1, merchantKey);
}
/**
* 创建结算账户对象
*
* @param params 创建结算账户对象的请求参数,参见 AdaPay api
* @return 创建结算账户对象
* @ 异常
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.SETTLE_ACCOUNT_V1, null);
}
/**
* 查询结算账户对象
*
* @param params 查询结算账户对象的请求参数,参见 AdaPay api
* @return 查询的结算账户对象
* @ 异常
*/
public static Dictionary<string, Object> query(Dictionary<string, object> requestParams)
{
string settleAccountId = StringUtils.tryGetNotNullValue(requestParams, "settle_account_id");
string uri = new StringBuilder(APIUrlEnum.QUERY_SETTLE_ACCOUNT_V1).Append(settleAccountId).ToString();
return AdapayRequest.getRequestAdapay(requestParams, uri, null);
}
/**
* 删除结算账户对象
*
* @param params 删除结算账户对象的请求参数,参见 AdaPay api
* @return 删除的结算账户对象
* @ 异常
*/
public static Dictionary<string, Object> delete(Dictionary<string, object> requestParams)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.DELETE_SETTLE_ACCOUNT_V1, null);
}
/**
* 查询结算明细列表
*
* @param params 查询结算明细列表的请求参数,参见 AdaPay api
* @return 查询的结算账户对象
* @ 异常
*/
public static Dictionary<string, Object> details(Dictionary<string, object> requestParams)
{
return AdapayRequest.getRequestAdapay(requestParams, APIUrlEnum.QUERY_SETTLE_DETAILS_V1, null);
}
/**
* 修改结算账户配置
*
* @param params 修改结算账户配置的请求参数,参见 AdaPay api
* @return 修改的结算账户对象
* @ 异常
*/
public static Dictionary<string, Object> update(Dictionary<string, object> requestParams)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.MODIFY_SETTLE_ACCOUNT_V1, null);
}
/**
* 修改结算账户配置
*
* @param params 修改结算账户配置的请求参数,参见 AdaPay api
* @return 修改的结算账户对象
* @ 异常
*/
public static Dictionary<string, Object> update(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.MODIFY_SETTLE_ACCOUNT_V1, merchantKey);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AdapaySDK
{
public class Transfer
{
/**
* 创建转账对象
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 创建转账对象
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.CREATE_TRANSFER, null);
}
/**
* 创建转账对象
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 创建转账对象
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.CREATE_TRANSFER,merchantKey);
}
/**
* 查询账户转账对象列表
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 账户转账对象列表
*/
public static Dictionary<string, Object> queryList(Dictionary<string, object> requestParams)
{
return AdapayRequest.getRequestAdapay(requestParams, APIUrlEnum.TRANSFER_LIST, null);
}
/**
* 查询账户转账对象列表
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 账户转账对象列表
*/
public static Dictionary<string, Object> queryList(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.getRequestAdapay(requestParams, APIUrlEnum.TRANSFER_LIST, merchantKey);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AdapaySDK
{
public class UnFreezeAccount
{
/**
* 创建账户解冻对象
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 创建账户解冻对象
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.UN_FREEZE_ACCOUNT_CREATE, null);
}
/**
* 创建账户解冻对象
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 创建账户解冻对象
*/
public static Dictionary<string, Object> create(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.requestAdapay(requestParams, APIUrlEnum.UN_FREEZE_ACCOUNT_CREATE, merchantKey);
}
/**
* 查询账户解冻对象列表
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 查询账户解冻对象列表
*/
public static Dictionary<string, Object> queryList(Dictionary<string, object> requestParams)
{
return AdapayRequest.getRequestAdapay(requestParams, APIUrlEnum.UN_FREEZE_ACCOUNT_LIST, null);
}
/**
* 查询账户解冻对象列表
*
* @param requestParams 请求参数
* @param merchantKey merchantKey
* @return 查询账户解冻对象列表
*/
public static Dictionary<string, Object> queryList(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.getRequestAdapay(requestParams, APIUrlEnum.UN_FREEZE_ACCOUNT_LIST, APIUrlEnum.UN_FREEZE_ACCOUNT_CREATE);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace AdapaySDK
{
public class Wallet
{
/**
* 获取登录信息
*
* @param requestParams 登录请求参数,参见 AdaPay api
* @param merchantKey merchantKey
* @return 跳转页面信息
*/
public static Dictionary<string, Object> login(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.requestAdapayPageServer(requestParams, APIUrlEnum.WALLET_LOGIN, merchantKey);
}
/**
* 获取登录信息
*
* @param requestParams 登录请求参数,参见 AdaPay api
* @param merchantKey merchantKey
* @return 跳转页面信息
*/
public static Dictionary<string, Object> login(Dictionary<string, object> requestParams)
{
return AdapayRequest.requestAdapayPageServer(requestParams, APIUrlEnum.WALLET_LOGIN, null);
}
/**
* 查询帐户余额
*
* @param params 查询帐户余额的请求参数,参见 AdaPay api
* @return 帐户余额
*/
public static Dictionary<string, Object> balance(Dictionary<string, object> requestParams)
{
return AdapayRequest.getRequestAdapay(requestParams, APIUrlEnum.QUERY_BALANCE, null);
}
/**
* 查询帐户余额
*
* @param params 查询帐户余额的请求参数,参见 AdaPay api
* @return 帐户余额
*/
public static Dictionary<string, Object> balance(Dictionary<string, object> requestParams, string merchantKey)
{
return AdapayRequest.getRequestAdapay(requestParams, APIUrlEnum.QUERY_BALANCE, merchantKey);
}
}
}

using System.Collections.Generic;
namespace Mall.ThirdCore.Adapay.Model
{
/// <summary>
/// 汇付天下 支付回调
/// </summary>
public class AdaPayResultModel
{
/// <summary>
/// 由 Adapay 生成的支付对象 id, 该 id 在 Adapay 系统内唯一
/// </summary>
public string id { get; set; }
/// <summary>
/// 支付创建时的 10 位时间戳
/// </summary>
public string created_time { get; set; }
/// <summary>
/// 请求订单号,只能为英文、数字或者下划线的一种或多种组合,保证在app_id下唯一
/// </summary>
public string order_no { get; set; }
/// <summary>
/// 是否 prod模式,true 是 prod模式,false 是 mock模式
/// </summary>
public string prod_mode { get; set; }
/// <summary>
/// 控制台 主页面应用的app_id
/// </summary>
public string app_id { get; set; }
/// <summary>
/// 支付渠道,参见 支付渠道 说明
/// </summary>
public string pay_channel { get; set; }
/// <summary>
/// 交易金额(必须大于 0),保留两位小数点,如0.10、100.05等
/// </summary>
public decimal pay_amt { get; set; }
/// <summary>
/// 详见 货币代码
/// </summary>
public string currency { get; set; }
/// <summary>
/// 可临时用来查询支付订单状态的链接,此链接的有效期只有30分钟
/// </summary>
public string query_url { get; set; }
/// <summary>
/// 订单附加说明
/// </summary>
public string description { get; set; }
/// <summary>
/// 支付渠道请求成功返回的额外参数。详见 支付渠道 expend参数 说明
/// </summary>
public object expend { get; set; }
/// <summary>
/// 用户账单上的商户订单号
/// </summary>
public string party_order_id { get; set; }
/// <summary>
/// 用户账单上的交易订单号
/// </summary>
public string out_trans_id { get; set; }
/// <summary>
/// 用户支付完成时间
/// </summary>
public string end_time { get; set; }
/// <summary>
/// 当前交易状态,参见 状态 说明
/// </summary>
public string status { get; set; }
/// <summary>
/// 错误码,详见 错误
/// </summary>
public string error_code { get; set; }
/// <summary>
/// 错误描述,详见 错误
/// </summary>
public string error_msg { get; set; }
/// <summary>
/// 错误类型,详见 错误
/// </summary>
public string error_type { get; set; }
/// <summary>
/// 当发生参数错误时返回具体的参数名,便于定位错误原因,详见 错误
/// </summary>
public string invalid_param { get; set; }
//以下退款
/// <summary>
/// 退款单号
/// </summary>
public string refund_order_no { get; set; }
/// <summary>
/// 退费描述
/// </summary>
public string reason { get; set; }
/// <summary>
/// 退款目标 =>支付对象 id
/// </summary>
public string payment_id { get; set; }
/// <summary>
/// 退款目标 =>支付对象订单号
/// </summary>
public string payment_order_no { get; set; }
/// <summary>
/// 退款金额
/// </summary>
public decimal refund_amt { get; set; }
/// <summary>
/// 退款手续费
/// </summary>
public decimal fee_amt { get; set; }
}
}
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using AdapayCore;
using Mall.Common.Plugin;
using Mall.Module.User;
using Mall.Repository.Education;
using Mall.ThirdCore.Adapay.Model;
using Mall.WebApi.Filter;
using Microsoft.AspNetCore.Cors;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
namespace Mall.WebApi.Controllers.Adapay
{
[Route("api/[controller]/[action]")]
[ApiExceptionFilter]
[ApiController]
[EnableCors("AllowCors")]
public class AdapayCallBackController : ControllerBase
{
private readonly UserCommonModule userCommonModule = new UserCommonModule();
#region 汇付天下接收事件
/// <summary>
/// 汇付天下支付回调
/// </summary>
[HttpPost]
public string AdapayCallBackEvent()
{
LogHelper.WriteInfo("汇付天下 支付回调进来了");
#region Post请求的密文数据
Request.EnableBuffering();
string responseData = "";
using (var reader = new StreamReader(Request.Body, encoding: System.Text.Encoding.UTF8))
{
var body = reader.ReadToEndAsync();
responseData = body.Result;
Request.Body.Position = 0;
}
#endregion
LogHelper.WriteInfo("回调参数:" + responseData);
#region 解码参数
try
{
responseData = System.Web.HttpUtility.UrlDecode(responseData);
List<string> rlist = responseData.Split('&').ToList();
Dictionary<string, string> expendDict = new Dictionary<string, string>();
foreach (var item in rlist)
{
string[] values = item.Split('=');
expendDict.Add(values[0], values[1]);
}
//验签请参data
expendDict.TryGetValue("data", out string data);
//验签请参sign
expendDict.TryGetValue("sign", out string sign);
//事件类型
expendDict.TryGetValue("type", out string type);
//验签
bool checkSign = NetUtils.verfySign(sign, data);
if (checkSign)
{
//验签成功逻辑
LogHelper.WriteInfo("成功返回数据data:" + data);
//退款返回
//data = '{"object":"refund","status":"succeeded","prod_mode":"true","id":"0021120220718133304980394978062292664320","refund_order_no":"R202207181658151172712","payment_id":"002112022071419472310393622712813637632","payment_order_no":"202207141657828044797","refund_amt":"0.01","fee_amt":"0.00","channel_no":"2022071821R5j30g","created_time":"1658122384000","succeed_time":"1658122386000","app_id":"app_c474eae3-28a4-487b-9d07-c92c228c9a0b"}';
AdaPayResultModel payMdoel = JsonHelper.DeserializeObject<AdaPayResultModel>(data);
switch (type)
{
case "payment.succeeded"://支付成功
//异步操作订单实收 新增财务单据
System.Threading.Tasks.Task.Run(() => userCommonModule.InsertAdapayOrderTrade(payMdoel));
break;
case "payment.failed"://支付失败
LogHelper.WriteInfo("订单支付失败:" + data);
break;
case "refund.succeeded"://退款成功
break;
case "refund.failed"://退款失败
break;
case "fastpay.succeeded":// 快捷支付确认成功
break;
case "fastpay.failed":// 快捷支付确认失败
break;
}
}
else
{
//验签失败逻辑
LogHelper.WriteInfo("签名效验失败");
}
}
catch (Exception ex)
{
LogHelper.Write(ex, "AdapayCallBackEvent");
}
#endregion
return "";
}
#endregion
}
}
\ No newline at end of file
using System;
using System.Collections.Generic;
using System.Linq;
using AdapayCore;
using AdapaySDK;
using Mall.Common.API;
using Mall.Common.Plugin;
using Mall.Model.Extend.Product;
using Mall.Module.User;
using Mall.Repository.Education;
using Mall.WebApi.Filter;
using Mall.WeChat.Helper;
using Microsoft.AspNetCore.Cors;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
namespace Mall.WebApi.Controllers.Adapay
{
[Route("api/[controller]/[action]")]
[ApiExceptionFilter]
[ApiController]
[EnableCors("AllowCors")]
public class AdapayController : BaseController
{
private readonly UserCommonModule userCommonModule = new UserCommonModule();
private readonly RB_Trade_ConfigRepository trade_ConfigRepository = new RB_Trade_ConfigRepository();
/// <summary>
/// 获取支付信息
/// </summary>
/// <returns></returns>
[HttpPost]
public ApiResult GetAdapayInfo()
{
var rparms = RequestParm;
var userInfo = AppletUserInfo;
if (userInfo == null)
{
return ApiResult.Failed("请登录");
}
var ParmJObj = JObject.Parse(rparms.msg.ToString());
string pay_channel = ParmJObj.GetStringValue("pay_channel");
string open_id = ParmJObj.GetStringValue("open_id");// 微信支付 需要openId 对应公众号/小程序openId
string hb_fq_num = ParmJObj.GetStringValue("hb_fq_num");//支付宝 分期期数 只支持 3,6,12 必须大于等于100元 可用户自己选
int orderId = ParmJObj.GetInt("orderId", 0);//商城订单ID
if (orderId <= 0)
{
return ApiResult.ParamIsNull("请传递商城订单ID");
}
if (string.IsNullOrEmpty(pay_channel))
{
return ApiResult.ParamIsNull("请传递支付渠道");
}
if ((pay_channel == "wx_pub" || pay_channel == "wx_lite") && string.IsNullOrEmpty(open_id))
{
return ApiResult.Failed("请传递微信OpenId");
}
var offerModel = userCommonModule.GetAdapayOrderInfo(orderId, userInfo.MallBaseId);
if (offerModel == null)
{
return ApiResult.Failed("订单不存在");
}
if (offerModel.OrderStatus != Common.Enum.Goods.OrderStatusEnum.NonPayment)
{
return ApiResult.Failed("订单支付状态不正确");
}
string appId = InitAdapay(100001);
var parms = PaymentDemo.CreatePayment(appId, pay_channel, open_id, hb_fq_num, offerModel);
parms.TryGetValue("status", out object status);
if (status != null && status.ToString() == "succeeded")
{
//获取pay_info信息
parms.TryGetValue("expend", out object expend);
string pay_info = "";
if (pay_channel == "alipay_qr")
{
pay_info = JObject.Parse(expend.ToString()).GetStringValue("qrcode_url");
}
else
{
pay_info = JObject.Parse(expend.ToString()).GetStringValue("pay_info");
}
return ApiResult.Success("", pay_info);
}
else
{
return ApiResult.Failed("创建支付失败,请联系管理员");
}
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="GroupId"></param>
/// <returns></returns>
private string InitAdapay(int GroupId)
{
var tcModel = trade_ConfigRepository.GetList(new Model.Extend.Education.RB_Trade_Config() { GroupId = GroupId, Type = 1 }).FirstOrDefault();
string appId = tcModel.AppId;
MerConfig config = new MerConfig
{
apiKey = tcModel.ApiKey,
privateKey = tcModel.PrivateKey,
apiMockKey = tcModel.ApiMockKey
};
AdapaySDK.Adapay.debug = false;
AdapaySDK.Adapay.deviceId = "jjsw" + GroupId;
AdapaySDK.Adapay.isMock = false;
//商户配置字典
Dictionary<string, MerConfig> dict = new Dictionary<string, MerConfig>
{
//default商户
{ "default", config },
//另一个商户信息
{ "yifuyun", config }
};
//多商户启动
AdapaySDK.Adapay.initWithMerConfigs(dict);
return appId;
}
}
class PaymentDemo
{
public static string merchantKey = "yifuyun";
public static void testPayment(string appId)
{
Dictionary<string, Object> payment = testCreatePayment(appId);
testQueryPayment(appId, (string)payment["id"]);
testClosePayment(appId, (string)payment["id"]);
testCreateReverse(appId, "002112019102420545010033426145952493568");
testReverseList(appId, "002112019102420545010033426145952493568");
testQueryReverse(appId, "002112019102420545010033426145952493568");
testCreateConfirm(appId, "002112019102420545010033426145952493568");
testQueryConfirm(appId, "002112019102420545010033426145952493568");
testQueryConfirmList(appId, "002112019102420545010033426145952493568");
}
public static Dictionary<string, Object> CreatePayment(string appId, string pay_channel, string open_id, string hb_fq_num, RB_Goods_Order_Extend offerModel)
{
string courseName = offerModel.DetailList.FirstOrDefault().GoodsName;
if (!string.IsNullOrEmpty(courseName) && courseName.Length > 15)
{
courseName = courseName.Substring(0, 15);
}
courseName += "等" + offerModel.DetailList.Count() + "件";
Dictionary<string, object> dict = new Dictionary<string, object>
{
{ "pay_amt", offerModel.Income},
{ "app_id", appId },
{ "order_no", DateTime.Now.ToString("yyyyMMdd") + StringUtils.timeStamp() },
{ "pay_channel", pay_channel },
{ "goods_title", "您的待支付订单" },
{ "goods_desc", courseName},
{ "currency", "cny" },
{ "time_expire", DateTime.Now.AddMinutes(3).ToString("yyyyMMddHHmmss")},
{ "description", offerModel.MallBaseId + "|" + offerModel.OrderId},
{ "notify_url", "https://mallapi.oytour.com/api/AdapayCallBack/AdapayCallBackEvent"}
};
Dictionary<string, object> expendDict = new Dictionary<string, object>();
if (pay_channel == "wx_pub" || pay_channel == "wx_lite")
{
expendDict.Add("open_id", open_id);//"oT-wi55Qi2eUJxt8UDZxsmsgZ5fc"
}
if (!string.IsNullOrEmpty(hb_fq_num))
{
expendDict.Add("hb_fq_num", hb_fq_num);// 支付宝分期 目前 只支持3,6,12
}
expendDict.Add("limit_pay", 1);
dict.Add("expend", expendDict);
Dictionary<string, object> result = Payment.create(dict, merchantKey);
object errorCode = null;
result.TryGetValue("error_code", out errorCode);
LogHelper.WriteInfo(JsonConvert.SerializeObject(result, Formatting.None));
if (!String.IsNullOrEmpty((string)errorCode))
{
LogHelper.WriteInfo(JsonConvert.SerializeObject(result, Formatting.None));
}
return result;
}
public static Dictionary<string, Object> testCreatePayment(string appId)
{
Dictionary<string, object> dict = new Dictionary<string, object>
{
{ "pay_amt", "0.01" },
{ "app_id", appId },
{ "order_no", DateTime.Now.ToString("yyyyMMdd") + StringUtils.timeStamp() },
{ "pay_channel", "alipay_wap" },
{ "goods_title", "测试一下支付" },
{ "goods_desc", "your goods desc" },
{ "currency", "cny" }
};
Dictionary<string, object> expendDict = new Dictionary<string, object>();
expendDict.Add("open_id", "sddddddddfasfdfas");
expendDict.Add("wx_app_id", appId);
dict.Add("expend", expendDict);
Dictionary<string, object> result = Payment.create(dict, merchantKey);
object errorCode = null;
result.TryGetValue("error_code", out errorCode);
if (!String.IsNullOrEmpty((string)errorCode))
{
Console.WriteLine("Payment.create failed");
Console.WriteLine(JsonConvert.SerializeObject(result, Formatting.None));
}
else
{
Console.WriteLine("Payment.create success");
}
return result;
}
public static Dictionary<string, Object> testQueryPayment(string appId, string paymentId)
{
Dictionary<string, object> dict = new Dictionary<string, object>();
dict.Add("payment_id", paymentId);
Dictionary<string, object> result = Payment.query(dict, merchantKey);
object errorCode = null;
result.TryGetValue("error_code", out errorCode);
if (!String.IsNullOrEmpty((string)errorCode))
{
Console.WriteLine(JsonConvert.SerializeObject(result, Formatting.None));
}
else
{
Console.WriteLine("Payment.query success");
}
return result;
}
public static Dictionary<string, Object> testClosePayment(string appId, string paymentId)
{
Dictionary<string, object> dict = new Dictionary<string, object>();
dict.Add("payment_id", paymentId);
Dictionary<string, object> result = Payment.close(dict, merchantKey);
object errorCode = null;
result.TryGetValue("error_code", out errorCode);
if (!String.IsNullOrEmpty((string)errorCode))
{
Console.WriteLine(JsonConvert.SerializeObject(result, Formatting.None));
}
else
{
Console.WriteLine("Payment.close success");
}
return result;
}
public static Dictionary<string, Object> testReverseList(string appId, string paymentId)
{
Dictionary<string, object> reverse = new Dictionary<string, object>();
reverse.Add("payment_id", paymentId);
reverse.Add("app_id", appId);
reverse.Add("page_index", "1");
reverse.Add("page_size", "20");
reverse.Add("created_gte", "1571913923");
reverse.Add("created_lte", "1571913924");
Dictionary<string, object> result = PaymentReverse.queryList(reverse, merchantKey);
object errorCode = null;
result.TryGetValue("error_code", out errorCode);
if (!String.IsNullOrEmpty((string)errorCode))
{
Console.WriteLine(JsonConvert.SerializeObject(result, Formatting.None));
}
else
{
Console.WriteLine(" Payment.queryReverseList success");
}
return result;
}
public static Dictionary<string, Object> testQueryReverse(string appId, string paymentId)
{
Dictionary<string, object> dict = new Dictionary<string, object>();
dict.Add("reverse_id", paymentId);
Dictionary<string, object> result = PaymentReverse.query(dict, merchantKey);
object errorCode = null;
result.TryGetValue("error_code", out errorCode);
if (!String.IsNullOrEmpty((string)errorCode))
{
Console.WriteLine(JsonConvert.SerializeObject(result, Formatting.None));
}
else
{
Console.WriteLine("Payment.queryReverse success");
}
return result;
}
/**
* 创建撤销对象
*
* @param paymentId 要查询的支付id
* @return 查询的支付对象
* @ 异常
*/
public static Dictionary<string, Object> testCreateReverse(string paymentId, string appId)
{
Dictionary<string, object> reverse = new Dictionary<string, object>();
reverse.Add("payment_id", paymentId);
reverse.Add("app_id", appId);
reverse.Add("order_no", "csdk_reverse_" + StringUtils.timeStamp());
reverse.Add("notify_url", "");
reverse.Add("reverse_amt", "0.01");
reverse.Add("reason", "reason");
reverse.Add("expand", "expend");
reverse.Add("device_info", "device_info");
Dictionary<string, Object> result = PaymentReverse.create(reverse, merchantKey);
object errorCode = null;
result.TryGetValue("error_code", out errorCode);
if (!String.IsNullOrEmpty((string)errorCode))
{
Console.WriteLine("Payment.createReverse: \n " + JsonConvert.SerializeObject(result, Formatting.None));
}
else
{
Console.WriteLine("Payment.createReverse success");
}
return result;
}
public static Dictionary<string, Object> testCreateConfirm(string paymentId, string appId)
{
Dictionary<string, object> confirm = new Dictionary<string, object>();
confirm.Add("payment_id", paymentId);
confirm.Add("order_no", "csdk_confirm_" + StringUtils.timeStamp());
confirm.Add("confirm_amt", "0.01");
confirm.Add("description", "description");
confirm.Add("div_members", "");
Dictionary<string, object> result = PaymentConfirm.create(confirm, merchantKey);
object errorCode = null;
result.TryGetValue("error_code", out errorCode);
if (!String.IsNullOrEmpty((string)errorCode))
{
Console.WriteLine("Payment.createConfirm \n" + JsonConvert.SerializeObject(result, Formatting.None));
}
else
{
Console.WriteLine("Payment.createConfirm success");
}
return result;
}
public static Dictionary<string, Object> testQueryConfirm(string appId, string paymentConfirmId)
{
Dictionary<string, object> confirm = new Dictionary<string, object>();
confirm.Add("payment_confirm_id", paymentConfirmId);
Dictionary<string, Object> result = PaymentConfirm.query(confirm, merchantKey);
object errorCode = null;
result.TryGetValue("error_code", out errorCode);
if (!String.IsNullOrEmpty((string)errorCode))
{
Console.WriteLine("Payment.queryConfirm \n" + JsonConvert.SerializeObject(result, Formatting.None));
}
else
{
Console.WriteLine("Payment.queryConfirm success");
}
return result;
}
/**
* 查询确认对象列表
*
* @param
* @return 查询的支付对象
* @ 异常
*/
public static Dictionary<string, Object> testQueryConfirmList(string appId, string paymentId)
{
Dictionary<string, object> confirm = new Dictionary<string, object>();
confirm.Add("payment_id", paymentId);
confirm.Add("app_id", appId);
confirm.Add("page_index", "1");
confirm.Add("page_size", "20");
confirm.Add("created_gte", "1571913867");
confirm.Add("created_lte", "1571913923");
Dictionary<string, object> result = PaymentConfirm.queryList(confirm, merchantKey);
object errorCode = null;
result.TryGetValue("error_code", out errorCode);
if (!String.IsNullOrEmpty((string)errorCode))
{
Console.WriteLine("Payment.queryConfirmList \n" + JsonConvert.SerializeObject(result, Formatting.None));
}
else
{
Console.WriteLine("Payment.queryConfirmList success");
}
return result;
}
}
}
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment