淘宝转链接口更新

admin

2025-02-25 30d8e227e8d823b6c38c3b9c90ac2df03b63befe

 fanli/src/main/java/com/yeshi/fanli/service/impl/lable/LabelClassServiceImpl.java

@@ -1,277 +1,277 @@
package com.yeshi.fanli.service.impl.lable;



import java.util.ArrayList;

import java.util.Date;

import java.util.HashSet;

import java.util.List;



import javax.annotation.Resource;



import org.springframework.cache.annotation.Cacheable;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;



import com.yeshi.fanli.dao.mybatis.lable.LabelClassMapper;

import com.yeshi.fanli.entity.bus.clazz.GoodsClass;

import com.yeshi.fanli.entity.bus.clazz.GoodsSubClass;

import com.yeshi.fanli.entity.bus.lable.Label;

import com.yeshi.fanli.entity.bus.lable.LabelClass;

import com.yeshi.fanli.exception.goods.quality.LabelClassException;

import com.yeshi.fanli.service.inter.lable.LabelClassService;

import com.yeshi.fanli.service.inter.lable.LabelService;



@Service

public class LabelClassServiceImpl implements LabelClassService {



	
   @Resource

   private LabelService labelService;

	
   @Resource

   private LabelClassMapper labelClassMapper;

	
	


   @Override

   public int insert(LabelClass record) throws LabelClassException{

      return labelClassMapper.insert(record);

   }



	
   @Override

   public int updateByPrimaryKey(LabelClass record) throws LabelClassException{

      return labelClassMapper.updateByPrimaryKey(record);

   }



   @Override

   public int updateByPrimaryKeySelective(LabelClass record) throws LabelClassException{

      return labelClassMapper.updateByPrimaryKeySelective(record);

   }



   @Override

   public int deleteByPrimaryKey(Long id) throws LabelClassException{

      return labelClassMapper.deleteByPrimaryKey(id);

   }





   @Override

   public LabelClass selectByPrimaryKey(Long id) throws LabelClassException {

      return labelClassMapper.selectByPrimaryKey(id);

   }

	
   @Override

   public List<LabelClass> getByClassId(Long classId) throws LabelClassException {

      return labelClassMapper.getByClassId(classId);

   }

	
   @Override

   public List<LabelClass> getBySubClassId(Long classId) throws LabelClassException {

      return labelClassMapper.getBySubClassId(classId);

   }

	
	
   @Override

   public List<LabelClass> queryByClassId(int start, int count, Long classId) throws LabelClassException {

      return labelClassMapper.queryByClassId(start, count, classId);

   }

	
   @Override

   public int getCountQueryByClassId(Long classId) throws LabelClassException {

      return labelClassMapper.getCountQueryByClassId(classId);

   }

	
   @Override

   public List<LabelClass> queryBySubClassId(int start, int count, Long classId) throws LabelClassException {

      return labelClassMapper.queryBySubClassId(start, count, classId);

   }

	
   @Override

   @Cacheable(value = "labelCache",key="'queryBySubClassIdCache-'+#start+'-'+#classId")

   public List<LabelClass> queryBySubClassIdCache(int start, int count, Long classId) throws LabelClassException {

      return queryBySubClassId(start, count, classId);

   }

	
   @Override

   public List<Long> getRelationLabIds(int start, int count, Long classId) throws LabelClassException {

	
      /* 1、根据标签查询商品 */

      List<Long> listLabId = null;

		
      List<LabelClass> labelClassList = queryBySubClassIdCache(start, count, classId);



      if (labelClassList != null && labelClassList.size() > 0) {

         listLabId = new ArrayList<Long>();

         for (LabelClass labelClass : labelClassList) {

            Label label = labelClass.getLabel();

            listLabId.add(label.getId());

         }

      }

		
      return listLabId; 
		
   }

	
	
   @Override

   public int getCountQueryBySubClassId(Long subClassId) throws LabelClassException {

      return labelClassMapper.getCountQueryBySubClassId(subClassId);

   }

	
	
	
   @Override

   @Transactional

   public void addBatchClass(GoodsClass goodsClass,List<Long> labIdList) throws Exception {

		
      long recordId = goodsClass.getId();

		
      if (labIdList == null || labIdList.size() == 0) {

         // 清空关联标签

         labelClassMapper.deleteByClassId(recordId);

         return;

      }

		
      // 删除标签

      List<Long> subList = new ArrayList<Long>();

		
      // 查询现有关联标签

      List<LabelClass> hasList = labelClassMapper.getByClassId(recordId);

		
		
      // 已存在，则遍历哪些需要删除

      if (hasList != null && hasList.size() > 0) {

			
         for (LabelClass lClass: hasList) {

				
            Long lablClassID = lClass.getId();

				
            Label label = lClass.getLabel();

				
            if (label != null) {

					
               Long labid = label.getId();

               if (labIdList.contains(labid)) {

                  // 包含，则从集合中删除 labid

                  labIdList.remove(labid);

               } else {

                  // 当前传递中不包含  那么需要删除 lablClassID

                  subList.add(lablClassID);

               }

            }

         }

      }

			
      if (subList != null && subList.size() > 0) {

         for (Long id: subList) {

            labelClassMapper.deleteByPrimaryKey(id);

         }

      }

		
      if (labIdList != null && labIdList.size() > 0) {

			
         // 去重复

          HashSet<Long> h = new HashSet<Long>(labIdList);   
          labIdList.clear();   
          labIdList.addAll(h);   
		    
         for (Long labId: labIdList) {

            // 查询数据库 标签是否存在

            Label label = labelService.selectByPrimaryKey(labId);

            if (label == null) {

               continue;

            } 
				
            LabelClass labelClass = new LabelClass();

				
            labelClass.setLabel(label);

            labelClass.setGoodClass(goodsClass);

            labelClass.setCreatetime(new Date());

            labelClassMapper.insertSelective(labelClass);

         }

      }

			
   }

	
	
   @Override

   @Transactional

   public void addBatchSubClass(GoodsSubClass goodsSubClass,List<Long> labIdList) throws Exception {

		
      long recordId = goodsSubClass.getId();

      // 删除标签

      List<Long> subList = new ArrayList<Long>();

		
      // 查询现有关联标签

      List<LabelClass> hasList = labelClassMapper.getBySubClassId(recordId);

		
		
      // 已存在，则遍历哪些需要删除

      if (hasList != null && hasList.size() > 0) {

			
         for (LabelClass lClass: hasList) {

            Long lablClassID = lClass.getId();

            Label label = lClass.getLabel();

            if (label != null) {

               Long id = label.getId();

					
					
               if (labIdList.contains(id)) {

                  // 包含，则从集合中删除 labid

                  labIdList.remove(id);

						
               } else {

                  // 当前传递中不包含  那么需要删除 lablClassID

                  subList.add(lablClassID);

               }

            }

         }

      }

		
      /*    删除标签       */

      if (subList != null && subList.size() > 0) {

         for (Long id: subList) {

            labelClassMapper.deleteByPrimaryKey(id);

         }

      }

		
      /*    添加新增标签       */

      if (labIdList != null && labIdList.size() > 0) {

			
         // 去重复

          HashSet<Long> h = new HashSet<Long>(labIdList);   
          labIdList.clear();   
          labIdList.addAll(h);   
			 
			
         for (Long labId: labIdList) {

				
            Label label = labelService.selectByPrimaryKey(labId);

            if (label == null) {

               continue;

            } 
				
            LabelClass labelClass = new LabelClass();

				
            labelClass.setLabel(label);

            labelClass.setCreatetime(new Date());

            labelClass.setGoodsSubClass(goodsSubClass);

            labelClassMapper.insertSelective(labelClass);

         }

      }

		
			
   }

		
	
   @Override

   public int deleteByClassId(Long recordId) throws Exception {

      return labelClassMapper.deleteByClassId(recordId);

   }

	
   @Override

   public int deleteBySubClassId(Long recordId) throws Exception {

      return labelClassMapper.deleteBySubClassId(recordId);

   }

	
}



package com.yeshi.fanli.service.impl.lable;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashSet;
import java.util.List;

import javax.annotation.Resource;

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.yeshi.fanli.dao.mybatis.lable.LabelClassMapper;
import com.yeshi.fanli.entity.bus.clazz.GoodsClass;
import com.yeshi.fanli.entity.bus.clazz.GoodsSubClass;
import com.yeshi.fanli.entity.bus.lable.Label;
import com.yeshi.fanli.entity.bus.lable.LabelClass;
import com.yeshi.fanli.exception.goods.quality.LabelClassException;
import com.yeshi.fanli.service.inter.lable.LabelClassService;
import com.yeshi.fanli.service.inter.lable.LabelService;

@Service
public class LabelClassServiceImpl implements LabelClassService {

	
   @Resource
   private LabelService labelService;
	
   @Resource
   private LabelClassMapper labelClassMapper;
	
	

   @Override
   public int insert(LabelClass record) throws LabelClassException{
      return labelClassMapper.insert(record);
   }

	
   @Override
   public int updateByPrimaryKey(LabelClass record) throws LabelClassException{
      return labelClassMapper.updateByPrimaryKey(record);
   }

   @Override
   public int updateByPrimaryKeySelective(LabelClass record) throws LabelClassException{
      return labelClassMapper.updateByPrimaryKeySelective(record);
   }

   @Override
   public int deleteByPrimaryKey(Long id) throws LabelClassException{
      return labelClassMapper.deleteByPrimaryKey(id);
   }


   @Override
   public LabelClass selectByPrimaryKey(Long id) throws LabelClassException {
      return labelClassMapper.selectByPrimaryKey(id);
   }
	
   @Override
   public List<LabelClass> getByClassId(Long classId) throws LabelClassException {
      return labelClassMapper.getByClassId(classId);
   }
	
   @Override
   public List<LabelClass> getBySubClassId(Long classId) throws LabelClassException {
      return labelClassMapper.getBySubClassId(classId);
   }
	
	
   @Override
   public List<LabelClass> queryByClassId(int start, int count, Long classId) throws LabelClassException {
      return labelClassMapper.queryByClassId(start, count, classId);
   }
	
   @Override
   public int getCountQueryByClassId(Long classId) throws LabelClassException {
      return labelClassMapper.getCountQueryByClassId(classId);
   }
	
   @Override
   public List<LabelClass> queryBySubClassId(int start, int count, Long classId) throws LabelClassException {
      return labelClassMapper.queryBySubClassId(start, count, classId);
   }
	
   @Override
   @Cacheable(value = "labelCache",key="'queryBySubClassIdCache-'+#start+'-'+#classId")
   public List<LabelClass> queryBySubClassIdCache(int start, int count, Long classId) throws LabelClassException {
      return queryBySubClassId(start, count, classId);
   }
	
   @Override
   public List<Long> getRelationLabIds(int start, int count, Long classId) throws LabelClassException {
	
      /* 1、根据标签查询商品 */
      List<Long> listLabId = null;
		
      List<LabelClass> labelClassList = queryBySubClassIdCache(start, count, classId);

      if (labelClassList != null && labelClassList.size() > 0) {
         listLabId = new ArrayList<Long>();
         for (LabelClass labelClass : labelClassList) {
            Label label = labelClass.getLabel();
            listLabId.add(label.getId());
         }
      }
		
      return listLabId; 
		
   }
	
	
   @Override
   public int getCountQueryBySubClassId(Long subClassId) throws LabelClassException {
      return labelClassMapper.getCountQueryBySubClassId(subClassId);
   }
	
	
	
   @Override
   @Transactional(rollbackFor=Exception.class)
   public void addBatchClass(GoodsClass goodsClass,List<Long> labIdList) throws Exception {
		
      long recordId = goodsClass.getId();
		
      if (labIdList == null || labIdList.size() == 0) {
         // 清空关联标签
         labelClassMapper.deleteByClassId(recordId);
         return;
      }
		
      // 删除标签
      List<Long> subList = new ArrayList<Long>();
		
      // 查询现有关联标签
      List<LabelClass> hasList = labelClassMapper.getByClassId(recordId);
		
		
      // 已存在，则遍历哪些需要删除
      if (hasList != null && hasList.size() > 0) {
			
         for (LabelClass lClass: hasList) {
				
            Long lablClassID = lClass.getId();
				
            Label label = lClass.getLabel();
				
            if (label != null) {
					
               Long labid = label.getId();
               if (labIdList.contains(labid)) {
                  // 包含，则从集合中删除 labid
                  labIdList.remove(labid);
               } else {
                  // 当前传递中不包含  那么需要删除 lablClassID
                  subList.add(lablClassID);
               }
            }
         }
      }
			
      if (subList != null && subList.size() > 0) {
         for (Long id: subList) {
            labelClassMapper.deleteByPrimaryKey(id);
         }
      }
		
      if (labIdList != null && labIdList.size() > 0) {
			
         // 去重复
          HashSet<Long> h = new HashSet<Long>(labIdList);   
          labIdList.clear();   
          labIdList.addAll(h);   
		    
         for (Long labId: labIdList) {
            // 查询数据库 标签是否存在
            Label label = labelService.selectByPrimaryKey(labId);
            if (label == null) {
               continue;
            } 
				
            LabelClass labelClass = new LabelClass();
				
            labelClass.setLabel(label);
            labelClass.setGoodClass(goodsClass);
            labelClass.setCreatetime(new Date());
            labelClassMapper.insertSelective(labelClass);
         }
      }
			
   }
	
	
   @Override
   @Transactional(rollbackFor=Exception.class)
   public void addBatchSubClass(GoodsSubClass goodsSubClass,List<Long> labIdList) throws Exception {
		
      long recordId = goodsSubClass.getId();
      // 删除标签
      List<Long> subList = new ArrayList<Long>();
		
      // 查询现有关联标签
      List<LabelClass> hasList = labelClassMapper.getBySubClassId(recordId);
		
		
      // 已存在，则遍历哪些需要删除
      if (hasList != null && hasList.size() > 0) {
			
         for (LabelClass lClass: hasList) {
            Long lablClassID = lClass.getId();
            Label label = lClass.getLabel();
            if (label != null) {
               Long id = label.getId();
					
					
               if (labIdList.contains(id)) {
                  // 包含，则从集合中删除 labid
                  labIdList.remove(id);
						
               } else {
                  // 当前传递中不包含  那么需要删除 lablClassID
                  subList.add(lablClassID);
               }
            }
         }
      }
		
      /*    删除标签       */
      if (subList != null && subList.size() > 0) {
         for (Long id: subList) {
            labelClassMapper.deleteByPrimaryKey(id);
         }
      }
		
      /*    添加新增标签       */
      if (labIdList != null && labIdList.size() > 0) {
			
         // 去重复
          HashSet<Long> h = new HashSet<Long>(labIdList);   
          labIdList.clear();   
          labIdList.addAll(h);   
			 
			
         for (Long labId: labIdList) {
				
            Label label = labelService.selectByPrimaryKey(labId);
            if (label == null) {
               continue;
            } 
				
            LabelClass labelClass = new LabelClass();
				
            labelClass.setLabel(label);
            labelClass.setCreatetime(new Date());
            labelClass.setGoodsSubClass(goodsSubClass);
            labelClassMapper.insertSelective(labelClass);
         }
      }
		
			
   }
		
	
   @Override
   public int deleteByClassId(Long recordId) throws Exception {
      return labelClassMapper.deleteByClassId(recordId);
   }
	
   @Override
   public int deleteBySubClassId(Long recordId) throws Exception {
      return labelClassMapper.deleteBySubClassId(recordId);
   }
	
}