mirror of
https://github.com/R0m1k3/CollectFlow.git
synced 2026-10-19 13:08:11 +02:00
Claude
48860271a5
- Grille servie depuis l'instantané (lot 4) : les colonnes réseau sont relues dans le cache Qlik, comme le calcul en direct. Elles restaient figées à la date du calcul de l'instantané. - Tendance : si la fenêtre du jour est incomplète mais que les 12 mois précédents le sont (cache Qlik pas encore resynchronisé depuis le changement de mois), la tendance porte sur ces 12 mois au lieu de disparaître. Le modal le signale. - Courbe des magasins vendeurs alignée sur les mois de la tendance (modal Grille et fiche produit). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015MouZgPPAuEZjHXXifW7bm
780 lines
37 KiB
TypeScript
780 lines
37 KiB
TypeScript
import "server-only";
|
|
|
|
import type { ProductRow, GammeCode, GridFilters } from "@/types/grid";
|
|
import { buildLast12MonthsRange, getMensuelByArticles } from "@/lib/api-ff-client";
|
|
import {
|
|
pgGetArticlesByFournisseur,
|
|
pgGetMensuelByFournisseur,
|
|
pgGetGammesByFournisseur,
|
|
pgGetNomenclatureByFournisseur,
|
|
pgGetStockByFournisseur,
|
|
pgGetCommandesByFournisseur,
|
|
pgGetPrixVenteByFournisseur,
|
|
type PgStockRow,
|
|
} from "@/lib/pg-ff-client";
|
|
import { db } from "@/db";
|
|
import { sessionSnapshots } from "@/db/schema";
|
|
import { eq, desc } from "drizzle-orm";
|
|
import { getNetworkMetricsByCodeCentrale, type NetworkMetricCached } from "@/lib/qlik-network-cache";
|
|
import { NB_MAGASINS_RESEAU } from "@/features/grid/lib/network-trend";
|
|
// Persiste l'instantané lu par /api/v1 : sans lui, l'API n'aurait aucune donnée.
|
|
import { readGridSnapshot, upsertGridRows } from "@/lib/grid-store";
|
|
import {
|
|
applyStorePatchInPlace,
|
|
buildStorePatchEntries,
|
|
storePatchCandidates,
|
|
type StorePatch,
|
|
type StorePatchEntry,
|
|
} from "@/features/grid/lib/store-patch";
|
|
|
|
interface GetProductRowsInput {
|
|
codeFournisseur: string;
|
|
magasin?: string;
|
|
filters?: Partial<GridFilters>;
|
|
forceRefresh?: boolean;
|
|
}
|
|
|
|
const GRID_ROWS_CACHE_TTL_MS = 10 * 60 * 1000;
|
|
/**
|
|
* Bornes du cache mémoire. La synchro nocturne et le préchauffage passent par
|
|
* `getProductRows()` pour CHAQUE fournisseur : sans plafond, le processus finissait
|
|
* par garder toutes les grilles en mémoire (plusieurs centaines de Mo), ce qui
|
|
* ralentissait toutes les requêtes (ramasse-miettes). Ordre d'insertion de la Map
|
|
* = ordre d'usage : on évince les entrées les moins récemment servies.
|
|
*/
|
|
const GRID_ROWS_CACHE_MAX_ENTRIES = Number(process.env.GRID_ROWS_CACHE_MAX_ENTRIES ?? 30);
|
|
const GRID_ROWS_CACHE_MAX_ROWS = Number(process.env.GRID_ROWS_CACHE_MAX_ROWS ?? 150_000);
|
|
const gridRowsCache = new Map<string, { rows: ProductRow[]; createdAt: number }>();
|
|
const gridRowsPending = new Map<string, Promise<ProductRow[]>>();
|
|
/** Nombre d'enregistrements de gammes par fournisseur (cf. patchGridRowsCache). */
|
|
const gammeSaveVersion = new Map<string, number>();
|
|
|
|
function cacheGridRows(key: string, rows: ProductRow[]): void {
|
|
gridRowsCache.delete(key);
|
|
gridRowsCache.set(key, { rows, createdAt: Date.now() });
|
|
let totalRows = 0;
|
|
for (const entry of gridRowsCache.values()) totalRows += entry.rows.length;
|
|
for (const [oldKey, entry] of gridRowsCache) {
|
|
if (gridRowsCache.size <= 1) break;
|
|
if (gridRowsCache.size <= GRID_ROWS_CACHE_MAX_ENTRIES && totalRows <= GRID_ROWS_CACHE_MAX_ROWS) break;
|
|
gridRowsCache.delete(oldKey);
|
|
totalRows -= entry.rows.length;
|
|
}
|
|
}
|
|
|
|
function gridRowsCacheKey(input: GetProductRowsInput): string {
|
|
return `${input.codeFournisseur}:${input.magasin ?? "TOTAL"}`;
|
|
}
|
|
|
|
export function invalidateGridRowsCache(codeFournisseur?: string) {
|
|
if (codeFournisseur) {
|
|
for (const key of gridRowsCache.keys()) {
|
|
if (key.startsWith(`${codeFournisseur}:`)) gridRowsCache.delete(key);
|
|
}
|
|
for (const key of gridRowsPending.keys()) {
|
|
if (key.startsWith(`${codeFournisseur}:`)) gridRowsPending.delete(key);
|
|
}
|
|
return;
|
|
}
|
|
gridRowsCache.clear();
|
|
gridRowsPending.clear();
|
|
}
|
|
|
|
/**
|
|
* Reporte des gammes enregistrées sur les lignes déjà en cache, au lieu de jeter
|
|
* le cache : l'invalidation forçait un recalcul complet (jusqu'à ~40 s sur un gros
|
|
* fournisseur) à la réouverture suivante. Le résultat est celui qu'aurait donné
|
|
* ce recalcul : la colonne Gamme reprend la valeur du dernier snapshot (Phase 9),
|
|
* la colonne INIT reste l'état serveur.
|
|
*/
|
|
export function patchGridRowsCache(
|
|
codeFournisseur: string,
|
|
changes: ReadonlyArray<{ codein: string; codeGamme: string }>,
|
|
): void {
|
|
if (changes.length === 0) return;
|
|
// Un calcul en cours pour ce fournisseur a lu les gammes avant cet
|
|
// enregistrement : le compteur lui signale de les relire avant d'être caché.
|
|
gammeSaveVersion.set(codeFournisseur, (gammeSaveVersion.get(codeFournisseur) ?? 0) + 1);
|
|
const byCodein = new Map(changes.map((c) => [c.codein, c.codeGamme as GammeCode]));
|
|
for (const [key, entry] of gridRowsCache) {
|
|
if (!key.startsWith(`${codeFournisseur}:`)) continue;
|
|
for (const row of entry.rows) {
|
|
const gamme = byCodein.get(row.codein);
|
|
if (gamme !== undefined) row.codeGamme = gamme;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Rafraîchit UNIQUEMENT la colonne INIT (codeGammeInit = gamme serveur courante)
|
|
* sur des lignes servies depuis le cache. La colonne Gamme (codeGamme) n'est pas
|
|
* touchée : elle conserve la valeur issue du snapshot. Ainsi l'état serveur (INIT)
|
|
* est toujours à jour à chaque chargement, même sur un hit du cache 10 min — et le
|
|
* marqueur "modifié" (Gamme ≠ INIT) se résorbe dès que le serveur rattrape la modif.
|
|
*/
|
|
async function refreshGammeInit(rows: ProductRow[], codeFournisseur: string): Promise<void> {
|
|
try {
|
|
const gammeMap = await pgGetGammesByFournisseur(codeFournisseur);
|
|
if (gammeMap.size === 0) return;
|
|
for (const row of rows) {
|
|
const live = gammeMap.get(row.codein);
|
|
if (live !== undefined) row.codeGammeInit = live as GammeCode;
|
|
}
|
|
} catch (e) {
|
|
console.error("[getProductRows] refreshGammeInit error:", (e as Error).message?.slice(0, 200));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Écrit l'instantané de grille lu par /api/v1 (table `grid_rows`).
|
|
*
|
|
* Seul `magasin = TOTAL` est persisté : `ProductRow` embarque déjà les ventilations
|
|
* par magasin (sales12mByStore, caByStore…), inutile de stocker trois variantes.
|
|
* Toute erreur est avalée : la persistance ne doit jamais casser l'affichage.
|
|
*/
|
|
async function persistGridSnapshot(input: GetProductRowsInput, rows: ProductRow[]): Promise<void> {
|
|
if ((input.magasin ?? "TOTAL") !== "TOTAL") return;
|
|
try {
|
|
const n = await upsertGridRows(input.codeFournisseur, rows);
|
|
console.log(`[getProductRows] instantané persisté: ${n} lignes pour ${input.codeFournisseur}`);
|
|
} catch (e) {
|
|
console.error("[getProductRows] persistance grid_rows KO:", (e as Error).message?.slice(0, 200));
|
|
}
|
|
}
|
|
|
|
export async function getProductRows(input: GetProductRowsInput): Promise<ProductRow[]> {
|
|
const cacheKey = gridRowsCacheKey(input);
|
|
const cached = gridRowsCache.get(cacheKey);
|
|
if (!input.forceRefresh && cached && Date.now() - cached.createdAt < GRID_ROWS_CACHE_TTL_MS) {
|
|
// Remonte l'entrée en tête de l'ordre d'usage (éviction LRU).
|
|
gridRowsCache.delete(cacheKey);
|
|
gridRowsCache.set(cacheKey, cached);
|
|
// La colonne INIT doit refléter l'état serveur à CHAQUE chargement,
|
|
// y compris sur un hit de cache (les données lourdes restent, elles, cachées).
|
|
await refreshGammeInit(cached.rows, input.codeFournisseur);
|
|
return cached.rows;
|
|
}
|
|
|
|
// Un calcul déjà en cours est réutilisé même en rechargement forcé : il part
|
|
// de données fraîches, et en lancer un second en parallèle doublait la charge
|
|
// (double clic, onglet rouvert…) sans rien apporter.
|
|
const pending = gridRowsPending.get(cacheKey);
|
|
if (pending) {
|
|
return pending;
|
|
}
|
|
|
|
// Instantané persisté (calcul de la nuit ou de la dernière ouverture) : servi
|
|
// en une lecture au lieu d'un recalcul de 10 à 40 s. Jamais en rechargement
|
|
// forcé — c'est précisément ce que l'utilisateur demande d'éviter.
|
|
if (!input.forceRefresh) {
|
|
const servi = await serveFromSnapshot(input, cacheKey);
|
|
if (servi) return servi;
|
|
}
|
|
|
|
const versionAuDepart = gammeSaveVersion.get(input.codeFournisseur) ?? 0;
|
|
const promise = buildProductRows(input).then(async (rows) => {
|
|
if ((gammeSaveVersion.get(input.codeFournisseur) ?? 0) !== versionAuDepart) {
|
|
// Gammes enregistrées pendant le calcul : on reprend le dernier snapshot.
|
|
applySnapshotChanges(rows, await loadLatestSnapshotChanges(input.codeFournisseur));
|
|
}
|
|
cacheGridRows(cacheKey, rows);
|
|
gridRowsPending.delete(cacheKey);
|
|
// Persiste l'instantané pour /api/v1 : le calcul vient d'avoir lieu, on
|
|
// arrête simplement de jeter le résultat. Volontairement NON bloquant —
|
|
// l'affichage de la Grille ne doit pas attendre l'écriture.
|
|
void persistGridSnapshot(input, rows);
|
|
return rows;
|
|
}).catch((error) => {
|
|
gridRowsPending.delete(cacheKey);
|
|
throw error;
|
|
});
|
|
|
|
gridRowsPending.set(cacheKey, promise);
|
|
return promise;
|
|
}
|
|
|
|
/** Au-delà, l'instantané est servi mais un recalcul est relancé en arrière-plan. */
|
|
const SNAPSHOT_REFRESH_AFTER_MS = 20 * 60 * 60 * 1000;
|
|
|
|
/**
|
|
* Sert la Grille depuis `grid_rows` quand c'est possible : mêmes lignes que le
|
|
* calcul en direct (elles en sont issues), avec la gamme FF du moment (INIT) et
|
|
* les dernières gammes enregistrées reportées dessus. Hors « tous magasins »,
|
|
* le rattrapage du magasin choisi est appliqué comme après un calcul.
|
|
*
|
|
* `null` = pas d'instantané utilisable (absent, ancien format, autre mois) :
|
|
* l'appelant recalcule.
|
|
*/
|
|
async function serveFromSnapshot(input: GetProductRowsInput, cacheKey: string): Promise<ProductRow[] | null> {
|
|
const { codeFournisseur, magasin = "TOTAL" } = input;
|
|
let snapshot: Awaited<ReturnType<typeof readGridSnapshot>>;
|
|
try {
|
|
snapshot = await readGridSnapshot(codeFournisseur);
|
|
} catch (e) {
|
|
console.error("[getProductRows] lecture grid_rows KO:", (e as Error).message?.slice(0, 200));
|
|
return null;
|
|
}
|
|
if (!snapshot || snapshot.rows.length === 0) return null;
|
|
|
|
const { rows } = snapshot;
|
|
// Les colonnes réseau de l'instantané datent de son calcul : on les relit dans
|
|
// le cache Qlik, comme le calcul en direct. Sans cela, une synchro Qlik faite
|
|
// depuis (au changement de mois notamment) restait invisible jusqu'au
|
|
// prochain recalcul, et la tendance réseau disparaissait.
|
|
const [changes, network] = await Promise.all([
|
|
loadLatestSnapshotChanges(codeFournisseur),
|
|
fetchNetworkMetrics(rows.map((r) => r.codeCentrale ?? "")),
|
|
refreshGammeInit(rows, codeFournisseur),
|
|
]);
|
|
applySnapshotChanges(rows, changes);
|
|
enrichWithNetworkMetrics(rows, network);
|
|
|
|
if (magasin !== "TOTAL") {
|
|
const { dateDebut, dateFin } = buildLast12MonthsRange();
|
|
await reconcileSelectedStoreFromMensuelApi(rows, magasin, dateDebut, dateFin, last12Periods());
|
|
}
|
|
|
|
cacheGridRows(cacheKey, rows);
|
|
|
|
// Instantané qui n'a pas été recalculé par la nuit : on le rafraîchit sans
|
|
// faire attendre l'utilisateur (la prochaine ouverture en profitera).
|
|
// Toujours le calcul « tous magasins » : c'est lui qui réécrit l'instantané.
|
|
if (Date.now() - snapshot.computedAt.getTime() > SNAPSHOT_REFRESH_AFTER_MS && !gridRowsPending.has(`${codeFournisseur}:TOTAL`)) {
|
|
void getProductRows({ codeFournisseur, magasin: "TOTAL", forceRefresh: true }).catch((e) =>
|
|
console.error("[getProductRows] rafraîchissement en arrière-plan KO:", (e as Error).message?.slice(0, 200)),
|
|
);
|
|
}
|
|
return rows;
|
|
}
|
|
|
|
/** Les 12 derniers mois complets, clés « YYYYMM » triées (même fenêtre que le calcul). */
|
|
function last12Periods(): string[] {
|
|
const now = new Date();
|
|
const periods: string[] = [];
|
|
for (let i = 12; i >= 1; i--) {
|
|
const d = new Date(now.getFullYear(), now.getMonth() - i, 1);
|
|
periods.push(`${d.getFullYear()}${String(d.getMonth() + 1).padStart(2, "0")}`);
|
|
}
|
|
return periods;
|
|
}
|
|
|
|
async function buildProductRows(input: GetProductRowsInput): Promise<ProductRow[]> {
|
|
const { codeFournisseur, magasin = "TOTAL" } = input;
|
|
console.log(`\n>>> [getProductRows] supplier: ${codeFournisseur}, magasin: ${magasin}`);
|
|
|
|
try {
|
|
const { dateDebut, dateFin } = buildLast12MonthsRange();
|
|
|
|
// ─── Phase 1 : 7 requêtes SQL en parallèle ────────────────────────────
|
|
// Remplace des centaines/milliers d'appels HTTP per-article.
|
|
const articlesPromise = pgGetArticlesByFournisseur(codeFournisseur).catch(e => { console.error("[getProductRows] pgGetArticlesByFournisseur ERROR:", e); return []; });
|
|
// Phases 8 et 9 lancées dès maintenant : elles n'attendent que la liste des
|
|
// articles (codes centraux) ou le seul code fournisseur. Exécutées après la
|
|
// Phase 1, elles ajoutaient deux allers-retours en série à chaque calcul.
|
|
const networkPromise = articlesPromise.then((arts) =>
|
|
fetchNetworkMetrics(arts.map((a) => (a.codeCentrale ? String(a.codeCentrale).trim() : ""))),
|
|
);
|
|
const snapshotPromise = loadLatestSnapshotChanges(codeFournisseur);
|
|
|
|
const [
|
|
articles,
|
|
mensuelRows,
|
|
gammeMap,
|
|
nomMap,
|
|
stockMap,
|
|
commandesMap,
|
|
prixVenteMap,
|
|
] = await Promise.all([
|
|
articlesPromise,
|
|
pgGetMensuelByFournisseur(codeFournisseur, dateDebut, dateFin).catch(e => { console.error("[getProductRows] pgGetMensuelByFournisseur ERROR:", e); return []; }),
|
|
pgGetGammesByFournisseur(codeFournisseur).catch(e => { console.error("[getProductRows] pgGetGammesByFournisseur ERROR:", e); return new Map<string, string>(); }),
|
|
pgGetNomenclatureByFournisseur(codeFournisseur).catch(e => { console.error("[getProductRows] pgGetNomenclatureByFournisseur ERROR:", e); return new Map(); }),
|
|
pgGetStockByFournisseur(codeFournisseur).catch(e => { console.error("[getProductRows] pgGetStockByFournisseur ERROR:", e); return new Map<string, PgStockRow[]>(); }),
|
|
pgGetCommandesByFournisseur(codeFournisseur).catch(e => { console.error("[getProductRows] pgGetCommandesByFournisseur ERROR:", e); return new Map<string, number>(); }),
|
|
pgGetPrixVenteByFournisseur(codeFournisseur).catch(e => { console.error("[getProductRows] pgGetPrixVenteByFournisseur ERROR:", e); return new Map<string, Record<string, number>>(); }),
|
|
]);
|
|
|
|
console.log(`[getProductRows] ${articles.length} articles, ${mensuelRows.length} mensuel rows, ${gammeMap.size} gammes`);
|
|
|
|
// ─── Phase 2 : Fenêtre temporelle 12 mois complets ───────────────────
|
|
const sortedPeriods = last12Periods();
|
|
const allowedPeriods = new Set(sortedPeriods);
|
|
|
|
// ─── Phase 3 : Seed productMap depuis articles ────────────────────────
|
|
const productMap = new Map<string, ProductRow>();
|
|
for (const art of articles) {
|
|
if (!art.codein || productMap.has(art.codein)) continue;
|
|
productMap.set(art.codein, {
|
|
codein: art.codein,
|
|
codeFournisseur: art.codefou ?? codeFournisseur,
|
|
nomFournisseur: art.nomfou ?? "",
|
|
fournisseurPrincipalCode: art.codefou_principal ?? undefined,
|
|
fournisseurPrincipalNom: art.nomfou_principal ?? undefined,
|
|
libelle1: art.libelle1 ?? "",
|
|
gtin: art.gtin ?? "",
|
|
reference: art.reference ?? "",
|
|
codeCentrale: art.codeCentrale ? String(art.codeCentrale).trim() : undefined,
|
|
code1: "", libelleNiveau1: "",
|
|
code2: "", libelleNiveau2: "",
|
|
code3: "", libelle3: "",
|
|
codeGamme: null,
|
|
codeGammeInit: null,
|
|
codeGammeDraft: null,
|
|
sales12m: {},
|
|
stock12m: {},
|
|
receptions12m: {},
|
|
totalQuantite: 0,
|
|
totalCa: 0,
|
|
totalMarge: 0,
|
|
tauxMarge: 0,
|
|
workingStores: [],
|
|
noid: art.no_id ? Number(art.no_id) : undefined,
|
|
pcb: art.pcb ? Number(art.pcb) : undefined,
|
|
prixVente: art.pv_central ? Number(art.pv_central) : undefined,
|
|
});
|
|
}
|
|
|
|
// ─── Phase 4 : Agréger mensuelRows → byPeriod par codein ─────────────
|
|
// SQL a déjà fait l'agrégation par (codein, site, mois).
|
|
// On somme les 2 sites (TOTAL) ET on accumule par site pour le switch client-side.
|
|
type PeriodData = { qty: number; ca: number; marge: number; stock: number; receptions: number };
|
|
const mensuelByCodein = new Map<string, Map<string, PeriodData>>();
|
|
const mensuelBySite = new Map<string, Map<string, Map<string, PeriodData>>>(); // codein → site → periode → data
|
|
const storeMonthsByCodein = new Map<string, Map<string, Set<string>>>();
|
|
|
|
for (const row of mensuelRows) {
|
|
const periode = row.mois.replace("-", ""); // "2026-02" → "202602"
|
|
if (!allowedPeriods.has(periode)) continue;
|
|
|
|
// Accumulation TOTAL (toujours tous sites)
|
|
if (!mensuelByCodein.has(row.codein)) mensuelByCodein.set(row.codein, new Map());
|
|
const byPeriod = mensuelByCodein.get(row.codein)!;
|
|
if (!byPeriod.has(periode)) byPeriod.set(periode, { qty: 0, ca: 0, marge: 0, stock: 0, receptions: 0 });
|
|
const p = byPeriod.get(periode)!;
|
|
p.stock += Number(row.stock_fin_mois) || 0;
|
|
p.qty += Number(row.qte_vendue) || 0;
|
|
p.ca += Number(row.ca_ht) || 0;
|
|
p.marge += Number(row.marge) || 0;
|
|
p.receptions += Number(row.qte_recue) || 0;
|
|
|
|
// Accumulation par site (pour switch client-side)
|
|
if (!mensuelBySite.has(row.codein)) mensuelBySite.set(row.codein, new Map());
|
|
const bySite = mensuelBySite.get(row.codein)!;
|
|
if (!bySite.has(row.site)) bySite.set(row.site, new Map());
|
|
const siteByPeriod = bySite.get(row.site)!;
|
|
if (!siteByPeriod.has(periode)) siteByPeriod.set(periode, { qty: 0, ca: 0, marge: 0, stock: 0, receptions: 0 });
|
|
const sp = siteByPeriod.get(periode)!;
|
|
sp.qty += Number(row.qte_vendue) || 0;
|
|
sp.ca += Number(row.ca_ht) || 0;
|
|
sp.marge += Number(row.marge) || 0;
|
|
sp.stock = Number(row.stock_fin_mois) || 0; // SQL donne déjà le dernier mouvement
|
|
sp.receptions += Number(row.qte_recue) || 0;
|
|
|
|
// Suivi magasins actifs (pour workingStores) : 1 vente suffit
|
|
if (Number(row.qte_vendue) > 0) {
|
|
if (!storeMonthsByCodein.has(row.codein)) storeMonthsByCodein.set(row.codein, new Map());
|
|
storeMonthsByCodein.get(row.codein)!.set(row.site, new Set());
|
|
}
|
|
}
|
|
|
|
// ─── Phase 5 : Remplir ProductRow depuis mensuelByCodein ─────────────
|
|
for (const [codein, byPeriod] of mensuelByCodein.entries()) {
|
|
const product = productMap.get(codein);
|
|
if (!product) continue;
|
|
|
|
let lastStock = 0;
|
|
for (const periode of sortedPeriods) {
|
|
const p = byPeriod.get(periode);
|
|
if (p) {
|
|
product.sales12m[periode] = p.qty;
|
|
product.stock12m[periode] = p.stock;
|
|
product.receptions12m[periode] = p.receptions;
|
|
product.totalQuantite += p.qty;
|
|
product.totalCa += p.ca;
|
|
product.totalMarge += p.marge;
|
|
lastStock = p.stock;
|
|
} else {
|
|
product.sales12m[periode] = 0;
|
|
product.stock12m[periode] = lastStock; // carry-forward
|
|
product.receptions12m[periode] = 0;
|
|
}
|
|
}
|
|
|
|
product.tauxMarge = product.totalCa > 0 ? (product.totalMarge / product.totalCa) * 100 : 0;
|
|
|
|
// Breakdowns par site pour le switch client-side
|
|
const siteMap = mensuelBySite.get(codein);
|
|
if (siteMap) {
|
|
product.sales12mByStore = {};
|
|
product.stock12mByStore = {};
|
|
product.receptions12mByStore = {};
|
|
product.caByStore = {};
|
|
product.quantiteByStore = {};
|
|
product.margeByStore = {};
|
|
for (const [site, siteByPeriod] of siteMap.entries()) {
|
|
product.sales12mByStore[site] = {};
|
|
product.stock12mByStore[site] = {};
|
|
product.receptions12mByStore![site] = {};
|
|
let sQty = 0, sCa = 0, sMarge = 0;
|
|
let lastSiteStock = 0;
|
|
for (const periode of sortedPeriods) {
|
|
const sp = siteByPeriod.get(periode);
|
|
product.sales12mByStore[site][periode] = sp?.qty ?? 0;
|
|
product.receptions12mByStore![site][periode] = sp?.receptions ?? 0;
|
|
if (sp) {
|
|
product.stock12mByStore[site][periode] = sp.stock;
|
|
lastSiteStock = sp.stock;
|
|
} else {
|
|
product.stock12mByStore[site][periode] = lastSiteStock; // carry-forward
|
|
}
|
|
sQty += sp?.qty ?? 0;
|
|
sCa += sp?.ca ?? 0;
|
|
sMarge += sp?.marge ?? 0;
|
|
}
|
|
product.quantiteByStore[site] = sQty;
|
|
product.caByStore[site] = sCa;
|
|
product.margeByStore[site] = sMarge;
|
|
}
|
|
|
|
// Le stock TOTAL se recalcule ici, à partir des séries par site.
|
|
//
|
|
// Il était sommé plus haut depuis les lignes mensuelles brutes, ce
|
|
// qui perdait tout magasin SANS MOUVEMENT dans le mois : le stock
|
|
// est un niveau, pas un flux — un magasin qui n'a rien vendu ni reçu
|
|
// détient toujours sa marchandise. Sur un produit à faible rotation,
|
|
// « tous magasins » n'affichait donc que le site actif, en pratique
|
|
// Frouard. Les séries par site, elles, sont reportées d'un mois sur
|
|
// l'autre : leur somme est la bonne.
|
|
const sites = Object.keys(product.stock12mByStore);
|
|
if (sites.length > 0) {
|
|
for (const periode of sortedPeriods) {
|
|
product.stock12m[periode] = sites.reduce(
|
|
(total, site) => total + (product.stock12mByStore![site][periode] ?? 0),
|
|
0,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
// workingStores : sites avec au moins 1 vente sur les 12 derniers mois
|
|
const storeMonths = storeMonthsByCodein.get(codein);
|
|
if (storeMonths) {
|
|
product.workingStores = [...storeMonths.keys()].sort();
|
|
}
|
|
|
|
// Commandes en cours
|
|
const cmdQty = commandesMap.get(codein);
|
|
if (cmdQty) product.commandesEnCours = cmdQty;
|
|
}
|
|
|
|
// ─── Phase 6 : Gammes (saison active) ────────────────────────────────
|
|
for (const [codein, gammeCode] of gammeMap.entries()) {
|
|
const product = productMap.get(codein);
|
|
if (!product) continue;
|
|
product.codeGammeInit = gammeCode as GammeCode;
|
|
product.codeGamme = gammeCode as GammeCode;
|
|
}
|
|
|
|
// ─── Phase 6b : Nomenclature (famille / sous-famille) ────────────────
|
|
for (const [codein, nom] of nomMap.entries()) {
|
|
const product = productMap.get(codein);
|
|
if (!product) continue;
|
|
product.code3 = nom.code3 ?? "";
|
|
product.libelle3 = nom.libelle3 ?? "";
|
|
product.code2 = nom.code2 ?? "";
|
|
product.libelleNiveau2 = nom.libelle2 ?? "";
|
|
product.code1 = nom.code1 ?? "";
|
|
product.libelleNiveau1 = nom.libelle1nom ?? "";
|
|
}
|
|
|
|
// ─── Phase 7 : Stock temps réel (cube_stock) ─────────────────────────
|
|
for (const [codein, stocks] of stockMap.entries()) {
|
|
const product = productMap.get(codein);
|
|
if (!product) continue;
|
|
|
|
const sitesStock = stocks;
|
|
|
|
product.stockActuel = sitesStock.reduce((s, r) => s + (Number(r.stockdispo) || 0), 0);
|
|
product.stockTotal = sitesStock.reduce((s, r) => s + (Number(r.qte) || 0), 0);
|
|
product.stockValeur = sitesStock.reduce((s, r) => s + (Number(r.valstock) || 0), 0);
|
|
|
|
const withPrmp = sitesStock.find(r => Number(r.prmp) > 0);
|
|
if (withPrmp) {
|
|
product.pa = Number(withPrmp.prmp);
|
|
product.prixAchat = product.pa;
|
|
}
|
|
|
|
const dernVente = sitesStock.reduce<string>((best, r) =>
|
|
r.dernierevente && r.dernierevente > best ? r.dernierevente : best, "");
|
|
if (dernVente) product.derniereVente = dernVente;
|
|
|
|
const dernLiv = sitesStock.reduce<string>((best, r) =>
|
|
r.dernierereception && r.dernierereception > best ? r.dernierereception : best, "");
|
|
if (dernLiv) product.derniereLivraison = dernLiv;
|
|
|
|
// Map store-specific delivery dates
|
|
product.derniereLivraisonByStore = {};
|
|
for (const r of sitesStock) {
|
|
if (r.site && r.dernierereception) {
|
|
product.derniereLivraisonByStore[r.site] = r.dernierereception;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ─── Phase 7b : Prix de vente (cube_pv, sinon le PV du cube de stock) ─
|
|
//
|
|
// `article_infosup.prix_vente_mini`, renseigné en Phase 3, n'est qu'une
|
|
// borne de paramétrage : elle est vide en base et laissait la colonne PV
|
|
// entièrement creuse. Le vrai prix vit dans `cube_pv`, par article ET par
|
|
// site. On garde le détail par magasin — deux magasins peuvent ne pas
|
|
// pratiquer le même prix, et l'afficher vaut mieux que le moyenner.
|
|
for (const product of productMap.values()) {
|
|
const parSite = prixVenteMap.get(product.codein);
|
|
if (parSite && Object.keys(parSite).length > 0) {
|
|
product.prixVenteByStore = parSite;
|
|
} else {
|
|
// Filet de secours : le cube de stock porte le même PV, mais
|
|
// seulement pour les articles qui ont une ligne de stock.
|
|
const depuisStock: Record<string, number> = {};
|
|
for (const s of stockMap.get(product.codein) ?? []) {
|
|
const pv = Number(s.pv);
|
|
const site = String(s.site ?? "").trim();
|
|
if (site && Number.isFinite(pv) && pv > 0) depuisStock[site] = pv;
|
|
}
|
|
if (Object.keys(depuisStock).length > 0) product.prixVenteByStore = depuisStock;
|
|
}
|
|
|
|
const prix = Object.values(product.prixVenteByStore ?? {});
|
|
// Le plus élevé quand les magasins divergent : une moyenne inventerait
|
|
// un prix qu'aucune caisse ne pratique. L'écart est signalé à l'écran.
|
|
if (prix.length > 0) product.prixVente = Math.max(...prix);
|
|
}
|
|
|
|
// ─── Phase 8 : Données réseau Qlik (CA / Qté / nb magasins par code centrale) ──
|
|
enrichWithNetworkMetrics(productMap.values(), await networkPromise);
|
|
|
|
// ─── Phase 9 : Restaurer gammes depuis dernier snapshot ──────────────
|
|
// La colonne Gamme (codeGamme) conserve la valeur du snapshot telle quelle.
|
|
// La colonne INIT (codeGammeInit) reste, elle, l'état LIVE du serveur
|
|
// rechargé en Phase 6 — jamais écrasée ici.
|
|
applySnapshotChanges(productMap.values(), await snapshotPromise);
|
|
|
|
// ─── Phase 10 : Filtrer gamme Y sans ventes ──────────────────────────
|
|
const allRows = Array.from(productMap.values());
|
|
const rows = allRows.filter(p => p.codeGamme !== "Y" || p.totalQuantite > 0);
|
|
await reconcileSelectedStoreFromMensuelApi(rows, magasin, dateDebut, dateFin, sortedPeriods);
|
|
const excludedY = allRows.length - rows.length;
|
|
console.log(`[getProductRows] ${rows.length} produits (${excludedY} gamme Y sans ventes exclus), ${mensuelByCodein.size} avec ventes`);
|
|
|
|
return rows;
|
|
|
|
} catch (error) {
|
|
console.error(`[getProductRows] Error for ${codeFournisseur}:`, error);
|
|
// Ne PAS renvoyer [] : une liste vide est indiscernable d'un fournisseur
|
|
// sans article. La Grille affichait une page blanche sans explication, et
|
|
// la synchro nocturne prenait la panne pour un fournisseur vide — qu'elle
|
|
// désactivait alors automatiquement. La remonter laisse chaque appelant la
|
|
// traiter comme une erreur (bandeau rouge, statut « echec »).
|
|
throw error instanceof Error
|
|
? error
|
|
: new Error(`Calcul de la grille impossible pour ${codeFournisseur} : ${String(error)}`);
|
|
}
|
|
}
|
|
|
|
/** Articles complétés par l'API FF, au plus, lors d'un changement de magasin. */
|
|
function plafondComplement(): number {
|
|
return Number(process.env.GRID_STORE_RECONCILE_MAX ?? 300);
|
|
}
|
|
|
|
/** Interroge l'API FF pour les articles du magasin à compléter (cf. store-patch). */
|
|
async function fetchStorePatchEntries(
|
|
rows: ProductRow[],
|
|
magasin: string,
|
|
dateDebut: string,
|
|
dateFin: string,
|
|
periods: string[],
|
|
): Promise<StorePatchEntry[]> {
|
|
const candidates = storePatchCandidates(rows, magasin);
|
|
if (candidates.length === 0) return [];
|
|
|
|
// Ce rattrapage fait UNE requête HTTP par article : sur un gros fournisseur,
|
|
// les candidats se comptent par milliers et le changement de magasin se fige
|
|
// plusieurs minutes. On le borne, et on dit ce qui a été laissé de côté
|
|
// plutôt que de tronquer en silence.
|
|
const PLAFOND = plafondComplement();
|
|
const retenus = candidates.slice(0, PLAFOND);
|
|
if (candidates.length > retenus.length) {
|
|
console.warn(
|
|
`[getProductRows] rattrapage magasin ${magasin} borné à ${retenus.length} articles`
|
|
+ ` sur ${candidates.length} : les autres gardent la valeur SQL.`,
|
|
);
|
|
}
|
|
|
|
const mensuelMap = await getMensuelByArticles(
|
|
retenus.map((row) => ({
|
|
codein: row.codein,
|
|
libelle1: row.libelle1,
|
|
codefou: row.codeFournisseur,
|
|
noid: row.noid,
|
|
})),
|
|
dateDebut,
|
|
dateFin,
|
|
25
|
|
);
|
|
return buildStorePatchEntries(retenus, magasin, periods, mensuelMap);
|
|
}
|
|
|
|
async function reconcileSelectedStoreFromMensuelApi(
|
|
rows: ProductRow[],
|
|
magasin: string,
|
|
dateDebut: string,
|
|
dateFin: string,
|
|
sortedPeriods: string[]
|
|
) {
|
|
if (magasin === "TOTAL") return;
|
|
try {
|
|
const entries = await fetchStorePatchEntries(rows, magasin, dateDebut, dateFin, sortedPeriods);
|
|
const fixedRows = applyStorePatchInPlace(rows, magasin, sortedPeriods, entries);
|
|
if (fixedRows > 0) {
|
|
console.log(`[getProductRows] ${fixedRows} produits corrigés via API mensuelle pour magasin ${magasin}`);
|
|
}
|
|
} catch (error) {
|
|
console.error("[getProductRows] Mensuel API reconciliation error:", error);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Compléments par magasin, rattachés au tableau de lignes « tous magasins » en
|
|
* cache : ils vivent et meurent avec lui (expiration, « Actualiser », nouvel
|
|
* enregistrement), sans autre invalidation à gérer.
|
|
*/
|
|
const storePatches = new WeakMap<ProductRow[], Map<string, Promise<StorePatch>>>();
|
|
|
|
/**
|
|
* Complément de l'API FF pour un magasin, calculé sur les lignes « tous
|
|
* magasins » (jamais modifiées ici). La Grille l'applique à son arrivée, sans
|
|
* recharger les lignes. Les demandes simultanées partagent le même calcul, et
|
|
* un échec n'est jamais gardé.
|
|
*/
|
|
export async function getStorePatch(codeFournisseur: string, magasin: string): Promise<StorePatch> {
|
|
const enCache = gridRowsCache.get(`${codeFournisseur}:TOTAL`);
|
|
const rows = enCache && Date.now() - enCache.createdAt < GRID_ROWS_CACHE_TTL_MS
|
|
? enCache.rows
|
|
: await getProductRows({ codeFournisseur, magasin: "TOTAL" });
|
|
|
|
let parMagasin = storePatches.get(rows);
|
|
if (!parMagasin) {
|
|
parMagasin = new Map();
|
|
storePatches.set(rows, parMagasin);
|
|
}
|
|
let patch = parMagasin.get(magasin);
|
|
if (!patch) {
|
|
const periods = last12Periods();
|
|
const { dateDebut, dateFin } = buildLast12MonthsRange();
|
|
const enCours = fetchStorePatchEntries(rows, magasin, dateDebut, dateFin, periods)
|
|
.then((entries): StorePatch => ({ magasin, periods, entries }));
|
|
const table = parMagasin;
|
|
enCours.catch(() => {
|
|
if (table.get(magasin) === enCours) table.delete(magasin);
|
|
});
|
|
parMagasin.set(magasin, enCours);
|
|
patch = enCours;
|
|
}
|
|
return patch;
|
|
}
|
|
|
|
/**
|
|
* Extrait la série « nombre de magasins vendeurs » du détail mensuel complet.
|
|
*
|
|
* `metricsByMonth` porte les cinq mesures Qlik du mois ; seule `nbMag` sert à la
|
|
* deuxième courbe de la carte tendance. Renvoie `null` plutôt qu'un objet vide
|
|
* pour que l'UI distingue « pas de donnée » de « zéro magasin ».
|
|
*/
|
|
function nbMagParMois(
|
|
metricsByMonth: Record<string, { nbMag?: number }> | null | undefined,
|
|
): Record<string, number> | null {
|
|
if (!metricsByMonth) return null;
|
|
const parMois: Record<string, number> = {};
|
|
for (const [mois] of Object.entries(metricsByMonth)) {
|
|
// Un mois PRÉSENT dans le détail est un mois extrait : s'il n'a pas de
|
|
// `nbMag`, c'est qu'aucun magasin n'a vendu, donc zéro. Le traiter comme
|
|
// « manquant » amputait la série et faisait disparaître toute la courbe
|
|
// (les anciens caches n'écrivaient `nbMag` que sur les mois avec vente).
|
|
const nb = Number(metricsByMonth[mois]?.nbMag);
|
|
parMois[mois] = Number.isFinite(nb) ? nb : 0;
|
|
}
|
|
return Object.keys(parMois).length > 0 ? parMois : null;
|
|
}
|
|
|
|
type SnapshotChanges = Record<string, { before: string | null; after: string }>;
|
|
|
|
/**
|
|
* Phase 9 : la colonne Gamme (codeGamme) reprend la valeur du snapshot ;
|
|
* codeGammeInit reste figé (état serveur).
|
|
*/
|
|
function applySnapshotChanges(rows: Iterable<ProductRow>, changes: SnapshotChanges | null): void {
|
|
if (!changes) return;
|
|
for (const row of rows) {
|
|
const change = changes[row.codein];
|
|
if (change?.after) row.codeGamme = change.after as GammeCode;
|
|
}
|
|
}
|
|
|
|
/** Dernières gammes enregistrées pour ce fournisseur (Phase 9), ou `null`. */
|
|
async function loadLatestSnapshotChanges(codeFournisseur: string): Promise<SnapshotChanges | null> {
|
|
try {
|
|
const snaps = await db
|
|
.select({ changes: sessionSnapshots.changes })
|
|
.from(sessionSnapshots)
|
|
.where(eq(sessionSnapshots.codeFournisseur, codeFournisseur))
|
|
.orderBy(desc(sessionSnapshots.createdAt))
|
|
.limit(1);
|
|
return snaps.length > 0 ? (snaps[0].changes as SnapshotChanges) : null;
|
|
} catch (snapErr) {
|
|
console.error("[getProductRows] Snapshot restore error:", snapErr);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Lit les metriques reseau Qlik (cache qlik_network_metrics) des codes centraux
|
|
* donnes. `null` en cas d'erreur : la grille s'affiche alors sans donnees reseau.
|
|
*/
|
|
async function fetchNetworkMetrics(
|
|
codesCentrale: string[],
|
|
): Promise<Map<string, NetworkMetricCached> | null> {
|
|
try {
|
|
const codes = [...new Set(codesCentrale.filter(Boolean))];
|
|
if (codes.length === 0) return null;
|
|
return await getNetworkMetricsByCodeCentrale(codes);
|
|
} catch (error) {
|
|
console.error("[getProductRows] enrichWithNetworkMetrics error:", error);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Enrichit les produits avec les metriques reseau Qlik, jointes par code centrale.
|
|
* Degradation propre si la sync Qlik n'a jamais tourne ou si le code centrale
|
|
* n'est pas encore disponible.
|
|
*/
|
|
function enrichWithNetworkMetrics(
|
|
products: Iterable<ProductRow>,
|
|
metrics: Map<string, NetworkMetricCached> | null,
|
|
): void {
|
|
if (!metrics || metrics.size === 0) return;
|
|
for (const product of products) {
|
|
const m = product.codeCentrale ? metrics.get(product.codeCentrale) : undefined;
|
|
if (!m) continue;
|
|
product.caReseau = m.caReseau;
|
|
product.qteReseau = m.qteReseau;
|
|
product.nbMagasinsReseau = m.nbMagasinsReseau;
|
|
product.caParMagasinReseau = m.caParMagasinReseau;
|
|
product.margePctReseau = m.margePctReseau;
|
|
product.tauxPresenceReseau = m.nbMagasinsReseau / NB_MAGASINS_RESEAU;
|
|
product.qteReseauByMonth = m.qteByMonth ?? null;
|
|
product.nbMagReseauByMonth = nbMagParMois(m.metricsByMonth);
|
|
product.networkFetchedAt = m.fetchedAt ?? undefined;
|
|
}
|
|
}
|