release: squash merge develop → master
Quotidien / Epic C : feed bulles parent (#173), module Cartes (#194/#195), evenements_agenda (#205), couples garde AM (#169–#171), API absences (#172). Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
Cursor
@@ -16,7 +16,8 @@ import { AllExceptionsFilter } from './common/filters/all_exceptions.filters';
|
||||
import { EnfantsModule } from './routes/enfants/enfants.module';
|
||||
import { AppConfigModule } from './modules/config/config.module';
|
||||
import { DocumentsLegauxModule } from './modules/documents-legaux';
|
||||
import { AbsencesGardeModule } from './modules/absences-garde';
|
||||
import { EvenementsAgendaModule } from './modules/evenements-agenda';
|
||||
import { CardsModule } from './modules/cards';
|
||||
import { RelaisModule } from './routes/relais/relais.module';
|
||||
import { DossiersModule } from './routes/dossiers/dossiers.module';
|
||||
import { SuppressionsModule } from './routes/suppressions/suppressions.module';
|
||||
@@ -57,7 +58,8 @@ import { SuppressionsModule } from './routes/suppressions/suppressions.module';
|
||||
AuthModule,
|
||||
AppConfigModule,
|
||||
DocumentsLegauxModule,
|
||||
AbsencesGardeModule,
|
||||
EvenementsAgendaModule,
|
||||
CardsModule,
|
||||
RelaisModule,
|
||||
DossiersModule,
|
||||
SuppressionsModule,
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
import { Entity, PrimaryColumn, Column, OneToOne, OneToMany, JoinColumn } from 'typeorm';
|
||||
import { Entity, PrimaryColumn, Column, OneToOne, OneToMany, JoinColumn, ManyToOne } from 'typeorm';
|
||||
import { Users } from './users.entity';
|
||||
import { AmChildren } from './am_children.entity';
|
||||
|
||||
@@ -37,22 +37,32 @@ export class AssistanteMaternelle {
|
||||
@Column({ name: 'ville_residence', length: 100, nullable: true })
|
||||
residence_city?: string;
|
||||
|
||||
@Column( { name: 'date_agrement', type: 'date', nullable: true })
|
||||
@Column({ name: 'date_agrement', type: 'date', nullable: true })
|
||||
agreement_date?: Date;
|
||||
|
||||
@Column( { name: 'annee_experience', type: 'smallint', nullable: true })
|
||||
@Column({ name: 'annee_experience', type: 'smallint', nullable: true })
|
||||
years_experience?: number;
|
||||
|
||||
@Column( { name: 'specialite', length: 100, nullable: true })
|
||||
|
||||
@Column({ name: 'specialite', length: 100, nullable: true })
|
||||
specialty?: string;
|
||||
|
||||
@Column( { name: 'place_disponible', type: 'integer', nullable: true })
|
||||
@Column({ name: 'place_disponible', type: 'integer', nullable: true })
|
||||
places_available?: number;
|
||||
|
||||
/** Numéro de dossier (format AAAA-NNNNNN), même valeur que sur utilisateurs (ticket #103) */
|
||||
@Column({ name: 'numero_dossier', length: 20, nullable: true })
|
||||
numero_dossier?: string;
|
||||
|
||||
/**
|
||||
* Placement AM↔enfant sélectionné sur le TdB AM (couple actif) — ticket #171.
|
||||
*/
|
||||
@Column({ name: 'id_placement_garde_courant', type: 'uuid', nullable: true })
|
||||
id_placement_garde_courant?: string;
|
||||
|
||||
@ManyToOne(() => AmChildren, { nullable: true, onDelete: 'SET NULL' })
|
||||
@JoinColumn({ name: 'id_placement_garde_courant', referencedColumnName: 'id' })
|
||||
placement_garde_courant?: AmChildren;
|
||||
|
||||
@OneToMany(() => AmChildren, (ac) => ac.am)
|
||||
amChildren: AmChildren[];
|
||||
}
|
||||
|
||||
@@ -0,0 +1,35 @@
|
||||
import {
|
||||
Column,
|
||||
Entity,
|
||||
JoinColumn,
|
||||
ManyToOne,
|
||||
PrimaryGeneratedColumn,
|
||||
} from 'typeorm';
|
||||
import { CardInstance } from './card_instances.entity';
|
||||
import { Users } from './users.entity';
|
||||
|
||||
@Entity('card_audience_members', { schema: 'public' })
|
||||
export class CardAudienceMember {
|
||||
@PrimaryGeneratedColumn('uuid')
|
||||
id: string;
|
||||
|
||||
@Column({ name: 'id_card', type: 'uuid' })
|
||||
id_card: string;
|
||||
|
||||
@ManyToOne(() => CardInstance, (c) => c.audience, { onDelete: 'CASCADE' })
|
||||
@JoinColumn({ name: 'id_card', referencedColumnName: 'id' })
|
||||
card: CardInstance;
|
||||
|
||||
@Column({ name: 'id_utilisateur', type: 'uuid' })
|
||||
id_utilisateur: string;
|
||||
|
||||
@ManyToOne(() => Users, { onDelete: 'CASCADE' })
|
||||
@JoinColumn({ name: 'id_utilisateur', referencedColumnName: 'id' })
|
||||
user: Users;
|
||||
|
||||
@Column({ name: 'role_snapshot', type: 'varchar', length: 64 })
|
||||
role_snapshot: string;
|
||||
|
||||
@Column({ name: 'is_creator', type: 'boolean', default: false })
|
||||
is_creator: boolean;
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
import {
|
||||
Column,
|
||||
CreateDateColumn,
|
||||
Entity,
|
||||
JoinColumn,
|
||||
ManyToOne,
|
||||
OneToMany,
|
||||
PrimaryGeneratedColumn,
|
||||
UpdateDateColumn,
|
||||
} from 'typeorm';
|
||||
import { AmChildren } from './am_children.entity';
|
||||
import { EvenementsAgenda } from './evenements_agenda.entity';
|
||||
import { Users } from './users.entity';
|
||||
import { CardType } from './card_types.entity';
|
||||
import { CardAudienceMember } from './card_audience_members.entity';
|
||||
import { CardResponse } from './card_responses.entity';
|
||||
|
||||
export enum CardInstanceStatutType {
|
||||
OUVERTE = 'ouverte',
|
||||
REFUSEE = 'refusee',
|
||||
TRAITEE = 'traitee',
|
||||
}
|
||||
|
||||
export enum CardOperationType {
|
||||
CREATE = 'create',
|
||||
UPDATE = 'update',
|
||||
}
|
||||
|
||||
@Entity('card_instances', { schema: 'public' })
|
||||
export class CardInstance {
|
||||
@PrimaryGeneratedColumn('uuid')
|
||||
id: string;
|
||||
|
||||
@Column({ name: 'type_code', type: 'varchar', length: 64 })
|
||||
type_code: string;
|
||||
|
||||
@ManyToOne(() => CardType, { onDelete: 'RESTRICT' })
|
||||
@JoinColumn({ name: 'type_code', referencedColumnName: 'code' })
|
||||
type: CardType;
|
||||
|
||||
@Column({ name: 'id_placement', type: 'uuid' })
|
||||
id_placement: string;
|
||||
|
||||
@ManyToOne(() => AmChildren, { onDelete: 'CASCADE' })
|
||||
@JoinColumn({ name: 'id_placement', referencedColumnName: 'id' })
|
||||
placement: AmChildren;
|
||||
|
||||
@Column({ name: 'id_evenement', type: 'uuid', nullable: true })
|
||||
id_evenement?: string;
|
||||
|
||||
@ManyToOne(() => EvenementsAgenda, { nullable: true, onDelete: 'SET NULL' })
|
||||
@JoinColumn({ name: 'id_evenement', referencedColumnName: 'id' })
|
||||
evenement?: EvenementsAgenda;
|
||||
|
||||
@Column({ name: 'cree_par', type: 'uuid', nullable: true })
|
||||
cree_par?: string;
|
||||
|
||||
@ManyToOne(() => Users, { nullable: true, onDelete: 'SET NULL' })
|
||||
@JoinColumn({ name: 'cree_par', referencedColumnName: 'id' })
|
||||
createdBy?: Users;
|
||||
|
||||
@Column({
|
||||
type: 'enum',
|
||||
enum: CardOperationType,
|
||||
enumName: 'card_operation_type',
|
||||
name: 'operation',
|
||||
default: CardOperationType.CREATE,
|
||||
})
|
||||
operation: CardOperationType;
|
||||
|
||||
@Column({
|
||||
type: 'enum',
|
||||
enum: CardInstanceStatutType,
|
||||
enumName: 'card_instance_statut_type',
|
||||
name: 'statut',
|
||||
default: CardInstanceStatutType.OUVERTE,
|
||||
})
|
||||
statut: CardInstanceStatutType;
|
||||
|
||||
@Column({ name: 'payload', type: 'jsonb', default: {} })
|
||||
payload: Record<string, unknown>;
|
||||
|
||||
@Column({ name: 'purge_at', type: 'timestamptz' })
|
||||
purge_at: Date;
|
||||
|
||||
@OneToMany(() => CardAudienceMember, (m) => m.card)
|
||||
audience: CardAudienceMember[];
|
||||
|
||||
@OneToMany(() => CardResponse, (r) => r.card)
|
||||
responses: CardResponse[];
|
||||
|
||||
@CreateDateColumn({ name: 'cree_le', type: 'timestamptz' })
|
||||
cree_le: Date;
|
||||
|
||||
@UpdateDateColumn({ name: 'modifie_le', type: 'timestamptz' })
|
||||
modifie_le: Date;
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
import {
|
||||
Column,
|
||||
CreateDateColumn,
|
||||
Entity,
|
||||
JoinColumn,
|
||||
ManyToOne,
|
||||
PrimaryGeneratedColumn,
|
||||
RelationId,
|
||||
} from 'typeorm';
|
||||
import { CardInstance } from './card_instances.entity';
|
||||
import { Users } from './users.entity';
|
||||
|
||||
export enum CardResponseActionType {
|
||||
ACCEPT = 'accept',
|
||||
REFUSE = 'refuse',
|
||||
ACK = 'ack',
|
||||
}
|
||||
|
||||
@Entity('card_responses', { schema: 'public' })
|
||||
export class CardResponse {
|
||||
@PrimaryGeneratedColumn('uuid')
|
||||
id: string;
|
||||
|
||||
/** FK carte — une seule source de vérité via @JoinColumn (pas de @Column doublon). */
|
||||
@ManyToOne(() => CardInstance, (c) => c.responses, { onDelete: 'CASCADE' })
|
||||
@JoinColumn({ name: 'id_card', referencedColumnName: 'id' })
|
||||
card: CardInstance;
|
||||
|
||||
@RelationId((r: CardResponse) => r.card)
|
||||
id_card: string;
|
||||
|
||||
@ManyToOne(() => Users, { onDelete: 'CASCADE' })
|
||||
@JoinColumn({ name: 'id_utilisateur', referencedColumnName: 'id' })
|
||||
user: Users;
|
||||
|
||||
@RelationId((r: CardResponse) => r.user)
|
||||
id_utilisateur: string;
|
||||
|
||||
@Column({
|
||||
type: 'enum',
|
||||
enum: CardResponseActionType,
|
||||
enumName: 'card_response_action_type',
|
||||
name: 'action',
|
||||
})
|
||||
action: CardResponseActionType;
|
||||
|
||||
@Column({ name: 'comment', type: 'text', nullable: true })
|
||||
comment?: string;
|
||||
|
||||
@CreateDateColumn({ name: 'cree_le', type: 'timestamptz' })
|
||||
cree_le: Date;
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
import {
|
||||
Column,
|
||||
CreateDateColumn,
|
||||
Entity,
|
||||
PrimaryColumn,
|
||||
UpdateDateColumn,
|
||||
} from 'typeorm';
|
||||
|
||||
export enum CardResponseModeType {
|
||||
NONE = 'none',
|
||||
ACK = 'ack',
|
||||
ACCEPT_REFUSE = 'accept_refuse',
|
||||
}
|
||||
|
||||
@Entity('card_types', { schema: 'public' })
|
||||
export class CardType {
|
||||
@PrimaryColumn({ name: 'code', type: 'varchar', length: 64 })
|
||||
code: string;
|
||||
|
||||
@Column({ name: 'system', type: 'boolean', default: true })
|
||||
system: boolean;
|
||||
|
||||
@Column({ name: 'titre', type: 'varchar', length: 120 })
|
||||
titre: string;
|
||||
|
||||
@Column({ name: 'emitter_roles', type: 'text', array: true })
|
||||
emitter_roles: string[];
|
||||
|
||||
@Column({ name: 'recipient_roles', type: 'text', array: true })
|
||||
recipient_roles: string[];
|
||||
|
||||
@Column({ name: 'audience_resolver', type: 'varchar', length: 64 })
|
||||
audience_resolver: string;
|
||||
|
||||
@Column({
|
||||
type: 'enum',
|
||||
enum: CardResponseModeType,
|
||||
enumName: 'card_response_mode_type',
|
||||
name: 'response_mode',
|
||||
})
|
||||
response_mode: CardResponseModeType;
|
||||
|
||||
@Column({ name: 'retention_days', type: 'int', default: 14 })
|
||||
retention_days: number;
|
||||
|
||||
@Column({ name: 'couleur', type: 'varchar', length: 32, nullable: true })
|
||||
couleur?: string;
|
||||
|
||||
@CreateDateColumn({ name: 'cree_le', type: 'timestamptz' })
|
||||
cree_le: Date;
|
||||
|
||||
@UpdateDateColumn({ name: 'modifie_le', type: 'timestamptz' })
|
||||
modifie_le: Date;
|
||||
}
|
||||
+14
-14
@@ -10,25 +10,25 @@ import {
|
||||
import { AmChildren } from './am_children.entity';
|
||||
import { Users } from './users.entity';
|
||||
|
||||
export enum TypeAbsenceGardeType {
|
||||
export enum TypeEvenementAgendaType {
|
||||
ABSENCE_ENFANT = 'absence_enfant',
|
||||
CONGE_AM = 'conge_am',
|
||||
ARRET_MALADIE_AM = 'arret_maladie_am',
|
||||
}
|
||||
|
||||
export enum StatutAbsenceGardeType {
|
||||
export enum StatutEvenementAgendaType {
|
||||
EN_ATTENTE = 'en_attente',
|
||||
ACCEPTE = 'accepte',
|
||||
REFUSE = 'refuse',
|
||||
}
|
||||
|
||||
/**
|
||||
* Vérité métier des absences / congés / arrêts par couple AM↔enfant.
|
||||
* Les cartes (module ultérieur) collectent ; cette table stocke.
|
||||
* Ticket #193.
|
||||
* Vérité métier agenda par couple AM↔enfant (placement).
|
||||
* Types V1 : absences / congés / arrêts ; extensible (soins, école, mairie…).
|
||||
* Les cartes collectent ; cette table historise. Ticket #205.
|
||||
*/
|
||||
@Entity('absences_garde', { schema: 'public' })
|
||||
export class AbsencesGarde {
|
||||
@Entity('evenements_agenda', { schema: 'public' })
|
||||
export class EvenementsAgenda {
|
||||
@PrimaryGeneratedColumn('uuid')
|
||||
id: string;
|
||||
|
||||
@@ -41,11 +41,11 @@ export class AbsencesGarde {
|
||||
|
||||
@Column({
|
||||
type: 'enum',
|
||||
enum: TypeAbsenceGardeType,
|
||||
enumName: 'type_absence_garde_type',
|
||||
enum: TypeEvenementAgendaType,
|
||||
enumName: 'type_evenement_agenda_type',
|
||||
name: 'type',
|
||||
})
|
||||
type: TypeAbsenceGardeType;
|
||||
type: TypeEvenementAgendaType;
|
||||
|
||||
@Column({ name: 'date_debut', type: 'date' })
|
||||
date_debut: string;
|
||||
@@ -55,12 +55,12 @@ export class AbsencesGarde {
|
||||
|
||||
@Column({
|
||||
type: 'enum',
|
||||
enum: StatutAbsenceGardeType,
|
||||
enumName: 'statut_absence_garde_type',
|
||||
enum: StatutEvenementAgendaType,
|
||||
enumName: 'statut_evenement_agenda_type',
|
||||
name: 'statut',
|
||||
default: StatutAbsenceGardeType.EN_ATTENTE,
|
||||
default: StatutEvenementAgendaType.EN_ATTENTE,
|
||||
})
|
||||
statut: StatutAbsenceGardeType;
|
||||
statut: StatutEvenementAgendaType;
|
||||
|
||||
/** Purge auto pour en_attente/refuse ; accepte → infinity. */
|
||||
@Column({ name: 'expire_at', type: 'timestamptz' })
|
||||
@@ -0,0 +1,94 @@
|
||||
import {
|
||||
Controller,
|
||||
Get,
|
||||
Headers,
|
||||
MessageEvent,
|
||||
Query,
|
||||
Sse,
|
||||
UnauthorizedException,
|
||||
UseGuards,
|
||||
} from '@nestjs/common';
|
||||
import {
|
||||
ApiBearerAuth,
|
||||
ApiOperation,
|
||||
ApiQuery,
|
||||
ApiTags,
|
||||
} from '@nestjs/swagger';
|
||||
import { ConfigService } from '@nestjs/config';
|
||||
import { JwtService } from '@nestjs/jwt';
|
||||
import { Observable } from 'rxjs';
|
||||
import { AuthGuard } from 'src/common/guards/auth.guard';
|
||||
import { RolesGuard } from 'src/common/guards/roles.guard';
|
||||
import { Roles } from 'src/common/decorators/roles.decorator';
|
||||
import { Public } from 'src/common/decorators/public.decorator';
|
||||
import { User } from 'src/common/decorators/user.decorator';
|
||||
import { RoleType } from 'src/entities/users.entity';
|
||||
import { CardsRealtimeService } from './cards-realtime.service';
|
||||
|
||||
/**
|
||||
* SSE Cartes — #195
|
||||
* Auth : Bearer (recommandé) ou `?access_token=` (EventSource navigateur).
|
||||
*/
|
||||
@ApiTags('Cartes')
|
||||
@Controller('cards')
|
||||
export class CardsRealtimeController {
|
||||
constructor(
|
||||
private readonly realtime: CardsRealtimeService,
|
||||
private readonly jwtService: JwtService,
|
||||
private readonly configService: ConfigService,
|
||||
) {}
|
||||
|
||||
@Sse('stream')
|
||||
@Public()
|
||||
@ApiOperation({
|
||||
summary: 'Flux SSE bulles (card.created|updated|deleted, response.added) — #195',
|
||||
})
|
||||
@ApiQuery({
|
||||
name: 'access_token',
|
||||
required: false,
|
||||
description: 'JWT si pas de header Authorization (EventSource)',
|
||||
})
|
||||
@ApiBearerAuth('access-token')
|
||||
async stream(
|
||||
@Headers('authorization') authorization?: string,
|
||||
@Query('access_token') accessToken?: string,
|
||||
): Promise<Observable<MessageEvent>> {
|
||||
const userId = await this.resolveUserId(authorization, accessToken);
|
||||
return this.realtime.streamFor(userId);
|
||||
}
|
||||
|
||||
/** Variante gardée (clients qui envoient Bearer correctement). */
|
||||
@Get('stream/info')
|
||||
@UseGuards(AuthGuard, RolesGuard)
|
||||
@Roles(RoleType.PARENT, RoleType.ASSISTANTE_MATERNELLE)
|
||||
@ApiBearerAuth('access-token')
|
||||
@ApiOperation({ summary: 'Debug : abonnés SSE pour mon user — #195' })
|
||||
info(@User('id') userId: string) {
|
||||
return {
|
||||
user_id: userId,
|
||||
subscribers: this.realtime.subscriberCount(userId),
|
||||
};
|
||||
}
|
||||
|
||||
private async resolveUserId(
|
||||
authorization?: string,
|
||||
accessToken?: string,
|
||||
): Promise<string> {
|
||||
let token = accessToken?.trim();
|
||||
if (!token && authorization?.startsWith('Bearer ')) {
|
||||
token = authorization.slice(7).trim();
|
||||
}
|
||||
if (!token) {
|
||||
throw new UnauthorizedException('Token manquant (Bearer ou access_token)');
|
||||
}
|
||||
try {
|
||||
const payload = await this.jwtService.verifyAsync<{ sub: string }>(token, {
|
||||
secret: this.configService.get<string>('jwt.accessSecret'),
|
||||
});
|
||||
if (!payload?.sub) throw new UnauthorizedException('Token invalide');
|
||||
return payload.sub;
|
||||
} catch {
|
||||
throw new UnauthorizedException('Token invalide ou expiré');
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
import { MessageEvent } from '@nestjs/common';
|
||||
import { CardsRealtimeService } from './cards-realtime.service';
|
||||
|
||||
describe('CardsRealtimeService (#195)', () => {
|
||||
let service: CardsRealtimeService;
|
||||
|
||||
beforeEach(() => {
|
||||
service = new CardsRealtimeService();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
service.onModuleDestroy();
|
||||
});
|
||||
|
||||
it('émet card.created aux abonnés du user', async () => {
|
||||
const events: MessageEvent[] = [];
|
||||
const sub = service.streamFor('user-a').subscribe((e) => events.push(e));
|
||||
|
||||
await new Promise((r) => setTimeout(r, 20));
|
||||
expect(events[0]?.type).toBe('heartbeat');
|
||||
expect(service.subscriberCount('user-a')).toBe(1);
|
||||
|
||||
service.emitToUsers(['user-a', 'user-b'], 'card.created', 'card-1', {
|
||||
id: 'card-1',
|
||||
});
|
||||
await new Promise((r) => setTimeout(r, 20));
|
||||
|
||||
const created = events.find((e) => e.type === 'card.created');
|
||||
expect(created).toBeDefined();
|
||||
expect((created!.data as { card_id: string }).card_id).toBe('card-1');
|
||||
expect(service.subscriberCount('user-b')).toBe(0);
|
||||
|
||||
sub.unsubscribe();
|
||||
expect(service.subscriberCount('user-a')).toBe(0);
|
||||
});
|
||||
|
||||
it('ne diffuse pas aux users non abonnés', async () => {
|
||||
const events: MessageEvent[] = [];
|
||||
const sub = service.streamFor('user-a').subscribe((e) => events.push(e));
|
||||
await new Promise((r) => setTimeout(r, 20));
|
||||
const before = events.length;
|
||||
service.emitToUsers(['user-b'], 'card.updated', 'x');
|
||||
await new Promise((r) => setTimeout(r, 20));
|
||||
expect(events.length).toBe(before);
|
||||
sub.unsubscribe();
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,111 @@
|
||||
import { Injectable, MessageEvent, OnModuleDestroy } from '@nestjs/common';
|
||||
import { Observable, Subject, interval, merge, takeUntil } from 'rxjs';
|
||||
import { map } from 'rxjs/operators';
|
||||
|
||||
export type CardRealtimeEventType =
|
||||
| 'card.created'
|
||||
| 'card.updated'
|
||||
| 'card.deleted'
|
||||
| 'response.added'
|
||||
| 'heartbeat';
|
||||
|
||||
export interface CardRealtimePayload {
|
||||
event: CardRealtimeEventType;
|
||||
card_id?: string;
|
||||
data?: unknown;
|
||||
at: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Bus SSE in-memory par utilisateur (V1 mono-instance).
|
||||
* Rooms = userId (audience carte).
|
||||
*/
|
||||
@Injectable()
|
||||
export class CardsRealtimeService implements OnModuleDestroy {
|
||||
private readonly byUser = new Map<string, Set<Subject<CardRealtimePayload>>>();
|
||||
private readonly destroy$ = new Subject<void>();
|
||||
|
||||
onModuleDestroy(): void {
|
||||
this.destroy$.next();
|
||||
this.destroy$.complete();
|
||||
for (const set of this.byUser.values()) {
|
||||
for (const s of set) s.complete();
|
||||
}
|
||||
this.byUser.clear();
|
||||
}
|
||||
|
||||
/** Flux SSE pour un utilisateur authentifié. */
|
||||
streamFor(userId: string): Observable<MessageEvent> {
|
||||
const subject = new Subject<CardRealtimePayload>();
|
||||
let set = this.byUser.get(userId);
|
||||
if (!set) {
|
||||
set = new Set();
|
||||
this.byUser.set(userId, set);
|
||||
}
|
||||
set.add(subject);
|
||||
|
||||
const heartbeat$ = interval(25_000).pipe(
|
||||
map(
|
||||
(): CardRealtimePayload => ({
|
||||
event: 'heartbeat',
|
||||
at: new Date().toISOString(),
|
||||
}),
|
||||
),
|
||||
);
|
||||
|
||||
return new Observable<MessageEvent>((observer) => {
|
||||
const sub = merge(subject, heartbeat$)
|
||||
.pipe(takeUntil(this.destroy$))
|
||||
.subscribe({
|
||||
next: (payload) =>
|
||||
observer.next({
|
||||
type: payload.event,
|
||||
data: payload,
|
||||
} as MessageEvent),
|
||||
error: (err) => observer.error(err),
|
||||
complete: () => observer.complete(),
|
||||
});
|
||||
|
||||
// ping initial
|
||||
subject.next({
|
||||
event: 'heartbeat',
|
||||
at: new Date().toISOString(),
|
||||
});
|
||||
|
||||
return () => {
|
||||
sub.unsubscribe();
|
||||
set!.delete(subject);
|
||||
subject.complete();
|
||||
if (set!.size === 0) this.byUser.delete(userId);
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
emitToUsers(
|
||||
userIds: string[],
|
||||
event: Exclude<CardRealtimeEventType, 'heartbeat'>,
|
||||
cardId: string | undefined,
|
||||
data?: unknown,
|
||||
): void {
|
||||
const unique = [...new Set(userIds.filter(Boolean))];
|
||||
const payload: CardRealtimePayload = {
|
||||
event,
|
||||
card_id: cardId,
|
||||
data,
|
||||
at: new Date().toISOString(),
|
||||
};
|
||||
for (const uid of unique) {
|
||||
const set = this.byUser.get(uid);
|
||||
if (!set) continue;
|
||||
for (const s of set) s.next(payload);
|
||||
}
|
||||
}
|
||||
|
||||
/** Test / debug : nombre d’abonnés actifs. */
|
||||
subscriberCount(userId?: string): number {
|
||||
if (userId) return this.byUser.get(userId)?.size ?? 0;
|
||||
let n = 0;
|
||||
for (const s of this.byUser.values()) n += s.size;
|
||||
return n;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,119 @@
|
||||
import {
|
||||
Body,
|
||||
Controller,
|
||||
Delete,
|
||||
Get,
|
||||
HttpCode,
|
||||
HttpStatus,
|
||||
Param,
|
||||
ParseUUIDPipe,
|
||||
Patch,
|
||||
Post,
|
||||
Query,
|
||||
UseGuards,
|
||||
} from '@nestjs/common';
|
||||
import {
|
||||
ApiBearerAuth,
|
||||
ApiBody,
|
||||
ApiOperation,
|
||||
ApiQuery,
|
||||
ApiResponse,
|
||||
ApiTags,
|
||||
} from '@nestjs/swagger';
|
||||
import { AuthGuard } from 'src/common/guards/auth.guard';
|
||||
import { RolesGuard } from 'src/common/guards/roles.guard';
|
||||
import { Roles } from 'src/common/decorators/roles.decorator';
|
||||
import { User } from 'src/common/decorators/user.decorator';
|
||||
import { RoleType } from 'src/entities/users.entity';
|
||||
import { CardsService } from './cards.service';
|
||||
import {
|
||||
CarteDto,
|
||||
CreerCarteDto,
|
||||
ListeCartesDto,
|
||||
MajCarteDto,
|
||||
RepondreCarteDto,
|
||||
} from './dto/cards.dto';
|
||||
|
||||
@ApiTags('Cartes')
|
||||
@ApiBearerAuth('access-token')
|
||||
@Controller('cards')
|
||||
@UseGuards(AuthGuard, RolesGuard)
|
||||
export class CardsController {
|
||||
constructor(private readonly cardsService: CardsService) {}
|
||||
|
||||
@Get('types')
|
||||
@Roles(RoleType.PARENT, RoleType.ASSISTANTE_MATERNELLE)
|
||||
@ApiOperation({ summary: 'Types SYSTEM émissibles pour mon rôle — #194' })
|
||||
listerTypes(@User('role') role: RoleType) {
|
||||
return this.cardsService.listerTypes(role);
|
||||
}
|
||||
|
||||
@Get()
|
||||
@Roles(RoleType.PARENT, RoleType.ASSISTANTE_MATERNELLE)
|
||||
@ApiOperation({ summary: 'Feed bulles de l’utilisateur — #194' })
|
||||
@ApiQuery({ name: 'placementId', required: false })
|
||||
@ApiResponse({ status: 200, type: ListeCartesDto })
|
||||
lister(
|
||||
@User('id') userId: string,
|
||||
@User('role') role: RoleType,
|
||||
@Query('placementId') placementId?: string,
|
||||
): Promise<ListeCartesDto> {
|
||||
return this.cardsService.lister(userId, role, placementId);
|
||||
}
|
||||
|
||||
@Post()
|
||||
@Roles(RoleType.PARENT, RoleType.ASSISTANTE_MATERNELLE)
|
||||
@HttpCode(HttpStatus.CREATED)
|
||||
@ApiOperation({
|
||||
summary: 'Créer une bulle (+ hook evenements_agenda) — #194',
|
||||
})
|
||||
@ApiBody({ type: CreerCarteDto })
|
||||
@ApiResponse({ status: 201, type: CarteDto })
|
||||
creer(
|
||||
@User('id') userId: string,
|
||||
@User('role') role: RoleType,
|
||||
@Body() dto: CreerCarteDto,
|
||||
): Promise<CarteDto> {
|
||||
return this.cardsService.creer(userId, role, dto);
|
||||
}
|
||||
|
||||
@Post(':id/respond')
|
||||
@Roles(RoleType.PARENT, RoleType.ASSISTANTE_MATERNELLE)
|
||||
@ApiOperation({ summary: 'Répondre (accept / refuse / ack) — #194' })
|
||||
@ApiBody({ type: RepondreCarteDto })
|
||||
repondre(
|
||||
@User('id') userId: string,
|
||||
@User('role') role: RoleType,
|
||||
@Param('id', ParseUUIDPipe) id: string,
|
||||
@Body() dto: RepondreCarteDto,
|
||||
): Promise<CarteDto> {
|
||||
return this.cardsService.repondre(userId, role, id, dto);
|
||||
}
|
||||
|
||||
@Patch(':id')
|
||||
@Roles(RoleType.PARENT, RoleType.ASSISTANTE_MATERNELLE)
|
||||
@ApiOperation({
|
||||
summary: 'Modifier dates (créateur, ouverte/refusée) — #194',
|
||||
})
|
||||
@ApiBody({ type: MajCarteDto })
|
||||
maj(
|
||||
@User('id') userId: string,
|
||||
@User('role') role: RoleType,
|
||||
@Param('id', ParseUUIDPipe) id: string,
|
||||
@Body() dto: MajCarteDto,
|
||||
): Promise<CarteDto> {
|
||||
return this.cardsService.majEnAttente(userId, role, id, dto);
|
||||
}
|
||||
|
||||
@Delete(':id')
|
||||
@Roles(RoleType.PARENT, RoleType.ASSISTANTE_MATERNELLE)
|
||||
@HttpCode(HttpStatus.NO_CONTENT)
|
||||
@ApiOperation({ summary: 'Supprimer bulle (+ absence si non traitée) — #194' })
|
||||
async supprimer(
|
||||
@User('id') userId: string,
|
||||
@User('role') role: RoleType,
|
||||
@Param('id', ParseUUIDPipe) id: string,
|
||||
): Promise<void> {
|
||||
await this.cardsService.supprimer(userId, role, id);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { ConfigModule, ConfigService } from '@nestjs/config';
|
||||
import { JwtModule } from '@nestjs/jwt';
|
||||
import { TypeOrmModule } from '@nestjs/typeorm';
|
||||
import { EvenementsAgendaModule } from '../evenements-agenda';
|
||||
import { CardType } from 'src/entities/card_types.entity';
|
||||
import { CardInstance } from 'src/entities/card_instances.entity';
|
||||
import { CardAudienceMember } from 'src/entities/card_audience_members.entity';
|
||||
import { CardResponse } from 'src/entities/card_responses.entity';
|
||||
import { AmChildren } from 'src/entities/am_children.entity';
|
||||
import { ParentsChildren } from 'src/entities/parents_children.entity';
|
||||
import { CardsController } from './cards.controller';
|
||||
import { CardsRealtimeController } from './cards-realtime.controller';
|
||||
import { CardsService } from './cards.service';
|
||||
import { CardsRealtimeService } from './cards-realtime.service';
|
||||
|
||||
@Module({
|
||||
imports: [
|
||||
EvenementsAgendaModule,
|
||||
TypeOrmModule.forFeature([
|
||||
CardType,
|
||||
CardInstance,
|
||||
CardAudienceMember,
|
||||
CardResponse,
|
||||
AmChildren,
|
||||
ParentsChildren,
|
||||
]),
|
||||
JwtModule.registerAsync({
|
||||
imports: [ConfigModule],
|
||||
useFactory: (config: ConfigService) => ({
|
||||
secret: config.get('jwt.accessSecret'),
|
||||
signOptions: { expiresIn: config.get('jwt.accessExpiresIn') },
|
||||
}),
|
||||
inject: [ConfigService],
|
||||
}),
|
||||
],
|
||||
controllers: [CardsController, CardsRealtimeController],
|
||||
providers: [CardsService, CardsRealtimeService],
|
||||
exports: [CardsService, CardsRealtimeService],
|
||||
})
|
||||
export class CardsModule {}
|
||||
@@ -0,0 +1,284 @@
|
||||
import { Test, TestingModule } from '@nestjs/testing';
|
||||
import { getRepositoryToken } from '@nestjs/typeorm';
|
||||
import { ForbiddenException } from '@nestjs/common';
|
||||
import { CardsService } from './cards.service';
|
||||
import { CardsRealtimeService } from './cards-realtime.service';
|
||||
import { EvenementsAgendaService } from '../evenements-agenda/evenements-agenda.service';
|
||||
import { CardType, CardResponseModeType } from 'src/entities/card_types.entity';
|
||||
import {
|
||||
CardInstance,
|
||||
CardInstanceStatutType,
|
||||
CardOperationType,
|
||||
} from 'src/entities/card_instances.entity';
|
||||
import { CardAudienceMember } from 'src/entities/card_audience_members.entity';
|
||||
import { CardResponse } from 'src/entities/card_responses.entity';
|
||||
import { AmChildren } from 'src/entities/am_children.entity';
|
||||
import { ParentsChildren } from 'src/entities/parents_children.entity';
|
||||
import { RoleType } from 'src/entities/users.entity';
|
||||
import { StatutEvenementAgendaType, TypeEvenementAgendaType } from 'src/entities/evenements_agenda.entity';
|
||||
|
||||
describe('CardsService (#194)', () => {
|
||||
let service: CardsService;
|
||||
|
||||
const typesRepo = { find: jest.fn(), findOne: jest.fn() };
|
||||
const cardsRepo = {
|
||||
create: jest.fn((x) => x),
|
||||
save: jest.fn(async (x) => ({ ...x, id: x.id ?? 'card-1', cree_le: new Date(), modifie_le: new Date() })),
|
||||
update: jest.fn(async () => ({ affected: 1 })),
|
||||
findOne: jest.fn(),
|
||||
delete: jest.fn(),
|
||||
createQueryBuilder: jest.fn(),
|
||||
manager: { query: jest.fn() },
|
||||
};
|
||||
const audienceRepo = {
|
||||
create: jest.fn((x) => x),
|
||||
save: jest.fn(),
|
||||
findOne: jest.fn(),
|
||||
find: jest.fn(),
|
||||
};
|
||||
const responsesRepo = {
|
||||
create: jest.fn((x) => x),
|
||||
save: jest.fn(async (x) => x),
|
||||
insert: jest.fn(),
|
||||
};
|
||||
const amChildrenRepo = { findOne: jest.fn() };
|
||||
const parentsChildrenRepo = { find: jest.fn(), findOne: jest.fn() };
|
||||
const evenementsService = {
|
||||
creer: jest.fn(),
|
||||
maj: jest.fn(),
|
||||
supprimer: jest.fn(),
|
||||
};
|
||||
const realtime = { emitToUsers: jest.fn() };
|
||||
|
||||
beforeEach(async () => {
|
||||
const module: TestingModule = await Test.createTestingModule({
|
||||
providers: [
|
||||
CardsService,
|
||||
{ provide: getRepositoryToken(CardType), useValue: typesRepo },
|
||||
{ provide: getRepositoryToken(CardInstance), useValue: cardsRepo },
|
||||
{ provide: getRepositoryToken(CardAudienceMember), useValue: audienceRepo },
|
||||
{ provide: getRepositoryToken(CardResponse), useValue: responsesRepo },
|
||||
{ provide: getRepositoryToken(AmChildren), useValue: amChildrenRepo },
|
||||
{ provide: getRepositoryToken(ParentsChildren), useValue: parentsChildrenRepo },
|
||||
{ provide: EvenementsAgendaService, useValue: evenementsService },
|
||||
{ provide: CardsRealtimeService, useValue: realtime },
|
||||
],
|
||||
}).compile();
|
||||
service = module.get(CardsService);
|
||||
jest.clearAllMocks();
|
||||
});
|
||||
|
||||
it('should be defined', () => {
|
||||
expect(service).toBeDefined();
|
||||
});
|
||||
|
||||
it('AM crée congé → absence + carte ouverte + audience parents', async () => {
|
||||
typesRepo.findOne.mockResolvedValue({
|
||||
code: 'conge_am',
|
||||
system: true,
|
||||
titre: 'Congé AM',
|
||||
emitter_roles: [RoleType.ASSISTANTE_MATERNELLE],
|
||||
recipient_roles: [RoleType.PARENT],
|
||||
audience_resolver: 'couple_parents',
|
||||
response_mode: CardResponseModeType.ACCEPT_REFUSE,
|
||||
retention_days: 14,
|
||||
});
|
||||
amChildrenRepo.findOne.mockResolvedValue({
|
||||
id: 'pl-1',
|
||||
amId: 'am-1',
|
||||
enfantId: 'e-1',
|
||||
date_fin: null,
|
||||
});
|
||||
evenementsService.creer.mockResolvedValue({
|
||||
id: 'abs-1',
|
||||
type: TypeEvenementAgendaType.CONGE_AM,
|
||||
statut: StatutEvenementAgendaType.EN_ATTENTE,
|
||||
});
|
||||
parentsChildrenRepo.find.mockResolvedValue([
|
||||
{ parentId: 'p-1', enfantId: 'e-1' },
|
||||
{ parentId: 'p-2', enfantId: 'e-1' },
|
||||
]);
|
||||
cardsRepo.findOne.mockResolvedValue({
|
||||
id: 'card-1',
|
||||
type_code: 'conge_am',
|
||||
id_placement: 'pl-1',
|
||||
id_evenement: 'abs-1',
|
||||
cree_par: 'am-1',
|
||||
operation: CardOperationType.CREATE,
|
||||
statut: CardInstanceStatutType.OUVERTE,
|
||||
payload: { date_debut: '2026-11-01', date_fin: '2026-11-07' },
|
||||
purge_at: new Date(),
|
||||
cree_le: new Date(),
|
||||
modifie_le: new Date(),
|
||||
type: {
|
||||
titre: 'Congé AM',
|
||||
response_mode: CardResponseModeType.ACCEPT_REFUSE,
|
||||
retention_days: 14,
|
||||
},
|
||||
responses: [],
|
||||
audience: [
|
||||
{ id_utilisateur: 'am-1' },
|
||||
{ id_utilisateur: 'p-1' },
|
||||
{ id_utilisateur: 'p-2' },
|
||||
],
|
||||
});
|
||||
|
||||
const res = await service.creer('am-1', RoleType.ASSISTANTE_MATERNELLE, {
|
||||
type_code: 'conge_am',
|
||||
id_placement: 'pl-1',
|
||||
date_debut: '2026-11-01',
|
||||
date_fin: '2026-11-07',
|
||||
});
|
||||
|
||||
expect(evenementsService.creer).toHaveBeenCalled();
|
||||
expect(audienceRepo.save).toHaveBeenCalled();
|
||||
expect(realtime.emitToUsers).toHaveBeenCalledWith(
|
||||
['am-1', 'p-1', 'p-2'],
|
||||
'card.created',
|
||||
'card-1',
|
||||
expect.any(Object),
|
||||
);
|
||||
expect(res.type_code).toBe('conge_am');
|
||||
expect(res.statut).toBe(CardInstanceStatutType.OUVERTE);
|
||||
});
|
||||
|
||||
it('parent ne peut pas émettre conge_am', async () => {
|
||||
typesRepo.findOne.mockResolvedValue({
|
||||
code: 'conge_am',
|
||||
system: true,
|
||||
emitter_roles: [RoleType.ASSISTANTE_MATERNELLE],
|
||||
});
|
||||
await expect(
|
||||
service.creer('p-1', RoleType.PARENT, {
|
||||
type_code: 'conge_am',
|
||||
id_placement: 'pl-1',
|
||||
date_debut: '2026-11-01',
|
||||
date_fin: '2026-11-07',
|
||||
}),
|
||||
).rejects.toBeInstanceOf(ForbiddenException);
|
||||
});
|
||||
|
||||
it('parent crée absence_enfant → audience AM + co-parent', async () => {
|
||||
typesRepo.findOne.mockResolvedValue({
|
||||
code: 'absence_enfant',
|
||||
system: true,
|
||||
titre: 'Absence enfant',
|
||||
emitter_roles: [RoleType.PARENT],
|
||||
recipient_roles: [RoleType.ASSISTANTE_MATERNELLE],
|
||||
audience_resolver: 'couple_am',
|
||||
response_mode: CardResponseModeType.NONE,
|
||||
retention_days: 7,
|
||||
});
|
||||
amChildrenRepo.findOne.mockResolvedValue({
|
||||
id: 'pl-1',
|
||||
amId: 'am-1',
|
||||
enfantId: 'e-1',
|
||||
date_fin: null,
|
||||
});
|
||||
parentsChildrenRepo.findOne.mockResolvedValue({
|
||||
parentId: 'p-1',
|
||||
enfantId: 'e-1',
|
||||
});
|
||||
parentsChildrenRepo.find.mockResolvedValue([
|
||||
{ parentId: 'p-1', enfantId: 'e-1' },
|
||||
{ parentId: 'p-2', enfantId: 'e-1' },
|
||||
]);
|
||||
evenementsService.creer.mockResolvedValue({
|
||||
id: 'abs-1',
|
||||
type: TypeEvenementAgendaType.ABSENCE_ENFANT,
|
||||
statut: StatutEvenementAgendaType.ACCEPTE,
|
||||
});
|
||||
cardsRepo.findOne.mockResolvedValue({
|
||||
id: 'card-abs',
|
||||
type_code: 'absence_enfant',
|
||||
id_placement: 'pl-1',
|
||||
id_evenement: 'abs-1',
|
||||
cree_par: 'p-1',
|
||||
operation: CardOperationType.CREATE,
|
||||
statut: CardInstanceStatutType.OUVERTE,
|
||||
payload: { date_debut: '2026-10-28', date_fin: '2026-10-29' },
|
||||
purge_at: new Date(),
|
||||
cree_le: new Date(),
|
||||
modifie_le: new Date(),
|
||||
type: {
|
||||
titre: 'Absence enfant',
|
||||
response_mode: CardResponseModeType.NONE,
|
||||
retention_days: 7,
|
||||
},
|
||||
responses: [],
|
||||
audience: [
|
||||
{ id_utilisateur: 'p-1' },
|
||||
{ id_utilisateur: 'am-1' },
|
||||
{ id_utilisateur: 'p-2' },
|
||||
],
|
||||
});
|
||||
|
||||
await service.creer('p-1', RoleType.PARENT, {
|
||||
type_code: 'absence_enfant',
|
||||
id_placement: 'pl-1',
|
||||
date_debut: '2026-10-28',
|
||||
date_fin: '2026-10-29',
|
||||
});
|
||||
|
||||
const saved = audienceRepo.save.mock.calls[0][0] as Array<{
|
||||
id_utilisateur: string;
|
||||
is_creator: boolean;
|
||||
}>;
|
||||
const ids = saved.map((m) => m.id_utilisateur).sort();
|
||||
expect(ids).toEqual(['am-1', 'p-1', 'p-2']);
|
||||
expect(saved.find((m) => m.id_utilisateur === 'p-2')?.is_creator).toBe(false);
|
||||
});
|
||||
|
||||
it('parent accepte conge_am → response via relation + carte traitee', async () => {
|
||||
cardsRepo.findOne.mockResolvedValue({
|
||||
id: 'card-1',
|
||||
type_code: 'conge_am',
|
||||
id_placement: 'pl-1',
|
||||
id_evenement: 'ev-1',
|
||||
cree_par: 'am-1',
|
||||
operation: CardOperationType.CREATE,
|
||||
statut: CardInstanceStatutType.OUVERTE,
|
||||
payload: { date_debut: '2026-10-27', date_fin: '2026-10-31' },
|
||||
purge_at: new Date(),
|
||||
cree_le: new Date(),
|
||||
modifie_le: new Date(),
|
||||
type: {
|
||||
titre: 'Congé AM',
|
||||
response_mode: CardResponseModeType.ACCEPT_REFUSE,
|
||||
retention_days: 14,
|
||||
},
|
||||
responses: [],
|
||||
audience: [
|
||||
{ id_utilisateur: 'am-1' },
|
||||
{ id_utilisateur: 'p-1' },
|
||||
{ id_utilisateur: 'p-2' },
|
||||
],
|
||||
});
|
||||
audienceRepo.findOne.mockResolvedValue({ id_card: 'card-1', id_utilisateur: 'p-1' });
|
||||
evenementsService.maj.mockResolvedValue({});
|
||||
|
||||
const res = await service.repondre('p-1', RoleType.PARENT, 'card-1', {
|
||||
action: 'accept' as never,
|
||||
});
|
||||
|
||||
expect(responsesRepo.create).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
card: { id: 'card-1' },
|
||||
user: { id: 'p-1' },
|
||||
action: 'accept',
|
||||
}),
|
||||
);
|
||||
expect(responsesRepo.save).toHaveBeenCalled();
|
||||
expect(evenementsService.maj).toHaveBeenCalledWith(
|
||||
'p-1',
|
||||
RoleType.PARENT,
|
||||
'ev-1',
|
||||
expect.objectContaining({ statut: StatutEvenementAgendaType.ACCEPTE }),
|
||||
);
|
||||
expect(cardsRepo.update).toHaveBeenCalledWith(
|
||||
{ id: 'card-1' },
|
||||
expect.objectContaining({ statut: CardInstanceStatutType.TRAITEE }),
|
||||
);
|
||||
expect(res.statut).toBe(CardInstanceStatutType.TRAITEE);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,534 @@
|
||||
import {
|
||||
BadRequestException,
|
||||
ForbiddenException,
|
||||
Injectable,
|
||||
NotFoundException,
|
||||
} from '@nestjs/common';
|
||||
import { InjectRepository } from '@nestjs/typeorm';
|
||||
import { IsNull, Repository } from 'typeorm';
|
||||
import { EvenementsAgendaService } from '../evenements-agenda/evenements-agenda.service';
|
||||
import {
|
||||
StatutEvenementAgendaType,
|
||||
TypeEvenementAgendaType,
|
||||
} from 'src/entities/evenements_agenda.entity';
|
||||
import { AmChildren } from 'src/entities/am_children.entity';
|
||||
import { ParentsChildren } from 'src/entities/parents_children.entity';
|
||||
import { RoleType } from 'src/entities/users.entity';
|
||||
import { CardType, CardResponseModeType } from 'src/entities/card_types.entity';
|
||||
import {
|
||||
CardInstance,
|
||||
CardInstanceStatutType,
|
||||
CardOperationType,
|
||||
} from 'src/entities/card_instances.entity';
|
||||
import { CardAudienceMember } from 'src/entities/card_audience_members.entity';
|
||||
import {
|
||||
CardResponse,
|
||||
CardResponseActionType,
|
||||
} from 'src/entities/card_responses.entity';
|
||||
import {
|
||||
CarteDto,
|
||||
CreerCarteDto,
|
||||
ListeCartesDto,
|
||||
MajCarteDto,
|
||||
RepondreCarteDto,
|
||||
} from './dto/cards.dto';
|
||||
import { CardsRealtimeService } from './cards-realtime.service';
|
||||
|
||||
@Injectable()
|
||||
export class CardsService {
|
||||
constructor(
|
||||
@InjectRepository(CardType)
|
||||
private readonly typesRepo: Repository<CardType>,
|
||||
@InjectRepository(CardInstance)
|
||||
private readonly cardsRepo: Repository<CardInstance>,
|
||||
@InjectRepository(CardAudienceMember)
|
||||
private readonly audienceRepo: Repository<CardAudienceMember>,
|
||||
@InjectRepository(CardResponse)
|
||||
private readonly responsesRepo: Repository<CardResponse>,
|
||||
@InjectRepository(AmChildren)
|
||||
private readonly amChildrenRepo: Repository<AmChildren>,
|
||||
@InjectRepository(ParentsChildren)
|
||||
private readonly parentsChildrenRepo: Repository<ParentsChildren>,
|
||||
private readonly evenementsService: EvenementsAgendaService,
|
||||
private readonly realtime: CardsRealtimeService,
|
||||
) {}
|
||||
|
||||
async listerTypes(role: RoleType): Promise<
|
||||
Pick<
|
||||
CardType,
|
||||
| 'code'
|
||||
| 'system'
|
||||
| 'titre'
|
||||
| 'emitter_roles'
|
||||
| 'recipient_roles'
|
||||
| 'audience_resolver'
|
||||
| 'response_mode'
|
||||
| 'retention_days'
|
||||
>[]
|
||||
> {
|
||||
const all = await this.typesRepo.find({ where: { system: true } });
|
||||
return all
|
||||
.filter((t) => t.emitter_roles.includes(role))
|
||||
.map((t) => ({
|
||||
code: t.code,
|
||||
system: t.system,
|
||||
titre: t.titre,
|
||||
emitter_roles: t.emitter_roles,
|
||||
recipient_roles: t.recipient_roles,
|
||||
audience_resolver: t.audience_resolver,
|
||||
response_mode: t.response_mode,
|
||||
retention_days: t.retention_days,
|
||||
}));
|
||||
}
|
||||
|
||||
async lister(
|
||||
userId: string,
|
||||
role: RoleType,
|
||||
placementId?: string,
|
||||
): Promise<ListeCartesDto> {
|
||||
const qb = this.cardsRepo
|
||||
.createQueryBuilder('c')
|
||||
.innerJoin('c.audience', 'aud', 'aud.id_utilisateur = :userId', { userId })
|
||||
.leftJoinAndSelect('c.type', 'type')
|
||||
.leftJoinAndSelect('c.responses', 'responses')
|
||||
.where('c.purge_at > now()')
|
||||
.orderBy(
|
||||
`CASE c.statut WHEN 'refusee' THEN 0 WHEN 'ouverte' THEN 1 ELSE 2 END`,
|
||||
'ASC',
|
||||
)
|
||||
.addOrderBy('c.modifie_le', 'DESC');
|
||||
|
||||
if (placementId) {
|
||||
await this.assertPlacementAccess(userId, role, placementId);
|
||||
qb.andWhere('c.id_placement = :placementId', { placementId });
|
||||
}
|
||||
|
||||
const rows = await qb.getMany();
|
||||
return {
|
||||
items: rows.map((c) => this.toDto(c, userId)),
|
||||
};
|
||||
}
|
||||
|
||||
async creer(
|
||||
userId: string,
|
||||
role: RoleType,
|
||||
dto: CreerCarteDto,
|
||||
): Promise<CarteDto> {
|
||||
if (dto.date_fin < dto.date_debut) {
|
||||
throw new BadRequestException('date_fin < date_debut');
|
||||
}
|
||||
|
||||
const type = await this.typesRepo.findOne({ where: { code: dto.type_code } });
|
||||
if (!type || !type.system) {
|
||||
throw new NotFoundException('Type de carte inconnu');
|
||||
}
|
||||
if (!type.emitter_roles.includes(role)) {
|
||||
throw new ForbiddenException('Vous ne pouvez pas émettre ce type de carte');
|
||||
}
|
||||
|
||||
const placement = await this.assertPlacementAccess(
|
||||
userId,
|
||||
role,
|
||||
dto.id_placement,
|
||||
);
|
||||
const operation = dto.operation ?? CardOperationType.CREATE;
|
||||
|
||||
let absenceId = dto.id_evenement;
|
||||
const absenceType = this.mapAbsenceType(dto.type_code);
|
||||
|
||||
if (operation === CardOperationType.CREATE) {
|
||||
const absence = await this.evenementsService.creer(userId, role, {
|
||||
id_placement: dto.id_placement,
|
||||
type: absenceType,
|
||||
date_debut: dto.date_debut,
|
||||
date_fin: dto.date_fin,
|
||||
motif: dto.motif,
|
||||
});
|
||||
absenceId = absence.id;
|
||||
} else {
|
||||
if (!absenceId) {
|
||||
throw new BadRequestException('id_evenement requis pour operation=update');
|
||||
}
|
||||
await this.evenementsService.maj(userId, role, absenceId, {
|
||||
date_debut: dto.date_debut,
|
||||
date_fin: dto.date_fin,
|
||||
motif: dto.motif,
|
||||
// Congé accepté modifié → repasse en attente via cartes respond flow;
|
||||
// pour absence enfant update immédiat déjà fait.
|
||||
...(dto.type_code === 'conge_am'
|
||||
? { statut: StatutEvenementAgendaType.EN_ATTENTE }
|
||||
: {}),
|
||||
});
|
||||
}
|
||||
|
||||
const statutInitial =
|
||||
type.response_mode === CardResponseModeType.NONE
|
||||
? CardInstanceStatutType.TRAITEE
|
||||
: CardInstanceStatutType.OUVERTE;
|
||||
|
||||
const card = this.cardsRepo.create({
|
||||
type_code: type.code,
|
||||
id_placement: dto.id_placement,
|
||||
id_evenement: absenceId,
|
||||
cree_par: userId,
|
||||
operation,
|
||||
statut: statutInitial,
|
||||
payload: {
|
||||
date_debut: dto.date_debut,
|
||||
date_fin: dto.date_fin,
|
||||
motif: dto.motif ?? null,
|
||||
},
|
||||
purge_at: this.purgeAt(type.retention_days, statutInitial),
|
||||
});
|
||||
const saved = await this.cardsRepo.save(card);
|
||||
|
||||
if (absenceId) {
|
||||
await this.linkAbsenceCard(absenceId, saved.id);
|
||||
}
|
||||
|
||||
await this.buildAudience(saved, type, placement, userId, role);
|
||||
|
||||
const full = await this.loadCard(saved.id);
|
||||
const dtoOut = this.toDto(full, userId);
|
||||
this.emitAudience(full, 'card.created', dtoOut);
|
||||
return dtoOut;
|
||||
}
|
||||
|
||||
async repondre(
|
||||
userId: string,
|
||||
role: RoleType,
|
||||
cardId: string,
|
||||
dto: RepondreCarteDto,
|
||||
): Promise<CarteDto> {
|
||||
const card = await this.loadCard(cardId);
|
||||
await this.assertInAudience(card, userId);
|
||||
if (card.statut !== CardInstanceStatutType.OUVERTE) {
|
||||
throw new BadRequestException('Cette carte n’est plus ouverte');
|
||||
}
|
||||
if (card.cree_par === userId) {
|
||||
throw new ForbiddenException('Le créateur ne répond pas à sa propre carte');
|
||||
}
|
||||
|
||||
const mode = card.type.response_mode;
|
||||
if (mode === CardResponseModeType.NONE) {
|
||||
throw new BadRequestException('Ce type de carte ne demande pas de réponse');
|
||||
}
|
||||
if (mode === CardResponseModeType.ACK && dto.action !== CardResponseActionType.ACK) {
|
||||
throw new BadRequestException('Action attendue : ack');
|
||||
}
|
||||
if (
|
||||
mode === CardResponseModeType.ACCEPT_REFUSE &&
|
||||
dto.action !== CardResponseActionType.ACCEPT &&
|
||||
dto.action !== CardResponseActionType.REFUSE
|
||||
) {
|
||||
throw new BadRequestException('Action attendue : accept ou refuse');
|
||||
}
|
||||
if (dto.action === CardResponseActionType.REFUSE && !dto.comment?.trim()) {
|
||||
throw new BadRequestException('Motivation obligatoire en cas de refus');
|
||||
}
|
||||
|
||||
await this.responsesRepo.save(
|
||||
this.responsesRepo.create({
|
||||
card: { id: card.id },
|
||||
user: { id: userId },
|
||||
action: dto.action,
|
||||
comment: dto.comment?.trim() || undefined,
|
||||
}),
|
||||
);
|
||||
|
||||
if (card.id_evenement) {
|
||||
if (dto.action === CardResponseActionType.ACCEPT || dto.action === CardResponseActionType.ACK) {
|
||||
await this.evenementsService.maj(userId, role, card.id_evenement, {
|
||||
statut: StatutEvenementAgendaType.ACCEPTE,
|
||||
});
|
||||
card.statut = CardInstanceStatutType.TRAITEE;
|
||||
} else if (dto.action === CardResponseActionType.REFUSE) {
|
||||
await this.evenementsService.maj(userId, role, card.id_evenement, {
|
||||
statut: StatutEvenementAgendaType.REFUSE,
|
||||
motif: dto.comment!.trim(),
|
||||
});
|
||||
card.statut = CardInstanceStatutType.REFUSEE;
|
||||
}
|
||||
} else if (dto.action === CardResponseActionType.ACK) {
|
||||
card.statut = CardInstanceStatutType.TRAITEE;
|
||||
}
|
||||
|
||||
card.purge_at = this.purgeAt(card.type.retention_days, card.statut);
|
||||
// Ne pas cardsRepo.save(card) avec relations chargées : TypeORM peut
|
||||
// resynchroniser les FK enfants (UPDATE … SET id_card=null).
|
||||
await this.cardsRepo.update(
|
||||
{ id: card.id },
|
||||
{ statut: card.statut, purge_at: card.purge_at },
|
||||
);
|
||||
const full = await this.loadCard(cardId);
|
||||
const dtoOut = this.toDto(full, userId);
|
||||
this.emitAudience(full, 'response.added', {
|
||||
action: dto.action,
|
||||
card: dtoOut,
|
||||
});
|
||||
this.emitAudience(full, 'card.updated', dtoOut);
|
||||
return dtoOut;
|
||||
}
|
||||
|
||||
async majEnAttente(
|
||||
userId: string,
|
||||
role: RoleType,
|
||||
cardId: string,
|
||||
dto: MajCarteDto,
|
||||
): Promise<CarteDto> {
|
||||
const card = await this.loadCard(cardId);
|
||||
if (card.cree_par !== userId) {
|
||||
throw new ForbiddenException('Seul le créateur peut modifier cette carte');
|
||||
}
|
||||
if (
|
||||
card.statut !== CardInstanceStatutType.OUVERTE &&
|
||||
card.statut !== CardInstanceStatutType.REFUSEE
|
||||
) {
|
||||
throw new BadRequestException('Carte non modifiable dans cet état');
|
||||
}
|
||||
|
||||
const debut =
|
||||
dto.date_debut ?? String(card.payload?.['date_debut'] ?? '');
|
||||
const fin = dto.date_fin ?? String(card.payload?.['date_fin'] ?? '');
|
||||
if (!debut || !fin || fin < debut) {
|
||||
throw new BadRequestException('Dates invalides');
|
||||
}
|
||||
|
||||
if (card.id_evenement) {
|
||||
await this.evenementsService.maj(userId, role, card.id_evenement, {
|
||||
date_debut: debut,
|
||||
date_fin: fin,
|
||||
motif: dto.motif,
|
||||
statut: StatutEvenementAgendaType.EN_ATTENTE,
|
||||
});
|
||||
}
|
||||
|
||||
card.payload = {
|
||||
...card.payload,
|
||||
date_debut: debut,
|
||||
date_fin: fin,
|
||||
motif: dto.motif ?? card.payload?.['motif'] ?? null,
|
||||
};
|
||||
card.statut = CardInstanceStatutType.OUVERTE;
|
||||
card.purge_at = this.purgeAt(card.type.retention_days, card.statut);
|
||||
await this.cardsRepo.manager.query(
|
||||
`UPDATE card_instances
|
||||
SET statut = $1, purge_at = $2, payload = $3::jsonb, modifie_le = now()
|
||||
WHERE id = $4`,
|
||||
[card.statut, card.purge_at, JSON.stringify(card.payload), card.id],
|
||||
);
|
||||
const full = await this.loadCard(cardId);
|
||||
const dtoOut = this.toDto(full, userId);
|
||||
this.emitAudience(full, 'card.updated', dtoOut);
|
||||
return dtoOut;
|
||||
}
|
||||
|
||||
async supprimer(
|
||||
userId: string,
|
||||
role: RoleType,
|
||||
cardId: string,
|
||||
): Promise<void> {
|
||||
const card = await this.loadCard(cardId);
|
||||
if (card.cree_par !== userId) {
|
||||
throw new ForbiddenException('Seul le créateur peut supprimer cette carte');
|
||||
}
|
||||
const audienceIds = await this.audienceUserIds(card);
|
||||
if (card.id_evenement) {
|
||||
const absStatut =
|
||||
card.statut === CardInstanceStatutType.TRAITEE
|
||||
? null
|
||||
: card.id_evenement;
|
||||
// Supprime l’absence liée si pas encore acceptée définitivement
|
||||
if (
|
||||
card.statut === CardInstanceStatutType.OUVERTE ||
|
||||
card.statut === CardInstanceStatutType.REFUSEE
|
||||
) {
|
||||
await this.evenementsService.supprimer(userId, role, card.id_evenement);
|
||||
}
|
||||
void absStatut;
|
||||
}
|
||||
await this.cardsRepo.delete({ id: cardId });
|
||||
this.realtime.emitToUsers(audienceIds, 'card.deleted', cardId, {
|
||||
id: cardId,
|
||||
});
|
||||
}
|
||||
|
||||
private emitAudience(
|
||||
card: CardInstance,
|
||||
event: 'card.created' | 'card.updated' | 'response.added',
|
||||
data: unknown,
|
||||
): void {
|
||||
const ids = (card.audience ?? []).map((a) => a.id_utilisateur);
|
||||
if (ids.length === 0) return;
|
||||
this.realtime.emitToUsers(ids, event, card.id, data);
|
||||
}
|
||||
|
||||
private async audienceUserIds(card: CardInstance): Promise<string[]> {
|
||||
if (card.audience?.length) {
|
||||
return card.audience.map((a) => a.id_utilisateur);
|
||||
}
|
||||
const rows = await this.audienceRepo.find({ where: { id_card: card.id } });
|
||||
return rows.map((r) => r.id_utilisateur);
|
||||
}
|
||||
|
||||
private mapAbsenceType(typeCode: string): TypeEvenementAgendaType {
|
||||
if (typeCode === 'absence_enfant' || typeCode === 'absence_enfant_modif') {
|
||||
return TypeEvenementAgendaType.ABSENCE_ENFANT;
|
||||
}
|
||||
if (typeCode === 'conge_am') return TypeEvenementAgendaType.CONGE_AM;
|
||||
if (typeCode === 'arret_maladie_am') {
|
||||
return TypeEvenementAgendaType.ARRET_MALADIE_AM;
|
||||
}
|
||||
throw new BadRequestException(`Type non mappé à une absence: ${typeCode}`);
|
||||
}
|
||||
|
||||
private async linkAbsenceCard(absenceId: string, cardId: string): Promise<void> {
|
||||
// Update direct pour éviter droits maj vides
|
||||
await this.cardsRepo.manager.query(
|
||||
`UPDATE evenements_agenda SET id_card_instance = $1, modifie_le = now() WHERE id = $2`,
|
||||
[cardId, absenceId],
|
||||
);
|
||||
}
|
||||
|
||||
private async buildAudience(
|
||||
card: CardInstance,
|
||||
type: CardType,
|
||||
placement: AmChildren,
|
||||
creatorId: string,
|
||||
creatorRole: RoleType,
|
||||
): Promise<void> {
|
||||
const members: Partial<CardAudienceMember>[] = [
|
||||
{
|
||||
id_card: card.id,
|
||||
id_utilisateur: creatorId,
|
||||
role_snapshot: creatorRole,
|
||||
is_creator: true,
|
||||
},
|
||||
];
|
||||
|
||||
if (type.audience_resolver === 'couple_am') {
|
||||
// Destinataire métier = AM + miroir foyer : tous les co-parents de l’enfant
|
||||
members.push({
|
||||
id_card: card.id,
|
||||
id_utilisateur: placement.amId,
|
||||
role_snapshot: RoleType.ASSISTANTE_MATERNELLE,
|
||||
is_creator: false,
|
||||
});
|
||||
const liensAm = await this.parentsChildrenRepo.find({
|
||||
where: { enfantId: placement.enfantId },
|
||||
});
|
||||
for (const l of liensAm) {
|
||||
if (l.parentId === creatorId) continue;
|
||||
members.push({
|
||||
id_card: card.id,
|
||||
id_utilisateur: l.parentId,
|
||||
role_snapshot: RoleType.PARENT,
|
||||
is_creator: false,
|
||||
});
|
||||
}
|
||||
} else if (type.audience_resolver === 'couple_parents') {
|
||||
const liens = await this.parentsChildrenRepo.find({
|
||||
where: { enfantId: placement.enfantId },
|
||||
});
|
||||
for (const l of liens) {
|
||||
if (l.parentId === creatorId) continue;
|
||||
members.push({
|
||||
id_card: card.id,
|
||||
id_utilisateur: l.parentId,
|
||||
role_snapshot: RoleType.PARENT,
|
||||
is_creator: false,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// dédup
|
||||
const seen = new Set<string>();
|
||||
const unique = members.filter((m) => {
|
||||
const k = m.id_utilisateur!;
|
||||
if (seen.has(k)) return false;
|
||||
seen.add(k);
|
||||
return true;
|
||||
});
|
||||
await this.audienceRepo.save(this.audienceRepo.create(unique));
|
||||
}
|
||||
|
||||
private purgeAt(
|
||||
retentionDays: number,
|
||||
statut: CardInstanceStatutType,
|
||||
): Date {
|
||||
const days =
|
||||
statut === CardInstanceStatutType.OUVERTE
|
||||
? Math.max(retentionDays, 15)
|
||||
: retentionDays;
|
||||
return new Date(Date.now() + days * 24 * 60 * 60 * 1000);
|
||||
}
|
||||
|
||||
private async loadCard(id: string): Promise<CardInstance> {
|
||||
const card = await this.cardsRepo.findOne({
|
||||
where: { id },
|
||||
relations: ['type', 'responses', 'audience'],
|
||||
});
|
||||
if (!card) throw new NotFoundException('Carte introuvable');
|
||||
return card;
|
||||
}
|
||||
|
||||
private async assertInAudience(card: CardInstance, userId: string): Promise<void> {
|
||||
const ok = (card.audience ?? []).some((a) => a.id_utilisateur === userId);
|
||||
if (!ok) {
|
||||
const row = await this.audienceRepo.findOne({
|
||||
where: { id_card: card.id, id_utilisateur: userId },
|
||||
});
|
||||
if (!row) throw new ForbiddenException('Carte hors de votre audience');
|
||||
}
|
||||
}
|
||||
|
||||
private async assertPlacementAccess(
|
||||
userId: string,
|
||||
role: RoleType,
|
||||
placementId: string,
|
||||
): Promise<AmChildren> {
|
||||
const placement = await this.amChildrenRepo.findOne({
|
||||
where: { id: placementId, date_fin: IsNull() },
|
||||
});
|
||||
if (!placement) {
|
||||
throw new NotFoundException('Placement introuvable ou inactif');
|
||||
}
|
||||
if (role === RoleType.ASSISTANTE_MATERNELLE) {
|
||||
if (placement.amId !== userId) {
|
||||
throw new ForbiddenException('Placement non autorisé');
|
||||
}
|
||||
return placement;
|
||||
}
|
||||
if (role === RoleType.PARENT) {
|
||||
const lien = await this.parentsChildrenRepo.findOne({
|
||||
where: { parentId: userId, enfantId: placement.enfantId },
|
||||
});
|
||||
if (!lien) throw new ForbiddenException('Placement non autorisé');
|
||||
return placement;
|
||||
}
|
||||
throw new ForbiddenException('Rôle non autorisé');
|
||||
}
|
||||
|
||||
private toDto(card: CardInstance, userId: string): CarteDto {
|
||||
const lastRefuse = [...(card.responses ?? [])]
|
||||
.reverse()
|
||||
.find((r) => r.action === CardResponseActionType.REFUSE);
|
||||
return {
|
||||
id: card.id,
|
||||
type_code: card.type_code,
|
||||
titre: card.type?.titre ?? card.type_code,
|
||||
id_placement: card.id_placement,
|
||||
id_evenement: card.id_evenement ?? null,
|
||||
operation: card.operation,
|
||||
statut: card.statut,
|
||||
payload: card.payload ?? {},
|
||||
purge_at: card.purge_at?.toISOString?.() ?? String(card.purge_at),
|
||||
cree_par: card.cree_par ?? null,
|
||||
is_creator: card.cree_par === userId,
|
||||
response_mode: card.type?.response_mode,
|
||||
last_refuse_comment: lastRefuse?.comment ?? null,
|
||||
cree_le: card.cree_le?.toISOString?.() ?? String(card.cree_le),
|
||||
modifie_le: card.modifie_le?.toISOString?.() ?? String(card.modifie_le),
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,134 @@
|
||||
import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
|
||||
import {
|
||||
IsDateString,
|
||||
IsEnum,
|
||||
IsOptional,
|
||||
IsString,
|
||||
IsUUID,
|
||||
MaxLength,
|
||||
MinLength,
|
||||
ValidateIf,
|
||||
} from 'class-validator';
|
||||
import { CardInstanceStatutType, CardOperationType } from 'src/entities/card_instances.entity';
|
||||
import { CardResponseActionType } from 'src/entities/card_responses.entity';
|
||||
|
||||
export class CreerCarteDto {
|
||||
@ApiProperty({
|
||||
description: 'absence_enfant | absence_enfant_modif | conge_am | arret_maladie_am',
|
||||
})
|
||||
@IsString()
|
||||
type_code: string;
|
||||
|
||||
@ApiProperty()
|
||||
@IsUUID()
|
||||
id_placement: string;
|
||||
|
||||
@ApiProperty({ example: '2026-10-01' })
|
||||
@IsDateString()
|
||||
date_debut: string;
|
||||
|
||||
@ApiProperty({ example: '2026-10-05' })
|
||||
@IsDateString()
|
||||
date_fin: string;
|
||||
|
||||
@ApiPropertyOptional()
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(2000)
|
||||
motif?: string;
|
||||
|
||||
@ApiPropertyOptional({
|
||||
description: 'Requis pour operation=update (même id evenements_agenda)',
|
||||
})
|
||||
@IsOptional()
|
||||
@IsUUID()
|
||||
id_evenement?: string;
|
||||
|
||||
@ApiPropertyOptional({ enum: CardOperationType, default: CardOperationType.CREATE })
|
||||
@IsOptional()
|
||||
@IsEnum(CardOperationType)
|
||||
operation?: CardOperationType;
|
||||
}
|
||||
|
||||
export class RepondreCarteDto {
|
||||
@ApiProperty({ enum: CardResponseActionType })
|
||||
@IsEnum(CardResponseActionType)
|
||||
action: CardResponseActionType;
|
||||
|
||||
@ApiPropertyOptional({ description: 'Obligatoire si action=refuse' })
|
||||
@ValidateIf((o) => o.action === CardResponseActionType.REFUSE)
|
||||
@IsString()
|
||||
@MinLength(1)
|
||||
@MaxLength(2000)
|
||||
comment?: string;
|
||||
}
|
||||
|
||||
export class MajCarteDto {
|
||||
@ApiPropertyOptional()
|
||||
@IsOptional()
|
||||
@IsDateString()
|
||||
date_debut?: string;
|
||||
|
||||
@ApiPropertyOptional()
|
||||
@IsOptional()
|
||||
@IsDateString()
|
||||
date_fin?: string;
|
||||
|
||||
@ApiPropertyOptional()
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(2000)
|
||||
motif?: string;
|
||||
}
|
||||
|
||||
export class CarteDto {
|
||||
@ApiProperty()
|
||||
id: string;
|
||||
|
||||
@ApiProperty()
|
||||
type_code: string;
|
||||
|
||||
@ApiProperty()
|
||||
titre: string;
|
||||
|
||||
@ApiProperty()
|
||||
id_placement: string;
|
||||
|
||||
@ApiPropertyOptional()
|
||||
id_evenement?: string | null;
|
||||
|
||||
@ApiProperty({ enum: CardOperationType })
|
||||
operation: CardOperationType;
|
||||
|
||||
@ApiProperty({ enum: CardInstanceStatutType })
|
||||
statut: CardInstanceStatutType;
|
||||
|
||||
@ApiProperty()
|
||||
payload: Record<string, unknown>;
|
||||
|
||||
@ApiProperty()
|
||||
purge_at: string;
|
||||
|
||||
@ApiPropertyOptional()
|
||||
cree_par?: string | null;
|
||||
|
||||
@ApiProperty()
|
||||
is_creator: boolean;
|
||||
|
||||
@ApiPropertyOptional()
|
||||
response_mode?: string;
|
||||
|
||||
@ApiPropertyOptional()
|
||||
last_refuse_comment?: string | null;
|
||||
|
||||
@ApiProperty()
|
||||
cree_le: string;
|
||||
|
||||
@ApiProperty()
|
||||
modifie_le: string;
|
||||
}
|
||||
|
||||
export class ListeCartesDto {
|
||||
@ApiProperty({ type: [CarteDto] })
|
||||
items: CarteDto[];
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
export { CardsModule } from './cards.module';
|
||||
export { CardsService } from './cards.service';
|
||||
export { CardsRealtimeService } from './cards-realtime.service';
|
||||
@@ -0,0 +1,119 @@
|
||||
import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
|
||||
import {
|
||||
IsDateString,
|
||||
IsEnum,
|
||||
IsOptional,
|
||||
IsString,
|
||||
IsUUID,
|
||||
MaxLength,
|
||||
MinLength,
|
||||
} from 'class-validator';
|
||||
import {
|
||||
StatutEvenementAgendaType,
|
||||
TypeEvenementAgendaType,
|
||||
} from 'src/entities/evenements_agenda.entity';
|
||||
|
||||
export class CreerEvenementAgendaDto {
|
||||
@ApiProperty({ description: 'Placement AM↔enfant (couple)' })
|
||||
@IsUUID()
|
||||
id_placement: string;
|
||||
|
||||
@ApiProperty({ enum: TypeEvenementAgendaType })
|
||||
@IsEnum(TypeEvenementAgendaType)
|
||||
type: TypeEvenementAgendaType;
|
||||
|
||||
@ApiProperty({ example: '2026-10-01' })
|
||||
@IsDateString()
|
||||
date_debut: string;
|
||||
|
||||
@ApiProperty({ example: '2026-10-05' })
|
||||
@IsDateString()
|
||||
date_fin: string;
|
||||
|
||||
@ApiPropertyOptional()
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(2000)
|
||||
motif?: string;
|
||||
}
|
||||
|
||||
export class MajEvenementAgendaDto {
|
||||
@ApiPropertyOptional({ example: '2026-10-02' })
|
||||
@IsOptional()
|
||||
@IsDateString()
|
||||
date_debut?: string;
|
||||
|
||||
@ApiPropertyOptional({ example: '2026-10-06' })
|
||||
@IsOptional()
|
||||
@IsDateString()
|
||||
date_fin?: string;
|
||||
|
||||
@ApiPropertyOptional({ enum: StatutEvenementAgendaType })
|
||||
@IsOptional()
|
||||
@IsEnum(StatutEvenementAgendaType)
|
||||
statut?: StatutEvenementAgendaType;
|
||||
|
||||
@ApiPropertyOptional({
|
||||
description: 'Motivation de refus (parent) ou motif créateur',
|
||||
})
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MinLength(1)
|
||||
@MaxLength(2000)
|
||||
motif?: string;
|
||||
}
|
||||
|
||||
export class EvenementAgendaDto {
|
||||
@ApiProperty()
|
||||
id: string;
|
||||
|
||||
@ApiProperty()
|
||||
id_placement: string;
|
||||
|
||||
@ApiProperty({ enum: TypeEvenementAgendaType })
|
||||
type: TypeEvenementAgendaType;
|
||||
|
||||
@ApiProperty()
|
||||
date_debut: string;
|
||||
|
||||
@ApiProperty()
|
||||
date_fin: string;
|
||||
|
||||
@ApiProperty({ enum: StatutEvenementAgendaType })
|
||||
statut: StatutEvenementAgendaType;
|
||||
|
||||
@ApiProperty()
|
||||
expire_at: string;
|
||||
|
||||
@ApiPropertyOptional()
|
||||
cree_par?: string | null;
|
||||
|
||||
@ApiPropertyOptional()
|
||||
motif?: string | null;
|
||||
|
||||
@ApiPropertyOptional()
|
||||
id_enfant?: string | null;
|
||||
|
||||
@ApiPropertyOptional()
|
||||
prenom_enfant?: string | null;
|
||||
|
||||
@ApiPropertyOptional()
|
||||
id_am?: string | null;
|
||||
|
||||
@ApiPropertyOptional()
|
||||
prenom_am?: string | null;
|
||||
|
||||
@ApiPropertyOptional()
|
||||
nom_am?: string | null;
|
||||
|
||||
@ApiProperty()
|
||||
cree_le: string;
|
||||
|
||||
@ApiProperty()
|
||||
modifie_le: string;
|
||||
}
|
||||
|
||||
export class ListeEvenementsAgendaDto {
|
||||
@ApiProperty({ type: [EvenementAgendaDto] })
|
||||
items: EvenementAgendaDto[];
|
||||
}
|
||||
@@ -0,0 +1,73 @@
|
||||
import { Test, TestingModule } from '@nestjs/testing';
|
||||
import { EvenementsAgendaController } from './evenements-agenda.controller';
|
||||
import { EvenementsAgendaService } from './evenements-agenda.service';
|
||||
import { AuthGuard } from 'src/common/guards/auth.guard';
|
||||
import { RolesGuard } from 'src/common/guards/roles.guard';
|
||||
import { RoleType } from 'src/entities/users.entity';
|
||||
import { TypeEvenementAgendaType } from 'src/entities/evenements_agenda.entity';
|
||||
|
||||
describe('EvenementsAgendaController (#172)', () => {
|
||||
let controller: EvenementsAgendaController;
|
||||
const serviceMock = {
|
||||
lister: jest.fn(),
|
||||
creer: jest.fn(),
|
||||
maj: jest.fn(),
|
||||
supprimer: jest.fn(),
|
||||
};
|
||||
|
||||
beforeEach(async () => {
|
||||
const module: TestingModule = await Test.createTestingModule({
|
||||
controllers: [EvenementsAgendaController],
|
||||
providers: [{ provide: EvenementsAgendaService, useValue: serviceMock }],
|
||||
})
|
||||
.overrideGuard(AuthGuard)
|
||||
.useValue({ canActivate: () => true })
|
||||
.overrideGuard(RolesGuard)
|
||||
.useValue({ canActivate: () => true })
|
||||
.compile();
|
||||
|
||||
controller = module.get(EvenementsAgendaController);
|
||||
jest.clearAllMocks();
|
||||
});
|
||||
|
||||
it('should be defined', () => {
|
||||
expect(controller).toBeDefined();
|
||||
});
|
||||
|
||||
it('lister délègue au service', async () => {
|
||||
serviceMock.lister.mockResolvedValue({ items: [] });
|
||||
const res = await controller.lister(
|
||||
'u1',
|
||||
RoleType.PARENT,
|
||||
'pl-1',
|
||||
undefined,
|
||||
undefined,
|
||||
'2026-01-01',
|
||||
'2026-12-31',
|
||||
);
|
||||
expect(serviceMock.lister).toHaveBeenCalledWith('u1', RoleType.PARENT, {
|
||||
placementId: 'pl-1',
|
||||
type: undefined,
|
||||
statut: undefined,
|
||||
from: '2026-01-01',
|
||||
to: '2026-12-31',
|
||||
});
|
||||
expect(res.items).toEqual([]);
|
||||
});
|
||||
|
||||
it('creer délègue au service', async () => {
|
||||
serviceMock.creer.mockResolvedValue({ id: 'a1' });
|
||||
const dto = {
|
||||
id_placement: 'pl-1',
|
||||
type: TypeEvenementAgendaType.ABSENCE_ENFANT,
|
||||
date_debut: '2026-10-01',
|
||||
date_fin: '2026-10-02',
|
||||
};
|
||||
await controller.creer('u1', RoleType.PARENT, dto);
|
||||
expect(serviceMock.creer).toHaveBeenCalledWith(
|
||||
'u1',
|
||||
RoleType.PARENT,
|
||||
dto,
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,124 @@
|
||||
import {
|
||||
Body,
|
||||
Controller,
|
||||
Delete,
|
||||
Get,
|
||||
HttpCode,
|
||||
HttpStatus,
|
||||
Param,
|
||||
ParseUUIDPipe,
|
||||
Patch,
|
||||
Post,
|
||||
Query,
|
||||
UseGuards,
|
||||
} from '@nestjs/common';
|
||||
import {
|
||||
ApiBearerAuth,
|
||||
ApiBody,
|
||||
ApiOperation,
|
||||
ApiQuery,
|
||||
ApiResponse,
|
||||
ApiTags,
|
||||
} from '@nestjs/swagger';
|
||||
import { AuthGuard } from 'src/common/guards/auth.guard';
|
||||
import { RolesGuard } from 'src/common/guards/roles.guard';
|
||||
import { Roles } from 'src/common/decorators/roles.decorator';
|
||||
import { User } from 'src/common/decorators/user.decorator';
|
||||
import {
|
||||
StatutEvenementAgendaType,
|
||||
TypeEvenementAgendaType,
|
||||
} from 'src/entities/evenements_agenda.entity';
|
||||
import { RoleType } from 'src/entities/users.entity';
|
||||
import { EvenementsAgendaService } from './evenements-agenda.service';
|
||||
import {
|
||||
EvenementAgendaDto,
|
||||
CreerEvenementAgendaDto,
|
||||
ListeEvenementsAgendaDto,
|
||||
MajEvenementAgendaDto,
|
||||
} from './dto/evenements-agenda.dto';
|
||||
|
||||
@ApiTags('Événements agenda')
|
||||
@ApiBearerAuth('access-token')
|
||||
@Controller('evenements-agenda')
|
||||
@UseGuards(AuthGuard, RolesGuard)
|
||||
export class EvenementsAgendaController {
|
||||
constructor(private readonly evenementsAgendaService: EvenementsAgendaService) {}
|
||||
|
||||
@Get()
|
||||
@Roles(RoleType.PARENT, RoleType.ASSISTANTE_MATERNELLE)
|
||||
@ApiOperation({
|
||||
summary: 'Lister les absences / congés / arrêts — ticket #205 / ex-#172',
|
||||
description:
|
||||
'Sans placementId : tous les placements du user (parent = famille multi-AM ; AM = tous accueils). ' +
|
||||
'Avec placementId : un couple enfant–AM.',
|
||||
})
|
||||
@ApiQuery({ name: 'placementId', required: false })
|
||||
@ApiQuery({ name: 'type', required: false, enum: TypeEvenementAgendaType })
|
||||
@ApiQuery({ name: 'statut', required: false, enum: StatutEvenementAgendaType })
|
||||
@ApiQuery({ name: 'from', required: false, description: 'YYYY-MM-DD' })
|
||||
@ApiQuery({ name: 'to', required: false, description: 'YYYY-MM-DD' })
|
||||
@ApiResponse({ status: 200, type: ListeEvenementsAgendaDto })
|
||||
lister(
|
||||
@User('id') userId: string,
|
||||
@User('role') role: RoleType,
|
||||
@Query('placementId') placementId?: string,
|
||||
@Query('type') type?: TypeEvenementAgendaType,
|
||||
@Query('statut') statut?: StatutEvenementAgendaType,
|
||||
@Query('from') from?: string,
|
||||
@Query('to') to?: string,
|
||||
): Promise<ListeEvenementsAgendaDto> {
|
||||
return this.evenementsAgendaService.lister(userId, role, {
|
||||
placementId,
|
||||
type,
|
||||
statut,
|
||||
from,
|
||||
to,
|
||||
});
|
||||
}
|
||||
|
||||
@Post()
|
||||
@Roles(RoleType.PARENT, RoleType.ASSISTANTE_MATERNELLE)
|
||||
@ApiOperation({ summary: 'Créer une période d’absence / congé / arrêt — #172' })
|
||||
@ApiBody({ type: CreerEvenementAgendaDto })
|
||||
@ApiResponse({ status: 201, type: EvenementAgendaDto })
|
||||
@HttpCode(HttpStatus.CREATED)
|
||||
creer(
|
||||
@User('id') userId: string,
|
||||
@User('role') role: RoleType,
|
||||
@Body() dto: CreerEvenementAgendaDto,
|
||||
): Promise<EvenementAgendaDto> {
|
||||
return this.evenementsAgendaService.creer(userId, role, dto);
|
||||
}
|
||||
|
||||
@Patch(':id')
|
||||
@Roles(RoleType.PARENT, RoleType.ASSISTANTE_MATERNELLE)
|
||||
@ApiOperation({
|
||||
summary: 'Mettre à jour dates / statut / motif — #172',
|
||||
description:
|
||||
'Parent : accept/refuse congé (motivation si refus), ack arrêt. ' +
|
||||
'AM : modifier dates (en attente / refuse / accepté), republication après refus.',
|
||||
})
|
||||
@ApiBody({ type: MajEvenementAgendaDto })
|
||||
@ApiResponse({ status: 200, type: EvenementAgendaDto })
|
||||
maj(
|
||||
@User('id') userId: string,
|
||||
@User('role') role: RoleType,
|
||||
@Param('id', ParseUUIDPipe) id: string,
|
||||
@Body() dto: MajEvenementAgendaDto,
|
||||
): Promise<EvenementAgendaDto> {
|
||||
return this.evenementsAgendaService.maj(userId, role, id, dto);
|
||||
}
|
||||
|
||||
@Delete(':id')
|
||||
@Roles(RoleType.PARENT, RoleType.ASSISTANTE_MATERNELLE)
|
||||
@HttpCode(HttpStatus.NO_CONTENT)
|
||||
@ApiOperation({ summary: 'Supprimer une absence (hard delete) — #172' })
|
||||
@ApiResponse({ status: 204 })
|
||||
async supprimer(
|
||||
@User('id') userId: string,
|
||||
@User('role') role: RoleType,
|
||||
@Param('id', ParseUUIDPipe) id: string,
|
||||
): Promise<void> {
|
||||
await this.evenementsAgendaService.supprimer(userId, role, id);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { ConfigModule, ConfigService } from '@nestjs/config';
|
||||
import { JwtModule } from '@nestjs/jwt';
|
||||
import { TypeOrmModule } from '@nestjs/typeorm';
|
||||
import { EvenementsAgenda } from 'src/entities/evenements_agenda.entity';
|
||||
import { AmChildren } from 'src/entities/am_children.entity';
|
||||
import { ParentsChildren } from 'src/entities/parents_children.entity';
|
||||
import { EvenementsAgendaController } from './evenements-agenda.controller';
|
||||
import { EvenementsAgendaService } from './evenements-agenda.service';
|
||||
|
||||
@Module({
|
||||
imports: [
|
||||
TypeOrmModule.forFeature([EvenementsAgenda, AmChildren, ParentsChildren]),
|
||||
JwtModule.registerAsync({
|
||||
imports: [ConfigModule],
|
||||
useFactory: (config: ConfigService) => ({
|
||||
secret: config.get('jwt.accessSecret'),
|
||||
signOptions: { expiresIn: config.get('jwt.accessExpiresIn') },
|
||||
}),
|
||||
inject: [ConfigService],
|
||||
}),
|
||||
],
|
||||
controllers: [EvenementsAgendaController],
|
||||
providers: [EvenementsAgendaService],
|
||||
exports: [EvenementsAgendaService],
|
||||
})
|
||||
export class EvenementsAgendaModule {}
|
||||
@@ -0,0 +1,168 @@
|
||||
import { Test, TestingModule } from '@nestjs/testing';
|
||||
import { getRepositoryToken } from '@nestjs/typeorm';
|
||||
import { ForbiddenException, BadRequestException } from '@nestjs/common';
|
||||
import { EvenementsAgendaService } from './evenements-agenda.service';
|
||||
import {
|
||||
EvenementsAgenda,
|
||||
StatutEvenementAgendaType,
|
||||
TypeEvenementAgendaType,
|
||||
} from 'src/entities/evenements_agenda.entity';
|
||||
import { AmChildren } from 'src/entities/am_children.entity';
|
||||
import { ParentsChildren } from 'src/entities/parents_children.entity';
|
||||
import { RoleType } from 'src/entities/users.entity';
|
||||
|
||||
describe('EvenementsAgendaService (#172)', () => {
|
||||
let service: EvenementsAgendaService;
|
||||
const absencesRepo = {
|
||||
create: jest.fn((x) => x),
|
||||
save: jest.fn(async (x) => ({
|
||||
...x,
|
||||
id: x.id ?? 'abs-1',
|
||||
cree_le: new Date(),
|
||||
modifie_le: new Date(),
|
||||
})),
|
||||
findOne: jest.fn(),
|
||||
delete: jest.fn(),
|
||||
createQueryBuilder: jest.fn(),
|
||||
};
|
||||
const amChildrenRepo = {
|
||||
find: jest.fn(),
|
||||
findOne: jest.fn(),
|
||||
};
|
||||
const parentsChildrenRepo = {
|
||||
find: jest.fn(),
|
||||
findOne: jest.fn(),
|
||||
};
|
||||
|
||||
beforeEach(async () => {
|
||||
const module: TestingModule = await Test.createTestingModule({
|
||||
providers: [
|
||||
EvenementsAgendaService,
|
||||
{ provide: getRepositoryToken(EvenementsAgenda), useValue: absencesRepo },
|
||||
{ provide: getRepositoryToken(AmChildren), useValue: amChildrenRepo },
|
||||
{
|
||||
provide: getRepositoryToken(ParentsChildren),
|
||||
useValue: parentsChildrenRepo,
|
||||
},
|
||||
],
|
||||
}).compile();
|
||||
service = module.get(EvenementsAgendaService);
|
||||
jest.clearAllMocks();
|
||||
});
|
||||
|
||||
it('should be defined', () => {
|
||||
expect(service).toBeDefined();
|
||||
});
|
||||
|
||||
it('parent crée absence_enfant → statut accepte', async () => {
|
||||
amChildrenRepo.findOne.mockResolvedValue({
|
||||
id: 'pl-1',
|
||||
amId: 'am-1',
|
||||
enfantId: 'e-1',
|
||||
date_fin: null,
|
||||
});
|
||||
parentsChildrenRepo.findOne.mockResolvedValue({
|
||||
parentId: 'p-1',
|
||||
enfantId: 'e-1',
|
||||
});
|
||||
absencesRepo.findOne.mockResolvedValue({
|
||||
id: 'abs-1',
|
||||
id_placement: 'pl-1',
|
||||
type: TypeEvenementAgendaType.ABSENCE_ENFANT,
|
||||
date_debut: '2026-10-01',
|
||||
date_fin: '2026-10-02',
|
||||
statut: StatutEvenementAgendaType.ACCEPTE,
|
||||
expire_at: new Date('9999-12-31'),
|
||||
cree_le: new Date(),
|
||||
modifie_le: new Date(),
|
||||
placement: {
|
||||
enfantId: 'e-1',
|
||||
amId: 'am-1',
|
||||
child: { id: 'e-1', first_name: 'Léo' },
|
||||
am: { user: { prenom: 'Marie', nom: 'AM' } },
|
||||
},
|
||||
});
|
||||
|
||||
const res = await service.creer('p-1', RoleType.PARENT, {
|
||||
id_placement: 'pl-1',
|
||||
type: TypeEvenementAgendaType.ABSENCE_ENFANT,
|
||||
date_debut: '2026-10-01',
|
||||
date_fin: '2026-10-02',
|
||||
});
|
||||
|
||||
expect(absencesRepo.save).toHaveBeenCalled();
|
||||
const savedArg = absencesRepo.save.mock.calls[0][0];
|
||||
expect(savedArg.statut).toBe(StatutEvenementAgendaType.ACCEPTE);
|
||||
expect(res.type).toBe(TypeEvenementAgendaType.ABSENCE_ENFANT);
|
||||
});
|
||||
|
||||
it('parent ne peut pas créer un congé AM', async () => {
|
||||
amChildrenRepo.findOne.mockResolvedValue({
|
||||
id: 'pl-1',
|
||||
amId: 'am-1',
|
||||
enfantId: 'e-1',
|
||||
date_fin: null,
|
||||
});
|
||||
parentsChildrenRepo.findOne.mockResolvedValue({
|
||||
parentId: 'p-1',
|
||||
enfantId: 'e-1',
|
||||
});
|
||||
await expect(
|
||||
service.creer('p-1', RoleType.PARENT, {
|
||||
id_placement: 'pl-1',
|
||||
type: TypeEvenementAgendaType.CONGE_AM,
|
||||
date_debut: '2026-10-01',
|
||||
date_fin: '2026-10-05',
|
||||
}),
|
||||
).rejects.toBeInstanceOf(ForbiddenException);
|
||||
});
|
||||
|
||||
it('refus congé sans motif → BadRequest', async () => {
|
||||
absencesRepo.findOne.mockResolvedValue({
|
||||
id: 'abs-1',
|
||||
id_placement: 'pl-1',
|
||||
type: TypeEvenementAgendaType.CONGE_AM,
|
||||
date_debut: '2026-10-01',
|
||||
date_fin: '2026-10-05',
|
||||
statut: StatutEvenementAgendaType.EN_ATTENTE,
|
||||
expire_at: new Date(),
|
||||
});
|
||||
amChildrenRepo.findOne.mockResolvedValue({
|
||||
id: 'pl-1',
|
||||
amId: 'am-1',
|
||||
enfantId: 'e-1',
|
||||
date_fin: null,
|
||||
});
|
||||
parentsChildrenRepo.findOne.mockResolvedValue({
|
||||
parentId: 'p-1',
|
||||
enfantId: 'e-1',
|
||||
});
|
||||
|
||||
await expect(
|
||||
service.maj('p-1', RoleType.PARENT, 'abs-1', {
|
||||
statut: StatutEvenementAgendaType.REFUSE,
|
||||
}),
|
||||
).rejects.toBeInstanceOf(BadRequestException);
|
||||
});
|
||||
|
||||
it('dates invalides → BadRequest', async () => {
|
||||
amChildrenRepo.findOne.mockResolvedValue({
|
||||
id: 'pl-1',
|
||||
amId: 'am-1',
|
||||
enfantId: 'e-1',
|
||||
date_fin: null,
|
||||
});
|
||||
parentsChildrenRepo.findOne.mockResolvedValue({
|
||||
parentId: 'p-1',
|
||||
enfantId: 'e-1',
|
||||
});
|
||||
await expect(
|
||||
service.creer('p-1', RoleType.PARENT, {
|
||||
id_placement: 'pl-1',
|
||||
type: TypeEvenementAgendaType.ABSENCE_ENFANT,
|
||||
date_debut: '2026-10-10',
|
||||
date_fin: '2026-10-01',
|
||||
}),
|
||||
).rejects.toBeInstanceOf(BadRequestException);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,421 @@
|
||||
import {
|
||||
BadRequestException,
|
||||
ForbiddenException,
|
||||
Injectable,
|
||||
NotFoundException,
|
||||
} from '@nestjs/common';
|
||||
import { InjectRepository } from '@nestjs/typeorm';
|
||||
import { In, IsNull, Repository } from 'typeorm';
|
||||
import {
|
||||
EvenementsAgenda,
|
||||
StatutEvenementAgendaType,
|
||||
TypeEvenementAgendaType,
|
||||
} from 'src/entities/evenements_agenda.entity';
|
||||
import { AmChildren } from 'src/entities/am_children.entity';
|
||||
import { ParentsChildren } from 'src/entities/parents_children.entity';
|
||||
import { RoleType } from 'src/entities/users.entity';
|
||||
import {
|
||||
EvenementAgendaDto,
|
||||
CreerEvenementAgendaDto,
|
||||
ListeEvenementsAgendaDto,
|
||||
MajEvenementAgendaDto,
|
||||
} from './dto/evenements-agenda.dto';
|
||||
|
||||
const TTL_EN_ATTENTE_MS = 15 * 24 * 60 * 60 * 1000;
|
||||
const TTL_REFUSE_MS = 7 * 24 * 60 * 60 * 1000;
|
||||
/** Sentinel « pas de purge » pour les périodes acceptées */
|
||||
const EXPIRE_ACCEPTE = new Date('9999-12-31T23:59:59.999Z');
|
||||
|
||||
@Injectable()
|
||||
export class EvenementsAgendaService {
|
||||
constructor(
|
||||
@InjectRepository(EvenementsAgenda)
|
||||
private readonly absencesRepo: Repository<EvenementsAgenda>,
|
||||
@InjectRepository(AmChildren)
|
||||
private readonly amChildrenRepo: Repository<AmChildren>,
|
||||
@InjectRepository(ParentsChildren)
|
||||
private readonly parentsChildrenRepo: Repository<ParentsChildren>,
|
||||
) {}
|
||||
|
||||
async lister(
|
||||
userId: string,
|
||||
role: RoleType,
|
||||
opts: {
|
||||
placementId?: string;
|
||||
type?: TypeEvenementAgendaType;
|
||||
statut?: StatutEvenementAgendaType;
|
||||
from?: string;
|
||||
to?: string;
|
||||
},
|
||||
): Promise<ListeEvenementsAgendaDto> {
|
||||
const placementIds = await this.resolvePlacementIds(
|
||||
userId,
|
||||
role,
|
||||
opts.placementId,
|
||||
);
|
||||
if (placementIds.length === 0) {
|
||||
return { items: [] };
|
||||
}
|
||||
|
||||
const qb = this.absencesRepo
|
||||
.createQueryBuilder('ag')
|
||||
.leftJoinAndSelect('ag.placement', 'placement')
|
||||
.leftJoinAndSelect('placement.child', 'child')
|
||||
.leftJoinAndSelect('placement.am', 'am')
|
||||
.leftJoinAndSelect('am.user', 'amUser')
|
||||
.where('ag.id_placement IN (:...placementIds)', { placementIds })
|
||||
.orderBy('ag.date_debut', 'DESC');
|
||||
|
||||
if (opts.type) {
|
||||
qb.andWhere('ag.type = :type', { type: opts.type });
|
||||
}
|
||||
if (opts.statut) {
|
||||
qb.andWhere('ag.statut = :statut', { statut: opts.statut });
|
||||
}
|
||||
if (opts.from) {
|
||||
qb.andWhere('ag.date_fin >= :from', { from: opts.from });
|
||||
}
|
||||
if (opts.to) {
|
||||
qb.andWhere('ag.date_debut <= :to', { to: opts.to });
|
||||
}
|
||||
|
||||
const rows = await qb.getMany();
|
||||
return { items: rows.map((r) => this.toDto(r)) };
|
||||
}
|
||||
|
||||
async creer(
|
||||
userId: string,
|
||||
role: RoleType,
|
||||
dto: CreerEvenementAgendaDto,
|
||||
): Promise<EvenementAgendaDto> {
|
||||
this.assertDates(dto.date_debut, dto.date_fin);
|
||||
await this.assertCanAccessPlacement(userId, role, dto.id_placement);
|
||||
this.assertCanCreateType(role, dto.type);
|
||||
|
||||
const statut = this.statutInitial(dto.type);
|
||||
const entity = this.absencesRepo.create({
|
||||
id_placement: dto.id_placement,
|
||||
type: dto.type,
|
||||
date_debut: dto.date_debut,
|
||||
date_fin: dto.date_fin,
|
||||
statut,
|
||||
expire_at: this.expireAtFor(statut),
|
||||
cree_par: userId,
|
||||
motif: dto.motif?.trim() || undefined,
|
||||
});
|
||||
const saved = await this.absencesRepo.save(entity);
|
||||
return this.getByIdForUser(saved.id, userId, role);
|
||||
}
|
||||
|
||||
async maj(
|
||||
userId: string,
|
||||
role: RoleType,
|
||||
id: string,
|
||||
dto: MajEvenementAgendaDto,
|
||||
): Promise<EvenementAgendaDto> {
|
||||
const row = await this.absencesRepo.findOne({ where: { id } });
|
||||
if (!row) {
|
||||
throw new NotFoundException('Absence introuvable');
|
||||
}
|
||||
await this.assertCanAccessPlacement(userId, role, row.id_placement);
|
||||
|
||||
if (dto.date_debut !== undefined || dto.date_fin !== undefined) {
|
||||
const debut = dto.date_debut ?? row.date_debut;
|
||||
const fin = dto.date_fin ?? row.date_fin;
|
||||
this.assertDates(debut, fin);
|
||||
// Parent : peut modifier ses absences enfant
|
||||
// AM : peut modifier congé/arrêt en_attente (avant accept) ou dates si créateur
|
||||
this.assertCanEditDates(role, row);
|
||||
row.date_debut = debut;
|
||||
row.date_fin = fin;
|
||||
if (row.statut === StatutEvenementAgendaType.EN_ATTENTE) {
|
||||
row.expire_at = this.expireAtFor(StatutEvenementAgendaType.EN_ATTENTE);
|
||||
}
|
||||
}
|
||||
|
||||
if (dto.statut !== undefined && dto.statut !== row.statut) {
|
||||
this.assertCanChangeStatut(role, row, dto.statut, dto.motif);
|
||||
if (
|
||||
dto.statut === StatutEvenementAgendaType.REFUSE &&
|
||||
(!dto.motif || !dto.motif.trim())
|
||||
) {
|
||||
throw new BadRequestException(
|
||||
'Une motivation est obligatoire en cas de refus',
|
||||
);
|
||||
}
|
||||
row.statut = dto.statut;
|
||||
row.expire_at = this.expireAtFor(dto.statut);
|
||||
if (dto.motif?.trim()) {
|
||||
row.motif = dto.motif.trim();
|
||||
}
|
||||
} else if (dto.motif !== undefined) {
|
||||
row.motif = dto.motif.trim() || undefined;
|
||||
}
|
||||
|
||||
await this.absencesRepo.save(row);
|
||||
return this.getByIdForUser(id, userId, role);
|
||||
}
|
||||
|
||||
async supprimer(
|
||||
userId: string,
|
||||
role: RoleType,
|
||||
id: string,
|
||||
): Promise<void> {
|
||||
const row = await this.absencesRepo.findOne({ where: { id } });
|
||||
if (!row) {
|
||||
throw new NotFoundException('Absence introuvable');
|
||||
}
|
||||
await this.assertCanAccessPlacement(userId, role, row.id_placement);
|
||||
|
||||
if (
|
||||
role === RoleType.PARENT &&
|
||||
row.type !== TypeEvenementAgendaType.ABSENCE_ENFANT
|
||||
) {
|
||||
throw new ForbiddenException(
|
||||
'Un parent ne peut supprimer que les absences enfant',
|
||||
);
|
||||
}
|
||||
|
||||
await this.absencesRepo.delete({ id });
|
||||
}
|
||||
|
||||
private async getByIdForUser(
|
||||
id: string,
|
||||
userId: string,
|
||||
role: RoleType,
|
||||
): Promise<EvenementAgendaDto> {
|
||||
const row = await this.absencesRepo.findOne({
|
||||
where: { id },
|
||||
relations: ['placement', 'placement.child', 'placement.am', 'placement.am.user'],
|
||||
});
|
||||
if (!row) {
|
||||
throw new NotFoundException('Absence introuvable');
|
||||
}
|
||||
await this.assertCanAccessPlacement(userId, role, row.id_placement);
|
||||
return this.toDto(row);
|
||||
}
|
||||
|
||||
private statutInitial(type: TypeEvenementAgendaType): StatutEvenementAgendaType {
|
||||
if (type === TypeEvenementAgendaType.ABSENCE_ENFANT) {
|
||||
return StatutEvenementAgendaType.ACCEPTE;
|
||||
}
|
||||
return StatutEvenementAgendaType.EN_ATTENTE;
|
||||
}
|
||||
|
||||
private expireAtFor(statut: StatutEvenementAgendaType): Date {
|
||||
const now = Date.now();
|
||||
if (statut === StatutEvenementAgendaType.ACCEPTE) {
|
||||
return EXPIRE_ACCEPTE;
|
||||
}
|
||||
if (statut === StatutEvenementAgendaType.REFUSE) {
|
||||
return new Date(now + TTL_REFUSE_MS);
|
||||
}
|
||||
return new Date(now + TTL_EN_ATTENTE_MS);
|
||||
}
|
||||
|
||||
private assertDates(debut: string, fin: string): void {
|
||||
if (fin < debut) {
|
||||
throw new BadRequestException(
|
||||
'date_fin doit être supérieure ou égale à date_debut',
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
private assertCanCreateType(role: RoleType, type: TypeEvenementAgendaType): void {
|
||||
if (role === RoleType.PARENT) {
|
||||
if (type !== TypeEvenementAgendaType.ABSENCE_ENFANT) {
|
||||
throw new ForbiddenException(
|
||||
'Un parent ne peut créer que des absences enfant',
|
||||
);
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (role === RoleType.ASSISTANTE_MATERNELLE) {
|
||||
if (
|
||||
type !== TypeEvenementAgendaType.CONGE_AM &&
|
||||
type !== TypeEvenementAgendaType.ARRET_MALADIE_AM
|
||||
) {
|
||||
throw new ForbiddenException(
|
||||
'Une AM ne peut créer que congé ou arrêt maladie',
|
||||
);
|
||||
}
|
||||
return;
|
||||
}
|
||||
throw new ForbiddenException('Rôle non autorisé à créer une absence');
|
||||
}
|
||||
|
||||
private assertCanEditDates(
|
||||
role: RoleType,
|
||||
row: EvenementsAgenda,
|
||||
): void {
|
||||
if (role === RoleType.PARENT) {
|
||||
if (row.type !== TypeEvenementAgendaType.ABSENCE_ENFANT) {
|
||||
throw new ForbiddenException(
|
||||
'Un parent ne peut modifier que les absences enfant',
|
||||
);
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (role === RoleType.ASSISTANTE_MATERNELLE) {
|
||||
if (
|
||||
row.type === TypeEvenementAgendaType.CONGE_AM ||
|
||||
row.type === TypeEvenementAgendaType.ARRET_MALADIE_AM
|
||||
) {
|
||||
if (
|
||||
row.statut !== StatutEvenementAgendaType.EN_ATTENTE &&
|
||||
row.statut !== StatutEvenementAgendaType.REFUSE &&
|
||||
row.statut !== StatutEvenementAgendaType.ACCEPTE
|
||||
) {
|
||||
throw new ForbiddenException('Statut incompatible avec une modification');
|
||||
}
|
||||
// Accepté : autorisé (S2b — re-validation via cartes plus tard ; API permet update dates)
|
||||
return;
|
||||
}
|
||||
throw new ForbiddenException('Type non modifiable par l’AM');
|
||||
}
|
||||
throw new ForbiddenException('Modification non autorisée');
|
||||
}
|
||||
|
||||
private assertCanChangeStatut(
|
||||
role: RoleType,
|
||||
row: EvenementsAgenda,
|
||||
next: StatutEvenementAgendaType,
|
||||
_motif?: string,
|
||||
): void {
|
||||
if (role === RoleType.PARENT) {
|
||||
// Accept / refuse congé ; ack arrêt (accepte)
|
||||
if (
|
||||
row.type === TypeEvenementAgendaType.CONGE_AM ||
|
||||
row.type === TypeEvenementAgendaType.ARRET_MALADIE_AM
|
||||
) {
|
||||
if (
|
||||
next !== StatutEvenementAgendaType.ACCEPTE &&
|
||||
next !== StatutEvenementAgendaType.REFUSE
|
||||
) {
|
||||
throw new BadRequestException('Transition de statut invalide');
|
||||
}
|
||||
if (
|
||||
row.type === TypeEvenementAgendaType.ARRET_MALADIE_AM &&
|
||||
next === StatutEvenementAgendaType.REFUSE
|
||||
) {
|
||||
throw new BadRequestException(
|
||||
'Un arrêt maladie ne se refuse pas (accusé seulement)',
|
||||
);
|
||||
}
|
||||
if (row.statut !== StatutEvenementAgendaType.EN_ATTENTE) {
|
||||
throw new BadRequestException('Cette demande n’est plus en attente');
|
||||
}
|
||||
return;
|
||||
}
|
||||
throw new ForbiddenException(
|
||||
'Pas de changement de statut sur ce type pour un parent',
|
||||
);
|
||||
}
|
||||
if (role === RoleType.ASSISTANTE_MATERNELLE) {
|
||||
// Remise en attente après refus OU modification d’un congé déjà accepté (S2b)
|
||||
if (
|
||||
next === StatutEvenementAgendaType.EN_ATTENTE &&
|
||||
(row.statut === StatutEvenementAgendaType.REFUSE ||
|
||||
row.statut === StatutEvenementAgendaType.ACCEPTE)
|
||||
) {
|
||||
return;
|
||||
}
|
||||
throw new ForbiddenException(
|
||||
'L’AM ne valide pas elle-même (sauf republication / modification)',
|
||||
);
|
||||
}
|
||||
throw new ForbiddenException('Changement de statut non autorisé');
|
||||
}
|
||||
|
||||
private async resolvePlacementIds(
|
||||
userId: string,
|
||||
role: RoleType,
|
||||
placementId?: string,
|
||||
): Promise<string[]> {
|
||||
if (placementId) {
|
||||
await this.assertCanAccessPlacement(userId, role, placementId);
|
||||
return [placementId];
|
||||
}
|
||||
|
||||
if (role === RoleType.PARENT) {
|
||||
const liens = await this.parentsChildrenRepo.find({
|
||||
where: { parentId: userId },
|
||||
select: ['enfantId'],
|
||||
});
|
||||
const enfantIds = liens.map((l) => l.enfantId);
|
||||
if (enfantIds.length === 0) return [];
|
||||
const placements = await this.amChildrenRepo.find({
|
||||
where: { enfantId: In(enfantIds), date_fin: IsNull() },
|
||||
select: ['id'],
|
||||
});
|
||||
return placements.map((p) => p.id);
|
||||
}
|
||||
|
||||
if (role === RoleType.ASSISTANTE_MATERNELLE) {
|
||||
const placements = await this.amChildrenRepo.find({
|
||||
where: { amId: userId, date_fin: IsNull() },
|
||||
select: ['id'],
|
||||
});
|
||||
return placements.map((p) => p.id);
|
||||
}
|
||||
|
||||
throw new ForbiddenException('Rôle non autorisé');
|
||||
}
|
||||
|
||||
private async assertCanAccessPlacement(
|
||||
userId: string,
|
||||
role: RoleType,
|
||||
placementId: string,
|
||||
): Promise<AmChildren> {
|
||||
const placement = await this.amChildrenRepo.findOne({
|
||||
where: { id: placementId, date_fin: IsNull() },
|
||||
});
|
||||
if (!placement) {
|
||||
throw new NotFoundException('Placement / couple introuvable ou inactif');
|
||||
}
|
||||
|
||||
if (role === RoleType.ASSISTANTE_MATERNELLE) {
|
||||
if (placement.amId !== userId) {
|
||||
throw new ForbiddenException('Ce placement ne vous appartient pas');
|
||||
}
|
||||
return placement;
|
||||
}
|
||||
|
||||
if (role === RoleType.PARENT) {
|
||||
const lien = await this.parentsChildrenRepo.findOne({
|
||||
where: { parentId: userId, enfantId: placement.enfantId },
|
||||
});
|
||||
if (!lien) {
|
||||
throw new ForbiddenException(
|
||||
'Ce placement ne concerne pas un de vos enfants',
|
||||
);
|
||||
}
|
||||
return placement;
|
||||
}
|
||||
|
||||
throw new ForbiddenException('Rôle non autorisé');
|
||||
}
|
||||
|
||||
private toDto(row: EvenementsAgenda): EvenementAgendaDto {
|
||||
const child = row.placement?.child;
|
||||
const amUser = row.placement?.am?.user;
|
||||
return {
|
||||
id: row.id,
|
||||
id_placement: row.id_placement,
|
||||
type: row.type,
|
||||
date_debut: row.date_debut,
|
||||
date_fin: row.date_fin,
|
||||
statut: row.statut,
|
||||
expire_at: row.expire_at?.toISOString?.() ?? String(row.expire_at),
|
||||
cree_par: row.cree_par ?? null,
|
||||
motif: row.motif ?? null,
|
||||
id_enfant: child?.id ?? row.placement?.enfantId ?? null,
|
||||
prenom_enfant: child?.first_name ?? null,
|
||||
id_am: row.placement?.amId ?? null,
|
||||
prenom_am: amUser?.prenom ?? null,
|
||||
nom_am: amUser?.nom ?? null,
|
||||
cree_le: row.cree_le?.toISOString?.() ?? String(row.cree_le),
|
||||
modifie_le: row.modifie_le?.toISOString?.() ?? String(row.modifie_le),
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,2 @@
|
||||
export { EvenementsAgendaModule } from './evenements-agenda.module';
|
||||
export { EvenementsAgendaService } from './evenements-agenda.service';
|
||||
+29
-1
@@ -10,7 +10,10 @@ describe('AssistantesMaternellesController', () => {
|
||||
const authServiceMock = {
|
||||
createAmDossierStaff: jest.fn(),
|
||||
};
|
||||
const amServiceMock = {};
|
||||
const amServiceMock = {
|
||||
listerCouplesGarde: jest.fn(),
|
||||
definirCoupleGardeCourant: jest.fn(),
|
||||
};
|
||||
|
||||
beforeEach(async () => {
|
||||
const module: TestingModule = await Test.createTestingModule({
|
||||
@@ -66,4 +69,29 @@ describe('AssistantesMaternellesController', () => {
|
||||
);
|
||||
expect(res.numero_dossier).toBe('2026-000001');
|
||||
});
|
||||
|
||||
it('listerCouplesGarde délègue au service (#171)', async () => {
|
||||
amServiceMock.listerCouplesGarde.mockResolvedValue({
|
||||
couples: [],
|
||||
couple_courant_id: null,
|
||||
});
|
||||
const res = await controller.listerCouplesGarde('am-uuid');
|
||||
expect(amServiceMock.listerCouplesGarde).toHaveBeenCalledWith('am-uuid');
|
||||
expect(res.couple_courant_id).toBeNull();
|
||||
});
|
||||
|
||||
it('definirCoupleGardeCourant délègue au service (#171)', async () => {
|
||||
amServiceMock.definirCoupleGardeCourant.mockResolvedValue({
|
||||
couples: [{ id: 'pl-1', courant: true }],
|
||||
couple_courant_id: 'pl-1',
|
||||
});
|
||||
const res = await controller.definirCoupleGardeCourant('am-uuid', {
|
||||
couple_id: 'pl-1',
|
||||
});
|
||||
expect(amServiceMock.definirCoupleGardeCourant).toHaveBeenCalledWith(
|
||||
'am-uuid',
|
||||
'pl-1',
|
||||
);
|
||||
expect(res.couple_courant_id).toBe('pl-1');
|
||||
});
|
||||
});
|
||||
|
||||
@@ -2,6 +2,7 @@ import {
|
||||
Controller,
|
||||
Get,
|
||||
Post,
|
||||
Put,
|
||||
Body,
|
||||
Patch,
|
||||
Param,
|
||||
@@ -20,6 +21,8 @@ import { UpdateAssistanteDto } from '../user/dto/update_assistante.dto';
|
||||
import { UpdateAmFicheAdminDto } from './dto/update-am-fiche-admin.dto';
|
||||
import { StaffCreateAmDossierDto } from './dto/staff-create-am-dossier.dto';
|
||||
import { StaffCreateAmDossierResponseDto } from './dto/staff-create-am-dossier-response.dto';
|
||||
import { CouplesGardeAmResponseDto } from './dto/couples-garde-am.dto';
|
||||
import { DefinirCoupleGardeCourantAmDto } from './dto/definir-couple-garde-courant-am.dto';
|
||||
import { RolesGuard } from 'src/common/guards/roles.guard';
|
||||
import { AuthGuard } from 'src/common/guards/auth.guard';
|
||||
import { User } from 'src/common/decorators/user.decorator';
|
||||
@@ -83,6 +86,36 @@ export class AssistantesMaternellesController {
|
||||
return mapAmsForApi(ams);
|
||||
}
|
||||
|
||||
@Get('me/couples-garde')
|
||||
@Roles(RoleType.ASSISTANTE_MATERNELLE)
|
||||
@ApiOperation({
|
||||
summary: 'Couples de garde de l’AM connectée — ticket #171',
|
||||
description:
|
||||
'Placements actifs (enfant + parents) pour peupler le bandeau couple TdB AM, ' +
|
||||
'avec indication du couple courant.',
|
||||
})
|
||||
@ApiResponse({ status: 200, type: CouplesGardeAmResponseDto })
|
||||
listerCouplesGarde(
|
||||
@User('id') userId: string,
|
||||
): Promise<CouplesGardeAmResponseDto> {
|
||||
return this.assistantesMaternellesService.listerCouplesGarde(userId);
|
||||
}
|
||||
|
||||
@Put('me/couples-garde/courant')
|
||||
@Roles(RoleType.ASSISTANTE_MATERNELLE)
|
||||
@ApiOperation({ summary: 'Définir le couple de garde courant (AM) — ticket #171' })
|
||||
@ApiBody({ type: DefinirCoupleGardeCourantAmDto })
|
||||
@ApiResponse({ status: 200, type: CouplesGardeAmResponseDto })
|
||||
definirCoupleGardeCourant(
|
||||
@User('id') userId: string,
|
||||
@Body() dto: DefinirCoupleGardeCourantAmDto,
|
||||
): Promise<CouplesGardeAmResponseDto> {
|
||||
return this.assistantesMaternellesService.definirCoupleGardeCourant(
|
||||
userId,
|
||||
dto.couple_id,
|
||||
);
|
||||
}
|
||||
|
||||
@Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE, RoleType.ADMINISTRATEUR)
|
||||
@Get(':id')
|
||||
@ApiParam({ name: 'id', description: "UUID de la nounou" })
|
||||
|
||||
@@ -4,13 +4,21 @@ import { AssistantesMaternellesController } from './assistantes_maternelles.cont
|
||||
import { AssistanteMaternelle } from 'src/entities/assistantes_maternelles.entity';
|
||||
import { AmChildren } from 'src/entities/am_children.entity';
|
||||
import { Children } from 'src/entities/children.entity';
|
||||
import { ParentsChildren } from 'src/entities/parents_children.entity';
|
||||
import { TypeOrmModule } from '@nestjs/typeorm';
|
||||
import { Users } from 'src/entities/users.entity';
|
||||
import { AuthModule } from '../auth/auth.module';
|
||||
|
||||
@Module({
|
||||
imports: [TypeOrmModule.forFeature([AssistanteMaternelle, AmChildren, Children, Users]),
|
||||
AuthModule
|
||||
imports: [
|
||||
TypeOrmModule.forFeature([
|
||||
AssistanteMaternelle,
|
||||
AmChildren,
|
||||
Children,
|
||||
Users,
|
||||
ParentsChildren,
|
||||
]),
|
||||
AuthModule,
|
||||
],
|
||||
controllers: [AssistantesMaternellesController],
|
||||
providers: [AssistantesMaternellesService],
|
||||
@@ -19,4 +27,4 @@ import { AuthModule } from '../auth/auth.module';
|
||||
TypeOrmModule,
|
||||
],
|
||||
})
|
||||
export class AssistantesMaternellesModule { }
|
||||
export class AssistantesMaternellesModule {}
|
||||
|
||||
+138
-6
@@ -1,18 +1,150 @@
|
||||
import { NotFoundException } from '@nestjs/common';
|
||||
import { Test, TestingModule } from '@nestjs/testing';
|
||||
import { getRepositoryToken } from '@nestjs/typeorm';
|
||||
import { AssistantesMaternellesService } from './assistantes_maternelles.service';
|
||||
import { AssistanteMaternelle } from 'src/entities/assistantes_maternelles.entity';
|
||||
import { Users } from 'src/entities/users.entity';
|
||||
import { AmChildren } from 'src/entities/am_children.entity';
|
||||
import { Children } from 'src/entities/children.entity';
|
||||
import { ParentsChildren } from 'src/entities/parents_children.entity';
|
||||
|
||||
describe('AssistantesMaternellesService', () => {
|
||||
describe('AssistantesMaternellesService — couples de garde (#171)', () => {
|
||||
let service: AssistantesMaternellesService;
|
||||
|
||||
beforeEach(async () => {
|
||||
const module: TestingModule = await Test.createTestingModule({
|
||||
providers: [AssistantesMaternellesService],
|
||||
}).compile();
|
||||
const amRepo = { findOne: jest.fn(), update: jest.fn() };
|
||||
const usersRepo = {};
|
||||
const amChildrenRepo = { find: jest.fn(), findOne: jest.fn() };
|
||||
const childrenRepo = {};
|
||||
const parentsChildrenRepo = { find: jest.fn() };
|
||||
|
||||
service = module.get<AssistantesMaternellesService>(AssistantesMaternellesService);
|
||||
beforeEach(async () => {
|
||||
jest.clearAllMocks();
|
||||
const module: TestingModule = await Test.createTestingModule({
|
||||
providers: [
|
||||
AssistantesMaternellesService,
|
||||
{ provide: getRepositoryToken(AssistanteMaternelle), useValue: amRepo },
|
||||
{ provide: getRepositoryToken(Users), useValue: usersRepo },
|
||||
{ provide: getRepositoryToken(AmChildren), useValue: amChildrenRepo },
|
||||
{ provide: getRepositoryToken(Children), useValue: childrenRepo },
|
||||
{
|
||||
provide: getRepositoryToken(ParentsChildren),
|
||||
useValue: parentsChildrenRepo,
|
||||
},
|
||||
],
|
||||
}).compile();
|
||||
service = module.get(AssistantesMaternellesService);
|
||||
});
|
||||
|
||||
it('should be defined', () => {
|
||||
expect(service).toBeDefined();
|
||||
});
|
||||
|
||||
describe('listerCouplesGarde', () => {
|
||||
it('retourne vide si aucun placement', async () => {
|
||||
amRepo.findOne.mockResolvedValue({
|
||||
user_id: 'am-1',
|
||||
id_placement_garde_courant: null,
|
||||
});
|
||||
amChildrenRepo.find.mockResolvedValue([]);
|
||||
const res = await service.listerCouplesGarde('am-1');
|
||||
expect(res).toEqual({ couples: [], couple_courant_id: null });
|
||||
expect(parentsChildrenRepo.find).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('mappe placements + parents et marque le courant', async () => {
|
||||
amRepo.findOne.mockResolvedValue({
|
||||
user_id: 'am-1',
|
||||
id_placement_garde_courant: 'pl-2',
|
||||
});
|
||||
amChildrenRepo.find.mockResolvedValue([
|
||||
{
|
||||
id: 'pl-1',
|
||||
enfantId: 'e1',
|
||||
child: { id: 'e1', first_name: 'Léa', last_name: 'M', photo_url: null },
|
||||
},
|
||||
{
|
||||
id: 'pl-2',
|
||||
enfantId: 'e2',
|
||||
child: { id: 'e2', first_name: 'Emma', last_name: 'M', photo_url: null },
|
||||
},
|
||||
]);
|
||||
parentsChildrenRepo.find.mockResolvedValue([
|
||||
{
|
||||
parentId: 'p1',
|
||||
enfantId: 'e1',
|
||||
parent: { user: { prenom: 'Claire', nom: 'Martin', photo_url: null } },
|
||||
},
|
||||
{
|
||||
parentId: 'p2',
|
||||
enfantId: 'e1',
|
||||
parent: { user: { prenom: 'Thomas', nom: 'Martin', photo_url: null } },
|
||||
},
|
||||
{
|
||||
parentId: 'p1',
|
||||
enfantId: 'e2',
|
||||
parent: { user: { prenom: 'Claire', nom: 'Martin', photo_url: null } },
|
||||
},
|
||||
]);
|
||||
|
||||
const res = await service.listerCouplesGarde('am-1');
|
||||
expect(res.couples).toHaveLength(2);
|
||||
expect(res.couple_courant_id).toBe('pl-2');
|
||||
expect(res.couples[1].courant).toBe(true);
|
||||
expect(res.couples[0].parents).toHaveLength(2);
|
||||
expect(res.couples[0].parents[0].prenom).toBe('Claire');
|
||||
expect(res.couples[0].enfant.prenom).toBe('Léa');
|
||||
});
|
||||
|
||||
it('404 si AM inconnue', async () => {
|
||||
amRepo.findOne.mockResolvedValue(null);
|
||||
await expect(service.listerCouplesGarde('x')).rejects.toBeInstanceOf(
|
||||
NotFoundException,
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('definirCoupleGardeCourant', () => {
|
||||
it('persiste si le placement appartient à l’AM', async () => {
|
||||
amRepo.findOne.mockResolvedValue({
|
||||
user_id: 'am-1',
|
||||
id_placement_garde_courant: null,
|
||||
});
|
||||
amChildrenRepo.findOne.mockResolvedValue({
|
||||
id: 'pl-1',
|
||||
amId: 'am-1',
|
||||
enfantId: 'e1',
|
||||
});
|
||||
amRepo.update.mockResolvedValue({ affected: 1 });
|
||||
amChildrenRepo.find.mockResolvedValue([
|
||||
{
|
||||
id: 'pl-1',
|
||||
enfantId: 'e1',
|
||||
child: { id: 'e1', first_name: 'Léa', last_name: null, photo_url: null },
|
||||
},
|
||||
]);
|
||||
parentsChildrenRepo.find.mockResolvedValue([
|
||||
{
|
||||
parentId: 'p1',
|
||||
enfantId: 'e1',
|
||||
parent: { user: { prenom: 'Claire', nom: 'M', photo_url: null } },
|
||||
},
|
||||
]);
|
||||
|
||||
const res = await service.definirCoupleGardeCourant('am-1', 'pl-1');
|
||||
expect(amRepo.update).toHaveBeenCalledWith(
|
||||
{ user_id: 'am-1' },
|
||||
{ id_placement_garde_courant: 'pl-1' },
|
||||
);
|
||||
expect(res.couple_courant_id).toBe('pl-1');
|
||||
expect(res.couples[0].courant).toBe(true);
|
||||
});
|
||||
|
||||
it('404 si placement d’une autre AM', async () => {
|
||||
amRepo.findOne.mockResolvedValue({ user_id: 'am-1' });
|
||||
amChildrenRepo.findOne.mockResolvedValue(null);
|
||||
await expect(
|
||||
service.definirCoupleGardeCourant('am-1', 'pl-x'),
|
||||
).rejects.toBeInstanceOf(NotFoundException);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
@@ -5,14 +5,16 @@ import {
|
||||
NotFoundException,
|
||||
} from '@nestjs/common';
|
||||
import { InjectRepository } from '@nestjs/typeorm';
|
||||
import { IsNull, Repository } from 'typeorm';
|
||||
import { In, IsNull, Repository } from 'typeorm';
|
||||
import { RoleType, Users } from 'src/entities/users.entity';
|
||||
import { AssistanteMaternelle } from 'src/entities/assistantes_maternelles.entity';
|
||||
import { AmChildren } from 'src/entities/am_children.entity';
|
||||
import { Children, StatutEnfantType } from 'src/entities/children.entity';
|
||||
import { ParentsChildren } from 'src/entities/parents_children.entity';
|
||||
import { CreateAssistanteDto } from '../user/dto/create_assistante.dto';
|
||||
import { UpdateAssistanteDto } from '../user/dto/update_assistante.dto';
|
||||
import { UpdateAmFicheAdminDto } from './dto/update-am-fiche-admin.dto';
|
||||
import { CouplesGardeAmResponseDto } from './dto/couples-garde-am.dto';
|
||||
import { validateNir } from 'src/common/utils/nir.util';
|
||||
|
||||
const AM_CHILDREN_RELATIONS = ['user', 'amChildren', 'amChildren.child'] as const;
|
||||
@@ -28,6 +30,8 @@ export class AssistantesMaternellesService {
|
||||
private readonly amChildrenRepository: Repository<AmChildren>,
|
||||
@InjectRepository(Children)
|
||||
private readonly childrenRepository: Repository<Children>,
|
||||
@InjectRepository(ParentsChildren)
|
||||
private readonly parentsChildrenRepository: Repository<ParentsChildren>,
|
||||
) {}
|
||||
|
||||
async create(dto: CreateAssistanteDto): Promise<AssistanteMaternelle> {
|
||||
@@ -264,4 +268,107 @@ export class AssistantesMaternellesService {
|
||||
await this.assistantesMaternelleRepository.delete(id);
|
||||
return { message: 'Assistante maternelle supprimée' };
|
||||
}
|
||||
|
||||
/**
|
||||
* Liste les couples de garde (enfant ↔ parents) de l’AM connectée — ticket #171.
|
||||
* Un couple = un placement actif dans enfants_assistantes_maternelles pour cette AM.
|
||||
*/
|
||||
async listerCouplesGarde(amUserId: string): Promise<CouplesGardeAmResponseDto> {
|
||||
const am = await this.assistantesMaternelleRepository.findOne({
|
||||
where: { user_id: amUserId },
|
||||
});
|
||||
if (!am) {
|
||||
throw new NotFoundException('Assistante maternelle introuvable');
|
||||
}
|
||||
|
||||
const placements = await this.amChildrenRepository.find({
|
||||
where: { amId: amUserId, date_fin: IsNull() },
|
||||
relations: ['child'],
|
||||
order: { date_debut: 'ASC' },
|
||||
});
|
||||
|
||||
if (placements.length === 0) {
|
||||
return { couples: [], couple_courant_id: null };
|
||||
}
|
||||
|
||||
const enfantIds = placements.map((p) => p.enfantId);
|
||||
const liens = await this.parentsChildrenRepository.find({
|
||||
where: { enfantId: In(enfantIds) },
|
||||
relations: ['parent', 'parent.user'],
|
||||
});
|
||||
const parentsByEnfant = new Map<
|
||||
string,
|
||||
{ id: string; prenom: string | null; nom: string | null; photo_url: string | null }[]
|
||||
>();
|
||||
for (const l of liens) {
|
||||
const list = parentsByEnfant.get(l.enfantId) ?? [];
|
||||
const u = l.parent?.user;
|
||||
list.push({
|
||||
id: l.parentId,
|
||||
prenom: u?.prenom ?? null,
|
||||
nom: u?.nom ?? null,
|
||||
photo_url: u?.photo_url ?? null,
|
||||
});
|
||||
parentsByEnfant.set(l.enfantId, list);
|
||||
}
|
||||
|
||||
let idCourant = am.id_placement_garde_courant ?? null;
|
||||
const idsValides = new Set(placements.map((p) => p.id));
|
||||
if (idCourant && !idsValides.has(idCourant)) {
|
||||
idCourant = null;
|
||||
await this.assistantesMaternelleRepository.update(
|
||||
{ user_id: amUserId },
|
||||
{ id_placement_garde_courant: () => 'NULL' },
|
||||
);
|
||||
}
|
||||
if (!idCourant && placements.length === 1) {
|
||||
idCourant = placements[0].id;
|
||||
}
|
||||
|
||||
const couples = placements.map((p) => ({
|
||||
id: p.id,
|
||||
enfant: {
|
||||
id: p.child.id,
|
||||
prenom: p.child.first_name ?? null,
|
||||
nom: p.child.last_name ?? null,
|
||||
photo_url: p.child.photo_url ?? null,
|
||||
},
|
||||
parents: parentsByEnfant.get(p.enfantId) ?? [],
|
||||
courant: idCourant != null && p.id === idCourant,
|
||||
}));
|
||||
|
||||
return {
|
||||
couples,
|
||||
couple_courant_id: idCourant,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Persiste le couple de garde actif pour l’AM — ticket #171.
|
||||
*/
|
||||
async definirCoupleGardeCourant(
|
||||
amUserId: string,
|
||||
coupleId: string,
|
||||
): Promise<CouplesGardeAmResponseDto> {
|
||||
const am = await this.assistantesMaternelleRepository.findOne({
|
||||
where: { user_id: amUserId },
|
||||
});
|
||||
if (!am) {
|
||||
throw new NotFoundException('Assistante maternelle introuvable');
|
||||
}
|
||||
|
||||
const placement = await this.amChildrenRepository.findOne({
|
||||
where: { id: coupleId, amId: amUserId, date_fin: IsNull() },
|
||||
});
|
||||
if (!placement) {
|
||||
throw new NotFoundException('Couple de garde introuvable ou inactif pour cette AM');
|
||||
}
|
||||
|
||||
await this.assistantesMaternelleRepository.update(
|
||||
{ user_id: amUserId },
|
||||
{ id_placement_garde_courant: coupleId },
|
||||
);
|
||||
|
||||
return this.listerCouplesGarde(amUserId);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,67 @@
|
||||
import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
|
||||
|
||||
/** Identité minimale enfant — ticket #171 (miroir #168) */
|
||||
export class CoupleGardeAmEnfantDto {
|
||||
@ApiProperty({ format: 'uuid' })
|
||||
id: string;
|
||||
|
||||
@ApiPropertyOptional()
|
||||
prenom?: string | null;
|
||||
|
||||
@ApiPropertyOptional()
|
||||
nom?: string | null;
|
||||
|
||||
@ApiPropertyOptional()
|
||||
photo_url?: string | null;
|
||||
}
|
||||
|
||||
/** Identité minimale parent pour bandeau AM — ticket #171 */
|
||||
export class CoupleGardeAmParentDto {
|
||||
@ApiProperty({ format: 'uuid', description: 'UUID utilisateur du parent' })
|
||||
id: string;
|
||||
|
||||
@ApiPropertyOptional()
|
||||
prenom?: string | null;
|
||||
|
||||
@ApiPropertyOptional()
|
||||
nom?: string | null;
|
||||
|
||||
@ApiPropertyOptional()
|
||||
photo_url?: string | null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Un couple côté AM = placement actif enfant ↔ foyer parents.
|
||||
* `id` = enfants_assistantes_maternelles.id (même clé que #168).
|
||||
*/
|
||||
export class CoupleGardeAmDto {
|
||||
@ApiProperty({
|
||||
format: 'uuid',
|
||||
description: 'Id du placement (enfants_assistantes_maternelles.id)',
|
||||
})
|
||||
id: string;
|
||||
|
||||
@ApiProperty({ type: CoupleGardeAmEnfantDto })
|
||||
enfant: CoupleGardeAmEnfantDto;
|
||||
|
||||
@ApiProperty({
|
||||
type: [CoupleGardeAmParentDto],
|
||||
description: 'Parents rattachés à l’enfant (0–2 typiquement)',
|
||||
})
|
||||
parents: CoupleGardeAmParentDto[];
|
||||
|
||||
@ApiProperty({ description: 'True si c’est le couple actuellement sélectionné' })
|
||||
courant: boolean;
|
||||
}
|
||||
|
||||
export class CouplesGardeAmResponseDto {
|
||||
@ApiProperty({ type: [CoupleGardeAmDto] })
|
||||
couples: CoupleGardeAmDto[];
|
||||
|
||||
@ApiPropertyOptional({
|
||||
format: 'uuid',
|
||||
nullable: true,
|
||||
description: 'Id du couple courant (null si aucun)',
|
||||
})
|
||||
couple_courant_id: string | null;
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
import { ApiProperty } from '@nestjs/swagger';
|
||||
import { IsNotEmpty, IsUUID } from 'class-validator';
|
||||
|
||||
/** Corps PUT couple de garde courant AM — ticket #171 */
|
||||
export class DefinirCoupleGardeCourantAmDto {
|
||||
@ApiProperty({
|
||||
format: 'uuid',
|
||||
description: 'Id du placement (enfants_assistantes_maternelles.id) à sélectionner',
|
||||
})
|
||||
@IsUUID()
|
||||
@IsNotEmpty()
|
||||
couple_id: string;
|
||||
}
|
||||
Reference in New Issue
Block a user