package com.vincent.rsf.server.system.controller;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.OrderItem;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.IService;
|
import com.vincent.rsf.common.utils.Utils;
|
import com.vincent.rsf.framework.common.Cools;
|
import com.vincent.rsf.server.common.domain.BaseParam;
|
import com.vincent.rsf.server.common.domain.CursorPageParam;
|
import com.vincent.rsf.server.common.domain.CursorPageResult;
|
import com.vincent.rsf.server.common.domain.PageParam;
|
import com.vincent.rsf.server.system.entity.User;
|
import org.springframework.security.core.Authentication;
|
import org.springframework.security.core.GrantedAuthority;
|
import org.springframework.security.core.context.SecurityContextHolder;
|
|
import java.lang.reflect.Field;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.function.Consumer;
|
|
/**
|
* Created by vincent on 1/30/2024
|
*/
|
|
public class BaseController {
|
public User getLoginUser() {
|
try {
|
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
|
if (authentication != null) {
|
Object object = authentication.getPrincipal();
|
if (object instanceof User) {
|
return (User) object;
|
}
|
}
|
} catch (Exception e) {
|
System.out.println(e.getMessage());
|
}
|
return null;
|
}
|
|
public Long getLoginUserId() {
|
User loginUser = getLoginUser();
|
return loginUser == null ? null : loginUser.getId();
|
}
|
|
public Long getTenantId() {
|
User loginUser = getLoginUser();
|
return loginUser == null ? null : loginUser.getTenantId();
|
}
|
|
public boolean hasAuthority(String authority) {
|
if (authority == null || authority.trim().isEmpty()) {
|
return false;
|
}
|
try {
|
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
|
if (authentication == null || authentication.getAuthorities() == null) {
|
return false;
|
}
|
for (GrantedAuthority grantedAuthority : authentication.getAuthorities()) {
|
if (grantedAuthority != null && authority.equals(grantedAuthority.getAuthority())) {
|
return true;
|
}
|
}
|
} catch (Exception e) {
|
System.out.println(e.getMessage());
|
}
|
return false;
|
}
|
|
public <T extends BaseParam> T buildParam(Map<String, Object> map, Class<T> clz) {
|
if (!Objects.isNull(map.get("meta"))) {
|
Map<String, Object> meta = (Map<String, Object>) map.get("meta");
|
meta.keySet().forEach(key -> {
|
map.put(key, meta.get(key));
|
});
|
map.remove("meta");
|
}
|
// 移除筛选条件里面的 $
|
for (String key : map.keySet()) {
|
Object value = map.get(key);
|
if (key.equals("orderBy")) {
|
String newValue = value.toString().replace("$", "");
|
map.replace("orderBy", value, newValue);
|
}
|
}
|
T t = null;
|
try {
|
t = clz.getDeclaredConstructor().newInstance();
|
t.syncMap(map);
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
return t;
|
}
|
|
public Boolean hasCreateTimeDesc(List<OrderItem> orderItems) {
|
if (Cools.isEmpty(orderItems)) {
|
return true;
|
}
|
if (orderItems.size() > 1) {
|
return false;
|
}
|
OrderItem orderItem = orderItems.get(0);
|
if (!orderItem.getColumn().equals("create_time")) {
|
return false;
|
}
|
if (orderItem.isAsc()) {
|
return false;
|
}
|
return true;
|
}
|
|
/**
|
* 通用游标分页实现。
|
*
|
* <p>这个方法的目标不是替代所有分页，而是把“单字段、倒序、向后翻页”的游标分页
|
* 收敛成一套统一实现，避免各个 controller 重复写下面这些样板逻辑：</p>
|
* <ul>
|
* <li>buildParam</li>
|
* <li>忽略前端传入的 orderBy</li>
|
* <li>buildWrapper(true) 构建通用筛选</li>
|
* <li>cursor 条件</li>
|
* <li>按固定字段倒序</li>
|
* <li>多查一条判断 hasNext</li>
|
* <li>截断结果并生成 nextCursor</li>
|
* </ul>
|
*
|
* <p>适用前提：</p>
|
* <ul>
|
* <li>游标字段是单一字段</li>
|
* <li>游标字段的值稳定、可比较，并且能映射成 Long</li>
|
* <li>分页方向固定为“按该字段倒序，向更小的值翻页”</li>
|
* </ul>
|
*
|
* <p>参数说明：</p>
|
* <ul>
|
* <li>{@code map}：原始请求参数</li>
|
* <li>{@code paramClass}：游标参数类型，通常传 {@link CursorPageParam}</li>
|
* <li>{@code entityClass}：实体类，用于 PageParam 条件构建和 condition 模糊查询</li>
|
* <li>{@code service}：MyBatis-Plus 的 IService，负责执行 page 查询</li>
|
* <li>{@code cursorField}：实体字段名，不是数据库列名，例如传 {@code id}</li>
|
* <li>{@code defaultPageSize}：当前接口的默认分页大小</li>
|
* <li>{@code wrapperConsumer}：可选的额外 where 条件扩展钩子</li>
|
* <li>{@code recordsConsumer}：可选的结果后处理钩子，例如补充 createBy$/updateBy$</li>
|
* </ul>
|
*/
|
protected <T, U extends CursorPageParam> CursorPageResult<T> cursorPage(
|
Map<String, Object> map,
|
Class<U> paramClass,
|
Class<T> entityClass,
|
IService<T> service,
|
String cursorField,
|
int defaultPageSize,
|
Consumer<QueryWrapper<T>> wrapperConsumer,
|
Consumer<List<T>> recordsConsumer
|
) {
|
// 允许 controller 传 null，内部统一兜底成空 map，
|
// 这样 buildParam 不需要每个调用方自己先判空。
|
U baseParam = buildParam(map == null ? new HashMap<>() : map, paramClass);
|
|
// 游标分页不允许客户端自定义排序，
|
// 否则“上一页最后一条作为下一页游标”的前提会被破坏。
|
baseParam.setOrderBy(null);
|
|
// pageSize 允许从请求里带入，但非法值（null、0、负数）统一回退到接口默认值。
|
int pageSize = resolveCursorPageSize(baseParam.getPageSize(), defaultPageSize);
|
|
// controller 传的是实体字段名，例如 "id" / "poId"，
|
// 这里统一转成数据库列名并补反引号，避免每个业务自己手写 SQL 片段。
|
String cursorColumn = resolveCursorColumn(cursorField);
|
|
// 先复用系统现有的 PageParam + buildWrapper(true) 机制，
|
// 保留原来的条件解析、时间范围、condition 模糊搜索等能力。
|
PageParam<T, U> pageParam = new PageParam<>(baseParam, entityClass);
|
QueryWrapper<T> wrapper = pageParam.buildWrapper(true);
|
|
// 给业务预留额外 where 条件的扩展点；
|
// 如果某个接口除了通用筛选外，还要拼接额外限制，可以在这里补。
|
if (wrapperConsumer != null) {
|
wrapperConsumer.accept(wrapper);
|
}
|
|
// 游标分页的核心条件：
|
// 当前约定是“按 cursorField 倒序查看更旧的数据”，所以条件固定为 < cursor。
|
if (baseParam.getCursor() != null) {
|
wrapper.lt(cursorColumn, baseParam.getCursor());
|
}
|
|
// 强制按游标字段倒序排序，保证每一页的数据顺序稳定。
|
wrapper.orderByDesc(cursorColumn);
|
|
// 多查一条是游标分页判断 hasNext 的常见做法：
|
// 实际要 20 条，就查 21 条；多出来那一条只用来判断是否还有下一页。
|
Page<T> queryPage = new Page<>(1L, pageSize + 1L, false);
|
List<T> records = service.page(queryPage, wrapper).getRecords();
|
List<T> pageRecords = Cools.isEmpty(records) ? new ArrayList<>() : new ArrayList<>(records);
|
|
// 如果查出来的数量大于 pageSize，说明至少还有下一页。
|
boolean hasNext = pageRecords.size() > pageSize;
|
if (hasNext) {
|
// 只把真正需要返回给前端的 pageSize 条数据留在当前页。
|
pageRecords = new ArrayList<>(pageRecords.subList(0, pageSize));
|
}
|
|
// 给业务侧一个“结果出库前处理”的机会。
|
// 典型场景是批量补充用户名、字典文本、缓存字段等，
|
// 这样公共分页逻辑不关心业务细节，但业务也不需要回到 controller 自己重写分页。
|
if (recordsConsumer != null && !Cools.isEmpty(pageRecords)) {
|
recordsConsumer.accept(pageRecords);
|
}
|
|
CursorPageResult<T> result = new CursorPageResult<>();
|
result.setRecords(pageRecords);
|
result.setPageSize(pageSize);
|
result.setHasNext(hasNext);
|
// nextCursor 只有在还有下一页时才有意义；
|
// 约定取“当前页最后一条记录”的游标字段值。
|
result.setNextCursor(hasNext ? extractCursorValue(pageRecords, cursorField) : null);
|
return result;
|
}
|
|
/**
|
* 统一解析当前接口实际使用的 pageSize。
|
*
|
* <p>只要前端没传、传了 0、或者传了负数，就回退到 controller 传入的默认值。</p>
|
*/
|
private int resolveCursorPageSize(Integer pageSize, int defaultPageSize) {
|
if (pageSize == null || pageSize <= 0) {
|
return defaultPageSize;
|
}
|
return pageSize;
|
}
|
|
/**
|
* 把实体字段名转换成数据库列名。
|
*
|
* <p>例如：</p>
|
* <ul>
|
* <li>{@code id -> `id`}</li>
|
* <li>{@code poId -> `po_id`}</li>
|
* </ul>
|
*
|
* <p>这样 controller 调用时只需要关心 Java 字段名，不需要自己拼 SQL。</p>
|
*/
|
private String resolveCursorColumn(String cursorField) {
|
return "`" + Utils.toSymbolCase(cursorField, '_') + "`";
|
}
|
|
/**
|
* 从当前页最后一条记录中提取 nextCursor。
|
*
|
* <p>这里使用反射而不是额外定义接口，目的是降低接入成本：
|
* 只要实体里存在同名字段，就能直接复用通用方法。</p>
|
*
|
* <p>支持的字段值类型：</p>
|
* <ul>
|
* <li>{@link Long}</li>
|
* <li>其他 {@link Number}</li>
|
* <li>可转成 Long 的字符串</li>
|
* </ul>
|
*
|
* <p>如果字段不存在、为空、或无法转成 Long，则返回 null。</p>
|
*/
|
private <T> Long extractCursorValue(List<T> records, String cursorField) {
|
if (Cools.isEmpty(records)) {
|
return null;
|
}
|
T lastRecord = records.get(records.size() - 1);
|
if (lastRecord == null || Cools.isEmpty(cursorField)) {
|
return null;
|
}
|
Field field = Cools.getField(lastRecord.getClass(), cursorField);
|
if (field == null) {
|
return null;
|
}
|
boolean accessible = field.isAccessible();
|
try {
|
field.setAccessible(true);
|
Object value = field.get(lastRecord);
|
if (value instanceof Long) {
|
return (Long) value;
|
}
|
if (value instanceof Number) {
|
return ((Number) value).longValue();
|
}
|
if (value instanceof String && !((String) value).trim().isEmpty()) {
|
return Long.parseLong(((String) value).trim());
|
}
|
} catch (IllegalAccessException | NumberFormatException ignored) {
|
return null;
|
} finally {
|
field.setAccessible(accessible);
|
}
|
return null;
|
}
|
|
}
|
