@steedos/service-metadata-objects 3.0.0-beta.7 → 3.0.0-beta.70
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/lib/actionsHandler.js +45 -21
- package/lib/actionsHandler.js.map +1 -1
- package/lib/formula/core.js +35 -8
- package/lib/formula/core.js.map +1 -1
- package/lib/formula/formulaActionHandler.d.ts +1 -1
- package/lib/formula/formulaActionHandler.js +40 -23
- package/lib/formula/formulaActionHandler.js.map +1 -1
- package/lib/summary/summaryActionHandler.d.ts +2 -2
- package/lib/summary/summaryActionHandler.js +21 -11
- package/lib/summary/summaryActionHandler.js.map +1 -1
- package/package.json +5 -5
- package/src/actionsHandler.ts +335 -258
- package/src/formula/core.ts +44 -10
- package/src/formula/formulaActionHandler.ts +499 -379
- package/src/summary/summaryActionHandler.ts +279 -208
package/src/actionsHandler.ts
CHANGED
|
@@ -1,304 +1,381 @@
|
|
|
1
1
|
import _ = require("lodash");
|
|
2
|
-
import { Register } from
|
|
2
|
+
import { Register } from "@steedos/metadata-registrar";
|
|
3
3
|
import { METADATA_TYPE } from ".";
|
|
4
|
-
import {
|
|
4
|
+
import {
|
|
5
|
+
getObjectServiceName,
|
|
6
|
+
getOriginalObject,
|
|
7
|
+
refreshObject,
|
|
8
|
+
MONGO_BASE_OBJECT,
|
|
9
|
+
SQL_BASE_OBJECT,
|
|
10
|
+
} from "./objects";
|
|
5
11
|
export type SObject = {
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
}
|
|
12
|
+
name: string;
|
|
13
|
+
[x: string]: any;
|
|
14
|
+
};
|
|
9
15
|
|
|
10
16
|
export type MetadataObject = {
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
}
|
|
17
|
+
nodeID: [string];
|
|
18
|
+
service: {
|
|
19
|
+
name: string;
|
|
20
|
+
version: string | undefined;
|
|
21
|
+
fullName: string;
|
|
22
|
+
};
|
|
23
|
+
metadata: SObject;
|
|
24
|
+
};
|
|
19
25
|
|
|
20
|
-
function cacherKey(objectApiName: string): string{
|
|
21
|
-
|
|
26
|
+
function cacherKey(objectApiName: string): string {
|
|
27
|
+
return `$steedos.#${METADATA_TYPE}.${objectApiName}`;
|
|
22
28
|
}
|
|
23
29
|
|
|
24
|
-
const DELAY_MESSAGE_OF_OBJECT_CHANGED
|
|
30
|
+
const DELAY_MESSAGE_OF_OBJECT_CHANGED = 10; // 延迟通知对象事件的时间，单位：毫秒
|
|
25
31
|
|
|
26
32
|
export class ActionHandlers {
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
33
|
+
onRegister: any = null;
|
|
34
|
+
onDestroy: any = null;
|
|
35
|
+
onRegistered: any = null;
|
|
36
|
+
registerObjectMemEntry: Map<string, any>;
|
|
37
|
+
|
|
38
|
+
constructor(onRegister, onDestroy, onRegistered) {
|
|
39
|
+
this.onRegister = onRegister;
|
|
40
|
+
this.onDestroy = onDestroy;
|
|
41
|
+
this.onRegistered = onRegistered;
|
|
42
|
+
this.registerObjectMemEntry = new Map<string, number>();
|
|
43
|
+
}
|
|
31
44
|
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
45
|
+
async registerObject(ctx, objectApiName, data, meta) {
|
|
46
|
+
if (
|
|
47
|
+
objectApiName != MONGO_BASE_OBJECT &&
|
|
48
|
+
objectApiName != SQL_BASE_OBJECT &&
|
|
49
|
+
this.onRegister &&
|
|
50
|
+
_.isFunction(this.onRegister)
|
|
51
|
+
) {
|
|
52
|
+
await this.onRegister(data);
|
|
53
|
+
}
|
|
54
|
+
// await ctx.broker.call('metadata.add', {key: cacherKey(objectApiName), data: data}, {meta: meta});
|
|
55
|
+
await Register.add(
|
|
56
|
+
ctx.broker,
|
|
57
|
+
{ key: cacherKey(objectApiName), data: data },
|
|
58
|
+
meta,
|
|
59
|
+
);
|
|
60
|
+
if (
|
|
61
|
+
objectApiName != MONGO_BASE_OBJECT &&
|
|
62
|
+
objectApiName != SQL_BASE_OBJECT &&
|
|
63
|
+
this.onRegistered &&
|
|
64
|
+
_.isFunction(this.onRegistered)
|
|
65
|
+
) {
|
|
66
|
+
await this.onRegistered(data);
|
|
67
|
+
}
|
|
68
|
+
// 为每个对象 setTimeout 延时执行
|
|
69
|
+
const registerObjectMemEntry = this.registerObjectMemEntry;
|
|
70
|
+
let timeoutId = registerObjectMemEntry.get(objectApiName);
|
|
71
|
+
if (timeoutId) {
|
|
72
|
+
clearTimeout(timeoutId);
|
|
37
73
|
}
|
|
74
|
+
timeoutId = setTimeout(function () {
|
|
75
|
+
ctx.broker.emit("metadata.objects.inserted", {
|
|
76
|
+
objectApiName: objectApiName,
|
|
77
|
+
isInsert: true,
|
|
78
|
+
});
|
|
79
|
+
ctx.broker.broadcast(
|
|
80
|
+
`${data.datasource}.@${objectApiName}.metadata.objects.inserted`,
|
|
81
|
+
{ objectApiName: objectApiName, isInsert: true, data: data },
|
|
82
|
+
);
|
|
83
|
+
registerObjectMemEntry.delete(objectApiName);
|
|
84
|
+
}, DELAY_MESSAGE_OF_OBJECT_CHANGED);
|
|
85
|
+
registerObjectMemEntry.set(objectApiName, timeoutId);
|
|
86
|
+
return true;
|
|
87
|
+
}
|
|
38
88
|
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
await this.onRegister(data)
|
|
43
|
-
}
|
|
44
|
-
// await ctx.broker.call('metadata.add', {key: cacherKey(objectApiName), data: data}, {meta: meta});
|
|
45
|
-
await Register.add(ctx.broker, {key: cacherKey(objectApiName), data: data}, meta)
|
|
46
|
-
if (objectApiName != MONGO_BASE_OBJECT &&
|
|
47
|
-
objectApiName != SQL_BASE_OBJECT && this.onRegistered && _.isFunction(this.onRegistered)) {
|
|
48
|
-
await this.onRegistered(data)
|
|
49
|
-
}
|
|
50
|
-
// 为每个对象 setTimeout 延时执行
|
|
51
|
-
const registerObjectMemEntry = this.registerObjectMemEntry;
|
|
52
|
-
let timeoutId = registerObjectMemEntry.get(objectApiName);
|
|
53
|
-
if (timeoutId) {
|
|
54
|
-
clearTimeout(timeoutId);
|
|
55
|
-
}
|
|
56
|
-
timeoutId = setTimeout(function(){
|
|
57
|
-
ctx.broker.emit("metadata.objects.inserted", {objectApiName: objectApiName, isInsert: true});
|
|
58
|
-
ctx.broker.broadcast(`${data.datasource}.@${objectApiName}.metadata.objects.inserted`, { objectApiName: objectApiName, isInsert: true, data: data });
|
|
59
|
-
registerObjectMemEntry.delete(objectApiName);
|
|
60
|
-
}, DELAY_MESSAGE_OF_OBJECT_CHANGED);
|
|
61
|
-
registerObjectMemEntry.set(objectApiName, timeoutId);
|
|
62
|
-
return true;
|
|
63
|
-
}
|
|
89
|
+
async get(ctx: any): Promise<MetadataObject> {
|
|
90
|
+
return await Register.get(ctx.broker, cacherKey(ctx.params.objectApiName));
|
|
91
|
+
}
|
|
64
92
|
|
|
65
|
-
|
|
66
|
-
|
|
93
|
+
async getAll(ctx: any): Promise<Array<MetadataObject>> {
|
|
94
|
+
const datasource = ctx.params.datasource;
|
|
95
|
+
// const objects = await ctx.broker.call('metadata.filter', {key: cacherKey("*")}, {meta: ctx.meta});
|
|
96
|
+
const objects = await Register.filter(ctx.broker, cacherKey("*"));
|
|
97
|
+
if (datasource) {
|
|
98
|
+
return _.filter(objects, (object) => {
|
|
99
|
+
return object?.metadata?.datasource == datasource;
|
|
100
|
+
});
|
|
67
101
|
}
|
|
102
|
+
return objects;
|
|
103
|
+
}
|
|
68
104
|
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
const objects = await Register.filter(ctx.broker, cacherKey("*"));
|
|
73
|
-
if(datasource){
|
|
74
|
-
return _.filter(objects, (object)=>{
|
|
75
|
-
return object?.metadata?.datasource == datasource;
|
|
76
|
-
});
|
|
77
|
-
}
|
|
78
|
-
return objects
|
|
105
|
+
async add(ctx: any): Promise<boolean> {
|
|
106
|
+
if (true) {
|
|
107
|
+
return true;
|
|
79
108
|
}
|
|
109
|
+
const objectApiName = ctx.params.data.name;
|
|
110
|
+
const data = ctx.params.data;
|
|
111
|
+
const meta = ctx.meta;
|
|
112
|
+
return await this.registerObject(ctx, objectApiName, data, meta);
|
|
113
|
+
}
|
|
80
114
|
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
const objectApiName = ctx.params.data.name;
|
|
86
|
-
const data = ctx.params.data;
|
|
87
|
-
const meta = ctx.meta;
|
|
88
|
-
return await this.registerObject(ctx, objectApiName, data, meta);
|
|
115
|
+
async addConfig(ctx: any): Promise<boolean> {
|
|
116
|
+
let config = ctx.params.data;
|
|
117
|
+
if (config.extend) {
|
|
118
|
+
config.name = config.extend;
|
|
89
119
|
}
|
|
120
|
+
const metadataApiName = config.name;
|
|
121
|
+
if (!config.isMain) {
|
|
122
|
+
// const metadataConfig = await ctx.broker.call('metadata.getServiceMetadata', {
|
|
123
|
+
// serviceName: ctx.meta.metadataServiceName,
|
|
124
|
+
// metadataType: METADATA_TYPE,
|
|
125
|
+
// metadataApiName: metadataApiName,
|
|
126
|
+
// }, {meta: ctx.meta});
|
|
90
127
|
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
// metadataType: METADATA_TYPE,
|
|
101
|
-
// metadataApiName: metadataApiName,
|
|
102
|
-
// }, {meta: ctx.meta});
|
|
103
|
-
|
|
104
|
-
const metadataConfig = await Register.getServiceMetadata(ctx.broker, {
|
|
105
|
-
serviceName: ctx.meta.metadataServiceName,
|
|
106
|
-
metadataType: METADATA_TYPE,
|
|
107
|
-
metadataApiName: metadataApiName,
|
|
108
|
-
}, ctx.meta)
|
|
128
|
+
const metadataConfig = await Register.getServiceMetadata(
|
|
129
|
+
ctx.broker,
|
|
130
|
+
{
|
|
131
|
+
serviceName: ctx.meta.metadataServiceName,
|
|
132
|
+
metadataType: METADATA_TYPE,
|
|
133
|
+
metadataApiName: metadataApiName,
|
|
134
|
+
},
|
|
135
|
+
ctx.meta,
|
|
136
|
+
);
|
|
109
137
|
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
138
|
+
if (metadataConfig && metadataConfig.metadata) {
|
|
139
|
+
config.list_views = _.defaultsDeep(
|
|
140
|
+
metadataConfig.metadata.list_views || {},
|
|
141
|
+
config.list_views || {},
|
|
142
|
+
);
|
|
143
|
+
config = _.defaultsDeep(config, metadataConfig.metadata);
|
|
144
|
+
}
|
|
145
|
+
}
|
|
115
146
|
|
|
116
|
-
|
|
147
|
+
// await ctx.broker.call('metadata.addServiceMetadata', { key: cacherKey(metadataApiName), data: config }, { meta: Object.assign({}, ctx.meta, { metadataType: METADATA_TYPE, metadataApiName: metadataApiName }) })
|
|
117
148
|
|
|
118
|
-
|
|
149
|
+
await Register.addServiceMetadata(
|
|
150
|
+
ctx.broker,
|
|
151
|
+
{ key: cacherKey(metadataApiName), data: config },
|
|
152
|
+
Object.assign({}, ctx.meta, {
|
|
153
|
+
metadataType: METADATA_TYPE,
|
|
154
|
+
metadataApiName: metadataApiName,
|
|
155
|
+
}),
|
|
156
|
+
);
|
|
119
157
|
|
|
120
|
-
|
|
158
|
+
const objectConfig = await refreshObject(ctx, metadataApiName);
|
|
121
159
|
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
}
|
|
125
|
-
|
|
126
|
-
const objectServiceName = getObjectServiceName(metadataApiName);
|
|
127
|
-
|
|
128
|
-
const result = await this.registerObject(ctx, metadataApiName, objectConfig, {
|
|
129
|
-
caller: {
|
|
130
|
-
// nodeID: broker.nodeID,
|
|
131
|
-
service: {
|
|
132
|
-
name: objectServiceName,
|
|
133
|
-
// version: broker.service.version, TODO
|
|
134
|
-
// fullName: broker.service.fullName, TODO
|
|
135
|
-
}
|
|
136
|
-
}
|
|
137
|
-
});
|
|
138
|
-
return result;
|
|
160
|
+
if (!objectConfig) {
|
|
161
|
+
return;
|
|
139
162
|
}
|
|
140
163
|
|
|
141
|
-
|
|
142
|
-
let configs = ctx.params.data;
|
|
143
|
-
for (let config of configs) {
|
|
144
|
-
if (config.extend) {
|
|
145
|
-
config.name = config.extend
|
|
146
|
-
}
|
|
147
|
-
const metadataApiName = config.name;
|
|
148
|
-
if (!config.isMain) {
|
|
149
|
-
// const metadataConfig = await ctx.broker.call('metadata.getServiceMetadata', {
|
|
150
|
-
// serviceName: ctx.meta.metadataServiceName,
|
|
151
|
-
// metadataType: METADATA_TYPE,
|
|
152
|
-
// metadataApiName: metadataApiName,
|
|
153
|
-
// }, { meta: ctx.meta });
|
|
164
|
+
const objectServiceName = getObjectServiceName(metadataApiName);
|
|
154
165
|
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
166
|
+
const result = await this.registerObject(
|
|
167
|
+
ctx,
|
|
168
|
+
metadataApiName,
|
|
169
|
+
objectConfig,
|
|
170
|
+
{
|
|
171
|
+
caller: {
|
|
172
|
+
// nodeID: broker.nodeID,
|
|
173
|
+
service: {
|
|
174
|
+
name: objectServiceName,
|
|
175
|
+
// version: broker.service.version, TODO
|
|
176
|
+
// fullName: broker.service.fullName, TODO
|
|
177
|
+
},
|
|
178
|
+
},
|
|
179
|
+
},
|
|
180
|
+
);
|
|
181
|
+
return result;
|
|
182
|
+
}
|
|
160
183
|
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
184
|
+
async addConfigs(ctx: any): Promise<boolean> {
|
|
185
|
+
let configs = ctx.params.data;
|
|
186
|
+
for (let config of configs) {
|
|
187
|
+
if (config.extend) {
|
|
188
|
+
config.name = config.extend;
|
|
189
|
+
}
|
|
190
|
+
const metadataApiName = config.name;
|
|
191
|
+
if (!config.isMain) {
|
|
192
|
+
// const metadataConfig = await ctx.broker.call('metadata.getServiceMetadata', {
|
|
193
|
+
// serviceName: ctx.meta.metadataServiceName,
|
|
194
|
+
// metadataType: METADATA_TYPE,
|
|
195
|
+
// metadataApiName: metadataApiName,
|
|
196
|
+
// }, { meta: ctx.meta });
|
|
167
197
|
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
198
|
+
const metadataConfig = await Register.getServiceMetadata(
|
|
199
|
+
ctx.broker,
|
|
200
|
+
{
|
|
201
|
+
serviceName: ctx.meta.metadataServiceName,
|
|
202
|
+
metadataType: METADATA_TYPE,
|
|
203
|
+
metadataApiName: metadataApiName,
|
|
204
|
+
},
|
|
205
|
+
ctx.meta,
|
|
206
|
+
);
|
|
172
207
|
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
|
|
177
|
-
|
|
178
|
-
|
|
179
|
-
await this.registerObject(ctx, metadataApiName, objectConfig, {
|
|
180
|
-
caller: {
|
|
181
|
-
// nodeID: broker.nodeID,
|
|
182
|
-
service: {
|
|
183
|
-
name: objectServiceName,
|
|
184
|
-
// version: broker.service.version, TODO
|
|
185
|
-
// fullName: broker.service.fullName, TODO
|
|
186
|
-
}
|
|
187
|
-
}
|
|
188
|
-
});
|
|
208
|
+
if (metadataConfig && metadataConfig.metadata) {
|
|
209
|
+
config.list_views = _.defaultsDeep(
|
|
210
|
+
metadataConfig.metadata.list_views || {},
|
|
211
|
+
config.list_views || {},
|
|
212
|
+
);
|
|
213
|
+
config = _.defaultsDeep(config, metadataConfig.metadata);
|
|
189
214
|
}
|
|
190
|
-
|
|
191
|
-
|
|
215
|
+
}
|
|
216
|
+
// await ctx.broker.call('metadata.addServiceMetadata', { key: cacherKey(metadataApiName), data: config }, { meta: Object.assign({}, ctx.meta, { metadataType: METADATA_TYPE, metadataApiName: metadataApiName }) })
|
|
192
217
|
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
}
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
218
|
+
await Register.addServiceMetadata(
|
|
219
|
+
ctx.broker,
|
|
220
|
+
{
|
|
221
|
+
key: cacherKey(metadataApiName),
|
|
222
|
+
data: config,
|
|
223
|
+
},
|
|
224
|
+
Object.assign({}, ctx.meta, {
|
|
225
|
+
metadataType: METADATA_TYPE,
|
|
226
|
+
metadataApiName: metadataApiName,
|
|
227
|
+
}),
|
|
228
|
+
);
|
|
229
|
+
|
|
230
|
+
const objectConfig = await refreshObject(ctx, metadataApiName);
|
|
231
|
+
if (!objectConfig) {
|
|
232
|
+
ctx.broker.logger.error(
|
|
233
|
+
`not find extend object ${metadataApiName}, Please check 「${ctx.meta.metadataServiceName}」 package.service.js for dependencies`,
|
|
234
|
+
);
|
|
235
|
+
break;
|
|
236
|
+
}
|
|
237
|
+
const objectServiceName = getObjectServiceName(metadataApiName);
|
|
238
|
+
await this.registerObject(ctx, metadataApiName, objectConfig, {
|
|
239
|
+
caller: {
|
|
240
|
+
// nodeID: broker.nodeID,
|
|
241
|
+
service: {
|
|
242
|
+
name: objectServiceName,
|
|
243
|
+
// version: broker.service.version, TODO
|
|
244
|
+
// fullName: broker.service.fullName, TODO
|
|
245
|
+
},
|
|
246
|
+
},
|
|
247
|
+
});
|
|
203
248
|
}
|
|
249
|
+
return true;
|
|
250
|
+
}
|
|
204
251
|
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
252
|
+
async change(ctx: any): Promise<boolean> {
|
|
253
|
+
const { data, oldData } = ctx.params;
|
|
254
|
+
if (oldData.name != data.name) {
|
|
255
|
+
// console.log(`change==================`, oldData.name, data.name);
|
|
256
|
+
await this.deleteObject(ctx, oldData.name);
|
|
257
|
+
}
|
|
258
|
+
// await ctx.broker.call('metadata.add', {key: cacherKey(data.name), data: data}, {meta: ctx.meta})
|
|
259
|
+
await Register.add(
|
|
260
|
+
ctx.broker,
|
|
261
|
+
{ key: cacherKey(data.name), data: data },
|
|
262
|
+
ctx.meta,
|
|
263
|
+
);
|
|
264
|
+
ctx.broker.emit("metadata.objects.updated", {
|
|
265
|
+
objectApiName: data.name,
|
|
266
|
+
oldObjectApiName: oldData.name,
|
|
267
|
+
isUpdate: true,
|
|
268
|
+
});
|
|
269
|
+
return true;
|
|
270
|
+
}
|
|
214
271
|
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
}
|
|
225
|
-
}
|
|
226
|
-
});
|
|
227
|
-
return true;
|
|
228
|
-
}
|
|
272
|
+
async removeConfig(ctx: any): Promise<boolean> {
|
|
273
|
+
const { serviceName = "~database-objects", objectName } = ctx.params;
|
|
274
|
+
await Register.deleteServiceMetadata(ctx.broker, {
|
|
275
|
+
nodeID: ctx.broker.nodeID,
|
|
276
|
+
serviceName: serviceName,
|
|
277
|
+
metadataType: METADATA_TYPE,
|
|
278
|
+
metadataApiName: objectName,
|
|
279
|
+
});
|
|
280
|
+
const objectConfig = await refreshObject(ctx, objectName);
|
|
229
281
|
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
282
|
+
if (!objectConfig) {
|
|
283
|
+
await this.deleteObject(ctx, objectName);
|
|
284
|
+
return;
|
|
233
285
|
}
|
|
286
|
+
const objectServiceName = getObjectServiceName(objectName);
|
|
287
|
+
await this.registerObject(ctx, objectName, objectConfig, {
|
|
288
|
+
caller: {
|
|
289
|
+
// nodeID: broker.nodeID,
|
|
290
|
+
service: {
|
|
291
|
+
name: objectServiceName,
|
|
292
|
+
},
|
|
293
|
+
},
|
|
294
|
+
});
|
|
295
|
+
return true;
|
|
296
|
+
}
|
|
234
297
|
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
298
|
+
async delete(ctx: any): Promise<boolean> {
|
|
299
|
+
// console.log(`delete==================`, ctx.params.objectApiName);
|
|
300
|
+
return await this.deleteObject(ctx, ctx.params.objectApiName);
|
|
301
|
+
}
|
|
239
302
|
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
303
|
+
async verify(ctx: any): Promise<boolean> {
|
|
304
|
+
console.log("verify");
|
|
305
|
+
return true;
|
|
306
|
+
}
|
|
243
307
|
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
|
|
308
|
+
async getOriginalObject(ctx: any): Promise<boolean> {
|
|
309
|
+
return await getOriginalObject(ctx, ctx.params.objectApiName);
|
|
310
|
+
}
|
|
311
|
+
|
|
312
|
+
async refresh(ctx) {
|
|
313
|
+
const { isClear, metadataApiNames } = ctx.params;
|
|
314
|
+
if (isClear) {
|
|
315
|
+
for await (const metadataApiName of metadataApiNames) {
|
|
316
|
+
const objectConfig = await refreshObject(ctx, metadataApiName);
|
|
317
|
+
if (!objectConfig) {
|
|
318
|
+
// console.log(`refresh deleteObject==================`, metadataApiName);
|
|
319
|
+
await this.deleteObject(ctx, metadataApiName);
|
|
320
|
+
} else {
|
|
321
|
+
const objectServiceName = getObjectServiceName(metadataApiName);
|
|
322
|
+
await this.registerObject(ctx, metadataApiName, objectConfig, {
|
|
323
|
+
caller: {
|
|
324
|
+
// nodeID: broker.nodeID,
|
|
325
|
+
service: {
|
|
326
|
+
name: objectServiceName,
|
|
327
|
+
// version: broker.service.version, TODO
|
|
328
|
+
// fullName: broker.service.fullName, TODO
|
|
329
|
+
},
|
|
330
|
+
},
|
|
331
|
+
});
|
|
266
332
|
}
|
|
333
|
+
}
|
|
267
334
|
}
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
|
|
335
|
+
}
|
|
336
|
+
async deleteObject(ctx, objectApiName): Promise<boolean> {
|
|
337
|
+
await ctx.broker.broadcast(`delete.metadata.${METADATA_TYPE}`, {
|
|
338
|
+
objectApiName: objectApiName,
|
|
339
|
+
});
|
|
340
|
+
return true;
|
|
341
|
+
}
|
|
342
|
+
async handleDeleteObject(ctx, objectApiName): Promise<boolean> {
|
|
343
|
+
// const { metadata } = (await ctx.broker.call("metadata.get", { key: cacherKey(objectApiName) }, { meta: ctx.meta })) || {};
|
|
344
|
+
const { metadata } =
|
|
345
|
+
(await Register.get(ctx.broker, cacherKey(objectApiName))) || {};
|
|
346
|
+
// await ctx.broker.call('metadata.delete', {key: cacherKey(objectApiName)}, {meta: ctx.meta})
|
|
347
|
+
await Register.delete(ctx.broker, cacherKey(objectApiName));
|
|
348
|
+
try {
|
|
349
|
+
// await ctx.broker.call('metadata.deleteServiceMetadata', {
|
|
350
|
+
// nodeID: ctx.broker.nodeID,
|
|
351
|
+
// serviceName: '~database-objects',
|
|
352
|
+
// metadataType: METADATA_TYPE,
|
|
353
|
+
// metadataApiName: objectApiName
|
|
354
|
+
// }, {meta: ctx.meta})
|
|
284
355
|
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
356
|
+
await Register.deleteServiceMetadata(ctx.broker, {
|
|
357
|
+
nodeID: ctx.broker.nodeID,
|
|
358
|
+
serviceName: "~database-objects",
|
|
359
|
+
metadataType: METADATA_TYPE,
|
|
360
|
+
metadataApiName: objectApiName,
|
|
361
|
+
});
|
|
362
|
+
} catch (error) {
|
|
363
|
+
console.log(error);
|
|
364
|
+
}
|
|
365
|
+
if (this.onDestroy && _.isFunction(this.onDestroy)) {
|
|
366
|
+
await this.onDestroy(metadata);
|
|
367
|
+
}
|
|
368
|
+
await ctx.broker.broadcast("metadata.objects.deleted", {
|
|
369
|
+
objectApiName: objectApiName,
|
|
370
|
+
isDelete: true,
|
|
371
|
+
objectConfig: metadata,
|
|
372
|
+
});
|
|
373
|
+
if (metadata) {
|
|
374
|
+
await ctx.broker.broadcast(
|
|
375
|
+
`${metadata.datasource}.@${objectApiName}.metadata.objects.deleted`,
|
|
376
|
+
{ objectApiName: objectApiName, data: metadata },
|
|
377
|
+
);
|
|
303
378
|
}
|
|
379
|
+
return true;
|
|
380
|
+
}
|
|
304
381
|
}
|