Added registrar + fixed sign bug in car-body flow

src/claim-request-management/claim-request-management.module.ts

@@ -6,6 +6,7 @@ import { RequestManagementModule } from "src/request-management/request-manageme
 import { UsersModule } from "src/users/users.module";
 import { ClaimRequestManagementController } from "./claim-request-management.controller";
 import { ClaimRequestManagementV2Controller } from "./claim-request-management.v2.controller";
+import { RegistrarClaimV1Controller } from "./registrar-claim.v1.controller";
 import { ClaimRequestManagementService } from "./claim-request-management.service";
 import { CarGreenCardDbService } from "./entites/db-service/car-green-card.db.service";
 import { ClaimRequestManagementDbService } from "./entites/db-service/claim-request-management.db.service";
@@ -85,7 +86,11 @@ import { JwtModule } from "@nestjs/jwt";
     ClaimRequiredDocumentDbService,
     ClaimAccessGuard,
   ],
-  controllers: [ClaimRequestManagementController, ClaimRequestManagementV2Controller],
+  controllers: [
+    ClaimRequestManagementController,
+    ClaimRequestManagementV2Controller,
+    RegistrarClaimV1Controller,
+  ],
   exports: [
     ClaimRequestManagementService,
     ClaimRequestManagementDbService,

src/claim-request-management/claim-request-management.service.ts

@@ -2996,25 +2996,130 @@ export class ClaimRequestManagementService {
     currentUserId: string,
     actorRole?: string,
   ): Promise<string> {
-    if (actorRole !== RoleEnum.FIELD_EXPERT || !claimCase?.blameRequestId) {
+    if (
+      ![RoleEnum.FIELD_EXPERT, RoleEnum.REGISTRAR].includes(actorRole as any) ||
+      !claimCase?.blameRequestId
+    ) {
       return currentUserId;
     }
     const blameRequest = await this.blameRequestDbService.findById(
       claimCase.blameRequestId.toString(),
     );
-    if (
-      !blameRequest?.expertInitiated ||
-      blameRequest.creationMethod !== "IN_PERSON" ||
-      !blameRequest.initiatedByFieldExpertId
-    ) {
-      return currentUserId;
-    }
-    if (String(blameRequest.initiatedByFieldExpertId) !== currentUserId) {
-      return currentUserId;
+    if (!blameRequest || blameRequest.creationMethod !== "IN_PERSON") return currentUserId;
+    if (actorRole === RoleEnum.FIELD_EXPERT) {
+      if (
+        !blameRequest.expertInitiated ||
+        !blameRequest.initiatedByFieldExpertId ||
+        String(blameRequest.initiatedByFieldExpertId) !== currentUserId
+      ) {
+        return currentUserId;
+      }
+    } else {
+      if (
+        !blameRequest.registrarInitiated ||
+        !blameRequest.initiatedByRegistrarId ||
+        String(blameRequest.initiatedByRegistrarId) !== currentUserId
+      ) {
+        return currentUserId;
+      }
     }
     return claimCase.owner?.userId ? String(claimCase.owner.userId) : currentUserId;
   }
 
+  async createClaimFromBlameForRegistrarV1(
+    blameRequestId: string,
+    registrar: { sub: string; firstName?: string; lastName?: string },
+  ): Promise<CreateClaimFromBlameResponseDto> {
+    const blameRequest = await this.blameRequestDbService.findById(blameRequestId);
+    if (!blameRequest) throw new NotFoundException("Blame request not found");
+    if (blameRequest.status !== BlameCaseStatus.COMPLETED) {
+      throw new BadRequestException(
+        `Blame request must be COMPLETED. Current status: ${blameRequest.status}`,
+      );
+    }
+    if (
+      !blameRequest.registrarInitiated ||
+      blameRequest.creationMethod !== "IN_PERSON" ||
+      !blameRequest.initiatedByRegistrarId
+    ) {
+      throw new BadRequestException(
+        "This endpoint is only for registrar-initiated IN_PERSON blame files.",
+      );
+    }
+    if (String(blameRequest.initiatedByRegistrarId) !== String(registrar.sub)) {
+      throw new ForbiddenException(
+        "Only the registrar who created this blame file can create the claim.",
+      );
+    }
+    const parties = blameRequest.parties || [];
+    const isCarBody = blameRequest.type === BlameRequestType.CAR_BODY;
+    let damagedUserId: string;
+    if (isCarBody) {
+      const first = parties.find((p) => p.role === "FIRST");
+      if (!first?.person?.userId) throw new BadRequestException("First party has no userId");
+      damagedUserId = String(first.person.userId);
+    } else {
+      const guiltyPartyId = blameRequest.expert?.decision?.guiltyPartyId
+        ? String(blameRequest.expert.decision.guiltyPartyId)
+        : null;
+      if (!guiltyPartyId) throw new BadRequestException("Blame request has no guilty party set");
+      const damagedParty = parties.find(
+        (p) => p.person?.userId && String(p.person.userId) !== guiltyPartyId,
+      );
+      if (!damagedParty?.person?.userId) throw new BadRequestException("Could not determine damaged party");
+      damagedUserId = String(damagedParty.person.userId);
+    }
+    const existingClaim = await this.claimCaseDbService.findOne({
+      blameRequestId: new Types.ObjectId(blameRequestId),
+    });
+    if (existingClaim) throw new ConflictException("A claim for this blame case already exists");
+    const claimNo = await this.generateUniqueClaimNumber();
+    const damagedParty = parties.find(
+      (p) => p.person?.userId && String(p.person.userId) === damagedUserId,
+    );
+    const newClaim = await this.claimCaseDbService.create({
+      requestNo: claimNo,
+      publicId: blameRequest.publicId,
+      blameRequestId: new Types.ObjectId(blameRequestId),
+      blameRequestNo: blameRequest.requestNo,
+      status: ClaimCaseStatus.SELECTING_OUTER_PARTS,
+      claimStatus: ClaimStatus.PENDING,
+      workflow: {
+        currentStep: ClaimWorkflowStep.SELECT_OUTER_PARTS,
+        nextStep: ClaimWorkflowStep.SELECT_OTHER_PARTS,
+        completedSteps: [ClaimWorkflowStep.CLAIM_CREATED],
+        locked: false,
+      },
+      owner: {
+        userId: new Types.ObjectId(damagedUserId),
+        userRole: damagedParty?.role as any,
+      },
+      createdByRegistrarId: new Types.ObjectId(registrar.sub),
+      history: [
+        {
+          type: "CLAIM_CREATED",
+          actor: {
+            actorId: new Types.ObjectId(registrar.sub),
+            actorName: `${registrar.firstName || ""} ${registrar.lastName || ""}`.trim(),
+            actorType: "registrar",
+          },
+          timestamp: new Date(),
+          metadata: {
+            blameRequestId,
+            blamePublicId: blameRequest.publicId,
+            createdByRegistrar: true,
+          },
+        },
+      ],
+    } as any);
+    return {
+      claimRequestId: String(newClaim._id),
+      publicId: blameRequest.publicId,
+      status: ClaimCaseStatus.SELECTING_OUTER_PARTS,
+      message: "Claim created successfully. Registrar can now fill claim data.",
+    };
+  }
+
   /**
    * V2 API: Select damaged outer car parts for claim (Step 2 of claim workflow)
    * 

src/claim-request-management/entites/schema/claim-cases.schema.ts

@@ -133,6 +133,9 @@ export class ClaimCase {
   @Prop({ type: [HistoryEventSchema], default: [] })
   history?: HistoryEvent[];
 
+  @Prop({ type: Types.ObjectId, index: true })
+  createdByRegistrarId?: Types.ObjectId;
+
   /**
    * Legacy fields kept optional to simplify progressive migration.
    * If you choose to migrate later, we can remove these.

src/claim-request-management/registrar-claim.v1.controller.ts

@@ -0,0 +1,135 @@
+import { Body, Controller, Get, Param, Patch, Post, UploadedFile, UseGuards, UseInterceptors } from "@nestjs/common";
+import { FileInterceptor } from "@nestjs/platform-express";
+import { diskStorage } from "multer";
+import { extname } from "path";
+import { ApiBearerAuth, ApiBody, ApiConsumes, ApiOperation, ApiParam, ApiTags } from "@nestjs/swagger";
+import { LocalActorAuthGuard } from "src/auth/guards/actor-local.guard";
+import { RolesGuard } from "src/auth/guards/role.guard";
+import { Roles } from "src/decorators/roles.decorator";
+import { CurrentUser } from "src/decorators/user.decorator";
+import { RoleEnum } from "src/Types&Enums/role.enum";
+import { SelectOuterPartsV2Dto } from "./dto/select-outer-parts-v2.dto";
+import { SelectOtherPartsV2Dto } from "./dto/select-other-parts-v2.dto";
+import { UploadRequiredDocumentV2Dto } from "./dto/upload-document-v2.dto";
+import { CapturePartV2Dto } from "./dto/capture-part-v2.dto";
+import { ClaimRequestManagementService } from "./claim-request-management.service";
+
+@ApiTags("registrar-claim (v1)")
+@Controller("registrar-claim")
+@ApiBearerAuth()
+@UseGuards(LocalActorAuthGuard, RolesGuard)
+@Roles(RoleEnum.REGISTRAR)
+export class RegistrarClaimV1Controller {
+  constructor(private readonly claimRequestManagementService: ClaimRequestManagementService) {}
+
+  @Post("create-from-blame/:blameRequestId")
+  @ApiParam({ name: "blameRequestId" })
+  createFromBlame(@Param("blameRequestId") blameRequestId: string, @CurrentUser() registrar: any) {
+    return this.claimRequestManagementService.createClaimFromBlameForRegistrarV1(
+      blameRequestId,
+      registrar,
+    );
+  }
+
+  @Get("request/:claimRequestId")
+  getClaim(@Param("claimRequestId") claimRequestId: string, @CurrentUser() registrar: any) {
+    return this.claimRequestManagementService.getClaimDetailsV2(
+      claimRequestId,
+      registrar.sub,
+      registrar,
+    );
+  }
+
+  @Patch("select-outer-parts/:claimRequestId")
+  @ApiBody({ type: SelectOuterPartsV2Dto })
+  selectOuter(
+    @Param("claimRequestId") claimRequestId: string,
+    @Body() body: SelectOuterPartsV2Dto,
+    @CurrentUser() registrar: any,
+  ) {
+    return this.claimRequestManagementService.selectOuterPartsV2(
+      claimRequestId,
+      body,
+      registrar.sub,
+      registrar,
+    );
+  }
+
+  @Patch("select-other-parts/:claimRequestId")
+  @ApiBody({ type: SelectOtherPartsV2Dto })
+  selectOther(
+    @Param("claimRequestId") claimRequestId: string,
+    @Body() body: SelectOtherPartsV2Dto,
+    @CurrentUser() registrar: any,
+  ) {
+    return this.claimRequestManagementService.selectOtherPartsV2(
+      claimRequestId,
+      body,
+      registrar.sub,
+      registrar,
+    );
+  }
+
+  @Get("capture-requirements/:claimRequestId")
+  getCapture(@Param("claimRequestId") claimRequestId: string, @CurrentUser() registrar: any) {
+    return this.claimRequestManagementService.getCaptureRequirementsV2(
+      claimRequestId,
+      registrar.sub,
+      registrar,
+    );
+  }
+
+  @Post("upload-document/:claimRequestId")
+  @ApiConsumes("multipart/form-data")
+  @UseInterceptors(
+    FileInterceptor("file", {
+      limits: { fileSize: 10 * 1024 * 1024 },
+      storage: diskStorage({
+        destination: "./files/claim-documents",
+        filename: (req, file, cb) => cb(null, `${Date.now()}${extname(file.originalname)}`),
+      }),
+    }),
+  )
+  @ApiOperation({ summary: "Registrar uploads required claim document" })
+  uploadDoc(
+    @Param("claimRequestId") claimRequestId: string,
+    @Body() body: UploadRequiredDocumentV2Dto,
+    @UploadedFile() file: Express.Multer.File,
+    @CurrentUser() registrar: any,
+  ) {
+    return this.claimRequestManagementService.uploadRequiredDocumentV2(
+      claimRequestId,
+      body,
+      file,
+      registrar.sub,
+      registrar,
+    );
+  }
+
+  @Post("capture-part/:claimRequestId")
+  @ApiConsumes("multipart/form-data")
+  @UseInterceptors(
+    FileInterceptor("file", {
+      limits: { fileSize: 10 * 1024 * 1024 },
+      storage: diskStorage({
+        destination: "./files/claim-captures",
+        filename: (req, file, cb) => cb(null, `${Date.now()}${extname(file.originalname)}`),
+      }),
+    }),
+  )
+  capturePart(
+    @Param("claimRequestId") claimRequestId: string,
+    @Body() body: CapturePartV2Dto,
+    @UploadedFile() file: Express.Multer.File,
+    @CurrentUser() registrar: any,
+  ) {
+    return this.claimRequestManagementService.capturePartV2(
+      claimRequestId,
+      body,
+      file,
+      registrar.sub,
+      registrar,
+    );
+  }
+}
+