forked from Yara724/api
502 lines
18 KiB
TypeScript
502 lines
18 KiB
TypeScript
import { extname } from "node:path";
|
||
import {
|
||
BadRequestException,
|
||
Body,
|
||
Controller,
|
||
Get,
|
||
HttpException,
|
||
InternalServerErrorException,
|
||
Param,
|
||
Patch,
|
||
Post,
|
||
Put,
|
||
UploadedFile,
|
||
UseGuards,
|
||
UseInterceptors,
|
||
} from "@nestjs/common";
|
||
import {
|
||
ApiBearerAuth,
|
||
ApiBody,
|
||
ApiConsumes,
|
||
ApiOperation,
|
||
ApiParam,
|
||
ApiTags,
|
||
} from "@nestjs/swagger";
|
||
import { FileInterceptor } from "@nestjs/platform-express";
|
||
import { diskStorage } from "multer";
|
||
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 { MediaPolicyService } from "src/media-policy/media-policy.service";
|
||
import { DEFAULT_MEDIA_MAX_BYTES } from "src/client/client.service";
|
||
import { RoleEnum } from "src/Types&Enums/role.enum";
|
||
import { ExpertAccidentFieldsDto } from "./dto/expert-accident-fields.dto";
|
||
import { RequestManagementService } from "./request-management.service";
|
||
import { ClaimRequestManagementService } from "src/claim-request-management/claim-request-management.service";
|
||
import {
|
||
SelectOuterPartsV2Dto,
|
||
SelectOuterPartsV2ResponseDto,
|
||
} from "src/claim-request-management/dto/select-outer-parts-v2.dto";
|
||
import { SelectOtherPartsV2ResponseDto } from "src/claim-request-management/dto/select-other-parts-v2.dto";
|
||
import { SelectOtherPartsV3Dto } from "src/claim-request-management/dto/select-other-parts-v3.dto";
|
||
import {
|
||
UploadRequiredDocumentV2Dto,
|
||
UploadRequiredDocumentV2ResponseDto,
|
||
} from "src/claim-request-management/dto/upload-document-v2.dto";
|
||
import {
|
||
CapturePartV2Dto,
|
||
CapturePartV2ResponseDto,
|
||
} from "src/claim-request-management/dto/capture-part-v2.dto";
|
||
import { GetCaptureRequirementsV2ResponseDto } from "src/claim-request-management/dto/capture-requirements-v2.dto";
|
||
|
||
/**
|
||
* V4 FileReviewer flow — second half of the split blame workflow.
|
||
*
|
||
* The FileReviewer picks up a sealed file (both signatures collected by the
|
||
* FileMaker) and completes the damage-assessment portion: accident fields,
|
||
* documents, part selection, photo capture, and walk-around video (final step).
|
||
*
|
||
* Sequence:
|
||
* accident-fields
|
||
* → capture-requirements (via linked claimRequestId)
|
||
* → upload-document (licenses, car cards)
|
||
* → select-outer-parts
|
||
* → select-other-parts
|
||
* → capture-part (damaged-part photos + four angles)
|
||
* → upload-document (chassis / engine — capture phase)
|
||
* → car-capture (walk-around video — FINAL FileReviewer step)
|
||
* ↳ claim → WAITING_FOR_DAMAGE_EXPERT, blame → COMPLETED
|
||
*
|
||
* NOTE: upload-video is a no-op for V4 (blame is already COMPLETED by car-capture).
|
||
*/
|
||
@ApiTags("v4 FileReviewer — blame file review & capture")
|
||
@Controller("v4/file-reviewer/blame-request-management")
|
||
@ApiBearerAuth()
|
||
@UseGuards(LocalActorAuthGuard, RolesGuard)
|
||
@Roles(RoleEnum.FILE_REVIEWER)
|
||
export class FileReviewerBlameV4Controller {
|
||
constructor(
|
||
private readonly requestManagementService: RequestManagementService,
|
||
private readonly claimRequestManagementService: ClaimRequestManagementService,
|
||
private readonly mediaPolicyService: MediaPolicyService,
|
||
) {}
|
||
|
||
// ─── Linked claim lookup ──────────────────────────────────────────────────────
|
||
|
||
@Get("my-files")
|
||
@ApiOperation({
|
||
summary: "List available and assigned FileMaker blame files",
|
||
description:
|
||
"Returns V4 FileMaker blame files in this reviewer's insurer: sealed files that are still available to claim, plus files already assigned to the authenticated FileReviewer.",
|
||
})
|
||
async getMyFiles(@CurrentUser() fileReviewer: any) {
|
||
return this.requestManagementService.getMyFileReviewerFiles(fileReviewer);
|
||
}
|
||
|
||
@Get("my-files/:requestId")
|
||
@ApiParam({ name: "requestId", description: "Blame request ID" })
|
||
@ApiOperation({
|
||
summary: "Get one available or assigned FileMaker blame file",
|
||
description:
|
||
"Returns full detail for a V4 FileMaker blame file in this reviewer's insurer when it is still available to claim or is assigned to the authenticated FileReviewer.",
|
||
})
|
||
async getMyFileDetail(
|
||
@Param("requestId") requestId: string,
|
||
@CurrentUser() fileReviewer: any,
|
||
) {
|
||
return this.requestManagementService.getMyFileReviewerFileDetail(fileReviewer, requestId);
|
||
}
|
||
|
||
@Get("claim-id/:requestId")
|
||
@ApiParam({ name: "requestId", description: "Blame request ID" })
|
||
@ApiOperation({
|
||
summary: "Get linked claim ID",
|
||
description:
|
||
"Returns the claim auto-created during FileMaker's guilty-party run-inquiries. " +
|
||
"Use this claim ID for all capture/document/parts endpoints below.",
|
||
})
|
||
async getLinkedClaimId(
|
||
@Param("requestId") requestId: string,
|
||
@CurrentUser() fileReviewer: any,
|
||
) {
|
||
return this.requestManagementService.getV3LinkedClaimForExpert(
|
||
fileReviewer,
|
||
requestId,
|
||
);
|
||
}
|
||
|
||
// ─── Accident fields ──────────────────────────────────────────────────────────
|
||
|
||
@Post("accident-fields/:requestId")
|
||
@ApiParam({ name: "requestId" })
|
||
@ApiBody({ type: ExpertAccidentFieldsDto })
|
||
@ApiOperation({
|
||
summary: "Accident type / fields (FileReviewer first step)",
|
||
description:
|
||
"Saves accident fields on the sealed file. " +
|
||
"Does not move to WAITING_FOR_EXPERT — that happens after the final blame accident video.",
|
||
})
|
||
async addAccidentFields(
|
||
@Param("requestId") requestId: string,
|
||
@Body() fields: ExpertAccidentFieldsDto,
|
||
@CurrentUser() fileReviewer: any,
|
||
) {
|
||
return this.requestManagementService.expertAddAccidentFieldsForBlameV3(
|
||
fileReviewer,
|
||
requestId,
|
||
fields,
|
||
);
|
||
}
|
||
|
||
// ─── Capture requirements ─────────────────────────────────────────────────────
|
||
|
||
@Get("capture-requirements/:claimRequestId")
|
||
@ApiParam({ name: "claimRequestId" })
|
||
@ApiOperation({
|
||
summary: "Capture requirements (step-aware)",
|
||
description:
|
||
"Initial documents phase: pre-capture docs only (no chassis/engine/metal plate). " +
|
||
"CAPTURE_PART_DAMAGES phase: damaged parts + angles via capture-part, then chassis/engine/metal plate via upload-document. " +
|
||
"Use `captureSequencePhase` and `captureSequenceHint` to drive the UI.",
|
||
})
|
||
async getCaptureRequirements(
|
||
@Param("claimRequestId") claimRequestId: string,
|
||
@CurrentUser() fileReviewer: any,
|
||
): Promise<GetCaptureRequirementsV2ResponseDto> {
|
||
return this.claimRequestManagementService.getCaptureRequirementsV3(
|
||
claimRequestId,
|
||
fileReviewer.sub,
|
||
fileReviewer,
|
||
);
|
||
}
|
||
|
||
// ─── Document upload ──────────────────────────────────────────────────────────
|
||
|
||
@Post("upload-document/:claimRequestId")
|
||
@ApiParam({ name: "claimRequestId" })
|
||
@ApiConsumes("multipart/form-data")
|
||
@UseInterceptors(
|
||
FileInterceptor("file", {
|
||
limits: { fileSize: DEFAULT_MEDIA_MAX_BYTES },
|
||
storage: diskStorage({
|
||
destination: "./files/claim-documents",
|
||
filename: (req, file, callback) => {
|
||
const unique = Date.now();
|
||
const ex = extname(file.originalname);
|
||
callback(null, `${file.originalname.split(".")[0]}-${unique}${ex}`);
|
||
},
|
||
}),
|
||
}),
|
||
)
|
||
@ApiOperation({
|
||
summary: "Upload one required claim document",
|
||
description:
|
||
"Initial phase (UPLOAD_REQUIRED_DOCUMENTS): licenses and car cards only. " +
|
||
"Capture phase (CAPTURE_PART_DAMAGES, after parts + angles): chassis, engine, metal plate only.",
|
||
})
|
||
async uploadDocument(
|
||
@Param("claimRequestId") claimRequestId: string,
|
||
@Body() body: UploadRequiredDocumentV2Dto,
|
||
@UploadedFile() file: Express.Multer.File,
|
||
@CurrentUser() fileReviewer: any,
|
||
): Promise<UploadRequiredDocumentV2ResponseDto> {
|
||
await this.mediaPolicyService.assertForClaim(file, claimRequestId, "image");
|
||
return this.claimRequestManagementService.uploadRequiredDocumentV3(
|
||
claimRequestId,
|
||
body,
|
||
file,
|
||
fileReviewer.sub,
|
||
fileReviewer,
|
||
);
|
||
}
|
||
|
||
// ─── Part selection ───────────────────────────────────────────────────────────
|
||
|
||
@Patch("select-outer-parts/:claimRequestId")
|
||
@ApiParam({ name: "claimRequestId" })
|
||
@ApiBody({ type: SelectOuterPartsV2Dto })
|
||
@ApiOperation({ summary: "Select damaged outer parts" })
|
||
async selectOuterParts(
|
||
@Param("claimRequestId") claimRequestId: string,
|
||
@Body() body: SelectOuterPartsV2Dto,
|
||
@CurrentUser() fileReviewer: any,
|
||
): Promise<SelectOuterPartsV2ResponseDto> {
|
||
return this.claimRequestManagementService.selectOuterPartsV3(
|
||
claimRequestId,
|
||
body,
|
||
fileReviewer.sub,
|
||
fileReviewer,
|
||
);
|
||
}
|
||
|
||
@Patch("select-other-parts/:claimRequestId")
|
||
@ApiParam({ name: "claimRequestId", example: "507f1f77bcf86cd799439011" })
|
||
@ApiOperation({
|
||
summary: "Select other damaged parts (V4)",
|
||
description:
|
||
"Other parts only — sheba and national code were collected during FileMaker's run-inquiries. Optional car green card file.",
|
||
})
|
||
@ApiBody({
|
||
description:
|
||
"Other parts selection. Bank info is already on the claim from run-inquiries.",
|
||
schema: {
|
||
type: "object",
|
||
properties: {
|
||
otherParts: {
|
||
oneOf: [
|
||
{
|
||
type: "array",
|
||
items: {
|
||
type: "string",
|
||
enum: [
|
||
"engine",
|
||
"suspension",
|
||
"brake_system",
|
||
"electrical",
|
||
"radiator",
|
||
"transmission",
|
||
"exhaust",
|
||
"headlight",
|
||
"taillight",
|
||
"mirror",
|
||
"glass",
|
||
],
|
||
},
|
||
},
|
||
{ type: "string", description: "JSON string array for multipart" },
|
||
],
|
||
example: ["engine", "suspension"],
|
||
},
|
||
},
|
||
},
|
||
})
|
||
async selectOtherParts(
|
||
@Param("claimRequestId") claimRequestId: string,
|
||
@Body() body: SelectOtherPartsV3Dto,
|
||
@CurrentUser() fileReviewer: any,
|
||
): Promise<SelectOtherPartsV2ResponseDto> {
|
||
return this.claimRequestManagementService.selectOtherPartsV3(
|
||
claimRequestId,
|
||
body,
|
||
fileReviewer.sub,
|
||
fileReviewer,
|
||
);
|
||
}
|
||
|
||
// ─── Photo capture ────────────────────────────────────────────────────────────
|
||
|
||
@Post("capture-part/:claimRequestId")
|
||
@ApiParam({ name: "claimRequestId", example: "507f1f77bcf86cd799439011" })
|
||
@ApiConsumes("multipart/form-data")
|
||
@UseInterceptors(
|
||
FileInterceptor("file", {
|
||
limits: { fileSize: DEFAULT_MEDIA_MAX_BYTES },
|
||
storage: diskStorage({
|
||
destination: "./files/claim-captures",
|
||
filename: (req, file, callback) => {
|
||
const unique = Date.now();
|
||
const ex = extname(file.originalname);
|
||
callback(null, `v4-capture-${unique}${ex}`);
|
||
},
|
||
}),
|
||
}),
|
||
)
|
||
@ApiOperation({
|
||
summary: "Car angles and damaged-part photos",
|
||
description:
|
||
"CAPTURE_PART_DAMAGES: (1) all damaged-part photos, (2) four car angles, " +
|
||
"(3) chassis/engine/metal-plate via upload-document. Then car-capture walk-around video.",
|
||
})
|
||
@ApiBody({
|
||
schema: {
|
||
type: "object",
|
||
required: ["captureType", "captureKey", "file"],
|
||
properties: {
|
||
captureType: {
|
||
type: "string",
|
||
enum: ["angle", "part"],
|
||
example: "angle",
|
||
},
|
||
captureKey: {
|
||
type: "string",
|
||
example: "front",
|
||
description:
|
||
"For angle: front/back/left/right. For part: hood/front_bumper/etc.",
|
||
},
|
||
file: { type: "string", format: "binary" },
|
||
},
|
||
},
|
||
})
|
||
async capturePart(
|
||
@Param("claimRequestId") claimRequestId: string,
|
||
@Body() body: CapturePartV2Dto,
|
||
@UploadedFile() file: Express.Multer.File,
|
||
@CurrentUser() fileReviewer: any,
|
||
): Promise<CapturePartV2ResponseDto> {
|
||
await this.mediaPolicyService.assertForClaim(file, claimRequestId, "image");
|
||
return this.claimRequestManagementService.capturePartV3(
|
||
claimRequestId,
|
||
body,
|
||
file,
|
||
fileReviewer.sub,
|
||
fileReviewer,
|
||
);
|
||
}
|
||
|
||
// ─── Mixed-factor priced-line signature ──────────────────────────────────────
|
||
|
||
@Put("claim-sign/:claimRequestId")
|
||
@ApiParam({ name: "claimRequestId" })
|
||
@ApiConsumes("multipart/form-data")
|
||
@ApiBody({
|
||
description: "Signature file and agreement",
|
||
schema: {
|
||
type: "object",
|
||
required: ["sign", "agree"],
|
||
properties: {
|
||
sign: { type: "string", format: "binary", description: "Signature image" },
|
||
agree: { type: "boolean", description: "true to accept, false to reject" },
|
||
},
|
||
},
|
||
})
|
||
@ApiOperation({
|
||
summary: "Priced-line acceptance before factor uploads (V4 — FileReviewer acts for user)",
|
||
description:
|
||
"For mixed priced/factor claims only, FileReviewer records the damaged party's " +
|
||
"acceptance of priced lines before factor uploads. V2–V5 no longer require a final " +
|
||
"owner signature: they complete after expert work. The FileReviewer's identity is " +
|
||
"resolved to the claim owner via `resolveClaimEffectiveUserId`.",
|
||
})
|
||
@UseInterceptors(
|
||
FileInterceptor("sign", {
|
||
limits: { fileSize: DEFAULT_MEDIA_MAX_BYTES },
|
||
storage: diskStorage({
|
||
destination: "./files/claim-sign",
|
||
filename: (req, file, callback) => {
|
||
const unique = Date.now();
|
||
const ex = extname(file.originalname);
|
||
const base = file.originalname.split(/[.,\s-]/)[0] || "sign";
|
||
callback(null, `${base}-${unique}${ex}`);
|
||
},
|
||
}),
|
||
}),
|
||
)
|
||
async submitOwnerSign(
|
||
@Param("claimRequestId") claimRequestId: string,
|
||
@Body("agree") agree: string | boolean,
|
||
@CurrentUser() fileReviewer: any,
|
||
@UploadedFile() sign: Express.Multer.File,
|
||
) {
|
||
await this.mediaPolicyService.assertForClaim(sign, claimRequestId, "image");
|
||
const agreed =
|
||
typeof agree === "string"
|
||
? agree === "true" || agree === "1"
|
||
: Boolean(agree);
|
||
try {
|
||
return await this.claimRequestManagementService.submitOwnerInsurerApprovalSignV2(
|
||
claimRequestId,
|
||
agreed,
|
||
sign,
|
||
fileReviewer.sub,
|
||
fileReviewer,
|
||
);
|
||
} catch (error) {
|
||
if (error instanceof HttpException) throw error;
|
||
throw new InternalServerErrorException(
|
||
error instanceof Error ? error.message : "Failed to submit signature",
|
||
);
|
||
}
|
||
}
|
||
|
||
// ─── Walk-around video ────────────────────────────────────────────────────────
|
||
|
||
@Patch("car-capture/:claimRequestId")
|
||
@ApiParam({ name: "claimRequestId", example: "507f1f77bcf86cd799439011" })
|
||
@ApiConsumes("multipart/form-data")
|
||
@UseInterceptors(
|
||
FileInterceptor("file", {
|
||
limits: { fileSize: DEFAULT_MEDIA_MAX_BYTES },
|
||
storage: diskStorage({
|
||
destination: "./files/car-capture-videos/",
|
||
filename: (req, file, callback) => {
|
||
const unique = Date.now();
|
||
const ex = extname(file.originalname);
|
||
callback(null, `v4-claim-video-${unique}${ex}`);
|
||
},
|
||
}),
|
||
}),
|
||
)
|
||
@ApiBody({
|
||
schema: {
|
||
type: "object",
|
||
required: ["file"],
|
||
properties: { file: { type: "string", format: "binary" } },
|
||
},
|
||
})
|
||
@ApiOperation({
|
||
summary: "Walk-around video (final FileReviewer step — V4)",
|
||
description:
|
||
"Last FileReviewer action. Upload after capture-part is complete (parts, angles, chassis/engine docs). " +
|
||
"Finalises the claim → WAITING_FOR_DAMAGE_EXPERT and marks the blame as COMPLETED.",
|
||
})
|
||
async carCapture(
|
||
@Param("claimRequestId") claimRequestId: string,
|
||
@UploadedFile("file") file: Express.Multer.File,
|
||
@CurrentUser() fileReviewer: any,
|
||
) {
|
||
await this.mediaPolicyService.assertForClaim(file, claimRequestId, "video");
|
||
return this.claimRequestManagementService.setVideoCaptureV3(
|
||
claimRequestId,
|
||
file,
|
||
fileReviewer.sub,
|
||
fileReviewer,
|
||
);
|
||
}
|
||
|
||
// ─── Final blame video ────────────────────────────────────────────────────────
|
||
|
||
@ApiBody({
|
||
schema: {
|
||
type: "object",
|
||
properties: { file: { type: "string", format: "binary" } },
|
||
},
|
||
})
|
||
@ApiConsumes("multipart/form-data")
|
||
@UseInterceptors(
|
||
FileInterceptor("file", {
|
||
limits: { fileSize: DEFAULT_MEDIA_MAX_BYTES },
|
||
storage: diskStorage({
|
||
destination: "./files/video",
|
||
filename: (req, file, callback) => {
|
||
const unique = Date.now();
|
||
const ex = extname(file.originalname);
|
||
callback(null, `v4-blame-accident-${unique}${ex}`);
|
||
},
|
||
}),
|
||
}),
|
||
)
|
||
@Post("upload-video/:requestId")
|
||
@ApiParam({ name: "requestId" })
|
||
@ApiOperation({
|
||
summary: "Blame accident video (no-op for V4 — car-capture is the final step)",
|
||
description:
|
||
"Deprecated for V4. The blame is already COMPLETED by car-capture. " +
|
||
"Calling this endpoint returns an idempotent success response.",
|
||
})
|
||
async uploadBlameVideo(
|
||
@Param("requestId") requestId: string,
|
||
@CurrentUser() fileReviewer: any,
|
||
@UploadedFile() file: Express.Multer.File,
|
||
) {
|
||
if (file) {
|
||
await this.mediaPolicyService.assertForBlame(file, requestId, "video");
|
||
}
|
||
return this.requestManagementService.expertUploadBlameVideoV3(
|
||
fileReviewer,
|
||
requestId,
|
||
file,
|
||
);
|
||
}
|
||
}
|