李林
2023-10-07 658d4927d468c47208fd012d9128b09249c07eff
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
package com.chinaztt.mes.plan.service.impl;
 
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.chinaztt.mes.plan.dto.ManufacturingOrderSnGenerateDTO;
import com.chinaztt.mes.plan.entity.ManufacturingOrderSnGenerate;
import com.chinaztt.mes.plan.mapper.ManufacturingOrderSnGenerateMapper;
import com.chinaztt.mes.plan.service.ManufacturingOrderSnGenerateService;
import com.chinaztt.mes.technology.entity.Operation;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import java.util.Arrays;
import java.util.List;
 
/**
 * @Description:
 * @Author: shz
 * @Date: 2023/3/14 18:14
 */
@AllArgsConstructor
@Transactional(rollbackFor = Exception.class)
@Service
public class ManufacturingOrderSnGenerateServiceImpl extends ServiceImpl<ManufacturingOrderSnGenerateMapper, ManufacturingOrderSnGenerate> implements ManufacturingOrderSnGenerateService {
 
    @Override
    public IPage<ManufacturingOrderSnGenerateDTO> getTaskDetailPage(Page page, String customerName, String customerOrderNo, Long operationId) {
        return this.baseMapper.getTaskDetailPage(page, customerName, customerOrderNo, operationId);
    }
 
    @Override
    public IPage<ManufacturingOrderSnGenerateDTO> getTaskDetailPageByWorkstation(Page page, Long mpsId, List<Long> operationIds, Long operationTaskId, Boolean produceStatus) {
        Long moId = null;
        if (CollectionUtil.isNotEmpty(operationIds)) {
            operationTaskId = null;
        } else {
            if (operationTaskId == null) {
                return new Page<>();
            }
            ManufacturingOrderSnGenerateDTO generateDTO = this.baseMapper.getJoinDocBomRoutingIdByOperationTaskId(operationTaskId);
            operationIds = Arrays.asList(generateDTO.getOperationId());
            moId = generateDTO.getMoId();
        }
 
        return this.baseMapper.getTaskDetailPageByWorkstation(page, mpsId, operationIds, moId, produceStatus);
    }
 
    @Override
    public void updateProduceStatus(List<Long> ids, Boolean produceStatus, String sn) {
        for (Long id : ids) {
            ManufacturingOrderSnGenerate generate = this.baseMapper.selectById(id);
            if (generate != null) {
                UpdateWrapper<ManufacturingOrderSnGenerate> updateWrapper = new UpdateWrapper<>();
                if (generate.getIsGenerateSn()) {
                    updateWrapper.lambda().set(ManufacturingOrderSnGenerate::getProduceStatus, produceStatus)
                            .eq(ManufacturingOrderSnGenerate::getId, id)
                            .eq(ManufacturingOrderSnGenerate::getProduceStatus, !produceStatus);
                } else {
                    updateWrapper.lambda()
                            .set(ManufacturingOrderSnGenerate::getSn, sn)
                            .set(ManufacturingOrderSnGenerate::getOriginalSn, sn)
                            .set(ManufacturingOrderSnGenerate::getProduceStatus, produceStatus)
                            .eq(ManufacturingOrderSnGenerate::getId, id)
                            .eq(ManufacturingOrderSnGenerate::getProduceStatus, !produceStatus);
                }
                this.update(updateWrapper);
            }
        }
    }
 
    @Override
    public boolean resetSn(List<Long> idList, Boolean isReproduce) {
        if (isReproduce) {
            UpdateWrapper<ManufacturingOrderSnGenerate> updateWrapper = new UpdateWrapper<>();
            updateWrapper.lambda().set(ManufacturingOrderSnGenerate::getSn, null)
                    .set(ManufacturingOrderSnGenerate::getProduceStatus, false)
                    .in(ManufacturingOrderSnGenerate::getId, idList);
            this.update(updateWrapper);
        } else {
            UpdateWrapper<ManufacturingOrderSnGenerate> updateWrapper = new UpdateWrapper<>();
            updateWrapper.lambda().set(ManufacturingOrderSnGenerate::getSn, null)
                    .set(ManufacturingOrderSnGenerate::getProduceStatus, true)
                    .in(ManufacturingOrderSnGenerate::getId, idList);
            this.update(updateWrapper);
        }
        return true;
    }
 
    @Override
    public boolean updateSn(List<ManufacturingOrderSnGenerate> generateList) {
        if (CollectionUtil.isNotEmpty(generateList)) {
            for (ManufacturingOrderSnGenerate snGenerate : generateList) {
                if (StrUtil.isBlank(snGenerate.getSn())) {
                    throw new RuntimeException("SN不能为空");
                }
                ManufacturingOrderSnGenerate generate = this.getById(snGenerate.getId());
                if (generate != null) {
                    if (generate.getSn() != null) {
                        throw new RuntimeException("未进行重置操作,不能修改SN");
                    }
                    int count = this.count(Wrappers.<ManufacturingOrderSnGenerate>lambdaQuery().eq(ManufacturingOrderSnGenerate::getOriginalSn, snGenerate.getSn()));
                    if (count > 0) {
                        this.update(Wrappers.<ManufacturingOrderSnGenerate>lambdaUpdate()
                                .set(ManufacturingOrderSnGenerate::getSn, snGenerate.getSn())
                                .eq(ManufacturingOrderSnGenerate::getId, snGenerate.getId()));
                    } else {
                        throw new RuntimeException("不能编辑成未存在的SN");
                    }
                }
            }
        }
        return true;
    }
 
    @Override
    public List<Operation> getOperationInfo(Long mpsId) {
        return this.baseMapper.getOperationInfo(mpsId);
    }
 
    @Override
    public void updateProduceStatusBySn(String outBatchNo, Boolean produceStatus, String sn) {
        List<ManufacturingOrderSnGenerate> generateList = this.baseMapper.selectList(Wrappers.<ManufacturingOrderSnGenerate>lambdaQuery()
                .eq(ManufacturingOrderSnGenerate::getSn, outBatchNo));
        if (CollectionUtil.isNotEmpty(generateList)) {
            for (ManufacturingOrderSnGenerate generate : generateList) {
                UpdateWrapper<ManufacturingOrderSnGenerate> updateWrapper = new UpdateWrapper<>();
                if (generate.getIsGenerateSn()) {
                    updateWrapper.lambda().set(ManufacturingOrderSnGenerate::getProduceStatus, produceStatus)
                            .eq(ManufacturingOrderSnGenerate::getId, generate.getId())
                            .eq(ManufacturingOrderSnGenerate::getProduceStatus, !produceStatus);
                } else {
                    updateWrapper.lambda()
                            .set(ManufacturingOrderSnGenerate::getSn, sn)
                            .set(ManufacturingOrderSnGenerate::getProduceStatus, produceStatus)
                            .eq(ManufacturingOrderSnGenerate::getId, generate.getId())
                            .eq(ManufacturingOrderSnGenerate::getProduceStatus, !produceStatus);
                }
                this.update(updateWrapper);
            }
        }
    }
}