forked from Yara724/api
380 lines
17 KiB
TypeScript
380 lines
17 KiB
TypeScript
import {
|
||
BadRequestException,
|
||
Body,
|
||
Controller,
|
||
Get,
|
||
Param,
|
||
Post,
|
||
Put,
|
||
Query,
|
||
UnauthorizedException,
|
||
UseGuards,
|
||
} from "@nestjs/common";
|
||
import {
|
||
ApiBearerAuth,
|
||
ApiBody,
|
||
ApiOperation,
|
||
ApiParam,
|
||
ApiQuery,
|
||
ApiResponse,
|
||
ApiTags,
|
||
} from "@nestjs/swagger";
|
||
import { Types } from "mongoose";
|
||
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 { FileRating } from "src/request-management/entities/schema/request-management.schema";
|
||
import { RoleEnum } from "src/Types&Enums/role.enum";
|
||
import { ExpertInsurerService } from "./expert-insurer.service";
|
||
import { ListQueryV2Dto } from "src/common/dto/list-query-v2.dto";
|
||
import {
|
||
UnifiedFileStatusReportDto,
|
||
UnifiedFileStatusReportQueryDto,
|
||
} from "src/common/dto/unified-file-status-report.dto";
|
||
import { CreateBranchDto } from "src/client/dto/create-branch.dto";
|
||
import {
|
||
CreateBlameExpertByInsurerDto,
|
||
CreateClaimExpertByInsurerDto,
|
||
CreateFileMakerByInsurerDto,
|
||
CreateFileReviewerByInsurerDto,
|
||
} from "./dto/create-insurer-expert.dto";
|
||
import {
|
||
InsurerStatisticsDto,
|
||
InsurerTopExpertsDto,
|
||
InsurerTopFileDto,
|
||
InsurerWorkLogResponseDto,
|
||
} from "./dto/insurer-reports.dto";
|
||
import { ReportsService } from "src/reports/reports.service";
|
||
|
||
@Controller("expert-insurer")
|
||
@ApiTags("expert-insurer-panel")
|
||
@ApiBearerAuth()
|
||
@UseGuards(LocalActorAuthGuard, RolesGuard)
|
||
@Roles(RoleEnum.COMPANY)
|
||
export class ExpertInsurerController {
|
||
constructor(
|
||
private readonly expertInsurerService: ExpertInsurerService,
|
||
private readonly reportsService: ReportsService,
|
||
) {}
|
||
|
||
// ─── Branch management ────────────────────────────────────────────────────
|
||
|
||
@Get("branches")
|
||
@ApiQuery({ name: "search", required: false, type: String })
|
||
@ApiQuery({ name: "from", required: false, description: "Optional start datetime (ISO string)" })
|
||
@ApiQuery({ name: "to", required: false, description: "Optional end datetime (ISO string)" })
|
||
@ApiQuery({ name: "isActive", required: false, description: "Filter active state (true/false)" })
|
||
async getInsuranceBranches(
|
||
@CurrentUser() insurer,
|
||
@Query("search") search?: string,
|
||
@Query("from") from?: string,
|
||
@Query("to") to?: string,
|
||
@Query("isActive") isActive?: string,
|
||
) {
|
||
if (!insurer) throw new UnauthorizedException("Could not identify the current user.");
|
||
return await this.expertInsurerService.retrieveInsuranceBranches(
|
||
insurer.clientKey,
|
||
{ search, from, to, isActive },
|
||
);
|
||
}
|
||
|
||
@Post("branches")
|
||
@ApiBody({ type: CreateBranchDto })
|
||
async addBranch(@CurrentUser() insurer, @Body() createBranchDto: CreateBranchDto) {
|
||
if (!insurer) throw new UnauthorizedException("Could not identify the current user.");
|
||
return await this.expertInsurerService.addBranch(insurer.clientKey, createBranchDto);
|
||
}
|
||
|
||
@Put("branches/:branchId/status")
|
||
@ApiParam({ name: "branchId" })
|
||
@ApiBody({
|
||
schema: {
|
||
type: "object",
|
||
properties: { isActive: { type: "boolean" } },
|
||
required: ["isActive"],
|
||
},
|
||
})
|
||
async setBranchStatus(
|
||
@CurrentUser() insurer,
|
||
@Param("branchId") branchId: string,
|
||
@Body("isActive") isActive: unknown,
|
||
) {
|
||
if (!insurer) throw new UnauthorizedException("Could not identify the current user.");
|
||
let active: boolean;
|
||
if (typeof isActive === "boolean") {
|
||
active = isActive;
|
||
} else {
|
||
const normalized = String(isActive ?? "").trim().toLowerCase();
|
||
if (!["true", "false", "1", "0", "yes", "no"].includes(normalized)) {
|
||
throw new BadRequestException("isActive must be a boolean");
|
||
}
|
||
active = ["true", "1", "yes"].includes(normalized);
|
||
}
|
||
return this.expertInsurerService.setBranchActive(insurer.clientKey, branchId, active);
|
||
}
|
||
|
||
// ─── Expert management ────────────────────────────────────────────────────
|
||
|
||
@Post("experts/blame")
|
||
@ApiBody({ type: CreateBlameExpertByInsurerDto })
|
||
async addBlameExpert(@CurrentUser() insurer, @Body() body: CreateBlameExpertByInsurerDto) {
|
||
if (!insurer) throw new UnauthorizedException("Could not identify the current user.");
|
||
return this.expertInsurerService.addBlameExpert(insurer.clientKey, body);
|
||
}
|
||
|
||
@Post("experts/claim")
|
||
@ApiBody({ type: CreateClaimExpertByInsurerDto })
|
||
async addClaimExpert(@CurrentUser() insurer, @Body() body: CreateClaimExpertByInsurerDto) {
|
||
if (!insurer) throw new UnauthorizedException("Could not identify the current user.");
|
||
return this.expertInsurerService.addClaimExpert(insurer.clientKey, body);
|
||
}
|
||
|
||
@Post("experts/file-maker")
|
||
@ApiBody({ type: CreateFileMakerByInsurerDto })
|
||
@ApiOperation({ summary: "Create a FileMaker account under this insurer" })
|
||
async addFileMaker(@CurrentUser() insurer, @Body() body: CreateFileMakerByInsurerDto) {
|
||
if (!insurer) throw new UnauthorizedException("Could not identify the current user.");
|
||
return this.expertInsurerService.addFileMaker(insurer.clientKey, body);
|
||
}
|
||
|
||
@Post("experts/file-reviewer")
|
||
@ApiBody({ type: CreateFileReviewerByInsurerDto })
|
||
@ApiOperation({ summary: "Create a FileReviewer account under this insurer" })
|
||
async addFileReviewer(@CurrentUser() insurer, @Body() body: CreateFileReviewerByInsurerDto) {
|
||
if (!insurer) throw new UnauthorizedException("Could not identify the current user.");
|
||
return this.expertInsurerService.addFileReviewer(insurer.clientKey, body);
|
||
}
|
||
|
||
@ApiQuery({ name: "page", type: Number })
|
||
@ApiQuery({ name: "response_count", type: Number })
|
||
@Get("experts/list")
|
||
async getAllExperts(
|
||
@Query("page") page: number,
|
||
@Query("response_count") count: number,
|
||
@CurrentUser() actor,
|
||
) {
|
||
return await this.expertInsurerService.retrieveAllExpertsOfClient(actor, page, count);
|
||
}
|
||
|
||
// ─── Reports: statistics ──────────────────────────────────────────────────
|
||
|
||
@Get("statistics")
|
||
@ApiOperation({
|
||
summary: "نمایش کلی — KPI cards for insurer reports page",
|
||
description:
|
||
"Returns `totalFilesReviewed` (distinct tenant claim files with ≥1 expert CHECKED activity), " +
|
||
"`averageUserRatingPercentage` (mean of progressSpeed + registrationEase + overallEvaluation across rated files, normalised to 0–100), " +
|
||
"`inPersonAccompaniedCount` (blame files where expertInitiated=true AND creationMethod=IN_PERSON), " +
|
||
"`filesCreatedThisMonth`, `totalFiles`, `objectionPercentage`, `insurerToBotRatingPercentage`. " +
|
||
"⚠️ `userRatingPercentage` and `filesWithUserRatingPercentage` are the share of files *that have any user rating* — NOT a satisfaction score. Use `averageUserRatingPercentage` for رضایت کاربران.",
|
||
})
|
||
@ApiQuery({ name: "from", required: false, description: "Optional start datetime (ISO string) — restricts counted claim portfolio" })
|
||
@ApiQuery({ name: "to", required: false, description: "Optional end datetime (ISO string)" })
|
||
@ApiResponse({ status: 200, type: InsurerStatisticsDto })
|
||
async getExpertStatistics(
|
||
@CurrentUser() actor,
|
||
@Query("from") from?: string,
|
||
@Query("to") to?: string,
|
||
) {
|
||
return await this.expertInsurerService.getExpertStatisticsReport(actor, { from, to });
|
||
}
|
||
|
||
// ─── Reports: top files ───────────────────────────────────────────────────
|
||
|
||
@Get("top-files")
|
||
@ApiOperation({
|
||
summary: "Top 10 highest-rated claim files for this insurer",
|
||
description:
|
||
"Sorted by combined insurer + user rating blend (getCombinedFileScore). " +
|
||
"Returns slim DTO only: publicId, createdAt, combinedScore, userRating.{comment, overallEvaluation}. " +
|
||
"Use publicId to build مشاهده پرونده links.",
|
||
})
|
||
@ApiQuery({ name: "from", required: false, description: "Restrict to files created on or after this ISO date" })
|
||
@ApiQuery({ name: "to", required: false, description: "Restrict to files created on or before this ISO date" })
|
||
@ApiResponse({ status: 200, type: [InsurerTopFileDto] })
|
||
async getTopFiles(
|
||
@CurrentUser() insurer,
|
||
@Query("from") from?: string,
|
||
@Query("to") to?: string,
|
||
) {
|
||
return await this.expertInsurerService.getTopFilesForClient(insurer.clientKey, { from, to });
|
||
}
|
||
|
||
// ─── Reports: top experts (canonical + alias) ─────────────────────────────
|
||
|
||
@Get("experts/top")
|
||
@ApiOperation({
|
||
summary: "Top blame vs claim experts for this insurer",
|
||
description:
|
||
"Response: `{ blameExperts: [], claimExperts: [] }`. " +
|
||
"Each item: `_id`, `fullName`, `expertKind`, `overallAverageRating`, `requestStats`. " +
|
||
"Sorted by overallAverageRating descending; up to 10 per group. " +
|
||
"Optional `from` / `to` accepted for forward-compat (currently accepted but roster is full-history).",
|
||
})
|
||
@ApiQuery({ name: "from", required: false, description: "Optional start datetime (ISO string)" })
|
||
@ApiQuery({ name: "to", required: false, description: "Optional end datetime (ISO string)" })
|
||
@ApiResponse({ status: 200, type: InsurerTopExpertsDto })
|
||
async getTopExperts(
|
||
@CurrentUser() actor,
|
||
@Query("from") from?: string,
|
||
@Query("to") to?: string,
|
||
) {
|
||
return await this.expertInsurerService.getTopExpertsForClient(actor, { from, to });
|
||
}
|
||
|
||
/**
|
||
* Alias: some BFF/frontend paths call /top-experts instead of /experts/top.
|
||
* Both routes point to the same handler.
|
||
*/
|
||
@Get("top-experts")
|
||
@ApiOperation({
|
||
summary: "Alias for GET experts/top — top blame + claim experts",
|
||
description: "Same response as `GET experts/top`. Provided for front-end compatibility.",
|
||
})
|
||
@ApiQuery({ name: "from", required: false })
|
||
@ApiQuery({ name: "to", required: false })
|
||
@ApiResponse({ status: 200, type: InsurerTopExpertsDto })
|
||
async getTopExpertsAlias(
|
||
@CurrentUser() actor,
|
||
@Query("from") from?: string,
|
||
@Query("to") to?: string,
|
||
) {
|
||
return await this.expertInsurerService.getTopExpertsForClient(actor, { from, to });
|
||
}
|
||
|
||
// ─── Reports: work-log (delegates to ReportsService) ─────────────────────
|
||
|
||
@Get("expert-work-log")
|
||
@ApiOperation({
|
||
summary: "نمایش جدولی — per-expert work log (blame panel + damage experts)",
|
||
description:
|
||
"Rows for every tenant expert in the `expert` (blame) and `damage-expert` (claim) collections — same scope as GET experts/list, field-expert excluded. " +
|
||
"Columns: expertId, fullName, expertKind, totalHandled (files in HANDLED state up to `to`/now), " +
|
||
"currentlyChecking (CHECKED but not yet HANDLED up to `to`/now), " +
|
||
"distinctFilesCheckedInPeriod (distinct files with ≥1 CHECKED event inside from–to window; all-time when omitted). " +
|
||
"Optional `expertKind` filter: `expert` = blame panel, `damage_expert` = claim damage experts, `all` (default).",
|
||
})
|
||
@ApiQuery({ name: "expertKind", required: false, enum: ["all", "expert", "damage_expert"], description: "Filter by expert kind" })
|
||
@ApiQuery({ name: "from", required: false, description: "Start of date window (ISO string)" })
|
||
@ApiQuery({ name: "to", required: false, description: "End of date window (ISO string)" })
|
||
@ApiQuery({ name: "page", required: false, type: Number, description: "Page (1-based)" })
|
||
@ApiQuery({ name: "limit", required: false, type: Number, description: "Items per page" })
|
||
@ApiResponse({ status: 200, type: InsurerWorkLogResponseDto })
|
||
async getExpertWorkLog(
|
||
@CurrentUser() actor,
|
||
@Query("expertKind") expertKind?: "all" | "expert" | "damage_expert",
|
||
@Query("from") from?: string,
|
||
@Query("to") to?: string,
|
||
@Query("page") page?: string,
|
||
@Query("limit") limit?: string,
|
||
) {
|
||
return this.reportsService.getInsurerExpertWorkLog(actor, {
|
||
expertKind,
|
||
from,
|
||
to,
|
||
page: page ? parseInt(page, 10) : undefined,
|
||
limit: limit ? parseInt(limit, 10) : undefined,
|
||
});
|
||
}
|
||
|
||
// ─── Files ────────────────────────────────────────────────────────────────
|
||
|
||
@Get("files")
|
||
@ApiOperation({
|
||
summary: "List insurer files (blame + claim merged by publicId)",
|
||
description:
|
||
"Optional query: `search`, `sortBy` (publicId | createdAt | requestNo | status), `sortOrder`, `page`, `limit`, `unifiedStatus`, `fileType` (THIRD_PARTY | CAR_BODY).",
|
||
})
|
||
async getAllFiles(@CurrentUser() insurer, @Query() query: ListQueryV2Dto) {
|
||
return await this.expertInsurerService.retrieveAllFilesOfClient(insurer.clientKey, query);
|
||
}
|
||
|
||
@Get("report/unified-file-statuses")
|
||
@ApiOperation({
|
||
summary: "Unified file status catalog + counts (blame + claim)",
|
||
description:
|
||
"Calculatable unified statuses and per-status counts for this insurer's files. Filter lists with `unifiedStatus` and `fileType`. Optional `from` / `to` ISO dates narrow the counted portfolio.",
|
||
})
|
||
@ApiResponse({ status: 200, type: UnifiedFileStatusReportDto })
|
||
async getUnifiedFileStatusReport(
|
||
@CurrentUser() actor,
|
||
@Query() query: UnifiedFileStatusReportQueryDto,
|
||
): Promise<UnifiedFileStatusReportDto> {
|
||
return await this.expertInsurerService.getInsurerUnifiedFileStatusReport(actor, query);
|
||
}
|
||
|
||
@Get("files/:publicId/timeline")
|
||
@ApiParam({ name: "publicId" })
|
||
@ApiOperation({
|
||
summary: "Activity timeline for a case",
|
||
description:
|
||
"Returns a chronological list of all history events for the blame and/or claim associated with the given publicId. Each event has: source, type, timestamp, actor, metadata.",
|
||
})
|
||
async getFileTimeline(@CurrentUser() insurer, @Param("publicId") publicId: string) {
|
||
return await this.expertInsurerService.getFileTimeline(insurer.clientKey, publicId);
|
||
}
|
||
|
||
@Get("files/:publicId")
|
||
@ApiParam({ name: "publicId" })
|
||
async getFileDetailsByPublicId(@CurrentUser() insurer, @Param("publicId") publicId: string) {
|
||
return await this.expertInsurerService.retrieveFileDetailsByPublicId(insurer.clientKey, publicId);
|
||
}
|
||
|
||
@ApiBody({
|
||
description:
|
||
"One insurer rating for the shared publicId; persisted on claim and/or blame case documents when both exist.",
|
||
schema: {
|
||
type: "object",
|
||
properties: {
|
||
collisionMethodAccuracy: { type: "number", minimum: 0, maximum: 5, example: 4, description: "تشخیص درست نحوه برخورد" },
|
||
evaluationTimeliness: { type: "number", minimum: 0, maximum: 5, example: 3, description: "زمان ارزیابی" },
|
||
accidentCauseAccuracy: { type: "number", minimum: 0, maximum: 5, example: 5, description: "تشخیص درست علت تصادف" },
|
||
guiltyVehicleIdentification: { type: "number", minimum: 0, maximum: 5, example: 4, description: "تشخیص درست وسیله نقلیه مقصر" },
|
||
botRating: { type: "number", minimum: 0, maximum: 5, example: 4, description: "برای امتیاز دادن به عملکرد بات" },
|
||
},
|
||
required: ["collisionMethodAccuracy", "evaluationTimeliness", "accidentCauseAccuracy", "guiltyVehicleIdentification", "botRating"],
|
||
example: { collisionMethodAccuracy: 4, evaluationTimeliness: 3, accidentCauseAccuracy: 5, guiltyVehicleIdentification: 4, botRating: 4 },
|
||
},
|
||
})
|
||
@ApiParam({ name: "publicId" })
|
||
@Put("files/:publicId/rating")
|
||
async rateExpertsByPublicId(
|
||
@CurrentUser() insurer,
|
||
@Param("publicId") publicId: string,
|
||
@Body() rating: FileRating,
|
||
) {
|
||
return await this.expertInsurerService.rateExpertByPublicId(publicId, rating, insurer.clientKey);
|
||
}
|
||
|
||
@Get("report/status-counts")
|
||
@ApiOperation({
|
||
summary: "Legacy status counts (mapped from unified statuses)",
|
||
deprecated: true,
|
||
description: "Prefer GET report/unified-file-statuses for full calculatable blame+claim statuses.",
|
||
})
|
||
@ApiQuery({ name: "from", required: false, description: "Optional start datetime (ISO string)" })
|
||
@ApiQuery({ name: "to", required: false, description: "Optional end datetime (ISO string)" })
|
||
async getInsurerStatusReport(
|
||
@CurrentUser() actor,
|
||
@Query("from") from?: string,
|
||
@Query("to") to?: string,
|
||
) {
|
||
return await this.expertInsurerService.getInsurerFileStatusCounts(actor, from, to);
|
||
}
|
||
|
||
// ─── Expert detail ────────────────────────────────────────────────────────
|
||
|
||
@ApiParam({ name: "expertId" })
|
||
@ApiOperation({
|
||
summary: "Files handled by one roster expert (summary rows)",
|
||
description:
|
||
"Resolves id against this insurer's `expert` then `damage-expert` roster. Blame branch runs when the id is on the expert roster (field experts). Each item is a small summary (`kind`, ids, statuses, dates)—not full file payloads. Claim matches use final or draft damage-expert reply.",
|
||
})
|
||
@Get("/:expertId")
|
||
async requestDetail(@CurrentUser() insurer, @Param("expertId") id: string) {
|
||
if (!Types.ObjectId.isValid(id)) throw new BadRequestException("Invalid expert ID");
|
||
return await this.expertInsurerService.getAllFilesForInsurerExpert(id, insurer.clientKey);
|
||
}
|
||
}
|