@steedos/objectql 2.2.50-beta.7 → 2.2.51-beta.2

package/src/dynamic-load/preload_data.ts

@@ -1,104 +0,0 @@
-import { addObjectFieldConfig } from './field'
-import { addObjectButtonsConfig } from './button'
-import { addAppConfig, loadObjectLayoutMetadata, SteedosDataSourceType } from '..';
-import { addTabConfig } from './tabs';
-import { registerRestrictionRules } from '../metadata-register/restrictionRules';
-import { registerShareRules } from '../metadata-register/shareRules';
-import { registerPermissionFields } from '../metadata-register/permissionFields';
-import { getSteedosSchema } from '../types/schema';
-
-declare var Creator: any;
-
-export const preloadDBObjectFields = async function(datasource: SteedosDataSourceType){
-    const tableName = "object_fields";
-    if(datasource.name === 'meteor'){
-        Creator.Collections[tableName] = Creator.createCollection({name: tableName});
-    }
-    let fields: any = await datasource.find(tableName, {});
-    fields.forEach(element => {
-        addObjectFieldConfig(element.object, element);
-    });
-}
-
-export const preloadDBObjectButtons = async function(datasource: SteedosDataSourceType){
-    const tableName = "object_actions";
-    if(datasource.name === 'meteor'){
-        Creator.Collections[tableName] = Creator.createCollection({name: tableName});
-    }
-    let buttons: any = await datasource.find(tableName , {filters: ['is_enable','=',true]});
-    buttons.forEach(element => {
-        addObjectButtonsConfig(element.object, element);
-    });
-}
-
-export const preloadDBApps = async function(datasource: SteedosDataSourceType){
-    const tableName = "apps";
-    if(datasource.name === 'meteor'){
-        Creator.Collections[tableName] = Creator.createCollection({name: tableName});
-    }
-    let apps: any = await datasource.find(tableName , {filters: ['visible','=',true]});
-    for await (const element of apps) {
-        await addAppConfig(element, `~database-${tableName}`);
-    }
-}
-
-export const preloadDBTabs = async function(datasource: SteedosDataSourceType){
-    const tableName = "tabs";
-    if(datasource.name === 'meteor'){
-        Creator.Collections[tableName] = Creator.createCollection({name: tableName});
-    }
-    let tabs: any = await datasource.find(tableName, {});
-    for await (const element of tabs) {
-        await addTabConfig(element, `~database-${tableName}`);
-    }
-}
-
-export const preloadDBObjectLayouts = async function(datasource: SteedosDataSourceType){
-    const tableName = "object_layouts";
-    if(datasource.name === 'meteor'){
-        Creator.Collections[tableName] = Creator.createCollection({name: tableName});
-    }
-    let objectLayouts: any = await datasource.find(tableName, {});
-    for await (const element of objectLayouts) {
-        await loadObjectLayoutMetadata(element, `~database-${tableName}`);
-    }
-}
-
-
-export const preloadDBRestrictionRules = async function (datasource: SteedosDataSourceType) {
-    const schema = getSteedosSchema();
-    const tableName = "restriction_rules";
-    if (datasource.name === 'meteor') {
-        Creator.Collections[tableName] = Creator.createCollection({ name: tableName });
-    }
-    let records: any = await datasource.find(tableName, {});
-
-    for await (const element of records) {
-        await registerRestrictionRules.register(schema.broker, `~database-${tableName}`, element);
-    }
-}
-
-export const preloadDBShareRules = async function (datasource: SteedosDataSourceType) {
-    const schema = getSteedosSchema();
-    const tableName = "share_rules";
-    if (datasource.name === 'meteor') {
-        Creator.Collections[tableName] = Creator.createCollection({ name: tableName });
-    }
-    let records: any = await datasource.find(tableName, {});
-
-    for await (const element of records) {
-        await registerShareRules.register(schema.broker, `~database-${tableName}`, element);
-    }
-}
-
-export const preloadDBPermissionFields = async function (datasource: SteedosDataSourceType) {
-    const schema = getSteedosSchema();
-    const tableName = "permission_fields";
-    if (datasource.name === 'meteor') {
-        Creator.Collections[tableName] = Creator.createCollection({ name: tableName });
-    }
-    let records: any = await datasource.find(tableName, {});
-    if (records && records.length > 0) {
-        await registerPermissionFields.mregister(schema.broker, `~database-${tableName}`, records);
-    }
-}

package/src/dynamic-load/profile.ts

@@ -1,90 +0,0 @@
-import { SteedosProfileTypeConfig } from '../ts-types';
-import { getSteedosSchema } from '../types/schema';
-var util = require('../util');
-var clone = require('clone');
-var _ = require('underscore');
-const PERMISSIONS = {
-  allowEdit: false,
-  allowDelete: false,
-  allowRead: true,
-};
-
-const BASERECORD = {
-  is_system: true,
-  type: "profile",
-  record_permissions: PERMISSIONS
-};
-
-const DEFAULTRECORD = {
-    password_history: "3",
-    max_login_attempts: "10",
-    lockout_interval: "15",
-}
-
-const STANDARD_PROFILES = {
-    admin: {_id: 'admin', name: 'admin',label: 'admin', ...DEFAULTRECORD, ...BASERECORD},
-    user: {_id: 'user', name: 'user',label: 'user', ...DEFAULTRECORD, ...BASERECORD},
-    supplier: {_id: 'supplier', name: 'supplier',label: 'supplier', ...DEFAULTRECORD, ...BASERECORD},
-    customer: {_id: 'customer', name: 'customer', label: 'customer', ...DEFAULTRECORD, ...BASERECORD}
-}
-
-// const PROFILES_KEY = 'STANDARD_PROFILES';
-
-const getStandardProfile = function(name){
-    return getStandardProfiles()[name];
-}
-
-const getStandardProfiles = function(){
-    return clone(STANDARD_PROFILES);
-}
-
-const addProfile = async function(json: SteedosProfileTypeConfig, serviceName: string){
-    if(!json.name){
-        throw new Error('missing attribute name: ' + (json as any)?.__filename)
-    }
-
-    let profileConfig = null;
-
-    if(_.include(_.keys(STANDARD_PROFILES), json.name)){
-        profileConfig = Object.assign({}, getStandardProfile(json.name), json, clone(BASERECORD))
-        // addConfig(PROFILES_KEY, Object.assign({}, getStandardProfile(json.name), json, clone(BASERECORD)));
-    }else{
-        profileConfig = Object.assign({}, clone(DEFAULTRECORD), json, clone(BASERECORD))
-        // addConfig(PROFILES_KEY, Object.assign({}, clone(DEFAULTRECORD), json, clone(BASERECORD)));
-    }
-    const schema = getSteedosSchema();
-    await schema.metadataRegister?.addProfile(serviceName, profileConfig);
-}
-
-export const loadStandardProfiles = async function(serviceName: string){
-    const schema = getSteedosSchema();
-    const keys = _.keys(STANDARD_PROFILES);
-    for (const key of keys) {
-        const standardProfile = STANDARD_PROFILES[key];
-        await schema.metadataRegister.addProfile(serviceName, standardProfile);
-    }
-}
-
-export const loadSourceProfiles = async function (filePath: string, serviceName: string){
-    let profiles = util.loadProfiles(filePath)
-    for (const profile of profiles) {
-       await addProfile(profile, serviceName);
-    }
-}
-
-export const getSourceProfile = async function(name){
-    const schema = getSteedosSchema();
-    const profile = await schema.metadataRegister.getProfile(name);
-    return profile?.metadata
-}
-
-export const getSourceProfilesKeys = async function(){
-    const profiles = await getSourceProfiles();
-    return _.pluck(profiles, 'name');
-}
-
-export const getSourceProfiles = async function(){
-    const schema = getSteedosSchema();
-    const profiles = await schema.metadataRegister.getProfiles();
-    return  profiles ? _.pluck(profiles, 'metadata') : [];
-}

package/src/dynamic-load/query.ts

@@ -1,22 +0,0 @@
-import { LoadQueryFile } from '@steedos/metadata-core';
-import { registerQuery } from '../metadata-register/query';
-import { getSteedosSchema } from '../types'
-const loadQueryFile = new LoadQueryFile();
-
-export const registerPackageQueries = async (packagePath: string, packageServiceName: string)=>{
-    const packageQueries = loadQueryFile.load(packagePath);
-    const schema = getSteedosSchema();
-    const data = [];
-    for (const apiName in packageQueries) {
-        const query = packageQueries[apiName];
-        data.push(Object.assign(query, {
-            is_system: true, record_permissions: {
-            allowEdit: false,
-            allowDelete: false,
-            allowRead: true,
-        }}))
-    }
-    if (data.length > 0) {
-        await registerQuery.mregister(schema.broker, packageServiceName, data)
-    }
-}

package/src/dynamic-load/restrictionRules.ts

@@ -1,23 +0,0 @@
-import { LoadRestrictionRules } from '@steedos/metadata-core';
-import { registerRestrictionRules } from '../metadata-register/restrictionRules';
-import { getSteedosSchema } from '../types'
-const loadRestrictionRules = new LoadRestrictionRules();
-
-export const registerPackageRestrictionRules = async (packagePath: string, packageServiceName: string) => {
-    const metadata = loadRestrictionRules.load(packagePath);
-    const schema = getSteedosSchema();
-    const data = [];
-    for (const apiName in metadata) {
-        const item = metadata[apiName];
-        data.push(Object.assign(item, {
-            is_system: true, record_permissions: {
-                allowEdit: false,
-                allowDelete: false,
-                allowRead: true,
-            }
-        }));
-    }
-    if (data.length > 0) {
-        await registerRestrictionRules.mregister(schema.broker, packageServiceName, data)
-    }
-}

package/src/dynamic-load/role.ts

@@ -1,46 +0,0 @@
-import { addConfig, getConfig, getConfigs } from '../types';
-const _ = require('underscore');
-const clone = require('clone');
-var util = require('../util');
-
-const PERMISSIONS = {
-    allowEdit: false,
-    allowDelete: false,
-    allowRead: true,
-};
-
-const BASERECORD = {
-    is_system: true,
-    type: "role",
-    record_permissions: PERMISSIONS
-};
-
-const ROLES_KEY = 'ROLES';
-
-const addRole = function(json){
-    if(!json.name){
-        throw new Error('missing attribute name');
-    }
-    if(!json.api_name){
-        throw new Error('missing attribute api_name');
-    }
-    addConfig(ROLES_KEY, Object.assign({}, json, clone(BASERECORD), {_id: json.api_name}));
-}
-export const getSourceRolesKeys = function(){
-    return _.pluck(getSourceRoles(), 'api_name');
-}
-
-export const getSourceRole = function(api_name){
-    return clone(getConfig(ROLES_KEY, api_name));
-}
-
-export const getSourceRoles = function(){
-    return clone(getConfigs(ROLES_KEY)) || [];
-}
-
-export const loadSourceRoles = function (filePath: string){
-    let roles = util.loadRoles(filePath);
-    roles.forEach(element => {
-        addRole(element);
-    });
-}

package/src/dynamic-load/shareRules.ts

@@ -1,23 +0,0 @@
-import { LoadShareRules } from '@steedos/metadata-core';
-import { registerShareRules } from '../metadata-register/shareRules';
-import { getSteedosSchema } from '../types'
-const loadShareRules = new LoadShareRules();
-
-export const registerPackageShareRules = async (packagePath: string, packageServiceName: string) => {
-    const metadata = loadShareRules.load(packagePath);
-    const schema = getSteedosSchema();
-    const data = [];
-    for (const apiName in metadata) {
-        const item = metadata[apiName];
-        data.push(Object.assign(item, {
-            is_system: true, record_permissions: {
-                allowEdit: false,
-                allowDelete: false,
-                allowRead: true,
-            }
-        }))
-    }
-    if (data.length > 0) {
-        await registerShareRules.mregister(schema.broker, packageServiceName, data)
-    }
-}

package/src/dynamic-load/tab.ts

@@ -1,17 +0,0 @@
-import { LoadTabFile } from '@steedos/metadata-core';
-import { registerTab } from '../metadata-register/tab';
-import { getSteedosSchema } from '../types'
-const loadTabFile = new LoadTabFile();
-
-export const registerPackageTabs = async (packagePath: string, packageServiceName: string)=>{
-    const tabs = loadTabFile.load(packagePath);
-    const schema = getSteedosSchema();
-    for (const apiName in tabs) {
-        const tab = tabs[apiName];
-        await registerTab.register(schema.broker, packageServiceName, Object.assign(tab, {is_system:true, record_permissions: {
-            allowEdit: false,
-            allowDelete: false,
-            allowRead: true,
-        }}))
-    }
-}

package/src/dynamic-load/tabs.ts

@@ -1,13 +0,0 @@
-import { getSteedosSchema } from "..";
-/***
- * 此文件不再维护，请使用tab.ts
- */
-export const addTabConfig = async (tabConfig: any, serviceName: string = '') => {
-    const schema = getSteedosSchema();
-    await schema.metadataRegister?.addTab(serviceName, tabConfig);
-}
-
-export const removeTab = async (tabApiName) => {
-    const schema = getSteedosSchema();
-    await schema.metadataRegister?.removeTab(tabApiName);
-}

package/src/dynamic-load/translations.ts

@@ -1,54 +0,0 @@
-import { getSteedosSchema } from '../types/schema';
-import path = require('path');
-import * as _ from 'underscore';
-// import { loadCoreTranslations } from '@steedos/i18n'
-import { getMD5 } from '../util';
-
-var util = require('../util');
-
-const brokeEmitEvents = async(filePath)=>{
-    let schema = getSteedosSchema();
-    await schema.broker?.emit(`translations.change`, {
-        filePath
-    });
-}
-
-const addTranslation = async (key, data)=>{
-    return await getSteedosSchema().metadataBroker?.call('translations.addTranslation', {
-        key, data
-    })
-}
-
-// export const addCoreTranslations = async  (filePath: string)=>{
-//     let coreTranslations = loadCoreTranslations(filePath);
-//     for (const element of coreTranslations) {
-//         try {
-//             await addTranslation(getMD5(element.__filename), element)
-//         } catch (error) {
-//             console.error(`addTranslation error`, error.message)
-//         }
-//     }
-// }
-
-export const addTranslationsFiles = async (filePath: string)=>{
-    if(!path.isAbsolute(filePath)){
-        throw new Error(`${filePath} must be an absolute path`);
-    }
-
-    let translations = util.loadTranslations(filePath)
-    for (const element of translations) {
-        try {
-            await addTranslation(getMD5(element.__filename), element)
-        } catch (error) {
-            console.error(`addTranslation error`, error.message)
-        }
-    }
-    if (translations && translations.length > 0) {
-        await brokeEmitEvents(filePath)
-    }
-}
-
-export const getTranslations = async ()=>{
-    const metadataObjectTranslations = await getSteedosSchema().metadataBroker.call('translations.getTranslations')
-    return _.pluck(metadataObjectTranslations, 'metadata')
-}

package/src/dynamic-load/trigger.ts

@@ -1,236 +0,0 @@
-import { getDataSource, SteedosListenerConfig } from '../types'
-import { Dictionary } from '@salesforce/ts-types';
-import { getObjectConfig } from '../types'
-import { getMD5, JSONStringify, transformListenersToTriggers } from '../util'
-import _ = require('lodash');
-var util = require('../util');
-var clone = require('clone');
-import { _TRIGGERKEYS } from '../types';
-
-const _lazyLoadListeners: Dictionary<any> = {};
-
-// 用于存放通配触发器，即listenTo的值是通配符
-const _patternListerners: Dictionary<any> = {}; 
-
-const addLazyLoadListeners = function(objectName: string, json: SteedosListenerConfig){
-    if(!_lazyLoadListeners[objectName]){
-        _lazyLoadListeners[objectName] = []
-    }
-    _lazyLoadListeners[objectName].push(json)
-
-    if (isPatternListener(json)) {
-        if(!_patternListerners[objectName]){
-            _patternListerners[objectName] = []
-        }
-        _patternListerners[objectName].push(json)
-    }
-}
-
-export const getLazyLoadListeners = function(objectName?: string){
-    if (objectName) {
-        return _lazyLoadListeners[objectName]
-    } else {
-        return _lazyLoadListeners;
-    }
-}
-
-export const loadObjectLazyListenners = function(objectName: string){
-    let listenners = getLazyLoadListeners(objectName);
-    _.each(listenners, function(listenner){
-        addObjectListenerConfig(clone(listenner));
-    })
-}
-
-export const addObjectListenerConfig = (json: SteedosListenerConfig) => {
-    if (!json.listenTo) {
-        throw new Error('missing attribute listenTo')
-    }
-
-    if (!_.isString(json.listenTo) && !_.isFunction(json.listenTo) && !_.isArray(json.listenTo) && !_.isRegExp(json.listenTo)) {
-        throw new Error('listenTo must be a function or string or array or regExp')
-    }
-
-    let object_name = '';
-
-    if (_.isString(json.listenTo)) {
-        object_name = json.listenTo
-    } else if (_.isFunction(json.listenTo)) {
-        object_name = json.listenTo()
-    }
-    if(object_name){
-        let object = getObjectConfig(object_name);
-        if (object) {
-            if(!object.listeners){
-                object.listeners = {}
-            }
-            delete json.listenTo
-            delete json.name
-            const listener = clone(json);
-            listener.name = json._id || getMD5(JSONStringify(json));
-            object.listeners[listener.name] = listener
-            if(object.datasource === 'meteor'){
-                util.extend(object, {triggers: transformListenersToTriggers(object, listener)})
-            }
-
-            try {
-                const localObject = getDataSource(object.datasource).getLocalObject(object_name);
-                if(localObject){
-                    localObject.setListener(listener.name, listener);
-                }
-            } catch (error) {
-                // console.error(error)
-            }
-            
-        }
-        addLazyLoadListeners(object_name, Object.assign({}, json, {listenTo: object_name, name: json._id || getMD5(JSONStringify(json))}));
-        return Object.assign({}, json, {listenTo: object_name}); 
-    }else{
-        if(_.isRegExp(json.listenTo)){
-            return Object.assign({}, json, {listenTo: json.listenTo.toString()}); 
-        }else{
-            return json; 
-        }
-    }
-}
-
-export const removePackageObjectTriggers = (serviceName: string)=>{
-    _.each(_lazyLoadListeners, (listeners, objectName)=>{
-        let objectConfig = getObjectConfig(objectName);
-        _lazyLoadListeners[objectName] = _.filter(listeners, function(listener: any) { 
-            const drop = listener.metadataServiceName === serviceName; 
-            if(drop){
-                try {
-                    if(objectConfig && objectConfig.listeners){
-                        delete objectConfig.listeners[listener.name]
-                    }
-                } catch (error) {
-                    
-                }
-                try {
-                    const object = getDataSource(objectConfig.datasource).getLocalObject(objectName);
-                    if(object){
-                        object.removeListener(listener.name ,listener)
-                    }
-                } catch (error) {
-                    
-                }
-            }
-            return drop != true;
-        });
-
-        // try {
-        //     let object = getObjectConfig(objectName);
-        //     if(object && object.datasource === 'meteor'){
-        //         (object as any).triggers = _.dropWhile(triggers, function(trigger: any) { 
-        //             return  trigger.metadataServiceName === serviceName; 
-        //         });
-
-        //         try {
-        //             Creator.Objects[object.name] = object;
-        //             Creator.loadObjects(object, object.name);
-        //         } catch (error) {
-        //             console.log(error)
-        //         }
-        //     }
-        // } catch (error) {
-        //     console.log(error)
-        // }
-    })
-
-    _.each(_patternListerners, (listeners, objectName)=>{
-        let objectConfig = getObjectConfig(objectName);
-        _patternListerners[objectName] = _.filter(listeners, function(listener: any) { 
-            const drop = listener.metadataServiceName === serviceName; 
-            if(drop){
-                try {
-                    if(objectConfig && objectConfig.listeners){
-                        delete objectConfig.listeners[listener.name]
-                    }
-                } catch (error) {
-                    
-                }
-            }
-            return drop != true;
-        });
-    })
-}
-
-export const loadObjectTriggers = function (filePath: string, serviceName: string){
-    if(!serviceName){
-        throw new Error("serviceName is null");
-    }
-    let triggerJsons = util.loadTriggers(filePath)
-    let triggers = [];
-    _.each(triggerJsons, (json: SteedosListenerConfig) => {
-        triggers.push(addObjectListenerConfig(Object.assign(json, {metadataServiceName: serviceName})));
-    })
-    return triggers;
-}
-
-/**
- * 判断是否通配触发器
- * @param data 
- * @returns 
- */
-function isPatternListener(data){
-    const {listenTo} = data;
-    if(listenTo === '*'){
-        return true;
-    }else if(_.isRegExp(listenTo)){
-        return true;
-    }else if(_.isString(listenTo) && listenTo.startsWith("/")){
-        try {
-            if(_.isRegExp(eval(listenTo))){
-                return true;
-            }
-        } catch (error) {
-            return false
-        }
-        return false;
-    }
-    return false;
-}
-
-/**
- * 获取旧版触发器中写了通配符的触发器
- * @param objectApiName 
- * @returns 
- */
-export function getPatternListeners(objectApiName: string) {
-    let patternListeners = {};
-
-    const pushTrigger = (listeners: [any]) => {
-        for (const listener of listeners) {
-            _TRIGGERKEYS.forEach((key) => {
-                let event = listener[key];
-                if (_.isFunction(event)) {
-                    patternListeners[listener.name] = listener;
-                }
-            })
-        }
-    }
-
-    _.each(_patternListerners, (listeners, objectName) => {
-        try {
-            if (objectName === '*') {
-                pushTrigger(listeners);
-            } 
-            else if (_.isRegExp(objectName) && objectName.test(objectApiName)) {
-                pushTrigger(listeners);
-            } 
-            else if (_.isString(objectName) && objectName.startsWith("/")) {
-                try {
-                    if (_.isRegExp(eval(objectName)) && eval(objectName).test(objectApiName)) {
-                        pushTrigger(listeners);
-                    }
-                } catch (error) {
-                    // DO NOTHING
-                }
-            }
-        } catch (error) {
-            console.log(`[getPatternListeners] `, error);
-        }
-    })
-
-    return patternListeners;
-}