update 后台管理新增定时任务开关，收益入库定时任务修改。新增用户待支付汇总 接口

m2pool-modules/m2pool-pool/src/main/java/com/m2pool/pool/mapper/PoolMapper.java

@@ -147,6 +147,9 @@ public interface PoolMapper {
 
         //写入币价数据 30m
         public boolean insertPrice(@Param("table") String table,@Param("date") String date,@Param("vo") DateValueVo vo);
+
+        public BigDecimal selectPrice(@Param("coin") String coin);
+
         //@Pool2DB
         //public boolean insertMhsDataToDB(@Param("table") String table,@Param("list") List<MinerDataDto> list);
         //报块信息表

m2pool-modules/m2pool-pool/src/main/java/com/m2pool/pool/service/impl/PoolServiceImpl.java

@@ -189,6 +189,8 @@ public class PoolServiceImpl implements PoolService {
 
         int scale = PoolProfitScale.getScaleByCoin(pool.getCoin());
 
+        PowerLineDto powerLineDto = priceList.stream()
+                .max(Comparator.comparing(PowerLineDto::getPrice)).orElse(new PowerLineDto());
 
         if("1h".equals(vo.getInterval()) || "rt".equals(vo.getInterval())){
             // 获取当前日期
@@ -215,13 +217,19 @@ public class PoolServiceImpl implements PoolService {
             list = fillMissingOnlineData(list,oneDayAgo,currentDate,powerUnit.getUnit(),30);
             //通过全网算力接口 获取到的时间段价格补充到矿池算力接口的价格中
             list.stream().forEach(e -> priceList.stream().anyMatch(p ->{
-                if(p.getDate().equals(e.getDate())){
+                if( p.getDate().equals(e.getDate())){
                     e.setPrice(p.getPrice());
                 }
                 return false;
             }));
 
-            return AjaxResult.success(list);
+            List<PowerLineDto> collect = list.stream().peek(e -> {
+                if (e.getPrice() == 0) {
+                    e.setPrice(powerLineDto.getPrice());
+                }
+            }).collect(Collectors.toList());
+
+            return AjaxResult.success(collect);
         }else if ("1d".equals(vo.getInterval())){
 
             //获取当天零点时间
@@ -256,13 +264,17 @@ public class PoolServiceImpl implements PoolService {
 
             list = fillMissingOnlineData(list,oneMonthAgo,currentDate,powerUnit.getUnit(),24*60);
             list.stream().forEach(e -> priceList.stream().anyMatch(p ->{
-                if(p.getDate().equals(e.getDate())){
+                if( p.getDate().equals(e.getDate())){
                     e.setPrice(p.getPrice());
                 }
                 return false;
             }));
-
-            return AjaxResult.success(list);
+            List<PowerLineDto> collect = list.stream().peek(e -> {
+                if (e.getPrice() == 0) {
+                    e.setPrice(powerLineDto.getPrice());
+                }
+            }).collect(Collectors.toList());
+            return AjaxResult.success(collect);
         }else {
             return AjaxResult.error("参数错误:interval");
         }
@@ -404,6 +416,17 @@ public class PoolServiceImpl implements PoolService {
 
 
         List<PowerLineDto> list = poolMapper.getHourNetPowerList(pool.getCoin());
+
+        PowerLineDto powerLineDto = list.stream()
+                .max(Comparator.comparing(PowerLineDto::getPrice)).orElse(new PowerLineDto());
+
+         list = list.stream().peek(e -> {
+            if (e.getPrice() == 0) {
+                e.setPrice(powerLineDto.getPrice());
+            }
+        }).collect(Collectors.toList());
+
+
         if("1h".equals(vo.getInterval()) || "rt".equals(vo.getInterval())){
             PageHelper.clearPage();
             //30m数据 限制条数为最近1天的条数 即1*48=48

m2pool-modules/m2pool-pool/src/main/java/com/m2pool/pool/task/DataTask.java

@@ -3945,7 +3945,7 @@ public class DataTask {
         List<UserPowerDto> userMhsList = poolMapper.getUserTodayTotalPower("alph", nowStr);
         HashMap<String,BigDecimal> map = new HashMap<>();
         userMhsList.stream().forEach(e ->{
-            if(poolMhs !=  BigDecimal.ZERO){
+            if(poolMhs.compareTo(BigDecimal.ZERO) != 0){
                 map.put(e.getUser(),e.getMhs().divide(poolMhs,8, RoundingMode.HALF_UP));
             }
         });
@@ -4323,4 +4323,441 @@ public class DataTask {
         return list;
     }
 
+
+
+    @Scheduled(cron = "20 1,3,10,31,33,40 * * * ?")
+    public void MONERO30mDataToDB(){
+        //String nowStr = DateUtils.dateTimeNow("yyyy-MM-dd HH:mm:00");
+        if(!enable){
+            System.out.println("DataTask 定时任务已关闭，请在nacos修改配置");
+            return;
+        }
+        Date now = new Date();
+        int minute = (now.getMinutes() / 30) * 30;
+        now.setMinutes( minute);
+        now.setSeconds(0);
+        String nowStr = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, now);
+
+        System.out.println("MONERO 30分钟定时任务执行时间:"+now);
+        System.out.println("格式化后的时间:"+nowStr);
+
+        //检查二级表是否有当前时间数据
+        int count = poolMapper.getLastDataTime(Pools.MONERO.getMhs() + "30m", nowStr);
+
+        if(count == 0) {
+            List<MinerDataDto> list = poolMapper.getHourMinerDataList(Pools.MONERO.getMhs()+"_realv2",nowStr);
+            if(list.size() > 0){
+                List<MinerDataDto> offlineList = new ArrayList<>();
+                list.stream().forEach(e -> {
+                    if(StringUtils.isNotNull(e.getMhs())){
+                        e.setMhs(e.getMhs() * Pools.MONERO.getFac());
+                    }
+                    if("offline".equals(e.getState())){
+                        offlineList.add(e);
+                    }
+                });
+                list = filterList(list,now);
+
+                boolean result = poolMapper.batchInsertMhsDataToDB(Pools.MONERO.getMhs() + "30m", getToHourDBListByMinerDataList(list));
+
+                Map<Date, List<MinerDataDto>> map = list.stream().collect(Collectors.groupingBy(MinerDataDto::getDate));
+                map.forEach((date,dList) -> {
+                    PoolPower poolPower  = new PoolPower();
+                    //poolPower.setDate(date);
+                    poolPower.setDateStr(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS,date));
+                    Map<String, Long> stateCount = dList.stream().collect(Collectors.groupingBy(MinerDataDto::getState, Collectors.counting()));
+                    poolPower.setMhs(dList.stream().map(e -> BigDecimal.valueOf(e.getMhs())).reduce(BigDecimal::add).get().stripTrailingZeros());
+                    poolPower.setMiners(dList.size());
+                    poolPower.setOnline(Convert.toInt(stateCount.get("online"),0));
+                    poolPower.setOffline(Convert.toInt(stateCount.get("offline"),0));
+
+                    boolean poolResult = poolMapper.insertPoolPower(Pools.MONERO.getPoolTable() + "_30m", poolPower);
+                    int time =0;
+                    while (!poolResult){
+                        poolResult = poolMapper.insertPoolPower(Pools.MONERO.getPoolTable() + "_30m", poolPower);
+                        if (time > 5) {
+                            break;
+                        }
+                        time ++;
+                    }
+
+                    System.out.println("构造写入user算力表数据");
+                    Map<String, List<MinerDataDto>> userMap = dList.stream().collect(Collectors.groupingBy(MinerDataDto::getUser));
+                    List<MinerDataInsertDBDto> userList = new ArrayList<>();
+                    userMap.forEach((user,uList)->{
+                        MinerDataInsertDBDto uDto = new MinerDataInsertDBDto();
+                        uDto.setDate(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS,date));
+                        uDto.setUser(user);
+                        uDto.setMhs(uList.stream().map(e->BigDecimal.valueOf(e.getMhs())).reduce(BigDecimal::add).get().doubleValue());
+                        userList.add(uDto);
+                    } );
+                    System.out.println("user算力表入库数据条数："+userList.size());
+                    boolean userResult = poolMapper.batchInsertUserMhsDateToDB(Pools.MONERO.getName() + "_users_30m", userList);
+                    int uTime =0;
+                    while (!userResult){
+                        userResult = poolMapper.batchInsertUserMhsDateToDB(Pools.MONERO.getName() + "_users_30m", userList);
+                        if (uTime > 5) {
+                            break;
+                        }
+                        uTime ++;
+                    }
+
+
+
+
+                });
+
+                Map<String, List<MinerDataDto>> userMap = list.stream().collect(Collectors.groupingBy(MinerDataDto::getMiner));
+                if (result) {
+                    System.out.println(DateUtils.dateTimeNow() + "MONERO 小时数据存入数据成功");
+                } else {
+                    System.out.println(DateUtils.dateTimeNow() + "MONERO 小时数据存入数据失败");
+                }
+
+                if(offlineList.size() >0){
+                    CompletableFuture.runAsync(()->{
+
+                        //根据挖矿账户分组、统计离线矿机名单、离线矿机数
+
+                        //对比redis中该挖矿账户上一次离线矿机数
+                        //有redis数据 需要判断 上一次离线矿机数<本次矿机离线数 才执行通知 否则跳过
+                        //无redis数据 说明是第一次 执行通知
+                    });
+
+                }
+
+            }
+            else{
+                //重来一次！
+                CompletableFuture.runAsync(()->{
+                    System.out.println("MONERO 30分钟定时任务执行失败 延时一分钟时间重新查询");
+                    System.out.println("延迟后使用的查询时间:"+now);
+                    System.out.println("延迟后 格式化后的时间:"+nowStr);
+
+                    //检查二级表是否有当前时间数据
+                    int newCount = poolMapper.getLastDataTime(Pools.MONERO.getMhs() + "30m", nowStr);
+                    if(newCount == 0){
+                        List<MinerDataDto> newList = poolMapper.getHourMinerDataList(Pools.MONERO.getMhs()+"_realv2",nowStr);
+                        if(newList.size() > 0){
+
+                            newList.stream().forEach(e -> {
+                                if(StringUtils.isNotNull(e.getMhs())){
+                                    e.setMhs(e.getMhs() * Pools.MONERO.getFac());
+                                }
+                            });
+                            newList = filterList(newList,now);
+
+                            boolean newResult = poolMapper.batchInsertMhsDataToDB(Pools.MONERO.getMhs() + "30m", getToHourDBListByMinerDataList(newList));
+
+                            Map<Date, List<MinerDataDto>> map2 = newList.stream().collect(Collectors.groupingBy(MinerDataDto::getDate));
+                            map2.forEach((date,dList) -> {
+                                PoolPower poolPower  = new PoolPower();
+                                //poolPower.setDate(date);
+                                poolPower.setDateStr(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS,date));
+                                Map<String, Long> stateCount = dList.stream().collect(Collectors.groupingBy(MinerDataDto::getState, Collectors.counting()));
+                                poolPower.setMhs(dList.stream().map(e -> BigDecimal.valueOf(e.getMhs())).reduce(BigDecimal::add).get().stripTrailingZeros());
+                                poolPower.setMiners(dList.size());
+                                poolPower.setOnline(Convert.toInt(stateCount.get("online"),0));
+                                poolPower.setOffline(Convert.toInt(stateCount.get("offline"),0));
+
+                                boolean poolResult2 = poolMapper.insertPoolPower(Pools.MONERO.getPoolTable() + "_30m", poolPower);
+                                int time =0;
+                                while (!poolResult2){
+                                    poolResult2 = poolMapper.insertPoolPower(Pools.MONERO.getPoolTable() + "_30m", poolPower);
+                                    if (time > 5) {
+                                        break;
+                                    }
+                                    time ++;
+                                }
+
+                                System.out.println("延迟任务 构造写入user算力表数据");
+                                Map<String, List<MinerDataDto>> userMap = dList.stream().collect(Collectors.groupingBy(MinerDataDto::getUser));
+                                List<MinerDataInsertDBDto> userList = new ArrayList<>();
+                                userMap.forEach((user,uList)->{
+                                    MinerDataInsertDBDto uDto = new MinerDataInsertDBDto();
+                                    uDto.setDate(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS,date));
+                                    uDto.setUser(user);
+                                    uDto.setMhs(uList.stream().map(e->BigDecimal.valueOf(e.getMhs())).reduce(BigDecimal::add).get().doubleValue());
+                                    userList.add(uDto);
+                                } );
+                                System.out.println("延迟任务 user算力表入库数据条数："+userList.size());
+                                boolean userResult = poolMapper.batchInsertUserMhsDateToDB(Pools.MONERO.getName() + "_users_30m", userList);
+                                int uTime =0;
+                                while (!userResult){
+                                    userResult = poolMapper.batchInsertUserMhsDateToDB(Pools.MONERO.getName() + "_users_30m", userList);
+                                    if (uTime > 5) {
+                                        break;
+                                    }
+                                    uTime ++;
+                                }
+                            });
+                            if (newResult) {
+                                System.out.println(DateUtils.dateTimeNow() + "MONERO 30m数据 延迟存入数据成功");
+                            } else {
+                                System.out.println(DateUtils.dateTimeNow() + "MONERO 30m数据 延迟存入数据失败");
+
+                            }
+
+                        }
+                    }
+                });
+
+            }
+        }
+
+    }
+
+    @Scheduled(cron = "0 1,3,5 0 * * ?")
+    public void MONERODailyDataToDB(){
+        if(!enable){
+            return;
+        }
+        String nowStr = DateUtils.dateTimeNow(DateUtils.YYYY_MM_DD);
+        Date now = DateUtils.parseDate( nowStr);
+
+        //检查二级表是否有当前时间数据
+        int count = poolMapper.getLastDataTime(Pools.MONERO.getMhs() + "24h", nowStr);
+
+        if(count == 0) {
+            List<MinerDataDto> list = poolMapper.getDailyMinerDataList(Pools.MONERO.getMhs()+"_realv2", nowStr);
+            if(list.size() > 0){
+                list.stream().forEach(e -> {
+                    if(StringUtils.isNotNull(e.getMhs())){
+                        e.setMhs(e.getMhs() * Pools.MONERO.getFac());
+                    }
+                });
+                list = filterList(list,now);
+                //list.stream().forEach(e ->{
+                //    e.setDate(DateUtils.addDays(e.getDate(),-1));
+                //});
+                boolean result = poolMapper.batchInsertMhsDataToDB(Pools.MONERO.getMhs() + "24h", getToDailyDBListByMinerDataList(list));
+                //todo 统计矿池数据写入矿池数据库 $coin_pool_24h
+                Map<Date, List<MinerDataDto>> map = list.stream().collect(Collectors.groupingBy(MinerDataDto::getDate));
+                map.forEach((date,dList) -> {
+                    PoolPower poolPower  = new PoolPower();
+                    //poolPower.setDate(date);
+                    poolPower.setDateStr(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS,date));
+                    Map<String, Long> stateCount = dList.stream().collect(Collectors.groupingBy(MinerDataDto::getState, Collectors.counting()));
+                    poolPower.setMhs(dList.stream().map(e -> BigDecimal.valueOf(e.getMhs())).reduce(BigDecimal::add).get().stripTrailingZeros());
+                    poolPower.setMiners(dList.size());
+                    poolPower.setOnline(Convert.toInt(stateCount.get("online"),0));
+                    poolPower.setOffline(Convert.toInt(stateCount.get("offline"),0));
+
+                    boolean poolResult = poolMapper.insertPoolPower(Pools.MONERO.getPoolTable() + "_24h", poolPower);
+                    int time =0;
+                    while (!poolResult){
+                        poolResult = poolMapper.insertPoolPower(Pools.MONERO.getPoolTable() + "_24h", poolPower);
+                        if (time > 5) {
+                            break;
+                        }
+                        time ++;
+                    }
+
+                    //写入数据到coin_users表中
+                    Map<String, List<MinerDataDto>> userMap = dList.stream().collect(Collectors.groupingBy(MinerDataDto::getUser));
+                    List<MinerDataInsertDBDto> userList = new ArrayList<>();
+                    userMap.forEach((user,uList)->{
+                        MinerDataInsertDBDto uDto = new MinerDataInsertDBDto();
+                        uDto.setDate(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS,date));
+                        uDto.setUser(user);
+                        uDto.setMhs(uList.stream().map(e->BigDecimal.valueOf(e.getMhs())).reduce(BigDecimal::add).get().doubleValue());
+                        userList.add(uDto);
+                    } );
+
+                    boolean userResult = poolMapper.batchInsertUserMhsDateToDB(Pools.MONERO.getName() + "_users_24h", userList);
+                    int uTime =0;
+                    while (!userResult){
+                        userResult = poolMapper.batchInsertUserMhsDateToDB(Pools.MONERO.getName() + "_users_24h", userList);
+                        if (uTime > 5) {
+                            break;
+                        }
+                        uTime ++;
+                    }
+                });
+                if(result){
+                    System.out.println(DateUtils.dateTimeNow()+"MONERO 每日存入数据成功");
+                }else {
+                    System.out.println(DateUtils.dateTimeNow()+"MONERO 每日存入数据失败");
+
+                }
+
+            }else {
+                CompletableFuture.runAsync(()->{
+                    System.out.println("MONERO 每日矿池定时任务执行失败 延时一分钟时间重新查询");
+                    System.out.println("延迟后使用的查询时间:"+now);
+                    System.out.println("延迟后 格式化后的时间:"+nowStr);
+
+                    //检查二级表是否有当前时间数据
+                    int newCount = poolMapper.getLastDataTime(Pools.MONERO.getMhs() + "24h", nowStr);
+                    if(newCount == 0){
+                        List<MinerDataDto> newList = poolMapper.getDailyMinerDataList(Pools.MONERO.getMhs()+"_realv2", nowStr);
+                        if(newList.size() > 0){
+
+                            newList.stream().forEach(e -> {
+                                if(StringUtils.isNotNull(e.getMhs())){
+                                    e.setMhs(e.getMhs() * Pools.MONERO.getFac());
+                                }
+                            });
+
+                            newList = filterList(newList,now);
+
+                            boolean newResult = poolMapper.batchInsertMhsDataToDB(Pools.MONERO.getMhs() + "24h", getToDailyDBListByMinerDataList(newList));
+
+                            Map<Date, List<MinerDataDto>> map2 = newList.stream().collect(Collectors.groupingBy(MinerDataDto::getDate));
+                            map2.forEach((date,dList) -> {
+                                PoolPower poolPower  = new PoolPower();
+                                //poolPower.setDate(date);
+                                poolPower.setDateStr(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS,date));
+                                Map<String, Long> stateCount = dList.stream().collect(Collectors.groupingBy(MinerDataDto::getState, Collectors.counting()));
+                                poolPower.setMhs(dList.stream().map(e -> BigDecimal.valueOf(e.getMhs())).reduce(BigDecimal::add).get().stripTrailingZeros());
+                                poolPower.setMiners(dList.size());
+                                poolPower.setOnline(Convert.toInt(stateCount.get("online"),0));
+                                poolPower.setOffline(Convert.toInt(stateCount.get("offline"),0));
+
+                                boolean poolResult2 = poolMapper.insertPoolPower(Pools.MONERO.getPoolTable() + "_24h", poolPower);
+                                int time =0;
+                                while (!poolResult2){
+                                    poolResult2 = poolMapper.insertPoolPower(Pools.MONERO.getPoolTable() + "_24h", poolPower);
+                                    if (time > 5) {
+                                        break;
+                                    }
+                                    time ++;
+                                }
+
+                                Map<String, List<MinerDataDto>> userMap = dList.stream().collect(Collectors.groupingBy(MinerDataDto::getUser));
+                                List<MinerDataInsertDBDto> userList = new ArrayList<>();
+                                userMap.forEach((user,uList)->{
+                                    MinerDataInsertDBDto uDto = new MinerDataInsertDBDto();
+                                    uDto.setDate(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS,date));
+                                    uDto.setUser(user);
+                                    uDto.setMhs(uList.stream().map(e->BigDecimal.valueOf(e.getMhs())).reduce(BigDecimal::add).get().doubleValue());
+                                    userList.add(uDto);
+                                } );
+
+                                boolean userResult = poolMapper.batchInsertUserMhsDateToDB(Pools.MONERO.getName() + "_users_24h", userList);
+                                int uTime =0;
+                                while (!userResult){
+                                    userResult = poolMapper.batchInsertUserMhsDateToDB(Pools.MONERO.getName() + "_users_24h", userList);
+                                    if (uTime > 5) {
+                                        break;
+                                    }
+                                    uTime ++;
+                                }
+                            });
+
+
+                        }else {
+                            PoolPower poolPower  = new PoolPower();
+                            poolPower.setDate(now);
+                            poolPower.setMhs(BigDecimal.ZERO);
+                            poolPower.setMiners(0);
+                            poolPower.setOnline(0);
+                            poolPower.setOffline(0);
+                            boolean poolResult = poolMapper.insertPoolPower(Pools.MONERO.getPoolTable() + "_24h", poolPower);
+                            System.out.println("延时任务未查到 构造0数据入库,结果:"+poolPower);
+                        }
+                    }
+                });
+            }
+        }
+    }
+
+    @Scheduled(cron = "50 0,1,30,31 * * * ?")
+    public void MONEROUserPowerRatioDataToDB(){
+        //String nowStr = DateUtils.dateTimeNow("yyyy-MM-dd HH:mm:00");
+        if(!enable){
+            return;
+        }
+        Date now = new Date();
+        now.setHours(0);
+        now.setMinutes(0);
+        now.setSeconds(0);
+        String nowStr = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, now);
+
+        BigDecimal poolMhs = poolMapper.getPoolTodayTotalPower("monero", nowStr);
+        List<UserPowerDto> userMhsList = poolMapper.getUserTodayTotalPower("monero", nowStr);
+        HashMap<String,BigDecimal> map = new HashMap<>();
+        userMhsList.stream().forEach(e ->{
+            map.put(e.getUser(),e.getMhs().divide(poolMhs,8,BigDecimal.ROUND_HALF_UP));
+        });
+
+        if(map.size() >0){
+            redisService.deleteObject("NEXAUserPowerRatio");
+            redisService.setCacheMap("NEXAUserPowerRatio",map);
+        }
+
+    }
+
+
+
+    @Scheduled(cron = "30 3 0/1 * * ?")
+    //@Scheduled(cron = "0 0/2 * * * ?")
+    public void MONEROLuckyDataToDB(){
+        if(!enable){
+            return;
+        }
+        log.info("MONERO 幸运值---定时任务开始");
+        LuckDto dto = new LuckDto();
+        Date end =  DateUtils.parseDate(DateUtils.dateTimeNow(DateUtils.YYYY_MM_DD_HH_MM_SS));
+        //幸运值 = 矿池实际报块/矿池理论报块
+        //矿池实际报块 = distribution数据库查询表名为 币名_blkreportprofitv2
+        //矿池理论报块 =  (矿池过去N段时间的平均算力 / 全网过去N段时间平均算力) * 全网过去N段时间实际报块
+        Date start3d = DateUtils.addDays(end,-3);
+        Date start7d = DateUtils.addDays(end,-7);
+        Date start30d = DateUtils.addDays(end,-30);
+        Date start90d = DateUtils.addDays(end,-90);
+
+        //获取全网实际90天内的报块数(v2)
+        List<BlockInfoDto> blockPerDays = poolMapper.selectNetBlock("monero_net_block");
+        boolean useAggregated = blockPerDays.get(blockPerDays.size()-1).getDate().before(start3d);
+        //获取3天内全网的实际报块数
+        BlockTimeAndNumberDto blockData = blockDataContext.getBlockData("monero",start3d, end,blockPerDays, useAggregated);
+        //3天矿池理论报块数
+        BigDecimal throreticalBlocks = getTheoreticalBlocks("monero",PoolUnits.MONERO.gethRate(),start3d, end, blockData);
+        //3天矿池实际报块数
+        int actualBlocks = poolMapper.selectPoolBlock(start3d, end,"monero",3);
+        log.info("monero 3天实际报块数{},理论报块数{},全网实际报块数{},开始时间{},结束时间{}",actualBlocks,throreticalBlocks,blockData.getHeight(),start3d,end);
+        //3天幸运值
+        if(!BigDecimal.ZERO.equals(throreticalBlocks)){
+            dto.setLuck3d(BigDecimal.valueOf(actualBlocks).multiply(BigDecimal.valueOf(100)).divide(throreticalBlocks,2, RoundingMode.HALF_UP).doubleValue());
+        }
+        //7天幸运值
+        useAggregated = blockPerDays.get(blockPerDays.size()-1).getDate().before(start7d);
+
+        blockData = blockDataContext.getBlockData("monero",start7d, end,blockPerDays, useAggregated);
+        throreticalBlocks= getTheoreticalBlocks("monero",PoolUnits.MONERO.gethRate(),start7d, end, blockData);
+        actualBlocks = poolMapper.selectPoolBlock(start7d, end,"monero",7);
+        log.info("monero 7天实际报块数{},理论报块数{}",actualBlocks,throreticalBlocks);
+        if(!BigDecimal.ZERO.equals(throreticalBlocks)){
+            dto.setLuck7d(BigDecimal.valueOf(actualBlocks).multiply(BigDecimal.valueOf(100)).divide(throreticalBlocks,2, RoundingMode.HALF_UP).doubleValue());
+        }
+
+        //30天幸运值
+        useAggregated = blockPerDays.get(blockPerDays.size()-1).getDate().before(start30d);
+
+        blockData = blockDataContext.getBlockData("monero",start30d, end,blockPerDays, useAggregated);
+        throreticalBlocks= getTheoreticalBlocks("monero",PoolUnits.MONERO.gethRate(),start30d, end, blockData);
+        actualBlocks = poolMapper.selectPoolBlock(start30d, end,"monero",30);
+        log.info("monero 30天实际报块数{},理论报块数{}",actualBlocks,throreticalBlocks);
+        if(!BigDecimal.ZERO.equals(throreticalBlocks)){
+            dto.setLuck30d(BigDecimal.valueOf(actualBlocks).multiply(BigDecimal.valueOf(100)).divide(throreticalBlocks,2, RoundingMode.HALF_UP).doubleValue());
+        }
+
+        //90天幸运值
+        useAggregated = blockPerDays.get(blockPerDays.size()-1).getDate().before(start90d);
+
+        blockData = blockDataContext.getBlockData("monero",start90d, end,blockPerDays, useAggregated);
+        throreticalBlocks= getTheoreticalBlocks("monero",PoolUnits.MONERO.gethRate(),start90d, end, blockData);
+        actualBlocks = poolMapper.selectPoolBlock(start90d, end,"monero",90);
+        log.info("monero 90天实际报块数{},理论报块数{}",actualBlocks,throreticalBlocks);
+        if(!BigDecimal.ZERO.equals(throreticalBlocks)){
+            dto.setLuck90d(BigDecimal.valueOf(actualBlocks).multiply(BigDecimal.valueOf(100)).divide(throreticalBlocks,2, RoundingMode.HALF_UP).doubleValue());
+        }
+
+        redisService.deleteObject("MONEROLuck");
+        redisService.setCacheObject("NMONEROLuck",dto);
+        log.info("monero幸运值入库完成---幸运值3天：{},幸运值7天：{},幸运值30天：{},幸运值90天：{},",
+                dto.getLuck3d(),dto.getLuck7d(),dto.getLuck30d(),dto.getLuck90d());
+    }
+
 }

m2pool-modules/m2pool-pool/src/main/resources/mapper/pool/PoolMapper.xml

@@ -698,6 +698,15 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
         `date` = VALUES(`date`)
     </insert>
 
+    <select id="selectPrice" resultType="java.math.BigDecimal">
+        select
+            `value`
+        from
+            ${coin}_price
+        order by id desc
+        limit 1
+    </select>
+
     <insert id="batchInsertNexaPoolBlkToDB">
         insert into nexa_pool_blkstats (
             `date`,