forked from Yara724/api
Sepehr Yahyaee
7d1a50db7b
Preserve damage history and current vehicle price, restore depreciation mapping, normalize inquiry/report output, and support resumable expert review with paginated case retrieval.
1185 lines
34 KiB
TypeScript
1185 lines
34 KiB
TypeScript
import {
|
||
resolveClaimOwnerParty,
|
||
resolveDamagedPartyRow,
|
||
} from "src/helpers/blame-damaged-party";
|
||
import { toJalaliDateAndTime } from "src/helpers/date-jalali";
|
||
import { PartyRole } from "src/request-management/entities/schema/partyRole.enum";
|
||
import { sanitizeStoredInquiryParticipants } from "src/request-management/inquiry-participant-resolver";
|
||
import {
|
||
InsurerFileReportField,
|
||
InsurerFileReportSection,
|
||
InsurerFileReportViewModel,
|
||
} from "./case-expert-report.types";
|
||
import {
|
||
PR,
|
||
persianAccidentCondition,
|
||
persianFieldPath,
|
||
persianReportValue,
|
||
persianStatus,
|
||
} from "./persian-report-labels";
|
||
|
||
const SKIP_FLATTEN_KEYS = new Set([
|
||
"_id",
|
||
"__v",
|
||
"history",
|
||
"workflow",
|
||
"evidence",
|
||
"confirmation",
|
||
"inquiries",
|
||
"raw",
|
||
"source",
|
||
]);
|
||
|
||
type ReportRecord = Record<string, unknown>;
|
||
type ReportParty = ReportRecord & {
|
||
role?: string;
|
||
person?: ReportRecord;
|
||
insurance?: ReportRecord & { carBodyInsurance?: ReportRecord };
|
||
vehicle?: ReportRecord;
|
||
statement?: ReportRecord;
|
||
location?: { lat?: number; lon?: number };
|
||
participants?: ReportRecord[];
|
||
participantRoles?: ReportRecord;
|
||
};
|
||
|
||
function asString(value: unknown): string | undefined {
|
||
if (value === undefined || value === null || value === "") return undefined;
|
||
if (typeof value === "boolean") return value ? "بله" : "خیر";
|
||
if (value instanceof Date) {
|
||
const [d, t] = toJalaliDateAndTime(value);
|
||
return `${d} ${t}`;
|
||
}
|
||
if (typeof value === "object") {
|
||
if (typeof (value as { toString?: () => string }).toString === "function") {
|
||
const s = String(value);
|
||
if (s !== "[object Object]") return s;
|
||
}
|
||
return undefined;
|
||
}
|
||
return String(value);
|
||
}
|
||
|
||
function formatBirthDate(value: unknown): string | undefined {
|
||
if (value === undefined || value === null || value === "") return undefined;
|
||
const raw = String(value);
|
||
if (/^\d{8}$/.test(raw)) {
|
||
return `${raw.slice(0, 4)}/${raw.slice(4, 6)}/${raw.slice(6, 8)}`;
|
||
}
|
||
return raw;
|
||
}
|
||
|
||
function formatDateTime(value: unknown): string | undefined {
|
||
if (value === undefined || value === null || value === "") return undefined;
|
||
const date =
|
||
value instanceof Date ? value : new Date(value as string | number);
|
||
if (Number.isNaN(date.getTime())) return asString(value);
|
||
const [d, t] = toJalaliDateAndTime(date);
|
||
return `${d} ${t}`;
|
||
}
|
||
|
||
const PERSIAN_NUMBER_FORMATTER = new Intl.NumberFormat("fa-IR", {
|
||
maximumFractionDigits: 0,
|
||
});
|
||
|
||
function normalizeNumber(value: unknown): number | undefined {
|
||
if (typeof value === "number") {
|
||
return Number.isFinite(value) ? value : undefined;
|
||
}
|
||
if (typeof value !== "string" || !value.trim()) return undefined;
|
||
|
||
const normalized = value
|
||
.trim()
|
||
.replace(/[۰-۹]/g, (digit) => String("۰۱۲۳۴۵۶۷۸۹".indexOf(digit)))
|
||
.replace(/[٠-٩]/g, (digit) => String("٠١٢٣٤٥٦٧٨٩".indexOf(digit)))
|
||
.replace(/[٬,\s]/g, "");
|
||
const parsed = Number(normalized);
|
||
return Number.isFinite(parsed) ? parsed : undefined;
|
||
}
|
||
|
||
function formatToman(value: unknown): string | undefined {
|
||
if (value === undefined || value === null || value === "") return undefined;
|
||
const amount = normalizeNumber(value);
|
||
if (amount === undefined) return asString(value);
|
||
return `${PERSIAN_NUMBER_FORMATTER.format(amount)} تومان`;
|
||
}
|
||
|
||
function firstDefined(...values: unknown[]): string | undefined {
|
||
for (const value of values) {
|
||
const str = asString(value);
|
||
if (str) return str;
|
||
}
|
||
return undefined;
|
||
}
|
||
|
||
function normalizeListValue(value: unknown, path = ""): string | undefined {
|
||
if (!Array.isArray(value) || !value.length) return undefined;
|
||
const items = value
|
||
.map(
|
||
(item) =>
|
||
asString(persianReportValue(path, item)) ?? JSON.stringify(item),
|
||
)
|
||
.filter(Boolean);
|
||
return items.length ? items.join("، ") : undefined;
|
||
}
|
||
|
||
function flattenObject(
|
||
obj: unknown,
|
||
prefix = "",
|
||
depth = 0,
|
||
): InsurerFileReportField[] {
|
||
if (obj == null) return [];
|
||
if (depth > 6) {
|
||
return [
|
||
{
|
||
label: persianFieldPath(prefix),
|
||
value: asString(persianReportValue(prefix, obj)),
|
||
},
|
||
];
|
||
}
|
||
|
||
if (Array.isArray(obj)) {
|
||
if (obj.some((item) => item && typeof item === "object")) {
|
||
return obj.flatMap((item, index) =>
|
||
flattenObject(item, `${prefix}.${index + 1}`, depth + 1),
|
||
);
|
||
}
|
||
const value = normalizeListValue(obj, prefix);
|
||
return value ? [{ label: persianFieldPath(prefix || "items"), value }] : [];
|
||
}
|
||
|
||
if (typeof obj !== "object") {
|
||
return [
|
||
{
|
||
label: persianFieldPath(prefix || "value"),
|
||
value: asString(persianReportValue(prefix || "value", obj)),
|
||
},
|
||
];
|
||
}
|
||
|
||
const rows: InsurerFileReportField[] = [];
|
||
const objRecord = obj as Record<string, unknown>;
|
||
const hasMapped =
|
||
objRecord.mapped != null && typeof objRecord.mapped === "object";
|
||
|
||
for (const [key, value] of Object.entries(objRecord)) {
|
||
if (SKIP_FLATTEN_KEYS.has(key)) continue;
|
||
if (key === "raw" && hasMapped) continue;
|
||
if (value === undefined || value === null || value === "") continue;
|
||
|
||
const path = prefix ? `${prefix}.${key}` : key;
|
||
if (typeof value === "object" && !(value instanceof Date)) {
|
||
rows.push(...flattenObject(value, path, depth + 1));
|
||
} else {
|
||
rows.push({
|
||
label: persianFieldPath(path),
|
||
value: asString(persianReportValue(path, value)),
|
||
});
|
||
}
|
||
}
|
||
|
||
return rows;
|
||
}
|
||
|
||
function dedupeFields(
|
||
fields: InsurerFileReportField[],
|
||
): InsurerFileReportField[] {
|
||
const seen = new Set<string>();
|
||
const out: InsurerFileReportField[] = [];
|
||
|
||
for (const field of fields) {
|
||
const value = asString(field.value);
|
||
if (!value) continue;
|
||
const key = `${field.label}::${value}`;
|
||
if (seen.has(key)) continue;
|
||
seen.add(key);
|
||
out.push({ label: field.label, value });
|
||
}
|
||
|
||
return out;
|
||
}
|
||
|
||
function filterEmptySections(
|
||
sections: Array<InsurerFileReportSection | undefined>,
|
||
): InsurerFileReportSection[] {
|
||
return sections.filter(
|
||
(section): section is InsurerFileReportSection =>
|
||
!!section && section.fields.length > 0,
|
||
);
|
||
}
|
||
|
||
function buildSection(
|
||
title: string,
|
||
fields: InsurerFileReportField[],
|
||
withPlaceholder = true,
|
||
): InsurerFileReportSection {
|
||
const deduped = dedupeFields(fields);
|
||
return {
|
||
title,
|
||
fields:
|
||
deduped.length || !withPlaceholder
|
||
? deduped
|
||
: [{ label: PR.data, value: PR.empty }],
|
||
};
|
||
}
|
||
|
||
function expertNameFromSnapshot(snapshot?: {
|
||
firstName?: string;
|
||
lastName?: string;
|
||
}): string | undefined {
|
||
if (!snapshot) return undefined;
|
||
const name = [snapshot.firstName, snapshot.lastName]
|
||
.filter(Boolean)
|
||
.join(" ");
|
||
return name || undefined;
|
||
}
|
||
|
||
function collectExpertNames(
|
||
blame?: Record<string, unknown> | null,
|
||
claim?: Record<string, unknown> | null,
|
||
): string | undefined {
|
||
const names = new Set<string>();
|
||
|
||
const blameDecision = (blame?.expert as Record<string, unknown> | undefined)
|
||
?.decision as Record<string, unknown> | undefined;
|
||
const blameExpert = expertNameFromSnapshot(
|
||
blameDecision?.expertProfileSnapshot as
|
||
| { firstName?: string; lastName?: string }
|
||
| undefined,
|
||
);
|
||
if (blameExpert) names.add(blameExpert);
|
||
|
||
const evaluation = claim?.evaluation as Record<string, unknown> | undefined;
|
||
for (const key of ["damageExpertReplyFinal", "damageExpertReply"] as const) {
|
||
const reply = evaluation?.[key] as Record<string, unknown> | undefined;
|
||
if (!reply) continue;
|
||
const actor = (reply.actorDetail as { actorName?: string } | undefined)
|
||
?.actorName;
|
||
if (actor) names.add(actor);
|
||
const snap = expertNameFromSnapshot(
|
||
reply.expertProfileSnapshot as
|
||
| { firstName?: string; lastName?: string }
|
||
| undefined,
|
||
);
|
||
if (snap) names.add(snap);
|
||
}
|
||
|
||
return names.size ? [...names].join(", ") : undefined;
|
||
}
|
||
|
||
function inquiryRoleData(
|
||
inquiries: Record<string, unknown> | undefined,
|
||
key: string,
|
||
role?: string,
|
||
): Record<string, unknown> | undefined {
|
||
const block = inquiries?.[key] as Record<string, unknown> | undefined;
|
||
const data = block?.data as Record<string, unknown> | undefined;
|
||
if (!data) return undefined;
|
||
if (role && data[role] && typeof data[role] === "object") {
|
||
return data[role] as Record<string, unknown>;
|
||
}
|
||
return data;
|
||
}
|
||
|
||
function pickInquiryReportPayload(
|
||
inquiry?: Record<string, unknown>,
|
||
): Record<string, unknown> | undefined {
|
||
if (!inquiry) return undefined;
|
||
const mapped = inquiry.mapped;
|
||
if (mapped && typeof mapped === "object" && !Array.isArray(mapped)) {
|
||
return mapped as Record<string, unknown>;
|
||
}
|
||
const { raw: _raw, ...rest } = inquiry;
|
||
return Object.keys(rest).length ? rest : inquiry;
|
||
}
|
||
|
||
function resolveReportBlameContext(
|
||
blame?: Record<string, unknown> | null,
|
||
claim?: Record<string, unknown> | null,
|
||
): Record<string, unknown> | null {
|
||
if (blame) return blame;
|
||
const snapshot = claim?.snapshot as Record<string, unknown> | undefined;
|
||
if (!snapshot) return null;
|
||
return {
|
||
type:
|
||
(claim?.blameFileContext as Record<string, unknown> | undefined)
|
||
?.blameRequestType ??
|
||
(snapshot.accident as Record<string, unknown> | undefined)?.type,
|
||
blameStatus: (
|
||
claim?.blameFileContext as Record<string, unknown> | undefined
|
||
)?.blameStatus,
|
||
parties: snapshot.parties,
|
||
};
|
||
}
|
||
|
||
function getPartyRole(
|
||
party: ReportParty | null | undefined,
|
||
): string | undefined {
|
||
const role = party?.role;
|
||
return typeof role === "string" ? role : undefined;
|
||
}
|
||
|
||
function partyKindLabel(
|
||
party: ReportParty | null | undefined,
|
||
damagedParty: ReportParty | null,
|
||
guiltyParty: ReportParty | null,
|
||
): string | undefined {
|
||
if (sameParty(party, damagedParty)) return "damaged";
|
||
if (sameParty(party, guiltyParty)) return "guilty";
|
||
return undefined;
|
||
}
|
||
|
||
function partyRoleLabel(role: string | undefined): string | undefined {
|
||
if (!role) return undefined;
|
||
if (role === PartyRole.FIRST) return "طرف اول";
|
||
if (role === PartyRole.SECOND) return "طرف دوم";
|
||
return role;
|
||
}
|
||
|
||
function statementBoolean(value: unknown): string | undefined {
|
||
if (typeof value !== "boolean") return undefined;
|
||
return persianStatus(value);
|
||
}
|
||
|
||
function sameParty(
|
||
first: ReportParty | null | undefined,
|
||
second: ReportParty | null | undefined,
|
||
): boolean {
|
||
if (!first || !second) return false;
|
||
const firstUserId =
|
||
first.person?.userId != null ? String(first.person.userId) : "";
|
||
const secondUserId =
|
||
second.person?.userId != null ? String(second.person.userId) : "";
|
||
if (firstUserId && secondUserId) return firstUserId === secondUserId;
|
||
return getPartyRole(first) === getPartyRole(second);
|
||
}
|
||
|
||
function resolveEvaluationReply(
|
||
claim?: Record<string, unknown> | null,
|
||
): Record<string, unknown> | undefined {
|
||
const evaluation = claim?.evaluation as Record<string, unknown> | undefined;
|
||
return (
|
||
(evaluation?.damageExpertReplyFinal as
|
||
| Record<string, unknown>
|
||
| undefined) ??
|
||
(evaluation?.damageExpertReply as Record<string, unknown> | undefined)
|
||
);
|
||
}
|
||
|
||
function resolveEvaluationSubmittedAt(
|
||
claim: Record<string, unknown> | null | undefined,
|
||
reply: Record<string, unknown> | undefined,
|
||
): unknown {
|
||
if (reply?.submittedAt != null) return reply.submittedAt;
|
||
|
||
const history = Array.isArray(claim?.history) ? claim.history : [];
|
||
const submittedEvent = [...history]
|
||
.reverse()
|
||
.find((event) =>
|
||
["EXPERT_REPLY_SUBMITTED", "EXPERT_FINAL_REPLY_SUBMITTED"].includes(
|
||
String((event as Record<string, unknown>)?.type ?? ""),
|
||
),
|
||
) as Record<string, unknown> | undefined;
|
||
return submittedEvent?.timestamp;
|
||
}
|
||
|
||
function insuranceValueFromCandidates(
|
||
...values: unknown[]
|
||
): string | undefined {
|
||
for (const value of values) {
|
||
if (Array.isArray(value)) {
|
||
const listValue = normalizeListValue(value);
|
||
if (listValue) return listValue;
|
||
continue;
|
||
}
|
||
const str = asString(value);
|
||
if (str) return str;
|
||
}
|
||
return undefined;
|
||
}
|
||
|
||
function buildThirdPartyInsuranceFields(
|
||
party: ReportParty | null | undefined,
|
||
blame?: Record<string, unknown> | null,
|
||
claim?: Record<string, unknown> | null,
|
||
): InsurerFileReportField[] {
|
||
const role = getPartyRole(party);
|
||
const direct = (party?.insurance ?? {}) as Record<string, unknown>;
|
||
const blameInquiry = pickInquiryReportPayload(
|
||
inquiryRoleData(
|
||
blame?.inquiries as Record<string, unknown> | undefined,
|
||
"thirdParty",
|
||
role,
|
||
),
|
||
);
|
||
const claimInquiry = pickInquiryReportPayload(
|
||
inquiryRoleData(
|
||
claim?.inquiries as Record<string, unknown> | undefined,
|
||
"thirdParty",
|
||
role,
|
||
),
|
||
);
|
||
|
||
return [
|
||
{
|
||
label: PR.policyNumber,
|
||
value: insuranceValueFromCandidates(
|
||
direct.policyNumber,
|
||
blameInquiry?.policyNumber,
|
||
blameInquiry?.PolicyNumber,
|
||
claimInquiry?.policyNumber,
|
||
claimInquiry?.PolicyNumber,
|
||
blameInquiry?.ThirdPolicyCode,
|
||
claimInquiry?.ThirdPolicyCode,
|
||
),
|
||
},
|
||
{
|
||
label: PR.insuranceCompany,
|
||
value: insuranceValueFromCandidates(
|
||
direct.company,
|
||
direct.insurerCompany,
|
||
blameInquiry?.company,
|
||
blameInquiry?.CompanyName,
|
||
claimInquiry?.company,
|
||
claimInquiry?.CompanyName,
|
||
),
|
||
},
|
||
{
|
||
label: PR.policyStartDate,
|
||
value: insuranceValueFromCandidates(
|
||
direct.startDate,
|
||
blameInquiry?.startDate,
|
||
blameInquiry?.PolicyStartDate,
|
||
blameInquiry?.SatrtDate,
|
||
claimInquiry?.startDate,
|
||
claimInquiry?.PolicyStartDate,
|
||
claimInquiry?.SatrtDate,
|
||
),
|
||
},
|
||
{
|
||
label: PR.policyEndDate,
|
||
value: insuranceValueFromCandidates(
|
||
direct.endDate,
|
||
blameInquiry?.endDate,
|
||
blameInquiry?.PolicyEndDate,
|
||
blameInquiry?.EndDate,
|
||
claimInquiry?.endDate,
|
||
claimInquiry?.PolicyEndDate,
|
||
claimInquiry?.EndDate,
|
||
),
|
||
},
|
||
{
|
||
label: PR.financialCeiling,
|
||
value: insuranceValueFromCandidates(
|
||
direct.financialCeiling,
|
||
blameInquiry?.financialCeiling,
|
||
blameInquiry?.FinancialCvrCptl,
|
||
blameInquiry?.FnCvrCptl,
|
||
claimInquiry?.financialCeiling,
|
||
claimInquiry?.FinancialCvrCptl,
|
||
claimInquiry?.FnCvrCptl,
|
||
),
|
||
},
|
||
{
|
||
label: PR.coverages,
|
||
value: insuranceValueFromCandidates(
|
||
direct.coverages,
|
||
blameInquiry?.coverages,
|
||
claimInquiry?.coverages,
|
||
),
|
||
},
|
||
];
|
||
}
|
||
|
||
function buildCarBodyInsuranceFields(
|
||
party: ReportParty | null | undefined,
|
||
blame?: Record<string, unknown> | null,
|
||
claim?: Record<string, unknown> | null,
|
||
): InsurerFileReportField[] {
|
||
const role = getPartyRole(party);
|
||
const direct = (party?.insurance?.carBodyInsurance ??
|
||
party?.insurance?.carBody ??
|
||
{}) as Record<string, unknown>;
|
||
const blameInquiry = pickInquiryReportPayload(
|
||
inquiryRoleData(
|
||
blame?.inquiries as Record<string, unknown> | undefined,
|
||
"carBody",
|
||
role,
|
||
),
|
||
);
|
||
const claimInquiry = pickInquiryReportPayload(
|
||
inquiryRoleData(
|
||
claim?.inquiries as Record<string, unknown> | undefined,
|
||
"carBody",
|
||
role,
|
||
),
|
||
);
|
||
const legacy = (blame?.carBodyInsuranceDetail ?? {}) as Record<
|
||
string,
|
||
unknown
|
||
>;
|
||
|
||
return [
|
||
{
|
||
label: PR.policyNumber,
|
||
value: insuranceValueFromCandidates(
|
||
direct.policyNumber,
|
||
legacy.policyNumber,
|
||
blameInquiry?.policyNumber,
|
||
blameInquiry?.PolicyNumber,
|
||
claimInquiry?.policyNumber,
|
||
claimInquiry?.PolicyNumber,
|
||
),
|
||
},
|
||
{
|
||
label: PR.insuranceCompany,
|
||
value: insuranceValueFromCandidates(
|
||
direct.insurerCompany,
|
||
direct.company,
|
||
legacy.insurerCompany,
|
||
blameInquiry?.company,
|
||
blameInquiry?.CompanyName,
|
||
claimInquiry?.company,
|
||
claimInquiry?.CompanyName,
|
||
),
|
||
},
|
||
{
|
||
label: PR.policyStartDate,
|
||
value: insuranceValueFromCandidates(
|
||
direct.startDate,
|
||
legacy.startDate,
|
||
blameInquiry?.startDate,
|
||
blameInquiry?.PolicyStartDate,
|
||
claimInquiry?.startDate,
|
||
claimInquiry?.PolicyStartDate,
|
||
),
|
||
},
|
||
{
|
||
label: PR.policyEndDate,
|
||
value: insuranceValueFromCandidates(
|
||
direct.endDate,
|
||
legacy.endDate,
|
||
blameInquiry?.endDate,
|
||
blameInquiry?.PolicyEndDate,
|
||
claimInquiry?.endDate,
|
||
claimInquiry?.PolicyEndDate,
|
||
),
|
||
},
|
||
{
|
||
label: PR.coverages,
|
||
value: insuranceValueFromCandidates(
|
||
direct.coverages,
|
||
legacy.coverages,
|
||
blameInquiry?.coverages,
|
||
claimInquiry?.coverages,
|
||
),
|
||
},
|
||
];
|
||
}
|
||
|
||
function buildPartyOwnerSection(
|
||
title: string,
|
||
party: ReportParty | null | undefined,
|
||
options?: {
|
||
claim?: Record<string, unknown> | null;
|
||
useClaimOwnerFallback?: boolean;
|
||
includeSheba?: boolean;
|
||
},
|
||
): InsurerFileReportSection | undefined {
|
||
const person = party?.person as ReportRecord | undefined;
|
||
const claim = options?.claim;
|
||
const money = claim?.money as
|
||
| { sheba?: string; nationalCodeOfInsurer?: string }
|
||
| undefined;
|
||
const claimOwner = claim?.owner as { fullName?: string } | undefined;
|
||
|
||
if (!person && !options?.useClaimOwnerFallback) return undefined;
|
||
|
||
return buildSection(title, [
|
||
{
|
||
label: PR.name,
|
||
value: options?.useClaimOwnerFallback
|
||
? firstDefined(person?.fullName, claimOwner?.fullName)
|
||
: firstDefined(person?.fullName),
|
||
},
|
||
{ label: PR.phone, value: asString(person?.phoneNumber) },
|
||
{
|
||
label: PR.nationalCode,
|
||
value: options?.useClaimOwnerFallback
|
||
? firstDefined(
|
||
person?.nationalCodeOfInsurer,
|
||
money?.nationalCodeOfInsurer,
|
||
)
|
||
: firstDefined(person?.nationalCodeOfInsurer, person?.nationalCode),
|
||
},
|
||
{
|
||
label: PR.birthDate,
|
||
value: formatBirthDate(
|
||
person?.insurerBirthday ?? person?.birthday ?? person?.driverBirthday,
|
||
),
|
||
},
|
||
{
|
||
label: PR.sheba,
|
||
value: options?.includeSheba ? money?.sheba : undefined,
|
||
},
|
||
]);
|
||
}
|
||
|
||
function buildParticipantRolesSection(
|
||
title: string,
|
||
party: ReportParty | null | undefined,
|
||
): InsurerFileReportSection | undefined {
|
||
const participants =
|
||
sanitizeStoredInquiryParticipants(party?.participants) ?? [];
|
||
const assignments = party?.participantRoles;
|
||
if (!assignments || participants.length === 0) return undefined;
|
||
|
||
const roleLabels: Record<string, string> = {
|
||
driver: PR.driverRole,
|
||
vehicleOwner: PR.vehicleOwnerRole,
|
||
thirdPartyPolicyholder: PR.thirdPartyPolicyholderRole,
|
||
carBodyPolicyholder: PR.carBodyPolicyholderRole,
|
||
};
|
||
const fields = Object.entries(assignments).map(([role, participantId]) => {
|
||
const participant = participants.find(
|
||
(candidate) => String(candidate.participantId) === String(participantId),
|
||
);
|
||
const value = [
|
||
asString(participant?.fullName),
|
||
participant?.nationalCode
|
||
? `${PR.nationalCode}: ${asString(participant.nationalCode)}`
|
||
: undefined,
|
||
participant?.birthday
|
||
? `${PR.birthDate}: ${formatBirthDate(participant.birthday)}`
|
||
: undefined,
|
||
participant?.licenseNumber
|
||
? `${PR.licenseNumber}: ${asString(participant.licenseNumber)}`
|
||
: undefined,
|
||
participant?.hasDrivingLicense != null
|
||
? `${PR.hasDrivingLicense}: ${persianStatus(participant.hasDrivingLicense)}`
|
||
: undefined,
|
||
participant?.licenseType
|
||
? `${PR.licenseType}: ${asString(
|
||
persianReportValue(
|
||
"participant.licenseType",
|
||
participant.licenseType,
|
||
),
|
||
)}`
|
||
: undefined,
|
||
]
|
||
.filter(Boolean)
|
||
.join("، ");
|
||
return {
|
||
label: roleLabels[role] ?? persianFieldPath(role),
|
||
value: value || PR.empty,
|
||
};
|
||
});
|
||
|
||
return buildSection(title, fields, false);
|
||
}
|
||
|
||
function licenseFieldsFromInquiry(inquiry?: Record<string, unknown>): {
|
||
licenseType?: string;
|
||
licenseDate?: string;
|
||
} {
|
||
if (!inquiry) return {};
|
||
return {
|
||
licenseType: firstDefined(
|
||
inquiry.LicenseType,
|
||
inquiry.licenseType,
|
||
inquiry.Type,
|
||
inquiry.type,
|
||
inquiry.LicenseCategory,
|
||
inquiry.licenseCategory,
|
||
),
|
||
licenseDate: firstDefined(
|
||
inquiry.IssueDate,
|
||
inquiry.issueDate,
|
||
inquiry.LicenseIssueDate,
|
||
inquiry.licenseIssueDate,
|
||
inquiry.ExpireDate,
|
||
inquiry.expireDate,
|
||
),
|
||
};
|
||
}
|
||
|
||
function buildDriverSection(
|
||
damagedParty: ReportParty | null,
|
||
blame?: Record<string, unknown> | null,
|
||
): InsurerFileReportSection | undefined {
|
||
const person = damagedParty?.person as ReportRecord | undefined;
|
||
if (!person || person.driverIsInsurer !== false) return undefined;
|
||
|
||
const role = damagedParty?.role ?? PartyRole.FIRST;
|
||
const licenseInquiry = inquiryRoleData(
|
||
blame?.inquiries as Record<string, unknown> | undefined,
|
||
"drivingLicence",
|
||
String(role),
|
||
);
|
||
const { licenseType, licenseDate } = licenseFieldsFromInquiry(licenseInquiry);
|
||
|
||
return buildSection(PR.driverSection, [
|
||
{ label: PR.name, value: asString(person.fullName) },
|
||
{
|
||
label: PR.licenseType,
|
||
value:
|
||
asString(
|
||
persianReportValue(
|
||
"participant.licenseType",
|
||
licenseType ?? person.licenseType,
|
||
),
|
||
) ??
|
||
(person.driverLicense ? PR.driverLicense : undefined),
|
||
},
|
||
{
|
||
label: PR.licenseDate,
|
||
value: licenseDate ?? asString(person.driverLicense),
|
||
},
|
||
{ label: PR.phone, value: asString(person.phoneNumber) },
|
||
{ label: PR.nationalCode, value: asString(person.nationalCodeOfDriver) },
|
||
{ label: PR.birthDate, value: formatBirthDate(person.driverBirthday) },
|
||
{ label: PR.licenseNumber, value: asString(person.driverLicense) },
|
||
]);
|
||
}
|
||
|
||
function buildPartyVehicleSection(
|
||
title: string,
|
||
party: ReportParty | null | undefined,
|
||
claimVehicle?: Record<string, unknown>,
|
||
): InsurerFileReportSection | undefined {
|
||
if (!party && !claimVehicle) return undefined;
|
||
|
||
return buildSection(title, [
|
||
...flattenObject(claimVehicle, "claim.vehicle"),
|
||
...flattenObject(party?.vehicle, "party.vehicle"),
|
||
]);
|
||
}
|
||
|
||
function buildPartyStatementSection(
|
||
title: string,
|
||
party: ReportParty | null | undefined,
|
||
damagedParty: ReportParty | null,
|
||
guiltyParty: ReportParty | null,
|
||
): InsurerFileReportSection | undefined {
|
||
if (!party) return undefined;
|
||
const statement = (party.statement ?? {}) as ReportRecord;
|
||
const kind = partyKindLabel(party, damagedParty, guiltyParty);
|
||
|
||
return buildSection(title, [
|
||
{
|
||
label: PR.partyRole,
|
||
value: partyRoleLabel(getPartyRole(party)),
|
||
},
|
||
{
|
||
label: PR.name,
|
||
value: firstDefined(party.person?.fullName),
|
||
},
|
||
{
|
||
label: PR.admitsGuilt,
|
||
value:
|
||
kind === "damaged"
|
||
? undefined
|
||
: statementBoolean(statement.admitsGuilt),
|
||
},
|
||
{
|
||
label: PR.claimsDamage,
|
||
value:
|
||
kind === "guilty"
|
||
? undefined
|
||
: statementBoolean(statement.claimsDamage),
|
||
},
|
||
{
|
||
label: PR.acceptsExpertOpinion,
|
||
value: statementBoolean(statement.acceptsExpertOpinion),
|
||
},
|
||
{
|
||
label: PR.partyDescription,
|
||
value: asString(statement.description),
|
||
},
|
||
]);
|
||
}
|
||
|
||
function buildCaseTimelineSection(
|
||
overview?: Record<string, unknown> | null,
|
||
claim?: Record<string, unknown> | null,
|
||
): InsurerFileReportSection {
|
||
const evaluationReply = resolveEvaluationReply(claim);
|
||
return buildSection(PR.timelineSection, [
|
||
{
|
||
label: PR.fileRegisteredAt,
|
||
value: formatDateTime(overview?.createdAt),
|
||
},
|
||
{
|
||
label: PR.evaluationRegisteredAt,
|
||
value: formatDateTime(
|
||
resolveEvaluationSubmittedAt(claim, evaluationReply),
|
||
),
|
||
},
|
||
]);
|
||
}
|
||
|
||
function buildFanavaranCodesSection(
|
||
claim?: Record<string, unknown> | null,
|
||
): InsurerFileReportSection | undefined {
|
||
if (!claim) return undefined;
|
||
const sync =
|
||
(claim.fanavaranSync as Record<string, unknown> | undefined) ?? {};
|
||
const baseClaim =
|
||
(sync.baseClaim as Record<string, unknown> | undefined) ?? {};
|
||
const damageCase =
|
||
(sync.damageCase as Record<string, unknown> | undefined) ?? {};
|
||
const expertise =
|
||
(sync.expertise as Record<string, unknown> | undefined) ?? {};
|
||
|
||
return buildSection(PR.fanavaranSection, [
|
||
{
|
||
label: PR.fanavaranClaimNo,
|
||
value: firstDefined(claim.claimNo, baseClaim.claimNo),
|
||
},
|
||
{
|
||
label: PR.fanavaranClaimId,
|
||
value: firstDefined(claim.claimId, baseClaim.claimId),
|
||
},
|
||
{
|
||
label: PR.fanavaranDamageCaseId,
|
||
value: firstDefined(
|
||
claim.dmgCaseId,
|
||
damageCase.dmgCaseId,
|
||
expertise.dmgCaseId,
|
||
),
|
||
},
|
||
{
|
||
label: PR.fanavaranExpertiseId,
|
||
value: firstDefined(claim.expertiseId, expertise.expertiseId),
|
||
},
|
||
{
|
||
label: PR.fanavaranPolicyId,
|
||
value: firstDefined(baseClaim.policyId),
|
||
},
|
||
{
|
||
label: PR.fanavaranDriverId,
|
||
value: firstDefined(baseClaim.driverId),
|
||
},
|
||
{
|
||
label: PR.fanavaranVehicleKindId,
|
||
value: firstDefined(baseClaim.vehicleKindId),
|
||
},
|
||
{
|
||
label: PR.fanavaranInsuranceCorpId,
|
||
value: firstDefined(baseClaim.insuranceCorpId),
|
||
},
|
||
]);
|
||
}
|
||
|
||
function buildEvaluationSection(
|
||
claim?: Record<string, unknown> | null,
|
||
): InsurerFileReportSection | undefined {
|
||
if (!claim) return undefined;
|
||
const reply = resolveEvaluationReply(claim);
|
||
const actorDetail = reply?.actorDetail as { actorName?: string } | undefined;
|
||
const snapshotName = expertNameFromSnapshot(
|
||
reply?.expertProfileSnapshot as
|
||
| { firstName?: string; lastName?: string }
|
||
| undefined,
|
||
);
|
||
|
||
return buildSection(PR.evaluationSection, [
|
||
{
|
||
label: PR.evaluationResult,
|
||
value: persianStatus(claim.claimStatus),
|
||
},
|
||
{
|
||
label: PR.evaluationExpert,
|
||
value: actorDetail?.actorName ?? snapshotName,
|
||
},
|
||
{
|
||
label: PR.evaluationSubmittedAt,
|
||
value: formatDateTime(resolveEvaluationSubmittedAt(claim, reply)),
|
||
},
|
||
{
|
||
label: PR.evaluationResponse,
|
||
value: asString(reply?.description),
|
||
},
|
||
]);
|
||
}
|
||
|
||
function evaluationPartName(part: ReportRecord): string | undefined {
|
||
const damage = part.carPartDamage;
|
||
if (damage && typeof damage === "object" && !Array.isArray(damage)) {
|
||
const record = damage as ReportRecord;
|
||
return firstDefined(
|
||
record.label_fa,
|
||
record.name,
|
||
record.part,
|
||
record.label,
|
||
part.partId != null ? `${PR.part} ${part.partId}` : undefined,
|
||
);
|
||
}
|
||
return firstDefined(
|
||
damage,
|
||
part.partName,
|
||
part.partId != null ? `${PR.part} ${part.partId}` : undefined,
|
||
);
|
||
}
|
||
|
||
function evaluationDaghiValue(value: unknown): string | undefined {
|
||
if (!value || typeof value !== "object" || Array.isArray(value)) {
|
||
return asString(value);
|
||
}
|
||
const daghi = value as ReportRecord;
|
||
const option = asString(persianReportValue("daghi.option", daghi.option));
|
||
const price = formatToman(daghi.price);
|
||
return [option, price].filter(Boolean).join(" - ") || undefined;
|
||
}
|
||
|
||
function buildEvaluationPartsSection(
|
||
claim?: Record<string, unknown> | null,
|
||
): InsurerFileReportSection | undefined {
|
||
const reply = resolveEvaluationReply(claim);
|
||
const parts = Array.isArray(reply?.parts)
|
||
? (reply.parts as ReportRecord[])
|
||
: [];
|
||
if (!parts.length) return undefined;
|
||
|
||
const fields = parts.flatMap((part, index) => {
|
||
const prefix = `${PR.part} ${PERSIAN_NUMBER_FORMATTER.format(index + 1)}`;
|
||
return [
|
||
{ label: `${prefix} / ${PR.partName}`, value: evaluationPartName(part) },
|
||
{
|
||
label: `${prefix} / ${PR.damageType}`,
|
||
value: asString(
|
||
persianReportValue("evaluation.part.typeOfDamage", part.typeOfDamage),
|
||
),
|
||
},
|
||
{ label: `${prefix} / ${PR.partPrice}`, value: formatToman(part.price) },
|
||
{
|
||
label: `${prefix} / ${PR.repairSalary}`,
|
||
value: formatToman(part.salary),
|
||
},
|
||
{
|
||
label: `${prefix} / ${PR.totalPayment}`,
|
||
value: formatToman(part.totalPayment),
|
||
},
|
||
{
|
||
label: `${prefix} / ${PR.factorNeeded}`,
|
||
value:
|
||
typeof part.factorNeeded === "boolean"
|
||
? persianStatus(part.factorNeeded)
|
||
: undefined,
|
||
},
|
||
{
|
||
label: `${prefix} / ${PR.daghi}`,
|
||
value: evaluationDaghiValue(part.daghi),
|
||
},
|
||
];
|
||
});
|
||
|
||
return buildSection(PR.evaluationPartsSection, fields, false);
|
||
}
|
||
|
||
function buildAccidentReportSection(
|
||
blame?: Record<string, unknown> | null,
|
||
claim?: Record<string, unknown> | null,
|
||
damagedParty?: ReportParty | null,
|
||
): InsurerFileReportSection {
|
||
const statement = damagedParty?.statement as ReportRecord | undefined;
|
||
const location = damagedParty?.location;
|
||
const snapshotAccident = (
|
||
claim?.snapshot as { accident?: Record<string, unknown> } | undefined
|
||
)?.accident;
|
||
const blameDecision = (blame?.expert as Record<string, unknown> | undefined)
|
||
?.decision as Record<string, unknown> | undefined;
|
||
const decisionFields = blameDecision?.fields as
|
||
| Record<string, unknown>
|
||
| undefined;
|
||
|
||
return buildSection(PR.accidentSection, [
|
||
{
|
||
label: PR.accidentDate,
|
||
value:
|
||
asString(statement?.accidentDate) ??
|
||
asString(snapshotAccident?.date) ??
|
||
asString(blame?.createdAtFormatted) ??
|
||
formatDateTime(blame?.createdAt),
|
||
},
|
||
{
|
||
label: PR.accidentTime,
|
||
value:
|
||
asString(statement?.accidentTime) ?? asString(snapshotAccident?.time),
|
||
},
|
||
{
|
||
label: PR.experts,
|
||
value: collectExpertNames(blame, claim),
|
||
},
|
||
{
|
||
label: PR.location,
|
||
value:
|
||
location?.lat != null && location?.lon != null
|
||
? `${location.lat}، ${location.lon}`
|
||
: undefined,
|
||
},
|
||
{
|
||
label: PR.weather,
|
||
value: persianAccidentCondition(
|
||
"weather",
|
||
statement?.weatherCondition ?? snapshotAccident?.weatherCondition,
|
||
),
|
||
},
|
||
{
|
||
label: PR.road,
|
||
value: persianAccidentCondition(
|
||
"road",
|
||
statement?.roadCondition ?? snapshotAccident?.roadCondition,
|
||
),
|
||
},
|
||
{
|
||
label: PR.light,
|
||
value: persianAccidentCondition(
|
||
"light",
|
||
statement?.lightCondition ?? snapshotAccident?.lightCondition,
|
||
),
|
||
},
|
||
{
|
||
label: PR.blameStatus,
|
||
value: persianStatus(blame?.blameStatus),
|
||
},
|
||
{
|
||
label: PR.claimStatus,
|
||
value: persianStatus(claim?.claimStatus),
|
||
},
|
||
{ label: PR.expertDecision, value: asString(blameDecision?.description) },
|
||
{
|
||
label: PR.accidentWay,
|
||
value: asString(
|
||
(decisionFields?.accidentWay as { label?: string } | undefined)
|
||
?.label ??
|
||
(
|
||
snapshotAccident?.classification as {
|
||
accidentWay?: { label?: string };
|
||
}
|
||
)?.accidentWay?.label,
|
||
),
|
||
},
|
||
{
|
||
label: PR.accidentReason,
|
||
value: asString(
|
||
(decisionFields?.accidentReason as { label?: string } | undefined)
|
||
?.label ??
|
||
(
|
||
snapshotAccident?.classification as {
|
||
accidentReason?: { label?: string };
|
||
}
|
||
)?.accidentReason?.label,
|
||
),
|
||
},
|
||
{
|
||
label: PR.accidentType,
|
||
value: asString(
|
||
(decisionFields?.accidentType as { label?: string } | undefined)
|
||
?.label ??
|
||
(
|
||
snapshotAccident?.classification as {
|
||
accidentType?: { label?: string };
|
||
}
|
||
)?.accidentType?.label,
|
||
),
|
||
},
|
||
{
|
||
label: PR.partyDescription,
|
||
value: asString(statement?.description),
|
||
},
|
||
]);
|
||
}
|
||
|
||
export function buildInsurerFileReport(file: {
|
||
overview?: Record<string, unknown>;
|
||
blame?: Record<string, unknown>;
|
||
claim?: Record<string, unknown>;
|
||
}): InsurerFileReportViewModel {
|
||
const overview = file.overview ?? {};
|
||
const claim = file.claim ?? null;
|
||
const blame = file.blame ?? null;
|
||
const blameContext = resolveReportBlameContext(blame, claim);
|
||
const damagedParty = blameContext
|
||
? (resolveDamagedPartyRow(blameContext as any) as ReportParty | null)
|
||
: null;
|
||
const guiltyParty = blameContext
|
||
? (resolveClaimOwnerParty(blameContext as any) as ReportParty | null)
|
||
: null;
|
||
const isCarBody =
|
||
String((blameContext?.type as string | undefined) ?? "") === "CAR_BODY";
|
||
const includeGuiltySections =
|
||
!!guiltyParty && !(isCarBody && sameParty(damagedParty, guiltyParty));
|
||
|
||
const claimVehicle = claim?.vehicle as Record<string, unknown> | undefined;
|
||
|
||
const sections = filterEmptySections([
|
||
buildCaseTimelineSection(overview, claim),
|
||
buildParticipantRolesSection(PR.damagedParticipantsSection, damagedParty),
|
||
includeGuiltySections
|
||
? buildParticipantRolesSection(PR.guiltyParticipantsSection, guiltyParty)
|
||
: undefined,
|
||
buildPartyOwnerSection(PR.ownerSection, damagedParty, {
|
||
claim,
|
||
useClaimOwnerFallback: true,
|
||
includeSheba: true,
|
||
}),
|
||
includeGuiltySections
|
||
? buildPartyOwnerSection(PR.guiltyOwnerSection, guiltyParty)
|
||
: undefined,
|
||
buildDriverSection(damagedParty, blameContext),
|
||
buildSection(
|
||
PR.damagedThirdPartyInsuranceSection,
|
||
buildThirdPartyInsuranceFields(damagedParty, blameContext, claim),
|
||
),
|
||
buildSection(
|
||
PR.damagedCarBodyInsuranceSection,
|
||
buildCarBodyInsuranceFields(damagedParty, blameContext, claim),
|
||
),
|
||
includeGuiltySections
|
||
? buildSection(
|
||
PR.guiltyThirdPartyInsuranceSection,
|
||
buildThirdPartyInsuranceFields(guiltyParty, blameContext, claim),
|
||
)
|
||
: undefined,
|
||
includeGuiltySections
|
||
? buildSection(
|
||
PR.guiltyCarBodyInsuranceSection,
|
||
buildCarBodyInsuranceFields(guiltyParty, blameContext, claim),
|
||
)
|
||
: undefined,
|
||
buildPartyVehicleSection(
|
||
PR.damagedVehicleSection,
|
||
damagedParty,
|
||
claimVehicle,
|
||
),
|
||
includeGuiltySections
|
||
? buildPartyVehicleSection(PR.guiltyVehicleSection, guiltyParty)
|
||
: undefined,
|
||
buildPartyStatementSection(
|
||
PR.damagedStatementSection,
|
||
damagedParty,
|
||
damagedParty,
|
||
guiltyParty,
|
||
),
|
||
includeGuiltySections
|
||
? buildPartyStatementSection(
|
||
PR.guiltyStatementSection,
|
||
guiltyParty,
|
||
damagedParty,
|
||
guiltyParty,
|
||
)
|
||
: undefined,
|
||
buildFanavaranCodesSection(claim),
|
||
buildEvaluationSection(claim),
|
||
buildEvaluationPartsSection(claim),
|
||
buildAccidentReportSection(blameContext, claim, damagedParty),
|
||
]);
|
||
|
||
return {
|
||
title: PR.reportTitle,
|
||
publicId: asString(overview.publicId) ?? PR.empty,
|
||
requestNo: asString(overview.requestNo),
|
||
sections,
|
||
};
|
||
}
|