Merge branch 'feature/dispute-flow-test'

backend/src/dispute/dispute.controller.ts

@@ -0,0 +1,43 @@
+import { Controller, Post, Body, Get, Param, HttpStatus, HttpCode } from '@nestjs/common';
+import { DisputeService } from './dispute.service';
+import { Dispute, DisputeEvent } from '@prisma/client';
+
+@Controller('disputes')
+export class DisputeController {
+  constructor(private readonly disputeService: DisputeService) {}
+
+  @Post()
+  async createDispute(@Body() disputeData: Partial<Dispute>): Promise<Dispute> {
+    return this.disputeService.createDispute(disputeData);
+  }
+
+  @Get(':id')
+  async getDispute(@Param('id') id: number): Promise<Dispute | null> {
+    return this.disputeService.getDisputeById(id);
+  }
+
+  @Post(':id/evidence')
+  async addEvidence(
+    @Param('id') disputeId: number,
+    @Body() evidenceData: any
+  ): Promise<DisputeEvent> {
+    return this.disputeService.addEvidence(disputeId, evidenceData);
+  }
+
+  @Post(':id/status')
+  @HttpCode(HttpStatus.OK)
+  async updateStatus(
+    @Param('id') disputeId: number,
+    @Body() statusData: { status: string }
+  ): Promise<Dispute> {
+    return this.disputeService.updateDisputeStatus(disputeId, statusData.status);
+  }
+
+  @Post(':id/resolve')
+  async resolveDispute(
+    @Param('id') disputeId: number,
+    @Body() decisionData: any
+  ): Promise<Dispute> {
+    return this.disputeService.resolveDispute(disputeId, decisionData);
+  }
+}

backend/src/dispute/dispute.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { DisputeService } from './dispute.service';
+import { DisputeController } from './dispute.controller';
+import { PrismaService } from '../prisma/prisma.service';
+
+@Module({
+  controllers: [DisputeController],
+  providers: [DisputeService, PrismaService],
+  exports: [DisputeService],
+})
+export class DisputeModule {}

backend/src/dispute/dispute.service.ts

@@ -0,0 +1,56 @@
+import { Injectable } from '@nestjs/common';
+import { PrismaService } from '../prisma/prisma.service';
+import { Dispute, DisputeEvent } from '@prisma/client';
+
+@Injectable()
+export class DisputeService {
+  constructor(private prisma: PrismaService) {}
+
+  async createDispute(disputeData: Partial<Dispute>): Promise<Dispute> {
+    return this.prisma.dispute.create({
+      data: disputeData,
+    });
+  }
+
+  async getDisputeById(id: number): Promise<Dispute | null> {
+    return this.prisma.dispute.findUnique({
+      where: { id },
+    });
+  }
+
+  async updateDisputeStatus(disputeId: number, status: string): Promise<Dispute> {
+    return this.prisma.dispute.update({
+      where: { id: disputeId },
+      data: { status },
+    });
+  }
+
+  async addEvidence(disputeId: number, evidenceData: any): Promise<DisputeEvent> {
+    const event = await this.prisma.disputeEvent.create({
+      data: {
+        disputeId,
+        eventType: 'evidence',
+        actorUserId: evidenceData.actorUserId,
+        payloadJson: evidenceData.payload,
+      },
+    });
+
+    // Update dispute status to 'evidence' if not already
+    await this.updateDisputeStatus(disputeId, 'evidence');
+
+    return event;
+  }
+
+  async resolveDispute(disputeId: number, decisionData: any): Promise<Dispute> {
+    return this.prisma.dispute.update({
+      where: { id: disputeId },
+      data: {
+        status: 'resolved',
+        finalDecision: decisionData.decision,
+        finalReason: decisionData.reason,
+        decidedByUserId: decisionData.decidedByUserId,
+        decidedAt: new Date(),
+      },
+    });
+  }
+}