/**
 * 規格參數列表
 */
@GetMapping("/{attrType}/list/{catelogId}")
//@RequiresPermissions("product:attr:list")
public R baseAttrList(@RequestParam Map<String, Object> params,
                      @PathVariable("catelogId") Long catelogId,
                      @PathVariable("attrType") String attrType
) {
    PageUtils page = attrService.queryBaseAttrPage(params, catelogId, attrType);
    return R.ok().put("page", page);
}

@Override
public PageUtils queryBaseAttrPage(Map<String, Object> params, Long catelogId, String attrType) {
    QueryWrapper<AttrEntity> qw = new QueryWrapper<>();
    // 判斷是要銷售還是基本屬性，1=基本，0=銷售
    qw.eq("attr_type", "base".equalsIgnoreCase(attrType) ? 1 : 0);

/**
 * 根據分組ID查找關聯
 *
 * @param attrgroupId
 * @return
 */
@GetMapping("/{attrgroupId}/attr/relation")
public R attrRelation(@PathVariable("attrgroupId") Long attrgroupId) {
    List<AttrEntity> entities = attrService.getAttrRelation(attrgroupId);
    return R.ok().put("data", entities);
}

@Override
public List<AttrEntity> getAttrRelation(Long attrgroupId) {
    List<AttrAttrgroupRelationEntity> relationEntities =
            relationDao.selectList(new QueryWrapper<AttrAttrgroupRelationEntity>().eq("attr_group_id",
                    attrgroupId));
    // 收集出attrId
    List<Long> longList =
            relationEntities.stream().map(AttrAttrgroupRelationEntity::getAttrId).collect(Collectors.toList());
    if (longList == null || longList.size() == 0) {
        return null;
    }
    return this.listByIds(longList);
    }

/**
 * 删除
 */
@PostMapping("/attr/relation/delete")
public R delete(@RequestBody AttrGroupRelationVo[] vos) {
    attrService.deleteRelation(vos);
    return R.ok();
}

@Override
public void deleteRelation(AttrGroupRelationVo[] vos) {
    // 無情將VO再轉回來 哭R
    List<AttrAttrgroupRelationEntity> entities = Arrays.stream(vos).map(item -> {
        AttrAttrgroupRelationEntity relationEntity = new AttrAttrgroupRelationEntity();
        BeanUtils.copyProperties(item, relationEntity);
        return relationEntity;
    }).collect(Collectors.toList());
    relationDao.batchDelete(entities);
}

<delete id="batchDelete">
    DELETE
    FROM pms_attr_attrgroup_relation WHERE
    <foreach collection="entities" item="item" separator=" OR ">
        attr_id = #{item.attrId} AND attr_group_id = #{item.attrGroupId}
    </foreach>
</delete>

	/**
     * 根據分組ID查找無關聯(新增時逆向篩選用)
     */
@GetMapping("/{attrgroupId}/noattr/relation")
public R attrNoRelation(@RequestParam Map<String, Object> params,
                        @PathVariable("attrgroupId") Long attrgroupId) {
    PageUtils page = attrService.getAttrNoRelation(params, attrgroupId);

    return R.ok().put("page", page);

}

@Override
public PageUtils getAttrNoRelation(Map<String, Object> params, Long attrgroupId) {
    // 只查自己所屬分類中的屬性
    AttrGroupEntity attrGroupEntity = attrGroupDao.selectById(attrgroupId);
    // 獲取當前分類的id
    Long catelogId = attrGroupEntity.getCatelogId();

    // 只關連沒引用的屬性，這裡用排除法把已經被關聯的ID找出來，這是用來存排除的清單
    List<Long> alreadyInGroupIdList = new ArrayList<>();
    // 先找出當前分類下的其他分組
    List<AttrGroupEntity> attr_groups = attrGroupDao.selectList(new QueryWrapper<AttrGroupEntity>().eq(
            "catelog_id"
            , catelogId));
    List<Long> attr_group_ids =
            attr_groups.stream().map(AttrGroupEntity::getAttrGroupId).collect(Collectors.toList());
    // 現在獲取到可能很多個attr_group_id，一個attr_group_id又會對應多個attr_id
    if (attr_group_ids != null && attr_group_ids.size() > 0) {
        // 到pms_attr_attrgroup_relation，拿attr_group_id找出對應的relationEntities
        List<AttrAttrgroupRelationEntity> relationEntities =
                relationDao.selectList(new QueryWrapper<AttrAttrgroupRelationEntity>().in("attr_group_id",
                        attr_group_ids));
        // 這些relationEntities有attr_group_id，表示他的attr_id已經在某個分組內了
        if (relationEntities != null && relationEntities.size() > 0) {
            // 把其中的ID一個一個找出來，這些是要排除的
            alreadyInGroupIdList =
                    relationEntities.stream().map(AttrAttrgroupRelationEntity::getAttrId).collect(Collectors.toList());
        }
    }
    // 可以開查了
    QueryWrapper<AttrEntity> queryWrapper = new QueryWrapper<AttrEntity>();
    // 如果有要排除的
    if (alreadyInGroupIdList != null && alreadyInGroupIdList.size() > 0) {
        // 只查自己所屬分類中的屬性，移除掉要排除的，而且只要基本屬性
        queryWrapper.eq("catelog_id", catelogId).notIn("attr_id", alreadyInGroupIdList).eq("attr_type",
                ProductConstant.ATTR_TYPE_BASE.getCode());
    } else {
        // 只查自己所屬分類中的屬性，而且只要基本屬性
        queryWrapper.eq("catelog_id", catelogId).eq("attr_type", ProductConstant.ATTR_TYPE_BASE.getCode());
    }
    // 前端要的是page，還可能要查key
    String key = (String) params.get("key");
    if (!StringUtils.isEmpty(key)) {
        queryWrapper.and(qw -> {
            qw.eq("attr_id", key).or().like("attr_name", key);
        });
    }
    IPage<AttrEntity> page = this.page(new Query<AttrEntity>().getPage(params),
            queryWrapper);
    PageUtils pageUtils = new PageUtils(page);
    return pageUtils;
}

/**
 * 新增保存
 */
@RequestMapping("/attr/relation")
//@RequiresPermissions("product:attrgroup:save")
public R addAttrGroupRelation(@RequestBody List<AttrGroupRelationVo> vos) {
    relationService.addAttrGroupRelation(vos);

    return R.ok();
}

@Override
public void addAttrGroupRelation(List<AttrGroupRelationVo> vos) {
    List<AttrAttrgroupRelationEntity> collect = vos.stream().map(e -> {
        // 一樣，轉存
        AttrAttrgroupRelationEntity relationEntity = new AttrAttrgroupRelationEntity();
        BeanUtils.copyProperties(e, relationEntity);
        return relationEntity;
    }).collect(Collectors.toList());
    // 調用原生批量保存
    this.saveBatch(collect);
}

/**
 * 刪除
 */
@RequestMapping("/delete")
//@RequiresPermissions("product:attr:delete")
public R delete(@RequestBody Long[] attrIds) {
    attrService.removeAttrAndRelationByIds(Arrays.asList(attrIds));
    return R.ok();
}

@Override
public void removeAttrAndRelationByIds(List<Long> asList) {
    this.removeByIds(asList);
    // 還要移除關聯
    List<AttrAttrgroupRelationEntity> entities =
            relationDao.selectList(new QueryWrapper<AttrAttrgroupRelationEntity>().in("attr_id", asList));
    if (entities != null && entities.size() > 0) {
        relationDao.batchDelete(entities);
    }
}

        - id: member_route
          uri: lb://member
          predicates:
            - Path=/api/member/**
          filters:
            - RewritePath=/api/(?<segment>.*),/$\{segment}

@Data
public class BrandVo {
    private Long brandId;
    private String brandName;
}

/**
 * 根據catId返回關聯的品牌
 */
@GetMapping("/brands/list")
public R list(@RequestParam("catId") Long catId) {
    List<BrandEntity> vos = categoryBrandRelationService.getBrandsByCatId(catId);
    List<BrandVo> list = vos.stream().map(e -> {
        BrandVo brandVo = new BrandVo();
        brandVo.setBrandId(e.getBrandId);
        brandVo.setBrandName(e.getBrandName);
        return brandVo;
    }).collect(Collectors.toList());
    return R.ok().put("data", list);
}

@Override
public List<BrandEntity> getBrandsByCatId(Long catId) {
    List<CategoryBrandRelationEntity> relationEntities =
            baseMapper.selectList(new QueryWrapper<CategoryBrandRelationEntity>().eq("catelog_id", catId));
    List<BrandEntity> collect = relationEntities.stream().map(e -> {
        Long brandId = e.getBrandId();
        // 調用Service而非DAO，因為DAO是生成的最好寫死的
        return brandService.getById(brandId);
    }).collect(Collectors.toList());
    return collect;
}

/**
 * 新增商品獲取規格參數
 */
@GetMapping("/{catelogId}/withattr")
public R getAttrGroupWithAttrs(@PathVariable("catelogId") Long catelogId) {
    List<AttrGroupWithAttrsVo> vos = attrGroupService.getAttrGroupWithAttrsByCatelogId(catelogId);
    return R.ok().put("data", vos);
}

@Override
public List<AttrGroupWithAttrsVo> getAttrGroupWithAttrsByCatelogId(Long catelogId) {
    List<AttrGroupEntity> attrGroupEntities = this.list(new QueryWrapper<AttrGroupEntity>().eq("catelog_id",
            catelogId));
    List<AttrGroupWithAttrsVo> collect = attrGroupEntities.stream().map(e -> {
        AttrGroupWithAttrsVo attrGroupWithAttrsVo = new AttrGroupWithAttrsVo();
        BeanUtils.copyProperties(e, attrGroupWithAttrsVo);
        // 獲取attrs，用之前寫過的方法從分組ID就能找到
        List<AttrEntity> attrEntityList = attrService.getAttrRelation(e.getAttrGroupId());
        // 裝進VO
        attrGroupWithAttrsVo.setAttrs(attrEntityList);
        return attrGroupWithAttrsVo;
    }).collect(Collectors.toList());
    return collect;
}

/**
 * 保存SpuSaveVo
 */
@RequestMapping("/save")
public R save(@RequestBody SpuSaveVo vo) {
    spuInfoService.saveSpuInfo(vo);
    return R.ok();
}

@Transactional(rollbackFor = Exception.class)
@Override
public void saveSpuInfo(SpuSaveVo vo) {
    // 1、保存spu基本信息：pms_spu_info
    SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
    BeanUtils.copyProperties(vo, spuInfoEntity);
    spuInfoEntity.setCreateTime(new Date());
    spuInfoEntity.setUpdateTime(new Date());
    this.save(spuInfoEntity);

    // 2、保存spu的描述圖片：pms_spu_info_desc
    // 這個decript錯字來自前端...算了就照它的吧
    List<String> decript = vo.getDecript();
    SpuInfoDescEntity spuInfoDescEntity = new SpuInfoDescEntity();
    spuInfoDescEntity.setSpuId(spuInfoEntity.getId());
    // 用逗號分隔多張描述圖片，描述圖片就是購物時左上那些摸過去會放大的小圖
    // String.join方法可以自動遍歷數組中的String然後拼接成一個String
    spuInfoDescEntity.setDecript(String.join(",", decript));
    spuInfoDescService.save(spuInfoDescEntity);

    // 3、保存spu的圖片集：pms_spu_images，
    // 圖片集就是往下拉，在頁面中央出現的多張商品宣傳大圖
    List<String> images = vo.getImages();
    spuImagesService.saveImages(spuInfoEntity.getId(), images);

    // 4、保存spu的規格參數：pms_product_attr_value
    List<BaseAttrsItem> baseAttrs = vo.getBaseAttrs();
    List<ProductAttrValueEntity> collect = baseAttrs.stream().map(attr -> {
        ProductAttrValueEntity valueEntity = new ProductAttrValueEntity();
        valueEntity.setAttrId(attr.getAttrId());

        // 查詢attr屬性名
        AttrEntity byId = attrService.getById(attr.getAttrId());

        valueEntity.setAttrName(byId.getAttrName());
        valueEntity.setAttrValue(attr.getAttrValues());
        valueEntity.setQuickShow(attr.getShowDesc());
        valueEntity.setSpuId(spuInfoEntity.getId());
        return valueEntity;
    }).collect(Collectors.toList());
    productAttrValueService.saveBatch(collect);

    // 6、保存spu的積分信息：gulimall_sms--->sms_spu_bounds
    Bounds bounds = vo.getBounds();
    SpuBoundsTo spuBoundsTo = new SpuBoundsTo();
    BeanUtils.copyProperties(bounds, spuBoundsTo);
    spuBoundsTo.setSpuId(spuInfoEntity.getId());
    R r = couponFeignService.saveSpuBounds(spuBoundsTo);

    if (r.getCode() != 0) {
        log.error("遠程保存spu積分失敗");
    }

    // 5、保存當前spu對應的所有sku信息：pms_sku_info
    List<SkusItem> skus = vo.getSkus();
    if (skus != null && skus.size() > 0) {
        skus.forEach(item -> {
            // 傳來的是多個skus，遍歷一個一個處理

            // 5、1）、sku的基本信息:pms_sku_info
            // 如果有設定預設圖片
            String defaultImg = "";
            for (ImagesItem image : item.getImages()) {
                if (image.getDefaultImg() == 1) {
                    defaultImg = image.getImgUrl();
                }
            }

            // 準備存到pms_sku_info表
            SkuInfoEntity skuInfoEntity = new SkuInfoEntity();
            BeanUtils.copyProperties(item, skuInfoEntity);
            skuInfoEntity.setBrandId(spuInfoEntity.getBrandId());
            // 資料庫中又是這個錯字CatalogId，之前被坑好久
            skuInfoEntity.setCatalogId(spuInfoEntity.getCatalogId());
            skuInfoEntity.setSaleCount(0L);
            skuInfoEntity.setSpuId(spuInfoEntity.getId());
            skuInfoEntity.setSkuDefaultImg(defaultImg);
            skuInfoService.save(skuInfoEntity);

            Long skuId = skuInfoEntity.getSkuId();
            // 5、2）、sku的圖片信息：pms_sku_images，這張表中的條目是基於skuId
            // 因為一個skuId可以有多張圖片
            List<SkuImagesEntity> imagesEntities = item.getImages().stream().map(img -> {
                SkuImagesEntity skuImagesEntity = new SkuImagesEntity();
                skuImagesEntity.setSkuId(skuId);
                skuImagesEntity.setImgUrl(img.getImgUrl());
                skuImagesEntity.setDefaultImg(img.getDefaultImg());
                return skuImagesEntity;
            }).filter(entity -> {
                // filter返回true就是需要留下的，false就是剔除的
                return !StringUtils.isEmpty(entity.getImgUrl());
            }).collect(Collectors.toList());

            // 批量保存到pms_sku_images
            skuImagesService.saveBatch(imagesEntities);

            // 5、3）、sku的銷售屬性：pms_sku_sale_attr_value
            // 就是因為銷售屬性的笛卡爾積導致有多個sku，這張表保存了某個skuId對應的屬性具體是啥值
            // 例如顏色是黑色，RAM是8G
            List<AttrItem> attr = item.getAttr();
            List<SkuSaleAttrValueEntity> skuSaleAttrValueEntities = attr.stream().map(a -> {
                SkuSaleAttrValueEntity skuSaleAttrValueEntity = new SkuSaleAttrValueEntity();
                BeanUtils.copyProperties(a, skuSaleAttrValueEntity);
                skuSaleAttrValueEntity.setSkuId(skuId);
                return skuSaleAttrValueEntity;
            }).collect(Collectors.toList());
            // 批量保存到pms_sku_sale_attr_value
            skuSaleAttrValueService.saveBatch(skuSaleAttrValueEntities);

            // 5、4）、sku的優惠、滿減等信息：gulimall_sms--->sms_sku_ladder、sms_sku_full_reduction、sms_member_price
            SkuReductionTo skuReductionTo = new SkuReductionTo();
            BeanUtils.copyProperties(item, skuReductionTo);
            skuReductionTo.setSkuId(skuId);
            // 有設定打折規則再保存，省得資料庫中存一堆0
            if (skuReductionTo.getFullCount() > 0 || skuReductionTo.getFullPrice().compareTo(BigDecimal.ZERO) == 1) {
                R r1 = couponFeignService.saveSkuReduction(skuReductionTo);
                if (r1.getCode() != 0) {
                    log.error("遠程保存sku優惠資訊失敗");
                }
            }
        });
    }

@Override
public void saveImages(Long id, List<String> images) {
    if (images != null && images.size() > 0) {
        // 要存成多條紀錄
        List<SpuImagesEntity> collect = images.stream().map(e -> {
            SpuImagesEntity spuImagesEntity = new SpuImagesEntity();
            spuImagesEntity.setSpuId(id);
            spuImagesEntity.setImgUrl(e);
            return spuImagesEntity;
        }).collect(Collectors.toList());
        this.saveBatch(collect);
    }
}

@FeignClient("coupon")
public interface CouponFeignService {
    // 上傳商品時，保存 遠程調用的積分訊息
    @PostMapping("/coupon/spubounds/save")
    R saveSpuBounds(@RequestBody SpuBoundsTo spuBoundsTo);
    // 相當於 R save(@RequestBody SpuBoundsEntity spuBounds)
    // 因為都是轉成JSON在傳送，轉回來屬性能對上就行

    // 上傳商品時，保存 遠程調用的滿減、會員優惠訊息
    @PostMapping("/coupon/skufullreduction/saveinfo")
    R saveSkuReduction(@RequestBody SkuReductionTo skuReductionTo);
}

@EnableFeignClients(basePackages = "yozi.mall.common.feign")
public class ProductApplication {

@Data
public class SkuReductionTo {

    private Long skuId;
    // 打幾折
    private BigDecimal discount;
    private Integer priceStatus;
    private BigDecimal fullPrice;
    private BigDecimal reducePrice;
    private Integer countStatus;
    // 滿幾件
    private Integer fullCount;

    private List<MemberPriceItem> memberPrice;
}

@Override
    public void saveInfo(SkuReductionTo skuReductionTo) {
        // 保存階梯優惠
        if (skuReductionTo.getFullCount() > 0) {
            SkuLadderEntity skuLadderEntity = new SkuLadderEntity();
            skuLadderEntity.setSkuId(skuReductionTo.getSkuId());
            skuLadderEntity.setFullCount(skuReductionTo.getFullCount());
            skuLadderEntity.setDiscount(skuReductionTo.getDiscount());
            skuLadderEntity.setAddOther(skuReductionTo.getCountStatus());
            skuLadderService.save(skuLadderEntity);
        }

        // 保存滿減優惠
        if (skuReductionTo.getFullPrice().compareTo(BigDecimal.ZERO) > 0) {
            SkuFullReductionEntity fullReductionEntity = new SkuFullReductionEntity();
            fullReductionEntity.setSkuId(skuReductionTo.getSkuId());
            fullReductionEntity.setFullPrice(skuReductionTo.getFullPrice());
            fullReductionEntity.setReducePrice(skuReductionTo.getReducePrice());
            fullReductionEntity.setAddOther(skuReductionTo.getCountStatus());
            this.save(fullReductionEntity);
        }

        // 保存會員優惠
        List<MemberPriceEntity> collect = skuReductionTo.getMemberPrice().stream().map(e -> {
            MemberPriceEntity memberPriceEntity = new MemberPriceEntity();
            memberPriceEntity.setSkuId(skuReductionTo.getSkuId());
            memberPriceEntity.setMemberLevelId(e.getId());
            memberPriceEntity.setMemberLevelName(e.getName());
            memberPriceEntity.setMemberPrice(e.getPrice());
            // 預設可疊加會員優惠
            memberPriceEntity.setAddOther(1);
            return memberPriceEntity;
        }).filter(e -> e.getMemberPrice().compareTo(BigDecimal.ZERO) > 0).collect(Collectors.toList());
        memberPriceService.saveBatch(collect);
    }

.filter(entity -> {
    // filter返回true就是需要留下的，false就是剔除的
    return !StringUtils.isEmpty(entity.getImgUrl());

xxx.compareTo(BigDecimal.ZERO) == 1 或 > 0