@steedos/service-rest 2.6.10-beta.9 → 2.7.0-beta.10

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@steedos/service-rest",
-    "version": "2.6.10-beta.9",
+    "version": "2.7.0-beta.10",
     "main": "package.service.js",
     "private": false,
     "publishConfig": {
@@ -16,9 +16,9 @@
     "repository": {},
     "license": "MIT",
     "dependencies": {
-        "@steedos/objectql": "2.6.10-beta.9",
-        "@steedos/service-object-mixin": "2.6.10-beta.9",
+        "@steedos/objectql": "2.7.0-beta.10",
+        "@steedos/service-object-mixin": "2.7.0-beta.10",
         "lodash": "^4.17.21"
     },
-    "gitHead": "63d67e404a721f1947eceed105a56aac8c8d93ec"
+    "gitHead": "78659952139c455e4fdd3d581c0d242219e033d0"
 }

package/package.service.js

@@ -1,14 +1,15 @@
 /*
  * @Author: sunhaolin@hotoa.com
  * @Date: 2023-03-23 15:12:14
- * @LastEditors: 孙浩林 sunhaolin@steedos.com
- * @LastEditTime: 2023-09-23 11:50:21
+ * @LastEditors: 殷亮辉 yinlianghui@hotoa.com
+ * @LastEditTime: 2024-03-14 10:39:22
  * @Description: 
  */
 "use strict";
 // @ts-check
 const serviceObjectMixin = require('@steedos/service-object-mixin');
 const { QUERY_DOCS_TOP, REQUEST_SUCCESS_STATUS } = require('./consts')
+const { translateRecords } = require('./translate');
 const _ = require('lodash')
 const { getObject } = require('@steedos/objectql');
 
@@ -53,6 +54,8 @@ module.exports = {
          * @apiGroup @steedos/service-rest
          * @apiParam {String} objectName 对象API Name，如：contracts
          * @apiQuery {String} [fields] 字段名，如：'["name", "description"]'
+         * @apiQuery {String} [uiFields] 字段名，如：'["owner", "date"]',此参数中的字段要求在参数fields中存在
+         * @apiQuery {String} [expandFields] 字段名，如：'{owner: {fields: ["name"], uiFields: ["owner"], expandFields: ...}}'
          * @apiQuery {String} [filters] 过滤条件，如：'[["name", "=", "test"],["amount", ">", 100]]'
          * @apiQuery {String} [top] 获取条数，如：'10'，最多5000
          * @apiQuery {String} [skip] 跳过条数，如：'10'
@@ -90,22 +93,51 @@ module.exports = {
             params: {
                 objectName: { type: "string" },
                 fields: { type: 'string', optional: true },
+                uiFields: { type: 'string', optional: true },
+                expandFields: { type: 'string', optional: true },
                 filters: { type: 'string', optional: true },
                 top: { type: 'string', optional: true, default: QUERY_DOCS_TOP },
                 skip: { type: 'string', optional: true },
                 sort: { type: 'string', optional: true }
             },
             async handler(ctx) {
+                if (process.env.STEEDOS_DEBUG) {
+                    console.time('open api find total time');
+                }
+
+                if (process.env.STEEDOS_DEBUG) {
+                    console.time('open api find before find');
+                }
                 const params = ctx.params
-                const { objectName, fields, filters, top, skip, sort } = params
+                const { objectName, filters, top, skip, sort } = params
                 const userSession = ctx.meta.user;
 
+                let fields = [];
+                if(params.fields){
+                    fields = JSON.parse(params.fields)
+                }
+
+                let uiFields = [];
+                if(params.uiFields){
+                    uiFields = JSON.parse(params.uiFields)
+                }
+
+                let expandFields;
+                if(params.expandFields){
+                    expandFields = JSON.parse(params.expandFields)
+                }
+
                 const query = {}
                 if (filters) {
                     query.filters = JSON.parse(filters)
                 }
                 if (fields) {
-                    query.fields = JSON.parse(fields)
+                    let queryFields = fields;
+                    if(expandFields){
+                        // 跟GraphQL第一层一样，从库里查的字段要补上expandFields中的字段，即uiFields中依赖的字段可以在fields中定义，也可以在expandFields中字义
+                        queryFields = _.union(queryFields, _.keys(expandFields));
+                    }
+                    query.fields = queryFields;
                 }
                 if (top) {
                     query.top = Number(top)
@@ -126,22 +158,128 @@ module.exports = {
                     }
                 }
 
-                const records = await this.find(objectName, query, userSession)
+                if (process.env.STEEDOS_DEBUG) {
+                    console.timeEnd('open api find before find');
+                }
+
                 const countQuery = {
                     filters: query.filters
                 }
-                const totalCount = await this.count(objectName, countQuery, userSession)
+
+                if (process.env.STEEDOS_DEBUG) {
+                    console.time('open api find find record and count');
+                }
+                const [records, totalCount] = await Promise.all([
+                    await this.find(objectName, query, userSession),
+                    await this.count(objectName, countQuery, userSession)
+                ])
+                if (process.env.STEEDOS_DEBUG) {
+                    console.timeEnd('open api find find record and count');
+                }
+
+
+                if (process.env.STEEDOS_DEBUG) {
+                    console.time('open api find translateRecords');
+                }
+                const translatedRecords = await translateRecords(records, objectName, fields, uiFields, expandFields, userSession);
+                if (process.env.STEEDOS_DEBUG) {
+                    console.timeEnd('open api find translateRecords');
+                }
+
+                if (process.env.STEEDOS_DEBUG) {
+                    console.timeEnd('open api find total time');
+                }
 
                 return {
                     "status": REQUEST_SUCCESS_STATUS,
                     "msg": "",
                     "data": {
-                        "items": records,
+                        "items": translatedRecords,
                         "total": totalCount
                     }
                 }
             }
         },
+        /**
+         * @api {GET} /api/v1/:objectName/count 获取记录个数
+         * @apiVersion 0.0.0
+         * @apiName count
+         * @apiGroup @steedos/service-rest
+         * @apiParam {String} objectName 对象API Name，如：contracts
+         * @apiQuery {String} [filters] 过滤条件，如：'[["name", "=", "test"],["amount", ">", 100]]'
+         * @apiSuccess {Object[]} count  记录个数
+         * @apiSuccessExample {json} Success-Response:
+         *     HTTP/1.1 200 OK
+         *     {
+         *       "status": 0, // 返回 0，表示当前接口正确返回，否则按错误请求处理
+         *       "msg": "", // 返回接口处理信息
+         *       "data": {
+         *         "count": 200 
+         *       }
+         *     }
+         * @apiErrorExample {json} Error-Response:
+         *     HTTP/1.1 500 Error
+         *     {
+         *       "status": -1,
+         *       "msg": "",
+         *       "data": {}
+         *     }
+         */
+        count: {
+            rest: {
+                method: "GET",
+                path: "/:objectName/count"
+            },
+            params: {
+                objectName: { type: "string" },
+                filters: { type: 'string', optional: true },
+            },
+            async handler(ctx) {
+                if (process.env.STEEDOS_DEBUG) {
+                    console.time('open api count total time');
+                }
+
+                if (process.env.STEEDOS_DEBUG) {
+                    console.time('open api count before find');
+                }
+                const params = ctx.params
+                const { objectName, filters } = params
+                const userSession = ctx.meta.user;
+
+                const query = {}
+                if (filters) {
+                    query.filters = JSON.parse(filters)
+                }
+
+                if (process.env.STEEDOS_DEBUG) {
+                    console.timeEnd('open api count before find');
+                }
+
+                const countQuery = {
+                    filters: query.filters
+                }
+
+                if (process.env.STEEDOS_DEBUG) {
+                    console.time('open api count find count');
+                }
+                const count = await this.count(objectName, countQuery, userSession);
+                if (process.env.STEEDOS_DEBUG) {
+                    console.timeEnd('open api count find count');
+                }
+
+                if (process.env.STEEDOS_DEBUG) {
+                    console.timeEnd('open api count total time');
+                }
+
+                return {
+                    "status": REQUEST_SUCCESS_STATUS,
+                    "msg": "",
+                    "data": {
+                        "count": count
+                    }
+                }
+            }
+        },
         /**
          * @api {POST} /api/v1/:objectName/search 查询列表记录
          * @apiVersion 0.0.0

package/translate.js

@@ -0,0 +1,459 @@
+/*
+ * @Author: baozhoutao@steedos.com
+ * @Date: 2024-02-26 13:29:53
+ * @LastEditors: 殷亮辉 yinlianghui@hotoa.com
+ * @LastEditTime: 2024-03-12 17:32:17
+ * @Description: 
+ */
+const _ = require('lodash')
+
+const { getSteedosSchema, getUserLocale, absoluteUrl } = require("@steedos/objectql");
+const { translationObject } = require("@steedos/i18n");
+const { formatBasicFieldValue } = require("./utils");
+
+const EXPAND_SUFFIX = '__expand';
+const UI_PREFIX = '_ui';
+
+function getTranslatedFieldConfig(translatedObject, name) {
+    return translatedObject.fields[name.replace(/__label$/, "")];
+}
+
+async function translateRecordToUI(record, objectName, selectorFieldNames, userSession){
+
+    const lng = getUserLocale(userSession);
+    let steedosSchema = getSteedosSchema();
+    let object = steedosSchema.getObject(objectName);
+    let objConfig = await object.toConfig();
+    let fields = objConfig.fields;
+    // let _object = clone(objConfig);
+    translationObject(lng, objConfig.name, objConfig, true);
+    
+    async function _translateToUI(record, selectorFieldNames, parentRecord) {
+        let displayObj = {};
+        for (const name of selectorFieldNames) {
+            if (Object.prototype.hasOwnProperty.call(fields, name)) {
+                const field = fields[name];
+                try {
+                    if (_.has(record, name)) {
+                        const fType = field.type;
+                        const dataType = field.data_type;
+                        if (fType == "select") {
+                            let label = "";
+                            let map = {};
+                            let value = record[name];
+                            let translatedField = getTranslatedFieldConfig(objConfig, name);
+                            let translatedFieldOptions =
+                                translatedField && translatedField.options;
+                            _.forEach(translatedFieldOptions, function (o) {
+                                map[o.value] = o.label;
+                            });
+                            if (field.multiple) {
+                                let labels = [];
+                                _.forEach(value, function (v) {
+                                    labels.push(map[v]);
+                                });
+                                label = labels.join(",");
+                            } else {
+                                label = map[value];
+                            }
+                            displayObj[name] = label;
+                        } else if (fType == "lookup" && (_.isString(field.reference_to) || (!_.has(field, 'reference_to') && !_.has(field, '_reference_to')))) {
+                            if (_.isString(field.reference_to)) {
+                                let refTo = field.reference_to;
+
+                                let refField = field.reference_to_field || '_id';
+
+                                if (refTo === 'users') {
+                                    refTo = 'space_users';
+                                    refField = 'user'
+                                }
+
+                                let refValue = record[name];
+                                if (!refValue) {
+                                    continue;
+                                }
+                                let refObj = steedosSchema.getObject(refTo);
+                                let nameFieldKey = await refObj.getNameFieldKey();
+                                let refFilters = null;
+
+                                if (field.multiple) {
+                                    refFilters = [refField, "in", refValue]
+                                } else {
+                                    refFilters = [refField, "=", refValue]
+                                }
+
+                                // 判断如果是 reference_to = object_fields &&  reference_to_field = name, 则额外添加查询条件 object 查询条件;
+                                if (refTo === 'object_fields' && refField == 'name') {
+                                    if(objConfig.name === 'objects'){
+                                        refFilters = [['object', '=', parentRecord['name']], refFilters]
+                                    }else{
+                                        const refToObjectsField = _.find(fields, (_field) => {
+                                            return _field.reference_to === 'objects'
+                                        })
+                                        if (refToObjectsField) {
+                                            refFilters = [['object', '=', parentRecord[refToObjectsField.name]], refFilters]
+                                        }
+                                    }
+                                    
+                                }
+
+                                // 判断如果是 reference_to = object_actions &&  reference_to_field = name, 则额外添加查询条件 object 查询条件;
+                                if (refTo === 'object_actions' && refField == 'name') {
+                                    const refToObjectsField = _.find(fields, (_field) => {
+                                        return _field.reference_to === 'objects'
+                                    })
+                                    if (refToObjectsField) {
+                                        refFilters = [['object', '=', parentRecord[refToObjectsField.name]], refFilters]
+                                    }
+                                }
+
+                                if (field.multiple) {
+                                    let refRecords = await refObj.find({
+                                        filters: refFilters,
+                                        fields: [nameFieldKey],
+                                    });
+                                    displayObj[name] = _.map(refRecords, (item) => {
+                                        return {
+                                            objectName: refTo,
+                                            value: item ? item._id : refValue,
+                                            label: item ? item[nameFieldKey] : refValue
+                                        }
+                                    })
+                                } else {
+                                    let refRecord = (
+                                        await refObj.find({
+                                            filters: refFilters,
+                                            fields: [nameFieldKey],
+                                        })
+                                    )[0];
+                                    if (refRecord) {
+                                        displayObj[name] = {
+                                            objectName: refTo,
+                                            value: refRecord._id,
+                                            label: refRecord[nameFieldKey]
+                                        };
+                                    } else {
+                                        displayObj[name] = {
+                                            objectName: refTo,
+                                            value: refValue,
+                                            label: refValue
+                                        };
+                                    }
+                                }
+                            } else {
+                                let refValue = record[name];
+                                if (!refValue) {
+                                    continue;
+                                }
+                                if (field.multiple && _.isArray(refValue)) {
+                                    _.each(refValue, (item) => {
+                                        displayObj[name] = {
+                                            value: item,
+                                            label: item
+                                        };
+                                    })
+                                } else {
+                                    displayObj[name] = {
+                                        value: refValue,
+                                        label: refValue
+                                    };
+                                }
+                            }
+
+                        } else if (fType == "master_detail" && _.isString(field.reference_to)) {
+                            let refTo = field.reference_to;
+                            let refField = field.reference_to_field || '_id';
+
+                            if (refTo === 'users') {
+                                refTo = 'space_users';
+                                refField = 'user'
+                            }
+                            let refValue = record[name];
+                            if (!refValue) {
+                                continue;
+                            }
+                            let refObj = steedosSchema.getObject(refTo);
+                            let nameFieldKey = await refObj.getNameFieldKey();
+
+                            if (field.multiple) {
+                                let refRecords = await refObj.find({
+                                    filters: [refField, "in", refValue],
+                                    fields: [nameFieldKey],
+                                });
+                                displayObj[name] = _.map(refRecords, (item) => {
+                                    return {
+                                        objectName: refTo,
+                                        value: item._id,
+                                        label: item[nameFieldKey]
+                                    }
+                                })
+                            } else {
+                                let refRecord = (
+                                    await refObj.find({
+                                        filters: [refField, "=", refValue],
+                                        fields: [nameFieldKey],
+                                    })
+                                )[0];
+                                if (refRecord) {
+                                    displayObj[name] = {
+                                        objectName: refTo,
+                                        value: refRecord._id,
+                                        label: refRecord[nameFieldKey]
+                                    };
+                                }
+                            }
+                        } else if ((fType == "master_detail" || fType == "lookup") && ((field.reference_to && !_.isString(field.reference_to)) || _.isString(field._reference_to))) {
+                            let refValue = record[name];
+                            if (!refValue) {
+                                continue;
+                            }
+                            let refTo = refValue.o;
+                            let refValues = refValue.ids;
+                            if (!refTo) {
+                                continue;
+                            }
+                            let refObj = steedosSchema.getObject(refTo);
+                            let nameFieldKey = await refObj.getNameFieldKey();
+                            let refRecords = await refObj.find({
+                                filters: [`_id`, "in", refValues],
+                                fields: [nameFieldKey]
+                            });
+
+                            displayObj[name] = _.map(refRecords, (item) => {
+                                return {
+                                    objectName: refTo,
+                                    value: item._id,
+                                    label: item[nameFieldKey]
+                                }
+                            })
+                        } else if (fType == "formula") {
+                            displayObj[name] = formatBasicFieldValue(field.data_type, field, record[name], objConfig, userSession);
+                        } else if (fType == "summary") {
+                            displayObj[name] = formatBasicFieldValue(dataType, field, record[name], objConfig, userSession);
+                        } else if (fType == "image" || fType == "file" || fType === 'avatar') {
+                            const optionsStr = fType == "file" ? '?download=1' : ''
+                            let fileValue = null;
+                            let value = record[name];
+                            if (!value) {
+                                continue;
+                            }
+                            // TODO: cfs_images_filerecord对象不存在，需要额外处理
+                            let storageName = getFileStorageName(fType)
+                            let fileObjectName = `cfs_${storageName}_filerecord`;
+                            let fileObject = steedosSchema.getObject(fileObjectName);
+                            const fileNameFieldKey = "original.name";
+                            if (field.multiple) {
+                                let fileRecords = await fileObject.find({
+                                    filters: [`_id`, "in", value],
+                                    fields: ['_id', fileNameFieldKey, 'original.size', 'original.type'],
+                                });
+                                fileValue = _.map(fileRecords, (fileRecord) => {
+                                    return {
+                                        name: fileRecord.original?.name,
+                                        url: absoluteUrl(`/api/files/${storageName}/${fileRecord._id}${optionsStr}`),
+                                        size: fileRecord.original?.size,
+                                        type: fileRecord.original?.type,
+                                    };
+                                });
+                            } else {
+                                let fileRecord = (
+                                    await fileObject.find({
+                                        filters: [`_id`, "=", value],
+                                        fields: ['_id', fileNameFieldKey, 'original.size', 'original.type'],
+                                    })
+                                )[0];
+                                if (fileRecord) {
+                                    fileValue = {
+                                        name: fileRecord["original"]["name"],
+                                        url: absoluteUrl(`/api/files/${storageName}/${value}${optionsStr}`),
+                                        size: fileRecord.original?.size,
+                                        type: fileRecord.original?.type
+                                    };
+                                } else {
+                                    fileValue = {
+                                        url: value
+                                    };
+                                }
+                            }
+                            displayObj[name] = fileValue;
+                        } else if (fType == "filesize") {
+                            displayObj[name] = formatFileSize(record[name]);
+                        }
+                        else if (fType === 'object') {
+                            if (record[name] && _.isObject(record[name])) {
+                                const _doc = {}
+                                _.each(record[name], function (v, k) {
+                                    const newKey = `${name}.${k}`
+                                    _doc[newKey] = v
+                                })
+                                const objectFieldDoc = await _translateToUI(_doc, Object.keys(_doc), record)
+                                const objectDoc = {}
+                                _.each(objectFieldDoc, function (v, k) {
+                                    const newKey = k.replace(`${name}.`, '')
+                                    objectDoc[newKey] = v
+                                })
+                                displayObj[name] = objectDoc
+                            }
+                        }
+                        else if (fType === 'grid' || 'table' === fType) {
+                            if (record[name] && _.isArray(record[name])) {
+                                const gridDocs = []
+                                for (const gridDoc of record[name]) {
+                                    const _doc = {}
+                                    _.each(gridDoc, function (v, k) {
+                                        const newKey = `${name}.$.${k}`
+                                        _doc[newKey] = v
+                                    })
+                                    const objectFieldDoc = await _translateToUI(_doc, Object.keys(_doc), record)
+                                    const objectDoc = {}
+                                    _.each(objectFieldDoc, function (v, k) {
+                                        const newKey = k.replace(`${name}.$.`, '')
+                                        objectDoc[newKey] = v
+                                    })
+                                    gridDocs.push(objectDoc)
+                                }
+
+                                displayObj[name] = gridDocs
+                            }
+                        }
+                        else {
+                            displayObj[name] = formatBasicFieldValue(fType, field, record[name], objConfig, userSession);
+                        }
+                    }
+                    else {
+                        displayObj[name] = ""; // 如果值为空，均返回空字符串
+                    }
+                } catch (error) {
+                    displayObj[name] = record[name];
+                    // console.warn(error)
+                }
+            }
+        }
+        return displayObj
+    }
+
+    let uiDoc = await _translateToUI(record, selectorFieldNames, record)
+    return uiDoc;
+}
+
+async function translateRecordToExpand(record, objectName, expandFields, userSession) {
+    let steedosSchema = getSteedosSchema();
+    let object = steedosSchema.getObject(objectName);
+    let objConfig = await object.toConfig();
+    let fields = objConfig.fields;
+
+    async function _translateToExpand(record, expandFields) {
+        let expandObj = {};
+        for (const fieldName in expandFields) {
+            const expandField = expandFields[fieldName];
+            let expandFieldFields = expandField.fields || [];
+            const expandFieldUiFields = expandField.uiFields;
+            const expandFieldExpandFields = expandField.expandFields;
+            if(expandFieldFields.length === 0 && _.isEmpty(expandFieldExpandFields)){
+                continue;
+            }
+
+            if (Object.prototype.hasOwnProperty.call(fields, fieldName) && expandFieldFields.length > 0) {
+                const field = fields[fieldName];
+                try {
+                    if (field && _.has(record, fieldName)) {
+                        let isLookup = (field.type == "lookup" || field.type == "master_detail") &&
+                            field.reference_to && _.isString(field.reference_to);
+                        let isFile = field.type == "image" || field.type == "file";
+                        if (isLookup || isFile){
+                            let refTo = field.reference_to;
+                            let refField = field.reference_to_field || '_id';
+                            if (isFile) {
+                                // TODO: cfs_images_filerecord对象不存在，需要额外处理
+                                refTo = field.type == "image" ? "cfs_images_filerecord" : "cfs_files_filerecord";
+                            }
+
+                            let refValue = record[fieldName];
+                            if (!refValue) {
+                                // 如果值为空，跟GraphQL一样，返回null值
+                                expandObj[fieldName + EXPAND_SUFFIX] = null;
+                                continue;
+                            }
+                            let refObj = steedosSchema.getObject(refTo);
+                            let refFilters = null;
+
+                            if (field.multiple) {
+                                refFilters = [refField, "in", refValue]
+                            } else {
+                                refFilters = [refField, "=", refValue]
+                            }
+
+                            let queryFields = expandFieldFields;
+                            if(expandFieldExpandFields){
+                                // 跟GraphQL第一层一样，从库里查的字段要补上expandFields中的字段，即uiFields中依赖的字段可以在fields中定义，也可以在expandFields中字义
+                                queryFields = _.union(queryFields, _.keys(expandFieldExpandFields));
+                            }
+
+                            const queryFilters = [refFilters];
+                            const spaceId = userSession.spaceId;
+                            if (refField && refField != '_id' && refTo != 'users' && refTo != 'spaces' && spaceId) {
+                                queryFilters.push(["space", "=", spaceId])
+                            }
+
+                            let refRecords = await refObj.find({
+                                filters: queryFilters,
+                                fields: queryFields,
+                            });
+                            let translatedRecords = await translateRecords(refRecords, refTo, expandFieldFields, expandFieldUiFields, expandFieldExpandFields, userSession);
+                            if(field.multiple){
+                                expandObj[fieldName + EXPAND_SUFFIX] = translatedRecords;
+                            }
+                            else{
+                                expandObj[fieldName + EXPAND_SUFFIX] = translatedRecords[0];
+                            }
+                        }
+                    }
+                    else {
+                        // 如果值为空，跟GraphQL一样，返回null值
+                        expandObj[fieldName + EXPAND_SUFFIX] = null;
+                    }
+                } catch (error) {
+                    // 如果报错，跟GraphQL一样，返回null值
+                    expandObj[fieldName + EXPAND_SUFFIX] = null;
+                }
+
+            }
+        };
+        return expandObj
+    }
+
+    let expandProps = await _translateToExpand(record, expandFields)
+    return expandProps;
+}
+
+async function translateRecords(records, objectName, fields, uiFields, expandFields, userSession) {
+    var hasUiFields = !_.isEmpty(uiFields);
+    var hasExpandFields = !_.isEmpty(expandFields);
+    var emptyRecord = {};
+    _.each(fields || [], (field) => {
+        // GraphQL那边空值规则是返回null，openApi跟它一样
+        emptyRecord[field] = null;
+    });
+    // 跟GraphQl一样，找出在expandFields中字义过，但是没在fields中定义的字段，需要排除掉这些字段，即只返回fields中指定的字段，record中因为expandFields额外多查出的字段不返回
+    let omitFields = _.difference(_.keys(expandFields), fields);
+    let resRecords = [];
+    for (let record of records) {
+        if (hasUiFields || hasExpandFields) {
+            record = Object.assign({}, emptyRecord, record); // 跟GraphQl一样，只返回fields中指定的字段，record中多查出的字段不返回
+            if (hasUiFields) {
+                record[UI_PREFIX] = await translateRecordToUI(record, objectName, uiFields, userSession);
+            }
+            if (hasExpandFields) {
+                let expandProps = await translateRecordToExpand(record, objectName, expandFields, userSession);
+                Object.assign(record, expandProps);
+            }
+        }
+        record = _.omit(record, omitFields);
+        resRecords.push(record);
+    }
+    return resRecords;
+}
+
+module.exports = {
+    translateRecords
+}

package/utils.js

@@ -0,0 +1,150 @@
+/*
+ * @Author: sunhaolin@hotoa.com
+ * @Date: 2023-02-06 16:44:55
+ * @LastEditors: 殷亮辉 yinlianghui@hotoa.com
+ * @LastEditTime: 2024-03-12 16:52:36
+ * @Description: 
+ */
+
+const moment = require('moment');
+const _ = require("underscore");
+const { getSteedosSchema } = require('@steedos/objectql');
+
+function formatFileSize(fileSize) {
+    var rev, unit;
+    rev = fileSize / 1024.00;
+    unit = 'KB';
+    if (rev > 1024.00) {
+        rev = rev / 1024.00;
+        unit = 'MB';
+    }
+    if (rev > 1024.00) {
+        rev = rev / 1024.00;
+        unit = 'GB';
+    }
+    return rev.toFixed(2) + unit;
+};
+
+function getFileStorageName(type) {
+    switch (type) {
+        case 'avatar':
+            return 'avatars'
+        case 'image':
+            return 'images'
+        case 'file':
+            return 'files'
+        default:
+            break;
+    }
+};
+
+function formatBasicFieldValue(valueType, field, value, objectConfig, userSession) {
+    switch (valueType) {
+        case 'text':
+        case 'textarea':
+        case 'html_text':
+        case 'color':
+        case 'autonumber':
+        case 'url':
+        case 'email':
+        case 'html':
+        case 'markdown':
+        case 'code':
+            return value || "";
+        case 'boolean':
+            return value ? "√" : ""
+        case 'date':
+            return value ? moment.utc(value).format("YYYY-MM-DD") : '';
+        case 'datetime':
+            return value ? moment(value).utcOffset(userSession.utcOffset || 8).format("YYYY-MM-DD HH:mm") : '';
+        case 'time':
+            return value ? moment.utc(value).format("HH:mm") : '';
+        case 'number':
+        case 'currency':
+            return numberToString(value, field.scale, field.enable_thousands === false);
+        case 'percent':
+            const str = numberToString(value * 100, field.scale, field.enable_thousands === false);
+            return str ? `${str}%` : ''
+        case 'password':
+            return _.isString(value) ? "******" : ""
+        default:
+            // console.log(field)
+            console.error(
+                `Graphql Display: need to handle new field type ${field.type} for ${objectConfig.name}.`
+            );
+            return value || "";
+    }
+}
+
+function numberToString(number, scale, notThousands = false) {
+    if (typeof number === "number") {
+        number = number.toString();
+    }
+    if (!number) {
+        return '';
+    }
+    if (number !== "NaN") {
+        if (scale || scale === 0) {
+            number = Number(number).toFixed(scale);
+        }
+        if (!notThousands) {
+            if (!(scale || scale === 0)) {
+                // 没定义scale时，根据小数点位置算出scale值
+                let regDots = number.match(/\.(\d+)/);
+                scale = regDots && regDots[1] && regDots[1].length
+                if (!scale) {
+                    scale = 0;
+                }
+            }
+            let reg = /(\d)(?=(\d{3})+\.)/g;
+            if (scale === 0) {
+                reg = /(\d)(?=(\d{3})+\b)/g;
+            }
+            number = number.replace(reg, '$1,');
+        }
+        return number;
+    } else {
+        return "";
+    }
+}
+
+async function callObjectServiceAction(actionName, userSession, data) {
+    const broker = getSteedosSchema().broker;
+    return broker.call(actionName, data, { meta: { user: userSession } })
+}
+
+// 获取object元数据
+function getLocalService(objectApiName) {
+    let steedosSchema = getSteedosSchema();
+    return steedosSchema.broker.getLocalService(getObjectServiceName(objectApiName));
+}
+
+function correctName(name) {
+    return name.replace(/\./g, "_").replace(/\$/g, "_");
+}
+
+function _getRelatedType(relatedFieldName, relatedObjName) {
+    return `${relatedFieldName}(fields: [String], filters: JSON, top: Int, skip: Int, sort: String): [${relatedObjName}] `;
+}
+
+function getObjectServiceName(objectApiName){
+    return `@${objectApiName}`;
+}
+
+function getGraphqlServiceName(){
+    return 'graphql';
+}
+
+
+module.exports = {
+    formatFileSize,
+    getFileStorageName,
+    formatBasicFieldValue,
+    numberToString,
+    callObjectServiceAction,
+    getLocalService,
+    correctName,
+    _getRelatedType,
+    getObjectServiceName,
+    getGraphqlServiceName
+}