forked from Yara724/api
921 lines
27 KiB
JavaScript
921 lines
27 KiB
JavaScript
#!/usr/bin/env node
|
||
|
||
/*
|
||
* One-time script to replace mocked blameCases party vehicle inquiry data.
|
||
* THIRD_PARTY cases use Tejarat block inquiry; CAR_BODY cases use both
|
||
* Tejarat third-party block inquiry and car-body inquiry. All cases also
|
||
* refresh available party personal inquiries into inquiries.person.
|
||
*
|
||
* Defaults to DRY_RUN=true. Set DRY_RUN=false to write changes.
|
||
*/
|
||
|
||
const fs = require("fs");
|
||
const path = require("path");
|
||
const mongoose = require("mongoose");
|
||
|
||
const loadedEnvFiles = loadEnvFiles(process.env.ENV_FILE || ".env");
|
||
|
||
const LETTER_TO_NUMBER = {
|
||
"الف": 1,
|
||
"ب": 2,
|
||
"ت": 3,
|
||
"ج": 4,
|
||
"د": 5,
|
||
"س": 6,
|
||
"ص": 7,
|
||
"ط": 8,
|
||
"ع": 9,
|
||
"ق": 10,
|
||
"ل": 11,
|
||
"م": 12,
|
||
"ن": 13,
|
||
"و": 14,
|
||
"ه": 15,
|
||
"ی": 16,
|
||
"ر": 17,
|
||
"ک": 18,
|
||
"ژ": 19,
|
||
"پ": 20,
|
||
"ظ": 24,
|
||
"ض": 25,
|
||
"ز": 41,
|
||
"ش": 42,
|
||
"گ": 43,
|
||
"ث": 44,
|
||
D: 45,
|
||
S: 46,
|
||
"ح": 47,
|
||
"ف": 48,
|
||
};
|
||
|
||
const NUMBER_TO_LETTER = Object.fromEntries(
|
||
Object.entries(LETTER_TO_NUMBER).map(([letter, number]) => [String(number), letter]),
|
||
);
|
||
|
||
const config = {
|
||
mongoUri: requiredEnv("MONGO_URL", "MONGODB_URI", "DATABASE_URL"),
|
||
collectionName: process.env.BLAME_COLLECTION || "blameCases",
|
||
mongoDbName: process.env.MONGO_DB_NAME || "",
|
||
thirdPartyUrl:
|
||
process.env.TEJARAT_THIRD_PARTY_URL ||
|
||
"http://82.99.202.245:3027/block-inquiry-tejarat",
|
||
carBodyUrl:
|
||
process.env.TEJARAT_CAR_BODY_URL ||
|
||
"http://82.99.202.245:3027/block-inquiry-tejarat/badane",
|
||
personUrl:
|
||
process.env.TEJARAT_PERSON_URL ||
|
||
"http://82.99.202.245:3027/personal-inquiry/tejarat-no",
|
||
thirdPartyToken:
|
||
process.env.TEJARAT_THIRD_PARTY_TOKEN || process.env.TEJARAT_TOKEN || "",
|
||
carBodyToken:
|
||
process.env.TEJARAT_CAR_BODY_TOKEN || process.env.TEJARAT_TOKEN || "",
|
||
personToken:
|
||
process.env.TEJARAT_PERSON_TOKEN || process.env.TEJARAT_TOKEN || "",
|
||
rateLimitPerMinute: Number(process.env.RATE_LIMIT_PER_MINUTE || 5),
|
||
retryEnabled: String(process.env.RETRY_ENABLED ?? "true").toLowerCase() !== "false",
|
||
retryCount: Number(process.env.RETRY_COUNT || 3),
|
||
retryDelayMs: Number(process.env.RETRY_DELAY_MS || 2000),
|
||
dryRun: String(process.env.DRY_RUN ?? "true").toLowerCase() !== "false",
|
||
limit: process.env.LIMIT ? Number(process.env.LIMIT) : 0,
|
||
publicId: process.env.PUBLIC_ID || "",
|
||
};
|
||
|
||
let lastRequestAt = 0;
|
||
|
||
main().catch(async (error) => {
|
||
console.error("[fatal]", error && error.stack ? error.stack : error);
|
||
await mongoose.disconnect().catch(() => undefined);
|
||
process.exitCode = 1;
|
||
});
|
||
|
||
async function main() {
|
||
validateConfig();
|
||
|
||
console.log("script runned successfully");
|
||
console.log(
|
||
"[config] envFiles=" +
|
||
(loadedEnvFiles.length ? loadedEnvFiles.join(",") : "none") +
|
||
", dbName=" +
|
||
(config.mongoDbName || "from-url-or-driver-default") +
|
||
", collection=" +
|
||
config.collectionName +
|
||
", dryRun=" +
|
||
config.dryRun +
|
||
", rateLimitPerMinute=" +
|
||
config.rateLimitPerMinute +
|
||
", retryEnabled=" +
|
||
config.retryEnabled +
|
||
", retryCount=" +
|
||
config.retryCount,
|
||
);
|
||
|
||
await mongoose.connect(config.mongoUri, {
|
||
autoIndex: false,
|
||
dbName: config.mongoDbName || undefined,
|
||
});
|
||
const collection = mongoose.connection.collection(config.collectionName);
|
||
|
||
const query = {
|
||
type: { $in: ["THIRD_PARTY", "CAR_BODY"] },
|
||
};
|
||
if (config.publicId) query.publicId = config.publicId;
|
||
|
||
const totalDocs = await collection.countDocuments(query);
|
||
console.log(`total docs that we have to edit: ${totalDocs}`);
|
||
|
||
const cursor = collection
|
||
.find(query, {
|
||
projection: {
|
||
publicId: 1,
|
||
requestNo: 1,
|
||
type: 1,
|
||
parties: 1,
|
||
inquiries: 1,
|
||
},
|
||
})
|
||
.sort({ createdAt: 1, _id: 1 });
|
||
|
||
if (config.limit > 0) cursor.limit(config.limit);
|
||
|
||
const summary = {
|
||
docsSeen: 0,
|
||
docsChanged: 0,
|
||
partiesInquired: 0,
|
||
partiesSkipped: 0,
|
||
partiesFailed: 0,
|
||
personInquired: 0,
|
||
personSkipped: 0,
|
||
personFailed: 0,
|
||
};
|
||
|
||
for await (const doc of cursor) {
|
||
summary.docsSeen += 1;
|
||
const label = doc.publicId || doc.requestNo || String(doc._id);
|
||
const requestId = String(doc._id);
|
||
console.log(`currently inquiry for doc with ${label} and requestId ${requestId}`);
|
||
|
||
const parties = Array.isArray(doc.parties) ? clone(doc.parties) : [];
|
||
const inquiries = doc.inquiries && typeof doc.inquiries === "object" ? clone(doc.inquiries) : {};
|
||
let docChanged = false;
|
||
let inquiriesChanged = false;
|
||
|
||
for (let index = 0; index < parties.length; index += 1) {
|
||
const party = parties[index];
|
||
const partyLabel = `${label} parties[${index}] role=${party && party.role ? party.role : "-"}`;
|
||
|
||
const input = buildInquiryInputs(doc, party);
|
||
if (!input.ok) {
|
||
summary.partiesSkipped += 1;
|
||
console.warn(`[skip] ${partyLabel}: ${input.reason}`);
|
||
} else {
|
||
let nextParty = party;
|
||
let partyChanged = false;
|
||
|
||
for (const request of input.requests) {
|
||
console.log(
|
||
`[request] ${partyLabel} type=${request.type} body=${JSON.stringify(request.body)}`,
|
||
);
|
||
|
||
try {
|
||
const inquiryResponse = await inquiryWithRetry(request.type, request.body);
|
||
const successful = isInquirySuccessful(request.type, inquiryResponse);
|
||
console.log(
|
||
`[response] ${partyLabel} type=${request.type} successful=${successful} body=${JSON.stringify(inquiryResponse)}`,
|
||
);
|
||
|
||
if (!successful) {
|
||
summary.partiesFailed += 1;
|
||
continue;
|
||
}
|
||
|
||
nextParty = applyInquiryToParty(request.type, nextParty, inquiryResponse, input.plate);
|
||
summary.partiesInquired += 1;
|
||
partyChanged = true;
|
||
} catch (error) {
|
||
summary.partiesFailed += 1;
|
||
console.error(`[error] ${partyLabel} type=${request.type}: ${error.message}`);
|
||
}
|
||
}
|
||
|
||
if (partyChanged) {
|
||
parties[index] = nextParty;
|
||
docChanged = true;
|
||
}
|
||
}
|
||
|
||
const personInput = buildPersonInquiryInput(party);
|
||
if (!personInput.ok) {
|
||
summary.personSkipped += 1;
|
||
console.warn(`[skip] ${partyLabel} person: ${personInput.reason}`);
|
||
continue;
|
||
}
|
||
|
||
console.log(`[request] ${partyLabel} type=PERSON body=${JSON.stringify(personInput.body)}`);
|
||
try {
|
||
const personResponse = await inquiryWithRetry("PERSON", personInput.body);
|
||
const successful = isInquirySuccessful("PERSON", personResponse);
|
||
console.log(
|
||
`[response] ${partyLabel} type=PERSON successful=${successful} body=${JSON.stringify(personResponse)}`,
|
||
);
|
||
|
||
if (!successful) {
|
||
summary.personFailed += 1;
|
||
applyPersonInquiryToCaseInquiries(inquiries, party, index, false, {}, personResponse);
|
||
inquiriesChanged = true;
|
||
continue;
|
||
}
|
||
|
||
applyPersonInquiryToCaseInquiries(
|
||
inquiries,
|
||
party,
|
||
index,
|
||
true,
|
||
normalizePersonResponse(personResponse),
|
||
);
|
||
summary.personInquired += 1;
|
||
inquiriesChanged = true;
|
||
} catch (error) {
|
||
summary.personFailed += 1;
|
||
applyPersonInquiryToCaseInquiries(inquiries, party, index, false, {}, error);
|
||
inquiriesChanged = true;
|
||
console.error(`[error] ${partyLabel} type=PERSON: ${error.message}`);
|
||
}
|
||
}
|
||
|
||
if (!docChanged && !inquiriesChanged) {
|
||
console.log(`[doc] ${label} no changes`);
|
||
continue;
|
||
}
|
||
|
||
if (config.dryRun) {
|
||
console.log(`[dry-run] ${label} would update parties/inquiries`);
|
||
continue;
|
||
}
|
||
|
||
const updateSet = {
|
||
updatedAt: new Date(),
|
||
};
|
||
if (docChanged) updateSet.parties = parties;
|
||
if (inquiriesChanged) updateSet.inquiries = inquiries;
|
||
|
||
const result = await collection.updateOne(
|
||
{ _id: doc._id },
|
||
{
|
||
$set: updateSet,
|
||
},
|
||
);
|
||
summary.docsChanged += result.modifiedCount;
|
||
console.log(`[update] ${label} matched=${result.matchedCount} modified=${result.modifiedCount}`);
|
||
}
|
||
|
||
await mongoose.disconnect();
|
||
console.log(`[done] ${JSON.stringify(summary)}`);
|
||
}
|
||
|
||
function buildInquiryInputs(doc, party) {
|
||
if (!party || typeof party !== "object") return { ok: false, reason: "party is empty" };
|
||
if (!party.vehicle || typeof party.vehicle !== "object") {
|
||
return { ok: false, reason: "party.vehicle is missing" };
|
||
}
|
||
|
||
const plate = extractPlate(party);
|
||
const nationalCode =
|
||
cleanString(party.person && party.person.nationalCodeOfInsurer) ||
|
||
cleanString(party.person && party.person.nationalCodeOfDriver);
|
||
|
||
if (!plate) return { ok: false, reason: "Plk1/Plk2/Plk3/PlkSrl not found" };
|
||
if (!nationalCode) return { ok: false, reason: "nationalCodeOfInsurer/nationalCodeOfDriver missing" };
|
||
|
||
const serialLetter = NUMBER_TO_LETTER[String(plate.Plk2)] || cleanString(plate.Plk2);
|
||
if (!serialLetter) return { ok: false, reason: `no Persian letter mapping for Plk2=${plate.Plk2}` };
|
||
|
||
if (doc.type === "THIRD_PARTY") {
|
||
return {
|
||
ok: true,
|
||
plate,
|
||
requests: [buildThirdPartyRequest(plate, serialLetter, nationalCode)],
|
||
};
|
||
}
|
||
|
||
if (doc.type === "CAR_BODY") {
|
||
return {
|
||
ok: true,
|
||
plate,
|
||
requests: [
|
||
buildThirdPartyRequest(plate, serialLetter, nationalCode),
|
||
buildCarBodyRequest(plate, serialLetter, nationalCode),
|
||
],
|
||
};
|
||
}
|
||
|
||
return { ok: false, reason: `unsupported type=${doc.type}` };
|
||
}
|
||
|
||
function buildThirdPartyRequest(plate, serialLetter, nationalCode) {
|
||
return {
|
||
type: "THIRD_PARTY",
|
||
body: {
|
||
leftTwoDigits: String(plate.Plk1),
|
||
serialLetter,
|
||
threeDigits: String(plate.Plk3),
|
||
rightTwoDigits: String(plate.PlkSrl),
|
||
nationalCode,
|
||
},
|
||
};
|
||
}
|
||
|
||
function buildCarBodyRequest(plate, serialLetter, nationalCode) {
|
||
return {
|
||
type: "CAR_BODY",
|
||
body: {
|
||
part1: toNumber(plate.Plk1),
|
||
part2: serialLetter,
|
||
part3: toNumber(plate.Plk3),
|
||
part4: toNumber(plate.PlkSrl),
|
||
nationalCode,
|
||
},
|
||
};
|
||
}
|
||
|
||
function buildPersonInquiryInput(party) {
|
||
if (!party || typeof party !== "object") return { ok: false, reason: "party is empty" };
|
||
const person = party.person && typeof party.person === "object" ? party.person : null;
|
||
if (!person) return { ok: false, reason: "party.person is missing" };
|
||
|
||
const nationalCode =
|
||
cleanString(person.nationalCodeOfInsurer) ||
|
||
cleanString(person.nationalCodeOfDriver);
|
||
const birthDate = firstPresent(
|
||
person.insurerBirthday,
|
||
person.driverBirthday,
|
||
person.birthday,
|
||
);
|
||
const gregorianBirthdate = jalaliToGregorianDate(birthDate);
|
||
|
||
if (!nationalCode) {
|
||
return { ok: false, reason: "nationalCodeOfInsurer/nationalCodeOfDriver missing" };
|
||
}
|
||
if (!gregorianBirthdate) {
|
||
return {
|
||
ok: false,
|
||
reason: `invalid insurerBirthday/driverBirthday=${cleanString(birthDate)}`,
|
||
};
|
||
}
|
||
|
||
return {
|
||
ok: true,
|
||
body: {
|
||
nationalCode,
|
||
birthdate: gregorianBirthdate,
|
||
},
|
||
};
|
||
}
|
||
|
||
function parsePlateId(plateId) {
|
||
const value = cleanString(plateId);
|
||
if (!value) return null;
|
||
|
||
const parts = value.split("-").map((part) => normalizePlateNumber(part));
|
||
if (parts.length !== 4) return null;
|
||
|
||
const thirdPartIsLetter = LETTER_TO_NUMBER[parts[2]] !== undefined;
|
||
const fourthPartIsLetter = LETTER_TO_NUMBER[parts[3]] !== undefined;
|
||
|
||
if (thirdPartIsLetter) {
|
||
return {
|
||
Plk1: parts[1],
|
||
Plk2: String(LETTER_TO_NUMBER[parts[2]]),
|
||
Plk3: parts[3],
|
||
PlkSrl: parts[0],
|
||
};
|
||
}
|
||
|
||
if (fourthPartIsLetter) {
|
||
return {
|
||
Plk1: parts[2],
|
||
Plk2: String(LETTER_TO_NUMBER[parts[3]]),
|
||
Plk3: parts[1],
|
||
PlkSrl: parts[0],
|
||
};
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
function extractPlate(party) {
|
||
const plateFromPlateId = parsePlateId(party.vehicle && party.vehicle.plateId);
|
||
if (plateFromPlateId) return plateFromPlateId;
|
||
|
||
const candidates = [
|
||
party.vehicle && party.vehicle.inquiry && party.vehicle.inquiry.mapped,
|
||
party.vehicle && party.vehicle.inquiry && party.vehicle.inquiry.raw,
|
||
party.vehicle && party.vehicle.inquiry,
|
||
party.vehicle,
|
||
].filter(Boolean);
|
||
|
||
for (const candidate of candidates) {
|
||
const Plk1 = firstPresent(candidate.Plk1, candidate.platePartOne);
|
||
const Plk2 = firstPresent(candidate.Plk2, candidate.plateLetterid, candidate.plateLetterId);
|
||
const Plk3 = firstPresent(candidate.Plk3, candidate.platePartThree);
|
||
const PlkSrl = firstPresent(candidate.PlkSrl, candidate.plkSrl, candidate.plateSerialNumber);
|
||
|
||
if (
|
||
Plk1 !== undefined &&
|
||
Plk2 !== undefined &&
|
||
Plk3 !== undefined &&
|
||
PlkSrl !== undefined
|
||
) {
|
||
return {
|
||
Plk1: normalizePlateNumber(Plk1),
|
||
Plk2: normalizePlateNumber(Plk2),
|
||
Plk3: normalizePlateNumber(Plk3),
|
||
PlkSrl: normalizePlateNumber(PlkSrl),
|
||
};
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
async function inquiryWithRetry(type, body) {
|
||
const endpoint = getInquiryEndpoint(type);
|
||
const url = endpoint.url;
|
||
const token = endpoint.token;
|
||
const accept = endpoint.accept;
|
||
let lastError;
|
||
|
||
const maxAttempts = config.retryEnabled ? config.retryCount : 1;
|
||
|
||
for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
|
||
await waitForRateLimit();
|
||
try {
|
||
console.log("[http] " + type + " attempt=" + attempt + "/" + maxAttempts);
|
||
return await postJson(url, token, body, accept);
|
||
} catch (error) {
|
||
lastError = error;
|
||
console.error(`[retry] ${type} attempt=${attempt} failed: ${error.message}`);
|
||
if (attempt < maxAttempts) {
|
||
await sleep(config.retryDelayMs * attempt);
|
||
}
|
||
}
|
||
}
|
||
|
||
throw lastError;
|
||
}
|
||
|
||
async function postJson(url, token, body, accept = "application/json") {
|
||
const response = await fetch(url, {
|
||
method: "POST",
|
||
headers: {
|
||
accept,
|
||
authorization: `Bearer ${token}`,
|
||
"content-type": "application/json",
|
||
},
|
||
body: JSON.stringify(body),
|
||
});
|
||
|
||
const text = await response.text();
|
||
let data;
|
||
try {
|
||
data = text ? JSON.parse(text) : null;
|
||
} catch {
|
||
data = text;
|
||
}
|
||
|
||
if (!response.ok) {
|
||
const error = new Error(`HTTP ${response.status}: ${JSON.stringify(data)}`);
|
||
error.status = response.status;
|
||
error.data = data;
|
||
throw error;
|
||
}
|
||
|
||
return data;
|
||
}
|
||
|
||
function isInquirySuccessful(type, response) {
|
||
if (type === "CAR_BODY") return response && response.isSuccess === true && response.data;
|
||
if (type === "PERSON") return response && response.status === 200 && response.data;
|
||
return response && response.resultStatus === true;
|
||
}
|
||
|
||
function getInquiryEndpoint(type) {
|
||
if (type === "CAR_BODY") {
|
||
return { url: config.carBodyUrl, token: config.carBodyToken, accept: "application/json" };
|
||
}
|
||
if (type === "PERSON") {
|
||
return { url: config.personUrl, token: config.personToken, accept: "*/*" };
|
||
}
|
||
return { url: config.thirdPartyUrl, token: config.thirdPartyToken, accept: "application/json" };
|
||
}
|
||
|
||
function applyInquiryToParty(type, party, response, originalPlate) {
|
||
if (type === "CAR_BODY") return applyCarBodyInquiryToParty(party, response, originalPlate);
|
||
return applyThirdPartyInquiryToParty(party, response, originalPlate);
|
||
}
|
||
|
||
function applyThirdPartyInquiryToParty(party, response, originalPlate) {
|
||
const next = clone(party);
|
||
if (!next.vehicle) next.vehicle = {};
|
||
if (!next.insurance) next.insurance = {};
|
||
|
||
const mapped = normalizeThirdPartyResponse(response, originalPlate);
|
||
const plateId = buildPlateId(originalPlate);
|
||
|
||
next.vehicle.plateId = plateId || next.vehicle.plateId;
|
||
|
||
next.vehicle.inquiry = {
|
||
source: "TEJARAT_BLOCK_INQUIRY",
|
||
raw: response,
|
||
mapped,
|
||
refreshedAt: new Date().toISOString(),
|
||
};
|
||
if (party.vehicle && party.vehicle.inquiry && party.vehicle.inquiry.carBody) {
|
||
next.vehicle.inquiry.carBody = party.vehicle.inquiry.carBody;
|
||
}
|
||
|
||
next.vehicle.name = mapped.vehiclePersianName || mapped.MapTypNam || "اطلاعات این گزینه در استعلام موجود نیست";
|
||
next.vehicle.type = mapped.persianCarType || mapped.MapUsageName || next.vehicle.type;
|
||
next.insurance.policyNumber =
|
||
mapped.LastCompanyDocumentNumber || mapped.insuranceNumber || next.insurance.policyNumber;
|
||
next.insurance.company = mapped.companyPersianName || next.insurance.company;
|
||
next.insurance.financialCeiling = mapped.financeCoverage || next.insurance.financialCeiling;
|
||
next.insurance.startDate = mapped.persianStartDate || next.insurance.startDate;
|
||
next.insurance.endDate = mapped.persianEndDate || next.insurance.endDate;
|
||
return next;
|
||
}
|
||
|
||
function applyCarBodyInquiryToParty(party, response, originalPlate) {
|
||
const next = clone(party);
|
||
if (!next.vehicle) next.vehicle = {};
|
||
if (!next.insurance) next.insurance = {};
|
||
|
||
const mapped = normalizeCarBodyResponse(response, originalPlate);
|
||
const plateId = buildPlateId(originalPlate);
|
||
|
||
next.vehicle.plateId = plateId || next.vehicle.plateId;
|
||
if (!next.vehicle.inquiry || typeof next.vehicle.inquiry !== "object") {
|
||
next.vehicle.inquiry = {};
|
||
}
|
||
|
||
next.vehicle.inquiry.carBody = {
|
||
source: "TEJARAT_CAR_BODY_INQUIRY",
|
||
raw: response,
|
||
mapped,
|
||
refreshedAt: new Date().toISOString(),
|
||
};
|
||
|
||
next.vehicle.name = mapped.vehicleSystemTitle || next.vehicle.name;
|
||
next.vehicle.type = mapped.vehicleGroupTitle || next.vehicle.type;
|
||
next.insurance.carBodyInsurance = {
|
||
policyNumber: mapped.policyNumber,
|
||
companyId: mapped.companyId,
|
||
companyName: mapped.CompanyName,
|
||
insurerName: mapped.insurerName,
|
||
insurerNationalCode: mapped.insurerNationalCode,
|
||
ownerNationalCode: mapped.ownerNationalCode,
|
||
chassisNumber: mapped.chassisNumber,
|
||
vin: mapped.vin,
|
||
motorNumber: mapped.motorNumber,
|
||
vehicleGroup: mapped.vehicleGroupTitle,
|
||
vehicleSystem: mapped.vehicleSystemTitle,
|
||
startDate: mapped.StartDate,
|
||
endDate: mapped.EndDate,
|
||
issueDate: mapped.IssueDate,
|
||
noLossYearsCount: mapped.noLossYearsCount,
|
||
lossDocuments: Array.isArray(mapped.lossDocuments) ? mapped.lossDocuments : [],
|
||
hasEndorsement: mapped.hasEndorsement,
|
||
};
|
||
return next;
|
||
}
|
||
|
||
function applyPersonInquiryToCaseInquiries(inquiries, party, index, has, data, error) {
|
||
if (!inquiries.person || typeof inquiries.person !== "object") {
|
||
inquiries.person = {};
|
||
}
|
||
|
||
const existingData =
|
||
inquiries.person.data && typeof inquiries.person.data === "object" && !Array.isArray(inquiries.person.data)
|
||
? inquiries.person.data
|
||
: {};
|
||
const existingError =
|
||
inquiries.person.error && typeof inquiries.person.error === "object" && !Array.isArray(inquiries.person.error)
|
||
? inquiries.person.error
|
||
: {};
|
||
const roleKey = party && party.role ? party.role : `party_${index}`;
|
||
const nextData = { ...existingData };
|
||
const nextError = { ...existingError };
|
||
|
||
if (has) {
|
||
nextData[roleKey] = data || {};
|
||
delete nextError[roleKey];
|
||
} else {
|
||
nextError[roleKey] = normalizeInquiryError(error);
|
||
}
|
||
|
||
inquiries.person = {
|
||
has: Object.keys(nextData).length > 0,
|
||
data: nextData,
|
||
...(Object.keys(nextError).length > 0 ? { error: nextError } : {}),
|
||
updatedAt: new Date(),
|
||
};
|
||
}
|
||
|
||
function normalizePersonResponse(response) {
|
||
return response && response.data ? response.data : response;
|
||
}
|
||
|
||
function normalizeInquiryError(error) {
|
||
if (!error) return undefined;
|
||
return {
|
||
message: error.message || String(error),
|
||
status: error.status,
|
||
data: error.data,
|
||
};
|
||
}
|
||
|
||
function buildPlateId(plate) {
|
||
if (!plate) return "";
|
||
const serialLetter = NUMBER_TO_LETTER[String(plate.Plk2)] || cleanString(plate.Plk2);
|
||
if (!serialLetter) return "";
|
||
return (
|
||
cleanString(plate.PlkSrl) +
|
||
"-" +
|
||
cleanString(plate.Plk1) +
|
||
"-" +
|
||
serialLetter +
|
||
"-" +
|
||
cleanString(plate.Plk3)
|
||
);
|
||
}
|
||
|
||
function normalizeThirdPartyResponse(response, originalPlate) {
|
||
return {
|
||
...response,
|
||
Plk1: toNumber(originalPlate.Plk1),
|
||
Plk2: toNumber(originalPlate.Plk2),
|
||
Plk3: toNumber(originalPlate.Plk3),
|
||
PlkSrl: toNumber(originalPlate.PlkSrl),
|
||
CompanyName: response.companyPersianName,
|
||
CompanyCode: response.companyId,
|
||
LastCompanyDocumentNumber: response.lastCompanyInsuranceNumber || response.insuranceNumber,
|
||
FinancialCvrCptl: response.financeCoverage,
|
||
IssueDate: response.hIsuDte || response.persianStartDate,
|
||
SatrtDate: response.persianStartDate,
|
||
EndDate: response.persianEndDate,
|
||
MapTypNam: response.vehiclePersianName,
|
||
MapUsageName: response.MapUsageName || response.persianCarType,
|
||
UsageField: response.persianCarType,
|
||
UsageCode: response.usgCod,
|
||
VehicleSystemCode: response.vehSysCod,
|
||
CarGroupCode: response.carGrpCod,
|
||
EdrsJson: Array.isArray(response.edrSes) ? JSON.stringify(response.edrSes) : response.EdrsJson,
|
||
InsuranceFullName: response.fullname,
|
||
};
|
||
}
|
||
|
||
function normalizeCarBodyResponse(response, originalPlate) {
|
||
const data = response.data || {};
|
||
return {
|
||
...data,
|
||
Plk1: toNumber(originalPlate.Plk1),
|
||
Plk2: toNumber(originalPlate.Plk2),
|
||
Plk3: toNumber(originalPlate.Plk3),
|
||
PlkSrl: toNumber(originalPlate.PlkSrl),
|
||
policyNumber: data.printNumber,
|
||
CompanyName: data.companyName,
|
||
CompanyCode: data.companyId,
|
||
LastCompanyDocumentNumber: data.printNumber,
|
||
InsuranceFullName: data.insurerName,
|
||
IssueDate: data.issueDate,
|
||
StartDate: data.beginDate,
|
||
SatrtDate: data.beginDate,
|
||
EndDate: data.endDate,
|
||
EngineNumberField: data.motorNumber,
|
||
MtrNum: data.motorNumber,
|
||
ChassisNumberField: data.chassisNumber,
|
||
ShsNum: data.chassisNumber,
|
||
VinNumberField: data.vin,
|
||
MapTypNam: data.vehicleGroupTitle,
|
||
isSuccess: response.isSuccess,
|
||
statusCode: response.statusCode,
|
||
message: response.message,
|
||
};
|
||
}
|
||
|
||
function jalaliToGregorianDate(input) {
|
||
if (input === null || input === undefined) return null;
|
||
|
||
const raw = normalizeDigits(typeof input === "number" ? String(input) : String(input).trim());
|
||
if (!raw) return null;
|
||
|
||
let year = 0;
|
||
let month = 0;
|
||
let day = 0;
|
||
|
||
const separated = raw.match(/^(\d{4})[\-/](\d{1,2})[\-/](\d{1,2})$/);
|
||
if (separated) {
|
||
year = parseInt(separated[1], 10);
|
||
month = parseInt(separated[2], 10);
|
||
day = parseInt(separated[3], 10);
|
||
} else {
|
||
const digits = raw.replace(/\D/g, "");
|
||
if (digits.length !== 8) return null;
|
||
year = parseInt(digits.slice(0, 4), 10);
|
||
month = parseInt(digits.slice(4, 6), 10);
|
||
day = parseInt(digits.slice(6, 8), 10);
|
||
}
|
||
|
||
if (!year || !month || !day) return null;
|
||
|
||
if (year >= 1900) {
|
||
const mm = String(month).padStart(2, "0");
|
||
const dd = String(day).padStart(2, "0");
|
||
const result = `${year}-${mm}-${dd}`;
|
||
return isNaN(new Date(result).getTime()) ? null : result;
|
||
}
|
||
|
||
return jalaliPartsToGregorian(year, month, day);
|
||
}
|
||
|
||
function jalaliPartsToGregorian(jYear, jMonth, jDay) {
|
||
const jy = jYear - 979;
|
||
const jm = jMonth - 1;
|
||
const jd = jDay - 1;
|
||
|
||
let jDayNo =
|
||
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 += 1) {
|
||
jDayNo += jalaliMonthDays[i];
|
||
}
|
||
jDayNo += jd;
|
||
|
||
let gDayNo = jDayNo + 79;
|
||
|
||
let gy = 1600 + 400 * Math.floor(gDayNo / 146097);
|
||
gDayNo %= 146097;
|
||
|
||
let leap = true;
|
||
if (gDayNo >= 36525) {
|
||
gDayNo -= 1;
|
||
gy += 100 * Math.floor(gDayNo / 36524);
|
||
gDayNo %= 36524;
|
||
if (gDayNo >= 365) gDayNo += 1;
|
||
else leap = false;
|
||
}
|
||
|
||
gy += 4 * Math.floor(gDayNo / 1461);
|
||
gDayNo %= 1461;
|
||
|
||
if (gDayNo >= 366) {
|
||
leap = false;
|
||
gDayNo -= 1;
|
||
gy += Math.floor(gDayNo / 365);
|
||
gDayNo %= 365;
|
||
}
|
||
|
||
const gregorianMonthDays = [
|
||
31,
|
||
leap ? 29 : 28,
|
||
31,
|
||
30,
|
||
31,
|
||
30,
|
||
31,
|
||
31,
|
||
30,
|
||
31,
|
||
30,
|
||
31,
|
||
];
|
||
|
||
let gm = 0;
|
||
for (let i = 0; i < 12; i += 1) {
|
||
if (gDayNo < gregorianMonthDays[i]) {
|
||
gm = i + 1;
|
||
break;
|
||
}
|
||
gDayNo -= gregorianMonthDays[i];
|
||
}
|
||
|
||
const gd = gDayNo + 1;
|
||
const mm = String(gm).padStart(2, "0");
|
||
const dd = String(gd).padStart(2, "0");
|
||
const result = `${gy}-${mm}-${dd}`;
|
||
|
||
return isNaN(new Date(result).getTime()) ? null : result;
|
||
}
|
||
|
||
async function waitForRateLimit() {
|
||
const minDelayMs = Math.ceil(60000 / config.rateLimitPerMinute);
|
||
const elapsed = Date.now() - lastRequestAt;
|
||
if (lastRequestAt > 0 && elapsed < minDelayMs) {
|
||
const waitMs = minDelayMs - elapsed;
|
||
console.log(`[rate-limit] waiting ${waitMs}ms`);
|
||
await sleep(waitMs);
|
||
}
|
||
lastRequestAt = Date.now();
|
||
}
|
||
|
||
function validateConfig() {
|
||
if (!config.mongoUri) throw new Error("MONGO_URL is required");
|
||
if (!Number.isFinite(config.rateLimitPerMinute) || config.rateLimitPerMinute <= 0) {
|
||
throw new Error("RATE_LIMIT_PER_MINUTE must be a positive number");
|
||
}
|
||
if (!Number.isFinite(config.retryCount) || config.retryCount <= 0) {
|
||
throw new Error("RETRY_COUNT must be a positive number");
|
||
}
|
||
if (!config.thirdPartyToken) {
|
||
throw new Error("TEJARAT_THIRD_PARTY_TOKEN or TEJARAT_TOKEN is required");
|
||
}
|
||
if (!config.carBodyToken) {
|
||
throw new Error("TEJARAT_CAR_BODY_TOKEN or TEJARAT_TOKEN is required");
|
||
}
|
||
if (!config.personToken) {
|
||
throw new Error("TEJARAT_PERSON_TOKEN or TEJARAT_TOKEN is required");
|
||
}
|
||
}
|
||
|
||
function loadEnvFiles(filePath) {
|
||
const candidates = path.isAbsolute(filePath)
|
||
? [filePath]
|
||
: [
|
||
path.resolve(process.cwd(), filePath),
|
||
path.resolve(__dirname, "..", filePath),
|
||
];
|
||
|
||
const loaded = [];
|
||
for (const candidate of [...new Set(candidates)]) {
|
||
if (!fs.existsSync(candidate)) continue;
|
||
loadEnvFile(candidate);
|
||
loaded.push(candidate);
|
||
}
|
||
return loaded;
|
||
}
|
||
|
||
function loadEnvFile(filePath) {
|
||
const resolved = path.resolve(process.cwd(), filePath);
|
||
if (!fs.existsSync(resolved)) return;
|
||
|
||
const lines = fs.readFileSync(resolved, "utf8").split(/\r?\n/);
|
||
for (const line of lines) {
|
||
const trimmed = line.trim();
|
||
if (!trimmed || trimmed.startsWith("#")) continue;
|
||
const equalIndex = trimmed.indexOf("=");
|
||
if (equalIndex === -1) continue;
|
||
|
||
const key = trimmed.slice(0, equalIndex).trim();
|
||
let value = trimmed.slice(equalIndex + 1).trim();
|
||
if (
|
||
(value.startsWith('"') && value.endsWith('"')) ||
|
||
(value.startsWith("'") && value.endsWith("'"))
|
||
) {
|
||
value = value.slice(1, -1);
|
||
}
|
||
if (key && process.env[key] === undefined) process.env[key] = value;
|
||
}
|
||
}
|
||
|
||
function requiredEnv(...names) {
|
||
for (const name of names) {
|
||
if (process.env[name]) return process.env[name];
|
||
}
|
||
return "";
|
||
}
|
||
|
||
function firstPresent(...values) {
|
||
return values.find((value) => value !== undefined && value !== null && value !== "");
|
||
}
|
||
|
||
function normalizePlateNumber(value) {
|
||
const cleaned = normalizeDigits(cleanString(value));
|
||
return cleaned === "" ? value : cleaned;
|
||
}
|
||
|
||
function normalizeDigits(value) {
|
||
return cleanString(value).replace(/./g, (char) => {
|
||
const code = char.charCodeAt(0);
|
||
if (code >= 0x06f0 && code <= 0x06f9) return String(code - 0x06f0);
|
||
if (code >= 0x0660 && code <= 0x0669) return String(code - 0x0660);
|
||
return char;
|
||
});
|
||
}
|
||
|
||
function toNumber(value) {
|
||
const number = Number(value);
|
||
return Number.isFinite(number) ? number : value;
|
||
}
|
||
|
||
function cleanString(value) {
|
||
return value === undefined || value === null ? "" : String(value).trim();
|
||
}
|
||
|
||
function clone(value) {
|
||
return JSON.parse(JSON.stringify(value));
|
||
}
|
||
|
||
function sleep(ms) {
|
||
return new Promise((resolve) => setTimeout(resolve, ms));
|
||
}
|