u

src/store/shipping/create.js

@@ -1,7 +1,7 @@
 import { queriesFor, requireId, requireText } from '../logistics/helpers.js';
 import resolveSelectedCompanyAccess from '../companyuser/resolveSelectedCompanyAccess.js';
-import resolveManifestAccess from '../manifestattachment/resolveManifestAccess.js';
 import nextNumber from '../numbers/nextNumber.js';
+import ledgerAdd from '../ledger/add.js';
 import makeRunner from '../runner.js';
 
 function shape(row) {
@@ -16,37 +16,60 @@ function shape(row) {
 
 export default function create(provider) {
   const access = resolveSelectedCompanyAccess(provider);
-  const manifestAccess = resolveManifestAccess(provider);
   const allocateNumber = nextNumber(provider);
+  const addLedger = ledgerAdd(provider);
   const q = queriesFor(provider);
 
   /**
    * Creates a shipping for a manifest (order). The number is allocated from the
-   * `shipping` numbers sequence (own prefix + counter).
+   * `shipping` numbers sequence (own prefix + counter). If state is 'shipped',
+   * adjusts stock by appending negative ledger movements for tracked order lines,
+   * writes article history, and ensures the order was not already shipped.
    *
    * @param {number} googleAuthId - The id of the Google auth user.
    * @param {object} input - Shipping input.
    * @param {number} input.manifestId - The manifest (order) id.
    * @param {string} input.type - Shipping type.
-   * @param {string} input.state - Shipping state.
+   * @param {string} input.state - Shipping state ('shipped' or other).
+   * @param {number} [input.warehouseId] - Optional warehouse ID for stock deduction (defaults to company's first warehouse).
    * @param {object} [tx] - Optional transaction to run within.
    * @returns {Promise<{id: number, manifestId: number, number: string, type: string, state: string}>}
-   * @throws {Error} If manifest is not found or input is invalid.
+   * @throws {Error} If manifest is not found, order already shipped, or input is invalid.
    *
    * @example
-   * await store.shipping.create(googleAuthId, { manifestId: 42, type: 'parcel', state: 'open' });
+   * await store.shipping.create(googleAuthId, { manifestId: 42, type: 'parcel', state: 'shipped' });
    */
   return async (googleAuthId, input = {}, tx) => {
     const manifestId = requireId(input.manifestId, 'Manifest');
     const type = requireText(input.type, 'Shipping type');
     const state = requireText(input.state, 'Shipping state');
+    const isShipped = state.trim().toLowerCase() === 'shipped';
 
     const run = async (runner, innerTx) => {
       const { companyId } = await access(googleAuthId, runner);
-      await manifestAccess(companyId, manifestId, innerTx);
 
+      // Verify manifest exists and belongs to company
+      const manifestRes = await runner.query(q.GET_MANIFEST_HEADER_BY_ID, {
+        manifestId,
+        companyId,
+      });
+      const manifest = manifestRes.rows[0];
+      if (!manifest) {
+        throw new Error('Manifest not found');
+      }
+
+      if (isShipped) {
+        // Check if order was already shipped
+        const shippedCheck = await runner.query(q.CHECK_ORDER_SHIPPED, {
+          manifestId,
+        });
+        if (shippedCheck.rows[0]) {
+          throw new Error('Order already shipped');
+        }
+      }
+
+      // Allocate shipping number and insert shipping record
       const number = await allocateNumber(companyId, 'shipping', innerTx);
-
       const result = await runner.query(q.SHIPPING_CREATE, {
         manifestId,
         number,
@@ -60,12 +83,83 @@ export default function create(provider) {
         type,
         state,
       };
+
+      if (isShipped) {
+        // Load order lines
+        const linesRes = await runner.query(q.GET_ORDER_LINES_FOR_SHIPPING, {
+          manifestId,
+        });
+        const lines = linesRes.rows ?? [];
+
+        // Check which lines need warehouse stock deduction
+        const trackedLines = [];
+        for (const line of lines) {
+          const sku = line.sku ? String(line.sku).trim() : '';
+          const amount = Number(line.amount);
+          if (!sku || !Number.isFinite(amount) || amount <= 0) {
+            continue;
+          }
+
+          const trackRes = await runner.query(q.CHECK_ARTICLE_TRACK_STOCK, {
+            companyId,
+            sku,
+          });
+          const isUntracked = (trackRes.rows ?? []).some(
+            (r) => Number(r.track_stock ?? 1) === 0
+          );
+          if (!isUntracked && (trackRes.rows ?? []).length > 0) {
+            trackedLines.push({ ...line, amount });
+          }
+        }
+
+        if (trackedLines.length > 0) {
+          let warehouseId = null;
+          if (input.warehouseId != null) {
+            const requestedWhId = requireId(input.warehouseId, 'Warehouse');
+            const whCheck = await runner.query(q.CHECK_WAREHOUSE, {
+              warehouseId: requestedWhId,
+              companyId,
+            });
+            if (!whCheck.rows[0]) {
+              throw new Error('Warehouse not found');
+            }
+            warehouseId = requestedWhId;
+          } else {
+            const defaultWh = await runner.query(q.GET_DEFAULT_WAREHOUSE, {
+              companyId,
+            });
+            if (!defaultWh.rows[0]) {
+              throw new Error('Warehouse not found');
+            }
+            warehouseId = defaultWh.rows[0].id;
+          }
+
+          const manifestNumber = manifest.number || String(manifestId);
+          for (const line of trackedLines) {
+            await addLedger(
+              googleAuthId,
+              {
+                manifestarticle_id: line.id,
+                warehouse_id: warehouseId,
+                transaction_type: 'SHIPPING',
+                amount: -line.amount,
+                transaction_text: `Versand Auftrag ${manifestNumber}`,
+              },
+              innerTx,
+            );
+          }
+        }
+      }
+
       return shape(row);
     };
 
+    if (tx) {
+      return run(makeRunner(provider, tx), tx);
+    }
     if (typeof provider?.transaction === 'function') {
       return provider.transaction((runner, innerTx) => run(runner, innerTx));
     }
-    return run(makeRunner(provider, tx));
+    return run(makeRunner(provider));
   };
 }