src/categories/services/categories.service.spec.ts

@@ -5,7 +5,7 @@ import { CreateCategories } from '../dto/create-categories.dto';
 import { CategoriesService } from './categories.service';
 
 describe('CategoriesService', () => {
-  let service: CategoriesService;
+  let categoriesService: CategoriesService;
 
   const mockCategoriesModel = {
     create: jest.fn(),
@@ -27,11 +27,11 @@ describe('CategoriesService', () => {
       ],
     }).compile();
 
-    service = module.get<CategoriesService>(CategoriesService);
+    categoriesService = module.get<CategoriesService>(CategoriesService);
   });
 
   it('should be defined', () => {
-    expect(service).toBeDefined();
+    expect(categoriesService).toBeDefined();
   });
 
   it('should findAll structures', async () => {
@@ -41,7 +41,7 @@ describe('CategoriesService', () => {
     ];
     mockCategoriesModel.find.mockReturnThis();
     mockCategoriesModel.exec.mockResolvedValueOnce(data);
-    expect(await service.findAll()).toEqual(data);
+    expect(await categoriesService.findAll()).toEqual(data);
   });
   it('should findOneComplete structures', async () => {
     const data: CreateCategories[] = [
@@ -50,6 +50,6 @@ describe('CategoriesService', () => {
     ];
     mockCategoriesModel.findOne.mockReturnThis();
     mockCategoriesModel.exec.mockResolvedValueOnce(data);
-    expect(await service.findOneComplete('categoryId')).toEqual(data);
+    expect(await categoriesService.findOneComplete('categoryId')).toEqual(data);
   });
 });

src/configuration/config.ts

@@ -25,6 +25,10 @@ export const config = {
       ejs: 'adminStructureCreate.ejs',
       json: 'adminStructureCreate.json',
     },
+    adminStructureImport: {
+      ejs: 'adminStructureImport.ejs',
+      json: 'adminStructureImport.json',
+    },
     adminUserCreate: {
       ejs: 'adminUserCreate.ejs',
       json: 'adminUserCreate.json',

src/configuration/configuration.service.spec.ts

@@ -2,7 +2,7 @@ import { Test, TestingModule } from '@nestjs/testing';
 import { ConfigurationService } from './configuration.service';
 
 describe('ConfigurationService', () => {
-  let service: ConfigurationService;
+  let configurationService: ConfigurationService;
 
   process.env.NODE_ENV = 'local';
 
@@ -12,7 +12,7 @@ describe('ConfigurationService', () => {
       providers: [ConfigurationService],
     }).compile();
 
-    service = module.get<ConfigurationService>(ConfigurationService);
+    configurationService = module.get<ConfigurationService>(ConfigurationService);
   });
 
   describe('initialisation', () => {
@@ -28,12 +28,12 @@ describe('ConfigurationService', () => {
     });
 
     it('should be defined', () => {
-      expect(service).toBeDefined();
+      expect(configurationService).toBeDefined();
     });
 
     it('should init with dev conf', () => {
       process.env.NODE_ENV = 'dev';
-      expect(service.config.host).toBe('resin-dev.grandlyon.com');
+      expect(configurationService.config.host).toBe('resin-dev.grandlyon.com');
     });
   });
 
@@ -50,25 +50,25 @@ describe('ConfigurationService', () => {
     });
 
     it('should be defined', () => {
-      expect(service).toBeDefined();
+      expect(configurationService).toBeDefined();
     });
 
     it('should init with prod conf', () => {
       process.env.NODE_ENV = 'production';
-      expect(service.config.host).toBe('resin.grandlyon.com');
+      expect(configurationService.config.host).toBe('resin.grandlyon.com');
     });
   });
 
   describe('validateUser', () => {
     it('should be local conf', () => {
       process.env.NODE_ENV = 'local';
-      expect(service.isLocalConf()).toBe(true);
+      expect(configurationService.isLocalConf()).toBe(true);
     });
   });
 
   describe('get config', () => {
     it('should get config', () => {
-      const config = service.config;
+      const config = configurationService.config;
       expect(Object.keys(config).length).toBe(9);
       expect(Object.keys(config)).toEqual(
         expect.arrayContaining([

src/contact/contact.controller.spec.ts

 import { Test, TestingModule } from '@nestjs/testing';
+import { MailerModule } from '../mailer/mailer.module';
 import { ContactController } from './contact.controller';
 import { ContactService } from './contact.service';
-import { MailerModule } from '../mailer/mailer.module';
 import { ContactMessage } from './schemas/contact-message.schema';
 
 describe('ContactController', () => {
-  let controller: ContactController;
+  let contactController: ContactController;
 
   const contactServiceMock = {
     sendMessage: jest.fn(),
@@ -23,16 +23,16 @@ describe('ContactController', () => {
       controllers: [ContactController],
     }).compile();
 
-    controller = module.get<ContactController>(ContactController);
+    contactController = module.get<ContactController>(ContactController);
   });
 
   it('should be defined', () => {
-    expect(controller).toBeDefined();
+    expect(contactController).toBeDefined();
   });
 
   it('should call sendMessage', async () => {
     const spyer = jest.spyOn(contactServiceMock, 'sendMessage');
-    await controller.sendContactMessage({ contactMessage: new ContactMessage() });
+    await contactController.sendContactMessage({ contactMessage: new ContactMessage() });
     expect(spyer).toBeCalledTimes(1);
     expect(spyer).toBeCalledWith(new ContactMessage());
   });

src/contact/contact.service.spec.ts

@@ -9,7 +9,7 @@ import { ContactService } from './contact.service';
 import { ContactMessage } from './schemas/contact-message.schema';
 
 describe('ContactService', () => {
-  let service: ContactService;
+  let contactService: ContactService;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
@@ -17,15 +17,15 @@ describe('ContactService', () => {
       providers: [ContactService, ConfigurationService, { provide: MailerService, useClass: MailerMockService }],
     }).compile();
 
-    service = module.get<ContactService>(ContactService);
+    contactService = module.get<ContactService>(ContactService);
   });
 
   it('should be defined', () => {
-    expect(service).toBeDefined();
+    expect(contactService).toBeDefined();
   });
 
   it('should send message with status OK', async () => {
-    const res = (await service.sendMessage(new ContactMessage())) as { data: { status: unknown } };
+    const res = (await contactService.sendMessage(new ContactMessage())) as { data: { status: unknown } };
     expect(res.data.status).toBe(HttpStatus.OK);
   });
 });

src/espaceCoop/services/espaceCoop.service.spec.ts

 import { HttpService } from '@nestjs/axios';
 import { getModelToken } from '@nestjs/mongoose';
 import { Test, TestingModule } from '@nestjs/testing';
-import { UsersService } from '../../users/services/users.service';
 import {
   espaceCoopCNFSMockData,
   espaceCoopPermanencesMockData,
 } from '../../../test/mock/data/espaceCoopCNFS.mock.data';
-import { EspaceCoopService } from './espaceCoop.service';
 import { usersMockData } from '../../../test/mock/data/users.mock.data';
+import { UsersService } from '../../users/services/users.service';
+import { EspaceCoopService } from './espaceCoop.service';
 
 describe('EspaceCoopCNFSService', () => {
-  let service: EspaceCoopService;
+  let espaceCoopService: EspaceCoopService;
 
   const mockEspaceCoopCNFSModel = {
     create: jest.fn(),
@@ -44,18 +44,18 @@ describe('EspaceCoopCNFSService', () => {
       ],
     }).compile();
 
-    service = module.get<EspaceCoopService>(EspaceCoopService);
+    espaceCoopService = module.get<EspaceCoopService>(EspaceCoopService);
   });
 
   it('should be defined', () => {
-    expect(service).toBeDefined();
+    expect(espaceCoopService).toBeDefined();
   });
 
   describe('parsePermanences', () => {
     it('should parse correctly permanences', async () => {
       // Mock finding first cnfs in user database
       jest.spyOn(usersServiceMock, 'findOne').mockImplementationOnce(() => usersMockData[0]);
-      const result = await service.parsePermanences(espaceCoopPermanencesMockData);
+      const result = await espaceCoopService.parsePermanences(espaceCoopPermanencesMockData);
       expect(result).toStrictEqual(espaceCoopCNFSMockData);
     });
   });

src/indicator/dto/orientation-indicator.dto.ts

@@ -35,6 +35,7 @@ export class OrientationIndicator {
   @Type(() => StructureDto)
   origin: {
     nom: string;
+    prescripteur: string;
     adresse: Address;
   };
 
@@ -55,5 +56,5 @@ export class OrientationIndicator {
   @IsNumber()
   progress: number;
 
-  createdAt?: Date;
+  createdAt: Date;
 }

src/indicator/schemas/orientation-indicator.schema.ts

@@ -35,11 +35,12 @@ export class Type {
 
 export type OrientationIndicatorDocument = OrientationIndicator & Document;
 
-@Schema({ timestamps: true })
+@Schema()
 export class OrientationIndicator {
   @Prop({ type: Object })
   origin: {
     nom: string;
+    prescripteur: string;
     adresse: Address;
   };
 
@@ -57,6 +58,9 @@ export class OrientationIndicator {
 
   @Prop({ required: true })
   progress: number;
+
+  @Prop({ type: Date, default: Date.now })
+  createdAt: Date;
 }
 
 export const OrientationIndicatorSchema = SchemaFactory.createForClass(OrientationIndicator);

src/indicator/services/indicator.service.spec.ts

-import { Test, TestingModule } from '@nestjs/testing';
-import { IndicatorService } from './indicator.service';
 import { getModelToken } from '@nestjs/mongoose';
-import { OrientationIndicator } from '../schemas/orientation-indicator.schema';
+import { Test, TestingModule } from '@nestjs/testing';
 import { mockIndicator, mockIndicators } from '../../../test/mock/data/indicators/orientationIndicators.mock.data';
 import { User } from '../../users/schemas/user.schema';
+import { OrientationIndicator } from '../schemas/orientation-indicator.schema';
+import { IndicatorService } from './indicator.service';
 
 describe('IndicatorService', () => {
-  let service: IndicatorService;
+  let indicatorService: IndicatorService;
   let mockModel;
 
   beforeEach(async () => {
@@ -29,18 +29,18 @@ describe('IndicatorService', () => {
       ],
     }).compile();
 
-    service = module.get<IndicatorService>(IndicatorService);
+    indicatorService = module.get<IndicatorService>(IndicatorService);
   });
 
   it('should be defined', () => {
-    expect(service).toBeDefined();
+    expect(indicatorService).toBeDefined();
   });
 
   describe('createOrientation', () => {
     it('should create orientation indicator', async () => {
       mockModel.create.mockResolvedValue(mockIndicator);
 
-      const result = await service.createOrientation(mockIndicator);
+      const result = await indicatorService.createOrientation(mockIndicator);
       expect(result).toBe(mockIndicator);
       expect(mockModel.create).toHaveBeenCalledWith(mockIndicator);
     });
@@ -48,7 +48,7 @@ describe('IndicatorService', () => {
     it('should handle errors when creating orientation indicator', async () => {
       mockModel.create.mockRejectedValue(new Error('Some error'));
 
-      await expect(service.createOrientation(mockIndicator)).rejects.toThrow('Some error');
+      await expect(indicatorService.createOrientation(mockIndicator)).rejects.toThrow('Some error');
     });
   });
 
@@ -56,7 +56,7 @@ describe('IndicatorService', () => {
     it('should retrieve all orientation indicators', async () => {
       mockModel.find.mockResolvedValue(mockIndicators);
 
-      const result = await service.getAllOrientation();
+      const result = await indicatorService.getAllOrientation();
       expect(result).toBe(mockIndicators);
       expect(mockModel.find).toHaveBeenCalledWith({});
     });
@@ -64,7 +64,7 @@ describe('IndicatorService', () => {
     it('should handle errors when fetching all orientation indicators', async () => {
       mockModel.find.mockRejectedValue(new Error('Some fetching error'));
 
-      await expect(service.getAllOrientation()).rejects.toThrow('Some fetching error');
+      await expect(indicatorService.getAllOrientation()).rejects.toThrow('Some fetching error');
     });
   });
 });

src/indicator/services/indicator.service.ts

@@ -34,7 +34,7 @@ export class IndicatorService {
     const query = {};
 
     if (startDate || endDate) {
-      query['createdAt'] = {}; // replace 'dateField' with the name of your date attribute in the collection
+      query['createdAt'] = {};
       if (startDate) {
         query['createdAt']['$gte'] = new Date(startDate);
       }

src/mailer/mail-templates/adminStructureImport.ejs

+Bonjour,<br />
+<br />
+De nouvelles structures ont été importées:
+<a href="<%= config.protocol %>://<%= config.host %><%= config.port ? ':' + config.port : '' %>/admin/structure-list"
+  >cliquez ici pour les consulter.</a
+>

src/mailer/mail-templates/adminStructureImport.json

+{
+  "subject": "Nouvelles structures importées"
+}

src/mailer/mailer.service.spec.ts

 import { HttpModule, HttpService } from '@nestjs/axios';
 import { Test, TestingModule } from '@nestjs/testing';
-import { of, throwError } from 'rxjs';
 import { AxiosResponse } from 'axios';
-import { ConfigurationService } from '../configuration/configuration.service';
-import { MailerService } from './mailer.service';
 import * as fs from 'fs';
 import * as path from 'path';
+import { of, throwError } from 'rxjs';
+import { ConfigurationService } from '../configuration/configuration.service';
+import { MailerService } from './mailer.service';
 
 describe('MailerService', () => {
-  let service: MailerService;
+  let mailerService: MailerService;
   let httpService: HttpService;
 
   beforeEach(async () => {
@@ -17,12 +17,12 @@ describe('MailerService', () => {
       providers: [MailerService, ConfigurationService],
     }).compile();
 
-    service = module.get<MailerService>(MailerService);
+    mailerService = module.get<MailerService>(MailerService);
     httpService = module.get<HttpService>(HttpService);
   });
 
   it('should be defined', () => {
-    expect(service).toBeDefined();
+    expect(mailerService).toBeDefined();
   });
 
   describe('email sending', () => {
@@ -41,7 +41,7 @@ describe('MailerService', () => {
         config: {},
       };
       jest.spyOn(httpService, 'post').mockImplementationOnce(() => of(result));
-      expect(await service.send('a@a.com', 'test', '<p>This is a test</p>')).toBe(result.data);
+      expect(await mailerService.send('a@a.com', 'test', '<p>This is a test</p>')).toBe(result.data);
     });
 
     it('should not send email', async () => {
@@ -60,7 +60,7 @@ describe('MailerService', () => {
       };
       jest.spyOn(httpService, 'post').mockImplementationOnce(() => throwError(result));
       try {
-        await service.send('a@a.com', 'test', '<p>This is a test</p>');
+        await mailerService.send('a@a.com', 'test', '<p>This is a test</p>');
       } catch (e) {
         expect(e.data.detail).toBe('There was a validation error');
         expect(e.status).toBe(400);
@@ -72,7 +72,7 @@ describe('MailerService', () => {
     it('should get template location', async () => {
       jest.spyOn(path, 'join').mockImplementationOnce(() => '/path/to/template');
       jest.spyOn(fs, 'existsSync').mockImplementationOnce(() => true);
-      expect(service.getTemplateLocation('filename')).toBe('/path/to/template');
+      expect(mailerService.getTemplateLocation('filename')).toBe('/path/to/template');
     });
 
     it('should not get template location', async () => {
@@ -80,7 +80,7 @@ describe('MailerService', () => {
       jest.spyOn(path, 'join').mockImplementationOnce(() => '/path/to/filename');
       jest.spyOn(fs, 'existsSync').mockImplementationOnce(() => false);
       try {
-        expect(service.getTemplateLocation(filename)).toBe('/path/to/template');
+        expect(mailerService.getTemplateLocation(filename)).toBe('/path/to/template');
       } catch (e) {
         expect(e.message).toBe(`Email template '${filename}' cannot be found in ./src/mailer/mail-templates`);
       }
@@ -95,7 +95,7 @@ describe('MailerService', () => {
       const buf = Buffer.from(JSON.stringify(data), 'utf8');
       jest.spyOn(fs, 'readFileSync').mockImplementationOnce(() => buf);
       jest.spyOn(JSON, 'parse').mockImplementationOnce(() => JSON.stringify(data));
-      expect(service.loadJsonConfig('filename')).toStrictEqual(JSON.stringify(data));
+      expect(mailerService.loadJsonConfig('filename')).toStrictEqual(JSON.stringify(data));
     });
 
     it('should not get template location', async () => {
@@ -103,7 +103,7 @@ describe('MailerService', () => {
       jest.spyOn(path, 'join').mockImplementationOnce(() => '/path/to/filename');
       jest.spyOn(fs, 'existsSync').mockImplementationOnce(() => false);
       try {
-        expect(service.loadJsonConfig(filename)).toBe('/path/to/template');
+        expect(mailerService.loadJsonConfig(filename)).toBe('/path/to/template');
       } catch (e) {
         expect(e.message).toBe(
           `Email json definition file '${filename}' cannot be found in ./src/mailer/mail-templates`
@@ -114,7 +114,7 @@ describe('MailerService', () => {
 
   it('should add signature', async () => {
     const test = '<p>test email</p>';
-    expect(service.addSignature(test)).toBe(
+    expect(mailerService.addSignature(test)).toBe(
       `<p>test email</p><br /><br /><p>L’équipe projet inclusion numérique.</p><p style="font-family:helvetica;font-size:24px;font-weight:bold;margin:0;">rés<span style="color:red;font-weight:400;">’in</span></p><br /><br /><p>Ce mail est automatique. Merci de ne pas y répondre.</p>`
     );
   });

src/migrations/scripts/1695223467052-remove-pix-label.ts

+import { Db } from 'mongodb';
+import { getDb } from '../migrations-utils/db';
+
+export const up = async () => {
+  const db: Db = await getDb();
+
+  await db.collection('categories').updateOne(
+    { id: 'labelsQualifications' },
+    {
+      $pull: { modules: { id: 'pix' } },
+    }
+  );
+
+  await db.collection('structures').updateMany({ 'categories.labelsQualifications': 'pix' }, {
+    $pull: { 'categories.labelsQualifications': 'pix' },
+  } as unknown);
+
+  console.log('Updated : Pix label removed');
+};
+
+export const down = async () => {
+  const db: Db = await getDb();
+  await db.collection('categories').updateOne(
+    { id: 'labelsQualifications' },
+    {
+      $push: { modules: { id: 'pix', name: 'Pix' } },
+    }
+  );
+  console.log('Downgraded : Pix label added');
+};

src/migrations/scripts/1695282868772-remove-cpam.ts

+import { Db } from 'mongodb';
+import { getDb } from '../migrations-utils/db';
+
+export const up = async () => {
+  const db: Db = await getDb();
+
+  await db.collection('categories').updateOne(
+    { id: 'onlineProcedures' },
+    {
+      $pull: { modules: { id: 'cpam' } },
+    }
+  );
+
+  await db.collection('categories').updateOne(
+    { id: 'onlineProcedures', 'modules.id': 'health' },
+    {
+      $set: { 'modules.$.name': 'Santé (Ameli, CPAM...)' },
+    }
+  );
+
+  // Iterate through cpam structures, remove cpam from onlineProcedures and add health if not already present
+  const cursor = db.collection('structures').find({ 'categories.onlineProcedures': 'cpam' });
+  let cpamStructure;
+  while ((cpamStructure = await cursor.next())) {
+    const updatedOnlineProcedures = cpamStructure.categories.onlineProcedures.filter((item) => item !== 'cpam');
+
+    if (!updatedOnlineProcedures.includes('health')) {
+      updatedOnlineProcedures.push('health');
+    }
+
+    await db
+      .collection('structures')
+      .updateOne({ _id: cpamStructure._id }, { $set: { 'categories.onlineProcedures': updatedOnlineProcedures } });
+  }
+  console.log('Updated : replace cpam online procedure with health');
+};
+
+export const down = async () => {
+  const db: Db = await getDb();
+
+  await db.collection('categories').updateOne(
+    { id: 'onlineProcedures' },
+    {
+      $push: { modules: { id: 'cpam', name: 'CPAM' } },
+    }
+  );
+
+  await db.collection('categories').updateOne(
+    { id: 'onlineProcedures', 'modules.id': 'health' },
+    {
+      $set: { 'modules.$.name': 'Santé (Ameli...)' },
+    }
+  );
+  console.log('Downgraded : added cpam online procedure and renamed health');
+};

src/migrations/scripts/1695375219601-new-structure-types.ts

+import { Db } from 'mongodb';
+import { getDb } from '../migrations-utils/db';
+
+export const up = async () => {
+  try {
+    const db: Db = await getDb();
+
+    // Maison du Rhône will become the new type "administration"
+    await db
+      .collection('structuretype')
+      .findOneAndUpdate({ value: 'Maison du Rhône' }, { $set: { value: 'administration' } });
+
+    // Mapping of old values to new values
+    const mapping = [
+      { value: 'bijPij', newValue: 'sij' },
+      { value: 'CAF', newValue: 'administration' },
+      { value: 'CARSAT', newValue: 'administration' },
+      { value: 'CPAM', newValue: 'administration' },
+      { value: 'centreDeGestion', newValue: 'administration' },
+      { value: 'prefecture', newValue: 'administration' },
+      { value: 'poleEmploi', newValue: 'administration' },
+      { value: 'CCAS', newValue: 'mairie' },
+    ];
+
+    for (const map of mapping) {
+      // Find the old and new _id for the given value
+      const newStructureType = await db.collection('structuretype').findOne({ value: map.newValue });
+      const oldStructureType = await db.collection('structuretype').findOne({ value: map.value });
+      // Update the "structures" collection with the new _id for structureType
+      if (oldStructureType && newStructureType) {
+        await db
+          .collection('structures')
+          .updateMany({ structureType: oldStructureType._id }, { $set: { structureType: newStructureType._id } });
+      }
+
+      // Delete the old "structureType" documents
+      await db.collection('structuretype').deleteMany({ value: map.value });
+    }
+
+    // Remove two other obsolete structure types and empty their references in the structure collection
+    const toDelete = [{ value: 'EPIC' }, { value: 'MaisonFranceService' }];
+    for (const del of toDelete) {
+      // Find the _id
+      const structureType = await db.collection('structuretype').findOne({ value: del.value });
+      // Remove the structureType id from the "structures" collection and delete the obsolete structureType
+      if (structureType) {
+        await db
+          .collection('structures')
+          .updateMany({ structureType: structureType._id }, { $set: { structureType: null } });
+        await db.collection('structuretype').deleteOne({ _id: structureType._id });
+      }
+    }
+
+    // Add full names in database
+    const nameMapping = [
+      { value: 'administration', name: 'Administration' },
+      { value: 'formation', name: 'Structure de formation' },
+      { value: 'sij', name: 'Structure information jeunesse' },
+      { value: 'espaceEmploi', name: 'Espace emploi' },
+      { value: 'laPoste', name: 'La Poste' },
+      { value: 'mediatheque', name: 'Médiathèque/Bibliothèque' },
+      { value: 'logement', name: 'Bailleur social' },
+      { value: 'association', name: 'Association' },
+      { value: 'insertion', name: "Structure d'insertion" },
+      { value: 'centreSocio', name: 'Centre socio-culturel' },
+      { value: 'AFPA', name: 'Organisme public de formation' },
+      { value: 'mairie', name: 'Mairie' },
+      { value: 'mjc', name: 'MJC' },
+      { value: 'missionsLocales', name: 'Mission locale' },
+      { value: 'Communauté de communes', name: 'Communauté de communes' },
+      { value: 'mdm', name: 'Maison de la Métropole de Lyon' },
+      { value: 'Université', name: 'Université' },
+      { value: 'autre', name: 'Autre' },
+    ];
+    // Add name field to structure types
+    for (const nameMap of nameMapping) {
+      await db.collection('structuretype').updateMany({ value: nameMap.value }, { $set: { name: nameMap.name } });
+    }
+
+    // Keep the "value" field because it is useful for elastic search to find a structure type with another search string (ex if value='mdml toto' then 'mdml' or 'toto' = maison de la métropole de lyon)
+
+    // Change value from mdm to mdml so that searches with 'mdm 'and 'mdml' both show structures with structureType name 'Maison de la Métropole de Lyon'
+    await db.collection('structuretype').updateOne({ value: 'mdm' }, { $set: { value: 'mdml' } });
+
+    console.log('Updated : "StructureType" collection updated');
+  } catch (error) {
+    console.error('Error updating documents:', error);
+  }
+};
+
+export const down = async () => {
+  try {
+    const db: Db = await getDb();
+
+    await db.collection('structuretype').drop();
+
+    await db.collection('structuretype').insertMany([
+      { category: 'Publique', value: 'mairie', selectable: 'true' },
+      { category: 'Publique', value: 'CAF', selectable: 'true' },
+      { category: 'Publique', value: 'CCAS', selectable: 'true' },
+      { category: 'Publique', value: 'CARSAT', selectable: 'true' },
+      { category: 'Publique', value: 'poleEmploi', selectable: 'true' },
+      { category: 'Publique', value: 'mdml', selectable: 'true' },
+      { category: 'Publique', value: 'mediatheque', selectable: 'true' },
+      { category: 'Publique', value: 'prefecture', selectable: 'true' },
+      { category: 'Publique', value: 'bijPij', selectable: 'true' },
+      { category: 'Publique', value: 'logement', selectable: 'true' },
+      { category: 'Publique', value: 'MaisonFranceService', selectable: 'true' },
+      { category: 'Publique', value: 'autre', selectable: 'false' },
+      { category: 'Publique', value: 'laPoste', selectable: 'true' },
+      { category: 'Publique', value: 'espaceEmploi', selectable: 'true' },
+      { category: 'Publique', value: 'CPAM', selectable: 'true' },
+      { category: 'Publique', value: 'AFPA', selectable: 'true' },
+      { category: 'Publique', value: 'centreDeGestion', selectable: 'true' },
+      { category: 'Publique', value: 'EPIC', selectable: 'true' },
+      { category: 'Publique', value: 'Communauté de communes', selectable: 'true' },
+      { category: 'Publique', value: 'Maison du Rhône', selectable: 'true' },
+      { category: 'Publique', value: 'Université', selectable: 'true' },
+      { category: 'Privée à but non lucratif', value: 'association', selectable: 'true' },
+      { category: 'Privée à but non lucratif', value: 'centreSocio', selectable: 'true' },
+      { category: 'Privée à but non lucratif', value: 'mjc', selectable: 'true' },
+      { category: 'Privée à but non lucratif', value: 'sij', selectable: 'true' },
+      { category: 'Privée à but non lucratif', value: 'missionsLocales', selectable: 'true' },
+      { category: 'Privée à but lucratif', value: 'formation', selectable: 'true' },
+      { category: 'Privée à but lucratif', value: 'insertion', selectable: 'true' },
+    ]);
+
+    console.log('Downgrade : old structure types have been restored (but not attached to the appropriate structures)');
+  } catch (error) {
+    console.error('Error downgrading documents:', error);
+  }
+};

src/newsletter/newsletter.controller.spec.ts

@@ -6,7 +6,7 @@ import { NewsletterSubscription } from './newsletter-subscription.schema';
 import { NewsletterController } from './newsletter.controller';
 import { NewsletterService } from './newsletter.service';
 describe('NewsletterController', () => {
-  let controller: NewsletterController;
+  let newsletterController: NewsletterController;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
@@ -21,28 +21,28 @@ describe('NewsletterController', () => {
       controllers: [NewsletterController],
     }).compile();
 
-    controller = module.get<NewsletterController>(NewsletterController);
+    newsletterController = module.get<NewsletterController>(NewsletterController);
   });
 
   it('should be defined', () => {
-    expect(controller).toBeDefined();
+    expect(newsletterController).toBeDefined();
   });
 
   it('should subscribe user', async () => {
     const result = { email: 'email@test.com', mailchimpId: 'test' };
     jest
-      .spyOn(controller, 'newsletterSubscribe')
+      .spyOn(newsletterController, 'newsletterSubscribe')
       .mockImplementation(async (): Promise<{ email; mailchimpId }> => result);
     const email = { email: 'email@test.com', mailchimpId: 'test' };
-    expect(await controller.newsletterSubscribe(email)).toBe(result);
+    expect(await newsletterController.newsletterSubscribe(email)).toBe(result);
   });
 
   it('should unsubscribe user', async () => {
     const result = { email: 'email@test.com', mailchimpId: 'test' };
     jest
-      .spyOn(controller, 'newsletterUnsubscribe')
+      .spyOn(newsletterController, 'newsletterUnsubscribe')
       .mockImplementation(async (): Promise<{ email; mailchimpId }> => result);
     const email = { email: 'email@test.com', mailchimpId: 'test' };
-    expect(await controller.newsletterUnsubscribe(email)).toBe(result);
+    expect(await newsletterController.newsletterUnsubscribe(email)).toBe(result);
   });
 });

src/newsletter/newsletter.service.spec.ts

@@ -10,7 +10,7 @@ const mailchimp = require('@mailchimp/mailchimp_marketing');
 jest.mock('@mailchimp/mailchimp_marketing');
 describe('NewsletterService', () => {
   const OLD_ENV = process.env;
-  let service: NewsletterService;
+  let newsletterService: NewsletterService;
 
   const mockNewsletterModel = {
     create: jest.fn(),
@@ -34,12 +34,13 @@ describe('NewsletterService', () => {
       ],
     }).compile();
 
-    service = module.get<NewsletterService>(NewsletterService);
+    newsletterService = module.get<NewsletterService>(NewsletterService);
 
     process.env = { ...OLD_ENV }; // Make a copy
     process.env.MC_LIST_ID = 'abcde';
     process.env.MC_API_KEY = 'k3y';
     process.env.MC_SERVER = 's3rv3r';
+    jest.clearAllMocks();
   });
 
   afterAll(() => {
@@ -47,7 +48,7 @@ describe('NewsletterService', () => {
   });
 
   it('should be defined', () => {
-    expect(service).toBeDefined();
+    expect(newsletterService).toBeDefined();
   });
 
   describe('newsletterSubscribe', () => {
@@ -55,11 +56,11 @@ describe('NewsletterService', () => {
       const _doc = { _id: 'a1aaaaa1a1', email: 'test2@test.com' } as INewsletterSubscription;
       mailchimp.lists.setListMember.mockResolvedValueOnce({ email_address: 'test2@test.com' });
       jest
-        .spyOn(service, 'findOne')
+        .spyOn(newsletterService, 'findOne')
         .mockImplementationOnce(async (): Promise<INewsletterSubscription | undefined> => _doc);
       mockNewsletterModel.create.mockResolvedValueOnce(_doc);
 
-      const subscription = await service.newsletterSubscribe('test2@test.com');
+      const subscription = await newsletterService.newsletterSubscribe('test2@test.com');
       expect(subscription).toEqual(_doc);
     });
     it('it should add a subscription for email test2@test.com', async () => {
@@ -67,12 +68,12 @@ describe('NewsletterService', () => {
       const _doc = { _id: 'a1aaaaa1a1', email: 'test2@test.com' };
       mailchimp.lists.setListMember.mockResolvedValueOnce({ email_address: 'test2@test.com' });
       jest
-        .spyOn(service, 'findOne')
+        .spyOn(newsletterService, 'findOne')
         .mockImplementationOnce(async (): Promise<INewsletterSubscription | undefined> => undefined)
         .mockImplementationOnce(async (): Promise<INewsletterSubscription | undefined> => result);
       mockNewsletterModel.create.mockResolvedValueOnce(_doc);
 
-      const subscription = await service.newsletterSubscribe('test2@test.com');
+      const subscription = await newsletterService.newsletterSubscribe('test2@test.com');
       expect(subscription).toEqual(_doc);
     });
     it('it should return error if mailchimp 400 issue', async () => {
@@ -80,13 +81,13 @@ describe('NewsletterService', () => {
       const _doc = { _id: 'a1aaaaa1a1', email: 'test2@test.com' };
       mailchimp.lists.setListMember.mockRejectedValueOnce({ status: 400 });
       jest
-        .spyOn(service, 'findOne')
+        .spyOn(newsletterService, 'findOne')
         .mockImplementationOnce(async (): Promise<INewsletterSubscription | undefined> => undefined)
         .mockImplementationOnce(async (): Promise<INewsletterSubscription | undefined> => result);
       mockNewsletterModel.create.mockResolvedValueOnce(_doc);
 
       try {
-        await service.newsletterSubscribe('test2@test.com');
+        await newsletterService.newsletterSubscribe('test2@test.com');
         expect(true).toBe(false);
       } catch (e) {
         expect(e.message).toBe('Subscribe error');
@@ -98,13 +99,13 @@ describe('NewsletterService', () => {
       const _doc = { _id: 'a1aaaaa1a1', email: 'test2@test.com' };
       mailchimp.lists.setListMember.mockRejectedValueOnce({ status: 500 });
       jest
-        .spyOn(service, 'findOne')
+        .spyOn(newsletterService, 'findOne')
         .mockImplementationOnce(async (): Promise<INewsletterSubscription | undefined> => undefined)
         .mockImplementationOnce(async (): Promise<INewsletterSubscription | undefined> => result);
       mockNewsletterModel.create.mockResolvedValueOnce(_doc);
 
       try {
-        await service.newsletterSubscribe('test2@test.com');
+        await newsletterService.newsletterSubscribe('test2@test.com');
         expect(true).toBe(false);
       } catch (e) {
         expect(e.message).toBe('Subscribe error');
@@ -118,7 +119,7 @@ describe('NewsletterService', () => {
       mockNewsletterModel.findOne.mockReturnThis();
       mockNewsletterModel.exec.mockResolvedValueOnce(undefined);
       try {
-        await service.newsletterUnsubscribe('test@test.com');
+        await newsletterService.newsletterUnsubscribe('test@test.com');
         // Fail test if above expression doesn't throw anything.
         expect(true).toBe(false);
       } catch (e) {
@@ -135,10 +136,10 @@ describe('NewsletterService', () => {
         deleteOne: async () => _doc,
       } as INewsletterSubscription;
       jest
-        .spyOn(service, 'findOne')
+        .spyOn(newsletterService, 'findOne')
         .mockImplementationOnce(async (): Promise<INewsletterSubscription | undefined> => result);
 
-      const subscription = await service.newsletterUnsubscribe('test2@test.com');
+      const subscription = await newsletterService.newsletterUnsubscribe('test2@test.com');
       expect(subscription).toEqual(_doc);
     });
   });
@@ -147,14 +148,14 @@ describe('NewsletterService', () => {
     it('it should not find a subscription with email test@test.com', async () => {
       mockNewsletterModel.findOne.mockReturnThis();
       mockNewsletterModel.exec.mockResolvedValueOnce(undefined);
-      const findOneEmail = await service.findOne('test@test.com');
+      const findOneEmail = await newsletterService.findOne('test@test.com');
       expect(findOneEmail).toEqual(undefined);
     });
     it('it should find a subscription with email test2@test.com', async () => {
       const _doc = { _id: 'a1aaaaa1a1', email: 'test2@test.com' } as INewsletterSubscription;
       mockNewsletterModel.findOne.mockReturnThis();
       mockNewsletterModel.exec.mockResolvedValueOnce(_doc);
-      const findOneEmail = await service.findOne('test2@test.com');
+      const findOneEmail = await newsletterService.findOne('test2@test.com');
       expect(findOneEmail).toEqual(_doc);
     });
   });
@@ -163,12 +164,12 @@ describe('NewsletterService', () => {
       const _docs = [{ _id: 'a1aaaaa1a1', email: 'test2@test.com' } as INewsletterSubscription];
       mockNewsletterModel.find.mockReturnThis();
       mockNewsletterModel.exec.mockResolvedValueOnce(_docs);
-      const findOneEmail = await service.findAll();
+      const findOneEmail = await newsletterService.findAll();
       expect(findOneEmail).toEqual(_docs);
     });
   });
   describe('updateNewsletterSubscription', () => {
-    it('should update existing user subscription', () => {
+    it('should update existing user subscription', async () => {
       mailchimp.lists.getListMembersInfo.mockResolvedValueOnce({ total_items: 10 }).mockResolvedValueOnce({
         members: [
           { email_address: 'a@a.com', status: 'subscribed' },
@@ -176,11 +177,12 @@ describe('NewsletterService', () => {
           { email_address: 'test2@test.com', status: 'unsubscribed' },
         ],
       });
-      const result = { email: 'test2@test.com' } as INewsletterSubscription;
-      const spyer = jest.spyOn(mockNewsletterModel, 'findOne');
-      mockNewsletterModel.findOne.mockResolvedValueOnce(result).mockResolvedValueOnce(null);
-      service.updateNewsletterSubscription();
-      expect(spyer).toBeCalledTimes(3);
+      const result = { email: 'test2@test.com', deleteOne: jest.fn() };
+      mockNewsletterModel.findOne.mockReturnThis();
+      mockNewsletterModel.exec.mockResolvedValueOnce(result).mockResolvedValueOnce(null);
+      await newsletterService.updateNewsletterSubscription();
+      expect(mockNewsletterModel.findOne).toBeCalledTimes(2);
+      // Remove subscription is not tested
       // expect(spyerDelete).toBeCalledTimes(1);
     });
   });

src/online-mediation/onlineMediation.controller.spec.ts

@@ -6,7 +6,7 @@ import { OnlineMediation } from './onlineMediation.schema';
 import { OnlineMediationService } from './onlineMediation.service';
 
 describe('UserRegistryController', () => {
-  let controller: OnlineMediationController;
+  let onlineMediationController: OnlineMediationController;
 
   const onlineMediationServiceMock = {
     getAll: jest.fn(),
@@ -29,24 +29,24 @@ describe('UserRegistryController', () => {
       controllers: [OnlineMediationController],
     }).compile();
 
-    controller = module.get<OnlineMediationController>(OnlineMediationController);
+    onlineMediationController = module.get<OnlineMediationController>(OnlineMediationController);
   });
 
   it('should be defined', () => {
-    expect(controller).toBeDefined();
+    expect(onlineMediationController).toBeDefined();
   });
 
   describe('findAll', () => {
     it('should findAll entries', async () => {
       onlineMediationServiceMock.getAll.mockResolvedValue(onlineMediationMockData);
-      const reply = await controller.findAll();
+      const reply = await onlineMediationController.findAll();
       expect(reply).toStrictEqual(onlineMediationMockData);
     });
   });
   describe('createOnlineMediation', () => {
     it('should create a new entry', async () => {
       onlineMediationServiceMock.create.mockResolvedValue(singleOnlineMediationMock);
-      const reply = await controller.createOnlineMediation(singleOnlineMediationMock);
+      const reply = await onlineMediationController.createOnlineMediation(singleOnlineMediationMock);
       expect(reply).toStrictEqual(singleOnlineMediationMock);
     });
   });

src/online-mediation/onlineMediation.service.spec.ts

+import { HttpModule } from '@nestjs/axios';
 import { getModelToken } from '@nestjs/mongoose';
 import { Test, TestingModule } from '@nestjs/testing';
-import { OnlineMediationService } from './onlineMediation.service';
+import * as ejs from 'ejs';
 import { onlineMediationMockData } from '../../test/mock/data/onlineMediation.mock.data';
-import { MailerService } from '../mailer/mailer.service';
 import { ConfigurationService } from '../configuration/configuration.service';
 import { MailerModule } from '../mailer/mailer.module';
-import { HttpModule } from '@nestjs/axios';
-import * as ejs from 'ejs';
+import { MailerService } from '../mailer/mailer.service';
+import { OnlineMediationService } from './onlineMediation.service';
 
 jest.mock('ejs');
 describe('userRegistryService', () => {
-  let service: OnlineMediationService;
+  let onlineMediationService: OnlineMediationService;
   const mockOnlineMediationModel = {
     find: jest.fn(() => mockOnlineMediationModel),
     create: jest.fn(() => mockOnlineMediationModel),
@@ -51,17 +51,17 @@ describe('userRegistryService', () => {
         },
       ],
     }).compile();
-    service = module.get<OnlineMediationService>(OnlineMediationService);
+    onlineMediationService = module.get<OnlineMediationService>(OnlineMediationService);
   });
 
   it('should be defined', () => {
-    expect(service).toBeDefined();
+    expect(onlineMediationService).toBeDefined();
   });
 
   describe('findAll', () => {
     it('should findAll entries', async () => {
       mockOnlineMediationModel.exec.mockResolvedValueOnce(onlineMediationMockData);
-      expect(await service.getAll()).toBe(onlineMediationMockData);
+      expect(await onlineMediationService.getAll()).toBe(onlineMediationMockData);
     });
   });
   describe('create', () => {
@@ -70,13 +70,13 @@ describe('userRegistryService', () => {
         accompanimentType: 'RDV Conseiller Numérique',
         dateSlot: { day: 'Vendredi', hours: '15h00-17h00' },
         name: 'test',
-        onlineDemarcheType: ['Démarches Métropolitaines', 'CPAM'],
+        onlineDemarcheType: ['Démarches Métropolitaines'],
         phone: '65 65',
         surname: 'teztrfzegfv',
         preferredLanguage: 'Français',
       };
       mockOnlineMediationModel.create.mockResolvedValueOnce(res);
-      expect(await service.create(res)).toStrictEqual(res);
+      expect(await onlineMediationService.create(res)).toStrictEqual(res);
     });
   });
   describe('sendMailAndResetDb', () => {
@@ -90,7 +90,7 @@ describe('userRegistryService', () => {
       mockOnlineMediationModel.exec.mockResolvedValueOnce(onlineMediationMockData.length);
       mockMailService.loadJsonConfig.mockReturnValueOnce({ subject: 'Teste Mail' });
       ejsSpy.mockResolvedValueOnce('coucou');
-      const response = await service.sendMailAndResetDb();
+      const response = await onlineMediationService.sendMailAndResetDb();
       expect(mailerSpy).toHaveBeenCalledTimes(1);
       expect(response).toBe(onlineMediationMockData.length);
     });
@@ -99,7 +99,7 @@ describe('userRegistryService', () => {
       mockOnlineMediationModel.exec.mockResolvedValueOnce(onlineMediationMockData);
       mockOnlineMediationModel.deleteMany.mockReturnThis();
       mockOnlineMediationModel.exec.mockResolvedValueOnce(onlineMediationMockData.length);
-      const response = await service.sendMailAndResetDb();
+      const response = await onlineMediationService.sendMailAndResetDb();
       expect(mailerSpy).toHaveBeenCalledTimes(0);
       expect(response).toBe(onlineMediationMockData.length);
     });