oyingServer.git

			@@ -1,79 +1,148 @@
			package com.oying.modules.pc.store.service.impl;

			import cn.hutool.core.collection.CollectionUtil;
			import cn.hutool.core.util.ObjUtil;
			import com.oying.exception.EntityExistException;
			import com.oying.modules.pc.common.id.StoreQualificationIdGenerator;
			import com.oying.modules.pc.store.domain.StoreQualification;
			import com.oying.modules.pc.store.domain.dto.StoreQualificationQueryCriteria;
			import com.oying.modules.pc.store.mapper.StoreQualificationMapper;
			import com.oying.modules.pc.store.service.StoreQualificationService;
			import com.oying.utils.*;
			import lombok.RequiredArgsConstructor;
			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.time.ZonedDateTime;
			import java.util.*;
			import java.io.IOException;
			import javax.servlet.http.HttpServletResponse;
			import java.util.List;
			import java.util.Map;
			import java.util.Optional;
			import java.util.stream.Collectors;

			/**
			* @description 服务实现
			* @author lzp
			* @date 2025-04-27
			**/
			* @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){
			public PageResult<StoreQualification> queryAll(StoreQualificationQueryCriteria criteria, Page<Object> page) {
			return PageUtil.toPage(storeQualificationMapper.findAll(criteria, page));
			}

			@Override
			public List<StoreQualification> queryAll(StoreQualificationQueryCriteria criteria){
			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) {
			// resources.setQualificationId(StoreQualificationIdGenerator.getId());
			resources.setCreateBy(SecurityUtils.getCurrentUserId());
			resources.setCreateTime(ZonedDateTime.now());
			storeQualificationMapper.insert(resources);
			}

			@Override
			public void batchCreate(List<StoreQualification> resources) {
			resources.forEach(i-> {
			i.setCreateBy(SecurityUtils.getCurrentUserId());
			i.setCreateTime(ZonedDateTime.now());
			});
			this.saveBatch(resources);
			}

			@Override
			@Transactional(rollbackFor = Exception.class)
			public void update(StoreQualification resources) {
			// resources.setUpdateBy();
			Long qualificationId = resources.getQualificationId();
			public void update(StoreQualificationUpdateRequest request) {

			Long qualificationId = request.getQualificationId();
			StoreQualification existingStoreQualification = this.getById(qualificationId);
			if (ObjUtil.isEmpty(existingStoreQualification)) {
			throw new EntityExistException(StoreQualification.class, "id", Optional.ofNullable(qualificationId).map(Object::toString).orElse("null"));
			throw new EntityNotFoundException(StoreQualification.class, "qualificationId", Optional.ofNullable(qualificationId).map(Object::toString).orElse("null"));
			}
			existingStoreQualification.copy(resources);

			// 新的资质数据
			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);
			}
			}
			}