Agile PLM_统计物料消耗

Agile PLM_统计物料消耗

需求：统计PLM的物件下，所有子bom的物件消耗数量，方便核算成本

要求：

1. 搜索物件编号，查询出该物件下所有的子物件（所有下级）

2. 只带出主料，不需要替代料

3. 计算每一层级的用量（计算方式：每阶的数量乘积）

   // 举例
   A(一级母件) 1
   |---B(二级) 2
       ---C(三级) 2
   |---D(二级) 3
       ---C(三级) 1
       
   // 计算方式
   A(用量)：1
   B(用量)：1 * 2
   D(用量)：1 * 3
   C(用量)：1 * 2 * 2 + 1 * 3 * 1  

4. 相同物件（物料）汇总（相同的物料用量相加）

 

做出的效果

 

思路：

1. BOM表，递归查询一个物料的所有BOM

2. 递归（设置消耗量）

3. 相同物料汇总

 

实现：

1、BOM表（ 查询一个物料的所有BOM的SQL ）

使用到的表：bom（ BOM表 ）；ITEM（ 物件表 ）；LISTENTRY（ 列表表（数据字典））；ITEM_QUERY（ 物件查询视图 ）；LANGTABLE（ 文本表 ）；

SELECT
            b.*,
            ic.DESCRIPTION,
            l.value as sub_class_text,
            ls.value as life_cycle,
            ic.rev_number
        FROM
        (
            SELECT b.*,nvl(l3.ENTRYVALUE, '主') rep FROM
                (
                    SELECT
                        ITEM AS parent_id,
                        COMPONENT AS ID,
                        ITEM_NUMBER,
                        FIND_NUMBER,
                        to_number(QUANTITY) QUANTITY,
                        CHANGE_OUT,
                        FLAGS,
                        LIST03
                    FROM
                        bom START WITH ITEM = (SELECT ID FROM ITEM WHERE ITEM_NUMBER = '200002000001')
                        AND NVL (CHANGE_OUT, 0) = 0 AND SUBSTR (FLAGS, 5, 1) = 1
                        CONNECT BY PRIOR COMPONENT = ITEM
                        AND NVL (CHANGE_OUT, 0) = 0 AND SUBSTR (FLAGS, 5, 1) = 1
                ) b
            LEFT JOIN LISTENTRY l3 on b.LIST03 = l3.ENTRYID and L3.LANGID = 4
        ) b
        LEFT JOIN item ip on b.parent_id = ip.id
        LEFT JOIN ITEM_QUERY ic on b.id = ic.id
        INNER JOIN LANGTABLE l on ic.SUBCLASS = l.id and type = 4450 and l.langid = 4
        INNER JOIN LANGTABLE ls on ic.RELEASE_TYPE = ls.id and ls.type = 4450 and ls.langid = 4
        WHERE b.REP NOT LIKE '替%'

结果

 

2、递归（设置消耗量）

    // 根据树形结构 设置物料消耗量
    private static List<Material> getTree(List<Material> materials, String itemNumber, String pid) {
        Map<String, List<Material>> collects = materials.stream().filter(a -> a.getPid() != pid)
                .collect(Collectors.groupingBy(a -> a.getPid()));
        materials.forEach(d -> d.setChildren(collects.get(d.getId())));
        Material material = materials.stream().filter(p -> p.getItemNumber().equals(itemNumber)).findAny().orElse(null);
        if (material.getChildren() != null) {
            material.setResult(1); // 设置根母件消耗单位为1个
            setExpend(material, material.getChildren());
        }
        materials.remove(material);
        return materials;
    }

    // 递归(设置消耗量)
    private static void setExpend(Material father, List<Material> children) {
        List<Material> materialList = new ArrayList<>();
        for (Material material : children) {
            material.setResult(father.getResult() * material.getQty());
            if (material.getChildren() != null) {
                setExpend(material, material.getChildren());
            }
            materialList.add(material);
        }
    }

3、相同物料用量汇总

// 相同物料汇总
List<Material> collect = tree.stream().collect(Collectors.toMap(Material::getItemNumber, a -> a, (o1, o2) -> {
    o1.setResult(o1.getResult() + o2.getResult());
    return o1;
})).values().stream().collect(Collectors.toList());

最后把结果collect传到前端，进行数据渲染。