package com.xcong.excoin.modules.okxNewPrice.okxpi.verify.impl;
|
|
import cn.hutool.core.util.ObjectUtil;
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.xcong.excoin.modules.okxNewPrice.utils.FebsException;
|
import com.xcong.excoin.modules.okxNewPrice.utils.FebsResponse;
|
import com.xcong.excoin.modules.okxNewPrice.okxpi.DataUtil;
|
import com.xcong.excoin.modules.okxNewPrice.okxpi.config.Dto.QuantApiMessage;
|
import com.xcong.excoin.modules.okxNewPrice.okxpi.config.OKXAccount;
|
import com.xcong.excoin.modules.okxNewPrice.okxpi.config.enums.DefaultUrls;
|
import com.xcong.excoin.modules.okxNewPrice.okxpi.config.enums.HttpMethod;
|
import com.xcong.excoin.modules.okxNewPrice.okxpi.config.utils.OKXContants;
|
import com.xcong.excoin.modules.okxNewPrice.okxpi.verify.IVerifyAccountService;
|
import com.xcong.excoin.modules.okxNewPrice.okxpi.verify.dto.*;
|
import com.xcong.excoin.modules.okxNewPrice.okxpi.verify.enums.PublicStatusEnum;
|
import com.xcong.excoin.modules.okxNewPrice.okxpi.verify.vo.ApiAccountHoldVo;
|
import com.xcong.excoin.modules.okxNewPrice.okxpi.verify.vo.ApiPositionsInfoVo;
|
import com.xcong.excoin.modules.okxNewPrice.okxpi.verify.vo.ProductMessVo;
|
import com.xcong.excoin.modules.okxNewPrice.okxpi.verify.vo.SinglemarketVo;
|
import com.xcong.excoin.modules.okxNewPrice.zhanghu.IApiMessageService;
|
import com.xcong.excoin.modules.okxNewPrice.zhanghu.ZhangHuEnum;
|
import lombok.RequiredArgsConstructor;
|
import lombok.SneakyThrows;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
|
import java.io.BufferedReader;
|
import java.io.InputStreamReader;
|
import java.math.BigDecimal;
|
import java.net.HttpURLConnection;
|
import java.net.URL;
|
import java.util.*;
|
|
@Slf4j
|
@Service("oKXVerifyAccount")
|
@RequiredArgsConstructor
|
public class OKXVerifyAccountServiceImpl implements IVerifyAccountService {
|
|
private final IApiMessageService apiMessageService;
|
@Value("${spring.OKEX.baseurl}")
|
private String baseurl;
|
|
@Override
|
public OKXAccount initAccount(QuantApiMessage quantApiMessage) {
|
return new OKXAccount(
|
quantApiMessage.getAccountType().equalsIgnoreCase("true") ? DefaultUrls.USDM_PROD_URL : DefaultUrls.USDM_UAT_URL,
|
quantApiMessage.getASecretkey(),
|
quantApiMessage.getBSecretkey(),
|
quantApiMessage.getPassPhrass(),
|
!quantApiMessage.getAccountType().equalsIgnoreCase("true"));
|
|
}
|
|
@Override
|
public OKXAccount initAccountV2(String apiKey, String secretKey, String passPhrass, boolean accountType) {
|
return new OKXAccount(
|
accountType ? DefaultUrls.USDM_PROD_URL : DefaultUrls.USDM_UAT_URL,
|
apiKey,
|
secretKey,
|
passPhrass,
|
!accountType);
|
}
|
|
@SneakyThrows
|
@Override
|
public FebsResponse verifyAccount(ApiMessageDto apiMessageDto) {
|
if(validateAccount(apiMessageDto)){
|
return new FebsResponse().success();
|
}
|
return new FebsResponse().fail();
|
}
|
|
@Override
|
public FebsResponse getProductMess(ApiValidApiMessageDto apiValidApiMessageDto) {
|
Long id = apiValidApiMessageDto.getId();
|
|
QuantApiMessage quantApiMessage = apiMessageService.getApiMessage(ZhangHuEnum.JIAOYISUO.getValue());
|
if(ObjectUtil.isEmpty(quantApiMessage)){
|
throw new FebsException("参数错误");
|
}
|
|
OKXAccount okxAccount = this.initAccount(quantApiMessage);
|
LinkedHashMap<String, Object> balanceParameters = new LinkedHashMap<>();
|
balanceParameters.put("instType", "SWAP");
|
if(StringUtils.isNotBlank(apiValidApiMessageDto.getCoinName())){
|
balanceParameters.put("instId", apiValidApiMessageDto.getCoinName()+"-USD-SWAP");
|
balanceParameters.put("instFamily", apiValidApiMessageDto.getCoinName()+"-USD");
|
}
|
|
String productStr = okxAccount.requestHandler.sendSignedRequest(okxAccount.baseUrl, OKXContants.INSTRUMENTS, balanceParameters, HttpMethod.GET, okxAccount.isSimluate());
|
log.info("productStr:{}", productStr);
|
JSONObject balanceJson = JSON.parseObject(productStr);
|
JSONObject data = balanceJson.getJSONArray("data").getJSONObject(0);
|
|
ProductMessVo productMessVo = new ProductMessVo();
|
productMessVo.setLotSz(data.getString("lotSz"));
|
productMessVo.setMinSz(data.getString("minSz"));
|
productMessVo.setTickSz(data.getString("tickSz"));
|
productMessVo.setCtVal(data.getString("ctVal"));
|
|
return new FebsResponse().success().data(productMessVo);
|
}
|
|
@Override
|
public FebsResponse getCurrenPrice(OperateCurrencyDto operateCurrencyDto) {
|
|
QuantApiMessage quantApiMessage = apiMessageService.getApiMessage(ZhangHuEnum.JIAOYISUO.getValue());
|
if(null == quantApiMessage){
|
return new FebsResponse().fail().message("请先配置交易所");
|
}
|
OKXAccount okxAccount = this.initAccount(quantApiMessage);
|
|
LinkedHashMap<String, Object> balanceParameters = new LinkedHashMap<>();
|
if(StringUtils.isNotBlank(operateCurrencyDto.getCoinSymbol())){
|
balanceParameters.put("instId", operateCurrencyDto.getCoinSymbol()+"-SWAP");
|
}
|
String ticker = okxAccount.requestHandler.sendSignedRequest(okxAccount.baseUrl, OKXContants.TICKER, balanceParameters, HttpMethod.GET, okxAccount.isSimluate());
|
|
log.info("ticker================:{}", ticker);
|
|
JSONObject jsonObject = JSON.parseObject(ticker);
|
JSONObject data = jsonObject.getJSONArray("data").getJSONObject(0);
|
|
SinglemarketVo singlemarketVo = new SinglemarketVo();
|
singlemarketVo.setInstId(data.getString("instId"));
|
singlemarketVo.setLast(data.getString("last"));
|
singlemarketVo.setInstType(data.getString("instType"));
|
|
return new FebsResponse().success().data(singlemarketVo);
|
}
|
|
@Override
|
public FebsResponse getlever(OperateCurrencyLeverDto operateCurrencyLeverDto) {
|
|
QuantApiMessage quantApiMessage = apiMessageService.getApiMessage(ZhangHuEnum.JIAOYISUO.getValue());
|
if(ObjectUtil.isEmpty(quantApiMessage)){
|
throw new FebsException("参数错误");
|
}
|
|
OKXAccount okxAccount = this.initAccount(quantApiMessage);
|
LinkedHashMap<String, Object> balanceParameters = new LinkedHashMap<>();
|
balanceParameters.put("instId", operateCurrencyLeverDto.getInstId());
|
balanceParameters.put("mgnMode", "cross");
|
String leverStr = okxAccount.requestHandler.sendSignedRequest(okxAccount.baseUrl, OKXContants.LEVERAGE, balanceParameters, HttpMethod.GET, okxAccount.isSimluate());
|
log.info("leverStr:{}", leverStr);
|
JSONObject leverStrJson = JSON.parseObject(leverStr);
|
|
Set<String> leverage = new HashSet<>();
|
|
JSONArray details = leverStrJson.getJSONArray("data");
|
int size = details.size();
|
for (int i = 0; i < size; i++) {
|
leverage.add(details.getJSONObject(i).getString("lever"));
|
}
|
|
|
log.info("leverage:{}", leverage);
|
|
return new FebsResponse().success().data(leverage);
|
}
|
|
@Override
|
public FebsResponse setLever(OperateCurrencyLeverDto operateCurrencyLeverDto) {
|
|
log.info("OKX_SET_LEVEL");
|
log.info("operateCurrencyLeverDto:{}", operateCurrencyLeverDto);
|
|
QuantApiMessage quantApiMessage = apiMessageService.getApiMessage(ZhangHuEnum.JIAOYISUO.getValue());
|
if(ObjectUtil.isEmpty(quantApiMessage)){
|
throw new FebsException("参数错误");
|
}
|
|
OKXAccount okxAccount = this.initAccount(quantApiMessage);
|
LinkedHashMap<String, Object> balanceParameters = new LinkedHashMap<>();
|
balanceParameters.put("instId", operateCurrencyLeverDto.getInstId()+"-SWAP");
|
balanceParameters.put("mgnMode", "cross");
|
balanceParameters.put("lever", operateCurrencyLeverDto.getLever());
|
String setleverStr = okxAccount.requestHandler.sendSignedRequest(okxAccount.baseUrl, OKXContants.SETLEVERAGE, balanceParameters, HttpMethod.POST, okxAccount.isSimluate());
|
log.info("setleverStr:{}", setleverStr);
|
JSONObject leverStrJson = JSON.parseObject(setleverStr);
|
|
String code = leverStrJson.getString("code");
|
if("0".equals(code)||"59000".equals(code)){
|
if("59000".equals(code)){
|
return new FebsResponse().success().message("59000");
|
}
|
return new FebsResponse().success().message("设置杠杆成功");
|
} else {
|
return new FebsResponse().fail().message("设置杠杆失败");
|
}
|
|
}
|
|
/**
|
* 测试API链接
|
*
|
* @param quantApiMessage 包含API链接信息的DTO对象
|
* @return 返回一个FebsResponse对象，包含验证结果和消息
|
*/
|
@Override
|
public FebsResponse testApiLink(QuantApiMessage quantApiMessage) {
|
log.info("apiMessageDto:{}",quantApiMessage);
|
try{
|
// 初始化账户对象
|
OKXAccount okxAccount = this.initAccount(quantApiMessage);
|
|
// 创建用于存储余额查询参数的容器
|
LinkedHashMap<String, Object> balanceParameters = new LinkedHashMap<>();
|
log.info("okxAccount:{}",okxAccount);
|
|
// 发送签名请求以获取账户余额
|
String balance = okxAccount.requestHandler.sendSignedRequest(okxAccount.baseUrl, OKXContants.BALANCE, balanceParameters, HttpMethod.GET, okxAccount.isSimluate());
|
log.info("balance:{}",balance);
|
|
// 解析余额响应JSON
|
JSONObject balanceJson = JSON.parseObject(balance);
|
|
// 检查余额响应代码，如果为0则表示成功
|
if("0".equals(balanceJson.getString("code").toString())){
|
// 更新QuantApiMessage状态为成功
|
HashMap<String, Integer> objectObjectHashMap = new HashMap<>();
|
objectObjectHashMap.put("state", PublicStatusEnum.API_MESSAGE_STATUS_SUCCESS);
|
return new FebsResponse().success().data(objectObjectHashMap).message("账号验证成功");
|
}
|
|
// 返回验证失败的消息
|
return new FebsResponse().fail().message("账号验证失败");
|
} catch (Exception e){
|
// 异常情况下返回验证失败的消息
|
return new FebsResponse().fail().message("账号验证失败");
|
}
|
}
|
|
/**
|
* 获取账户余额的方法
|
*
|
* @param apiAccountBalanceDto 包含账户余额查询信息的数据传输对象
|
* @throws FebsException 当API消息信息未设置时抛出异常
|
*/
|
@Override
|
public void getAccountBalance(ApiAccountBalanceDto apiAccountBalanceDto) {
|
// 提取API消息ID、账户类型和币种名称
|
String coinName = apiAccountBalanceDto.getCoinName();
|
|
// 根据ID查询API消息信息
|
QuantApiMessage quantApiMessage = apiMessageService.getApiMessage(ZhangHuEnum.JIAOYISUO.getValue());
|
// 检查API消息信息是否存在
|
if(ObjectUtil.isEmpty(quantApiMessage)){
|
throw new FebsException("API_MESSAGE信息未设置");
|
}
|
|
// 初始化账户对象
|
OKXAccount okxAccount = this.initAccount(quantApiMessage);
|
|
// 构建查询余额的参数
|
LinkedHashMap<String, Object> balanceParameters = new LinkedHashMap<>();
|
balanceParameters.put("ccy", coinName);
|
// 发送签名请求获取余额信息
|
String balance = okxAccount.requestHandler.sendSignedRequest(
|
okxAccount.baseUrl,
|
OKXContants.BALANCE,
|
balanceParameters,
|
HttpMethod.GET,
|
okxAccount.isSimluate());
|
// 记录余额信息日志
|
log.info("ACCOUNT_BALANCE:{}", balance);
|
JSONObject balanceJson = JSON.parseObject(balance);
|
JSONObject data = balanceJson.getJSONArray("data").getJSONObject(0);
|
JSONArray details = data.getJSONArray("details");
|
for (int i = 0; i < details.size(); i++) {
|
JSONObject jsonObject = details.getJSONObject(i);
|
// 总权益
|
String bal = jsonObject.getString("eq");
|
// String upl = jsonObject.getString("upl");
|
}
|
}
|
|
@Override
|
public ApiAccountHoldVo getAccountBalanceInfo(ApiAccountBalanceInfoDto apiAccountBalanceInfoDto) {
|
ApiAccountHoldVo apiAccountHoldVo = new ApiAccountHoldVo();
|
|
// 提取API消息ID、账户类型和币种名称
|
Long apiMessageId = apiAccountBalanceInfoDto.getId();
|
String coinName = apiAccountBalanceInfoDto.getCoinName();
|
|
// 根据ID查询API消息信息
|
QuantApiMessage quantApiMessage = apiMessageService.getApiMessage(
|
ZhangHuEnum.JIAOYISUO.getValue()
|
);
|
// 检查API消息信息是否存在
|
if(ObjectUtil.isEmpty(quantApiMessage)){
|
throw new FebsException("API_MESSAGE信息未设置");
|
}
|
|
// 初始化账户对象
|
OKXAccount okxAccount = this.initAccount(quantApiMessage);
|
|
// 构建查询余额的参数
|
LinkedHashMap<String, Object> balanceParameters = new LinkedHashMap<>();
|
balanceParameters.put("ccy", coinName);
|
// 发送签名请求获取余额信息
|
String balance = okxAccount.requestHandler.sendSignedRequest(
|
okxAccount.baseUrl,
|
OKXContants.BALANCE,
|
balanceParameters,
|
HttpMethod.GET,
|
okxAccount.isSimluate());
|
// 记录余额信息日志
|
log.info("ACCOUNT_BALANCE:{}", balance);
|
JSONObject balanceJson = JSON.parseObject(balance);
|
JSONObject data = balanceJson.getJSONArray("data").getJSONObject(0);
|
JSONArray details = data.getJSONArray("details");
|
for (int i = 0; i < details.size(); i++) {
|
JSONObject jsonObject = details.getJSONObject(i);
|
log.info("OKX-HOLD:",jsonObject);
|
// 总权益
|
String bal = jsonObject.getString("eq");//币种总权益
|
String cashBal = jsonObject.getString("cashBal");//币种余额
|
String availEq = jsonObject.getString("availEq");//可用保证金
|
String availBal = jsonObject.getString("availBal");//可用余额
|
String frozenBal = jsonObject.getString("frozenBal");//币种占用金额
|
String imr = jsonObject.getString("imr");//币种维度全仓占用保证金，适用于现货和合约模式且有全仓仓位时
|
String mgnRatio = jsonObject.getString("mgnRatio");//币种全仓保证金率，衡量账户内某项资产风险的指标
|
String mmr = jsonObject.getString("mmr");//币种维度全仓维持保证金
|
String upl = jsonObject.getString("upl");//未实现盈亏
|
apiAccountHoldVo.setTotalBalance(new BigDecimal(bal));
|
apiAccountHoldVo.setTotalPercent(new BigDecimal(upl));
|
apiAccountHoldVo.setAvailableBalance(new BigDecimal(availBal));
|
// apiAccountHoldVo.setHoldBalance(new BigDecimal(mmr));
|
apiAccountHoldVo.setHoldBalance(new BigDecimal(mmr));
|
apiAccountHoldVo.setUseBalance(new BigDecimal(mmr));
|
apiAccountHoldVo.setCashBal(new BigDecimal(cashBal));
|
apiAccountHoldVo.setFrozenBal(new BigDecimal(frozenBal));
|
apiAccountHoldVo.setAvailEq(new BigDecimal(availEq));
|
apiAccountHoldVo.setMgnRatio(mgnRatio);
|
}
|
return apiAccountHoldVo;
|
}
|
|
@Override
|
public ApiPositionsInfoVo getAccountPositionsInfo(ApiPositionsInfoDto apiPositionsInfoDto) {
|
|
log.info("getAccountPositionsInfo:{}",apiPositionsInfoDto);
|
ApiPositionsInfoVo apiPositionsInfoVo = new ApiPositionsInfoVo();
|
// 提取API消息ID、账户类型和币种名称
|
Long apiMessageId = apiPositionsInfoDto.getId();
|
String coinName = apiPositionsInfoDto.getCoinName();
|
|
// 根据ID查询API消息信息
|
QuantApiMessage quantApiMessage = apiMessageService.getApiMessage(
|
ZhangHuEnum.JIAOYISUO.getValue()
|
);
|
// 检查API消息信息是否存在
|
if(ObjectUtil.isEmpty(quantApiMessage)){
|
throw new FebsException("API_MESSAGE信息未设置");
|
}
|
|
// 初始化账户对象
|
OKXAccount okxAccount = this.initAccount(quantApiMessage);
|
|
// 构建查询余额的参数
|
LinkedHashMap<String, Object> positionsParameters = new LinkedHashMap<>();
|
positionsParameters.put("instType", "SWAP");
|
positionsParameters.put("instId", coinName+"-USDT-SWAP");
|
try{
|
// 发送签名请求获取余额信息
|
String positions = okxAccount.requestHandler.sendSignedRequest(
|
okxAccount.baseUrl,
|
OKXContants.POSITIONS,
|
positionsParameters,
|
HttpMethod.GET,
|
okxAccount.isSimluate());
|
// 记录余额信息日志
|
log.info("POSITIONS:{}", positions);
|
JSONObject balanceJson = JSON.parseObject(positions);
|
String code = balanceJson.getString("code");
|
if(!"0".equals(code)){
|
return null;
|
}
|
JSONObject data = balanceJson.getJSONArray("data").getJSONObject(0);
|
String avgPx = data.getString("avgPx");
|
String upl = data.getString("upl");
|
String markPx = data.getString("markPx");
|
String bePx = data.getString("bePx");
|
String pos = data.getString("pos");
|
apiPositionsInfoVo.setUpl(new BigDecimal(ObjectUtil.isNotEmpty(upl)? DataUtil.getDecimalDigits8(upl):"0"));
|
apiPositionsInfoVo.setAvgPx(new BigDecimal(ObjectUtil.isNotEmpty(avgPx)?DataUtil.getDecimalDigits8(avgPx):"0"));
|
apiPositionsInfoVo.setMarkPx(new BigDecimal(ObjectUtil.isNotEmpty(markPx)?DataUtil.getDecimalDigits8(markPx):"0"));
|
apiPositionsInfoVo.setBePx(new BigDecimal(ObjectUtil.isNotEmpty(bePx)?DataUtil.getDecimalDigits8(bePx):"0"));
|
apiPositionsInfoVo.setPos(new BigDecimal(ObjectUtil.isNotEmpty(pos)?DataUtil.getDecimalDigits8(pos):"0"));
|
apiPositionsInfoVo.setCoinName(coinName);
|
return apiPositionsInfoVo;
|
}catch (Exception e){
|
return null;
|
}
|
|
}
|
|
@Override
|
public FebsResponse getTradeData(ApiValidApiMessageDto apiValidApiMessageDto) {
|
|
log.info("getTradeData:{}", apiValidApiMessageDto);
|
QuantApiMessage quantApiMessage = apiMessageService.getApiMessage(
|
ZhangHuEnum.JIAOYISUO.getValue()
|
);
|
// 检查API消息信息是否存在
|
if(ObjectUtil.isEmpty(quantApiMessage)){
|
throw new FebsException("API_MESSAGE信息未设置");
|
}
|
|
// 初始化账户对象
|
OKXAccount okxAccount = this.initAccount(quantApiMessage);
|
|
// 构建查询余额的参数
|
LinkedHashMap<String, Object> positionsParameters = new LinkedHashMap<>();
|
try{
|
// 发送签名请求获取余额信息
|
String tradedata = okxAccount.requestHandler.sendSignedRequest(
|
okxAccount.baseUrl,
|
OKXContants.TRADEDATA,
|
positionsParameters,
|
HttpMethod.GET,
|
okxAccount.isSimluate());
|
// 记录余额信息日志
|
log.info("tradedata:{}", tradedata);
|
JSONObject balanceJson = JSON.parseObject(tradedata);
|
String code = balanceJson.getString("code");
|
if(!"0".equals(code)){
|
return null;
|
}
|
JSONObject dataObject = balanceJson.getJSONObject("data");
|
JSONArray contractArray = dataObject.getJSONArray("contract");
|
List<String> contractList = new ArrayList<>();
|
if (contractArray != null) {
|
for (int i = 0; i < contractArray.size(); i++) {
|
contractList.add(contractArray.getString(i));
|
}
|
}
|
return new FebsResponse().data(contractList);
|
}catch (Exception e){
|
return null;
|
}
|
}
|
|
@Override
|
public FebsResponse getBuySellSituation(ApiValidApiMessageDto apiValidApiMessageDto) {
|
log.info("getBuySellSituation:{}", apiValidApiMessageDto);
|
|
String coinName = apiValidApiMessageDto.getCoinName();// String coinName = "BTC";
|
QuantApiMessage quantApiMessage = apiMessageService.getApiMessage(
|
ZhangHuEnum.JIAOYISUO.getValue()
|
);
|
// 检查API消息信息是否存在
|
if(ObjectUtil.isEmpty(quantApiMessage)){
|
throw new FebsException("API_MESSAGE信息未设置");
|
}
|
|
// 初始化账户对象
|
OKXAccount okxAccount = this.initAccount(quantApiMessage);
|
|
// 构建查询余额的参数
|
LinkedHashMap<String, Object> positionsParameters = new LinkedHashMap<>();
|
positionsParameters.put("period", "4H");
|
positionsParameters.put("instId", coinName+"-USDT-SWAP");
|
positionsParameters.put("limit", "1");
|
try{
|
// 发送签名请求获取余额信息
|
String buySellSituation = okxAccount.requestHandler.sendSignedRequest(
|
okxAccount.baseUrl,
|
OKXContants.BUYSELLSITUATION,
|
positionsParameters,
|
HttpMethod.GET,
|
okxAccount.isSimluate());
|
// 记录余额信息日志
|
log.info("buySellSituation:{}", buySellSituation);
|
JSONObject balanceJson = JSON.parseObject(buySellSituation);
|
String code = balanceJson.getString("code");
|
if(!"0".equals(code)){
|
return null;
|
}
|
JSONArray dataArray = balanceJson.getJSONArray("data");
|
TradeBigdataDto tradeBigdataDto = new TradeBigdataDto();
|
if (dataArray != null) {
|
JSONArray innerArray = dataArray.getJSONArray(0);
|
String sellVol = innerArray.getString(1);
|
String buyVol = innerArray.getString(2);
|
String ts = innerArray.getString(0);
|
tradeBigdataDto.setBuyVol(buyVol);
|
tradeBigdataDto.setSellVol(sellVol);
|
tradeBigdataDto.setTs(ts);
|
}
|
return new FebsResponse().data(tradeBigdataDto);
|
}catch (Exception e){
|
return null;
|
}
|
}
|
|
@Override
|
public FebsResponse getPositionRatio(ApiValidApiMessageDto apiValidApiMessageDto) {
|
log.info("getPositionRatio:{}", apiValidApiMessageDto);
|
|
String coinName = apiValidApiMessageDto.getCoinName();// String coinName = "BTC";
|
QuantApiMessage quantApiMessage = apiMessageService.getApiMessage(
|
ZhangHuEnum.JIAOYISUO.getValue()
|
);
|
// 检查API消息信息是否存在
|
if(ObjectUtil.isEmpty(quantApiMessage)){
|
throw new FebsException("API_MESSAGE信息未设置");
|
}
|
|
// 初始化账户对象
|
OKXAccount okxAccount = this.initAccount(quantApiMessage);
|
|
// 构建查询余额的参数
|
LinkedHashMap<String, Object> positionsParameters = new LinkedHashMap<>();
|
positionsParameters.put("period", "4H");
|
positionsParameters.put("instId", coinName+"-USDT-SWAP");
|
positionsParameters.put("limit", "1");
|
try{
|
// 发送签名请求获取余额信息
|
String positionRatio = okxAccount.requestHandler.sendSignedRequest(
|
okxAccount.baseUrl,
|
OKXContants.POSITIONRATIO,
|
positionsParameters,
|
HttpMethod.GET,
|
okxAccount.isSimluate());
|
// 记录余额信息日志
|
log.info("positionRatio:{}", positionRatio);
|
JSONObject balanceJson = JSON.parseObject(positionRatio);
|
String code = balanceJson.getString("code");
|
if(!"0".equals(code)){
|
return null;
|
}
|
JSONArray dataArray = balanceJson.getJSONArray("data");
|
TradeBigdataDto tradeBigdataDto = new TradeBigdataDto();
|
if (dataArray != null) {
|
JSONArray innerArray = dataArray.getJSONArray(0);
|
String longShortAcctRatio = innerArray.getString(1);
|
String ts = innerArray.getString(0);
|
tradeBigdataDto.setLongShortAcctRatio(longShortAcctRatio);
|
tradeBigdataDto.setTs(ts);
|
}
|
return new FebsResponse().data(tradeBigdataDto);
|
}catch (Exception e){
|
return null;
|
}
|
}
|
|
@Override
|
public FebsResponse getPositionTradingvolume(ApiValidApiMessageDto apiValidApiMessageDto) {
|
log.info("getPositionTradingvolume:{}", apiValidApiMessageDto);
|
|
String coinName = apiValidApiMessageDto.getCoinName();// String coinName = "BTC";
|
QuantApiMessage quantApiMessage = apiMessageService.getApiMessage(
|
ZhangHuEnum.JIAOYISUO.getValue()
|
);
|
// 检查API消息信息是否存在
|
if(ObjectUtil.isEmpty(quantApiMessage)){
|
throw new FebsException("API_MESSAGE信息未设置");
|
}
|
|
// 初始化账户对象
|
OKXAccount okxAccount = this.initAccount(quantApiMessage);
|
|
// 构建查询余额的参数
|
LinkedHashMap<String, Object> positionsParameters = new LinkedHashMap<>();
|
positionsParameters.put("period", "1D");
|
positionsParameters.put("ccy", coinName);
|
positionsParameters.put("limit", "1");
|
try{
|
// 发送签名请求获取余额信息
|
String positionTradingvolume = okxAccount.requestHandler.sendSignedRequest(
|
okxAccount.baseUrl,
|
OKXContants.POSITIONVOLUME,
|
positionsParameters,
|
HttpMethod.GET,
|
okxAccount.isSimluate());
|
// 记录余额信息日志
|
log.info("positionTradingvolume:{}", positionTradingvolume);
|
JSONObject balanceJson = JSON.parseObject(positionTradingvolume);
|
String code = balanceJson.getString("code");
|
if(!"0".equals(code)){
|
return null;
|
}
|
JSONArray dataArray = balanceJson.getJSONArray("data");
|
TradeBigdataDto tradeBigdataDto = new TradeBigdataDto();
|
if (dataArray != null) {
|
JSONArray innerArray = dataArray.getJSONArray(0);
|
String oi = innerArray.getString(1);
|
String vol = innerArray.getString(2);
|
String ts = innerArray.getString(0);
|
tradeBigdataDto.setOi(oi);
|
tradeBigdataDto.setVol(vol);
|
tradeBigdataDto.setTs(ts);
|
}
|
return new FebsResponse().data(tradeBigdataDto);
|
}catch (Exception e){
|
return null;
|
}
|
}
|
|
//此方法用于验证账号
|
private boolean validateAccount(ApiMessageDto apiMessageDto) throws Exception {
|
boolean flag = false;
|
// try {
|
//设置请求
|
URL url = new URL(baseurl+"/api/v5/account/balance");
|
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
|
|
//设置请求方法
|
connection.setRequestMethod("GET");
|
|
//设置必需的头信息
|
long now = System.currentTimeMillis() / 1000;
|
String timestamp = String.valueOf(now);
|
String preHash = timestamp + "GET" + "/api/v5/account/balance"; //URL路径
|
String signature = generateSignature(preHash, apiMessageDto.getBSecretkey());
|
|
connection.setRequestProperty("OK-ACCESS-KEY", apiMessageDto.getASecretkey());
|
connection.setRequestProperty("OK-ACCESS-SIGN", signature);
|
connection.setRequestProperty("OK-ACCESS-TIMESTAMP", timestamp);
|
connection.setRequestProperty("OK-ACCESS-PASSPHRASE", apiMessageDto.getPassPhrass());
|
|
connection.setRequestProperty("Content-Type", "application/json");
|
|
//执行请求
|
int responseCode = connection.getResponseCode();
|
BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
|
String inputLine;
|
StringBuffer response = new StringBuffer();
|
|
while ((inputLine = in.readLine()) != null) {
|
response.append(inputLine);
|
}
|
in.close();
|
|
//打印响应
|
if(responseCode == 200){
|
flag = true;
|
} else {
|
flag = false;
|
}
|
// } catch (Exception e) {
|
// //在此打印异常信息
|
// log.error("Exception: " + e.getMessage());
|
// flag = false;
|
// }
|
return flag;
|
}
|
|
//此方法用于生成签名
|
private static String generateSignature(String preHash, String secretKey) throws Exception{
|
javax.crypto.Mac sha256_HMAC = javax.crypto.Mac.getInstance("HmacSHA256");
|
javax.crypto.spec.SecretKeySpec secret_key = new javax.crypto.spec.SecretKeySpec(secretKey.getBytes(), "HmacSHA256");
|
sha256_HMAC.init(secret_key);
|
return Base64.getEncoder().encodeToString(sha256_HMAC.doFinal(preHash.getBytes()));
|
}
|
|
public static void main(String[] args) throws Exception {
|
String buySellSituation = "{\"code\":\"0\",\"data\":[[\"1718164800000\",\"52000.2999999999975\",\"60671.0000000000019\"]],\"msg\":\"\"}";
|
log.info("buySellSituation:{}", buySellSituation);
|
JSONObject balanceJson = JSON.parseObject(buySellSituation);
|
JSONArray dataArray = balanceJson.getJSONArray("data");
|
TradeBigdataDto tradeBigdataDto = new TradeBigdataDto();
|
if (dataArray != null) {
|
JSONArray innerArray = dataArray.getJSONArray(0);
|
String sellVol = innerArray.getString(1);
|
String buyVol = innerArray.getString(2);
|
String ts = innerArray.getString(0);
|
tradeBigdataDto.setBuyVol(buyVol);
|
tradeBigdataDto.setSellVol(sellVol);
|
tradeBigdataDto.setTs(ts);
|
}
|
System.out.println(tradeBigdataDto.toString());
|
}
|
}
|
