protected void Page_Load(object sender, EventArgs e)
{
string sp_billno = Request["order_no"];
//当前时间 yyyyMMdd
string date = DateTime.Now.ToString("yyyyMMdd");
//订单号，此处用时间和随机数生成，商户根据自己调整，保证唯一
string out_trade_no = "" + DateTime.Now.ToString("HHmmss") + WeixinPayUtil.BuildRandomStr(4);
if (null == sp_billno)
{
//生成订单10位序列号，此处用时间和随机数生成，商户根据自己调整，保证唯一
sp_billno = DateTime.Now.ToString("HHmmss") + WeixinPayUtil.BuildRandomStr(4);
}
else
{
sp_billno = Request["order_no"].ToString();
}
sp_billno = WeixinPayUtil.PartnerId + sp_billno;
//创建RequestHandler实例
RequestHandler packageReqHandler = new RequestHandler(Context);
//初始化
packageReqHandler.Init();
packageReqHandler.SetKey(WeixinPayUtil.Key);
//设置package订单参数
packageReqHandler.SetParameter("partner", WeixinPayUtil.PartnerId); //商户号
packageReqHandler.SetParameter("bank_type", "WX"); //银行类型
packageReqHandler.SetParameter("fee_type", "1"); //币种，1人民币
packageReqHandler.SetParameter("input_charset", "GBK");
packageReqHandler.SetParameter("out_trade_no", sp_billno); //商家订单号
packageReqHandler.SetParameter("total_fee", "1"); //商品金额,以分为单位(money * 100).ToString()
packageReqHandler.SetParameter("notify_url", WeixinPayUtil.TenpayNotify); //接收财付通通知的URL
packageReqHandler.SetParameter("body", "nativecall"); //商品描述
packageReqHandler.SetParameter("spbill_create_ip", Page.Request.UserHostAddress); //用户的公网ip，不是商户服务器IP
//获取package包
string packageValue = packageReqHandler.GetRequestURL();
//调起微信支付签名
string timeStamp = WeixinPayUtil.GetTimestamp();
string nonceStr = WeixinPayUtil.GetNoncestr();
//设置支付参数
RequestHandler payHandler = new RequestHandler(Context);
payHandler.SetParameter("appid", WeixinPayUtil.AppId);
payHandler.SetParameter("noncestr", nonceStr);
payHandler.SetParameter("timestamp", timeStamp);
payHandler.SetParameter("package", packageValue);
payHandler.SetParameter("RetCode","0");
payHandler.SetParameter("RetErrMsg","成功");
string paySign = payHandler.CreateSHA1Sign();
payHandler.SetParameter("app_signature", paySign);
payHandler.SetParameter("sign_method","SHA1");
Response.ContentType = "text/xml";
Response.Clear();
Response.Write(payHandler.ParseXML());
}
public void RequestHandlerRetryDecisionTest()
{
var statement = new SimpleStatement("SELECT WILL FAIL");
var request = Session.GetRequest(statement);
var requestHandler = new RequestHandler<RowSet>(Session, request, statement);
//Using default retry policy the decision will always be to rethrow on read/write timeout
var expected = RetryDecision.RetryDecisionType.Rethrow;
var decision = requestHandler.GetRetryDecision(new ReadTimeoutException(ConsistencyLevel.Quorum, 1, 2, true));
Assert.AreEqual(expected, decision.DecisionType);
decision = requestHandler.GetRetryDecision(new WriteTimeoutException(ConsistencyLevel.Quorum, 1, 2, "SIMPLE"));
Assert.AreEqual(expected, decision.DecisionType);
decision = requestHandler.GetRetryDecision(new UnavailableException(ConsistencyLevel.Quorum, 2, 1));
Assert.AreEqual(expected, decision.DecisionType);
decision = requestHandler.GetRetryDecision(new Exception());
Assert.AreEqual(expected, decision.DecisionType);
//Expecting to retry when a Cassandra node is Bootstrapping/overloaded
expected = RetryDecision.RetryDecisionType.Retry;
decision = requestHandler.GetRetryDecision(new OverloadedException(null));
Assert.AreEqual(expected, decision.DecisionType);
decision = requestHandler.GetRetryDecision(new IsBootstrappingException(null));
Assert.AreEqual(expected, decision.DecisionType);
decision = requestHandler.GetRetryDecision(new TruncateException(null));
Assert.AreEqual(expected, decision.DecisionType);
}
public void LogoutTest()
{
LoginData login = DefaultLoginData;
var requestHandler = new RequestHandler(login.UserName, login.Password, login.URL);
requestHandler.Login();
Assert.True(requestHandler.Logout());
}
/// <summary>
/// 查询订单 请求参数
/// </summary>
/// <param name="appId"></param>
/// <param name="mchId"></param>
/// <param name="outTradeNo"></param>
/// <param name="signType"></param>
/// <param name="key"></param>
/// <param name="transactionId"></param>
/// <param name="nonceStr"></param>
public TenPayV3OrderQueryRequestData(string appId, string mchId, string transactionId, string nonceStr,
string outTradeNo, string key, string signType = "MD5")
{
AppId = appId;
MchId = mchId;
NonceStr = nonceStr;
TransactionId = transactionId;
OutTradeNo = outTradeNo;
SignType = signType;
Key = key;
#region 设置RequestHandler
PackageRequestHandler = new RequestHandler(null);
//设置package订单参数
PackageRequestHandler.SetParameter("appid", this.AppId); //公众账号ID
PackageRequestHandler.SetParameter("mch_id", this.MchId); //商户号
PackageRequestHandler.SetParameter("transaction_id", this.TransactionId); //微信的订单号
PackageRequestHandler.SetParameter("out_trade_no", this.OutTradeNo); //商户系统内部的订单号
PackageRequestHandler.SetParameter("nonce_str", this.NonceStr); //随机字符串
Sign = PackageRequestHandler.CreateMd5Sign("key", this.Key);
PackageRequestHandler.SetParameter("sign", Sign); //签名
PackageRequestHandler.SetParameter("sign_type", this.SignType); //签名类型
#endregion
}
public Server(FuSettings settings, RequestHandler handler)
{
this.Settings = settings;
this.Handler = handler;
ifStats(s => Stats = new Stats());
}
/// <summary>
/// Registers request handlers that process room Navigator queries etc.
/// </summary>
public void RegisterNavigator()
{
mRequestHandlers[380] = new RequestHandler(SetFrontPageListening);
mRequestHandlers[381] = new RequestHandler(GuestRoomSearch);
mRequestHandlers[382] = new RequestHandler(GetPopularRoomTags);
mRequestHandlers[385] = new RequestHandler(GetGuestRoom);
}
public void Connect(string username, SecureString password, string url)
{
_requestHandler = new RequestHandler(username, password, url);
string sId = _requestHandler.Login();
var cInfo = new SessionInformation(sId, url, username);
SessionState.PSVariable.Set(SessionInfoVariableName, cInfo);
}
public override string CheckRoutes(string url, RequestHandler r)
{
string[] segments = url.Split('?');
string path = server.settings.webRoot + segments[0];
if (url == "/")
{
if (Boolean.Parse(server.settings.dirListing))
SendContentHandler.SendDirectories(r.stream, DirectoryListing.Generate(path, server.settings.webRoot));
else
return server.settings.webRoot + "/" + server.settings.defaultPage;
}
else if (File.Exists(path))
{
return server.settings.webRoot + url;
}
else if (Directory.Exists(path))
{
if (Boolean.Parse(server.settings.dirListing))
SendContentHandler.SendDirectories(r.stream, DirectoryListing.Generate(path, server.settings.webRoot));
else
errorHandler.SendErrorPage(r.stream, 403);
}
else
{
errorHandler.SendErrorPage(r.stream, 404);
}
return null;
}
/// <summary>
/// 转换短链接 请求参数
/// </summary>
/// <param name="appId"></param>
/// <param name="mchId"></param>
/// <param name="signType"></param>
/// <param name="longUrl"></param>
/// <param name="key"></param>
/// <param name="nonceStr"></param>
public TenPayV3ShortUrlRequestData(string appId, string mchId, string nonceStr,
string longUrl, string key, string signType = "MD5")
{
AppId = appId;
MchId = mchId;
NonceStr = nonceStr;
SignType = signType;
LongUrl = longUrl;
Key = key;
#region 设置RequestHandler
//创建支付应答对象
PackageRequestHandler = new RequestHandler(null);
//初始化
PackageRequestHandler.Init();
//设置package订单参数
PackageRequestHandler.SetParameter("appid", this.AppId); //公众账号ID
PackageRequestHandler.SetParameter("mch_id", this.MchId); //商户号
PackageRequestHandler.SetParameter("long_url", this.LongUrl); //微信的订单号
PackageRequestHandler.SetParameter("nonce_str", this.NonceStr); //随机字符串
PackageRequestHandler.SetParameter("sign_type", this.SignType); //签名类型
Sign = PackageRequestHandler.CreateMd5Sign("key", this.Key);
PackageRequestHandler.SetParameter("sign", Sign); //签名
#endregion
}
protected void Page_Load(object sender, EventArgs e)
{
string sp_billno = Request["order_no"];
//当前时间 yyyyMMdd
string date = DateTime.Now.ToString("yyyyMMdd");
if (null == sp_billno)
{
//生成订单10位序列号，此处用时间和随机数生成，商户根据自己调整，保证唯一
sp_billno = DateTime.Now.ToString("HHmmss") + TenPayUtil.BuildRandomStr(4);
}
else
{
sp_billno = Request["order_no"].ToString();
}
sp_billno = TenPayInfo.PartnerId + sp_billno;
//创建支付应答对象
RequestHandler packageReqHandler = new RequestHandler(Context);
//初始化
packageReqHandler.Init();
//设置package订单参数
packageReqHandler.SetParameter("partner", TenPayInfo.PartnerId); //商户号
packageReqHandler.SetParameter("fee_type", "1"); //币种，1人民币
packageReqHandler.SetParameter("input_charset", "GBK");
packageReqHandler.SetParameter("out_trade_no", sp_billno); //商家订单号
packageReqHandler.SetParameter("total_fee", "1"); //商品金额,以分为单位(money * 100).ToString()
packageReqHandler.SetParameter("notify_url", TenPayInfo.TenPayNotify); //接收财付通通知的URL
packageReqHandler.SetParameter("body", "JSAPIdemo"); //商品描述
packageReqHandler.SetParameter("spbill_create_ip", Page.Request.UserHostAddress); //用户的公网ip，不是商户服务器IP
//获取package包
packageValue = packageReqHandler.GetRequestURL();
//调起微信支付签名
timeStamp = TenPayUtil.GetTimestamp();
nonceStr = TenPayUtil.GetNoncestr();
//设置支付参数
RequestHandler paySignReqHandler = new RequestHandler(Context);
paySignReqHandler.SetParameter("appid", appId);
paySignReqHandler.SetParameter("appkey", TenPayInfo.AppKey);
paySignReqHandler.SetParameter("noncestr", nonceStr);
paySignReqHandler.SetParameter("timestamp", timeStamp);
paySignReqHandler.SetParameter("package", packageValue);
paySign = paySignReqHandler.CreateSHA1Sign();
//获取debug信息,建议把请求和debug信息写入日志，方便定位问题
//string pakcageDebuginfo = packageReqHandler.getDebugInfo();
//Response.Write("<br/>pakcageDebuginfo:" + pakcageDebuginfo + "<br/>");
//string paySignDebuginfo = paySignReqHandler.getDebugInfo();
//Response.Write("<br/>paySignDebuginfo:" + paySignDebuginfo + "<br/>");
}
public void AddRequestHandler(RequestHandler httpProcessor)
{
String requestUri = httpProcessor.getProcessorUri();
log.debug(requestUri, "requestUri");
_httpProcessors.Add(httpProcessor);
}
public CSharpServerImplementation()
{
myRegisterHandler = new RegisterHandler();
myElectionHelper = new ElectionHelper();
myRequestHandler = new RequestHandler();
myRequestCentralHandler = new RequestHandlerCentralized();
myResourceHandler = new ResourceHandler();
}
public static Middleware Create(RequestHandler handler, RequestMiddleware[] requestModules, ResponseMiddleware[] responseModules)
{
Middleware m = new Middleware();
m.RequestModules = requestModules;
m.ResponseModules = responseModules;
m.Handler = handler;
return m;
}
public ServerBase(string[] urls, RequestHandler handler)
{
if (urls == null)
urls = new string[] { };
Urls = Array.AsReadOnly(urls);
Handler = handler;
}
public void RegisterPath(string path, RequestHandler handler)
{
LOGGER.DebugFormat("Registering path {0}", path);
if (m_RequestHandlers.ContainsKey(path))
throw new InvalidOperationException(string.Format("Request path [{0}] is already registered to this JSON server!", path));
m_RequestHandlers[path] = handler;
}
public ConnectRequestHandler(Reference @ref, Ice.ObjectPrx proxy)
{
_reference = @ref;
_response = _reference.getMode() == Reference.Mode.ModeTwoway;
_proxy = (Ice.ObjectPrxHelperBase)proxy;
_initialized = false;
_flushing = false;
_requestHandler = this;
}
/// <summary>
/// Registers request handlers available from successful login.
/// </summary>
public void RegisterUser()
{
mRequestHandlers[7] = new RequestHandler(InfoRetrieve);
mRequestHandlers[8] = new RequestHandler(GetCredits);
mRequestHandlers[12] = new RequestHandler(MessengerInit);
mRequestHandlers[26] = new RequestHandler(ScrGetUserInfo);
mRequestHandlers[157] = new RequestHandler(GetBadges);
mRequestHandlers[233] = new RequestHandler(GetIgnoredUsers);
mRequestHandlers[370] = new RequestHandler(GetAchievements);
}
public virtual IServer BuildServer(string host, int port, RequestHandler handler)
{
Assert.ArgumentNotNull(() => handler);
Assert.ArgumentSatisfy(() => host, s => !string.IsNullOrEmpty(s),
"Host cannot be null or empty.");
Assert.ArgumentSatisfy(() => port, p => 0 < p && p < 65536,
"Port must be between 0 and 65536 exclusive.");
return new HttpListenerServer(host, port, handler);
}
public ProcessRequestAsync()
{
var smtpClient = BackupSmtpClientBuilder.Build();
_emailDirectory = smtpClient.PickupDirectoryLocation;
if (!string.IsNullOrEmpty(_emailDirectory) && !Directory.Exists(_emailDirectory))
{
Directory.CreateDirectory(_emailDirectory);
}
_requestHandler = new RequestHandler(_emailDirectory);
}
public void Applies_One_Constraint()
{
var doesNotContainBlahConstraint = new Func<string, bool>(uri => uri.Contains("blah") == false);
var h = new RequestHandler("", null);
h.WithUrlConstraint(doesNotContainBlahConstraint);
var uriWithBlah = "http://www.blah.com";
Assert.That(h.CanVerifyConstraintsFor(uriWithBlah), Is.EqualTo(false));
}
public void ShouldRegisterCommandInOperationRegistry()
{
// Arrange
var operationRegistryMock = new Mock<IOperationRegistry>();
var requestHandler = new RequestHandler(operationRegistryMock.Object);
// Act
requestHandler.RegisterCommand("testCommand", new Action(() =>{}));
// Assert
operationRegistryMock.Verify(x => x.RegisterCommand("testCommand", It.IsAny<System.Delegate>()), Times.Once());
}
/// <summary>
/// Constructs this <see cref="MansionHttpHandlerBase"/> with the given <paramref name="requestHandler"/>.
/// </summary>
/// <param name="requestContext">The <see cref="MansionWebContext"/> for this request.</param>
/// <param name="requestHandler">The <see cref="RequestHandler"/> which does the actual work of handling the request.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="requestHandler"/> is null.</exception>
protected MansionHttpHandlerBase(MansionWebContext requestContext, RequestHandler requestHandler)
{
// validate arguments
if (requestContext == null)
throw new ArgumentNullException("requestContext");
if (requestHandler == null)
throw new ArgumentNullException("requestHandler");
// set values
webRequestContext = requestContext;
this.requestHandler = requestHandler;
}
public void ShouldHandlePingRequests()
{
// Arrange
var requestHandler = new RequestHandler(null);
// Act
var actual = requestHandler.HandleRequest("http://localhost:8100/ping", "", "GET");
// Assert
var responseString = actual.ResponseStream.ToString();
Assert.That(responseString, Is.EqualTo("pong"));
Assert.That(actual.StatusCode, Is.EqualTo(HttpStatusCode.OK));
}
/// <summary>
/// Registers the request handlers for the in-game messenger. ('Console')
/// </summary>
public void RegisterMessenger()
{
mRequestHandlers[15] = new RequestHandler(FriendListUpdate);
mRequestHandlers[33] = new RequestHandler(SendMsg);
mRequestHandlers[34] = new RequestHandler(SendRoomInvite);
mRequestHandlers[37] = new RequestHandler(AcceptBuddy);
mRequestHandlers[38] = new RequestHandler(DeclineBuddy);
mRequestHandlers[39] = new RequestHandler(RequestBuddy);
mRequestHandlers[40] = new RequestHandler(RemoveBuddy);
mRequestHandlers[41] = new RequestHandler(HabboSearch);
mRequestHandlers[233] = new RequestHandler(GetBuddyRequests);
mRequestHandlers[262] = new RequestHandler(FollowFriend);
}
//
// These functions allow this object to be reused, rather than reallocated.
//
public void reset(RequestHandler handler, string operation, Ice.OperationMode mode,
Dictionary<string, string> context, InvocationObserver observer)
{
_state = StateUnsent;
_exception = null;
_sent = false;
_handler = handler;
_observer = observer;
_encoding = Protocol.getCompatibleEncoding(handler.getReference().getEncoding());
Protocol.checkSupportedProtocol(Protocol.getCompatibleProtocol(_handler.getReference().getProtocol()));
writeHeader(operation, mode, context);
}
public Outgoing(RequestHandler handler, string operation, Ice.OperationMode mode,
Dictionary<string, string> context, InvocationObserver observer)
{
_state = StateUnsent;
_sent = false;
_handler = handler;
_observer = observer;
_encoding = Protocol.getCompatibleEncoding(handler.getReference().getEncoding());
_os = new BasicStream(_handler.getReference().getInstance(), Ice.Util.currentProtocolEncoding);
Protocol.checkSupportedProtocol(Protocol.getCompatibleProtocol(_handler.getReference().getProtocol()));
writeHeader(operation, mode, context);
}
private HttpConnectionHandler(Socket socket, RequestHandler httpProcessor)
{
this._socket = socket;
//
{
LingerOption linger = new LingerOption(true, 60);
_socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, linger);
// Object langer = _socket.GetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger);
}
_httpProcessor = httpProcessor;
_networkStream = new NetworkStream(_socket, FileAccess.ReadWrite, false);
}
removeRequestHandler(Reference rf, RequestHandler handler)
{
if(rf.getCacheConnection())
{
lock(this)
{
ConnectRequestHandler h;
if(_handlers.TryGetValue(rf, out h) && h == handler)
{
_handlers.Remove(rf);
}
}
}
}
public void ShouldHandleApiPostRequest()
{
// Arrange
var operationRegistryMock = new Mock<IOperationRegistry>();
var requestHandler = new RequestHandler(operationRegistryMock.Object);
operationRegistryMock.Setup(x => x.InvokeCommand("command", It.IsAny<Dictionary<string, string>>())).Returns("result");
// Act
var actual = requestHandler.HandleRequest("http://localhost:8100/api/command?param1=42", "", "GET");
// Assert
var responseString = actual.ResponseStream.ToString();
Assert.That(responseString, Is.EqualTo("\"result\""));
Assert.That(actual.StatusCode, Is.EqualTo(HttpStatusCode.OK));
}
public void ShouldReturn404WhenFileNotFound()
{
// Arrange
var requestHandler = new RequestHandler(null);
requestHandler.RegisterAssembly(Assembly.GetAssembly(GetType()), "", "Resources");
// Act
var actual = requestHandler.HandleRequest("http://localhost:8100/favicon.ico", "", "GET");
// Assert
Assert.That(actual.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
var responseString = actual.ResponseStream.ToString();
Assert.That(responseString, Is.EqualTo("http://localhost:8100/favicon.ico not found."));
}
public Task <IActionResult> DeleteCustomer(PrivateCustomerCommandDto.DeleteCustomer request) => RequestHandler.HandleCommand(request, Application.Handle, Log);
public IRequestWorker Create(RequestHandler requestHander)
{
return(new RequestWorker(requestHander));
}
public RequestWorker(RequestHandler handler, ThreadType threadType) : base(handler, threadType)
{
}
public void Use(RequestHandler handler) => RegisterHandler("/", handler);
/// <summary>
/// 财付通支付接口
/// </summary>
/// <returns></returns>
public ActionResult Index(string id) //传入订单ID 输入订单价格等信息 订单必须是未支付状态
{
try
{
var order = psv.GetOrderByOrderNo(id);
var tenpay_id = ConfigurationManager.AppSettings["tenpay_bargainor_id"]; //商户号
var tenpay_key = ConfigurationManager.AppSettings["tenpay_key"]; //密钥
//创建RequestHandler实例
RequestHandler reqHandler = new RequestHandler(HttpContext);
//通信对象
TenpayHttpClient httpClient = new TenpayHttpClient();
//应答对象
ClientResponseHandler resHandler = new ClientResponseHandler();
reqHandler.init();
//设置密钥
reqHandler.setKey(TenpayUtil.tenpay_key);
reqHandler.setGateUrl("https://wap.tenpay.com/cgi-bin/wappayv2.0/wappay_init.cgi");
//-----------------------------
//设置支付初始化参数
//-----------------------------
reqHandler.setParameter("ver", "2.0");
reqHandler.setParameter("charset", "1");
reqHandler.setParameter("bank_type", "0");
reqHandler.setParameter("desc", "蛋糕"); //订单描述
reqHandler.setParameter("bargainor_id", tenpay_id);
reqHandler.setParameter("sp_billno", order.No); //订单号
reqHandler.setParameter("total_fee", (Convert.ToDouble(order.NeedPay) * 100).ToString());
reqHandler.setParameter("fee_type", "1");
reqHandler.setParameter("notify_url", ConfigurationManager.AppSettings["tenpay_notify"]);
reqHandler.setParameter("callback_url", ConfigurationManager.AppSettings["tenpay_return"]);
reqHandler.setParameter("attach", "attach");
string initRequestUrl = reqHandler.getRequestURL();
//设置请求内容
httpClient.setReqContent(initRequestUrl);
//设置超时
httpClient.setTimeOut(5);
string rescontent = "";
string payRequestUrl = "";
//后台调用
if (httpClient.call())
{
//获取结果
rescontent = httpClient.getResContent();
//设置结果参数
resHandler.setContent(rescontent);
string token_id = resHandler.getParameter("token_id");
//成功，则token_id有只
if (token_id != "")
{
//生成支付请求
payRequestUrl = "https://wap.tenpay.com/cgi-bin/wappayv2.0/wappay_gate.cgi?token_id=" + TenpayUtil.UrlEncode(token_id, Request.ContentEncoding.BodyName);
return(Redirect(payRequestUrl));
}
else
{
return(Content("支付初始化错误:" + resHandler.getParameter("err_info") + "<br>"));
}
}
else
{
return(Content("call err:" + httpClient.getErrInfo() + "<br>" + httpClient.getResponseCode() + "<br>"));
}
}
catch
{
return(Content("支付失败"));
}
}
public RoutingContext(RequestHandler requestHandler, IEnumerable <string> parameters)
{
Parameters = new List <string>();
this.RequestHandler = requestHandler;
this.Parameters = parameters;
}
public AsyncTask(RequestHandler requestHandler, IODataRequestMessage requestMessage, DateTime dueAt)
{
this.requestHandler = requestHandler;
this.requestMessage = requestMessage;
this.dueAt = dueAt;
}
protected void Page_Load(object sender, EventArgs e)
{
//读取站点配置信息
Model.siteconfig siteConfig = new BLL.siteconfig().loadConfig();
TenpayUtil xmlConfig = new TenpayUtil();
//=============================获得订单信息================================
string order_no = DTRequest.GetFormString("pay_order_no").ToUpper(); //订单号
decimal order_amount = DTRequest.GetFormDecimal("pay_order_amount", 0); //订单金额
string user_name = DTRequest.GetFormString("pay_user_name"); //支付用户名
string subject = DTRequest.GetFormString("pay_subject"); //备注说明
string trans_type = string.Empty; //交易类型1实物2虚拟
if (order_no == "" || order_amount == 0)
{
Response.Redirect(new Web.UI.BasePage().linkurl("error", "?msg=" + Utils.UrlEncode("对不起，您提交的参数有误！")));
return;
}
if (order_no.StartsWith("R")) //R开头为在线充值订单
{
Model.user_recharge model = new BLL.user_recharge().GetModel(order_no);
if (model == null)
{
Response.Redirect(new Web.UI.BasePage().linkurl("error", "?msg=" + Utils.UrlEncode("对不起，您充值的订单号不存在或已删除！")));
return;
}
if (model.amount != order_amount)
{
Response.Redirect(new Web.UI.BasePage().linkurl("error", "?msg=" + Utils.UrlEncode("对不起，您充值的订单金额与实际金额不一致！")));
return;
}
trans_type = "2";
}
else //B开头为商品订单
{
Model.orders model = new BLL.orders().GetModel(order_no);
if (model == null)
{
Response.Redirect(new Web.UI.BasePage().linkurl("error", "?msg=" + Utils.UrlEncode("对不起，您支付的订单号不存在或已删除！")));
return;
}
if (model.order_amount != order_amount)
{
Response.Redirect(new Web.UI.BasePage().linkurl("error", "?msg=" + Utils.UrlEncode("对不起，您支付的订单金额与实际金额不一致！")));
return;
}
trans_type = "1";
}
//检查会员还是匿名
if (!string.IsNullOrEmpty(user_name))
{
user_name = "支付会员：" + user_name;
}
else
{
user_name = "匿名用户";
}
//===============================请求参数==================================
//创建RequestHandler实例
RequestHandler reqHandler = new RequestHandler(Context);
//初始化
reqHandler.init();
//设置密钥
reqHandler.setKey(xmlConfig.key);
reqHandler.setGateUrl("https://gw.tenpay.com/gateway/pay.htm");
//-----------------------------
//设置支付参数
//-----------------------------
reqHandler.setParameter("partner", xmlConfig.partner); //商户号
reqHandler.setParameter("out_trade_no", order_no); //商家订单号
reqHandler.setParameter("total_fee", (Convert.ToDouble(order_amount) * 100).ToString()); //商品金额,以分为单位
reqHandler.setParameter("return_url", xmlConfig.return_url); //交易完成后跳转的URL
reqHandler.setParameter("notify_url", xmlConfig.notify_url); //接收财付通通知的URL
reqHandler.setParameter("body", user_name); //商品描述
reqHandler.setParameter("bank_type", "DEFAULT"); //银行类型(中介担保时此参数无效)
reqHandler.setParameter("spbill_create_ip", Page.Request.UserHostAddress); //用户的公网ip，不是商户服务器IP
reqHandler.setParameter("fee_type", "1"); //币种，1人民币
reqHandler.setParameter("subject", siteConfig.webname + "-" + subject); //商品名称(中介交易时必填)
//系统可选参数
reqHandler.setParameter("sign_type", "MD5");
reqHandler.setParameter("service_version", "1.0");
reqHandler.setParameter("input_charset", "UTF-8");
reqHandler.setParameter("sign_key_index", "1");
//业务可选参数
reqHandler.setParameter("product_fee", "0"); //商品费用，必须保证transport_fee + product_fee=total_fee
reqHandler.setParameter("transport_fee", "0"); //物流费用，必须保证transport_fee + product_fee=total_fee
reqHandler.setParameter("time_start", DateTime.Now.ToString("yyyyMMddHHmmss")); //订单生成时间，格式为yyyymmddhhmmss
reqHandler.setParameter("time_expire", ""); //订单失效时间，格式为yyyymmddhhmmss
reqHandler.setParameter("buyer_id", ""); //买方财付通账号
reqHandler.setParameter("goods_tag", ""); //商品标记
reqHandler.setParameter("trade_mode", xmlConfig.type); //交易模式，1即时到账(默认)，2中介担保，3后台选择（买家进支付中心列表选择）
reqHandler.setParameter("transport_desc", ""); //物流说明
reqHandler.setParameter("trans_type", "1"); //交易类型，1实物交易，2虚拟交易
reqHandler.setParameter("agentid", ""); //平台ID
reqHandler.setParameter("agent_type", ""); //代理模式，0无代理(默认)，1表示卡易售模式，2表示网店模式
reqHandler.setParameter("seller_id", ""); //卖家商户号，为空则等同于partner
//获取请求带参数的url
string requestUrl = reqHandler.getRequestURL();
//实现自动跳转===============================
StringBuilder sbHtml = new StringBuilder();
sbHtml.Append("<form id='tenpaysubmit' name='tenpaysubmit' action='" + reqHandler.getGateUrl() + "' method='get'>");
Hashtable ht = reqHandler.getAllParameters();
foreach (DictionaryEntry de in ht)
{
sbHtml.Append("<input type=\"hidden\" name=\"" + de.Key + "\" value=\"" + de.Value + "\" >\n");
}
//submit按钮控件请不要含有name属性
sbHtml.Append("<input type='submit' value='确认' style='display:none;'></form>");
sbHtml.Append("<script>document.forms['tenpaysubmit'].submit();</script>");
Response.Write(sbHtml.ToString());
}
public MessageCallImpl(RequestHandler requestHandler, ILoggerFactory factory, BusyFlag busyFlag)
{
_busyFlag = busyFlag;
_requestHandler = requestHandler;
_logger = factory.CreateLogger("NetRpc");
}
/// <summary>
/// 退款接口,可重复提交得到状态
/// </summary>
/// <param name="order"></param>
/// <param name="message"></param>
/// <returns></returns>
public override bool RefundOrder(PayHistory order, out string message)
{
#region 退款
RequestHandler reqHandler = new RequestHandler(HttpContext.Current);
//通信对象
TenpayHttpClient httpClient = new TenpayHttpClient();
ClientResponseHandler resHandler = new ClientResponseHandler();
//-----------------------------
//设置请求参数
//-----------------------------
reqHandler.init();
reqHandler.setKey(key);
reqHandler.setGateUrl("https://mch.tenpay.com/refundapi/gateway/refund.xml");
reqHandler.setParameter("partner", bargainor_id);
//out_trade_no和transaction_id至少一个必填，同时存在时transaction_id优先
//reqHandler.setParameter("out_trade_no", order.OrderId);
reqHandler.setParameter("transaction_id", order.OrderId);
reqHandler.setParameter("out_refund_no", order.OrderId + "C");
reqHandler.setParameter("total_fee", (order.Amount * 100).ToString());
reqHandler.setParameter("refund_fee", (order.Amount * 100).ToString());
reqHandler.setParameter("op_user_id", bargainor_id);
reqHandler.setParameter("op_user_passwd", ChargeConfig.GetConfigKey(ThisCompanyType, ChargeConfig.DataType.PayPass));
string requestUrl = reqHandler.getRequestURL();
//证书和证书密码
httpClient.setCertInfo(ChargeConfig.GetConfigKey(ThisCompanyType, ChargeConfig.DataType.CertFile), bargainor_id);
//设置请求内容
httpClient.setReqContent(requestUrl);
//设置超时
httpClient.setTimeOut(10);
string rescontent = "";
//后台调用
if (!httpClient.call())
{
message = "接口调用失败";
return(false);
}
//获取结果
rescontent = httpClient.getResContent();
resHandler.setKey(key);
//设置结果参数
resHandler.setContent(rescontent);
message = resHandler.getParameter("retmsg");
//Log("退款返回结果为:" + rescontent);
//判断签名及结果
if (!resHandler.isTenpaySign())
{
message = "返回签名验证错误";
return(false);
}
if (resHandler.getParameter("retcode") != "0")
{
return(false);
}
//商户订单号
string out_trade_no = resHandler.getParameter("out_trade_no");
//财富通订单号
string transaction_id = resHandler.getParameter("transaction_id");
// 退款状态：
//4，10：退款成功。
//3，5，6：退款失败。
//8，9，11：退款处理中。
//1，2：未确定，需要商户原退款单号重新发起。
//7：转入代发，退款到银行发现用户的卡作废或者冻结了，导致原路退款银行卡失败，资金回流到商户的现金帐号，需要商户人工干预，通过线下或者财富通转账的方式进行退款
string refund_status = resHandler.getParameter("refund_status");
if (refund_status == "4" || refund_status == "10")
{
string recv_user_id = resHandler.getParameter("recv_user_id");
string reccv_user_name = resHandler.getParameter("reccv_user_name");
//Log("退款接收人信息为:" + recv_user_id + " " + reccv_user_name);
BaseRefundOrder(order);
return(true);
}
if (refund_status == "8" || refund_status == "9" || refund_status == "11")
{
//todo 自动重复查询
message = "退款处理中";
return(true);
}
return(false);
#endregion
}
public override bool CheckOrder(PayHistory order, out string message)
{
//创建请求对象
RequestHandler reqHandler = new RequestHandler(HttpContext.Current);
//通信对象
TenpayHttpClient httpClient = new TenpayHttpClient();
//应答对象
ClientResponseHandler resHandler = new ClientResponseHandler();
//-----------------------------
//设置请求参数
//-----------------------------
reqHandler.init();
reqHandler.setKey(key);
reqHandler.setGateUrl("https://gw.tenpay.com/gateway/normalorderquery.xml");
reqHandler.setParameter("partner", bargainor_id);
//out_trade_no和transaction_id至少一个必填，同时存在时transaction_id优先
reqHandler.setParameter("out_trade_no", order.OrderId);
//reqHandler.setParameter("transaction_id", "1900000109201103020030626316");
string requestUrl = reqHandler.getRequestURL();
//设置请求内容
httpClient.setReqContent(requestUrl);
//设置超时
httpClient.setTimeOut(10);
string rescontent = "";
//后台调用
if (httpClient.call())
{
//获取结果
rescontent = httpClient.getResContent();
resHandler.setKey(key);
//设置结果参数
resHandler.setContent(rescontent);
//判断签名及结果
if (resHandler.isTenpaySign() && resHandler.getParameter("retcode") == "0")
{
//商户订单号
string out_trade_no = resHandler.getParameter("out_trade_no");
//财富通订单号
string transaction_id = resHandler.getParameter("transaction_id");
//金额,以分为单位
string total_fee = resHandler.getParameter("total_fee");
//如果有使用折扣券，discount有值，total_fee+discount=原请求的total_fee
string discount = resHandler.getParameter("discount");
//支付结果
string trade_state = resHandler.getParameter("trade_state");
//支付成功
if (trade_state == "0")
{
if (order.Status != OrderStatus.已确认)
{
Confirm(order, GetType(), order.Amount);
}
message = "成功";
return(true);
}
}
else
{
message = "失败";
return(false);
}
}
else
{
message = "服务器返回:" + httpClient.getResponseCode();
return(false);
}
message = "失败";
return(false);
}
protected override string OnNotify(System.Web.HttpContext context)
{
var handler = new ResponseHandler(context);
handler.setKey(key);
if (handler.isTenpaySign())
{
///通知id
string notify_id = handler.getParameter("notify_id");
//通过通知ID查询，确保通知来至财富通
//创建查询请求
RequestHandler queryReq = new RequestHandler(context);
queryReq.init();
queryReq.setKey(key);
queryReq.setGateUrl("https://gw.tenpay.com/gateway/verifynotifyid.xml");
queryReq.setParameter("partner", bargainor_id);
queryReq.setParameter("notify_id", notify_id);
//通信对象
TenpayHttpClient httpClient = new TenpayHttpClient();
httpClient.setTimeOut(5);
//设置请求内容
httpClient.setReqContent(queryReq.getRequestURL());
if (httpClient.call())
{
//设置结果参数
ClientResponseHandler queryRes = new ClientResponseHandler();
queryRes.setContent(httpClient.getResContent());
queryRes.setKey(key);
//判断签名及结果
//只有签名正确,retcode为0，trade_state为0才是支付成功
if (queryRes.isTenpaySign() && queryRes.getParameter("retcode") == "0" && queryRes.getParameter("trade_state") == "0" && queryRes.getParameter("trade_mode") == "1")
{
string out_trade_no = queryRes.getParameter("out_trade_no");
//财富通订单号
string transaction_id = queryRes.getParameter("transaction_id");
//金额,以分为单位
string total_fee = queryRes.getParameter("total_fee");
PayHistory order = OnlinePayBusiness.Instance.GetOrder(out_trade_no, ThisCompanyType);
if (order == null)
{
CoreHelper.EventLog.Log(string.Format("在线支付确认时找不到订单{0} 订单号{1}", ThisCompanyType, out_trade_no), true);
//context.Response.Write("fail");
return("fail");
}
order.SpBillno = transaction_id;
decimal fee = Convert.ToDecimal(total_fee);
lock (thisLock)
{
Confirm(order, GetType(), fee / 100);
}
//context.Response.Write("success");
return("success");
}
}
}
//context.Response.Write("fail");
return("fail");
}
/// <summary>
/// Creates a new EveCentral object, with a default base uri and request handler.
/// </summary>
public EveCentral()
{
BaseUri = new Uri(DefaultUri);
RequestHandler = new RequestHandler(new XmlSerializer());
}
public RabbitMQHostedService(IOptions <RabbitMQServiceOptions> mqOptions, BusyFlag busyFlag, RequestHandler requestHandler, ILoggerFactory factory)
{
_busyFlag = busyFlag;
_logger = factory.CreateLogger("NetRpc");
_requestHandler = requestHandler;
Reset(mqOptions.Value);
}
public RoutingContext(IEnumerable <string> parameters, RequestHandler requestHandler)
{
this.Parameters = parameters;
this.RequestHandler = requestHandler;
}
protected void btnAgreeRefund_Click(object sender, EventArgs e)
{
try
{
var refundBll = new BLL.wx_diancai_tuidan_manage();
var refundResult = refundBll.GetWeChatRefundParams(shopid, orderID, refundCode);
//使用系统订单号退单
if (refundResult != null && refundResult.Tables.Count > 0 && refundResult.Tables[0].Rows.Count > 0)
{
var orderNumber = refundResult.Tables[0].Rows[0]["orderNumber"].ToString();
var transaction_id = refundResult.Tables[0].Rows[0]["transaction_id"].ToString();
var refundAmount = Convert.ToInt32(refundResult.Tables[0].Rows[0]["refundAmount"]);
var payAmount = Convert.ToInt32(refundResult.Tables[0].Rows[0]["payAmount"]);
var shopInfo = new BLL.wx_diancai_shopinfo().GetModel(shopid);
var wxModel = new BLL.wx_userweixin().GetModel((int)shopInfo.wid);
var payInfo = new BLL.wx_payment_wxpay().GetModelByWid((int)shopInfo.wid);
var requestHandler = new RequestHandler(null);
requestHandler.SetParameter("out_trade_no", orderNumber);
//requestHandler.SetParameter("transaction_id", transaction_id);
requestHandler.SetParameter("out_refund_no", refundCode);
requestHandler.SetParameter("appid", wxModel.AppId);
requestHandler.SetParameter("mch_id", payInfo.mch_id);//商户号
requestHandler.SetParameter("nonce_str", Guid.NewGuid().ToString().Replace("-", ""));
//退款金额
if (PayHelper.IsDebug)
{
requestHandler.SetParameter("total_fee", (payAmount / 100).ToString());
requestHandler.SetParameter("refund_fee", (refundAmount / 100).ToString());
}
else
{
requestHandler.SetParameter("total_fee", payAmount.ToString());
requestHandler.SetParameter("refund_fee", refundAmount.ToString());
}
requestHandler.SetParameter("op_user_id", wxModel.AppId);
requestHandler.SetParameter("sign", requestHandler.CreateMd5Sign("key", payInfo.paykey));
var refundInfo = TenPayV3Helper.Refund(requestHandler.ParseXML(), string.Format(@"{0}{1}", AppDomain.CurrentDomain.BaseDirectory, payInfo.certInfoPath), payInfo.cerInfoPwd);
var refundOrderResponse = new RefundOrderResponse(refundInfo);
if (refundOrderResponse.IsSuccess)
{
new BLL.wx_diancai_tuidan_manage().RefundComplete(refundCode, this.txtRefundReason.Value.Trim());
Response.Redirect("diancai_dingdanRefund_manage.aspx");
}
else
{
Response.Write(refundOrderResponse.return_msg);
List();
}
}
}
catch (Exception exception)
{
Response.Write(exception.Message);
Response.Write(exception.StackTrace);
List();
}
}
public void Get_project_estimated()
{
var repo = new ProjectRepository(REPO_PATH);
var mail = new MockMailProvider();
var sut = new RequestHandler(repo, mail);
// create project
var projectId = "123abc";
var prjId = sut.Create_project(new CreateProjectRequestDto {
Id = projectId,
Title = "P1",
ProductOwnerEmail = "*****@*****.**",
Items = new[] { "a", "b", "c" },
SummaryPageUrlSchema = "summary/{projectid}",
RearrangePageUrlSchema = "rearrange/{PROJECTID}"
});
Assert.IsTrue(mail.Body.IndexOf("summary/" + projectId) > 0);
Assert.IsTrue(mail.Body.IndexOf("rearrange/" + projectId) > 0);
// initial summary shows items in original order
var summary = sut.Generate_project_summary(prjId);
Assert.AreEqual("P1", summary.Title);
Assert.AreEqual(0, summary.NumberOfSubmissions);
Assert.AreEqual(new[] { "a", "b", "c" }, summary.Items);
// retrieve items for ordering
var items = sut.Retrieve_project_items(prjId);
Assert.AreEqual("P1", items.Title);
Assert.AreEqual("0", items.Items[0].Id);
Assert.AreEqual("a", items.Items[0].Text);
Assert.AreEqual("1", items.Items[1].Id);
Assert.AreEqual("b", items.Items[1].Text);
Assert.AreEqual("2", items.Items[2].Id);
Assert.AreEqual("c", items.Items[2].Text);
// submit first total order
sut.Submit_ordered_items(prjId, new TotalOrderSubmissionDto {
StakeholderEmail = "*****@*****.**",
ItemIds = new[] { "0", "2", "1" }
});
Assert.IsTrue(mail.Body.IndexOf("summary/" + projectId) > 0);
// summary reflects first total order
summary = sut.Generate_project_summary(prjId);
Assert.AreEqual("P1", summary.Title);
Assert.AreEqual(1, summary.NumberOfSubmissions);
Assert.AreEqual(new[] { "a", "c", "b" }, summary.Items);
// submit second total order
sut.Submit_ordered_items(prjId, new TotalOrderSubmissionDto {
StakeholderEmail = "*****@*****.**",
ItemIds = new[] { "2", "1", "0" }
});
// summary reflects second total order
// 0:0+2=2, 1:2+1=3, 2:1+0=1
summary = sut.Generate_project_summary(prjId);
Assert.AreEqual(2, summary.NumberOfSubmissions);
Assert.AreEqual(new[] { "c", "a", "b" }, summary.Items);
}
public async Task MockExecuteWithDebugLoggerTest()
{
string xml = @"<?xml version=""1.0"" encoding=""UTF-8""?>
<response>
<control>
<status>success</status>
<senderid>testsenderid</senderid>
<controlid>sessionProvider</controlid>
<uniqueid>false</uniqueid>
<dtdversion>3.0</dtdversion>
</control>
<operation>
<authentication>
<status>success</status>
<userid>testuser</userid>
<companyid>testcompany</companyid>
<sessiontimestamp>2015-12-06T15:57:08-08:00</sessiontimestamp>
</authentication>
<result>
<status>success</status>
<function>getAPISession</function>
<controlid>func1UnitTest</controlid>
<data>
<api>
<sessionid>unittest..</sessionid>
<endpoint>https://unittest.intacct.com/ia/xml/xmlgw.phtml</endpoint>
</api>
</data>
</result>
</operation>
</response>";
HttpResponseMessage mockResponse = new HttpResponseMessage()
{
StatusCode = System.Net.HttpStatusCode.OK,
Content = new StringContent(xml)
};
List <HttpResponseMessage> mockResponses = new List <HttpResponseMessage>
{
mockResponse,
};
MockHandler mockHandler = new MockHandler(mockResponses);
var guid = Guid.NewGuid().ToString();
MemoryTarget target = new MemoryTarget
{
Name = guid,
Layout = "${message}"
};
SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Debug);
ClientConfig clientConfig = new ClientConfig()
{
SenderId = "testsenderid",
SenderPassword = "******",
SessionId = "testsession..",
MockHandler = mockHandler,
Logger = LogManager.GetLogger(guid),
};
RequestConfig requestConfig = new RequestConfig();
List <IFunction> contentBlock = new List <IFunction>
{
new ApiSessionCreate()
};
RequestHandler requestHandler = new RequestHandler(clientConfig, requestConfig);
OnlineResponse response = await requestHandler.ExecuteOnline(contentBlock);
// Check for the user agent
Assert.True(true); // TODO fix this test from randomly failing
//Assert.Contains("intacct-api-net-client/", target.Logs[0]);
}
public Task <IActionResult> Post(V1.Create request)
{
return(RequestHandler.HandleCommand(request, _applicationService.Handle, _logger));
}
public ActionResult NativeCall()
{
string sp_billno = Request.Form["order_no"];
//当前时间 yyyyMMdd
string date = SystemTime.Now.ToString("yyyyMMdd");
//订单号，此处用时间和随机数生成，商户根据自己调整，保证唯一
string out_trade_no = "" + SystemTime.Now.ToString("HHmmss") + TenPayUtil.BuildRandomStr(4);
if (null == sp_billno)
{
//生成订单10位序列号，此处用时间和随机数生成，商户根据自己调整，保证唯一
sp_billno = SystemTime.Now.ToString("HHmmss") + TenPayUtil.BuildRandomStr(4);
}
else
{
sp_billno = Request.Form["order_no"].ToString();
}
sp_billno = TenPayInfo.PartnerId + sp_billno;
//创建RequestHandler实例
RequestHandler packageReqHandler = new RequestHandler(null);
//初始化
packageReqHandler.Init();
packageReqHandler.SetKey(TenPayInfo.Key);
//设置package订单参数
packageReqHandler.SetParameter("partner", TenPayInfo.PartnerId); //商户号
packageReqHandler.SetParameter("bank_type", "WX"); //银行类型
packageReqHandler.SetParameter("fee_type", "1"); //币种，1人民币
packageReqHandler.SetParameter("input_charset", "GBK");
packageReqHandler.SetParameter("out_trade_no", sp_billno); //商家订单号
packageReqHandler.SetParameter("total_fee", "1"); //商品金额,以分为单位(money * 100).ToString()
packageReqHandler.SetParameter("notify_url", TenPayInfo.TenPayNotify); //接收财付通通知的URL
packageReqHandler.SetParameter("body", "nativecall"); //商品描述
packageReqHandler.SetParameter("spbill_create_ip", "8.8.8.8" /*Page.Request.UserHostAddress*/); //用户的公网ip，不是商户服务器IP
//获取package包
string packageValue = packageReqHandler.GetRequestURL();
//调起微信支付签名
string timeStamp = TenPayUtil.GetTimestamp();
string nonceStr = TenPayUtil.GetNoncestr();
//设置支付参数
RequestHandler payHandler = new RequestHandler(null);
payHandler.SetParameter("appid", TenPayInfo.AppId);
payHandler.SetParameter("noncestr", nonceStr);
payHandler.SetParameter("timestamp", timeStamp);
payHandler.SetParameter("package", packageValue);
payHandler.SetParameter("RetCode", "0");
payHandler.SetParameter("RetErrMsg", "成功");
string paySign = payHandler.CreateSHA1Sign();
payHandler.SetParameter("app_signature", paySign);
payHandler.SetParameter("sign_method", "SHA1");
Response.ContentType = "text/xml";
Response.Clear();
ViewData["payHandler"] = payHandler.ParseXML();
return(View());
}
public async Task MockExecuteOfflineWithSessionCredsTest()
{
string xml = @"<?xml version=""1.0"" encoding=""UTF-8""?>
<response>
<acknowledgement>
<status>success</status>
</acknowledgement>
<control>
<status>success</status>
<senderid>testsenderid</senderid>
<controlid>requestUnitTest</controlid>
<uniqueid>false</uniqueid>
<dtdversion>3.0</dtdversion>
</control>
</response>";
HttpResponseMessage mockResponse = new HttpResponseMessage()
{
StatusCode = System.Net.HttpStatusCode.OK,
Content = new StringContent(xml)
};
List <HttpResponseMessage> mockResponses = new List <HttpResponseMessage>
{
mockResponse,
};
MockHandler mockHandler = new MockHandler(mockResponses);
var guid = Guid.NewGuid().ToString();
MemoryTarget target = new MemoryTarget
{
Name = guid,
Layout = "${message}"
};
SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Debug);
ClientConfig clientConfig = new ClientConfig()
{
SenderId = "testsenderid",
SenderPassword = "******",
SessionId = "testsession..",
MockHandler = mockHandler,
Logger = LogManager.GetLogger(guid),
};
RequestConfig requestConfig = new RequestConfig()
{
ControlId = "requestUnitTest",
PolicyId = "policyid123",
};
List <IFunction> contentBlock = new List <IFunction>
{
new ApiSessionCreate()
};
RequestHandler requestHandler = new RequestHandler(clientConfig, requestConfig);
OfflineResponse response = await requestHandler.ExecuteOffline(contentBlock);
Assert.True(true); // TODO fix this test from randomly failing
//Assert.Contains("Offline execution sent to Intacct using Session-based credentials.", target.Logs[0]);
}
public IRequestWorker Create(RequestHandler requestHander, ThreadType threadType)
{
return(new RequestWorker(requestHander, threadType));
}
public async Task MockDefaultRetryFailureTest()
{
HttpResponseMessage mockResponse1 = new HttpResponseMessage()
{
StatusCode = HttpStatusCode.InternalServerError,
};
HttpResponseMessage mockResponse2 = new HttpResponseMessage()
{
StatusCode = HttpStatusCode.NotImplemented,
};
HttpResponseMessage mockResponse3 = new HttpResponseMessage()
{
StatusCode = HttpStatusCode.BadGateway,
};
HttpResponseMessage mockResponse4 = new HttpResponseMessage()
{
StatusCode = HttpStatusCode.GatewayTimeout,
};
HttpResponseMessage mockResponse5 = new HttpResponseMessage()
{
StatusCode = HttpStatusCode.HttpVersionNotSupported,
};
HttpResponseMessage mockResponse6 = new HttpResponseMessage()
{
StatusCode = HttpStatusCode.InternalServerError,
};
List <HttpResponseMessage> mockResponses = new List <HttpResponseMessage>
{
mockResponse1,
mockResponse2,
mockResponse3,
mockResponse4,
mockResponse5,
mockResponse6,
};
MockHandler mockHandler = new MockHandler(mockResponses);
ClientConfig clientConfig = new ClientConfig()
{
SenderId = "testsenderid",
SenderPassword = "******",
SessionId = "testsession..",
MockHandler = mockHandler,
};
RequestConfig requestConfig = new RequestConfig();
List <IFunction> contentBlock = new List <IFunction>
{
new ApiSessionCreate()
};
RequestHandler requestHandler = new RequestHandler(clientConfig, requestConfig);
var ex = await Record.ExceptionAsync(() => requestHandler.ExecuteOnline(contentBlock));
Assert.IsType <HttpRequestException>(ex);
Assert.Equal("Request retry count exceeded max retry count: 5", ex.Message);
}
/// <summary>
/// Add XML-RPC responder factory that will be called for each request.
/// </summary>
/// <typeparam name="TResponder"></typeparam>
/// <param name="instanceFactory"></param>
/// <returns></returns>
public XmlRpcMiddleware Add <TResponder>(Func <TResponder> instanceFactory) where TResponder : class
{
RequestHandler.Add(instanceFactory);
return(this);
}
public MsgDispatcher(Channel channel, MessageListener l, MembershipListener l2, RequestHandler req_handler, MessageResponder responder, bool deadlock_detection, bool concurrent_processing)
{
this.channel = channel;
this._ncacheLog = ((GroupChannel)channel).NCacheLog;
this.deadlock_detection = deadlock_detection;
this.concurrent_processing = concurrent_processing;
msg_listener = l;
membership_listener = l2;
_req_handler = req_handler;
_msgResponder = responder;
channel.UpHandler = this;
start();
}
protected void Page_Load(object sender, EventArgs e)
{
int order_id = RequestTool.RequestInt("order_id", 0);
Lebi_Order order = B_Lebi_Order.GetModel(order_id);
if (order == null)
{
Response.Write("ERROR");
Response.End();
return;
}
Lebi_Language language = B_Lebi_Language.GetModel(order.Language_id);
if (order.IsPaid == 1)
{
Response.Write(Language.Tag("已付款", language.Code));
Response.End();
return;
}
order.Site_id_pay = CurrentSite.id;
order.Language_id = CurrentLanguage.id;
Lebi_OnlinePay pay = Shop.Bussiness.Money.GetOnlinePay(order, "tenpayJSDZ");
if (pay == null)
{
Response.Write("系统错误");
Response.End();
return;
}
if (pay.FeeRate > 0)
{
order.Money_OnlinepayFee = order.Money_Pay * pay.FeeRate / 100;
}
if (order.OnlinePay_id != pay.id)
{
order.OnlinePay_id = pay.id;
order.OnlinePay_Code = pay.Code;
order.OnlinePay = pay.Name;
}
B_Lebi_Order.Update(order);
Lebi_Currency currendy = B_Lebi_Currency.GetModel(pay.Currency_id);
string sp_billno = order.Code;
string product_name = order.Code;
string order_price = (order.Money_Pay * currendy.ExchangeRate * (1 + (pay.FeeRate / 100))).ToString("f" + currendy.DecimalLength + "");
string remarkexplain = "";
double money = 0;
try
{
money = Convert.ToDouble(order_price);
}
catch
{
//Response.Write("支付金额格式错误！");
//Response.End();
//return;
}
//if (null == sp_billno)
//{
// //生成订单10位序列号，此处用时间和随机数生成，商户根据自己调整，保证唯一
// sp_billno = DateTime.Now.ToString("HHmmss") + TenpayUtil.BuildRandomStr(4);
//}
//else
//{
// sp_billno = Request["order_no"].ToString();
//}
//创建RequestHandler实例
RequestHandler reqHandler = new RequestHandler(Context);
//初始化
reqHandler.init();
TenpayUtil tu = new TenpayUtil(order);
//设置密钥
reqHandler.setKey(tu.tenpay_key);
reqHandler.setGateUrl("https://gw.tenpay.com/gateway/pay.htm");
//-----------------------------
//设置支付参数
//-----------------------------
reqHandler.setParameter("partner", tu.bargainor_id); //商户号
reqHandler.setParameter("out_trade_no", sp_billno); //商家订单号
reqHandler.setParameter("total_fee", (money * 100).ToString()); //商品金额,以分为单位
reqHandler.setParameter("return_url", tu.tenpay_return); //交易完成后跳转的URL
reqHandler.setParameter("notify_url", tu.tenpay_notify); //接收财付通通知的URL
reqHandler.setParameter("body", order.Code); //商品描述
reqHandler.setParameter("bank_type", "DEFAULT"); //银行类型(中介担保时此参数无效)
reqHandler.setParameter("spbill_create_ip", Page.Request.UserHostAddress); //用户的公网ip，不是商户服务器IP
reqHandler.setParameter("fee_type", "1"); //币种，1人民币
reqHandler.setParameter("subject", product_name); //商品名称(中介交易时必填)
//系统可选参数
reqHandler.setParameter("sign_type", "MD5");
reqHandler.setParameter("service_version", "1.0");
reqHandler.setParameter("input_charset", "UTF-8");
reqHandler.setParameter("sign_key_index", "1");
//业务可选参数
reqHandler.setParameter("attach", ""); //附加数据，原样返回
reqHandler.setParameter("product_fee", "0"); //商品费用，必须保证transport_fee + product_fee=total_fee
reqHandler.setParameter("transport_fee", "0"); //物流费用，必须保证transport_fee + product_fee=total_fee
reqHandler.setParameter("time_start", DateTime.Now.ToString("yyyyMMddHHmmss")); //订单生成时间，格式为yyyymmddhhmmss
reqHandler.setParameter("time_expire", ""); //订单失效时间，格式为yyyymmddhhmmss
reqHandler.setParameter("buyer_id", ""); //买方财付通账号
reqHandler.setParameter("goods_tag", ""); //商品标记
reqHandler.setParameter("trade_mode", "1"); //交易模式，1即时到账(默认)，2中介担保，3后台选择（买家进支付中心列表选择）
reqHandler.setParameter("transport_desc", ""); //物流说明
reqHandler.setParameter("trans_type", "1"); //交易类型，1实物交易，2虚拟交易
reqHandler.setParameter("agentid", ""); //平台ID
reqHandler.setParameter("agent_type", ""); //代理模式，0无代理(默认)，1表示卡易售模式，2表示网店模式
reqHandler.setParameter("seller_id", ""); //卖家商户号，为空则等同于partner
//获取请求带参数的url
string requestUrl = reqHandler.getRequestURL();
Response.Redirect(requestUrl);
//Get的实现方式
// string a_link = "<a target=\"_blank\" href=\"" + requestUrl + "\">" + "财付通支付" + "</a>";
//Response.Write(a_link);
//post实现方式
/* Response.Write("<form method=\"post\" action=\""+ reqHandler.getGateUrl() + "\" >\n");
* Hashtable ht = reqHandler.getAllParameters();
* foreach(DictionaryEntry de in ht)
* {
* Response.Write("<input type=\"hidden\" name=\"" + de.Key + "\" value=\"" + de.Value + "\" >\n");
* }
* Response.Write("<input type=\"submit\" value=\"财付通支付\" >\n</form>\n");*/
//获取debug信息,建议把请求和debug信息写入日志，方便定位问题
string debuginfo = reqHandler.getDebugInfo();
Response.Write("<br/>requestUrl:" + requestUrl + "<br/>");
Response.Write("<br/>debuginfo:" + debuginfo + "<br/>");
}
public ActionResult NativeNotifyUrl()
{
ResponseHandler resHandler = new ResponseHandler(null);
//返回给微信的请求
RequestHandler res = new RequestHandler(null);
string openId = resHandler.GetParameter("openid");
string productId = resHandler.GetParameter("product_id");
if (openId == null || productId == null)
{
res.SetParameter("return_code", "FAIL");
res.SetParameter("return_msg", "回调数据异常");
}
//创建支付应答对象
//RequestHandler packageReqHandler = new RequestHandler(null);
var sp_billno = DateTime.Now.ToString("HHmmss") + TenPayV3Util.BuildRandomStr(26);//最多32位
var nonceStr = TenPayV3Util.GetNoncestr();
//创建请求统一订单接口参数
//packageReqHandler.SetParameter("appid", TenPayV3Info.AppId);
//packageReqHandler.SetParameter("mch_id", TenPayV3Info.MchId);
//packageReqHandler.SetParameter("nonce_str", nonceStr);
//packageReqHandler.SetParameter("body", "test");
//packageReqHandler.SetParameter("out_trade_no", sp_billno);
//packageReqHandler.SetParameter("total_fee", "1");
//packageReqHandler.SetParameter("spbill_create_ip", HttpContext.UserHostAddress()?.ToString());
//packageReqHandler.SetParameter("notify_url", TenPayV3Info.TenPayV3Notify);
//packageReqHandler.SetParameter("trade_type", TenPayV3Type.NATIVE.ToString());
//packageReqHandler.SetParameter("openid", openId);
//packageReqHandler.SetParameter("product_id", productId);
//string sign = packageReqHandler.CreateMd5Sign("key", TenPayV3Info.Key);
//packageReqHandler.SetParameter("sign", sign);
//string data = packageReqHandler.ParseXML();
var xmlDataInfo = new TenPayV3UnifiedorderRequestData(TenPayV3Info.AppId, TenPayV3Info.MchId, "test", sp_billno, 1, HttpContext.UserHostAddress()?.ToString(), TenPayV3Info.TenPayV3Notify, TenPay.TenPayV3Type.JSAPI, openId, TenPayV3Info.Key, nonceStr);
try
{
//调用统一订单接口
var result = TenPayV3.Unifiedorder(xmlDataInfo);
//var unifiedorderRes = XDocument.Parse(result);
//string prepayId = unifiedorderRes.Element("xml").Element("prepay_id").Value;
//创建应答信息返回给微信
res.SetParameter("return_code", result.return_code);
res.SetParameter("return_msg", result.return_msg ?? "OK");
res.SetParameter("appid", result.appid);
res.SetParameter("mch_id", result.mch_id);
res.SetParameter("nonce_str", result.nonce_str);
res.SetParameter("prepay_id", result.prepay_id);
res.SetParameter("result_code", result.result_code);
res.SetParameter("err_code_des", "OK");
string nativeReqSign = res.CreateMd5Sign("key", TenPayV3Info.Key);
res.SetParameter("sign", result.sign);
}
catch (Exception)
{
res.SetParameter("return_code", "FAIL");
res.SetParameter("return_msg", "统一下单失败");
}
return(Content(res.ParseXML()));
}
public RequestWorker(RequestHandler handler) : this(handler, ThreadType.Main)
{
}
public ActionResult JsApi()
{
//string appId = TenPayInfo.AppId;
string timeStamp = "";
string nonceStr = "";
string packageValue = "";
string paySign = "";
string sp_billno = Request.Form["order_no"];
//当前时间 yyyyMMdd
string date = SystemTime.Now.ToString("yyyyMMdd");
if (null == sp_billno)
{
//生成订单10位序列号，此处用时间和随机数生成，商户根据自己调整，保证唯一
sp_billno = SystemTime.Now.ToString("HHmmss") + TenPayUtil.BuildRandomStr(4);
}
else
{
sp_billno = Request.Form["order_no"].ToString();
}
sp_billno = TenPayInfo.PartnerId + sp_billno;
//创建支付应答对象
RequestHandler packageReqHandler = new RequestHandler(null);
//初始化
packageReqHandler.Init();
packageReqHandler.SetKey(TenPayInfo.Key);
//设置package订单参数
packageReqHandler.SetParameter("partner", TenPayInfo.PartnerId); //商户号
packageReqHandler.SetParameter("fee_type", "1"); //币种，1人民币
packageReqHandler.SetParameter("input_charset", "GBK");
packageReqHandler.SetParameter("bank_type", "WX");
packageReqHandler.SetParameter("out_trade_no", sp_billno); //商家订单号
packageReqHandler.SetParameter("total_fee", "1"); //商品金额,以分为单位(money * 100).ToString()
packageReqHandler.SetParameter("notify_url", TenPayInfo.TenPayNotify); //接收财付通通知的URL
packageReqHandler.SetParameter("body", "JSAPIdemo"); //商品描述
packageReqHandler.SetParameter("spbill_create_ip", HttpContext.UserHostAddress()?.ToString()); //用户的公网ip，不是商户服务器IP
//获取package包
packageValue = packageReqHandler.GetRequestURL();
//调起微信支付签名
timeStamp = TenPayUtil.GetTimestamp();
nonceStr = TenPayUtil.GetNoncestr();
//设置支付参数
RequestHandler paySignReqHandler = new RequestHandler(null);
paySignReqHandler.SetParameter("appid", TenPayInfo.AppId);
paySignReqHandler.SetParameter("appkey", TenPayInfo.AppKey);
paySignReqHandler.SetParameter("noncestr", nonceStr);
paySignReqHandler.SetParameter("timestamp", timeStamp);
paySignReqHandler.SetParameter("package", packageValue);
paySign = paySignReqHandler.CreateSHA1Sign();
//TenPay.Delivernotify(TenPayInfo.AppId, "oX99MDgNcgwnz3zFN3DNmo8uwa-w", "111112222233333", sp_billno,
// timeStamp, "1", "ok", "53cca9d47b883bd4a5c85a9300df3da0cb48565c", "sha1");
//获取debug信息,建议把请求和debug信息写入日志，方便定位问题
//string pakcageDebuginfo = packageReqHandler.getDebugInfo();
//result +="<br/>pakcageDebuginfo:" + pakcageDebuginfo + "<br/>");
//string paySignDebuginfo = paySignReqHandler.getDebugInfo();
//result +="<br/>paySignDebuginfo:" + paySignDebuginfo + "<br/>");
//TODO：和JSSDK一样整合信息包
ViewData["appId"] = TenPayInfo.AppId;
ViewData["timeStamp"] = timeStamp;
ViewData["nonceStr"] = nonceStr;
ViewData["packageValue"] = packageValue;
ViewData["paySign"] = paySign;
return(View());
}
public async Task MockExecuteSynchronousTest()
{
string xml = @"<?xml version=""1.0"" encoding=""UTF-8""?>
<response>
<control>
<status>success</status>
<senderid>testsenderid</senderid>
<controlid>sessionProvider</controlid>
<uniqueid>false</uniqueid>
<dtdversion>3.0</dtdversion>
</control>
<operation>
<authentication>
<status>success</status>
<userid>testuser</userid>
<companyid>testcompany</companyid>
<sessiontimestamp>2015-12-06T15:57:08-08:00</sessiontimestamp>
</authentication>
<result>
<status>success</status>
<function>getAPISession</function>
<controlid>func1UnitTest</controlid>
<data>
<api>
<sessionid>unittest..</sessionid>
<endpoint>https://unittest.intacct.com/ia/xml/xmlgw.phtml</endpoint>
</api>
</data>
</result>
</operation>
</response>";
HttpResponseMessage mockResponse = new HttpResponseMessage()
{
StatusCode = System.Net.HttpStatusCode.OK,
Content = new StringContent(xml)
};
List <HttpResponseMessage> mockResponses = new List <HttpResponseMessage>
{
mockResponse,
};
MockHandler mockHandler = new MockHandler(mockResponses);
ClientConfig clientConfig = new ClientConfig()
{
SenderId = "testsenderid",
SenderPassword = "******",
SessionId = "testsession..",
MockHandler = mockHandler,
};
RequestConfig requestConfig = new RequestConfig()
{
ControlId = "unittest",
};
List <IFunction> contentBlock = new List <IFunction>
{
new ApiSessionCreate()
};
RequestHandler requestHandler = new RequestHandler(clientConfig, requestConfig);
OnlineResponse response = await requestHandler.ExecuteOnline(contentBlock);
Assert.IsType <OnlineResponse>(response);
}
