.gitlab-ci.yml

@@ -69,6 +69,7 @@ deploy_dev:
     - deploy
   only:
     - dev
+    - V2.0
   script:
     - cd /home/mps/ram
     - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
@@ -103,7 +104,6 @@ test:
   only:
     - dev
     - merge_requests
-
 # code_analysis:
 #   image: registry.forge.grandlyon.com/apoyen2/sonnar-scanner-gl:master
 #   services:
@@ -128,15 +128,15 @@ test:
 #       -Dsonar.login=${SONAR_TOKEN}
 #       -Dsonar.qualitygate.wait=true
 
-mr:
-  variables:
-    DOCKER_TLS_CERTDIR: ''
-    DOCKER_HOST: tcp://docker:2375/
-    DOCKER_DRIVER: overlay2
-  image: ${CI_DEPENDENCY_PROXY_DIRECT_GROUP_IMAGE_PREFIX}/docker:18.09
-  stage: build
-  only:
-    - merge_requests
-  script:
-    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
-    - docker build .
+# mr:
+#   variables:
+#     DOCKER_TLS_CERTDIR: ''
+#     DOCKER_HOST: tcp://docker:2375/
+#     DOCKER_DRIVER: overlay2
+#   image: ${CI_DEPENDENCY_PROXY_DIRECT_GROUP_IMAGE_PREFIX}/docker:18.09
+#   stage: build
+#   only:
+#     - merge_requests
+#   script:
+#     - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
+#     - docker build .

CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [2.0.0-beta1](https://forge.grandlyon.com/web-et-numerique/pamn_plateforme-des-acteurs-de-la-mediation-numerique/pamn_server/compare/v1.16.0...v2.0.0-beta1) (2022-03-29)
+
+
+### Features
+
+* **jobs:** add filtering of unvalidated jobs ([2d98fc6](https://forge.grandlyon.com/web-et-numerique/pamn_plateforme-des-acteurs-de-la-mediation-numerique/pamn_server/commit/2d98fc6689d5759c8affda3183a7fffe10c3be55))
+* **onboarding:** add structure search by name with improved french analyzer ([b0d2e9b](https://forge.grandlyon.com/web-et-numerique/pamn_plateforme-des-acteurs-de-la-mediation-numerique/pamn_server/commit/b0d2e9b555409a5c07857939ab2bab969354c90b))
+* **personalOffers:** create personal offers endpoints ([ba6f7db](https://forge.grandlyon.com/web-et-numerique/pamn_plateforme-des-acteurs-de-la-mediation-numerique/pamn_server/commit/ba6f7dbd7faf31ebb00177cc6ed78f02fa1d387f))
+
+
+### Bug Fixes
+
+* **gitlab-ci:** update V2.0 autodeploy ([17b77c7](https://forge.grandlyon.com/web-et-numerique/pamn_plateforme-des-acteurs-de-la-mediation-numerique/pamn_server/commit/17b77c72541b2932b37658e232dd9dc631728e30))
+* **swagger:** routing definition ([d264a4e](https://forge.grandlyon.com/web-et-numerique/pamn_plateforme-des-acteurs-de-la-mediation-numerique/pamn_server/commit/d264a4eedda9253e46300ba2fee8bcb9289be086))
+
 ## [1.16.0](https://forge.grandlyon.com/web-et-numerique/pamn_plateforme-des-acteurs-de-la-mediation-numerique/pamn_server/compare/v1.15.1...v1.16.0) (2022-03-18)
 
 

package-lock.json

 {
   "name": "ram_server",
-  "version": "1.16.0",
+  "version": "2.0.0-beta1",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package.json

 {
   "name": "ram_server",
   "private": true,
-  "version": "1.16.0",
+  "version": "2.0.0-beta1",
   "description": "Nest TypeScript starter repository",
   "license": "MIT",
   "scripts": {

scripts/init-index.js

@@ -14,7 +14,16 @@ axios
     axios
       .post('http://localhost:3000/api/structures/resetSearchIndex', {}, config)
       .then((res) => {
-        console.log(`statusCode: ${res.status}`);
+        console.log(`Structures | statusCode: ${res.status}`);
+      })
+      .catch((error) => {
+        console.error('Error in index create');
+        console.error(error);
+      });
+    axios
+      .post('http://localhost:3000/api/employer/searchIndex', {}, config)
+      .then((res) => {
+        console.log(`Employers | statusCode: ${res.status}`);
       })
       .catch((error) => {
         console.error('Error in index create');

src/admin/admin.controller.spec.ts

@@ -10,7 +10,7 @@ import { Structure } from '../structures/schemas/structure.schema';
 import { StructuresService } from '../structures/services/structures.service';
 import { StructuresSearchService } from '../structures/services/structures-search.service';
 import { User } from '../users/schemas/user.schema';
-import { UsersService } from '../users/users.service';
+import { UsersService } from '../users/services/users.service';
 import { AdminController } from './admin.controller';
 import { mockJwtAuthGuard } from '../../test/mock/guards/jwt-auth.mock.guard';
 import { mockRoleGuard } from '../../test/mock/guards/role.mock.guard';

src/admin/admin.controller.ts

@@ -17,7 +17,7 @@ import { NewsletterService } from '../newsletter/newsletter.service';
 import { StructuresService } from '../structures/services/structures.service';
 import { Roles } from '../users/decorators/roles.decorator';
 import { RolesGuard } from '../users/guards/roles.guard';
-import { UsersService } from '../users/users.service';
+import { UsersService } from '../users/services/users.service';
 import { PendingStructureDto } from './dto/pending-structure.dto';
 import { validate } from 'class-validator';
 import { Structure } from '../structures/schemas/structure.schema';

src/app.module.ts

@@ -15,6 +15,7 @@ import { PagesModule } from './pages/pages.module';
 import { TempUserModule } from './temp-user/temp-user.module';
 import { NewsletterModule } from './newsletter/newsletter.module';
 import { ContactModule } from './contact/contact.module';
+import { PersonalOffersModule } from './personal-offers/personal-offers.module';
 @Module({
   imports: [
     ConfigurationModule,
@@ -34,6 +35,7 @@ import { ContactModule } from './contact/contact.module';
     TempUserModule,
     NewsletterModule,
     ContactModule,
+    PersonalOffersModule,
   ],
   controllers: [AppController],
 })

src/auth/auth.controller.spec.ts

@@ -6,7 +6,7 @@ import { AuthServiceMock } from '../../test/mock/services/auth.mock.service';
 import { ConfigurationModule } from '../configuration/configuration.module';
 import { MailerModule } from '../mailer/mailer.module';
 import { User } from '../users/schemas/user.schema';
-import { UsersService } from '../users/users.service';
+import { UsersService } from '../users/services/users.service';
 import { AuthController } from './auth.controller';
 import { AuthService } from './auth.service';
 import { LoginDto } from './login-dto';

src/auth/auth.service.spec.ts

@@ -5,7 +5,7 @@ import { JwtServiceMock } from '../../test/mock/services/jwt.mock.service';
 import { UsersServiceMock } from '../../test/mock/services/user.mock.service';
 import { ConfigurationModule } from '../configuration/configuration.module';
 import { MailerModule } from '../mailer/mailer.module';
-import { UsersService } from '../users/users.service';
+import { UsersService } from '../users/services/users.service';
 import { AuthService } from './auth.service';
 import { LoginDto } from './login-dto';
 
@@ -44,6 +44,7 @@ describe('AuthService', () => {
         emailVerified: false,
         email: 'jacques.dupont@mii.com',
         role: 0,
+        personalOffers: [],
       };
       const loginDto: LoginDto = { email: 'jacques.dupont@mii.com', password: 'test1A!!' }; //NOSONAR
       expect(await service.validateUser(loginDto)).toStrictEqual(result);

src/auth/auth.service.ts

 import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
-import { UsersService } from '../users/users.service';
+import { UsersService } from '../users/services/users.service';
 import { JwtService } from '@nestjs/jwt';
 import { LoginDto } from './login-dto';
 import { DateTime } from 'luxon';

src/main.ts

@@ -15,9 +15,9 @@ async function bootstrap() {
     .setVersion('1.0')
     .addBearerAuth({ type: 'http', scheme: 'bearer', bearerFormat: 'JWT' }, 'JWT')
     .build();
-  const document = SwaggerModule.createDocument(app, options);
-  SwaggerModule.setup('doc', app, document);
   app.setGlobalPrefix('api');
+  const document = SwaggerModule.createDocument(app, options);
+  SwaggerModule.setup('api/doc', app, document);
   await app.listen(3000);
 }
 bootstrap();

src/migrations/scripts/1647422119764-add-jobs-and-employer.ts

+import { Db } from 'mongodb';
+import { getDb } from '../migrations-utils/db';
+
+export const up = async () => {
+  const db: Db = await getDb();
+  // Add employers
+  await db.collection('employers').insertMany([
+    { name: 'CAF', validated: true },
+    { name: 'CARSAT', validated: true },
+    { name: 'Pôle emploi', validated: true },
+    { name: 'CPAM', validated: true },
+    { name: 'Métropole de Lyon', validated: true },
+    { name: 'Médiathèque / Bibliothèque', validated: true },
+    { name: 'Mairie', validated: true },
+    { name: 'CCAS', validated: true },
+    { name: 'Centre socio-culturel', validated: true },
+    { name: 'Association', validated: true },
+    { name: `Structure d'insertion`, validated: true },
+    { name: 'Structure de formation', validated: true },
+    { name: 'Structure information jeunesse (SIJ)', validated: true },
+    { name: 'Cyberbase', validated: true },
+    { name: 'Fablab', validated: true },
+    { name: 'Missions locales', validated: true },
+    { name: 'MJC', validated: true },
+    { name: 'Espace de coworking', validated: true },
+    { name: 'Pimms', validated: true },
+    { name: 'Ressourcerie', validated: true },
+    { name: 'Maison France Service', validated: true },
+  ]);
+
+  // Add jobs
+  await db.collection('jobs').insertMany([
+    { name: 'CNFS', validated: true, hasPersonalOffer: true },
+    { name: 'Médiateur numérique', validated: true, hasPersonalOffer: true },
+    { name: 'Formateur', validated: true, hasPersonalOffer: true },
+    { name: 'Travailleur social', validated: true, hasPersonalOffer: false },
+    { name: 'Conseiller', validated: true, hasPersonalOffer: false },
+    { name: 'Chef de projet', validated: true, hasPersonalOffer: false },
+    { name: 'Élu', validated: true, hasPersonalOffer: false },
+  ]);
+};
+
+export const down = async () => {
+  const db: Db = await getDb();
+
+  db.collection('employers').drop();
+  db.collection('jobs').drop();
+};

src/personal-offers/dto/create-personal-offer.dto.ts

+import { ApiProperty } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import { IsNotEmpty, ValidateNested } from 'class-validator';
+import { PersonalOfferDto } from './personal-offer.dto';
+
+export class CreatePersonalOfferDto {
+  @ApiProperty({
+    description: 'Id of the structure',
+    type: [String],
+  })
+  @IsNotEmpty()
+  structureId: string;
+
+  @ApiProperty({
+    description: 'Personal offer to create',
+    type: [String],
+  })
+  @ValidateNested({ each: true })
+  @Type(() => PersonalOfferDto)
+  personalOffer: PersonalOfferDto;
+}

src/personal-offers/dto/personal-offer.dto.ts

+import { ApiProperty } from '@nestjs/swagger';
+
+export class PersonalOfferDto {
+  /** accompaniments **/
+  @ApiProperty({
+    description: 'List of procedures accompaniments',
+    type: [String],
+  })
+  proceduresAccompaniment: string[];
+  /** trainings **/
+  @ApiProperty({
+    description: 'List of base skills trainings',
+    type: [String],
+  })
+  baseSkills: string[];
+  @ApiProperty({
+    description: 'List of access right trainings',
+    type: [String],
+  })
+  accessRight: string[];
+  @ApiProperty({
+    description: 'List of digital, culture and security trainings',
+    type: [String],
+  })
+  digitalCultureSecurity: string[];
+  @ApiProperty({
+    description: 'List of social and profressional trainings',
+    type: [String],
+  })
+  socialAndProfessional: string[];
+  @ApiProperty({
+    description: 'List of parenting help trainings',
+    type: [String],
+  })
+  parentingHelp: string[];
+}

src/personal-offers/personal-offers.controller.spec.ts

+import { Test, TestingModule } from '@nestjs/testing';
+import { PersonalOffersController } from './personal-offers.controller';
+import { PersonalOffersService } from './personal-offers.service';
+import { PersonalOffersServiceMock } from '../../test/mock/services/personalOffers.mock.service';
+import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
+import { mockJwtAuthGuard } from '../../test/mock/guards/jwt-auth.mock.guard';
+import { IsPersonalOfferOwnerGuard } from '../users/guards/isPersonalOfferOwner.guard';
+import { mockIsPersonalOfferOwnerGuard } from '../../test/mock/guards/isPersonalOfferOwner.mock.guard';
+import {
+  createPersonalOffersDtoDataMock,
+  updatePersonalOffersDtoDataMock,
+  personalOffersDataMock,
+} from '../../test/mock/data/personalOffers.mock.data';
+import { UsersService } from '../users/services/users.service';
+import { UsersServiceMock } from '../../test/mock/services/user.mock.service';
+import { StructuresService } from '../structures/services/structures.service';
+import { StructuresServiceMock } from '../../test/mock/services/structures.mock.service';
+
+describe('PersonalOffersController', () => {
+  let controller: PersonalOffersController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [PersonalOffersController],
+      providers: [
+        {
+          provide: PersonalOffersService,
+          useClass: PersonalOffersServiceMock,
+        },
+        {
+          provide: UsersService,
+          useClass: UsersServiceMock,
+        },
+        {
+          provide: StructuresService,
+          useClass: StructuresServiceMock,
+        },
+      ],
+    })
+      .overrideGuard(JwtAuthGuard)
+      .useValue(mockJwtAuthGuard)
+      .overrideGuard(IsPersonalOfferOwnerGuard)
+      .useValue(mockIsPersonalOfferOwnerGuard)
+      .compile();
+
+    controller = module.get<PersonalOffersController>(PersonalOffersController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+
+  describe('find personal offer', () => {
+    it('should get personal offer', async () => {
+      expect(await controller.find('1234ba0e2ab5775cfc01ed3e')).toBe(personalOffersDataMock[0]);
+    });
+    it('should get personal offer does not exist', async () => {
+      try {
+        await controller.find('abcd');
+        // Fail test if above expression doesn't throw anything.
+        expect(true).toBe(false);
+      } catch (e) {
+        expect(e.message).toBe('Personal offer does not exist');
+        expect(e.status).toBe(404);
+      }
+    });
+  });
+
+  describe('create personal offer', () => {
+    it('should create personal offer for existing user and structure', async () => {
+      const req = { user: { _id: '6036721022462b001334c4bb' } };
+      expect(await controller.create(req, createPersonalOffersDtoDataMock[0])).toEqual(personalOffersDataMock[0]);
+    });
+    it('should return personal offer already exist in the structure', async () => {
+      const req = { user: { _id: '6036721022462b001334c4bb' } };
+      try {
+        await controller.create(req, createPersonalOffersDtoDataMock[1]);
+        // Fail test if above expression doesn't throw anything.
+        expect(true).toBe(false);
+      } catch (e) {
+        expect(e.message).toBe('Personal offer already exist in the structure');
+        expect(e.status).toBe(400);
+      }
+    });
+    it('should return structure not found for the personal offer attachment', async () => {
+      const req = { user: { _id: '6036721022462b001334c4bb' } };
+      try {
+        await controller.create(req, createPersonalOffersDtoDataMock[2]);
+        // Fail test if above expression doesn't throw anything.
+        expect(true).toBe(false);
+      } catch (e) {
+        expect(e.message).toBe('Structure not found for the personal offer attachment');
+        expect(e.status).toBe(400);
+      }
+    });
+    it('should return user not found for the personal offer attachment', async () => {
+      const req = { user: { _id: 'unIdQuiExistePasTropTrop' } };
+      try {
+        await controller.create(req, createPersonalOffersDtoDataMock[0]);
+        // Fail test if above expression doesn't throw anything.
+        expect(true).toBe(false);
+      } catch (e) {
+        expect(e.message).toBe('User not found for the personal offer attachment');
+        expect(e.status).toBe(400);
+      }
+    });
+  });
+
+  describe('update personal offer', () => {
+    it('should get updated personal offer', async () => {
+      expect(await controller.update('2345ba0e2ab5775cfc01ed4d', updatePersonalOffersDtoDataMock[1])).toEqual(
+        personalOffersDataMock[1]
+      );
+    });
+    it('should get invalid personal offer id', async () => {
+      try {
+        await controller.update('abcd', updatePersonalOffersDtoDataMock[1]);
+        // Fail test if above expression doesn't throw anything.
+        expect(true).toBe(false);
+      } catch (e) {
+        expect(e.message).toBe('Invalid personal offer id for update');
+        expect(e.status).toBe(400);
+      }
+    });
+  });
+
+  describe('update personal offer', () => {
+    it('should get deleted personal offer', async () => {
+      expect(await controller.delete('2345ba0e2ab5775cfc01ed4d')).toEqual(personalOffersDataMock[1]);
+    });
+    it('should get invalid personal offer id', async () => {
+      try {
+        await controller.delete('abcd');
+        // Fail test if above expression doesn't throw anything.
+        expect(true).toBe(false);
+      } catch (e) {
+        expect(e.message).toBe('Invalid personal offer id for deletion');
+        expect(e.status).toBe(400);
+      }
+    });
+  });
+});

src/personal-offers/personal-offers.controller.ts

+import { Body, Controller, Delete, Get, Param, Post, Put, Request, UseGuards } from '@nestjs/common';
+import { ApiBody, ApiParam } from '@nestjs/swagger';
+import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
+import { StructuresService } from '../structures/services/structures.service';
+import { IsPersonalOfferOwnerGuard } from '../users/guards/isPersonalOfferOwner.guard';
+import { IUser } from '../users/interfaces/user.interface';
+import { UsersService } from '../users/services/users.service';
+import { CreatePersonalOfferDto } from './dto/create-personal-offer.dto';
+import { PersonalOfferDto } from './dto/personal-offer.dto';
+import { PersonalOffersService } from './personal-offers.service';
+import { PersonalOfferDocument } from './schemas/personal-offer.schema';
+
+@Controller('personal-offers')
+export class PersonalOffersController {
+  constructor(
+    private personalOffersService: PersonalOffersService,
+    private structuresService: StructuresService,
+    private usersService: UsersService
+  ) {}
+
+  /**
+   * Return personal offer of given id.
+   * @param id
+   * @returns {PersonalOffer} Personal offer
+   */
+  @Get(':id')
+  @ApiParam({ name: 'id', type: String, required: true })
+  public async find(@Param('id') id: string) {
+    return this.personalOffersService.findOne(id);
+  }
+
+  /**
+   * Create and return a personal offer.
+   * @param createPersonalOfferDto
+   * @returns {PersonalOffer} created personal offer
+   */
+  @Post()
+  @ApiBody({ type: CreatePersonalOfferDto, required: true })
+  @UseGuards(JwtAuthGuard)
+  public async create(
+    @Request() req,
+    @Body() createPersonalOfferDto: CreatePersonalOfferDto
+  ): Promise<PersonalOfferDocument> {
+    const user: IUser = req.user;
+    const personalOfferDocument: PersonalOfferDocument = await this.personalOffersService.create(
+      createPersonalOfferDto
+    );
+    await this.structuresService.addPersonalOffer(createPersonalOfferDto.structureId, personalOfferDocument);
+    await this.usersService.addPersonalOffer(user._id, personalOfferDocument);
+    return personalOfferDocument;
+  }
+
+  /**
+   * Update and return a personal offer.
+   * @param id - id of the personal offer to update
+   * @param updatePersonalOfferDto - personal offer data to update
+   * @returns {PersonalOffer} Updated personal offer
+   */
+  @Put(':id')
+  @ApiParam({ name: 'id', type: String, required: true })
+  @ApiBody({ type: PersonalOfferDto, required: true })
+  @UseGuards(JwtAuthGuard, IsPersonalOfferOwnerGuard)
+  public async update(
+    @Param('id') id: string,
+    @Body() updatePersonalOfferDto: PersonalOfferDto
+  ): Promise<PersonalOfferDocument> {
+    return this.personalOffersService.update(id, updatePersonalOfferDto);
+  }
+
+  /**
+   * Delete and return a personal offer.
+   * @param id - id of the personal offer to delete
+   * @returns {PersonalOffer} Deleted personal offer
+   */
+  @Delete(':id')
+  @ApiParam({ name: 'id', type: String, required: true })
+  @UseGuards(JwtAuthGuard, IsPersonalOfferOwnerGuard)
+  public async delete(@Param('id') id: string): Promise<PersonalOfferDocument> {
+    return this.personalOffersService.delete(id);
+  }
+}

src/personal-offers/personal-offers.module.ts

+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { StructuresModule } from '../structures/structures.module';
+import { UsersModule } from '../users/users.module';
+import { PersonalOffersController } from './personal-offers.controller';
+import { PersonalOffersService } from './personal-offers.service';
+import { PersonalOffer, PersonalOfferSchema } from './schemas/personal-offer.schema';
+
+@Module({
+  imports: [
+    MongooseModule.forFeature([{ name: PersonalOffer.name, schema: PersonalOfferSchema }]),
+    StructuresModule,
+    UsersModule,
+  ],
+  controllers: [PersonalOffersController],
+  providers: [PersonalOffersService],
+})
+export class PersonalOffersModule {}

src/personal-offers/personal-offers.service.spec.ts

+import { getModelToken } from '@nestjs/mongoose';
+import { Test, TestingModule } from '@nestjs/testing';
+import {
+  createPersonalOffersDtoDataMock,
+  updatePersonalOffersDtoDataMock,
+  personalOffersDataMock,
+} from '../../test/mock/data/personalOffers.mock.data';
+import { PersonalOffersService } from './personal-offers.service';
+
+describe('PersonalOffersService', () => {
+  let service: PersonalOffersService;
+
+  const personalOfferModelMock = {
+    findById: jest.fn(),
+    create: jest.fn(),
+    findByIdAndUpdate: jest.fn(),
+    findByIdAndDelete: jest.fn(),
+    exec: jest.fn(),
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        PersonalOffersService,
+        {
+          provide: getModelToken('PersonalOffer'),
+          useValue: personalOfferModelMock,
+        },
+      ],
+    }).compile();
+
+    service = module.get<PersonalOffersService>(PersonalOffersService);
+  });
+
+  afterEach(async () => {
+    jest.clearAllMocks();
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('findOne', () => {
+    it('should return personal offer', async () => {
+      personalOfferModelMock.findById.mockReturnThis();
+      personalOfferModelMock.exec.mockResolvedValueOnce(personalOffersDataMock[0]);
+      expect(await service.findOne('1234ba0e2ab5775cfc01ed3e')).toEqual(personalOffersDataMock[0]);
+    });
+    it('should return exception if personal offer is not found for given id', async () => {
+      personalOfferModelMock.findById.mockReturnThis();
+      personalOfferModelMock.exec.mockResolvedValueOnce(null);
+      let error: any;
+      try {
+        await service.findOne('abcd');
+      } catch (e) {
+        error = e;
+      }
+      expect(error.message).toBe('Personal offer does not exist');
+      expect(error.status).toBe(404);
+    });
+  });
+
+  describe('create', () => {
+    it('should create personal offer', async () => {
+      personalOfferModelMock.create.mockResolvedValueOnce(personalOffersDataMock[0]);
+      expect(await service.create(createPersonalOffersDtoDataMock[0])).toEqual(personalOffersDataMock[0]);
+    });
+  });
+
+  describe('update', () => {
+    it('should update personal offer', async () => {
+      personalOfferModelMock.findByIdAndUpdate.mockReturnThis();
+      personalOfferModelMock.exec.mockResolvedValueOnce(personalOffersDataMock[1]);
+      expect(await service.update('2345ba0e2ab5775cfc01ed4d', updatePersonalOffersDtoDataMock[1])).toEqual(
+        personalOffersDataMock[1]
+      );
+    });
+    it('should return exception if personal offer is not found for given id', async () => {
+      personalOfferModelMock.findById.mockReturnThis();
+      personalOfferModelMock.exec.mockResolvedValueOnce(null);
+      let error: any;
+      try {
+        await service.update('abcd', updatePersonalOffersDtoDataMock[1]);
+      } catch (e) {
+        error = e;
+      }
+      expect(error.message).toBe('Invalid personal offer id for update');
+      expect(error.status).toBe(400);
+    });
+  });
+
+  describe('delete', () => {
+    it('should update personal offer', async () => {
+      personalOfferModelMock.findByIdAndDelete.mockReturnThis();
+      personalOfferModelMock.exec.mockResolvedValueOnce(personalOffersDataMock[0]);
+      expect(await service.delete('2345ba0e2ab5775cfc01ed4d')).toEqual(personalOffersDataMock[0]);
+    });
+    it('should return exception if personal offer is not found for given id', async () => {
+      personalOfferModelMock.findById.mockReturnThis();
+      personalOfferModelMock.exec.mockResolvedValueOnce(null);
+      let error: any;
+      try {
+        await service.delete('abcd');
+      } catch (e) {
+        error = e;
+      }
+      expect(error.message).toBe('Invalid personal offer id for deletion');
+      expect(error.status).toBe(400);
+    });
+  });
+});

src/personal-offers/personal-offers.service.ts

+import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { CreatePersonalOfferDto } from './dto/create-personal-offer.dto';
+import { PersonalOfferDto } from './dto/personal-offer.dto';
+import { PersonalOffer, PersonalOfferDocument } from './schemas/personal-offer.schema';
+
+@Injectable()
+export class PersonalOffersService {
+  constructor(@InjectModel(PersonalOffer.name) private personalOfferModel: Model<PersonalOfferDocument>) {}
+
+  public async findOne(id: string): Promise<PersonalOffer> {
+    const result: PersonalOfferDocument = await this.personalOfferModel.findById(id).exec();
+    if (!result) {
+      throw new HttpException('Personal offer does not exist', HttpStatus.NOT_FOUND);
+    }
+    return result;
+  }
+
+  public async create(createDto: CreatePersonalOfferDto): Promise<PersonalOfferDocument> {
+    return this.personalOfferModel.create(createDto.personalOffer);
+  }
+
+  public async update(id: string, updatePersonalOfferDto: PersonalOfferDto): Promise<PersonalOfferDocument> {
+    const result: PersonalOfferDocument = await this.personalOfferModel
+      .findByIdAndUpdate(id, updatePersonalOfferDto)
+      .exec();
+    if (!result) {
+      throw new HttpException('Invalid personal offer id for update', HttpStatus.BAD_REQUEST);
+    }
+    return result;
+  }
+
+  public async delete(id: string): Promise<PersonalOfferDocument> {
+    const result: PersonalOfferDocument = await this.personalOfferModel.findByIdAndDelete(id).exec();
+    if (!result) {
+      throw new HttpException('Invalid personal offer id for deletion', HttpStatus.BAD_REQUEST);
+    }
+    return result;
+  }
+}