Imports into the General Ledger (chart, journal entries, trial balance), Inventory, Deals, Aged schedules, Customers, Vendors and the Check register with a column-mapping preview, reads packets of old scanned reports (Old reports), restores DMS backups, and runs the nightly manufacturer/lender feeds.
);
};
/* ─── Import (one path for every destination) ─────────────────────────
1 Destination → 2 File → 3 Map columns → 4 Preview (validation + dry run)
→ 5 Import (explicit final action). Nothing is saved before step 5. All
logic is in ImportCore (DMS.importPlan / DMS.importCommit); this is the UI. */
const IMP_STEPS = [[1, "Destination"], [2, "File"], [3, "Map columns"], [4, "Preview"], [5, "Import"]];
// Destination cards: one per group of DMS.IMPORT_GROUPS (order and blurb come from ImportCore); a group with several
// destinations (General Ledger: chart / journal / trial balance / aged schedules) shows them as pills.
const IMP_ICONS = { gl: "📒", inventory: "🚗", deals: "🤝", customers: "👤", vendors: "🏢", checks: "🧾", service: "🔧", parts: "📦" }; // RC25 (imp): + service / parts
const IMP_SUB_LABEL = { glChart: "Chart of accounts", glJournal: "Journal entries", glTrial: "Trial balance (opening balances)", schedule: "Aged schedules (261 / 220 / 220A)", inventory: "Units in stock (vehicle master)", vehicleMaster: "VIN list (lookup only)" };
const impCards = () => {
const D = window.DMS; const G = (D && D.IMPORT_GROUPS) || {};
const dests = D && D.importDests ? D.importDests() : [];
return Object.keys(G).map(k => ({ key: k, icon: IMP_ICONS[k] || "📄", title: G[k].label, blurb: G[k].blurb, dests: dests.filter(d => d.group === k).map(d => d.key) })).filter(c => c.dests.length);
};
// A "posts to the General Ledger" destination needs the extra confirm; everything else is records only.
const IMP_POSTS_GL = { glJournal: true, glTrial: true };
// Which columns of the old report to show next to the record in the preview, per destination (importer field keys)
const IMP_PV_COLS = { glChart: ["alt", "dc", "costAcct", "invAcct"], glTrial: ["mtd", "ytd"], schedule: ["days", "balance"], inventory: ["invoiceDate", "invoiceCost", "repairs", "glCost"], deals: ["date", "buyer", "vehicle", "salePrice", "netNet"],
roHistory: ["date", "flag", "laborSale", "partsSale", "total", "customerPay", "otherPay"], partsMaster: ["bin", "onHand", "cost", "list"], vehicleMaster: ["year", "make", "model"] }; // RC25 (imp)
// "What to check next" after an import: Classic Reports tab, plain words
const IMP_NEXT = {
glChart: { tab: "coa", label: "Classic Reports › Chart of Accounts", why: "Compare the alter numbers, D/C flags and cost / inventory accounts with the printed chart." },
glTrial: { tab: "tb", label: "Classic Reports › Trial Balance (report 11)", why: "Pick the month of the as-of date: every account should show the printed year-to-date amount and the report should end at 0.00 / 0.00." },
glJournal: { tab: "journal", label: "Classic Reports › Journal Document", why: "Look up one of the imported document numbers and compare its lines with the printout." },
inventory: { tab: "vehicles", label: "Classic Reports › Vehicle Master Report", why: "Each inventory account's subtotal (units and GL cost) should equal the printed subtotal; the total should be the printed Total Cars." },
schedule: { tab: "sched", label: "Classic Reports › Aged Schedules", why: "The imported detail shows beside the ledger's balance; the FINAL TOTAL and count should equal the printed ones." },
deals: { tab: "recap", label: "Classic Reports › Deal Recap", why: "Open one imported deal: the recap should show the printed numbers, including net / net." },
// RC25 (imp)
roHistory: { route: "servicedept", label: "Service › Old ROs", why: "Look up one of the imported repair orders by its number or VIN: the totals, the payer and the job lines should match the old printout. The open ones are on the Dispatch Board." },
partsMaster: { route: "partsdept", label: "Parts Dept", why: "The parts list shows the imported parts with their bin, on-hand count and prices. Then tie the value on hand to the ledger on Accounting › Reconcile inventory to GL." },
vehicleMaster: { route: "servicedept", label: "Service › Old ROs", why: "The VIN list feeds the repair-order history lookup (year / make / model by VIN)." },
};
const IMP_RECONCILE_AFTER = { inventory: 1, partsMaster: 1, roHistory: 1 }; // RC25 (imp): offer Reconcile inventory to GL after these
// open Classic Reports on a tab (deal focus optional). Uses the app's navigation when it was handed down, else the sidebar entry.
const impOpenClassic = (go, tab, deal) => {
try { if (tab) localStorage.setItem("k2b-cr-tab", tab); if (deal) localStorage.setItem("jb_deal_focus", String(deal)); } catch (e) {}
if (typeof go === "function") { go("classicreports"); return; }
const el = document.querySelector('.jb-sidebar [data-route="classicreports"]');
if (el) el.click(); else window.k2bToast && window.k2bToast("Open Accounting › Classic Reports from the menu.", "info", 4200);
};
let impAppliedPreload = null; // nonce of the last Old reports hand-off the wizard applied (survives remounts)
const IMP_ACT = {
add: { label: "ADD", bg: "#D9F0DE", fg: "#176A38" },
update: { label: "UPDATE", bg: "#FFF0CC", fg: "#8A6400" },
skip: { label: "SKIP", bg: "#ECECEC", fg: "#555" },
reject: { label: "REJECT", bg: "#F3D9D9", fg: "#9A2A2A" },
};
const impBadge = (bg, fg, t, extra) => {t};
const impDownload = (name, text) => {
const blob = new Blob([text], { type: "text/csv" });
const url = URL.createObjectURL(blob); const a = document.createElement("a");
a.href = url; a.download = name; document.body.appendChild(a); a.click(); a.remove();
setTimeout(() => URL.revokeObjectURL(url), 1000);
};
const impFmtVal = (v) => (v === null || v === undefined || v === "" ? "blank" : typeof v === "number" ? v.toLocaleString("en-US", { maximumFractionDigits: 2 }) : typeof v === "boolean" ? (v ? "Yes" : "No") : String(v));
const impStamp = (iso) => { const d = new Date(iso); return isNaN(d) ? String(iso || "") : d.toLocaleString("en-US", { month: "2-digit", day: "2-digit", year: "numeric", hour: "numeric", minute: "2-digit" }); };
const impFileSlug = (s) => String(s || "import").replace(/\.[^.]+$/, "").replace(/[^A-Za-z0-9\-_]+/g, "-").slice(0, 40);
/* ── import options (the plan options a destination declares in DMS.importDest(key).optionDefs) ───────────────────────── */
const impMoney = (n) => (n == null || n === "" || isNaN(+n) ? "—" : (+n < 0 ? "-$" : "$") + Math.abs(+n).toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 }));
const impIso = (v) => { if (!v) return ""; if (v instanceof Date) return isNaN(v) ? "" : v.getFullYear() + "-" + String(v.getMonth() + 1).padStart(2, "0") + "-" + String(v.getDate()).padStart(2, "0"); const m = String(v).match(/^(\d{4})-(\d{2})-(\d{2})/); if (m) return m[0]; const u = String(v).match(/^(\d{1,2})\/(\d{1,2})\/(\d{2}|\d{4})$/); if (u) return (u[3].length === 2 ? "20" + u[3] : u[3]) + "-" + u[1].padStart(2, "0") + "-" + u[2].padStart(2, "0"); return ""; };
const impOptDefaults = (def) => { const o = {}; ((def && def.optionDefs) || []).forEach(od => { o[od.key] = od.type === "bool" ? !!od.default : od.default != null ? od.default : ""; }); return o; };
// only what the destination declares, only what is set — this is exactly what importPlan (and so the commit) receives
const impOptsForPlan = (def, opts) => {
const out = {};
((def && def.optionDefs) || []).forEach(od => {
const v = opts[od.key];
if (od.type === "bool") out[od.key] = !!v;
else if (v !== "" && v != null) out[od.key] = v;
});
return out;
};
const ImpOptions = ({ def, opts, setOpts, plan, pre, mapped }) => {
// the schedule account is only asked for when the file has no column for it
const defs = ((def && def.optionDefs) || []).filter(od => !(od.key === "glAcct" && mapped && mapped.glAcct));
if (!defs.length) return null;
const S = plan && plan.summary && !plan.error ? plan.summary : null;
const set = (k, v) => setOpts(o => ({ ...o, [k]: v }));
const lab = { fontWeight: 700, fontSize: 12, color: "var(--k2b-navy)" };
const hint = { fontSize: 11, color: "#666", lineHeight: 1.45 };
const weak = S && (S.asOfSource && /print|default|file|sheet|heading/i.test(String(S.asOfSource)) && !/option|you|balance sheet/i.test(String(S.asOfSource)));
return (
Before you import — confirm these
{defs.map(od => {
const v = opts[od.key];
if (od.type === "date") return (
set(od.key, e.target.value)} style={{ font: "inherit", padding: "3px 6px", borderColor: !v && od.required ? "#C0392B" : undefined }} />
{S && S.suggestedAsOf && impIso(S.suggestedAsOf) && impIso(S.suggestedAsOf) !== impIso(v) && }
{pre && pre.asOfIso && impIso(v) === impIso(pre.asOfIso) && od.key === "asOf"
? {pre.asOfLevel === "warn" ? "⚠ only the date the report was printed" + (pre.asOfPrinted ? " (" + pre.asOfPrinted + ")" : "") + " was found in the packet — please check it" : "✓ read from " + (pre.asOfSource || "the old report") + " in the packet"}{pre.asOfPrinted && pre.asOfLevel !== "warn" ? " (the report itself was printed " + pre.asOfPrinted + ")" : ""}
: S && S.asOfSource && {weak ? "⚠ guessed from the " : "✓ taken from "}{S.asOfSource}{weak ? " — please check it" : ""}}
{od.hint || ""} {def.key === "glTrial" ? "The opening balances are dated this day, so everything up to and including it is treated as already inside the trial balance." : ""}
);
if (od.type === "select") return (
{(od.options || []).map(([val, txt]) => (
))}
{S && S.period && od.key === "periodMode" && (
{S.period.asOfPeriodLabel} is {S.period.state === "closed" ? closed : S.period.state === "open" ? "open" : S.period.state === "ahead" ? "after the open month" : "before the open month"}; the open month is {S.period.openLabel}. The entry will be dated {S.period.postDate}.
{S.period.state === "closed" ? " A closed month cannot take an entry: reopen it in Accounting › F6-Period End, or choose “the open month” above." : ""}
)}
);
if (od.type === "bool") return (
);
if (od.options) return (
);
};
// red: nothing can be imported while any of these exist; amber: worth a look
const ImpBlockers = ({ plan, setOpts }) => {
const bl = (plan && plan.blockers) || [];
if (!bl.length) return null;
return (
{s.rows} repair orders: {b.closed} closed (history), {b.open} open (go on the service board), {b.held} held, {b.void} void · total of the non-void ROs {impMoney(s.total)}{s.payerSplit ? <> — customer pay {impMoney(s.customerPay)}, warranty / internal {impMoney(s.otherPay)} : null}{b.open ? <> · labor cost on the open ones {impMoney(s.openLaborCost)} (work in process) : null}
Job lines: {s.lines}{s.linesSheet ? ` from the sheet “${s.linesSheet}”` : ""} on {s.withLines} repair orders · sent in {s.batches} batch{s.batches === 1 ? "" : "es"} of {(window.DMS && window.DMS.IMPORT_BATCH) || 1000}.
{s.note}
);
}
if (s.kind === "roLines") return
{s.lines} job lines for {s.ros} repair orders · {s.note}
;
if (s.kind === "parts") return
Parts in this file
{s.parts} parts · {s.onHandRows} with an on-hand count · value on hand (on-hand × cost) {impMoney(s.onHandValue)} · on-hand counts {s.applyOnHand ? will be set from the file : "are NOT applied"} · prices {s.updatePrices ? "updated" : "kept"}.
{s.note}
;
if (s.kind === "vehicles") return
{s.rows} VINs · sent in {s.batches} batch{s.batches === 1 ? "" : "es"} · {s.note}
;
if (s.kind === "trialBalance") {
const e = s.entry, br = (s.breaks || []).filter(b => b.ok === false), nChecks = (s.checks || []).length, held = !!plan.blocked;
const nLines = (e && e.lines || []).length || plan.toImport;
return (
{held ? "The old report" : "What will be posted to the General Ledger"}
{held
?
Nothing will be posted until the red problems above are fixed.
Each account gets its year-to-date amount from the old report (+ debit / − credit); the month-to-date column is kept for reference only. {s.counts ? s.counts.accountRows + " account row" + (s.counts.accountRows === 1 ? "" : "s") + " in the file" + (held ? "" : "; " + s.counts.posted + " with a balance are posted" + (s.counts.zero ? ", " + s.counts.zero + " at zero are not" : "")) + "; " + s.counts.subtotals + " subtotal rows are used only to check the file." : ""}
{s.balance ? (s.balance.ok ? "✓ The accounts in the file add up to 0.00 (debits equal credits)." : "✕ The accounts do not add up to 0.00 (year to date " + impMoney(s.balance.ytd) + ").") : ""}
{nChecks > 0 &&
{br.length ? "⚠ " + br.length + (br.length === 1 ? " subtotal row of the file does not match its accounts: " : " subtotal rows of the file do not match their accounts: ") + br.map(b => b.label + " (printed " + impMoney(b.printedYtd) + ", accounts add to " + impMoney(b.computedYtd) + ")").join("; ") + "." : "✓ All " + nChecks + " subtotal rows of the file match the accounts above them."}
}
{s.alreadyPosted &&
This trial balance was already imported ({s.alreadyPosted.id}, {s.alreadyPosted.date}); it will not be posted twice.
}
{s.unknown && s.unknown.length > 0 && (
{s.unknown.length} account{s.unknown.length === 1 ? "" : "s"} not in your chart — {(s.newAccounts || []).length ? "they will be added (ticked above) with the name from the report and the type guessed from the account number (shown in brackets; change a type afterwards in the chart of accounts if it is wrong)" : "tick “Add accounts missing from the chart” above or import the chart first"}: {s.unknown.slice(0, 10).map(u => { const na = (s.newAccounts || []).find(a => a.acct === u.acct); return u.acct + (u.didYouMean ? " (did you mean " + u.didYouMean + "?)" : na && na.type ? " (" + na.type + ")" : ""); }).join(", ")}{s.unknown.length > 10 ? " … +" + (s.unknown.length - 10) : ""}
)}
{s.profit && s.profit.note &&
Profit and retained earnings. {s.profit.note}{s.profit.plNet != null ? " Profit & loss accounts net to " + impMoney(s.profit.plNet) + " (debit = loss)." : ""}
}
{(s.byType || []).length > 0 && (
What goes where — by account type
Type
Accounts
Debits
Credits
Net
{s.byType.map((t, i) =>
{t.type}
{t.accounts}
{impMoney(t.debit)}
{impMoney(t.credit)}
{impMoney(t.net)}
)}
)}
);
}
if (s.kind === "schedule") {
return (
Sub-ledger detail only — nothing is posted to the General Ledger
{r.glAcct} {r.name || ""}: imported {impMoney(r.imported)} ({r.rows} row{r.rows === 1 ? "" : "s"}) {r.glBalance == null ? — the General Ledger has no balance for this account yet, so there is nothing to compare with. Import the trial balance to get one. : <>against the ledger balance of {impMoney(r.glBalance)}: {Math.abs(r.diff || 0) < 0.005 ? ✓ equal : difference {impMoney(r.diff)}}}
{r.note ? {r.note} : null}
);
// ── step bodies ──
let body = null;
if (step === 1) body = (
What are you importing?
Pick where the data goes first. Next you choose the file, check how its columns map to DMS fields, and see exactly what will be added, updated, skipped or rejected. Nothing is saved until the owner approves the import (Accounting › Import review & approval): the rows wait on the server, with every problem explained and the totals tied to the general ledger. Have scanned old reports (PDF or photos)? Use Old reports in the menu bar: it reads them and brings the lists here.
Need the layout? Download the import template: K2B-Import-Template.xlsx (every sheet, with a column guide), or one CSV per sheet:
{["Chart_of_Accounts", "GL_Opening_Balances", "Journal_Entries", "Vendors", "Check_Register", "Customers", "Service_Customers", "Vehicles", "Inventory", "Floorplan_Statement", "Parts", "Aged_Schedules", "AR_Aging", "Warranty_Claims", "Body_Shop_WIP", "Sales_Deals", "Repair_Orders", "RO_Lines", "Tie_Out"].map(n => {n})}
{window.ImpTemplateGuideButton ? : null}{/* RC36 (imp36): a template for every import — its CSV, sheet, made-up sample row and what each column means / which GL account it ties to */}
· the customer_number column is the 7-digit customer # (the phone without the area code)
{def.label}: {def.match}{dest === "glJournal" ? " Entries must balance, use accounts in the chart and fall in an open period." : ""}{IMP_POSTS_GL[dest] ? "" : dest === "glChart" ? "" : " Nothing is posted to the General Ledger."}
CSV, Excel (.xls / .xlsx) or a PDF printout with the column names in the first row{dest === "customers" ? ". Customer sheets as Word / photos are read with OCR too" : ""}. The file is read here in your browser — nothing is saved yet. A PDF is read from its text (every row is marked “read from PDF — check” until approved); pages with no text layer are scanned pages — read those in Old reports.
{["glTrial", "schedule", "deals", "glChart", "inventory"].includes(dest) && <> A scanned or photographed old report (photo / scanned PDF)? Open Old reports in the menu bar instead — it reads the pages and brings the list here, checked against the printed totals.}
{" "}Template: K2B-Import-Template.xlsx.
{pre &&
✓ Loaded from Old reports: {pre.label} ({file ? file.sheets[0].rows.length : 0} rows).
}
{wbInfo && wbInfo.ok && (
This is the whole old-system workbook — {wbInfo.recognised} sheets recognised ({wbInfo.names.join(", ")}){wbInfo.unknown && wbInfo.unknown.length ? · not recognised (not imported): {wbInfo.unknown.map(u => u.name).join(", ")} : null}{wbInfo.missing && wbInfo.missing.indexOf("GL_Opening_Balances") !== -1 ? · no GL_Opening_Balances sheet : null}. It can be imported as ONE job, every sheet to its own destination in the README's load order, with the counts per sheet shown first.
⚠ {sheet.formulas} cell{sheet.formulas === 1 ? " of this sheet is a formula" : "s of this sheet are formulas"} with no saved result (a file written by a program, never opened in Excel). They are NOT read as $0.00: those rows are refused on the preview with the reason. Open the file in Excel and save it (or paste the values), then choose it again.
{[["all", "All", plan.items.length, "#E8EEF5", "var(--k2b-navy)"], ["add", def && def.async ? "To send" : "Add", plan.counts.added], ["update", "Update", plan.counts.updated], ["skip", "Skip", plan.counts.skipped], ["reject", "Reject", plan.counts.rejected]].map(([k, l, n, bg, fg]) => {
const a = IMP_ACT[k] || { bg, fg };
return (
);
})}
{!isJE && !neverClear && (
)}
{neverClear && A blank cell never erases anything for this kind of import.}
{def && def.async && These rows are checked by the server when they arrive: it adds the new ones, updates only where the file differs and leaves the rest unchanged — the last step shows its counts. (This station cannot see the history already on the server.)}
{plan.unmapped.length > 0 && (
Not imported — kept in the import history: {plan.unmapped.map(u => `${u.header} (${u.values.length} value${u.values.length === 1 ? "" : "s"}${u.samples.length ? ", e.g. " + u.samples.slice(0, 2).join(", ") : ""})`).join(" · ")}
)}
{dest === "checks" &&
Check-register import adds register records only — no GL entries are posted. Checks that already have a GL entry (CK-#) are linked, never posted twice.
}
{isJE &&
Each entry must balance, use accounts in the chart and fall in an open period. Nothing posts until you confirm on the last step.
}
Row{isJE ? "s" : ""}
Result
{isJE ? "Entry ref" : dest === "glTrial" ? "Account" : dest === "deals" ? "Deal #" : "Record"}
{impBadge(IMP_ACT.skip.bg, IMP_ACT.skip.fg, "SKIP")} {c.skipped} already on file, no change: {list(keysOf("skip"))}
{impBadge(IMP_ACT.reject.bg, IMP_ACT.reject.fg, "REJECT")} {c.rejected} not imported (see error list): {list(keysOf("reject"))}
{isJE &&
This posts to the General Ledger. {c.added} balanced entr{c.added === 1 ? "y" : "ies"} totaling {jeTotal.toLocaleString("en-US", { style: "currency", currency: "USD" })} will post with source “Import”. Posted entries can only be corrected by reversing them in Accounting.
}
{dest === "glTrial" && tbEntry &&
This posts to the General Ledger. One opening-balances entry ({tbEntry.ref}, {tbEntry.date}) with {plan.toImport} account line{plan.toImport === 1 ? "" : "s"}. You can undo it afterwards (it is reversed, not deleted).
}
{dest === "checks" &&
Register records only — no GL entries will be posted for these checks.
}
{(dest === "schedule" || dest === "inventory" || dest === "deals" || dest === "partsMaster" || dest === "vehicleMaster" || dest === "svcCustomers" || dest === "arAging" || dest === "warrantyClaims" || dest === "bodyWip") &&
Records only — nothing is posted to the General Ledger.
}
{dest === "roHistory" && plan.summary &&
History only — no journal entry (the closed repair orders are already in the old books). The rows go to the server in {plan.summary.batches || 1} batch{(plan.summary.batches || 1) === 1 ? "" : "es"}; you will see the progress, and a dropped connection continues where it stopped.
}
Nothing is saved or posted by this button. The rows are sent to the server and wait for the owner's approval on Accounting › Import review & approval, where every problem row is explained and the lists are tied to the general ledger. An import-history record is written when the run is approved.
);
}
if (step === 6 && !result && progress) { // RC25 (imp): the batches on their way
const pct = progress.total ? Math.round(progress.done / progress.total * 100) : 0;
const c = progress.counts || {};
body = (
{progress.status === "failed" ? "⚠ The import stopped" : progress.status === "starting" ? "Starting the import…" : `Sending to the server — batch ${progress.done} of ${progress.total}`}
{progress.status !== "failed" && <>
{(progress.rows || 0).toLocaleString("en-US")} of {(progress.rowsTotal || 0).toLocaleString("en-US")} rows sent ({pct}%){c.added != null ? ` · so far on the server: ${c.added || 0} added, ${c.updated || 0} updated, ${c.unchanged || 0} unchanged, ${c.rejected || 0} rejected` : ""}{progress.resumed ? " · continued from an earlier run" : ""}
Each batch is one step on the server: a batch that is sent twice (a dropped connection, a retry) is never counted twice. You can keep working in another tab; if this page is reloaded, choose the same file again and the import continues from the first batch the server has not seen.
}
{progress.status === "failed" &&
{progress.msg}{progress.batchNo ? ` (stopped at batch ${progress.batchNo})` : ""}
}
);
}
if (step === 6 && result && result.staged) { // RC30 (imp2): the rows are on the server, waiting for the owner's approval
const h = result.history, c = result.counts || {};
body = (
⏳ Sent for approval — {def.label}
{c.staged || 0} rows ready0 written yet{c.skipped || 0} skipped{c.rejected || 0} with problemsImport run {result.runId} · {impStamp(h.at)} · {h.by || "—"}
{result.msg &&
{result.msg}
}
{result.server &&
Server run {result.server.runId} · {result.server.batches} batch{result.server.batches === 1 ? "" : "es"} · status Waiting for approval — nothing is in the records or the general ledger yet.
}
Next: the owner reviews and approves. The review screen shows every row with a problem and what it most likely means, ties the lists to the general ledger as of the as-of date, and offers the reconciling entries. Approval writes the records and posts the ticked entries in one step; it can be undone while nothing has used the data.
Server run {result.server.runId} · {result.server.batches} batch{result.server.batches === 1 ? "" : "es"}{dest === "roHistory" && result.summary && result.summary.kind === "roHistory" ? ` · closed ${result.server.closed} · open ${result.server.open} (${result.server.boardOpened} put on the board) · held ${result.server.held} · void ${result.server.voided}${result.server.boardUntouched ? ` · ${result.server.boardUntouched} started in K2B — untouched` : ""}` : ""}{dest === "roHistory" && result.summary && result.summary.kind === "roLines" ? ` · lines attached to ${result.server.linesAttached} repair orders${result.server.linesNoRo ? `, ${result.server.linesNoRo} not imported yet` : ""}` : ""}
}
{IMP_RECONCILE_AFTER[dest] && !undone && (
Now tie it to the General Ledger. The reconciliation screen shows, per inventory account, what this list says is on hand next to what the ledger carries, the difference, and the two ways to post it.
{plan.counts.rejected} rejected entr{plan.counts.rejected === 1 ? "y is" : "ies are"} NOT posted.
}
Posted entries can only be corrected by reversing them in Accounting.
)}
)}
{confirmUndo && result && (
setConfirmUndo(false)}
buttons={<>
setConfirmUndo(false)}>Keep it
}>
{dest === "glTrial" ? "The opening-balances entry is reversed in the General Ledger (a reversing entry is posted; nothing is deleted). Accounts that were added to the chart stay." : "The rows this import added are removed. Rows you edited since are kept and listed."}
)}
);
};
/* Import history: who / when / file / mapping / counts / affected records. */
const ImportHistoryView = ({ focus, onFocus, onBack, rev, go }) => {
const D = window.DMS;
const SKIP = (D && D.IMPORT_SKIP) || "__skip";
const hist = (D && D.importHistory ? D.importHistory() : []) || [];
const [open, setOpen] = React.useState(null); // affected record id expanded
const [undoFor, setUndoFor] = React.useState(null); // history record waiting for "Undo this import?" confirmation
const sel = hist.find(h => h.id === focus) || null;
const cell = { padding: "4px 7px", borderTop: "1px solid #EEE", verticalAlign: "top" };
const hcell = { padding: "5px 7px", textAlign: "left", position: "sticky", top: 0, background: "#F0F3F7", zIndex: 1, whiteSpace: "nowrap", fontWeight: 700, borderBottom: "1px solid #D6DEE7" };
const btn = (primary) => ({ fontWeight: 700, padding: "4px 12px", background: primary ? "#FFE9B0" : undefined });
const box = { background: "#FFF", border: "1px solid #C9D6E3", borderRadius: 4 };
const def = sel && D.importDest ? D.importDest(sel.dest) : null;
const fieldLabel = def ? Object.fromEntries(def.fields.map(f => [f.key, f.label])) : {};
const recView = (rec) => {
if (!rec) return not found now (deleted or renamed since the import);
if (sel.dest === "glJournal") return (
How to undo: {sel.undo.kind === "journal" ? "the entry is reversed in the General Ledger" : "the unedited rows this import added are removed"} (the Undo button above).
{undoFor && (
setUndoFor(null)}
buttons={<>
setUndoFor(null)}>Keep it
}>
{undoFor.dest === "glTrial" || undoFor.undo.kind === "journal" ? "The entry is reversed in the General Ledger (a reversing entry is posted; nothing is deleted)." : "The rows this import added are removed. Rows you edited since are kept and listed."} {undoFor.destLabel} — {undoFor.file}
)}
);
};
/* ─── Import wizard (REAL — parses & loads a file into the ledger) ─────── */
// Tolerant CSV → array-of-objects parser (handles quoted fields).
const parseCSV = (text) => {
const rows = []; let row = [], cur = "", q = false;
for (let i = 0; i < text.length; i++) {
const c = text[i];
if (q) {
if (c === '"' && text[i + 1] === '"') { cur += '"'; i++; }
else if (c === '"') q = false;
else cur += c;
} else {
if (c === '"') q = true;
else if (c === ",") { row.push(cur); cur = ""; }
else if (c === "\n" || c === "\r") { if (cur !== "" || row.length) { row.push(cur); rows.push(row); row = []; cur = ""; } if (c === "\r" && text[i + 1] === "\n") i++; }
else cur += c;
}
}
if (cur !== "" || row.length) { row.push(cur); rows.push(row); }
if (!rows.length) return [];
const head = rows[0].map(h => h.trim());
return rows.slice(1).filter(r => r.some(c => c.trim() !== "")).map(r => { const o = {}; head.forEach((h, i) => o[h] = (r[i] || "").trim()); return o; });
};
// Map a CSV record set into the DMS dataset it most resembles.
const csvToDataset = (records) => {
if (!records.length) return { key: null, rows: [] };
const keys = Object.keys(records[0]).map(k => k.toLowerCase());
const has = (...names) => names.some(n => keys.some(k => k.includes(n)));
if (has("vin", "stock")) return { key: "inventory", rows: records };
if (has("acct", "account") && has("name", "customer")) return { key: "arCustomers", rows: records };
if (has("buyer", "deal")) return { key: "deals", rows: records };
return { key: "arCustomers", rows: records };
};
const ImportWizard = ({ step, setStep, source, setSource, path, setPath, picked, setPicked, onClose }) => {
const [file, setFile] = React.useState(null);
const [parsed, setParsed] = React.useState(null); // { data, label } ready for import
const [parseErr, setParseErr] = React.useState("");
const [needPass, setNeedPass] = React.useState(false);
const [passText, setPassText] = React.useState("");
const [encBlob, setEncBlob] = React.useState(null);
const [mode, setMode] = React.useState("merge"); // merge | replace
const [progress, setProgress] = React.useState(0);
const [done, setDone] = React.useState(false);
const [result, setResult] = React.useState(null);
// Document parsing (PDF/Word/Excel/OCR)
const [parsing, setParsing] = React.useState(false);
const [parsePct, setParsePct] = React.useState(0);
const [parseStat, setParseStat] = React.useState("");
const [custPreview, setCustPreview] = React.useState(null); // extracted customer records
const fileRef = React.useRef(null);
const simRows = IMPORT_TABLES.filter(t => picked[t.key]).reduce((s, t) => s + t.rows, 0);
const ingestText = (text, name) => {
setParseErr(""); setNeedPass(false); setEncBlob(null);
const trimmed = (text || "").trim();
if (trimmed.startsWith("JBZ1:")) { // our encrypted backup → need passphrase
setEncBlob(trimmed); setNeedPass(true); setParsed(null); return;
}
try { // JSON backup (JBREWS or generic)
const obj = JSON.parse(trimmed);
const data = obj && obj.data ? obj.data : obj;
setParsed({ data, label: obj && obj.format ? `${obj.format} backup` : "JSON export", source: name, isBackup: !!(obj && obj.format) });
return;
} catch (e) {}
// Fall back to CSV / fixed-width legacy "Z file".
const records = parseCSV(trimmed);
if (records.length) {
// Classify + map through the shared importer so vehicle inventory gets
// the column mapping / preview and the stock-#/VIN merge (never a raw append).
const JI = window.JBImporters;
const ds = JI ? JI.datasetFromRows(records, name) : null;
if (ds && ds.count) { setParsed({ datasets: [ds], label: `${ds.count} ${ds.label} (CSV)`, source: name }); return; }
const guess = csvToDataset(records);
if (guess.key === "inventory") { setParsed({ datasets: [{ collection: "inventory", label: "Vehicle Inventory", confidence: "low", sheet: name, count: records.length, rows: records, raw: records }], label: `${records.length} Vehicle Inventory (CSV)`, source: name }); return; }
setParsed({ data: { [guess.key]: guess.rows }, label: `${records.length} ${guess.key} rows (CSV)`, source: name });
} else {
setParseErr("Could not read this file. Supported: DMS .json / .jbz backups, or CSV exports.");
setParsed(null);
}
};
const onFile = async (f) => {
if (!f) return;
setFile(f); setParseErr(""); setParsed(null); setCustPreview(null);
setNeedPass(false); setEncBlob(null);
const e = (f.name.split(".").pop() || "").toLowerCase();
// Restore takes DMS backups only. Spreadsheets / documents go through
// Import (destination → mapping → preview → explicit import).
if (e !== "json" && e !== "jbz") {
setParseErr("Restore takes a DMS backup (.json / .jbz). Spreadsheets and documents go through Import — pick a destination first (Import menu).");
return;
}
const docType = ["xlsx", "xls", "docx", "pdf", "png", "jpg", "jpeg", "gif", "bmp", "tif", "tiff", "webp"].includes(e);
// Plain text/JSON/CSV → fast path through the existing text ingester.
if (!docType && !window.JBImporters) {
const reader = new FileReader();
reader.onload = () => ingestText(String(reader.result), f.name);
reader.readAsText(f);
return;
}
try {
setParsing(true); setParsePct(0); setParseStat("Opening " + f.name + "…");
const res = await window.JBImporters.parseFile(f, (pct, st) => { setParsePct(pct); if (st) setParseStat(st); });
setParsing(false);
if (res.kind === "jbz") { setEncBlob(res.blob); setNeedPass(true); return; }
if (res.kind === "json") { setParsed({ data: res.data, label: res.label, source: f.name, isBackup: /backup$/.test(res.label || "") }); return; }
if (res.kind === "csvtext") { ingestText(res.text, f.name); return; }
if (res.kind === "multi") {
if (!res.datasets.length) { setParseErr("No recognizable data found in this file."); return; }
setParsed({ datasets: res.datasets, label: res.label, source: f.name });
return;
}
if (res.kind === "collections") { setParsed({ data: res.data, label: res.label, source: f.name }); return; }
if (res.kind === "customers") {
if (!res.customers.length) { setParseErr("No customer records could be read from this document."); return; }
setCustPreview(res.customers);
setParsed({ customers: res.customers, label: res.label, source: f.name });
return;
}
if (res.kind === "text") {
// Couldn't structure it — still try the customer extractor, else show a note.
setParseErr(`Read the document text but found no recognizable customer fields. ${res.text ? "Preview: " + res.text.slice(0, 120).replace(/\s+/g, " ") + "…" : ""}`);
return;
}
} catch (err) {
setParsing(false);
setParseErr("Could not parse this file: " + (err && err.message ? err.message : err));
}
};
const decryptBlob = async () => {
try {
const plain = await window.JBVault.decryptWithPass(passText, encBlob);
ingestText(plain, file ? file.name : "backup.jbz");
setNeedPass(false);
} catch (e) { setParseErr("Incorrect passphrase for this encrypted backup."); }
};
// Vehicle inventory ALWAYS goes through DMS.importInventory (match by stock #,
// then VIN; blanks keep existing values unless the user chose to clear them).
// Datasets already imported from the preview are not imported twice.
const importDatasetsSafe = (datasets, m) => {
const D = window.DMS;
const inv = datasets.filter(d => d.collection === "inventory");
const rest = datasets.filter(d => d.collection !== "inventory");
const counts = {}; const invIssues = []; const parts = [];
inv.forEach(d => {
if (d.imported) { parts.push(`inventory${d.sheet ? " (" + d.sheet + ")" : ""} already imported from the preview`); return; }
const JI = window.JBImporters;
const pr = JI && JI.prepareInventoryRows ? JI.prepareInventoryRows(d, { clearBlanks: !!d.clearBlanks, units: D.inventory() }) : { rows: d.rows || [], issues: [] };
const r = D.importInventory(pr.rows, { clearBlanks: !!d.clearBlanks });
invIssues.push(...pr.issues);
counts["inventory — new"] = (counts["inventory — new"] || 0) + r.created;
counts["inventory — updated"] = (counts["inventory — updated"] || 0) + r.updated;
counts["inventory — unchanged"] = (counts["inventory — unchanged"] || 0) + r.unchanged;
invIssues.push(...(d.mapIssues || []), ...(r.errors || []));
parts.push(`inventory: ${r.created} new · ${r.updated} updated · ${r.unchanged} unchanged`);
});
let ok = inv.length > 0;
if (rest.length) {
const r = D.importDatasets(rest, { mode: m });
Object.assign(counts, r.counts || {}); parts.push(r.msg); ok = ok || r.ok;
}
if (invIssues.length) parts.push(`${invIssues.length} inventory issue(s) — see list`);
return { ok, msg: parts.join(" · ") || "Nothing recognized to import.", counts, invIssues };
};
// JSON: a full DMS backup is a restore (importBackup). A generic JSON export
// with an inventory list merges that list through importInventory instead.
const importJsonSafe = (data, m, isBackup) => {
const D = window.DMS;
if (isBackup || !data || !Array.isArray(data.inventory) || !data.inventory.length) return D.importBackup(data, m);
const ir = D.importInventory(data.inventory, {});
const rest = { ...data }; delete rest.inventory;
const hasRest = Object.values(rest).some(v => Array.isArray(v) && v.length);
const br = hasRest ? D.importBackup(rest, m) : { ok: true, msg: "", counts: {} };
return { ok: true, msg: [`inventory: ${ir.created} new · ${ir.updated} updated · ${ir.unchanged} unchanged`, br.msg].filter(Boolean).join(" · "),
counts: { ...(br.counts || {}), "inventory — new": ir.created, "inventory — updated": ir.updated }, invIssues: ir.errors || [] };
};
const resetFile = () => {
setFile(null); setParsed(null); setCustPreview(null); setParseErr(""); setNeedPass(false); setEncBlob(null);
if (fileRef.current) fileRef.current.value = "";
};
const updateDs = (i, fn) => setParsed(p => {
if (!p || !p.datasets) return p;
const datasets = p.datasets.map((x, j) => j === i ? fn(x) : x);
return { ...p, datasets };
});
const runImport = () => {
if (!parsed) return;
setStep(4); setDone(false); setProgress(0); setResult(null);
const tick = setInterval(() => setProgress(p => Math.min(95, p + 7 + Math.random() * 8)), 120);
setTimeout(() => {
clearInterval(tick);
let r;
try {
r = parsed.datasets
? importDatasetsSafe(parsed.datasets, mode)
: parsed.customers
? window.DMS.importCustomers(parsed.customers)
: importJsonSafe(parsed.data, mode, parsed.isBackup);
} catch (e) { r = { ok: false, msg: "Import failed: " + (e && e.message ? e.message : e) }; }
setProgress(100); setDone(true); setResult(r);
window.k2bToast && window.k2bToast(r.ok ? `Import complete — ${r.msg}` : r.msg, r.ok ? "ok" : "warn", 3800);
}, 900);
};
return (
Restores a full DMS backup file (.json or encrypted .jbz). To bring in a spreadsheet from another system (GL, inventory, customers, vendors, checks) use Import — it maps the columns and shows a preview before anything is saved.
{/* REAL file picker — now PDF / Word / Excel / image OCR aware */}
Select the backup file
A backup downloaded from Controls → Backup & Restore (.json) or an encrypted backup (.jbz, needs its passphrase). Nothing is written until you confirm in Step 3.
No file loaded yet. Go back to Step 1 and choose your export file.
)}
Import mode
{parsed && parsed.customers
?
Customer records are merged — new people are added and matching phone numbers are updated. Existing data is preserved.
: [["merge", "Merge — add new records, keep existing data (recommended)"],
["replace", "Replace — overwrite the entire ledger with this file"]].map(([k, lbl]) => (
))}
{mode === "replace"
? <>Heads up: Replace overwrites all current records. Export a backup first if unsure.
: <>Safe: Merge only adds records not already present — existing data is preserved.}
);
};
/* ─── Vehicle inventory: column mapping + dry-run preview ───────────────
Shown as soon as a file with vehicle inventory is read. Every column is
mapped to a DMS field (changeable), the dry run comes from the SAME core
function the import uses (DMS.importInventory, dryRun) — existing units are
matched by stock #, then VIN; blank cells keep existing data unless the user
ticks "Blank cells clear existing values". Every skipped row / field is in
the issue list; nothing is dropped silently. */
const InvImportPreview = ({ ds, onChange, onImported, onCancel }) => {
const D = window.DMS, JI = window.JBImporters;
const [rev, setRev] = React.useState(0);
React.useEffect(() => (D && D.subscribe ? D.subscribe(() => setRev(r => r + 1)) : undefined), []);
const clearBlanks = !!ds.clearBlanks;
const done = ds.importResult || null;
// Same row prep for the dry run and the real import (see prepareInventoryRows).
const prep = React.useMemo(() => (JI && JI.prepareInventoryRows ? JI.prepareInventoryRows(ds, { clearBlanks, units: D.inventory() }) : { rows: ds.rows || [], issues: [] }), [ds, clearBlanks, rev]);
const dry = React.useMemo(() => {
try { return D.importInventory(prep.rows, { dryRun: true, clearBlanks }); }
catch (e) { return { created: 0, updated: 0, unchanged: 0, plan: [], errors: [{ row: "—", field: "—", reason: "Preview failed: " + (e && e.message) }] }; }
}, [prep, clearBlanks]);
// The core compares JSON, so 2020 vs "2020", undefined vs "" or 0 count as
// "changes". Show only changes a person would call a change.
const NUMF = { miles: 1, cost: 1, asking: 1, msrp: 1 };
const same = (f, a, b) => NUMF[f]
? (a == null || a === "" ? 0 : +a) === (b == null || b === "" ? 0 : +b)
: String(a == null ? "" : a).trim() === String(b == null ? "" : b).trim();
const realPlan = (r) => (r.plan || []).map(p => {
if (p.action !== "update") return p;
const ch = {}; Object.keys(p.changes || {}).forEach(f => { if (!same(f, p.changes[f].from, p.changes[f].to)) ch[f] = p.changes[f]; });
return Object.keys(ch).length ? { ...p, changes: ch } : { ...p, action: "unchanged" };
});
const tally = (r) => { const pl = realPlan(r); return { ...r, plan: pl, created: pl.filter(p => p.action === "create").length, updated: pl.filter(p => p.action === "update").length, unchanged: pl.filter(p => p.action === "unchanged").length }; };
const res = tally(done || dry);
const issues = [...(ds.mapIssues || []), ...(done ? (done.prepIssues || []) : prep.issues), ...(res.errors || [])].sort((a, b) => (+a.row || 0) - (+b.row || 0));
const planByRow = {}; (res.plan || []).forEach(p => { planByRow[p.row] = p; });
const issuesByRow = {}; issues.forEach(x => { (issuesByRow[x.row] = issuesByRow[x.row] || []).push(x); });
const nRows = (ds.rows || []).length;
const skipped = nRows - (res.plan || []).length;
const dryT = tally(dry);
const toImport = dryT.created + dryT.updated;
const fields = (JI && JI.INV_FIELDS) || [];
const fieldLabel = Object.fromEntries(fields.map(f => [f.key, f.label]));
const mapped = new Set(Object.values(ds.mapping || {}).filter(Boolean));
const KEY6 = ["stock", "vin", "asking", "cost", "miles", "newUsed"];
const missing = KEY6.filter(k => !mapped.has(k));
const sampleOf = (h) => { const r = (ds.raw || []).find(x => String((x || {})[h] ?? "").trim()); return r ? String(r[h]).trim() : ""; };
const setMap = (header, field) => {
const next = { ...(ds.mapping || {}) };
if (field) Object.keys(next).forEach(h => { if (h !== header && next[h] === field) next[h] = ""; }); // one column per field
next[header] = field;
onChange(JI.remapInventory(ds, next));
};
const money = (v) => (v === null || v === undefined || v === "" || Number.isNaN(v)) ? "" : "$" + Number(v).toLocaleString("en-US", { minimumFractionDigits: Number(v) % 1 ? 2 : 0, maximumFractionDigits: 2 });
const miles = (v) => (v === null || v === undefined || v === "" || Number.isNaN(v)) ? "" : Number(v).toLocaleString("en-US");
const runReal = () => {
let r;
const pr = JI && JI.prepareInventoryRows ? JI.prepareInventoryRows(ds, { clearBlanks, units: D.inventory() }) : { rows: ds.rows || [], issues: [] };
try { r = D.importInventory(pr.rows, { clearBlanks }); }
catch (e) { window.k2bToast && window.k2bToast("Import failed: " + (e && e.message), "warn", 4000); return; }
r = { ...r, prepIssues: pr.issues };
onImported(r);
const nIss = (ds.mapIssues || []).length + pr.issues.length + (r.errors || []).length;
const t = tally(r);
window.k2bToast && window.k2bToast(`Inventory import — ${t.created} new · ${t.updated} updated · ${t.unchanged} unchanged${nIss ? ` · ${nIss} issue(s) listed` : ""}`, nIss ? "warn" : "ok", 4200);
};
const downloadReport = () => {
const q = (v) => { const s = String(v == null ? "" : v); return /[",\n]/.test(s) ? '"' + s.replace(/"/g, '""') + '"' : s; };
const lines = [["row", "stock", "result", "field", "detail"].join(",")];
(res.plan || []).forEach(p => {
if (p.action === "update") Object.keys(p.changes || {}).forEach(f => lines.push([p.row, p.stock, "updated", f, `${p.changes[f].from ?? ""} → ${p.changes[f].to ?? ""}`].map(q).join(",")));
else lines.push([p.row, p.stock, p.action === "create" ? "created" : "unchanged", "", ""].map(q).join(","));
});
issues.forEach(x => lines.push([x.row, ((ds.rows || [])[+x.row - 2] || {}).stock || "", "issue", x.field, x.reason].map(q).join(",")));
const blob = new Blob([lines.join("\n")], { type: "text/csv" });
const url = URL.createObjectURL(blob); const a = document.createElement("a");
a.href = url; a.download = `inventory-import-${done ? "result" : "preview"}-${new Date().toISOString().slice(0, 10)}.csv`; a.click();
setTimeout(() => URL.revokeObjectURL(url), 1000);
};
const cell = { padding: "3px 6px", borderTop: "1px solid #EEE", whiteSpace: "nowrap" };
const hcell = { padding: "4px 6px", textAlign: "left", position: "sticky", top: 0, background: "#F0F0F0", zIndex: 1, whiteSpace: "nowrap" };
const badge = (bg, fg, t) => {t};
const ACTION = {
create: badge("#D9F0DE", "#176A38", "NEW"), update: badge("#FFF0CC", "#8A6400", "UPDATE"),
unchanged: badge("#ECECEC", "#555", "NO CHANGE"), skipped: badge("#F3D9D9", "#9A2A2A", "SKIPPED"),
};
const btn = (primary) => ({ fontWeight: 700, padding: "4px 12px", background: primary ? "#FFE9B0" : undefined });
// One preview cell: the file's value; changed fields highlighted; a blank
// file cell on an existing unit shows the value that is KEPT (or CLEARED).
const valCell = (f, fileVal, fmt, p, unit, key) => {
const blank = fileVal === null || fileVal === undefined || fileVal === "" || Number.isNaN(fileVal);
const ch = p && p.action === "update" && p.changes && p.changes[f];
const style = { ...cell, textAlign: fmt === "text" ? "left" : "right", fontFamily: fmt === "text" ? undefined : "'Courier Prime', monospace" };
const show = (v) => fmt === "money" ? money(v) : fmt === "miles" ? miles(v) : String(v ?? "");
if (ch) return
{blank ? cleared : show(fileVal)}
;
if (blank && unit && unit[f] !== undefined && unit[f] !== "" && unit[f] !== null)
return
{show(unit[f])} kept
;
if (blank) return
—
;
return
{show(fileVal)}
;
};
return (
🚗 Vehicle inventory — {done ? "import result" : "check the column mapping and preview before importing"}{ds.sheet ? `(${ds.sheet})` : ""} · {nRows} row{nRows === 1 ? "" : "s"} · existing units matched by stock #, then VIN
{/* (a) column mapping */}
{!done && (
File column
Sample
Imports into (DMS field)
{(ds.headers || []).map(h => (
{h}
{sampleOf(h) || "—"}
))}
{(ds.unmapped || []).length > 0 && (
Unmapped columns — not imported: {(ds.unmapped || []).join(", ")}. Pick a DMS field in the dropdown to bring one in.
)}
{missing.length > 0 && (
No column found for: {missing.map(k => fieldLabel[k]).join(", ")} — {missing.length === 1 ? "that field is" : "those fields are"} left unchanged on existing units (new units get it blank / $0){missing.includes("newUsed") ? "; new units without New/Used are saved as Used" : ""}.
… {nRows - 200} more row(s) not shown — all {nRows} are included in the counts, the import and the issue list.
}
{/* issues */}
{issues.length > 0 && (
⚠ {issues.length} row/field issue{issues.length === 1 ? "" : "s"} — {done ? "these were NOT imported as-is" : "fix the file or the mapping, or import and correct afterwards"}
Row
Field
What happened
{issues.map((x, k) => (
{x.row}
{x.field}
{x.reason}
))}
)}
{!done ? (<>
{toImport ? `${dryT.created} new unit(s) will be added and ${dryT.updated} existing unit(s) updated. Nothing is written until you click Import.` : "Every row matches what is already in inventory."}
) : (<>
✓ Saved to inventory: {res.created} new · {res.updated} updated · {res.unchanged} unchanged.
)}