谷粒商城后台库存系统

在初级篇里：只有这些模块（仓库维护，商品库存，采购需求，采购单）
谷粒商城接口文档：https://easydoc.net/doc/75716633/ZUqEdvA4/hKJTcbfd
这里我没有依赖注入所以某些对象要自己注入，如果你是跟着谷粒商城项目敲过来，那么我写的对象你肯定知道怎么来的。

仓库维护模块

这里就是简单的增删改查，在这里不做多叙述

合并采购项

获取采购单信息(采购单状态是 ’ 未领取 ‘)

接口： /ware/purchase/unreceive/list
controller层
查询未领取的采购单
@GetMapping(value = "/unreceive/list")
    public R unreceiveList(@RequestParam Map<String, Object> params){
        PageUtils page = purchaseService.queryPageUnreceive(params);
        return R.ok().put("page", page);
    }

service层
@Override
   public PageUtils queryPageUnreceive(Map<String, Object> params) {
       IPage<PurchaseEntity> page = this.page(
               new Query<PurchaseEntity>().getPage(params),
               new QueryWrapper<PurchaseEntity>().eq("status",0).or().eq("status",1)
       );
       return new PageUtils(page);
   }

合并采购需求-》变为采购单
注意：如果前台没有传采购单id，则说明，我们后台需要自己创建一个采购单，如果传了采购单id则就正常修改状态即可
注意：系统人员他不会一个一个点击采购项，他会点击全选然后提交，这里就有一个问题，这里的采购项不止有新建，已分配还有已完成等等等，所有我们在后台要过滤新建和已分配的采购项

接口： /ware/purchase/merge

Vo实体类
@Data
public class MergeVo {
    private Long purchaseId;//采购单id
    private List<Long> items;//采购需求id
}

controller层
合并采购需求，post请求  /ware/purchase/merge
@PostMapping(value = "/merge")
public R merge(@RequestBody MergeVo mergeVo) {
    purchaseService.mergePurchase(mergeVo);
    return R.ok();
}

service层  注意我们这里需要添加事务：因为有添加操作
//合并采购项
@Transactional(rollbackFor = Exception.class)
@Override
public void mergePurchase(MergeVo mergeVo) {
   1. 首先判断该采购单是否存在，如果不存在就新增采购单，状态未新建状态，并提取采购单id(因为后面采购项中有使用)，

    Long purchaseId = mergeVo.getPurchaseId();
    if(purchaseId==null){
        PurchaseEntity purchaseEntity = new PurchaseEntity();
        //新建采购单的状态为‘新建’
        purchaseEntity.setStatus(WareConstant.PurchaseStatusEnum.CREATED.getCode());
        purchaseEntity.setCreateTime(new Date());
        purchaseEntity.setUpdateTime(new Date());
        this.save(purchaseEntity);
        purchaseId=purchaseEntity.getId();
    }
    
    2.过滤采购项未新建和已分配数据
    
    List<Long> items = mergeVo.getItems();
    //采购需求只有是0或1才可以分配
    Collection<PurchaseDetailEntity> purchaseDetailEntities = purchaseDetailService.listByIds(items);
    purchaseDetailEntities.forEach((item) -> {
        if (!item.getStatus().equals(WareConstant.PurchaseDetailStatusEnum.CREATED.getCode())
                && !item.getStatus().equals(WareConstant.PurchaseDetailStatusEnum.ASSIGNED.getCode())) {
            throw new IllegalArgumentException("正在采购，无法进行分配");
        }
    });

    3.遍历采购项,并将采购需求设置为已分配
    
    Long finalPurchaseId = purchaseId;//为什么不可以直接给purchaseId放入PurchaseDetailEntity表中
    List<PurchaseDetailEntity> collect = items.stream().map((i) -> {
        PurchaseDetailEntity entity = new PurchaseDetailEntity();
        entity.setId(i);
        entity.setPurchaseId(finalPurchaseId);
        entity.setStatus(WareConstant.PurchaseDetailStatusEnum.ASSIGNED.getCode());
        return entity;
    }).collect(Collectors.toList());

    purchaseDetailService.updateBatchById(collect);

    4.更新时间PurchaseEntity表中数据修改时间
    
    PurchaseEntity purchaseEntity = new PurchaseEntity();
    purchaseEntity.setId(purchaseId);
    purchaseEntity.setUpdateTime(new Date());
    this.updateById(purchaseEntity);

}

领取采购单

我们后台需要将采购单和采购需求的状态变为 ’ 已分配 ‘。
注意：工作人员不会一个一个点击采购单，他会点击全选，然后领取采购单，所以我们要过滤状态为新建和已分配的数据

接口：  /ware/purchase/received

controller
领取采购单  post请求   /ware/purchase/merge
@PostMapping(value = "/received")
    public R received(@RequestBody List<Long> ids) {
        purchaseService.received(ids);

        return R.ok();
    }

service层 
@Override
public void received(List<Long> ids) {
    //前台传的状态可能有多种，已领取，已完成啊...所有我们要根据传过来的id过滤出新建和已分配
    1.遍历采购单id，选出状态为新建和已分配的采购单
    List<PurchaseEntity> collect = ids.stream().map((id) -> {
        PurchaseEntity byId = this.getById(id);
        return byId;
    }).filter((item) -> {
        if (item.getStatus() == WareConstant.PurchaseStatusEnum.CREATED.getCode() ||
                item.getStatus() == WareConstant.PurchaseStatusEnum.ASSIGNED.getCode()) {
            return true;//收集该数据
        }
        return false;//拦截该数据
    }).map((item) -> {
        item.setStatus(WareConstant.PurchaseStatusEnum.RECEIVE.getCode());
        item.setUpdateTime(new Date());
        return item;
    }).collect(Collectors.toList());


    this.updateBatchById(collect);

    2.改变采购项的状态
    collect.forEach((item) -> {
        List<PurchaseDetailEntity> list = purchaseDetailService.listDetailByPurchaseId(item.getId());
        List<PurchaseDetailEntity> detailEntities = list.stream().map(entity -> {

            PurchaseDetailEntity purchaseDetailEntity = new PurchaseDetailEntity();
            purchaseDetailEntity.setId(entity.getId());
            purchaseDetailEntity.setStatus(WareConstant.PurchaseDetailStatusEnum.BUYING.getCode());
            return purchaseDetailEntity;
        }).collect(Collectors.toList());
        purchaseDetailService.updateBatchById(detailEntities);
    });

}

完成采购单

我们不仅需要修改采购单和采购项的状态，还需要将已购买的商品存入库存
在这里不将异常(这里的异常：购买的商品不足，或者购买的商品数据为0)状态的采购项商品存入库存，如果你硬是将有异常(够买了商品，但没有到达指定购买数量)状态的数据存入库存中:解决：1、给数据库添加字段(已购买，reson)，然后我们根据已购买的数据更新库存商品，解决步骤：前端参数(采购单id，{采购项：id，status，num，reson})，遍历前端传来采购项数据(采购项状态为已完成的，则正常修改采购单和采购项的状态，如果采购项状态异常，1、得到采购项购买商品数量，并将已购买字段数据更新，然后将库存更新）

接口：  ware/purchase/done

Vo实体类
@Data
public class PurchaseDoneVo {
    @NotNull(message = "id不允许为空")
    private Long id;//采购单id
    private List<PurchaseItemDoneVo> items;//完成/失败的需求详情
}

@Data
public class PurchaseItemDoneVo {
    private Long itemId;//采购项id

    private Integer status;

    private String reason;
}

controller层
完成采购单  post请求
@PostMapping("/done")
public R finish(@RequestBody PurchaseDoneVo doneVo) {
     System.out.println("提交采购单");
     purchaseService.done(doneVo);

     return R.ok();
 }

service层
@Transactional
@Override
public void done(PurchaseDoneVo doneVo) {
    
    1.修改采购项状态,更新库存
    boolean flag=true;
    List<PurchaseItemDoneVo> items = doneVo.getItems();
    ArrayList<PurchaseDetailEntity> objects = new ArrayList<>();
    for (PurchaseItemDoneVo item : items) {
        PurchaseDetailEntity purchaseDetailEntity = new PurchaseDetailEntity();
        //设置状态
        if(item.getStatus()==WareConstant.PurchaseDetailStatusEnum.HASERROR.getCode()){
            //采购失败
            flag=false;
            purchaseDetailEntity.setStatus(item.getStatus());
        }else {
            purchaseDetailEntity.setStatus(WareConstant.PurchaseDetailStatusEnum.FINISH.getCode());
            //修改库存：在这里修改是因为，反正已经得到了对象，那就直接修改库存数据
            PurchaseDetailEntity entity = purchaseDetailService.getById(item.getItemId());
            //修改数据：要判断数据库中是否存在数据，有就修改数据，没有就添加数据
            wareSkuService.addStock(entity.getSkuId(),entity.getWareId(),entity.getSkuNum());
        }
        //设置采购项id
        purchaseDetailEntity.setId(item.getItemId());
        objects.add(purchaseDetailEntity);
    }
    purchaseDetailService.updateBatchById(objects);

    2.修改采购单状态
    PurchaseEntity purchaseEntity = new PurchaseEntity();
    purchaseEntity.setId(doneVo.getId());
    purchaseEntity.setStatus(flag?WareConstant.PurchaseStatusEnum.FINISH.getCode():WareConstant.PurchaseStatusEnum.HASERROR.getCode());
    purchaseEntity.setUpdateTime(new Date());
    this.updateById(purchaseEntity);
}

spu商品修改规格

会发生404错误，解决给数据库(gulimall_admin)添加一个数据

INSERT INTO sys_menu ( menu_id, parent_id, NAME, url, perms, type, icon, order_num )
VALUES
	( 76, 37, '规格维护', 'product/attrupdate', NULL, 2, 'log', 0 );

然后就是正常的增删改查了

接口    /product/attr/base/listforspu/{spuId}

获取spu规格
controller
//获取spu规格
@GetMapping("/base/listforspu/{spuId}")
public R baseAttrlistforspu(@PathVariable("spuId") Long spuId){
    System.out.println("获取spu规格数据");
    List<ProductAttrValueEntity> entities = productAttrValueService.baseAttrListforspu(spuId);

    return R.ok().put("data",entities);
}

service层
获取ProductAttrValueEntity
@Override
public List<ProductAttrValueEntity> baseAttrListforspu(Long spuId) {
    List<ProductAttrValueEntity> entities = this.baseMapper.selectList(new QueryWrapper<ProductAttrValueEntity>()
            .eq("spu_id", spuId));
    return entities;
}

修改spu

接口  /product/attr/update/{spuId}

controller层
Vo 实体类//修改spu规格
@PostMapping("/update/{spuId}")
public R updateSpuAttr(@PathVariable("spuId") Long spuId,
                       @RequestBody List<ProductAttrValueEntity> entities){
    productAttrValueService.updateSpuAttr(spuId,entities);
    return R.ok();
}

service层
注意：将之前存入的数据全部删除，再插入新数据即可
@Override
public void updateSpuAttr(Long spuId, List<ProductAttrValueEntity> entities) {
    this.baseMapper.delete(new QueryWrapper<ProductAttrValueEntity>()
            .eq("spu_id",spuId));
    //2、添加商品规格信息
    List<ProductAttrValueEntity> collect = entities.stream().map(item -> {
        item.setSpuId(spuId);
        return item;
    }).collect(Collectors.toList());

    //批量新增
    this.saveBatch(collect);
}

原文链接：https://blog.csdn.net/m0_50574545/article/details/121563888