app-service/dcuc-app-service/src/main/java/com/dragoninfo/dcuc/app/facade/DataResourceFacade.java

package com.dragoninfo.dcuc.app.facade;

import com.dragoninfo.dcuc.app.dto.dataresource.ChildResourceClassify;
import com.dragoninfo.dcuc.app.dto.dataresource.ResourceClassify;
import com.dragoninfo.dcuc.app.enumresources.DataResourceEnum;
import com.dragoninfo.dcuc.app.service.IDataResourceService;
import com.dragoninfo.dcuc.app.vo.*;
import com.dragonsoft.duceap.commons.util.UUIDUtils;
import com.dragonsoft.duceap.commons.util.enums.EnumUtils;
import com.google.common.base.Joiner;
import com.google.common.collect.Lists;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

/**
 * Created by lidr on 2021/4/14
 */
@RestController
@RequestMapping(value = "/dcuc/app/dataResourceFacade")
public class DataResourceFacade implements IDataResourceFacade {

    public static final String ID_SEPARATOR = "|";
    /**
     * codeDataTypeStr分隔符
     */
    public static final String CODE_DATA_TYPE_SEPARATOR = "★";

    @Autowired
    private IDataResourceService dataResourceService;

    @Override
    public List<DataResourceClassifyVo> getAllDataResourceTree(@RequestParam("attrType") String attrType) {
        List<DataResourceClassifyVo> result = Lists.newArrayList();

        //列：数据安全级别  字段分类
        //表：数据分级  数据资源分类
        if ("TABLE".equals(attrType)) {
            result.add(getDataLevelTree());
            result.add(getDataClassifyTree());
        } else {
            result.add(getSecurityLevelTree());
            result.add(getFieldClassifyTree());
        }
        return result;
    }

    @Override
    public DataResourceClassifyVo getDataResourceTree(String typeCode) {
        DataResourceClassifyVo result = null;
        DataResourceEnum dataResourceEnum = Enum.valueOf(DataResourceEnum.class, typeCode);
        switch (dataResourceEnum){
            case DATA_CLASSIFY:
                result = getDataLevelTree();
                break;
            case COLUMN_CLASSIFY:
                result = getFieldClassifyTree();
                break;

            case DATA_SECURITY_LEVEL:
                result = getSecurityLevelTree();
                break;
            case DATA_RESOURCE_CLASSIFY:
                result = getDataClassifyTree();
                break;
                default:
                    break;
        }

        return result;
    }


    /**
     * 数据分级树
     *
     * @return
     */
    private DataResourceClassifyVo getDataLevelTree() {
        DataResourceEnum dataResourceEnum = DataResourceEnum.DATA_CLASSIFY;

        DataResourceClassifyVo dataResourceClassifyVo = DataResourceClassifyVo.builder()
                .id(dataResourceEnum.getCode())
                .attrType(dataResourceEnum.getAttrType().getValue())
                .label(dataResourceEnum.getLabel())
                .build();

        DataResourceTreeVo dataLevelTreeVo = DataResourceTreeVo.builder()
                .id(dataResourceEnum.getCode())
                .label("全部")
                .code(dataResourceEnum.getCode())
                .treeNode(true)
                .build();

        dataLevelTreeVo.setChild(getFirstChildResourceClassifies(dataResourceService.getDataLevelList())
                .stream()
                .map(childResourceClassify -> DataResourceTreeVo.builder()
                        .id(Joiner.on(ID_SEPARATOR).join(dataLevelTreeVo.getId(), childResourceClassify.getCodeValue()))
                        .code(childResourceClassify.getCodeValue())
                        .label(childResourceClassify.getCodeName())
                        .dataType(childResourceClassify.getTypeCode())
                        .codeDataTypeStr(UUIDUtils.getUUID() + CODE_DATA_TYPE_SEPARATOR + childResourceClassify.getCodeValue() + CODE_DATA_TYPE_SEPARATOR + childResourceClassify.getTypeCode())
                        .treeNode(false)
                        .pId(dataLevelTreeVo.getId()).build()
                ).collect(Collectors.toList())
        );

        dataResourceClassifyVo.setNodes(new ArrayList<DataResourceTreeVo>(){{add(dataLevelTreeVo);}});
        //设置总数量
        dataResourceClassifyVo.setTotal(dataLevelTreeVo.getChild().size());
        return dataResourceClassifyVo;
    }

    /**
     * 数据安全级别树
     *
     * @return
     */
    private DataResourceClassifyVo getSecurityLevelTree() {
        DataResourceEnum dataResourceEnum = DataResourceEnum.DATA_SECURITY_LEVEL;

        DataResourceClassifyVo dataResourceClassifyVo = DataResourceClassifyVo.builder()
                .id(dataResourceEnum.getCode())
                .attrType(dataResourceEnum.getAttrType().getValue())
                .label(dataResourceEnum.getLabel())
                .build();

        DataResourceTreeVo securityLevelTree = DataResourceTreeVo.builder()
                .id(dataResourceEnum.getCode())
                .label("全部")
                .code(dataResourceEnum.getCode())
                .treeNode(true)
                .build();

        securityLevelTree.setChild(getFirstChildResourceClassifies(dataResourceService.getSecurityLevelList())
                .stream()
                .map(childResourceClassify -> DataResourceTreeVo.builder()
                        .id(Joiner.on(ID_SEPARATOR).join(securityLevelTree.getId(), childResourceClassify.getCodeValue()))
                        .code(childResourceClassify.getCodeValue())
                        .label(childResourceClassify.getCodeName())
                        .dataType(childResourceClassify.getTypeCode())
                        .codeDataTypeStr(UUIDUtils.getUUID() + CODE_DATA_TYPE_SEPARATOR + childResourceClassify.getCodeValue() + CODE_DATA_TYPE_SEPARATOR + childResourceClassify.getTypeCode())
                        .treeNode(false)
                        .pId(securityLevelTree.getId()).build()
                ).collect(Collectors.toList())
        );
        dataResourceClassifyVo.setNodes(new ArrayList<DataResourceTreeVo>(){{add(securityLevelTree);}} );
        //设置总数量
        dataResourceClassifyVo.setTotal(securityLevelTree.getChild().size());
        return dataResourceClassifyVo;
    }

    /**
     * 数据资源分类
     *
     * @return
     */
    private DataResourceClassifyVo getDataClassifyTree() {
        DataResourceEnum dataResourceEnum = DataResourceEnum.DATA_RESOURCE_CLASSIFY;

        DataResourceClassifyVo dataResourceClassifyVo = DataResourceClassifyVo.builder().id(dataResourceEnum.getCode())
                .attrType(dataResourceEnum.getAttrType().getValue()).label(dataResourceEnum.getLabel()).build();

        DataResourceTreeVo dataClassifyTree = DataResourceTreeVo.builder().id(dataResourceEnum.getCode()).label("全部")
                .code(dataResourceEnum.getCode()).treeNode(true).build();

        dataClassifyTree.setChild(getFirstChildResourceClassifies(dataResourceService.getDataClassifyList())
                .stream()
                .map(firstClassify -> {
                    DataResourceTreeVo firstTreeVo = DataResourceTreeVo.builder()
                            .id(Joiner.on(ID_SEPARATOR).join(dataClassifyTree.getId(), firstClassify.getCodeValue()))
                            .code(firstClassify.getCodeValue())
                            .label(firstClassify.getCodeName())
                            .treeNode(true)
                            .pId(dataClassifyTree.getId())
                            .dataType(firstClassify.getTypeCode())
                            .codeDataTypeStr(UUIDUtils.getUUID() + CODE_DATA_TYPE_SEPARATOR + firstClassify.getCodeValue() + CODE_DATA_TYPE_SEPARATOR + firstClassify.getTypeCode())
                            .build();

                    firstTreeVo.setChild(getFirstChildResourceClassifies(firstClassify.getChildrenType()).stream()
                            .map(secondClassify -> {
                                DataResourceTreeVo secondTreeVo = DataResourceTreeVo.builder()
                                        .id(Joiner.on(ID_SEPARATOR).join(firstTreeVo.getId(), secondClassify.getCodeValue()))
                                        .code(secondClassify.getCodeValue())
                                        .label(secondClassify.getCodeName())
                                        .treeNode(true)
                                        .pId(firstTreeVo.getId())
                                        .dataType(secondClassify.getTypeCode())
                                        .codeDataTypeStr(UUIDUtils.getUUID() + CODE_DATA_TYPE_SEPARATOR + secondClassify.getCodeValue() + CODE_DATA_TYPE_SEPARATOR + secondClassify.getTypeCode())
                                        .build();

                                secondTreeVo.setChild(getChildrenTypeList(secondClassify.getChildrenType()).stream()
                                        .map(thirdClassify -> {
                                            DataResourceTreeVo thirdTreeVo = DataResourceTreeVo.builder()
                                                    .id(Joiner.on(ID_SEPARATOR).join(secondTreeVo.getId(), thirdClassify.getTypeCode()))
                                                    .code(thirdClassify.getTypeCode())
                                                    .label(thirdClassify.getTypeName())
                                                    .treeNode(true)
                                                    .pId(secondTreeVo.getId())
                                                    .dataType(thirdClassify.getTypeCode())
                                                    .codeDataTypeStr(UUIDUtils.getUUID() + CODE_DATA_TYPE_SEPARATOR + thirdClassify.getTypeCode() + CODE_DATA_TYPE_SEPARATOR + thirdClassify.getTypeCode())
                                                    .build();

                                            thirdTreeVo.setChild(thirdClassify.getDataList().stream()
                                                    .map(fourClassify -> {
                                                        DataResourceTreeVo fourTreeVo = DataResourceTreeVo.builder()
                                                                .id(Joiner.on(ID_SEPARATOR).join(thirdTreeVo.getId(), fourClassify.getCodeValue()))
                                                                .code(fourClassify.getCodeValue())
                                                                .label(fourClassify.getCodeName())
                                                                .treeNode(false).child(null)
                                                                .pId(thirdTreeVo.getId())
                                                                .dataType(thirdClassify.getTypeCode())
                                                                .codeDataTypeStr(UUIDUtils.getUUID() + CODE_DATA_TYPE_SEPARATOR + fourClassify.getCodeValue() + CODE_DATA_TYPE_SEPARATOR + thirdClassify.getTypeCode())
                                                                .build();
                                                        return fourTreeVo;
                                                    }).collect(Collectors.toList()));
                                            return thirdTreeVo;
                                        }).collect(Collectors.toList()));
                                return secondTreeVo;
                            }).collect(Collectors.toList()));
                    return firstTreeVo;
                }).collect(Collectors.toList()));

        dataResourceClassifyVo.setNodes(new ArrayList<DataResourceTreeVo>(){{add(dataClassifyTree);}} );
        dataResourceClassifyVo.setTotal(getTotalCount(dataClassifyTree));
        return dataResourceClassifyVo;
    }

    /**
     * 字段分类
     *
     * @return
     */
    private DataResourceClassifyVo getFieldClassifyTree() {
        DataResourceEnum dataResourceEnum = DataResourceEnum.COLUMN_CLASSIFY;

        DataResourceClassifyVo dataResourceClassifyVo = DataResourceClassifyVo.builder()
                .id(dataResourceEnum.getCode())
                .attrType(dataResourceEnum.getAttrType().getValue())
                .label(dataResourceEnum.getLabel())
                .build();

        DataResourceTreeVo fieldClassifyTree = DataResourceTreeVo.builder()
                .id(dataResourceEnum.getCode())
                .label("全部")
                .code(dataResourceEnum.getCode())
                .treeNode(true)
                .build();

        fieldClassifyTree.setChild(getFirstChildResourceClassifies(dataResourceService.getFieldClassifyList())
                .stream()
                .map(firstClassify -> {
                    DataResourceTreeVo firstTreeVo = DataResourceTreeVo.builder()
                            .id(Joiner.on(ID_SEPARATOR).join(fieldClassifyTree.getId(), firstClassify.getCodeValue()))
                            .code(firstClassify.getCodeValue())
                            .label(firstClassify.getCodeName())
                            .dataType(firstClassify.getTypeCode())
                            .treeNode(true)
                            .pId(fieldClassifyTree.getId())
                            .codeDataTypeStr(UUIDUtils.getUUID() + CODE_DATA_TYPE_SEPARATOR + firstClassify.getCodeValue() + CODE_DATA_TYPE_SEPARATOR + firstClassify.getTypeCode())
                            .build();

                    firstTreeVo.setChild(getFirstChildResourceClassifies(firstClassify.getChildrenType())
                            .stream()
                            .map(secondClassify -> {
                                        DataResourceTreeVo secondTreeVo = DataResourceTreeVo.builder()
                                                .id(Joiner.on(ID_SEPARATOR).join(firstTreeVo.getId(), secondClassify.getCodeValue()))
                                                .code(secondClassify.getCodeValue())
                                                .label(secondClassify.getCodeName())
                                                .treeNode(false)
                                                .dataType(secondClassify.getTypeCode())
                                                .pId(firstTreeVo.getId())
                                                .codeDataTypeStr(UUIDUtils.getUUID() + CODE_DATA_TYPE_SEPARATOR + secondClassify.getCodeValue() + CODE_DATA_TYPE_SEPARATOR + secondClassify.getTypeCode())
                                                .build();
                                        return secondTreeVo;
                                    }
                            ).collect(Collectors.toList()));
                    return firstTreeVo;
                }).collect(Collectors.toList())
        );

        dataResourceClassifyVo.setNodes(new ArrayList<DataResourceTreeVo>(){{add(fieldClassifyTree);}} );
        //设置总数
        dataResourceClassifyVo.setTotal(getTotalCount(fieldClassifyTree));
        return dataResourceClassifyVo;
    }

    private int getTotalCount(DataResourceTreeVo treeVo) {
        int count = 0;
        List<DataResourceTreeVo> child = treeVo.getChild();
        for (DataResourceTreeVo childVo : child) {
            Boolean treeNode = childVo.getTreeNode();
            if(treeNode){
                count += getTotalCount(childVo);
            }else {
                count += 1;
            }
        }
        return count;
    }

    @Override
    public List<DataLevelVo> getDataLevelList() {
        return getFirstChildResourceClassifies(dataResourceService.getDataLevelList())
                .stream()
                .map(childResourceClassify -> new DataLevelVo(childResourceClassify.getCodeValue(), childResourceClassify.getCodeName()))
                .collect(Collectors.toList());
    }

    @Override
    public List<DataLevelVo> getSecurityLevelList() {
        return getFirstChildResourceClassifies(dataResourceService.getSecurityLevelList())
                .stream()
                .map(childResourceClassify -> new DataLevelVo(childResourceClassify.getCodeValue(), childResourceClassify.getCodeName()))
                .collect(Collectors.toList());
    }

    @Override
    public List<DataClassifyVo> getDataClassifyList() {
        return getFirstChildResourceClassifies(dataResourceService.getDataClassifyList())
                .stream()
                .flatMap(
                        firstClassify -> getFirstChildResourceClassifies(firstClassify.getChildrenType()).stream()
                                .flatMap(
                                        secondClassify -> getChildrenTypeList(secondClassify.getChildrenType()).stream()
                                                .flatMap(
                                                        thirdClassify -> thirdClassify.getDataList().stream()
                                                                .map(fourClassify -> new DataClassifyVo(firstClassify.getCodeValue(),
                                                                        firstClassify.getCodeName(),
                                                                        secondClassify.getCodeValue(),
                                                                        secondClassify.getCodeName(),
                                                                        thirdClassify.getTypeCode(),
                                                                        thirdClassify.getTypeName(),
                                                                        fourClassify.getCodeValue(),
                                                                        fourClassify.getCodeName())
                                                                ).collect(Collectors.toList()).stream()

                                                )
                                )
                ).collect(Collectors.toList());
    }

    @Override
    public List<DataFieldClassifyVo> getFieldClassifyList() {
        return getFirstChildResourceClassifies(dataResourceService.getFieldClassifyList())
                .stream()
                .flatMap(firstClassify ->
                        getFirstChildResourceClassifies(firstClassify.getChildrenType())
                                .stream()
                                .map(secondClassify ->
                                        new DataFieldClassifyVo(firstClassify.getCodeValue(),
                                                firstClassify.getCodeName(),
                                                secondClassify.getCodeValue(),
                                                secondClassify.getCodeName())
                                ).collect(Collectors.toList()).stream()
                ).collect(Collectors.toList());
    }

    private List<ChildResourceClassify> getFirstChildResourceClassifies(List<ResourceClassify> fieldClassifyList) {
        return Optional.ofNullable(fieldClassifyList)
                .map(resourceClassifies -> resourceClassifies.get(0))
                .map(resourceClassify -> {
                    //设置节点的dataType,dataType为上级的typeCode字段
                    List<ChildResourceClassify> dataList = Optional.ofNullable(resourceClassify.getDataList()).orElse(Lists.newArrayList());
                    dataList.stream().forEach(item-> item.setTypeCode(resourceClassify.getTypeCode()));
                    return dataList;
                })
                .orElse(Lists.newArrayList());
    }

    private List<ResourceClassify> getChildrenTypeList(List<ResourceClassify> fieldClassifyList) {
        return Optional.ofNullable(fieldClassifyList)
                .orElse(Lists.newArrayList());
    }
}