@steedos/objectql 2.1.16 → 2.1.20

package/src/driver/metadata.ts

@@ -0,0 +1,213 @@
+import { Dictionary } from "@salesforce/ts-types";
+import { SteedosDriver } from ".";
+import { SteedosQueryOptions, SteedosIDType, SteedosObjectType } from "../types";
+import { SteedosDriverConfig } from "./driver";
+import { SteedosFieldDBType } from "./fieldDBType";
+import mingo = require('mingo');
+import steedosFilters = require('@steedos/filters');
+import odataV4Mongodb = require('odata-v4-mongodb');
+import clone = require("clone");
+import _ = require('underscore');
+
+export class MetadataDriver implements SteedosDriver {
+    databaseVersion?: string;
+    config?: SteedosDriverConfig;
+    connect() {
+        
+    }
+    close() {
+        
+    }
+
+    formatFiltersToMongoQuery(filters) {
+        let emptyFilters = {};
+        let odataQuery = "";
+        if (_.isString(filters)) {
+            odataQuery = filters;
+        }
+        else {
+            odataQuery = steedosFilters.formatFiltersToODataQuery(filters)
+        }
+        if(!odataQuery){
+            return emptyFilters;
+        }
+        let query = odataV4Mongodb.createFilter(odataQuery);
+        return query;
+    }
+    
+    getMongoFilters(filters) {
+        let emptyFilters = {};
+        if (_.isUndefined(filters)) {
+            return emptyFilters;
+        }
+        if (_.isString(filters) && !filters.length) {
+            return emptyFilters
+        }
+        if (_.isArray(filters) && !filters.length) {
+            return emptyFilters
+        }
+        let mongoFilters = this.formatFiltersToMongoQuery(filters);
+        return mongoFilters
+    }
+    
+    getMongoFieldsOptions(fields) {
+        if (typeof fields == "string") {
+            fields = (fields).split(",").map((n) => { return n.trim(); });
+        }
+        if (!(fields && fields.length)) {
+            return {}
+        }
+        let projection = {};
+        (fields).forEach((field) => {
+            if (field) {
+                projection[field] = 1;
+            }
+        });
+        return projection;
+    }
+    
+    getMongoOptions(options) {
+        if (_.isUndefined(options)) {
+            return {};
+        }
+        let result: any = {};
+        let projection = this.getMongoFieldsOptions(options.fields);
+        let sort = this.getMongoSortOptions(options.sort);
+        result.projection = projection;
+        result.sort = sort;
+        result.limit = options.top;
+        result.skip = options.skip;
+        return result;
+    }
+    
+    getMongoSortOptions(sort) {
+        let result = undefined;
+        if (sort && typeof sort === "string") {
+            let arraySort= sort.split(",").map((n) => { return n.trim(); });
+            let stringSort = "";
+            arraySort.forEach((n) => {
+                if (n) {
+                    stringSort += `${n},`
+                }
+            });
+            stringSort = stringSort.replace(/,$/g, "");
+            result = odataV4Mongodb.createQuery(`$orderby=${stringSort}`).sort;
+        }
+        return result;
+    }
+    
+    getAggregateOptions(options){
+        if (_.isUndefined(options)) {
+            return [];
+        }
+        let result = [];
+        let projection = this.getMongoFieldsOptions(options.fields);
+        let sort = this.getMongoSortOptions(options.sort);
+        if (!_.isEmpty(projection)) {
+            result.push({ $project: projection });
+        }
+        if (!_.isEmpty(sort)) {
+            result.push({ $sort: sort });
+        }
+        if (options.skip) {
+            result.push({ $skip: options.skip });
+        }
+        if (options.top) {
+            result.push({ $limit: options.top });
+        }
+        return result;
+    }
+    
+    queryMetadata(collection, queryOptions, spaceId){
+        const _collection = clone(collection);
+        _.each(_collection, function(item){ item.space = spaceId})
+        let mongoFilters = this.getMongoFilters(queryOptions.filters);
+        let mongoOptions = this.getMongoOptions(queryOptions);
+        // console.log(`mongoFilters`, JSON.stringify(mongoFilters));
+        // console.log(`mongoOptions`, mongoOptions);
+        let query = new mingo.Query(mongoFilters, mongoOptions.projectio)
+        let cursor = query.find(_collection);
+        if(mongoOptions.sort){
+            cursor.sort(mongoOptions.sort)
+        }
+        // if(mongoOptions.skip){
+        //     cursor.skip(mongoOptions.skip)
+        // }
+        // if(mongoOptions.limit){
+        //     cursor.limit(mongoOptions.limit)
+        // }
+        return cursor;
+    }
+
+
+    getSupportedColumnTypes(): SteedosFieldDBType[] {
+        throw new Error("Method not implemented.");
+    }
+    find(collection: any, query: SteedosQueryOptions, spaceId?: SteedosIDType) {
+        const result = this.queryMetadata(collection, query, spaceId).all();
+        return result;
+    }
+    aggregate(collection: any, query: SteedosQueryOptions, externalPipeline: any, spaceId?: SteedosIDType) {
+        const result = this.queryMetadata(collection, query, spaceId).all();
+        return result;
+    }
+    findOne(collection: any, id: SteedosIDType, query: SteedosQueryOptions, spaceId?: SteedosIDType) {
+        throw new Error("Method not implemented.");
+    }
+    insert(collection: any, doc: Dictionary<any>, spaceId?: SteedosIDType) {
+        throw new Error("Method not implemented.");
+    }
+    update(collection: any, id: SteedosQueryOptions | SteedosIDType, doc: Dictionary<any>, spaceId?: SteedosIDType) {
+        throw new Error("Method not implemented.");
+    }
+    updateOne(collection: any, id: SteedosQueryOptions | SteedosIDType, doc: Dictionary<any>, spaceId?: SteedosIDType) {
+        throw new Error("Method not implemented.");
+    }
+    updateMany?(collection: any, queryFilters: any, doc: Dictionary<any>, spaceId?: SteedosIDType) {
+        throw new Error("Method not implemented.");
+    }
+    delete(collection: any, id: SteedosQueryOptions | SteedosIDType, spaceId?: SteedosIDType) {
+        throw new Error("Method not implemented.");
+    }
+    directUpdate(collection: any, id: SteedosQueryOptions | SteedosIDType, doc: Dictionary<any>, spaceId?: SteedosIDType) {
+        throw new Error("Method not implemented.");
+    }
+    directFind(collection: any, query: SteedosQueryOptions, spaceId?: SteedosIDType) {
+        throw new Error("Method not implemented.");
+    }
+    directInsert(collection: any, doc: Dictionary<any>, spaceId?: SteedosIDType) {
+        throw new Error("Method not implemented.");
+    }
+    directDelete(collection: any, id: SteedosQueryOptions | SteedosIDType, spaceId?: SteedosIDType) {
+        throw new Error("Method not implemented.");
+    }
+    directAggregate?(collection: any, query: SteedosQueryOptions, externalPipeline: any, spaceId?: SteedosIDType) {
+        throw new Error("Method not implemented.");
+    }
+    directAggregatePrefixalPipeline?(collection: any, query: SteedosQueryOptions, prefixalPipeline: any, spaceId?: SteedosIDType) {
+        throw new Error("Method not implemented.");
+    }
+    count(collection: any, query: SteedosQueryOptions, spaceId?: SteedosIDType) {
+        const result = this.queryMetadata(collection, query, spaceId).count();
+        return result;
+    }
+    dropEntities?() {
+        throw new Error("Method not implemented.");
+    }
+    registerEntities?(objects: Dictionary<SteedosObjectType>) {
+        throw new Error("Method not implemented.");
+    }
+    dropTables?() {
+        throw new Error("Method not implemented.");
+    }
+    createTables?(objects: Dictionary<SteedosObjectType>) {
+        throw new Error("Method not implemented.");
+    }
+    init(objects: Dictionary<SteedosObjectType>) {
+        throw new Error("Method not implemented.");
+    }
+    _makeNewID?(tableName?: string) {
+        throw new Error("Method not implemented.");
+    }
+
+}

package/src/types/object.ts

@@ -14,6 +14,7 @@ import { runValidationRules } from './validation_rules';
 import { brokeEmitEvents } from "./object_events";
 import { translationObject } from "@steedos/i18n";
 import { getObjectLayouts } from "./object_layouts";
+import { sortBy } from 'lodash';
 declare var Creator: any;
 const clone = require('clone')
 
@@ -942,6 +943,7 @@ export class SteedosObjectType extends SteedosObjectProperties {
         if(layouts && layouts.length > 0){
             const layout = layouts[0];
             let _fields = {};
+            let sort_no = 1;
             _.each(layout.fields, function(_item){
                 _fields[_item.field_name] = objectConfig.fields[_item.field_name]
                 if(_fields[_item.field_name]){
@@ -962,6 +964,9 @@ export class SteedosObjectType extends SteedosObjectProperties {
                     if(_item.visible_on){
                         _fields[_item.field_name].visible_on = _item.visible_on
                     }
+
+                    _fields[_item.field_name].sort_no = sort_no;
+                    sort_no++;
                 }
             })
 
@@ -976,22 +981,36 @@ export class SteedosObjectType extends SteedosObjectProperties {
             
             _.each(difference, function(fieldApiName){
                 objectConfig.fields[fieldApiName].hidden = true;
+                objectConfig.fields[fieldApiName].sort_no = 99999;
             })
 
-            let _buttons = {};
             _.each(layout.buttons, function(button){
                 const action = objectConfig.actions[button.button_name];
                 if(action){
                     if(button.visible_on){
-                        action.visible = button.visible_on;
+                        action._visible = button.visible_on;
                     }
-                    _buttons[button.button_name] = action
                 }
             })
-            objectConfig.actions = _buttons;
+    
+            const layoutButtonsName = _.pluck(layout.buttons,'button_name');
+            _.each(objectConfig.actions, function(action){
+                if(!_.include(layoutButtonsName, action.name)){
+                    action.visible = false
+                    action._visible = function(){return false}.toString()
+                }
+            })
             // _object.allow_customActions = userObjectLayout.custom_actions || []
             // _object.exclude_actions = userObjectLayout.exclude_actions || []
             objectConfig.related_lists = layout.related_lists || []
+            _.each(objectConfig.related_lists, (related_list)=>{
+                if(related_list.sort_field_name && _.isArray(related_list.sort_field_name) && related_list.sort_field_name.length > 0){
+                    related_list.sort = [];
+                    _.each(related_list.sort_field_name, (fName)=>{
+                        related_list.sort.push({field_name: fName, order: related_list.sort_order || 'asc'})
+                    })
+                }
+            })
         }
 
         // TODO object layout 是否需要控制审批记录显示？
@@ -1031,7 +1050,7 @@ export class SteedosObjectType extends SteedosObjectProperties {
         const related_lists = [];
 
         const objectConfig: any = await this.callMetadataObjectServiceAction('getOriginalObject', {objectApiName: this.name});
-        _.each(objectConfig.fields, function(field, key){
+        _.each(sortBy(objectConfig.fields, function(o) { return o.sort_no; }), function(field, key){
             const layoutField: any = {};
             layoutField.field_name = field.name || key;
             layoutField.is_readonly = field.readonly;
@@ -1208,7 +1227,7 @@ export class SteedosObjectType extends SteedosObjectProperties {
     }
 
     private async runBeforeTriggers(method: string, context: SteedosTriggerContextConfig) {
-        if (method === 'count') {
+        if (method === 'count' || method === "findOne") {
             method = 'find';
         }
         let meteorWhen = `before${method.charAt(0).toLocaleUpperCase()}${_.rest([...method]).join('')}`

package/src/types/schema.ts

@@ -9,6 +9,7 @@ import { getFromContainer } from 'typeorm';
 // import { preloadDBObjectFields, preloadDBObjectButtons } from '../dynamic-load';
 import { buildGraphQLSchema } from '../graphql';
 import { MetadataRegister } from '../metadata-register';
+import { MetadataDriver } from '../driver/metadata';
 
 
 const defaultDatasourceName = 'default';
@@ -25,6 +26,7 @@ export class SteedosSchema {
     private _broker: any = null;
     private _metadataBroker: any = null;
     metadataRegister: MetadataRegister = null;
+    metadataDriver = new MetadataDriver();
     public get metadataBroker(): any {
         return this._metadataBroker;
     }