尚品汇-（九）

（1）品牌管理

品牌表： 

实体类：BaseTrademark 

package com.atguigu.gmall.model.product;

import com.atguigu.gmall.model.base.BaseEntity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

/**
 * <p>
 * BaseTrademark
 * </p>
 *
 */
@Data
@ApiModel(description = "商标品牌")
@TableName("base_trademark")
public class BaseTrademark extends BaseEntity {
	
	private static final long serialVersionUID = 1L;
	
	@ApiModelProperty(value = "属性值")
	@TableField("tm_name")
	private String tmName;

	@ApiModelProperty(value = "品牌logo的图片路径")
	@TableField("logo_url")
	private String logoUrl;

}

创建mapper：BaseTrademarkMapper 

@Mapper
public interface BaseTrademarkMapper extends BaseMapper<BaseTrademark> {

}

创建接口BaseTrademarkService 

public interface BaseTrademarkService  extends IService<BaseTrademark> {

   /**
    * Banner分页列表
    * @param pageParam
    * @return
    */
   IPage<BaseTrademark> getPage(Page<BaseTrademark> pageParam);

}

 创建实现类BaseTrademarkServiceImpl

@Service
public class BaseTrademarkServiceImpl extends ServiceImpl<BaseTrademarkMapper, BaseTrademark> implements BaseTrademarkService {

   @Autowired
   private BaseTrademarkMapper baseTrademarkMapper;

   @Override
   public IPage<BaseTrademark> getPage(Page<BaseTrademark> pageParam) {
      QueryWrapper<BaseTrademark> queryWrapper = new QueryWrapper<>();
      queryWrapper.orderByAsc("id");

      IPage<BaseTrademark> page = baseTrademarkMapper.selectPage(pageParam, queryWrapper);
      return page;
   }
}

创建控制器 BaseTrademarkController

@RestController
@RequestMapping("/admin/product/baseTrademark")
public class BaseTrademarkController {

   @Autowired
   private BaseTrademarkService baseTrademarkService;

   @ApiOperation(value = "分页列表")
   @GetMapping("{page}/{limit}")
   public Result index(@PathVariable Long page,
                       @PathVariable Long limit) {

      Page<BaseTrademark> pageParam = new Page<>(page, limit);
      IPage<BaseTrademark> pageModel = baseTrademarkService.getPage(pageParam);
      return Result.ok(pageModel);
   }

   @ApiOperation(value = "获取BaseTrademark")
   @GetMapping("get/{id}")
   public Result get(@PathVariable String id) {
      BaseTrademark baseTrademark = baseTrademarkService.getById(id);
      return Result.ok(baseTrademark);
   }

   @ApiOperation(value = "新增BaseTrademark")
   @PostMapping("save")
   public Result save(@RequestBody BaseTrademark banner) {
         baseTrademarkService.save(banner);
      return Result.ok();
   }

   @ApiOperation(value = "修改BaseTrademark")
   @PutMapping("update")
   public Result updateById(@RequestBody BaseTrademark banner) {
         baseTrademarkService.updateById(banner);
      return Result.ok();
   }

   @ApiOperation(value = "删除BaseTrademark")
   @DeleteMapping("remove/{id}")
   public Result remove(@PathVariable Long id) {
         baseTrademarkService.removeById(id);
      return Result.ok();
   }

}

分页查询接口： 

删除接口：

修改接口：

（2）分类品牌列表

点击三类下拉框后就会查询分类品牌

品牌分类关系表 

CategoryTrademarkVo 实体类 

//
//
package com.atguigu.gmall.model.product;

import com.atguigu.gmall.model.base.BaseEntity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.util.List;

/**
 * <p>
 * BaseCategoryView
 * </p>
 *
 */
@Data
public class CategoryTrademarkVo {
	
	@ApiModelProperty(value = "三级分类编号")
	private Long category3Id;

	@ApiModelProperty(value = "品牌id")
	private List<Long> trademarkIdList;


}

创建mapperBase：CategoryTrademarkMapper 

@Mapper
public interface BaseCategoryTrademarkMapper extends BaseMapper<BaseCategoryTrademark> {
}

创建接口：BaseCategoryTrademarkService 

package com.atguigu.gmall.product.service;

public interface BaseCategoryTrademarkService extends IService<BaseCategoryTrademark> {

    /**
     * 根据三级分类获取品牌
     * @param category3Id
     * @return
     */
    List<BaseTrademark> findTrademarkList(Long category3Id);

    /**
     * 保存分类与品牌关联
     * @param categoryTrademarkVo
     */
    void save(CategoryTrademarkVo categoryTrademarkVo);

    /**
     * 获取当前未被三级分类关联的所有品牌
     * @param category3Id
     * @return
     */
    List<BaseTrademark> findCurrentTrademarkList(Long category3Id);

    /**
     * 删除关联
     * @param category3Id
     * @param trademarkId
     */
    void remove(Long category3Id, Long trademarkId);
}

 创建实现类：BaseCategoryTrademarkServiceImpl 

查询品牌的时候有好几种方式，我们用selectBatchIds

package com.atguigu.gmall.product.service.impl;

@Service
public class BaseCategoryTrademarkServiceImpl extends ServiceImpl<BaseCategoryTrademarkMapper,BaseCategoryTrademark> implements BaseCategoryTrademarkService {

    //  调用mapper 层！
    @Autowired
    private BaseTrademarkMapper baseTrademarkMapper;

    @Autowired
    private BaseCategoryTrademarkMapper baseCategoryTrademarkMapper;


    /**
     * 根据三级分类获取品牌
     * @param category3Id
     * @return
     */
    @Override
    public List<BaseTrademark> findTrademarkList(Long category3Id) {
        //  根据分类Id 获取到品牌Id 集合数据  map：获取遍历过程中指定的数据
        //  select * from base_category_trademark where category3_id = ?;
        QueryWrapper<BaseCategoryTrademark> baseCategoryTrademarkQueryWrapper = new QueryWrapper<>();
        baseCategoryTrademarkQueryWrapper.eq("category3_id",category3Id);
        List<BaseCategoryTrademark> baseCategoryTrademarkList = baseCategoryTrademarkMapper.selectList(baseCategoryTrademarkQueryWrapper);

        //  判断baseCategoryTrademarkList 这个集合
        if(!CollectionUtils.isEmpty(baseCategoryTrademarkList)){
            //  需要获取到这个集合中的品牌Id 集合数据
            List<Long> tradeMarkIdList = baseCategoryTrademarkList.stream().map(baseCategoryTrademark -> {
                return baseCategoryTrademark.getTrademarkId();
            }).collect(Collectors.toList());
            //  正常查询数据的话... 需要根据品牌Id 来获取集合数据！
            return baseTrademarkMapper.selectBatchIds(tradeMarkIdList);
        }
        //  如果集合为空，则默认返回空
        return null;
    }

    //删除分类品牌关联
    @Override
    public void removeBaseCategoryTrademarkById(Long category3Id, Long trademarkId) {
        //  逻辑删除： 本质更新操作 is_deleted
        //  更新： update base_category_trademark set is_deleted = 1 where category3_id=? and trademark_id=?;
        QueryWrapper<BaseCategoryTrademark> baseCategoryTrademarkQueryWrapper = new QueryWrapper<>();
        baseCategoryTrademarkQueryWrapper.eq("category3_id",category3Id);
        baseCategoryTrademarkQueryWrapper.eq("trademark_id",trademarkId);
        baseCategoryTrademarkMapper.delete(baseCategoryTrademarkQueryWrapper);

    }


   
   //获取当前未被三级分类关联的所有品牌
    @Override
    public List<BaseTrademark> findCurrentTrademarkList(Long category3Id) {
        //  哪些是关联的品牌Id
        QueryWrapper<BaseCategoryTrademark> baseCategoryTrademarkQueryWrapper = new QueryWrapper<>();
        baseCategoryTrademarkQueryWrapper.eq("category3_id",category3Id);
        List<BaseCategoryTrademark> baseCategoryTrademarkList = baseCategoryTrademarkMapper.selectList(baseCategoryTrademarkQueryWrapper);

        //  判断
        if (!CollectionUtils.isEmpty(baseCategoryTrademarkList)){
            //  找到关联的品牌Id 集合数据 {1,3}
            List<Long> tradeMarkIdList = baseCategoryTrademarkList.stream().map(baseCategoryTrademark -> {
                return baseCategoryTrademark.getTrademarkId();
            }).collect(Collectors.toList());
            //  在所有的品牌Id 中将这些有关联的品牌Id 给过滤掉就可以！
            //  select * from base_trademark; 外面 baseTrademarkMapper.selectList(null) {1,2,3,5}
            List<BaseTrademark> baseTrademarkList = baseTrademarkMapper.selectList(null).stream().filter(baseTrademark -> {
                return !tradeMarkIdList.contains(baseTrademark.getId());
            }).collect(Collectors.toList());
            //  返回数据
            return baseTrademarkList;
        }
        //  如果说这个三级分类Id 下 没有任何品牌！ 则获取到所有的品牌数据！
        return baseTrademarkMapper.selectList(null);
    }

    
    //保存分类与品牌关联
    @Override
    public void save(CategoryTrademarkVo categoryTrademarkVo) {
        /*
        private Long category3Id;
        private List<Long> trademarkIdList;

        category3Id 61 2   BasecategoryTrademark;
        category3Id 61 5   BasecategoryTrademark;
         */
        //  获取到品牌Id 集合数据
        List<Long> trademarkIdList = categoryTrademarkVo.getTrademarkIdList();

        //  判断
        if (!CollectionUtils.isEmpty(trademarkIdList)){
                  //  做映射关系
            List<BaseCategoryTrademark> baseCategoryTrademarkList = trademarkIdList.stream().map((trademarkId) -> {
                //  创建一个分类Id 与品牌的关联的对象
                BaseCategoryTrademark baseCategoryTrademark = new BaseCategoryTrademark();
                baseCategoryTrademark.setCategory3Id(categoryTrademarkVo.getCategory3Id());
                baseCategoryTrademark.setTrademarkId(trademarkId);
                //  返回数据
                return baseCategoryTrademark;
            }).collect(Collectors.toList());

            //  集中保存到数据库    baseCategoryTrademarkList
            this.saveBatch(baseCategoryTrademarkList);
        }
    }
}

 //获取当前未被三级分类关联的所有品牌:

创建控制器：

package com.atguigu.gmall.product.controller;

@RestController
@RequestMapping("admin/product/baseCategoryTrademark")
public class BaseCategoryTrademarkController {

    @Autowired
    private BaseCategoryTrademarkService baseCategoryTrademarkService;


    @PostMapping("save")
    public Result save(@RequestBody CategoryTrademarkVo categoryTrademarkVo){
        //  保存方法
        baseCategoryTrademarkService.save(categoryTrademarkVo);
        return Result.ok();
    }


    //删除分类品牌关联
    @DeleteMapping("remove/{category3Id}/{trademarkId}")
    public Result remove(@PathVariable Long category3Id, @PathVariable Long trademarkId){
        //  调用服务层方法
        baseCategoryTrademarkService.remove(category3Id, trademarkId);
        return Result.ok();
    }


    //根据category3Id获取品牌列表
    @GetMapping("findTrademarkList/{category3Id}")
    public Result findTrademarkList(@PathVariable Long category3Id){
        //  select * from base_trademark
        List<BaseTrademark> list = baseCategoryTrademarkService.findTrademarkList(category3Id);
        //  返回
        return Result.ok(list);
    }


    //根据category3Id获取可选的品牌列表
    @GetMapping("findCurrentTrademarkList/{category3Id}")
    public Result findCurrentTrademarkList(@PathVariable Long category3Id){
        List<BaseTrademark> list = baseCategoryTrademarkService.findCurrentTrademarkList(category3Id);
        //  返回
        return Result.ok(list);
    }
}

根据category3Id获取品牌列表：

删除的话对应删除的关系表的数据：

//删除分类品牌关联：

添加品牌： 

 根据category3Id获取可选的品牌列表：

保存分类与品牌关联:

删除后，再关联就多了关联选项