@ruiapp/rapid-core 0.3.0 → 0.3.2

package/dist/index.js

@@ -910,6 +910,9 @@ function isNull(val) {
 }
 function isNullOrUndefined(val) {
     return isNull(val) || isUndefined(val);
+}
+function isNullOrUndefinedOrEmpty(val) {
+    return isNull(val) || isUndefined(val) || val === "";
 }
 
 async function buildRoutes(server, applicationConfig) {
@@ -2801,8 +2804,8 @@ async function findManyRelationLinksViaLinkTable(options) {
     const command = `SELECT * FROM ${server.queryBuilder.quoteTable({
         schema: relationProperty.linkSchema,
         tableName: relationProperty.linkTableName,
-    })} WHERE ${server.queryBuilder.quoteObject(relationProperty.selfIdColumnName)} = ANY($1::int[])
-    ORDER BY id
+    })} WHERE ${server.queryBuilder.quoteObject(relationProperty.selfIdColumnName)} = ANY($1::int[])
+    ORDER BY id
   `;
     const params = [mainEntityIds];
     const links = await server.queryDatabaseObject(command, params);
@@ -3421,7 +3424,7 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
             await server.queryDatabaseObject(`DELETE FROM ${server.queryBuilder.quoteTable({
                 schema: property.linkSchema,
                 tableName: property.linkTableName,
-            })} WHERE ${server.queryBuilder.quoteObject(property.selfIdColumnName)} = $1
+            })} WHERE ${server.queryBuilder.quoteObject(property.selfIdColumnName)} = $1
               AND ${server.queryBuilder.quoteObject(property.targetIdColumnName)} <> ALL($2::int[])`, [id, targetIdsToKeep]);
         }
         else {
@@ -3731,11 +3734,11 @@ class EntityManager {
                 const command = `INSERT INTO ${queryBuilder.quoteTable({
                     schema: relationProperty.linkSchema,
                     tableName: relationProperty.linkTableName,
-                })} (${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}, ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)})
-    SELECT $1, $2 WHERE NOT EXISTS (
-      SELECT ${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}, ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)}
-        FROM ${queryBuilder.quoteTable({ schema: relationProperty.linkSchema, tableName: relationProperty.linkTableName })}
-        WHERE ${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}=$1 AND ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)}=$2
+                })} (${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}, ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)})
+    SELECT $1, $2 WHERE NOT EXISTS (
+      SELECT ${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}, ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)}
+        FROM ${queryBuilder.quoteTable({ schema: relationProperty.linkSchema, tableName: relationProperty.linkTableName })}
+        WHERE ${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}=$1 AND ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)}=$2
       )`;
                 const params = [id, relation.id];
                 await server.queryDatabaseObject(command, params);
@@ -3775,7 +3778,7 @@ class EntityManager {
         const { queryBuilder } = server;
         if (relationProperty.linkTableName) {
             for (const relation of relations) {
-                const command = `DELETE FROM ${queryBuilder.quoteTable({ schema: relationProperty.linkSchema, tableName: relationProperty.linkTableName })}
+                const command = `DELETE FROM ${queryBuilder.quoteTable({ schema: relationProperty.linkSchema, tableName: relationProperty.linkTableName })}
     WHERE ${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}=$1 AND ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)}=$2;`;
                 const params = [id, relation.id];
                 await server.queryDatabaseObject(command, params);
@@ -4315,32 +4318,32 @@ async function generateJwtSecretKey() {
     return encode(exportedKey);
 }
 
-const code$t = "listMetaModels";
-async function handler$t(plugin, ctx, options) {
+const code$u = "listMetaModels";
+async function handler$u(plugin, ctx, options) {
     const { applicationConfig } = ctx;
     ctx.output = { list: applicationConfig.models };
 }
 
 var listMetaModels = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$t,
-  handler: handler$t
+  code: code$u,
+  handler: handler$u
 });
 
-const code$s = "listMetaRoutes";
-async function handler$s(plugin, ctx, options) {
+const code$t = "listMetaRoutes";
+async function handler$t(plugin, ctx, options) {
     const { applicationConfig } = ctx;
     ctx.output = { list: applicationConfig.routes };
 }
 
 var listMetaRoutes = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$s,
-  handler: handler$s
+  code: code$t,
+  handler: handler$t
 });
 
-const code$r = "getMetaModelDetail";
-async function handler$r(plugin, ctx, options) {
+const code$s = "getMetaModelDetail";
+async function handler$s(plugin, ctx, options) {
     const { server, input } = ctx;
     const model = server.getModel(input);
     ctx.output = model;
@@ -4348,8 +4351,8 @@ async function handler$r(plugin, ctx, options) {
 
 var getMetaModelDetail = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$r,
-  handler: handler$r
+  code: code$s,
+  handler: handler$s
 });
 
 function removeFiltersWithNullValue(filters) {
@@ -4599,7 +4602,7 @@ async function syncDatabaseSchema(server, applicationConfig) {
             await server.queryDatabaseObject(`CREATE TABLE IF NOT EXISTS ${queryBuilder.quoteTable(model)} ()`, []);
         }
     }
-    const sqlQueryColumnInformations = `SELECT table_schema, table_name, column_name, data_type, udt_name, is_nullable, column_default, character_maximum_length, numeric_precision, numeric_scale
+    const sqlQueryColumnInformations = `SELECT table_schema, table_name, column_name, data_type, udt_name, is_nullable, column_default, character_maximum_length, numeric_precision, numeric_scale
   FROM information_schema.columns;`;
     const columnsInDb = await server.queryDatabaseObject(sqlQueryColumnInformations, []);
     for (const model of applicationConfig.models) {
@@ -4863,9 +4866,9 @@ async function runCollectionEntityActionHandler(ctx, options, code, handleEntity
     }
 }
 
-const code$q = "findCollectionEntities";
-async function handler$q(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$q, async (entityManager, input) => {
+const code$r = "findCollectionEntities";
+async function handler$r(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$r, async (entityManager, input) => {
         input.filters = removeFiltersWithNullValue(input.filters);
         input.routeContext = ctx.routerContext;
         const entities = await entityManager.findEntities(input);
@@ -4881,14 +4884,14 @@ async function handler$q(plugin, ctx, options) {
 
 var findCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$q,
-  handler: handler$q
+  code: code$r,
+  handler: handler$r
 });
 
-const code$p = "findCollectionEntityById";
-async function handler$p(plugin, ctx, options) {
+const code$q = "findCollectionEntityById";
+async function handler$q(plugin, ctx, options) {
     const { logger, server, input } = ctx;
-    logger.debug(`Running ${code$p} handler...`, { input });
+    logger.debug(`Running ${code$q} handler...`, { input });
     const { id } = input;
     const entityManager = server.getEntityManager(options.singularCode);
     const entity = await entityManager.findById({
@@ -4903,13 +4906,13 @@ async function handler$p(plugin, ctx, options) {
 
 var findCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$p,
-  handler: handler$p
+  code: code$q,
+  handler: handler$q
 });
 
-const code$o = "countCollectionEntities";
-async function handler$o(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$o, async (entityManager, input) => {
+const code$p = "countCollectionEntities";
+async function handler$p(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$p, async (entityManager, input) => {
         input.filters = removeFiltersWithNullValue(input.filters);
         input.routeContext = ctx.routerContext;
         const count = await entityManager.count(input);
@@ -4919,16 +4922,16 @@ async function handler$o(plugin, ctx, options) {
 
 var countCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$o,
-  handler: handler$o
+  code: code$p,
+  handler: handler$p
 });
 
-const code$n = "createCollectionEntity";
-async function handler$n(plugin, ctx, options) {
+const code$o = "createCollectionEntity";
+async function handler$o(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$n} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$o} handler...`, { defaultInput, fixedInput, mergedInput });
     const entityManager = server.getEntityManager(options.singularCode);
     const output = await entityManager.createEntity({
         entity: input,
@@ -4939,15 +4942,15 @@ async function handler$n(plugin, ctx, options) {
 
 var createCollectionEntity = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$n,
-  handler: handler$n
+  code: code$o,
+  handler: handler$o
 });
 
-const code$m = "createCollectionEntitiesBatch";
-async function handler$m(plugin, ctx, options) {
+const code$n = "createCollectionEntitiesBatch";
+async function handler$n(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
-    logger.debug(`Running ${code$m} handler...`, { defaultInput, fixedInput, input });
+    logger.debug(`Running ${code$n} handler...`, { defaultInput, fixedInput, input });
     const { entities } = input;
     if (!lodash.isArray(entities)) {
         throw new Error("input.entities should be an array.");
@@ -4971,16 +4974,16 @@ async function handler$m(plugin, ctx, options) {
 
 var createCollectionEntitiesBatch = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$m,
-  handler: handler$m
+  code: code$n,
+  handler: handler$n
 });
 
-const code$l = "updateCollectionEntityById";
-async function handler$l(plugin, ctx, options) {
+const code$m = "updateCollectionEntityById";
+async function handler$m(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$l} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$m} handler...`, { defaultInput, fixedInput, mergedInput });
     const operation = mergedInput.$operation;
     if (operation) {
         delete mergedInput.$operation;
@@ -5008,15 +5011,15 @@ async function handler$l(plugin, ctx, options) {
 
 var updateCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$l,
-  handler: handler$l
+  code: code$m,
+  handler: handler$m
 });
 
-const code$k = "deleteCollectionEntities";
-async function handler$k(plugin, ctx, options) {
+const code$l = "deleteCollectionEntities";
+async function handler$l(plugin, ctx, options) {
     const { logger, server, routerContext } = ctx;
     const input = ctx.input;
-    logger.debug(`Running ${code$k} handler...`);
+    logger.debug(`Running ${code$l} handler...`);
     if (!input.filters || !input.filters.length) {
         throw new Error("Filters are required when deleting entities.");
     }
@@ -5037,14 +5040,14 @@ async function handler$k(plugin, ctx, options) {
 
 var deleteCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$k,
-  handler: handler$k
+  code: code$l,
+  handler: handler$l
 });
 
-const code$j = "deleteCollectionEntityById";
-async function handler$j(plugin, ctx, options) {
+const code$k = "deleteCollectionEntityById";
+async function handler$k(plugin, ctx, options) {
     const { logger, server, input } = ctx;
-    logger.debug(`Running ${code$j} handler...`);
+    logger.debug(`Running ${code$k} handler...`);
     const entityManager = server.getEntityManager(options.singularCode);
     await entityManager.deleteById({
         id: input.id,
@@ -5056,16 +5059,16 @@ async function handler$j(plugin, ctx, options) {
 
 var deleteCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$j,
-  handler: handler$j
+  code: code$k,
+  handler: handler$k
 });
 
-const code$i = "addEntityRelations";
-async function handler$i(plugin, ctx, options) {
+const code$j = "addEntityRelations";
+async function handler$j(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$i} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$j} handler...`, { defaultInput, fixedInput, mergedInput });
     const entityManager = server.getEntityManager(options.singularCode);
     mergedInput.routeContext = ctx.routerContext;
     await entityManager.addRelations(mergedInput, plugin);
@@ -5074,16 +5077,16 @@ async function handler$i(plugin, ctx, options) {
 
 var addEntityRelations = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$i,
-  handler: handler$i
+  code: code$j,
+  handler: handler$j
 });
 
-const code$h = "removeEntityRelations";
-async function handler$h(plugin, ctx, options) {
+const code$i = "removeEntityRelations";
+async function handler$i(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$h} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$i} handler...`, { defaultInput, fixedInput, mergedInput });
     mergedInput.routeContext = ctx.routerContext;
     const entityManager = server.getEntityManager(options.singularCode);
     await entityManager.removeRelations(mergedInput, plugin);
@@ -5092,16 +5095,16 @@ async function handler$h(plugin, ctx, options) {
 
 var removeEntityRelations = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$h,
-  handler: handler$h
+  code: code$i,
+  handler: handler$i
 });
 
-const code$g = "queryDatabase";
-async function handler$g(plugin, ctx, options) {
+const code$h = "queryDatabase";
+async function handler$h(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { sql, querySingle, defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$g} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$h} handler...`, { defaultInput, fixedInput, mergedInput });
     const result = await server.queryDatabaseObject(sql, mergedInput);
     if (querySingle) {
         ctx.output = lodash.first(result);
@@ -5113,8 +5116,8 @@ async function handler$g(plugin, ctx, options) {
 
 var queryDatabase = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$g,
-  handler: handler$g
+  code: code$h,
+  handler: handler$h
 });
 
 /**
@@ -5292,17 +5295,17 @@ async function sendSourceResponse(proxyCtx, targetRes) {
     srcRes.body = targetRes.body;
 }
 
-const code$f = "httpProxy";
-async function handler$f(plugin, ctx, options) {
+const code$g = "httpProxy";
+async function handler$g(plugin, ctx, options) {
     const { logger } = ctx;
-    logger.debug(`Running ${code$f} handler...`);
+    logger.debug(`Running ${code$g} handler...`);
     await doProxy(ctx.routerContext, options);
 }
 
 var httpProxy = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$f,
-  handler: handler$f
+  code: code$g,
+  handler: handler$g
 });
 
 /**
@@ -5349,8 +5352,8 @@ class RouteManager {
     }
 }
 
-const code$e = "generateSn";
-async function handler$e(plugin, ctx, options) {
+const code$f = "generateSn";
+async function handler$f(plugin, ctx, options) {
     const { server, routerContext } = ctx;
     const input = ctx.input;
     if (options?.ruleCode) {
@@ -5368,11 +5371,11 @@ async function handler$e(plugin, ctx, options) {
 
 var generateSn$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$e,
-  handler: handler$e
+  code: code$f,
+  handler: handler$f
 });
 
-var pluginActionHandlers$7 = [generateSn$1];
+var pluginActionHandlers$8 = [generateSn$1];
 
 var SequenceRule = {
     maintainedBy: "sequencePlugin",
@@ -5463,7 +5466,7 @@ var SequenceAutoIncrementRecord = {
     ],
 };
 
-var pluginModels$5 = [SequenceRule, SequenceAutoIncrementRecord];
+var pluginModels$6 = [SequenceRule, SequenceAutoIncrementRecord];
 
 var generateSn = {
     namespace: "svc",
@@ -5479,7 +5482,7 @@ var generateSn = {
     ],
 };
 
-var pluginRoutes$7 = [generateSn];
+var pluginRoutes$8 = [generateSn];
 
 const segmentType$5 = "literal";
 async function resolveSegmentValue$5(server, ruleCode, config, input) {
@@ -5696,19 +5699,19 @@ class SequencePlugin$1 {
         return [];
     }
     async registerActionHandlers(server) {
-        for (const actionHandler of pluginActionHandlers$7) {
+        for (const actionHandler of pluginActionHandlers$8) {
             server.registerActionHandler(this, actionHandler);
         }
     }
     async configureModels(server, applicationConfig) {
-        server.appendApplicationConfig({ models: pluginModels$5 });
+        server.appendApplicationConfig({ models: pluginModels$6 });
     }
     async configureServices(server, applicationConfig) {
         this.#sequenceService = new SequenceService(server);
         server.registerService("sequenceService", this.#sequenceService);
     }
     async configureRoutes(server, applicationConfig) {
-        server.appendApplicationConfig({ routes: pluginRoutes$7 });
+        server.appendApplicationConfig({ routes: pluginRoutes$8 });
     }
     async onApplicationLoaded(server, applicationConfig) {
         const models = server.getApplicationConfig().models;
@@ -5948,8 +5951,8 @@ class WebhooksPlugin {
     }
 }
 
-const code$d = "changePassword";
-async function handler$d(plugin, ctx, options) {
+const code$e = "changePassword";
+async function handler$e(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const { id, oldPassword, newPassword } = input;
     const userId = routerContext.state.userId;
@@ -5991,15 +5994,24 @@ async function handler$d(plugin, ctx, options) {
 
 var changePassword$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$d,
-  handler: handler$d
+  code: code$e,
+  handler: handler$e
 });
 
-const code$c = "createSession";
-async function handler$c(plugin, ctx, options) {
+const code$d = "createSession";
+async function handler$d(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const { response } = routerContext;
     const { account, password } = input;
+    const licenseService = server.getService("licenseService");
+    const license = licenseService.getLicense();
+    if (!license) {
+        throw new Error(`登录失败，无法获取系统授权信息。`);
+    }
+    if (licenseService.isExpired()) {
+        const expireDate = lodash.get(license.authority, "expireDate");
+        throw new Error(`登录失败，系统授权已于${expireDate}过期。`);
+    }
     const userDataAccessor = server.getDataAccessor({
         singularCode: "oc_user",
     });
@@ -6039,12 +6051,12 @@ async function handler$c(plugin, ctx, options) {
 
 var createSession = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$c,
-  handler: handler$c
+  code: code$d,
+  handler: handler$d
 });
 
-const code$b = "deleteSession";
-async function handler$b(plugin, ctx, options) {
+const code$c = "deleteSession";
+async function handler$c(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const { response } = routerContext;
     setCookie(response.headers, {
@@ -6057,12 +6069,12 @@ async function handler$b(plugin, ctx, options) {
 
 var deleteSession = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$b,
-  handler: handler$b
+  code: code$c,
+  handler: handler$c
 });
 
-const code$a = "getMyProfile";
-async function handler$a(plugin, ctx, options) {
+const code$b = "getMyProfile";
+async function handler$b(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const userId = routerContext.state.userId;
     if (!userId) {
@@ -6092,12 +6104,12 @@ async function handler$a(plugin, ctx, options) {
 
 var getMyProfile$2 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$a,
-  handler: handler$a
+  code: code$b,
+  handler: handler$b
 });
 
-const code$9 = "resetPassword";
-async function handler$9(plugin, ctx, options) {
+const code$a = "resetPassword";
+async function handler$a(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const { userId, password } = input;
     const userDataAccessor = server.getDataAccessor({
@@ -6125,11 +6137,11 @@ async function handler$9(plugin, ctx, options) {
 
 var resetPassword$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$9,
-  handler: handler$9
+  code: code$a,
+  handler: handler$a
 });
 
-var pluginActionHandlers$6 = [changePassword$1, createSession, deleteSession, getMyProfile$2, resetPassword$1];
+var pluginActionHandlers$7 = [changePassword$1, createSession, deleteSession, getMyProfile$2, resetPassword$1];
 
 var AccessToken = {
     maintainedBy: "authManager",
@@ -6186,7 +6198,7 @@ var AccessToken = {
     ],
 };
 
-var pluginModels$4 = [AccessToken];
+var pluginModels$5 = [AccessToken];
 
 var changePassword = {
     namespace: "auth",
@@ -6258,7 +6270,7 @@ var signout$1 = {
     ],
 };
 
-var pluginRoutes$6 = [changePassword, getMyProfile$1, resetPassword, signin$1, signout$1];
+var pluginRoutes$7 = [changePassword, getMyProfile$1, resetPassword, signin$1, signout$1];
 
 /**
  * Auth manager plugin
@@ -6280,15 +6292,15 @@ class AuthPlugin {
         return [];
     }
     async registerActionHandlers(server) {
-        for (const actionHandler of pluginActionHandlers$6) {
+        for (const actionHandler of pluginActionHandlers$7) {
             server.registerActionHandler(this, actionHandler);
         }
     }
     async configureModels(server, applicationConfig) {
-        server.appendApplicationConfig({ models: pluginModels$4 });
+        server.appendApplicationConfig({ models: pluginModels$5 });
     }
     async configureRoutes(server, applicationConfig) {
-        server.appendApplicationConfig({ routes: pluginRoutes$6 });
+        server.appendApplicationConfig({ routes: pluginRoutes$7 });
     }
     async onPrepareRouteContext(server, routeContext) {
         const request = routeContext.request;
@@ -6349,8 +6361,8 @@ function getFileBaseName(pathname) {
     return path__default["default"].basename(pathname, extName);
 }
 
-const code$8 = "downloadDocument";
-async function handler$8(plugin, ctx, options) {
+const code$9 = "downloadDocument";
+async function handler$9(plugin, ctx, options) {
     const { server, applicationConfig, routerContext, input } = ctx;
     const { request, response } = routerContext;
     const documentDataAccessor = ctx.server.getDataAccessor({
@@ -6406,12 +6418,12 @@ async function handler$8(plugin, ctx, options) {
 
 var downloadDocumentActionHandler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$8,
-  handler: handler$8
+  code: code$9,
+  handler: handler$9
 });
 
-const code$7 = "downloadFile";
-async function handler$7(plugin, ctx, options) {
+const code$8 = "downloadFile";
+async function handler$8(plugin, ctx, options) {
     const { server, applicationConfig, routerContext } = ctx;
     const { request, response } = routerContext;
     //TODO: only public files can download by this handler
@@ -6437,12 +6449,12 @@ async function handler$7(plugin, ctx, options) {
 
 var downloadFileActionHandler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$7,
-  handler: handler$7
+  code: code$8,
+  handler: handler$8
 });
 
-const code$6 = "uploadFile";
-async function handler$6(plugin, ctx, options) {
+const code$7 = "uploadFile";
+async function handler$7(plugin, ctx, options) {
     const { server, applicationConfig, routerContext, input } = ctx;
     let file = input.file || input.files;
     if (lodash.isArray(file)) {
@@ -6463,8 +6475,8 @@ async function handler$6(plugin, ctx, options) {
 
 var uploadFileActionHandler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$6,
-  handler: handler$6
+  code: code$7,
+  handler: handler$7
 });
 
 var getMyProfile = {
@@ -6509,7 +6521,7 @@ var signout = {
     ],
 };
 
-var pluginRoutes$5 = [getMyProfile, signin, signout];
+var pluginRoutes$6 = [getMyProfile, signin, signout];
 
 /**
  * File manager plugin
@@ -6535,9 +6547,206 @@ class FileManager {
         server.registerActionHandler(this, downloadFileActionHandler);
         server.registerActionHandler(this, uploadFileActionHandler);
     }
+    async configureRoutes(server, applicationConfig) {
+        server.appendApplicationConfig({ routes: pluginRoutes$6 });
+    }
+}
+
+const code$6 = "getLicense";
+async function handler$6(plugin, ctx, options) {
+    const { server, routerContext } = ctx;
+    const licenseService = server.getService("licenseService");
+    const license = licenseService.getLicense();
+    ctx.output = license;
+}
+
+var getLicense$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$6,
+  handler: handler$6
+});
+
+var pluginActionHandlers$6 = [getLicense$1];
+
+var pluginModels$4 = [];
+
+var getLicense = {
+    namespace: "svc",
+    name: "svc.getLicense",
+    code: "svc.getLicense",
+    type: "RESTful",
+    method: "GET",
+    endpoint: "/svc/license",
+    actions: [
+        {
+            code: "getLicense",
+        },
+    ],
+};
+
+var pluginRoutes$5 = [getLicense];
+
+function getEncryptionIV(input) {
+    const hash = crypto__default["default"].createHash("sha512").update(input).digest("hex");
+    return hash.substring(0, 12);
+}
+function generatePubKeyFileContent(base64EncodedPubKey) {
+    return `-----BEGIN PUBLIC KEY-----\n${base64EncodedPubKey}\n-----END PUBLIC KEY-----`;
+}
+const ENC_ALGORITHM = "aes-256-gcm";
+// Decrypt data
+function decryptData(encryptedData, encryptedDataEncoding, decryptedDataEncoding, encryptionKey, encryptionIV, authTag) {
+    const decipher = crypto__default["default"].createDecipheriv(ENC_ALGORITHM, Buffer.from(encryptionKey, "base64"), encryptionIV);
+    decipher.setAuthTag(Buffer.from(authTag, "base64"));
+    const buff = Buffer.from(encryptedData, encryptedDataEncoding);
+    return Buffer.concat([decipher.update(buff), decipher.final()]).toString(decryptedDataEncoding); // Decrypts data and converts to utf8
+}
+function validateDigitalSignature(data, dataEncoding, signature, signatureEncoding, publicKey) {
+    const verify = crypto__default["default"].createVerify("RSA-SHA256");
+    const buffer = Buffer.from(data, dataEncoding);
+    verify.update(buffer);
+    return verify.verify(publicKey, signature, signatureEncoding);
+}
+
+function extractCertLicense(encryptionKey, deployId, cert) {
+    const iv = getEncryptionIV(deployId);
+    const signature = cert.sig;
+    const pub = generatePubKeyFileContent(cert.pub);
+    const valid = validateDigitalSignature(cert.lic, "base64", signature, "base64", pub);
+    if (!valid) {
+        throw new Error("Certification validate failed.");
+    }
+    try {
+        const licenseText = decryptData(cert.lic, "base64", "utf-8", encryptionKey, iv, cert.tag);
+        return JSON.parse(licenseText);
+    }
+    catch (ex) {
+        throw new Error("Certification parse failed.", {
+            cause: ex,
+        });
+    }
+}
+
+class LicenseService {
+    #server;
+    #systemSettingItemManager;
+    #encryptionKey;
+    #license;
+    constructor(server, encryptionKey) {
+        this.#server = server;
+        this.#encryptionKey = encryptionKey;
+        this.#systemSettingItemManager = server.getEntityManager("system_setting_item");
+    }
+    async loadLicense() {
+        const settingService = this.#server.getService("settingService");
+        const licenseSettings = await settingService.getSystemSettingValues("license");
+        const { deployId } = licenseSettings;
+        const certText = licenseSettings.cert;
+        const certJSON = Buffer.from(certText, "base64").toString();
+        const cert = JSON.parse(certJSON);
+        try {
+            const license = extractCertLicense(this.#encryptionKey, deployId, cert);
+            this.#license = license;
+        }
+        catch (error) {
+            this.#server.getLogger().error("Loading license failed.", error);
+            throw new Error("Loading license failed.");
+        }
+    }
+    getLicense() {
+        return this.#license;
+    }
+    isExpired() {
+        if (!this.#license) {
+            return true;
+        }
+        const { neverExpire, expireDate } = this.#license.authority;
+        if (neverExpire) {
+            return false;
+        }
+        if (!expireDate) {
+            return true;
+        }
+        const today = dayjs__default["default"](dayjs__default["default"]().format("YYYY-MM-DD"));
+        return today.isAfter(dayjs__default["default"](expireDate));
+    }
+    getQuota(name) {
+        if (!this.#license) {
+            return null;
+        }
+        return lodash.get(this.#license.authority, `quota.${name}`, null);
+    }
+    isOutOfQuota(name, currentAmount) {
+        const quotaLimit = this.getQuota(name);
+        if (isNullOrUndefinedOrEmpty(quotaLimit)) {
+            return true;
+        }
+        let quotaLimitAmount = quotaLimit;
+        if (lodash.isString(quotaLimitAmount)) {
+            quotaLimitAmount = parseInt(quotaLimit, 10);
+        }
+        if (quotaLimitAmount === -1) {
+            return true;
+        }
+        return currentAmount > quotaLimitAmount;
+    }
+    isFunctionAllowed(name) {
+        if (!this.#license) {
+            return false;
+        }
+        const functions = lodash.get(this.#license.authority, "functions", []);
+        return functions.includes(name);
+    }
+}
+
+/**
+ * License plugin
+ */
+class LicensePlugin {
+    #licenseService;
+    #encryptionKey;
+    constructor(options) {
+        if (!options.encryptionKey) {
+            throw new Error(`"encryptionKey" must be provided.`);
+        }
+        this.#encryptionKey = options.encryptionKey;
+    }
+    get licenseService() {
+        return this.#licenseService;
+    }
+    get code() {
+        return "license";
+    }
+    get description() {
+        return null;
+    }
+    get extendingAbilities() {
+        return [];
+    }
+    get configurableTargets() {
+        return [];
+    }
+    get configurations() {
+        return [];
+    }
+    async registerActionHandlers(server) {
+        for (const actionHandler of pluginActionHandlers$6) {
+            server.registerActionHandler(this, actionHandler);
+        }
+    }
+    async configureModels(server, applicationConfig) {
+        server.appendApplicationConfig({ models: pluginModels$4 });
+    }
+    async configureServices(server, applicationConfig) {
+        this.#licenseService = new LicenseService(server, this.#encryptionKey);
+        server.registerService("licenseService", this.#licenseService);
+    }
     async configureRoutes(server, applicationConfig) {
         server.appendApplicationConfig({ routes: pluginRoutes$5 });
     }
+    async onApplicationLoaded(server, applicationConfig) {
+        await this.#licenseService.loadLicense();
+    }
 }
 
 var pluginActionHandlers$5 = [];
@@ -6667,11 +6876,14 @@ var Notification = {
             columnName: "details",
             description: '{"url": "", "actions": [{"text": "", "url": ""}]}',
             type: "json",
+            required: false,
         },
         {
             name: "用户",
             code: "user",
             type: "relation",
+            required: false,
+            relation: "one",
             targetSingularCode: "oc_user",
             targetIdColumnName: "user_id",
         },
@@ -6986,6 +7198,12 @@ var SystemSettingItem = {
             required: false,
         },
     ],
+    indexes: [
+        {
+            unique: true,
+            properties: ["groupCode", "itemCode"],
+        },
+    ],
 };
 
 var SystemSettingItemSetting = {
@@ -7162,6 +7380,12 @@ var UserSettingItem = {
             required: false,
         },
     ],
+    indexes: [
+        {
+            unique: true,
+            properties: ["ownerId", "groupCode", "itemCode"],
+        },
+    ],
 };
 
 var UserSettingItemSetting = {
@@ -8009,9 +8233,9 @@ class EntityAccessControlPlugin {
         if (!userId) {
             return;
         }
-        const actions = await server.queryDatabaseObject(`select distinct a.* from sys_actions a
-      inner join oc_role_sys_action_links ra on a.id = ra.action_id
-      inner join oc_role_user_links ru on ru.role_id = ra.role_id
+        const actions = await server.queryDatabaseObject(`select distinct a.* from sys_actions a
+      inner join oc_role_sys_action_links ra on a.id = ra.action_id
+      inner join oc_role_user_links ru on ru.role_id = ra.role_id
       where ru.user_id = $1;`, [userId]);
         routeContext.state.allowedActions = actions.map((item) => item.code);
     }
@@ -8038,6 +8262,7 @@ exports.DataManagePlugin = DataManager;
 exports.EntityAccessControlPlugin = EntityAccessControlPlugin;
 exports.FileManagePlugin = FileManager;
 exports.GlobalRequest = GlobalRequest;
+exports.LicensePlugin = LicensePlugin;
 exports.MailPlugin = MailPlugin;
 exports.MetaManagePlugin = MetaManager;
 exports.NotificationPlugin = SequencePlugin;