#

Junjie

20 小时以前 0ed68cc1d412d1722d52c5c41777970924221be4

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
package com.zy.asrs.controller;
 
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.core.annotations.ManagerAuth;
import com.core.common.BaseRes;
import com.core.common.Cools;
import com.core.common.DateUtils;
import com.core.common.R;
import com.zy.asrs.entity.ApiLog;
import com.zy.asrs.service.ApiLogService;
import com.zy.common.web.BaseController;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
@RestController
public class ApiLogController extends BaseController {
 
    @Autowired
    private ApiLogService apiLogService;
 
    @RequestMapping(value = "/apiLog/{id}/auth")
    @ManagerAuth
    public R get(@PathVariable("id") String id) {
        return R.ok(apiLogService.getById(String.valueOf(id)));
    }
 
    @RequestMapping(value = "/apiLog/list/auth")
    @ManagerAuth
    public R list(@RequestParam(defaultValue = "1")Integer curr,
                  @RequestParam(defaultValue = "10")Integer limit,
                  @RequestParam(required = false)String orderByField,
                  @RequestParam(required = false)String orderByType,
                  @RequestParam(required = false)String condition,
                  @RequestParam Map<String, Object> param){
        QueryWrapper<ApiLog> wrapper = new QueryWrapper<>();
        excludeTrash(param);
        convert(param, wrapper);
        allLike(ApiLog.class, param.keySet(), wrapper, condition);
        if (!Cools.isEmpty(orderByField)){wrapper.orderBy(true, "asc".equals(orderByType), humpToLine(orderByField));} else {
            wrapper.orderBy(true, false, "create_time");
        }
        return R.ok(apiLogService.page(new Page<>(curr, limit), wrapper));
    }
 
    private <T> void convert(Map<String, Object> map, QueryWrapper<T> wrapper){
        for (Map.Entry<String, Object> entry : map.entrySet()){
            String val = String.valueOf(entry.getValue());
            String column = humpToLine(entry.getKey());
            if (val.contains(RANGE_TIME_LINK)){
                String[] dates = val.split(RANGE_TIME_LINK);
                wrapper.ge(column, DateUtils.convert(dates[0]));
                wrapper.le(column, DateUtils.convert(dates[1]));
            } else {
                wrapper.like(column, val);
            }
        }
    }
 
    @RequestMapping(value = "/apiLog/add/auth")
    @ManagerAuth
    public R add(ApiLog apiLog) {
        apiLogService.save(apiLog);
        return R.ok();
    }
 
    @RequestMapping(value = "/apiLog/update/auth")
    @ManagerAuth
    public R update(ApiLog apiLog){
        if (Cools.isEmpty(apiLog) || null==apiLog.getId()){
            return R.error();
        }
        apiLogService.updateById(apiLog);
        return R.ok();
    }
 
    @RequestMapping(value = "/apiLog/delete/auth")
    @ManagerAuth
    public R delete(@RequestParam(value="ids[]") Long[] ids){
         for (Long id : ids){
            apiLogService.removeById(id);
        }
        return R.ok();
    }
 
    @RequestMapping(value = "/apiLog/export/auth")
    @ManagerAuth
    public R export(@RequestBody JSONObject param){
        QueryWrapper<ApiLog> wrapper = new QueryWrapper<>();
        List<String> fields = JSONObject.parseArray(param.getJSONArray("fields").toJSONString(), String.class);
        Map<String, Object> map = excludeTrash(param.getJSONObject("apiLog"));
        convert(map, wrapper);
        List<ApiLog> list = apiLogService.list(wrapper);
        return R.ok(exportSupport(list, fields));
    }
 
    @RequestMapping(value = "/apiLogQuery/auth")
    @ManagerAuth
    public R query(String condition) {
        QueryWrapper<ApiLog> wrapper = new QueryWrapper<>();
        wrapper.like("uuid", condition);
        Page<ApiLog> page = apiLogService.page(new Page<>(0, 10), wrapper);
        List<Map<String, Object>> result = new ArrayList<>();
        for (ApiLog apiLog : page.getRecords()){
            Map<String, Object> map = new HashMap<>();
            map.put("id", apiLog.getId());
            map.put("value", apiLog.getId());
            result.add(map);
        }
        return R.ok(result);
    }
 
    @RequestMapping(value = "/apiLog/check/column/auth")
    @ManagerAuth
    public R query(@RequestBody JSONObject param) {
        QueryWrapper<ApiLog> wrapper = new QueryWrapper<ApiLog>().eq(humpToLine(String.valueOf(param.get("key"))), param.get("val"));
        if (null != apiLogService.getOne(wrapper)){
            return R.parse(BaseRes.REPEAT).add(getComment(ApiLog.class, String.valueOf(param.get("key"))));
        }
        return R.ok();
    }
 
}