@bisondesk/core-sdk 1.0.677 → 1.0.679

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bisondesk/core-sdk",
-  "version": "1.0.677",
+  "version": "1.0.679",
   "description": "",
   "type": "module",
   "author": "TheTruckCompany",

package/src/apis/exchange-rates.ts

@@ -1,9 +1,5 @@
 import { XError } from '@bisondesk/commons-sdk/errors';
 import { getAdminAuth } from '@bisondesk/commons-sdk/fetch';
-import {
-  CurrencyConversionRequest,
-  CurrencyConversionResponse,
-} from '@bisondesk/commons-sdk/types';
 import fetch, { Response } from 'node-fetch';
 import { ExchangeRate } from '../types/exchange-rates.js';
 
@@ -50,51 +46,6 @@ export const getExchangeRate = async (
   throw new XError(response.statusText, { url, body, fromCurrency, toCurrency });
 };
 
-/** The daily rates of the rate provider, as the quote and invoice forms get them. */
-export const getCurrencyConversionRates = async (
-  request: CurrencyConversionRequest,
-): Promise<CurrencyConversionResponse> => {
-  const auth = await getAdminAuth();
-  const url = `${process.env.CORE_API_ORIGIN}/api/currency/rates`;
-  const response: Response = await fetch(url, {
-    method: 'POST',
-    headers: {
-      Authorization: auth,
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify(request),
-  });
-
-  if (response.ok) {
-    return response.json() as any;
-  }
-
-  const body = await response.text();
-  throw new XError(response.statusText, { url, body, request });
-};
-
-/**
- * The plain daily rate of `date`: how many units of `toCurrency` equal 1 unit of `fromCurrency`,
- * without the bank-fee markup. Undefined when the provider has no rate for the pair.
- */
-export const getDailyConversionRate = async (
-  fromCurrency: string,
-  toCurrency: string,
-  date?: string,
-): Promise<string | undefined> => {
-  if (fromCurrency === toCurrency) {
-    return '1';
-  }
-
-  const { rates } = await getCurrencyConversionRates({
-    sourceCurrency: fromCurrency,
-    targetCurrency: toCurrency,
-    date,
-    bankFeeMarkup: false,
-  });
-  return rates[toCurrency];
-};
-
 /**
  * Direction-agnostic conversion multiplier: how many units of `toCurrency`
  * equal 1 unit of `fromCurrency`. Tries a direct pair first, then falls back

package/src/apis/organization-bank-accounts.ts

@@ -0,0 +1,123 @@
+import { SERVICE_ID_ADMIN_HEADER, TENANT_ID_ADMIN_HEADER } from '@bisondesk/commons-sdk/constants';
+import { XError } from '@bisondesk/commons-sdk/errors';
+import { cleanHeaders, getAdminAuth } from '@bisondesk/commons-sdk/fetch';
+import { DataRecord } from '@bisondesk/commons-sdk/utils';
+import fetch, { Response } from 'node-fetch';
+import {
+  NewOrganizationBankAccount,
+  OrganizationBankAccount,
+  OrganizationBankAccountMeta,
+} from '../types/organization-bank-accounts.js';
+
+type ServiceOptions = { serviceId?: string };
+
+/**
+ * Calls an organisation bank-account route as a service. The service id becomes the user core
+ * records as having made the change.
+ */
+const callBankAccountsRoute = async (
+  tenantId: string,
+  path: string,
+  init: { method: string; body?: unknown },
+  opts?: ServiceOptions,
+): Promise<Response> => {
+  const auth = await getAdminAuth();
+  const url = `${process.env.CORE_API_ORIGIN}${path}`;
+  const response: Response = await fetch(url, {
+    method: init.method,
+    headers: cleanHeaders({
+      Authorization: auth,
+      'Content-Type': init.body != null ? 'application/json' : undefined,
+      [TENANT_ID_ADMIN_HEADER]: tenantId,
+      [SERVICE_ID_ADMIN_HEADER]: opts?.serviceId,
+    }),
+    body: init.body != null ? JSON.stringify(init.body) : undefined,
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new XError(response.statusText, { method: init.method, url, body, tenantId, opts });
+  }
+  return response;
+};
+
+const bankAccountsPath = (organizationId: string) =>
+  `/api/crm/organizations/${organizationId}/bank-accounts`;
+
+/** An organisation's bank accounts, the default first. */
+export const listOrganizationBankAccounts = async (
+  tenantId: string,
+  organizationId: string,
+  opts?: ServiceOptions,
+): Promise<OrganizationBankAccount[]> => {
+  const response = await callBankAccountsRoute(
+    tenantId,
+    bankAccountsPath(organizationId),
+    { method: 'GET' },
+    opts,
+  );
+  const records = (await response.json()) as DataRecord<
+    OrganizationBankAccount,
+    OrganizationBankAccountMeta
+  >[];
+  return records.map((entry) => entry.record);
+};
+
+export const createOrganizationBankAccount = async (
+  tenantId: string,
+  input: NewOrganizationBankAccount,
+  opts?: ServiceOptions,
+): Promise<OrganizationBankAccount> => {
+  const { organizationId, ...details } = input;
+  const response = await callBankAccountsRoute(
+    tenantId,
+    bankAccountsPath(organizationId),
+    { method: 'POST', body: details },
+    opts,
+  );
+  return (await response.json()) as OrganizationBankAccount;
+};
+
+export const updateOrganizationBankAccount = async (
+  tenantId: string,
+  bankAccountId: string,
+  input: NewOrganizationBankAccount,
+  opts?: ServiceOptions,
+): Promise<OrganizationBankAccount> => {
+  const { organizationId, ...details } = input;
+  const response = await callBankAccountsRoute(
+    tenantId,
+    `${bankAccountsPath(organizationId)}/${bankAccountId}`,
+    { method: 'PUT', body: details },
+    opts,
+  );
+  return (await response.json()) as OrganizationBankAccount;
+};
+
+export const deleteOrganizationBankAccount = async (
+  tenantId: string,
+  organizationId: string,
+  bankAccountId: string,
+  opts?: ServiceOptions,
+): Promise<void> => {
+  await callBankAccountsRoute(
+    tenantId,
+    `${bankAccountsPath(organizationId)}/${bankAccountId}`,
+    { method: 'DELETE' },
+    opts,
+  );
+};
+
+export const setDefaultOrganizationBankAccount = async (
+  tenantId: string,
+  organizationId: string,
+  bankAccountId: string,
+  opts?: ServiceOptions,
+): Promise<OrganizationBankAccount> => {
+  const response = await callBankAccountsRoute(
+    tenantId,
+    `${bankAccountsPath(organizationId)}/${bankAccountId}/default`,
+    { method: 'POST' },
+    opts,
+  );
+  return (await response.json()) as OrganizationBankAccount;
+};

package/src/types/intercompany-payments.ts

@@ -13,9 +13,8 @@ export type IntercompanyPaymentHop = {
   /** Deep link to the hop opportunity on the target tenant's own subdomain. */
   opportunityUrl: string;
   /**
-   * Currency of the amounts: the hop opportunity's quote currency, or the quote's alternative
-   * currency when every payment of the hop arrived in it. A reserved-stage opportunity always
-   * carries a quote; hops missing one (malformed) are skipped.
+   * Currency of the amounts: the hop opportunity's quote currency. A reserved-stage
+   * opportunity always carries a quote; hops missing one (malformed) are skipped.
    */
   currency: string;
   vehicle: {
@@ -33,7 +32,7 @@ export type IntercompanyPaymentHop = {
    * total payment before delivery). Absent until that hop's quote is manager-accepted.
    */
   expectedTotal?: string;
-  /** Sum of the hop opportunity's non-deleted payment amounts, in `currency`. */
+  /** Sum of the hop opportunity's non-deleted payment amounts. */
   paid: string;
 };
 

package/src/types/offers.ts

@@ -9,7 +9,6 @@ import {
   SearchVehicle,
   VehicleExternalInfo,
   VehicleInternalInfo,
-  VehiclePurchaseDealForeign,
   VehiclePurchaseDealStatus,
   VehiclePurchaseDeliveryType,
 } from './vehicles.js';
@@ -331,7 +330,6 @@ export type OfferPurchase = {
       | VehiclePurchaseDealStatus.Marketing;
     costs: {
       purchase: string;
-      foreign?: VehiclePurchaseDealForeign;
       purchaseVatPercentage: string;
       internalGarage?: string;
       externalGarage?: string;

package/src/types/opportunities.ts

@@ -251,23 +251,8 @@ export type OpportunityUpdate = {
 };
 
 export type OpportunityPaymentSummary = {
-  /** Branch currency. */
   total: string;
-  /** Sum of `amount` over the payments, in branch currency. */
   paid: string;
-  /**
-   * The same pair in the quote's alternative currency, present when the branch can be paid in it.
-   * `paid` sums the payments that arrived in that currency.
-   */
-  foreign?: {
-    total: string;
-    paid: string;
-    currencyCode: string;
-    exchangeRate: string;
-  };
-  /** Fully paid when either currency reaches its total. */
-  status: OpportunityPaymentStatus;
-  percentagePaid: string;
   entries: DataRecord<OpportunityPayment>[];
 };
 
@@ -536,6 +521,7 @@ export type HpLeasingDealRunDataCi = HpLeasingDealRunDataBase & {
   dueeDuLeasingEnMois: number;
   travauxHorsNormesNecessaire: boolean;
   descriptionDesTravauxHorsNormes: string;
+  prixTravaexSupplementaire: string;
 };
 
 export type HpLeasingDealRequest = {

package/src/types/opportunity-payments.ts

@@ -7,27 +7,8 @@ export enum OpportunityPaymentActions {
 
 export const OPPORTUNITY_PAYMENT_NOTIFICATION_ORIGIN = 'opportunity-payment-notification';
 
-/**
- * The money as it arrived, when it arrived in the quote's alternative currency. `amount` then
- * holds its value in branch currency: `foreign.amount × foreign.exchangeRate`.
- */
-export type OpportunityPaymentForeign = {
-  amount: string;
-  currencyCode: string;
-  /** Branch currency units per 1 unit of `currencyCode`, the quote's rate. */
-  exchangeRate: string;
-};
-
-/** What a user sends for a payment in another currency. The backend takes the rate from the quote
- * and derives `amount`. */
-export type OpportunityPaymentForeignRequest = Pick<
-  OpportunityPaymentForeign,
-  'amount' | 'currencyCode'
->;
-
 type BaseOpportunityPayment = {
   opportunityId: string;
-  /** Branch currency. */
   amount: string;
   description?: string;
   vehicleId: string;
@@ -43,7 +24,6 @@ export type NewOpportunityPayment = BaseOpportunityPayment & {
   deletedAt?: undefined;
   deletedBy?: undefined;
   paidAt: string;
-  foreign?: OpportunityPaymentForeignRequest;
 };
 
 export type OpportunityPayment = BaseOpportunityPayment & {
@@ -55,14 +35,11 @@ export type OpportunityPayment = BaseOpportunityPayment & {
   deletedAt?: string;
   deletedBy?: string;
   paidAt?: string;
-  foreign?: OpportunityPaymentForeign;
 };
 
 export type OpportunityPaymentUpdate = {
   description?: string;
   amount?: string;
-  /** `null` turns the payment back into a branch currency payment. */
-  foreign?: OpportunityPaymentForeignRequest | null;
   paidAt?: string;
 };
 

package/src/types/organization-bank-accounts.ts

@@ -0,0 +1,56 @@
+import { BankAccountDetails } from '@bisondesk/commons-sdk/bank-accounts';
+
+/**
+ * An accountant's confirmation of one account number. It only counts while the account still
+ * holds that number, so trust never carries over to a new number however the account was edited.
+ */
+export type OrganizationBankAccountVerification = {
+  accountNumber: string;
+  verifiedBy: string;
+  verifiedAt: string;
+};
+
+export enum OrganizationBankAccountActions {
+  VERIFY = 'verify',
+}
+
+export enum OrganizationBankAccountActionBlockerCode {
+  CHANGED_NEEDS_VERIFICATION = 'changed_needs_verification',
+}
+
+export type OrganizationBankAccountActionBlocker = {
+  code: OrganizationBankAccountActionBlockerCode;
+};
+
+/**
+ * Why an action the user would otherwise see is refused right now. A missing permission hides the
+ * action instead.
+ */
+export type OrganizationBankAccountBlockedAction = {
+  action: OrganizationBankAccountActions;
+  reasons: OrganizationBankAccountActionBlocker[];
+};
+
+export type OrganizationBankAccountMeta = {
+  blockedActions: OrganizationBankAccountBlockedAction[];
+};
+
+export type NewOrganizationBankAccount = BankAccountDetails & {
+  organizationId: string;
+};
+
+/**
+ * An organisation's bank account for outgoing SEPA transfers, never shared across companies. An
+ * organisation can hold several; at most one is its `default`, the one payment exports pay to.
+ * Editing the account number or holder name clears the manual verification, so a valid checksum is
+ * never mistaken for a confirmed account holder.
+ */
+export type OrganizationBankAccount = NewOrganizationBankAccount & {
+  id: string;
+  default?: boolean;
+  createdAt: string;
+  createdBy: string;
+  modifiedAt: string;
+  modifiedBy: string;
+  verification?: OrganizationBankAccountVerification;
+};

package/src/types/payment-exports.ts

@@ -0,0 +1,40 @@
+import { BankAccountDetails } from '@bisondesk/commons-sdk/bank-accounts';
+import { AttachmentValue } from '@bisondesk/commons-sdk/types';
+
+/**
+ * The transfer details of one payment, frozen at export time. A later edit to the payment or the
+ * supplier bank account must not rewrite what the sent file said, so the export keeps its own copy
+ * of every value that went into the XML. It also records the payment batch the payment was sent to
+ * processing in, so the export is a self-contained audit record even though one file can span
+ * several batches.
+ */
+export type PaymentExportLine = {
+  paymentId: string;
+  vehicleId: string;
+  amount: string;
+  creditor: BankAccountDetails;
+  paymentBatchId: string;
+  transferReference?: string;
+};
+
+export type NewPaymentExport = {
+  /** Single execution date (`yyyy-MM-dd`) written to the file's `ReqdExctnDt`. */
+  executionDate: string;
+  /** Σ of the exported line amounts (string; computed with decimal arithmetic). */
+  totalAmount: string;
+  paymentIds: string[];
+  lines: PaymentExportLine[];
+  /** The generated SEPA file, stored in S3 and re-downloadable from Processing. */
+  xmlFile: AttachmentValue;
+};
+
+/**
+ * A generated SEPA file for a selection of Processing payments, plus the frozen record of exactly what
+ * was sent. Re-downloading serves the same file and never re-exports; a payment cancelled out of the
+ * file returns to Allowed and leaves this record intact.
+ */
+export type PaymentExport = NewPaymentExport & {
+  id: string;
+  exportedAt: string;
+  exportedBy: string;
+};

package/src/types/tenants.ts

@@ -55,6 +55,13 @@ export enum TenantModule {
   Intercompany = 'intercompany',
   Opportunities = 'opportunities',
   Offers = 'offers',
+  /**
+   * The tenant pays suppliers through Isabel file exports (SEPA transfer files). It grants the
+   * export itself and the verification of the supplier bank accounts it pays to, and requires those
+   * account numbers to be valid IBANs. Without it, Processing payments are simply marked paid, and
+   * a bank account can hold any account number.
+   */
+  PaymentExports = 'payment_exports',
   Vehicles = 'vehicles',
   Tasks = 'tasks',
   TrackAndTrace = 'track_and_trace',
@@ -148,12 +155,6 @@ export type Branch = {
   exactAccounting?: boolean;
   accounting?: AccountingProvider;
   currency: string;
-  /**
-   * The currencies money moves in at this branch, its own `currency` included. Customer payments,
-   * purchase prices, supplier invoice drafts and Exact bookings are supported in these currencies
-   * only. Absent = the branch's own `currency` only. Set by script.
-   */
-  paymentCurrencies?: [string, ...string[]];
   adminNumberPrefix: string;
   stockNumberPrefix: string;
   vatNumber: string;

package/src/types/transports.ts

@@ -340,7 +340,7 @@ export const KANBAN_TRANSPORT_ITEM_FIELDS = [
   'org.name',
   'org.countryCode',
   'org.externalId',
-  'opportunity.deliveredAt',
+  'opportunity.branch',
   'purchase.logistics.status',
   'purchase.logistics.availableWeek',
   'purchase.logistics.pickupAddress',

package/src/types/vehicle-purchase-payments.ts

@@ -1,41 +1,142 @@
 import { BaseEvent } from './internal-events.js';
+import { OrganizationBankAccountActions } from './organization-bank-accounts.js';
 import { SearchVehicle } from './vehicles.js';
 
 export const VEHICLE_PURCHASE_PAYMENT_ALLOWED_NOTIFICATION_ORIGIN =
   'vehicle-purchase-payment-allowed-notification';
 
 /**
- * A payment on a purchase priced in another currency is authorized and paid in that currency.
- * `amount` then holds its value in branch currency: `foreign.amount × foreign.exchangeRate`.
+ * The stage a supplier payment sits at, driving the Unpaid/Allowed/Processing/Executed tabs.
+ * A payment only ever moves forward: an authorised payment is `allowed`; sending it to processing
+ * groups it into a payment batch and hands it to accounting (`processing`), which exports it
+ * to the Isabel bank file; marking it paid moves it to `executed`.
+ * (`unpaid` is not a stage — it is an agreed purchase with an amount still to authorise.)
  */
-export type VehiclePurchasePaymentForeign = {
-  amount: string;
-  currencyCode: string;
-  /** Branch currency units per 1 unit of `currencyCode`, the purchase's rate. */
-  exchangeRate: string;
-};
+export enum PaymentStage {
+  Allowed = 'allowed',
+  Processing = 'processing',
+  Executed = 'executed',
+}
 
 export type NewVehiclePurchasePayment = {
   vehicleId: string;
-  /** Branch currency. Derived from `foreign` when the purchase is priced in another currency. */
   amount: string;
-  /** The backend takes the rate from the purchase. */
-  foreign?: Pick<VehiclePurchasePaymentForeign, 'amount' | 'currencyCode'>;
   description?: string;
   paidAt?: string;
   paidBy?: string;
 };
 
-export type VehiclePurchasePayment = Omit<NewVehiclePurchasePayment, 'foreign'> & {
+export type VehiclePurchasePayment = NewVehiclePurchasePayment & {
   id: string;
   createdBy: string;
   createdAt: string;
-  foreign?: VehiclePurchasePaymentForeign;
+  stage: PaymentStage;
+  /** Manual settlement priority within the Allowed tab; lower is paid first. */
+  priority: number;
+  /** Set once the payment has been exported; links it to its payment export. */
+  exportId?: string;
+  /** The payment batch this payment was sent to processing in; unset while Allowed, and on payments
+   * marked paid straight from Allowed. */
+  paymentBatchId?: string;
+  /**
+   * Supplier-facing communication that becomes the SEPA transfer's remittance information (`RmtInf`),
+   * so the supplier can reconcile the payment to an invoice. Editable while Processing and not yet
+   * exported; prefilled from the latest purchase invoice. This is not the file's per-line
+   * `EndToEndId`.
+   */
+  transferReference?: string;
+  /** Who sent the payment to processing, and when — set at the Allowed → Processing step. */
+  sentToProcessingBy?: string;
+  sentToProcessingAt?: string;
+};
+
+/**
+ * One send to processing: the Allowed payments an accountant moved to Processing together, and who
+ * sent them. The Processing tab groups its rows by batch. A batch holds no amount of its own; its
+ * total is the sum of the payments still in it.
+ */
+export type PaymentBatch = {
+  id: string;
+  createdAt: string;
+  createdBy: string;
+};
+
+/**
+ * Whether a payment's supplier can be paid in an export. Mirrors the export gate: a transfer needs a
+ * supplier bank account that carries an IBAN and holder name and has been verified. Shown as an
+ * export-blocked marker on the Processing rows, where the accountant clears it before exporting.
+ * (The invoice / pro-forma document half of the gate is not reflected here — its source is a Q3
+ * residual the backend export gate also defers.)
+ *
+ * The bank account is the supplier's default one, `bankAccountId`, which is the account an export
+ * pays. `bankAccountActions` lists what the current user may do on it, so a row can point out the
+ * accounts they can verify themselves. Once the account number or holder name changed, verify is
+ * left out for accountants, and for whichever Senior Accountant made the change (four-eyes).
+ */
+export type PaymentExportChecks = {
+  bankAccountId?: string;
+  hasBankAccount: boolean;
+  bankAccountVerified: boolean;
+  bankAccountActions: OrganizationBankAccountActions[];
 };
 
 export type VehiclePurchasePaymentBff = {
   payment: VehiclePurchasePayment;
   vehicle: SearchVehicle;
+  /** Name of the supplier organisation (`vehicle.purchase.organizationId`), resolved for display. */
+  supplierName?: string;
+  /** Export checks on the supplier bank account; filled for the Processing list only. */
+  exportChecks?: PaymentExportChecks;
+};
+
+/**
+ * A row on the Unpaid tab: an agreed purchase that still has an amount to authorise for payment.
+ * Derived from the purchase deal and the payments already authorised, not a payment record.
+ */
+export type UnpaidPurchase = {
+  vehicle: SearchVehicle;
+  /** The agreed purchase price including VAT (`deal.purchase` grossed up by `deal.purchaseVatRate`),
+   * so it matches the VAT-inclusive cost the vehicle purchase tab authorises against. */
+  purchaseAmount: string;
+  /** Sum of amounts already authorised (payments in any stage) for this vehicle. */
+  allowedAmount: string;
+  /** Sum of the authorised amounts already settled (payments in Executed) for this vehicle. */
+  paidAmount: string;
+  /** `purchaseAmount − allowedAmount`; always greater than zero for rows shown here. */
+  remainingAmount: string;
+  /** Due date of the purchase invoice. */
+  invoiceDueDate?: string;
+  /** Name of the supplier organisation (`vehicle.purchase.organizationId`), resolved for display. */
+  supplierName?: string;
+};
+
+/** Body of the export request: the Processing payments to put in one file, the paying account, and the execution date. */
+export type ExportPaymentsRequest = {
+  paymentIds: string[];
+  /** The bank account (from documents settings) to pay the file from — the file's debtor. */
+  debtorBankAccountId: string;
+  /** Single execution date (`yyyy-MM-dd`) written to `ReqdExctnDt`; defaults to today. */
+  executionDate?: string;
+};
+
+/** Body of the mark-paid request: the payments (Allowed or Processing) to settle in one call. */
+export type MarkPaymentsPaidRequest = {
+  paymentIds: string[];
+};
+
+/** Body of the send-to-processing request: the Allowed payments to send together as one batch. */
+export type SendPaymentsToProcessingRequest = {
+  paymentIds: string[];
+};
+
+/**
+ * How many rows sit behind each payment tab, for the tab counters. Executed is unbounded and has no
+ * counter, so it is left out.
+ */
+export type PurchasePaymentCounts = {
+  unpaid: number;
+  allowed: number;
+  processing: number;
 };
 
 export type VehiclePurchasePaymentCreateEvent = {

package/src/types/vehicles.ts

@@ -170,7 +170,6 @@ export type NewVehicleRequest = {
     dealStatus: VehiclePurchaseDealStatus;
     costs: {
       purchase: string;
-      foreign?: VehiclePurchaseDealForeign;
       purchaseVatPercentage: string;
       commission?: string;
       externalTransport?: string;
@@ -812,18 +811,6 @@ export type VehiclePriceUpdateResponse =
       errors: VehiclePriceUpdateError[];
     };
 
-/**
- * The price the supplier asked, in the supplier's currency: one of the payment currencies of the
- * vehicle's branch. The purchase's `deal.purchase` is then `purchase × exchangeRate`, and payments
- * are authorized in `currencyCode`.
- */
-export type VehiclePurchaseDealForeign = {
-  purchase: string; // exclusive VAT
-  currencyCode: string;
-  /** Branch currency units per 1 unit of `currencyCode`. */
-  exchangeRate: string;
-};
-
 export type VehiclePurchase = {
   organizationId: string;
   contactId: string;
@@ -859,13 +846,15 @@ export type VehiclePurchase = {
     checkedInBy?: string;
   };
 
+  /** Due date of the supplier purchase invoice; editable from the payments page. */
+  invoiceDueDate?: string;
+
   deal: {
     status: VehiclePurchaseDealStatus; // partially set by the user, if there are payments then it is set automatically by the backend
     readyToDeliver?: boolean;
 
     purchaseVatRate?: string;
-    purchase?: string; // exclusive VAT; derived from `foreign` when present
-    foreign?: VehiclePurchaseDealForeign;
+    purchase?: string; // exclusive VAT
 
     bonus?: string; // sometimes manufacturers pay us a bonus when we reach a target
 

package/src/utils/organization-bank-accounts.ts

@@ -0,0 +1,19 @@
+import { normalizeIban } from '@bisondesk/commons-sdk/iban';
+import { OrganizationBankAccount } from '../types/organization-bank-accounts.js';
+
+/**
+ * Whether an organisation's bank account can be paid: it carries a verification, and that
+ * verification was given for the account number the account holds now. A verification recorded
+ * without an account number, or for a different one, does not count.
+ *
+ * Shared so the export gate and the Processing rows read one rule.
+ */
+export const isOrganizationBankAccountVerified = (
+  account: OrganizationBankAccount | undefined,
+): boolean => {
+  const verifiedAccountNumber = account?.verification?.accountNumber;
+  if (account == null || verifiedAccountNumber == null) {
+    return false;
+  }
+  return normalizeIban(verifiedAccountNumber) === normalizeIban(account.accountNumber);
+};