Java Code Examples for com.baomidou.mybatisplus.extension.plugins.pagination.Page#setSize()

protected Page setPageParam(QueryParam queryParam, OrderItem defaultOrder) {
    Page page = new Page();
    // 设置当前页码
    page.setCurrent(queryParam.getCurrent());
    // 设置页大小
    page.setSize(queryParam.getSize());
    /**
     * 如果是queryParam是OrderQueryParam，并且不为空，则使用前端排序
     * 否则使用默认排序
     */
    if (queryParam instanceof OrderQueryParam){
        OrderQueryParam orderQueryParam = (OrderQueryParam) queryParam;
        List<OrderItem> orderItems = orderQueryParam.getOrders();
        if (CollectionUtils.isEmpty(orderItems)){
            page.setOrders(Arrays.asList(defaultOrder));
        }else{
            page.setOrders(orderItems);
        }
    }else{
        page.setOrders(Arrays.asList(defaultOrder));
    }

    return page;
}
 

@Override
public IPage<SysDictType> getPageList(SysDictTypeVO sysDictTypeVO) {
    QueryWrapper<SysDictType> queryWrapper = new QueryWrapper<>();

    // 字典名称
    if (StringUtils.isNotEmpty(sysDictTypeVO.getDictName()) && !StringUtils.isEmpty(sysDictTypeVO.getDictName().trim())) {
        queryWrapper.like(SQLConf.DICT_NAME, sysDictTypeVO.getDictName().trim());
    }

    // 字典类型
    if (StringUtils.isNotEmpty(sysDictTypeVO.getDictType()) && !StringUtils.isEmpty(sysDictTypeVO.getDictType().trim())) {
        queryWrapper.like(SQLConf.DICT_TYPE, sysDictTypeVO.getDictType().trim());
    }

    Page<SysDictType> page = new Page<>();
    page.setCurrent(sysDictTypeVO.getCurrentPage());
    page.setSize(sysDictTypeVO.getPageSize());
    queryWrapper.eq(SQLConf.STATUS, EStatus.ENABLE);
    queryWrapper.orderByDesc(SQLConf.SORT, SQLConf.CREATE_TIME);
    IPage<SysDictType> pageList = sysDictTypeService.page(page, queryWrapper);
    return pageList;
}
 

@Override
public IPage<Blog> searchBlogByAuthor(String author, Long currentPage, Long pageSize) {
    QueryWrapper<Blog> queryWrapper = new QueryWrapper<>();

    Page<Blog> page = new Page<>();
    page.setCurrent(currentPage);
    page.setSize(pageSize);

    queryWrapper.eq(SQLConf.AUTHOR, author);
    queryWrapper.eq(BaseSQLConf.IS_PUBLISH, EPublish.PUBLISH);
    queryWrapper.eq(BaseSQLConf.STATUS, EStatus.ENABLE);
    queryWrapper.orderByDesc(SQLConf.CREATE_TIME);

    queryWrapper.select(Blog.class, i -> !i.getProperty().equals(SysConf.CONTENT));

    IPage<Blog> pageList = blogService.page(page, queryWrapper);
    List<Blog> list = pageList.getRecords();
    list = blogService.setTagAndSortAndPictureByBlogList(list);
    pageList.setRecords(list);
    return pageList;
}
 

@ApiOperation(value = "获取用户反馈", notes = "获取用户反馈")
@GetMapping("/getFeedbackList")
public String getFeedbackList(HttpServletRequest request) {
    if (request.getAttribute(SysConf.USER_UID) == null) {
        return ResultUtil.result(SysConf.ERROR, MessageConf.INVALID_TOKEN);
    }
    String userUid = request.getAttribute(SysConf.USER_UID).toString();

    QueryWrapper<Feedback> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq(SQLConf.USER_UID, userUid);
    queryWrapper.eq(SQLConf.STATUS, EStatus.ENABLE);
    queryWrapper.orderByDesc(SQLConf.CREATE_TIME);
    Page<Feedback> page = new Page<>();
    page.setSize(20);
    page.setCurrent(1);
    IPage<Feedback> pageList = feedbackService.page(page, queryWrapper);
    return ResultUtil.result(SysConf.SUCCESS, pageList);
}
 

@Override
public IPage<Blog> getSameBlogByTagUid(String tagUid) {
    QueryWrapper<Blog> queryWrapper = new QueryWrapper<>();
    Page<Blog> page = new Page<>();
    page.setCurrent(1);
    page.setSize(10);
    queryWrapper.like(SQLConf.TAG_UID, tagUid);
    queryWrapper.orderByDesc(SQLConf.CREATE_TIME);
    queryWrapper.eq(SQLConf.STATUS, EStatus.ENABLE);
    queryWrapper.eq(SQLConf.IS_PUBLISH, EPublish.PUBLISH);
    IPage<Blog> pageList = blogService.page(page, queryWrapper);
    List<Blog> list = pageList.getRecords();
    list = blogService.setTagAndSortByBlogList(list);
    pageList.setRecords(list);
    return pageList;
}
 

@Override
public String stickLink(LinkVO linkVO) {
    Link link = linkService.getById(linkVO.getUid());

    //查找出最大的那一个
    QueryWrapper<Link> queryWrapper = new QueryWrapper<>();
    queryWrapper.orderByDesc(SQLConf.SORT);
    Page<Link> page = new Page<>();
    page.setCurrent(0);
    page.setSize(1);
    IPage<Link> pageList = linkService.page(page, queryWrapper);
    List<Link> list = pageList.getRecords();
    Link maxSort = list.get(0);
    if (StringUtils.isEmpty(maxSort.getUid())) {
        return ResultUtil.result(SysConf.ERROR, MessageConf.PARAM_INCORRECT);
    }
    if (maxSort.getUid().equals(link.getUid())) {
        return ResultUtil.result(SysConf.ERROR, MessageConf.OPERATION_FAIL);
    }
    Integer sortCount = maxSort.getSort() + 1;
    link.setSort(sortCount);
    link.setUpdateTime(new Date());
    link.updateById();
    return ResultUtil.result(SysConf.SUCCESS, MessageConf.OPERATION_SUCCESS);
}
 

@Override
public IPage<Todo> getPageList(TodoVO todoVO) {
    String adminUid = RequestHolder.getAdminUid();
    QueryWrapper<Todo> queryWrapper = new QueryWrapper<>();

    if (StringUtils.isNotEmpty(todoVO.getKeyword()) && !StringUtils.isEmpty(todoVO.getKeyword().trim())) {
        queryWrapper.like(SQLConf.TEXT, todoVO.getKeyword().trim());
    }
    queryWrapper.eq(SQLConf.ADMINUID, adminUid);

    //按时间顺序倒排
    queryWrapper.orderByDesc(SQLConf.CREATE_TIME);

    Page<Todo> page = new Page<>();
    page.setCurrent(todoVO.getCurrentPage());
    page.setSize(todoVO.getPageSize());
    queryWrapper.eq(SQLConf.STATUS, EStatus.ENABLE);
    IPage<Todo> pageList = todoService.page(page, queryWrapper);
    return pageList;
}
 

@Override
public IPage<Link> getPageList(LinkVO linkVO) {
    QueryWrapper<Link> queryWrapper = new QueryWrapper<>();
    if (StringUtils.isNotEmpty(linkVO.getKeyword()) && !StringUtils.isEmpty(linkVO.getKeyword().trim())) {
        queryWrapper.like(SQLConf.TITLE, linkVO.getKeyword().trim());
    }

    if (linkVO.getLinkStatus() != null) {
        queryWrapper.eq(SQLConf.LINK_STATUS, linkVO.getLinkStatus());
    }

    Page<Link> page = new Page<>();
    page.setCurrent(linkVO.getCurrentPage());
    page.setSize(linkVO.getPageSize());
    queryWrapper.eq(SQLConf.STATUS, EStatus.ENABLE);
    queryWrapper.orderByDesc(SQLConf.SORT);
    IPage<Link> pageList = linkService.page(page, queryWrapper);
    return pageList;
}
 

@Override
public String stickTag(TagVO tagVO) {
    Tag tag = tagService.getById(tagVO.getUid());

    //查找出最大的那一个
    QueryWrapper<Tag> queryWrapper = new QueryWrapper<>();
    queryWrapper.orderByDesc(SQLConf.SORT);
    Page<Tag> page = new Page<>();
    page.setCurrent(0);
    page.setSize(1);
    IPage<Tag> pageList = tagService.page(page, queryWrapper);
    List<Tag> list = pageList.getRecords();
    Tag maxTag = list.get(0);

    if (StringUtils.isEmpty(maxTag.getUid())) {
        return ResultUtil.result(SysConf.ERROR, MessageConf.PARAM_INCORRECT);
    }
    if (maxTag.getUid().equals(tag.getUid())) {
        return ResultUtil.result(SysConf.ERROR, MessageConf.THIS_TAG_IS_TOP);
    }

    Integer sortCount = maxTag.getSort() + 1;

    tag.setSort(sortCount);
    tag.setUpdateTime(new Date());
    tag.updateById();

    return ResultUtil.result(SysConf.SUCCESS, MessageConf.OPERATION_SUCCESS);
}
 

@Override
public String stickBlogSort(BlogSortVO blogSortVO) {
    BlogSort blogSort = blogSortService.getById(blogSortVO.getUid());

    //查找出最大的那一个
    QueryWrapper<BlogSort> queryWrapper = new QueryWrapper<>();
    queryWrapper.orderByDesc(SQLConf.SORT);
    Page<BlogSort> page = new Page<>();
    page.setCurrent(0);
    page.setSize(1);
    IPage<BlogSort> pageList = blogSortService.page(page, queryWrapper);
    List<BlogSort> list = pageList.getRecords();
    BlogSort maxSort = list.get(0);

    if (StringUtils.isEmpty(maxSort.getUid())) {
        return ResultUtil.result(SysConf.ERROR, MessageConf.PARAM_INCORRECT);
    }
    if (maxSort.getUid().equals(blogSort.getUid())) {
        return ResultUtil.result(SysConf.ERROR, MessageConf.THIS_SORT_IS_TOP);
    }

    Integer sortCount = maxSort.getSort() + 1;

    blogSort.setSort(sortCount);

    blogSort.setUpdateTime(new Date());

    blogSort.updateById();

    return ResultUtil.result(SysConf.SUCCESS, MessageConf.OPERATION_SUCCESS);
}
 

@Override
    public IPage<ExceptionLog> getPageList(ExceptionLogVO exceptionLogVO) {
        QueryWrapper<ExceptionLog> queryWrapper = new QueryWrapper<>();
        if (!StringUtils.isEmpty(exceptionLogVO.getKeyword())) {
            queryWrapper.like(SQLConf.CONTENT, exceptionLogVO.getKeyword());
        }

        if (!StringUtils.isEmpty(exceptionLogVO.getOperation())) {
            queryWrapper.like(SQLConf.OPERATION, exceptionLogVO.getOperation());
        }

        if (!StringUtils.isEmpty(exceptionLogVO.getStartTime())) {
            String[] time = exceptionLogVO.getStartTime().split(SysConf.FILE_SEGMENTATION);
            if (time.length == 2) {
                queryWrapper.between(SQLConf.CREATE_TIME, DateUtils.str2Date(time[0]), DateUtils.str2Date(time[1]));
            }
        }

        Page<ExceptionLog> page = new Page<>();
        page.setCurrent(exceptionLogVO.getCurrentPage());
        page.setSize(exceptionLogVO.getPageSize());
        queryWrapper.eq(SQLConf.STATUS, EStatus.ENABLE);
        queryWrapper.orderByDesc(SQLConf.CREATE_TIME);
//        queryWrapper.select(ExceptionLog.class, i -> !i.getProperty().equals(SQLConf.EXCEPTION_JSON));
        IPage<ExceptionLog> pageList = exceptionLogService.page(page, queryWrapper);
        return pageList;
    }
 

@Override
public List<Blog> getSameBlogByBlogUid(String blogUid) {
    Blog blog = blogService.getById(blogUid);
    QueryWrapper<Blog> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq(SQLConf.STATUS, EStatus.ENABLE);
    Page<Blog> page = new Page<>();
    page.setCurrent(1);
    page.setSize(10);
    // 通过分类来获取相关博客
    String blogSortUid = blog.getBlogSortUid();
    queryWrapper.eq(SQLConf.BLOG_SORT_UID, blogSortUid);
    queryWrapper.eq(SQLConf.IS_PUBLISH, EPublish.PUBLISH);
    queryWrapper.orderByDesc(SQLConf.CREATE_TIME);
    IPage<Blog> pageList = blogService.page(page, queryWrapper);
    List<Blog> list = pageList.getRecords();
    list = blogService.setTagAndSortByBlogList(list);

    //过滤掉当前的博客
    List<Blog> newList = new ArrayList<>();
    for (Blog item : list) {
        if (item.getUid().equals(blogUid)) {
            continue;
        }
        newList.add(item);
    }
    return newList;
}
 

@Override
public IPage<Tag> getHotTag(Integer hotTagCount) {
    QueryWrapper<Tag> queryWrapper = new QueryWrapper<>();
    Page<Tag> page = new Page<>();
    page.setCurrent(1);
    page.setSize(hotTagCount);
    queryWrapper.eq(SQLConf.STATUS, EStatus.ENABLE);
    queryWrapper.orderByDesc(SQLConf.SORT);
    queryWrapper.orderByDesc(SQLConf.CLICK_COUNT);
    IPage<Tag> pageList = tagService.page(page, queryWrapper);
    return pageList;
}
 

@Override
public IPage<Tag> getPageList(TagVO tagVO) {
    QueryWrapper<Tag> queryWrapper = new QueryWrapper<>();
    if (StringUtils.isNotEmpty(tagVO.getKeyword()) && !StringUtils.isEmpty(tagVO.getKeyword())) {
        queryWrapper.like(SQLConf.CONTENT, tagVO.getKeyword().trim());
    }

    Page<Tag> page = new Page<>();
    page.setCurrent(tagVO.getCurrentPage());
    page.setSize(tagVO.getPageSize());
    queryWrapper.eq(SQLConf.STATUS, EStatus.ENABLE);
    queryWrapper.orderByDesc(SQLConf.SORT);
    IPage<Tag> pageList = tagService.page(page, queryWrapper);
    return pageList;
}
 

public PageVo pageList(CommonDTO commonDTO) {
    Page page = new Page();
    // 设置当前页码
    page.setCurrent(commonDTO.getPage());
    // 设置页大小
    page.setSize(commonDTO.getLimit());
    IPage iPage = this.baseMapper.pageList(page, commonDTO);
    return new PageVo(iPage);

}
 

@Override
public List<PluginData> getByPage(Long size, Long currentPage) {
    Page<PluginData> page = new Page<>();
    page.setSize(size);
    page.setCurrent(currentPage);
    IPage<PluginData> page1 = page(page);
    return page1.getRecords();
}
 

@Override
public List<Blog> getBlogListByTop(Integer top) {
    QueryWrapper<Blog> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq(SQLConf.STATUS, EStatus.ENABLE);
    Page<Blog> page = new Page<>();
    page.setCurrent(1);
    page.setSize(top);
    queryWrapper.eq(SQLConf.IS_PUBLISH, EPublish.PUBLISH);
    queryWrapper.orderByDesc(SQLConf.SORT);
    IPage<Blog> pageList = blogService.page(page, queryWrapper);
    List<Blog> list = pageList.getRecords();
    list = blogService.setTagAndSortAndPictureByBlogList(list);
    return list;
}
 

@Override
public Map<String, Object> getBlogByKeyword(String keywords, Long currentPage, Long pageSize) {
    final String keyword = keywords.trim();
    QueryWrapper<Blog> queryWrapper = new QueryWrapper<>();
    queryWrapper.and(wrapper -> wrapper.like(SQLConf.TITLE, keyword).or().like(SQLConf.SUMMARY, keyword));
    queryWrapper.eq(SQLConf.STATUS, EStatus.ENABLE);
    queryWrapper.eq(SQLConf.IS_PUBLISH, EPublish.PUBLISH);
    queryWrapper.select(Blog.class, i -> !i.getProperty().equals(SQLConf.CONTENT));
    queryWrapper.orderByDesc(SQLConf.CLICK_COUNT);
    Page<Blog> page = new Page<>();
    page.setCurrent(currentPage);
    page.setSize(pageSize);

    IPage<Blog> iPage = blogService.page(page, queryWrapper);

    List<Blog> blogList = iPage.getRecords();

    List<String> blogSortUidList = new ArrayList<>();
    Map<String, String> pictureMap = new HashMap<>();
    final StringBuffer fileUids = new StringBuffer();

    blogList.forEach(item -> {

        // 获取图片uid
        blogSortUidList.add(item.getBlogSortUid());
        if (StringUtils.isNotEmpty(item.getFileUid())) {
            fileUids.append(item.getFileUid() + SysConf.FILE_SEGMENTATION);
        }

        // 给标题和简介设置高亮
        item.setTitle(getHitCode(item.getTitle(), keyword));
        item.setSummary(getHitCode(item.getTitle(), keyword));

    });

    // 调用图片接口，获取图片
    String pictureList = null;
    if (fileUids != null) {
        pictureList = this.pictureFeignClient.getPicture(fileUids.toString(), SysConf.FILE_SEGMENTATION);
    }
    List<Map<String, Object>> picList = webUtil.getPictureMap(pictureList);

    picList.forEach(item -> {
        pictureMap.put(item.get(SQLConf.UID).toString(), item.get(SQLConf.URL).toString());
    });

    Collection<BlogSort> blogSortList = new ArrayList<>();
    if (blogSortUidList.size() > 0) {
        blogSortList = blogSortService.listByIds(blogSortUidList);
    }

    Map<String, String> blogSortMap = new HashMap<>();
    blogSortList.forEach(item -> {
        blogSortMap.put(item.getUid(), item.getSortName());
    });

    // 设置分类名 和 图片
    blogList.forEach(item -> {
        if (blogSortMap.get(item.getBlogSortUid()) != null) {
            item.setBlogSortName(blogSortMap.get(item.getBlogSortUid()));
        }

        //获取图片
        if (StringUtils.isNotEmpty(item.getFileUid())) {
            List<String> pictureUidsTemp = StringUtils.changeStringToString(item.getFileUid(), SysConf.FILE_SEGMENTATION);
            List<String> pictureListTemp = new ArrayList<>();

            pictureUidsTemp.forEach(picture -> {
                pictureListTemp.add(pictureMap.get(picture));
            });
            // 只设置一张标题图
            if (pictureListTemp.size() > 0) {
                item.setPhotoUrl(pictureListTemp.get(0));
            } else {
                item.setPhotoUrl("");
            }
        }
    });


    Map<String, Object> map = new HashMap<>();

    // 返回总记录数
    map.put(SysConf.TOTAL, iPage.getTotal());

    // 返回总页数
    map.put(SysConf.TOTAL_PAGE, iPage.getPages());

    // 返回当前页大小
    map.put(SysConf.PAGE_SIZE, pageSize);

    // 返回当前页
    map.put(SysConf.CURRENT_PAGE, iPage.getCurrent());

    // 返回数据
    map.put(SysConf.BLOG_LIST, blogList);

    return map;
}
 

@Override
public Map<String, Object> getPageList(CategoryMenuVO categoryMenuVO) {
    Map<String, Object> resultMap = new HashMap<>();
    QueryWrapper<CategoryMenu> queryWrapper = new QueryWrapper<>();
    if (StringUtils.isNotEmpty(categoryMenuVO.getKeyword()) && !StringUtils.isEmpty(categoryMenuVO.getKeyword().trim())) {
        queryWrapper.like(SQLConf.NAME, categoryMenuVO.getKeyword().trim());
    }

    if (categoryMenuVO.getMenuLevel() != 0) {
        queryWrapper.eq(SQLConf.MENU_LEVEL, categoryMenuVO.getMenuLevel());
    }

    Page<CategoryMenu> page = new Page<>();
    page.setCurrent(categoryMenuVO.getCurrentPage());
    page.setSize(categoryMenuVO.getPageSize());
    queryWrapper.eq(SQLConf.STATUS, EStatus.ENABLE);
    queryWrapper.orderByDesc(SQLConf.SORT);
    IPage<CategoryMenu> pageList = categoryMenuService.page(page, queryWrapper);
    List<CategoryMenu> list = pageList.getRecords();

    List<String> ids = new ArrayList<>();
    list.forEach(item -> {
        if (StringUtils.isNotEmpty(item.getParentUid())) {
            ids.add(item.getParentUid());
        }
    });

    if (ids.size() > 0) {
        Collection<CategoryMenu> parentList = categoryMenuService.listByIds(ids);
        Map<String, CategoryMenu> map = new HashMap<>();
        parentList.forEach(item -> {
            map.put(item.getUid(), item);
        });

        list.forEach(item -> {
            if (StringUtils.isNotEmpty(item.getParentUid())) {
                item.setParentCategoryMenu(map.get(item.getParentUid()));
            }
        });

        resultMap.put(SysConf.OTHER_DATA, parentList);
    }
    pageList.setRecords(list);
    resultMap.put(SysConf.DATA, pageList);
    return resultMap;
}
 

@Override
public IPage<Blog> searchBlogByBlogSort(String blogSortUid, Long currentPage, Long pageSize) {
    BlogSort blogSort = blogSortService.getById(blogSortUid);
    if (blogSort != null) {
        HttpServletRequest request = RequestHolder.getRequest();
        String ip = IpUtils.getIpAddr(request);

        //从Redis取出数据，判断该用户24小时内，是否点击过该分类
        String jsonResult = redisUtil.get(RedisConf.TAG_CLICK + RedisConf.SEGMENTATION + ip + RedisConf.WELL_NUMBER + blogSortUid);

        if (StringUtils.isEmpty(jsonResult)) {

            //给标签点击数增加
            int clickCount = blogSort.getClickCount() + 1;
            blogSort.setClickCount(clickCount);
            blogSort.updateById();

            //将该用户点击记录存储到redis中, 24小时后过期
            redisUtil.setEx(RedisConf.TAG_CLICK + RedisConf.SEGMENTATION + ip + RedisConf.WELL_NUMBER + blogSortUid, clickCount + "",
                    24, TimeUnit.HOURS);
        }

    }

    QueryWrapper<Blog> queryWrapper = new QueryWrapper<>();

    Page<Blog> page = new Page<>();
    page.setCurrent(currentPage);
    page.setSize(pageSize);

    queryWrapper.eq(SQLConf.BLOG_SORT_UID, blogSortUid);
    queryWrapper.orderByDesc(SQLConf.CREATE_TIME);
    queryWrapper.eq(BaseSQLConf.IS_PUBLISH, EPublish.PUBLISH);
    queryWrapper.eq(BaseSQLConf.STATUS, EStatus.ENABLE);

    queryWrapper.select(Blog.class, i -> !i.getProperty().equals(SysConf.CONTENT));
    IPage<Blog> pageList = blogService.page(page, queryWrapper);
    List<Blog> list = pageList.getRecords();
    list = blogService.setTagAndSortAndPictureByBlogList(list);
    pageList.setRecords(list);
    return pageList;
}