aldehyde 0.2.74 → 0.2.76

package/src/aldehyde/tree/tree-node.tsx

@@ -0,0 +1,78 @@
+import React from 'react'
+import {Avatar, Card, Col, message, Row, Space,Badge} from 'antd'
+import {} from '@ant-design/icons'
+import {TreeDataNode} from "./tree-utils";
+import {OrderableTmplBase} from "../tmpl/interface";
+export interface TreeNodeProps {
+   currentActiveKey?:(string|number)[],
+    nodeData: TreeDataNode,
+}
+
+interface TreeNodeState {
+    sorts: Array<OrderableTmplBase>,
+}
+
+const treeCardTitleBody0 = {
+    padding: '4px 4px 4px 4px',
+    maxWidth: '300px',
+}
+
+
+const buttonIcon={color:'#597ef7'}
+
+class TreeNode extends React.PureComponent<TreeNodeProps, TreeNodeState> {
+    state = {
+        sorts: [],
+    }
+
+    async componentDidMount() {
+
+    }
+
+    async componentDidUpdate(preProps) {
+
+    }
+
+    async componentWillUnmount() {
+
+    }
+
+    onDelete = async (nodeData:TreeDataNode) => {
+
+    }
+
+    render() {
+        const {nodeData,currentActiveKey} = this.props;
+        const {sorts} = this.state;
+        let backgroundColor = '#fff';
+         let avatarBackgroundColor = '#fff';
+        let bodyCss = treeCardTitleBody0;
+        if (nodeData.level == 0) {
+            avatarBackgroundColor = '#fff';
+            bodyCss = treeCardTitleBody0;
+        }
+
+
+
+
+        return <Card bordered={nodeData.level==2?false:false} bodyStyle={bodyCss} style={{marginBottom:2,backgroundColor}} className={'tree-node'}>
+            <Row>
+                <Col span={24}>
+                    <Space>
+                        {nodeData.avatar ? nodeData.avatar : <Avatar shape="square" size={10} style={{
+                            backgroundColor: avatarBackgroundColor,
+                            height: 24,
+                            width: 10
+                        }}></Avatar>}{nodeData.title}{
+                        currentActiveKey && currentActiveKey.indexOf(nodeData.key) >= 0 ?<Badge key={"red"} color={'red'}  />:null
+                    }
+                    </Space>
+                </Col>
+            </Row>
+
+         </Card>
+    }
+
+}
+
+export default TreeNode

package/src/aldehyde/tree/tree-utils.tsx

@@ -0,0 +1,166 @@
+import React from "react";
+import {DataNode} from "antd/es/tree";
+import {HydrocarbonService} from "../index";
+import {DtmplData, LtmplConfig, LtmplConfigRes, TtmplConfig} from "../tmpl/interface";
+import HCDataSource from "../tmpl/hc-data-source";
+
+export interface TtmplNodeConfig extends TtmplConfig{
+    leafTitleId?:string,
+    branchTitleId?:string,
+    rootTitleId?:string,
+    rootLTmplConfig?:LtmplConfig,
+    branchLTmplConfig?:LtmplConfig,
+    leafLTmplConfig?:LtmplConfig,
+
+}
+
+export interface TreeDataNode extends DataNode{
+    parent:TreeDataNode,
+    code:string,
+    name:string,
+    avatar:any,
+    level:number,
+    children:any,
+}
+
+export default class TreeUtils {
+
+    static initTtmplNodeConfig = async (config: TtmplConfig) => {
+
+        if(!config){
+            return null;
+        }
+        let ttmplNodeConfig:TtmplNodeConfig={...config}
+        if(ttmplNodeConfig.rootGtmplId){
+            let res:LtmplConfigRes =await HCDataSource.requestLtmplConfig(null,ttmplNodeConfig.rootGtmplId);
+            let rootLTmplConfig: LtmplConfig=res.ltmplConfig;
+            ttmplNodeConfig.rootLTmplConfig=rootLTmplConfig;
+            ttmplNodeConfig.rootTitleId=rootLTmplConfig.primaryColumn.id;
+        }
+        if(ttmplNodeConfig.branchRatmplId){
+            let res:LtmplConfigRes =await HCDataSource.requestLtmplConfig(null,ttmplNodeConfig.branchRatmplId);
+            let branchLTmplConfig: LtmplConfig=res.ltmplConfig;
+            ttmplNodeConfig.branchLTmplConfig=branchLTmplConfig;
+            ttmplNodeConfig.branchTitleId=branchLTmplConfig.primaryColumn.id;
+        }
+        if(ttmplNodeConfig.leafRatmplId){
+            let res:LtmplConfigRes =await HCDataSource.requestLtmplConfig(null,ttmplNodeConfig.leafRatmplId);
+            let leafLTmplConfig: LtmplConfig =res.ltmplConfig;
+            ttmplNodeConfig.leafLTmplConfig=leafLTmplConfig;
+            ttmplNodeConfig.leafTitleId=leafLTmplConfig.primaryColumn.id;
+        }
+
+        return ttmplNodeConfig;
+    }
+
+    static loadRootNodeData = async (config: TtmplNodeConfig) => {
+        let res = await HydrocarbonService.requestTtmplRootData(null, config.id, {});
+        let data = [];
+        //组织data
+        if (res.entities) {
+            res.entities.forEach((item, index) => {
+                data.push(this.toTreeNodeData(item,config.rootTitleId,null,false));
+            })
+        }
+        return data;
+    }
+
+    static pushNodeData =  (parentNode: TreeDataNode, config: TtmplNodeConfig,brancEntities:any[],leafEntities:any[]) => {
+        //先查询branch
+        parentNode.children.splice(0,parentNode.children.length);
+        if (brancEntities) {
+            brancEntities.forEach((item, index) => {
+                parentNode.children.push(this.toBanchTreeNodeData(item, config, parentNode));
+            })
+        }
+        //debugger
+        //再查询leaf
+        if (leafEntities) {
+            leafEntities.forEach((item, index) => {
+                parentNode.children.push(this.toLeafTreeNodeData(item, config, parentNode));
+            })
+        }
+
+    }
+
+    static pushSameCodeNodeData = async (parentNodes: TreeDataNode[], config: TtmplNodeConfig) => {
+        if (parentNodes.length > 0) {
+            //先查询branch
+            let brancEntities: any[];
+            if(config.branchRatmplId){
+                let res = await HydrocarbonService.requestLtmplQueryTop(null, config.branchRatmplId, {mainCode: parentNodes[0].code});
+                 brancEntities = res.entities;
+            }
+
+            let res1 = await HydrocarbonService.requestLtmplQueryTop(null, config.leafRatmplId, {mainCode: parentNodes[0].code});
+            let leafEntities: any[] = res1.entities;
+            for(let parentNode of parentNodes){
+                this.pushNodeData(parentNode, config,brancEntities,leafEntities);
+            }
+        }
+    }
+
+
+    static toLeafTreeNodeData = (item: DtmplData,config:TtmplNodeConfig, parent: TreeDataNode) => {
+        let d=  this.toTreeNodeData(item,config.leafTitleId,parent,true);
+        return d;
+    }
+
+    static toBanchTreeNodeData = (item: DtmplData,config:TtmplNodeConfig, parent: TreeDataNode) => {
+      let d=  this.toTreeNodeData(item,config.branchTitleId,parent,false);
+        return d;
+    }
+
+    static toTreeNodeData = (item: DtmplData,titleId:string, parent: TreeDataNode,isLeaf:boolean) => {
+        let name = item.fieldMap[titleId];
+        let d = {
+            code: item.code,
+            key: parent?.code+item.code,
+            name,
+            title: <><span>{name?name:item.code}</span></>,
+            children: [],
+            isLeaf,
+            parent,
+        };
+
+        return d;
+    }
+
+    static filterNode = (node, searchValue: string) => {
+        let children = [...node.children];
+        let newNodes: TreeDataNode[] = [];
+        let tagNodes: TreeDataNode[] = [];
+
+        children.forEach((no) => {
+            let n = {...no};
+            let  v=n.searchValue?n.searchValue:n.name;
+            if (v.indexOf(searchValue) >= 0) {
+                newNodes.push(n);
+            }
+            if (n.children && n.children.length > 0) {
+                let retNodes: TreeDataNode[] = this.filterNode(n, searchValue);
+                if (retNodes.length > 0) {
+                    n.children = retNodes;
+                    //补充父没有的
+                    if ((n.searchValue?n.searchValue:n.name).indexOf(searchValue) < 0) {
+                        newNodes.push(n);
+                    }
+                } else {
+                    // 没有子节点情况
+                    n.children = [];
+                    // 标记,循环结束后删除
+                    tagNodes.push(n);
+                }
+            }
+        })
+        node.children = newNodes;
+        return newNodes;
+    }
+
+    static filterTree = (nodes: any[], searchValue: string) => {
+        let root = {code: "", config: undefined, key: undefined, children: [...nodes]};
+        this.filterNode(root, searchValue);
+        return root.children;
+    }
+
+}