@byted-apaas/server-sdk-node 0.0.1-beta.3

package/context/metadata/components/desktop/list.ts

@@ -0,0 +1,457 @@
+import * as common from '@byted-apaas/server-common-node'
+
+const commonUtils = common.utils;
+
+import {Component, componentTypes} from "../common";
+import {
+    ConcatTextType,
+    FieldApiType,
+    UIMetaFilterType,
+    UIMetaLangType,
+    UIMetaSortConditionsType,
+    UIMetaDesktopType, DeskListDetailField, DeskListSubtitleField, DeskListTitleField
+} from "../../types/components";
+import {I18ns, isNullOrUndefined} from "../../types/common";
+
+/*
+titleAreaText: i18n;
+objectApiName: string;
+isCompositeType: boolean;
+titleFields: [{
+    fieldApiName: string;
+},...]
+subtitleFields: [{
+    type: "field"|"concatText"
+    fieldApiName: string;
+    alias: i18n;
+    concatText: {
+        zh_CN: [{
+            dataType: "fieldApiName"|"text"
+            fieldApiName: string;
+            text: string;
+        },...]
+        en_US: [{
+            dataType: "fieldApiName"|"text"
+            fieldApiName: string;
+            text: string;
+        },...]
+    }
+},...]
+detailFields: [{
+    fieldApiName: string;
+    alias: i18n;
+},...]
+filter: {
+    conditions: object[];
+    logic: string;
+};
+sortConditions: object[];
+ */
+
+class List extends Component {
+    titleAreaText: I18ns;
+    objectApiName: string;
+    isCompositeType: boolean;
+    titleFields: DeskListTitleField[];
+    subtitleFields: DeskListSubtitleField[];
+    detailFields: DeskListDetailField[];
+    filter: UIMetaFilterType;
+    sortConditions: object[];
+
+    constructor(params: UIMetaDesktopType) {
+        super(componentTypes.desktopList);
+
+        // TODO check
+        this.titleAreaText = params.titleAreaText;
+        this.objectApiName = params.objectApiName;
+        this.isCompositeType = params.isCompositeType;
+        this.titleFields = params.titleFields;
+        this.subtitleFields = params.subtitleFields as any;
+        this.detailFields = params.detailFields as any;
+        this.filter = params.filter;
+        this.sortConditions = params.sortConditions;
+    }
+
+    static parse(input: Record<string, any>): List {
+        if (input.dataType === 'object') {
+            return convertUIMetaListObject(input);
+        } else if (input.dataType === 'compositeType') {
+            return convertUIMetaListCompositeType(input);
+        }
+        return input as List;
+    }
+}
+
+function convertUIMetaListObject(input: Record<string, any>): List {
+    return {
+        isCompositeType: false,
+        titleAreaText: input.titleLabel,
+        objectApiName: input.objectApiName,
+        titleFields: getListObjectTitleFields(input),
+        subtitleFields: getListObjectSubtitleFields(input),
+        detailFields: getListObjectDetailFields(input),
+        filter: getListFilter(input),
+        sortConditions: getListSort(input),
+    } as List;
+}
+
+function convertUIMetaListCompositeType(input: Record<string, any>): List {
+    return {
+        isCompositeType: true,
+        titleAreaText: input.titleLabel,
+        objectApiName: getListCompositeTypeObjectApiName(input),
+        titleFields: getListCompositeTypeTitleFields(input),
+        subtitleFields: getListCompositeTypeSubtitleFields(input),
+        detailFields: getListCompositeTypeDetailFields(input),
+        filter: getListCompositeTypeFilter(input),
+        sortConditions: getListSort(input),
+    } as List;
+}
+
+function getListObjectTitleFields(input: Record<string, any>): DeskListTitleField[] {
+    if (!input || isNullOrUndefined(input.title)) {
+        return [];
+    }
+
+    let titles: DeskListTitleField[] = [];
+    try {
+        let inputTitles = JSON.parse(input.title)
+        if (!inputTitles || !(inputTitles instanceof Array)) {
+            return [];
+        }
+
+        for (let inputTitle of inputTitles) {
+            titles.push({
+                fieldApiName: inputTitle.columnApiName,
+            });
+        }
+    } catch (err) {
+        return [];
+    }
+    return titles;
+}
+
+function getListObjectSubtitleFields(input: Record<string, any>): DeskListSubtitleField[] {
+    if (!input || isNullOrUndefined(input["subTitle"])) {
+        return [];
+    }
+
+    let subtitles: DeskListSubtitleField[] = [];
+
+    try {
+        let inputSubtitles = JSON.parse(input.subTitle)
+        if (!inputSubtitles || !Array.isArray(inputSubtitles)) {
+            return [];
+        }
+        for (let inputSubtitle of inputSubtitles) {
+            subtitles.push({
+                fieldApiName: inputSubtitle.columnApiName,
+                alias: inputSubtitle.alias,
+            });
+        }
+    } catch (err) {
+        return [];
+    }
+    return subtitles;
+}
+
+function getListObjectDetailFields(input: Record<string, any>): DeskListDetailField[] {
+    if (!input || isNullOrUndefined(input.detail)) {
+        return [];
+    }
+
+    let details: DeskListDetailField[] = [];
+    try {
+        let inputDetails = JSON.parse(input.detail)
+        if (!inputDetails || !Array.isArray(inputDetails)) {
+            return [];
+        }
+
+        for (let inputDetail of inputDetails) {
+            details.push({
+                fieldApiName: inputDetail.columnApiName,
+                alias: inputDetail.alias,
+            });
+        }
+    } catch (err) {
+        return [];
+    }
+    return details;
+}
+
+function getListFilter(input: Record<string, any>): UIMetaFilterType {
+    if (!input || !input.describeFilter || isNullOrUndefined(input.describeFilter.filter)) {
+        return {} as UIMetaFilterType;
+    }
+
+    try {
+        let inputFilter = JSON.parse(input.describeFilter.filter);
+        if (!inputFilter) {
+            return {} as UIMetaFilterType;
+        }
+        return {
+            conditions: inputFilter.conditions,
+            logic: inputFilter.logic,
+        }
+    } catch (err) {
+        return {} as UIMetaFilterType;
+    }
+}
+
+function getListSort(input: Record<string, any>): UIMetaSortConditionsType[] {
+    if (!input || !input.sort || !Array.isArray(input.sort)) {
+        return [];
+    }
+
+    let sortFields = [];
+    for (let field of input.sort) {
+        sortFields.push({
+            fieldApiName: field.field,
+            sort: field.direction,
+        });
+    }
+
+    return sortFields;
+}
+
+
+function getListCompositeTypeObjectApiName(input: Record<string, any>): string {
+    if (isNullOrUndefined(input)) {
+        return "";
+    }
+
+    let objectApiName = getObjectApiNameFromTitle(input);
+    if (objectApiName) {
+        return objectApiName;
+    }
+
+    objectApiName = getObjectApiNameFromSubTitle(input);
+    if (objectApiName) {
+        return objectApiName;
+    }
+
+    objectApiName = getObjectApiNameFromDetail(input);
+    if (objectApiName) {
+        return objectApiName;
+    }
+
+    return "";
+}
+
+function getObjectApiNameFromTitle(input: Record<string, any>): string {
+    if (!input || isNullOrUndefined(input.title)) {
+        return "";
+    }
+
+    try {
+        return JSON.parse(input.title)[0].picker.fieldPath[0].objectApiName;
+    } catch (err) {
+        return "";
+    }
+}
+
+function getObjectApiNameFromDetail(input: Record<string, any>): string {
+    if (!input || isNullOrUndefined(input.detail)) {
+        return "";
+    }
+
+    try {
+        return JSON.parse(input.detail)[0].picker.fieldPath[0].objectApiName;
+    } catch (err) {
+        return "";
+    }
+}
+
+function getObjectApiNameFromSubTitle(input: Record<string, any>): string {
+    if (!input || isNullOrUndefined(input.subTitle)) {
+        return "";
+    }
+
+    try {
+        return JSON.parse(input.subTitle)[0].picker.fieldPath[0].objectApiName;
+    } catch (err) {
+        return "";
+    }
+}
+
+function getListCompositeTypeTitleFields(input: Record<string, any>): FieldApiType[] {
+    if (!input || isNullOrUndefined(input.title)) {
+        return [];
+    }
+
+    let inputFields: FieldApiType[] = [];
+    try {
+        let inputTitles = JSON.parse(input.title);
+        if (!inputTitles || !(inputTitles instanceof Array)) {
+            return [];
+        }
+
+        for (let title of inputTitles) {
+            try {
+                inputFields.push({
+                    fieldApiName: title.picker.fieldPath[0].fieldApiName,
+                });
+            } catch (e) {
+                continue;
+            }
+        }
+    } catch (err) {
+        return [];
+    }
+    return inputFields;
+}
+
+function parsePrimitive(element: Record<string, any>): FieldApiType {
+    try {
+        return {
+            type: "field",
+            fieldApiName: element.picker.fieldPath[0].fieldApiName,
+            alias: [],
+            concatText: {
+                zh_CN: [],
+                en_US: [],
+            }
+        }
+    } catch (e) {
+        return null;
+    }
+}
+
+
+function getListCompositeTypeSubtitleFields(input: Record<string, any>): FieldApiType[] {
+    if (!input || isNullOrUndefined(input.subTitle)) {
+        return [];
+    }
+
+    let fields: FieldApiType[] = [], subTitle;
+    try {
+        subTitle = JSON.parse(input.subTitle);
+    } catch (err) {
+        return [];
+    }
+
+    if (!subTitle || !Array.isArray(subTitle)) {
+        return [];
+    }
+
+    for (let element of subTitle) {
+        let field = null;
+        if (element.type === 'primitive') {
+            field = parsePrimitive(element);
+        } else if (element.type === 'concatenate') {
+            field = parseConcatenate(element);
+        }
+
+        if (field) {
+            fields.push(field);
+        }
+    }
+    return fields;
+}
+
+function getListCompositeTypeDetailFields(input: Record<string, any>): FieldApiType[] {
+    if (!input || isNullOrUndefined(input.detail)) {
+        return [];
+    }
+
+    let fields: FieldApiType[] = [];
+    try {
+        let detail = JSON.parse(input.detail);
+        if (!detail || !(detail instanceof Array)) {
+            return [];
+        }
+        for (let element of detail) {
+            try {
+                fields.push({
+                    fieldApiName: element.picker.fieldPath[0].fieldApiName,
+                    alias: [], // TODO
+                });
+            } catch (e) {
+                continue;
+            }
+        }
+    } catch (err) {
+        return [];
+    }
+    return fields;
+}
+
+function getListCompositeTypeFilter(input: Record<string, any>): UIMetaFilterType {
+    if (!input || !input.describeFilter || isNullOrUndefined(input.describeFilter.filter)) {
+        return {} as UIMetaFilterType;
+    }
+
+    try {
+        let inputFilter = JSON.parse(input.describeFilter.filter);
+        if (!inputFilter) {
+            return {} as UIMetaFilterType;
+        }
+
+        return {
+            conditions: inputFilter.conditions,
+            logic: inputFilter.logic,
+        }
+    } catch (err) {
+        return {} as UIMetaFilterType;
+    }
+}
+
+function parseLangValues(values: Record<string, any>[]): UIMetaLangType[] {
+    let lang = [];
+    for (let value of values) {
+        if (value.type === "text") {
+            lang.push({
+                dataType: "text",
+                fieldApiName: "",
+                text: value.value,
+            });
+        } else if (value.type === "field") {
+            if (value && value.picker && commonUtils.getArrayLength(value.picker.fieldPath) > 0
+                && value.picker.fieldPath[0].fieldApiName) {
+                lang.push({
+                    dataType: "fieldApiName",
+                    fieldApiName: value.picker.fieldPath[0].fieldApiName,
+                    text: ""
+                });
+
+            }
+        }
+    }
+    return lang;
+}
+
+function parseConcatenate(element: Record<string, any>): FieldApiType {
+    if (!element || isNullOrUndefined(element.content)) {
+        return null;
+    }
+
+    let concatEle: FieldApiType = {
+        type: "concatText",
+        fieldApiName: "",
+        alias: [],
+        concatText: {
+            zh_CN: [],
+            en_US: [],
+        }
+    };
+
+    for (let code of Object.keys(element.content)) {
+        let values = element.content[code];
+        if (code === "2052") {
+            concatEle.concatText.zh_CN = parseLangValues(values);
+        } else if (code === "1033") {
+            concatEle.concatText.en_US = parseLangValues(values);
+        }
+    }
+
+    if (commonUtils.getArrayLength(concatEle.concatText.zh_CN) > 0 ||
+        commonUtils.getArrayLength(concatEle.concatText.en_US) > 0) {
+        return concatEle;
+    }
+
+    return null;
+}
+
+export {
+    List,
+}

package/context/metadata/components/desktop/recordDetail.d.ts

@@ -0,0 +1,11 @@
+import { Component } from "../common";
+import { SelectFieldType } from '../../types/components';
+import { I18ns } from "../../types/common";
+declare class RecordDetail extends Component {
+    titleAreaText: I18ns;
+    objectApiName: string;
+    selectedFields: SelectFieldType[];
+    constructor(params: Record<string, any>);
+    static parse(input: Record<string, any>): RecordDetail;
+}
+export { RecordDetail, };

package/context/metadata/components/desktop/recordDetail.js

@@ -0,0 +1,53 @@
+"use strict";
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordDetail = void 0;
+const common_1 = require("../common");
+/*
+titleAreaText: i18n;
+objectApiName: string;
+selectedFields: [{
+    fieldPath: [{
+        objectApiName: string;
+        fieldApiName: string;
+    }, ...];
+},...]
+ */
+class RecordDetail extends common_1.Component {
+    constructor(params) {
+        super(common_1.componentTypes.desktopRecordDetail);
+        // TODO check
+        this.titleAreaText = params.titleAreaText;
+        this.objectApiName = params.objectApiName;
+        this.selectedFields = params.selectedFields;
+    }
+    static parse(input) {
+        return new RecordDetail({
+            titleAreaText: input.titleLabel,
+            objectApiName: input.objectApiName,
+            selectedFields: getSelectedFields(input),
+        });
+    }
+}
+exports.RecordDetail = RecordDetail;
+function getSelectedFields(input) {
+    if (!input || !input.selectedFields || !Array.isArray(input.selectedFields)) {
+        return [];
+    }
+    let selectedFields = [];
+    for (let selectedField of input.selectedFields) {
+        if (!selectedField || !selectedField.picker || !selectedField.picker.fieldPath) {
+            continue;
+        }
+        let fieldPath = [];
+        for (let field of selectedField.picker.fieldPath) {
+            fieldPath.push({
+                objectApiName: field.objectApiName,
+                fieldApiName: field.fieldApiName,
+            });
+        }
+        selectedFields.push({ fieldPath: fieldPath });
+    }
+    return selectedFields;
+}

package/context/metadata/components/desktop/recordDetail.ts

@@ -0,0 +1,67 @@
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+
+import {Component, componentTypes} from "../common";
+import {SelectFieldType} from '../../types/components'
+import {I18ns} from "../../types/common";
+
+/*
+titleAreaText: i18n;
+objectApiName: string;
+selectedFields: [{
+    fieldPath: [{
+        objectApiName: string;
+        fieldApiName: string;
+    }, ...];
+},...]
+ */
+
+class RecordDetail extends Component {
+    titleAreaText: I18ns;
+    objectApiName: string;
+    selectedFields: SelectFieldType[];
+
+    constructor(params: Record<string, any>) {
+        super(componentTypes.desktopRecordDetail);
+
+        // TODO check
+        this.titleAreaText = params.titleAreaText;
+        this.objectApiName = params.objectApiName;
+        this.selectedFields = params.selectedFields;
+    }
+
+    static parse(input: Record<string, any>): RecordDetail {
+        return new RecordDetail({
+            titleAreaText: input.titleLabel,
+            objectApiName: input.objectApiName,
+            selectedFields: getSelectedFields(input),
+        });
+    }
+}
+
+function getSelectedFields(input: Record<string, any>): SelectFieldType[] {
+    if (!input || !input.selectedFields || !Array.isArray(input.selectedFields)) {
+        return [];
+    }
+
+    let selectedFields = [];
+    for (let selectedField of input.selectedFields) {
+        if (!selectedField || !selectedField.picker || !selectedField.picker.fieldPath) {
+            continue;
+        }
+
+        let fieldPath = [];
+        for (let field of selectedField.picker.fieldPath) {
+            fieldPath.push({
+                objectApiName: field.objectApiName,
+                fieldApiName: field.fieldApiName,
+            });
+        }
+        selectedFields.push({fieldPath: fieldPath});
+    }
+    return selectedFields;
+}
+
+export {
+    RecordDetail,
+}

package/context/metadata/components/mobile/list.d.ts

@@ -0,0 +1,24 @@
+import { MobileListItem, UIMetaFilterType, UIMetaMobileType } from "../../types/components";
+import { I18ns } from "../../types/common";
+import { Component } from "../common";
+declare class List extends Component {
+    titleAreaText: I18ns;
+    objectApiName: string;
+    listItems: MobileListItem;
+    filter: UIMetaFilterType;
+    sortConditions: object[];
+    pageApiName: string;
+    componentName: string;
+    pageType: ("app" | "record_page");
+    needPublish: boolean;
+    constructor(params: UIMetaMobileType);
+    static parse(input: Record<string, any>): List;
+    getReqParam(): Record<string, any>;
+    getTableColumn(): {
+        apiName: string;
+    }[];
+    getDescribeFilter(): {
+        filter: string;
+    };
+}
+export { List, };