package project.web.api;
|
|
import java.io.IOException;
|
import java.text.DecimalFormat;
|
import java.text.ParseException;
|
import java.text.SimpleDateFormat;
|
import java.util.Calendar;
|
import java.util.Date;
|
import java.util.GregorianCalendar;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
import javax.servlet.http.HttpServletRequest;
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.web.bind.annotation.CrossOrigin;
|
import org.springframework.web.bind.annotation.RequestMapping;
|
import org.springframework.web.bind.annotation.RestController;
|
|
import kernel.exception.BusinessException;
|
import kernel.sessiontoken.SessionTokenService;
|
import kernel.util.Arith;
|
import kernel.util.DateUtils;
|
import kernel.util.StringUtils;
|
import kernel.web.ApplicationUtil;
|
import kernel.web.BaseAction;
|
import kernel.web.ResultObject;
|
import project.data.DataService;
|
import project.data.model.Realtime;
|
import project.miner.MinerOrderService;
|
import project.miner.MinerService;
|
import project.miner.model.Miner;
|
import project.miner.model.MinerOrder;
|
import project.party.PartyService;
|
import project.party.model.Party;
|
import project.syspara.SysparaService;
|
import util.DateUtil;
|
import util.RandomUtil;
|
|
/**
|
* 矿池订单
|
*
|
*/
|
@RestController
|
@CrossOrigin
|
public class MinerOrderController extends BaseAction {
|
|
private Logger logger = LoggerFactory.getLogger(MinerOrderController.class);
|
|
@Autowired
|
protected MinerOrderService minerOrderService;
|
@Autowired
|
protected MinerService minerService;
|
@Autowired
|
protected PartyService partyService;
|
@Autowired
|
protected SessionTokenService sessionTokenService;
|
@Autowired
|
protected SysparaService sysparaService;
|
@Autowired
|
protected DataService dataService;
|
|
private final String action = "api/minerOrder!";
|
|
/**
|
* 矿池订单 列表
|
*/
|
@RequestMapping(action + "list.action")
|
public Object list(HttpServletRequest request) {
|
|
ResultObject resultObject = new ResultObject();
|
resultObject = readSecurityContextFromSession(resultObject);
|
if (!"0".equals(resultObject.getCode())) {
|
return resultObject;
|
}
|
try {
|
List<Map<String, Object>> datas = null;
|
String partyId = getLoginPartyId();
|
|
// 状态。0.正常赎回， 1 托管中 ,2提前赎回 (违约)3.取消
|
String state = request.getParameter("state");
|
String page_no = request.getParameter("page_no");
|
int pageNo = 1;
|
if (StringUtils.isNotEmpty(page_no)) {
|
pageNo = Integer.valueOf(page_no);
|
}
|
|
datas = minerOrderService.pagedQuery(pageNo, 40, partyId, state).getElements();
|
|
for (Map<String, Object> data : datas) {
|
int intervalDaysByTwoDate = 0;
|
if (null == data.get("stop_time")) {
|
if ("0" != data.get("cycle_close")) {
|
String can_close_time = DateUtils
|
.format(DateUtils.addDay(DateUtils.toDate(data.get("create_time").toString()),
|
new Double(data.get("cycle_close").toString()).intValue()),
|
DateUtils.DF_yyyyMMdd);
|
intervalDaysByTwoDate = DateUtils.getIntervalDaysByTwoDate(DateUtils.toDate(can_close_time),
|
new Date());
|
}
|
} else {
|
intervalDaysByTwoDate = DateUtils.getIntervalDaysByTwoDate(
|
DateUtils.toDate(data.get("stop_time").toString()), new Date());
|
}
|
if (intervalDaysByTwoDate < 0) {
|
intervalDaysByTwoDate = 0;
|
}
|
data.put("days", intervalDaysByTwoDate);
|
DecimalFormat df = new DecimalFormat("#.##");
|
data.put("profit", df.format(data.get("profit")));
|
data.put("test", null != data.get("test") && "Y".equals(data.get("test").toString()));
|
data.put("can_close", intervalDaysByTwoDate <= 0);
|
|
if ((boolean) data.get("test")) {
|
Double minerTestProfit = sysparaService.find("miner_test_profit").getDouble();
|
data.put("daily_profit", minerTestProfit);
|
data.put("daily_rate", minerTestProfit);
|
data.put("cycle", data.get("cycle"));
|
data.put("all_rate", Arith.mul(minerTestProfit, Integer.valueOf(data.get("cycle").toString())));
|
} else {
|
double dailyProfitRate = Arith.mul(Double.valueOf(data.get("daily_rate").toString()), 0.01);
|
double dailyProfitAmount = Arith.mul(dailyProfitRate, Double.valueOf(data.get("amount").toString()));
|
String dailyProfit = df.format(dailyProfitAmount);
|
// 当日收益
|
data.put("daily_profit", dailyProfit);
|
data.put("daily_rate", data.get("daily_rate"));
|
// 这里的周期，体验矿机是周期，其他矿机是解锁周期(到期后需手动解锁)
|
data.put("cycle", data.get("cycle_close"));
|
double all_rate = Arith.mul(30, Double.valueOf(data.get("daily_rate").toString()));
|
data.put("all_rate", df.format(all_rate));
|
}
|
}
|
resultObject.setData(datas);
|
} catch (BusinessException e) {
|
resultObject.setCode("1");
|
resultObject.setMsg(e.getMessage());
|
} catch (Exception e) {
|
resultObject.setCode("1");
|
resultObject.setMsg("程序错误");
|
logger.error("error:", e);
|
}
|
return resultObject;
|
}
|
|
/**
|
* 矿机收益统计
|
*/
|
@RequestMapping(action + "listSum.action")
|
public Object listSum() {
|
ResultObject resultObject = new ResultObject();
|
try {
|
String partyId = getLoginPartyId();
|
List<MinerOrder> data = minerOrderService.findByState(partyId, null);
|
MinerOrder order;
|
Map<String, Object> map = new HashMap<String, Object>();
|
|
// 金额总数
|
double amount_sum = 0;
|
// 预计今日盈利
|
double today_profit = 0;
|
// 已获收益
|
double aready_profit = 0;
|
// 订单数
|
double order_sum = 0;
|
// 金额总数 换算U
|
double amountSumValue = 0;
|
// 今日盈利 换算U
|
double todayProfitValue = 0;
|
// 已获收益 换算U
|
double areadyProfitValue = 0;
|
|
String buyCurrency = "";
|
String outputCurrency = "";
|
|
Double miner_test_profit = sysparaService.find("miner_test_profit").getDouble();
|
|
if (data != null) {
|
Map<String, Miner> minerMap = minerService.findMinerMap();
|
|
for (int i = 0; i < data.size(); i++) {
|
order = data.get(i);
|
Miner miner = minerMap.get(order.getMinerId());
|
buyCurrency = miner.getBuyCurrency();
|
outputCurrency = miner.getOutputCurrency();
|
double close = 1;
|
if (!"usdt".equals(miner.getOutputCurrency())) {
|
List<Realtime> realtimes = dataService.realtime(miner.getOutputCurrency());
|
if (null == realtimes || realtimes.size() <= 0) {
|
throw new BusinessException("行情获取异常，稍后再试");
|
}
|
close = realtimes.get(0).getClose();
|
}
|
|
if ("1".equals(order.getState())) {
|
order_sum = Arith.add(order_sum, 1);
|
amount_sum = Arith.add(amount_sum, order.getAmount());
|
amountSumValue = Arith.add(amountSumValue, Arith.mul(order.getAmount(), close));
|
}
|
aready_profit = Arith.add(aready_profit, order.getProfit());
|
areadyProfitValue = Arith.add(areadyProfitValue, Arith.mul(order.getProfit(), close));
|
|
if (miner.getId().equals(order.getMinerId()) && "1".equals(order.getState())) {
|
if (miner.getTest()) {
|
today_profit = Arith.add(today_profit, miner_test_profit);
|
} else {
|
double miner_profit = Arith.mul(miner.getDaily_rate(), 0.01);
|
double get_profit = Arith.mul(miner_profit, order.getAmount());
|
today_profit = Arith.add(today_profit, get_profit);
|
todayProfitValue = Arith.add(todayProfitValue, Arith.mul(get_profit, close));
|
// break;
|
}
|
}
|
}
|
}
|
DecimalFormat df = new DecimalFormat("#.##");
|
map.put("amount_sum", df.format(amount_sum));
|
map.put("amountSumValue", df.format(amountSumValue));
|
map.put("today_profit", df.format(today_profit));
|
map.put("aready_profit", df.format(aready_profit));
|
map.put("order_sum", order_sum);
|
map.put("buyCurrency", buyCurrency);
|
map.put("outputCurrency", outputCurrency);
|
map.put("areadyProfitValue", df.format(areadyProfitValue));
|
map.put("todayProfitValue", df.format(todayProfitValue));
|
resultObject.setData(map);
|
resultObject.setCode("0");
|
} catch (BusinessException e) {
|
resultObject.setCode("1");
|
resultObject.setMsg(e.getMessage());
|
} catch (Exception e) {
|
resultObject.setCode("1");
|
resultObject.setMsg("程序错误");
|
logger.error("error:", e);
|
}
|
return resultObject;
|
}
|
|
/**
|
* 矿池订单 详情
|
*/
|
@RequestMapping(action + "get.action")
|
public Object get(HttpServletRequest request) {
|
ResultObject resultObject = new ResultObject();
|
resultObject = readSecurityContextFromSession(resultObject);
|
if (!"0".equals(resultObject.getCode())) {
|
return resultObject;
|
}
|
try {
|
String order_no = request.getParameter("order_no");
|
MinerOrder data = minerOrderService.findByOrder_no(order_no);
|
|
resultObject.setData(bulidData(data));
|
resultObject.setCode("0");
|
} catch (BusinessException e) {
|
resultObject.setCode("1");
|
resultObject.setMsg(e.getMessage());
|
} catch (Exception e) {
|
resultObject.setCode("1");
|
resultObject.setMsg("程序错误");
|
logger.error("error:", e);
|
}
|
return resultObject;
|
}
|
|
/**
|
* 创建买入矿机订单
|
*/
|
@RequestMapping(action + "open.action")
|
public Object open(HttpServletRequest request) {
|
ResultObject resultObject = new ResultObject();
|
resultObject = readSecurityContextFromSession(resultObject);
|
if (!"0".equals(resultObject.getCode())) {
|
return resultObject;
|
}
|
String partyId = this.getLoginPartyId();
|
try {
|
String session_token = request.getParameter("session_token");
|
String minerId = request.getParameter("minerId");
|
String amount = request.getParameter("amount");
|
|
Object object = this.sessionTokenService.cacheGet(session_token);
|
this.sessionTokenService.del(session_token);
|
if ((object == null) || (!this.getLoginPartyId().equals((String) object))) {
|
resultObject.setCode("1");
|
resultObject.setMsg("请稍后再试");
|
return resultObject;
|
}
|
|
Party party = this.partyService.cachePartyBy(partyId, false);
|
if (!party.getEnabled()) {
|
resultObject.setCode("506");
|
resultObject.setMsg(error);
|
return resultObject;
|
}
|
|
MinerOrder order = new MinerOrder();
|
order.setId(ApplicationUtil.getCurrentTimeUUID());
|
order.setPartyId(partyId);
|
order.setMinerId(minerId);
|
order.setAmount(Double.valueOf(amount));
|
order.setOrder_no(DateUtil.getToday("yyMMddHHmmss") + RandomUtil.getRandomNum(8));
|
order.setState("1");
|
|
this.minerOrderService.saveCreateNew(order, false);
|
|
Map<String, Object> map = new HashMap<String, Object>();
|
map.put("order_no", order.getOrder_no());
|
resultObject.setData(map);
|
resultObject.setCode("0");
|
} catch (BusinessException e) {
|
resultObject.setCode("1");
|
resultObject.setMsg(e.getMessage());
|
} catch (Exception e) {
|
resultObject.setCode("1");
|
resultObject.setMsg("程序错误");
|
logger.error("error:", e);
|
}
|
return resultObject;
|
}
|
|
/**
|
* 获取订单
|
*/
|
@RequestMapping(action + "getOpen.action")
|
public Object getOpen(HttpServletRequest request) throws IOException {
|
ResultObject resultObject = new ResultObject();
|
resultObject = readSecurityContextFromSession(resultObject);
|
if (!"0".equals(resultObject.getCode())) {
|
return resultObject;
|
}
|
try {
|
String minerId = request.getParameter("minerId");
|
String amount_temp = request.getParameter("amount");
|
Miner miner = minerService.findById(minerId);
|
if (StringUtils.isNullOrEmpty(amount_temp)
|
|| !StringUtils.isDouble(amount_temp)
|
|| Double.valueOf(amount_temp) < 0) {
|
throw new BusinessException("金额错误");
|
}
|
|
DecimalFormat df = new DecimalFormat("#.##");
|
Map<String, Object> map = new HashMap<String, Object>();
|
map.put("miner_test", miner.getTest());
|
map.put("miner_name", miner.getName());
|
map.put("miner_name_en", miner.getName_en());
|
map.put("miner_name_cn", miner.getName_cn());
|
map.put("buyCurrenc", miner.getBuyCurrency());
|
map.put("outputCurrency", miner.getOutputCurrency());
|
String partyId = getLoginPartyId();
|
if (!StringUtils.isNullOrEmpty(partyId)) {
|
String session_token = sessionTokenService.savePut(partyId);
|
map.put("session_token", session_token);
|
}
|
|
Date date = new Date();
|
map.put("create_time", DateUtils.format(date, DateUtils.DF_yyyyMMddHHmmss));
|
Calendar calendar = new GregorianCalendar();
|
calendar.setTime(date);
|
date = calendar.getTime();
|
|
// 起息时间
|
map.put("earn_time", DateUtils.format(date, DateUtils.DF_yyyyMMdd));
|
|
if (miner.getTest()) {
|
map.put("amount", 0);
|
calendar.add(calendar.DATE, miner.getCycle());
|
date = calendar.getTime();
|
map.put("stop_time", DateUtils.format(DateUtils.addDay(new Date(), miner.getCycle()), DateUtils.DF_yyyyMMdd));
|
Double minerTestProfit = sysparaService.find("miner_test_profit").getDouble();
|
map.put("daily_rate", minerTestProfit);
|
map.put("profit_may", String.valueOf(Arith.mul(minerTestProfit, miner.getCycle())));
|
map.put("cycle", miner.getCycle());
|
map.put("all_rate", Arith.mul(minerTestProfit, miner.getCycle()));
|
} else {
|
double amount = Double.valueOf(amount_temp);
|
map.put("amount", amount);
|
map.put("stop_time", null);
|
map.put("daily_rate", miner.getDaily_rate());
|
double rate = Arith.mul(miner.getDaily_rate(), 0.01);
|
map.put("profit_may", String.valueOf(df.format(Arith.mul(amount, Arith.mul(rate, 30)))));
|
map.put("cycle", miner.getCycle_close());
|
double all_rate = Arith.mul(30, miner.getDaily_rate());
|
map.put("all_rate", df.format(all_rate));
|
}
|
|
map.put("investment_min", miner.getInvestment_min());
|
map.put("minerId", minerId);
|
map.put("order_no", DateUtil.getToday("yyMMddHHmmss") + RandomUtil.getRandomNum(8));
|
map.put("test", miner.getTest());
|
|
resultObject.setData(map);
|
resultObject.setCode("0");
|
} catch (BusinessException e) {
|
resultObject.setCode("1");
|
resultObject.setMsg(e.getMessage());
|
} catch (Exception e) {
|
resultObject.setCode("1");
|
resultObject.setMsg("程序错误");
|
logger.error("error:", e.fillInStackTrace());
|
}
|
return resultObject;
|
}
|
|
|
/**
|
* 赎回订单
|
*
|
*/
|
@RequestMapping(action + "closOrder.action")
|
public Object closOrder(HttpServletRequest request) throws IOException {
|
ResultObject resultObject = new ResultObject();
|
resultObject = readSecurityContextFromSession(resultObject);
|
if (!"0".equals(resultObject.getCode())) {
|
return resultObject;
|
}
|
try {
|
MinerOrder order = minerOrderService.findByOrder_no(request.getParameter("order_no"));
|
Miner miner = minerService.findById(order.getMinerId());
|
Date date_now = new Date();
|
double last_days = daysBetween(order.getCreate_time(), date_now);
|
if(last_days < miner.getCycle_close()) {
|
resultObject.setCode("1");
|
resultObject.setMsg("解锁时间未到,暂不能赎回");
|
return resultObject;
|
}
|
if ("1".equals(order.getState())) {
|
// 解锁，不扣违约金
|
order.setState("2");
|
this.minerOrderService.saveClose(order, miner);
|
}
|
} catch (BusinessException e) {
|
resultObject.setCode("1");
|
resultObject.setMsg(e.getMessage());
|
} catch (Exception e) {
|
resultObject.setCode("1");
|
resultObject.setMsg("程序错误");
|
logger.error("error:", e.fillInStackTrace());
|
}
|
return resultObject;
|
}
|
|
/**
|
* 新线程处理，直接拿到订单锁处理完成后退出
|
*
|
*/
|
public class CloseDelayThread implements Runnable {
|
private String orderNo;
|
private MinerOrderService minerOrderService;
|
|
public void run() {
|
try {
|
// 提前赎回理财产品需要支付违约金
|
MinerOrder order = minerOrderService.findByOrder_no(orderNo);
|
Miner miner = minerService.findById(order.getMinerId());
|
|
// 取时间
|
Date date_now = new Date();
|
double last_days = daysBetween(order.getCreate_time(), date_now);
|
if ("1".equals(order.getState()) && last_days >= miner.getCycle_close()) {
|
// 解锁，不扣违约金
|
double default_money = 0;
|
order.setState("2");
|
order.setProfit(Arith.sub(order.getProfit(), default_money));
|
this.minerOrderService.saveClose(order, miner);
|
}
|
} catch (Exception e) {
|
logger.error("error:", e);
|
}
|
}
|
|
public CloseDelayThread(String orderNo, MinerOrderService minerOrderService) {
|
this.orderNo = orderNo;
|
this.minerOrderService = minerOrderService;
|
}
|
|
}
|
|
protected Map<String, Object> bulidData(MinerOrder order) throws ParseException {
|
Miner miner = new Miner();
|
miner = minerService.findById(order.getMinerId());
|
|
DecimalFormat df = new DecimalFormat("#.##");
|
Map<String, Object> map = new HashMap<String, Object>();
|
map.put("miner_name", miner.getName());
|
map.put("miner_name_en", miner.getName_en());
|
map.put("miner_name_cn", miner.getName_cn());
|
Double miner_test_profit = sysparaService.find("miner_test_profit").getDouble();
|
|
map.put("daily_rate", miner.getTest() ? miner_test_profit : miner.getDaily_rate());
|
map.put("create_timeStr", DateUtils.format(order.getCreate_time(), DateUtils.DF_yyyyMMddHHmmss));
|
map.put("close_timeStr", DateUtils.format(order.getClose_time(), DateUtils.DF_yyyyMMddHHmmss));
|
map.put("stop_timeStr", miner.getTest() ? DateUtils.format(order.getStop_time(), DateUtils.DF_yyyyMMdd) : null);
|
map.put("earn_timeStr", DateUtils.format(order.getEarn_time(), DateUtils.DF_yyyyMMdd));
|
// Date date_now = new Date();// 取时间
|
// int daysBetween = order.getStop_time() == null ? 0 : daysBetween(date_now, order.getStop_time());
|
// daysBetween = daysBetween < 0 ? 0 : daysBetween;
|
|
int intervalDaysByTwoDate = 0;
|
if (null == order.getStop_time()) {
|
if (0 != miner.getCycle_close()) {
|
String can_close_time = DateUtils
|
.format(DateUtils.addDay(order.getCreate_time(), miner.getCycle_close()),
|
DateUtils.DF_yyyyMMdd);
|
intervalDaysByTwoDate = DateUtils.getIntervalDaysByTwoDate(DateUtils.toDate(can_close_time),
|
new Date());
|
}
|
} else {
|
intervalDaysByTwoDate = DateUtils.getIntervalDaysByTwoDate(order.getStop_time(), new Date());
|
}
|
if (intervalDaysByTwoDate < 0) {
|
intervalDaysByTwoDate = 0;
|
}
|
|
map.put("days", intervalDaysByTwoDate);
|
map.put("can_close", intervalDaysByTwoDate <= 0);
|
double rate = Arith.mul(miner.getDaily_rate(), 0.01);
|
map.put("profit_may", miner.getTest() ? String.valueOf(Arith.mul(miner_test_profit, miner.getCycle()))
|
: String.valueOf(Arith.mul(order.getAmount(), Arith.mul(rate, 30))));
|
map.put("order_no", order.getOrder_no());
|
map.put("amount", order.getAmount());
|
map.put("cycle", miner.getCycle());
|
map.put("id", order.getId());
|
|
map.put("state", order.getState());
|
map.put("profit", order.getProfit());
|
|
int cycle = miner.getTest() ? miner.getCycle() : miner.getCycle_close();
|
map.put("cycle", cycle);
|
double all_rate = Arith.mul(30, miner.getDaily_rate());
|
map.put("all_rate", miner.getTest() ? Arith.mul(miner_test_profit, miner.getCycle()) : df.format(all_rate));
|
|
map.put("test", miner.getTest());
|
map.put("buyCurrency", miner.getBuyCurrency());
|
map.put("outputCurrency", miner.getOutputCurrency());
|
|
if ("1".equals(order.getState())) {
|
map.put("profit", order.getProfit());
|
map.put("default_amount", 0);
|
map.put("principal_amount", 0);
|
}
|
if ("2".equals(order.getState())) {
|
map.put("profit", 0);
|
map.put("default_amount", 0);
|
map.put("principal_amount", df.format(order.getAmount()));
|
}
|
if ("0".equals(order.getState())) {// 正常
|
map.put("profit", order.getProfit());
|
map.put("default_amount", 0);
|
map.put("principal_amount", df.format(order.getAmount()));
|
}
|
return map;
|
}
|
|
public static int daysBetween(Date smdate, Date bdate) throws ParseException {
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
|
smdate = sdf.parse(sdf.format(smdate));
|
bdate = sdf.parse(sdf.format(bdate));
|
Calendar cal = Calendar.getInstance();
|
cal.setTime(smdate);
|
long time1 = cal.getTimeInMillis();
|
cal.setTime(bdate);
|
long time2 = cal.getTimeInMillis();
|
long between_days = (time2 - time1) / (1000 * 3600 * 24);
|
return Integer.parseInt(String.valueOf(between_days));
|
}
|
|
}
|
