feat: add lifecycle history page for identities

- Implemented a new lifecycle history page for identities with timeline view and grouping options.
- Added functionality to load lifecycles based on selected grouping (day, month, year).

feat: create trash view for identities

- Developed a trash view for identities allowing users to view and manage deleted identities.
- Integrated identity details and save functionality within the trash view.

feat: add job details page

- Introduced a job details page with timeline representation of jobs.
- Implemented grouping options for jobs and detailed views for job parameters and results.

feat: create agent settings pages

- Added agent settings pages including index, debug, and details views.
- Implemented save and delete functionalities for agents with validation handling.

feat: implement initial hash capture and restoration

- Created plugins to capture and restore the initial URL hash for better navigation handling.
- Enhanced scroll behavior to manage hash-based navigation effectively.

chore: add HTTP type definitions

- Introduced TypeScript definitions for HTTP instance to improve type safety across the application.

chore: add release notes generation script

- Developed a Python script to generate release notes from Git commit history.
- The script supports specifying previous and target versions for changelog generation.

Author: tacxou

apps/api/src/config.ts

@@ -157,6 +157,10 @@ export const validationSchema = Joi.object({
   SESAME_CRON_LOG_DIRECTORY: Joi
     .string()
     .default(path.join(process.cwd(), 'logs', 'handlers')),
+
+  SESAME_IDENTITY_DOUBLON_SEARCH_ATTRIBUTES: Joi
+    .string()
+    .default(''),
 });
 
 /**
@@ -249,6 +253,9 @@ export interface ConfigInstance {
   lifecycle: {
     triggerCronExpression: string
   }
+  identities: {
+    doublonSearchAttributes: string[]
+  }
   swagger: {
     path: string
     api: string
@@ -382,6 +389,14 @@ export default (): ConfigInstance => ({
   lifecycle: {
     triggerCronExpression: process.env['SESAME_LIFECYCLE_TRIGGER_CRON'] || '*/5 * * * *',
   },
+  identities: {
+    doublonSearchAttributes: process.env['SESAME_IDENTITY_DOUBLON_SEARCH_ATTRIBUTES']
+      ? process.env['SESAME_IDENTITY_DOUBLON_SEARCH_ATTRIBUTES'].split(',').map(attr => attr.trim())
+      : [
+        'additionalFields.attributes.supannPerson.supannOIDCDatedeNaissance',
+        'inetOrgPerson.givenName',
+      ],
+  },
   sms: {
     host: process.env['SESAME_SMPP_SERVER'] || '',
     systemId: process.env['SESAME_SMPP_SYSTEMID'] || '',

apps/api/src/core/cron/_dto/config-task.dto.ts

@@ -1,6 +1,40 @@
 import { ApiProperty } from '@nestjs/swagger'
 import { Type } from 'class-transformer'
-import { IsArray, IsBoolean, IsNotEmpty, IsObject, IsOptional, IsString, ValidateNested } from 'class-validator'
+import {
+  IsArray,
+  IsBoolean,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  Validate,
+  ValidateNested,
+  ValidationArguments,
+  ValidatorConstraint,
+  ValidatorConstraintInterface,
+} from 'class-validator'
+
+@ValidatorConstraint({ name: 'isStringArrayOrObject', async: false })
+class IsStringArrayOrObject implements ValidatorConstraintInterface {
+  public validate(value: any, args: ValidationArguments) {
+    if (!value) return true // Optional field
+
+    // Vérifie si c'est un tableau de strings
+    if (Array.isArray(value)) {
+      return value.every((item) => typeof item === 'string')
+    }
+
+    // Vérifie si c'est un objet (mais pas un tableau ou null)
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      return true
+    }
+
+    return false
+  }
+
+  defaultMessage(args: ValidationArguments) {
+    return 'options doit être soit un tableau de strings, soit un objet clé-valeur'
+  }
+}
 
 /**
  * DTO représentant la configuration d'une tâche cron
@@ -58,15 +92,28 @@ export class CronTaskDTO {
   })
   handler: string
 
-  @IsObject()
+  /**
+   * Options de la tâche : soit un tableau de strings (args), soit un objet clé-valeur
+   *
+   * @type {string[] | Record<string, any>}
+   * @description Permet de spécifier des options supplémentaires pour la tâche cron.
+   * Peut être un tableau de chaînes de caractères représentant des arguments,
+   * ou un objet avec des paires clé-valeur pour des configurations plus complexes.
+   */
   @IsOptional()
+  @Validate(IsStringArrayOrObject)
   @ApiProperty({
-    type: 'object',
-    description: 'Options spécifiques de la tâche (clé/valeur)',
-    example: { retentionPeriodDays: 30 },
-    additionalProperties: true,
+    oneOf: [
+      { type: 'array', items: { type: 'string' } },
+      { type: 'object', additionalProperties: true },
+    ],
+    description: 'Options spécifiques de la tâche : tableau de strings ou objet clé/valeur',
+    examples: [
+      ['arg1', 'arg2'],
+      { key1: 'value1', key2: 'value2', retentionPeriodDays: 30 },
+    ],
   })
-  options?: Record<string, any>
+  options?: string[] | Record<string, any>
 }
 
 export class ConfigTaskDTO {

apps/api/src/management/identities/_dto/_parts/activation-dto.ts

@@ -1,12 +1,20 @@
 import { ApiProperty } from '@nestjs/swagger';
-import { IsBoolean, IsString } from 'class-validator';
+import { IsIn, IsMongoId } from 'class-validator';
+import { DataStatusEnum } from '../../_enums/data-status';
 
 export class ActivationDto {
-  @IsString()
+  @IsMongoId()
   @ApiProperty({ example: '66d80ab41821baca9bf965b2', description: 'Id of identity', type: String })
-  public id: string;
+  public id: string
 
-  @IsBoolean()
-  @ApiProperty({ example: 'true', description: 'true or false to enable or disable the identity', type: String })
-  public status: boolean;
+  @IsIn([DataStatusEnum.ACTIVE, DataStatusEnum.INACTIVE], {
+    message: 'Le statut doit être ACTIVE ou INACTIVE.'
+  })
+  @ApiProperty({
+    example: DataStatusEnum.ACTIVE,
+    description: 'Desired status of the identity: ACTIVE or INACTIVE',
+    enum: [DataStatusEnum.ACTIVE, DataStatusEnum.INACTIVE],
+    type: Number,
+  })
+  public status: DataStatusEnum
 }

apps/api/src/management/identities/_schemas/identities.schema.ts

@@ -32,6 +32,9 @@ export class Identities extends AbstractSchema {
   @Prop({ type: Boolean, default: false })
   public ignoreLifecycle: boolean;
 
+  @Prop({ type: [Types.ObjectId], default: [] })
+  public ignoreFusion: Types.ObjectId[];
+
   @Prop({ type: inetOrgPersonSchema, required: true })
   public inetOrgPerson: inetOrgPerson;
 
@@ -93,4 +96,4 @@ export const IdentitiesSchema = SchemaFactory.createForClass(Identities)
   .index(
     { 'inetOrgPerson.employeeNumber': 1, 'inetOrgPerson.employeeType': 1 },
     { unique: true },
-  );
+  )

apps/api/src/management/identities/abstract-identities.service.ts

@@ -18,6 +18,7 @@ import { DataStatusEnum } from "~/management/identities/_enums/data-status";
 import { JobState } from "~/core/jobs/_enums/state.enum";
 import { inetOrgPersonDto } from './_dto/_parts/inetOrgPerson.dto';
 import { EventEmitter2 } from '@nestjs/event-emitter';
+import { ConfigService } from '@nestjs/config';
 
 /**
  * Service abstrait pour la gestion des identités
@@ -31,6 +32,7 @@ export abstract class AbstractIdentitiesService extends AbstractServiceSchema {
    *
    * @param _model - Modèle Mongoose pour les identités
    * @param _validation - Service de validation des identités
+   * @param config - Service de configuration
    * @param storage - Service de stockage de fichiers
    * @param passwdAdmService - Service d'administration des mots de passe
    * @param eventEmitter - Émetteur d'événements
@@ -40,6 +42,7 @@ export abstract class AbstractIdentitiesService extends AbstractServiceSchema {
     @InjectModel(Identities.name) protected _model: Model<Identities>,
     protected readonly _validation: IdentitiesValidationService,
     protected readonly storage: FactorydriveService,
+    protected readonly config: ConfigService,
     protected readonly passwdAdmService: PasswdadmService,
     protected readonly eventEmitter: EventEmitter2,
     @Inject(forwardRef(() => BackendsService)) protected readonly backends: BackendsService,

apps/api/src/management/identities/identities-activation.controller.ts

@@ -44,30 +44,11 @@ export class IdentitiesActivationController extends AbstractController {
     @Body() body: ActivationDto,
   ): Promise<Response> {
     try {
-      // Validation des paramètres d'entrée
-      if (!body?.id || typeof body.id !== 'string') {
-        return res.status(HttpStatus.BAD_REQUEST).json({
-          statusCode: HttpStatus.BAD_REQUEST,
-          message: 'Valid identity ID is required',
-        });
-      }
-
-      if (typeof body.status !== 'boolean') {
-        return res.status(HttpStatus.BAD_REQUEST).json({
-          statusCode: HttpStatus.BAD_REQUEST,
-          message: 'Status must be a boolean value',
-        });
-      }
-
-      // Détermination du statut cible selon le paramètre booléen
-      const targetStatus = body.status ? DataStatusEnum.ACTIVE : DataStatusEnum.INACTIVE;
-
-      // Appel du service d'activation
-      const result = await this._service.activation(body.id, targetStatus);
+      const result = await this._service.activation(body.id, body.status)
 
       return res.status(HttpStatus.OK).json({
         statusCode: HttpStatus.OK,
-        message: `Identity ${body.status ? 'activated' : 'deactivated'} successfully`,
+        message: `Identity ${body.status === DataStatusEnum.ACTIVE ? 'activated' : 'deactivated'} successfully`,
         data: result,
       });
 

apps/api/src/management/identities/identities-crud.controller.ts

@@ -8,6 +8,7 @@ import {
   Param,
   Patch,
   Post,
+  Query,
   Res,
 } from '@nestjs/common';
 import { ApiOperation, ApiParam, ApiTags } from '@nestjs/swagger';
@@ -36,6 +37,8 @@ import { IdentitiesValidationService } from './validations/identities.validation
 import { FilestorageService } from '~/core/filestorage/filestorage.service';
 import { TransformersFilestorageService } from '~/core/filestorage/_services/transformers-filestorage.service';
 import { IdentitiesCrudService } from '~/management/identities/identities-crud.service';
+import { Public } from '~/_common/decorators/public.decorator';
+import { isEmpty } from 'radash';
 
 @ApiTags('management/identities')
 @Controller('identities')
@@ -58,6 +61,14 @@ export class IdentitiesCrudController extends AbstractController {
     lifecycle: 1,
   };
 
+  protected static readonly searchFields: PartialProjectionType<any> = {
+    'inetOrgPerson.cn': 1,
+    'inetOrgPerson.givenName': 1,
+    'inetOrgPerson.sn': 1,
+    'inetOrgPerson.mail': 1,
+    'inetOrgPerson.employeeType': 1,
+  };
+
   @Post()
   @ApiCreateDecorator(IdentitiesCreateDto, IdentitiesDto)
   public async create(
@@ -109,6 +120,7 @@ export class IdentitiesCrudController extends AbstractController {
   @ApiPaginatedDecorator(PickProjectionHelper(IdentitiesDto, IdentitiesCrudController.projection))
   public async getdeleted(
     @Res() res: Response,
+    @Query('search') search: string,
     @SearchFilterOptions() searchFilterOptions: FilterOptions,
   ): Promise<
     Response<
@@ -134,30 +146,40 @@ export class IdentitiesCrudController extends AbstractController {
   @ApiPaginatedDecorator(PickProjectionHelper(IdentitiesDto, IdentitiesCrudController.projection))
   public async search(
     @Res() res: Response,
+    @Query('search') search: string,
     @SearchFilterSchema() searchFilterSchema: FilterSchema,
-    @SearchFilterOptions() searchFilterOptions: FilterOptions,
-  ): Promise<
-    Response<
-      {
-        statusCode: number;
-        data?: Document<Identities, any, Identities>;
-        total?: number;
-        message?: string;
-        validations?: MixedValue;
-      },
-      any
-    >
-  > {
+    @SearchFilterOptions({ allowUnlimited: true }) searchFilterOptions: FilterOptions,
+  ): Promise<Response<{
+    statusCode: number;
+    data?: Document<Identities, any, Identities>;
+    total?: number;
+    message?: string;
+    validations?: MixedValue;
+  }>> {
+    const searchFilter = {}
+
+    if (search && search.trim().length > 0) {
+      const searchRequest = {}
+      searchRequest['$or'] = Object.keys(IdentitiesCrudController.searchFields).map((key) => {
+        return { [key]: { $regex: `^${search}`, $options: 'i' } }
+      }).filter(item => item !== undefined)
+      searchFilter['$and'] = [searchRequest]
+      searchFilter['$and'].push(searchFilterSchema)
+    } else {
+      Object.assign(searchFilter, searchFilterSchema)
+    }
+
     const [data, total] = await this._service.findAndCount(
-      searchFilterSchema,
+      searchFilter,
       IdentitiesCrudController.projection,
       searchFilterOptions,
-    );
+    )
+
     return res.status(HttpStatus.OK).json({
       statusCode: HttpStatus.OK,
       total,
       data,
-    });
+    })
   }
 
   @Get(':_id([0-9a-fA-F]{24})')

apps/api/src/management/identities/identities-doublon.controller.ts

@@ -1,11 +1,12 @@
-import { Body, Controller, Get, HttpStatus, Post, Res } from '@nestjs/common';
-import { ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
+import { BadRequestException, Body, Controller, Get, HttpStatus, Param, Post, Query, Res } from '@nestjs/common';
+import { ApiOperation, ApiParam, ApiResponse, ApiTags } from '@nestjs/swagger';
 import { Response } from 'express';
 import { AbstractController } from '~/_common/abstracts/abstract.controller';
 import { PartialProjectionType } from '~/_common/types/partial-projection.type';
 import { IdentitiesDto } from './_dto/identities.dto';
 import { FusionDto } from '~/management/identities/_dto/fusion.dto';
 import { IdentitiesDoublonService } from '~/management/identities/identities-doublon.service';
+import { Types } from 'mongoose';
 
 @ApiTags('management/identities')
 @Controller('identities')
@@ -24,16 +25,68 @@ export class IdentitiesDoublonController extends AbstractController {
 
   @Get('duplicates')
   @ApiOperation({ summary: 'Renvoie la liste des doublons supposés' })
-  public async getDoublons(@Res() res: Response): Promise<Response> {
-    const data = await this._service.searchDoubles();
+  public async getDoublons(@Res() res: Response, @Query('includeIgnored') includeIgnored?: string): Promise<Response> {
+    const includeIgnoredBool = /^(true|1|yes|on)$/i.test(includeIgnored || '');
+    const data = await this._service.searchDoubles(includeIgnoredBool);
     const total = data.length;
+
     return res.status(HttpStatus.OK).json({
       statusCode: HttpStatus.OK,
       data,
       total,
     });
   }
 
+  @Post('ignore-fusion')
+  @ApiOperation({ summary: 'Ignore la fusion pour une identité' })
+  @ApiParam({ name: 'id', description: 'ID de l\'identité', type: String })
+  @ApiResponse({ status: HttpStatus.OK, description: 'Fusion ignorée avec succès' })
+  @ApiResponse({ status: HttpStatus.BAD_REQUEST, description: 'Identité non trouvée' })
+  public async ignoreFusionForIdentities(
+    @Res() res: Response,
+    @Body('ids') ids: string[],
+  ): Promise<Response> {
+    if (ids.length !== 2) {
+      throw new BadRequestException('Deux IDs doivent être fournis pour ignorer la fusion.');
+    }
+
+    if (!ids.every(id => Types.ObjectId.isValid(id))) {
+      throw new BadRequestException('Tous les IDs doivent être des ObjectId valides.');
+    }
+
+    const data = await this._service.ignoreFusionForIdentities(ids.map(id => new Types.ObjectId(id)));
+
+    return res.status(HttpStatus.OK).json({
+      statusCode: HttpStatus.OK,
+      data,
+    });
+  }
+
+  @Post('unignore-fusion')
+  @ApiOperation({ summary: 'Annule l\'ignorance de la fusion pour une identité' })
+  @ApiParam({ name: 'id', description: 'ID de l\'identité', type: String })
+  @ApiResponse({ status: HttpStatus.OK, description: 'Ignorance de fusion annulée avec succès' })
+  @ApiResponse({ status: HttpStatus.BAD_REQUEST, description: 'Identité non trouvée' })
+  public async unignoreFusionForIdentities(
+    @Res() res: Response,
+    @Body('ids') ids: string[],
+  ): Promise<Response> {
+    if (ids.length !== 2) {
+      throw new BadRequestException('Deux IDs doivent être fournis pour annuler l\'ignorance de la fusion.');
+    }
+
+    if (!ids.every(id => Types.ObjectId.isValid(id))) {
+      throw new BadRequestException('Tous les IDs doivent être des ObjectId valides.');
+    }
+
+    const data = await this._service.unignoreFusionForIdentities(ids.map(id => new Types.ObjectId(id)));
+
+    return res.status(HttpStatus.OK).json({
+      statusCode: HttpStatus.OK,
+      data,
+    });
+  }
+
   @Post('fusion')
   @ApiOperation({ summary: 'fusionne les deux identités' })
   @ApiResponse({ status: HttpStatus.OK })