云
22 小时以前 d80fa460742ddf052844746482801de355e85528
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
package cn.iocoder.yudao.module.mes.controller.admin.qc.seedquality;
 
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.mes.controller.admin.qc.seedquality.vo.MesQcSeedQualityBatchRespVO;
import cn.iocoder.yudao.module.mes.controller.admin.qc.seedquality.vo.MesQcSeedQualityPageReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.qc.seedquality.vo.MesQcSeedQualityRespVO;
import cn.iocoder.yudao.module.mes.controller.admin.qc.seedquality.vo.MesQcSeedQualitySubmitReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.qc.seedquality.vo.MesQcSeedQualityApprovalReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.qc.seedquality.vo.MesQcSeedQualityRetestReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.qc.seedquality.vo.MesQcSeedQualityBatchApprovalReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.qc.seedquality.vo.MesQcSeedQualityBatchRetestReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.qc.seedquality.vo.MesQcSeedQualityScopeRetestReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.qc.seedquality.vo.MesQcSeedReturnQualitySubmitReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.qc.seedquality.vo.MesQcSeedIndicatorRangeSaveReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.qc.seedquality.vo.MesQcSeedIndicatorRangeRespVO;
import cn.iocoder.yudao.module.mes.controller.admin.qc.seedquality.vo.MesQcSeedQualityActionRespVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.bagcode.MesProBagCodeDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.seedquality.MesQcSeedQualityActionDO;
import cn.iocoder.yudao.module.system.api.user.AdminUserApi;
import cn.iocoder.yudao.module.system.api.user.dto.AdminUserRespDTO;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.bagcode.MesProBagCodeMapper;
import cn.iocoder.yudao.module.mes.service.qc.seedquality.MesQcSeedQualityService;
import cn.iocoder.yudao.module.mes.service.qc.seedquality.MesQcSeedIndicatorRangeService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import jakarta.validation.Valid;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
 
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
 
@Tag(name = "管理后台 - MES 种子质检")
@RestController @RequestMapping("/mes/qc/seed-quality") @Validated
public class MesQcSeedQualityController {
    @Resource private MesQcSeedQualityService service;
    @Resource private MesQcSeedIndicatorRangeService rangeService;
    @Resource private MesProBagCodeMapper bagCodeMapper;
    @Resource private AdminUserApi adminUserApi;
    @GetMapping("/ranges") @Operation(summary = "获得产品质检项配置")
    @PreAuthorize("@ss.hasAnyPermissions('mes:qc-seed-quality:submit', 'mes:qc-seed-quality:retest', 'mes:qc-seed-range:query')")
    public CommonResult<List<MesQcSeedIndicatorRangeRespVO>> ranges(@RequestParam(required = false) Long itemId,
                                                                    @RequestParam(required = false) String keyword,
                                                                    @RequestParam(required = false) Integer status) {
        return success(BeanUtils.toBean(rangeService.getRanges(itemId, keyword, status), MesQcSeedIndicatorRangeRespVO.class));
    }
 
    @GetMapping("/ranges/effective") @Operation(summary = "获得产品生效的质检项")
    @PreAuthorize("@ss.hasAnyPermissions('mes:qc-seed-quality:submit', 'mes:qc-seed-quality:retest', 'mes:qc-seed-range:query')")
    public CommonResult<List<MesQcSeedIndicatorRangeRespVO>> effectiveRanges(@RequestParam Long itemId) {
        return success(BeanUtils.toBean(rangeService.getEffectiveRanges(itemId), MesQcSeedIndicatorRangeRespVO.class));
    }
 
    @PostMapping("/ranges") @Operation(summary = "新增产品质检项")
    @PreAuthorize("@ss.hasPermission('mes:qc-seed-range:update')")
    public CommonResult<Long> createRange(@Valid @RequestBody MesQcSeedIndicatorRangeSaveReqVO reqVO) {
        return success(rangeService.create(reqVO));
    }
 
    @PutMapping("/ranges/{id}") @Operation(summary = "修改产品质检项")
    @PreAuthorize("@ss.hasPermission('mes:qc-seed-range:update')")
    public CommonResult<Boolean> updateRange(@PathVariable Long id, @Valid @RequestBody MesQcSeedIndicatorRangeSaveReqVO reqVO) {
        rangeService.update(id, reqVO);
        return success(true);
    }
 
    @DeleteMapping("/ranges/{id}") @Operation(summary = "删除产品质检项")
    @PreAuthorize("@ss.hasPermission('mes:qc-seed-range:update')")
    public CommonResult<Boolean> deleteRange(@PathVariable Long id) {
        rangeService.delete(id);
        return success(true);
    }
 
    @PostMapping("/ranges/copy-default") @Operation(summary = "复制通用默认质检项到产品")
    @PreAuthorize("@ss.hasPermission('mes:qc-seed-range:update')")
    public CommonResult<Integer> copyDefaultRanges(@RequestParam Long itemId) {
        return success(rangeService.copyDefaults(itemId));
    }
    @GetMapping("/resolve")
    @Operation(summary = "解析待质检袋码及确认该袋质检结果")
    @PreAuthorize("@ss.hasAnyPermissions('mes:qc-seed-quality:submit', 'mes:qc-seed-quality:retest', 'mes:qc-seed-quality:process-approve', 'mes:qc-seed-quality:company-approve')")
    public CommonResult<java.util.Map<String, Object>> resolve(@RequestParam String code, @RequestParam(defaultValue = "AUTO") String scanType,
                                                                @RequestParam(defaultValue = "1") Integer qcLine) {
        return success(service.resolveScan(code, scanType, qcLine));
    }
    @GetMapping("/page")
    @Operation(summary = "获得种子质检记录分页")
    @PreAuthorize("@ss.hasAnyPermissions('mes:qc-seed-quality:query', 'mes:qc-seed-quality:submit', "
            + "'mes:qc-seed-quality:retest', 'mes:qc-seed-quality:process-approve', 'mes:qc-seed-quality:company-approve')")
    public CommonResult<PageResult<MesQcSeedQualityRespVO>> getQualityPage(@Valid MesQcSeedQualityPageReqVO pageReqVO) {
        PageResult<MesQcSeedQualityRespVO> page = BeanUtils.toBean(
                service.getQualityPage(pageReqVO), MesQcSeedQualityRespVO.class);
        List<String> codes = page.getList().stream().map(MesQcSeedQualityRespVO::getCode)
                .filter(java.util.Objects::nonNull).distinct().toList();
        if (!codes.isEmpty()) {
            Map<String, MesProBagCodeDO> bagMap = bagCodeMapper.selectList(MesProBagCodeDO::getCode, codes).stream()
                    .collect(Collectors.toMap(MesProBagCodeDO::getCode, Function.identity(), (first, ignored) -> first));
            page.getList().forEach(record -> {
                MesProBagCodeDO bag = bagMap.get(record.getCode());
                if (bag != null) record.setPalletCode(bag.getPalletCode());
            });
        }
        return success(page);
    }
 
    @GetMapping("/batch-page")
    @Operation(summary = "获得种子质检记录按生产批次分组分页")
    @PreAuthorize("@ss.hasPermission('mes:qc-seed-quality:query')")
    public CommonResult<PageResult<MesQcSeedQualityBatchRespVO>> getQualityBatchPage(@Valid MesQcSeedQualityPageReqVO pageReqVO) {
        return success(service.getQualityBatchPage(pageReqVO));
    }
 
    @GetMapping("/indicators") @Operation(summary = "获得种子质检最新指标")
    @PreAuthorize("@ss.hasAnyPermissions('mes:qc-seed-quality:query', 'mes:qc-seed-quality:submit', "
            + "'mes:qc-seed-quality:retest', 'mes:qc-seed-quality:process-approve', 'mes:qc-seed-quality:company-approve')")
    public CommonResult<java.util.List<cn.iocoder.yudao.module.mes.dal.dataobject.qc.seedquality.MesQcSeedQualityIndicatorDO>> indicators(@RequestParam Long id) {
        return success(service.getIndicatorsByQualityId(id));
    }
    @GetMapping("/actions") @Operation(summary = "获得种子质检流程留痕")
    @PreAuthorize("@ss.hasAnyPermissions('mes:qc-seed-quality:query', 'mes:qc-seed-quality:submit', "
            + "'mes:qc-seed-quality:retest', 'mes:qc-seed-quality:process-approve', 'mes:qc-seed-quality:company-approve')")
    public CommonResult<List<MesQcSeedQualityActionRespVO>> actions(@RequestParam Long id) {
        List<MesQcSeedQualityActionDO> actions = service.getActions(id);
        Map<Long, AdminUserRespDTO> userMap = adminUserApi.getUserMap(actions.stream()
                .map(MesQcSeedQualityActionDO::getOperatorId).filter(java.util.Objects::nonNull)
                .collect(Collectors.toSet()));
        return success(BeanUtils.toBean(actions, MesQcSeedQualityActionRespVO.class, vo -> {
            AdminUserRespDTO user = userMap.get(vo.getOperatorId());
            if (user != null) vo.setOperatorName(user.getNickname());
        }));
    }
 
    @PostMapping("/submit") @Operation(summary = "提交种子质检")
    @PreAuthorize("@ss.hasPermission('mes:qc-seed-quality:submit')")
    public CommonResult<Long> submit(@Valid @RequestBody MesQcSeedQualitySubmitReqVO reqVO) { return success(service.submit(reqVO)); }
 
    @PostMapping("/submit-group") @Operation(summary = "按袋码、托盘或生产批次统一提交种子质检")
    @PreAuthorize("@ss.hasPermission('mes:qc-seed-quality:submit')")
    public CommonResult<java.util.Map<String, Object>> submitGroup(@Valid @RequestBody cn.iocoder.yudao.module.mes.controller.admin.qc.seedquality.vo.MesQcSeedQualityGroupSubmitReqVO reqVO) {
        return success(service.submitGroup(reqVO));
    }
 
    @PostMapping("/retry-bpm") @Operation(summary = "重新发起质检 BPM 审批")
    @PreAuthorize("@ss.hasPermission('mes:qc-seed-quality:process-approve')")
    public CommonResult<Boolean> retryBpm(@RequestParam Long id) {
        service.retryBpmProcess(id);
        return success(true);
    }
 
    @PostMapping("/retest") @Operation(summary = "种子质检复检")
    @PreAuthorize("@ss.hasPermission('mes:qc-seed-quality:retest')")
    public CommonResult<Boolean> retest(@RequestParam Long id, @Valid @RequestBody MesQcSeedQualityRetestReqVO reqVO) {
        service.retest(id, reqVO);
        return success(true);
    }
 
    @PostMapping("/retest-batch") @Operation(summary = "同批次种子批量复检或重新初检")
    @PreAuthorize("@ss.hasPermission('mes:qc-seed-quality:retest')")
    public CommonResult<Boolean> retestBatch(@Valid @RequestBody MesQcSeedQualityBatchRetestReqVO reqVO) {
        service.retestBatch(reqVO);
        return success(true);
    }
 
    @GetMapping("/retest-scope/resolve") @Operation(summary = "按托盘码或生产批次码解析待批量质检记录")
    @PreAuthorize("@ss.hasAnyPermissions('mes:qc-seed-quality:submit', 'mes:qc-seed-quality:retest', 'mes:qc-seed-quality:process-approve', 'mes:qc-seed-quality:company-approve')")
    public CommonResult<java.util.Map<String, Object>> resolveRetestScope(@RequestParam String code, @RequestParam String scanType,
                                                                          @RequestParam(defaultValue = "1") Integer qcLine) {
        return success(service.resolveRetestScope(code, scanType, qcLine));
    }
 
    @PostMapping("/retest-scope") @Operation(summary = "按托盘码或生产批次码批量复检或重新初检")
    @PreAuthorize("@ss.hasPermission('mes:qc-seed-quality:retest')")
    public CommonResult<java.util.Map<String, Object>> retestScope(@Valid @RequestBody MesQcSeedQualityScopeRetestReqVO reqVO) {
        return success(service.retestScope(reqVO));
    }
 
    @PostMapping("/process-approve") @Operation(summary = "初检审核")
    @PreAuthorize("@ss.hasPermission('mes:qc-seed-quality:process-approve')")
    public CommonResult<Boolean> processApprove(@Valid @RequestBody MesQcSeedQualityApprovalReqVO reqVO) {
        service.processApprove(reqVO.getId(), reqVO.getApproved(), reqVO.getOpinion());
        return success(true);
    }
 
    @PostMapping("/company-approve") @Operation(summary = "复检审核并流转库存")
    @PreAuthorize("@ss.hasPermission('mes:qc-seed-quality:company-approve')")
    public CommonResult<Boolean> companyApprove(@Valid @RequestBody MesQcSeedQualityApprovalReqVO reqVO) {
        service.companyApprove(reqVO.getId(), reqVO.getApproved(), reqVO.getOpinion());
        return success(true);
    }
    @PostMapping("/process-approve-batch") @Operation(summary = "批量初检审核")
    @PreAuthorize("@ss.hasPermission('mes:qc-seed-quality:process-approve')")
    public CommonResult<Boolean> processApproveBatch(@Valid @RequestBody MesQcSeedQualityBatchApprovalReqVO reqVO) {
        service.processApproveBatch(reqVO.getIds(), reqVO.getApproved(), reqVO.getOpinion());
        return success(true);
    }
    @PostMapping("/company-approve-batch") @Operation(summary = "批量复检审核并流转库存")
    @PreAuthorize("@ss.hasPermission('mes:qc-seed-quality:company-approve')")
    public CommonResult<Boolean> companyApproveBatch(@Valid @RequestBody MesQcSeedQualityBatchApprovalReqVO reqVO) {
        service.companyApproveBatch(reqVO.getIds(), reqVO.getApproved(), reqVO.getOpinion());
        return success(true);
    }
 
    @GetMapping("/return/resolve") @Operation(summary = "解析经销商退货单待质检信息")
    @PreAuthorize("@ss.hasAnyPermissions('mes:qc-seed-quality:submit', 'mes:qc-seed-quality:retest', 'mes:qc-seed-quality:process-approve')")
    public CommonResult<Map<String, Object>> resolveReturnQuality(@RequestParam Long returnSalesId) {
        return success(service.resolveReturnQuality(returnSalesId));
    }
 
    @PostMapping("/return/submit") @Operation(summary = "提交经销商退货质检")
    @PreAuthorize("@ss.hasPermission('mes:qc-seed-quality:submit')")
    public CommonResult<Long> submitReturnQuality(@Valid @RequestBody MesQcSeedReturnQualitySubmitReqVO reqVO) {
        return success(service.submitReturnQuality(reqVO));
    }
 
    @PostMapping("/return/approve") @Operation(summary = "经销商退货质检销售部审批")
    @PreAuthorize("@ss.hasPermission('mes:qc-seed-quality:process-approve')")
    public CommonResult<Boolean> returnApprove(@Valid @RequestBody MesQcSeedQualityApprovalReqVO reqVO) {
        service.returnApprove(reqVO.getId(), reqVO.getApproved(), reqVO.getOpinion());
        return success(true);
    }
}