zepengdev
2025-07-14 43315000b2840313a5aff96bf314b3c061e4616d
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.oying.modules.pc.store.service.impl;
 
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ObjUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.common.collect.Lists;
import com.oying.exception.EntityExistException;
import com.oying.exception.EntityNotFoundException;
import com.oying.modules.pc.common.ValueUpdate;
import com.oying.modules.pc.store.converter.StoreQualificationAssembler;
import com.oying.modules.pc.store.domain.StoreQualification;
import com.oying.modules.pc.store.domain.dto.StoreQualificationQueryCriteria;
import com.oying.modules.pc.store.domain.dto.StoreQualificationUpdateRequest;
import com.oying.modules.pc.store.mapper.StoreQualificationMapper;
import com.oying.modules.pc.store.service.StoreQualificationService;
import com.oying.service.BucketStorageService;
import com.oying.utils.PageResult;
import com.oying.utils.PageUtil;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
 
/**
 * @author lzp
 * @description 服务实现
 * @date 2025-04-27
 **/
@Service
@RequiredArgsConstructor
public class StoreQualificationServiceImpl extends ServiceImpl<StoreQualificationMapper, StoreQualification> implements StoreQualificationService {
 
    private final StoreQualificationMapper storeQualificationMapper;
    private final BucketStorageService bucketStorageService;
 
    @Override
    public PageResult<StoreQualification> queryAll(StoreQualificationQueryCriteria criteria, Page<Object> page) {
        return PageUtil.toPage(storeQualificationMapper.findAll(criteria, page));
    }
 
    @Override
    public List<StoreQualification> queryAll(StoreQualificationQueryCriteria criteria) {
        return storeQualificationMapper.findAll(criteria);
    }
 
    @Override
    public List<StoreQualification> queryBatchIds(List<Long> ids) {
        LambdaQueryWrapper<StoreQualification> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(StoreQualification::getQualificationId, ids);
        return storeQualificationMapper.selectList(wrapper);
    }
 
    @Override
    public List<StoreQualification> getByStoreId(Long storeId) {
        LambdaQueryWrapper<StoreQualification> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(StoreQualification::getStoreId, storeId);
        return storeQualificationMapper.selectList(wrapper);
    }
 
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void create(StoreQualification resources) {
        storeQualificationMapper.insert(resources);
    }
 
    @Override
    public void batchCreate(List<StoreQualification> resources) {
        this.saveBatch(resources);
    }
 
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void update(StoreQualificationUpdateRequest request) {
 
        Long qualificationId = request.getQualificationId();
        StoreQualification existingStoreQualification = this.getById(qualificationId);
        if (ObjUtil.isEmpty(existingStoreQualification)) {
            throw new EntityNotFoundException(StoreQualification.class, "qualificationId", Optional.ofNullable(qualificationId).map(Object::toString).orElse("null"));
        }
 
        // 新的资质数据
        StoreQualification newStoreQualification = StoreQualificationAssembler.to(request);
        // 记录图片值的变更
        ValueUpdate<Long> imageValueUpdate = new ValueUpdate<>(newStoreQualification.getQualificationImageId(), existingStoreQualification.getQualificationImageId());
        // 填充新的数据
        existingStoreQualification.copy(newStoreQualification);
        storeQualificationMapper.updateById(existingStoreQualification);
        // 删除旧图片原纪录
        if (imageValueUpdate.isChangeAndOldValueNotEmpty()) {
            bucketStorageService.deleteAll(Lists.newArrayList(imageValueUpdate.getOldValue()));
        }
    }
 
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void batchUpdate(List<StoreQualificationUpdateRequest> requests) {
 
        List<Long> updateIds = requests.stream().map(StoreQualificationUpdateRequest::getQualificationId).collect(Collectors.toList());
        List<StoreQualification> existingStoreQualifications = this.queryBatchIds(updateIds);
        if (CollectionUtil.isEmpty(existingStoreQualifications)) {
            throw new EntityNotFoundException(StoreQualification.class, "qualificationIds", updateIds.toString());
        }
 
        Map<Long, StoreQualificationUpdateRequest> requestMap = requests.stream().collect(Collectors.toMap(
                StoreQualificationUpdateRequest::getQualificationId,
                storeQualificationUpdateRequest -> storeQualificationUpdateRequest
        ));
 
        // 提取需要删除的图片原纪录ID
        List<Long> deleteBucketStorageIds = existingStoreQualifications.stream().filter(i -> {
            Long newCloudStorageId = requestMap.get(i.getQualificationId()).getImageUploadFileId();
            return ValueUpdate.isChangeAndOldValueNotEmpty(newCloudStorageId, i.getQualificationImageId());
        }).map(StoreQualification::getQualificationImageId).collect(Collectors.toList());
 
        // 填充新的数据
        for (StoreQualification existingStoreQualification : existingStoreQualifications) {
            StoreQualification newStoreQualification = StoreQualificationAssembler.to(requestMap.get(existingStoreQualification.getQualificationId()));
            existingStoreQualification.copy(newStoreQualification);
        }
 
        this.updateBatchById(existingStoreQualifications);
        // 删除旧图片原记录
        if (CollectionUtil.isNotEmpty(deleteBucketStorageIds)) {
            bucketStorageService.deleteAll(deleteBucketStorageIds);
        }
    }
 
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteAll(List<Long> ids) {
        List<StoreQualification> existingStoreQualifications = this.queryBatchIds(ids);
        if (CollectionUtil.isEmpty(existingStoreQualifications)) {
            throw new EntityNotFoundException(StoreQualification.class, "qualificationIds", ids.toString());
        }
        storeQualificationMapper.deleteBatchIds(ids);
        // 删除旧图片原记录
        List<Long> bucketStorageIds = existingStoreQualifications.stream().map(StoreQualification::getQualificationImageId).collect(Collectors.toList());
        if (CollectionUtil.isNotEmpty(bucketStorageIds)) {
            bucketStorageService.deleteAll(bucketStorageIds);
        }
    }
}