s.hajizadeh/yara724api
1
0
Fork 0
forked from Yara724/api
Code Pull Requests Activity

merge upstream

Browse Source
This commit is contained in:
Soheil Hajizadeh
2026-06-01 16:02:06 +03:30
parent 4bc5889ccd a47c6f1c96
commit 519d91102f
11 changed files with 1115 additions and 797 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/claim-request-management/claim-request-management.service.ts
View File

@@ -3985,7 +3985,10 @@ export class ClaimRequestManagementService {
...(currentUserParty.person?.clientId
? {
clientId: new Types.ObjectId(
currentUserParty.person.clientId as any,
String(blameRequest?.expert?.decision?.guiltyPartyId) ===
String(blameRequest?.parties[0]?.person?.userId)
? blameRequest?.parties[0]?.person?.clientId
: blameRequest?.parties[1]?.person?.clientId,
),
}
: {}),
@@ -4651,11 +4654,8 @@ export class ClaimRequestManagementService {
const updatePayload: any = {
"damage.otherParts": otherParts.length > 0 ? otherParts : undefined,
...(step !== ClaimWorkflowStep.USER_EXPERT_RESEND && {
"money.sheba": "",
"money.nationalCodeOfInsurer": nationalCode,
}),
"money.sheba": shebaNumber,
"money.nationalCodeOfInsurer": nationalCode,
status: ClaimWorkflowStep.CAPTURE_PART_DAMAGES,
"workflow.currentStep": ClaimWorkflowStep.CAPTURE_PART_DAMAGES,

185
src/expert-blame/expert-blame.service.ts
View File

@@ -303,66 +303,58 @@ export class ExpertBlameService {
requireActorClientKey(actor);
const expertId = actor.sub;
// Fetch all DISAGREEMENT cases
const allCases = await this.blameRequestDbService.find(
{
blameStatus: BlameStatus.DISAGREEMENT,
},
{ blameStatus: BlameStatus.DISAGREEMENT },
{ lean: true },
);
// Filter to show only:
// 1. Same insurance tenant (party clientId or expert-initiated by this actor)
// 2. Fresh requests (WAITING_FOR_EXPERT and no decision)
// 3. Requests decided by current expert
// 4. Expert-initiated: only the initiating field expert sees them
const visibleCases = (allCases as Record<string, unknown>[]).filter(
(doc) => {
if (!blameCaseAccessibleToExpert(doc, actor)) {
return false;
}
const expertInitiated = doc.expertInitiated === true;
const initiatedByFieldExpertId = doc.initiatedByFieldExpertId;
if (expertInitiated && initiatedByFieldExpertId) {
if (String(initiatedByFieldExpertId) !== expertId) {
return false; // Only the initiating field expert can see this file
}
return true; // Initiating expert can see their expert-initiated file
}
// Always filter by tenant first
if (!blameCaseAccessibleToExpert(doc, actor)) return false;
const status = doc.status as string;
const decision = doc.expert as any;
const decidedByExpertId = decision?.decision?.decidedByExpertId;
const hasDecision = !!decision?.decision;
const decision = (doc.expert as any)?.decision;
const decidedByExpertId = decision?.decidedByExpertId
? String(decision.decidedByExpertId)
: null;
const lockedById = String(
(doc.workflow as any)?.lockedBy?.actorId ?? "",
);
const lockEnforced =
(doc.workflow as any)?.locked &&
this.isBlameV2WorkflowLockCurrentlyEnforced(doc as any);
// Fresh request (no decision yet)
if (status === CaseStatus.WAITING_FOR_EXPERT && !hasDecision) {
return true;
// Expert-initiated files: only the initiating expert sees them
if (doc.expertInitiated === true && doc.initiatedByFieldExpertId) {
return String(doc.initiatedByFieldExpertId) === expertId;
}
// Request decided by current expert
if (decidedByExpertId && String(decidedByExpertId) === expertId) {
return true;
}
// Locked by current expert but no decision yet
const lockedBy =
decision?.resend?.requestedByExpertId ||
(doc.workflow as any)?.lockedBy?.actorId;
if (
// Bucket 1: Available — waiting, no decision, no active lock by someone else
const isAvailable =
status === CaseStatus.WAITING_FOR_EXPERT &&
lockedBy &&
String(lockedBy) === expertId
) {
return true;
}
!decidedByExpertId &&
(!lockEnforced || lockedById === expertId);
return false;
// Bucket 2: Mine — decided by me
const isDecidedByMe =
!!decidedByExpertId && decidedByExpertId === expertId;
// Bucket 3: Mine — currently locked/assigned to me (in progress)
const isLockedByMe = lockEnforced && lockedById === expertId;
// Bucket 4: Mine — persistently assigned to me for review
const assignedForReviewById = String(
(doc.workflow as any)?.assignedForReviewBy?.actorId ?? "",
);
const isAssignedToMe =
!!assignedForReviewById && assignedForReviewById === expertId;
return isAvailable || isDecidedByMe || isLockedByMe || isAssignedToMe;
},
);
// Reconcile stale locks in-memory (same as before)
const staleIds = new Set<string>();
for (const doc of visibleCases) {
const w = doc.workflow as Record<string, unknown> | undefined;
@@ -564,6 +556,7 @@ export class ExpertBlameService {
const assigneeToPersist = blameWorkflowAssigneeToPersistOnLockExpiry(
request.workflow,
request,
);
const expireSet: Record<string, unknown> = { "workflow.locked": false };
if (assigneeToPersist) {
@@ -854,75 +847,79 @@ export class ExpertBlameService {
actor: any,
): Promise<Record<string, unknown>> {
try {
// requireActorClientKey(actor);
const actorId = actor.sub;
await this.expireBlameCaseWorkflowLockV2IfStale(requestId);
const doc =
await this.blameRequestDbService.findByIdWithoutHistory(requestId);
if (!doc) {
throw new NotFoundException("Request not found");
}
// assertBlameCaseForExpertTenant(doc, actor);
const type = doc.type as string;
if (type === BlameRequestType.CAR_BODY) {
// Tenant check
assertBlameCaseForExpertTenant(doc, actor);
if (doc.type === BlameRequestType.CAR_BODY) {
throw new ForbiddenException(
"CAR_BODY type requests are automatically handled and do not require expert review.",
);
}
// Access control
const expertInitiated = doc.expertInitiated === true;
const initiatedByFieldExpertId = doc.initiatedByFieldExpertId;
// Expert-initiated: only the initiating expert
if (
expertInitiated &&
initiatedByFieldExpertId &&
String(initiatedByFieldExpertId) !== actorId
doc.expertInitiated === true &&
doc.initiatedByFieldExpertId &&
String(doc.initiatedByFieldExpertId) !== actorId
) {
throw new ForbiddenException(
"Only the field expert who created this file can view and review it.",
);
}
if (this.isBlameV2WorkflowLockCurrentlyEnforced(doc)) {
const w = doc.workflow as
| { lockedBy?: { actorId?: unknown } }
| undefined;
const lockerId = String(w?.lockedBy?.actorId ?? "");
if (lockerId && lockerId !== actorId) {
const decision = (doc.expert as any)?.decision;
const decidedByExpertId = decision?.decidedByExpertId
? String(decision.decidedByExpertId)
: null;
const lockedById = String((doc.workflow as any)?.lockedBy?.actorId ?? "");
const lockEnforced =
(doc.workflow as any)?.locked &&
this.isBlameV2WorkflowLockCurrentlyEnforced(doc);
const assignedForReviewById = String(
(doc.workflow as any)?.assignedForReviewBy?.actorId ?? "",
);
// Access gates — must satisfy at least one bucket
const isAvailable =
doc.status === CaseStatus.WAITING_FOR_EXPERT && !decidedByExpertId;
const isDecidedByMe = decidedByExpertId === actorId;
const isLockedByMe = lockEnforced && lockedById === actorId;
const isAssignedToMe =
!!assignedForReviewById && assignedForReviewById === actorId;
if (!isAvailable && !isDecidedByMe && !isLockedByMe && !isAssignedToMe) {
// Give a specific reason if possible
if (lockEnforced && lockedById && lockedById !== actorId) {
throw new ForbiddenException(
"This request is locked by another expert.",
);
}
}
const decision = (doc.expert as any)?.decision;
const decidedByExpertId = decision?.decidedByExpertId;
if (decidedByExpertId && String(decidedByExpertId) !== actorId) {
if (decidedByExpertId && decidedByExpertId !== actorId) {
throw new ForbiddenException(
"You do not have permission to view this request. It has been handled by another expert.",
);
}
throw new ForbiddenException(
"You do not have permission to view this request. It has been handled by another expert.",
"You do not have permission to view this request.",
);
}
// Build evidence URLs
const parties = Array.isArray(doc.parties) ? doc.parties : [];
const typedParties = parties as Array<{
vehicle?: {
inquiry?: {
mapped?: any;
};
};
evidence?: {
videoId?: string | number;
voices?: (string | number)[];
videoUrl?: string;
voiceUrls?: string[];
};
}>;
// Evidence (videos + voices)
for (const party of typedParties) {
for (const party of parties as Array<{
evidence?: Record<string, unknown>;
}>) {
if (!party.evidence) continue;
const evidence = party.evidence as Record<string, unknown>;
const evidence = party.evidence;
if (evidence.videoId) {
const videoDoc = await this.blameVideoDbService.findById(
@@ -931,7 +928,7 @@ export class ExpertBlameService {
if (videoDoc?.path) evidence.videoUrl = buildFileLink(videoDoc.path);
}
if (evidence.voices && Array.isArray(evidence.voices)) {
if (Array.isArray(evidence.voices)) {
const voiceUrls: string[] = [];
for (const voiceId of evidence.voices) {
const voiceDoc = await this.blameVoiceDbService.findById(
@@ -950,31 +947,31 @@ export class ExpertBlameService {
const updatedAt = doc.updatedAt
? new Date(doc.updatedAt as string | number)
: new Date();
const [createdDate, createdTime] = toJalaliDateAndTime(createdAt);
const [updatedDate, updatedTime] = toJalaliDateAndTime(updatedAt);
doc.createdAtFormatted = `${createdDate} ${createdTime}`;
doc.updatedAtFormatted = `${updatedDate} ${updatedTime}`;
// Omit heavy SandHub inquiry blob from expert response (keep other vehicle fields)
for (const party of typedParties) {
const veh = party?.vehicle as Record<string, unknown> | undefined;
if (veh && Object.prototype.hasOwnProperty.call(veh, "inquiry")) {
delete veh.inquiry;
// Strip heavy SandHub inquiry blob
for (const party of parties as Array<{
vehicle?: Record<string, unknown>;
}>) {
if (
party.vehicle &&
Object.prototype.hasOwnProperty.call(party.vehicle, "inquiry")
) {
delete party.vehicle.inquiry;
}
}
return doc;
} catch (error) {
if (error instanceof HttpException) throw error;
this.logger.error(
"findOneV2 failed",
requestId,
error instanceof Error ? error.stack : String(error),
);
throw new InternalServerErrorException(
error instanceof Error
? error.message

138
src/expert-claim/dto/claim-damaged-part.enricher.ts Normal file
View File

@@ -0,0 +1,138 @@
// claim-damaged-part.enricher.ts
import {
DamagedPartCaptureStatus,
EnrichedDamagedPart,
} from "./claim-damaged-part.types";
export function buildEnrichedDamagedParts(params: {
selectedParts: any[];
damagedPartsData: any;
evaluationBlock: any;
expertAddedParts?: any[];
getDamagedPartCaptureBlob: (data: any, key: string, parts: any[]) => any;
hasDamagedPartCapture: (data: any, key: string, parts: any[]) => boolean;
catalogLikeKeyFromPart: (part: any) => string;
buildFileLink: (path: string) => string;
}): EnrichedDamagedPart[] {
const {
selectedParts,
damagedPartsData,
evaluationBlock,
expertAddedParts = [],
getDamagedPartCaptureBlob,
hasDamagedPartCapture,
catalogLikeKeyFromPart,
buildFileLink,
} = params;
const priceDropLines: any[] = evaluationBlock?.priceDrop?.partLines ?? [];
const objectionParts: any[] =
evaluationBlock?.objection?.objectionParts ?? [];
const newObjectionParts: any[] = evaluationBlock?.objection?.newParts ?? [];
// Resend block — lives at evaluation.damageExpertResend
const damageExpertResend = evaluationBlock?.damageExpertResend;
const resendCarParts: any[] = damageExpertResend?.resendCarParts ?? [];
const resendFulfilledAt: Date | undefined = damageExpertResend?.fulfilledAt;
function isPartInResend(sp: any): boolean {
return resendCarParts.some(
(r: any) =>
r.id === sp.id || r.name === sp.name || r.catalogKey === sp.catalogKey,
);
}
function resolveOrigin(sp: any): EnrichedDamagedPart["origin"] {
if (
newObjectionParts.some((p: any) => p.id === sp.id || p.name === sp.name)
) {
return "added_by_objection";
}
if (
expertAddedParts.some((p: any) => p.id === sp.id || p.name === sp.name)
) {
return "added_by_expert";
}
return "user_selected";
}
function resolveCaptureStatus(
sp: any,
captured: boolean,
): DamagedPartCaptureStatus {
const inResend = isPartInResend(sp);
if (!captured) {
return inResend ? "resend_requested" : "pending";
}
// captured=true + was in a resend request that is now fulfilled → "resent"
return inResend && resendFulfilledAt ? "resent" : "uploaded";
}
return selectedParts.map((sp, index) => {
const ck = sp.catalogKey ?? catalogLikeKeyFromPart(sp);
const cap = getDamagedPartCaptureBlob(
damagedPartsData,
ck,
selectedParts,
) as { url?: string; path?: string } | undefined;
const captured = hasDamagedPartCapture(damagedPartsData, ck, selectedParts);
const url = cap?.url || (cap?.path ? buildFileLink(cap.path) : undefined);
const matchingPriceDrop = priceDropLines.find(
(line: any) =>
line.partId === sp.id ||
line.priceDropPartKey?.toLowerCase() === sp.name?.toLowerCase(),
);
const isObjected = objectionParts.some(
(p: any) => p.id === sp.id || p.name === sp.name,
);
const isNewlyAdded = newObjectionParts.some(
(p: any) => p.id === sp.id || p.name === sp.name,
);
const isNewByExpert = expertAddedParts.some(
(p: any) => p.id === sp.id || p.name === sp.name,
);
const inResend = isPartInResend(sp);
return {
index,
partId: sp.id ?? null,
id: sp.id ?? null,
name: sp.name,
side: sp.side,
label_fa: sp.label_fa,
...(sp.catalogKey ? { catalogKey: sp.catalogKey } : {}),
origin: resolveOrigin(sp),
captureStatus: resolveCaptureStatus(sp, captured),
captured,
url,
objection: {
isObjected,
isNewlyAdded,
...(isNewlyAdded ? { addedBy: isNewByExpert ? "expert" : "user" } : {}),
},
resend: {
wasRequested: inResend,
isFulfilled: inResend && !!resendFulfilledAt,
...(inResend && damageExpertResend?.requestedAt
? { requestedAt: damageExpertResend.requestedAt }
: {}),
...(inResend && resendFulfilledAt
? { fulfilledAt: resendFulfilledAt }
: {}),
},
pricing: {
hasPriceDrop: !!matchingPriceDrop,
severity: matchingPriceDrop?.severity ?? null,
coefficient: matchingPriceDrop?.coefficient ?? null,
},
};
});
}

40
src/expert-claim/dto/claim-damaged-part.types.ts Normal file
View File

@@ -0,0 +1,40 @@
// claim-damaged-part.types.ts — update the type
export type DamagedPartCaptureStatus =
| "pending" // never uploaded
| "uploaded" // uploaded, no issues
| "resend_requested" // expert asked to redo this part's photo
| "resent"; // owner re-uploaded after resend request
export interface EnrichedDamagedPart {
index: number;
partId: number | null;
id: number | null;
name: string;
side: string;
label_fa: string;
catalogKey?: string;
origin: "user_selected" | "added_by_objection" | "added_by_expert";
captureStatus: DamagedPartCaptureStatus;
captured: boolean;
url?: string;
objection: {
isObjected: boolean;
isNewlyAdded: boolean;
addedBy?: "user" | "expert";
};
resend: {
wasRequested: boolean; // expert included this part in a resend request
isFulfilled: boolean; // owner completed the resend
requestedAt?: Date;
fulfilledAt?: Date;
};
pricing: {
hasPriceDrop: boolean;
severity: string | null;
coefficient: number | null;
};
}

198
src/expert-claim/expert-claim.service.ts
View File

@@ -132,6 +132,7 @@ import {
import { CLAIM_V2_TOTAL_PAYMENT_CAP_TOMAN } from "src/constants/repair-amount-limits";
import { ListQueryV2Dto } from "src/common/dto/list-query-v2.dto";
import { applyListQueryV2 } from "src/helpers/list-query-v2";
import { buildEnrichedDamagedParts } from "./dto/claim-damaged-part.enricher";
const CLAIM_V2_TOTAL_PAYMENT_CAP = CLAIM_V2_TOTAL_PAYMENT_CAP_TOMAN;
@@ -3293,22 +3294,26 @@ export class ExpertClaimService {
const claims = await this.claimCaseDbService.find({
$or: [
// Available claims: waiting for expert, not locked
// Available: waiting, not locked
{
status: ClaimCaseStatus.WAITING_FOR_DAMAGE_EXPERT,
"workflow.locked": { $ne: true },
// No persistent assignee (or expired without decision)
$or: [
{ "workflow.assignedForReviewBy": { $exists: false } },
{ "workflow.assignedForReviewBy": null },
],
},
// Expert reviewing but lock cleared (e.g. TTL expiry) — still list until status is reconciled
{
status: ClaimCaseStatus.EXPERT_REVIEWING,
"workflow.locked": { $ne: true },
},
// This expert's own locked/in-progress claims
// This expert's locked/in-progress claims
{
"workflow.locked": true,
"workflow.lockedBy.actorId": new Types.ObjectId(actorId),
},
// User uploaded all factors; expert must approve/reject (unlocked queue)
// This expert's persistently assigned claims (decided or resend/objection follow-up)
{
"workflow.assignedForReviewBy.actorId": new Types.ObjectId(actorId),
},
// Factor validation queue (open to all tenant experts — no lock needed)
{
$or: [
{
@@ -3323,6 +3328,16 @@ export class ExpertClaimService {
},
],
},
// WAITING_FOR_USER_RESEND assigned to this expert
{
status: ClaimCaseStatus.WAITING_FOR_USER_RESEND,
"workflow.assignedForReviewBy.actorId": new Types.ObjectId(actorId),
},
// EXPERT_REVIEWING with stale lock (reconciliation will fix status, show in meantime)
{
status: ClaimCaseStatus.EXPERT_REVIEWING,
"workflow.locked": { $ne: true },
},
],
});
@@ -3330,10 +3345,12 @@ export class ExpertClaimService {
claimCaseTouchesClient(c, clientKey),
);
// Reconcile stale locks — if no decision was made, also clear assignedForReviewBy
const staleLockToReconcile = filtered.filter(
(c) =>
c.workflow?.locked && !this.isClaimV2WorkflowLockCurrentlyEnforced(c),
);
const touchedIds = (
await Promise.all(
staleLockToReconcile.map(async (c) => {
@@ -3356,9 +3373,39 @@ export class ExpertClaimService {
}
}
// Post-filter: remove files that belong to another expert after reconciliation
const finalFiltered = filtered.filter((c) => {
const assignedId = String(c.workflow?.assignedForReviewBy?.actorId ?? "");
const lockEnforced =
c.workflow?.locked && this.isClaimV2WorkflowLockCurrentlyEnforced(c);
const lockedById = String(c.workflow?.lockedBy?.actorId ?? "");
const isFactorValidation = claimIsAwaitingExpertFactorValidationV2(c);
// Factor validation is open to all tenant experts
if (isFactorValidation) return true;
// Available: no assignee, not locked by someone else
const isAvailable =
c.status === ClaimCaseStatus.WAITING_FOR_DAMAGE_EXPERT &&
!assignedId &&
(!lockEnforced || lockedById === actorId);
// Mine: assigned to me (covers decided, resend, objection follow-up)
const isAssignedToMe = !!assignedId && assignedId === actorId;
// Mine: currently locked by me
const isLockedByMe = lockEnforced && lockedById === actorId;
// Mine: resend pending and I'm the assigned expert
const isResendMine =
c.status === ClaimCaseStatus.WAITING_FOR_USER_RESEND && isAssignedToMe;
return isAvailable || isAssignedToMe || isLockedByMe || isResendMine;
});
const blameIds = [
...new Set(
filtered
finalFiltered
.map((c) => c.blameRequestId?.toString())
.filter((id): id is string => !!id),
),
@@ -3374,7 +3421,7 @@ export class ExpertClaimService {
blames.map((b) => [String(b._id), b]),
);
const list = filtered.map((c) => {
const list = finalFiltered.map((c) => {
const awaitingFactorValidation =
claimIsAwaitingExpertFactorValidationV2(c);
const v = this.vehicleForExpertFromClaimAndBlameMap(c, blameById);
@@ -3389,6 +3436,7 @@ export class ExpertClaimService {
c.status === ClaimCaseStatus.EXPERT_REVIEWING
? ClaimCaseStatus.WAITING_FOR_DAMAGE_EXPERT
: c.status;
return {
claimRequestId: c._id.toString(),
publicId: c.publicId,
@@ -3405,11 +3453,7 @@ export class ExpertClaimService {
}
: undefined,
vehicle: v
? {
carName: v.carName,
carModel: v.carModel,
carType: v.carType,
}
? { carName: v.carName, carModel: v.carModel, carType: v.carType }
: undefined,
...fileCtx,
createdAt: c.createdAt,
@@ -3726,6 +3770,7 @@ export class ExpertClaimService {
const assigneeToPersist = claimWorkflowAssigneeToPersistOnLockExpiry(
claim.workflow,
claim,
);
const expireLockSet: Record<string, unknown> = { "workflow.locked": false };
if (assigneeToPersist) {
@@ -3794,21 +3839,53 @@ export class ExpertClaimService {
claim.status === ClaimCaseStatus.EXPERT_REVIEWING;
const isFactorValidationPending =
claimIsAwaitingExpertFactorValidationV2(claim);
const isResendPending =
claim.status === ClaimCaseStatus.WAITING_FOR_USER_RESEND;
if (!isDamageExpertPhase && !isFactorValidationPending) {
if (
!isDamageExpertPhase &&
!isFactorValidationPending &&
!isResendPending
) {
throw new ForbiddenException(
`This claim is not available for expert review. Current status: ${claim.status}`,
);
}
const lockBlocksOthers = this.isClaimV2WorkflowLockCurrentlyEnforced(claim);
if (lockBlocksOthers) {
const lockerId = claim.workflow?.lockedBy?.actorId?.toString();
if (lockerId && lockerId !== actorId) {
// Ownership access control — same 4-bucket logic as list
const assignedForReviewById = String(
(claim.workflow as any)?.assignedForReviewBy?.actorId ?? "",
);
const lockEnforced = this.isClaimV2WorkflowLockCurrentlyEnforced(claim);
const lockedById = String(claim.workflow?.lockedBy?.actorId ?? "");
const isAvailable =
isDamageExpertPhase && !assignedForReviewById && !lockEnforced;
const isAssignedToMe =
!!assignedForReviewById && assignedForReviewById === actorId;
const isLockedByMe = lockEnforced && lockedById === actorId;
// Factor validation is open to all tenant experts (no individual ownership)
const isFactorValidationOpen = isFactorValidationPending;
if (
!isAvailable &&
!isAssignedToMe &&
!isLockedByMe &&
!isFactorValidationOpen
) {
if (lockEnforced && lockedById && lockedById !== actorId) {
throw new ForbiddenException(
`This claim is locked by another expert: ${claim.workflow.lockedBy?.actorName}`,
`This claim is locked by another expert: ${claim.workflow?.lockedBy?.actorName}`,
);
}
if (assignedForReviewById && assignedForReviewById !== actorId) {
throw new ForbiddenException(
"This claim has been assigned to another expert.",
);
}
throw new ForbiddenException(
"You do not have permission to view this claim.",
);
}
const hasCapture = (data: any, key: string) =>
@@ -3867,56 +3944,19 @@ export class ExpertClaimService {
const objectionParts = evaluationBlock?.objection?.objectionParts || [];
const newObjectionParts = evaluationBlock?.objection?.newParts || [];
const damagedParts = selectedNormExpert.map((sp, index) => {
const ck = sp.catalogKey ?? catalogLikeKeyFromPart(sp);
const cap = getDamagedPartCaptureBlob(
damagedPartsDataExpert,
ck,
selectedNormExpert,
) as { url?: string; path?: string } | undefined;
// Inside getClaimDetailV2, replace the damagedParts block:
// 1. Cross-reference Price Drop items via partId or name match
const matchingPriceDrop = priceDropLines.find(
(line: any) =>
line.partId === sp.id ||
line.priceDropPartKey?.toLowerCase() === sp.name?.toLowerCase(),
);
// 2. Evaluate if this specific part is flag-linked within an active user objection
const isObjected = objectionParts.some(
(objPart: any) => objPart.id === sp.id || objPart.name === sp.name,
);
const isNewAddedPart = newObjectionParts.some(
(newPart: any) => newPart.id === sp.id || newPart.name === sp.name,
);
return {
index,
partId: catalogPartIdFromSelectedPart(sp),
id: sp.id,
name: sp.name,
side: sp.side,
label_fa: sp.label_fa,
captured: hasDamagedPartCapture(
damagedPartsDataExpert,
ck,
selectedNormExpert,
),
url: cap?.url || (cap?.path ? buildFileLink(cap.path) : undefined),
// --- Added Consolidated Production Enrichments ---
severity: matchingPriceDrop ? matchingPriceDrop.severity : null,
coefficient: matchingPriceDrop ? matchingPriceDrop.coefficient : null,
objectionStatus: {
hasObjection: isObjected,
isNewlyAddedByObjection: isNewAddedPart,
// You can map extra parameters here if the front-end requires reason texts
},
};
const damagedParts = buildEnrichedDamagedParts({
selectedParts: selectedNormExpert,
damagedPartsData: damagedPartsDataExpert,
evaluationBlock: (claim as any).evaluation, // damageExpertResend lives here already
expertAddedParts: (claim.damage as any)?.expertAddedParts ?? [],
getDamagedPartCaptureBlob,
hasDamagedPartCapture,
catalogLikeKeyFromPart,
buildFileLink,
});
// --- Combine both branches of the conflict, preserving necessary logic from both ---
// 1. Vehicle payload logic from "upstream"
let vehiclePayload = claim.vehicle as any;
const hasClaimVehicle =
@@ -4377,9 +4417,29 @@ export class ExpertClaimService {
? [...(claim as any).damage.selectedParts]
: [];
// Diff to find parts the expert is adding that weren't in the original selection
const previousPartIds = new Set(
previousNorm.map((p) => p.id ?? `${p.name}::${p.side}`),
);
const expertAddedNow = nextNorm.filter(
(p) => !previousPartIds.has(p.id ?? `${p.name}::${p.side}`),
);
// Merge with parts the expert added in any previous edits on this claim (idempotent)
const existingExpertAdded: any[] =
(claim.damage as any)?.expertAddedParts ?? [];
const existingExpertAddedIds = new Set(
existingExpertAdded.map((p: any) => p.id ?? `${p.name}::${p.side}`),
);
const expertAddedToAppend = expertAddedNow.filter(
(p) => !existingExpertAddedIds.has(p.id ?? `${p.name}::${p.side}`),
);
const mergedExpertAdded = [...existingExpertAdded, ...expertAddedToAppend];
const $set: Record<string, unknown> = {
"damage.selectedParts": nextNorm,
"media.damagedParts": nextMedia,
"damage.expertAddedParts": mergedExpertAdded,
};
await this.claimCaseDbService.findByIdAndUpdate(claimRequestId, {
@@ -4396,6 +4456,7 @@ export class ExpertClaimService {
metadata: {
previousSelectedParts: previous,
selectedParts: nextNorm,
expertAddedParts: mergedExpertAdded,
...(damagedPartsEditSnapshot && {
expertProfileSnapshot: damagedPartsEditSnapshot,
}),
@@ -4408,6 +4469,7 @@ export class ExpertClaimService {
claimRequestId: claim._id.toString(),
selectedParts: nextNorm,
previousSelectedParts: previous,
expertAddedParts: mergedExpertAdded,
message: "Damaged parts updated successfully.",
};
}

42
src/helpers/date-jalali.ts
View File

@@ -96,14 +96,13 @@ function jalaliPartsToGregorian(
jMonth: number,
jDay: number,
): string | null {
// Jalali to Julian Day Number, then to Gregorian
// Algorithm: https://www.fourmilab.ch/documents/calendar/
const jy = jYear - 979;
const jm = jMonth - 1;
const jd = jDay - 1;
// Jalali day number — correct leap cycle is every 33 years with 8 leaps
let jDayNo =
365 * jy + Math.floor(jy / 4) - Math.floor(jy / 100) + Math.floor(jy / 400);
365 * jy + Math.floor(jy / 33) * 8 + Math.floor(((jy % 33) + 3) / 4);
const jalaliMonthDays = [31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 29];
for (let i = 0; i < jm; i++) {
@@ -111,29 +110,29 @@ function jalaliPartsToGregorian(
}
jDayNo += jd;
// Convert to Gregorian day number (offset from 1970-01-01 in Julian days)
const gDayNo = jDayNo + 79;
// Offset to Gregorian day number anchored at 1600
let gDayNo = jDayNo + 79;
let gy = 1979 + 400 * Math.floor(gDayNo / 146097);
let days = gDayNo % 146097;
let gy = 1600 + 400 * Math.floor(gDayNo / 146097);
gDayNo %= 146097;
let leap = true;
if (days >= 36525) {
days--;
gy += 100 * Math.floor(days / 36524);
days %= 36524;
if (days >= 365) days++;
if (gDayNo >= 36525) {
gDayNo--;
gy += 100 * Math.floor(gDayNo / 36524);
gDayNo %= 36524;
if (gDayNo >= 365) gDayNo++;
else leap = false;
}
gy += 4 * Math.floor(days / 1461);
days %= 1461;
gy += 4 * Math.floor(gDayNo / 1461);
gDayNo %= 1461;
if (days >= 366) {
if (gDayNo >= 366) {
leap = false;
days--;
gy += Math.floor(days / 365);
days %= 365;
gDayNo--;
gy += Math.floor(gDayNo / 365);
gDayNo %= 365;
}
const gregorianMonthDays = [
@@ -153,19 +152,18 @@ function jalaliPartsToGregorian(
let gm = 0;
for (let i = 0; i < 12; i++) {
if (days < gregorianMonthDays[i]) {
if (gDayNo < gregorianMonthDays[i]) {
gm = i + 1;
break;
}
days -= gregorianMonthDays[i];
gDayNo -= gregorianMonthDays[i];
}
const gd = days + 1;
const gd = gDayNo + 1;
const mm = String(gm).padStart(2, "0");
const dd = String(gd).padStart(2, "0");
const result = `${gy}-${mm}-${dd}`;
// Sanity check
const check = new Date(result);
if (isNaN(check.getTime())) return null;

37
src/helpers/expert-workflow-review-assignee.ts
View File

@@ -25,9 +25,8 @@ export function resolvePersistentReviewAssigneeId(
if (fromField != null && String(fromField).length > 0) {
return String(fromField);
}
const fromHistory = history?.find(
(h) => h.type === assignedHistoryType,
)?.actor?.actorId;
const fromHistory = history?.find((h) => h.type === assignedHistoryType)
?.actor?.actorId;
if (fromHistory != null && String(fromHistory).length > 0) {
return String(fromHistory);
}
@@ -43,8 +42,7 @@ export function buildExpertAssignConflictForOtherReviewer(
message: string;
lockedBy: { actorId: string; actorName?: string; lockedAt?: string };
} {
const assignee =
workflow?.assignedForReviewBy ?? workflow?.lockedBy;
const assignee = workflow?.assignedForReviewBy ?? workflow?.lockedBy;
const lockedAt = workflow?.lockedAt;
return {
success: false,
@@ -53,25 +51,28 @@ export function buildExpertAssignConflictForOtherReviewer(
lockedBy: {
actorId: assigneeId,
actorName: assignee?.actorName,
lockedAt: lockedAt
? new Date(lockedAt as Date).toISOString()
: undefined,
lockedAt: lockedAt ? new Date(lockedAt as Date).toISOString() : undefined,
},
};
}
/** Copy lock holder into `assignedForReviewBy` when persisting a TTL unlock. */
export function blameWorkflowAssigneeToPersistOnLockExpiry(
workflow: WorkflowAssigneeRef | undefined,
): WorkflowAssigneeRef["assignedForReviewBy"] | undefined {
if (workflow?.assignedForReviewBy) {
return undefined;
}
return workflow?.lockedBy;
workflow: any,
request: any,
) {
const hasDecision = !!request?.expert?.decision;
return hasDecision ? (workflow?.assignedForReviewBy ?? null) : null;
}
export function claimWorkflowAssigneeToPersistOnLockExpiry(
workflow: WorkflowAssigneeRef | undefined,
): WorkflowAssigneeRef["assignedForReviewBy"] | undefined {
return blameWorkflowAssigneeToPersistOnLockExpiry(workflow);
workflow: any,
claim: any,
): typeof workflow.assignedForReviewBy | null {
// If a decision or resend was already submitted, preserve ownership
const hasDecision =
!!claim?.evaluation?.damageExpertReply ||
!!claim?.evaluation?.damageExpertReplyFinal ||
!!claim?.evaluation?.damageExpertResend;
return hasDecision ? (workflow?.assignedForReviewBy ?? null) : null;
}

18
src/request-management/request-management.service.ts
View File

@@ -1016,15 +1016,15 @@ export class RequestManagementService {
}
try {
// const personalInquiry = await this.sandHubService.getPersonalInquiry(
// personalNationalCode,
// personalBirthDate,
// );
// this.logger.log(
// `[SANDHUB] personal inquiry success request=${req._id} nationalCode=${personalNationalCode}: ${JSON.stringify(
// personalInquiry,
// )}`,
// );
const personalInquiry = await this.sandHubService.getPersonalInquiry(
personalNationalCode,
personalBirthDate,
);
this.logger.log(
`[SANDHUB] personal inquiry success request=${req._id} nationalCode=${personalNationalCode}: ${JSON.stringify(
personalInquiry,
)}`,
);
} catch (err: any) {
this.logger.error(
`[SANDHUB] personal inquiry failed request=${req._id} nationalCode=${personalNationalCode}: ${err?.message || err}`,

1
src/sand-hub/sand-hub.service.ts
View File

@@ -564,6 +564,7 @@ export class SandHubService {
const requestUrl = `${process.env.SANHUB_BASE_URL}/personal-inquiry/tejarat-no`;
const gregorianBirthdate = jalaliToGregorianDate(birthDate);
console.log(gregorianBirthdate);
if (!gregorianBirthdate) {
throw new BadRequestException(
`Invalid birth date for personal inquiry: ${birthDate}. Expected a Jalali date (e.g. 13770624 or "1377-06-24").`,

12
src/workflow-step-management/workflow-step-management.module.ts
View File

@@ -1,12 +1,12 @@
import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { WorkflowStepManagementService } from './workflow-step-management.service';
import { WorkflowStepManagementController } from './workflow-step-management.controller';
import { WorkflowStepDbService } from './entities/db-service/workflow-step.db.service';
import { Module } from "@nestjs/common";
import { MongooseModule } from "@nestjs/mongoose";
import { WorkflowStepManagementService } from "./workflow-step-management.service";
import { WorkflowStepManagementController } from "./workflow-step-management.controller";
import { WorkflowStepDbService } from "./entities/db-service/workflow-step.db.service";
import {
WorkflowStepsDB,
WorkflowStepSchema,
} from './entities/schema/workflow-step.schema';
} from "./entities/schema/workflow-step.schema";
@Module({
imports: [

1229
src/workflow-step-management/workflow-step-management.service.ts
View File

File diff suppressed because it is too large Load Diff