@steedos/objectql 2.2.50 → 2.2.51-beta.4

package/src/services/objectServiceDispatcher.ts

@@ -1,209 +0,0 @@
-class ObjectServiceDispatcher {
-    objectApiName: string;
-    serviceName: string;
-    broker: any;
-    metadataBroker: any;
-
-    constructor(objectApiName) {
-        const schema = require('../types/schema');
-        this.objectApiName = objectApiName
-        this.serviceName = `@${objectApiName}`;
-        this.broker = schema.getSteedosSchema().broker;
-        this.metadataBroker = schema.getSteedosSchema().metadataBroker;
-    }
-
-    private async callMetadataObjectServiceAction(action, params?){
-        const actionFullName = `objects.${action}`
-        const result = await this.metadataBroker.call(actionFullName, params);
-        return result;
-    }
-
-    private getActionFullName(method: string){
-        return `${this.serviceName}.${method}`
-    }
-
-    private async callAction(method: string, params?){
-        const actionFullName = this.getActionFullName(method);
-        if(!params){
-            params = {};
-        }
-        const opts = {
-            meta: {
-                user: params.userSession
-            }
-        };
-
-        delete params.userSession;
-        const result = await this.broker.call(actionFullName, params, opts);
-        return result;
-    }
-
-    async aggregate(query, externalPipeline, userSession?) {
-        return await this.callAction(`aggregate`, {query, externalPipeline, userSession});
-    }
-
-    async find(query, userSession?) {
-        return await this.callAction(`find`, {...query, userSession});
-    }
-
-    async findOne(id, query, userSession?) {
-        return await this.callAction(`findOne`, {id, query, userSession});
-    }
-
-    async insert(doc, userSession?) {
-        return await this.callAction(`insert`, {doc, userSession});
-    }
-
-    async update(id, doc, userSession?) {
-        return await this.callAction(`update`, {id, doc, userSession});
-    }
-
-    async updateOne(id, doc, userSession?) {
-        return await this.callAction(`updateOne`, {id, doc, userSession});
-    }
-
-    async updateMany(queryFilters, doc, userSession?) {
-        return await this.callAction(`updateMany`, {queryFilters, doc, userSession});
-    }
-
-    async delete(id, userSession?) {
-        return await this.callAction(`delete`, {id, userSession});
-    }
-
-    async directAggregate(query, externalPipeline: any[], userSession) {
-        return await this.callAction(`directAggregate`, {query, externalPipeline, userSession});
-    }
-
-    async directAggregatePrefixalPipeline(query, prefixalPipeline: any[], userSession?) {
-        return await this.callAction(`directAggregatePrefixalPipeline`, {query, prefixalPipeline, userSession});
-    }
-
-    async directFind(query, userSession) {
-        return await this.callAction(`directFind`, {...query, userSession});
-    }
-
-    async directInsert(doc, userSession?) {
-        return await this.callAction(`directInsert`, {doc, userSession});
-    }
-
-    async directUpdate(id, doc, userSession?) {
-        return await this.callAction(`directUpdate`, {id, doc, userSession});
-    }
-
-    async directDelete(id, userSession) {
-        return await this.callAction(`directDelete`, {id, userSession});
-    }
-
-    async count(query, userSession){
-        return await this.callAction(`count`, {...query, userSession});
-    }
-
-    async getField(fieldApiName: string) {
-        return await this.callAction(`getField`, {fieldApiName});
-    }
-
-    async getFields(){
-        return await this.callAction(`getFields`);
-    }
-
-    async getNameFieldKey(){
-        return await this.callAction(`getNameFieldKey`);
-    }
-
-    async toConfig() {
-        return await this.callAction(`toConfig`);
-    }
-
-    async getUserObjectPermission(userSession){
-        const permission = await this.callAction(`getUserObjectPermission`, {userSession});
-        return permission;
-    }
-
-    async isEnableAudit(){
-        return await this.callAction(`isEnableAudit`);
-    }
-
-    async _makeNewID(){
-        return await this.callAction(`_makeNewID`);
-    }
-
-    async getRecordAbsoluteUrl(){
-        return await this.callAction(`getRecordAbsoluteUrl`)
-    }
-
-    async getGridAbsoluteUrl(){
-        return await this.callAction(`getRecordAbsoluteUrl`)
-    }
-
-    async getDetails(){
-        return await this.callMetadataObjectServiceAction(`getDetails`, {objectApiName: this.objectApiName});
-    }
-
-    async getMasters(){
-        return await this.callMetadataObjectServiceAction(`getMasters`, {objectApiName: this.objectApiName});
-    }
-
-    async getLookupDetails(){
-        return await this.callMetadataObjectServiceAction(`getLookupDetails`, {objectApiName: this.objectApiName});
-    }
-
-    async getDetailsInfo(){
-        return await this.callMetadataObjectServiceAction(`getDetailsInfo`, {objectApiName: this.objectApiName});
-    }
-
-    async getMastersInfo(){
-        return await this.callMetadataObjectServiceAction(`getMastersInfo`, {objectApiName: this.objectApiName});
-    }
-
-    async getLookupDetailsInfo(){
-        return await this.callMetadataObjectServiceAction(`getLookupDetailsInfo`, {objectApiName: this.objectApiName});
-    }
-
-    async getRelationsInfo() {
-        return await this.callMetadataObjectServiceAction(`getRelationsInfo`, { objectApiName: this.objectApiName });
-    }
-
-    async getDetailPaths(){
-        return await this.callMetadataObjectServiceAction(`getDetailPaths`, {objectApiName: this.objectApiName});
-    }
-
-    async getMasterPaths(){
-        return await this.callMetadataObjectServiceAction(`getMasterPaths`, {objectApiName: this.objectApiName});
-    }
-
-    async getMaxDetailsLeave(paths?){
-        return await this.callMetadataObjectServiceAction(`getMaxDetailsLeave`, {objectApiName: this.objectApiName, paths});
-    }
-
-    async getMaxMastersLeave(paths?){
-        return await this.callMetadataObjectServiceAction(`getMaxMastersLeave`, {objectApiName: this.objectApiName, paths});
-    }
-
-    async getRecordPermissions(record, userSession){
-        return await this.callAction(`getRecordPermissions`, {record, userSession});
-    }
-
-    async getRecordView(userSession, context?) {
-        return await this.callAction(`getRecordView`, { userSession, context });
-    }
-
-    async createDefaultRecordView(userSession){
-        return await this.callAction(`createDefaultRecordView`, {userSession});
-    }
-
-    async getDefaultRecordView(userSession){
-        return await this.callAction(`getDefaultRecordView`, {userSession});
-    }
-
-    async getRelateds(){
-        return await this.callAction(`getRelateds`)
-    }
-
-    async refreshIndexes(){
-        return await this.callAction(`refreshIndexes`)
-    }
-}
-
-export function getObjectDispatcher(objectApiName): any {
-    return new ObjectServiceDispatcher(objectApiName);
-}

package/src/services/objectServiceFactory.ts

@@ -1,29 +0,0 @@
-import * as _ from 'underscore';
-import { getObjectServiceName } from './index';
-const objectService = require('../services/objectService');
-
-const LocalObjectServices = {};
-
-function onDestroyObjectService(objectApiName) {
-    const serviceName = getObjectServiceName(objectApiName);
-    delete LocalObjectServices[serviceName]
-}
-
-export async function createObjectService(broker, serviceName, objectConfig) {
-    if (LocalObjectServices[serviceName]) {
-        return;
-    }
-    let service = broker.createService({
-        name: serviceName,
-        mixins: [objectService],
-        settings: {
-            objectConfig: objectConfig,
-            onDestroyObjectService,
-        }
-    })
-    if (!broker.started) { //如果broker未启动则手动启动service
-        await broker._restartService(service)
-    }
-    LocalObjectServices[serviceName] = true;
-    return
-}

package/src/summary/core.ts

@@ -1,263 +0,0 @@
-import { getSteedosSchema, processFilters, getObjectConfig } from '../index';
-import { SteedosFieldSummaryTypeConfig, SteedosSummaryTypeValue, SteedosSummaryTypeBlankValue } from './type';
-import { getObjectQuotedByFieldSummaryConfigs, getObjectFieldSummaryConfigs } from './field_summary';
-import { runQuotedByObjectFieldFormulas } from '../formula';
-import { formatFiltersToODataQuery } from '@steedos/filters';
-import _ = require('lodash');
-import { JsonMap } from '@salesforce/ts-types';
-
-/**
- * 在所有字段引用关系（包括跨对象的字段引用关系）中找到引用了当前正在insert/update的对象字段的汇总字段并更新其字段值
- * @param objectName 当前正在insert/update的对象
- * @param recordId 当前正在insert/update的记录id
- * @param userSession 
- * @param fieldNames 传入该参数时，只查找和处理引用了该对象中这些指定字段的公式字段
- * @param quotedByConfigs 如果已经根据objectName和fieldNames查过相关配置了，请直接传入，可以避免重复查找，提高性能
- */
-export const runQuotedByObjectFieldSummaries = async function (objectName: string, recordId: string, previousDoc: any, userSession: any, options: {
-    fieldNames?: Array<string>,
-    quotedByConfigs?: Array<SteedosFieldSummaryTypeConfig>
-} = {}) {
-    let { fieldNames, quotedByConfigs } = options;
-    if (!quotedByConfigs) {
-        quotedByConfigs = await getObjectQuotedByFieldSummaryConfigs(objectName, fieldNames);
-    }
-    if (!quotedByConfigs.length) {
-        return;
-    }
-    for (const config of quotedByConfigs) {
-        await updateQuotedByObjectFieldSummaryValue(objectName, recordId, previousDoc, config, userSession);
-    }
-}
-
-const getSummaryAggregateGroupKey = (summary_type: SteedosSummaryTypeValue, summary_field: string) => {
-    return summary_type === SteedosSummaryTypeValue.COUNT ? SteedosSummaryTypeValue.COUNT : summary_field;
-}
-
-/**
- * 把累计汇总字段中需要聚合查询字段转换为aggregate函数需要的groups，
- * 比如聚合查找应付记录对象下合同_id为hNkuWqRmHtWaBvWpJ的所有记录，并可按sum,min,max,count来统计。
- * 将转换返回：
-[{
-    $group:
-    {
-        _id: "SUM",//因为只有一个分组，随便字义一个字符串常量写死就行
-        Money: { $max: "$Money" },//找到Money字段的最大值
-        total_amount: { $sum: "$total_amount" },//汇总合计total_amount字段值总合
-        total_count: { $sum: 1 }//这里是进行count计数统计,$sum值为1就表示计数
-    }
-}]
-* 从以上语法中可以看到支持多个聚合字段一起计算，目前只用到同时聚合一个字段计算。
- * @param summary_type
- * @param summary_field
- */
-export const getSummaryAggregateGroups = (summary_type: SteedosSummaryTypeValue, summary_field: string) => {
-    let group: any = {
-        _id: "summary_group"
-    };
-    const groupKey = getSummaryAggregateGroupKey(summary_type, summary_field);
-    switch (summary_type) {
-        case SteedosSummaryTypeValue.COUNT:
-            group[groupKey] = { $sum: 1 };
-            break;
-        case SteedosSummaryTypeValue.MAX:
-            group[groupKey] = { $max: `$${summary_field}` };
-            break;
-        case SteedosSummaryTypeValue.MIN:
-            group[groupKey] = { $min: `$${summary_field}` };
-            break;
-        case SteedosSummaryTypeValue.SUM:
-            group[groupKey] = { $sum: `$${summary_field}` };
-            break;
-        case SteedosSummaryTypeValue.AVG:
-            group[groupKey] = { $avg: `$${summary_field}` };
-            break;
-
-    }
-    return [{
-        $group: group
-    }];
-}
-
-/**
- * 新建或修改记录时，根据查到的引用了该记录相关字段汇总配置，重新计算字段值，并把计算结果更新到数据库相关记录中
- * @param objectName 当前修改的记录所属对象名称
- * @param recordId 当前修改的记录ID
- * @param fieldSummaryConfig 查到的引用了该记录所属对象的汇总字段配置之一
- * 执行类似以下的聚合查找语句，并把查找结果更新到要汇总的主表对象关联记录中。
- * 聚合查找应付记录对象下合同_id为hNkuWqRmHtWaBvWpJ的所有记录，并可按sum,min,max,count来统计。
- db.account_payable.aggregate([
-    {
-        $match: {
-            contractno: 'hNkuWqRmHtWaBvWpJ'
-        }
-    },
-    {
-        $group:
-        {
-            _id: "SUM",//因为只有一个分组，随便字义一个字符串常量写死就行
-            Money: { $max: "$Money" },//找到Money字段的最大值
-            total_amount: { $sum: "$total_amount" },//汇总合计total_amount字段值总合
-            total_count: { $sum: 1 }//这里是进行count计数统计,$sum值为1就表示计数
-        }
-    }
-])
-* 从以上语法中可以看到支持多个聚合字段一起计算，目前只用到同时聚合一个字段计算。
-* 以上语句返回的内容为：
-[{
-    "_id" : "SUM",
-    "Money" : 100,
-    "total_amount" : 33222,
-    "count" : 2.0
-}]
- */
-export const updateQuotedByObjectFieldSummaryValue = async (objectName: string, recordId: string, previousDoc: any, fieldSummaryConfig: SteedosFieldSummaryTypeConfig, userSession: any) => {
-    // console.log("===updateQuotedByObjectFieldSummaryValue===", objectName, recordId, JSON.stringify(fieldSummaryConfig));
-    const { reference_to_field } = fieldSummaryConfig;
-    const referenceToRecord = await getSteedosSchema().getObject(objectName).findOne(recordId, { fields: [reference_to_field] });
-    let referenceToId: string;
-    if(referenceToRecord){
-        referenceToId = referenceToRecord[reference_to_field];
-    }
-    let referenceToIds = [];
-    let previousReferenceToId = previousDoc && previousDoc[reference_to_field];
-    if(referenceToId){
-        referenceToIds.push(referenceToId);
-        if(previousReferenceToId && previousReferenceToId != referenceToId){
-            // 应该额外再判断子表中master_detail字段值是否变更了，如果变更了，则需要额外对变更前的记录做汇总
-            referenceToIds.push(previousReferenceToId);
-        }
-    }
-    else {
-        // 当子表中master_detail字段值为空，说明可能是直接删除了子表记录或者把子表记录的master_detail字段值修改为空了
-        // 这里要区别下原来是否有值，如果原来本来就是空就不需要进一步汇总了，如果原来不是空则还是要拿到原来的值进行汇总
-        if(previousReferenceToId){
-            referenceToIds.push(previousReferenceToId);
-        }
-    }
-    // console.log("===updateQuotedByObjectFieldSummaryValue===referenceToIds====", referenceToIds);
-    if(!referenceToIds.length){
-        return;
-    }
-    await updateReferenceTosFieldSummaryValue(referenceToIds, fieldSummaryConfig, userSession);
-}
-
-/**
- * 执行聚合计算，并把聚合汇总后的值更新到数据库中
- * @param referenceToIds 子表上的master_detail关联到主表对象的字段值集合，是多条子表记录上的关联id值组成的数组
- * @param fieldSummaryConfig 
- * @param userSession 
- */
-export const updateReferenceTosFieldSummaryValue = async (referenceToIds: Array<string> | Array<JsonMap>, fieldSummaryConfig: SteedosFieldSummaryTypeConfig, userSession: any) => {
-    // console.log("===updateReferenceTosFieldSummaryValue====referenceToIds, fieldSummaryConfig==", referenceToIds, fieldSummaryConfig);
-    const { reference_to_field, summary_type, summary_field, summary_object, object_name, summary_filters, field_name } = fieldSummaryConfig;
-    if (!_.isArray(referenceToIds)) {
-        referenceToIds = [referenceToIds];
-    }
-    // 需要使用aggregate来汇总计算
-    let aggregateGroups = getSummaryAggregateGroups(summary_type, summary_field);
-    // console.log("===updateReferenceTosFieldSummaryValue====aggregateGroups==", aggregateGroups);
-    for (let referenceToId of referenceToIds) {
-        if(typeof referenceToId !== "string"){
-            referenceToId = <string>referenceToId._id;
-        }
-        let referenceToFilters:any = [[reference_to_field, "=", referenceToId]];
-        let aggregateFilters:any = referenceToFilters;
-        if(summary_filters && summary_filters.length){
-            if(typeof summary_filters === "string"){
-                // 传入的过滤条件为odata字符串时，需要把aggregateFilters也解析为odata串并取AND
-                aggregateFilters = formatFiltersToODataQuery(referenceToFilters);
-                aggregateFilters = `(${aggregateFilters}) and (${summary_filters})`;
-            }
-            else{
-                const summaryObject = getObjectConfig(summary_object);
-                if(!summaryObject){
-                    throw new Error(`The summary_object '${summary_object}' of the field '${field_name}' on the object '${object_name}' is not found in the default datasource.`);
-                }
-                processFilters(summary_filters, summaryObject.fields);
-                aggregateFilters = [referenceToFilters, summary_filters];
-            }
-        }
-
-        if (userSession && aggregateFilters && !_.isString(aggregateFilters)) {
-            // 过滤器中支持userSession变量的写法，比如[["owner", "=", "{userId}"]]
-            aggregateFilters = formatFiltersToODataQuery(aggregateFilters, userSession);
-        }
-        // console.log("===aggregateFilters===", aggregateFilters);
-        const aggregateResults = await getSteedosSchema().getObject(summary_object).directAggregate({
-            filters: aggregateFilters
-        }, aggregateGroups);
-        // console.log("===aggregateResults===", aggregateResults);
-        if (aggregateResults && aggregateResults.length) {
-            const groupKey = getSummaryAggregateGroupKey(summary_type, summary_field);
-            let summarizedValue = aggregateResults[0][groupKey];
-            await updateReferenceToFieldSummaryValue(referenceToId, summarizedValue, fieldSummaryConfig, userSession);
-        }
-        else {
-            // 说明referenceToId对应的主表记录找不到了，可能被删除了，不用报错或其他处理
-            // 也可能是要汇总的子表记录全部删除了，或者不再有任何子表记录符合汇总字段过滤条件，这时应该重置汇总字段值
-            const masterRecord = await getSteedosSchema().getObject(object_name).findOne(referenceToId, { fields: ["_id"] });
-            if(masterRecord){
-                // sum和count类型直接按0值处理而不是空值，min/max类型（包括数值和日期时间字段）显示为空值
-                let defaultValue = SteedosSummaryTypeBlankValue[summary_type];
-                await updateReferenceToFieldSummaryValue(referenceToId, defaultValue, fieldSummaryConfig, userSession);
-            }
-
-        }
-    }
-    // 这里特意重新遍历一次referenceToIds而不是直接在updateReferenceToFieldSummaryValue函数中每次更新一条记录后立即处理被引用字段的级联变更，见：公式或汇总触发级联重算时，数据类型变更可能会造成无法重算 #965
-    await updateQuotedByReferenceTosForSummaryType(referenceToIds, fieldSummaryConfig, userSession);
-}
-
-export const updateReferenceToFieldSummaryValue = async (referenceToId: string, value: any, fieldSummaryConfig: SteedosFieldSummaryTypeConfig, userSession: any) => {
-    const { field_name, object_name } = fieldSummaryConfig;
-    let setDoc = {};
-    setDoc[field_name] = value;
-    await getSteedosSchema().getObject(object_name).directUpdate(referenceToId, setDoc);
-}
-
-export const updateQuotedByReferenceTosForSummaryType = async (referenceToIds: Array<string> | Array<JsonMap>, fieldSummaryConfig: SteedosFieldSummaryTypeConfig, userSession: any) => {
-    const { field_name, object_name } = fieldSummaryConfig;
-    if (!_.isArray(referenceToIds)) {
-        referenceToIds = [referenceToIds];
-    }
-    const fieldNames = [field_name];
-    for (let referenceToId of referenceToIds) {
-        if(typeof referenceToId !== "string"){
-            referenceToId = <string>referenceToId._id;
-        }
-        // console.log("===updateQuotedByReferenceTosForSummaryType====object_name, referenceToId, field_name===", object_name, referenceToId, field_name);
-        // 汇总字段修改后，需要找到引用了该字段的其他公式字段并更新其值
-        await runQuotedByObjectFieldFormulas(object_name, <string>referenceToId, userSession, {
-            fieldNames
-        });
-        // 汇总字段修改后，需要找到引用了该字段的其他汇总字段并更新其值
-        await runQuotedByObjectFieldSummaries(object_name, <string>referenceToId, null, userSession, {
-            fieldNames
-        });
-    }
-}
-
-/**
- * 新建主表记录时需要处理汇总字段默认值，只有insert主表记录才需要调用该函数
- * @param objectName 
- * @param recordId 
- */
-export const runCurrentObjectFieldSummaries = async function (objectName: string, recordId: string) {
-    const configs = await getObjectFieldSummaryConfigs(objectName);
-    if (!configs.length) {
-        return;
-    }
-    let setDoc = {};
-    for (const config of configs) {
-        // sum和count类型直接按0值处理而不是空值，min/max类型（包括数值和日期时间字段）显示为空值
-        let defaultValue = SteedosSummaryTypeBlankValue[config.summary_type];
-        if(defaultValue != null){
-            setDoc[config.field_name] = defaultValue;
-        }
-    }
-    if(_.isEmpty(setDoc)){
-        return;
-    }
-    await getSteedosSchema().getObject(objectName).directUpdate(recordId, setDoc);
-}

package/src/summary/field_summary.ts

@@ -1,71 +0,0 @@
-import { SteedosFieldSummaryTypeConfig } from './type';
-import { SteedosFieldFormulaTypeConfig } from '../formula';
-import { getSteedosSchema } from '../types/schema';
-
-
-export const getFieldSummaryConfigs = async(objectApiName?, fieldApiName?): Promise<Array<SteedosFieldSummaryTypeConfig>> => {
-    return await getSteedosSchema().metadataBroker.call(`objects.getObjectFieldSummaryConfigs`, {objectApiName, fieldApiName})
-}
-
-export const getFieldSummaryConfig = async (fieldApiFullName: string): Promise<SteedosFieldSummaryTypeConfig> => {
-    return await getSteedosSchema().metadataBroker.call(`objects.getObjectFieldSummaryConfig`, {fieldApiFullName})
-}
-
-/**
- * 获取对象本身的累计汇总配置
- * 不传入fieldName时取objectName关联的所有累计汇总配置
- * @param objectName 
- * @param fieldName 
- */
-export const getObjectFieldSummaryConfigs = async(objectName: string, fieldName?: string): Promise<Array<SteedosFieldSummaryTypeConfig>> => {
-    return await getFieldSummaryConfigs(objectName, fieldName);;
-}
-
-
-/**
- * 获取对象在哪些累计汇总中被引用
- * 不传入fieldNames时取objectName关联的所有累计汇总配置
- * @param objectName 
- * @param fieldNames 
- */
-export const getObjectQuotedByFieldSummaryConfigs = async (objectName: string, fieldNames?: Array<string>): Promise<Array<SteedosFieldSummaryTypeConfig>> => {
-    const configs = await getFieldSummaryConfigs(); //TODO 此处代码需要优化，取了所有配置。此处代码迁移到metadata objects services
-    return configs.filter((config: SteedosFieldSummaryTypeConfig) => {
-        const summaryObjectName = config.summary_object;
-        if(summaryObjectName){
-            const summaryFieldName = config.summary_field;
-            if(summaryObjectName === objectName){
-                if (fieldNames && fieldNames.length) {
-                    if(fieldNames.indexOf(summaryFieldName) > -1){
-                        return true;
-                    }
-                    const summaryFilters = config.summary_filters;
-                    if(summaryFilters && summaryFilters.length){
-                        // 如果汇总过滤条件中正好包括了fieldNames中一某个字段的话，也需要重新触发该汇总字段重新计算
-                        return !!fieldNames.find((fieldName)=>{
-                            return new RegExp(`\\b${fieldName}\\b`).test(JSON.stringify(summaryFilters))
-                        })
-                    }
-                    return false;
-                }
-                else{
-                    return true;
-                }
-            }
-            else{
-                return false;
-            }
-        }
-        else {
-            return false;
-        }
-    });
-}
-
-/**
- * 获取参数config在哪些累计汇总中被引用
- * @param config 
- */
-export const getQuotedByFieldSummaryConfigs = async(config: SteedosFieldFormulaTypeConfig): Promise<Array<SteedosFieldSummaryTypeConfig>> => {
-    return await getObjectQuotedByFieldSummaryConfigs(config.object_name, [config.field_name]);
-}

package/src/summary/index.ts

@@ -1,96 +0,0 @@
-import { SteedosObjectTypeConfig, getObjectConfigs } from '../types';
-import { SteedosFieldSummaryTypeConfig, SteedosSummaryTypeValue, SteedosSummaryDataTypeValue, SupportedSummaryFieldTypes } from './type';
-import { isCodeObject } from '../util';
-import { isFormulaFieldQuotingObjectAndFields } from '../formula';
-import _ = require('lodash')
-
-export * from './type'
-export * from './field_summary'
-export * from './core'
-export * from './recompute'
-
-/**
- * 校验summaryConfig合法性并设置其reference_to_field、data_type属性值
- * 因为getObjectConfigs拿到的对象肯定不包括被禁用和假删除的对象，所以不需要额外判断相关状态
- * @param summaryConfig 
- */
-export const initSummaryConfig = async(summaryConfig: SteedosFieldSummaryTypeConfig) => {
-    const objectConfigs: Array<SteedosObjectTypeConfig> = getObjectConfigs("default");
-    const { summary_object, field_name, object_name } = summaryConfig;
-    let summaryObject = _.find(objectConfigs, (item) => {
-        return item.name === summary_object;
-    });
-    if (!summaryObject) {
-        // 如果不是零代码对象，直接报错，否则直接返回，待相关零代码对象加载进来时，会再进入该函数
-        if(isCodeObject(summary_object)){
-            throw new Error(`The summary_object '${summary_object}' of the field '${field_name}' on the object '${object_name}' is not found in the default datasource.`);
-        }
-        else{
-            return;
-        }
-    }
-
-    const referenceToField = _.find(summaryObject.fields, (item) => {
-        return item.type === "master_detail" && item.reference_to === object_name;
-    });
-    if (!referenceToField) {
-        throw new Error(`Can't fount a master_detail type field that reference_to the master object '${object_name}' on the summary_object '${summary_object}'.`);
-    }
-    summaryConfig.reference_to_field = referenceToField.name;
-    if(!summaryConfig.data_type){
-        throw new Error(`Invalid field type summary '${field_name}' on the object '${object_name}', miss data_type property.`);
-    }
-    const dataType = await getSummaryDataType(summaryConfig, summaryObject);
-    if(dataType !== summaryConfig.data_type){
-        throw new Error(`The data_type of the summary field '${field_name}' on the object '${object_name}' is incorrect, it should be '${dataType}' but is set to '${summaryConfig.data_type}'.`);
-    }
-    summaryConfig.data_type = dataType;
-}
-
-export const getSummaryDataType = async (summaryConfig: SteedosFieldSummaryTypeConfig, summaryObject: SteedosObjectTypeConfig) => {
-    const { summary_object, summary_type, summary_field, field_name, object_name } = summaryConfig;
-    let result: SteedosSummaryDataTypeValue;
-    let needSummaryField = true;
-    if(summary_type === SteedosSummaryTypeValue.COUNT){
-        // 如果是COUNT类型，则忽然掉要聚合的字段
-        needSummaryField = false;
-    }
-    else if(!summary_field){
-        throw new Error(`You have to set a summary_field property for the field '${field_name}' of the object '${object_name}' when the summary_type is not set to 'count'.`);
-    }
-    if (summary_field && needSummaryField) {
-        const field = summaryObject.fields[summary_field];
-        if (field) {
-            let fieldType = field.type;
-            if(fieldType === "formula"){
-                // 要聚合的是公式，则其数据类型为公式字段的数据类型
-                // 因公式字段可能再引用当前汇总字段，所以要判断下不允许互相引用
-                fieldType = field.data_type;
-                const isQuotingTwoWay = await isFormulaFieldQuotingObjectAndFields(summary_object, summary_field, object_name, [field_name]);
-                if(isQuotingTwoWay){
-                    throw new Error(`Do not refer to each other, the field '${field_name}' of the master object '${object_name}' is summarizing a formula type summary_field '${summary_field}' of the detail object '${summary_object}', but the formula type field of the detail object exactly quoting the field of the master object, which is not allowed.`);
-                }
-            }
-            if(fieldType === "summary"){
-                // 要聚合的是汇总字段，则其数据类型为汇总字段的数据类型
-                // 因两个对象之前不可能互为子表关系，所以汇总字段不存在互为汇总聚合关系，不需要进一步判断它们是否互相引用
-                fieldType = field.data_type;
-            }
-            if(!isSummaryFieldTypeSupported(summary_type, fieldType)){
-                throw new Error(`The summary data_type '${fieldType}' on the field '${field_name}' of the object '${object_name}' is not supported for the summary_type '${summary_type}' which only support these types: ${SupportedSummaryFieldTypes[summary_type]}.`);
-            }
-            result = <SteedosSummaryDataTypeValue>fieldType;
-        }
-        else {
-            throw new Error(`The summary_field '${summary_field}' is not a field of the summary_object '${summary_object}'.`);
-        }
-    }
-    else {
-        result = SteedosSummaryDataTypeValue.Number;
-    }
-    return result;
-}
-
-export const isSummaryFieldTypeSupported = (summaryType: string, summaryFieldType: string) => {
-    return !!(SupportedSummaryFieldTypes[summaryType] && SupportedSummaryFieldTypes[summaryType].indexOf(summaryFieldType) > -1)
-}