(test) : début ajout de feature pour l'aggréation dans l'API.

src/Abstract/Model.ts

@@ -125,5 +125,6 @@ abstract class AbstractModel {
     abstract dataTransfertObject(document: any):any;
 
     abstract documentation():Promise<any>;
+
 }
 export default AbstractModel;

src/Database/QueryBuilder/ApiQuery.ts

@@ -22,6 +22,8 @@ export default class ApiQuery {
     public sections:Array<any>;
     private _transmuted:any;
     private _options:any;
+    private _lookup:any;
+    private _matches:any;
     private _projections:any;
 
     /**
@@ -57,6 +59,7 @@ export default class ApiQuery {
         return this._transmuted;
     }
 
+
     public set options(values) {
         this._options = values;
     }
@@ -70,6 +73,31 @@ export default class ApiQuery {
         return this._options;
     }
 
+
+    public set matches(values:any) {
+        this._matches = values;
+    }
+
+    public get matches() {
+        return this._matches;
+    }
+
+
+    public set lookup(values:any) {
+        /*
+        from: Collection,
+        localField: current Model field to match the value of ForeignField,
+        foreignField: The field to match the from collection,
+        as: Name of the properties to push the data.,
+         */
+        this._lookup = values;
+    }
+
+    public get lookup() {
+        return this._lookup;
+    }
+
+
     public get projections() {
         return {};
     }

src/Database/Search/SearchRoutes.ts

@@ -31,7 +31,8 @@ class SearchRoutes extends AbstractRoute {
      */
     public setupPublicRoutes(): express.Router {
 
-        this.routerInstance.get('/', [this.fullSearchHandler.bind(this), this.routeSendResponse.bind(this)])
+        this.routerInstance.get('/', [this.fullSearchHandler.bind(this), this.routeSendResponse.bind(this)]);
+        this.routerInstance.get('/all', [this.aggregateAllHandler.bind(this), this.routeSendResponse.bind(this)]);
         this.routerInstance.get('/regex', [this.textSearchSuggestionsHandler.bind(this), this.routeSendResponse.bind(this)]);
         this.routerInstance.get('/text', [this.textSearchResultsHandler.bind(this), this.routeSendResponse.bind(this)]);
         this.routerInstance.get('/nearestTaxonomy', [this.nearTaxonomyToSearchIndex.bind(this), this.routeSendResponse.bind(this)]);
@@ -126,6 +127,10 @@ class SearchRoutes extends AbstractRoute {
         return next();
     }
 
+    public async aggregateAllHandler(req:Request, res:Response, next: NextFunction):Promise<any> {
+        return next();
+    }
+
 
 }
 

src/Database/Service.ts

@@ -76,7 +76,7 @@ export abstract class Service {
             const items = await this.model.find(query.transmuted, query.projections, query.options);//.sort(sort).skip(skip).limit(limit);
             const returnItems = items.map((doc: any) => {
                 return this.appModel.dataTransfertObject(doc);
-            })
+            });
 
             //populate
             return SuccessResponse.create(

src/Database/ServiceAggregate.ts

@@ -0,0 +1,23 @@
+import AbstractModel from "@core/Model";
+
+
+export default class ServiceAggregate {
+    // take the model - mongooseModel
+
+    public model:AbstractModel;
+
+    constructor(model:AbstractModel) {
+        this.model = model;
+    }
+
+    public async lookupFor($query:any, $lookupQUery:any):Promise<any> {
+        let aggregateArray:Array<any> = [];
+        aggregateArray.push($query);
+        aggregateArray.push($lookupQUery);
+        return this.model.mongooseModel.aggregate([
+            {$match: $query},
+            {$lookup: $lookupQUery}
+        ]).exec();
+    }
+
+}

src/Persons/Controllers/PersonsController.ts

@@ -1,11 +1,16 @@
 import Person from "../Models/Person"
 import PersonsService from "../Services/PersonsService";
 import AbstractController from "../../Abstract/Controller"
+import {ApiResponseContract} from "@src/Http/Responses/ApiResponse";
+import {ReasonPhrases, StatusCodes} from "http-status-codes";
+import {SuccessResponse} from "@src/Http/Responses/SuccessResponse";
+import ServiceAggregate from "@database/ServiceAggregate";
+import {objectIdModifier} from "@database/QueryBuilder/PropertyModifier";
 
 class PersonsController extends AbstractController {
 
     /** @private @static Singleton instance */
-    private static _instance:AbstractController;
+    private static _instance:AbstractController|PersonsController;
 
     /** @public PersonsService */
     service:PersonsService;
@@ -23,11 +28,47 @@ class PersonsController extends AbstractController {
      * @public @static @method getInstance Create the singleton instance if not existing 
      * @return {PersonsController} Controller singleton constructor
     */
-    public static getInstance():AbstractController {
+    public static getInstance():AbstractController|PersonsController {
         if (PersonsController._instance === undefined) {
             PersonsController._instance = new PersonsController();
         }
         return PersonsController._instance;
     }
+
+    public async aggregateOrgs(id:any): Promise<ApiResponseContract> {
+
+        const PersonModel:any = Person.getInstance();
+        /*const results:any = await PersonModel.aggregate([
+            {
+                $lookup: {
+                    from: 'organisations',
+                    localField: '_id',
+                    foreignField: 'team.member',
+                    as: 'org'
+                }
+            }
+        ]).exec();*/
+
+        const aggregateService = new ServiceAggregate(PersonModel);
+        const results:any = await aggregateService.lookupFor(
+            {
+                _id: objectIdModifier(id)
+            },
+            {
+                from: 'organisations',
+                localField: '_id',
+                foreignField: 'team.member',
+                as: 'organisations'
+            }
+        );
+
+        console.log(results);
+
+        return SuccessResponse.create(
+            results,
+            StatusCodes.OK,
+            ReasonPhrases.OK
+        );
+    }
 }
 export default PersonsController;

src/Persons/Models/Person.ts

@@ -70,6 +70,13 @@ class Person extends AbstractModel {
     service: PersonsService;
     mongooseModel: mongoose.Model<any>;
 
+    public aggregations:Array<any> = [{
+        from: 'organisations',
+        localField: '_id',
+        foreignField: 'team.member',
+        as: 'organisations'
+    }];
+
     /** @public Database schema */
     schema: Schema =
         new Schema<PersonSchema>({
@@ -270,27 +277,23 @@ class Person extends AbstractModel {
     }
 
     public registerEvents():void {
+
         this.schema.pre('find', function() {
             taxonomyPopulate(this, 'occupations.skills');
             taxonomyPopulate(this, 'domains.domain');
             middlewarePopulateProperty(this, "mainImage");
 
             populateUser(this, "status.requestedBy", User.getInstance().mongooseModel);
             populateUser(this, "status.lastModifiedBy", User.getInstance().mongooseModel);
-
-            //populateUser(this, "occupations.occupation.status.requestedBy", User.getInstance().mongooseModel);
-            //populateUser(this, "occupations.occupation.status.lastModifiedBy", User.getInstance().mongooseModel);
         });
+
         this.schema.pre('findOne', function() {
             taxonomyPopulate(this, 'occupations.skills');
             taxonomyPopulate(this, 'domains.domain');
             middlewarePopulateProperty(this, 'mainImage');
 
             populateUser(this, "status.requestedBy", User.getInstance().mongooseModel);
             populateUser(this, "status.lastModifiedBy", User.getInstance().mongooseModel);
-
-            //populateUser(this, "occupations.occupation.status.requestedBy", User.getInstance().mongooseModel);
-            //populateUser(this, "occupations.occupation.status.lastModifiedBy", User.getInstance().mongooseModel);
         });
     }
 }

src/Persons/Routes/PersonsRoutes.ts

@@ -1,4 +1,4 @@
-import express from "express";
+import express, {NextFunction, Request, Response} from "express";
 import PersonsController from "@src/Persons/Controllers/PersonsController";
 import AbstractController from "@core/Controller";
 import CrudRoute from "@core/CrudRoute";
@@ -38,5 +38,25 @@ class PersonsRoutes extends CrudRoute {
         getinfo: [],
         getdoc: [],
     }
+
+    public setupAdditionnalPublicRoutes(router: express.Router):express.Router {
+        // Set the /:slug handler at the end of other route, to allow the routes sets in setupAdditionnalPublicRoutes to be 1 in priority.
+        this.routerInstance.get('/agg/:id', [
+            this.getPersonsOrganisationsHandler.bind(this),
+            this.routeSendResponse.bind(this),
+        ]);
+        return router;
+    }
+
+    public async getPersonsOrganisationsHandler(req: Request, res: Response, next: NextFunction): Promise<any> {
+
+        if (req.params.id) {
+            const personsController:PersonsController = PersonsController.getInstance() as PersonsController;
+            res.serviceResponse = await personsController.aggregateOrgs(req.params.id);
+        }
+
+        return next();
+    }
+
 }
 export {PersonsRoutes};

src/Persons/Schemas/withOrganisations.ts

@@ -0,0 +1,12 @@
+
+
+const withOrganiations = function() {
+    this.aggregate([{
+        from: 'organisations',
+        localField: '_id',
+        foreignField: 'team.member',
+        as: 'organisations'
+    }])
+}
+
+export default withOrganiations;