zzw
2023-12-01 e023474fc9bcc726ed558a0623f1316dddc13152
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
package com.zt.common.db.query;
 
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.zt.common.constant.Constant;
import com.zt.common.db.constant.OP;
import com.zt.common.db.constant.OrderType;
import org.apache.commons.lang3.StringUtils;
 
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
 
public class QueryFilter {
    /**
     * 分页组件
     */
    private Page page = new Page();
 
    private QueryWrapper queryWrapper = new QueryWrapper();
    /**
     * 字段参数构建列表
     */
    private Map<String, Object> params = new LinkedHashMap<>();
 
    public QueryFilter() {
    }
 
    public QueryFilter(List<QueryParam> queryParams) {
        try {
            for (QueryParam param : queryParams) {
                Object value = param.getValue();
                if (value == null || (value instanceof String && StringUtils.isBlank((String) value))) {
                    continue;// k空值跳过
                }
 
                this.params.put(param.getName(), value);
 
                /** 参数名称^条件 eg:a^EQ 则表示,a字段是varchar类型,条件是eq ^后第一个参数为数据类型 */
                if (StringUtils.isNotBlank(param.getFormat())) {// 指定格式
                    String[] aryParamKey = param.getFormat().split("\\^");
                    if (aryParamKey.length != 2) {
                        return;
                    }
                    String name = aryParamKey[0], op = aryParamKey[1];
                    if (OP.EQ.equals(op)) { // 等于
                        queryWrapper.eq(name, value);
                    } else if (OP.LESS.equals(op)) { // 小于
                        queryWrapper.lt(name, value);
                    } else if (OP.GT.equals(op)) { // 大于
                        queryWrapper.gt(name, value);
                    } else if (OP.LE.equals(op)) { // 小于等于
                        queryWrapper.le(name, value);
                    } else if (OP.GE.equals(op)) { // 大于等于
                        queryWrapper.ge(name, value);
                    } else if (OP.LIKE.equals(op)) { // 相似
                        queryWrapper.like(name, value);
                        this.params.put(param.getName(), "%" + value.toString() + "%");
                    } else if (OP.LEFT_LIKE.equals(op)) { // 左相似
                        queryWrapper.likeLeft(name, value);
                        this.params.put(param.getName(), "%" + value.toString());
                    } else if (OP.RIGHT_LIKE.equals(op)) { // 右相似
                        queryWrapper.likeRight(name, value);
                        this.params.put(param.getName(), value.toString() + "%");
                    } else if (OP.IN.equals(op)) { // 在...中
                        queryWrapper.in(name, value.toString().split(","));
                    } else if (OP.NOT_IN.equals(op)) { // 不在...中
                        queryWrapper.notIn(name, value.toString().split(","));
                    }
                }
            }
 
            String offset = String.valueOf(params.get(Constant.Q.PAGE));
            String limit = String.valueOf(params.get(Constant.Q.LIMIT));
            if (StringUtils.isNotBlank(offset) && StringUtils.isNotBlank(limit)) {
                Page page = new Page(Long.parseLong(offset), Long.parseLong(limit));
                // 分页参数
                params.put(Constant.Q.PAGE, page);
                // 分页对象
                this.setPage(page);
            }
 
            // 排序字段
            String orderField = (String) params.get(Constant.Q.ORDER_FIELD);
            String order = (String) params.get(Constant.Q.ORDER);
 
            // 前端字段排序
            if (StringUtils.isNotBlank(orderField) && StringUtils.isNotBlank(order)) {
                if (OrderType.fromString(order) == OrderType.ASC) {
                    queryWrapper.orderByAsc(orderField);
                } else {
                    queryWrapper.orderByDesc(orderField);
                }
            }
        } catch (Exception e) {
        }
    }
 
    public Page getPage() {
        return page;
    }
 
    public void setPage(Page page) {
        this.page = page;
    }
 
    public void addParam(String key, Object obj) {
        this.params.put(key, obj);
    }
 
    public Map<String, Object> getParams() {
        return params;
    }
 
    /**
     * 给工作流用的
     *
     * @return
     */
    public Map<String, Object> getQueryParams() {
        Map<String, Object> params = this.getParams();
 
        // 构建动态条件SQL
        String dynamicWhereSql = queryWrapper.getCustomSqlSegment();
        if (StringUtils.isNotEmpty(dynamicWhereSql)) {
            params.put("whereSql", dynamicWhereSql.replace("ew.paramNameValuePairs.", "").substring("where".length()));
        }
        params.putAll(queryWrapper.getParamNameValuePairs());
 
        Page page = (Page) params.get(Constant.Q.PAGE);
        if (page != null) {
            List<OrderItem> orderItems = page.getOrders();
            if (orderItems.size() > 0) {
                StringBuilder sb = new StringBuilder();
                for (OrderItem orderItem : orderItems) {
                    sb.append(orderItem.getColumn()).append(" ").append(orderItem.isAsc() ? "" : "desc").append(",");
                }
                sb.deleteCharAt(sb.length() - 1);
                params.put("orderBySql", sb.toString());
            }
        }
        return params;
    }
 
    public QueryWrapper getWrapper() {
        return queryWrapper;
    }
 
    public <T> List<T> getPageList(List<T> list) {
        return new PageList<>(list, page.getTotal());
    }
 
    public <T> List<T> getPageList(List<T> list, int total) {
        return new PageList<>(list, total);
    }
}