zss
2023-08-22 59ae18f04a602bdfdc91299bbe2ff74a2ae1d215
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.yuanchu.limslaboratory.service.impl;
 
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.yuanchu.limslaboratory.mapper.MaterialMapper;
import com.yuanchu.limslaboratory.mapper.ProductModelMapper;
import com.yuanchu.limslaboratory.mapper.StandardMapper;
import com.yuanchu.limslaboratory.pojo.Material;
import com.yuanchu.limslaboratory.pojo.Product;
import com.yuanchu.limslaboratory.pojo.Specifications;
import com.yuanchu.limslaboratory.pojo.Standard;
import com.yuanchu.limslaboratory.pojo.dto.AddStandardDto;
import com.yuanchu.limslaboratory.service.*;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
 
/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author 江苏鵷雏网络科技有限公司
 * @since 2023-07-11
 */
@Service
public class StandardServiceImpl extends ServiceImpl<StandardMapper, Standard> implements StandardService {
 
    @Resource
    private StandardMapper standardMapper;
 
    @Lazy
    @Autowired
    private SpecificationsService specificationsService;
 
    @Autowired
    private ProductService productService;
 
    @Resource
    ProductModelMapper productModelMapper;
 
    @Resource
    MaterialMapper materialMapper;
 
 
    @Override
    public List<Integer> deleteStandardsInformation(Integer materialId) {
        LambdaQueryWrapper<Standard> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Standard::getMaterialId, materialId);
        wrapper.select(Standard::getId);
        List<Integer> list = new ArrayList<>();
        List<Standard> standards = standardMapper.selectList(wrapper);
        for (Standard standard : standards){
            LambdaUpdateWrapper<Standard> updateWrapper = new LambdaUpdateWrapper<>();
            updateWrapper.eq(Standard::getMaterialId, materialId);
            updateWrapper.set(Standard::getState, 0);
            standardMapper.update(new Standard(), updateWrapper);
            list.add(standard.getId());
        }
        return list;
    }
 
    @Override
    public Integer deleteStandardInformation(Integer standardsId) {
        LambdaUpdateWrapper<Standard> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(Standard::getId, standardsId);
        updateWrapper.set(Standard::getState, 0);
        List<Integer> list = new ArrayList<>();
        int isDeleteSuccess = standardMapper.update(new Standard(), updateWrapper);
        if (isDeleteSuccess == 1){
            list.add(standardsId);
            List<Integer> idDeleteSpecifications = specificationsService.StandardIdDeleteSpecifications(list);
            if (!ObjectUtils.isEmpty(idDeleteSpecifications)){
                productService.deleteProductInformation(idDeleteSpecifications);
            }
            return 1;
        }
        return 0;
    }
 
    //二级新增
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Integer addStandardInformation(AddStandardDto addStandardDto) {
        Standard standard = new Standard()
                .setMaterialId(addStandardDto.getMaterialId())
                .setName(addStandardDto.getStandardName());
        int save = standardMapper.insert(standard);
        if (save == 1){
            Specifications specifications = new Specifications()
                    .setName(addStandardDto.getSpecificationsName())
                    .setStandardId(standard.getId());
            boolean save1 = specificationsService.save(specifications);
            if (save1){
                //添加型号之后添加项目
                List<Map<String, Object>> productModel=productModelMapper.seleMode(materialMapper.selectById(addStandardDto.getMaterialId()).getName());
                List<Product> productList = productModel.stream().map(stringObjectMap -> {
                    Product product = new Product();
                    product.setName(stringObjectMap.get("name").toString());
                    if (ObjectUtils.isNotEmpty(stringObjectMap.get("father"))) {
                        product.setFather(stringObjectMap.get("father").toString());
                    }
                    if (ObjectUtils.isNotEmpty(stringObjectMap.get("unit"))) {
                        product.setUnit(stringObjectMap.get("unit").toString());
                    }
                    product.setSpecifications_id(specifications.getId());
                    return product;
                }).collect(Collectors.toList());
                productService.saveBatch(productList);
                return 1;
            }
        }
        return 0;
    }
 
    @Override
    public List<Map<String, Object>> getSpecificationIdAndName(String materialId) {
        return standardMapper.getSpecificationIdAndName(materialId);
    }
}