@bisondesk/core-sdk 1.0.677 → 1.0.679

package/src/utils/tenants.test.ts

@@ -1,11 +1,5 @@
 import { Branch, Tenant } from '../types/tenants.js';
-import {
-  areBranchesQuoteCompatible,
-  getBranchAskingVies,
-  getBranchPaymentCurrencies,
-  hasForeignPaymentCurrency,
-  isForeignPaymentCurrency,
-} from './tenants.js';
+import { areBranchesQuoteCompatible, getBranchAskingVies } from './tenants.js';
 
 const createBranch = (override?: Partial<Branch>): Branch => ({
   id: 'TTC',
@@ -71,35 +65,3 @@ describe('getBranchAskingVies', () => {
     expect(getBranchAskingVies(tenantOf([bolivia]), 'BO')).toBeUndefined();
   });
 });
-
-describe('payment currencies of a branch', () => {
-  const southAmerica = createBranch({
-    id: 'HPA South America',
-    paymentCurrencies: ['EUR', 'USD'],
-  });
-
-  test('a branch without a list is paid in its own currency only', () => {
-    expect(getBranchPaymentCurrencies(createBranch())).toEqual(['EUR']);
-  });
-
-  test('a branch with a list is paid in the currencies it lists', () => {
-    expect(getBranchPaymentCurrencies(southAmerica)).toEqual(['EUR', 'USD']);
-  });
-
-  test.each([
-    ['a listed currency other than its own', 'USD', true],
-    ['its own currency', 'EUR', false],
-    ['a currency it does not list', 'BOB', false],
-  ])('%s is a foreign payment currency: %s', (_label, currencyCode, expected) => {
-    expect(isForeignPaymentCurrency(southAmerica, currencyCode)).toBe(expected);
-  });
-
-  test('a branch without a list has no foreign payment currency', () => {
-    expect(isForeignPaymentCurrency(createBranch(), 'USD')).toBe(false);
-    expect(hasForeignPaymentCurrency(createBranch())).toBe(false);
-  });
-
-  test('a branch listing another currency has a foreign payment currency', () => {
-    expect(hasForeignPaymentCurrency(southAmerica)).toBe(true);
-  });
-});

package/src/utils/tenants.ts

@@ -24,23 +24,6 @@ export const getBranchAskingVies = (tenant: Tenant, branchId?: string): Branch |
   return europeanBranches.find((branch) => branch.id === branchId) ?? europeanBranches.at(0);
 };
 
-/** The currencies money moves in at the branch, its own currency included. */
-export const getBranchPaymentCurrencies = (branch: Branch): string[] =>
-  branch.paymentCurrencies ?? [branch.currency];
-
-/**
- * Whether the branch can be paid, price a purchase or receive a supplier invoice in a currency
- * other than its own. Its own currency is never a foreign one.
- */
-export const isForeignPaymentCurrency = (branch: Branch, currencyCode: string): boolean =>
-  currencyCode !== branch.currency && getBranchPaymentCurrencies(branch).includes(currencyCode);
-
-/** Whether the branch lists any payment currency other than its own. */
-export const hasForeignPaymentCurrency = (branch: Branch): boolean =>
-  getBranchPaymentCurrencies(branch).some((currencyCode) =>
-    isForeignPaymentCurrency(branch, currencyCode),
-  );
-
 /** The source invoices the end customer directly; this branch collects payment and earns
  * commission (see {@link Branch.dropshipping}). */
 export const isDropshippingBranch = (branch: Branch): boolean => branch.dropshipping === true;

package/src/utils/transports.test.ts

@@ -0,0 +1,50 @@
+import { BusinessEntityIds } from '../constants.js';
+import { TransportStatus, TransportType } from '../types/transports.js';
+import { VehiclePurchaseLogisticsStatus } from '../types/vehicles.js';
+import { getTransportDocumentOwner, isTransportCompleted } from './transports.js';
+
+describe('getTransportDocumentOwner', () => {
+  test.each([
+    {
+      description: 'a sale transport files on its deal',
+      transport: { type: TransportType.Sale, vehicleId: 'V1', opportunityId: 'OPP1' },
+      expected: { businessEntityId: BusinessEntityIds.Opportunities, recordId: 'OPP1' },
+    },
+    {
+      description: 'a purchase transport files on its vehicle',
+      transport: { type: TransportType.Purchase, vehicleId: 'V1' },
+      expected: { businessEntityId: BusinessEntityIds.Vehicles, recordId: 'V1' },
+    },
+    {
+      description: 'a sale transport without a deal has no owner',
+      transport: { type: TransportType.Sale, vehicleId: 'V1' },
+      expected: undefined,
+    },
+  ])('$description', ({ transport, expected }) => {
+    expect(getTransportDocumentOwner(transport)).toEqual(expected);
+  });
+});
+
+describe('isTransportCompleted', () => {
+  test.each([
+    { status: TransportStatus.Done, expected: true },
+    { status: TransportStatus.OngoingInternal, expected: false },
+  ])('a sale transport at $status is completed: $expected', ({ status, expected }) => {
+    expect(isTransportCompleted({ type: TransportType.Sale, status }, {})).toBe(expected);
+  });
+
+  test.each([
+    { logistics: VehiclePurchaseLogisticsStatus.Arrived, expected: true },
+    { logistics: VehiclePurchaseLogisticsStatus.AtOrigin, expected: false },
+  ])('a purchase transport whose vehicle is $logistics is completed: $expected', ({
+    logistics,
+    expected,
+  }) => {
+    expect(
+      isTransportCompleted(
+        { type: TransportType.Purchase, status: TransportStatus.OngoingInternal },
+        { purchase: { logistics: { status: logistics } } },
+      ),
+    ).toBe(expected);
+  });
+});

package/src/utils/transports.ts

@@ -1,7 +1,7 @@
+import { BusinessEntityIds } from '../constants.js';
 import { PurchaseDeliveryTypes } from '../types/deliveries.js';
-import { Opportunity } from '../types/opportunities.js';
 import { PickFieldIds } from '../types/search.js';
-import { SearchTransport, Transport, TransportType } from '../types/transports.js';
+import { SearchTransport, Transport, TransportStatus, TransportType } from '../types/transports.js';
 import { VehiclePurchase } from '../types/vehicles.js';
 import { hasPurchaseArrived } from './vehicles.js';
 
@@ -14,39 +14,56 @@ export const isPurchaseDropOffTransport = (
   isPurchaseTransport(transport) && transport.delivery.type === PurchaseDeliveryTypes.DROP_OFF;
 
 /**
- * A transport is finished when the journey it describes has demonstrably happened: the customer has
- * the vehicle for a sale delivery, the vehicle is on our park for a purchase. From then on
- * the record is history and the server refuses edits to it.
+ * A transport is finished when the journey it describes is over. From then on the record is
+ * history and the server refuses edits to it.
  *
- * Not the same thing as the transport's own `doneAt`. Delivery can be declared on the opportunity
- * (a CMR, a delivery confirmation) and arrival on the purchase, without the transport ever being
- * moved — and reversing either of those is what unlocks the transport again, which a status stamped
- * on the transport itself could not express.
+ * A sale delivery is over when the transport itself is at Done: the transport drives the deal's
+ * delivery, not the other way around, so a deal delivered some other way (a CMR or the Deliver
+ * action, before that rule) does not lock a transport that never got there. Moving it out of Done
+ * unlocks it again.
+ *
+ * A purchase is over when the vehicle is on our park. The park declares the arrival on the purchase,
+ * without the transport ever being moved, and putting the purchase back to At origin is what
+ * unlocks the transport again.
  *
  * Shared so the board, the drawer and the server all answer the question the same way.
  */
 export const isTransportCompleted = (
-  transport: Pick<Transport, 'type'>,
-  context: {
-    opportunity?: Pick<Opportunity, 'deliveredAt'>;
-    purchase?: { logistics: Pick<VehiclePurchase['logistics'], 'status'> };
-  },
+  transport: Pick<Transport, 'type' | 'status'>,
+  context: { purchase?: { logistics: Pick<VehiclePurchase['logistics'], 'status'> } } = {},
 ): boolean => {
   if (transport.type === TransportType.Sale) {
-    return context.opportunity?.deliveredAt != null;
+    return transport.status === TransportStatus.Done;
   }
 
   return context.purchase != null && hasPurchaseArrived(context.purchase);
 };
 
-/** The same question asked of a search document, which already carries both sides. */
+/** The same question asked of a search document, which already carries the purchase. */
 export const isSearchTransportCompleted = (
   record: PickFieldIds<
     SearchTransport,
-    'transport.type' | 'opportunity.deliveredAt' | 'purchase.logistics.status'
+    'transport.type' | 'transport.status' | 'purchase.logistics.status'
   >,
-): boolean =>
-  isTransportCompleted(record.transport, {
-    opportunity: record.opportunity,
-    purchase: record.purchase,
-  });
+): boolean => isTransportCompleted(record.transport, { purchase: record.purchase });
+
+export type TransportDocumentOwner = {
+  businessEntityId: BusinessEntityIds.Opportunities | BusinessEntityIds.Vehicles;
+  recordId: string;
+};
+
+/**
+ * Where a transport's documents are filed. A transport owns none: a sale's belong to the deal and a
+ * purchase's to the vehicle, whose purchase tab lists them. Undefined for a sale without a deal.
+ */
+export const getTransportDocumentOwner = (
+  transport: Pick<Transport, 'type' | 'vehicleId' | 'opportunityId'>,
+): TransportDocumentOwner | undefined => {
+  if (isPurchaseTransport(transport)) {
+    return { businessEntityId: BusinessEntityIds.Vehicles, recordId: transport.vehicleId };
+  }
+
+  return transport.opportunityId == null
+    ? undefined
+    : { businessEntityId: BusinessEntityIds.Opportunities, recordId: transport.opportunityId };
+};