1 | import { repository } from "../core/decorators";
|
2 | import { preauthorize } from "../core/decorators/preauthorize";
|
3 | import { entityAction, EntityActionParam } from "../core/decorators/entityAction";
|
4 | import { postfilter } from "../core/decorators/postfilter";
|
5 | import { authorize } from "../core/decorators/authorize";
|
6 | import { } from '../di/decorators/inject';
|
7 | import { DynamicRepository } from '../core/dynamic/dynamic-repository';
|
8 | import { inject } from '../di/decorators/inject';
|
9 | import Q = require('q');
|
10 |
|
11 | import * as logger from "../logging";
|
12 |
|
13 |
|
14 | export class AuthorizationRepository extends DynamicRepository {
|
15 |
|
16 | logger = logger.winstonLog;
|
17 |
|
18 |
|
19 | preCreate(params: EntityActionParam): Q.Promise<EntityActionParam> {
|
20 | return Q.resolve(params);
|
21 | }
|
22 |
|
23 | postCreate(params: EntityActionParam): Q.Promise<EntityActionParam> {
|
24 | return Q.when(params);
|
25 | }
|
26 |
|
27 | preUpdate(params: EntityActionParam): Q.Promise<EntityActionParam> {
|
28 | return Q.resolve(params);
|
29 | }
|
30 |
|
31 | postUpdate(params: EntityActionParam): Q.Promise<EntityActionParam> {
|
32 | return Q.when(params);
|
33 | }
|
34 |
|
35 |
|
36 | preBulkCreate(params: Array<EntityActionParam>): Q.Promise<Array<EntityActionParam>> {
|
37 | return Q.resolve(params);
|
38 | }
|
39 |
|
40 | preBulkDelete(params: Array<EntityActionParam>): Q.Promise<Array<EntityActionParam>> {
|
41 | return Q.resolve(params);
|
42 | }
|
43 |
|
44 | postBulkCreate(params: Array<EntityActionParam>): Q.Promise<Array<EntityActionParam>> {
|
45 | return Q.resolve(params);
|
46 | }
|
47 |
|
48 | preBulkUpdate(params: Array<EntityActionParam>): Q.Promise<Array<EntityActionParam>> {
|
49 | return Q.when(params);
|
50 | }
|
51 |
|
52 | postBulkUpdate(params: Array<EntityActionParam>): Q.Promise<Array<EntityActionParam>> {
|
53 | return Q.when(params);
|
54 | }
|
55 |
|
56 | preDelete(params: EntityActionParam): Q.Promise<EntityActionParam> {
|
57 | return Q.when(params);
|
58 | }
|
59 |
|
60 | postDelete(params: EntityActionParam): Q.Promise<EntityActionParam> {
|
61 | return Q.when(params);
|
62 | }
|
63 |
|
64 | postBulkDelete(params: Array<EntityActionParam>): Q.Promise<Array<EntityActionParam>> {
|
65 | return Q.when(params);
|
66 | }
|
67 |
|
68 | preRead(params: EntityActionParam): Q.Promise<EntityActionParam> {
|
69 | return Q.when(params);
|
70 | }
|
71 |
|
72 | postRead(params: EntityActionParam): Q.Promise<any> {
|
73 | return Q.when(params);
|
74 | }
|
75 |
|
76 | preBulkRead(params: Array<EntityActionParam>): Q.Promise<Array<EntityActionParam>> {
|
77 | return Q.when(params);
|
78 | }
|
79 |
|
80 | postBulkRead(params: Array<EntityActionParam>): Q.Promise<Array<EntityActionParam>> {
|
81 | return Q.when(params);
|
82 | }
|
83 |
|
84 | @entityAction({ serviceName: "authorizationService", methodName: "canCreateEntities" })
|
85 | bulkPost(objArr: Array<any>, batchSize?: number): Q.Promise<any> {
|
86 | let actionEntities: Array<EntityActionParam> = this.getEntityFromArgs.apply(this, arguments);
|
87 | if (!actionEntities) {
|
88 | actionEntities = [];
|
89 | }
|
90 | this.logEntityInfo("bulkPost", objArr);
|
91 | return this.preBulkCreate(actionEntities)
|
92 | .then((params: Array<EntityActionParam>) => {
|
93 | let entitiesToCreate: Array<any> = new Array<any>();
|
94 | params.forEach((input: EntityActionParam) => { entitiesToCreate.push(input.inputEntity); });
|
95 | arguments[0] = entitiesToCreate;
|
96 | arguments[arguments.length - 1] = undefined;
|
97 | return super.bulkPost.apply(this, arguments).then((createdDbOEntites: Array<any>) => {
|
98 | let indexInMainCollection: number = 0;
|
99 | createdDbOEntites.forEach((createdEntity) => {
|
100 | actionEntities[indexInMainCollection].newPersistentEntity = createdEntity;
|
101 | indexInMainCollection++;
|
102 | })
|
103 |
|
104 | return this.postBulkCreate(actionEntities).then((result) => {
|
105 | return result.map(x => x.newPersistentEntity)
|
106 | }
|
107 | );
|
108 | }, (error) => {
|
109 | return Q.reject(error);
|
110 | })
|
111 | }, (error) => {
|
112 | return Q.reject(error);
|
113 | });
|
114 |
|
115 | }
|
116 |
|
117 | @entityAction({ serviceName: "authorizationService", methodName: "canSaveEntities" })
|
118 | bulkPut(objArr: Array<any>, batchSize?: number, donotLoadChilds?: boolean) {
|
119 | if (!objArr || !objArr.length) return Q.when(objArr);
|
120 | let actionEntities: Array<EntityActionParam> = this.getEntityFromArgs.apply(this, arguments);
|
121 | if (!actionEntities) {
|
122 | actionEntities = [];
|
123 | }
|
124 | this.logEntityInfo("bulkPut", objArr);
|
125 | return this.preBulkUpdate(actionEntities)
|
126 | .then((params: Array<EntityActionParam>) => {
|
127 | let entitiesToUpdate: Array<any> = new Array<any>();
|
128 | params.forEach((input: EntityActionParam) => { input.newPersistentEntity.__dbEntity = input.oldPersistentEntity; entitiesToUpdate.push(input.newPersistentEntity); });
|
129 | arguments[0] = entitiesToUpdate;
|
130 | arguments[arguments.length - 1] = undefined;
|
131 | return super.bulkPut.apply(this, arguments).then((createdDbOEntites: Array<any>) => {
|
132 | let indexInMainCollection: number = 0;
|
133 | createdDbOEntites.forEach((createdEntity) => {
|
134 | actionEntities[indexInMainCollection].newPersistentEntity = createdEntity;
|
135 | indexInMainCollection++;
|
136 | })
|
137 |
|
138 | return this.postBulkUpdate(actionEntities).then((result) =>
|
139 | result.map(x => x.newPersistentEntity)
|
140 | );
|
141 | }, (error) => {
|
142 | return Q.reject(error);
|
143 | })
|
144 | }, (error) => {
|
145 | return Q.reject(error);
|
146 | });
|
147 | }
|
148 |
|
149 | @entityAction({ serviceName: "authorizationService", methodName: "canSaveEntities" })
|
150 | bulkDel(params: Array<any>) {
|
151 | let actionParams: Array<EntityActionParam> = this.getEntityFromArgs.apply(this, arguments);
|
152 | let entitiesToDelete = [];
|
153 | if (!actionParams) {
|
154 | actionParams = [];
|
155 | }
|
156 | this.logEntityInfo("bulkDel", params);
|
157 | actionParams.forEach((input: EntityActionParam) => { entitiesToDelete.push(input.newPersistentEntity); })
|
158 | return this.preBulkDelete(actionParams)
|
159 | .then((params: Array<EntityActionParam>) => {
|
160 | return super.bulkDel(entitiesToDelete).then((updatedDbObj: Array<any>) => {
|
161 | return this.postBulkDelete(actionParams).then((result) =>
|
162 | result.map(x => x.newPersistentEntity)
|
163 | );
|
164 | }, (error) => {
|
165 | return Q.reject(error);
|
166 | })
|
167 | }, (error) => {
|
168 | return Q.reject(error);
|
169 | });
|
170 | }
|
171 |
|
172 |
|
173 |
|
174 | public bulkPutMany(objIds: Array<any>, obj: any) {
|
175 | obj._id = objIds[0];
|
176 | this.logEntityInfo("bulkPutMany", objIds);
|
177 | return super.bulkPutMany(objIds, obj);
|
178 | }
|
179 |
|
180 | @entityAction({ serviceName: "authorizationService", methodName: "canReadActionEntity" })
|
181 | findOne(id: any, donotLoadChilds?: boolean): Q.Promise<any> {
|
182 | let params: EntityActionParam = this.getEntityFromArgs.apply(this, arguments);
|
183 | if (!params) {
|
184 | params = {};
|
185 | }
|
186 | return this.preRead(params).then(result => {
|
187 | return this.postRead(result).then((updatedParams: EntityActionParam) => {
|
188 | return Q.resolve(updatedParams.newPersistentEntity);
|
189 | }).catch(exc => {
|
190 | return Q.reject(exc);
|
191 | });
|
192 | }).catch(exc => {
|
193 | return Q.reject(exc);
|
194 | });
|
195 | }
|
196 |
|
197 | @entityAction({ serviceName: "authorizationService", methodName: "canReadActionEntities" })
|
198 | findMany(ids: Array<any>, toLoadEmbededChilds?: boolean): Q.Promise<any> {
|
199 | let actionEntities: Array<EntityActionParam> = this.getEntityFromArgs.apply(this, arguments);
|
200 | if (!actionEntities) {
|
201 | actionEntities = [];
|
202 | }
|
203 | return this.preBulkRead(actionEntities).then(results => {
|
204 | return this.postBulkRead(results).then(newResults => {
|
205 | return Q.when(newResults.map(entity => entity.newPersistentEntity));
|
206 | }).catch(exc => {
|
207 | this.logger.logError(exc);
|
208 | return Q.reject(exc);
|
209 | });
|
210 | }).catch(exc => {
|
211 | this.logger.logError(exc);
|
212 | return Q.reject(exc);
|
213 | });
|
214 | }
|
215 |
|
216 |
|
217 |
|
218 |
|
219 |
|
220 | @entityAction({ serviceName: "authorizationService", methodName: "canReadActionEntities" })
|
221 | findWhere(query, selectedFields?: Array<any> | any, queryOptions?: any, toLoadChilds?: boolean): Q.Promise<any> {
|
222 | let actionEntities: Array<EntityActionParam> = this.getEntityFromArgs.apply(this, arguments);
|
223 | if (!actionEntities) {
|
224 | actionEntities = [];
|
225 | }
|
226 | return this.preBulkRead(actionEntities).then(results => {
|
227 | return this.postBulkRead(results).then(newResults => {
|
228 | return Q.when(newResults.map(entity => entity.newPersistentEntity));
|
229 | }).catch(exc => {
|
230 | this.logger.logError(exc);
|
231 | return Q.reject(exc);
|
232 | });
|
233 | }).catch(exc => {
|
234 | this.logger.logError(exc);
|
235 | return Q.reject(exc);
|
236 | });
|
237 | }
|
238 |
|
239 | findByField(fieldName, value): Q.Promise<any> {
|
240 | return super.findByField(fieldName, value);
|
241 | }
|
242 |
|
243 | @postfilter({ serviceName: "authorizationService", methodName: "canReadChildren" })
|
244 | findChild(id, prop): Q.Promise<any> {
|
245 | return super.findChild(id, prop);
|
246 | }
|
247 |
|
248 |
|
249 | @entityAction({ serviceName: "authorizationService", methodName: "canSaveEntity" })
|
250 | put(id: any, obj: any): Q.Promise<any> {
|
251 | let resultEntityActionObj: EntityActionParam = this.getEntityFromArgs.apply(this, arguments);
|
252 | if (!resultEntityActionObj) {
|
253 | resultEntityActionObj = {};
|
254 | }
|
255 | this.logEntityInfo("put", obj);
|
256 | return this.preUpdate(resultEntityActionObj)
|
257 | .then((params: EntityActionParam) => {
|
258 | params.newPersistentEntity.__dbEntity = params.oldPersistentEntity;
|
259 | return super.put(id, params.newPersistentEntity).then((updatedDbObj: any) => {
|
260 | resultEntityActionObj.newPersistentEntity = updatedDbObj;
|
261 | return this.postUpdate(resultEntityActionObj).then((updatedEntity: EntityActionParam) => {
|
262 | return Q.when(updatedEntity.newPersistentEntity);
|
263 | }, (exc) => {
|
264 | return Q.reject(exc);
|
265 | });
|
266 | }, (error) => {
|
267 | return Q.reject(error);
|
268 | })
|
269 | }, (error) => {
|
270 | return Q.reject(error);
|
271 | });
|
272 |
|
273 | }
|
274 |
|
275 |
|
276 | @entityAction({ serviceName: "authorizationService", methodName: "canSaveEntity" })
|
277 | post(obj: any): Q.Promise<any> {
|
278 | this.logEntityInfo("post", obj);
|
279 | let resultEntityActionObj: EntityActionParam = this.getEntityFromArgs.apply(this, arguments);
|
280 | if (!resultEntityActionObj) {
|
281 | resultEntityActionObj = {};
|
282 | }
|
283 | return this.preCreate(resultEntityActionObj)
|
284 | .then((params: EntityActionParam) => {
|
285 | return super.post(params.inputEntity).then((updatedDbObj: any) => {
|
286 | resultEntityActionObj.newPersistentEntity = updatedDbObj;
|
287 | return this.postCreate(resultEntityActionObj).then((result) => result.newPersistentEntity);
|
288 | }, (error) => {
|
289 | return Q.reject(error);
|
290 | })
|
291 | }, (error) => {
|
292 | return Q.reject(error);
|
293 | });
|
294 | }
|
295 |
|
296 | @entityAction({ serviceName: "authorizationService", methodName: "canDeleteEntity" })
|
297 | delete(obj: any) {
|
298 | let resultEntityActionObj: EntityActionParam = this.getEntityFromArgs.apply(this, arguments);
|
299 | if (!resultEntityActionObj) {
|
300 | resultEntityActionObj = {};
|
301 | }
|
302 | this.logEntityInfo("delete", resultEntityActionObj.newPersistentEntity._id);
|
303 | return this.preDelete(resultEntityActionObj)
|
304 | .then((params: EntityActionParam) => {
|
305 | return super.delete(resultEntityActionObj.newPersistentEntity._id).then((updatedDbObj: any) => {
|
306 | resultEntityActionObj.newPersistentEntity = updatedDbObj;
|
307 | return this.postDelete(resultEntityActionObj).then((result) => result.newPersistentEntity);
|
308 | }, (error) => {
|
309 | return Q.reject(error);
|
310 | })
|
311 | }, (error) => {
|
312 | return Q.reject(error);
|
313 | });
|
314 | }
|
315 |
|
316 | @entityAction({ serviceName: "authorizationService", methodName: "canSaveEntity" })
|
317 | patch(id: any, obj) {
|
318 | this.logEntityInfo("patch", obj);
|
319 | let resultEntityActionObj: EntityActionParam = this.getEntityFromArgs.apply(this, arguments);
|
320 | if (!resultEntityActionObj) {
|
321 | resultEntityActionObj = {};
|
322 | }
|
323 | return this.preUpdate(resultEntityActionObj)
|
324 | .then((params: EntityActionParam) => {
|
325 | params.inputEntity.__dbEntity = params.oldPersistentEntity;
|
326 | return super.patch(id, params.inputEntity).then((updatedDbObj: any) => {
|
327 | resultEntityActionObj.newPersistentEntity = updatedDbObj;
|
328 |
|
329 | return this.postUpdate(resultEntityActionObj).then((updatedEntity: EntityActionParam) => {
|
330 | return Q.when(updatedEntity.newPersistentEntity);
|
331 | }, (exc) => {
|
332 | return Q.reject(exc);
|
333 | });
|
334 | }, (error) => {
|
335 | return Q.reject(error);
|
336 | })
|
337 | }, (error) => {
|
338 | return Q.reject(error);
|
339 | });
|
340 |
|
341 | }
|
342 |
|
343 |
|
344 | @entityAction({ serviceName: "authorizationService", methodName: "canReadActionEntities" })
|
345 | findAll(): any {
|
346 | let actionEntities: Array<EntityActionParam> = this.getEntityFromArgs.apply(this, arguments);
|
347 | if (!actionEntities) {
|
348 | actionEntities = [];
|
349 | }
|
350 | return this.postBulkRead(actionEntities).then((newResults: Array<EntityActionParam>) => {
|
351 | return Q.when(newResults.map((x: EntityActionParam) => x.newPersistentEntity));
|
352 | }).catch(exc => {
|
353 | this.logger.logError(exc);
|
354 | return Q.reject(exc);
|
355 | });
|
356 | }
|
357 |
|
358 | getEntityType(): any {
|
359 | return super.getEntityType();
|
360 | }
|
361 |
|
362 | private getEntityFromArgs() {
|
363 | let args: Array<any> = Array.apply(null, arguments);
|
364 | let params: EntityActionParam = <EntityActionParam>args[args.length - 1];
|
365 | return params;
|
366 | }
|
367 |
|
368 | private logEntityInfo(methodName: string, obj: any) {
|
369 |
|
370 |
|
371 |
|
372 |
|
373 |
|
374 |
|
375 |
|
376 | }
|
377 |
|
378 | }
|
379 | export default AuthorizationRepository;
|