@powerhousedao/contributor-billing 0.0.33 → 0.0.34

package/dist/editors/invoice/validation/validationHandler.js

@@ -0,0 +1,117 @@
+import { validateField } from "./validationManager.js";
+import { toast } from "@powerhousedao/design-system";
+const validateStatusBeforeContinue = (newStatus, state, setInvoiceValidation, setWalletValidation, setCurrencyValidation, setMainCountryValidation, setBankCountryValidation, setIbanValidation, setBicValidation, setBankNameValidation, setStreetAddressValidation, setCityValidation, setPostalCodeValidation, setPayerEmailValidation, setLineItemValidation, isFiatCurrency) => {
+    if (newStatus === "PAYMENTSCHEDULED" || newStatus === "ISSUED") {
+        const context = {
+            currency: state.currency,
+            currentStatus: state.status,
+            targetStatus: newStatus === "PAYMENTSCHEDULED" ? "ISSUED" : "ISSUED",
+        };
+        // Collect all validation errors
+        const validationErrors = [];
+        // Validate invoice number
+        const invoiceValidation = validateField("invoiceNo", state.invoiceNo, context);
+        setInvoiceValidation(invoiceValidation);
+        if (invoiceValidation && !invoiceValidation.isValid) {
+            validationErrors.push(invoiceValidation);
+        }
+        // Validate wallet address if currency is crypto
+        if (!isFiatCurrency(state.currency)) {
+            const walletValidation = validateField("address", state.issuer.paymentRouting?.wallet?.address ?? "", context);
+            setWalletValidation(walletValidation);
+            if (walletValidation && !walletValidation.isValid) {
+                validationErrors.push(walletValidation);
+            }
+        }
+        // Validate currency
+        const currencyValidation = validateField("currency", state.currency, context);
+        setCurrencyValidation(currencyValidation);
+        if (currencyValidation && !currencyValidation.isValid) {
+            validationErrors.push(currencyValidation);
+        }
+        // Validate main country
+        const mainCountry = state.issuer.country ?? "";
+        const mainCountryValidation = validateField("mainCountry", mainCountry, context);
+        setMainCountryValidation(mainCountryValidation);
+        if (mainCountryValidation && !mainCountryValidation.isValid) {
+            validationErrors.push(mainCountryValidation);
+        }
+        // Validate bank country
+        const bankCountry = state.issuer.paymentRouting?.bank?.address?.country ?? "";
+        const bankCountryValidation = validateField("bankCountry", bankCountry, context);
+        setBankCountryValidation(bankCountryValidation);
+        if (bankCountryValidation && !bankCountryValidation.isValid) {
+            validationErrors.push(bankCountryValidation);
+        }
+        // Validate EUR&GBP IBAN account number
+        const ibanValidation = validateField("accountNum", state.issuer.paymentRouting?.bank?.accountNum, context);
+        setIbanValidation(ibanValidation);
+        if (ibanValidation && !ibanValidation.isValid) {
+            validationErrors.push(ibanValidation);
+        }
+        // Validate BIC number
+        const bicValidation = validateField("bicNumber", state.issuer.paymentRouting?.bank?.BIC, context);
+        setBicValidation(bicValidation);
+        if (bicValidation && !bicValidation.isValid) {
+            validationErrors.push(bicValidation);
+        }
+        // Validate bank name
+        const bankNameValidation = validateField("bankName", state.issuer.paymentRouting?.bank?.name, context);
+        setBankNameValidation(bankNameValidation);
+        if (bankNameValidation && !bankNameValidation.isValid) {
+            validationErrors.push(bankNameValidation);
+        }
+        // Validate street address
+        const streetAddressValidation = validateField("streetAddress", state.issuer.address?.streetAddress, context);
+        setStreetAddressValidation(streetAddressValidation);
+        if (streetAddressValidation && !streetAddressValidation.isValid) {
+            validationErrors.push(streetAddressValidation);
+        }
+        // Validate city
+        const cityValidation = validateField("city", state.issuer.address?.city, context);
+        setCityValidation(cityValidation);
+        if (cityValidation && !cityValidation.isValid) {
+            validationErrors.push(cityValidation);
+        }
+        // Validate postal code
+        const postalCodeValidation = validateField("postalCode", state.issuer.address?.postalCode, context);
+        setPostalCodeValidation(postalCodeValidation);
+        if (postalCodeValidation && !postalCodeValidation.isValid) {
+            validationErrors.push(postalCodeValidation);
+        }
+        // Validate payer email
+        const payerEmailValidation = validateField("email", state.payer.contactInfo?.email, context);
+        setPayerEmailValidation(payerEmailValidation);
+        if (payerEmailValidation && !payerEmailValidation.isValid) {
+            validationErrors.push(payerEmailValidation);
+        }
+        // Validate line items
+        const lineItemValidation = validateField("lineItem", state.lineItems, context);
+        setLineItemValidation(lineItemValidation);
+        if (lineItemValidation && !lineItemValidation.isValid) {
+            validationErrors.push(lineItemValidation);
+        }
+        if (newStatus === "PAYMENTSCHEDULED" &&
+            !isFiatCurrency(state.currency) &&
+            state.issuer.paymentRouting?.wallet?.chainName === "") {
+            validationErrors.push({
+                message: "Select currency and chain before accepting invoice",
+                severity: "warning",
+                isValid: false,
+            });
+        }
+        // If there are any validation errors, show them and return
+        if (validationErrors.length > 0) {
+            validationErrors.forEach((error) => {
+                toast(error.message, {
+                    type: error.severity === "error" ? "error" : "warning",
+                });
+            });
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+};
+export default validateStatusBeforeContinue;

package/dist/scripts/contributor-billing/createXeroCsv.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Fetches the exchange rate from `from` currency to `to` currency for a given date using Frankfurter API.
+ * Returns 1 for unsupported currencies or errors.
+ * See: https://frankfurter.dev/
+ */
+export declare function getExchangeRate(date: string, from: string, to: string): Promise<number>;
+export declare function exportInvoicesToXeroCSV(invoiceStates: any[], baseCurrency: string): Promise<void>;
+//# sourceMappingURL=createXeroCsv.d.ts.map

package/dist/scripts/contributor-billing/createXeroCsv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createXeroCsv.d.ts","sourceRoot":"","sources":["../../../scripts/contributor-billing/createXeroCsv.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAkC7F;AAED,wBAAsB,uBAAuB,CAAC,aAAa,EAAE,GAAG,EAAE,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA+LvG"}

package/dist/scripts/contributor-billing/createXeroCsv.js

@@ -0,0 +1,206 @@
+// Simple in-memory cache: { '2024-06-10|USD|CHF': 0.91 }
+const exchangeRateCache = {};
+/**
+ * Fetches the exchange rate from `from` currency to `to` currency for a given date using Frankfurter API.
+ * Returns 1 for unsupported currencies or errors.
+ * See: https://frankfurter.dev/
+ */
+export async function getExchangeRate(date, from, to) {
+    if (!date || !from || !to || from === to)
+        return 1;
+    // Use the invoice currency as base, CHF as symbol
+    let effectiveTo = from;
+    if (from === 'DAI' || from === 'USDS') {
+        effectiveTo = 'USD';
+    }
+    const formattedDate = date.split('T')[0];
+    const cacheKey = `${formattedDate}|${effectiveTo}|${to}`;
+    if (exchangeRateCache[cacheKey] !== undefined) {
+        return exchangeRateCache[cacheKey];
+    }
+    try {
+        // base=effectiveTo (invoice currency), symbols=CHF
+        const url = `https://api.frankfurter.dev/v1/${formattedDate}?base=${effectiveTo}&symbols=${to}`;
+        console.log('Fetching from Frankfurter URL:', url);
+        const res = await fetch(url);
+        if (!res.ok) {
+            throw new Error(`Failed to fetch Frankfurter exchange rate: ${res.status} ${res.statusText}`);
+        }
+        const data = await res.json();
+        const rate = data?.rates?.[to];
+        if (typeof rate !== 'number') {
+            throw new Error(`Frankfurter exchange rate for ${effectiveTo} to CHF on ${formattedDate} not found in response`);
+        }
+        exchangeRateCache[cacheKey] = rate;
+        return rate;
+    }
+    catch (err) {
+        console.error('Frankfurter ForEx API error:', err);
+        return 1; // Fallback to 1:1 on error
+    }
+}
+export async function exportInvoicesToXeroCSV(invoiceStates, baseCurrency) {
+    const headers = [
+        'Narration',
+        'Date',
+        'Description',
+        'AccountCode',
+        'TaxRate',
+        'Amount',
+        'TrackingName1',
+        'TrackingOption1',
+        'TrackingName2',
+        'TrackingOption2',
+        'Invoice currency',
+        'FX Rate Used',
+    ];
+    const allRows = [];
+    const exportDataByInvoice = {};
+    const exportTimestamp = new Date().toISOString();
+    const missingExpenseTagInvoices = [];
+    for (let state of invoiceStates) {
+        state = state.global;
+        const invoiceId = state.id || Math.random().toString(36).slice(2); // fallback if no id
+        const invoiceName = state.name || invoiceId;
+        const items = state.lineItems || [];
+        const dateIssued = state.dateIssued || '';
+        let datePaid = state.paymentDate || '';
+        if (datePaid.includes('T')) {
+            datePaid = datePaid.split('T')[0];
+        }
+        const narration = `${state.issuer?.name || 'Supplier'}, invoice ${state.invoiceNo || ''}`;
+        const currency = state.currency || 'USD';
+        const invoiceAmount = Number(state.totalPriceTaxIncl || 0);
+        let effectiveCurrency = currency;
+        if (currency === 'DAI' || currency === 'USDS') {
+            effectiveCurrency = 'USD';
+        }
+        // Check if any line item is missing a valid xero-expense-account tag
+        const hasMissingExpenseTag = items.some((item) => {
+            const expenseTag = (item.lineItemTag || []).find((tag) => tag.dimension === "xero-expense-account");
+            return !expenseTag || !expenseTag.label;
+        });
+        if (hasMissingExpenseTag) {
+            missingExpenseTagInvoices.push(invoiceName);
+            continue; // Skip this invoice entirely
+        }
+        // Fetch exchange rates
+        const [rateOnIssue,
+        //rateOnPayment
+        ] = await Promise.all([
+            getExchangeRate(dateIssued, effectiveCurrency, baseCurrency),
+            //getExchangeRate(datePaid, effectiveCurrency, 'CHF')
+        ]);
+        const amountAtIssue = invoiceAmount * rateOnIssue;
+        //const amountAtPayment = invoiceAmount * rateOnPayment;
+        //const realisedGain = amountAtPayment - amountAtIssue;
+        // Collect rows for this invoice
+        const invoiceRows = [];
+        // --- ISSUE DATE JOURNALS ---
+        if (amountAtIssue) {
+            invoiceRows.push([
+                narration,
+                dateIssued,
+                'Accounts Payable',
+                '802',
+                'Tax Exempt (0%)',
+                `-${amountAtIssue.toFixed(2)}`,
+                '', '', '', '',
+                currency,
+                rateOnIssue.toString()
+            ]);
+        }
+        items.forEach((item) => {
+            const expenseTag = (item.lineItemTag || []).find((tag) => tag.dimension === "xero-expense-account");
+            const description = expenseTag.label;
+            const accountCode = expenseTag.value?.toString() || item.accountCode?.toString() || '';
+            const taxRate = 'Tax Exempt (0%)';
+            const itemAmount = (item.totalPriceTaxIncl || 0) * rateOnIssue;
+            invoiceRows.push([
+                narration,
+                dateIssued,
+                description,
+                accountCode,
+                taxRate,
+                itemAmount.toFixed(2),
+                '', '', '', '',
+                currency,
+                rateOnIssue.toString()
+            ]);
+        });
+        // --- PAYMENT DATE JOURNALS (commented out) ---
+        /*
+        if (datePaid && amountAtPayment) {
+          // Accounts Payable (positive, at payment date)
+          rows.push([
+            narration,
+            datePaid,
+            'Accounts Payable',
+            '802',
+            'Tax Exempt (0%)',
+            amountAtIssue.toFixed(2),
+            '', '', state.txnHash || '', '',
+            currency,
+            rateOnPayment.toString()
+          ]);
+          // Wallet DAI (negative, at payment date)
+          rows.push([
+            narration,
+            datePaid,
+            'Wallet DAI',
+            '',
+            'Tax Exempt (0%)',
+            -amountAtPayment.toFixed(2),
+            '', '', state.txnHash || '', '',
+            currency,
+            rateOnPayment.toString()
+          ]);
+          // Realised Currency Gains (if any, at payment date)
+          if (Math.abs(realisedGain) > 0.01) {
+            rows.push([
+              narration,
+              datePaid,
+              'Realised Currency Gains',
+              '499',
+              'Tax Exempt (0%)',
+              realisedGain.toFixed(2),
+              '', '', state.txnHash || '', '',
+              currency,
+              rateOnPayment.toString()
+            ]);
+          }
+        }
+        */
+        // Add to allRows for CSV download
+        allRows.push(...invoiceRows);
+        // Store export data for this invoice
+        exportDataByInvoice[invoiceId] = {
+            exportTimestamp,
+            exportedLines: [headers, ...invoiceRows]
+        };
+        // Optionally, assign to the invoice state here if you want to mutate it directly:
+        // state.exportData = exportDataByInvoice[invoiceId];
+    }
+    // If any invoices are missing expense tags, throw an error
+    if (missingExpenseTagInvoices.length > 0) {
+        throw new Error(`The following invoices have line items missing a 'xero-expense-account' tag: ${[...new Set(missingExpenseTagInvoices)].join(', ')}`);
+    }
+    // Download CSV for all invoices
+    const csvLines = [headers.join(',')].concat(allRows.map(row => row.map(value => `"${value}"`).join(',')));
+    const csvData = csvLines.join('\n');
+    // Download logic (browser)
+    const blob = new Blob([csvData], { type: 'text/csv;charset=utf-8;' });
+    const link = document.createElement('a');
+    const url = URL.createObjectURL(blob);
+    link.setAttribute('href', url);
+    link.setAttribute('download', `xero-invoice-export-${new Date().toISOString().split('T')[0]}.csv`);
+    link.style.visibility = 'hidden';
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    // This is the data to be added to ExportData in the state of each invoice
+    console.log(exportDataByInvoice);
+    // Return or assign exportDataByInvoice as needed
+    // For example, return it if you want to use it elsewhere:
+    // return exportDataByInvoice;
+}