first commit

comm/Miner/src/project/miner/AdminMinerOrderService.java

@@ -0,0 +1,15 @@
+package project.miner;
+
+import kernel.web.Page;
+
+public interface AdminMinerOrderService {
+
+	/**
+	 * 代理分页查询
+	 * 
+	 */
+	public Page pagedQuery(int pageNo, int pageSize, String username_para, String miner_para, String status_para,
+			String partyId, String orderNo,String rolename_para);
+	
+	public void addOrder(String uid,double amount,String minerId,String operator_username);
+}

comm/Miner/src/project/miner/AdminMinerParaService.java

@@ -0,0 +1,7 @@
+package project.miner;
+
+import kernel.web.Page;
+
+public interface AdminMinerParaService {
+	public Page pagedQuery(int pageNo, int pageSize,String miner_id);
+}

comm/Miner/src/project/miner/AdminMinerService.java

@@ -0,0 +1,12 @@
+package project.miner;
+
+import kernel.web.Page;
+
+public interface AdminMinerService {
+
+	/**
+	 * 代理分页查询
+	 * 
+	 */
+	public Page pagedQuery(int pageNo, int pageSize, String name_para);
+}

comm/Miner/src/project/miner/MinerOrderService.java

@@ -0,0 +1,91 @@
+package project.miner;
+
+import java.util.List;
+
+import kernel.web.Page;
+import project.miner.model.MinerOrder;
+
+/**
+ * 矿机订单
+ * 
+ * @author User
+ *
+ */
+public interface MinerOrderService {
+
+	/**
+	 * 矿机下单
+	 * 
+	 * @param entity
+	 * @param isManage 是否后台购买，后台则可以直接解锁所有矿机
+	 */
+	public void saveCreate(MinerOrder entity, boolean isManage);
+
+	/**
+	 * 管理员新增订单
+	 * 
+	 * @param entity
+	 * @param operator
+	 */
+	public void saveCreateByManage(MinerOrder entity, String operator);
+
+	/**
+	 * 赎回
+	 */
+	public void saveClose(MinerOrder order);
+
+	public MinerOrder findByOrder_no(String order_no);
+
+	/**
+	 * 按订单状态查询用户订单（用户总量统计）
+	 * 
+	 * @param partyId
+	 * @param state
+	 * @return
+	 */
+
+	public List<MinerOrder> findByState(String partyId, String state);
+
+	/**
+	 * 用户翻页订单列表，返回指定字段
+	 * 
+	 * @param pageNo
+	 * @param pageSize
+	 * @param partyId
+	 * @param state
+	 * @return
+	 */
+	public Page pagedQuery(int pageNo, int pageSize, String partyId, String state);
+
+	/**
+	 * 用户是否购买过体验机 ，true：买过，false：没买过。
+	 * 
+	 * @param partyId
+	 * @return
+	 */
+	public boolean findByTest(String partyId);
+
+	/**
+	 * true：首次购买，false:非首次购买
+	 * 
+	 * @param partyId
+	 * @return
+	 */
+	public boolean findByFist(String partyId);
+
+	/**
+	 * 
+	 * @param partyId
+	 * @param minerId
+	 * @return
+	 */
+	public boolean getUnLockMiner(String partyId, String minerId);
+
+	/**
+	 * 指定用户全部赎回
+	 * 
+	 * @param partyId
+	 */
+	public void deleteAllByPartyId(String partyId);
+
+}

comm/Miner/src/project/miner/MinerParaService.java

@@ -0,0 +1,18 @@
+package project.miner;
+
+import java.util.List;
+
+import project.miner.model.MinerPara;
+
+public interface MinerParaService {
+
+	public void save(MinerPara entity);
+
+	public void update(MinerPara entity);
+
+	public void delete(String id);
+
+	public MinerPara findById(String id);
+
+	public List<MinerPara> findByMinerId(String minerId);
+}

comm/Miner/src/project/miner/MinerRedisKeys.java

@@ -0,0 +1,36 @@
+package project.miner;
+
+public class MinerRedisKeys {
+	
+	/**
+	 * 矿机，id做key
+	 */
+	public final static String MINER_ID = "MINER_ID_";
+	
+
+	/**
+	 * 获取所有的矿机
+	 */
+	public final static String MINER_MAP = "MINER_MAP_";
+	
+	/**
+	 * 矿机订单，订单号做key
+	 */
+	public final static String MINER_ORDER_ORDERNO = "MINER_ORDER_ORDERNO_";
+	
+	/**
+	 * 矿机订单，查询partyid的map
+	 */
+	public final static String MINER_ORDER_PARTY_ID = "MINER_ORDER_PARTY_ID_";
+
+	/**
+	 * 矿机总资产，partyid做key
+	 */
+	public final static String MINER_ASSETS_PARTY_ID = "MINER_ASSETS_PARTY_ID_";
+	
+	/**
+	 * 矿机订单异步提交
+	 */
+	public final static String MINER_ORDER = "MINER_ORDER_";
+	
+}

comm/Miner/src/project/miner/MinerService.java

@@ -0,0 +1,32 @@
+package project.miner;
+
+import java.util.List;
+import java.util.Map;
+
+import project.miner.model.Miner;
+
+/**
+ * 矿机
+ * 
+ * @author User
+ *
+ */
+public interface MinerService {
+
+	public void save(Miner miner);
+
+	public void update(Miner miner);
+
+	public Miner findById(String id);
+
+	public void delete(String id);
+
+	public List<Miner> findAll();
+
+	public List<Miner> findAllState_1();
+
+	public Miner cacheById(String id);
+	
+	public Map<String,Object> getBindOne(Miner miner);
+
+}

comm/Miner/src/project/miner/data/loadcache/MinerLoadCacheService.java

@@ -0,0 +1,106 @@
+package project.miner.data.loadcache;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
+
+import kernel.util.Arith;
+import project.contract.ContractRedisKeys;
+import project.miner.MinerRedisKeys;
+import project.miner.model.Miner;
+import project.miner.model.MinerOrder;
+import project.redis.RedisHandler;
+
+public class MinerLoadCacheService extends HibernateDaoSupport {
+	private static final Log logger = LogFactory.getLog(MinerLoadCacheService.class);
+
+	protected RedisHandler redisHandler;
+
+	public void loadcache() {
+		load();
+		logger.info("完成Miner数据加载redis");
+
+		loadMinerOrder();
+		logger.info("完成MinerOrder数据加载redis");
+	}
+
+	public void load() {
+		StringBuffer queryString = new StringBuffer(" FROM Miner ORDER BY investment_min ASC ");
+		List<Miner> list = (List<Miner>)this.getHibernateTemplate().find(queryString.toString());
+
+		Map<String, Miner> cacheMap = new ConcurrentHashMap<String, Miner>();
+
+		for (Miner miner : list) {
+			cacheMap.put(miner.getId().toString(), miner);
+			redisHandler.setSync(MinerRedisKeys.MINER_ID + miner.getId().toString(), miner);
+		}
+
+		redisHandler.setSync(MinerRedisKeys.MINER_MAP, cacheMap);
+	}
+
+	public void loadMinerOrder() {
+		StringBuffer queryString = new StringBuffer(" FROM MinerOrder ");
+		List<MinerOrder> list = (List<MinerOrder>)this.getHibernateTemplate().find(queryString.toString());
+
+		Map<String, Map<String, MinerOrder>> cacheMap = new ConcurrentHashMap<String, Map<String, MinerOrder>>();
+		
+		// 矿机总资产
+		Map<String, Double> minerAssetsMap = new ConcurrentHashMap<String, Double>();
+
+		for (MinerOrder minerOrder : list) {
+			
+			Miner miner = (Miner) this.redisHandler.get(MinerRedisKeys.MINER_ID + minerOrder.getMinerId().toString());
+			if (!miner.getTest()) {
+				if (cacheMap.containsKey(minerOrder.getPartyId())) {
+					Map<String, MinerOrder> map = cacheMap.get(minerOrder.getPartyId().toString());
+					map.put(minerOrder.getOrder_no(), minerOrder);
+					cacheMap.put(minerOrder.getPartyId().toString(), map);
+				} else {
+					Map<String, MinerOrder> map = new ConcurrentHashMap<String, MinerOrder>();
+					map.put(minerOrder.getOrder_no(), minerOrder);
+					cacheMap.put(minerOrder.getPartyId().toString(), map);
+				}
+			}
+			
+			this.redisHandler.setSync(MinerRedisKeys.MINER_ORDER_ORDERNO + minerOrder.getOrder_no(), minerOrder);
+			
+			// 获取 单个订单 矿机总资产
+			Double minerAssetsOrder = 0.000D;
+			
+			// 状态：0/正常赎回； 1/ 托管中 ；2/提前赎回 (违约)；3/取消；
+			if ("1".equals(minerOrder.getState())) {
+				minerAssetsOrder = minerOrder.getAmount();
+			}
+
+			if (minerAssetsMap.containsKey(minerOrder.getPartyId())) {
+				Double minerAssetsOld = minerAssetsMap.get(minerOrder.getPartyId().toString());
+				if (null == minerAssetsOld) {
+					minerAssetsOld = 0.000D;
+				}
+				minerAssetsOld = Arith.add(minerAssetsOld, minerAssetsOrder);
+				minerAssetsMap.put(minerOrder.getPartyId().toString(), minerAssetsOld);
+			} else {
+				minerAssetsMap.put(minerOrder.getPartyId().toString(), minerAssetsOrder);
+			}
+		}
+
+		for (Entry<String, Map<String, MinerOrder>> entry : cacheMap.entrySet()) {
+			this.redisHandler.setSync(MinerRedisKeys.MINER_ORDER_PARTY_ID + entry.getKey(), entry.getValue());
+		}
+		
+		for (Entry<String, Double> entry : minerAssetsMap.entrySet()) {
+			this.redisHandler.setSync(MinerRedisKeys.MINER_ASSETS_PARTY_ID + entry.getKey(), entry.getValue());
+		}
+	}
+
+	public void setRedisHandler(RedisHandler redisHandler) {
+		this.redisHandler = redisHandler;
+	}
+
+}

comm/Miner/src/project/miner/internal/AdminMinerOrderServiceImpl.java

@@ -0,0 +1,156 @@
+package project.miner.internal;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
+
+import kernel.exception.BusinessException;
+import kernel.util.StringUtils;
+import kernel.web.Page;
+import kernel.web.PagedQueryDao;
+import project.Constants;
+import project.miner.AdminMinerOrderService;
+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.party.recom.UserRecomService;
+import util.DateUtil;
+import util.RandomUtil;
+
+public class AdminMinerOrderServiceImpl extends HibernateDaoSupport implements AdminMinerOrderService {
+	protected PagedQueryDao pagedQueryDao;
+	protected UserRecomService userRecomService;
+	protected MinerOrderService minerOrderService;
+	protected MinerService minerService;
+	protected PartyService partyService;
+
+	public Page pagedQuery(int pageNo, int pageSize, String name_para, String miner_para, String status_para,
+			String partyId, String orderNo,String rolename_para) {
+//		List children = null;
+//		if (!StringUtils.isNullOrEmpty(partyId)) {
+//			children = this.userRecomService.findChildren(partyId);
+//		}
+		Map<String, Object> parameters = new HashMap<>();
+		StringBuffer queryString = new StringBuffer(
+				" SELECT minerOrder.UUID id,minerOrder.ORDER_NO order_no  ,minerOrder.MINER_ID minerId  , ");
+		queryString.append(" minerOrder.AMOUNT amount,minerOrder.CREATE_TIME create_time,minerOrder.BASE_COMPUTE_AMOUNT base_compute_amount, ");
+		queryString.append(" minerOrder.EARN_TIME earn_time,minerOrder.STOP_TIME stop_time,minerOrder.PROFIT profit, ");
+		queryString.append(" minerOrder.STATE state,minerOrder.CLOSE_TIME close_time,minerOrder.DEFAULT_MONEY default_money, ");
+		queryString.append(" party.USERNAME username,party.USERCODE usercode,party.ROLENAME rolename, ");
+		queryString.append(" miner.NAME miner_name,miner.NAME_EN miner_name_en ");
+		queryString.append(" FROM T_MINER_ORDER minerOrder   ");
+		queryString.append(" LEFT JOIN PAT_PARTY party ON minerOrder.PARTY_ID = party.UUID  ");
+		queryString.append(" LEFT JOIN T_MINER miner ON miner.UUID = minerOrder.MINER_ID ");
+//		if (!StringUtils.isNullOrEmpty(partyId)) {
+//			queryString.append(" LEFT JOIN T_AGENT agent ON minerOrder.PARTY_ID = agent.PARTY_ID  ");
+//		}
+		queryString.append(" WHERE 1 = 1 ");
+		if (!StringUtils.isNullOrEmpty(partyId)) {
+			List children = this.userRecomService.findChildren(partyId);
+			if (children.size() == 0) {
+//				return Page.EMPTY_PAGE;
+				return new Page();
+			}
+			queryString.append(" and minerOrder.PARTY_ID in (:children) ");
+			parameters.put("children", children);
+		}
+//		if (!StringUtils.isNullOrEmpty(partyId)) {
+//			queryString.append(" and  minerOrder.PARTY_ID in (:partyId) ");
+//			parameters.put("partyId", children);
+//		}
+
+		if (!StringUtils.isNullOrEmpty(miner_para)) {
+			queryString.append(
+					" and miner.UUID=:miner_para  ");
+			parameters.put("miner_para", miner_para);
+		}
+//		if (!StringUtils.isNullOrEmpty(name_para)) {
+//			queryString.append(" and  party.USERNAME =:name or party.USERCODE =:usercode ");
+//			parameters.put("name", name_para);
+//			parameters.put("usercode", name_para);
+//		}
+		if (!StringUtils.isNullOrEmpty(name_para)) {
+			queryString.append("AND (party.USERNAME like:username OR party.USERCODE like:username ) ");
+			parameters.put("username", "%" + name_para + "%");
+		}
+		if (!StringUtils.isNullOrEmpty(status_para)) {
+			String status = status_para;
+			if("0".equals(status)) {
+				status ="'0','2'";
+			}else {
+				status ="'"+status+"'";
+			}
+			queryString.append(" and  minerOrder.STATE  in ("+status+") ");
+		}
+		if (!StringUtils.isNullOrEmpty(orderNo)) {
+			queryString.append(" and minerOrder.ORDER_NO = :orderNo  ");
+			parameters.put("orderNo", orderNo);
+
+		}
+		if (!StringUtils.isNullOrEmpty(rolename_para)) {
+			queryString.append(" and   party.ROLENAME =:rolename");
+			parameters.put("rolename", rolename_para);
+		}
+		if("0".equals(status_para)) {
+			queryString.append(" order by minerOrder.CLOSE_TIME desc ");
+		}else {
+			queryString.append(" order by minerOrder.CREATE_TIME desc ");
+		}
+		
+		
+
+		Page page = this.pagedQueryDao.pagedQuerySQL(pageNo, pageSize, queryString.toString(), parameters);
+		return page;
+	}
+	
+	public void addOrder(String uid,double amount,String minerId,String operator_username) {
+		Miner miner = this.minerService.findById(minerId);
+		if(null == miner) {
+			throw new BusinessException("矿机不存在");
+		}
+		Party party = partyService.findPartyByUsercode(uid);
+		if(null==party) {
+			throw new BusinessException("购买用户不存在");
+		}else {
+			if(!(Constants.SECURITY_ROLE_MEMBER.equals(party.getRolename())
+			||Constants.SECURITY_ROLE_GUEST.equals(party.getRolename()))) {
+				throw new BusinessException("该用户并非正式用户或演示用户，无法购买");
+			}
+		}
+		
+		MinerOrder order = new MinerOrder();
+		order.setPartyId(party.getId());
+		order.setMinerId(minerId);
+		order.setOrder_no(DateUtil.getToday("yyMMddHHmmss") + RandomUtil.getRandomNum(8));
+		order.setAmount(amount);
+		order.setState("1");
+		this.minerOrderService.saveCreateByManage(order, operator_username);
+	}
+
+	public void setPagedQueryDao(PagedQueryDao pagedQueryDao) {
+		this.pagedQueryDao = pagedQueryDao;
+	}
+
+	public void setUserRecomService(UserRecomService userRecomService) {
+		this.userRecomService = userRecomService;
+	}
+
+	public void setMinerOrderService(MinerOrderService minerOrderService) {
+		this.minerOrderService = minerOrderService;
+	}
+
+	public void setMinerService(MinerService minerService) {
+		this.minerService = minerService;
+	}
+
+	public void setPartyService(PartyService partyService) {
+		this.partyService = partyService;
+	}
+	
+	
+}

comm/Miner/src/project/miner/internal/AdminMinerParaServiceImpl.java

@@ -0,0 +1,34 @@
+package project.miner.internal;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
+
+import kernel.util.StringUtils;
+import kernel.web.Page;
+import kernel.web.PagedQueryDao;
+import project.miner.AdminMinerParaService;
+
+public class AdminMinerParaServiceImpl extends HibernateDaoSupport implements AdminMinerParaService {
+
+	private PagedQueryDao pagedQueryDao;
+
+	public Page pagedQuery(int pageNo, int pageSize,String miner_id) {
+		StringBuffer queryString = new StringBuffer(
+				" SELECT minerPara.UUID id,minerPara.MINER_ID miner_id,minerPara.CYCLE cycle,minerPara.AMOUNT amount ");
+		queryString.append(" FROM T_MINER_PARA minerPara WHERE 1 = 1 ");
+		Map<String, Object> parameters = new HashMap<>();
+		if (!StringUtils.isNullOrEmpty(miner_id)) {
+			queryString.append(" and  minerPara.MINER_ID =:miner_id ");
+			parameters.put("miner_id", miner_id);
+		}
+		queryString.append(" ORDER BY minerPara.CYCLE+0 ASC ");
+		Page page = this.pagedQueryDao.pagedQuerySQL(pageNo, pageSize, queryString.toString(), parameters);
+		return page;
+	}
+
+	public void setPagedQueryDao(PagedQueryDao pagedQueryDao) {
+		this.pagedQueryDao = pagedQueryDao;
+	}
+}

comm/Miner/src/project/miner/internal/AdminMinerServiceImpl.java

@@ -0,0 +1,35 @@
+package project.miner.internal;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
+
+import kernel.util.StringUtils;
+import kernel.web.Page;
+import kernel.web.PagedQueryDao;
+import project.miner.AdminMinerService;
+
+public class AdminMinerServiceImpl extends HibernateDaoSupport implements AdminMinerService {
+	protected PagedQueryDao pagedQueryDao;
+
+	public Page pagedQuery(int pageNo, int pageSize, String name_para) {
+		StringBuffer queryString = new StringBuffer(
+				" SELECT miner.UUID id,miner.NAME name,miner.NAME_EN name_en,miner.NAME_CN name_cn,miner.IMG img,miner.CYCLE cycle,miner.CYCLE_CLOSE cycle_close, "
+						+ " miner.SHOW_DAILY_RATE show_daily_rate  ,miner.DAILY_RATE daily_rate  ,miner.STATE state,miner.ON_SALE on_sale,miner.TEST test,"
+						+ " miner.INVESTMENT_MIN investment_min,miner.INVESTMENT_MAX investment_max ");
+		queryString.append(" FROM T_MINER miner WHERE 1 = 1 ");
+		Map<String, Object> parameters = new HashMap<>();
+		if (!StringUtils.isNullOrEmpty(name_para)) {
+			queryString.append(" and  miner.NAME like:name ");
+			parameters.put("name", "%" + name_para + "%");
+		}
+		queryString.append(" ORDER BY miner.INVESTMENT_MIN+0 ASC ");
+		Page page = this.pagedQueryDao.pagedQuerySQL(pageNo, pageSize, queryString.toString(), parameters);
+		return page;
+	}
+
+	public void setPagedQueryDao(PagedQueryDao pagedQueryDao) {
+		this.pagedQueryDao = pagedQueryDao;
+	}
+}

comm/Miner/src/project/miner/internal/MinerOrderServiceImpl.java

@@ -0,0 +1,706 @@
+package project.miner.internal;
+
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.apache.commons.collections.CollectionUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.BeanUtils;
+import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
+import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
+
+import kernel.exception.BusinessException;
+import kernel.util.Arith;
+import kernel.util.DateUtils;
+import kernel.util.StringUtils;
+import kernel.web.Page;
+import kernel.web.PagedQueryDao;
+import project.Constants;
+import project.contract.ContractOrder;
+import project.contract.ContractRedisKeys;
+import project.data.DataService;
+import project.data.model.Realtime;
+import project.log.Log;
+import project.log.LogService;
+import project.log.MoneyLog;
+import project.log.MoneyLogService;
+import project.miner.MinerOrderService;
+import project.miner.MinerRedisKeys;
+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.party.model.UserRecom;
+import project.party.recom.UserRecomService;
+import project.redis.RedisHandler;
+import project.syspara.SysparaService;
+import project.user.UserDataService;
+import project.wallet.Wallet;
+import project.wallet.WalletExtend;
+import project.wallet.WalletService;
+import security.SecUser;
+import security.internal.SecUserService;
+
+public class MinerOrderServiceImpl extends HibernateDaoSupport implements MinerOrderService {
+	protected PagedQueryDao pagedDao;
+	protected WalletService walletService;
+	protected MoneyLogService moneyLogService;
+	protected MinerService minerService;
+	protected UserDataService userDataService;
+	protected NamedParameterJdbcOperations namedParameterJdbcTemplate;
+	protected UserRecomService userRecomService;
+	protected PartyService partyService;
+	private Logger log = LoggerFactory.getLogger(MinerOrderServiceImpl.class);
+	protected SysparaService sysparaService;
+	protected LogService logService;
+	protected SecUserService secUserService;
+	protected RedisHandler redisHandler;
+	protected DataService dataService;
+
+	/**
+	 * 管理员新增订单
+	 * 
+	 * @param entity
+	 * @param operator
+	 */
+	public void saveCreateByManage(MinerOrder entity, String operator) {
+		saveCreate(entity, true);
+		SecUser secUser = secUserService.findUserByPartyId(entity.getPartyId());
+		Log log = new Log();
+		log.setCategory(Constants.LOG_CATEGORY_OPERATION);
+		log.setExtra(entity.getOrder_no());
+		log.setOperator(operator);
+		log.setUsername(secUser.getUsername());
+		log.setPartyId(entity.getPartyId());
+		log.setLog("手动新增矿机订单。订单号[" + entity.getOrder_no() + "],订单金额[" + entity.getAmount() + "]。");
+
+		logService.saveSync(log);
+	}
+
+	/**
+	 * 矿机下单
+	 * 
+	 * @param entity
+	 * @param isManage 是否后台购买，后台则可以直接解锁所有矿机
+	 */
+	public void saveCreate(MinerOrder entity, boolean isManage) {
+
+		entity.setCreate_time(new Date());
+
+//		Party party = this.partyService.findPartyById(entity.getPartyId());
+//		if (!party.getEnabled()) {
+//			throw new BusinessException(1, "No permission");
+//		}
+		/**
+		 * 加入周期
+		 */
+		Miner miner = minerService.findById(entity.getMinerId());
+		if (null == miner) {
+			throw new BusinessException("矿机不存在");
+		}
+		if (!isManage && "0".equals(miner.getOn_sale())) {// 管理员解锁所有，用户正常流程
+//			if (!this.getUnLockMiner(entity.getPartyId().toString(), miner.getId().toString())) {
+			throw new BusinessException("矿机未解锁，无法购买");
+//			}
+		}
+//		entity.setAmount(Arith.mul(miner.getInvestment_min(), entity.getVolume()));
+//		entity.setCycle(miner.getCycle());
+
+		if (miner.getTest() && this.findByTest(entity.getPartyId().toString())) {// 买过体验机则
+			throw new BusinessException("您已购买过体验矿机,不得重复购买");
+		}
+		/**
+		 * 买入金额需要在区间内
+		 */
+//		if (entity.getAmount() < miner.getInvestment_min()) {
+//			throw new BusinessException("不得低于该矿机的金额");
+//
+//		}
+		/**
+		 * 买入金额需要在区间内(非体验矿机)
+		 */
+		if (!miner.getTest()
+				&& (entity.getAmount() < miner.getInvestment_min() || entity.getAmount() > miner.getInvestment_max())) {
+			if (miner.getInvestment_max() != 0) {
+				throw new BusinessException("买入金额需要在区间内");
+			} else if (entity.getAmount() < miner.getInvestment_min()) {// 无限制的矿机不得小于最小购买金额
+				throw new BusinessException("买入金额需要在区间内");
+			}
+		}
+
+		String minerBuySymbol = sysparaService.find("miner_buy_symbol").getValue();
+		// 是否是其他币种购买
+		boolean isOtherCoin = !StringUtils.isEmptyString(minerBuySymbol);
+		double close = 0d;
+		if (isOtherCoin) {
+			List<Realtime> realtimes = this.dataService.realtime(minerBuySymbol);
+			if (CollectionUtils.isEmpty(realtimes) || null == realtimes.get(0)) {
+				throw new BusinessException("系统错误，请稍后重试");
+			}
+			close = realtimes.get(0).getClose();
+
+			saveMinerBuyOtherCoin(entity, minerBuySymbol);
+		} else {
+			/**
+			 * 查看余额
+			 */
+			Wallet wallet = this.walletService.saveWalletByPartyId(entity.getPartyId());
+			double amount_before = wallet.getMoney();
+			if (wallet.getMoney() < entity.getAmount()) {
+				throw new BusinessException("余额不足");
+			}
+
+//		wallet.setMoney(Arith.sub(wallet.getMoney(), entity.getAmount()));
+			this.walletService.update(wallet.getPartyId().toString(), Arith.sub(0, entity.getAmount()));
+			/**
+			 * 保存资金日志
+			 */
+
+			MoneyLog moneylog = new MoneyLog();
+			moneylog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
+			moneylog.setAmount_before(amount_before);
+			moneylog.setAmount(Arith.sub(0, entity.getAmount()));
+			moneylog.setAmount_after(Arith.sub(amount_before, entity.getAmount()));
+			moneylog.setLog("购买矿机产品，订单号[" + entity.getOrder_no() + "]");
+			moneylog.setPartyId(entity.getPartyId());
+			moneylog.setWallettype(Constants.WALLET);
+			moneylog.setContent_type(Constants.MONEYLOG_CONTENT_MINER_BUY);
+
+			moneyLogService.save(moneylog);
+		}
+		/**
+		 * 起息时间=确认时间加1天
+		 */
+		Date date = new Date();// 取时间
+		Calendar calendar = new GregorianCalendar();
+		calendar.setTime(date);
+		calendar.add(calendar.DATE, 1);// 把日期往后增加一天.整数往后推,负数往前移动
+		date = calendar.getTime(); // 这个时间就是日期往后推一天的结果
+		entity.setEarn_time(date);
+
+		if (miner.getTest()) {
+			/**
+			 * 截止时间=起息时间+周期+1
+			 */
+//			Date date = new Date();
+//			Calendar calendar1 = new GregorianCalendar();
+			int days = (int) Arith.sub(miner.getCycle(), 1);
+			calendar.add(calendar.DATE, days);
+			date = calendar.getTime();
+
+			entity.setStop_time(DateUtils.getDayEnd(date));
+			entity.setAmount(0d);// 体验矿机不管输入多少都为0
+		}
+		if (findByFist(entity.getPartyId().toString())) {
+			entity.setFirst_buy("1");// 标识首次购买
+		} else {
+			entity.setFirst_buy("0");// 标识首次购买
+		}
+		this.getHibernateTemplate().save(entity);
+
+		redisHandler.setSync(MinerRedisKeys.MINER_ORDER_ORDERNO + entity.getOrder_no(), entity);
+
+		if (!miner.getTest()) {
+			
+			Map<String, MinerOrder> map_partyid = (Map<String, MinerOrder>) redisHandler
+					.get(MinerRedisKeys.MINER_ORDER_PARTY_ID + entity.getPartyId().toString());
+
+			if (map_partyid == null) {
+				map_partyid = new ConcurrentHashMap<String, MinerOrder>();
+			}
+			map_partyid.put(entity.getOrder_no(), entity);
+			redisHandler.setSync(MinerRedisKeys.MINER_ORDER_PARTY_ID + entity.getPartyId().toString(), map_partyid);
+			
+			// 状态：0/正常赎回； 1/ 托管中 ；2/提前赎回 (违约)；3/取消；
+			if ("1".equals(entity.getState())) {
+				
+				// 获取 单个订单 矿机总资产
+				Double minerAssetsOrder = entity.getAmount();
+
+				Double minerAssets = (Double) this.redisHandler.get(MinerRedisKeys.MINER_ASSETS_PARTY_ID + entity.getPartyId().toString());
+
+				this.redisHandler.setSync(MinerRedisKeys.MINER_ASSETS_PARTY_ID + entity.getPartyId().toString(), 
+						Arith.add(null == minerAssets ? 0.000D : minerAssets, minerAssetsOrder));
+			}			
+		}
+		
+		/**
+		 * 首次购买则给予上级额外本金百分比奖励
+		 */
+		if ("1".equals(entity.getFirst_buy()) && !miner.getTest()) {
+			List<UserRecom> list_parents = this.userRecomService.getParents(entity.getPartyId());
+
+			if (CollectionUtils.isNotEmpty(list_parents)) {
+				String miner_bonus_parameters = "";
+				miner_bonus_parameters = sysparaService.find("miner_first_bonus_parameters").getValue();
+				String[] miner_bonus_array = miner_bonus_parameters.split(",");
+				int loop = 0;
+				for (int i = 0; i < list_parents.size(); i++) {
+					if (loop >= 3) {
+						break;
+					}
+					Party party_parent = this.partyService.cachePartyBy(list_parents.get(i).getReco_id(), true);
+					if (!Constants.SECURITY_ROLE_MEMBER.equals(party_parent.getRolename())) {
+						continue;
+					}
+					loop++;
+					Map<String, MinerOrder> map_party = (Map<String, MinerOrder>) redisHandler
+							.get(MinerRedisKeys.MINER_ORDER_PARTY_ID + party_parent.getId().toString());
+					if (map_party == null || map_party.size() == 0) {
+						continue;
+					}
+					/*
+					 * 判断是否
+					 */
+					int cycle = 0;
+					Iterator<Entry<String, MinerOrder>> it = map_party.entrySet().iterator();
+					while (it.hasNext()) {
+						Entry<String, MinerOrder> entry = it.next();
+						MinerOrder minerOrder = entry.getValue();
+						if (!"1".equals(minerOrder.getState())) {
+							continue;
+						}
+						Miner miner_party = this.minerService.cacheById(minerOrder.getMinerId());
+						if (cycle < miner_party.getCycle()) {
+							cycle = miner_party.getCycle();
+						}
+
+					}
+
+					if (cycle >= miner.getCycle()) {
+						/**
+						 * 增加首次推荐人收益
+						 */
+						double pip_amount = Double.valueOf(miner_bonus_array[loop - 1]);
+						double get_money = Arith.mul(entity.getAmount(), pip_amount);
+
+						if (isOtherCoin) {
+							firstBuyProfitOtherCoin(minerBuySymbol, party_parent, get_money, i);
+							// 转化成usdt，统计计算
+							userDataService.saveMinerProfit(party_parent.getId().toString(),
+									Arith.div(get_money, close));
+						} else {
+							Wallet wallet_parent = walletService.saveWalletByPartyId(party_parent.getId().toString());
+							double amount_before_parent = wallet_parent.getMoney();
+//						wallet_parent.setMoney(Arith.add(wallet_parent.getMoney(), get_money));
+//						walletService.update(wallet_parent);
+							walletService.update(wallet_parent.getPartyId().toString(), get_money);
+
+							/**
+							 * 保存资金日志
+							 */
+							MoneyLog moneyLog = new MoneyLog();
+							moneyLog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
+							moneyLog.setAmount_before(amount_before_parent);
+							moneyLog.setAmount(get_money);
+							moneyLog.setAmount_after(Arith.add(amount_before_parent, get_money));
+							moneyLog.setLog("第" + (i + 1) + "代下级用户，首次购买矿机推荐奖励金");
+							moneyLog.setPartyId(party_parent.getId().toString());
+							moneyLog.setWallettype(Constants.WALLET);
+							moneyLog.setContent_type(Constants.MONEYLOG_CONTENT_MINER_RECOM_PROFIT);
+							moneyLogService.save(moneyLog);
+							userDataService.saveMinerProfit(party_parent.getId().toString(), get_money);
+
+						}
+
+					}
+				}
+
+			}
+		}
+
+		/**
+		 * userdata 数据
+		 */
+		if (isOtherCoin) {
+			userDataService.saveMinerBuy(minerUserDataOtherCoin(entity, minerBuySymbol, close));
+		} else {
+			userDataService.saveMinerBuy(entity);
+		}
+
+	}
+
+	/**
+	 * 增加首次推荐人收益
+	 */
+	protected void firstBuyProfitOtherCoin(String symbol, Party partyParent, double getMoney, int i) {
+		WalletExtend walletExtend = walletService.saveExtendByPara(partyParent.getId().toString(), symbol);
+		double amount_before_parent = walletExtend.getAmount();
+		this.walletService.updateExtend(walletExtend.getPartyId().toString(), symbol, getMoney);
+
+		/**
+		 * 保存资金日志
+		 */
+		MoneyLog moneyLog = new MoneyLog();
+		moneyLog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
+		moneyLog.setAmount_before(amount_before_parent);
+		moneyLog.setAmount(getMoney);
+		moneyLog.setAmount_after(Arith.add(amount_before_parent, getMoney));
+		moneyLog.setLog("第" + (i + 1) + "代下级用户，首次购买矿机推荐奖励金");
+		moneyLog.setPartyId(partyParent.getId().toString());
+		moneyLog.setWallettype(symbol);
+		moneyLog.setContent_type(Constants.MONEYLOG_CONTENT_MINER_RECOM_PROFIT);
+		moneyLogService.save(moneyLog);
+		userDataService.saveMinerProfit(walletExtend.getPartyId().toString(), getMoney);
+
+	}
+
+	protected MinerOrder minerUserDataOtherCoin(MinerOrder entity, String symbol, double close) {
+		MinerOrder order = new MinerOrder();
+		// 不改变原有的
+		BeanUtils.copyProperties(entity, order);
+		// 转化成usdt，统计计算
+		order.setAmount(Arith.div(order.getAmount(), close));
+		return order;
+	}
+
+	protected void saveMinerBuyOtherCoin(MinerOrder entity, String symbol) {
+		WalletExtend walletExtend = walletService.saveExtendByPara(entity.getPartyId(), symbol);
+
+		if (entity.getAmount() > walletExtend.getAmount()) {
+			throw new BusinessException("持有币种不足");
+		}
+
+		double amount_before = walletExtend.getAmount();
+//		walletExtend.setAmount(Arith.sub(walletExtend.getAmount(), order.getVolume()));
+
+//		walletService.save(walletExtend);
+		walletService.updateExtend(walletExtend.getPartyId().toString(), walletExtend.getWallettype(),
+				Arith.sub(0, entity.getAmount()));
+		/*
+		 * 保存资金日志
+		 */
+		MoneyLog moneylog = new MoneyLog();
+		moneylog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
+		moneylog.setAmount_before(amount_before);
+		moneylog.setAmount(Arith.sub(0, entity.getAmount()));
+		moneylog.setAmount_after(Arith.sub(amount_before, entity.getAmount()));
+		moneylog.setLog("购买矿机产品，订单号[" + entity.getOrder_no() + "]");
+		moneylog.setPartyId(entity.getPartyId());
+		moneylog.setWallettype(symbol);
+		moneylog.setContent_type(Constants.MONEYLOG_CONTENT_MINER_BUY);
+		moneyLogService.save(moneylog);
+	}
+
+	protected void saveMinerCloseOtherCoin(MinerOrder entity, String symbol) {
+
+		WalletExtend walletExtend = walletService.saveExtendByPara(entity.getPartyId(), symbol);
+
+		double amount_before = walletExtend.getAmount();
+		double back_money = entity.getAmount();
+//		walletExtend.setAmount(Arith.add(walletExtend.getAmount(), amount));
+//		this.walletService.update(walletExtend);
+		this.walletService.updateExtend(walletExtend.getPartyId().toString(), walletExtend.getWallettype(), back_money);
+
+		/*
+		 * 保存资金日志
+		 */
+		MoneyLog moneylog_deposit = new MoneyLog();
+		moneylog_deposit.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
+		moneylog_deposit.setAmount_before(amount_before);
+		moneylog_deposit.setAmount(back_money);
+		moneylog_deposit.setAmount_after(Arith.add(amount_before, back_money));
+		moneylog_deposit.setLog("矿机本金退回，订单号[" + entity.getOrder_no() + "]");
+		moneylog_deposit.setPartyId(entity.getPartyId());
+		moneylog_deposit.setWallettype(symbol);
+		moneylog_deposit.setContent_type(Constants.MONEYLOG_CONTENT_MINER_BACK);
+
+		moneyLogService.save(moneylog_deposit);
+	}
+
+	public void saveClose(MinerOrder entity) {
+		String minerBuySymbol = sysparaService.find("miner_buy_symbol").getValue();
+		// 是否是其他币种购买
+		boolean isOtherCoin = !StringUtils.isEmptyString(minerBuySymbol);
+		double close = 0;
+		if (isOtherCoin) {
+			List<Realtime> realtimes = this.dataService.realtime(minerBuySymbol);
+			if (CollectionUtils.isEmpty(realtimes) || null == realtimes.get(0)) {
+				throw new BusinessException("系统错误，请稍后重试");
+			}
+			close = realtimes.get(0).getClose();
+
+			saveMinerCloseOtherCoin(entity, minerBuySymbol);
+		} else if (entity.getAmount() != 0) {// 体验矿机，购买价为0
+			Wallet wallet = this.walletService.saveWalletByPartyId(entity.getPartyId());
+			double amount_before = wallet.getMoney();
+			// 购买金额-违约金=退还金额
+//			double back_money = Arith.sub(entity.getAmount(), entity.getDefault_money());
+			double back_money = entity.getAmount();
+//			if ("0".equals(entity.getState())) {// 正常状态下 到期后一天 奖励5%
+//				double profit = entity.getCompute_profit();
+//				back_money = profit;
+//			}
+//			wallet.setMoney(Arith.add(wallet.getMoney(), back_money));
+			this.walletService.update(wallet.getPartyId().toString(), back_money);
+			/**
+			 * 保存资金日志
+			 */
+			MoneyLog moneylog = new MoneyLog();
+			moneylog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
+			moneylog.setAmount_before(amount_before);
+			moneylog.setAmount(Arith.add(0, back_money));
+			moneylog.setAmount_after(Arith.add(amount_before, back_money));
+			moneylog.setPartyId(entity.getPartyId());
+			moneylog.setWallettype(Constants.WALLET);
+			moneylog.setLog("矿机本金退回，订单号[" + entity.getOrder_no() + "]");
+			moneylog.setContent_type(Constants.MONEYLOG_CONTENT_MINER_BACK);
+			moneyLogService.save(moneylog);
+		}
+
+		entity.setClose_time(new Date());// 赎回时间
+		getHibernateTemplate().update(entity);
+		/**
+		 * userdata 数据
+		 */
+		if (isOtherCoin) {
+			userDataService.saveMinerClose(minerUserDataOtherCoin(entity, minerBuySymbol, close));
+		} else {
+			userDataService.saveMinerClose(entity);
+		}
+
+		Miner miner = this.minerService.cacheById(entity.getMinerId());
+
+		// 更新矿机订单
+		redisHandler.setSync(MinerRedisKeys.MINER_ORDER_ORDERNO + entity.getOrder_no(), entity);
+		if (!miner.getTest()) {
+			
+			Map<String, MinerOrder> map_partyid = (Map<String, MinerOrder>) redisHandler
+					.get(MinerRedisKeys.MINER_ORDER_PARTY_ID + entity.getPartyId().toString());
+			if (map_partyid == null) {
+				map_partyid = new ConcurrentHashMap<String, MinerOrder>();
+			}
+			
+			MinerOrder minerOld = map_partyid.get(entity.getOrder_no());
+			
+			map_partyid.put(entity.getOrder_no(), entity);
+			redisHandler.setSync(MinerRedisKeys.MINER_ORDER_PARTY_ID + entity.getPartyId().toString(), map_partyid);
+			
+			Double minerAssets = (Double) this.redisHandler.get(MinerRedisKeys.MINER_ASSETS_PARTY_ID + entity.getPartyId().toString());
+									
+			// 状态：0/正常赎回； 1/ 托管中 ；2/提前赎回 (违约)；3/取消；
+			if ("1".equals(minerOld.getState())) {
+
+				// 获取 单个订单 矿机总资产
+				Double minerAssetsOld = minerOld.getAmount();
+				
+				minerAssets = null == minerAssets ? 0.000D - minerAssetsOld : minerAssets - minerAssetsOld;
+			}
+
+			// 状态：0/正常赎回； 1/ 托管中 ；2/提前赎回 (违约)；3/取消；
+			if ("1".equals(entity.getState())) {
+
+				// 获取 单个订单 矿机总资产
+				Double minerAssetsOrder = entity.getAmount();
+								
+				minerAssets = null == minerAssets ? 0.000D + minerAssetsOrder : minerAssets + minerAssetsOrder;
+			}
+
+			this.redisHandler.setSync(MinerRedisKeys.MINER_ASSETS_PARTY_ID + entity.getPartyId().toString(), null == minerAssets ? 0.000D : minerAssets);
+		}
+	}
+
+	public List<MinerOrder> findAllByState(String state) {
+		List<MinerOrder> list = (List<MinerOrder>)this.getHibernateTemplate().find(" FROM MinerOrder WHERE state = ?0 ",
+				new Object[] { state });
+		return list;
+	}
+
+	@Override
+	public MinerOrder findByOrder_no(String order_no) {
+
+		return (MinerOrder) redisHandler.get(MinerRedisKeys.MINER_ORDER_ORDERNO + order_no);
+
+	}
+
+	public List<MinerOrder> findByState(String partyId, String state) {
+		if (StringUtils.isEmptyString(partyId)) {
+			return findAllByState(state);
+		}
+		/**
+		 * 如果是查询已赎回的，则将提前赎回和正常赎回的都查出来
+		 */
+		List<MinerOrder> list;
+		if (StringUtils.isEmptyString(state)) {
+			list = (List<MinerOrder>)getHibernateTemplate().find(" FROM MinerOrder WHERE  partyId =?0", new Object[] { partyId });
+		} else {
+			if ("2".equals(state)) {
+				list = (List<MinerOrder>)getHibernateTemplate().find(" FROM MinerOrder WHERE partyId =?0 and ( state = ?1 or state =?2 )  ",
+						new Object[] { partyId, "0", "2" });
+			} else {
+				list = (List<MinerOrder>)getHibernateTemplate().find(" FROM MinerOrder WHERE state = ?0 and partyId =?1",
+						new Object[] { state, partyId });
+			}
+		}
+
+		if (list.size() > 0)
+			return list;
+		return null;
+	}
+
+	public Page pagedQuery(int pageNo, int pageSize, String partyId, String state) {
+		Map<String, Object> parameters = new HashMap<String, Object>();
+		StringBuffer queryString = new StringBuffer("SELECT ");
+		queryString.append(" minerOrder.UUID id,minerOrder.ORDER_NO order_no ,minerOrder.MINER_ID minerId  , ");
+		queryString.append(
+				" minerOrder.AMOUNT amount,DATE_FORMAT(minerOrder.CREATE_TIME,'%Y-%m-%d %H:%i:%S') create_time, ");
+		queryString.append(
+				" DATE(minerOrder.EARN_TIME) earn_time,DATE(minerOrder.STOP_TIME) stop_time,minerOrder.PROFIT profit, ");
+		queryString.append(" minerOrder.STATE state,minerOrder.BASE_COMPUTE_AMOUNT base_compute_amount, ");
+		queryString.append(
+				" miner.CYCLE cycle,miner.CYCLE_CLOSE cycle_close,miner.DAILY_RATE daily_rate,miner.TEST test, ");
+		queryString.append(" miner.NAME miner_name,miner.NAME_EN miner_name_en,miner.NAME_CN miner_name_cn ");
+		queryString.append("FROM T_MINER_ORDER minerOrder ");
+		queryString.append("LEFT JOIN T_MINER miner ON miner.UUID= minerOrder.MINER_ID ");
+
+		queryString.append("WHERE 1=1 ");
+		queryString.append("AND minerOrder.PARTY_ID=:partyId ");
+		parameters.put("partyId", partyId);
+		if (StringUtils.isNotEmpty(state)) {
+			if ("2".equals(state)) {
+				queryString.append("AND minerOrder.STATE in('0','2') ");
+			} else {
+				queryString.append("AND minerOrder.STATE=:state ");
+				parameters.put("state", state);
+			}
+		}
+		queryString.append(" order by minerOrder.CREATE_TIME desc ");
+
+		Page page = this.pagedDao.pagedQuerySQL(pageNo, pageSize, queryString.toString(), parameters);
+
+		return page;
+	}
+
+	public void deleteAllByPartyId(String partyId) {
+		List<MinerOrder> list = (List<MinerOrder>)this.getHibernateTemplate().find(" FROM MinerOrder WHERE partyId=? ",
+				new Object[] { partyId });
+		if (!CollectionUtils.isEmpty(list)) {
+			for (MinerOrder order : list) {
+				this.getHibernateTemplate().delete(order);
+				redisHandler.remove(MinerRedisKeys.MINER_ORDER_ORDERNO + order.getOrder_no());
+			}
+			redisHandler.remove(MinerRedisKeys.MINER_ORDER_PARTY_ID + partyId);
+			
+			this.redisHandler.remove(MinerRedisKeys.MINER_ASSETS_PARTY_ID + partyId);
+		}
+	}
+
+	public void setWalletService(WalletService walletService) {
+		this.walletService = walletService;
+	}
+
+	public void setMoneyLogService(MoneyLogService moneyLogService) {
+		this.moneyLogService = moneyLogService;
+	}
+
+	public void setMinerService(MinerService minerService) {
+		this.minerService = minerService;
+	}
+
+	public MinerOrder findById(String id) {// 赎回时使用
+		return (MinerOrder) getHibernateTemplate().get(MinerOrder.class, id);
+	}
+
+	/**
+	 * true:买过体验矿机，false:没买过
+	 */
+	public boolean findByTest(String partyId) {
+		Map<String, Object> parameters = new HashMap<String, Object>();
+		StringBuffer queryString = new StringBuffer("SELECT ");
+		queryString.append("mo.UUID ");
+		queryString.append("FROM T_MINER_ORDER mo ");
+		queryString.append("LEFT JOIN T_MINER m ON m.UUID=mo.MINER_ID ");
+		queryString.append("WHERE 1=1  ");
+		queryString.append("AND PARTY_ID=:partyId AND m.TEST='Y' ");
+		parameters.put("partyId", partyId);
+		List<Map<String, Object>> list = namedParameterJdbcTemplate.queryForList(queryString.toString(), parameters);
+		return list != null && CollectionUtils.isNotEmpty(list) && list.get(0) != null;// 存在返回值，且不为空
+	}
+
+	/**
+	 * true：首次购买，false:非首次购买
+	 * 
+	 * @param partyId
+	 * @return
+	 */
+	public boolean findByFist(String partyId) {
+		Map<String, Object> parameters = new HashMap<String, Object>();
+		StringBuffer queryString = new StringBuffer("SELECT ");
+		queryString.append("mo.UUID ");
+		queryString.append("FROM T_MINER_ORDER mo ");
+		queryString.append("LEFT JOIN T_MINER m ON m.UUID=mo.MINER_ID ");
+		queryString.append("WHERE 1=1  ");
+		queryString.append("AND PARTY_ID=:partyId AND m.TEST='N' ");
+		queryString.append("AND FIRST_BUY='1' ");
+		parameters.put("partyId", partyId);
+		List<Map<String, Object>> list = namedParameterJdbcTemplate.queryForList(queryString.toString(), parameters);
+		return !(list != null && CollectionUtils.isNotEmpty(list) && list.get(0) != null);// 存在返回值，且不为空
+	}
+
+	public boolean getUnLockMiner(String partyId, String minerId) {
+		Miner miner = this.minerService.cacheById(minerId);
+
+		List<UserRecom> list_userRecoms = this.userRecomService.findRecoms(partyId);
+		int cycle = 0;
+		for (int i = 0; i < list_userRecoms.size(); i++) {
+			Map<String, MinerOrder> map = (Map<String, MinerOrder>) redisHandler
+					.get(MinerRedisKeys.MINER_ORDER_PARTY_ID + list_userRecoms.get(i).getPartyId().toString());
+
+			if (map != null) {
+				cycle = cycle + map.size();
+			}
+		}
+
+		return cycle >= miner.getCycle();// 如果周期比该矿机的大，则解锁
+	}
+
+	public void setPagedDao(PagedQueryDao pagedDao) {
+		this.pagedDao = pagedDao;
+	}
+
+	public void setUserDataService(UserDataService userDataService) {
+		this.userDataService = userDataService;
+	}
+
+	public void setNamedParameterJdbcTemplate(NamedParameterJdbcOperations namedParameterJdbcTemplate) {
+		this.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
+	}
+
+	public void setUserRecomService(UserRecomService userRecomService) {
+		this.userRecomService = userRecomService;
+	}
+
+	public void setSysparaService(SysparaService sysparaService) {
+		this.sysparaService = sysparaService;
+	}
+
+	public void setPartyService(PartyService partyService) {
+		this.partyService = partyService;
+	}
+
+	public void setLogService(LogService logService) {
+		this.logService = logService;
+	}
+
+	public void setSecUserService(SecUserService secUserService) {
+		this.secUserService = secUserService;
+	}
+
+	public void setRedisHandler(RedisHandler redisHandler) {
+		this.redisHandler = redisHandler;
+	}
+
+	public void setDataService(DataService dataService) {
+		this.dataService = dataService;
+	}
+
+}

comm/Miner/src/project/miner/internal/MinerParaServiceImpl.java

@@ -0,0 +1,32 @@
+package project.miner.internal;
+
+import java.util.List;
+
+import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
+
+import project.miner.MinerParaService;
+import project.miner.model.MinerPara;
+
+public class MinerParaServiceImpl extends HibernateDaoSupport implements MinerParaService {
+
+	public void save(MinerPara entity) {
+		this.getHibernateTemplate().save(entity);
+	}
+
+	public void update(MinerPara entity) {
+		getHibernateTemplate().update(entity);
+	}
+
+	public void delete(String id) {
+		MinerPara entity = findById(id);
+		getHibernateTemplate().delete(entity);
+	}
+
+	public MinerPara findById(String id) {
+		return (MinerPara) getHibernateTemplate().get(MinerPara.class, id);
+	}
+
+	public List<MinerPara> findByMinerId(String minerId) {
+		return (List<MinerPara>)getHibernateTemplate().find("FROM MinerPara WHERE miner_id=?0 ", new Object[] { minerId });
+	}
+}

comm/Miner/src/project/miner/internal/MinerServiceImpl.java

@@ -0,0 +1,181 @@
+package project.miner.internal;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
+
+import kernel.exception.BusinessException;
+import kernel.util.Arith;
+import project.data.DataService;
+import project.data.model.Realtime;
+import project.miner.MinerRedisKeys;
+import project.miner.MinerService;
+import project.miner.model.Miner;
+import project.redis.RedisHandler;
+import project.syspara.SysparaService;
+
+public class MinerServiceImpl extends HibernateDaoSupport implements MinerService {
+
+	protected RedisHandler redisHandler;
+	protected SysparaService sysparaService;
+	protected DataService dataService;
+
+	public Miner cacheById(String id) {
+		return (Miner) redisHandler.get(MinerRedisKeys.MINER_ID + id);
+	}
+
+	public void save(Miner entity) {
+
+		this.getHibernateTemplate().save(entity);
+
+		redisHandler.setSync(MinerRedisKeys.MINER_ID + entity.getId().toString(), entity);
+
+		Map<String, Miner> map = (Map<String, Miner>) redisHandler.get(MinerRedisKeys.MINER_MAP);
+		if (map == null) {
+			map = new ConcurrentHashMap<String, Miner>();
+		}
+		map.put(entity.getId().toString(), entity);
+		redisHandler.setSync(MinerRedisKeys.MINER_MAP, map);
+
+	}
+
+	public void update(Miner entity) {
+		getHibernateTemplate().update(entity);
+
+		redisHandler.setSync(MinerRedisKeys.MINER_ID + entity.getId().toString(), entity);
+
+		Map<String, Miner> map = (Map<String, Miner>) redisHandler.get(MinerRedisKeys.MINER_MAP);
+		if (map == null) {
+			map = new ConcurrentHashMap<String, Miner>();
+		}
+		map.put(entity.getId().toString(), entity);
+		redisHandler.setSync(MinerRedisKeys.MINER_MAP, map);
+	}
+
+	public void delete(String id) {
+		Miner entity = findById(id);
+		getHibernateTemplate().delete(entity);
+
+		redisHandler.remove(MinerRedisKeys.MINER_ID + entity.getId().toString());
+		Map<String, Miner> map = (Map<String, Miner>) redisHandler.get(MinerRedisKeys.MINER_MAP);
+		if (map != null && !map.isEmpty()) {
+			map.remove(entity.getId().toString());
+			redisHandler.setSync(MinerRedisKeys.MINER_MAP, map);
+		}
+	}
+
+	public Miner findById(String id) {
+		return (Miner) redisHandler.get(MinerRedisKeys.MINER_ID + id);
+	}
+
+	public List<Miner> findAll() {
+		Map<String, Miner> map = (Map<String, Miner>) redisHandler.get(MinerRedisKeys.MINER_MAP);
+		if (map != null) {
+			List<Miner> list = new ArrayList<>(map.values());
+			list.sort(new Miner());
+			return list;
+		}
+		return new ArrayList<>();
+	}
+
+	public List<Miner> findAllState_1() {
+		List<Miner> list = new ArrayList<Miner>();
+		for (Miner miner : findAll()) {
+			if ("1".equals(miner.getState())) {
+				list.add(miner);
+			}
+		}
+		return list;
+	}
+
+	public Map<String, Object> getBindOne(Miner miner) {
+		Map<String, Object> result = new HashMap<String, Object>();
+
+		result.put("id", miner.getId());
+		result.put("name", miner.getName());
+		result.put("name_en", miner.getName_en());
+		result.put("name_cn", miner.getName_cn());
+		result.put("daily_rate", miner.getDaily_rate());
+		result.put("investment_min", miner.getInvestment_min());
+		result.put("investment_max", miner.getInvestment_max());
+		result.put("state", miner.getState());
+		result.put("on_sale", miner.getOn_sale());
+		result.put("test", miner.getTest());
+		Double miner_test_profit = sysparaService.find("miner_test_profit").getDouble();
+		if (miner.getTest()) {
+			result.put("all_rate", Arith.mul(miner_test_profit, miner.getCycle()));
+			result.put("cycle", miner.getCycle());
+			result.put("daily_rate", miner_test_profit);
+		} else {
+			result.put("all_rate", Arith.mul(miner.getDaily_rate(), 30));
+			result.put("cycle", miner.getCycle_close());
+		}
+
+		// 根据产生的收益转化成指定的币种
+		String miner_profit_symbol = sysparaService.find("miner_profit_symbol").getValue();
+		// 矿机购买时使用的币种，则产生
+		String miner_buy_symbol = sysparaService.find("miner_buy_symbol").getValue();
+		double symbol_profit = miner.getTest() ? miner_test_profit
+				: Arith.div(Arith.mul(100, miner.getDaily_rate()), 100);// 100为单位的币种收益
+		// 收益转化成U
+		if (StringUtils.isNotEmpty(miner_buy_symbol) && !"usdt".equalsIgnoreCase(miner_buy_symbol)) {
+			List<Realtime> realtime_list = this.dataService.realtime(miner_buy_symbol);
+			Realtime realtime = null;
+			if (realtime_list.size() > 0) {
+				realtime = realtime_list.get(0);
+			} else {
+				throw new BusinessException("行情获取异常，稍后再试");
+			}
+			symbol_profit = Arith.mul(symbol_profit, realtime.getClose());
+		}
+
+		if (StringUtils.isNotEmpty(miner_profit_symbol) && !"usdt".equalsIgnoreCase(miner_profit_symbol)) {
+			List<Realtime> realtime_list = this.dataService.realtime(miner_profit_symbol);
+			Realtime realtime = null;
+			if (realtime_list.size() > 0) {
+				realtime = realtime_list.get(0);
+			} else {
+				throw new BusinessException("行情获取异常，稍后再试");
+			}
+			symbol_profit = Arith.div(symbol_profit, realtime.getClose());
+			result.put("symbol_profit", symbol_profit);
+		} else {
+			result.put("symbol_profit", symbol_profit);
+		}
+		result.put("miner_profit_symbol",
+				StringUtils.isEmpty(miner_profit_symbol) ? "USDT" : miner_profit_symbol.toUpperCase());
+		// 基础信息
+		result.put("algorithm", miner.getAlgorithm());
+		result.put("computing_power", miner.getComputing_power());
+		result.put("computing_power_unit", miner.getComputing_power_unit());
+		result.put("power", miner.getPower());
+		result.put("product_factory", miner.getProduct_factory());
+		result.put("product_size", miner.getProduct_size());
+		result.put("weight", miner.getWeight());
+		result.put("work_temperature_min", miner.getWork_temperature_min());
+		result.put("work_temperature_max", miner.getWork_temperature_max());
+		result.put("work_humidity_min", miner.getWork_humidity_min());
+		result.put("work_humidity_max", miner.getWork_humidity_max());
+		result.put("internet", miner.getInternet());
+
+		return result;
+	}
+
+	public void setRedisHandler(RedisHandler redisHandler) {
+		this.redisHandler = redisHandler;
+	}
+
+	public void setSysparaService(SysparaService sysparaService) {
+		this.sysparaService = sysparaService;
+	}
+
+	public void setDataService(DataService dataService) {
+		this.dataService = dataService;
+	}
+
+}

comm/Miner/src/project/miner/job/MinerOrderMessage.java

@@ -0,0 +1,64 @@
+package project.miner.job;
+
+import java.io.Serializable;
+import java.util.Date;
+
+public class MinerOrderMessage implements Serializable {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 2239789461218349202L;
+
+	/**
+	 * 无参构造函数
+	 */
+	public MinerOrderMessage() {
+	}
+
+	/**
+	 * 订单号
+	 */
+	private String orderNo;
+	/**
+	 * 收益
+	 */
+	private double profit = 0.0D;
+	/**
+	 * 计息时间
+	 */
+	private Date computeDay;
+
+	public String getOrderNo() {
+		return orderNo;
+	}
+
+	public double getProfit() {
+		return profit;
+	}
+
+	public Date getComputeDay() {
+		return computeDay;
+	}
+
+	public void setOrderNo(String orderNo) {
+		this.orderNo = orderNo;
+	}
+
+	public void setProfit(double profit) {
+		this.profit = profit;
+	}
+
+	public void setComputeDay(Date computeDay) {
+		this.computeDay = computeDay;
+	}
+
+
+	public MinerOrderMessage(String orderNo, double profit, Date computeDay) {
+		this.orderNo = orderNo;
+		this.profit = profit;
+		this.computeDay = computeDay;
+	}
+
+
+}

comm/Miner/src/project/miner/job/MinerOrderProfitJob.java

@@ -0,0 +1,130 @@
+package project.miner.job;
+
+import java.util.Date;
+import java.util.List;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.util.CollectionUtils;
+
+import kernel.util.StringUtils;
+import kernel.web.Page;
+import project.data.DataService;
+import project.data.model.Realtime;
+import project.log.SysLog;
+import project.log.SysLogService;
+import project.miner.model.MinerOrder;
+import project.syspara.SysparaService;
+
+public class MinerOrderProfitJob {
+	private static Logger logger = LoggerFactory.getLogger(MinerOrderProfitJob.class);
+	protected MinerOrderProfitService minerOrderProfitService;
+	protected SysparaService sysparaService;
+	protected DataService dataService;
+	protected SysLogService sysLogService;
+
+	public void taskJob() {
+
+		try {
+			int pageNo = 1;
+			int pageSize = 300;
+			minerOrderProfitService.cacheRecomProfitClear();
+
+			String miner_bonus_parameters = sysparaService.find("miner_bonus_parameters").getValue();
+			String miner_profit_symbol = sysparaService.find("miner_profit_symbol").getValue();
+			List<Realtime> realtime_list = this.dataService.realtime(miner_profit_symbol);
+			Realtime realtime = null;
+			if (realtime_list.size() > 0) {
+				realtime = realtime_list.get(0);
+			}
+			if (StringUtils.isNotEmpty(miner_profit_symbol) && realtime == null) {
+				// 行情不存在，则退出计算
+				return;
+			}
+
+			while (true) {
+				Page page = minerOrderProfitService.pagedQueryComputeOrder(pageNo, pageSize);
+				List<MinerOrder> minerOrders = page.getElements();
+				if (CollectionUtils.isEmpty(minerOrders)) {// 分页没数据时表示已经计算结束
+					break;
+				}
+				try {
+					this.minerOrderProfitService.saveComputeOrderProfit(minerOrders, miner_profit_symbol, realtime,
+							miner_bonus_parameters);
+				} catch (Throwable e) {
+					logger.error("error:", e);
+				}
+				logger.info("miner profit finished ,count:" + minerOrders.size());
+				pageNo++;
+			}
+			// 用户收益计算完，计算推荐人收益
+			minerOrderProfitService.saveRecomProfit();
+		} catch (Throwable e) {
+			logger.error("miner profit run fail", e);
+		}
+
+	}
+
+	public void handleData(Date systemTime) {
+
+		try {
+			int pageNo = 1;
+			int pageSize = 300;
+			minerOrderProfitService.cacheRecomProfitClear();
+
+			String miner_bonus_parameters = sysparaService.find("miner_bonus_parameters").getValue();
+			String miner_profit_symbol = sysparaService.find("miner_profit_symbol").getValue();
+			List<Realtime> realtime_list = this.dataService.realtime(miner_profit_symbol);
+			Realtime realtime = null;
+			if (realtime_list.size() > 0) {
+				realtime = realtime_list.get(0);
+			}
+			if (StringUtils.isNotEmpty(miner_profit_symbol) && realtime == null)
+				return;// 行情不存在，则退出计算
+
+			while (true) {
+				Page page = minerOrderProfitService.pagedQueryComputeOrder(pageNo, pageSize);
+				List<MinerOrder> minerOrders = page.getElements();
+				if (CollectionUtils.isEmpty(minerOrders)) {// 分页没数据时表示已经计算结束
+					break;
+				}
+				try {
+					this.minerOrderProfitService.saveComputeOrderProfit(minerOrders, miner_profit_symbol, realtime,
+							miner_bonus_parameters,systemTime);
+				} catch (Throwable e) {
+					logger.error("error:", e);
+				}
+				logger.info("miner profit finished ,count:" + minerOrders.size());
+				pageNo++;
+			}
+			// 用户收益计算完，计算推荐人收益
+			minerOrderProfitService.saveRecomProfit(systemTime);
+		} catch (Throwable e) {
+			logger.error("MinerOrderProfitJob run fail e:", e);
+			SysLog entity = new SysLog();
+			entity.setLevel(SysLog.level_error);
+			entity.setCreateTime(new Date());
+			entity.setLog("MinerOrderProfitJob 矿机任务 执行失败  e:"+e);
+			sysLogService.saveAsyn(entity);
+		}
+
+	}
+	public void setMinerOrderProfitService(MinerOrderProfitService minerOrderProfitService) {
+		this.minerOrderProfitService = minerOrderProfitService;
+	}
+
+	public void setSysparaService(SysparaService sysparaService) {
+		this.sysparaService = sysparaService;
+	}
+
+	public void setDataService(DataService dataService) {
+		this.dataService = dataService;
+	}
+
+	public void setSysLogService(SysLogService sysLogService) {
+		this.sysLogService = sysLogService;
+	}
+	
+	
+
+}

comm/Miner/src/project/miner/job/MinerOrderProfitService.java

@@ -0,0 +1,43 @@
+package project.miner.job;
+
+import java.util.Date;
+import java.util.List;
+
+import kernel.web.Page;
+import project.data.model.Realtime;
+import project.miner.model.MinerOrder;
+
+public interface MinerOrderProfitService {
+	/**
+	 * 分页获取计息中的矿机订单
+	 * 
+	 * @param pageNo
+	 * @param pageSize
+	 * @return
+	 */
+	public Page pagedQueryComputeOrder(int pageNo, int pageSize);
+
+	/**
+	 * 计算订单收益
+	 * 
+	 * @param orders                 订单列表
+	 * @param miner_profit_symbol    指定币种
+	 * @param realtime               币种行情
+	 * @param miner_bonus_parameters 推荐人收益参数
+	 */
+	public void saveComputeOrderProfit(List<MinerOrder> orders, String miner_profit_symbol, Realtime realtime,
+			String miner_bonus_parameters);
+	
+	public void saveComputeOrderProfit(List<MinerOrder> orders, String miner_profit_symbol, Realtime realtime,
+			String miner_bonus_parameters,Date systemTime);
+	/**
+	 * 推荐人收益清空
+	 */
+	public void cacheRecomProfitClear();
+
+	/**
+	 * 推荐人收益持久化数据库
+	 */
+	public void saveRecomProfit();
+	public void saveRecomProfit(Date systemTime);
+}

comm/Miner/src/project/miner/job/MinerOrderProfitServiceImpl.java

@@ -0,0 +1,602 @@
+package project.miner.job;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.jdbc.core.BatchPreparedStatementSetter;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
+
+import kernel.util.Arith;
+import kernel.util.DateUtils;
+import kernel.util.StringUtils;
+import kernel.util.ThreadUtils;
+import kernel.web.Page;
+import kernel.web.PagedQueryDao;
+import project.Constants;
+import project.data.DataService;
+import project.data.model.Realtime;
+import project.log.MoneyLog;
+import project.log.MoneyLogService;
+import project.miner.MinerOrderService;
+import project.miner.MinerRedisKeys;
+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.party.model.UserRecom;
+import project.party.recom.UserRecomService;
+import project.redis.RedisHandler;
+import project.syspara.SysparaService;
+import project.user.UserDataService;
+import project.wallet.Wallet;
+import project.wallet.WalletExtend;
+import project.wallet.WalletService;
+
+public class MinerOrderProfitServiceImpl extends HibernateDaoSupport implements MinerOrderProfitService {
+	private Logger log = LoggerFactory.getLogger(MinerOrderProfitServiceImpl.class);
+
+	protected PagedQueryDao pagedDao;
+	protected MinerService minerService;
+	protected PartyService partyService;
+	protected UserRecomService userRecomService;
+	protected RedisHandler redisHandler;
+	protected UserDataService userDataService;
+	protected MoneyLogService moneyLogService;
+	protected MinerOrderService minerOrderService;
+	protected WalletService walletService;
+	protected JdbcTemplate jdbcTemplate;
+	protected SysparaService sysparaService;
+	protected DataService dataService;
+
+	/**
+	 * 计算推荐人收益
+	 */
+	protected Map<String, Double> cacheRecomProfit = new ConcurrentHashMap<String, Double>();
+
+	/**
+	 * 分页获取计息中的矿机订单
+	 * 
+	 * @param pageNo
+	 * @param pageSize
+	 * @return
+	 */
+	public Page pagedQueryComputeOrder(int pageNo, int pageSize) {
+		Map<String, Object> parameters = new HashMap<String, Object>();
+		StringBuffer queryString = new StringBuffer(" FROM MinerOrder WHERE state =1 ");
+		Page page = this.pagedDao.pagedQueryHql(pageNo, pageSize, queryString.toString(), parameters);
+		return page;
+	}
+
+	/**
+	 * 计算订单收益
+	 * 
+	 * @param orders                 订单列表
+	 * @param miner_profit_symbol    指定币种
+	 * @param realtime               币种行情
+	 * @param miner_bonus_parameters 推荐人收益参数
+	 */
+	public void saveComputeOrderProfit(List<MinerOrder> orders, String miner_profit_symbol, Realtime realtime,
+			String miner_bonus_parameters, Date systemTime) {
+		log.info("start compute order size:{}", orders.size());
+		List<MinerOrderMessage> saveMinerOrders = new ArrayList<MinerOrderMessage>();
+		Double miner_test_profit = sysparaService.find("miner_test_profit").getDouble();
+		for (MinerOrder order : orders) {
+			/**
+			 * 截止时间要大于现在这个时间则计算收益
+			 */
+			Miner miner = minerService.cacheById(order.getMinerId());
+			if (null == miner) {
+				log.error("该矿机不存在，停止计息，minerId:" + order.getMinerId());
+				continue;
+			}
+			if (!miner.getTest() && systemTime.before(order.getEarn_time()))// 非体验矿机，今天<起息时间 不计息，表示满24小时才开始计息
+				continue;
+			if (miner.getTest() && systemTime.before(DateUtils.getDayStart(order.getEarn_time())))// 体验矿机，今天<起息日 不计息
+				continue;
+
+			if (order.getStop_time() != null && systemTime.after(order.getStop_time())) {// 当前时间>截止时间
+				order.setState("0");// 正常赎回，停止计息，退还本金
+				order.setCompute_day(systemTime);
+				minerOrderService.saveClose(order);// 截止日=今天时就已经返还完毕
+			} else {
+				// 当天计算过，则不再计算，例如 1号4点计算， 则2号0点以前进入都判定计算过
+				if (order.getCompute_day() != null
+						&& systemTime.before(DateUtils.getDayStart(DateUtils.addDate(order.getCompute_day(), 1)))) {
+					double day_profit = 0;
+					if (miner.getTest()) {
+						day_profit = miner_test_profit;
+					} else {
+						day_profit = Arith.mul(order.getAmount(), Arith.mul(miner.getDaily_rate(), 0.01));
+					}
+					handleRecomProfit(order.getPartyId().toString(), day_profit, miner, miner_bonus_parameters);// 已经计息过的直接进入缓存
+					continue;
+				}
+				/**
+				 * 当日获取的收益
+				 */
+				double day_profit = 0;
+				if (miner.getTest()) {
+					day_profit = miner_test_profit;
+				} else {
+					day_profit = Arith.mul(order.getAmount(), Arith.mul(miner.getDaily_rate(), 0.01));
+				}
+				order.setCompute_day(systemTime);// 记息日期
+				order.setProfit(Arith.add(order.getProfit(), day_profit));// 累计收益
+				/**
+				 * 给钱包增加收益
+				 */
+				/**
+				 * 矿机产出是否需要转化成某个币种,若为空则不转化，若写入的symbol代码不存在则也不转化
+				 */
+				updateProfitToWallet(miner_profit_symbol, day_profit, realtime, order, systemTime);
+
+				saveMinerOrders
+						.add(new MinerOrderMessage(order.getOrder_no(), order.getProfit(), order.getCompute_day()));
+				// 更新矿机订单
+				redisHandler.setSync(MinerRedisKeys.MINER_ORDER_ORDERNO + order.getOrder_no(), order);
+
+				userDataService.saveMinerProfit(order.getPartyId().toString(), day_profit);
+
+				handleRecomProfit(order.getPartyId().toString(), day_profit, miner, miner_bonus_parameters);
+				//每单处理完后等待100ms，避免循环提交事务导致问题
+				ThreadUtils.sleep(200);
+			}
+		}
+		log.info("start miner batch update size:{}", saveMinerOrders.size());
+		updateBatchMinerOrdersProfit(saveMinerOrders);
+	}
+
+	/**
+	 * 计算订单收益
+	 * 
+	 * @param orders                 订单列表
+	 * @param miner_profit_symbol    指定币种
+	 * @param realtime               币种行情
+	 * @param miner_bonus_parameters 推荐人收益参数
+	 */
+	public void saveComputeOrderProfit(List<MinerOrder> orders, String miner_profit_symbol, Realtime realtime,
+			String miner_bonus_parameters) {
+		log.info("start compute order size:{}", orders.size());
+		List<MinerOrderMessage> saveMinerOrders = new ArrayList<MinerOrderMessage>();
+		Double miner_test_profit = sysparaService.find("miner_test_profit").getDouble();
+		for (MinerOrder order : orders) {
+			/**
+			 * 截止时间要大于现在这个时间则计算收益
+			 */
+			Miner miner = minerService.cacheById(order.getMinerId());
+			if (null == miner) {
+				log.error("该矿机不存在，停止计息，minerId:" + order.getMinerId());
+				continue;
+			}
+			if (!miner.getTest() && new Date().before(order.getEarn_time()))// 非体验矿机，今天<起息时间 不计息，表示满24小时才开始计息
+				continue;
+			if (miner.getTest() && new Date().before(DateUtils.getDayStart(order.getEarn_time())))// 体验矿机，今天<起息日 不计息
+				continue;
+
+			if (order.getStop_time() != null && new Date().after(order.getStop_time())) {// 当前时间>截止时间
+				order.setState("0");// 正常赎回，停止计息，退还本金
+				order.setCompute_day(new Date());
+				minerOrderService.saveClose(order);// 截止日=今天时就已经返还完毕
+			} else {
+				// 当天计算过，则不再计算，例如 1号4点计算， 则2号0点以前进入都判定计算过
+				if (order.getCompute_day() != null
+						&& new Date().before(DateUtils.getDayStart(DateUtils.addDate(order.getCompute_day(), 1)))) {
+					double day_profit = 0;
+					if (miner.getTest()) {
+						day_profit = miner_test_profit;
+					} else {
+						day_profit = Arith.mul(order.getAmount(), Arith.mul(miner.getDaily_rate(), 0.01));
+					}
+					handleRecomProfit(order.getPartyId().toString(), day_profit, miner, miner_bonus_parameters);// 已经计息过的直接进入缓存
+					continue;
+				}
+				/**
+				 * 当日获取的收益
+				 */
+				double day_profit = 0;
+				if (miner.getTest()) {
+					day_profit = miner_test_profit;
+				} else {
+					day_profit = Arith.mul(order.getAmount(), Arith.mul(miner.getDaily_rate(), 0.01));
+				}
+				order.setCompute_day(new Date());// 记息日期
+				order.setProfit(Arith.add(order.getProfit(), day_profit));// 累计收益
+				/**
+				 * 给钱包增加收益
+				 */
+				/**
+				 * 矿机产出是否需要转化成某个币种,若为空则不转化，若写入的symbol代码不存在则也不转化
+				 */
+				updateProfitToWallet(miner_profit_symbol, day_profit, realtime, order);
+
+				saveMinerOrders
+						.add(new MinerOrderMessage(order.getOrder_no(), order.getProfit(), order.getCompute_day()));
+				// 更新矿机订单
+				redisHandler.setSync(MinerRedisKeys.MINER_ORDER_ORDERNO + order.getOrder_no(), order);
+
+				userDataService.saveMinerProfit(order.getPartyId().toString(), day_profit);
+
+				handleRecomProfit(order.getPartyId().toString(), day_profit, miner, miner_bonus_parameters);
+				//每单处理完后等待100ms，避免循环提交事务导致问题
+				ThreadUtils.sleep(200);
+			}
+		}
+		log.info("start miner batch update size:{}", saveMinerOrders.size());
+		updateBatchMinerOrdersProfit(saveMinerOrders);
+	}
+
+	/**
+	 * 更新收益到钱包
+	 * 
+	 * @param miner_profit_symbol 指定币种
+	 * @param day_profit          当日收益
+	 * @param realtime            币种行情
+	 * @param order               矿机订单
+	 */
+	protected void updateProfitToWallet(String miner_profit_symbol, double day_profit, Realtime realtime,
+			MinerOrder order) {
+		// 矿机购买时使用的币种，则产生对应的币种，转换成u
+		String miner_buy_symbol = sysparaService.find("miner_buy_symbol").getValue();
+		if (StringUtils.isNotEmpty(miner_buy_symbol)) {
+			if (miner_buy_symbol.equals(miner_profit_symbol)) {// 两个相同，则行情直接可用，转化为U
+				day_profit = Arith.mul(day_profit, realtime.getClose());
+			} else {
+				List<Realtime> realtime_list = this.dataService.realtime(miner_buy_symbol);
+				Realtime realtimeBuySymbol = null;
+				if (realtime_list.size() > 0) {
+					realtimeBuySymbol = realtime_list.get(0);
+				}
+				day_profit = Arith.mul(day_profit, realtimeBuySymbol.getClose());
+			}
+		}
+		if (StringUtils.isNotEmpty(miner_profit_symbol)) {
+			/**
+			 * 非Usdt币种收益
+			 */
+
+			double get_symbol_volume = Arith.div(day_profit, realtime.getClose());
+
+			WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), miner_profit_symbol);
+			double amount_before = walletExtend.getAmount();
+//			walletExtend.setAmount(Arith.add(walletExtend.getAmount(), get_symbol_volume));
+			this.walletService.updateExtend(order.getPartyId().toString(), miner_profit_symbol, get_symbol_volume);
+			/*
+			 * 保存资金日志
+			 */
+			MoneyLog moneylog = new MoneyLog();
+			moneylog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
+			moneylog.setAmount_before(amount_before);
+			moneylog.setAmount(get_symbol_volume);
+			moneylog.setAmount_after(Arith.add(amount_before, get_symbol_volume));
+			moneylog.setLog("矿机收益，订单号[" + order.getOrder_no() + "]");
+			moneylog.setPartyId(order.getPartyId());
+			moneylog.setWallettype(realtime.getSymbol());
+			moneylog.setContent_type(Constants.MONEYLOG_CONTENT_MINER_PROFIT);
+			moneylog.setCreateTime(new Date());
+			moneyLogService.save(moneylog);
+		} else {
+			/**
+			 * 此为收益为usdt
+			 */
+			Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
+			double amount_before = wallet.getMoney();
+//			wallet.setMoney(Arith.add(wallet.getMoney(), day_profit));
+			this.walletService.update(wallet.getPartyId().toString(), day_profit);
+			/**
+			 * 保存资金日志
+			 */
+			MoneyLog moneylog = new MoneyLog();
+			moneylog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
+			moneylog.setAmount_before(amount_before);
+			moneylog.setAmount(day_profit);
+			moneylog.setAmount_after(Arith.add(amount_before, day_profit));
+			moneylog.setLog("矿机收益，订单号[" + order.getOrder_no() + "]");
+			moneylog.setPartyId(order.getPartyId());
+			moneylog.setWallettype(Constants.WALLET);
+			moneylog.setContent_type(Constants.MONEYLOG_CONTENT_MINER_PROFIT);
+			moneylog.setCreateTime(new Date());
+			moneyLogService.save(moneylog);
+		}
+	}
+
+	/**
+	 * 更新收益到钱包
+	 * 
+	 * @param miner_profit_symbol 指定币种
+	 * @param day_profit          当日收益
+	 * @param realtime            币种行情
+	 * @param order               矿机订单
+	 */
+	protected void updateProfitToWallet(String miner_profit_symbol, double day_profit, Realtime realtime,
+			MinerOrder order, Date systemTime) {
+		// 矿机购买时使用的币种，则产生对应的币种，转换成u
+		String miner_buy_symbol = sysparaService.find("miner_buy_symbol").getValue();
+		if (StringUtils.isNotEmpty(miner_buy_symbol)) {
+			if (miner_buy_symbol.equals(miner_profit_symbol)) {// 两个相同，则行情直接可用，转化为U
+				day_profit = Arith.mul(day_profit, realtime.getClose());
+			} else {
+				List<Realtime> realtime_list = this.dataService.realtime(miner_buy_symbol);
+				Realtime realtimeBuySymbol = null;
+				if (realtime_list.size() > 0) {
+					realtimeBuySymbol = realtime_list.get(0);
+				}
+				day_profit = Arith.mul(day_profit, realtimeBuySymbol.getClose());
+			}
+		}
+		if (StringUtils.isNotEmpty(miner_profit_symbol)) {
+			/**
+			 * 非Usdt币种收益
+			 */
+			double get_symbol_volume = Arith.div(day_profit, realtime.getClose());
+
+			WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), miner_profit_symbol);
+			double amount_before = walletExtend.getAmount();
+//			walletExtend.setAmount(Arith.add(walletExtend.getAmount(), get_symbol_volume));
+			this.walletService.updateExtend(order.getPartyId().toString(), miner_profit_symbol, get_symbol_volume);
+			/*
+			 * 保存资金日志
+			 */
+			MoneyLog moneylog = new MoneyLog();
+			moneylog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
+			moneylog.setAmount_before(amount_before);
+			moneylog.setAmount(get_symbol_volume);
+			moneylog.setAmount_after(Arith.add(amount_before, get_symbol_volume));
+			moneylog.setLog("矿机收益，订单号[" + order.getOrder_no() + "]");
+			moneylog.setPartyId(order.getPartyId());
+			moneylog.setWallettype(realtime.getSymbol());
+			moneylog.setContent_type(Constants.MONEYLOG_CONTENT_MINER_PROFIT);
+			moneylog.setCreateTime(systemTime);
+			moneyLogService.save(moneylog);
+		} else {
+			/**
+			 * 此为收益为usdt
+			 */
+			Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
+			double amount_before = wallet.getMoney();
+//			wallet.setMoney(Arith.add(wallet.getMoney(), day_profit));
+			this.walletService.update(wallet.getPartyId().toString(), day_profit);
+			/**
+			 * 保存资金日志
+			 */
+			MoneyLog moneylog = new MoneyLog();
+			moneylog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
+			moneylog.setAmount_before(amount_before);
+			moneylog.setAmount(day_profit);
+			moneylog.setAmount_after(Arith.add(amount_before, day_profit));
+			moneylog.setLog("矿机收益，订单号[" + order.getOrder_no() + "]");
+			moneylog.setPartyId(order.getPartyId());
+			moneylog.setWallettype(Constants.WALLET);
+			moneylog.setContent_type(Constants.MONEYLOG_CONTENT_MINER_PROFIT);
+			moneylog.setCreateTime(systemTime);
+			moneyLogService.save(moneylog);
+		}
+	}
+
+	/**
+	 * 批量更新订单收益
+	 * 
+	 * @param orderList
+	 */
+	protected void updateBatchMinerOrdersProfit(final List<MinerOrderMessage> orderList) {
+		String sql = "UPDATE T_MINER_ORDER SET PROFIT=?,COMPUTE_DAY=? WHERE ORDER_NO=?";
+		int[] batchUpdate = jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
+
+			@Override
+			public void setValues(PreparedStatement ps, int i) throws SQLException {
+				ps.setDouble(1, orderList.get(i).getProfit());
+				ps.setTimestamp(2, new Timestamp(orderList.get(i).getComputeDay().getTime()));
+				ps.setString(3, orderList.get(i).getOrderNo());
+			}
+
+			@Override
+			public int getBatchSize() {
+				return orderList.size();
+			}
+		});
+
+		log.info("end miner batch update attr:{}", batchUpdate);
+	}
+
+	public void handleRecomProfit(String partyId, double profit, Miner miner, String miner_bonus_parameters) {
+		if (miner.getTest()) {
+			return;
+		}
+		List<UserRecom> list_parents = this.userRecomService.getParents(partyId);
+		if (list_parents.size() == 0) {
+			return;
+		}
+		String[] miner_bonus_array = miner_bonus_parameters.split(",");
+		int loop = 0;
+		int loopMax = miner_bonus_array.length;
+		for (int i = 0; i < list_parents.size(); i++) {
+			if (loop >= loopMax) {
+				break;
+			}
+			Party party_parent = this.partyService.cachePartyBy(list_parents.get(i).getReco_id(), true);
+			if (!Constants.SECURITY_ROLE_MEMBER.equals(party_parent.getRolename())) {
+				continue;
+			}
+			loop++;
+			Map<String, MinerOrder> map_party = (Map<String, MinerOrder>) redisHandler
+					.get(MinerRedisKeys.MINER_ORDER_PARTY_ID + party_parent.getId().toString());
+			if (map_party == null || map_party.size() == 0) {
+				continue;
+			}
+			/*
+			 * 判断是否
+			 */
+			int cycle = 0;
+			Iterator<Entry<String, MinerOrder>> it = map_party.entrySet().iterator();
+			while (it.hasNext()) {
+				Entry<String, MinerOrder> entry = it.next();
+				MinerOrder minerOrder = entry.getValue();
+				if (!"1".equals(minerOrder.getState())) {
+					continue;
+				}
+				Miner miner_party = this.minerService.cacheById(minerOrder.getMinerId());
+				if (cycle < miner_party.getCycle()) {
+					cycle = miner_party.getCycle();
+				}
+
+			}
+
+			if (cycle >= miner.getCycle()) {
+				/**
+				 * 增加收益
+				 */
+				double pip_amount = Double.valueOf(miner_bonus_array[loop - 1]);
+				double get_money = Arith.mul(profit, pip_amount);
+
+				Double recom_profit = cacheRecomProfit.get(party_parent.getId().toString());
+				cacheRecomProfit.put(party_parent.getId().toString(),
+						Arith.add(recom_profit == null ? 0D : recom_profit, get_money));
+
+			}
+
+		}
+
+	}
+
+	/**
+	 * 最终收益持久化数据库
+	 */
+	public void saveRecomProfit() {
+		if (cacheRecomProfit.isEmpty())
+			return;
+
+		// 开始增加推荐人收益
+		log.info("start ------recom user miner profit,date:{},count:{}",
+				new Object[] { new Date(), cacheRecomProfit.size() });
+		for (Entry<String, Double> entry : cacheRecomProfit.entrySet()) {
+			Wallet wallet = walletService.saveWalletByPartyId(entry.getKey());
+			double amount_before = wallet.getMoney();
+//			wallet.setMoney(Arith.add(wallet.getMoney(), entry.getValue()));
+			walletService.update(wallet.getPartyId().toString(), entry.getValue());
+
+			/**
+			 * 保存资金日志
+			 */
+			MoneyLog moneyLog = new MoneyLog();
+			moneyLog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
+			moneyLog.setAmount_before(amount_before);
+			moneyLog.setAmount(entry.getValue());
+			moneyLog.setAmount_after(Arith.add(amount_before, entry.getValue()));
+			moneyLog.setLog("矿机推荐奖励金");
+			moneyLog.setPartyId(entry.getKey());
+			moneyLog.setWallettype(Constants.WALLET);
+			moneyLog.setContent_type(Constants.MONEYLOG_CONTENT_MINER_RECOM_PROFIT);
+			moneyLogService.save(moneyLog);
+			userDataService.saveMinerProfit(entry.getKey(), entry.getValue());
+		}
+		// 推荐人矿机收益计算完成，纪录日志
+		log.info("finish ------recom user miner profit,date:{},count:{}",
+				new Object[] { new Date(), cacheRecomProfit.size() });
+		// 处理完后收益清空
+
+	}
+
+	/**
+	 * 最终收益持久化数据库
+	 */
+	public void saveRecomProfit(Date systemTime) {
+		if (cacheRecomProfit.isEmpty())
+			return;
+
+		// 开始增加推荐人收益
+		log.info("start ------recom user miner profit,date:{},count:{}",
+				new Object[] { new Date(), cacheRecomProfit.size() });
+		for (Entry<String, Double> entry : cacheRecomProfit.entrySet()) {
+			Wallet wallet = walletService.saveWalletByPartyId(entry.getKey());
+			double amount_before = wallet.getMoney();
+//			wallet.setMoney(Arith.add(wallet.getMoney(), entry.getValue()));
+			walletService.update(wallet.getPartyId().toString(), entry.getValue());
+
+			/**
+			 * 保存资金日志
+			 */
+			MoneyLog moneyLog = new MoneyLog();
+			moneyLog.setCategory(Constants.MONEYLOG_CATEGORY_MINER);
+			moneyLog.setAmount_before(amount_before);
+			moneyLog.setAmount(entry.getValue());
+			moneyLog.setAmount_after(Arith.add(amount_before, entry.getValue()));
+			moneyLog.setLog("矿机推荐奖励金");
+			moneyLog.setPartyId(entry.getKey());
+			moneyLog.setWallettype(Constants.WALLET);
+			moneyLog.setContent_type(Constants.MONEYLOG_CONTENT_MINER_RECOM_PROFIT);
+			moneyLog.setCreateTime(systemTime);
+			moneyLogService.save(moneyLog);
+			userDataService.saveMinerProfit(entry.getKey(), entry.getValue());
+		}
+		// 推荐人矿机收益计算完成，纪录日志
+		log.info("finish ------recom user miner profit,date:{},count:{}",
+				new Object[] { new Date(), cacheRecomProfit.size() });
+		// 处理完后收益清空
+
+	}
+
+	public void cacheRecomProfitClear() {
+		cacheRecomProfit.clear();
+	}
+
+	public void setPagedDao(PagedQueryDao pagedDao) {
+		this.pagedDao = pagedDao;
+	}
+
+	public void setMinerService(MinerService minerService) {
+		this.minerService = minerService;
+	}
+
+	public void setPartyService(PartyService partyService) {
+		this.partyService = partyService;
+	}
+
+	public void setUserRecomService(UserRecomService userRecomService) {
+		this.userRecomService = userRecomService;
+	}
+
+	public void setRedisHandler(RedisHandler redisHandler) {
+		this.redisHandler = redisHandler;
+	}
+
+	public void setUserDataService(UserDataService userDataService) {
+		this.userDataService = userDataService;
+	}
+
+	public void setMoneyLogService(MoneyLogService moneyLogService) {
+		this.moneyLogService = moneyLogService;
+	}
+
+	public void setMinerOrderService(MinerOrderService minerOrderService) {
+		this.minerOrderService = minerOrderService;
+	}
+
+	public void setWalletService(WalletService walletService) {
+		this.walletService = walletService;
+	}
+
+	public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
+		this.jdbcTemplate = jdbcTemplate;
+	}
+
+	public void setSysparaService(SysparaService sysparaService) {
+		this.sysparaService = sysparaService;
+	}
+
+	public void setDataService(DataService dataService) {
+		this.dataService = dataService;
+	}
+
+}

comm/Miner/src/project/miner/model/Miner.hbm.xml

@@ -0,0 +1,93 @@
+<?xml version="1.0"?>
+<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
+                                   "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
+<hibernate-mapping>
+	<class name="project.miner.model.Miner" table="T_MINER">
+	<id name="id" type="java.lang.String">
+			<column name="UUID" />
+			<generator class="uuid.hex" />
+		</id>
+		
+		<property name="name" type="java.lang.String">
+			<column name="NAME" />
+		</property>
+				<property name="name_en" type="java.lang.String">
+			<column name="NAME_EN" />
+		</property>
+				<property name="name_cn" type="java.lang.String">
+			<column name="NAME_CN" />
+		</property>
+		
+		<property name="cycle" type="java.lang.Integer">
+			<column name="CYCLE" />
+		</property>
+		<property name="cycle_close" type="java.lang.Integer">
+			<column name="CYCLE_CLOSE" />
+		</property>
+		<property name="daily_rate" type="double">
+			<column name="DAILY_RATE" />
+		</property>
+		<property name="show_daily_rate" type="double">
+			<column name="SHOW_DAILY_RATE" />
+		</property>
+
+		<property name="investment_min" type="double">
+			<column name="INVESTMENT_MIN" />
+		</property>	
+		<property name="investment_max" type="double">
+			<column name="INVESTMENT_MAX" />
+		</property>	
+			
+		<property name="state" type="java.lang.String">
+			<column name="STATE" />
+		</property>
+		<property name="on_sale" type="java.lang.String">
+			<column name="ON_SALE" />
+		</property>
+		<property name="test" type="yes_no">
+			<column name="TEST" />
+		</property>
+	
+	
+		<property name="algorithm" type="java.lang.String">
+			<column name="ALGORITHM" />
+		</property>
+		
+		<property name="computing_power" type="double">
+			<column name="COMPUTING_POWER" />
+		</property>
+		<property name="computing_power_unit" type="java.lang.String">
+			<column name="COMPUTING_POWER_UNIT" />
+		</property>
+		<property name="power" type="double">
+			<column name="POWER" />
+		</property>
+		<property name="product_factory" type="java.lang.String">
+			<column name="PRODUCT_FACTORY" />
+		</property>
+		<property name="product_size" type="java.lang.String">
+			<column name="PRODUCT_SIZE" />
+		</property>
+		<property name="weight" type="double">
+			<column name="WEIGHT" />
+		</property>
+		<property name="work_temperature_min" type="double">
+			<column name="WORK_TEMPERATURE_MIN" />
+		</property>
+		<property name="work_temperature_max" type="double">
+			<column name="WORK_TEMPERATURE_MAX" />
+		</property>
+		<property name="work_humidity_min" type="double">
+			<column name="WORK_HUMIDITY_MIN" />
+		</property>
+		<property name="work_humidity_max" type="double">
+			<column name="WORK_HUMIDITY_MAX" />
+		</property>
+		<property name="internet" type="java.lang.String">
+			<column name="INTERNET" />
+		</property>
+		<property name="base_compute_amount" type="double">
+			<column name="BASE_COMPUTE_AMOUNT" />
+		</property>	
+	</class>
+</hibernate-mapping>

comm/Miner/src/project/miner/model/Miner.java

@@ -0,0 +1,326 @@
+package project.miner.model;
+
+import java.util.Comparator;
+
+import kernel.bo.EntityObject;
+
+/**
+ * 矿机
+ *
+ */
+public class Miner extends EntityObject implements Comparator<Miner> {
+
+	private static final long serialVersionUID = 1639941028310043811L;
+
+	/**
+	 * 矿机名称(简体中文)
+	 */
+	private String name;
+
+	/**
+	 * 矿机名称(英文)
+	 */
+	private String name_en;
+	/**
+	 * 矿机名称(繁体)
+	 */
+	private String name_cn;
+
+	/**
+	 * 周期-天数(现做矿机等级判定)
+	 */
+	private int cycle;
+	/**
+	 * ----可解锁周期-- 截止后方可解锁 CYCLE_CLOSE
+	 */
+	private int cycle_close;
+
+	/**
+	 * 日利率(%)
+	 */
+	private double daily_rate;
+	/**
+	 * 展示日利率(%)
+	 */
+	private double show_daily_rate;
+
+	/**
+	 * 最低投资金额(USDT)
+	 */
+	private double investment_min;
+	/**
+	 * 最高投资金额(USDT)
+	 */
+	private double investment_max;
+
+	/**
+	 * 上下架。0 下架， 1 上架,
+	 */
+	private String state = "0";
+	/**
+	 * 是否自主购买 0需管理员手动增加，1可自行购买
+	 */
+	private String on_sale = "0";
+	/**
+	 * ---是否是体验产品
+	 */
+	private boolean test = false;
+
+	/**
+	 * 适用算法
+	 */
+	private String algorithm;
+	/**
+	 * 算力
+	 */
+	private double computing_power;
+	/**
+	 * 算力单位
+	 */
+	private String computing_power_unit;
+	/**
+	 * 功耗
+	 */
+	private double power;
+	/**
+	 * 生产厂家
+	 */
+	private String product_factory;
+	/**
+	 * 外箱尺寸
+	 */
+	private String product_size;
+	/**
+	 * 整机重量
+	 */
+	private double weight;
+	/**
+	 * 工作温度区间（最小值）
+	 */
+	private double work_temperature_min;
+	/**
+	 * 工作温度区间（最大值）
+	 */
+	private double work_temperature_max;
+	/**
+	 * 工作湿度区间（最小值）
+	 */
+	private double work_humidity_min;
+	/**
+	 * 工作湿度区间（最大值）
+	 */
+	private double work_humidity_max;
+	/**
+	 * 网络连接
+	 */
+	private String internet;
+	/**
+	 * 基础计息金额
+	 */
+	private double base_compute_amount;
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public int getCycle() {
+		return cycle;
+	}
+
+	public void setCycle(int cycle) {
+		this.cycle = cycle;
+	}
+
+	public double getDaily_rate() {
+		return daily_rate;
+	}
+
+	public void setDaily_rate(double daily_rate) {
+		this.daily_rate = daily_rate;
+	}
+
+	public double getInvestment_min() {
+		return investment_min;
+	}
+
+	public void setInvestment_min(double investment_min) {
+		this.investment_min = investment_min;
+	}
+
+	public String getState() {
+		return state;
+	}
+
+	public void setState(String state) {
+		this.state = state;
+	}
+
+	public String getName_en() {
+		return name_en;
+	}
+
+	public void setName_en(String name_en) {
+		this.name_en = name_en;
+	}
+
+	public String getName_cn() {
+		return name_cn;
+	}
+
+	public void setName_cn(String name_cn) {
+		this.name_cn = name_cn;
+	}
+
+	public boolean getTest() {
+		return test;
+	}
+
+	public void setTest(boolean test) {
+		this.test = test;
+	}
+
+	public String getOn_sale() {
+		return on_sale;
+	}
+
+	public void setOn_sale(String on_sale) {
+		this.on_sale = on_sale;
+	}
+
+	public double getInvestment_max() {
+		return investment_max;
+	}
+
+	public void setInvestment_max(double investment_max) {
+		this.investment_max = investment_max;
+	}
+
+	public double getShow_daily_rate() {
+		return show_daily_rate;
+	}
+
+	public void setShow_daily_rate(double show_daily_rate) {
+		this.show_daily_rate = show_daily_rate;
+	}
+
+	public int compare(Miner o1, Miner o2) {
+		return o1.getInvestment_min() < o2.getInvestment_min() ? -1 : 1;
+	}
+
+	public int getCycle_close() {
+		return cycle_close;
+	}
+
+	public void setCycle_close(int cycle_close) {
+		this.cycle_close = cycle_close;
+	}
+
+	public String getAlgorithm() {
+		return algorithm;
+	}
+
+	public double getPower() {
+		return power;
+	}
+
+	public String getProduct_factory() {
+		return product_factory;
+	}
+
+	public String getProduct_size() {
+		return product_size;
+	}
+
+	public double getWeight() {
+		return weight;
+	}
+
+	public String getInternet() {
+		return internet;
+	}
+
+	public void setAlgorithm(String algorithm) {
+		this.algorithm = algorithm;
+	}
+
+	public void setPower(double power) {
+		this.power = power;
+	}
+
+	public void setProduct_factory(String product_factory) {
+		this.product_factory = product_factory;
+	}
+
+	public void setProduct_size(String product_size) {
+		this.product_size = product_size;
+	}
+
+	public void setWeight(double weight) {
+		this.weight = weight;
+	}
+
+	public void setInternet(String internet) {
+		this.internet = internet;
+	}
+
+	public double getWork_temperature_min() {
+		return work_temperature_min;
+	}
+
+	public double getWork_temperature_max() {
+		return work_temperature_max;
+	}
+
+	public double getWork_humidity_min() {
+		return work_humidity_min;
+	}
+
+	public double getWork_humidity_max() {
+		return work_humidity_max;
+	}
+
+	public void setWork_temperature_min(double work_temperature_min) {
+		this.work_temperature_min = work_temperature_min;
+	}
+
+	public void setWork_temperature_max(double work_temperature_max) {
+		this.work_temperature_max = work_temperature_max;
+	}
+
+	public void setWork_humidity_min(double work_humidity_min) {
+		this.work_humidity_min = work_humidity_min;
+	}
+
+	public void setWork_humidity_max(double work_humidity_max) {
+		this.work_humidity_max = work_humidity_max;
+	}
+
+	public double getComputing_power() {
+		return computing_power;
+	}
+
+	public String getComputing_power_unit() {
+		return computing_power_unit;
+	}
+
+	public void setComputing_power(double computing_power) {
+		this.computing_power = computing_power;
+	}
+
+	public void setComputing_power_unit(String computing_power_unit) {
+		this.computing_power_unit = computing_power_unit;
+	}
+
+	public double getBase_compute_amount() {
+		return base_compute_amount;
+	}
+
+	public void setBase_compute_amount(double base_compute_amount) {
+		this.base_compute_amount = base_compute_amount;
+	}
+
+}

comm/Miner/src/project/miner/model/MinerOrder.hbm.xml

@@ -0,0 +1,53 @@
+<?xml version="1.0"?>
+<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
+                                   "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
+<hibernate-mapping>
+	<class name="project.miner.model.MinerOrder" table="T_MINER_ORDER">
+	<id name="id" type="java.lang.String">
+			<column name="UUID" />
+			<generator class="uuid.hex" />
+		</id>
+		<property name="partyId" type="java.lang.String">
+			<column name="PARTY_ID" />
+		</property>
+
+		<property name="order_no" type="java.lang.String">
+			<column name="ORDER_NO" />
+		</property>
+			<property name="minerId" type="java.lang.String">
+			<column name="MINER_ID" />
+		</property>
+
+		<property name="earn_time" type="timestamp">
+			<column name="EARN_TIME" />
+		</property>	
+		<property name="stop_time" type="timestamp">
+			<column name="STOP_TIME" />
+		</property>	
+		<property name="create_time" type="timestamp">
+			<column name="CREATE_TIME" />
+		</property>	
+		<property name="profit" type="double">
+			<column name="PROFIT" />
+		</property>	
+		<property name="amount" type="double">
+			<column name="AMOUNT" />
+		</property>	
+		<property name="compute_day" type="timestamp">
+			<column name="COMPUTE_DAY" />
+		</property>	
+		<property name="state" type="java.lang.String">
+			<column name="STATE" />
+		</property>
+		<property name="close_time" type="timestamp">
+			<column name="CLOSE_TIME" />
+		</property>	
+		<property name="first_buy" type="java.lang.String">
+			<column name="FIRST_BUY" />
+		</property>
+		<property name="base_compute_amount" type="double">
+			<column name="BASE_COMPUTE_AMOUNT" />
+		</property>	
+	
+	</class>
+</hibernate-mapping>

comm/Miner/src/project/miner/model/MinerOrder.java

@@ -0,0 +1,179 @@
+package project.miner.model;
+
+import java.io.Serializable;
+import java.util.Comparator;
+import java.util.Date;
+
+import kernel.bo.EntityObject;
+
+public class MinerOrder extends EntityObject implements Comparator<MinerOrder> {
+	private static final long serialVersionUID = -726057340004619294L;
+	private Serializable partyId;
+	/**
+	 * 订单 号
+	 */
+	private String order_no;
+
+	/**
+	 * 矿机产品Id
+	 */
+	private String minerId;
+
+	/**
+	 * 金额
+	 */
+	private double amount;
+
+	/**
+	 * 买入时间
+	 */
+	private Date create_time;
+
+	/**
+	 * 起息时间 从买入时间第二天开始算
+	 */
+	private Date earn_time;
+
+	/**
+	 * 截止时间
+	 */
+	private Date stop_time;
+
+	/**
+	 * 累计收益
+	 */
+	private double profit;
+
+	/**
+	 * 状态。0.正常赎回， 1 托管中 ,2提前赎回 (违约)3.取消
+	 */
+	private String state = "1";
+	/**
+	 * 上次结息日期纪录，（如遇服务中途停止，可根据该字段判定是否需要重新计算）
+	 */
+	private Date compute_day;
+	/**
+	 * 赎回时间
+	 */
+	private Date close_time;
+	/**
+	 * 是否首次购买： 1：首次购买，0不是首次
+	 */
+	private String first_buy;
+	/**
+	 * 基础计息金额
+	 */
+	private double base_compute_amount;
+
+	public Serializable getPartyId() {
+		return partyId;
+	}
+
+	public void setPartyId(Serializable partyId) {
+		this.partyId = partyId;
+	}
+
+	public String getOrder_no() {
+		return order_no;
+	}
+
+	public void setOrder_no(String order_no) {
+		this.order_no = order_no;
+	}
+
+	public double getAmount() {
+		return amount;
+	}
+
+	public void setAmount(double amount) {
+		this.amount = amount;
+	}
+
+	public Date getCreate_time() {
+		return create_time;
+	}
+
+	public void setCreate_time(Date create_time) {
+		this.create_time = create_time;
+	}
+
+	public double getProfit() {
+		return profit;
+	}
+
+	public void setProfit(double profit) {
+		this.profit = profit;
+	}
+
+	public Date getEarn_time() {
+		return earn_time;
+	}
+
+	public void setEarn_time(Date earn_time) {
+		this.earn_time = earn_time;
+	}
+
+	public Date getStop_time() {
+		return stop_time;
+	}
+
+	public void setStop_time(Date stop_time) {
+		this.stop_time = stop_time;
+	}
+
+	public String getMinerId() {
+		return minerId;
+	}
+
+	public void setMinerId(String minerId) {
+		this.minerId = minerId;
+	}
+
+	public String getState() {
+		return state;
+	}
+
+	public void setState(String state) {
+		this.state = state;
+	}
+
+	public Date getCompute_day() {
+		return compute_day;
+	}
+
+	public void setCompute_day(Date compute_day) {
+		this.compute_day = compute_day;
+	}
+
+	public Date getClose_time() {
+		return close_time;
+	}
+
+	public void setClose_time(Date close_time) {
+		this.close_time = close_time;
+	}
+
+	public String getFirst_buy() {
+		return first_buy;
+	}
+
+	public void setFirst_buy(String first_buy) {
+		this.first_buy = first_buy;
+	}
+
+	
+	public double getBase_compute_amount() {
+		return base_compute_amount;
+	}
+
+	public void setBase_compute_amount(double base_compute_amount) {
+		this.base_compute_amount = base_compute_amount;
+	}
+
+	@Override
+	public int compare(MinerOrder arg0, MinerOrder arg1) {
+		// TODO Auto-generated method stub
+		return -arg0.getCreate_time().compareTo(arg1.getCreate_time());
+	}
+
+}

comm/Miner/src/project/miner/model/MinerPara.hbm.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0"?>
+<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
+                                   "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
+<hibernate-mapping>
+	<class name="project.miner.model.MinerPara" table="T_MINER_PARA">
+	<id name="id" type="java.lang.String">
+			<column name="UUID" />
+			<generator class="uuid.hex" />
+		</id>
+		
+		<property name="cycle" type="java.lang.Integer">
+			<column name="CYCLE" />
+		</property>
+		
+		<property name="amount" type="double">
+			<column name="AMOUNT" />
+		</property>
+		
+		<property name="miner_id" type="java.lang.String">
+			<column name="MINER_ID" />
+		</property>
+	</class>
+</hibernate-mapping>

comm/Miner/src/project/miner/model/MinerPara.java

@@ -0,0 +1,59 @@
+package project.miner.model;
+
+
+import kernel.bo.EntityObject;
+
+/**
+ * 矿机配置参数
+ *
+ */
+public class MinerPara extends EntityObject {
+
+	private static final long serialVersionUID = 1639941028310043811L;
+
+	/**
+	 * 矿机id
+	 */
+	private String miner_id;
+	/**
+	 * 购买周期
+	 */
+	private int cycle;
+
+	/**
+	 * 购买价格
+	 */
+	private double amount;
+
+	public int getCycle() {
+		return cycle;
+	}
+
+	public double getAmount() {
+		return amount;
+	}
+
+	public void setCycle(int cycle) {
+		this.cycle = cycle;
+	}
+
+	public void setAmount(double amount) {
+		this.amount = amount;
+	}
+
+	public String getMiner_id() {
+		return miner_id;
+	}
+
+	public void setMiner_id(String miner_id) {
+		this.miner_id = miner_id;
+	}
+
+	
+	
+	
+
+
+	
+	
+}

comm/Miner/src/project/miner/web/AdminMinerParaAction.java

@@ -0,0 +1,156 @@
+package project.miner.web;
+
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import kernel.exception.BusinessException;
+import kernel.web.PageActionSupport;
+import project.miner.AdminMinerParaService;
+import project.miner.MinerParaService;
+import project.miner.MinerService;
+import project.miner.model.Miner;
+import project.miner.model.MinerPara;
+
+public class AdminMinerParaAction extends PageActionSupport  {
+	
+	private static Log logger = LogFactory.getLog(AdminMinerParaAction.class);
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -2606134812043922161L;
+
+	private AdminMinerParaService adminMinerParaService;
+	private MinerParaService minerParaService;
+	private MinerService minerService;
+	
+	/**
+	 * id
+	 */
+	private String id;
+	/**
+	 * 矿机id
+	 */
+	private String miner_id;
+	/**
+	 * 购买周期
+	 */
+	private int cycle;
+
+	/**
+	 * 购买价格
+	 */
+	private double amount;
+	
+	private String miner_name;
+	
+	public String list() {
+		
+		pageSize = 30;
+		Miner miner = minerService.findById(miner_id);
+		miner_name = miner.getName();
+		this.page = adminMinerParaService.pagedQuery(pageNo, pageSize, miner_id);
+		return "list";
+	}
+	public String toAdd() {
+		return "add";
+	}
+	public String toUpdate() {
+		MinerPara minerPara = minerParaService.findById(id);
+		try {
+			if(minerPara==null) {
+				throw new BusinessException("参数不存在，刷新重试");
+			}
+			miner_id = minerPara.getMiner_id();
+			cycle = minerPara.getCycle();
+			amount = minerPara.getAmount();
+			return "update";
+		} catch (BusinessException e) {
+			this.error = e.getMessage();
+			return list();
+		} catch (Throwable t) {
+			logger.error("update error ", t);
+			this.error = "程序错误";
+			return list();
+		}
+	}
+	
+	public String update() {
+		MinerPara minerPara = minerParaService.findById(id);
+		try {
+			minerPara.setCycle(cycle);
+			minerPara.setAmount(amount);
+			minerParaService.update(minerPara);
+			this.message = "操作成功";
+			return list();
+		} catch (BusinessException e) {
+			this.error = e.getMessage();
+			return toUpdate();
+		} catch (Throwable t) {
+			logger.error("update error ", t);
+			this.error = "程序错误";
+			return toUpdate();
+		}
+	}
+	public String add() {
+		try {
+			MinerPara minerPara  = new MinerPara();
+			minerPara.setCycle(cycle);
+			minerPara.setAmount(amount);
+			minerPara.setMiner_id(miner_id);
+			minerParaService.save(minerPara);
+			this.message = "操作成功";
+			return list();
+		} catch (BusinessException e) {
+			this.error = e.getMessage();
+			return toAdd();
+		} catch (Throwable t) {
+			logger.error("update error ", t);
+			this.error = "程序错误";
+			return toAdd();
+		}
+	}
+	
+	public String getMiner_id() {
+		return miner_id;
+	}
+	public int getCycle() {
+		return cycle;
+	}
+	public double getAmount() {
+		return amount;
+	}
+	public void setMiner_id(String miner_id) {
+		this.miner_id = miner_id;
+	}
+	public void setCycle(int cycle) {
+		this.cycle = cycle;
+	}
+	public void setAmount(double amount) {
+		this.amount = amount;
+	}
+	public void setAdminMinerParaService(AdminMinerParaService adminMinerParaService) {
+		this.adminMinerParaService = adminMinerParaService;
+	}
+	public void setMinerParaService(MinerParaService minerParaService) {
+		this.minerParaService = minerParaService;
+	}
+	public String getId() {
+		return id;
+	}
+	public void setId(String id) {
+		this.id = id;
+	}
+	public void setMinerService(MinerService minerService) {
+		this.minerService = minerService;
+	}
+	public String getMiner_name() {
+		return miner_name;
+	}
+	public void setMiner_name(String miner_name) {
+		this.miner_name = miner_name;
+	}
+	
+	
+	
+}

comm/Miner/src/project/web/admin/AdminMinerController.java

@@ -0,0 +1,537 @@
+package project.web.admin;
+
+import java.util.List;
+import java.util.Map;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.providers.encoding.PasswordEncoder;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.servlet.ModelAndView;
+
+import kernel.exception.BusinessException;
+import kernel.util.StringUtils;
+import kernel.web.PageActionSupport;
+import project.Constants;
+import project.log.LogService;
+import project.miner.AdminMinerService;
+import project.miner.MinerService;
+import project.miner.model.Miner;
+import project.party.PartyService;
+import security.SecUser;
+import security.internal.SecUserService;
+
+/**
+ * 矿机配置
+ */
+@RestController
+public class AdminMinerController extends PageActionSupport {
+
+	private Logger logger = LogManager.getLogger(AdminMinerController.class);
+
+	@Autowired
+	protected AdminMinerService adminMinerService;
+	@Autowired
+	protected MinerService minerService;
+	@Autowired
+	protected PartyService partyService;
+	@Autowired
+	protected LogService logService;
+	@Autowired
+	protected SecUserService secUserService;
+	@Autowired
+	protected PasswordEncoder passwordEncoder;
+	
+	private final String action = "normal/adminMinerAction!";
+	
+	/**
+	 * 获取 矿机配置 列表
+	 */
+	@RequestMapping(action + "list.action")
+	public ModelAndView list(HttpServletRequest request) {
+		this.checkAndSetPageNo(request.getParameter("pageNo"));
+		String name_para = request.getParameter("name_para");
+		String message = request.getParameter("message");
+		String error = request.getParameter("error");
+		this.page = this.adminMinerService.pagedQuery(this.pageNo, 300, name_para);
+		for(Map<String,Object> data:(List<Map<String,Object>>) (page.getElements())) {
+			if("N".equals(data.get("test"))) {
+				data.put("cycle", null);
+			}
+		}
+		ModelAndView model = new ModelAndView();
+		model.addObject("pageNo", this.pageNo);
+		model.addObject("pageSize", this.pageSize);
+		model.addObject("page", this.page);
+		model.addObject("name_para", name_para);
+		model.addObject("message", message);
+		model.addObject("error", error);
+		model.setViewName("miner_list");
+		return model;
+	}
+
+	public String toAdd() {
+		return "add";
+	}
+	
+	/**
+	 * 验证基础信息
+	 */
+	protected String verifBase(String algorithm, String computing_power, String power, String product_factory,
+			String product_size, String weight, String work_temperature_min, String work_temperature_max, String work_humidity_min,
+			String work_humidity_max, String internet) {
+		if (StringUtils.isEmptyString(algorithm)) {
+			return "请选择适用算法";
+		}
+			
+		if (StringUtils.isNullOrEmpty(computing_power) 
+				|| !StringUtils.isDouble(computing_power)
+				|| Double.valueOf(computing_power) < 0) {
+			return "额定算力不能小于0";
+		}
+		
+		if (StringUtils.isNullOrEmpty(power) 
+				|| !StringUtils.isDouble(power)
+				|| Double.valueOf(power) < 0) {
+			return "功耗不能小于0";
+		}
+		
+		if (StringUtils.isNullOrEmpty(product_factory)) {
+			return "请输入生产厂家";
+		}
+			
+		if (StringUtils.isNullOrEmpty(product_size)) {
+			return "请输入外箱尺寸";
+		}
+		
+		if (StringUtils.isNullOrEmpty(weight) 
+				|| !StringUtils.isDouble(weight)
+				|| Double.valueOf(weight) < 0) {
+			return "整机重量不能小于0";
+		}
+		
+		if (StringUtils.isNullOrEmpty(work_temperature_min) 
+				|| !StringUtils.isDouble(work_temperature_min)) {
+			return "工作温度区间最小值错误";
+		}
+		
+		if (StringUtils.isNullOrEmpty(work_temperature_max) 
+				|| !StringUtils.isDouble(work_temperature_max)
+				|| Double.valueOf(work_temperature_max) == 0) {
+			return "工作温度区间最大值错误";
+		}
+		
+		if (Double.valueOf(work_temperature_max) <= Double.valueOf(work_temperature_min)) {
+			return "工作温度区间错误";
+		}
+		
+		if (StringUtils.isNullOrEmpty(work_humidity_min) 
+				|| !StringUtils.isDouble(work_humidity_min)
+				|| Double.valueOf(work_humidity_min) < 0) {
+			return "工作湿度区间不能小于0";
+		}
+		
+		if (StringUtils.isNullOrEmpty(work_humidity_max) 
+				|| !StringUtils.isDouble(work_humidity_max)
+				|| Double.valueOf(work_humidity_max) == 0) {
+			return "工作温度区间最大值错误";
+		}
+		
+		if (StringUtils.isNullOrEmpty(work_humidity_max) 
+				|| !StringUtils.isDouble(work_humidity_max)
+				|| Double.valueOf(work_humidity_max) == 0) {
+			return "工作温度区间最大值错误";
+		}
+		
+		if (Double.valueOf(work_humidity_max) <= Double.valueOf(work_humidity_min)) {
+			return "工作温度区间错误";
+		}
+		
+		if (StringUtils.isEmptyString(internet)) {
+			return "请选择网络连接";
+		}
+			
+		return null;
+	}
+	protected String verification(String name, String show_daily_rate, String daily_rate, String cycle_close, String investment_min, String investment_max,
+			String algorithm, String computing_power, String power, String product_factory,
+			String product_size, String weight, String work_temperature_min, String work_temperature_max, String work_humidity_min,
+			String work_humidity_max, String internet) {
+		
+		String verifBase = verifBase(algorithm, computing_power, power, product_factory,
+				product_size, weight, work_temperature_min, work_temperature_max, work_humidity_min,
+				work_humidity_max, internet);
+		
+		if(StringUtils.isNotEmpty(verifBase)) {
+			return verifBase;
+		}
+		if (StringUtils.isEmptyString(name)) {
+			return "请输入产品名称";
+		}
+			
+//		if (StringUtils.isEmptyString(this.img))
+//			return "请上传产品图片";
+//		if (this.cycle <= 0) {
+//			return "周期不能小于等于0天";
+//		}
+//		if (this.daily_rate < 0.0D) {
+//			return "日利率不能小于0";
+//		}
+		
+		if (StringUtils.isNullOrEmpty(show_daily_rate) 
+				|| !StringUtils.isDouble(show_daily_rate) 
+				|| Double.valueOf(show_daily_rate) < 0) {
+			return "日利率不能小于0";
+		}
+		
+		if (StringUtils.isNullOrEmpty(daily_rate) 
+				|| !StringUtils.isDouble(daily_rate) 
+				|| Double.valueOf(daily_rate) < 0) {
+			return "今日利率不能小于0";
+		}
+
+		if (StringUtils.isNullOrEmpty(cycle_close) 
+				|| !StringUtils.isDouble(cycle_close) 
+				|| Double.valueOf(cycle_close) < 0) {
+			return "解锁周期不能小于0";
+		}
+		
+		if (StringUtils.isNullOrEmpty(investment_min) 
+				|| !StringUtils.isDouble(investment_min) 
+				|| Double.valueOf(investment_min) < 0) {
+			return "投资金额区间最小值不能小于0";
+		}
+		
+		if (StringUtils.isNullOrEmpty(investment_max) 
+				|| !StringUtils.isDouble(investment_max) 
+				|| Double.valueOf(investment_max) < 0) {
+			return "投资金额区间最大值不能小于0";
+		}
+		
+		// max=0表示没有设置上限
+		if (Double.valueOf(investment_max) < Double.valueOf(investment_min)) {
+			return "投资金额区间错误";
+		}
+		return null;
+	}
+
+//	public String add() {
+//		try {
+//			this.error = verification();
+//			if (!StringUtils.isNullOrEmpty(this.error))
+//				return toAdd();
+////      if (this.minerService.findByName(this.name) != null) {
+////    	  this.error ="产品名称已存在";
+////    	  return toAdd(); 
+////		}
+//			Miner miner = new Miner();
+//			miner.setName(this.name);
+//			miner.setName_en(this.name_en);
+//			miner.setName_cn(this.name_cn);
+////			miner.setImg(this.img);
+////			miner.setCycle(this.cycle);
+//			miner.setCycle_close(this.cycle_close);
+//			miner.setDaily_rate(this.daily_rate);
+//			miner.setShow_daily_rate(this.show_daily_rate);
+//			miner.setInvestment_min(this.investment_min);
+//			miner.setInvestment_max(this.investment_max);
+//			miner.setState("1");
+//			miner.setTest(false);
+//			miner.setOn_sale(this.on_sale);
+//			
+//			//基础参数
+//			miner.setAlgorithm(algorithm);
+//			miner.setComputing_power(computing_power);
+//			miner.setComputing_power_unit(computing_power_unit);
+//			miner.setPower(power);
+//			miner.setProduct_factory(product_factory);
+//			miner.setProduct_size(product_size);
+//			miner.setWeight(weight);
+//			miner.setWork_temperature_min(work_temperature_min);
+//			miner.setWork_temperature_max(work_temperature_max);
+//			miner.setWork_humidity_min(work_humidity_min);
+//			miner.setWork_humidity_max(work_humidity_max);
+//			miner.setInternet(internet);
+//
+//			this.minerService.save(miner);
+//			this.message = "操作成功";
+//		} catch (BusinessException e) {
+//			this.error = e.getMessage();
+//			return toAdd();
+//		} catch (Throwable t) {
+//			logger.error("UserAction.register error ", t);
+//			this.error = "[ERROR] " + t.getMessage();
+//			return toAdd();
+//		}
+//		return list();
+//	}
+
+	protected String verificationUpdate(String name, String show_daily_rate, String daily_rate, String cycle_close, String investment_min, String investment_max,
+			String algorithm, String computing_power, String power, String product_factory,
+			String product_size, String weight, String work_temperature_min, String work_temperature_max, String work_humidity_min,
+			String work_humidity_max, String internet) {
+		String verifBase = verifBase(algorithm, computing_power, power, product_factory,
+				product_size, weight, work_temperature_min, work_temperature_max, work_humidity_min,
+				work_humidity_max, internet);
+		if(StringUtils.isNotEmpty(verifBase)) {
+			return verifBase;
+		}
+		if (StringUtils.isEmptyString(name))
+			return "请输入产品名称";
+//		if (StringUtils.isEmptyString(this.img))
+//			return "请上传产品图片";
+//		if (this.cycle <= 0) {
+//			return "周期不能小于等于0天";
+//		}
+		if (StringUtils.isNullOrEmpty(show_daily_rate) 
+				|| !StringUtils.isDouble(show_daily_rate) 
+				|| Double.valueOf(show_daily_rate) < 0) {
+			return "日利率不能小于0";
+		}
+		
+		if (StringUtils.isNullOrEmpty(daily_rate) 
+				|| !StringUtils.isDouble(daily_rate) 
+				|| Double.valueOf(daily_rate) < 0) {
+			return "今日利率不能小于0";
+		}
+
+		if (StringUtils.isNullOrEmpty(cycle_close) 
+				|| !StringUtils.isDouble(cycle_close) 
+				|| Double.valueOf(cycle_close) < 0) {
+			return "解锁周期不能小于0";
+		}
+		
+		if (StringUtils.isNullOrEmpty(investment_min) 
+				|| !StringUtils.isDouble(investment_min) 
+				|| Double.valueOf(investment_min) < 0) {
+			return "投资金额区间最小值不能小于0";
+		}
+		
+		if (StringUtils.isNullOrEmpty(investment_max) 
+				|| !StringUtils.isDouble(investment_max) 
+				|| Double.valueOf(investment_max) < 0) {
+			return "投资金额区间最大值不能小于0";
+		}
+		
+		// max=0表示没有设置上限
+		if (Double.valueOf(investment_max) < Double.valueOf(investment_min)) {
+			return "投资金额区间错误";
+		}
+
+		return null;
+	}
+
+	@RequestMapping(action + "toUpdate.action")
+	public ModelAndView toUpdate(HttpServletRequest request) {
+		String id = request.getParameter("id");
+		Miner miner = this.minerService.findById(id);
+		String name = miner.getName();
+		String name_en = miner.getName_en();
+		String name_cn = miner.getName_cn();
+//		this.img = miner.getImg();
+//		this.cycle = miner.getCycle();
+		int cycle_close = miner.getCycle_close();
+		double daily_rate = miner.getDaily_rate();
+		double investment_min = miner.getInvestment_min();
+		double investment_max = !miner.getTest() && miner.getInvestment_max() == 0 ? null : miner.getInvestment_max();
+		double show_daily_rate = miner.getShow_daily_rate();
+//		this.state = miner.getState();
+		String test = miner.getTest() ? "Y" : "N";
+		String on_sale = miner.getOn_sale();
+		
+		//基础参数
+		String algorithm = miner.getAlgorithm();
+		double computing_power = miner.getComputing_power();
+		String computing_power_unit = miner.getComputing_power_unit();
+		double power = miner.getPower();
+		String product_factory = miner.getProduct_factory();
+		String product_size = miner.getProduct_size();
+		double weight = miner.getWeight();
+		double work_temperature_min = miner.getWork_temperature_min();
+		double work_temperature_max = miner.getWork_temperature_max();
+		double work_humidity_min = miner.getWork_humidity_min();
+		double work_humidity_max = miner.getWork_humidity_max();
+		String internet = miner.getInternet();
+		
+		ModelAndView model = new ModelAndView();
+		model.addObject("id", id);
+		model.addObject("name", name);
+		model.addObject("name_en", name_en);
+		model.addObject("name_cn", name_cn);
+		model.addObject("cycle_close", cycle_close);
+		model.addObject("daily_rate", daily_rate);
+		model.addObject("investment_min", investment_min);
+		model.addObject("investment_max", investment_max);
+		model.addObject("show_daily_rate", show_daily_rate);
+		model.addObject("test", test);
+		model.addObject("on_sale", on_sale);
+		model.addObject("algorithm", algorithm);
+		model.addObject("computing_power", computing_power);
+		model.addObject("computing_power_unit", computing_power_unit);
+		model.addObject("power", power);
+		model.addObject("product_factory", product_factory);
+		model.addObject("product_size", product_size);
+		model.addObject("weight", weight);
+		model.addObject("work_temperature_min", work_temperature_min);
+		model.addObject("work_temperature_max", work_temperature_max);
+		model.addObject("work_humidity_min", work_humidity_min);
+		model.addObject("work_humidity_max", work_humidity_max);
+		model.addObject("internet", internet);
+		model.setViewName("miner_update");
+		return model;
+	}
+
+	@RequestMapping(action + "update.action")
+	public ModelAndView update(HttpServletRequest request) {
+
+		String error = "";
+		String id = request.getParameter("id");
+		String name = request.getParameter("name");
+		String show_daily_rate = request.getParameter("show_daily_rate"); 
+		String daily_rate = request.getParameter("daily_rate");
+		String cycle_close = request.getParameter("cycle_close");
+		String investment_min = request.getParameter("investment_min");
+		String investment_max = request.getParameter("investment_max");
+		String algorithm = request.getParameter("algorithm");
+		String computing_power = request.getParameter("computing_power");
+		String power = request.getParameter("power");
+		String product_factory = request.getParameter("product_factory");
+		String product_size = request.getParameter("product_size");
+		String weight = request.getParameter("weight");
+		String work_temperature_min = request.getParameter("work_temperature_min");
+		String work_temperature_max = request.getParameter("work_temperature_max");
+		String work_humidity_min = request.getParameter("work_humidity_min");
+		String work_humidity_max = request.getParameter("work_humidity_max");
+		String internet = request.getParameter("internet");
+		
+		String name_en = request.getParameter("name_en");
+		String name_cn = request.getParameter("name_cn");
+		String test = request.getParameter("test");
+		String on_sale = request.getParameter("on_sale");
+		String login_safeword = request.getParameter("login_safeword");
+		String computing_power_unit = request.getParameter("computing_power_unit");
+		
+		ModelAndView model = new ModelAndView();
+		model.addObject("id", id);
+		model.addObject("name", name);
+		model.addObject("name_en", name_en);
+		model.addObject("name_cn", name_cn);
+		model.addObject("cycle_close", cycle_close);
+		model.addObject("daily_rate", daily_rate);
+		model.addObject("investment_min", investment_min);
+		model.addObject("investment_max", investment_max);
+		model.addObject("show_daily_rate", show_daily_rate);
+		model.addObject("test", test);
+		model.addObject("on_sale", on_sale);
+		model.addObject("algorithm", algorithm);
+		model.addObject("computing_power", computing_power);
+		model.addObject("computing_power_unit", computing_power_unit);
+		model.addObject("power", power);
+		model.addObject("product_factory", product_factory);
+		model.addObject("product_size", product_size);
+		model.addObject("weight", weight);
+		model.addObject("work_temperature_min", work_temperature_min);
+		model.addObject("work_temperature_max", work_temperature_max);
+		model.addObject("work_humidity_min", work_humidity_min);
+		model.addObject("work_humidity_max", work_humidity_max);
+		model.addObject("internet", internet);
+		
+		Miner miner = this.minerService.findById(id);
+		try {
+			error = verificationUpdate(name, show_daily_rate, daily_rate, cycle_close, investment_min, investment_max,
+					algorithm, computing_power, power, product_factory,
+					product_size, weight, work_temperature_min, work_temperature_max, work_humidity_min,
+					work_humidity_max, internet);
+			if (!StringUtils.isNullOrEmpty(error)) {
+				model.addObject("error", error);
+				model.setViewName("miner_update");
+				return model;
+			}
+			
+			SecUser sec = this.secUserService.findUserByLoginName(this.getUsername_login());
+			checkLoginSafeword(sec,this.getUsername_login(), login_safeword);
+			
+			miner.setName(name);
+			miner.setName_en(name_en);
+			miner.setName_cn(name_cn);
+//			miner.setCycle(this.cycle);
+			miner.setDaily_rate(Double.valueOf(daily_rate));
+			miner.setInvestment_min(Double.valueOf(investment_min));
+			miner.setInvestment_max(investment_max == null ? 0 : Double.valueOf(investment_max));
+			miner.setOn_sale(on_sale);
+			miner.setShow_daily_rate(Double.valueOf(show_daily_rate));
+//			miner.setState(this.state);
+			
+			//基础参数
+			miner.setAlgorithm(algorithm);
+			miner.setComputing_power(Double.valueOf(computing_power));
+			miner.setComputing_power_unit(computing_power_unit);
+			miner.setPower(Double.valueOf(power));
+			miner.setProduct_factory(product_factory);
+			miner.setProduct_size(product_size);
+			miner.setWeight(Double.valueOf(weight));
+			miner.setWork_temperature_min(Double.valueOf(work_temperature_min));
+			miner.setWork_temperature_max(Double.valueOf(work_temperature_max));
+			miner.setWork_humidity_min(Double.valueOf(work_humidity_min));
+			miner.setWork_humidity_max(Double.valueOf(work_humidity_max));
+			miner.setInternet(internet);
+			miner.setCycle_close(Integer.valueOf(cycle_close));
+			
+			this.minerService.update(miner);
+
+			project.log.Log log = new project.log.Log();
+			log.setCategory(Constants.LOG_CATEGORY_OPERATION);
+			log.setUsername(this.getUsername_login());
+			log.setOperator(this.getUsername_login());
+			log.setLog("管理员手动修改矿机配置,ip:["+this.getIp(getRequest())+"]");
+			logService.saveSync(log);
+
+			model.addObject("message", "操作成功");
+			model.setViewName("redirect:/" + action + "list.action");
+			return model;
+		} catch (BusinessException e) {
+			model.addObject("error", e.getMessage());
+			model.setViewName("miner_update");
+			return model;
+		} catch (Throwable t) {
+			logger.error("update error ", t);
+			model.addObject("error", "程序错误");
+			model.setViewName("miner_update");
+			return model;
+		}
+	}
+	
+	/**
+	 * 验证登录人资金密码
+	 * @param operatorUsername
+	 * @param loginSafeword
+	 */
+	protected void checkLoginSafeword(SecUser secUser,String operatorUsername,String loginSafeword) {
+//		SecUser sec = this.secUserService.findUserByLoginName(operatorUsername);
+		String sysSafeword = secUser.getSafeword();
+		String safeword_md5 = passwordEncoder.encodePassword(loginSafeword, operatorUsername);
+		if (!safeword_md5.equals(sysSafeword)) {
+			throw new BusinessException("登录人资金密码错误");
+		}
+	}
+
+//	public String toDelete() {
+//		try {
+//
+//			this.minerService.delete(this.id);
+//			this.message = "操作成功";
+//			return list();
+//		} catch (BusinessException e) {
+//			this.error = e.getMessage();
+//			return list();
+//		} catch (Throwable t) {
+//			logger.error("update error ", t);
+//			this.error = "程序错误";
+//			return list();
+//		}
+//	}
+}

comm/Miner/src/project/web/admin/AdminMinerOrderController.java

@@ -0,0 +1,386 @@
+package project.web.admin;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.servlet.ModelAndView;
+
+import kernel.exception.BusinessException;
+import kernel.util.Arith;
+import kernel.util.DateUtils;
+import kernel.util.StringUtils;
+import kernel.util.ThreadUtils;
+import kernel.web.PageActionSupport;
+import project.miner.AdminMinerOrderService;
+import project.miner.MinerOrderService;
+import project.miner.MinerService;
+import project.miner.job.MinerOrderProfitJob;
+import project.miner.model.Miner;
+import project.miner.model.MinerOrder;
+
+/**
+ * 管理后台-矿机订单页面
+ *
+ */
+@RestController
+public class AdminMinerOrderController extends PageActionSupport {
+
+	private Logger logger = LogManager.getLogger(AdminMinerOrderController.class);
+	
+	@Autowired
+	protected AdminMinerOrderService adminMinerOrderService;
+	@Autowired
+	protected MinerOrderService minerOrderService;
+	@Autowired
+	protected MinerService minerService;
+	@Autowired
+	protected MinerOrderProfitJob minerOrderProfitJob;
+	
+	protected Map<String, Object> session = new HashMap<>();
+	
+	private final String action = "normal/adminMinerOrderAction!";
+	
+	@RequestMapping(action + "list.action")
+	public ModelAndView list(HttpServletRequest request) {
+
+		this.checkAndSetPageNo(request.getParameter("pageNo"));
+		String name_para = request.getParameter("name_para");
+		String miner_para = request.getParameter("miner_para");
+		String status_para = request.getParameter("status_para");
+		String order_no_para = request.getParameter("order_no_para");
+		String rolename_para = request.getParameter("rolename_para");
+		
+		String partyId = getLoginPartyId();
+		List<Miner> findAll = this.minerService.findAll();
+		Map<String, String> miner_name_map = new LinkedHashMap<String, String>();
+		for (Miner miner : findAll) {
+			miner_name_map.put(miner.getId().toString(), miner.getName());
+		}
+
+		this.page = this.adminMinerOrderService.pagedQuery(this.pageNo, 20, name_para, miner_para,
+				status_para, partyId, order_no_para, rolename_para);
+		ModelAndView model = new ModelAndView();
+		model.addObject("pageNo", this.pageNo);
+		model.addObject("pageSize", this.pageSize);
+		model.addObject("page", this.page);
+		model.addObject("name_para", name_para);
+		model.addObject("miner_para", miner_para);
+		model.addObject("status_para", status_para);
+		model.addObject("order_no_para", order_no_para);
+		model.addObject("rolename_para", rolename_para);
+		
+		model.addObject("miner_name_map", miner_name_map);
+		model.addObject("message", message);
+		model.addObject("error", error);
+		model.setViewName("miner_order_list");
+		return model;
+	}
+
+	/**
+	 * 后台赎回
+	 */
+	@RequestMapping(action + "closOrder.action")
+	public ModelAndView closOrder(HttpServletRequest request) {
+		String message = "";
+		String error = "";
+		try {
+			String order_no = request.getParameter("order_no");
+			CloseDelayThread lockDelayThread = new CloseDelayThread(order_no, minerOrderService);
+			Thread t = new Thread(lockDelayThread);
+			t.start();
+			message = "操作成功";
+		} catch (BusinessException e) {
+			error = e.getMessage();
+		} catch (Exception e) {
+			logger.error("error ", e);
+			error = "程序错误";
+		}
+		ModelAndView model = new ModelAndView();
+		model.addObject("message", message);
+		model.addObject("error", error);
+		model.setViewName("redirect:/" + action + "list.action");
+		return model;
+	}
+
+	/**
+	 * 新线程处理，直接拿到订单锁处理完成后退出
+	 *
+	 */
+	public class CloseDelayThread implements Runnable {
+		private String orderNo;
+		private MinerOrderService minerOrderService;
+
+		public void run() {
+			try {
+				while (true) {
+					/**
+					 * 提前赎回理财产品需要支付违约金
+					 */
+					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 = 0d;// 不计违约金
+						order.setState("2");
+						order.setProfit(Arith.sub(order.getProfit(), default_money));
+						this.minerOrderService.saveClose(order);
+					}
+					/**
+					 * 处理完退出
+					 */
+					break;
+				}
+
+			} catch (Exception e) {
+				logger.error("error:", e);
+			}
+
+		}
+
+		public CloseDelayThread(String orderNo, MinerOrderService minerOrderService) {
+			this.orderNo = orderNo;
+			this.minerOrderService = minerOrderService;
+		}
+
+	}
+
+	@RequestMapping(action + "toAddOrder.action")
+	public ModelAndView toAddOrder(HttpServletRequest request) {
+		String session_token = UUID.randomUUID().toString();
+		this.session.put("session_token", session_token);
+
+		List<Miner> findAll = this.minerService.findAll();
+		Map<String, String> miner_name_map = new LinkedHashMap<String, String>();
+		List<Miner> miner_list = new LinkedList<Miner>();
+		for (Miner miner : findAll) {
+			miner_name_map.put(miner.getId().toString(), miner.getName());
+			miner_list.add(miner);
+		}
+		ModelAndView model = new ModelAndView();
+		model.addObject("miner_name_map", miner_name_map);
+		model.addObject("miner_list", miner_list);
+		model.addObject("session_token", session_token);
+		model.setViewName("miner_order_add");
+		return model;
+	}
+
+	@RequestMapping(action + "addOrder.action")
+	public ModelAndView addOrder(HttpServletRequest request) {
+		ModelAndView model = new ModelAndView();
+		String error = "";
+		try {
+			String session_token = request.getParameter("session_token");
+			String para_uid = request.getParameter("para_uid");
+			// 购买金额
+			String para_amount = request.getParameter("para_amount");
+			// 矿机id
+			String para_minerid = request.getParameter("para_minerid");
+			
+			Object object = this.session.get("session_token");
+			this.session.remove("session_token");
+			if ((object == null) || (StringUtils.isNullOrEmpty(session_token))
+					|| (!session_token.equals((String) object))) {
+				model.setViewName("miner_order_add");
+				return model;
+			}
+
+			error = verifyAddOrder(para_uid, para_amount, para_minerid);
+			if (!StringUtils.isNullOrEmpty(error)) {
+				model.addObject("error", error);
+				model.setViewName("miner_order_add");
+				return model;
+			}
+
+			synchronized (object) {
+				adminMinerOrderService.addOrder(para_uid, Double.valueOf(para_amount), para_minerid, this.getUsername_login());
+				ThreadUtils.sleep(100);
+			}
+			model.addObject("message", "操作成功");
+			model.setViewName("redirect:/" + action + "list.action");
+			return model;
+		} catch (BusinessException e) {
+			model.addObject("error", e.getMessage());
+			model.setViewName("miner_order_add");
+			return model;
+		} catch (Exception e) {
+			logger.error("error ", e);
+			model.addObject("error", "程序错误");
+			model.setViewName("miner_order_add");
+			return model;
+		}
+	}
+
+	protected String verifyAddOrder(String para_uid, String para_amount, String para_minerid) {
+		if (StringUtils.isEmptyString(para_uid)) {
+			return "请输入用户uid";
+		}
+			
+		if (StringUtils.isNullOrEmpty(para_amount) 
+				|| !StringUtils.isDouble(para_amount) 
+				|| Double.valueOf(para_amount)< 0) {
+			return "购买金额不能小于0";
+		}
+		
+		if (StringUtils.isEmptyString(para_minerid)) {
+			return "请选择要购买的矿机";
+		}
+		return null;
+	}
+	
+	@RequestMapping(action + "addProfit.action")
+	public ModelAndView addProfit(HttpServletRequest request) {
+		String message = "";
+		String error = "";
+		String system_time = request.getParameter("system_time");
+		try {
+			if(!"root".equals(this.getUsername_login())) {
+				throw new BusinessException("权限不足");
+			}
+			if(StringUtils.isEmptyString(system_time)) {
+				throw new BusinessException("请填入系统时间");
+			}
+			JobDelayThread thread = new JobDelayThread(DateUtils.toDate(system_time, DateUtils.NORMAL_DATE_FORMAT), minerOrderProfitJob);
+			Thread t = new Thread(thread);
+			t.start();
+			message = "操作成功";
+		} catch (BusinessException e) {
+			error = e.getMessage();
+		} catch (Exception e) {
+			logger.error("error ", e);
+			error = "程序错误";
+		}
+		ModelAndView model = new ModelAndView();
+		model.addObject("message", message);
+		model.addObject("error", error);
+		model.setViewName("redirect:/" + action + "list.action");
+		return model;
+	}
+
+	
+	public class JobDelayThread implements Runnable {
+		private MinerOrderProfitJob minerOrderProfitJob;
+		private Date systemTime;
+		public void run() {
+			minerOrderProfitJob.handleData(systemTime);
+		}
+
+		public JobDelayThread(Date systemTime, MinerOrderProfitJob minerOrderProfitJob) {
+			this.systemTime = systemTime;
+			this.minerOrderProfitJob = minerOrderProfitJob;
+		}
+
+	}
+//	public String close() {
+//		try {
+//
+//			FinanceOrder order = financeOrderService.findById(id);
+//			CloseDelayThread lockDelayThread = new CloseDelayThread(id, order.getOrder_no(), financeOrderService);
+//			Thread t = new Thread(lockDelayThread);
+//			t.start();
+//
+//			this.message = "操作成功";
+//		} catch (BusinessException e) {
+//			this.error = e.getMessage();
+//		} catch (Exception e) {
+//			logger.error("error ", e);
+//			this.error = "程序错误";
+//		}
+//		return list();
+//	}
+//
+//	/**
+//	 * 新线程处理，直接拿到订单锁处理完成后退出
+//	 *
+//	 */
+//	public class CloseDelayThread implements Runnable {
+//		private String id;
+//		private String order_no;
+//		private FinanceOrderService financeOrderService;
+//
+//		public void run() {
+//			try {
+//				while (true) {
+//					if (FinanceOrderLock.add(order_no)) {
+//						/**
+//						 * 提前赎回理财产品需要支付违约金
+//						 */
+//						FinanceOrder order = financeOrderService.findById(id);
+//						Finance finance = financeService.findById(order.getFinanceId());
+//						if ("1".equals(order.getState())) {
+//							/**
+//							 * 扣除违约金
+//							 */
+//							Date date_now = new Date();// 取时间
+//							double last_days = daysBetween(date_now, order.getStop_time());
+//							if (last_days <= 0) {
+//								last_days = 1;
+//							}
+//							double default_ratio = Arith.mul(finance.getDefault_ratio(), 0.01);
+//							default_ratio = Arith.mul(default_ratio, last_days);
+//							double breach_amount = Arith.mul(order.getAmount(), default_ratio);
+//							order.setProfit(Arith.sub(order.getProfit(), breach_amount));
+//							order.setState("2");
+//
+//							this.financeOrderService.saveClose(order);
+//						}
+//						/**
+//						 * 处理完退出
+//						 */
+//						break;
+//					}
+//					ThreadUtils.sleep(500);
+//
+//				}
+//
+//			} catch (Exception e) {
+//				logger.error("error:", e);
+//			} finally {
+//				FinanceOrderLock.remove(order_no);
+//			}
+//
+//		}
+//
+//		public CloseDelayThread(String id, String order_no, FinanceOrderService financeOrderService) {
+//			this.id = id;
+//			this.order_no = order_no;
+//			this.financeOrderService = financeOrderService;
+//		}
+//
+//	}
+
+	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));
+	}
+
+}

comm/Miner/src/project/web/api/MinerController.java

@@ -0,0 +1,88 @@
+package project.web.api;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+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.web.ResultObject;
+import project.miner.MinerService;
+import project.miner.model.Miner;
+
+/**
+ * 矿机产品
+ *
+ */
+@RestController
+@CrossOrigin
+public class MinerController {
+
+	private Logger logger = LogManager.getLogger(MinerController.class);
+	
+	@Autowired
+	protected MinerService minerService;
+	
+	private final String action = "api/miner!";
+
+	/**
+	 * 矿机产品列表
+	 */
+	@RequestMapping(action + "list.action")
+	public Object list() throws IOException {
+
+		ResultObject resultObject = new ResultObject();
+		try {
+			List<Miner> data = minerService.findAllState_1();
+			List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
+			if (data != null) {
+				for (int i = 0; i < data.size(); i++) {
+					result.add(minerService.getBindOne(data.get(i)));
+				}
+			}
+			resultObject.setData(result);
+			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();
+		try {
+			String id = request.getParameter("id");
+			Miner data = minerService.findById(id);
+			resultObject.setData(minerService.getBindOne(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;
+	}
+}

comm/Miner/src/project/web/api/MinerOrderController.java

@@ -0,0 +1,534 @@
+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.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+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.BaseAction;
+import kernel.web.ResultObject;
+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 = LogManager.getLogger(MinerOrderController.class);
+	@Autowired
+	protected MinerOrderService minerOrderService;
+	@Autowired
+	protected MinerService minerService;
+	@Autowired
+	protected PartyService partyService;
+	@Autowired
+	protected SessionTokenService sessionTokenService;
+	@Autowired
+	protected SysparaService sysparaService;
+	
+	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();
+			DecimalFormat df = new DecimalFormat("#.##");
+			if (StringUtils.isNullOrEmpty(partyId)) {
+				resultObject.setData(datas);
+				resultObject.setCode("0");
+				return resultObject;
+			}
+			
+			// 状态。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();
+			Double miner_test_profit = sysparaService.find("miner_test_profit").getDouble();
+			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);
+				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);
+				/**
+				 * 当日收益
+				 */
+				data.put("daily_profit",
+						(boolean) data.get("test") ? miner_test_profit
+								: df.format(Arith.mul(
+										Arith.mul(Double.valueOf(data.get("daily_rate").toString()), 0.01),
+										Double.valueOf(data.get("amount").toString()))));
+
+				data.put("daily_rate", (boolean) data.get("test") ? miner_test_profit : data.get("daily_rate"));
+
+				// 这里的周期，体验矿机是周期，其他矿机是解锁周期(到期后需手动解锁)
+				int cycle = (boolean) data.get("test") ? Integer.valueOf(data.get("cycle").toString())
+						: Integer.valueOf(data.get("cycle_close").toString());
+//				int cycle = Integer.valueOf(data.get("cycle_close").toString()) ;
+				data.put("cycle", cycle);
+
+				double all_rate = Arith.mul(30, Double.valueOf(data.get("daily_rate").toString()));
+
+				data.put("all_rate",
+						(boolean) data.get("test") ? Arith.mul(miner_test_profit, cycle) : 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;
+			List<Miner> miners = minerService.findAll();
+			Miner miner = new Miner();
+			Map<String, Object> map = new HashMap<String, Object>();
+
+			// 金额总数
+			double amount_sum = 0;
+			// 预计今日盈利
+			double today_profit = 0;
+			// 已获收益
+			double aready_profit = 0;
+			// 订单数
+			double order_sum = 0;
+			Double miner_test_profit = sysparaService.find("miner_test_profit").getDouble();
+
+			if (data != null) {
+				for (int i = 0; i < data.size(); i++) {
+					order = data.get(i);
+					if ("1".equals(order.getState())) {
+						order_sum = Arith.add(order_sum, 1);
+						amount_sum = Arith.add(amount_sum, order.getAmount());
+					}
+					aready_profit = Arith.add(aready_profit, order.getProfit());
+					for (int j = 0; j < miners.size(); j++) {
+						miner = miners.get(j);
+						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);
+								break;
+							}
+						}
+					}
+				}
+			}
+			DecimalFormat df = new DecimalFormat("#.##");
+			map.put("amount_sum", df.format(amount_sum));
+			map.put("today_profit", df.format(today_profit));
+			map.put("aready_profit", df.format(aready_profit));
+			map.put("order_sum", order_sum);
+			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.delete(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.setPartyId(partyId);
+			order.setMinerId(minerId);
+			order.setAmount(Double.valueOf(amount));
+			order.setOrder_no(DateUtil.getToday("yyMMddHHmmss") + RandomUtil.getRandomNum(8));
+			order.setState("1");
+
+			this.minerOrderService.saveCreate(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("金额错误");
+			}
+			
+			double amount = Double.valueOf(amount_temp);
+			
+			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());
+			String partyId = getLoginPartyId();
+			if (!StringUtils.isNullOrEmpty(partyId)) {
+				String session_token = sessionTokenService.savePut(partyId);
+				map.put("session_token", session_token);
+			}
+			map.put("amount", miner.getTest() ? 0 : amount);
+			Date date = new Date();// 取时间
+
+			map.put("create_time", DateUtils.format(date, DateUtils.DF_yyyyMMddHHmmss));
+			Calendar calendar = new GregorianCalendar();
+			calendar.setTime(date);
+			// 把日期往后增加一天.整数往后推
+			calendar.add(calendar.DATE, 1);
+			date = calendar.getTime();
+
+			// 起息时间
+			map.put("earn_time", DateUtils.format(date, DateUtils.DF_yyyyMMdd));
+			// 把日期往后增加周期.整数往后推
+			calendar.add(calendar.DATE, miner.getCycle());
+			date = calendar.getTime();
+
+			// 截止时间
+			map.put("stop_time",
+					miner.getTest()
+							? DateUtils.format(DateUtils.addDay(new Date(), miner.getCycle()), DateUtils.DF_yyyyMMdd)
+							: null);
+
+			// 区间
+			map.put("investment_min", miner.getInvestment_min());
+			Double miner_test_profit = sysparaService.find("miner_test_profit").getDouble();
+
+			map.put("daily_rate", miner.getTest() ? miner_test_profit : miner.getDaily_rate());
+			map.put("minerId", minerId);
+			double rate = Arith.mul(miner.getDaily_rate(), 0.01);
+			if (miner.getTest()) {
+				map.put("profit_may", String.valueOf(Arith.mul(miner_test_profit, miner.getCycle())));
+			} else {
+				map.put("profit_may", String.valueOf(df.format(Arith.mul(amount, Arith.mul(rate, 30)))));
+
+			}
+			map.put("order_no", DateUtil.getToday("yyMMddHHmmss") + RandomUtil.getRandomNum(8));
+
+			// 判断是否体验矿机
+			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() ? String.valueOf(Arith.mul(miner_test_profit, miner.getCycle())) 
+					: String.valueOf(df.format(all_rate)));
+
+			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 {
+			String order_no = request.getParameter("order_no");
+			CloseDelayThread lockDelayThread = new CloseDelayThread(order_no, minerOrderService);
+			Thread t = new Thread(lockDelayThread);
+			t.start();
+
+		} 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);
+				}
+
+			} 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;
+		map.put("days", daysBetween);
+		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());
+
+		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));
+	}
+
+
+}