tachybase_todo/packages/plugins/ui-schema-storage/src/server/server-hooks/index.ts
YANG QIA 70d5b9e44b
feat: localization management (#2210)
* feat: init localization-management

* feat: resource api

* Merge branch 'main' into T-62

* chore: change name

* feat: basic feature

* feat: support filter & sync

* feat: support auto get texts afterSave

* Merge branch 'main' into T-62

* chore: upgrade

* fix: dependency

* fix: field type

* fix: type error

* chore: remove some translations

* feat: support extract text from menu

* chore: cache text keys

* chore: remove test key

* fix: issue of extracting menu titles

* feat: translate collections & fields name

* fix: remove unique of text

* refactor: improve cache

* chore: remove listeners after disable

* chore: translation

* fix: lang switch bug

* refactor: actions & filter

* fix: translation

* refactor: merge lang bundles at backend

* fix: style & field name

* fix: translate issues

* fix: cache bug

* fix: translation merge bug

* fix: translate issues

* fix: map translation

* fix: translation issues

* fix: card title bug

* feat: cover mobile client tabbar

* fix: menu title

* refactor: add locale plugin

* chore: merge locale plugin

* fix: map translation

* chore: remove no data

* style: change button style

* fix: sync bug

* docs: add README

* chore: change name

---------

Co-authored-by: chenos <chenlinxh@gmail.com>
2023-07-17 23:23:44 +08:00

175 lines
4.6 KiB
TypeScript

import { Database } from '@nocobase/database';
import { hooks } from './hooks';
import { ServerHookModel } from './model';
export type HookType =
| 'onSelfDestroy'
| 'onCollectionDestroy'
| 'onCollectionFieldDestroy'
| 'onAnyCollectionFieldDestroy'
| 'onSelfCreate'
| 'onSelfSave'
| 'onSelfMove';
export class ServerHooks {
hooks = new Map<HookType, Map<string, any>>();
constructor(protected db: Database) {
this.listen();
this.registerHooks();
}
registerHooks() {
hooks.forEach((hook) => this.register(hook.hookType, hook.hookName, hook.hookFunc));
}
listen() {
this.db.on('fields.afterDestroy', async (model, options) => {
await this.onCollectionFieldDestroy(model, options);
await this.onAnyCollectionFieldDestroy(model, options);
});
this.db.on('collections.afterDestroy', async (model, options) => {
await this.onCollectionDestroy(model, options);
});
this.db.on('uiSchemas.afterCreateWithAssociations', async (model, options) => {
await this.onUiSchemaCreate(model, options);
});
this.db.on('uiSchemaMove', async (model, options) => {
await this.onUiSchemaMove(model, options);
});
this.db.on('uiSchemas.afterSave', async (model, options) => {
await this.onUiSchemaSave(model, options);
});
}
protected async callSchemaInstanceHooksByType(schemaInstance, options, type: HookType) {
const { transaction } = options;
const hooks = schemaInstance.getServerHooksByType(type);
for (const hook of hooks) {
const hookFunc = this.hooks.get(type)?.get(hook['method']);
await hookFunc?.({
schemaInstance,
options,
db: this.db,
params: hook['params'],
});
}
}
protected async onUiSchemaMove(schemaInstance, options) {
await this.callSchemaInstanceHooksByType(schemaInstance, options, 'onSelfMove');
}
protected async onCollectionDestroy(collectionModel, options) {
const { transaction } = options;
await this.findHooksAndCall(
{
type: 'onCollectionDestroy',
collection: collectionModel.get('name'),
},
{
collectionInstance: collectionModel,
options,
},
transaction,
);
}
protected async onAnyCollectionFieldDestroy(fieldModel, options) {
const { transaction } = options;
const collectionName = fieldModel.get('collectionName');
await this.findHooksAndCall(
{
type: 'onAnyCollectionFieldDestroy',
collection: collectionName,
},
{
collectionFieldInstance: fieldModel,
options,
},
transaction,
);
}
protected async onCollectionFieldDestroy(fieldModel, options) {
const { transaction } = options;
const collectionName = fieldModel.get('collectionName');
const fieldName = fieldModel.get('name');
await this.findHooksAndCall(
{
type: 'onCollectionFieldDestroy',
collection: collectionName,
field: fieldName,
},
{
collectionFieldInstance: fieldModel,
options,
},
transaction,
);
}
protected async onUiSchemaCreate(schemaInstance, options) {
await this.callSchemaInstanceHooksByType(schemaInstance, options, 'onSelfCreate');
}
protected async onUiSchemaSave(schemaInstance, options) {
await this.callSchemaInstanceHooksByType(schemaInstance, options, 'onSelfSave');
}
protected async findHooksAndCall(hooksFilter, hooksArgs, transaction) {
const hooks = (await this.db.getRepository('uiSchemaServerHooks').find({
filter: hooksFilter,
appends: ['uiSchema'],
transaction,
})) as ServerHookModel[];
for (const hookRecord of hooks) {
const hoodMethodName = hookRecord.get('method') as string;
const hookFunc = this.hooks.get(hookRecord.get('type') as HookType)?.get(hoodMethodName);
if (hookFunc) {
await hookFunc({
...hooksArgs,
schemaInstance: (<any>hookRecord).uiSchema,
db: this.db,
params: hookRecord.get('params'),
});
}
}
}
/**
* register a server hook function
* @param type type of server hook
* @param name name of server hook
* @param hookFunc server hook function
*/
register(type: HookType, name: string, hookFunc: any) {
if (!this.hooks.has(type)) {
this.hooks.set(type, new Map());
}
const hookTypeMap = this.hooks.get(type);
hookTypeMap.set(name, hookFunc);
}
remove(type: HookType, name: string) {
if (!this.hooks.has(type)) {
return;
}
const hookTypeMap = this.hooks.get(type);
hookTypeMap.delete(name);
}
}