sk_pay/src/main/java/com/jmfy/controller/PayController.java

1859 lines
94 KiB
Java
Raw Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

package com.jmfy.controller;
import cn.hutool.core.util.XmlUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.jmfy.Application;
import com.jmfy.dao.MongoConnectDao;
import com.jmfy.handler.PayHandler;
import com.jmfy.model.ServerInfo;
import com.jmfy.modelVo.PayVo;
import com.jmfy.redisProperties.RedisUserKey;
import com.jmfy.sdk.SdkSign;
import com.jmfy.util.*;
import com.jmfy.util.loginRedis.TimeUtil;
import com.ljsd.jieling.thrift.idl.Result;
import com.ljsd.jieling.thrift.idl.itemData;
import com.mongodb.BasicDBObject;
import com.mongodb.DBCollection;
import com.mongodb.DBObject;
import org.apache.commons.lang.StringEscapeUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.BasicQuery;
import org.springframework.web.bind.annotation.*;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import javax.annotation.Resource;
import javax.crypto.Cipher;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.StringReader;
import java.io.UnsupportedEncodingException;
import java.net.InetAddress;
import java.net.URLEncoder;
import java.net.UnknownHostException;
import java.security.KeyFactory;
import java.security.PublicKey;
import java.security.Signature;
import java.security.spec.X509EncodedKeySpec;
import java.util.*;
import static com.jmfy.util.MD5Util.encrypByMd5;
import static com.jmfy.util.SdkUtil.getOrderIdByTime;
@RestController
public class PayController {
// private static final String _COLLECTION_NAME = "user_register_info";
private static final String _COLLECTION_NAME_Order = "order";
public static final Logger LOGGER = LoggerFactory.getLogger(PayController.class);
@Resource
private MongoConnectDao mongoConnectDao;
@Resource
private PayHandler payHandler;
//生成订单号 (之前老的,现在没用到)
@Deprecated
@RequestMapping(value = "/order/genOrder", method = {RequestMethod.GET, RequestMethod.POST})
public void genOrder(String uid, HttpServletResponse response) {
try {
String orderId = uid + getOrderIdByTime();
MongoTemplate mongoTemplate;
DBObject doc = new BasicDBObject();
//doc.put("_id", name);
doc.put("uid", uid);
doc.put("gameOrder", orderId);
//存储
mongoTemplate = mongoConnectDao.getConnect().getMongoTemplete(Application.coreDb);
DBCollection dBCollection = mongoTemplate.getCollection(_COLLECTION_NAME_Order);
dBCollection.save(doc);
JSONObject returnResult = new JSONObject();
returnResult.put("gameOrder", orderId);
LOGGER.info("/sdk6kw/verify uid {} gameOrder {}", uid, returnResult.get("gameOrder"));
response.setContentType("application/json");
response.getOutputStream().write(returnResult.toJSONString().getBytes());
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* sdk统一创建订单接口
*
* @param openid 玩家的openid
* @param uid 玩家的uid
* @param region 区服
* @param channel 渠道
* @param pay_item 支付项支付表的id
* @param price 金额 单位:分
* @param CurrencyCode 币种
* @return
*/
@RequestMapping(value = "/pay/CreatOrder", method = {RequestMethod.GET, RequestMethod.POST})
public String CreatOrder(String openid, int uid, int region, String channel, String pay_item, int price,String CurrencyCode, int devalueId) {
try {
if (channel == "" || channel == null) {
channel = "0123";
}
LOGGER.info("--CreatOrder日志openid={},uid={},region={},channel={},pay_item={},price={},CurrencyCode={}",openid,uid,region,channel,pay_item,price,CurrencyCode);
PayVo payVo = new PayVo(openid, uid, region, channel, pay_item, TimeUtil.getTimeStamp(System.currentTimeMillis()), price,CurrencyCode);
String orderId = CreateUniqueCodeManager.createBillno(10031, 1);
payVo.setBillno(orderId);
MongoTemplate mongoTemplate = mongoConnectDao.getConnect().getMongoTemplete(Application.coreDb);
int serverId = payVo.getRegion();
//查询mongo:客户端传的serverId找到合服后的对应的真实的serverId
//Query query = new Query();
//Criteria cr = new Criteria();
//cr.andOperator(Criteria.where("server_id").is(serverId));
//query.addCriteria(cr);
//ServerInfo serverInfo = mongoTemplate.findOne(query, ServerInfo.class);
//查询mongo:客户端传的serverId找到合服后的对应的真实的serverId
BasicQuery query = new BasicQuery(new BasicDBObject("server_id", serverId+""));
ServerInfo serverInfo = mongoTemplate.findOne(query, ServerInfo.class, "server_info");
if(serverInfo != null){
serverId = serverInfo.getRealServerId();
payVo.setRegion(serverId);
}
LOGGER.info("--CreatOrder日志01region={}, serverId={},serverInfo={},query={}",payVo.getRegion(),serverId, JSON.toJSON(serverInfo),JSON.toJSON(query));
String rpcString = RedisUtil.getInstence().getObject(RedisUserKey.LOGIC_SERVER_INFO, String.valueOf(serverId), String.class, -1);
LOGGER.info("rpcString " + rpcString);
if (null == rpcString) {
LOGGER.error("serverAddress not exist");
}
String thriftIp = rpcString.split(":")[0];
String thriftPort = rpcString.split(":")[3];
if (thriftIp == null || thriftIp.isEmpty() || null == thriftPort || thriftPort.isEmpty()) {
LOGGER.error("serverAddress not exist");
} else {
//判断达到最大购买次数
long now = System.currentTimeMillis();
Result resultOrder = RPCClient.deliveryOrder(thriftIp, thriftPort, uid, pay_item, now, orderId, devalueId);
if (resultOrder.getResultCode() != 1) {
LOGGER.info("processOrder uid={}, goodsId={}, orderTime={},serverId={},errCode={},msg={},orderId={}",uid,pay_item,now,serverId,resultOrder.getResultCode(),resultOrder.getResultMsg(),orderId);
JSONObject returnResult = new JSONObject();
returnResult.put("errCode", resultOrder.getResultCode());
returnResult.put("msg", resultOrder.getResultMsg());
returnResult.put("orderId", orderId);
return returnResult.toJSONString();
}
LOGGER.info("processOrder uid=" + uid + " goodsId = " + pay_item + " orderTime = " + now + " serverId = " + serverId + " CreatOrder is ok ");
}
mongoTemplate.insert(payVo);
JSONObject returnResult = new JSONObject();
//returnResult.put("errCode", 1); //正确的不返回errCode,客户端要求
returnResult.put("msg", "");
returnResult.put("orderId", orderId);
return returnResult.toJSONString();
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
@RequestMapping(value = "/pay/sign", method = {RequestMethod.GET, RequestMethod.POST})
public JSONObject CreatOrder(String channel, String game_area, Integer game_guid, String game_orderid, String game_price, String subject) {
JSONObject returnResult = new JSONObject();
StringBuilder sb = new StringBuilder();
switch (channel){
case "Android_XiaoQi":
sb.append("game_area=").append(game_area).append("&");
sb.append("game_guid=").append(game_guid).append("&");
sb.append("game_orderid=").append(game_orderid).append("&");
sb.append("game_price=").append(game_price).append("&");
sb.append("subject=").append(subject);
sb.append(Constant.X7_PUBLIC_KEY);
returnResult.put("game_sign", MD5Util.encrypByMd5(sb.toString()));
break;
default:
returnResult.put("code", 600);
returnResult.put("msg", "channel not exist");
returnResult.put("game_sign", "");
return returnResult;
}
LOGGER.info("pay order channel:{}, param: {}", channel, sb);
return returnResult;
}
@RequestMapping(value = "/pay/xiaomiOrder", method = {RequestMethod.GET, RequestMethod.POST})
public JSONObject xiaomiOrder(HttpServletRequest request) {
try {
JSONObject json = new JSONObject();
String appId = request.getParameter("appId");// 应用ID
String cpOrderId = request.getParameter("cpOrderId");// 开发商订单ID
String cpUserInfo = request.getParameter("cpUserInfo");// 开发商透传信息
String xiaomiUid = request.getParameter("uid");// 用户ID
String orderId = request.getParameter("orderId");// 游戏平台订单ID
String orderStatus = request.getParameter("orderStatus");// 订单状态TRADE_SUCCESS代表成功
String amonut = request.getParameter("payFee");// 支付金额单位为分即0.01 米币
String productCode = request.getParameter("productCode");// 商品代码
String productName = request.getParameter("productName");// 商品名称
String productCount = request.getParameter("productCount");// 商品数量
String payTime = request.getParameter("payTime");// 支付时间,格式 yyyy-MM-dd
// HH:mm:ss
String partnerGiftConsume = request.getParameter("partnerGiftConsume"); // 可选,使用游戏券金额
// (如果订单使用游戏券则有,long型如果有则参与签名
String signature = request.getParameter("signature");// 签名:以上参数按字母顺序排序然后进行签名。
String parameterView = "appId:" + appId + ",cpOrderId:" + cpOrderId + ",cpUserInfo:" + cpUserInfo + ",uid:" + xiaomiUid + ",orderId:" + orderId + ",orderStatus:" + orderStatus + ",payFee:" + amonut + ",productCode:" + productCode + ",productName:" + productName + ",productCount:" + productCount + ",payTime:" + payTime + ",signature:" + signature;
//if (LOGGER.isDebugEnabled()) {
LOGGER.debug("pay:xiaomi," + parameterView);
if (StringUtils.isEmpty(appId) || StringUtils.isEmpty(cpOrderId) || StringUtils.isEmpty(cpUserInfo) || StringUtils.isEmpty(xiaomiUid) || StringUtils.isEmpty(orderId) || StringUtils.isEmpty(orderStatus) || StringUtils.isEmpty(amonut) || StringUtils.isEmpty(productCode) || StringUtils.isEmpty(productName) || StringUtils.isEmpty(productCount) || StringUtils.isEmpty(payTime) || StringUtils.isEmpty(signature)) {
LOGGER.error("pay:xiaomi,errcode:0,parameter has null," + parameterView);
json.put("errcode", 0);
json.put("errMsg", "接收失败,回调参数有误");
return json;
}
// 订单状态 TRADE_SUCCESS 代表成功
if (!"TRADE_SUCCESS".equals(orderStatus)) {
LOGGER.error("pay:xiaomi,errcode:0,orderStatus is not TRADE_SUCCESS," + parameterView);
json.put("errcode", 0);
json.put("errMsg", "订单状态支付不成功");
return json;
}
if (!Constant.XIAOMIAPPID.equals(appId)) {
LOGGER.error("pay:xiaomi,errcode:1515,appId is error," + parameterView);
json.put("errcode", 1515);
json.put("errMsg", "appId 错误");
return json;
}
// 游戏券金额,有则参与签名
String encryptText = "";
if (StringUtils.isEmpty(partnerGiftConsume)) {
encryptText = String.format("appId=%s&cpOrderId=%s&cpUserInfo=%s&orderId=%s&orderStatus=%s&payFee=%s&payTime=%s&productCode=%s&productCount=%s&productName=%s&uid=%s", Constant.XIAOMIAPPID, cpOrderId, cpUserInfo, orderId, orderStatus, amonut, payTime, productCode, productCount, productName, xiaomiUid);
} else {
encryptText = String.format("appId=%s&cpOrderId=%s&cpUserInfo=%s&orderId=%s&orderStatus=%s&partnerGiftConsume=%s&payFee=%s&payTime=%s&productCode=%s&productCount=%s&productName=%s&uid=%s", Constant.XIAOMIAPPID, cpOrderId, cpUserInfo, orderId, orderStatus, partnerGiftConsume, amonut, payTime, productCode, productCount, productName, xiaomiUid);
}
String sign = SdkSign.xiaomiSign(encryptText, Constant.XIAOMIAPPSECRET);
if (signature.equals(sign)) {
PayHandler payHandler = new PayHandler();
int payres = payHandler.processOrder(cpOrderId, orderId);
if (payres == 1) {
json.put("errcode", 200);
json.put("errMsg", "发货成功");
return json;
} else {
LOGGER.error("pay:xiaomi,errcode:3515,cpUserInfo is error," + parameterView);
json.put("errcode", 3515);
json.put("errMsg", "订单信息不一致");
return json;
}
} else {
LOGGER.error("pay:xiaomi,errcode:1525,signature check error," + parameterView);
json.put("errcode", 1525);
json.put("errMsg", "signature 错误");
return json;
}
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
@RequestMapping(value = "/pay/weiweiOrder", method = {RequestMethod.POST})
public String gameNoticeInterface(String out_trade_no, String price, int pay_status, String extend, String signType, String sign) {
try {
/*
@param orderId 游戏订单号
* @param out_trade_no 渠道订单号
*/
LOGGER.info("pay:gameNoticeInterface, out_trade_no={},price={},pay_status={},extend={},sign={}", out_trade_no, price, pay_status, extend, sign);
String[] extendStrs = extend.split("_");
String orderId = extendStrs[3];
String context = out_trade_no + price + pay_status + extend + Constant.WEIWEIORDERKEY;
String mySign = MD5Util.encrypByMd5(context);
if (!mySign.equals(sign)) {
LOGGER.error("pay:gameNoticeInterface,sign err, sign={},mySign={}", sign, mySign);
return "sign err!";
}
// PayHandler payHandler = new PayHandler();
// 统一发货接口
int payres = payHandler.processOrder(orderId, out_trade_no);
// 成功
if (payres == 1) {
return "success";
} else if (payres == -1) {
LOGGER.error("pay:gameNoticeInterface, {} 订单不存在,", orderId);
} else if (payres == -2) {
LOGGER.error("pay:gameNoticeInterface, {} 订单参数错误,", orderId);
} else if (payres == -3) {
LOGGER.error("pay:gameNoticeInterface, {} 服务器配置错误,", orderId);
} else if (payres == -4) {
LOGGER.error("pay:gameNoticeInterface, {} 充值失败,", orderId);
} else {
LOGGER.error("pay:gameNoticeInterface, {} 返回错误,", orderId);
return "err";
}
} catch (Exception ex) {
ex.printStackTrace();
}
return "err";
}
/**
* 百度sdk回调
*
* @param AppID 应用 ID
* @param OrderSerial SDK 系统内部订单号
* @param CooperatorOrderSerial CP 订单号
* @param Sign 签名
* @param Content 数据结构JSO N 编码格式: UTF8Base64 编码
* @return 线上回调地址http://120.131.0.103:9076/idip/sfzb/pay/baiduNotify
*/
@RequestMapping(value = "/pay/baiduNotify", method = {RequestMethod.POST})
public JSONObject payBaiduNotify(int AppID, String OrderSerial, String CooperatorOrderSerial, String Content, String Sign) {
JSONObject json = new JSONObject();
try {
LOGGER.info("payBaiduNotify, AppID={},OrderSerial={},CooperatorOrderSerial={},Sign={},Content={}", AppID, OrderSerial, CooperatorOrderSerial, Sign, Content);
//请求参数签名方式: MD5(AppID+OrderSerial+CooperatorOrderSerial+Content+AppSecret)
String context = AppID + OrderSerial + CooperatorOrderSerial + Content + Constant.BAIDU_SECRET_KEY;
String mySign = MD5Util.encrypByMd5(context);
json.put("AppID",AppID);
json.put("Sign",mySign);
if (!mySign.equals(Sign)) {
LOGGER.error("pay:gameNoticeInterface,sign err, sign={},mySign={}", Sign, mySign);
json.put("ResultMsg","Sign err");
json.put("ResultCode",91);
return json;
}
if (Constant.BAIDU_APPID != AppID) {
LOGGER.error("pay:baiduNotify,appId is error,BAIDU_APPID =" + Constant.BAIDU_APPID + ",AppID =" + AppID);
json.put("ResultMsg","AppID err");
json.put("ResultCode",91);
return json;
}
String orderId = CooperatorOrderSerial;
String out_trade_no = OrderSerial;
JSONObject jsonObj = JSONObject.parseObject(Content);
int payId = jsonObj.getIntValue("PayId"); //pay_source, — 付款渠道, 0表示为微信支付, 1表示支付宝支付, 2表示苹果支付, 3表示谷歌支付,4 表示onestore, 5 表示mycard,
// 统一发货接口
int payres = payHandler.processOrder(orderId, out_trade_no,String.valueOf(payId)); //orderId 游戏订单号 out_trade_no 渠道订单号
// 成功
if (payres == 1) {
json.put("ResultMsg","success");
json.put("ResultCode",1);
return json;
} else if (payres == -1) {
LOGGER.error("pay:gameNoticeInterface, {} 订单不存在,", orderId);
} else if (payres == -2) {
LOGGER.error("pay:gameNoticeInterface, {} 订单参数错误,", orderId);
} else if (payres == -3) {
LOGGER.error("pay:gameNoticeInterface, {} 服务器配置错误,", orderId);
} else if (payres == -4) {
LOGGER.error("pay:gameNoticeInterface, {} 充值失败,", orderId);
} else {
LOGGER.error("pay:gameNoticeInterface, {} 返回错误,", orderId);
json.put("ResultMsg","err");
json.put("ResultCode",91);
return json;
}
} catch (Exception ex) {
ex.printStackTrace();
}
json.put("ResultMsg","err");
json.put("ResultCode",91);
return json;
}
/**
* 百度sdk回调 测试
*
* @param AppID 应用 ID
* @param OrderSerial SDK 系统内部订单号
* @param CooperatorOrderSerial CP 订单号
* @param Sign 签名
* @param Content 数据结构JSO N 编码格式: UTF8Base64 编码
* @return 线上回调地址http://120.131.0.103:9076/idip/sfzb/pay/baiduTestNotify
*/
@RequestMapping(value = "/pay/baiduTestNotify", method = {RequestMethod.POST})
public JSONObject payBaiduTestNotify(int AppID, String OrderSerial, String CooperatorOrderSerial, String Content, String Sign) {
JSONObject json = new JSONObject();
try {
LOGGER.info("payBaiduNotify, AppID={},OrderSerial={},CooperatorOrderSerial={},Sign={},Content={}", AppID, OrderSerial, CooperatorOrderSerial, Sign, Content);
//请求参数签名方式: MD5(AppID+OrderSerial+CooperatorOrderSerial+Content+AppSecret)
String context = AppID + OrderSerial + CooperatorOrderSerial + Content + Constant.BAIDU_TEST_SECRET_KEY;
String mySign = MD5Util.encrypByMd5(context);
json.put("AppID",AppID);
json.put("Sign",mySign);
if (!mySign.equals(Sign)) {
LOGGER.error("pay:gameNoticeInterface,sign err, sign={},mySign={}", Sign, mySign);
json.put("ResultMsg","Sign err");
json.put("ResultCode",91);
return json;
}
// if (Constant.BAIDU_TEST_APPID != AppID) {
// LOGGER.error("pay:baiduNotify,appId is error,BAIDU_TEST_APPID =" + Constant.BAIDU_TEST_APPID + ",AppID =" + AppID);
// json.put("ResultMsg","AppID err");
// json.put("ResultCode",91);
// return json;
// }
String orderId = CooperatorOrderSerial;
String out_trade_no = OrderSerial;
JSONObject jsonObj = JSONObject.parseObject(Content);
int payId = jsonObj.getIntValue("PayId"); //pay_source, — 付款渠道, 0表示为微信支付, 1表示支付宝支付, 2表示苹果支付, 3表示谷歌支付,4 表示onestore, 5 表示mycard,
// 统一发货接口
int payres = payHandler.processOrder(orderId, out_trade_no,String.valueOf(payId)); //orderId 游戏订单号 out_trade_no 渠道订单号
// 成功
if (payres == 1) {
json.put("ResultMsg","success");
json.put("ResultCode",1);
return json;
} else if (payres == -1) {
LOGGER.error("pay:gameNoticeInterface, {} 订单不存在,", orderId);
} else if (payres == -2) {
LOGGER.error("pay:gameNoticeInterface, {} 订单参数错误,", orderId);
} else if (payres == -3) {
LOGGER.error("pay:gameNoticeInterface, {} 服务器配置错误,", orderId);
} else if (payres == -4) {
LOGGER.error("pay:gameNoticeInterface, {} 充值失败,", orderId);
} else {
LOGGER.error("pay:gameNoticeInterface, {} 返回错误,", orderId);
json.put("ResultMsg","err");
json.put("ResultCode",91);
return json;
}
} catch (Exception ex) {
ex.printStackTrace();
}
json.put("ResultMsg","err");
json.put("ResultCode",91);
return json;
}
@RequestMapping(value = "/pay/test")
public String gameNoticeInterface(String out_trade_no) throws Exception {
int payHandle1r = payHandler.processOrder(out_trade_no, out_trade_no);
return "1";
}
@RequestMapping(value = "/pay/6kwotherNotify", method = {RequestMethod.POST})
public String sixkwotherNotify(int appid, String data, String sign) {
try {
LOGGER.info("6kwotherNotify, AppID={},data={},Sign={}", appid, data, sign);
if (appid != Constant.SIXKW_OTHER_APPID) {
LOGGER.info("6kwotherNotify appid error");
return "fail";
}
//请求参数签名方式: MD5(AppID+OrderSerial+CooperatorOrderSerial+Content+AppSecret)
Map mapObj = JSONObject.parseObject(data, Map.class);
String bodyUrl = StringUtil.mapToString(mapObj);
String context = Constant.SIXKW_OTHER_APPID + bodyUrl + Constant.SIXKW_OTHER_PAY_SECRER;
LOGGER.info("6kwotherNotify sign str {}", context);
String mySign = MD5Util.encrypByMd5(context);
if (!mySign.equals(sign)) {
LOGGER.error("pay:gameNoticeInterface,sign err, sign={},mySign={}", sign, mySign);
return "91";
}
String orderId = String.valueOf(mapObj.get("cpOrder"));
String out_trade_no = String.valueOf(mapObj.get("orderId"));
// 统一发货接口
int payres = payHandler.processOrder(orderId, out_trade_no); //orderId 游戏订单号 out_trade_no 渠道订单号
// 成功
if (payres == 1) {
return "SUCCESS";
} else if (payres == -1) {
LOGGER.error("pay:gameNoticeInterface, {} 订单不存在,", orderId);
} else if (payres == -2) {
LOGGER.error("pay:gameNoticeInterface, {} 订单参数错误,", orderId);
} else if (payres == -3) {
LOGGER.error("pay:gameNoticeInterface, {} 服务器配置错误,", orderId);
} else if (payres == -4) {
LOGGER.error("pay:gameNoticeInterface, {} 充值失败,", orderId);
} else {
LOGGER.error("pay:gameNoticeInterface, {} 返回错误,", orderId);
return "err";
}
} catch (Exception ex) {
ex.printStackTrace();
}
return "err";
}
@RequestMapping(value = "/pay/6kwNotify")
public String sixkwNotify(HttpServletRequest request) {
try {
JSONObject responseObj = new JSONObject();
int resultCode = Constant.CODE_SUCCESS;
BufferedReader br;
br = request.getReader();
String str, wholeStr = "";
while ((str = br.readLine()) != null) {
wholeStr += str;
}
String jsonStr = wholeStr;
String exam = Constant.SIXKW_PAY_SECRER;
String tmpSign = encrypByMd5(jsonStr + exam);
String sign = request.getHeader("AUTH6KW");
LOGGER.info("notify jsonStr {} tmpSign {} sign {}", jsonStr, tmpSign, sign);
if (!tmpSign.equals(sign)) {
LOGGER.error("pay:gameNoticeInterface,sign err, sign={},mySign={}", sign, tmpSign);
return "91";
}
JSONObject obj = JSON.parseObject(jsonStr);
String orderId = String.valueOf(obj.get("gameOrder"));
String out_trade_no = String.valueOf(obj.get("orderID"));
// 统一发货接口
int payres = payHandler.processOrder(orderId, out_trade_no); //orderId 游戏订单号 out_trade_no 渠道订单号
// 成功
if (payres == 1) {
return "SUCCESS";
} else if (payres == -1) {
LOGGER.error("pay:gameNoticeInterface, {} 订单不存在,", orderId);
} else if (payres == -2) {
LOGGER.error("pay:gameNoticeInterface, {} 订单参数错误,", orderId);
} else if (payres == -3) {
LOGGER.error("pay:gameNoticeInterface, {} 服务器配置错误,", orderId);
} else if (payres == -4) {
LOGGER.error("pay:gameNoticeInterface, {} 充值失败,", orderId);
} else {
LOGGER.error("pay:gameNoticeInterface, {} 返回错误,", orderId);
return "err";
}
} catch (Exception ex) {
ex.printStackTrace();
}
return "err";
}
/**
* 唯4366支付回调
* @param order_id 平台订单号
* @param user_id 平台用户 ID
* @param server_id 区服 ID(CP 区服 ID)
* @param money 充值金额,单位元
* @param extra_info 透传参数
* @param time 当前时间戳
* @param sign 签名: md5(order_id+ user_id+server_id+money+extra_info+time +'#'+ secret_key)
* @param sandbox 是否是测试订单,1:是: 0
* @return 线上回调地址http://120.131.0.103:9076/idip/sfzb/pay/payWeiWei4366Notify
*/
@RequestMapping(value = "/pay/payWeiWei4366Notify", method = {RequestMethod.POST,RequestMethod.GET})
public JSONObject payWeiWei4366Notify(HttpServletRequest request,String order_id, String user_id, String server_id, String money, String extra_info,int time,String sign,String sandbox) {
JSONObject json = new JSONObject();
try {
List ipWhiteList = new ArrayList<>();
ipWhiteList.add("119.23.175.96");
ipWhiteList.add("120.77.12.228");
ipWhiteList.add("119.23.24.106");
ipWhiteList.add("120.78.192.221");
ipWhiteList.add("14.29.126.78");
ipWhiteList.add("14.23.117.83");
ipWhiteList.add("121.8.199.83");
ipWhiteList.add("47.106.234.30");
ipWhiteList.add("112.74.113.198");
ipWhiteList.add("27.18.94.43");
//获取自己游戏订单id 通过extra_info字段穿透传值
String[] split = extra_info.split("_");
String self_OrderId = split[3].substring(0,split[3].length()-2);
String ipAddr = getIpAddr(request);
LOGGER.info("payWeiWei4366Notify, order_id={},user_id={},server_id={},money={},extra_info={},time={},sign={},sandbox={},ip={},self_OrderId={}", order_id, user_id, server_id, money, extra_info,time,sign,sandbox,ipAddr,self_OrderId);
boolean contains = ipWhiteList.contains(ipAddr);
if(!contains){
LOGGER.error("pay:payWeiWei4366Notify, ip = {},白名单ip = {}, ip错误,不在白名单中!!!,", ipAddr,ipWhiteList.toString());
json.put("state",2);
json.put("msg","请勿非法提交订单,如有问题请联系客服!!!");
return json;
}
//签名: md5(order_id+ user_id+server_id+money+extra_info+time +'#'+ secret_key)
String context = order_id + user_id + server_id + money + extra_info + time +'#'+ Constant.WEIWEI_4366_SECRET_KEY ;
String mySign = MD5Util.encrypByMd5(context);
json.put("Sign",mySign);
json.put("order_id",order_id);
json.put("user_id",user_id);
json.put("server_id",server_id);
// json.put("money",money);
// json.put("extra_info",extra_info);
// json.put("time",time);
// json.put("sign",sign);
if (!mySign.equals(sign)) {
LOGGER.error("pay:gameNoticeInterface,sign err, sign={},mySign={}", sign, mySign);
json.put("state",0);
json.put("msg","Sign err");
return json;
}
// if (Constant.BAIDU_APPID != AppID) {
// LOGGER.error("pay:baiduNotify,appId is error,BAIDU_APPID =" + Constant.BAIDU_APPID + ",AppID =" + AppID);
// json.put("ResultMsg","AppID err");
// json.put("ResultCode",91);
// return json;
// }
String orderId = self_OrderId;
String out_trade_no = order_id;
//JSONObject jsonObj = JSONObject.parseObject(Content);
//int payId = jsonObj.getIntValue("PayId"); //pay_source, — 付款渠道, 0表示为微信支付, 1表示支付宝支付, 2表示苹果支付, 3表示谷歌支付,4 表示onestore, 5 表示mycard,
int amount =Double.valueOf(money).intValue()*100; //元转为分 (带小数点字符串转int类型)
// 统一发货接口
// int payres = payHandler.processOrder(orderId, out_trade_no,String.valueOf(payId)); //orderId 游戏订单号 out_trade_no 渠道订单号
int payres = payHandler.processOrderNew(orderId, out_trade_no,amount); //orderId 游戏订单号 out_trade_no 渠道订单号amount 支付金额 单位分
// 统一发货接口
// int payres = 0;
// if(sandbox.equals(0)){ //正式订单 (是否是测试订单,1:是: 0
// payHandler.processOrder(orderId, out_trade_no); //orderId 游戏订单号 out_trade_no 渠道订单号
// }else if(sandbox.equals(1)){ //测试订单
// payHandler.processOrderTest(orderId, out_trade_no); //orderId 游戏订单号 out_trade_no 渠道订单号
// }
// 成功
if (payres == 1) {
json.put("state",1);
json.put("msg","充值成功/重复充值");
return json;
} else if (payres == -1) {
LOGGER.error("pay:gameNoticeInterface, {} 订单不存在,", orderId);
} else if (payres == -2) {
LOGGER.error("pay:gameNoticeInterface, {} 订单参数错误,", orderId);
} else if (payres == -3) {
LOGGER.error("pay:gameNoticeInterface, {} 服务器配置错误,", orderId);
} else if (payres == -4) {
LOGGER.error("pay:gameNoticeInterface, {} 充值失败,", orderId);
} else {
LOGGER.error("pay:gameNoticeInterface, {} 返回错误,", orderId);
json.put("state",2);
json.put("msg","err");
return json;
}
} catch (Exception ex) {
ex.printStackTrace();
}
json.put("state",3);
json.put("msg","err");
return json;
}
/**
* 支付回调:赤兔回调
* @param request
* @param uid 用户ID(唯一)
* @param order_id 平台方订单号
* @param server 服务器唯一标识
* @param amount 金额/单位元
* @param extra 透传参数, 在SDK传入, 回调原样返回
* @param sandbox 是否是测试订单,1:是: 0
* @param timestamp 服务器时间戳, 秒
* @param sign MD5签名: sign = md5(uid + order_id + server + amount + extra + sandbox + timestamp + key)
* @return 线上回调地址http://cn_pay.caiyanghuyu.com/idip/sfzb/pay/chituNotify
*/
@RequestMapping(value = "/pay/chituNotify", method = {RequestMethod.POST,RequestMethod.GET})
public JSONObject chituNotify(HttpServletRequest request,String uid, String order_id, String server, String amount, String extra,String sandbox,String timestamp,String sign) {
JSONObject json = new JSONObject();
try {
List ipWhiteList = new ArrayList<>();
ipWhiteList.add("159.75.250.101");
ipWhiteList.add("159.75.228.66");
ipWhiteList.add("42.193.162.86");
ipWhiteList.add("106.52.165.154");
ipWhiteList.add("81.71.37.182");
ipWhiteList.add("113.108.204.50"); //wifi的ip
String strUnEscapeHTML = StringEscapeUtils.unescapeHtml(extra);
//获取自己游戏订单id 通过extra字段穿透传值
String[] split = strUnEscapeHTML.split("_");
String self_OrderId = split[3].substring(0,split[3].length()-2);
String ipAddr = getIpAddr(request);
LOGGER.info("chituNotify, uid={},order_id={},server={},amount={},extra={},sandbox={},timestamp={},sign={},ip={},self_OrderId={}", uid, order_id, server, amount, strUnEscapeHTML,sandbox,timestamp,sign,ipAddr,self_OrderId);
boolean contains = ipWhiteList.contains(ipAddr);
if(!contains){
LOGGER.error("pay:chituNotify, ip = {},白名单ip = {}, ip错误,不在白名单中!!!,", ipAddr,ipWhiteList.toString());
json.put("state",2);
json.put("msg","请勿非法提交订单,如有问题请联系客服!!!");
return json;
}
// MD5签名: sign = md5(uid + order_id + server + amount + extra + sandbox + timestamp + key)
String context = uid + order_id + server + amount + extra + sandbox + timestamp + Constant.CHITU_SECRET_KEY ;
String mySign = MD5Util.encrypByMd5(context);
json.put("Sign",mySign);
json.put("order_id",order_id);
json.put("user_id",uid);
json.put("server_id",server);
// json.put("money",money);
// json.put("extra_info",extra_info);
// json.put("time",time);
// json.put("sign",sign);
if (!mySign.equals(sign)) {
LOGGER.error("----签名不一致----pay:chituNotify,sign err, sign={},mySign={}", sign, mySign);
json.put("state",0);
json.put("msg","Sign err");
return json;
}
String orderId = self_OrderId;
String out_trade_no = order_id;
//JSONObject jsonObj = JSONObject.parseObject(Content);
//int payId = jsonObj.getIntValue("PayId"); //pay_source, — 付款渠道, 0表示为微信支付, 1表示支付宝支付, 2表示苹果支付, 3表示谷歌支付,4 表示onestore, 5 表示mycard,
int money =Double.valueOf(amount).intValue()*100; //元转为分 (带小数点字符串转int类型)
// 统一发货接口
// int payres = payHandler.processOrder(orderId, out_trade_no,String.valueOf(payId)); //orderId 游戏订单号 out_trade_no 渠道订单号
int payres = payHandler.processOrderNew(orderId, out_trade_no,money); //orderId 游戏订单号 out_trade_no 渠道订单号amount 支付金额 单位分
// 统一发货接口
// int payres = 0;
// if(sandbox.equals(0)){ //正式订单 (是否是测试订单,1:是: 0
// payHandler.processOrder(orderId, out_trade_no); //orderId 游戏订单号 out_trade_no 渠道订单号
// }else if(sandbox.equals(1)){ //测试订单
// payHandler.processOrderTest(orderId, out_trade_no); //orderId 游戏订单号 out_trade_no 渠道订单号
// }
// 成功
if (payres == 1) {
json.put("status",0);
json.put("msg","充值成功/重复充值");
return json;
} else if (payres == -1) {
LOGGER.error("pay:gameNoticeInterface, {} 订单不存在,", orderId);
} else if (payres == -2) {
LOGGER.error("pay:gameNoticeInterface, {} 订单参数错误,", orderId);
} else if (payres == -3) {
LOGGER.error("pay:gameNoticeInterface, {} 服务器配置错误,", orderId);
} else if (payres == -4) {
LOGGER.error("pay:gameNoticeInterface, {} 充值失败,", orderId);
} else {
LOGGER.error("pay:gameNoticeInterface, {} 返回错误,", orderId);
json.put("status",2);
json.put("msg","err");
return json;
}
} catch (Exception ex) {
ex.printStackTrace();
}
json.put("status",3);
json.put("msg","err");
return json;
}
/**
* 支付回调:韩国回调
* @param request
* @param userId 用户ID
* @param transactionId 订单号GPA-xxxx-xxxx-
* @param store 商店信息apple、google、one
* @param projectId 项目ID
* @param productId Google/Apple/ONE Store中注册的商品ID
* @param platform 操作平台信息android、ios
* @param payment 支付方式
* @param uniqueId 唯一ID调用purchase api时输入的uniqueId
* @param gamepotOrderId GAMEPOT Order ID
* @param serverId serverId调用purchase api时输入的serverId
* @param playerId playerId调用purchase api时输入的playerId
* @param tp 1测试支付 0一般支付
* @param etc etc调用purchase api时输入的 etc
* 说明文档: https://guide.ncloud-docs.com/docs/zh/game-gamepotserver
* 线上回调地址http://acpay.ilod.co.kr/idip/sfzb/pay/ilodNotify
*/
@RequestMapping(value = "/pay/ilodNotify", method = {RequestMethod.POST,RequestMethod.GET})
public JSONObject ilodNotify(HttpServletRequest request,String userId, String transactionId,String store, String projectId, String productId, String platform,String payment,String uniqueId,String gamepotOrderId,String serverId,String playerId,int tp,String etc) {
JSONObject json = new JSONObject();
try {
List ipWhiteList = new ArrayList<>();
ipWhiteList.add("49.236.143.202");
ipWhiteList.add("49.236.143.198");
ipWhiteList.add("106.10.53.19");
ipWhiteList.add("106.10.52.84");
String ipAddr = getIpAddr(request);
LOGGER.info("ilodNotify, userId={},transactionId={},store={},projectId={},productId={},platform={},payment={},uniqueId={},gamepotOrderId={},serverId={}playerId={}tp={},etc={},ip={}", userId, transactionId, store, projectId, productId,platform,payment,uniqueId,gamepotOrderId,serverId,playerId,tp,etc,ipAddr);
//获取自己游戏订单id 通过extra_info字段穿透传值
String[] split = etc.split("_");
String self_OrderId = split[3].substring(0,split[3].length()-2);
boolean contains = ipWhiteList.contains(ipAddr);
if(!contains){
LOGGER.error("pay:ilodNotify, ip = {},白名单ip = {}, ip错误,不在白名单中!!!,", ipAddr,ipWhiteList.toString());
json.put("status",0);
json.put("message","请勿非法提交订单,如有问题请联系客服!!!");
return json;
}
String orderId = self_OrderId;
String out_trade_no = transactionId;
// 统一发货接口
// int payres = payHandler.processOrderNew(orderId, out_trade_no,0); //orderId 游戏订单号 out_trade_no 渠道订单号amount 支付金额 单位分
// 统一发货接口
int payres = 0;
if(tp==0){ //正式订单 0一般支付,1测试支付
payres = payHandler.processOrderNew(orderId, out_trade_no,0); //orderId 游戏订单号 out_trade_no 渠道订单号
}else if(tp==1){ //测试订单
payres = payHandler.processOrderTest(orderId, out_trade_no); //orderId 游戏订单号 out_trade_no 渠道订单号
}
// 成功
if (payres == 1) {
json.put("status",1);
json.put("message","充值成功/重复充值");
return json;
} else if (payres == -1) {
LOGGER.error("pay:gameNoticeInterface, {} 订单不存在,", orderId);
} else if (payres == -2) {
LOGGER.error("pay:gameNoticeInterface, {} 订单参数错误,", orderId);
} else if (payres == -3) {
LOGGER.error("pay:gameNoticeInterface, {} 服务器配置错误,", orderId);
} else if (payres == -4) {
LOGGER.error("pay:gameNoticeInterface, {} 充值失败,", orderId);
} else {
LOGGER.error("pay:gameNoticeInterface, {} 返回错误,payres = {}", orderId,payres);
json.put("status",0);
json.put("message","Pay Fail EerrorCord001");
return json;
}
} catch (Exception ex) {
ex.printStackTrace();
}
json.put("status",0);
json.put("message","Pay Fail EerrorCord002");
return json;
}
/**
* 支付回调:韩国优惠劵回调
* @param request
* @param userId 用户ID(唯一)
* @param projectId 项目ID
* @param platform 操作平台信息android、ios
* @param store 商店信息apple、google、one
* @param title 在仪表盘 > 游戏 > 送礼物 > 标题中输入的值
* @param content 在仪表盘 > 游戏 > 送礼物 > 标题中输入的值
* @param target 在仪表盘 > 游戏 > 送礼物 > 标题中输入的值
* @param expireMs 在仪表盘 > 游戏 > 送礼物 > 有效期中输入的值时间戳GMT+9
* @param userData 调用优惠券API时在第二个参数中输入的值
* @param itemId itemData Array - itemData(JSON) {"item_id" : String, "store_item_id" : String, "count" : Number}
* item_id在仪表盘游戏 > 道具中创建的道具项目的唯一ID
* store_item_id要发放的道具ID
* count要发放的道具的数量
* 说明文档https://guide.ncloud-docs.com/docs/zh/game-gamepotserver
* 优惠劵线上回调地址http://acpay.ilod.co.kr/idip/sfzb/pay/ilodCouponNotify
*/
@RequestMapping(value = "/pay/ilodCouponNotify", method = {RequestMethod.POST,RequestMethod.GET})
// public JSONObject ilodCouponNotify(HttpServletRequest request,String userId, String projectId,String platform, String store, String title, String content,String target,String expireMs,String userData,List<itemData> itemId) {
public JSONObject ilodCouponNotify(HttpServletRequest request,String userId, String projectId,String platform, String store, String title, String content,String target,String expireMs,String userData,String itemId) {
JSONObject json = new JSONObject();
try {
List ipWhiteList = new ArrayList<>();
ipWhiteList.add("49.236.143.202");
ipWhiteList.add("49.236.143.198");
ipWhiteList.add("106.10.53.19");
ipWhiteList.add("106.10.52.84");
String ipAddr = getIpAddr(request);
List<itemData> itemDataList = readListValue(itemId, itemData.class);
LOGGER.info("ilodCouponNotify, userId={},projectId={},platform={},store={},title={},content={},target={},expireMs={},ip={},userData={},itemId={}", userId, projectId, platform, store, title,content,target,expireMs,ipAddr,userData,itemId);
//获取自己游戏订单id 通过userData字段穿透传值
String[] split = userData.split("#");
int gameUserId = Integer.parseInt(split[0]); //游戏里角色Id = userId
int serverId = Integer.parseInt(split[1]); //服务器Id
String couponCode = split[2]; //兑换码
boolean contains = ipWhiteList.contains(ipAddr);
if(!contains){
LOGGER.error("pay:ilodCouponNotify, ip = {},白名单ip = {}, ip错误,不在白名单中!!!,", ipAddr,ipWhiteList.toString());
json.put("status",0);
json.put("msg","请勿非法提交订单,如有问题请联系客服!!!");
return json;
}
// 优惠劵 发货接口
int payres = payHandler.processCoupon(gameUserId,serverId,couponCode,title,content,itemDataList);
// 统一发货接口
// int payres = 0;
// if(sandbox.equals(0)){ //正式订单 (是否是测试订单,1:是: 0
// payHandler.processOrder(orderId, out_trade_no); //orderId 游戏订单号 out_trade_no 渠道订单号
// }else if(sandbox.equals(1)){ //测试订单
// payHandler.processOrderTest(orderId, out_trade_no); //orderId 游戏订单号 out_trade_no 渠道订单号
// }
// 成功
if (payres == 1) {
json.put("status",1);
json.put("message","充值成功/重复充值");
return json;
} else if (payres == -2) {
LOGGER.error("pay:gameNoticeInterface, {} 服务器配置错误,", gameUserId);
} else if (payres == -3) {
LOGGER.error("pay:gameNoticeInterface, {} 兑换失败,", gameUserId);
} else {
LOGGER.error("pay:gameNoticeInterface, {} 返回错误,payres={}", gameUserId,payres);
json.put("status",0);
json.put("message","err");
return json;
}
} catch (Exception ex) {
ex.printStackTrace();
}
json.put("status",0);
json.put("message","err");
return json;
}
/**
* 支付回调:国内渠道 QuickGame Android
*
* 说明文档: https://www.quicksdk.com/doc-15.html
* 测试服回调地址http://1.13.176.142/idip/sfzb/pay/quickNotify
*/
@RequestMapping(value = "/pay/quickNotify", method = {RequestMethod.POST,RequestMethod.GET})
public String quickNotify(HttpServletRequest request1,String nt_data,String sign,String md5Sign) {
try {
LOGGER.info("quickNotify--01, nt_data={}sign={}md5Sign={}", nt_data,sign,md5Sign);
String signStr = nt_data + sign + Constant.MD5_KEY;
String mySign=MD5Util.encrypByMd5(signStr);
if(!mySign.equals(md5Sign)){
LOGGER.error("错误信息:签名不一致 mySign={}md5Sign={}", mySign,md5Sign);
return "-1";
}
String deCodeDateXml = QuickSDKUtil.decode(nt_data, Constant.CALLBACK_KEY);
LOGGER.info("quickNotify--02 deCodeDateXml={}",deCodeDateXml);
Map<String, Object> stringObjectMap = XmlUtil.xmlToMap(deCodeDateXml);
Map<String, Object> message = (Map<String, Object>)stringObjectMap.get("message");
String is_test=(String) message.get("is_test"); //是否为测试订单 1为测试 0为线上正式订单游戏应根据情况确定上线后是否向测试订单发放道具。
String channel=(String) message.get("channel"); //渠道标示ID 注意:游戏可根据实情,确定发放道具时是否校验充值来源渠道是否与该角色注册渠道相符
String channel_uid=(String) message.get("channel_uid"); //渠道用户唯一标示,该值从客户端GetUserId()中可获取
String game_order=(String) message.get("game_order"); //游戏在调用QuickSDK发起支付时传递的游戏方订单,这里会原样传回
String order_no=(String) message.get("order_no"); //QuickSDK唯一订单号
String pay_time=(String) message.get("pay_time"); //支付时间 2015-01-01 23:00:00
String amount=(String) message.get("amount"); //成交金额,单位元,游戏最终发放道具金额应以此为准
String status=(String) message.get("status"); //充值状态:0成功, 1失败(为1时 应返回FAILED失败)
String extras_params=(String) message.get("extras_params"); //可为空,充值状态游戏客户端调用SDK发起支付时填写的透传参数.没有则为空
LOGGER.info("quickNotify--03, is_test={}channel={}channel_uid={},game_order={},order_no={},pay_time={},amount={},status={},extras_params={}", is_test,channel,channel_uid,game_order,order_no,pay_time,amount,status,extras_params);
String orderId = game_order; //游戏订单号
String out_trade_no = order_no; //渠道订单号
// 统一发货接口
int payres = 0;
if(is_test.equals("0")){ //正式订单 0一般支付,1测试支付
Double amountDouble = Double.valueOf(amount) * 100;
payres = payHandler.processOrderNew(orderId, out_trade_no,amountDouble.intValue()); //orderId 游戏订单号 out_trade_no 渠道订单号,支付金额 单位分
}else if(is_test.equals("1")){ //测试订单
payres = payHandler.processOrderTest(orderId, out_trade_no); //orderId 游戏订单号 out_trade_no 渠道订单号
}
// 成功
if (payres == 1) {
return "SUCCESS";
} else if (payres == -1) {
LOGGER.error("pay:gameNoticeInterface, {} 订单不存在,", orderId);
} else if (payres == -2) {
LOGGER.error("pay:gameNoticeInterface, {} 订单参数错误,", orderId);
} else if (payres == -3) {
LOGGER.error("pay:gameNoticeInterface, {} 服务器配置错误,", orderId);
} else if (payres == -4) {
LOGGER.error("pay:gameNoticeInterface, {} 充值失败,", orderId);
} else {
LOGGER.error("pay:gameNoticeInterface, {} 返回错误,payres = {}", orderId,payres);
return "-2";
}
} catch (Exception ex) {
ex.printStackTrace();
}
return "-3";
}
/**
* 支付回调:国内渠道 QuickGame Android
*
* 说明文档: https://www.quicksdk.com/doc-15.html
* 测试服回调地址http://1.13.176.142/idip/sfzb/pay/quickNotify
*/
@RequestMapping(value = "/pay/quickNotifyNew", method = {RequestMethod.POST,RequestMethod.GET})
public String quickNotifyNew(String nt_data, String sign, String md5Sign) {
try {
LOGGER.info("quickNotifyNew--01, nt_data={}sign={}md5Sign={}", nt_data,sign,md5Sign);
String signStr = nt_data + sign + Constant.MD5_KEY_NEW;
String mySign=MD5Util.encrypByMd5(signStr);
if(!mySign.equals(md5Sign)){
LOGGER.error("错误信息:签名不一致 mySign={}md5Sign={}", mySign,md5Sign);
return "-1";
}
String deCodeDateXml = QuickSDKUtil.decode(nt_data, Constant.CALLBACK_KEY_NEW);
LOGGER.info("quickNotifyNew--02 deCodeDateXml={}",deCodeDateXml);
Map<String, Object> stringObjectMap = XmlUtil.xmlToMap(deCodeDateXml);
Map<String, Object> message = (Map<String, Object>)stringObjectMap.get("message");
String is_test=(String) message.get("is_test"); //是否为测试订单 1为测试 0为线上正式订单游戏应根据情况确定上线后是否向测试订单发放道具。
String channel=(String) message.get("channel"); //渠道标示ID 注意:游戏可根据实情,确定发放道具时是否校验充值来源渠道是否与该角色注册渠道相符
String channel_uid=(String) message.get("channel_uid"); //渠道用户唯一标示,该值从客户端GetUserId()中可获取
String game_order=(String) message.get("game_order"); //游戏在调用QuickSDK发起支付时传递的游戏方订单,这里会原样传回
String order_no=(String) message.get("order_no"); //QuickSDK唯一订单号
String pay_time=(String) message.get("pay_time"); //支付时间 2015-01-01 23:00:00
String amount=(String) message.get("amount"); //成交金额,单位元,游戏最终发放道具金额应以此为准
String status=(String) message.get("status"); //充值状态:0成功, 1失败(为1时 应返回FAILED失败)
String extras_params=(String) message.get("extras_params"); //可为空,充值状态游戏客户端调用SDK发起支付时填写的透传参数.没有则为空
LOGGER.info("quickNotifyNew--03, is_test={}channel={}channel_uid={},game_order={},order_no={},pay_time={},amount={},status={},extras_params={}", is_test,channel,channel_uid,game_order,order_no,pay_time,amount,status,extras_params);
String orderId = game_order; //游戏订单号
String out_trade_no = order_no; //渠道订单号
// 统一发货接口
int payres = 0;
if(is_test.equals("0")){ //正式订单 0一般支付,1测试支付
Double amountDouble = Double.valueOf(amount) * 100;
payres = payHandler.processOrderNew(orderId, out_trade_no,amountDouble.intValue()); //orderId 游戏订单号 out_trade_no 渠道订单号,支付金额 单位分
}else if(is_test.equals("1")){ //测试订单
payres = payHandler.processOrderTest(orderId, out_trade_no); //orderId 游戏订单号 out_trade_no 渠道订单号
}
// 成功
if (payres == 1) {
return "SUCCESS";
} else if (payres == -1) {
LOGGER.error("pay:gameNoticeInterface, {} 订单不存在,", orderId);
} else if (payres == -2) {
LOGGER.error("pay:gameNoticeInterface, {} 订单参数错误,", orderId);
} else if (payres == -3) {
LOGGER.error("pay:gameNoticeInterface, {} 服务器配置错误,", orderId);
} else if (payres == -4) {
LOGGER.error("pay:gameNoticeInterface, {} 充值失败,", orderId);
} else {
LOGGER.error("pay:gameNoticeInterface, {} 返回错误,payres = {}", orderId,payres);
return "-2";
}
} catch (Exception ex) {
ex.printStackTrace();
}
return "-3";
}
/**
* 支付回调:国内渠道 QuickGame IOS
*
* 说明文档: https://www.quicksdk.com/doc-544.html
* 测试服回调地址http://1.13.176.142/idip/sfzb/pay/quickIosNotify
*/
@RequestMapping(value = "/pay/quickIosNotify", method = {RequestMethod.POST,RequestMethod.GET})
public String quickIosNotify(HttpServletRequest request1,String nt_data,String sign,String md5Sign) {
try {
LOGGER.info("quickIosNotify--01, nt_data={}sign={}md5Sign={}", nt_data,sign,md5Sign);
String signStr = nt_data + sign + Constant.QUICK_IOS_MD5_KEY;
String mySign=MD5Util.encrypByMd5(signStr);
if(!mySign.equals(md5Sign)){
LOGGER.error("错误信息:签名不一致 mySign={}md5Sign={}", mySign,md5Sign);
return "-1";
}
String deCodeDateXml = QuickSDKUtil.decode(nt_data, Constant.QUICK_IOS_CALLBACK_KEY);
LOGGER.info("quickIosNotify--02 deCodeDateXml={}",deCodeDateXml);
Map<String, Object> stringObjectMap = XmlUtil.xmlToMap(deCodeDateXml);
Map<String, Object> message = (Map<String, Object>)stringObjectMap.get("message");
String uid=(String) message.get("uid"); //购买道具的用户uid
String login_name=(String) message.get("login_name"); //购买道具的用户username
String out_order_no=(String) message.get("out_order_no"); //游戏下单时传递的游戏订单号,原样返回
String order_no=(String) message.get("order_no"); //SDK唯一订单号
String pay_time=(String) message.get("pay_time"); //用户支付时间如2017-02-06 14:22:32
String amount=(String) message.get("amount"); //成交金额,单位元,游戏最终发放道具金额应以此为准
String status=(String) message.get("status"); //充值状态:0成功, 1失败(为1时 应返回FAILED失败)
String extras_params=(String) message.get("extras_params"); //可为空,充值状态游戏客户端调用SDK发起支付时填写的透传参数.没有则为空
LOGGER.info("quickIosNotify--03, uid={}login_name={}out_order_no={},order_no={},pay_time={},amount={},status={},extras_params={}", uid,login_name,out_order_no,order_no,pay_time,amount,status,extras_params);
String orderId = out_order_no; //游戏订单号
String out_trade_no = order_no; //渠道订单号
// 统一发货接口
//int payres = 0;
//if(is_test.equals("0")){ //正式订单 0一般支付,1测试支付
// Double amountDouble = Double.valueOf(amount) * 100;
// payres = payHandler.processOrderNew(orderId, out_trade_no,amountDouble.intValue()); //orderId 游戏订单号 out_trade_no 渠道订单号,支付金额 单位分
//}else if(is_test.equals("1")){ //测试订单
// payres = payHandler.processOrderTest(orderId, out_trade_no); //orderId 游戏订单号 out_trade_no 渠道订单号
//}
Double amountDouble = Double.valueOf(amount) * 100;
int payres = payHandler.processOrderNew(orderId, out_trade_no,amountDouble.intValue()); //orderId 游戏订单号 out_trade_no 渠道订单号,支付金额 单位分
// 成功
if (payres == 1) {
return "SUCCESS";
} else if (payres == -1) {
LOGGER.error("pay:gameNoticeInterface, {} 订单不存在,", orderId);
} else if (payres == -2) {
LOGGER.error("pay:gameNoticeInterface, {} 订单参数错误,", orderId);
} else if (payres == -3) {
LOGGER.error("pay:gameNoticeInterface, {} 服务器配置错误,", orderId);
} else if (payres == -4) {
LOGGER.error("pay:gameNoticeInterface, {} 充值失败,", orderId);
} else {
LOGGER.error("pay:gameNoticeInterface, {} 返回错误,payres = {}", orderId,payres);
return "-2";
}
} catch (Exception ex) {
ex.printStackTrace();
}
return "-3";
}
/**
* 支付回调:国内渠道 九九互动渠道
* 说明文档: https://forever9.feishu.cn/docx/ErqPdeDlRo00RJxHqyfcN6GNnsb
* 测试服回调地址http://43.139.240.49/idip/sfzb/pay/jjChannelNotify
*/
@RequestMapping(value = "/pay/jjChannelNotify", method = {RequestMethod.POST,RequestMethod.GET})
public JSONObject jjChannelNotify(HttpServletRequest request,@RequestBody JSONObject jsonObject) {
JSONObject json = new JSONObject();
try {
//SDK所在服务器的所有IP
List ipWhiteList = new ArrayList<>();
ipWhiteList.add("193.112.136.97");
String ipAddr = getIpAddr(request); //获取当前网络ip
boolean contains = ipWhiteList.contains(ipAddr);
if(!contains){
LOGGER.error("pay:jjChannelNotify, ip = {},白名单ip = {}, ip错误,不在白名单中!!!", ipAddr,ipWhiteList.toString());
json.put("ret",-1);
json.put("msg","请勿非法提交订单,如有问题请联系客服!!!");
return json;
}
String appid = jsonObject.getString("appid"); //游戏appid
String openid = jsonObject.getString("openid"); //用户openid
String pid = jsonObject.getString("pid"); //研发商品id发行不关心
int amount = jsonObject.getIntValue("amount"); //支付金额(单位:分),发货的时候一定要校验这个字段,防止中途支付金额被篡改
String transaction_id = jsonObject.getString("transaction_id"); //微信订单号
String out_trade_no = jsonObject.getString("out_trade_no"); //发行方订单号
String game_order_id = jsonObject.getString("game_order_id");
String params = jsonObject.getString("params"); //客户端传的透传参数
int state = jsonObject.getIntValue("state"); //状态是2表示支付成功
String created_at = jsonObject.getString("created_at"); //订单创建时间
String time_end = jsonObject.getString("time_end");
String order_id = jsonObject.getString("order_id"); //发行订单号
String sign = jsonObject.getString("sign"); //签名算法, 用MD5方式签名 签名key是游戏appid
LOGGER.info("jjChannelNotify, appid={},openid={},pid={},amount={},transaction_id={},out_trade_no={},game_order_id={},params={},state={},created_at={}time_end={}order_id={},sign={},ip={}", appid, openid, pid, amount, transaction_id,out_trade_no,game_order_id,params,state,created_at,time_end,order_id,sign,ipAddr);
//获取自己游戏订单id 通过extra_info字段穿透传值
String[] split = params.split("_");
String self_OrderId = split[3].substring(0,split[3].length()-2);
if(state != 2){
LOGGER.error("pay:jjChannelNotify, SDK支付失败,此处不发货state = {}", state);
json.put("ret",-2);
json.put("msg","SDK支付失败,不发货");
return json;
}
//不用签名验证,走下面订单查询验证
// String signStr = appid;
// String mySign=MD5Util.encrypByMd5(signStr);
// if(!mySign.equals(sign)){
// LOGGER.error("错误信息:签名不一致 mySign={}sign={}", mySign,sign);
// json.put("ret",-3);
// json.put("msg","签名不一致");
// return json;
// }
String ret = jjChannelOrderSearch(appid, openid, order_id);
if(!ret.equals("0")){
LOGGER.error("错误信息:订单信息不存在 ret={}", ret);
json.put("ret",-4);
json.put("msg","订单信息不存在");
return json;
}
// 统一发货接口
int payres = payHandler.processOrderNew(self_OrderId, out_trade_no,amount); //game_order_id 游戏订单号 out_trade_no 渠道订单号
// 成功
if (payres == 1) {
json.put("ret",0);
json.put("msg","SUCCESS");
return json;
} else if (payres == -1) {
LOGGER.error("pay:gameNoticeInterface, {} 订单不存在,", game_order_id);
} else if (payres == -2) {
LOGGER.error("pay:gameNoticeInterface, {} 订单参数错误,", game_order_id);
} else if (payres == -3) {
LOGGER.error("pay:gameNoticeInterface, {} 服务器配置错误,", game_order_id);
} else if (payres == -4) {
LOGGER.error("pay:gameNoticeInterface, {} 充值失败,", game_order_id);
} else if (payres == -5) {
LOGGER.error("pay:gameNoticeInterface, {} 提交的金额和支付的金额不一致,", game_order_id);
} else if (payres == -6) {
LOGGER.error("pay:gameNoticeInterface, {} 支付金额不能为0,", game_order_id);
} else {
LOGGER.error("pay:gameNoticeInterface, {} 返回错误,payres = {}", game_order_id,payres);
json.put("ret",-100);
json.put("msg","Pay Fail EerrorCord001");
return json;
}
} catch (Exception ex) {
ex.printStackTrace();
}
json.put("ret",-200);
json.put("msg","Pay Fail EerrorCord002");
return json;
}
/**
* 九九互动渠道
* 订单查询接口GET
* @param appid 游戏appid
* @param openId 用户openid
* @param orderId 发货回调中的order_id字段
* @return
*/
public static String jjChannelOrderSearch(String appid,String openId,String orderId) {
try {
// 请求参数
Map<String, String> headers = new HashMap<String, String>();
headers.put("ContentType", "application/json");
String body = String.format("game_appid=%s&game_openid=%s&orderId=%s", appid, openId, orderId);
String resurl = HttpUtil.fetch("GET", Constant.JJCHANNEL_ORDER_SEARCH_URL, body, headers);
net.sf.json.JSONObject jsonresObject = net.sf.json.JSONObject.fromObject(resurl);
LOGGER.info("jsonresObject="+jsonresObject.toString());
// ret为 0成功非0失败
int ret = jsonresObject.getInt("ret");
if (ret == 0) {
return "0";
}else {
LOGGER.info("错误编号:" + ret);
return String.valueOf(ret);
}
} catch (IOException e) {
e.printStackTrace();
}
return "-1";
}
public static <T> List<T> readListValue(String json, Class<T> tClazz){
return JSON.parseArray(json, tClazz);
}
/**
* 获取当前网络ip
* @param request
* @return
*/
public String getIpAddr(HttpServletRequest request){
String ipAddress = request.getHeader("x-forwarded-for");
if(ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
ipAddress = request.getHeader("Proxy-Client-IP");
}
if(ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
ipAddress = request.getHeader("WL-Proxy-Client-IP");
}
if(ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
ipAddress = request.getRemoteAddr();
if(ipAddress.equals("127.0.0.1") || ipAddress.equals("0:0:0:0:0:0:0:1")){
//根据网卡取本机配置的IP
InetAddress inet=null;
try {
inet = InetAddress.getLocalHost();
} catch (UnknownHostException e) {
e.printStackTrace();
}
ipAddress= inet.getHostAddress();
}
}
//对于通过多个代理的情况第一个IP为客户端真实IP,多个IP按照','分割
if(ipAddress!=null && ipAddress.length()>15){ //"***.***.***.***".length() = 15
if(ipAddress.indexOf(",")>0){
ipAddress = ipAddress.substring(0,ipAddress.indexOf(","));
}
}
return ipAddress;
}
/**
* 支付回调:长尾渠道支付回调
*
* 说明文档: https://www.quicksdk.com/doc-15.html
* 测试服回调地址http://1.13.176.142:8081/idip/sfzb/pay/changWeiNotify
*/
@RequestMapping(value = "/pay/changWeiNotify", method = {RequestMethod.POST,RequestMethod.GET})
public String changWeiNotify(HttpServletRequest request,String nt_data,String sign,String md5Sign) throws UnsupportedEncodingException {
try {
LOGGER.info("changWeiNotify--01, nt_data={}sign={}md5Sign={}", nt_data,sign,md5Sign);
String signStr = nt_data + sign + Constant.CHANGWEI_MD5_KEY;
String mySign=MD5Util.encrypByMd5(signStr);
if(!mySign.equals(md5Sign)){
LOGGER.error("错误信息:签名不一致 mySign={}md5Sign={}", mySign,md5Sign);
return "-1";
}
String deCodeDateXml = QuickSDKUtil.decode(nt_data, Constant.CHANGWEI_CALLBACK_KEY);
LOGGER.info("changWeiNotify--02 deCodeDateXml={}",deCodeDateXml);
Map<String, Object> stringObjectMap = XmlUtil.xmlToMap(deCodeDateXml);
Map<String, Object> message = (Map<String, Object>)stringObjectMap.get("message");
String is_test=(String) message.get("is_test"); //是否为测试订单 1为测试 0为线上正式订单游戏应根据情况确定上线后是否向测试订单发放道具。
String channel=(String) message.get("channel"); //渠道标示ID 注意:游戏可根据实情,确定发放道具时是否校验充值来源渠道是否与该角色注册渠道相符
String channel_uid=(String) message.get("channel_uid"); //渠道用户唯一标示,该值从客户端GetUserId()中可获取
String game_order=(String) message.get("game_order"); //游戏在调用QuickSDK发起支付时传递的游戏方订单,这里会原样传回
String order_no=(String) message.get("order_no"); //QuickSDK唯一订单号
String pay_time=(String) message.get("pay_time"); //支付时间 2015-01-01 23:00:00
String amount=(String) message.get("amount"); //成交金额,单位元,游戏最终发放道具金额应以此为准
String status=(String) message.get("status"); //充值状态:0成功, 1失败(为1时 应返回FAILED失败)
String extras_params=(String) message.get("extras_params"); //可为空,充值状态游戏客户端调用SDK发起支付时填写的透传参数.没有则为空
LOGGER.info("quickNotify--03, is_test={}channel={}channel_uid={},game_order={},order_no={},pay_time={},amount={},status={},extras_params={}", is_test,channel,channel_uid,game_order,order_no,pay_time,amount,status,extras_params);
String orderId = game_order; //游戏订单号
String out_trade_no = order_no; //渠道订单号
// 统一发货接口
int payres = 0;
if(is_test.equals("0")){ //正式订单 0一般支付,1测试支付
Double amountDouble = Double.valueOf(amount) * 100;
payres = payHandler.processOrderNew(orderId, out_trade_no,amountDouble.intValue()); //orderId 游戏订单号 out_trade_no 渠道订单号,支付金额 单位分
}else if(is_test.equals("1")){ //测试订单
payres = payHandler.processOrderTest(orderId, out_trade_no); //orderId 游戏订单号 out_trade_no 渠道订单号
}
// 成功
if (payres == 1) {
return "SUCCESS";
} else if (payres == -1) {
LOGGER.error("pay:gameNoticeInterface, {} 订单不存在,", orderId);
} else if (payres == -2) {
LOGGER.error("pay:gameNoticeInterface, {} 订单参数错误,", orderId);
} else if (payres == -3) {
LOGGER.error("pay:gameNoticeInterface, {} 服务器配置错误,", orderId);
} else if (payres == -4) {
LOGGER.error("pay:gameNoticeInterface, {} 充值失败,", orderId);
} else {
LOGGER.error("pay:gameNoticeInterface, {} 返回错误,payres = {}", orderId,payres);
return "-2";
}
} catch (Exception ex) {
ex.printStackTrace();
}
return "-3";
}
@GetMapping("/pay/superOrder") //bt版sdk
public JSONObject superOrder(@RequestParam("order_sn") String orderSn,
@RequestParam("good_name") String goodName,
@RequestParam("game_order_sn") String gameOrderSn,
@RequestParam("uuid") String uuid,
@RequestParam("pay_money") Integer payMoney,
@RequestParam("game_id") String gameId,
@RequestParam("service_id") String serviceId,
@RequestParam("service_name") String serviceName,
@RequestParam("role_id") String roleId,
@RequestParam("role_name") String roleName,
@RequestParam("time") Integer time,
@RequestParam("pay_status") Integer payStatus,
@RequestParam("remark") String remark,
@RequestParam("sign") String sign
) {
StringBuilder sb = new StringBuilder();
JSONObject json = new JSONObject();
try {
sb.append("good_name=").append(URLEncoder.encode(goodName, "utf-8")).append("&");
sb.append("uuid=").append(uuid).append("&");
sb.append("order_sn=").append(orderSn).append("&");
sb.append("game_order_sn=").append(gameOrderSn).append("&");
sb.append("game_id=").append(gameId).append("&");
sb.append("service_id=").append(serviceId).append("&");
sb.append("service_name=").append(URLEncoder.encode(serviceName, "utf-8")).append("&");
sb.append("role_id=").append(roleId).append("&");
sb.append("role_name=").append(URLEncoder.encode(roleName, "utf-8")).append("&");
sb.append("pay_money=").append(payMoney).append("&");
sb.append("pay_status=").append(payStatus).append("&");
sb.append("remark=").append(URLEncoder.encode(remark, "utf-8")).append("&");
sb.append("time=").append(time).append("&");
sb.append("key=").append(Constant.SUPER_ORDER_KEY);
} catch (UnsupportedEncodingException e) {
LOGGER.error("URLEncoder error, game_id:{}, game_order_sn:{}", gameId, gameOrderSn);
json.put("code", 500);
json.put("msg", "system error");
return json;
}
String mySign = encrypByMd5(sb.toString());
if (!mySign.equals(sign)){
LOGGER.error("super order sign error, game_id:{}, game_order_sn:{}, sign:{}, mySign:{}",
gameId, gameOrderSn, sign, mySign);
json.put("code", 600);
json.put("msg", "sign error");
return json;
}
int payres = 0;
try {
payres = payHandler.processOrderNew(gameOrderSn, orderSn, payMoney * 100);
} catch (Exception e) {
LOGGER.error("processOrder error, game_id:{}, game_order_sn:{}", gameId, gameOrderSn, e);
json.put("code", 500);
json.put("msg", "system error");
return json;
}
// 成功
if (payres == 1) {
json.put("code", 200);
json.put("msg", "success");
return json;
} else if (payres == -1) {
LOGGER.error("pay error, {} 订单不存在,", gameOrderSn);
} else if (payres == -2) {
LOGGER.error("pay error, {} 订单参数错误,", gameOrderSn);
} else if (payres == -3) {
LOGGER.error("pay error, {} 服务器配置错误,", gameOrderSn);
} else if (payres == -4) {
LOGGER.error("pay error, {} 充值失败,", gameOrderSn);
} else {
LOGGER.error("pay error, {} 返回错误,", gameOrderSn);
}
json.put("code", 601);
json.put("msg", "pay error");
return json;
}
@RequestMapping(value = "/pay/x7Order", method = {RequestMethod.POST,RequestMethod.GET})//小7sdk
public String xiaoQiOrder(@RequestParam("encryp_data") String encrypData,
@RequestParam("extends_info_data") String extendsInfoData,
@RequestParam("game_area") String gameArea,
@RequestParam("game_level") String gameLevel,
@RequestParam("game_orderid") String gameOrderId,
@RequestParam("game_role_id") String gameRoleId,
@RequestParam("game_role_name") String gameRoleName,
@RequestParam("sdk_version") String sdkVersion,
@RequestParam("subject") String subject,
@RequestParam("xiao7_goid") Integer xiao7Goid,
@RequestParam("sign_data") String signData
) {
StringBuilder sb = new StringBuilder();
sb.append("encryp_data=").append(encrypData).append("&");
sb.append("extends_info_data=").append(extendsInfoData).append("&");
sb.append("game_area=").append(gameArea).append("&");
sb.append("game_level=").append(gameLevel).append("&");
sb.append("game_orderid=").append(gameOrderId).append("&");
sb.append("game_role_id=").append(gameRoleId).append("&");
sb.append("game_role_name=").append(gameRoleName).append("&");
sb.append("sdk_version=").append(sdkVersion).append("&");
sb.append("subject=").append(subject).append("&");
sb.append("xiao7_goid=").append(xiao7Goid);
String sourceStr = sb.toString();
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.getDecoder().decode((Constant.X7_PUBLIC_KEY)));
PublicKey publicKey = null;
try {
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
publicKey = keyFactory.generatePublic(keySpec);
} catch (Exception e) {
LOGGER.error("generate public key error, encrypData:{}, gameOrderId:{}", encrypData, gameOrderId, e);
return "failed:order error";
}
try {
byte[] rawSignData = Base64.getDecoder().decode(signData);
Signature signature = Signature.getInstance("SHA1withRSA");
signature.initVerify(publicKey);
signature.update(sourceStr.getBytes());
boolean verify = signature.verify(rawSignData);
if (!verify){
LOGGER.error("x7 order sign verify fail, encrypData:{}, gameOrderId:{}, signData:{}, myData:{}",
encrypData, gameOrderId, signData, sourceStr);
return "sign_data_verify_failed";
}
} catch (Exception e) {
LOGGER.error("sign error, encrypData:{}, gameOrderId:{}", encrypData, gameOrderId, e);
return "failed:order error";
}
byte[] rawEncrypData = Base64.getDecoder().decode(encrypData);
String decrypData = null;
try {
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, publicKey);
decrypData = new String(cipher.doFinal(rawEncrypData));
} catch (Exception e) {
LOGGER.error("decrypt data error, encrypData:{}, gameOrderId:{}", encrypData, gameOrderId, e);
return "encryp_data_decrypt_failed";
}
int payres = 0;
try {
String[] strings = decrypData.split("&");
String gameOrderSn = strings[0].split("=")[1];
double payMoney = Double.parseDouble(strings[2].split("=")[1]);
payres = payHandler.processOrderNew(gameOrderSn, String.valueOf(xiao7Goid), (int)(payMoney * 100));
} catch (Exception e) {
LOGGER.error("processOrder error, encrypData:{}, gameOrderId:{}", encrypData, gameOrderId, e);
return "failed:order error";
}
// 成功
if (payres == 1) {
return "success";
} else if (payres == -1) {
LOGGER.error("pay error, {} 订单不存在,", gameOrderId);
} else if (payres == -2) {
LOGGER.error("pay error, {} 订单参数错误,", gameOrderId);
} else if (payres == -3) {
LOGGER.error("pay error, {} 服务器配置错误,", gameOrderId);
} else if (payres == -4) {
LOGGER.error("pay error, {} 充值失败,", gameOrderId);
} else {
LOGGER.error("pay error, {} 返回错误,", gameOrderId);
}
return "failed:order error";
}
@RequestMapping(value = "/pay/iCanOrder", method = {RequestMethod.POST,RequestMethod.GET})//艾肯sdk
public JSONObject iCanOrder(@RequestParam("account") String account,
@RequestParam("serverId") String serverId,
@RequestParam("orderId") String orderId,
@RequestParam("itemId") String itemId,
@RequestParam("iMoney") Integer iMoney,
@RequestParam("gMoney") Integer gMoney,
@RequestParam("roleId") String roleId,
@RequestParam("gOrderId") String gOrderId,
@RequestParam("time") String time,
@RequestParam("verify") String verify,
@RequestParam("platform") String platform
) {
LOGGER.info("iCan pay order, account:{}, serverId:{}, orderId:{}, itemId:{}, iMoney:{}, gMoney:{}, gOrderId:{}, roleId:{}, time:{}, platform:{}",
account, serverId, orderId, itemId, iMoney, gMoney, gOrderId, roleId, time, platform);
JSONObject jsonObject = new JSONObject();
StringBuilder sb = new StringBuilder();
sb.append(account).append(itemId).append(orderId).append(iMoney).append(Constant.AIKEN_SERVER_KEY).append(time).append(roleId);
try {
String mySign = encrypByMd5(sb.toString());
if (!mySign.equals(verify)){
LOGGER.error("iCan order sign verify fail, gOrderId:{}, roleId:{}",
gOrderId, roleId);
jsonObject.put("code", 3);
jsonObject.put("msg", "verify error");
return jsonObject;
}
} catch (Exception e) {
LOGGER.error("iCan order sign error, gOrderId:{}, roleId:{}", gOrderId, roleId, e);
jsonObject.put("code", 3);
jsonObject.put("msg", "verify error");
return jsonObject;
}
int payres = 0;
try {
payres = payHandler.processOrderWithPlatform(gOrderId, orderId, iMoney * 100, platform);
} catch (Exception e) {
LOGGER.error("processOrder error, gOrderId:{}, roleId:{}", gOrderId, roleId, e);
jsonObject.put("code", 99);
jsonObject.put("msg", "server error");
return jsonObject;
}
// 成功
if (payres == 1) {
jsonObject.put("code", 0);
jsonObject.put("msg", "");
return jsonObject;
} else if (payres == -1) {
LOGGER.error("pay error, {} 订单不存在,", gOrderId);
} else if (payres == -2) {
LOGGER.error("pay error, {} 订单参数错误,", gOrderId);
} else if (payres == -3) {
LOGGER.error("pay error, {} 服务器配置错误,", gOrderId);
} else if (payres == -4) {
LOGGER.error("pay error, {} 充值失败,", gOrderId);
} else {
LOGGER.error("pay error, {} 返回错误,", gOrderId);
}
jsonObject.put("code", 99);
jsonObject.put("msg", "server error");
return jsonObject;
}
@RequestMapping(value = "/pay/qianqian", method = {RequestMethod.POST,RequestMethod.GET})//千千sdk
public String iCanOrder(@RequestParam("appId") String appId,
@RequestParam("userId") String userId,
@RequestParam("channelId") String channelId,
@RequestParam("orderId") String orderId,
@RequestParam("orderStatus") String orderStatus,
@RequestParam("amount") String amount,
String currency,
Integer isTest,
String cpOrderID,
String callBackInfo,
@RequestParam("payTime") String payTime,
@RequestParam("sign") String sign) {
LOGGER.info("qianqian pay order, userId:{}, orderId:{}, amount:{}, currency:{}, cpOrderId:{}",
userId, orderId, amount, currency, cpOrderID);
StringBuilder sb = new StringBuilder();
sb.append("amount=").append(amount).append("&");
sb.append("appId=").append(appId).append("&");
if (callBackInfo != null){
sb.append("callBackInfo=").append(callBackInfo).append("&");
}
sb.append("channelId=").append(channelId).append("&");
if (cpOrderID != null){
sb.append("cpOrderID=").append(cpOrderID).append("&");
}
if (currency != null){
sb.append("currency=").append(currency).append("&");
}
if (isTest != null){
sb.append("isTest=").append(isTest).append("&");
}
sb.append("orderId=").append(orderId).append("&");
sb.append("orderStatus=").append(orderStatus).append("&");
sb.append("payTime=").append(payTime).append("&");
sb.append("userId=").append(userId).append("&");
sb.append("key=").append(Constant.QIANQIAN_KEY);
String mySign = encrypByMd5(sb.toString());
if(!mySign.equals(sign)){
LOGGER.error("错误信息:签名不一致 mySign={}md5Sign={}", mySign, sign);
return "sign fail";
}
int payres = 0;
try {
payres = payHandler.processOrderNew(cpOrderID, orderId, Integer.parseInt(amount));
} catch (Exception e) {
LOGGER.error("processOrder error, cpOrderID:{}, userId:{}", cpOrderID, userId, e);
}
if (payres == 1) {
return "SUCCESS";
} else if (payres == -1) {
LOGGER.error("pay error, {} 订单不存在,", cpOrderID);
} else if (payres == -2) {
LOGGER.error("pay error, {} 订单参数错误,", cpOrderID);
} else if (payres == -3) {
LOGGER.error("pay error, {} 服务器配置错误,", cpOrderID);
} else if (payres == -4) {
LOGGER.error("pay error, {} 充值失败,", cpOrderID);
} else {
LOGGER.error("pay error, {} 返回错误,", cpOrderID);
}
return "fail";
}
@RequestMapping(value = "/pay/qianqian/quick", method = {RequestMethod.POST,RequestMethod.GET})//千千sdk
public String iCanOrder(@RequestParam("nt_data") String ntData,
@RequestParam("sign") String sign,
@RequestParam("md5Sign") String md5Sign){
StringBuilder sb = new StringBuilder();
sb.append(ntData).append(sign).append(Constant.QUICK_MD5_KEY);
String mySign = encrypByMd5(sb.toString());
if(!mySign.equals(md5Sign)){
LOGGER.error("错误信息:签名不一致 mySign={}md5Sign={}", mySign, md5Sign);
return "sign fail";
}
String xml = QuickSDKUtil.decode(ntData, Constant.QUICK_CALLBACK_KEY);
DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder dBuilder = null;
Document doc = null;
try {
dBuilder = dbFactory.newDocumentBuilder();
doc = dBuilder.parse(new InputSource(new StringReader(xml)));
} catch (ParserConfigurationException | SAXException | IOException e) {
LOGGER.info("qianqian quick decode error ", e);
return "decode fail";
}
doc.getDocumentElement().normalize();
NodeList nodeList = doc.getElementsByTagName("message");
Node node = nodeList.item(0);
if (node.getNodeType() == Node.ELEMENT_NODE) {
Element element = (Element) node;
String channel_uid = element.getElementsByTagName("channel_uid").item(0).getTextContent();
String game_order = element.getElementsByTagName("game_order").item(0).getTextContent();
String order_no = element.getElementsByTagName("order_no").item(0).getTextContent();
String amount = element.getElementsByTagName("amount").item(0).getTextContent();
int payres = 0;
try {
payres = payHandler.processOrderNew(game_order, order_no, (int)(Double.parseDouble(amount)) * 100);
} catch (Exception e) {
LOGGER.error("processOrder error, cpOrderID:{}, userId:{}", game_order, channel_uid, e);
}
if (payres == 1) {
return "SUCCESS";
} else if (payres == -1) {
LOGGER.error("pay error, {} 订单不存在,", game_order);
} else if (payres == -2) {
LOGGER.error("pay error, {} 订单参数错误,", game_order);
} else if (payres == -3) {
LOGGER.error("pay error, {} 服务器配置错误,", game_order);
} else if (payres == -4) {
LOGGER.error("pay error, {} 充值失败,", game_order);
} else {
LOGGER.error("pay error, {} 返回错误,", game_order);
}
return "fail";
}else {
return "decode fail";
}
}
@RequestMapping(value = "/pay/ky/quick", method = {RequestMethod.POST,RequestMethod.GET})
public String kyOrder(@RequestParam("nt_data") String ntData,
@RequestParam("sign") String sign,
@RequestParam("md5Sign") String md5Sign){
StringBuilder sb = new StringBuilder();
sb.append(ntData).append(sign).append(Constant.QUICK_MD5_KEY_2);
String mySign = encrypByMd5(sb.toString());
if(!mySign.equals(md5Sign)){
LOGGER.error("错误信息:签名不一致 mySign={}md5Sign={}", mySign, md5Sign);
return "sign fail";
}
String xml = QuickSDKUtil.decode(ntData, Constant.QUICK_CALLBACK_KEY_2);
DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder dBuilder = null;
Document doc = null;
try {
dBuilder = dbFactory.newDocumentBuilder();
doc = dBuilder.parse(new InputSource(new StringReader(xml)));
} catch (ParserConfigurationException | SAXException | IOException e) {
LOGGER.info("ky quick decode error ", e);
return "decode fail";
}
doc.getDocumentElement().normalize();
NodeList nodeList = doc.getElementsByTagName("message");
Node node = nodeList.item(0);
if (node.getNodeType() == Node.ELEMENT_NODE) {
Element element = (Element) node;
String channel_uid = element.getElementsByTagName("channel_uid").item(0).getTextContent();
String game_order = element.getElementsByTagName("game_order").item(0).getTextContent();
String order_no = element.getElementsByTagName("order_no").item(0).getTextContent();
String amount = element.getElementsByTagName("amount").item(0).getTextContent();
int payres = 0;
try {
payres = payHandler.processOrderNew(game_order, order_no, (int)(Double.parseDouble(amount)) * 100);
} catch (Exception e) {
LOGGER.error("processOrder error, cpOrderID:{}, userId:{}", game_order, channel_uid, e);
}
if (payres == 1) {
return "SUCCESS";
} else if (payres == -1) {
LOGGER.error("pay error, {} 订单不存在,", game_order);
} else if (payres == -2) {
LOGGER.error("pay error, {} 订单参数错误,", game_order);
} else if (payres == -3) {
LOGGER.error("pay error, {} 服务器配置错误,", game_order);
} else if (payres == -4) {
LOGGER.error("pay error, {} 充值失败,", game_order);
} else {
LOGGER.error("pay error, {} 返回错误,", game_order);
}
return "fail";
}else {
return "decode fail";
}
}
}