@bos-alpha/data/lib/components/step-five/utils.js

数据管理

var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
var __rest = (this && this.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
};
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
        if (ar || !(i in from)) {
            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
            ar[i] = from[i];
        }
    }
    return to.concat(ar || Array.prototype.slice.call(from));
};
// 接口mappings解析
export var mappingsParse = function (mappings, docClassList, edgeClassList) {
    console.log('mappings=====', mappings);
    return mappings.map(function (item) {
        var label = item.bosclass;
        var curMappings = {};
        // 对象类
        if (item.relation === false) {
            var allAttributes_1 = {};
            (item.allAttributes || []).forEach(function (attr) {
                allAttributes_1[attr.rawKey] = attr.value;
            });
            curMappings = __assign({ bosclass: item.bosclass, dataset: item.dataset }, allAttributes_1);
            label = docClassList.find(function (ditem) { return ditem.className === item.bosclass; }).label;
        }
        // 关系类
        else {
            // 左对象关键字
            var leftAttributes_1 = {};
            (item.leftIdAttributes || []).forEach(function (attr) {
                leftAttributes_1[attr.rawKey] = attr.value;
            });
            // 右对象关键字
            var rightAttributes_1 = {};
            (item.rightIdAttributes || []).forEach(function (attr) {
                rightAttributes_1[attr.rawKey] = attr.value;
            });
            curMappings = __assign(__assign({ bosclass: item.bosclass, dataset: item.dataset, LeftObjectClass: item.leftObjectClass, RightObjectClass: item.rightObjectClass }, leftAttributes_1), rightAttributes_1);
            label = edgeClassList.find(function (eitem) { return eitem.className === item.bosclass; }).label;
        }
        return {
            code: item.bosclass,
            label: label,
            mappings: curMappings
        };
    });
};
// 映射列表解析转为表格数据
export var parseMappings2TableData = function (mapList, className, classAtts, classDefinition) {
    // 当前映射
    var curMap = mapList.find(function (item) { return item.code === className; });
    var _a = curMap.mappings, bosclass = _a.bosclass, dataset = _a.dataset, restMap = __rest(_a, ["bosclass", "dataset"]);
    // 当前类已有映射关系
    var curClassMappings = {};
    Object.keys(restMap || {}).forEach(function (key) {
        // 父节点关键字
        if (key.includes('ParentAttribute.')) {
            // 去掉父节点关键字前缀 用于回填
            var code = key.replace('ParentAttribute.', '');
            curClassMappings[code] = __assign(__assign({}, (curClassMappings[code] || {})), { isParent: true, parent: restMap[key] });
        }
        // 关键字映射(主关键字或左对象和右对象)或普通映射
        else {
            // 对象类映射 统统去掉主关键字前缀 用于回填
            var code = key;
            if (/^IdAttribute/.test(key)) {
                code = key.replace('IdAttribute.', '');
            }
            curClassMappings[code] = __assign(__assign({}, (curClassMappings[code] || {})), { value: restMap[key], checked: /^IdAttribute/.test(key), isParent: false, parent: null });
        }
    });
    // 属性列表
    var attributes = classAtts
        .filter(function (item) { return item.code !== 'bosclass'; })
        .map(function (item) {
        var curField = curClassMappings[item.code];
        return __assign(__assign({}, item), { field: curField ? curField.value : null, checked: curField ? curField.checked : false, isParent: curField ? curField.isParent : false, parent: curField ? curField.parent : null });
    });
    // 对象类直接列出所有属性 关系类列出已勾选关键字的左右对象属性
    if (classDefinition.type === 'doc') {
        return attributes;
    }
    else {
        /** 关系类 field
            "LeftIdAttribute.code":"folderCode" // 关系类左对象的主键字段
            "RightIdAttribute.code":"documentCode" // 关系类右对象的主键字段
        */
        var leftObjectClass_1 = classDefinition.leftObjectClass, rightObjectClass_1 = classDefinition.rightObjectClass;
        var leftFind = mapList.find(function (item) { return item.code === leftObjectClass_1; });
        var rightFind = mapList.find(function (item) { return item.code === rightObjectClass_1; });
        // 左对象关键字  右对象关键字
        var leftAttrs = [];
        var rightAttrs = [];
        // 左对象和右对象需完全匹配
        if (leftFind && rightFind) {
            leftAttrs = Object.keys(leftFind.mappings)
                .filter(function (key) { return /^IdAttribute/.test(key); })
                .map(function (key) {
                var keywordCode = key.replace('IdAttribute.', '');
                var curField = curClassMappings["LeftIdAttribute.".concat(keywordCode)];
                return {
                    code: "".concat(leftObjectClass_1, ".").concat(keywordCode),
                    edgeCode: "LeftIdAttribute.".concat(keywordCode),
                    leftObject: leftObjectClass_1,
                    field: curField ? curField.value : null,
                    checked: true
                };
            });
            rightAttrs = Object.keys(rightFind.mappings)
                .filter(function (key) { return /^IdAttribute/.test(key); })
                .map(function (key) {
                var keywordCode = key.replace('IdAttribute.', '');
                var curField = curClassMappings["RightIdAttribute.".concat(keywordCode)];
                return {
                    code: "".concat(rightObjectClass_1, ".").concat(keywordCode),
                    edgeCode: "RightIdAttribute.".concat(keywordCode),
                    rightObject: rightObjectClass_1,
                    field: curField ? curField.value : null,
                    checked: true
                };
            });
        }
        return __spreadArray(__spreadArray(__spreadArray([], leftAttrs, true), rightAttrs, true), attributes, true);
    }
};