forked from Yara724/api
494 lines
17 KiB
TypeScript
494 lines
17 KiB
TypeScript
import {
|
|
BadRequestException,
|
|
Body,
|
|
Controller,
|
|
Get,
|
|
Param,
|
|
Patch,
|
|
Post,
|
|
Put,
|
|
Query,
|
|
UseGuards,
|
|
} from "@nestjs/common";
|
|
import {
|
|
ApiBearerAuth,
|
|
ApiBody,
|
|
ApiOperation,
|
|
ApiParam,
|
|
ApiQuery,
|
|
ApiResponse,
|
|
ApiTags,
|
|
} from "@nestjs/swagger";
|
|
import { Types } from "mongoose";
|
|
import { SuperAdminGuard } from "./guards/super-admin.guard";
|
|
import { SuperAdminService } from "./super-admin.service";
|
|
import {
|
|
CreateSuperAdminDto,
|
|
CreateFieldExpertAdminDto,
|
|
CreateRegistrarAdminDto,
|
|
} from "./dto/super-admin.dto";
|
|
import { ClientDto } from "src/client/dto/create-client.dto";
|
|
import {
|
|
InsurerRegisterDto,
|
|
GenuineRegisterDto,
|
|
LegalRegisterDto,
|
|
} from "src/auth/dto/actor/register.actor.dto";
|
|
import { SystemSettingsService } from "src/system-settings/system-settings.service";
|
|
import {
|
|
SystemSettingsResponseDto,
|
|
UpdateSystemSettingsDto,
|
|
} from "src/system-settings/dto/system-settings.dto";
|
|
import { SetExternalInquiriesLiveDto } from "src/client/dto/external-inquiries-live.dto";
|
|
import { ExpertInsurerService } from "src/expert-insurer/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 { FileRating } from "src/request-management/entities/schema/request-management.schema";
|
|
import {
|
|
CreateBlameExpertByInsurerDto,
|
|
CreateClaimExpertByInsurerDto,
|
|
CreateFileMakerByInsurerDto,
|
|
CreateFileReviewerByInsurerDto,
|
|
} from "src/expert-insurer/dto/create-insurer-expert.dto";
|
|
|
|
@ApiTags("super-admin")
|
|
@ApiBearerAuth()
|
|
@UseGuards(SuperAdminGuard)
|
|
@Controller("super-admin")
|
|
export class SuperAdminController {
|
|
constructor(
|
|
private readonly superAdminService: SuperAdminService,
|
|
private readonly systemSettingsService: SystemSettingsService,
|
|
private readonly expertInsurerService: ExpertInsurerService,
|
|
) {}
|
|
|
|
// ── Super-admin account management ───────────────────────────────────────
|
|
|
|
@Get("accounts")
|
|
@ApiOperation({ summary: "List all super-admin accounts" })
|
|
listSuperAdmins() {
|
|
return this.superAdminService.listSuperAdmins();
|
|
}
|
|
|
|
@Post("accounts")
|
|
@ApiOperation({ summary: "Create an additional super-admin account" })
|
|
@ApiBody({ type: CreateSuperAdminDto })
|
|
createSuperAdmin(@Body() body: CreateSuperAdminDto) {
|
|
return this.superAdminService.createSuperAdmin(body);
|
|
}
|
|
|
|
// ── Client / insurer management ──────────────────────────────────────────
|
|
|
|
@Post("clients")
|
|
@ApiOperation({
|
|
summary: "Create a new insurer client",
|
|
description: "Registers a new insurer (client) in the platform.",
|
|
})
|
|
@ApiBody({ type: ClientDto })
|
|
createClient(@Body() body: ClientDto) {
|
|
return this.superAdminService.createClient(body);
|
|
}
|
|
|
|
@Get("clients")
|
|
@ApiOperation({ summary: "List all insurer clients" })
|
|
listClients() {
|
|
return this.superAdminService.listClients();
|
|
}
|
|
|
|
@Get("clients/names")
|
|
@ApiOperation({ summary: "List insurer client names and IDs" })
|
|
listClientNames() {
|
|
return this.superAdminService.listClientNames();
|
|
}
|
|
|
|
// ── Actor registration ───────────────────────────────────────────────────
|
|
|
|
@Post("register/insurer")
|
|
@ApiOperation({ summary: "Register a new insurer (company) actor" })
|
|
@ApiBody({ type: InsurerRegisterDto })
|
|
registerInsurer(@Body() body: InsurerRegisterDto) {
|
|
return this.superAdminService.registerInsurer(body);
|
|
}
|
|
|
|
@Post("register/genuine")
|
|
@ApiOperation({
|
|
deprecated: true,
|
|
summary: "[DEPRECATED] Register a genuine actor",
|
|
description:
|
|
"Kept for legacy clients. Use the unified onboarding flow instead.",
|
|
})
|
|
@ApiBody({ type: GenuineRegisterDto })
|
|
registerGenuine(@Body() body: GenuineRegisterDto) {
|
|
return this.superAdminService.registerGenuine(body);
|
|
}
|
|
|
|
@Post("register/legal")
|
|
@ApiOperation({
|
|
deprecated: true,
|
|
summary: "[DEPRECATED] Register a legal actor",
|
|
description:
|
|
"Kept for legacy clients. Use the unified onboarding flow instead.",
|
|
})
|
|
@ApiBody({ type: LegalRegisterDto })
|
|
registerLegal(@Body() body: LegalRegisterDto) {
|
|
return this.superAdminService.registerLegal(body);
|
|
}
|
|
|
|
@Post("create-field-expert")
|
|
@ApiOperation({ summary: "Create a field expert" })
|
|
@ApiBody({ type: CreateFieldExpertAdminDto })
|
|
createFieldExpert(@Body() body: CreateFieldExpertAdminDto) {
|
|
return this.superAdminService.createFieldExpert(body);
|
|
}
|
|
|
|
@Post("create-registrar")
|
|
@ApiOperation({ summary: "Create a registrar" })
|
|
@ApiBody({ type: CreateRegistrarAdminDto })
|
|
createRegistrar(@Body() body: CreateRegistrarAdminDto) {
|
|
return this.superAdminService.createRegistrar(body);
|
|
}
|
|
|
|
// ── System settings ──────────────────────────────────────────────────────
|
|
|
|
@Get("system-settings")
|
|
@ApiOperation({ summary: "Get global system settings" })
|
|
@ApiResponse({ status: 200, type: SystemSettingsResponseDto })
|
|
getSystemSettings() {
|
|
return this.systemSettingsService.getSettingsView();
|
|
}
|
|
|
|
@Patch("system-settings")
|
|
@ApiOperation({ summary: "Update global system settings" })
|
|
@ApiBody({ type: UpdateSystemSettingsDto })
|
|
@ApiResponse({ status: 200, type: SystemSettingsResponseDto })
|
|
updateSystemSettings(@Body() body: UpdateSystemSettingsDto) {
|
|
return this.systemSettingsService.updateSettings(body);
|
|
}
|
|
|
|
@Patch("external-inquiries-live")
|
|
@ApiOperation({
|
|
summary: "Enable or disable live external inquiries globally",
|
|
description:
|
|
"Updates `system_settings.externalApis.sandHubUseLiveApi`. When disabled, all inquiry flows use mocks.",
|
|
})
|
|
@ApiBody({ type: SetExternalInquiriesLiveDto })
|
|
@ApiResponse({ status: 200, type: SystemSettingsResponseDto })
|
|
setExternalInquiriesLive(@Body() body: SetExternalInquiriesLiveDto) {
|
|
return this.systemSettingsService.updateSettings({
|
|
externalApis: { sandHubUseLiveApi: body?.enabled === true },
|
|
});
|
|
}
|
|
|
|
// ── Insurer panel (super-admin proxy) ────────────────────────────────────
|
|
|
|
@Get("insurer/branches")
|
|
@ApiOperation({ summary: "List branches for a given client" })
|
|
@ApiQuery({ name: "clientId", required: true, type: String })
|
|
@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)" })
|
|
getInsuranceBranches(
|
|
@Query("clientId") clientId: string,
|
|
@Query("search") search?: string,
|
|
@Query("from") from?: string,
|
|
@Query("to") to?: string,
|
|
@Query("isActive") isActive?: string,
|
|
) {
|
|
return this.expertInsurerService.retrieveInsuranceBranches(
|
|
clientId,
|
|
{ search, from, to, isActive },
|
|
);
|
|
}
|
|
|
|
@Post("insurer/branches")
|
|
@ApiOperation({ summary: "Add a branch for a given client" })
|
|
@ApiBody({
|
|
schema: {
|
|
allOf: [
|
|
{ $ref: "#/components/schemas/CreateBranchDto" },
|
|
{
|
|
type: "object",
|
|
required: ["clientId"],
|
|
properties: { clientId: { type: "string", description: "Client ObjectId" } },
|
|
},
|
|
],
|
|
},
|
|
})
|
|
addBranch(
|
|
@Body("clientId") clientId: string,
|
|
@Body() createBranchDto: CreateBranchDto,
|
|
) {
|
|
return this.expertInsurerService.addBranch(clientId, createBranchDto);
|
|
}
|
|
|
|
@Put("insurer/branches/:branchId/status")
|
|
@ApiOperation({ summary: "Set branch active/inactive for a given client" })
|
|
@ApiParam({ name: "branchId" })
|
|
@ApiBody({
|
|
schema: {
|
|
type: "object",
|
|
properties: {
|
|
clientId: { type: "string", description: "Client ObjectId" },
|
|
isActive: { type: "boolean" },
|
|
},
|
|
required: ["clientId", "isActive"],
|
|
},
|
|
})
|
|
setBranchStatus(
|
|
@Param("branchId") branchId: string,
|
|
@Body("clientId") clientId: string,
|
|
@Body("isActive") isActive: unknown,
|
|
) {
|
|
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(clientId, branchId, active);
|
|
}
|
|
|
|
@Post("insurer/experts/blame")
|
|
@ApiOperation({ summary: "Create a blame expert under a given client" })
|
|
@ApiBody({
|
|
schema: {
|
|
allOf: [
|
|
{ $ref: "#/components/schemas/CreateBlameExpertByInsurerDto" },
|
|
{
|
|
type: "object",
|
|
required: ["clientId"],
|
|
properties: { clientId: { type: "string", description: "Client ObjectId" } },
|
|
},
|
|
],
|
|
},
|
|
})
|
|
addBlameExpert(
|
|
@Body("clientId") clientId: string,
|
|
@Body() body: CreateBlameExpertByInsurerDto,
|
|
) {
|
|
return this.expertInsurerService.addBlameExpert(clientId, body);
|
|
}
|
|
|
|
@Post("insurer/experts/claim")
|
|
@ApiOperation({ summary: "Create a claim expert under a given client" })
|
|
@ApiBody({
|
|
schema: {
|
|
allOf: [
|
|
{ $ref: "#/components/schemas/CreateClaimExpertByInsurerDto" },
|
|
{
|
|
type: "object",
|
|
required: ["clientId"],
|
|
properties: { clientId: { type: "string", description: "Client ObjectId" } },
|
|
},
|
|
],
|
|
},
|
|
})
|
|
addClaimExpert(
|
|
@Body("clientId") clientId: string,
|
|
@Body() body: CreateClaimExpertByInsurerDto,
|
|
) {
|
|
return this.expertInsurerService.addClaimExpert(clientId, body);
|
|
}
|
|
|
|
@Post("insurer/experts/file-maker")
|
|
@ApiOperation({ summary: "Create a FileMaker account under a given client" })
|
|
@ApiBody({
|
|
schema: {
|
|
allOf: [
|
|
{ $ref: "#/components/schemas/CreateFileMakerByInsurerDto" },
|
|
{
|
|
type: "object",
|
|
required: ["clientId"],
|
|
properties: { clientId: { type: "string", description: "Client ObjectId" } },
|
|
},
|
|
],
|
|
},
|
|
})
|
|
addFileMaker(
|
|
@Body("clientId") clientId: string,
|
|
@Body() body: CreateFileMakerByInsurerDto,
|
|
) {
|
|
return this.expertInsurerService.addFileMaker(clientId, body);
|
|
}
|
|
|
|
@Post("insurer/experts/file-reviewer")
|
|
@ApiOperation({ summary: "Create a FileReviewer account under a given client" })
|
|
@ApiBody({
|
|
schema: {
|
|
allOf: [
|
|
{ $ref: "#/components/schemas/CreateFileReviewerByInsurerDto" },
|
|
{
|
|
type: "object",
|
|
required: ["clientId"],
|
|
properties: { clientId: { type: "string", description: "Client ObjectId" } },
|
|
},
|
|
],
|
|
},
|
|
})
|
|
addFileReviewer(
|
|
@Body("clientId") clientId: string,
|
|
@Body() body: CreateFileReviewerByInsurerDto,
|
|
) {
|
|
return this.expertInsurerService.addFileReviewer(clientId, body);
|
|
}
|
|
|
|
@Get("insurer/experts/list")
|
|
@ApiOperation({ summary: "List all experts of a given client" })
|
|
@ApiQuery({ name: "clientId", required: true, type: String })
|
|
@ApiQuery({ name: "page", type: Number })
|
|
@ApiQuery({ name: "response_count", type: Number })
|
|
getAllExperts(
|
|
@Query("clientId") clientId: string,
|
|
@Query("page") page: number,
|
|
@Query("response_count") count: number,
|
|
) {
|
|
return this.expertInsurerService.retrieveAllExpertsOfClient(
|
|
{ clientKey: clientId },
|
|
page,
|
|
count,
|
|
);
|
|
}
|
|
|
|
@Get("insurer/experts/top")
|
|
@ApiOperation({ summary: "Top blame vs claim experts for a given client" })
|
|
@ApiQuery({ name: "clientId", required: true, type: String })
|
|
getTopExperts(@Query("clientId") clientId: string) {
|
|
return this.expertInsurerService.getTopExpertsForClient({ clientKey: clientId });
|
|
}
|
|
|
|
@Get("insurer/files")
|
|
@ApiOperation({ summary: "List files (blame + claim merged) for a given client" })
|
|
@ApiQuery({ name: "clientId", required: true, type: String })
|
|
getAllFiles(
|
|
@Query("clientId") clientId: string,
|
|
@Query() query: ListQueryV2Dto,
|
|
) {
|
|
return this.expertInsurerService.retrieveAllFilesOfClient(clientId, query);
|
|
}
|
|
|
|
@Get("insurer/report/unified-file-statuses")
|
|
@ApiOperation({ summary: "Unified file status catalog + counts for a given client" })
|
|
@ApiQuery({ name: "clientId", required: true, type: String })
|
|
@ApiResponse({ status: 200, type: UnifiedFileStatusReportDto })
|
|
getUnifiedFileStatusReport(
|
|
@Query("clientId") clientId: string,
|
|
@Query() query: UnifiedFileStatusReportQueryDto,
|
|
): Promise<UnifiedFileStatusReportDto> {
|
|
return this.expertInsurerService.getInsurerUnifiedFileStatusReport(
|
|
{ clientKey: clientId },
|
|
query,
|
|
);
|
|
}
|
|
|
|
@Get("insurer/report/status-counts")
|
|
@ApiOperation({
|
|
summary: "Legacy status counts for a given client",
|
|
deprecated: true,
|
|
description: "Prefer GET insurer/report/unified-file-statuses.",
|
|
})
|
|
@ApiQuery({ name: "clientId", required: true, type: String })
|
|
@ApiQuery({ name: "from", required: false, description: "Optional start datetime (ISO string)" })
|
|
@ApiQuery({ name: "to", required: false, description: "Optional end datetime (ISO string)" })
|
|
getInsurerStatusReport(
|
|
@Query("clientId") clientId: string,
|
|
@Query("from") from?: string,
|
|
@Query("to") to?: string,
|
|
) {
|
|
return this.expertInsurerService.getInsurerFileStatusCounts(
|
|
{ clientKey: clientId },
|
|
from,
|
|
to,
|
|
);
|
|
}
|
|
|
|
@Get("insurer/files/:publicId/timeline")
|
|
@ApiOperation({ summary: "Activity timeline for a case of a given client" })
|
|
@ApiParam({ name: "publicId" })
|
|
@ApiQuery({ name: "clientId", required: true, type: String })
|
|
getFileTimeline(
|
|
@Query("clientId") clientId: string,
|
|
@Param("publicId") publicId: string,
|
|
) {
|
|
return this.expertInsurerService.getFileTimeline(clientId, publicId);
|
|
}
|
|
|
|
@Get("insurer/files/:publicId")
|
|
@ApiOperation({ summary: "File details by publicId for a given client" })
|
|
@ApiParam({ name: "publicId" })
|
|
@ApiQuery({ name: "clientId", required: true, type: String })
|
|
getFileDetailsByPublicId(
|
|
@Query("clientId") clientId: string,
|
|
@Param("publicId") publicId: string,
|
|
) {
|
|
return this.expertInsurerService.retrieveFileDetailsByPublicId(clientId, publicId);
|
|
}
|
|
|
|
// @Put("insurer/files/:publicId/rating")
|
|
// @ApiOperation({ summary: "Rate experts by publicId for a given client" })
|
|
// @ApiParam({ name: "publicId" })
|
|
// @ApiBody({
|
|
// schema: {
|
|
// type: "object",
|
|
// required: [
|
|
// "clientId",
|
|
// "collisionMethodAccuracy",
|
|
// "evaluationTimeliness",
|
|
// "accidentCauseAccuracy",
|
|
// "guiltyVehicleIdentification",
|
|
// "botRating",
|
|
// ],
|
|
// properties: {
|
|
// clientId: { type: "string", description: "Client ObjectId" },
|
|
// collisionMethodAccuracy: { type: "number", minimum: 0, maximum: 5 },
|
|
// evaluationTimeliness: { type: "number", minimum: 0, maximum: 5 },
|
|
// accidentCauseAccuracy: { type: "number", minimum: 0, maximum: 5 },
|
|
// guiltyVehicleIdentification: { type: "number", minimum: 0, maximum: 5 },
|
|
// botRating: { type: "number", minimum: 0, maximum: 5 },
|
|
// },
|
|
// },
|
|
// })
|
|
// rateExpertsByPublicId(
|
|
// @Param("publicId") publicId: string,
|
|
// @Body() body: FileRating & { clientId: string },
|
|
// ) {
|
|
// const { clientId, ...rating } = body;
|
|
// return this.expertInsurerService.rateExpertByPublicId(publicId, rating as FileRating, clientId);
|
|
// }
|
|
|
|
@Get("insurer/top-files")
|
|
@ApiOperation({ summary: "Top-rated files for a given client" })
|
|
@ApiQuery({ name: "clientId", required: true, type: String })
|
|
getTopFiles(@Query("clientId") clientId: string) {
|
|
return this.expertInsurerService.getTopFilesForClient(clientId);
|
|
}
|
|
|
|
@Get("insurer/statistics")
|
|
@ApiOperation({ summary: "Expert statistics report for a given client" })
|
|
@ApiQuery({ name: "clientId", required: true, type: String })
|
|
getExpertStatistics(@Query("clientId") clientId: string) {
|
|
return this.expertInsurerService.getExpertStatisticsReport({ clientKey: clientId });
|
|
}
|
|
|
|
@Get("insurer/:expertId")
|
|
@ApiOperation({ summary: "Files handled by one roster expert for a given client" })
|
|
@ApiParam({ name: "expertId" })
|
|
@ApiQuery({ name: "clientId", required: true, type: String })
|
|
getExpertFiles(
|
|
@Query("clientId") clientId: string,
|
|
@Param("expertId") expertId: string,
|
|
) {
|
|
if (!Types.ObjectId.isValid(expertId)) {
|
|
throw new BadRequestException("Invalid expert ID");
|
|
}
|
|
return this.expertInsurerService.getAllFilesForInsurerExpert(expertId, clientId);
|
|
}
|
|
}
|