bug修改

zhaozhengjie

2022-09-23 4caee77833d46a483a32ea664ae7f4c4d7bc1096

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
package com.dg.core.service.impl;
 
 
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.dg.core.db.gen.entity.KeywordEntity;
import com.dg.core.db.gen.entity.OrganizationChartEntity;
import com.dg.core.db.gen.entity.SysUser;
import com.dg.core.db.gen.entity.TransactionEvent;
import com.dg.core.db.gen.mapper.KeywordMapper;
import com.dg.core.db.gen.mapper.OrganizationChartMapper;
import com.dg.core.db.gen.mapper.TransactionEventMapper;
import com.dg.core.db.manual.pojo.QueryResults;
import com.dg.core.db.manual.pojo.RecommendResult;
import com.dg.core.db.manual.pojo.Search;
import com.dg.core.service.ITransactionEventService;
 
import org.springframework.stereotype.Service;
 
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
 
@Service
public class TransactionEventImpl extends ServiceImpl<TransactionEventMapper, TransactionEvent> implements ITransactionEventService {
 
    @Resource
    private   OrganizationChartMapper organizationChartMapper;
 
    @Resource
    private KeywordMapper keywordMapper;
 
    @Override
    public TransactionEvent selectConfigData(String Id) {
        return baseMapper.selectConfigData(Id);
    }
 
    @Override
    public List<TransactionEvent> selectConfigList(IPage<TransactionEvent> page, Integer state,
                                                   String matterAndUser, String classifyGrade) {
        return baseMapper.selectConfigList(page,  state, matterAndUser, classifyGrade);
    }
 
    @Override
    public int insertConfig(TransactionEvent entity) {
        return baseMapper.insertConfig(entity);
    }
 
    @Override
    public int updateConfig(TransactionEvent entity) {
        return baseMapper.updateConfig(entity);
    }
 
    @Override
    public int deleteConfigById(String Id) {
        return baseMapper.deleteConfigById(Id);
    }
 
    @Override
    public int countNum(String matterAndUser,String classifyGrade) {
        return baseMapper.countNum( matterAndUser, classifyGrade);
    }
 
    @Override
    public QueryResults queryMatterNameList(IPage<Search> page,Integer state, Integer recommendSize,String keyWord) {
        QueryResults queryResults = new QueryResults();
        List<Search> searches = baseMapper.selectSearch(page, state, keyWord);
        queryResults.setSearchList(searches);
        List<Search> searchesAssociate = baseMapper.selectSearchAssociate(page, recommendSize, keyWord);
        queryResults.setTransactionEventList(searchesAssociate);
        queryResults.setKeywordEntityList( keywordMapper.selectByName(keyWord));
        queryResults.setTotal((baseMapper.selectSearch(keyWord).size())+(baseMapper.selectSearchAssociate(keyWord).size()));
        return queryResults;
    }
 
 
    @Override
    public RecommendResult smartConsulting(String keyWord){
        RecommendResult recommendResult=new RecommendResult();
        List<KeywordEntity> keywordEntityList=new ArrayList<>();
        List<TransactionEvent> transactionEventEntities = baseMapper.queryMatterNameList(keyWord);
        recommendResult.setTransactionEventList(transactionEventEntities);
        for (TransactionEvent transactionEvent: transactionEventEntities) {
            String[] associateNames = transactionEvent.getAssociateNames().split(",");
            for (String  associateName: associateNames) {
                KeywordEntity keywordEntity = new KeywordEntity();
                keywordEntity.setName(associateName);
                keywordEntityList.add(keywordEntity);
            }
 
        }
        recommendResult.setKeywordEntityList(keywordEntityList);
        List<OrganizationChartEntity> organizationChartEntities = organizationChartMapper.selectByKeyWord(keyWord);
        recommendResult.setOrganizationChartEntityList(organizationChartEntities);
        return recommendResult;
    }
 
    @Override
    public int countNumByMatterName(String matterName) {
        return baseMapper.countNumByMatterName(matterName);
    }
 
    @Override
    public List<TransactionEvent> queryByClassifyIdList(String classifyId,Integer departmentId) {
        return baseMapper.queryByClassifyIdList(classifyId,departmentId);
    }
 
    @Override
    public List<TransactionEvent> queryByQueryTime() {
        List<TransactionEvent> transactionEvents = baseMapper.selectList(new QueryWrapper<TransactionEvent>().lambda().orderByDesc(TransactionEvent::getQueryTime));
        return transactionEvents;
    }
 
    @Override
    public List<TransactionEvent> queryByBrowseNum() {
        List<TransactionEvent> transactionEvents = baseMapper.selectList(new QueryWrapper<TransactionEvent>().lambda().orderByDesc(TransactionEvent::getBrowseNum));
        return transactionEvents;
    }
 
    @Override
    public TransactionEvent sumTransactionNum() {
        return baseMapper.sumTransactionNum();
    }
 
    @Override
    public int countNumByClassifyIdList(String classifyId, Integer departmentId) {
        return baseMapper.countNumByClassifyIdList(classifyId,departmentId);
    }
 
    @Override
    public List<TransactionEvent> selectList(){
        return  baseMapper.selectList(new QueryWrapper<TransactionEvent>().lambda());
    }
}