@steedos/objectql 2.2.50 → 2.2.51-beta.4

package/src/summary/recompute.ts

@@ -1,31 +0,0 @@
-import { getSteedosSchema } from '../index';
-import { SteedosFieldSummaryTypeConfig } from './type';
-import { getFieldSummaryConfig } from './field_summary';
-import { updateReferenceTosFieldSummaryValue } from './core';
-
-const runCurrentFieldSummary = async function (fieldSummaryConfig: SteedosFieldSummaryTypeConfig, userSession: any) {
-    const { object_name: objectName } = fieldSummaryConfig;
-    const docs = await getSteedosSchema().getObject(objectName).find({ filters: [], fields: ["_id"] })
-    await updateReferenceTosFieldSummaryValue(docs, fieldSummaryConfig, userSession);
-}
-
-/**
- * 重算指定累计汇总字段Id对应的汇总值
- * @param fieldId 
- */
-export const recomputeSummaryValues = async (fieldId: string, userSession: any) => {
-    let config = await getFieldSummaryConfig(fieldId);
-    if (!config) {
-        throw new Error(`recomputeSummaryValues:${fieldId} not found in field_summary configs.`);
-    }
-    return await recomputeFieldSummaryValues(config, userSession);
-}
-
-/**
- * 重算指定累计汇总字段的汇总值
- * @param fieldSummaryConfig 
- */
-export const recomputeFieldSummaryValues = async (fieldSummaryConfig: SteedosFieldSummaryTypeConfig, userSession: any) => {
-    await runCurrentFieldSummary(fieldSummaryConfig, userSession);
-    return true;
-}

package/src/summary/type.ts

@@ -1,60 +0,0 @@
-import { SteedosQueryFilters } from '../types';
-
-/**
- * 累计汇总字段配置结构
- * 低代码/零代码中可以配置object_name、field_name、summary_object、summary_type、summary_field属性，其他属性都是算出来的
- */
-export type SteedosFieldSummaryTypeConfig = {
-    _id: string, //低代码值为${objectConfig.name}.${fieldConfig.name}，零代码为数据库中的_id值
-    object_name: string, //主表对象
-    field_name: string, //主表上的汇总字段
-    summary_object: string, //对汇总的子表对象
-    summary_type: SteedosSummaryTypeValue, //要汇总的类型
-    data_type: string, //数据类型，summary_type为count则为number，其他类型则关联到summary_field的数据类型
-    summary_field?: string, //要聚合的字段，只能是数值、金额、日期、日期时间字段类型
-    summary_filters?: SteedosQueryFilters, //要汇总的子表记录的过滤条件
-    reference_to_field?: string //子表上的master_detail关联到主表对象的字段，必须能找到且只能找到一个
-}
-
-/**
- * 累计汇总字段支持的计算类型
- */
-export enum SteedosSummaryTypeValue {
-    COUNT = "count",
-    SUM = "sum",
-    MIN = "min",
-    MAX = "max",
-    AVG = "avg"
-}
-
-/**
- * 累计汇总字段支持的字段类型（特指数据库中最终保存的结果类型）
- * 注意这时也是支持公式类型字段的，不过最终使用的是公式字段本身的数据类型
- */
-export enum SteedosSummaryDataTypeValue {
-    Number = "number",
-    Currency = "currency",
-    Percent = "percent",
-    Date = "date",
-    Datetime = "datetime"
-}
-
-/**
- * 各个累计汇总计算类型支持的字段类型，用于判断SteedosFieldSummaryTypeConfig中配置的summary_field所指向的字段类型是否符合规范
- */
-export const SupportedSummaryFieldTypes = {
-    "sum": [SteedosSummaryDataTypeValue.Number, SteedosSummaryDataTypeValue.Currency, SteedosSummaryDataTypeValue.Percent],
-    "avg": [SteedosSummaryDataTypeValue.Number, SteedosSummaryDataTypeValue.Currency, SteedosSummaryDataTypeValue.Percent],
-    "min": [SteedosSummaryDataTypeValue.Number, SteedosSummaryDataTypeValue.Currency, SteedosSummaryDataTypeValue.Percent, SteedosSummaryDataTypeValue.Date, SteedosSummaryDataTypeValue.Datetime],
-    "max": [SteedosSummaryDataTypeValue.Number, SteedosSummaryDataTypeValue.Currency, SteedosSummaryDataTypeValue.Percent, SteedosSummaryDataTypeValue.Date, SteedosSummaryDataTypeValue.Datetime]
-};
-
-/**
- * 各个累计汇总计算类型的空值处理方式
- */
-export const SteedosSummaryTypeBlankValue = {
-    "count": 0,
-    "sum": 0,
-    "min": null,
-    "max": null
-};

package/src/ts-types/index.ts

@@ -1,3 +0,0 @@
-export * from './profile'
-export * from './permissionset'
-export * from './triggerActionParams'

package/src/ts-types/permissionset.ts

@@ -1,8 +0,0 @@
-export type SteedosPermissionsetTypeConfig = {
-    name: string,
-    label: string,
-    type: 'permission_set',
-    license?: string,
-    assigned_apps: Array<string>,
-    is_system: boolean
-}

package/src/ts-types/profile.ts

@@ -1,11 +0,0 @@
-export type SteedosProfileTypeConfig = {
-    name: string,
-    label: string,
-    type: 'profile',
-    license: string,
-    assigned_apps: Array<string>,
-    is_system: boolean,
-    password_history: string,
-    max_login_attempts: string,
-    lockout_interval: string
-}

package/src/ts-types/triggerActionParams.ts

@@ -1,22 +0,0 @@
-import { JsonMap } from "@salesforce/ts-types";
-import { SteedosIDType } from "..";
-
-export type TriggerActionParams = {
-    objectName?: string
-    isExecuting?: boolean,
-    isInsert?: boolean,
-    isUpdate?: boolean,
-    isDelete?: boolean,
-    isBefore?: boolean,
-    isAfter?: boolean,
-    isUndelete?: boolean,
-    new?: [JsonMap],
-    newMap?: [SteedosIDType],
-    old?: [JsonMap],
-    oldMap?: [SteedosIDType],
-    operationType?: "BEFORE_FIND" | "BEFORE_AGGREGATE" | "BEFORE_INSERT" | "BEFORE_UPDATE" | "BEFORE_DELETE" | "AFTER_FIND" | "AFTER_AGGREGATE" | "AFTER_COUNT" | "AFTER_FINDONE" | "AFTER_INSERT" | "AFTER_UPDATE" | "AFTER_DELETE" | "AFTER_UNDELETE",
-    size?: number,
-    userId: SteedosIDType,
-    spaceId?: SteedosIDType,
-}
-

package/src/typeorm/driver.ts

@@ -1,379 +0,0 @@
-import { JsonMap, Dictionary } from "@salesforce/ts-types";
-import { SteedosDriver, SteedosFieldDBType, SteedosDriverConfig } from "../driver";
-import { createConnection, QueryRunner, EntitySchema, ConnectionOptions } from "typeorm";
-import { SteedosQueryOptions, SteedosQueryFilters } from "../types/query";
-import { SteedosIDType, SteedosObjectType } from "../types";
-import { formatFiltersToODataQuery } from "@steedos/filters";
-import { executeQuery, executeCountQuery, SqlOptions } from '@steedos/odata-v4-typeorm';
-import { SQLLang } from 'odata-v4-sql';
-import { getPrimaryKeys } from "../typeorm";
-
-import _ = require("underscore");
-
-export abstract class SteedosTypeormDriver implements SteedosDriver {
-    getSupportedColumnTypes() {
-        return [
-            SteedosFieldDBType.varchar,
-            SteedosFieldDBType.text,
-            SteedosFieldDBType.number,
-            SteedosFieldDBType.date,
-            SteedosFieldDBType.dateTime
-        ]
-    }
-    _url: string;
-    _client: any;
-    databaseVersion?: string;
-
-    private _config: SteedosDriverConfig;
-
-    public get config(): SteedosDriverConfig {
-        return this._config;
-    }
-
-    _queryRunner: QueryRunner;
-    _entities: Dictionary<EntitySchema>;
-
-    abstract readonly sqlLang: SQLLang;
-
-    constructor(config: SteedosDriverConfig) {
-        this._config = config;
-        this._url = config.url;
-    }
-
-    abstract getConnectionOptions(): ConnectionOptions;
-
-    async connect(reconnect?) {
-        if (!this._entities) {
-            throw new Error("Entities must be registered before connect");
-        }
-        if (!this._client || reconnect) {
-            let options = this.getConnectionOptions();
-            this._client = await createConnection(options);
-            this.databaseVersion = await this.getDatabaseVersion();
-            return true;
-        }
-    }
-
-    async close() {
-        if (this._client) {
-            await this._client.close();
-            this._client = null;
-            this._queryRunner = null;
-            return true;
-        }
-    }
-
-    async createQueryRunner() {
-        if (this._queryRunner) {
-            return this._queryRunner;
-        }
-        if (!this._client) {
-            await this.connect();
-        }
-        this._queryRunner = await this._client.driver.createQueryRunner("master");
-        return this._queryRunner;
-    }
-
-    formatFiltersToTypeormQuery(filters: any): JsonMap {
-        let odataQuery: string = "";
-        if (_.isString(filters)) {
-            odataQuery = filters;
-        }
-        else {
-            odataQuery = formatFiltersToODataQuery(filters)
-        }
-        return {
-            $filter: odataQuery
-        };
-    }
-
-    getTypeormFilters(filters: SteedosQueryFilters): JsonMap {
-        let emptyFilters = {
-        };
-        if (_.isUndefined(filters)) {
-            return emptyFilters;
-        }
-        if (_.isString(filters) && !filters.length) {
-            return emptyFilters
-        }
-        if (_.isArray(filters) && !filters.length) {
-            return emptyFilters
-        }
-        let typeormFilters: JsonMap = this.formatFiltersToTypeormQuery(filters);
-        return typeormFilters
-    }
-
-    getTypeormFieldsOptions(fields: string[] | string, primaryKeys: string[]): JsonMap {
-        if (typeof fields === "string") {
-            fields = (<string>fields).split(",").map((n) => { return n.trim(); });
-        }
-        if (!(fields && fields.length)) {
-            return {}
-        }
-        let projection: string = "";
-        (<string[]>fields).forEach((field) => {
-            if (field && primaryKeys.indexOf(field) < 0) {
-                projection += `${field},`
-            }
-        });
-        projection = projection.replace(/,$/g, "");
-        if (primaryKeys && primaryKeys.length){
-            if (projection){
-                projection = `${primaryKeys.join(",")},${projection}`;
-            }
-            else{
-                projection = primaryKeys.join(",");
-            }
-        }
-        return {
-            $select: projection
-        };
-    }
-
-    getTypeormSortOptions(sort: string, defaultSort?: string): JsonMap {
-        let result: JsonMap = {};
-        if (!(sort && typeof sort === "string" && sort.length)) {
-            if (defaultSort){
-                sort = defaultSort;
-            }
-            else{
-                return result;
-            }
-        }
-        let arraySort: string[] = sort.split(",").map((n) => { return n.trim(); });
-        let stringSort: string = "";
-        arraySort.forEach((n) => {
-            if (n) {
-                stringSort += `${n},`
-            }
-        });
-        stringSort = stringSort.replace(/,$/g, "");
-        if (stringSort) {
-            result = {
-                $orderby: stringSort
-            };
-        }
-        return result;
-    }
-
-    getTypeormTopAndSkipOptions(top: number = 0, skip: number = 0): JsonMap {
-        let result: JsonMap = {};
-        if (top > 0) {
-            result.$top = top;
-        }
-        if (skip > 0) {
-            result.$skip = skip;
-        }
-        return result;
-    }
-
-    async find(tableName: string, query: SteedosQueryOptions) {
-        await this.connect();
-        let entity = this._entities[tableName];
-        if (!entity) {
-            throw new Error(`${tableName} is not exist or not registered in the connect`);
-        }
-        let repository = this._client.getRepository(entity);
-        let primaryKeys: string[] = getPrimaryKeys(repository);
-        let filterQuery: JsonMap = this.getTypeormFilters(query.filters);
-        let projection: JsonMap = this.getTypeormFieldsOptions(query.fields, primaryKeys);
-        let sort: JsonMap = this.getTypeormSortOptions(query.sort);
-        let topAndSkip: JsonMap = this.getTypeormTopAndSkipOptions(query.top, query.skip);
-        const queryBuilder = repository.createQueryBuilder(tableName);
-        let queryOptions = Object.assign(filterQuery, projection, sort, topAndSkip);
-        let sqlOptions: SqlOptions = { alias: tableName, type: this.sqlLang, version: this.databaseVersion };
-        let result = await executeQuery(queryBuilder, queryOptions, sqlOptions);
-        return result.map((item:any)=>{
-            if (primaryKeys){
-                if (primaryKeys.length === 1){
-                    let key = primaryKeys[0];
-                    item['_id'] = item[key] ? item[key].toString() : "";
-                }
-                else if (primaryKeys.length > 1){
-                    item['_ids'] = {};
-                    primaryKeys.forEach((key) => {
-                        item['_ids'][key] = item[key] ? item[key].toString() : "";
-                    });
-                }
-            }
-            return item;
-        });
-    }
-
-    async count(tableName: string, query: SteedosQueryOptions) {
-        await this.connect();
-        let entity = this._entities[tableName];
-        if (!entity) {
-            throw new Error(`${tableName} is not exist or not registered in the connect`);
-        }
-        let filterQuery: JsonMap = this.getTypeormFilters(query.filters);
-        let repository = this._client.getRepository(entity);
-        const queryBuilder = repository.createQueryBuilder(tableName);
-        let result = await executeCountQuery(queryBuilder, filterQuery, { alias: tableName, type: this.sqlLang });
-        return result;
-    }
-
-    async findOne(tableName: string, id: SteedosIDType, query?: SteedosQueryOptions) {
-        await this.connect();
-        let entity = this._entities[tableName];
-        if (!entity) {
-            throw new Error(`${tableName} is not exist or not registered in the connect`);
-        }
-        let repository = this._client.getRepository(entity);
-        let primaryKeys: string[] = getPrimaryKeys(repository);
-        let filterQuery: JsonMap = this.getTypeormFilters([[primaryKeys[0], "=", id]]);
-        let projection: JsonMap = this.getTypeormFieldsOptions(query ? query.fields : [], primaryKeys);
-        const queryBuilder = repository.createQueryBuilder(tableName);
-        // 这里不可以用repository.findOne，也不可以用repository.createQueryBuilder(tableName).select(...).where(...).getOne();
-        // 因为sqlserver/sqlite3不兼容
-        let result = await executeQuery(queryBuilder, Object.assign(filterQuery, projection), { alias: tableName, type: this.sqlLang });
-        if (result && result[0]){
-            // result[0]['_id'] = result[0][primaryKey] ? result[0][primaryKey].toString() : "";
-            if (primaryKeys){
-                if (primaryKeys.length === 1){
-                    let key = primaryKeys[0];
-                    result[0]['_id'] = result[0][key] ? result[0][key].toString() : "";
-                }
-                else if (primaryKeys.length > 1){
-                    result[0]['_ids'] = {};
-                    primaryKeys.forEach((key) => {
-                        result[0]['_ids'][key] = result[0][key] ? result[0][key].toString() : "";
-                    });
-                }
-            }
-            return result[0];
-        }
-        else{
-            return null;
-        }
-    }
-
-    async run(sql: string, param?: any) {
-        const queryRunner: QueryRunner = await this.createQueryRunner();
-        try {
-            return queryRunner.query(sql, param);
-        } finally {
-            // release函数会根据不同的数据为类型执行不同的操作，比如close数据库
-            if (queryRunner !== this._queryRunner) {
-                await queryRunner.release();
-            }
-            if (this._client.driver.options.type === "sqljs") {
-                // driver instanceof SqljsDriver
-                // SqljsDriver is not export from typeorm,so we user driver.options.type to check the SqljsDriver instance
-                await this._client.driver.autoSave();
-            }
-        }
-    }
-
-    async insert(tableName: string, data: Dictionary<any>) {
-        await this.connect();
-        let entity = this._entities[tableName];
-        if (!entity) {
-            throw new Error(`${tableName} is not exist or not registered in the connect`);
-        }
-        let repository = this._client.getRepository(entity);
-        let result = await repository.insert(data);
-        if (result.identifiers && result.identifiers.length) {
-            let primaryKeys: string[] = getPrimaryKeys(repository);
-            if (primaryKeys && primaryKeys.length === 1) {
-                let id = primaryKeys[0] && result.identifiers[0][primaryKeys[0]];
-                if (id) {
-                    return await this.findOne(tableName, id);
-                }
-            }
-        }
-    }
-
-    async update(tableName: string, id: SteedosIDType, data: Dictionary<any>) {
-        await this.connect();
-        let entity = this._entities[tableName];
-        if (!entity) {
-            throw new Error(`${tableName} is not exist or not registered in the connect`);
-        }
-        let fields: any[] = Object.keys(data);
-        if (!fields.length) {
-            throw new Error("the params 'data' must not be empty");
-        }
-        let repository = this._client.getRepository(entity);
-        await repository.update(id, data);
-        return await this.findOne(tableName, id);
-    }
-
-    async updateOne(tableName: string, id: SteedosIDType, data: Dictionary<any>) {
-        await this.connect();
-        let entity = this._entities[tableName];
-        if (!entity) {
-            throw new Error(`${tableName} is not exist or not registered in the connect`);
-        }
-        let fields: any[] = Object.keys(data);
-        if (!fields.length) {
-            throw new Error("the params 'data' must not be empty");
-        }
-        let repository = this._client.getRepository(entity);
-        await repository.update(id, data);
-        return await this.findOne(tableName, id);
-    }
-
-    async delete(tableName: string, id: SteedosIDType) {
-        await this.connect();
-        let entity = this._entities[tableName];
-        if (!entity) {
-            throw new Error(`${tableName} is not exist or not registered in the connect`);
-        }
-        let repository = this._client.getRepository(entity);
-        await repository.delete(id);
-    }
-
-    async directFind(tableName: string, query: SteedosQueryOptions) {
-        return this.find(tableName, query)
-    }
-
-    async directInsert(tableName: string, data: Dictionary<any>) {
-        return this.insert(tableName, data)
-    }
-
-    async directUpdate(tableName: string, id: SteedosIDType, data: Dictionary<any>) {
-       return this.update(tableName, id, data)
-    }
-
-    async directDelete(tableName: string, id: SteedosIDType) {
-       return this.delete(tableName, id)
-    }
-
-    async getDatabaseVersion() {
-        // 各个driver层可以通过重写该函数来设置databaseVersion值
-        return "";
-    }
-
-    async dropEntities() {
-        let objects = {};
-        this._entities = this.getEntities(objects);
-        await this.connect();
-        await this._client.synchronize(true);
-        await this.close();
-        this._entities = null;
-    }
-
-    registerEntities(objects: Dictionary<SteedosObjectType>) {
-        // if (!this._entities) {
-        //     this._entities = this.getEntities(objects);
-        // }
-        this._entities = this.getEntities(objects);
-    }
-
-    async dropTables() {
-        await this.dropEntities();
-    }
-
-    async createTables(objects: Dictionary<SteedosObjectType>) {
-        await this.init(objects);
-        await this._client.synchronize();
-    }
-
-    async init(objects: Dictionary<SteedosObjectType>) {
-        this.registerEntities(objects);
-        await this.connect(true);
-    }
-
-    abstract getEntities(objects: Dictionary<SteedosObjectType>): Dictionary<EntitySchema>;
-}

package/src/typeorm/index.ts

@@ -1,3 +0,0 @@
-export * from "./util";
-
-export { SteedosTypeormDriver } from "./driver"

package/src/typeorm/util.ts

@@ -1,147 +0,0 @@
-import { EntitySchema, ColumnType, EntitySchemaColumnOptions, EntitySchemaRelationOptions, Repository, DatabaseType } from "typeorm";
-import { Dictionary } from "@salesforce/ts-types";
-import { SteedosObjectType, SteedosFieldType } from "../types";
-import { SteedosFieldDBType } from "../driver";
-
-export interface EntitySchemaColumnDictionary {
-    [x: string]: EntitySchemaColumnOptions;
-}
-export interface EntitySchemaRelationDictionary {
-    [x: string]: EntitySchemaRelationOptions;
-}
-
-export type RelationType = "one-to-one" | "one-to-many" | "many-to-one" | "many-to-many";
-
-export function getTableColumnType(field: SteedosFieldType, databaseType: DatabaseType): ColumnType {
-    let columnType: SteedosFieldDBType = field.fieldDBType;
-    switch (columnType) {
-        case SteedosFieldDBType.varchar:
-            return String;
-        case SteedosFieldDBType.text:
-            if (databaseType === "oracle"){
-                return "blob";
-            }
-            return "text";
-        case SteedosFieldDBType.number:
-            let scale = field.scale === undefined ? 0 : field.scale;
-            if (scale === 0){
-                return "int";
-            }
-            return "decimal";
-        case SteedosFieldDBType.dateTime:
-            return Date;
-        case SteedosFieldDBType.date:
-            if (databaseType === "postgres") {
-                // postgres数据库日期类型返回的最终是字符串，类似于：2019-04-30
-                return "date";
-            }
-            return Date;
-        case SteedosFieldDBType.boolean:
-            return Boolean;
-    }
-    return columnType || String;
-};
-
-export function getTableColumns(fields: Dictionary<SteedosFieldType>, object: SteedosObjectType, databaseType: DatabaseType): EntitySchemaColumnDictionary {
-    let columns: EntitySchemaColumnDictionary = {};
-    let primaryColumnCount = 0;
-    for (let fieldName in fields) {
-        let field = fields[fieldName];
-        let fieldType: ColumnType = getTableColumnType(field, databaseType);
-        if (!fieldType){
-            continue;
-        }
-        let nullable = field.required ? false : true;
-        if (field.primary){
-            nullable = false;
-            primaryColumnCount++;
-        }
-        columns[fieldName] = {
-            type: fieldType,
-            nullable: nullable,
-            primary: field.primary,
-            generated: field.generated,
-            precision: field.precision ? field.precision : (field.scale ? 18 : undefined),
-            scale: field.scale
-        };
-        if(field.column_name){
-            (columns as any)[fieldName]["name"] = field.column_name
-        }
-        // 服务端增加_id字段统一代理主键字段处理查询
-        if (field.primary) {
-            (columns as any)['_id'] = {
-                ...columns[fieldName],
-                name: field.column_name || fieldName,
-                generated: false,
-                primary: false,
-                nullable: true,
-                insert: false,
-                update: false
-            };
-        }
-    }
-    if (!primaryColumnCount){
-        return null;
-    }
-    return columns;
-}
-
-export function getEntity(object: SteedosObjectType, databaseType: DatabaseType): EntitySchema {
-    let tableName = object.table_name;
-    let fields = object.fields;
-    let columns: EntitySchemaColumnDictionary = getTableColumns(fields, object, databaseType);
-    if (!columns){
-        return null;
-    }
-    // typeorm支持对象类型:"regular" | "view" | "junction" | "closure" | "closure-junction" | "entity-child";
-    let type: any = "regular";
-    if (object.is_view){
-        type = "view";
-    }
-    return new EntitySchema({
-        name: tableName,
-        tableName: tableName,
-        columns: columns,
-        type: type
-    });
-}
-
-export function getEntities(objects: Dictionary<SteedosObjectType>, databaseType: DatabaseType): Dictionary<EntitySchema> {
-    let entities: Dictionary<EntitySchema> = {};
-    let primaryColumnEmptyErrorTables = [];
-    let primaryColumnMultiErrorTables = [];
-    for (let name in objects) {
-        let object = objects[name];
-        let primaryKeys = object.idFieldNames;
-        if (primaryKeys.length === 1) {
-            let entitySchema = getEntity(object, databaseType);
-            if (entitySchema) {
-                entities[object.table_name] = entitySchema;
-            }
-        }
-        else if (primaryKeys.length > 1) {
-            primaryColumnMultiErrorTables.push(object.table_name);
-        }
-        else{
-            primaryColumnEmptyErrorTables.push(object.table_name);
-        }
-    }
-    if (primaryColumnEmptyErrorTables.length) {
-        console.error(`These tables: "${primaryColumnEmptyErrorTables.join(",")}" does not have a primary column. Primary column is not required in DB, but is required in yml object file.`);
-    }
-    if (primaryColumnMultiErrorTables.length) {
-        console.error(`These tables: "${primaryColumnMultiErrorTables.join(",")}" have multi primary columns. it is not supported yet.`);
-    }
-    return entities;
-}
-
-export function getPrimaryKeys(repository: Repository<any>): Array<string> {
-    let primaryColumns: any = repository.metadata.primaryColumns;
-    let primaryKeys: [] = [];
-    if (primaryColumns && primaryColumns.length) {
-        primaryKeys = primaryColumns.map((item)=>{
-            return item.propertyPath;
-        });
-    }
-    return primaryKeys;
-}