Criar histórico de mudanças do chamado

backend/package.json

@@ -51,6 +51,7 @@
     "@nestjs/testing": "^11.0.1",
     "@types/express": "^5.0.0",
     "@types/jest": "^30.0.0",
+    "@types/mocha": "^10.0.10",
     "@types/morgan": "^1.9.10",
     "@types/node": "^22.10.7",
     "@types/passport-jwt": "^4.0.1",

backend/src/modules/ticket/application/useCases/create/create.usecase.ts

@@ -1,8 +1,5 @@
 import { Injectable } from '@nestjs/common';
-import {
-  Ticket,
-  TicketStatus,
-} from '../../../domain/entities/ticket.entity';
+import { Ticket, TicketStatus } from '../../../domain/entities/ticket.entity';
 import { ITicketRepository } from '../../../domain/repository/ticket.repository.interface';
 import { TriageService } from '../../../../triage/application/triage.service';
 
@@ -31,9 +28,7 @@ export class CreateTicketUseCase {
   ) {}
 
   async execute(input: CreateTicketInput): Promise<CreateTicketOutput> {
-    const triageResult = await this.triageService.classify(
-      input.description,
-    );
+    const triageResult = await this.triageService.classify(input.description);
 
     const ticket = Ticket.create({
       ...input,

backend/src/modules/ticket/application/useCases/getHistoryFiltered/getHistoryFiltered.usecase.spec.ts

@@ -0,0 +1,165 @@
+import { randomUUID } from 'crypto';
+import { ITicketRepository } from '../../../domain/repository/ticket.repository.interface';
+import {
+  Ticket,
+  TicketEvents,
+  TicketStatus,
+} from '../../../domain/entities/ticket.entity';
+import { GetHistoryFilteredUseCase } from './getHistoryFiltered.usecase';
+
+describe('GetHistoryFilteredUseCase', () => {
+  let repository: jest.Mocked<ITicketRepository>;
+  let useCase: GetHistoryFilteredUseCase;
+  let ticket: Ticket;
+
+  beforeEach(() => {
+    ticket = Ticket.create({
+      title: 'titulo do ticket',
+      category: 'iot',
+      description: 'descricao do ticket',
+      clientId: randomUUID(),
+    });
+
+    repository = {
+      readById: jest.fn(),
+    } as unknown as jest.Mocked<ITicketRepository>;
+
+    useCase = new GetHistoryFilteredUseCase(repository);
+  });
+
+  it('should return full history when no filters are provided', async () => {
+    repository.readById.mockResolvedValue(ticket);
+
+    const output = await useCase.execute(
+      ticket.id,
+      TicketEvents.OPEN_NEW_TICKET,
+      {},
+    );
+
+    expect(output).toBeDefined();
+    expect(output.id).toBe(ticket.id);
+    expect(Array.isArray(output.history)).toBe(true);
+    expect(output.history).toHaveLength(1);
+    expect(output.history[0].status).toBe(TicketStatus.OPEN);
+
+    expect(repository.readById).toHaveBeenCalledTimes(1);
+    expect(repository.readById).toHaveBeenCalledWith(ticket.id);
+  });
+
+  it('should filter history by status', async () => {
+    ticket.assignToAgent(randomUUID());
+    repository.readById.mockResolvedValue(ticket);
+
+    const output = await useCase.execute(ticket.id, {
+      status: TicketStatus.IN_PROGRESS,
+    });
+
+    expect(
+      output.history.every((e) => e.status === TicketStatus.IN_PROGRESS),
+    ).toBe(true);
+    expect(output.history).toHaveLength(1);
+  });
+
+  it('should filter history by responsibleAgent', async () => {
+    const agentId = randomUUID();
+    ticket.assignToAgent(agentId);
+    repository.readById.mockResolvedValue(ticket);
+
+    const output = await useCase.execute(ticket.id, {
+      responsibleAgent: agentId,
+    });
+
+    expect(output.history.every((e) => e.responsibleAgent === agentId)).toBe(
+      true,
+    );
+    expect(output.history).toHaveLength(1);
+  });
+
+  it('should filter history by event', async () => {
+    ticket.assignToAgent(randomUUID());
+    repository.readById.mockResolvedValue(ticket);
+
+    const output = await useCase.execute(ticket.id, {
+      event: TicketEvents.NEW_AGENT,
+    });
+
+    expect(
+      output.history.every((e) => e.event === TicketEvents.NEW_AGENT),
+    ).toBe(true);
+    expect(output.history).toHaveLength(1);
+  });
+
+  it('should filter history by fromDate', async () => {
+    const before = new Date(Date.now() - 10000);
+    ticket.assignToAgent(randomUUID());
+    repository.readById.mockResolvedValue(ticket);
+
+    const output = await useCase.execute(ticket.id, {
+      fromDate: before,
+    });
+
+    expect(output.history.every((e) => e.occurredAt >= before)).toBe(true);
+    expect(output.history.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('should return empty history when fromDate is in the future', async () => {
+    const future = new Date(Date.now() + 99999999);
+    repository.readById.mockResolvedValue(ticket);
+
+    const output = await useCase.execute(ticket.id, {
+      fromDate: future,
+    });
+
+    expect(output.history).toHaveLength(0);
+  });
+
+  it('should combine multiple filters correctly', async () => {
+    const agentId = randomUUID();
+    const before = new Date(Date.now() - 10000);
+    ticket.assignToAgent(agentId);
+    repository.readById.mockResolvedValue(ticket);
+
+    const output = await useCase.execute(ticket.id, {
+      status: TicketStatus.IN_PROGRESS,
+      responsibleAgent: agentId,
+      event: TicketEvents.NEW_AGENT,
+      fromDate: before,
+    });
+
+    expect(output.history).toHaveLength(1);
+    expect(output.history[0].status).toBe(TicketStatus.IN_PROGRESS);
+    expect(output.history[0].responsibleAgent).toBe(agentId);
+    expect(output.history[0].event).toBe(TicketEvents.NEW_AGENT);
+  });
+
+  it('should return empty history when no entries match filters', async () => {
+    repository.readById.mockResolvedValue(ticket);
+
+    const output = await useCase.execute(ticket.id, {
+      status: TicketStatus.CLOSED,
+    });
+
+    expect(output.history).toHaveLength(0);
+  });
+
+  it('should throw when ticket is not found', async () => {
+    repository.readById.mockResolvedValue(null);
+
+    await expect(useCase.execute('non-existent-id', {})).rejects.toThrow(
+      'Ticket not found',
+    );
+
+    expect(repository.readById).toHaveBeenCalledWith('non-existent-id');
+  });
+
+  it('should not expose domain methods in output', async () => {
+    repository.readById.mockResolvedValue(ticket);
+
+    const output = await useCase.execute(ticket.id, {});
+
+    expect(output).not.toHaveProperty('toPrimitives');
+    expect(output).not.toHaveProperty('escalate');
+    expect(output).not.toHaveProperty('assignToAgent');
+    expect(output).not.toHaveProperty('close');
+  });
+});

backend/src/modules/ticket/application/useCases/getHistoryFiltered/getHistoryFiltered.usecase.ts

@@ -0,0 +1,67 @@
+import { Injectable } from '@nestjs/common';
+import {
+  TicketEvents,
+  TicketStatus,
+} from '../../../domain/entities/ticket.entity';
+import { ITicketRepository } from '../../../domain/repository/ticket.repository.interface';
+
+export interface TicketHistoryEntryOutput {
+  event: TicketEvents;
+  responsibleAgent: string | null;
+  status: TicketStatus;
+  message: string;
+  solution?: string | null;
+  occurredAt: Date;
+}
+
+export interface GetHistoryTicketOutput {
+  id: string;
+  history: TicketHistoryEntryOutput[];
+}
+
+@Injectable()
+export class GetHistoryFilteredUseCase {
+  constructor(private readonly repository: ITicketRepository) {}
+
+  async execute(
+    id: string,
+    filters: {
+      status?: TicketStatus;
+      responsibleAgent?: string;
+      event?: TicketEvents;
+      fromDate?: Date;
+    },
+  ): Promise<GetHistoryTicketOutput> {
+    const foundTicket = await this.repository.readById(id);
+
+    if (!foundTicket) {
+      throw new Error('Ticket not found');
+    }
+
+    let history = foundTicket.history;
+
+    if (filters.status) {
+      history = history.filter((entry) => entry.status === filters.status);
+    }
+
+    if (filters.responsibleAgent) {
+      history = history.filter(
+        (entry) => entry.responsibleAgent === filters.responsibleAgent,
+      );
+    }
+
+    if (filters.event) {
+      history = history.filter((entry) => entry.event === filters.event);
+    }
+
+    if (filters.fromDate) {
+      const fromDate = filters.fromDate;
+      history = history.filter((entry) => entry.occurredAt >= fromDate);
+    }
+
+    return {
+      id: foundTicket.id,
+      history: [...history],
+    };
+  }
+}

backend/src/modules/ticket/domain/entities/ticket.entity.ts

@@ -110,6 +110,7 @@ export class Ticket {
 
     ticket._id = randomUUID();
     ticket.createdAt = new Date();
+    ticket.priority = TicketPriority.LOW;
 
     ticket.addHistory({
       event: TicketEvents.OPEN_NEW_TICKET,
@@ -148,8 +149,6 @@ export class Ticket {
 
     ticket._id = props._id;
 
-    ticket.priority = TicketPriority.LOW;
-
     ticket._agentId = props.agentId ?? null;
     ticket._groupId = props.groupId ?? null;
     ticket.attachmentsUrls = props.fileUrls ?? [];
@@ -183,6 +182,7 @@ export class Ticket {
       createdAt: this.createdAt,
       updatedAt: this.updatedAt,
       closedAt: this.closedAt,
+      history: this.history,
     };
   }