src/users/schemas/user.schema.ts

@@ -66,3 +66,4 @@ export class User {
 }
 
 export const UserSchema = SchemaFactory.createForClass(User);
+UserSchema.index({ name: 'text', surname: 'text' });

src/users/services/userRegistry-search.service.spec.ts

+import { Test, TestingModule } from '@nestjs/testing';
+import { mulitpleUsers, mulitpleUsersES } from '../../../test/mock/data/users.mock.data';
+import { ConfigurationModule } from '../../configuration/configuration.module';
+import { SearchModule } from '../../search/search.module';
+import { IUserRegistry } from '../interfaces/userRegistry.interface';
+import { UserRegistrySearchService } from './userRegistry-search.service';
+
+describe('UserRegistrySearchService Search cases', () => {
+  let service: UserRegistrySearchService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      imports: [SearchModule, ConfigurationModule],
+      providers: [UserRegistrySearchService],
+    }).compile();
+
+    service = module.get<UserRegistrySearchService>(UserRegistrySearchService);
+    service['index'] = 'user-unit-test';
+    // Init test cases
+    await service.dropIndex();
+    await service.createUserRegistryIndex();
+    await Promise.all(mulitpleUsersES.map((user: any) => service.indexUserRegistry(user)));
+
+    // wait for the new structures to be indexed before search
+    await service.refreshIndexUserRegistry();
+    await new Promise((r) => setTimeout(r, 2000));
+  }, 10000);
+
+  it('should be defined', async () => {
+    expect(service).toBeDefined();
+  });
+  describe('Search method', () => {
+    it('should find Guilhem', async () => {
+      const res = await service.search('Guilhem');
+      expect(res[0].surname).toBe('Guilhem');
+      expect(res.length).toBe(1);
+    });
+    it('should find adm', async () => {
+      const res = await service.search('adm');
+      expect(res[0].name).toBe('Admin');
+      expect(res.length).toBe(1);
+    });
+    it('should find empty string', async () => {
+      const res = await service.search('');
+      expect(res.length).toBe(6);
+    });
+  });
+  describe('Indexation methods', () => {
+    it('should index User', async () => {
+      const res = await Promise.all(mulitpleUsersES.map((user: any) => service.indexUserRegistry(user)));
+      expect(res).toBeTruthy();
+      expect(res.length).toBe(6);
+    });
+    it('should update index', async () => {
+      const res = await service.update(mulitpleUsers[0] as IUserRegistry);
+      expect(res).toBeTruthy();
+    });
+    it('should delete index', async () => {
+      const resAdm = await service.search('adm');
+      const res = await service.deleteIndex(resAdm[0] as IUserRegistry);
+      expect(res).toBeTruthy();
+    });
+  });
+});

src/users/services/userRegistry-search.service.ts

+import { Injectable, Logger } from '@nestjs/common';
+import { ElasticsearchService } from '@nestjs/elasticsearch';
+import { UserRegistrySearchBody } from '../interfaces/userRegistry-search-body.interface';
+import { UserRegistrySearchResult } from '../interfaces/userRegistry-search-response.interface';
+import { IUserRegistry } from '../interfaces/userRegistry.interface';
+
+@Injectable()
+export class UserRegistrySearchService {
+  private index = 'user';
+  private readonly logger = new Logger(UserRegistrySearchService.name);
+
+  constructor(private readonly elasticsearchService: ElasticsearchService) {}
+
+  public async indexUserRegistry(user: IUserRegistry): Promise<IUserRegistry> {
+    this.logger.debug(`indexUser ${user.name} ${user.surname}`);
+    this.elasticsearchService.index<UserRegistrySearchResult, UserRegistrySearchBody>({
+      index: this.index,
+      id: user.id,
+      body: {
+        name: user.name,
+        id: user.id,
+        surname: user.surname,
+        job: user.job,
+        employer: user.employer,
+      },
+    });
+    return user;
+  }
+
+  public async createUserRegistryIndex(): Promise<any> {
+    this.logger.debug('createUserRegistryIndex');
+    return this.elasticsearchService.indices.create({
+      index: this.index,
+      body: {
+        settings: {
+          analysis: {
+            analyzer: {
+              default: {
+                type: 'french',
+              },
+              default_search: {
+                type: 'french',
+              },
+            },
+          },
+        },
+      },
+    });
+  }
+
+  public async dropIndex(): Promise<any> {
+    this.logger.debug('dropIndex');
+    const foundIndexes = (
+      await this.elasticsearchService.indices.exists({
+        index: this.index,
+      })
+    ).body;
+    if (foundIndexes) {
+      return this.elasticsearchService.indices.delete({
+        index: this.index,
+      });
+    }
+  }
+
+  public async deleteIndex(user: IUserRegistry): Promise<IUserRegistry> {
+    this.logger.debug('deleteIndex');
+    this.elasticsearchService.delete<UserRegistrySearchResult, IUserRegistry>({
+      index: this.index,
+      id: user._id,
+    });
+    return user;
+  }
+
+  public async refreshIndexUserRegistry(): Promise<any> {
+    this.logger.debug('refreshIndexUserRegistry');
+    return this.elasticsearchService.indices.refresh({
+      index: this.index,
+    });
+  }
+
+  public async search(searchString: string): Promise<any[]> {
+    this.logger.debug(`search user with query: ${searchString}`);
+    searchString = searchString ? '*' + searchString + '*' : '*';
+    const { body } = await this.elasticsearchService.search<UserRegistrySearchResult>({
+      index: this.index,
+      body: {
+        from: 0,
+        size: 200,
+        query: {
+          query_string: {
+            analyze_wildcard: 'true',
+            query: searchString,
+            fields: ['name', 'surname'],
+            fuzziness: 'AUTO',
+          },
+        },
+      },
+    });
+    const sortedHits = body.hits.hits.filter(function (elem) {
+      return elem._score >= body.hits.max_score;
+    });
+    return sortedHits.map((item) => item._source);
+  }
+
+  public async update(user: IUserRegistry): Promise<any> {
+    this.logger.debug(`Updates user : ${user._id} `);
+    return this.elasticsearchService.update({
+      index: this.index,
+      id: user._id,
+      body: {
+        doc: {
+          name: user.name,
+          surname: user.surname,
+          job: user.job,
+          employer: user.employer,
+        },
+      },
+    });
+  }
+}

src/users/services/userRegistry.service.spec.ts

+import { HttpModule } from '@nestjs/axios';
+import { getModelToken } from '@nestjs/mongoose';
+import { Test, TestingModule } from '@nestjs/testing';
+import { Types } from 'mongoose';
+import { mulitpleUsers, mulitpleUsersES } from '../../../test/mock/data/users.mock.data';
+import { ConfigurationModule } from '../../configuration/configuration.module';
+import { IUserRegistry } from '../interfaces/userRegistry.interface';
+import { EmployerService } from './employer.service';
+import { JobsService } from './jobs.service';
+import { UserRegistrySearchService } from './userRegistry-search.service';
+import { UserRegistryService } from './userRegistry.service';
+
+describe('userRegistryService', () => {
+  let service: UserRegistryService;
+  const mockUserRegistryModel = {
+    find: jest.fn(() => mockUserRegistryModel),
+    populate: jest.fn(() => mockUserRegistryModel),
+    sort: jest.fn(() => mockUserRegistryModel),
+    select: jest.fn(() => mockUserRegistryModel),
+    exec: jest.fn(() => mockUserRegistryModel),
+    count: jest.fn(() => mockUserRegistryModel),
+    limit: jest.fn(() => mockUserRegistryModel),
+  };
+
+  const mockUserRegistrySearchService = {
+    search: jest.fn(),
+    dropIndex: jest.fn(),
+    deleteIndex: jest.fn(),
+    createUserRegistryIndex: jest.fn(),
+    indexUserRegistry: jest.fn(),
+  };
+  const mockEmployersService = {
+    findByName: jest.fn(),
+  };
+  const mockJobsService = {
+    findByName: jest.fn(),
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      imports: [ConfigurationModule, HttpModule],
+      providers: [
+        UserRegistryService,
+        {
+          provide: UserRegistrySearchService,
+          useValue: mockUserRegistrySearchService,
+        },
+        {
+          provide: getModelToken('User'),
+          useValue: mockUserRegistryModel,
+        },
+        {
+          provide: JobsService,
+          useValue: mockJobsService,
+        },
+        {
+          provide: EmployerService,
+          useValue: mockEmployersService,
+        },
+      ],
+    }).compile();
+    service = module.get<UserRegistryService>(UserRegistryService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('findAll', () => {
+    const result: IUserRegistry[] = [
+      {
+        _id: Types.ObjectId('6319dfa79672971e1f8fe1b7'),
+        surname: 'ADMIN',
+        name: 'Admin',
+        employer: {
+          name: 'Pimms',
+          validated: true,
+        },
+        job: {
+          hasPersonalOffer: true,
+
+          name: 'CNFS',
+          validated: true,
+        },
+      },
+    ] as IUserRegistry[];
+    it('should findAll UserRegistry for indexation', async () => {
+      mockUserRegistryModel.exec.mockResolvedValueOnce(result);
+      expect(await service.findAllForIndexation()).toBe(result);
+    });
+
+    it('should findAll UserRegistry count', async () => {
+      mockUserRegistryModel.exec.mockResolvedValueOnce(result.length);
+      expect(await service.countAllUserRegistry()).toBe(result.length);
+    });
+    it('should findAllUserRegistry with page number 1', async () => {
+      const res = { count: 1, docs: result };
+      mockUserRegistryModel.exec.mockResolvedValueOnce(1);
+      mockUserRegistryModel.exec.mockResolvedValueOnce(result);
+      expect(await service.findAllUserRegistry(1)).toStrictEqual(res);
+    });
+  });
+  describe('find with filter', () => {
+    const result: IUserRegistry[] = [
+      {
+        _id: Types.ObjectId('6319dfa79672971e1f8fe1b7'),
+        surname: 'ADMIN',
+        name: 'Admin',
+        employer: {
+          name: 'Pimms',
+          validated: true,
+        },
+        job: {
+          hasPersonalOffer: true,
+
+          name: 'CNFS',
+          validated: true,
+        },
+      },
+    ] as IUserRegistry[];
+    const res = {
+      count: 1,
+      docs: [
+        {
+          _id: Types.ObjectId('6319dfa79672971e1f8fe1b7'),
+          surname: 'ADMIN',
+          name: 'Admin',
+          employer: {
+            name: 'Pimms',
+            validated: true,
+          },
+          job: {
+            hasPersonalOffer: true,
+
+            name: 'CNFS',
+            validated: true,
+          },
+        },
+      ],
+    };
+    it('should findUsersByNameEmployerOrJob with string param and get a result', async () => {
+      mockUserRegistrySearchService.search.mockResolvedValueOnce(result);
+      expect(await service.findUsersByNameEmployerOrJob('adm', 1)).toStrictEqual(res);
+    });
+    it('should findUsersByNameEmployerOrJob with string param and get no result', async () => {
+      const emptyRes = { count: 0, docs: [] };
+      mockUserRegistrySearchService.search.mockResolvedValueOnce([]);
+      expect(await service.findUsersByNameEmployerOrJob('azerty', 1)).toStrictEqual(emptyRes);
+    });
+    it('should findUsersByNameEmployerOrJob with no string param and filters', async () => {
+      const res = { count: 1, docs: [mulitpleUsersES[1]] };
+      const jobList = [
+        {
+          hasPersonalOffer: true,
+          name: 'CNFS',
+          validated: true,
+        },
+      ];
+      const employerList = [{ name: 'Métropole', validated: true }];
+      mockUserRegistrySearchService.search.mockResolvedValueOnce(mulitpleUsersES);
+      mockJobsService.findByName.mockResolvedValueOnce(jobList[0]);
+      mockEmployersService.findByName.mockResolvedValueOnce(employerList[0]);
+      mockUserRegistryModel.exec.mockResolvedValueOnce(mulitpleUsers);
+      expect(await service.findUsersByNameEmployerOrJob('', 1, ['CNFS'], ['Métropole'])).toStrictEqual(res);
+    });
+
+    it('should findUsersByNameEmployerOrJob with string param and filters', async () => {
+      const res = { count: 1, docs: [mulitpleUsersES[1]] };
+      const jobList = [
+        {
+          hasPersonalOffer: true,
+          name: 'CNFS',
+          validated: true,
+        },
+      ];
+      const employerList = [{ name: 'Métropole', validated: true }];
+      mockUserRegistrySearchService.search.mockResolvedValueOnce([mulitpleUsersES[1]]);
+      mockJobsService.findByName.mockResolvedValueOnce(jobList[0]);
+      mockEmployersService.findByName.mockResolvedValueOnce(employerList[0]);
+      mockUserRegistryModel.exec.mockResolvedValueOnce(mulitpleUsers);
+      expect(await service.findUsersByNameEmployerOrJob('Guil', 1, ['CNFS'], ['Métropole'])).toStrictEqual(res);
+    });
+    it('should findUsersByNameEmployerOrJob with string param and filters and return empty', async () => {
+      const res = { count: 0, docs: [] };
+      const jobList = [
+        {
+          hasPersonalOffer: true,
+          name: 'CNFS',
+          validated: true,
+        },
+      ];
+      const employerList = [{ name: 'Métropole', validated: true }];
+      mockUserRegistrySearchService.search.mockResolvedValueOnce([]);
+      mockJobsService.findByName.mockResolvedValueOnce(jobList[0]);
+      mockEmployersService.findByName.mockResolvedValueOnce(employerList[0]);
+      mockUserRegistryModel.exec.mockResolvedValueOnce([]);
+      expect(await service.findUsersByNameEmployerOrJob('azerrttt', 1, ['CNFS'], ['Métropole'])).toStrictEqual(res);
+    });
+    it('should findUsersByNameEmployerOrJob with string param and one filter', async () => {
+      const res = { count: 2, docs: [mulitpleUsersES[0], mulitpleUsersES[2]] };
+      const employerList = [{ name: 'CAF', validated: true }];
+      mockUserRegistrySearchService.search.mockResolvedValueOnce(mulitpleUsersES);
+      mockEmployersService.findByName.mockResolvedValueOnce(employerList[0]);
+      mockUserRegistryModel.exec.mockResolvedValueOnce(mulitpleUsers);
+      expect(await service.findUsersByNameEmployerOrJob('a', 1, [], ['CAF'])).toStrictEqual(res);
+    });
+
+    it('should findUsersByNameEmployerOrJob with no string param and one employer filter', async () => {
+      const res = { count: 2, docs: [mulitpleUsersES[2], mulitpleUsersES[3]] };
+
+      const jobList = [
+        {
+          hasPersonalOffer: true,
+          name: 'Conseiller',
+          validated: true,
+        },
+      ];
+      mockUserRegistrySearchService.search.mockResolvedValueOnce(mulitpleUsersES);
+
+      mockJobsService.findByName.mockResolvedValueOnce(jobList[0]);
+      mockUserRegistryModel.exec.mockResolvedValueOnce(mulitpleUsers);
+      expect(await service.findUsersByNameEmployerOrJob('', 1, ['Conseiller'], [])).toStrictEqual(res);
+    });
+  });
+
+  describe('Search', () => {
+    it('should initUserRegistryIndex', async () => {
+      mockUserRegistryModel.exec.mockResolvedValueOnce(mulitpleUsers);
+      mockUserRegistrySearchService.dropIndex.mockResolvedValueOnce({});
+      mockUserRegistrySearchService.createUserRegistryIndex.mockResolvedValueOnce({});
+      mockUserRegistrySearchService.indexUserRegistry.mockResolvedValueOnce({});
+      expect(await service.initUserRegistryIndex()).toBe(mulitpleUsers);
+    });
+
+    it('should findAllUserRegistry with page number 1', async () => {
+      mockUserRegistrySearchService.search.mockResolvedValueOnce([mulitpleUsers[0]]);
+
+      expect(await service.searchByNameAndSurname('adm')).toStrictEqual([mulitpleUsers[0]]);
+    });
+  });
+});

src/users/services/userRegistry.service.ts

+import { Injectable, Logger } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { IUser } from '../interfaces/user.interface';
+import { IUserRegistry, UserRegistryPaginatedResponse } from '../interfaces/userRegistry.interface';
+import { Employer } from '../schemas/employer.schema';
+import { Job } from '../schemas/job.schema';
+import { User } from '../schemas/user.schema';
+import { EmployerService } from './employer.service';
+import { JobsService } from './jobs.service';
+import { UserRegistrySearchService } from './userRegistry-search.service';
+
+@Injectable()
+export class UserRegistryService {
+  private readonly logger = new Logger(UserRegistryService.name);
+  constructor(
+    @InjectModel(User.name) private userModel: Model<IUser>,
+    private userRegistrySearchService: UserRegistrySearchService,
+    private jobsService: JobsService,
+    private employerService: EmployerService
+  ) {}
+  public maxPerPage = 20;
+
+  public async findAllForIndexation(): Promise<IUserRegistry[]> {
+    return this.userModel
+      .find()
+      .select('name surname _id job employer ')
+      .populate('job employer')
+      .sort({ surname: 1 })
+      .exec();
+  }
+
+  public async countAllUserRegistry(): Promise<number> {
+    return this.userModel
+      .find()
+      .populate('employer')
+      .populate('job')
+      .select('name surname employer job _id ')
+      .sort({ surname: 1 })
+      .count()
+      .exec();
+  }
+
+  public async findAllUserRegistry(page: number): Promise<UserRegistryPaginatedResponse> {
+    const limit = this.maxPerPage * page;
+    const count = await this.countAllUserRegistry();
+    const docs = await this.userModel
+      .find()
+      .populate('employer')
+      .populate('job')
+      .select('name surname employer job _id ')
+      .limit(limit)
+      .sort({ surname: 1 })
+      .exec();
+    return { count: count, docs: docs };
+  }
+
+  private callbackFilter(users: IUser[], employersList: Employer[], jobList: Job[]): IUser[] {
+    const jobNames: string[] = jobList.map((job) => job.name);
+    const employersNames: string[] = employersList.map((e) => e.name);
+    // For each filter list (job or employer), we'll filter the main user list in order to get only the user that have a job or employer contained in the filters array
+    // For this, we une findexIndex method on job/employer name
+    if (employersList?.length && jobList?.length) {
+      return users.filter(
+        (user) =>
+          jobNames.findIndex((n) => user.job.name === n) > -1 &&
+          employersNames.findIndex((n) => user.employer.name === n) > -1
+      );
+    }
+
+    if (employersList?.length) {
+      return users.filter((user) => employersNames.findIndex((n) => user.employer.name === n) > -1);
+    }
+    if (jobList?.length) {
+      return users.filter((user) => jobNames.findIndex((n) => user.job.name === n) > -1);
+    }
+  }
+
+  public async findUsersByNameEmployerOrJob(
+    searchParam: string,
+    page: number,
+    jobs?: string[],
+    employers?: string[]
+  ): Promise<UserRegistryPaginatedResponse> {
+    const results = await this.userRegistrySearchService.search(searchParam);
+    const limit = page * this.maxPerPage || this.maxPerPage;
+    if (jobs?.length || employers?.length) {
+      const jobList: Job[] = [];
+      const employersList: Employer[] = [];
+      if (jobs) {
+        for (const job of jobs) {
+          jobList.push(await this.jobsService.findByName(job));
+        }
+      }
+      if (employers) {
+        for (const employer of employers) {
+          employersList.push(await this.employerService.findByName(employer));
+        }
+      }
+      const resultsWithFilter = await this.userModel
+        .find({
+          $or: [
+            {
+              job: { $exists: true },
+            },
+            {
+              employer: { $exists: true },
+            },
+          ],
+        })
+        .select('name surname employer job _id ')
+        .populate('employer job')
+        .sort({ surname: 1 })
+        .exec()
+        .then((res) => {
+          return this.callbackFilter(res, employersList, jobList);
+        });
+      const idsWithFilter = resultsWithFilter.map((user) => user._id.toString());
+      const mergedResults = results.filter((user) => idsWithFilter.includes(user.id.toString()));
+      return { count: mergedResults.length, docs: mergedResults.splice(0, limit) };
+    }
+    return { count: results.length, docs: results.splice(0, limit) };
+  }
+
+  // SEARCH
+  public async searchByNameAndSurname(searchString: string): Promise<any[]> {
+    this.logger.debug('searchByNameAndSurname');
+    return this.userRegistrySearchService.search(searchString);
+  }
+
+  public async initUserRegistryIndex(): Promise<IUserRegistry[]> {
+    Logger.log('Reset structures indexes');
+    await this.userRegistrySearchService.dropIndex();
+    await this.userRegistrySearchService.createUserRegistryIndex();
+    return this.populateES();
+  }
+
+  private async populateES(): Promise<IUserRegistry[]> {
+    const users = await this.findAllForIndexation();
+    await Promise.all(
+      users.map((user: IUserRegistry) => {
+        this.userRegistrySearchService.indexUserRegistry(user);
+      })
+    );
+    return users;
+  }
+}

src/users/services/users.service.spec.ts

@@ -17,6 +17,7 @@ import { User } from '../schemas/user.schema';
 import { IUser } from '../interfaces/user.interface';
 import { UpdateDetailsDto } from '../dto/update-details.dto';
 import { DescriptionDto } from '../dto/description.dto';
+import { UserRegistrySearchService } from './userRegistry-search.service';
 
 function hashPassword() {
   return bcrypt.hashSync(process.env.USER_PWD, process.env.SALT);
@@ -24,14 +25,26 @@ function hashPassword() {
 
 const mockUserModel = {
   create: jest.fn(),
-  findOne: jest.fn(),
+  findOne: jest.fn(() => mockUserModel),
   findById: jest.fn(),
   deleteOne: jest.fn(),
   updateMany: jest.fn(),
   exec: jest.fn(),
   find: jest.fn(() => mockUserModel),
   sort: jest.fn(() => mockUserModel),
-  findByIdAndUpdate: jest.fn(),
+  populate: jest.fn(() => mockUserModel),
+  select: jest.fn(() => mockUserModel),
+  limit: jest.fn(() => mockUserModel),
+  findByIdAndUpdate: jest.fn(() => mockUserModel),
+  findPopulatedUserRegistryById: jest.fn(() => mockUserModel),
+};
+const mockUserRegistrySearchService = {
+  indexUserRegistry: jest.fn(),
+  search: jest.fn(),
+  dropIndex: jest.fn(),
+  createindexUserRegistryIndex: jest.fn(),
+  deleteIndex: jest.fn(),
+  update: jest.fn(),
 };
 
 describe('UsersService', () => {
@@ -42,6 +55,11 @@ describe('UsersService', () => {
       imports: [MailerModule, ConfigurationModule],
       providers: [
         UsersService,
+        UserRegistrySearchService,
+        {
+          provide: UserRegistrySearchService,
+          useValue: mockUserRegistrySearchService,
+        },
         {
           provide: getModelToken('User'),
           useValue: mockUserModel,
@@ -481,6 +499,7 @@ describe('UsersService', () => {
       const user = usersMockData[0];
       const detailsDto: UpdateDetailsDto = { name: 'Michel', surname: 'Chelmi', phone: '0601020304' };
       mockUserModel.findByIdAndUpdate.mockResolvedValueOnce({ ...user, ...detailsDto });
+      mockUserModel.findPopulatedUserRegistryById.mockResolvedValueOnce({ ...user, ...detailsDto });
       const updatedUser = await service.updateUserDetails('', { name: '', surname: '', phone: '' });
       expect(updatedUser.name).toBe(detailsDto.name);
       expect(updatedUser.surname).toBe(detailsDto.surname);

src/users/services/users.service.ts

@@ -18,6 +18,8 @@ import { JobDocument } from '../schemas/job.schema';
 import { PersonalOfferDocument } from '../../personal-offers/schemas/personal-offer.schema';
 import { UpdateDetailsDto } from '../dto/update-details.dto';
 import { DescriptionDto } from '../dto/description.dto';
+import { UserRegistrySearchService } from './userRegistry-search.service';
+import { IUserRegistry } from '../interfaces/userRegistry.interface';
 
 @Injectable()
 export class UsersService {
@@ -25,6 +27,7 @@ export class UsersService {
   constructor(
     @InjectModel(User.name) private userModel: Model<IUser>,
     private readonly mailerService: MailerService,
+    private userRegistrySearchService: UserRegistrySearchService,
     private configurationService: ConfigurationService
   ) {}
 
@@ -55,6 +58,7 @@ export class UsersService {
     // Send verification email
     createUser = await this.verifyUserMail(createUser);
     createUser.save();
+    this.userRegistrySearchService.indexUserRegistry(createUser);
     return this.findOne(createUserDto.email);
   }
 
@@ -90,6 +94,15 @@ export class UsersService {
   public findAll(): Promise<User[]> {
     return this.userModel.find().populate('employer').populate('job').select('-password').exec();
   }
+  public async findPopulatedUserRegistryById(userId: string): Promise<IUserRegistry> {
+    return this.userModel
+      .findOne({ _id: userId })
+      .select('name surname _id job employer ')
+      .populate('job employer')
+      .sort({ surname: 1 })
+      .limit(1)
+      .exec();
+  }
 
   public findAllUnattached(): Promise<IUser[]> {
     return this.userModel
@@ -641,6 +654,7 @@ export class UsersService {
     if (!user) {
       throw new HttpException('Invalid user email', HttpStatus.BAD_REQUEST);
     }
+    this.userRegistrySearchService.deleteIndex(user);
     return user.deleteOne();
   }
 
@@ -649,6 +663,7 @@ export class UsersService {
     if (!user) {
       throw new HttpException('Invalid user id', HttpStatus.BAD_REQUEST);
     }
+    this.userRegistrySearchService.deleteIndex(user);
     return user.deleteOne();
   }
 
@@ -697,7 +712,9 @@ export class UsersService {
    */
   public async updateUserProfile(userId: Types.ObjectId, employer: EmployerDocument, job: JobDocument): Promise<any> {
     this.logger.debug(`updateUserProfile | ${userId}`);
-    return this.userModel.updateOne({ _id: userId }, { $set: { employer: employer._id, job: job._id } });
+    const updated = await this.userModel.updateOne({ _id: userId }, { $set: { employer: employer._id, job: job._id } });
+    if (updated) this.userRegistrySearchService.update(updated);
+    return updated;
   }
 
   /**
@@ -707,7 +724,12 @@ export class UsersService {
    */
   public async updateUserJob(userId: Types.ObjectId, job: JobDocument): Promise<any> {
     this.logger.debug(`updateUserProfile - Job | ${userId}`);
-    return this.userModel.updateOne({ _id: userId }, { $set: { job: job._id } });
+    const updated = await this.userModel.updateOne({ _id: userId }, { $set: { job: job._id } });
+    if (updated) {
+      const populatedResult = await this.findPopulatedUserRegistryById(updated._id);
+      this.userRegistrySearchService.update(populatedResult);
+    }
+    return updated;
   }
 
   /**
@@ -717,7 +739,12 @@ export class UsersService {
    */
   public async updateUserEmployer(userId: Types.ObjectId, employer: EmployerDocument): Promise<any> {
     this.logger.debug(`updateUserProfile - Employer | ${userId}`);
-    return this.userModel.updateOne({ _id: userId }, { $set: { employer: employer._id } });
+    const updated = await this.userModel.updateOne({ _id: userId }, { $set: { employer: employer._id } });
+    if (updated) {
+      const populatedResult = await this.findPopulatedUserRegistryById(updated._id);
+      this.userRegistrySearchService.update(populatedResult);
+    }
+    return updated;
   }
 
   /**
@@ -731,6 +758,8 @@ export class UsersService {
     if (!result) {
       throw new HttpException('User not found', HttpStatus.BAD_REQUEST);
     }
+    const populatedResult = await this.findPopulatedUserRegistryById(userId);
+    this.userRegistrySearchService.update(populatedResult);
     return result;
   }
 
@@ -745,6 +774,8 @@ export class UsersService {
     if (!result) {
       throw new HttpException('User not found', HttpStatus.BAD_REQUEST);
     }
+    const populatedResult = await this.findPopulatedUserRegistryById(userId);
+    this.userRegistrySearchService.update(populatedResult);
     return result;
   }
 }

src/users/users.module.ts

@@ -15,6 +15,9 @@ import { Job, JobSchema } from './schemas/job.schema';
 import { Employer, EmployerSchema } from './schemas/employer.schema';
 import { EmployerSearchService } from './services/employer-search.service';
 import { SearchModule } from '../search/search.module';
+import { UsersRegistryController } from './controllers/userRegistry.controller';
+import { UserRegistryService } from './services/userRegistry.service';
+import { UserRegistrySearchService } from './services/userRegistry-search.service';
 
 @Module({
   imports: [
@@ -29,8 +32,15 @@ import { SearchModule } from '../search/search.module';
     TempUserModule,
     SearchModule,
   ],
-  providers: [UsersService, JobsService, EmployerSearchService, EmployerService],
-  exports: [UsersService, JobsService, EmployerService],
-  controllers: [UsersController, JobsController, EmployerController],
+  providers: [
+    UsersService,
+    JobsService,
+    EmployerSearchService,
+    EmployerService,
+    UserRegistryService,
+    UserRegistrySearchService,
+  ],
+  exports: [UsersService, JobsService, EmployerService, UserRegistryService, UserRegistrySearchService],
+  controllers: [UsersController, JobsController, EmployerController, UsersRegistryController],
 })
 export class UsersModule {}

template.env

@@ -21,6 +21,10 @@ GHOST_CONTENT_API_KEY=<Ghost global api key, can be found in integration part of
 GHOST_ADMIN_API_KEY=<Ghost admin api key, can be found in integration part of ghost UI>
 GHOST_HOST_AND_PORT=<Ghost host and port, ex:http://localhost:2368>
 USER_PWD=<test user password, this password will be user by every test users>
+#Mailchimp
+MC_API_KEY=<Mailchimp api key>
+MC_SERVER=<Mailchimp server>
+MC_LIST_ID=<Mailchimp list id>
 ELASTICSEARCH_NODE=<elastic search container node>
 ELASTICSEARCH_PATH=<elastic search container path>
 ELASTICSEARCH_PORT=<elastic search port>

test/mock/data/structures.mock.data.ts

+import { StructureDto } from '../../../src/structures/dto/structure.dto';
 import { StructureDocument } from '../../../src/structures/schemas/structure.schema';
 
 export const structuresDocumentDataMock: StructureDocument[] = [
@@ -166,3 +167,81 @@ export const structuresDocumentDataMock: StructureDocument[] = [
     save: jest.fn(),
   } as any,
 ] as StructureDocument[];
+
+export const structureMockDto: StructureDto = {
+  coord: [4.8498155, 45.7514817],
+  equipmentsAndServices: ['wifiEnAccesLibre'],
+  digitalCultureSecurity: [],
+  parentingHelp: [],
+  socialAndProfessional: [],
+  accessRight: [],
+  baseSkills: [],
+  proceduresAccompaniment: [],
+  publicsAccompaniment: [],
+  publics: ['adultes'],
+  labelsQualifications: [],
+  accessModality: ['telephoneVisio'],
+  structureType: null,
+  structureName: 'a',
+  description: null,
+  lockdownActivity: null,
+  address: {
+    numero: null,
+    street: 'Rue Alphonse Daudet',
+    commune: 'Lyon 7ème Arrondissement',
+  },
+  contactMail: '',
+  contactPhone: '',
+  website: '',
+  facebook: null,
+  twitter: null,
+  instagram: null,
+  linkedin: null,
+  hours: {
+    monday: {
+      open: false,
+      time: [],
+    },
+    tuesday: {
+      open: false,
+      time: [],
+    },
+    wednesday: {
+      open: false,
+      time: [],
+    },
+    thursday: {
+      open: false,
+      time: [],
+    },
+    friday: {
+      open: false,
+      time: [],
+    },
+    saturday: {
+      open: false,
+      time: [],
+    },
+    sunday: {
+      open: false,
+      time: [],
+    },
+  },
+  pmrAccess: false,
+  exceptionalClosures: null,
+  otherDescription: null,
+  nbComputers: 1,
+  nbPrinters: 1,
+  nbTablets: 1,
+  nbNumericTerminal: 1,
+  nbScanners: 1,
+  freeWorkShop: false,
+  accountVerified: true,
+  personalOffers: [],
+  createdAt: new Date(),
+  updatedAt: new Date(),
+  deletedAt: new Date(),
+  remoteAccompaniment: true,
+  dataShareConsentDate: new Date(),
+  numero: '',
+};

test/mock/data/users.mock.data.ts

@@ -74,3 +74,190 @@ export const userDetails: IUser[] = [
     },
   },
 ] as IUser[];
+
+export const mulitpleUsers: IUser[] = [
+  {
+    _id: '627b85aea0466f0f132e1599',
+    surname: 'ADMIN',
+    name: 'Admin',
+    email: 'admin@admin.com',
+    employer: {
+      name: 'CAF',
+      validated: true,
+    },
+    job: {
+      hasPersonalOffer: true,
+      name: 'CNFS',
+      validated: true,
+    },
+  },
+  {
+    _id: '627b85aea0466f0f132e1598',
+    surname: 'Guilhem',
+    name: 'CARRON',
+    email: 'admin@admin.com',
+    employer: {
+      name: 'Métropole',
+      validated: true,
+    },
+    job: {
+      hasPersonalOffer: true,
+      name: 'CNFS',
+      validated: true,
+    },
+  },
+  {
+    _id: '627b85aea0466f0f132e1597',
+    surname: 'Jean-Paul',
+    name: 'DESCHAMPS',
+    email: 'admin@admin.com',
+    employer: {
+      name: 'CAF',
+      validated: true,
+    },
+    job: {
+      hasPersonalOffer: true,
+      name: 'Conseiller',
+      validated: true,
+    },
+  },
+  {
+    _id: '627b85aea0466f0f132e1596',
+    surname: 'Paula',
+    name: 'Dubois',
+    email: 'admin@admin.com',
+    employer: {
+      name: 'Pimms',
+      validated: true,
+    },
+    job: {
+      hasPersonalOffer: true,
+      name: 'Conseiller',
+      validated: true,
+    },
+  },
+  {
+    _id: '627b85aea0466f0f132e1595',
+    surname: 'Marine',
+    name: 'Ducal',
+    email: 'admin@admin.com',
+    employer: {
+      name: 'Médiateur',
+      validated: true,
+    },
+    job: {
+      hasPersonalOffer: true,
+      name: 'CNFS',
+      validated: true,
+    },
+  },
+  {
+    _id: '627b85aea0466f0f132e1594',
+    surname: 'Bastien',
+    name: 'Dumont',
+    email: 'admin@admin.com',
+    employer: {
+      name: 'Pimms',
+      validated: true,
+    },
+    job: {
+      hasPersonalOffer: true,
+      name: 'CNFS',
+      validated: true,
+    },
+  },
+] as IUser[];
+
+//Elastic search doesn't support _id
+export const mulitpleUsersES: IUser[] = [
+  {
+    id: '627b85aea0466f0f132e1599',
+    surname: 'ADMIN',
+    name: 'Admin',
+    email: 'admin@admin.com',
+    employer: {
+      name: 'CAF',
+      validated: true,
+    },
+    job: {
+      hasPersonalOffer: true,
+      name: 'CNFS',
+      validated: true,
+    },
+  },
+  {
+    id: '627b85aea0466f0f132e1598',
+    surname: 'Guilhem',
+    name: 'CARRON',
+    email: 'admin@admin.com',
+    employer: {
+      name: 'Métropole',
+      validated: true,
+    },
+    job: {
+      hasPersonalOffer: true,
+      name: 'CNFS',
+      validated: true,
+    },
+  },
+  {
+    id: '627b85aea0466f0f132e1597',
+    surname: 'Jean-Paul',
+    name: 'DESCHAMPS',
+    email: 'admin@admin.com',
+    employer: {
+      name: 'CAF',
+      validated: true,
+    },
+    job: {
+      hasPersonalOffer: true,
+      name: 'Conseiller',
+      validated: true,
+    },
+  },
+  {
+    id: '627b85aea0466f0f132e1596',
+    surname: 'Paula',
+    name: 'Dubois',
+    email: 'admin@admin.com',
+    employer: {
+      name: 'Pimms',
+      validated: true,
+    },
+    job: {
+      hasPersonalOffer: true,
+      name: 'Conseiller',
+      validated: true,
+    },
+  },
+  {
+    id: '627b85aea0466f0f132e1595',
+    surname: 'Marine',
+    name: 'Ducal',
+    email: 'admin@admin.com',
+    employer: {
+      name: 'Médiateur',
+      validated: true,
+    },
+    job: {
+      hasPersonalOffer: true,
+      name: 'CNFS',
+      validated: true,
+    },
+  },
+  {
+    id: '627b85aea0466f0f132e1594',
+    surname: 'Bastien',
+    name: 'Dumont',
+    email: 'admin@admin.com',
+    employer: {
+      name: 'Pimms',
+      validated: true,
+    },
+    job: {
+      hasPersonalOffer: true,
+      name: 'CNFS',
+      validated: true,
+    },
+  },
+] as IUser[];