Merge branch 'master' into get-people

README.md

@@ -26,13 +26,33 @@
 
 **IntershipManager** - The whole lifecycle of internship agreements in one app !
 
+This is the **REST API** connecting to the InternshipManager front end application to manage **CRUD** operations.
+
 ## Installation
 
 ```bash
 $ npm install
 ```
 
-In `/src/config/` create a file called `config.json` and copy the content of `config.template.json` in it. Change the values such as the server port to match your needs.
+In `/src/config/`, make a copy of the file `config.template.json` and rename it to `config.json`. 
+Set the following field :
+```json
+"server": {
+  "port": 3001
+},
+```
+You may replace `3001` by any port you wish to run the application on.
+
+### Initiating the database
+
+This server uses [Mongodb](https://www.mongodb.com/) for persistent data storage. To initiate the database, you must have an instance of mongo running. You may use the dockerfile located in `docker/` at the root of the project and run the command `docker-compose up -d` to create and run a mongo instance as a background task.
+In the `src/config/config.json`, set the following field :
+```json
+"mongodb": {
+  "uri": "mongodb://localhost:27017/internship-manager"
+}
+```
+In the event you wish to run mongo on another port or use another collection, make sure to update the **uri** in the config file.
 
 ## Running the app
 

package.json

@@ -29,6 +29,7 @@
     "@nestjs/core": "^9.0.0",
     "@nestjs/mongoose": "^9.2.1",
     "@nestjs/platform-express": "^9.0.0",
+    "class-transformer": "^0.5.1",
     "class-validator": "^0.13.2",
     "fastify": "^4.9.2",
     "mongoose": "^6.7.2",

src/app.module.ts

@@ -2,8 +2,9 @@ import { Module } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
 import { mongodb } from './config';
 import { PeopleModule } from './people/people.module';
+import { GroupsModule } from './groups/groups.module';
 
 @Module({
-  imports: [PeopleModule, MongooseModule.forRoot(mongodb.uri)],
+  imports: [PeopleModule, GroupsModule, MongooseModule.forRoot(mongodb.uri)],
 })
 export class AppModule {}

src/groups/dao/groups.dao.ts

+import {
+  Injectable,
+  NotFoundException,
+  InternalServerErrorException,
+} from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { CreateGroupDto } from '../dto/create-group.dto';
+import { UpdateGroupDto } from '../dto/update-group.dto';
+import { Group } from '../schemas/group.schema';
+
+@Injectable()
+export class GroupsDao {
+  constructor(
+    @InjectModel(Group.name)
+    private readonly _groupModel: Model<Group>,
+  ) {}
+
+  find = (): Promise<Group[]> =>
+    new Promise((resolve, reject) => {
+      this._groupModel.find({}, {}, {}, (err, value) => {
+        if (err) reject(err.message);
+        if (!value) reject('No values');
+        resolve(value);
+      });
+    });
+
+  findById = (id: string): Promise<Group | void> =>
+    new Promise((resolve, reject) => {
+      this._groupModel.findOne({ id: id }, {}, {}, (err, value) => {
+        if (err) reject(err.message);
+        if (!value) reject(new NotFoundException());
+        resolve(value);
+      });
+    });
+
+  save = (group: CreateGroupDto): Promise<Group> =>
+    new Promise((resolve, reject) => {
+      new this._groupModel(group).save((err, value) => {
+        if (err) reject(err.message);
+        if (!value) reject(new InternalServerErrorException());
+        resolve(value);
+      });
+    });
+
+  findByIdAndUpdate = (
+    id: string,
+    group: UpdateGroupDto,
+  ): Promise<Group | void> =>
+    new Promise((resolve, reject) => {
+      this._groupModel.updateOne(
+        { id: id },
+        group,
+        {
+          new: true,
+          runValidators: true,
+        },
+        (err, value) => {
+          if (err) reject(err.message);
+          if (value.matchedCount === 0) reject(new NotFoundException());
+          resolve(value);
+        },
+      );
+    });
+
+  findByIdAndRemove = (id: string): Promise<Group | void> =>
+    new Promise((resolve, reject) => {
+      this._groupModel.deleteOne({ id: id }, {}, (err) => {
+        if (err) reject(err.message);
+        resolve();
+      });
+    });
+}

src/groups/dto/create-group.dto.ts

+import { IsBoolean, IsString, IsNotEmpty } from 'class-validator';
+
+export class CreateGroupDto {
+  @IsString()
+  @IsNotEmpty()
+  id: string;
+
+  @IsBoolean()
+  final: boolean;
+
+  @IsString()
+  @IsNotEmpty()
+  parent: any;
+}

src/groups/dto/update-group.dto.ts

+import { IsArray, IsOptional } from 'class-validator';
+
+export class UpdateGroupDto {
+  @IsArray()
+  @IsOptional()
+  responsibles: string[];
+
+  @IsArray()
+  @IsOptional()
+  secretaries: string[];
+
+  @IsArray()
+  @IsOptional()
+  students: string[];
+}

src/groups/entities/group.entity.ts

+import { Group } from '../schemas/group.schema';
+
+export class GroupEntity {
+  _id: string;
+  id: string;
+  final: boolean;
+  responsibles: string[];
+  secretaries: string[];
+  students: string[];
+  parent: string;
+
+  constructor(partial: Partial<Group>) {
+    Object.assign(this, partial);
+  }
+}

src/groups/groups.controller.ts

+import {
+  Controller,
+  Get,
+  Post,
+  Put,
+  Delete,
+  Param,
+  Body,
+  UseInterceptors,
+} from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { HttpInterceptor } from '../interceptors/http.interceptor';
+import { CreateGroupDto } from './dto/create-group.dto';
+import { UpdateGroupDto } from './dto/update-group.dto';
+import { GroupEntity } from './entities/group.entity';
+import { GroupsService } from './groups.service';
+
+@Controller('groups')
+@UseInterceptors(HttpInterceptor)
+export class GroupsController {
+  constructor(private readonly _groupsService: GroupsService) {}
+
+  @Get()
+  findAll(): Promise<GroupEntity[] | void> {
+    return this._groupsService.findAll();
+  }
+
+  @Get(':id')
+  findOne(@Param() params: { id: string }): Promise<GroupEntity | void> {
+    return this._groupsService.findOne(params.id);
+  }
+
+  @Post()
+  create(@Body() createGroupDto: CreateGroupDto): Promise<GroupEntity> {
+    return this._groupsService.create(createGroupDto);
+  }
+
+  @Put(':id')
+  update(
+    @Param() params: { id: string },
+    @Body() updateGroupDto: UpdateGroupDto,
+  ): Promise<GroupEntity | void> {
+    return this._groupsService.update(params.id, updateGroupDto);
+  }
+
+  @Delete(':id')
+  delete(@Param() params: { id: string }): Promise<GroupEntity | void> {
+    return this._groupsService.delete(params.id);
+  }
+}

src/groups/groups.module.ts

+import { Module, Logger } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { GroupsDao } from './dao/groups.dao';
+import { GroupsController } from './groups.controller';
+import { GroupsService } from './groups.service';
+import { Group, GroupSchema } from './schemas/group.schema';
+
+@Module({
+  imports: [
+    MongooseModule.forFeature([{ name: Group.name, schema: GroupSchema }]),
+  ],
+  controllers: [GroupsController],
+  providers: [GroupsService, GroupsDao, Logger],
+})
+export class GroupsModule {}

src/groups/groups.service.ts

+import { Injectable } from '@nestjs/common';
+import { GroupsDao } from './dao/groups.dao';
+import { CreateGroupDto } from './dto/create-group.dto';
+import { UpdateGroupDto } from './dto/update-group.dto';
+import { GroupEntity } from './entities/group.entity';
+
+@Injectable()
+export class GroupsService {
+  constructor(private readonly _groupsDao: GroupsDao) {}
+
+  findAll = (): Promise<GroupEntity[] | void> => this._groupsDao.find();
+
+  findOne = (id: string): Promise<GroupEntity | void> =>
+    this._groupsDao.findById(id);
+
+  create = (group: CreateGroupDto): Promise<GroupEntity> =>
+    this._groupsDao.save(group);
+
+  update = (id: string, group: UpdateGroupDto): Promise<GroupEntity | void> =>
+    this._groupsDao.findByIdAndUpdate(id, group);
+
+  delete = (id: string): Promise<GroupEntity | void> =>
+    this._groupsDao.findByIdAndRemove(id);
+}

src/groups/groups.types.ts

+export type Group = {
+  _id: any;
+  id: string;
+  final: boolean;
+  responsibles: string[];
+  secretaries: string[];
+  students: string[];
+  subgroups: string[];
+  parent: string;
+};

src/groups/schemas/group.schema.ts

+import * as mongoose from 'mongoose';
+import { Document } from 'mongoose';
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+
+export type GroupDocument = Group & Document;
+
+@Schema({
+  toJSON: {
+    virtuals: true,
+    transform: (doc: any, ret: any) => {
+      delete ret._id;
+    },
+  },
+})
+export class Group {
+  @Prop({
+    type: mongoose.Schema.Types.ObjectId,
+    auto: true,
+  })
+  _id: any;
+
+  @Prop({
+    type: String,
+    required: true,
+    trim: true,
+  })
+  id: string;
+
+  @Prop({
+    type: Boolean,
+    required: true,
+    trim: true,
+  })
+  final: boolean;
+
+  @Prop({
+    type: [String],
+    required: true,
+    trim: true,
+  })
+  responsibles: string[];
+
+  @Prop({
+    type: [String],
+    required: true,
+    trim: true,
+  })
+  secretaries: string[];
+
+  @Prop({
+    type: [String],
+    required: true,
+    trim: true,
+  })
+  students: string[];
+
+  @Prop({
+    type: String,
+    required: true,
+    trim: true,
+  })
+  parent: string;
+}
+
+export const GroupSchema = SchemaFactory.createForClass(Group);
+
+GroupSchema.index({ id: 1 }, { unique: true });

src/interceptors/http.interceptor.ts

 import {
-    CallHandler,
-    ExecutionContext,
-    Injectable,
-    Logger,
-    NestInterceptor,
-  } from '@nestjs/common';
-  import { merge, Observable, of } from 'rxjs';
-  import { filter, map, mergeMap, tap } from 'rxjs/operators';
-  import { FastifyReply } from 'fastify';
-  
-  @Injectable()
-  export class HttpInterceptor implements NestInterceptor {
-    /**
-     * Class constructor
-     * @param _logger
-     */
-    constructor(private readonly _logger: Logger) {}
-  
-    /**
-     * Intercepts all HTTP requests and responses
-     *
-     * @param context
-     * @param next
-     */
-    intercept = (
-      context: ExecutionContext,
-      next: CallHandler,
-    ): Observable<any> => {
-      const cls = context.getClass();
-      const handler = context.getHandler();
-      const response: FastifyReply = context
-        .switchToHttp()
-        .getResponse<FastifyReply>();
-      const logCtx = `${cls.name}.${handler.name}`;
-  
-      return next.handle().pipe(
-        map((_) => of(_)),
-        mergeMap((obs: Observable<any>) =>
-          merge(
-            obs.pipe(
-              filter((_) => !!_),
-              map((_) => _),
-            ),
-            obs.pipe(
-              filter((_) => !_),
-              tap(() => response.status(204)),
-              map((_) => _),
-            ),
+  CallHandler,
+  ExecutionContext,
+  Injectable,
+  Logger,
+  NestInterceptor,
+} from '@nestjs/common';
+import { merge, Observable, of } from 'rxjs';
+import { filter, map, mergeMap, tap } from 'rxjs/operators';
+import { FastifyReply } from 'fastify';
+
+@Injectable()
+export class HttpInterceptor implements NestInterceptor {
+  /**
+   * Class constructor
+   * @param _logger
+   */
+  constructor(private readonly _logger: Logger) {}
+
+  /**
+   * Intercepts all HTTP requests and responses
+   *
+   * @param context
+   * @param next
+   */
+  intercept = (
+    context: ExecutionContext,
+    next: CallHandler,
+  ): Observable<any> => {
+    const cls = context.getClass();
+    const handler = context.getHandler();
+    const response: FastifyReply = context
+      .switchToHttp()
+      .getResponse<FastifyReply>();
+    const logCtx = `${cls.name}.${handler.name}`;
+
+    return next.handle().pipe(
+      map((_) => of(_)),
+      mergeMap((obs: Observable<any>) =>
+        merge(
+          obs.pipe(
+            filter((_) => !!_),
+            map((_) => _),
+          ),
+          obs.pipe(
+            filter((_) => !_),
+            tap(() => response.status(204)),
+            map((_) => _),
           ),
         ),
-        tap({
-          next: (_) =>
-            this._logger.log(!!_ ? JSON.stringify(_) : 'NO CONTENT', logCtx),
-          error: (_) =>
-            this._logger.error(
-              _?.message ?? 'unspecified error',
-              JSON.stringify(_),
-              logCtx,
-            ),
-        }),
-      );
-    };
-  }
+      ),
+      tap({
+        next: (_) =>
+          this._logger.log(!!_ ? JSON.stringify(_) : 'NO CONTENT', logCtx),
+        error: (_) =>
+          this._logger.error(
+            _?.message ?? 'unspecified error',
+            JSON.stringify(_),
+            logCtx,
+          ),
+      }),
+    );
+  };
\ No newline at end of file
+}