root
/
sk_pay
generated from root/miduo_server
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
sk_pay/src/main/java/com/jmfy/controller/PayController.java

1786 lines
90 KiB
Java
Raw Normal View History

first commit
2024-07-15 11:45:38 +08:00
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;
//生成订单号 （之前老的，现在没用到）
@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日志01：region={}, 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 编码格式： UTF8，Base64 编码
* @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 编码格式： UTF8，Base64 编码
* @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 EerrorCord：001");
return json;
}
} catch (Exception ex) {
ex.printStackTrace();
}
json.put("status",0);
json.put("message","Pay Fail EerrorCord：002");
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 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 EerrorCord：001");
return json;
}
} catch (Exception ex) {
ex.printStackTrace();
}
json.put("ret",-200);
json.put("msg","Pay Fail EerrorCord：002");
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";
}
}
}