修改标段名字问题

15030600271

2023-10-23 f547761b4f461b9716a1d773f2d28fb843a7deb3

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
package com.thhy.engineering.modules.biz.engineering.service.impl;
 
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.thhy.engineering.modules.biz.engineering.entity.ProSunDto.DictTypeDto;
import com.thhy.engineering.modules.biz.engineering.entity.SysDict;
import com.thhy.engineering.modules.biz.engineering.mapper.SysDictMapper;
import com.thhy.engineering.modules.biz.engineering.service.SysDictService;
import com.thhy.general.common.BasicResult;
import org.springframework.stereotype.Service;
 
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
@Service
public class SysDictServiceImp implements SysDictService {
    @Resource
    private SysDictMapper dictMapper;
 
 
    @Override
    public BasicResult dictInsert(Map<String, Object> values) {
        String dictName = values.get("dictName").toString();
        String diceType = values.get("dictType").toString();
 
        String dictId = dictMapper.diceSelectNameByOne(dictName,diceType);
        if(dictId!=null){
            return BasicResult.faild("11111","error","类型名称重复");
        }
        values.put("dict_id","");
        dictMapper.dictInsert(values);
        return BasicResult.success("添加成功");
    }
 
 
    @Override
    public BasicResult dictList(Map<String, Object> values) {
        Integer pageSize = Integer.valueOf(values.get("pageSize").toString());
        Integer pageNum = Integer.valueOf(values.get("pageNum").toString());
        PageHelper.startPage(pageNum,pageSize);
        List<SysDict> sysDicts = dictMapper.dictList(values);
        PageInfo<SysDict> sysDictPageInfo = new PageInfo<>(sysDicts);
        return BasicResult.success(sysDictPageInfo);
    }
 
    @Override
    public BasicResult dictInfo(String dictId) {
        SysDict sysDict = dictMapper.dictInfo(dictId);
        return BasicResult.success(sysDict);
    }
 
    @Override
    public BasicResult dictDel(String dictId) {
        SysDict dict = dictMapper.dictSelectByOne(dictId);
        if(dict.getDictType().equals("1")){
            List<String> sizeIds = dictMapper.dictByAll(dict.getDictId());
            if(sizeIds.size()>0){
                return BasicResult.faild("11111","该类型已被占用","该类型已被占用");
            }
        }else if(dict.getDictType().equals("2")){
            List<String> hasIds = dictMapper.dictByHasAll(dict.getDictId());
            if(hasIds.size()>0){
                return BasicResult.faild("11111","该类型已被占用","该类型已被占用");
            }
        }else if(dict.getDictType().equals("3")){
            List<String> turnIds = dictMapper.dictByTurnAll(dict.getDictId());
            if(turnIds.size()>0){
                return BasicResult.faild("11111","该类型已被占用","该类型已被占用");
            }
        } else if(dict.getDictType().equals("4")){
            List<String> grouting = dictMapper.dictByGroutingAll(dict.getDictId());
            if(grouting.size()>0){
                return BasicResult.faild("11111","该类型已被占用","该类型已被占用");
            }
        }else if(dict.getDictType().equals("5")){
            List<String> blok = dictMapper.dictByBlokAll(dict.getDictId());
            if(blok.size()>0){
                return BasicResult.faild("11111","该类型已被占用","该类型已被占用");
            }
        }
 
 
 
 
        dictMapper.dictDel(dictId);
        return BasicResult.success("删除成功");
    }
 
    @Override
    public BasicResult dictUpdate(Map<String, Object> values) {
        String dictName = values.get("dictName").toString();
        String diceType = values.get("dictType").toString();
        String dictId = dictMapper.diceSelectNameByOne(dictName,diceType);
        String dictId1  =  values.get("dictId").toString();
        if(dictId!=null&&!dictId.equals(dictId1)){
            return BasicResult.faild("11111","error","类型名称重复");
        }
        dictMapper.dictUpdate(values);
        return BasicResult.success("修改成功");
    }
 
    @Override
    public BasicResult dictTypePull() {
        List<DictTypeDto> dictTypeDtos = dictMapper.dictTypePull();
        return BasicResult.success(dictTypeDtos);
    }
}