Refactor code structure for improved readability and maintainability

backend/dist/receipt-import/receipt-import.service.js

@@ -0,0 +1,983 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var ReceiptImportService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReceiptImportService = void 0;
+exports.isIgnoredReceiptName = isIgnoredReceiptName;
+const common_1 = require("@nestjs/common");
+const prisma_service_1 = require("../prisma/prisma.service");
+const ai_service_1 = require("../ai/ai.service");
+const categories_service_1 = require("../categories/categories.service");
+const IMPORTER_SERVICE_URL = process.env.IMPORTER_SERVICE_URL || 'http://importer-api:3001';
+const WEAK_DESCRIPTORS = new Set([
+    'rokt',
+    'rökt',
+    'kokt',
+    'grillad',
+    'stekt',
+    'skivad',
+    'strimlad',
+    'fryst',
+    'farsk',
+    'färsk',
+]);
+function tokenize(value) {
+    return value
+        .toLowerCase()
+        .split(/[^a-z0-9åäö]+/)
+        .filter((w) => w.length >= 3);
+}
+function isIgnoredReceiptName(value) {
+    const normalized = (value ?? '').trim().toLowerCase();
+    if (!normalized)
+        return false;
+    if (/^rabatt\b/.test(normalized))
+        return true;
+    if (/^summa\b/.test(normalized))
+        return true;
+    if (/^moms\b/.test(normalized))
+        return true;
+    if (/^pant\b/.test(normalized))
+        return true;
+    if (/^att\s+betala\b/.test(normalized))
+        return true;
+    if (/^totalt\b/.test(normalized))
+        return true;
+    if (/^kort\b/.test(normalized))
+        return true;
+    if (/^kontant\b/.test(normalized))
+        return true;
+    if (/^willys\s+plus\s*[:\-]?\b/.test(normalized))
+        return true;
+    return false;
+}
+function normalizeToken(s) {
+    return s.replace(/å/g, 'a').replace(/ä/g, 'a').replace(/ö/g, 'o').replace(/é/g, 'e').replace(/è/g, 'e');
+}
+function normalizeForRules(value) {
+    return value
+        .toLowerCase()
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .replace(/[^a-z0-9]+/g, ' ')
+        .trim();
+}
+function hasPorkLikeSignal(normalized) {
+    return (normalized.includes('bacon') ||
+        normalized.includes('bacn') ||
+        normalized.includes('baco') ||
+        /\bbac[a-z0-9]{1,5}\b/.test(normalized) ||
+        /\bsidflask\b/.test(normalized) ||
+        /\bpancetta\b/.test(normalized) ||
+        /\bflask\b/.test(normalized) ||
+        /\bflaskfile\b/.test(normalized) ||
+        /\bkarr[eé]\b/.test(normalized) ||
+        /\bkotlett\b/.test(normalized));
+}
+function hasBreadLikeSignal(normalized) {
+    return (/\brostbrod\b/.test(normalized) ||
+        /\brost\s*n\s*toast\b/.test(normalized) ||
+        /\broast\s*n\s*toast\b/.test(normalized) ||
+        /\btoastbrod\b/.test(normalized) ||
+        /\bformbrod\b/.test(normalized) ||
+        /\blantbrod\b/.test(normalized) ||
+        /\bfullkornsbrod\b/.test(normalized) ||
+        /\bfranska\b/.test(normalized) ||
+        /\blimpa\b/.test(normalized) ||
+        /\bbrod\b/.test(normalized) ||
+        /\btoast\b/.test(normalized));
+}
+function inferPackageDebugFromRawName(rawName) {
+    const normalized = rawName.toLowerCase();
+    const multiPack = /(\d+)\s*[x×]\s*(\d+(?:[\.,]\d+)?)\s*(ml|cl|dl|l|g|kg)\b/i.exec(normalized);
+    if (multiPack) {
+        const count = Number.parseInt(multiPack[1], 10);
+        const qty = Number.parseFloat(multiPack[2].replace(',', '.'));
+        const unit = multiPack[3].toLowerCase();
+        return {
+            packageCount: Number.isFinite(count) && count > 0 ? count : 1,
+            packQuantity: Number.isFinite(qty) ? qty : null,
+            packUnit: unit,
+        };
+    }
+    const singlePack = /(\d+(?:[\.,]\d+)?)\s*(ml|cl|dl|l|g|kg)\b/i.exec(normalized.replace(/([\d.,]+)(ml|cl|dl|l|g|kg)\b/i, '$1 $2'));
+    if (singlePack) {
+        const qty = Number.parseFloat(singlePack[1].replace(',', '.'));
+        const unit = singlePack[2].toLowerCase();
+        return {
+            packageCount: 1,
+            packQuantity: Number.isFinite(qty) ? qty : null,
+            packUnit: unit,
+        };
+    }
+    return {
+        packageCount: 1,
+        packQuantity: null,
+        packUnit: null,
+    };
+}
+let ReceiptImportService = ReceiptImportService_1 = class ReceiptImportService {
+    constructor(prisma, aiService, categoriesService) {
+        this.prisma = prisma;
+        this.aiService = aiService;
+        this.categoriesService = categoriesService;
+        this.logger = new common_1.Logger(ReceiptImportService_1.name);
+        this.cachedCategories = [];
+        this.loadCategories();
+    }
+    async loadCategories() {
+        this.cachedCategories = await this.prisma.category.findMany({
+            include: { children: true },
+        });
+    }
+    async parseReceipt(file, _isPremium = false, userId) {
+        const rawItems = await this.parseReceiptViaImporter(file);
+        const matched = await this.matchProducts(rawItems, userId);
+        return this.enrichWithAiCategories(matched);
+    }
+    async parseReceiptViaImporter(file) {
+        const form = new FormData();
+        form.append('file', new Blob([new Uint8Array(file.buffer)], { type: file.mimetype }), file.originalname);
+        let response;
+        try {
+            response = await fetch(`${IMPORTER_SERVICE_URL}/api/receipt-import/parse`, {
+                method: 'POST',
+                body: form,
+            });
+        }
+        catch (err) {
+            this.logger.error(`Kunde inte nå importer-api för kvittoparsning: ${err}`);
+            throw new common_1.ServiceUnavailableException('Import-tjänsten är inte tillgänglig. Försök igen senare.');
+        }
+        if (!response.ok) {
+            let message = `Importer svarade ${response.status}`;
+            try {
+                const body = (await response.json());
+                if (body.message)
+                    message = body.message;
+            }
+            catch {
+            }
+            if (response.status === 503 || response.status === 429) {
+                throw new common_1.ServiceUnavailableException(message);
+            }
+            throw new common_1.BadRequestException(message);
+        }
+        const items = (await response.json());
+        return items.filter((item) => !isIgnoredReceiptName(item.rawName));
+    }
+    async matchProducts(items, userId) {
+        const productFilter = userId ? { isActive: true, ownerId: userId } : { isActive: true };
+        const aliasFilter = userId
+            ? {
+                OR: [
+                    { ownerId: userId, isGlobal: false },
+                    { isGlobal: true },
+                ],
+            }
+            : { isGlobal: true };
+        const [aliases, products] = await Promise.all([
+            this.prisma.receiptAlias.findMany({
+                where: aliasFilter,
+                orderBy: [
+                    { isGlobal: 'asc' },
+                    { id: 'asc' },
+                ],
+                select: { receiptName: true, productId: true, product: { select: { id: true, name: true, canonicalName: true, categoryId: true, categoryRef: { select: { id: true, name: true } } } } },
+            }),
+            this.prisma.product.findMany({
+                where: productFilter,
+                select: { id: true, name: true, canonicalName: true, categoryId: true, categoryRef: { select: { id: true, name: true } } },
+            }),
+        ]);
+        return items.map((item) => {
+            const raw = (item.rawName ?? '').toLowerCase().trim();
+            if (!raw)
+                return item;
+            const alias = aliases.find((a) => a.receiptName === raw);
+            if (alias) {
+                const cat = alias.product.categoryRef;
+                return {
+                    ...item,
+                    matchedProductId: alias.product.id,
+                    matchedProductName: alias.product.canonicalName ?? alias.product.name,
+                    ...(cat ? { categorySuggestion: { categoryId: cat.id, categoryName: cat.name, path: cat.name, confidence: 'high', usedFallback: false } } : {}),
+                };
+            }
+            const suggestion = this.findWordMatch(raw, products);
+            if (!suggestion) {
+                return { ...item };
+            }
+            const cat = suggestion.categoryRef;
+            return {
+                ...item,
+                suggestedProductId: suggestion.id,
+                suggestedProductName: suggestion.canonicalName ?? suggestion.name,
+                ...(cat ? { categorySuggestion: { categoryId: cat.id, categoryName: cat.name, path: cat.name, confidence: 'medium', usedFallback: false } } : {}),
+            };
+        });
+    }
+    findWordMatch(raw, products) {
+        const rawWords = tokenize(raw);
+        if (rawWords.length === 0)
+            return undefined;
+        const rawWordSet = new Set(rawWords);
+        const rawWordsNorm = rawWords.map(normalizeToken);
+        const rawWordSetNorm = new Set(rawWordsNorm);
+        let best;
+        for (const product of products) {
+            const productWords = tokenize(product.canonicalName ?? product.name);
+            if (productWords.length === 0)
+                continue;
+            let score = 0;
+            let exactStrong = 0;
+            let exactAny = 0;
+            let partialStrong = 0;
+            const phrase = (product.canonicalName ?? product.name).toLowerCase();
+            if (raw.includes(phrase)) {
+                score += 5;
+            }
+            for (const pw of productWords) {
+                const isWeak = WEAK_DESCRIPTORS.has(pw);
+                const pwNorm = normalizeToken(pw);
+                if (rawWordSet.has(pw) || rawWordSetNorm.has(pwNorm)) {
+                    exactAny += 1;
+                    if (isWeak) {
+                        score += 1;
+                    }
+                    else {
+                        exactStrong += 1;
+                        score += 8;
+                    }
+                    continue;
+                }
+                if (pw.length < 4)
+                    continue;
+                const hasPartial = rawWords.some((rw) => rw.includes(pw) || pw.includes(rw)) ||
+                    rawWordsNorm.some((rw) => rw.includes(pwNorm) || pwNorm.includes(rw));
+                if (!hasPartial)
+                    continue;
+                if (isWeak) {
+                    continue;
+                }
+                partialStrong += 1;
+                score += 3;
+            }
+            const hasLongPartial = partialStrong >= 1 && productWords.some((pw) => pw.length >= 5);
+            const hasStrongSignal = exactStrong >= 1 || exactAny + partialStrong >= 2 || hasLongPartial;
+            if (!hasStrongSignal)
+                continue;
+            if (score < 8)
+                continue;
+            if (!best || score > best.score) {
+                best = { product, score };
+            }
+        }
+        return best?.product;
+    }
+    async enrichWithAiCategories(items) {
+        let categories;
+        try {
+            categories = await this.categoriesService.findFlattened();
+        }
+        catch {
+            return items;
+        }
+        const enriched = [];
+        for (const item of items) {
+            if (!item.rawName) {
+                enriched.push(item);
+                continue;
+            }
+            try {
+                const signalText = [
+                    item.rawName,
+                    item.matchedProductName,
+                    item.suggestedProductName,
+                ]
+                    .filter((v) => typeof v === 'string' && v.trim().length > 0)
+                    .join(' ');
+                const trace = [];
+                const traceEnabled = this.shouldTraceDecision(signalText || item.rawName);
+                const pushTrace = (msg) => {
+                    if (traceEnabled)
+                        trace.push(msg);
+                };
+                const pkg = inferPackageDebugFromRawName(item.rawName);
+                pushTrace(`start raw="${item.rawName}" signal="${signalText || item.rawName}" parsedQuantity=${item.quantity ?? 'null'} parsedUnit=${item.unit ?? 'null'} packageCount=${pkg.packageCount} packQuantity=${pkg.packQuantity ?? 'null'} packUnit=${pkg.packUnit ?? 'null'}`);
+                pushTrace(`match matchedProductId=${item.matchedProductId ?? 'null'} suggestedProductId=${item.suggestedProductId ?? 'null'}`);
+                if (item.categorySuggestion) {
+                    pushTrace(`incoming category="${item.categorySuggestion.path}" confidence=${item.categorySuggestion.confidence} fallback=${item.categorySuggestion.usedFallback}`);
+                }
+                const byRule = this.ruleBasedCategorySuggestion(signalText || item.rawName, categories);
+                if (byRule) {
+                    pushTrace(`rule hit -> "${byRule.path}" (${byRule.confidence})`);
+                }
+                else {
+                    pushTrace('rule miss');
+                }
+                let nextSuggestion = item.categorySuggestion ?? null;
+                const isTrustedSuggestion = nextSuggestion?.confidence === 'high' && !nextSuggestion.usedFallback;
+                if (byRule?.confidence === 'high') {
+                    const sameAsCurrent = nextSuggestion != null && nextSuggestion.categoryId === byRule.categoryId;
+                    if (sameAsCurrent && nextSuggestion && nextSuggestion.confidence !== 'high') {
+                        nextSuggestion = { ...nextSuggestion, confidence: 'high' };
+                        pushTrace(`rule applied -> "${byRule.path}" (confidence upgraded to high)`);
+                    }
+                    else if (!sameAsCurrent && (!isTrustedSuggestion || nextSuggestion == null)) {
+                        nextSuggestion = byRule;
+                        pushTrace(`rule applied -> "${byRule.path}"`);
+                    }
+                    if (!sameAsCurrent && isTrustedSuggestion) {
+                        this.logger.log(`Rule-override: "${item.rawName}" ändras från "${nextSuggestion?.path}" till "${byRule.path}"`);
+                        nextSuggestion = byRule;
+                        pushTrace(`rule override trusted -> "${byRule.path}"`);
+                    }
+                }
+                else if (!nextSuggestion && byRule) {
+                    nextSuggestion = byRule;
+                    pushTrace(`rule fallback applied -> "${byRule.path}"`);
+                }
+                if (!nextSuggestion) {
+                    pushTrace('ai invoked');
+                    nextSuggestion = await this.aiService.suggestCategory(item.rawName, categories);
+                    pushTrace(`ai result -> "${nextSuggestion.path}" (${nextSuggestion.confidence})`);
+                }
+                else {
+                    pushTrace(`ai skipped, current -> "${nextSuggestion.path}"`);
+                }
+                const beforeGuardPath = nextSuggestion?.path;
+                const guardedSuggestion = nextSuggestion
+                    ? this.applyContradictionGuard(signalText || item.rawName, nextSuggestion, categories)
+                    : null;
+                if (guardedSuggestion && beforeGuardPath !== guardedSuggestion.path) {
+                    pushTrace(`contradiction guard remap "${beforeGuardPath}" -> "${guardedSuggestion.path}"`);
+                }
+                const beforeHardPath = guardedSuggestion?.path;
+                const finalSuggestion = guardedSuggestion
+                    ? this.applyHardCategoryOverrides(signalText || item.rawName, guardedSuggestion, categories)
+                    : null;
+                if (finalSuggestion && beforeHardPath !== finalSuggestion.path) {
+                    pushTrace(`hard override remap "${beforeHardPath}" -> "${finalSuggestion.path}"`);
+                }
+                if (finalSuggestion) {
+                    pushTrace(`final -> "${finalSuggestion.path}" (${finalSuggestion.confidence})`);
+                }
+                else {
+                    pushTrace('final -> no categorySuggestion');
+                }
+                if (traceEnabled) {
+                    this.logger.log(`[ReceiptDecision] ${trace.join(' | ')}`);
+                }
+                enriched.push(finalSuggestion
+                    ? { ...item, categorySuggestion: finalSuggestion }
+                    : item);
+            }
+            catch (err) {
+                const traceSignalText = [
+                    item.rawName,
+                    item.matchedProductName,
+                    item.suggestedProductName,
+                ]
+                    .filter((v) => typeof v === 'string' && v.trim().length > 0)
+                    .join(' ');
+                if (this.shouldTraceDecision(traceSignalText || item.rawName)) {
+                    this.logger.warn(`[ReceiptDecision] error raw="${item.rawName}" signal="${traceSignalText || item.rawName}" err=${String(err)}`);
+                }
+                enriched.push(item);
+            }
+        }
+        return enriched;
+    }
+    shouldTraceDecision(signalText) {
+        const envFlag = (process.env.RECEIPT_TRACE_DECISIONS ?? '').toLowerCase();
+        if (envFlag === '1' || envFlag === 'true' || envFlag === 'yes') {
+            return true;
+        }
+        const normalized = normalizeForRules(signalText);
+        return hasPorkLikeSignal(normalized);
+    }
+    resolvePorkCategory(categories) {
+        return (categories.find((c) => c.name.toLowerCase() === 'fläsk' &&
+            c.path.toLowerCase().startsWith('kött, chark & fågel > kött > ')) ||
+            categories.find((c) => c.name.toLowerCase() === 'kött' &&
+                c.path.toLowerCase() === 'kött, chark & fågel > kött') ||
+            categories.find((c) => c.path.toLowerCase() === 'kött, chark & fågel'));
+    }
+    resolveBreadCategory(categories) {
+        return (categories.find((c) => c.name.toLowerCase() === 'rostbröd' &&
+            c.path.toLowerCase().startsWith('bröd & kakor > bröd > ')) ||
+            categories.find((c) => c.name.toLowerCase() === 'bröd' &&
+                c.path.toLowerCase() === 'bröd & kakor > bröd') ||
+            categories.find((c) => c.path.toLowerCase() === 'bröd & kakor'));
+    }
+    applyHardCategoryOverrides(signalText, suggestion, categories) {
+        const normalized = normalizeForRules(signalText);
+        const hasBaconLikeSignal = hasPorkLikeSignal(normalized);
+        if (!hasBaconLikeSignal)
+            return suggestion;
+        const l3Pork = this.resolvePorkCategory(categories);
+        if (!l3Pork) {
+            this.logger.warn(`Hard-override: pork signal hittad men ingen köttkategori kunde hittas för "${signalText}"`);
+            return suggestion;
+        }
+        if (suggestion.categoryId === l3Pork.id)
+            return suggestion;
+        this.logger.log(`Hard-override: "${signalText}" remappas från "${suggestion.path}" till "${l3Pork.path}"`);
+        return {
+            categoryId: l3Pork.id,
+            categoryName: l3Pork.name,
+            path: l3Pork.path,
+            confidence: 'high',
+            usedFallback: true,
+        };
+    }
+    ruleBasedCategorySuggestion(rawName, categories) {
+        const normalized = normalizeForRules(rawName);
+        const findCategory = (opts) => categories.find((c) => {
+            const cName = c.name.toLowerCase();
+            const cPath = c.path.toLowerCase();
+            if (cName !== opts.name.toLowerCase())
+                return false;
+            if (opts.startsWith && !cPath.startsWith(opts.startsWith.toLowerCase()))
+                return false;
+            if (opts.includes && !cPath.includes(opts.includes.toLowerCase()))
+                return false;
+            return true;
+        });
+        const toSuggestion = (cat, confidence = 'high') => {
+            if (!cat)
+                return null;
+            return {
+                categoryId: cat.id,
+                categoryName: cat.name,
+                path: cat.path,
+                confidence,
+                usedFallback: false,
+            };
+        };
+        const hasPorkSignal = hasPorkLikeSignal(normalized);
+        const hasToastBreadSignal = hasBreadLikeSignal(normalized);
+        if (hasToastBreadSignal) {
+            const bread = this.resolveBreadCategory(categories);
+            const hit = toSuggestion(bread, 'high');
+            if (hit)
+                return hit;
+        }
+        if (hasPorkSignal) {
+            const l3Pork = this.resolvePorkCategory(categories);
+            const hit = toSuggestion(l3Pork, 'high');
+            if (hit)
+                return hit;
+        }
+        const hasSausageSignal = /\bkorv\b/.test(normalized) ||
+            /\bfalukorv\b/.test(normalized) ||
+            /\bchorizo\b/.test(normalized) ||
+            /\bbratwurst\b/.test(normalized) ||
+            /\bwienerkorv\b/.test(normalized) ||
+            /\bgrillkorv\b/.test(normalized) ||
+            /\bprinskorv\b/.test(normalized) ||
+            /\bolkorv\b/.test(normalized);
+        if (hasSausageSignal) {
+            const isVegetarian = /\bvegetarisk\b/.test(normalized) ||
+                /\bvegansk\b/.test(normalized) ||
+                /\bvego\b/.test(normalized);
+            if (isVegetarian) {
+                const vegSausage = findCategory({
+                    name: 'vegetarisk korv',
+                    startsWith: 'kött, chark & fågel > korv > ',
+                });
+                const hit = toSuggestion(vegSausage, 'high');
+                if (hit)
+                    return hit;
+            }
+            if (/\bolkorv\b/.test(normalized)) {
+                const beerSausage = findCategory({
+                    name: 'ölkorv',
+                    startsWith: 'kött, chark & fågel > korv > ',
+                });
+                const hit = toSuggestion(beerSausage, 'high');
+                if (hit)
+                    return hit;
+            }
+            const sausageGeneral = findCategory({
+                name: 'grill, kok- & kryddkorv',
+                startsWith: 'kött, chark & fågel > korv > ',
+            });
+            const hit = toSuggestion(sausageGeneral, 'high');
+            if (hit)
+                return hit;
+        }
+        const hasPoultrySignal = /\bkyckling\b/.test(normalized) ||
+            /\bkalkon\b/.test(normalized) ||
+            /\bdrumsticks?\b/.test(normalized) ||
+            /\bling?file\b/.test(normalized) ||
+            /\blarfile\b/.test(normalized) ||
+            /\bkycklinglar\b/.test(normalized);
+        if (hasPoultrySignal) {
+            const isFrozen = /\bfryst\b/.test(normalized) || /\bdjupfryst\b/.test(normalized);
+            if (isFrozen) {
+                const frozenPoultry = findCategory({
+                    name: 'fryst fågel',
+                    startsWith: 'kött, chark & fågel > fågel > ',
+                });
+                const hit = toSuggestion(frozenPoultry, 'high');
+                if (hit)
+                    return hit;
+            }
+            const freshPoultry = findCategory({
+                name: 'färsk fågel',
+                startsWith: 'kött, chark & fågel > fågel > ',
+            });
+            const hit = toSuggestion(freshPoultry, 'high');
+            if (hit)
+                return hit;
+        }
+        const hasColdCutSignal = /\bpalagg\b/.test(normalized) ||
+            /\bpalegg\b/.test(normalized) ||
+            /\bskivad\b/.test(normalized) ||
+            /\bsalami\b/.test(normalized) ||
+            /\bmedvurst\b/.test(normalized) ||
+            /\bpastrami\b/.test(normalized) ||
+            /\bskinka\b/.test(normalized);
+        if (hasColdCutSignal) {
+            const hasSlicedSausageSignal = /\bsalami\b/.test(normalized) ||
+                /\bmedvurst\b/.test(normalized) ||
+                /\bpastrami\b/.test(normalized);
+            if (hasSlicedSausageSignal) {
+                const salamiColdCut = findCategory({
+                    name: 'korv & salami',
+                    startsWith: 'kött, chark & fågel > pålägg > ',
+                });
+                const hit = toSuggestion(salamiColdCut, 'high');
+                if (hit)
+                    return hit;
+            }
+            const slicedColdCut = findCategory({
+                name: 'skivat pålägg',
+                startsWith: 'kött, chark & fågel > pålägg > ',
+            });
+            const hit = toSuggestion(slicedColdCut, 'high');
+            if (hit)
+                return hit;
+        }
+        const hasMinceSignal = /\bfars\b/.test(normalized) ||
+            /\bfarse\b/.test(normalized) ||
+            /\bmince\b/.test(normalized) ||
+            /\bköttfärs\b/.test(rawName.toLowerCase());
+        if (hasMinceSignal && !hasPoultrySignal) {
+            const mince = findCategory({
+                name: 'köttfärs',
+                startsWith: 'kött, chark & fågel > kött > ',
+            });
+            const hit = toSuggestion(mince, 'high');
+            if (hit)
+                return hit;
+        }
+        const hasBeefVealSignal = /\bnot\b/.test(normalized) ||
+            /\bkalv\b/.test(normalized) ||
+            /\bbiff\b/.test(normalized) ||
+            /\bentrecote\b/.test(normalized) ||
+            /\brostbiff\b/.test(normalized) ||
+            /\bryggbiff\b/.test(normalized);
+        if (hasBeefVealSignal && !hasMinceSignal) {
+            const beefVeal = findCategory({
+                name: 'nöt & kalv',
+                startsWith: 'kött, chark & fågel > kött > ',
+            });
+            const hit = toSuggestion(beefVeal, 'high');
+            if (hit)
+                return hit;
+        }
+        const hasPastaSignal = /\bmezze\b/.test(normalized) ||
+            /\bmaniche\b/.test(normalized) ||
+            /\bpenne\b/.test(normalized) ||
+            /\brigatoni\b/.test(normalized) ||
+            /\bfusilli\b/.test(normalized) ||
+            /\bspaghetti\b/.test(normalized) ||
+            /\btagliatelle\b/.test(normalized) ||
+            /\bmakaron\w*\b/.test(normalized) ||
+            /\bgnocchi\b/.test(normalized) ||
+            /\blasagne\b/.test(normalized) ||
+            /\bpasta\b/.test(normalized);
+        if (hasPastaSignal) {
+            const freshPasta = findCategory({
+                name: 'färsk pasta',
+                startsWith: 'skafferi > pasta, ris & matgryn > ',
+            });
+            if (/\bfarsk\b/.test(normalized) || /\bfresh\b/.test(normalized)) {
+                const freshHit = toSuggestion(freshPasta, 'high');
+                if (freshHit)
+                    return freshHit;
+            }
+            const pasta = findCategory({
+                name: 'pasta',
+                startsWith: 'skafferi > pasta, ris & matgryn > ',
+            });
+            const pastaHit = toSuggestion(pasta, 'high');
+            if (pastaHit)
+                return pastaHit;
+        }
+        const hasCreamSignal = /\bvispgradde\b/.test(normalized) ||
+            /\bmatlagningsgradde\b/.test(normalized) ||
+            /\bgradde\b/.test(normalized) ||
+            /\bcreme\s+fraiche\b/.test(normalized) ||
+            /\bgraddfil\b/.test(normalized);
+        const hasPlantOrAllergySignal = /\blaktosfri\b/.test(normalized) ||
+            /\bvegetabilisk\b/.test(normalized) ||
+            /\bhavre\b/.test(normalized) ||
+            /\bsoja\b/.test(normalized) ||
+            /\brisdryck\b/.test(normalized) ||
+            /\bplant\b/.test(normalized);
+        if (hasCreamSignal && !hasPlantOrAllergySignal) {
+            const l3Cream = findCategory({
+                name: 'grädde',
+                startsWith: 'mejeri, ost & ägg > matlagning > ',
+            });
+            const l3Hit = toSuggestion(l3Cream, 'high');
+            if (l3Hit)
+                return l3Hit;
+            const l2CookingDairy = findCategory({
+                name: 'matlagning',
+                startsWith: 'mejeri, ost & ägg > ',
+            });
+            const hit = toSuggestion(l2CookingDairy, 'high');
+            if (hit)
+                return hit;
+        }
+        const hasMilkSignal = /\bmjolk\b/.test(normalized) ||
+            /\bstandardmjolk\b/.test(normalized) ||
+            /\bstandmjolk\b/.test(normalized) ||
+            /\besl\b/.test(normalized);
+        const hasLactoseFreeSignal = /\blaktosfri\b/.test(normalized) ||
+            /\blactose\s*free\b/.test(normalized);
+        if (hasMilkSignal && !hasPlantOrAllergySignal && !hasLactoseFreeSignal) {
+            const l3StandardMilk = findCategory({
+                name: 'standardmjölk',
+                startsWith: 'mejeri, ost & ägg > mjölk > ',
+            });
+            const hit = toSuggestion(l3StandardMilk, 'high');
+            if (hit)
+                return hit;
+            const l2Milk = findCategory({
+                name: 'mjölk',
+                startsWith: 'mejeri, ost & ägg > ',
+            });
+            const fallbackHit = toSuggestion(l2Milk, 'high');
+            if (fallbackHit)
+                return fallbackHit;
+        }
+        const hasEggSignal = /\bagg\b/.test(normalized) ||
+            /\begg\b/.test(normalized) ||
+            /\binne\b/.test(normalized) ||
+            /\b24p\b/.test(normalized);
+        if (hasEggSignal) {
+            const l2Egg = categories.find((c) => c.name.toLowerCase() === 'ägg' &&
+                c.path.toLowerCase() === 'mejeri, ost & ägg > ägg');
+            if (l2Egg) {
+                return {
+                    categoryId: l2Egg.id,
+                    categoryName: l2Egg.name,
+                    path: l2Egg.path,
+                    confidence: 'high',
+                    usedFallback: false,
+                };
+            }
+            const l1DairyEgg = categories.find((c) => c.path.toLowerCase() === 'mejeri, ost & ägg');
+            if (l1DairyEgg) {
+                return {
+                    categoryId: l1DairyEgg.id,
+                    categoryName: l1DairyEgg.name,
+                    path: l1DairyEgg.path,
+                    confidence: 'high',
+                    usedFallback: false,
+                };
+            }
+        }
+        const hasJuiceSignal = /\bjuice\b/.test(normalized) ||
+            /\bnektar\b/.test(normalized) ||
+            /\bfruktdryck\b/.test(normalized) ||
+            /\bsmoothie\b/.test(normalized) ||
+            /\bmultivitamin\b/.test(normalized);
+        if (hasJuiceSignal) {
+            const l3ColdJuice = findCategory({
+                name: 'kyld juice & nektar',
+                startsWith: 'dryck > juice, fruktdryck & smoothie > ',
+            });
+            const l3Hit = toSuggestion(l3ColdJuice, 'high');
+            if (l3Hit)
+                return l3Hit;
+            const l2Juice = findCategory({
+                name: 'juice, fruktdryck & smoothie',
+                startsWith: 'dryck > ',
+            });
+            const l2Hit = toSuggestion(l2Juice, 'high');
+            if (l2Hit)
+                return l2Hit;
+        }
+        const isTea = /\bte\b/.test(normalized) ||
+            /\btea\b/.test(normalized) ||
+            /\bchai\b/.test(normalized) ||
+            /\btepa(se|k|r)?\b/.test(normalized);
+        if (isTea) {
+            const l3Te = categories.find((c) => c.name.toLowerCase() === 'te' && c.path.toLowerCase().includes('te & choklad'));
+            if (l3Te) {
+                return { categoryId: l3Te.id, categoryName: l3Te.name, path: l3Te.path, confidence: 'high', usedFallback: false };
+            }
+            const l2TeChoklad = categories.find((c) => c.name.toLowerCase() === 'te & choklad' && c.path.toLowerCase().startsWith('dryck'));
+            if (l2TeChoklad) {
+                return { categoryId: l2TeChoklad.id, categoryName: l2TeChoklad.name, path: l2TeChoklad.path, confidence: 'medium', usedFallback: false };
+            }
+        }
+        const isKaffebrod = /\bkaffebrod\b/.test(normalized) ||
+            /\bwienerbrod\b/.test(normalized) ||
+            /\bdonut\b/.test(normalized) ||
+            /\bmunk\b/.test(normalized) ||
+            /\bcroissant\b/.test(normalized) ||
+            /\bkanelbulle\b/.test(normalized) ||
+            /\bbakelse\b/.test(normalized) ||
+            /\bsemla\b/.test(normalized) ||
+            /\bdammsugare\b/.test(normalized) ||
+            /\bkladdkaka\b/.test(normalized) ||
+            /\bmuffin\b/.test(normalized) ||
+            /\bcupcake\b/.test(normalized) ||
+            /\bchokladboll\b/.test(normalized);
+        if (isKaffebrod) {
+            const l3Kaffebrod = categories.find((c) => c.name.toLowerCase() === 'kaffebröd' && c.path.toLowerCase().includes('kondis & fika'));
+            if (l3Kaffebrod) {
+                return { categoryId: l3Kaffebrod.id, categoryName: l3Kaffebrod.name, path: l3Kaffebrod.path, confidence: 'high', usedFallback: false };
+            }
+            const l2Kondis = categories.find((c) => c.name.toLowerCase() === 'kondis & fika' && c.path.toLowerCase().startsWith('bröd & kakor'));
+            if (l2Kondis) {
+                return { categoryId: l2Kondis.id, categoryName: l2Kondis.name, path: l2Kondis.path, confidence: 'medium', usedFallback: false };
+            }
+        }
+        const isChocolateBar = /\bsnickers\b/.test(normalized) ||
+            /\bmars\b/.test(normalized) ||
+            /\btwix\b/.test(normalized) ||
+            /\bbounty\b/.test(normalized) ||
+            /\bkitkat\b/.test(normalized) ||
+            /\bdajm\b/.test(normalized) ||
+            /\bjapp\b/.test(normalized);
+        if (isChocolateBar) {
+            const l3ChocolateBars = findCategory({
+                name: 'chokladkakor & rullar',
+                startsWith: 'glass, godis & snacks > choklad > ',
+            });
+            const hit = toSuggestion(l3ChocolateBars, 'high');
+            if (hit)
+                return hit;
+        }
+        const isCandyBagLike = /\bnappar\b/.test(normalized) ||
+            /\bgodispas\w*\b/.test(normalized);
+        if (isCandyBagLike) {
+            const l3CandyBag = findCategory({
+                name: 'godispåsar',
+                startsWith: 'glass, godis & snacks > godis > ',
+            });
+            const hit = toSuggestion(l3CandyBag, 'high');
+            if (hit)
+                return hit;
+        }
+        const hasPotatoSignal = /\bpotatis\b/.test(normalized);
+        const hasFrozenPotatoSignal = /\bfryst\b/.test(normalized) ||
+            /\bdjupfryst\b/.test(normalized) ||
+            /\bpommes\b/.test(normalized) ||
+            /\bstrips?\b/.test(normalized);
+        if (hasPotatoSignal && !hasFrozenPotatoSignal) {
+            const l3Potato = findCategory({
+                name: 'potatis',
+                startsWith: 'frukt & grönt > potatis & rotsaker > ',
+            });
+            const l3Hit = toSuggestion(l3Potato, 'high');
+            if (l3Hit)
+                return l3Hit;
+        }
+        const isCookingBase = /\bmatlagningsbas\b/.test(normalized) ||
+            /\bmatlagnings\b/.test(normalized) ||
+            /\bplant\s+cream\b/.test(normalized) ||
+            /\bcreme\s+fraiche\b/.test(normalized) ||
+            /\bgradde\b/.test(normalized) ||
+            /\bvispgradde\b/.test(normalized);
+        const isPlantOrAllergy = /\blaktosfri\b/.test(normalized) ||
+            /\bvegetabilisk\b/.test(normalized) ||
+            /\bhavre\b/.test(normalized) ||
+            /\bsoja\b/.test(normalized) ||
+            /\brisdryck\b/.test(normalized) ||
+            /\bplant\b/.test(normalized);
+        if (!isCookingBase || !isPlantOrAllergy)
+            return null;
+        const l3AllergyCooking = categories.find((c) => c.name.toLowerCase() === 'allergi matlagning' &&
+            c.path.toLowerCase().startsWith('matlagning > '));
+        if (l3AllergyCooking) {
+            return {
+                categoryId: l3AllergyCooking.id,
+                categoryName: l3AllergyCooking.name,
+                path: l3AllergyCooking.path,
+                confidence: 'high',
+                usedFallback: false,
+            };
+        }
+        const l2Cooking = categories.find((c) => c.name.toLowerCase() === 'matlagning' &&
+            c.path.toLowerCase() === 'mejeri, ost & ägg > matlagning');
+        if (l2Cooking) {
+            return {
+                categoryId: l2Cooking.id,
+                categoryName: l2Cooking.name,
+                path: l2Cooking.path,
+                confidence: 'medium',
+                usedFallback: false,
+            };
+        }
+        return null;
+    }
+    applyContradictionGuard(rawName, suggestion, categories) {
+        const normalized = normalizeForRules(rawName);
+        const hasPorkSignal = hasPorkLikeSignal(normalized);
+        if (hasPorkSignal) {
+            const aiPath = suggestion.path.toLowerCase();
+            const isClearlyWrongBranch = aiPath.includes('köttbullar & färsprodukter') || aiPath.includes('köttfärs');
+            if (!isClearlyWrongBranch)
+                return suggestion;
+            const l3Pork = this.resolvePorkCategory(categories);
+            if (!l3Pork)
+                return suggestion;
+            this.logger.log(`AI contradiction-guard: "${rawName}" remappas från "${suggestion.path}" till "${l3Pork.path}"`);
+            return {
+                categoryId: l3Pork.id,
+                categoryName: l3Pork.name,
+                path: l3Pork.path,
+                confidence: 'high',
+                usedFallback: true,
+            };
+        }
+        const hasMilkSignal = /\bmjolk\b/.test(normalized) ||
+            /\bstandardmjolk\b/.test(normalized) ||
+            /\bstandmjolk\b/.test(normalized) ||
+            /\besl\b/.test(normalized);
+        const hasLactoseFreeSignal = /\blaktosfri\b/.test(normalized) ||
+            /\blactose\s*free\b/.test(normalized);
+        if (hasMilkSignal && !hasLactoseFreeSignal) {
+            const isWrongLactoseFreeBranch = suggestion.path.toLowerCase().includes('allergi mejeri > laktosfri mjölk');
+            if (isWrongLactoseFreeBranch) {
+                const l3StandardMilk = categories.find((c) => c.name.toLowerCase() === 'standardmjölk' &&
+                    c.path.toLowerCase().startsWith('mejeri, ost & ägg > mjölk > '));
+                if (l3StandardMilk) {
+                    this.logger.log(`AI contradiction-guard: "${rawName}" remappas från "${suggestion.path}" till "${l3StandardMilk.path}"`);
+                    return {
+                        categoryId: l3StandardMilk.id,
+                        categoryName: l3StandardMilk.name,
+                        path: l3StandardMilk.path,
+                        confidence: 'high',
+                        usedFallback: true,
+                    };
+                }
+            }
+        }
+        const hasEggSignal = /\bagg\b/.test(normalized) ||
+            /\begg\b/.test(normalized) ||
+            /\binne\b/.test(normalized) ||
+            /\b24p\b/.test(normalized);
+        if (hasEggSignal && suggestion.path.toLowerCase().includes('allergi mejeri')) {
+            const l2Egg = categories.find((c) => c.name.toLowerCase() === 'ägg' &&
+                c.path.toLowerCase() === 'mejeri, ost & ägg > ägg');
+            if (l2Egg) {
+                this.logger.log(`AI contradiction-guard: "${rawName}" remappas från "${suggestion.path}" till "${l2Egg.path}"`);
+                return {
+                    categoryId: l2Egg.id,
+                    categoryName: l2Egg.name,
+                    path: l2Egg.path,
+                    confidence: 'high',
+                    usedFallback: true,
+                };
+            }
+            const l1DairyEgg = categories.find((c) => c.path.toLowerCase() === 'mejeri, ost & ägg');
+            if (l1DairyEgg) {
+                this.logger.log(`AI contradiction-guard: "${rawName}" remappas från "${suggestion.path}" till "${l1DairyEgg.path}"`);
+                return {
+                    categoryId: l1DairyEgg.id,
+                    categoryName: l1DairyEgg.name,
+                    path: l1DairyEgg.path,
+                    confidence: 'high',
+                    usedFallback: true,
+                };
+            }
+        }
+        const hasCreamSignal = /\bvispgradde\b/.test(normalized) ||
+            /\bmatlagningsgradde\b/.test(normalized) ||
+            /\bgradde\b/.test(normalized) ||
+            /\bcreme\s+fraiche\b/.test(normalized) ||
+            /\bgraddfil\b/.test(normalized);
+        const hasPlantOrAllergySignal = /\blaktosfri\b/.test(normalized) ||
+            /\bvegetabilisk\b/.test(normalized) ||
+            /\bhavre\b/.test(normalized) ||
+            /\bsoja\b/.test(normalized) ||
+            /\brisdryck\b/.test(normalized) ||
+            /\bplant\b/.test(normalized);
+        if (hasCreamSignal && !hasPlantOrAllergySignal) {
+            const aiPath = suggestion.path.toLowerCase();
+            const isOutsideDairy = !aiPath.startsWith('mejeri, ost & ägg > matlagning');
+            if (!isOutsideDairy)
+                return suggestion;
+            const l2CookingDairy = categories.find((c) => c.name.toLowerCase() === 'matlagning' &&
+                c.path.toLowerCase() === 'mejeri, ost & ägg > matlagning');
+            if (!l2CookingDairy)
+                return suggestion;
+            const l3Cream = categories.find((c) => c.name.toLowerCase() === 'grädde' &&
+                c.path.toLowerCase().startsWith('mejeri, ost & ägg > matlagning > '));
+            if (l3Cream) {
+                this.logger.log(`AI contradiction-guard: "${rawName}" remappas från "${suggestion.path}" till "${l3Cream.path}"`);
+                return {
+                    categoryId: l3Cream.id,
+                    categoryName: l3Cream.name,
+                    path: l3Cream.path,
+                    confidence: 'high',
+                    usedFallback: true,
+                };
+            }
+            this.logger.log(`AI contradiction-guard: "${rawName}" remappas från "${suggestion.path}" till "${l2CookingDairy.path}"`);
+            return {
+                categoryId: l2CookingDairy.id,
+                categoryName: l2CookingDairy.name,
+                path: l2CookingDairy.path,
+                confidence: 'high',
+                usedFallback: true,
+            };
+        }
+        const hasToastBreadSignal = hasBreadLikeSignal(normalized);
+        if (hasToastBreadSignal) {
+            const aiPath = suggestion.path.toLowerCase();
+            const isOutsideBread = !aiPath.startsWith('bröd & kakor > bröd');
+            if (!isOutsideBread)
+                return suggestion;
+            const bread = this.resolveBreadCategory(categories);
+            if (!bread)
+                return suggestion;
+            this.logger.log(`AI contradiction-guard: "${rawName}" remappas från "${suggestion.path}" till "${bread.path}"`);
+            return {
+                categoryId: bread.id,
+                categoryName: bread.name,
+                path: bread.path,
+                confidence: 'high',
+                usedFallback: true,
+            };
+        }
+        return suggestion;
+    }
+};
+exports.ReceiptImportService = ReceiptImportService;
+exports.ReceiptImportService = ReceiptImportService = ReceiptImportService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [prisma_service_1.PrismaService,
+        ai_service_1.AiService,
+        categories_service_1.CategoriesService])
+], ReceiptImportService);
+//# sourceMappingURL=receipt-import.service.js.map