@RestController
@RequestMapping("/educenter/member")
@CrossOrigin
public class UcenterMemberController {
    @Autowired
    private UcenterMemberService memberService;
    // 查询特定天的注册人数
    @GetMapping("countRegister/{day}")
    public Integer countRegister(@PathVariable String day) {
        Integer count = memberService.countRegister(day);
        return count;
    }
}

// 查询特定天的注册人数
@Override
public Integer countRegister(String day) {
    return baseMapper.countRegisterByDay(day);
}

@Component
@FeignClient("service-ucenter")
public interface UcenterClient {
    // 查询特定天的注册人数
    @GetMapping("/educenter/member/countRegister/{day}")
    public Integer countRegister(@PathVariable("day") String day);
}

@RestController
@RequestMapping("/staservice/sta")
@CrossOrigin
public class StatisticsDailyController {
    
    @Autowired
    private StatisticsDailyService staService;

    // 统计特定天的注册人数
    @PostMapping("countRegister/{day}")
    public R countRegister(@PathVariable String day) {
        staService.countRegister(day);
        return R.ok();
    }
}

@Service
public class StatisticsDailyServiceImpl extends ServiceImpl<StatisticsDailyMapper, StatisticsDaily> implements StatisticsDailyService {

    @Autowired
    private UcenterClient ucenterClient;

    @Override
    public void countRegister(String day) {
        // 先删除相同日期的记录
        QueryWrapper<StatisticsDaily> wrapper = new QueryWrapper<>();
        wrapper.eq("date_calculated", day);
        baseMapper.delete(wrapper);
        // 获得指定日期的统计数
        Integer count = ucenterClient.countRegister(day);
        // 把统计数据添加到统计表当中
        StatisticsDaily statisticsDaily = new StatisticsDaily();
        statisticsDaily.setRegisterNum(count);
        statisticsDaily.setDateCalculated(day);
        // 一下是一些随机数
        statisticsDaily.setVideoViewNum(RandomUtils.nextInt(100, 200));
        statisticsDaily.setLoginNum(RandomUtils.nextInt(100, 200));
        statisticsDaily.setCourseNum(RandomUtils.nextInt(100, 200));
        // 插入数据库
        baseMapper.insert(statisticsDaily);
    }
}

@EnableScheduling   // 使用自动任务public class StatisticsApplication {    public static void main(String[] args) {        SpringApplication.run(StatisticsApplication.class, args);    }}

@Componentpublic class ScheduledTask {    @Autowired    private StatisticsDailyService staService;    // 0/5 * * * * ?表示每隔5秒执行一次这个方法    @Scheduled(cron = "0/5 * * * * ?")    public void task1() {        System.out.println("**************task1执行了..");    }    //在每天凌晨1点，把前一天数据进行数据查询添加    @Scheduled(cron = "0 0 1 * * ?")    public void task2() {        staService.countRegister(DateUtil.formatDate(DateUtil.addDays(new Date(), -1)));    }}

public class DateUtil {    private static final String dateFormat = "yyyy-MM-dd";    /**     * 格式化日期     *     * @param date     * @return     */    public static String formatDate(Date date) {        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);        return sdf.format(date);    }    /**     * 在日期date上增加amount天 。     *     * @param date   处理的日期，非null     * @param amount 要加的天数，可能为负数     */    public static Date addDays(Date date, int amount) {        Calendar now =Calendar.getInstance();        now.setTime(date);        now.set(Calendar.DATE,now.get(Calendar.DATE)+amount);        return now.getTime();    }    public static void main(String[] args) {        System.out.println(DateUtil.formatDate(new Date()));        System.out.println(DateUtil.formatDate(DateUtil.addDays(new Date(), -1)));    }}

// echatrts图表显示@GetMapping("showChartData/{type}/{begin}/{end}")public R getChartData(@PathVariable String begin, @PathVariable String end, @PathVariable String type) {    Map<String, Object> map = staService.getChartData(type, begin, end);    return R.ok().data(map);}

// echatrts图表显示@Overridepublic Map<String, Object> getChartData(String type, String begin, String end) {    // 指定日期范围    QueryWrapper<StatisticsDaily> wrapper = new QueryWrapper<>();    wrapper.between("date_calculated", begin, end);    // 这里要求前端的传递的value和表中对应字段值相同，select指定查询列    wrapper.select("date_calculated", type);    List<StatisticsDaily> staDataList = baseMapper.selectList(wrapper);    //前端要求数组json结构，对应后端java代码是list集合    //创建两个list集合，一个日期list，一个数量list    List<String> dateList = new ArrayList<>();    List<Integer> numList = new ArrayList<>();    //遍历查询所有数据list集合，进行封装    for (int i = 0; i < staDataList.size(); i++) {        StatisticsDaily daily = staDataList.get(i);        //封装日期list集合        dateList.add(daily.getDateCalculated());        //封装对应选择的数量        switch (type) {            case "login_num":                numList.add(daily.getLoginNum());                break;            case "register_num":                numList.add(daily.getRegisterNum());                break;            case "video_view_num":                numList.add(daily.getVideoViewNum());                break;            case "course_num":                numList.add(daily.getCourseNum());                break;            default:                break;        }    }    //把封装之后两个list集合放到map集合，进行返回    Map<String, Object> map = new HashMap<>();    map.put("dateList", dateList);    map.put("numList", numList);    return map;}

@Component
public class CanalClient {

    //sql队列
    private Queue<String> SQL_QUEUE = new ConcurrentLinkedQueue<>();

    @Resource
    private DataSource dataSource;

    /**
     * canal入库方法
     */
    public void run() {

        CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress("192.168.128.129",
                11111), "example", "", "");
        int batchSize = 1000;
        try {
            connector.connect();
            connector.subscribe(".*\\..*");
            connector.rollback();
            try {
                while (true) {
                    //尝试从master那边拉去数据batchSize条记录，有多少取多少
                    Message message = connector.getWithoutAck(batchSize);
                    long batchId = message.getId();
                    int size = message.getEntries().size();
                    if (batchId == -1 || size == 0) {
                        Thread.sleep(1000);
                    } else {
                        dataHandle(message.getEntries());
                    }
                    connector.ack(batchId);

                    //当队列里面堆积的sql大于一定数值的时候就模拟执行
                    if (SQL_QUEUE.size() >= 1) {
                        executeQueueSql();
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (InvalidProtocolBufferException e) {
                e.printStackTrace();
            }
        } finally {
            connector.disconnect();
        }
    }

    /**
     * 模拟执行队列里面的sql语句
     */
    public void executeQueueSql() {
        int size = SQL_QUEUE.size();
        for (int i = 0; i < size; i++) {
            String sql = SQL_QUEUE.poll();
            System.out.println("[sql]----> " + sql);

            this.execute(sql.toString());
        }
    }

    /**
     * 数据处理
     *
     * @param entrys
     */
    private void dataHandle(List<Entry> entrys) throws InvalidProtocolBufferException {
        for (Entry entry : entrys) {
            if (EntryType.ROWDATA == entry.getEntryType()) {
                RowChange rowChange = RowChange.parseFrom(entry.getStoreValue());
                EventType eventType = rowChange.getEventType();
                if (eventType == EventType.DELETE) {
                    saveDeleteSql(entry);
                } else if (eventType == EventType.UPDATE) {
                    saveUpdateSql(entry);
                } else if (eventType == EventType.INSERT) {
                    saveInsertSql(entry);
                }
            }
        }
    }

    /**
     * 保存更新语句
     *
     * @param entry
     */
    private void saveUpdateSql(Entry entry) {
        try {
            RowChange rowChange = RowChange.parseFrom(entry.getStoreValue());
            List<RowData> rowDatasList = rowChange.getRowDatasList();
            for (RowData rowData : rowDatasList) {
                List<Column> newColumnList = rowData.getAfterColumnsList();
                StringBuffer sql = new StringBuffer("update " + entry.getHeader().getTableName() + " set ");
                for (int i = 0; i < newColumnList.size(); i++) {
                    sql.append(" " + newColumnList.get(i).getName()
                            + " = '" + newColumnList.get(i).getValue() + "'");
                    if (i != newColumnList.size() - 1) {
                        sql.append(",");
                    }
                }
                sql.append(" where ");
                List<Column> oldColumnList = rowData.getBeforeColumnsList();
                for (Column column : oldColumnList) {
                    if (column.getIsKey()) {
                        //暂时只支持单一主键
                        sql.append(column.getName() + "=" + column.getValue());
                        break;
                    }
                }
                SQL_QUEUE.add(sql.toString());
            }
        } catch (InvalidProtocolBufferException e) {
            e.printStackTrace();
        }
    }

    /**
     * 保存删除语句
     *
     * @param entry
     */
    private void saveDeleteSql(Entry entry) {
        try {
            RowChange rowChange = RowChange.parseFrom(entry.getStoreValue());
            List<RowData> rowDatasList = rowChange.getRowDatasList();
            for (RowData rowData : rowDatasList) {
                List<Column> columnList = rowData.getBeforeColumnsList();
                StringBuffer sql = new StringBuffer("delete from " + entry.getHeader().getTableName() + " where ");
                for (Column column : columnList) {
                    if (column.getIsKey()) {
                        //暂时只支持单一主键
                        sql.append(column.getName() + "=" + column.getValue());
                        break;
                    }
                }
                SQL_QUEUE.add(sql.toString());
            }
        } catch (InvalidProtocolBufferException e) {
            e.printStackTrace();
        }
    }

    /**
     * 保存插入语句
     *
     * @param entry
     */
    private void saveInsertSql(Entry entry) {
        try {
            RowChange rowChange = RowChange.parseFrom(entry.getStoreValue());
            List<RowData> rowDatasList = rowChange.getRowDatasList();
            for (RowData rowData : rowDatasList) {
                List<Column> columnList = rowData.getAfterColumnsList();
                StringBuffer sql = new StringBuffer("insert into " + entry.getHeader().getTableName() + " (");
                for (int i = 0; i < columnList.size(); i++) {
                    sql.append(columnList.get(i).getName());
                    if (i != columnList.size() - 1) {
                        sql.append(",");
                    }
                }
                sql.append(") VALUES (");
                for (int i = 0; i < columnList.size(); i++) {
                    sql.append("'" + columnList.get(i).getValue() + "'");
                    if (i != columnList.size() - 1) {
                        sql.append(",");
                    }
                }
                sql.append(")");
                SQL_QUEUE.add(sql.toString());
            }
        } catch (InvalidProtocolBufferException e) {
            e.printStackTrace();
        }
    }

    /**
     * 入库
     *
     * @param sql
     */
    public void execute(String sql) {
        Connection con = null;
        try {
            if (null == sql) return;
            con = dataSource.getConnection();
            QueryRunner qr = new QueryRunner();
            int row = qr.execute(con, sql);
            System.out.println("update: " + row);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DbUtils.closeQuietly(con);
        }
    }
}

@SpringBootApplication
public class CanalApplication implements CommandLineRunner {
    @Resource
    private CanalClient canalClient;

    public static void main(String[] args) {
        SpringApplication.run(CanalApplication.class, args);
    }

    @Override
    public void run(String... strings) throws Exception {
        //项目启动，执行canal客户端监听
        canalClient.run();
    }
}

@SpringBootApplication
@EnableDiscoveryClient	//nacos
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
    }
}

public class Permission implements Serializable {

    private static final long serialVersionUID = 1L;

    @ApiModelProperty(value = "编号")
    @TableId(value = "id", type = IdType.ID_WORKER_STR)
    private String id;

    @ApiModelProperty(value = "所属上级")
    private String pid;

    @ApiModelProperty(value = "层级")
    @TableField(exist = false)
    private Integer level;

    @ApiModelProperty(value = "下级")
    @TableField(exist = false)
    private List<Permission> children;
    
}

@RestController
@RequestMapping("/admin/acl/permission")
public class PermissionController {
    @Autowired
    private PermissionService permissionService;
    //获取全部菜单
    @ApiOperation(value = "查询所有菜单")
    @GetMapping
    public R indexAllPermission() {
        List<Permission> list =  permissionService.queryAllMenuGuli();
        return R.ok().data("children",list);
    }
}

//获取全部菜单
@Override
public List<Permission> queryAllMenuGuli() {
    //1 查询菜单表所有数据
    QueryWrapper<Permission> wrapper = new QueryWrapper<>();
    wrapper.orderByDesc("id");
    List<Permission> permissionList = baseMapper.selectList(wrapper);
    //2 把查询所有菜单list集合按照要求进行封装
    List<Permission> resultList = bulidPermission(permissionList);
    return resultList;
}
//把返回所有菜单list集合进行封装的方法
public static List<Permission> bulidPermission(List<Permission> permissionList) {

    //创建list集合，用于数据最终封装
    List<Permission> finalNode = new ArrayList<>();
    //把所有菜单list集合遍历，得到顶层菜单 pid=0菜单，设置level是1
    for(Permission permissionNode : permissionList) {
        //得到顶层菜单 pid=0菜单
        if("0".equals(permissionNode.getPid())) {
            //设置顶层菜单的level是1
            permissionNode.setLevel(1);
            //根据顶层菜单，向里面进行查询子菜单，封装到finalNode里面
            finalNode.add(selectChildren(permissionNode,permissionList));
        }
    }
    return finalNode;
}
private static Permission selectChildren(Permission permissionNode, List<Permission> permissionList) {
    //1 因为向一层菜单里面放二层菜单，二层里面还要放三层，把对象初始化
    permissionNode.setChildren(new ArrayList<Permission>());

    //2 遍历所有菜单list集合，进行判断比较，比较id和pid值是否相同
    for(Permission it : permissionList) {
        //判断 id和pid值是否相同
        if(permissionNode.getId().equals(it.getPid())) {
            //当前level=父菜单的level值+1
            int level = permissionNode.getLevel()+1;
            it.setLevel(level);
            //如果children为空，进行初始化操作
            //if(permissionNode.getChildren() == null) {
            //    permissionNode.setChildren(new ArrayList<Permission>());
            //}
            //把查询出来的子菜单放到父菜单里面
            permissionNode.getChildren().add(selectChildren(it,permissionList));
        }
    }
    return permissionNode;
}

@ApiOperation(value = "递归删除菜单")
@DeleteMapping("remove/{id}")
public R remove(@PathVariable String id) {
    permissionService.removeChildByIdGuli(id);
    return R.ok();
}

//============递归删除菜单==================================
@Override
public void removeChildByIdGuli(String id) {
    //1 创建list集合，用于封装所有删除菜单id值
    List<String> idList = new ArrayList<>();
    //2 向idList集合设置删除菜单id
    this.selectPermissionChildById(id, idList);
    //把当前id封装到list里面
    idList.add(id);
    baseMapper.deleteBatchIds(idList);
}

//2 根据当前菜单id，查询菜单里面子菜单id，封装到list集合
private void selectPermissionChildById(String id, List<String> idList) {
    //查询菜单里面子菜单id
    QueryWrapper<Permission> wrapper = new QueryWrapper<>();
    wrapper.eq("pid", id);
    wrapper.select("id");
    List<Permission> childIdList = baseMapper.selectList(wrapper);
    //把childIdList里面菜单id值获取出来，封装idList里面，做递归查询
    childIdList.stream().forEach(item -> {
        //封装idList里面
        idList.add(item.getId());
        //递归查询
        this.selectPermissionChildById(item.getId(), idList);
    });
}

@ApiOperation(value = "给角色分配权限")
@PostMapping("/doAssign")
public R doAssign(String roleId,String[] permissionId) {
    permissionService.saveRolePermissionRealtionShipGuli(roleId,permissionId);
    return R.ok();
}

//=========================给角色分配菜单=======================
@Override
public void saveRolePermissionRealtionShipGuli(String roleId, String[] permissionIds) {
    //roleId角色id
    //permissionId菜单id 数组形式
    //1 创建list集合，用于封装添加数据
    List<RolePermission> rolePermissionList = new ArrayList<>();
    //遍历所有菜单数组
    for (String perId : permissionIds) {
        //RolePermission对象
        RolePermission rolePermission = new RolePermission();
        rolePermission.setRoleId(roleId);
        rolePermission.setPermissionId(perId);
        //封装到list集合
        rolePermissionList.add(rolePermission);
    }
    //添加到角色菜单关系表
    rolePermissionService.saveBatch(rolePermissionList);
}