（云苍穹）树的构建

package zb.pc.formplugin.pcctm.basedata.ingredientslist;

import kd.bos.bill.BillShowParameter;
import kd.bos.bill.OperationStatus;
import kd.bos.context.RequestContext;
import kd.bos.dataentity.entity.DynamicObject;
import kd.bos.dataentity.metadata.IDataEntityProperty;
import kd.bos.dataentity.resource.ResManager;
import kd.bos.dataentity.utils.ObjectUtils;
import kd.bos.dataentity.utils.StringUtils;
import kd.bos.entity.BasedataEntityType;
import kd.bos.entity.EntityMetadataCache;
import kd.bos.entity.datamodel.ITreeModel;
import kd.bos.entity.property.GroupProp;
import kd.bos.entity.property.ParentBasedataProp;
import kd.bos.entity.tree.TreeNode;
import kd.bos.exception.KDBizException;
import kd.bos.form.*;
import kd.bos.form.control.Control;
import kd.bos.form.control.TreeView;
import kd.bos.form.control.events.RefreshNodeEvent;
import kd.bos.form.control.events.TreeNodeEvent;
import kd.bos.form.control.events.TreeNodeQueryListener;
import kd.bos.form.events.ClosedCallBackEvent;
import kd.bos.form.events.MessageBoxClosedEvent;
import kd.bos.form.events.SetFilterEvent;
import kd.bos.list.BillList;
import kd.bos.list.plugin.StandardTreeListPlugin;
import kd.bos.logging.Log;
import kd.bos.logging.LogFactory;
import kd.bos.orm.query.QCP;
import kd.bos.orm.query.QFilter;
import kd.bos.servicehelper.BusinessDataServiceHelper;
import kd.bos.servicehelper.operation.DeleteServiceHelper;
import org.springframework.util.CollectionUtils;
import zb.common.constant.BaseConstant;
import zb.common.constant.ManageOrgConstant;
import zb.pc.common.constant.pcctm.basedata.ingredientslist.IngredientsListConstant;
import zb.pc.common.constant.pcctm.basedata.ingredientstype.IngredientsTypeConstant;

import java.util.*;

import static zb.pc.common.constant.pceetm.PigletWearTagConstant.ZB_PIGEARTAG_ADD;

/**
 * @Module : 公共业务云--食堂管理模块--食材清单
 * @Description : 食材清单类别列表数结构插件
 * @Date : 2021-05-05
 * @Author : xxx
 * @Version : 1.0
 **/
public class IngredientsTreePlugin extends StandardTreeListPlugin implements TreeNodeQueryListener {
    private static Log log = LogFactory.getLog(IngredientsTreePlugin.class);
    private static final String KEY_TREEVIEW = "treeview";
    private static final String KEY_PARENT = "parent";
    private static final String KEY_ORGUNIT = "zb_orgunit";
    private static final String KEY_STOCKORG = "zb_stockorg";
    private static final String KEY_LONGNUMBER = "longnumber";
    private static final String KEY_ISLEAF = "isleaf";
    private static final String KEY_ISPARENT = "isParent";
    private static final String KEY_ROOT_PARENT_ID = "0";
    private static final String KEY_ROOT_TEXT = "全部";
    private static final String KEY_FLEXPANEL_TREEBTN = "flexpanel_treebtn";
    private static final String KEY_ISCONTAINNOW = "iscontainnow";
    private static final String KEY_ISCONTAINLOWER = "iscontainlower";
    private static final String STR_EMPTY = "";
    private static final String SPLIT_POINT = "[.]";
    private static final String STATUS_AUDITED = "C"; //已审核状态
    private static final String WIDTH = "800";
    private static final String HEIGHT = "500";

    @Override
    public void registerListener(EventObject e) {
        super.registerListener(e);
        TreeView treeView = this.getView().getControl(KEY_TREEVIEW);
        if (treeView != null) {
            //侦听树节点懒加载事件
            treeView.addTreeNodeQueryListener(this);
        }
    }


    @Override
    public void queryTreeNodeChildren(TreeNodeEvent treeNodeEvent) {
        //根据父级ID查询子节点数据
        List<TreeNode> childNodes = loadChildNode((String) treeNodeEvent.getNodeId());
        TreeView treeView = this.getView().getControl(KEY_TREEVIEW);
        treeView.addNodes(childNodes);
    }

    @Override
    public void afterCreateNewData(EventObject e) {
        super.afterCreateNewData(e);
        //初始化树形控件
        initTreeView();
        //隐藏控件
        //hideControl();
    }

    /**
     * 初始化树形控件
     */
    private void initTreeView() {
        //初始化树形控件的属性与第一层节点
        TreeView treeView = this.getView().getControl(KEY_TREEVIEW);
        if (treeView == null) {
            return;
        }
        //清空所有节点
        treeView.deleteAllNodes();
        //根节点
        TreeNode root = new TreeNode(STR_EMPTY, KEY_ROOT_PARENT_ID, KEY_ROOT_TEXT);
        //添加到控件中
        treeView.addNode(root);
        //查询根节点
        List<TreeNode> childNodes = loadChildNode(root.getId());
        if (CollectionUtils.isEmpty(childNodes)) {
            return;
        }
        //将根节点数据添加到控件中
        treeView.addNodes(childNodes);
        treeView.focusNode(childNodes.get(0));
        root.setIsOpened(true);
        //初始化当前用户的子节点
        initChildNode(childNodes, treeView);
    }

    /**
     * 根据父节点ID查询子节点数据
     *
     * @param parentId 父节点ID
     */
    private List<TreeNode> loadChildNode(String parentId) {
        //根据父节点ID查询子节点数据
        DynamicObject[] objects = queryIngredients(parentId);
        List<TreeNode> childNodes = new ArrayList<>();
        if (!ObjectUtils.isEmpty(objects) && objects.length > 0) {
            for (int i = 0; i < objects.length; i++) {
                DynamicObject object = objects[i];
                TreeNode treeNode = new TreeNode(parentId, object.getPkValue().toString(),
                        object.getLocaleString(BaseConstant.NAME).getLocaleValue());
                treeNode.setLongNumber(object.getString(KEY_LONGNUMBER));
                //叶子处理
                Object isLeaf = object.get(KEY_ISLEAF);
                if (isLeaf != null && !(Boolean) isLeaf) {
                    treeNode.setChildren(new ArrayList());
                }
                childNodes.add(treeNode);
            }
        }
        return childNodes;
    }

    /**
     * 根据过滤器查询食材清单类别数据
     *
     * @param parentId 父级ID
     * @return DynamicObject[]
     */
    private DynamicObject[] queryIngredients(String parentId) {
        QFilter statusFilter = new QFilter(BaseConstant.STATUS, QCP.equals, STATUS_AUDITED);
        QFilter enableFilter = new QFilter(BaseConstant.ENABLE, QCP.equals, Boolean.TRUE);
        QFilter filter = new QFilter(KEY_PARENT, QCP.equals, parentId);
        QFilter[] qFilters = new QFilter[]{statusFilter, enableFilter, filter};
        String orderBy = "createtime asc";
        String fields = "id, number, name, longnumber, level, fullname, isleaf, parent";
        DynamicObject[] objects = BusinessDataServiceHelper.load(IngredientsTypeConstant.FORMBILLID, fields, qFilters, orderBy);
        return objects;
    }


    /**
     * 初始化子节点
     */
    private void initChildNode(List<TreeNode> childNodes, TreeView treeView) {
        List<TreeNode> tempNodes = childNodes;
        for (int j = 0; j < tempNodes.size(); j++) {
            //找到对应的食材目录的父级，就继续往下找
            List<TreeNode> listNodes = loadChildNode(tempNodes.get(j).getId());
            if (listNodes.size() > 0 && !CollectionUtils.isEmpty(listNodes)) {
                tempNodes.get(j).setIsOpened(true);
                treeView.addNodes(listNodes);
                tempNodes = listNodes;
                break;
            }
        }
    }

    private void hideControl() {
        //隐藏树形列表默认的搜索框和包含下级这些按钮
        String[] hideBtn = new String[]{KEY_FLEXPANEL_TREEBTN, KEY_ISCONTAINNOW, KEY_ISCONTAINLOWER};
        this.getView().setVisible(Boolean.FALSE, hideBtn);
    }

    @Override
    public void setFilter(SetFilterEvent e) {
        TreeView treeView = this.getView().getControl(KEY_TREEVIEW);
        //如果非树型结构页面，不设置过滤条件
        if (treeView == null) {
            super.setFilter(e);
            return;
        }
        //根据光标选中的节点获取对应的食材清单类别id
        String focusNodeId = treeView.getTreeState().getFocusNodeId();
        if (StringUtils.isNotBlank(focusNodeId)) {
            DynamicObject object = BusinessDataServiceHelper.loadSingle(focusNodeId, IngredientsTypeConstant.FORMBILLID);
            String typeId = object.getPkValue().toString();
            QFilter qfilter = new QFilter(IngredientsListConstant.ZB_UPTYPE, QCP.equals, typeId);
            List<QFilter> filters = e.getQFilters();
            filters.add(qfilter);
        }
        super.setFilter(e);
    }

    /**i
     * 树节点工具栏功能实现
     *
     * @param e
     */
    public void treeToolbarClick(EventObject e) {
        ITreeModel treeModel = this.getTreeModel();
        Control ctl = (Control) e.getSource();
        GroupProp prop = this.getTreeModel().getGroupProp();
        String currentNodeId = (String)treeModel.getCurrentNodeId();
        TreeView treeView = this.getView().getControl(KEY_TREEVIEW);
        if (ctl.getKey().equals("btnnew")) {
            //跳转到食材清单类别界面新增
            this.addTreeNode(currentNodeId);

        } else if (ctl.getKey().equals("btnedit")) {
            //修改树节点 （跳转到食材清单类别修改界面）
            editTreeNode(currentNodeId);

        } else if (ctl.getKey().equals("btndel")) {
            //删除树节点
            deleteTreeNode(currentNodeId);

        }

        //重新加载节点信息
//        TreeNode currentNode = this.getTreeModel().getRoot().getTreeNode(currentNodeId, 10);
//        List<TreeNode> childNodes = loadChildNode(currentNode.getId());
//        initChildNode(childNodes, treeView);
        }

    /**
     * 新增树节点
     * @param currentNodeId
     *
     */
    private void addTreeNode(String currentNodeId) {
        String entityId = IngredientsTypeConstant.FORMBILLID;
        BillShowParameter formShowParameter = new BillShowParameter();
        StyleCss css = new StyleCss();
        css.setWidth(WIDTH);
        css.setHeight(HEIGHT);
        formShowParameter.getOpenStyle().setInlineStyleCss(css);

        formShowParameter.setFormId(entityId);
        formShowParameter.getOpenStyle().setShowType(ShowType.Modal);
        CloseCallBack callBack = new CloseCallBack(this, "addTreeNode");
        formShowParameter.setCloseCallBack(callBack);
        formShowParameter.setCustomParam("id", currentNodeId);
        formShowParameter.setCustomParam("operate", "addnew");
        if (!currentNodeId.equals(this.getTreeModel().getRoot().getId())) {
            BasedataEntityType basedataEntityType = (BasedataEntityType) EntityMetadataCache.getDataEntityType(entityId);
            if (basedataEntityType != null) {
                Map<String, Object> parentInfo = new HashMap();
                Iterator var7 = basedataEntityType.getProperties().iterator();

                while(var7.hasNext()) {
                    IDataEntityProperty pro = (IDataEntityProperty)var7.next();
                    if (pro instanceof ParentBasedataProp) {
                        parentInfo.put("key", pro.getName());
                        parentInfo.put("value", currentNodeId);
                        formShowParameter.setCustomParam("tree_parent_id", parentInfo);
                        break;
                    }
                }
            }
        }
        this.getView().showForm(formShowParameter);
    }

    /**
     * 修改节树点
     * @param currentNodeId
     */
    private void editTreeNode(String currentNodeId) {
        BillShowParameter formShowParameter = new BillShowParameter();
        StyleCss css = new StyleCss();
        css.setWidth(WIDTH);
        css.setHeight(HEIGHT);
        formShowParameter.getOpenStyle().setInlineStyleCss(css);

        formShowParameter.setFormId(IngredientsTypeConstant.FORMBILLID);
        formShowParameter.getOpenStyle().setShowType(ShowType.Modal);
        formShowParameter.setPkId(this.getTreeModel().getCurrentNodeId());
        formShowParameter.setStatus(OperationStatus.EDIT);
        CloseCallBack callBack = new CloseCallBack(this, "editTreeNode");
        formShowParameter.setCloseCallBack(callBack);
        formShowParameter.setCustomParam("operate", "edit");
        Map<String, Object> parentInfo = new HashMap();
        parentInfo.put("value", currentNodeId);
        formShowParameter.setCustomParam("tree_curr_id", parentInfo);

        this.getView().showForm(formShowParameter);
    }

    /**
     * 删除树节点
     * @param currentNodeId
     */
    private void deleteTreeNode(String currentNodeId) {
        TreeNode currentNode = this.getTreeModel().getRoot().getTreeNode(currentNodeId, 10);
        //String text = currentNode.getText();
        ConfirmCallBackListener confirmCallBacks = new ConfirmCallBackListener("deleteTreeNode", this);
        this.getView().showConfirm("您确认删除食材清单类别", MessageBoxOptions.YesNo, confirmCallBacks);
        QFilter qfilter = new QFilter(IngredientsTypeConstant.ID, QCP.equals, currentNodeId);
        DeleteServiceHelper.delete(IngredientsTypeConstant.FORMBILLID, qfilter.toArray());
    }

    /**
     * 子界面关闭时，会触发父界面的closedCallBack事件
     * @param e
     */
    @Override
    public void closedCallBack(ClosedCallBackEvent e) {
        String key = e.getActionId();
        if (StringUtils.equals("addTreeNode", key) || StringUtils.equals("editTreeNode", key)){
            String refreshNodeId = this.getTreeModel().getRoot().getId();
            this.treeListView.getTreeModel().refreshNode(refreshNodeId);
        }
    }

    /**
     * 刷新树节点
     * @param e
     */
    @Override
    public void refreshNode(RefreshNodeEvent e) {
        initTreeView();
    }

    /**
     * 用户确认了交互提示信息后，触发此事件
     * @param event
     */
    @Override
    public void confirmCallBack(MessageBoxClosedEvent event) {
        super.confirmCallBack(event);
        String key = event.getCallBackId();
        if (StringUtils.equals("deleteTreeNode", key) && event.getResult() == MessageBoxResult.Yes){
            String refreshNodeId = this.getTreeModel().getRoot().getId();
            this.treeListView.getTreeModel().refreshNode(refreshNodeId);
        }
    }
}