chnages

apps/edr-freight-api/src/modules/billing/eims-invoice.mapper.spec.ts

@@ -60,6 +60,8 @@ const context = (over: Partial<EimsMapperContext> = {}): EimsMapperContext => ({
   unitDefault: "PCS",
   incomeWithholdValue: 0,
   transactionWithholdValue: 0,
+  buyerRegionCodes: { "Addis Ababa": "13" },
+  buyerWeredaCodes: {},
   ...over,
 });
 
@@ -130,7 +132,7 @@ describe("toEimsInvoice", () => {
       ExciseTaxValue: 0,
       TotalLineAmount: 11500,
       Unit: "PCS",
-      NatureOfSupplies: "Service",
+      NatureOfSupplies: "service",
       HarmonizationCode: null,
     });
     expect(doc.ItemList[1]).toMatchObject({
@@ -207,6 +209,77 @@ describe("toEimsInvoice", () => {
   });
 });
 
+describe("toEimsInvoice — MoR field constraints", () => {
+  it("passes a buyer region through when it is already a MoR code", () => {
+    const doc = toEimsInvoice(invoice(), seller, context());
+    expect(doc.BuyerDetails.Region).toBe("13");
+  });
+
+  it("maps a region name to its code, ignoring case and spacing", () => {
+    const doc = toEimsInvoice(
+      invoice({ company: { ...invoice().company!, region: "  addis   ababa " } }),
+      seller,
+      context({ buyerRegionCodes: { "Addis Ababa": "13" } }),
+    );
+    expect(doc.BuyerDetails.Region).toBe("13");
+  });
+
+  it("refuses to file a buyer whose region has no mapping", () => {
+    expect(() =>
+      toEimsInvoice(
+        invoice({ company: { ...invoice().company!, region: "Somewhere Else" } }),
+        seller,
+        context(),
+      ),
+    ).toThrow(/not a MoR Region code and has no mapping/);
+  });
+
+  it("refuses a buyer with no region at all rather than guessing one", () => {
+    expect(() =>
+      toEimsInvoice(
+        invoice({ company: { ...invoice().company!, region: null } }),
+        seller,
+        context(),
+      ),
+    ).toThrow(/buyer Region \(unset\)/);
+  });
+
+  it("passes a buyer wereda through when it is already a MoR code", () => {
+    const doc = toEimsInvoice(invoice(), seller, context());
+    expect(doc.BuyerDetails.Wereda).toBe("574");
+  });
+
+  it("maps a wereda name to its code", () => {
+    const doc = toEimsInvoice(
+      invoice({ company: { ...invoice().company!, woreda: "Yeka" } }),
+      seller,
+      context({ buyerWeredaCodes: { Yeka: "99" } }),
+    );
+    expect(doc.BuyerDetails.Wereda).toBe("99");
+  });
+
+  it("refuses to file a buyer whose wereda has no mapping", () => {
+    expect(() =>
+      toEimsInvoice(
+        invoice({ company: { ...invoice().company!, woreda: "Yeka" } }),
+        seller,
+        context({ buyerWeredaCodes: {} }),
+      ),
+    ).toThrow(/buyer Wereda "Yeka".*EIMS_BUYER_WEREDA_CODES/);
+  });
+
+  it("emits NatureOfSupplies lowercase, whatever case it was configured in", () => {
+    const doc = toEimsInvoice(invoice(), seller, context({ natureOfSupplies: "Service" }));
+    expect(doc.ItemList[0].NatureOfSupplies).toBe("service");
+  });
+
+  it("rejects a NatureOfSupplies MoR does not accept", () => {
+    expect(() =>
+      toEimsInvoice(invoice(), seller, context({ natureOfSupplies: "Services" })),
+    ).toThrow(/must be one of goods, service/);
+  });
+});
+
 describe("formatEimsDate", () => {
   it("renders the observed dd-MM-yyyyTHH:mm:ss shape with zero padding", () => {
     expect(formatEimsDate(new Date(2025, 2, 21, 0, 0, 0))).toBe("21-03-2025T00:00:00");

apps/edr-freight-api/src/modules/billing/eims-invoice.mapper.ts

@@ -210,6 +210,22 @@ export interface EimsMapperContext {
   relatedDocument?: string | null;
   /** MoR numeric country code for the buyer; our DB stores the country name. */
   buyerCountryCode?: string | null;
+  /**
+   * Region name → MoR numeric code, for buyers whose stored region is free text.
+   *
+   * `companies.region` holds names ("Addis Ababa") while MoR validates `BuyerDetails.Region`
+   * against `^[0-9]{1,3}$`. A stored value that is already a code passes through; anything else
+   * must be in this map or the mapping **fails locally** — sending a guessed region code onto a
+   * tax document is worse than refusing to file.
+   */
+  buyerRegionCodes: Record<string, string>;
+  /**
+   * Wereda name → MoR code, same shape as `buyerRegionCodes`. `companies.woreda` holds names
+   * ("Yeka") or codes inconsistently; unlike Region, MoR has never named a Wereda regex in an
+   * error, so this is precautionary rather than confirmed — but the fix is identical either way:
+   * fail locally on an unmapped name rather than file a guess.
+   */
+  buyerWeredaCodes: Record<string, string>;
   buyerIdType?: string | null;
   buyerIdNumber?: string | null;
   buyerCity?: string | null;
@@ -220,6 +236,22 @@ export interface EimsMapperContext {
   formatDate?: (issuedAt: Date) => string;
 }
 
+/**
+ * MoR's own constraint on `Region`: one to three digits, confirmed by its 400 SCHEMA ERROR. Reused
+ * as the pass-through test for `Wereda` too — every Wereda value MoR has actually shown us (seller
+ * "12"/"13", the collection's "574") fits the same shape, though MoR has not named a Wereda regex
+ * the way it named Region's.
+ */
+const LOCATION_CODE = /^[0-9]{1,3}$/;
+
+/**
+ * The only two values MoR accepts for `NatureOfSupplies`, lowercase.
+ *
+ * Its schema branches on this as a `oneOf` with a `const` per branch, so `"Service"` fails the
+ * whole `ItemList` — the error reads "must be the constant value 'service'".
+ */
+const NATURE_OF_SUPPLIES = ["goods", "service"] as const;
+
 const num = (v: number | string): number => {
   const n = Number(v);
   if (!Number.isFinite(n)) throw new Error(`EIMS mapping: expected a numeric value, got ${String(v)}`);
@@ -240,6 +272,33 @@ export const formatEimsDate = (issuedAt: Date): string =>
  * an unissued invoice, unresolved line tax, a line/total mismatch, or a non-ETB invoice with no
  * exchange rate.
  */
+/**
+ * A buyer's location value (Region or Wereda) as a MoR code: passed through when already numeric,
+ * otherwise looked up by name (case- and space-insensitive). Throws when neither applies — sending
+ * a guessed code onto a tax document is worse than refusing to file.
+ */
+function resolveLocationCode(
+  field: "Region" | "Wereda",
+  value: string | null | undefined,
+  codes: Record<string, string>,
+  envVar: string,
+  invoiceNumber: string,
+): string {
+  const raw = (value ?? "").trim();
+  if (LOCATION_CODE.test(raw)) return raw;
+
+  const key = raw.toLowerCase().replace(/\s+/g, " ");
+  const mapped = Object.entries(codes).find(
+    ([name]) => name.trim().toLowerCase().replace(/\s+/g, " ") === key,
+  )?.[1];
+  if (mapped && LOCATION_CODE.test(mapped)) return mapped;
+
+  throw new Error(
+    `EIMS mapping: invoice ${invoiceNumber} has buyer ${field} ${raw ? `"${raw}"` : "(unset)"}, ` +
+      `which is not a MoR ${field} code and has no mapping. Add it to ${envVar}.`,
+  );
+}
+
 export function toEimsInvoice(
   invoice: EimsMapperInvoice,
   seller: EimsSellerDetails,
@@ -266,6 +325,14 @@ export function toEimsInvoice(
     throw new Error(`EIMS mapping: invoice ${invoice.invoiceNumber} has an unparseable issuedAt`);
   }
 
+  const natureOfSupplies = context.natureOfSupplies.trim().toLowerCase();
+  if (!NATURE_OF_SUPPLIES.includes(natureOfSupplies as (typeof NATURE_OF_SUPPLIES)[number])) {
+    throw new Error(
+      `EIMS mapping: NatureOfSupplies must be one of ${NATURE_OF_SUPPLIES.join(", ")}, ` +
+        `got "${context.natureOfSupplies}"`,
+    );
+  }
+
   const ItemList: EimsInvoiceItem[] = invoice.lines.map((line, index) => {
     const lineNumber = index + 1;
     const tax = context.taxForLine(line, lineNumber);
@@ -285,7 +352,7 @@ export function toEimsInvoice(
       Discount: 0,
       ExciseTaxValue,
       HarmonizationCode: null,
-      NatureOfSupplies: context.natureOfSupplies,
+      NatureOfSupplies: natureOfSupplies,
       ItemCode: line.chargeType,
       ProductDescription: line.description?.trim() || line.chargeType,
       PreTaxValue,
@@ -329,12 +396,24 @@ export function toEimsInvoice(
       Tin: company.tin,
       LegalName: company.name,
       Phone: company.phone ?? null,
-      Region: company.region ?? null,
+      Region: resolveLocationCode(
+        "Region",
+        company.region,
+        context.buyerRegionCodes,
+        "EIMS_BUYER_REGION_CODES",
+        invoice.invoiceNumber,
+      ),
       Country: context.buyerCountryCode ?? null,
       Zone: company.zone ?? null,
       Kebele: company.kebele ?? null,
       VatNumber: company.vatNumber ?? null,
-      Wereda: company.woreda ?? null,
+      Wereda: resolveLocationCode(
+        "Wereda",
+        company.woreda,
+        context.buyerWeredaCodes,
+        "EIMS_BUYER_WEREDA_CODES",
+        invoice.invoiceNumber,
+      ),
     },
     DocumentDetails: {
       DocumentNumber: context.documentNumber,

apps/edr-freight-api/src/modules/billing/entities/invoice.entity.ts

@@ -115,6 +115,10 @@ export class Invoice extends BaseEntity {
   @Column({ name: "eims_irn", type: "varchar", length: 64, nullable: true })
   eimsIrn?: string | null;
 
+  /** The numeric `DocumentDetails.DocumentNumber` filed for this invoice. */
+  @Column({ name: "eims_document_number", type: "varchar", length: 16, nullable: true })
+  eimsDocumentNumber?: string | null;
+
   /** The `SourceSystem.InvoiceCounter` this invoice consumed. */
   @Column({ name: "eims_invoice_counter", type: "bigint", nullable: true })
   eimsInvoiceCounter?: number | null;