“djh”
4 天以前 7acaebcb01438578ded72491f39105db893982ef
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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
package com.gkhy.exam.admin.controller.web;
 
import com.gkhy.exam.common.api.CommonResult;
import com.gkhy.exam.system.domain.*;
import com.gkhy.exam.system.domain.req.*;
import com.gkhy.exam.system.service.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
 
@Api(tags = "企业质量目标管理")
@RestController
@RequestMapping("/quality-target")
public class QualityController {
 
    @Autowired
    private QualityService qualityService;
 
    @Autowired
    private QualityTargetService qualityTargetService;
 
    @Autowired
    private QualityAccomplishService qualityAccomplishService;
 
    @Autowired
    private QualityDecomposeService qualityDecomposeService;
 
    @Autowired
    private CatalogueService catalogueService;
 
 
    /**
     * 质量目标列表
     * @param quality
     * @return
     */
    @ApiOperation(value = "质量目标列表(分页)")
    @ApiImplicitParams({
            @ApiImplicitParam(paramType = "query", name = "pageNum", dataType = "int", required = false, value = "当前页,默认1"),
            @ApiImplicitParam(paramType = "query", name = "pageSize", dataType = "int", required = false, value = "每页数目,默认10"),
    })
    @GetMapping("/policy/list")
    public CommonResult listQuality(Quality quality){
        return CommonResult.success(qualityService.selectQualityList(quality));
    }
 
    @GetMapping("/policy/listAll")
    public CommonResult listQualityAll(Quality quality){
        return CommonResult.success(qualityService.selectQualityListAll(quality));
    }
 
    /**
     * 质量目标新增
     * @param qualityTargetReq
     * @return
     */
    @ApiOperation(value = "质量目标新增")
    @PostMapping("/policy/insert")
    public CommonResult insertQuality(@RequestBody QualityTargetReq qualityTargetReq){
        return qualityService.insertQuality(qualityTargetReq);
    }
 
    /**
     * 质量目标修改
     * @param qualityTargetReq
     * @return
     */
    @ApiOperation(value = "质量目标修改")
    @PostMapping("/policy/update")
    public CommonResult updateQuality(@RequestBody QualityTargetReq qualityTargetReq){
        return qualityService.updateQuality(qualityTargetReq);
    }
 
    /**
     * 质量目标删除
     * @param qualityId
     * @return
     */
    @ApiOperation(value = "质量目标删除")
    @GetMapping("/policy/deleted")
    public CommonResult deletedQuality(@RequestParam("qualityId") Integer qualityId){
        return qualityService.deletedQuality(qualityId);
    }
 
    /**
     * 质量目标分解列表
     * @param qualityReq
     * @return
     */
    @ApiOperation(value = "质量目标分解列表(分页)")
    @ApiImplicitParams({
            @ApiImplicitParam(paramType = "query", name = "pageNum", dataType = "int", required = false, value = "当前页,默认1"),
            @ApiImplicitParam(paramType = "query", name = "pageSize", dataType = "int", required = false, value = "每页数目,默认10"),
    })
    @GetMapping("/decompose/list")
    public CommonResult listQualityDecompose(QualityReq qualityReq){
        return CommonResult.success(qualityDecomposeService.selectQualityDecomposeList(qualityReq));
    }
 
    /**
     * 质量目标分解新增
     * @param decomposeTargetReq
     * @return
     */
    @ApiOperation(value = "质量目标分解新增")
    @PostMapping("/decompose/insert")
    public CommonResult insertQualityDecompose(@RequestBody DecomposeTargetReq decomposeTargetReq){
        return qualityDecomposeService.insertQualityDecompose(decomposeTargetReq);
    }
 
    /**
     * 质量目标分解修改
     * @param decomposeTargetReq
     * @return
     */
    @ApiOperation(value = "质量目标分解修改")
    @PostMapping("/decompose/update")
    public CommonResult updateQualityDecompose(@RequestBody DecomposeTargetReq decomposeTargetReq){
        return qualityDecomposeService.updateQualityDecompose(decomposeTargetReq);
    }
 
    /**
     * 质量目标分解删除
     * @param decomposeId
     * @return
     */
    @ApiOperation(value = "质量目标分解删除")
    @GetMapping("/decompose/deleted")
    public CommonResult deletedQualityDecompose(@RequestParam("qualityDecomposeId") Integer decomposeId){
        return qualityDecomposeService.deletedQualityDecompose(decomposeId);
    }
 
 
    /**
     * 质量目标完成情况列表
     * @param qualityReq
     * @return
     */
    @ApiOperation(value = "质量目标完成情况列表(分页)")
    @ApiImplicitParams({
            @ApiImplicitParam(paramType = "query", name = "pageNum", dataType = "int", required = false, value = "当前页,默认1"),
            @ApiImplicitParam(paramType = "query", name = "pageSize", dataType = "int", required = false, value = "每页数目,默认10"),
    })
    @GetMapping("/accomplish/list")
    public CommonResult listQualityAccomplish(QualityReq qualityReq){
        return CommonResult.success(qualityAccomplishService.selectQualityAccomplishList(qualityReq));
    }
 
    /**
     * 质量目标完成情况新增
     * @param qualityAccomplish
     * @return
     */
    @ApiOperation(value = "质量目标完成情况新增")
    @PostMapping("/accomplish/insert")
    public CommonResult insertQualityAccomplish(@RequestBody QualityAccomplish qualityAccomplish){
        return qualityAccomplishService.insertQualityAccomplish(qualityAccomplish);
    }
 
    /**
     * 质量目标完成情况修改
     * @param qualityAccomplish
     * @return
     */
    @ApiOperation(value = "质量目标完成情况修改")
    @PostMapping("/accomplish/update")
    public CommonResult updateQualityAccomplish(@RequestBody QualityAccomplish qualityAccomplish){
        return qualityAccomplishService.updateQualityAccomplish(qualityAccomplish);
    }
 
    /**
     * 质量目标完成情况删除
     * @param qualityAccomplishId
     * @return
     */
    @ApiOperation(value = "质量目标完成情况删除")
    @GetMapping("/accomplish/deleted")
    public CommonResult deletedQualityAccomplish(@RequestParam("qualityAccomplishId") Integer qualityAccomplishId){
        return qualityAccomplishService.deletedQualityAccomplish(qualityAccomplishId);
    }
 
    /**
     * 质量目标对应数据
     * @param qualityId
     * @return
     */
    @ApiOperation(value = "质量目标对应数据")
    @GetMapping("/target/list")
    public CommonResult selectTargetList(@RequestParam("qualityId") Integer qualityId){
        return qualityTargetService.selectTargetList(qualityId);
    }
 
 
    /**
     * 质量管理体系运行列表
     * @param catalogueReq
     * @return
     */
    @ApiOperation(value = "质量管理体系运行列表")
    @GetMapping("/catalogue/list")
    public CommonResult listCatalogue(CatalogueReq catalogueReq){
        return CommonResult.success(catalogueService.selectCatalogueList(catalogueReq));
    }
 
 
    /**
     * 质量管理体系运行新增
     * @param catalogue
     * @return
     */
    @ApiOperation(value = "质量管理体系运行新增")
    @PostMapping("/catalogue/insert")
    public CommonResult insertCatalogue(@RequestBody Catalogue catalogue){
        return catalogueService.insertCatalogue(catalogue);
    }
 
    /**
     * 质量管理体系运行修改
     * @param catalogue
     * @return
     */
    @ApiOperation(value = "质量管理体系运行修改")
    @PostMapping("/catalogue/update")
    public CommonResult updateCatalogue(@RequestBody Catalogue catalogue){
        return catalogueService.updateCatalogue(catalogue);
    }
 
    /**
     * 质量管理体系运行删除
     * @param catalogueId
     * @return
     */
    @ApiOperation(value = "质量管理体系运行删除")
    @GetMapping("/catalogue/deleted")
    public CommonResult deletedCatalogue(@RequestParam("catalogueId") Integer catalogueId){
        return catalogueService.deletedCatalogue(catalogueId);
    }
 
 
 
    /**
     * 目录数据列表
     * @param catalogueReq
     * @return
     */
    @ApiOperation(value = "目录数据列表")
    @GetMapping("/catalogueData/list")
    public CommonResult listCatalogueData(CatalogueReq catalogueReq){
        return CommonResult.success(catalogueService.selectCatalogueDataList(catalogueReq));
    }
 
 
    /**
     * 目录数据新增
     * @param catalogue
     * @return
     */
    @ApiOperation(value = "目录数据新增")
    @PostMapping("/catalogueData/insert")
    public CommonResult insertCatalogueData(@RequestBody CatalogueDataReq catalogue){
        return catalogueService.insertCatalogueData(catalogue);
    }
 
    /**
     * 目录数据修改
     * @param catalogue
     * @return
     */
    @ApiOperation(value = "目录数据修改")
    @PostMapping("/catalogueData/update")
    public CommonResult updateCatalogueData(@RequestBody CatalogueDataReq catalogue){
        return catalogueService.updateCatalogueData(catalogue);
    }
 
    /**
     * 目录数据删除
     * @param catalogueDataId
     * @return
     */
    @ApiOperation(value = "目录数据删除")
    @GetMapping("/catalogueData/deleted")
    public CommonResult deletedCatalogueData(@RequestParam("catalogueDataId") Integer catalogueDataId){
        return catalogueService.deletedCatalogueData(catalogueDataId);
    }
//
//    /**
//     * 目录数据文件列表
//     * @param catalogueReq
//     * @return
//     */
//    @ApiOperation(value = "目录数据文件列表")
//    @GetMapping("/catalogueData/list")
//    public CommonResult listCatalogueDataFile(CatalogueReq catalogueReq){
//        return CommonResult.success(catalogueService.selectCatalogueDataList(catalogueReq));
//    }
 
 
    /**
     * 目录数据文件新增
     * @param catalogueDataFile
     * @return
     */
    @ApiOperation(value = "目录数据文件新增")
    @PostMapping("/catalogueDataFile/insert")
    public CommonResult insertCatalogueDataFile(@RequestBody CatalogueDataFile catalogueDataFile){
        return catalogueService.insertCatalogueDataFile(catalogueDataFile);
    }
 
    /**
     * 目录数据文件修改
     * @param catalogueDataFile
     * @return
     */
    @ApiOperation(value = "目录数据文件修改")
    @PostMapping("/catalogueDataFile/update")
    public CommonResult updateCatalogueDataFile(@RequestBody CatalogueDataFile catalogueDataFile){
        return catalogueService.updateCatalogueDataFile(catalogueDataFile);
    }
 
    /**
     * 目录数据文件删除
     * @param dataFileId
     * @return
     */
    @ApiOperation(value = "目录数据文件删除")
    @GetMapping("/catalogueDataFile/deleted")
    public CommonResult deletedCatalogueDataFile(@RequestParam("dataFileId") Integer dataFileId){
        return catalogueService.deletedCatalogueDataFile(dataFileId);
    }
 
 
 
}