huanghongfa
2021-08-26 3adb33652e097365ced4bdb58c31fce476b244fb
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
package com.panzhihua.service_community.service.impl;
 
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.panzhihua.common.model.dtos.community.reserve.*;
import com.panzhihua.common.model.vos.R;
import com.panzhihua.common.model.vos.community.reserve.ComActReserveMakeDetailAdminVO;
import com.panzhihua.common.model.vos.community.reserve.ComActReserveMakeOperationAdminVO;
import com.panzhihua.common.model.vos.community.reserve.ComActReserveRegisterStatisticsAdminVO;
import com.panzhihua.common.utlis.DateUtils;
import com.panzhihua.service_community.dao.ComActReserveOperationRecordMapper;
import com.panzhihua.service_community.dao.ComActReserveRecordMapper;
import com.panzhihua.service_community.model.dos.ComActReserveOperationRecordDO;
import com.panzhihua.service_community.model.dos.ComActReserveRecordDO;
import com.panzhihua.service_community.service.ComActReserveOperationRecordService;
import com.panzhihua.service_community.service.ComActReserveRecordService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
 
/**
 * @auther lyq
 * @create 2021-08-23 10:33:53
 * @describe 预约登记记录表服务实现类
 */
@Slf4j
@Service
public class ComActReserveRecordServiceImpl extends ServiceImpl<ComActReserveRecordMapper, ComActReserveRecordDO> implements ComActReserveRecordService {
 
    @Resource
    private ComActReserveOperationRecordMapper comActReserveOperationRecordMapper;
    @Resource
    private ComActReserveRecordMapper comActReserveRecordMapper;
    @Resource
    private ComActReserveOperationRecordService comActReserveOperationRecordService;
 
    /**
     * 社区后台-根据预约id查询预约明细
     * @param pageMakeDTO   请求参数
     * @return  预约明细
     */
    @Override
    public R pageMakeAdmin(PageReserveMakeAdminDTO pageMakeDTO){
        return R.ok(this.baseMapper.pageMakeAdmin(new Page(pageMakeDTO.getPageNum(),pageMakeDTO.getPageSize()),pageMakeDTO));
    }
 
    /**
     * 根据预约记录id查询预约明细操作记录
     * @param reserveRecordId   预约记录id
     * @return  预约明细操作记录
     */
    @Override
    public R detailMakeAdmin(Long reserveRecordId){
        ComActReserveMakeDetailAdminVO makeDetailAdminVO = this.baseMapper.getMakeDetailAdmin(reserveRecordId);
        if(makeDetailAdminVO != null){
            //查询预约明细操作记录
            List<ComActReserveMakeOperationAdminVO> makeOperationList = comActReserveOperationRecordMapper.getMakeOperationList(reserveRecordId);
            makeDetailAdminVO.setOperationList(makeOperationList);
        }
        return R.ok(makeDetailAdminVO);
    }
 
    /**
     * 批量取消预约记录
     * @param reserveRecordDTO   请求参数
     * @return  取消结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R makeCancelAdmin(CancelReserveRecordDTO reserveRecordDTO){
        Integer count = this.baseMapper.getReserveStatusById(reserveRecordDTO.getIds());
        if(count > 0){
            return R.ok("您选择的记录中存在未预约成功,不可进行批量取消");
        }
        if(this.baseMapper.editReserveStatusById(reserveRecordDTO.getIds()) > 0){
            Long userId = reserveRecordDTO.getUserId();
            reserveRecordDTO.getIds().forEach(id -> {
                ComActReserveRecordDO reserveRecordDO = comActReserveRecordMapper.selectById(id);
                if(reserveRecordDO != null){
                    //添加操作记录
                    comActReserveOperationRecordService.addReserveOperationRecord(reserveRecordDO.getReserveId()
                            ,reserveRecordDO.getId(),reserveRecordDO.getUserId(),ComActReserveOperationRecordDO.type.sq,null
                            ,"社区管理员取消预约",reserveRecordDTO.getRemark(),ComActReserveOperationRecordDO.status.qx,userId);
                }
            });
            return R.ok();
        }else{
            return R.fail();
        }
    }
 
    /**
     * 预约明细导出数据查询
     * @param pageMakeDTO   请求参数
     * @return  预约明细数据
     */
    @Override
    public R exportMakeAdmin(PageReserveMakeAdminDTO pageMakeDTO){
        return R.ok(this.baseMapper.exportMakeAdmin(pageMakeDTO));
    }
 
    /**
     * 分页查询登记统计汇总
     * @param registerStatisticsDTO 请求参数
     * @return  登记统计汇总
     */
    @Override
    public R registerStatisticsAdmin(ComActReserveRegisterStatisticsDTO registerStatisticsDTO){
        IPage<ComActReserveRegisterStatisticsAdminVO> registerStatisticsList = this.baseMapper.registerStatisticsAdmin(new Page(registerStatisticsDTO.getPageNum()
                ,registerStatisticsDTO.getPageSize()),registerStatisticsDTO);
        registerStatisticsList.getRecords().forEach(registerStatistics -> {
            BigDecimal tag = BigDecimal.ZERO;
            if(registerStatistics.getAllCount() > 0){
                tag = BigDecimal.valueOf(registerStatistics.getCount()).divide(BigDecimal.valueOf(registerStatistics.getAllCount()),4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
            }
            registerStatistics.setTag(tag);
        });
        return R.ok(registerStatisticsList.getRecords());
    }
 
    /**
     * 导出登记统计汇总
     * @param registerStatisticsDTO 请求参数
     * @return  登记统计汇总
     */
    @Override
    public R registerStatisticsExportAdmin(ComActReserveRegisterStatisticsDTO registerStatisticsDTO){
        List<ComActReserveRegisterStatisticsAdminVO> registerStatisticsList = this.baseMapper.registerStatisticsExportAdmin(registerStatisticsDTO);
        registerStatisticsList.forEach(registerStatistics -> {
            BigDecimal tag = BigDecimal.ZERO;
            if(registerStatistics.getAllCount() > 0){
                tag = BigDecimal.valueOf(registerStatistics.getCount()).divide(BigDecimal.valueOf(registerStatistics.getAllCount()),4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
            }
            registerStatistics.setTag(tag);
        });
        return R.ok(registerStatisticsList);
    }
 
    /**
     * 分页查询预约处理列表
     * @param pageMakeHandleDTO 请求参数
     * @return  预约处理列表
     */
    @Override
    public R pageMakeHandleAdmin(PageReserveMakeHandleAdminDTO pageMakeHandleDTO){
        return R.ok(this.baseMapper.pageMakeHandleAdmin(new Page(pageMakeHandleDTO.getPageNum(),pageMakeHandleDTO.getPageSize()),pageMakeHandleDTO));
    }
 
    /**
     * 批量处理预约记录
     * @param makeHandleDTO 请求参数
     * @return  处理结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R makeHandleAdmin(MakeHandleAdminDTO makeHandleDTO){
        if(makeHandleDTO.getIds() == null || makeHandleDTO.getIds().isEmpty()){
            return R.fail("请勾选预约记录");
        }
        //判断选中的所有记录是否都是待处理记录
        if(this.baseMapper.getReserveListCountByIds(makeHandleDTO.getIds()) > 0){
            return R.fail("您勾选的记录中存在不是待处理状态的记录,请核对后再进行处理");
        }
        Date nowDate = new Date();
        Long userId = makeHandleDTO.getUserId();
        String remark = makeHandleDTO.getRemark();
        List<ComActReserveRecordDO> updateList = new ArrayList<>();
        makeHandleDTO.getIds().forEach(id -> {
            ComActReserveRecordDO reserveRecordDO = this.baseMapper.selectById(id);
            if(reserveRecordDO != null){
                //判断处理是否通过
                if(makeHandleDTO.getIsOk().equals(MakeHandleAdminDTO.isOk.yes)){
                    reserveRecordDO.setStatus(ComActReserveRecordDO.status.yycg);
                    comActReserveOperationRecordService.addReserveOperationRecord(reserveRecordDO.getReserveId()
                            ,id,reserveRecordDO.getUserId(),ComActReserveOperationRecordDO.type.sq,null
                            ,"社区管理员处理预约成功",remark,ComActReserveOperationRecordDO.status.yycg,userId);
                }else if(makeHandleDTO.getIsOk().equals(MakeHandleAdminDTO.isOk.no)){
                    reserveRecordDO.setStatus(ComActReserveRecordDO.status.yysb);
                    comActReserveOperationRecordService.addReserveOperationRecord(reserveRecordDO.getReserveId()
                            ,id,reserveRecordDO.getUserId(),ComActReserveOperationRecordDO.type.sq,null
                            ,"社区管理员处理预约失败",remark,ComActReserveOperationRecordDO.status.yysb,userId);
                }
                reserveRecordDO.setActRemark(remark);
                reserveRecordDO.setReserveTime(DateUtils.stringToDate(makeHandleDTO.getMakeTime(),DateUtils.ymdhms_format));
                reserveRecordDO.setUpdateAt(nowDate);
                reserveRecordDO.setUpdateBy(userId);
                updateList.add(reserveRecordDO);
            }
        });
 
        if(!updateList.isEmpty()){
            this.updateBatchById(updateList);
        }
        return R.ok();
    }
 
    /**
     * 导出预约处理列表数据查询
     * @param pageMakeHandleDTO 请求参数
     * @return  预约处理列表
     */
    @Override
    public R exportMakeHandleAdmin(PageReserveMakeHandleAdminDTO pageMakeHandleDTO){
        return R.ok(this.baseMapper.exportMakeHandleAdmin(pageMakeHandleDTO));
    }
 
}