@pisell/pisellos 2.3.154 → 2.3.156

package/dist/solution/BookingByStep/index.d.ts

@@ -328,7 +328,7 @@ export declare class BookingByStepImpl extends BaseModule implements Module {
         date: string;
         status: string;
         week: string;
-        weekNum: 0 | 1 | 2 | 3 | 5 | 4 | 6;
+        weekNum: 0 | 5 | 3 | 1 | 2 | 4 | 6;
     }[]>;
     submitTimeSlot(timeSlots: TimeSliceItem): void;
     private getScheduleDataByIds;

package/lib/modules/Order/index.d.ts

@@ -595,7 +595,7 @@ export declare class OrderModule extends BaseModule implements Module, OrderModu
     generateIdempotencyToken(): string;
     syncPaymentsToOrder<T = any>(params: SyncPaymentsToOrderParams): Promise<SyncPaymentsToOrderResult<T>>;
     createOrder(params: CommitOrderParams['query']): {
-        type: "virtual" | "appointment_booking";
+        type: "appointment_booking" | "virtual";
         platform: string;
         sales_channel: string;
         order_sales_channel: string;

package/lib/modules/Order/index.js

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "isFulfillmentTimingBooking", {
   }
 });
 var _loadSalesOrderSnapshot = require("../../shared/sales/loadSalesOrderSnapshot");
+var _localEftposState = require("./localEftposState");
 var _BaseModule = require("../BaseModule");
 var _types = require("./types");
 var _utils = require("./utils");
@@ -3173,6 +3174,18 @@ class OrderModule extends _BaseModule.BaseModule {
     const matchMode = options.matchBy === 'compat' || options.matchBy === 'legacy' ? 'compat' : 'payment_number';
     const matchedPayment = (0, _paymentUtils.resolveOrderPaymentIdentity)(tempOrder.payments || [], identity, matchMode);
     if (!matchedPayment) {
+      try {
+        void Promise.resolve(this.logger?.addLog?.({
+          type: 'warning',
+          title: '[PaymentTrace] payment-missing',
+          metadata: {
+            moduleName: this.name,
+            saleId: tempOrder.external_sale_number,
+            paymentNumber: identity,
+            currentPaymentNumbers: (tempOrder.payments || []).map(p => p.payment_number)
+          }
+        })).catch(() => {});
+      } catch {/* 日志失败不影响原异常。 */}
       throw new Error(`未找到支付项: ${identity}`);
     }
     let updatedPayment = null;
@@ -4716,6 +4729,7 @@ class OrderModule extends _BaseModule.BaseModule {
   }
   async runSubmitTempOrder(params) {
     const tempOrder = this.ensureTempOrder();
+    if ((0, _localEftposState.requiresLocalPaymentRefresh)(tempOrder)) throw new Error(_localEftposState.PAYMENT_REFRESH_MESSAGE);
     this.prepareVirtualSettlementTempOrder(tempOrder);
     const isOnlineStorePlatform = this.isOnlineStorePlatform();
     const shouldConfirmPendingVoucherPayments = params?.confirmPendingVoucherPayments !== false;
@@ -5190,7 +5204,7 @@ class OrderModule extends _BaseModule.BaseModule {
       query
     } = params;
     const fetchUrl = url || '/order/sales/checkout';
-    const requestQuery = this.isSalesCheckoutHandledByOsServer(fetchUrl) ? query : (0, _osPrivatePayload.stripOsPrivatePayloadFields)(query);
+    const requestQuery = this.isSalesCheckoutHandledByOsServer(fetchUrl) ? query : (0, _localEftposState.stripLocalEftposState)((0, _osPrivatePayload.stripOsPrivatePayloadFields)(query));
     return this.request.post(fetchUrl, requestQuery, {
       osServer: true,
       customToast: () => {}

package/lib/modules/Order/localEftposState.d.ts

@@ -0,0 +1,13 @@
+/** Local reconciliation state; never part of a cloud checkout payload. */
+export declare const LOCAL_EFTPOS_REFRESH_REQUIRED = "_local_eftpos_refresh_required";
+export declare const LOCAL_EFTPOS_FINALIZED = "_local_eftpos_finalized";
+export declare const PAYMENT_REFRESH_MESSAGE = "\u8BA2\u5355\u9700\u8981\u5237\u65B0\uFF0C\u8BF7\u8054\u7F51\u5237\u65B0\u8BA2\u5355\u540E\u518D\u4ED8\u6B3E";
+export interface LocalEftposFinalization {
+    saleId: string | number;
+    paymentNumber: string;
+    result: 'failed' | 'not_started';
+    failedTransactionNumbers: string[];
+}
+export declare function requiresLocalPaymentRefresh(order: any): boolean;
+export declare function isLocalFinalizedPayment(payment: any): boolean;
+export declare function stripLocalEftposState<T extends Record<string, any>>(order: T): T;

package/lib/modules/Order/localEftposState.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PAYMENT_REFRESH_MESSAGE = exports.LOCAL_EFTPOS_REFRESH_REQUIRED = exports.LOCAL_EFTPOS_FINALIZED = void 0;
+exports.isLocalFinalizedPayment = isLocalFinalizedPayment;
+exports.requiresLocalPaymentRefresh = requiresLocalPaymentRefresh;
+exports.stripLocalEftposState = stripLocalEftposState;
+/** Local reconciliation state; never part of a cloud checkout payload. */
+const LOCAL_EFTPOS_REFRESH_REQUIRED = exports.LOCAL_EFTPOS_REFRESH_REQUIRED = '_local_eftpos_refresh_required';
+const LOCAL_EFTPOS_FINALIZED = exports.LOCAL_EFTPOS_FINALIZED = '_local_eftpos_finalized';
+const PAYMENT_REFRESH_MESSAGE = exports.PAYMENT_REFRESH_MESSAGE = '订单需要刷新，请联网刷新订单后再付款';
+function requiresLocalPaymentRefresh(order) {
+  return order?.metadata?.[LOCAL_EFTPOS_REFRESH_REQUIRED] === true;
+}
+function isLocalFinalizedPayment(payment) {
+  return payment?.status === 'voided' && payment?.metadata?.[LOCAL_EFTPOS_FINALIZED] === true;
+}
+function stripLocalEftposState(order) {
+  const result = {
+    ...order
+  };
+  if (order.metadata) {
+    result.metadata = {
+      ...order.metadata
+    };
+    delete result.metadata[LOCAL_EFTPOS_REFRESH_REQUIRED];
+  }
+  if (Array.isArray(order.payments)) {
+    result.payments = order.payments.filter(payment => !isLocalFinalizedPayment(payment)).map(payment => {
+      if (!payment.metadata?.[LOCAL_EFTPOS_FINALIZED]) return payment;
+      const metadata = {
+        ...payment.metadata
+      };
+      delete metadata[LOCAL_EFTPOS_FINALIZED];
+      return {
+        ...payment,
+        metadata
+      };
+    });
+  }
+  return result;
+}

package/lib/server/index.d.ts

@@ -499,6 +499,7 @@ declare class Server {
     private buildLocalPaymentSurchargeUpdate;
     private handleGetLocalPayment;
     private handleUpdateLocalPayment;
+    private handleFinalizeLocalEftposPayment;
     private runLocalPaymentUpdateInQueue;
     private processLocalPaymentUpdate;
     private processSuccessfulLocalPayment;

package/lib/server/index.js

@@ -7,6 +7,7 @@ var _exportNames = {};
 exports.default = void 0;
 var _dayjs = _interopRequireDefault(require("dayjs"));
 var _decimal = _interopRequireDefault(require("decimal.js"));
+var _localEftposState = require("../modules/Order/localEftposState");
 var _lodashEs = require("lodash-es");
 var _products = require("./modules/products");
 var _menu = require("./modules/menu");
@@ -646,7 +647,7 @@ class Server {
     const normalizedData = await this.normalizeCheckoutSubmitData(params.data, title);
     const numberedData = await this.ensureCheckoutOrderNumbers(normalizedData, title);
     const checkoutData = this.normalizeCheckoutCollections((0, _osPrivatePayload.stripOsPrivatePayloadFields)(this.applyCheckoutFulfillmentBuzzer(numberedData, title)));
-    const remoteCheckoutData = this.buildRemoteCheckoutData(checkoutData, title);
+    const remoteCheckoutData = (0, _localEftposState.stripLocalEftposState)(this.buildRemoteCheckoutData(checkoutData, title));
     const deviceHeaders = await this.buildCheckoutDeviceHeaders(title);
     if (!this.app?.request?.post) {
       throw new Error('app.request 不可用');
@@ -784,7 +785,7 @@ class Server {
     }
     const freshPayments = freshRecord.payments;
     const mergedPayments = (0, _paymentUtils.mergeOrderPaymentListsByIdentity)(localPayments, freshPayments, {
-      preserveUnmatchedExistingWhen: _paymentUtils.isIdentifiedPendingOrderPayment
+      preserveUnmatchedExistingWhen: payment => (0, _paymentUtils.isIdentifiedPendingOrderPayment)(payment) || (0, _localEftposState.isLocalFinalizedPayment)(payment)
     });
     const remoteIdentityKeys = new Set(freshPayments.flatMap(payment => (0, _paymentUtils.getOrderPaymentIdentityKeys)(payment)));
     const preservedPending = localPayments.filter(payment => (0, _paymentUtils.isIdentifiedPendingOrderPayment)(payment) && !(0, _paymentUtils.getOrderPaymentIdentityKeys)(payment).some(key => remoteIdentityKeys.has(key)));
@@ -1337,6 +1338,19 @@ class Server {
       method: 'post',
       path: '/shop/local/updateLocalPayment',
       handler: this.handleUpdateLocalPayment.bind(this)
+    }, {
+      method: 'post',
+      path: '/shop/local/finalizeLocalEftposPayment',
+      handler: this.handleFinalizeLocalEftposPayment.bind(this)
+    }, {
+      method: 'post',
+      path: '/shop/local/orderPaymentReadiness',
+      handler: async ({
+        data
+      }) => ({
+        code: 200,
+        data: await this.order?.getLocalOrderByLookup(data?.sale_id)
+      })
     }, {
       method: 'post',
       path: '/shop/machinecode/batch',
@@ -2998,7 +3012,7 @@ class Server {
         data: null
       };
     }
-    const queueKey = `${String(saleId)}:${String(paymentNumber)}`;
+    const queueKey = String(saleId);
     return this.runLocalPaymentUpdateInQueue(queueKey, () => this.processLocalPaymentUpdate({
       operationId,
       saleId,
@@ -3010,6 +3024,42 @@ class Server {
       hasSurchargeInput
     }), requestContext);
   };
+  handleFinalizeLocalEftposPayment = async ({
+    data
+  }) => {
+    const {
+      sale_id: saleId,
+      payment_number: paymentNumber,
+      result,
+      failed_transaction_numbers: numbers = []
+    } = data || {};
+    if (!saleId || !paymentNumber || !Array.isArray(numbers) || numbers.some(number => typeof number !== 'string' || !number.trim()) || result !== 'failed' && result !== 'not_started' || result === 'failed' && numbers.length === 0 || result === 'not_started' && numbers.length !== 0) {
+      return {
+        code: 400,
+        status: false,
+        message: '缺少明确的支付结果或交易编号',
+        data: null
+      };
+    }
+    return this.runLocalPaymentUpdateInQueue(String(saleId), async () => {
+      if (!this.order) throw new Error('Order 模块未注册');
+      const finalized = await this.order.finalizeLocalEftposPayment({
+        saleId,
+        paymentNumber,
+        result,
+        failedTransactionNumbers: [...new Set(numbers)]
+      });
+      return {
+        code: 200,
+        status: true,
+        local_only: true,
+        data: finalized
+      };
+    }, {
+      sale_id: saleId,
+      payment_number: paymentNumber
+    });
+  };
   async runLocalPaymentUpdateInQueue(key, task, context) {
     const queuedAt = Date.now();
     const hasPreviousTask = this.localPaymentUpdateQueues.has(key);
@@ -3769,7 +3819,7 @@ class Server {
         device_id: debugDeviceId,
         payload: {
           backendPath: params.backendPath,
-          data: params.data,
+          data: (0, _localEftposState.stripLocalEftposState)(params.data),
           invoice: this.normalizePrintInvoiceLayoutConfig(params.invoiceLayoutConfig),
           template_settings: this.normalizePrintInvoiceTemplateSettings(params.invoiceTemplateSettings),
           external_sale_number: params.data?.external_sale_number,
@@ -4324,6 +4374,16 @@ class Server {
       backendPath,
       title
     } = params;
+    const lookup = params.data?.order_id || params.data?.external_sale_number;
+    const localOrder = lookup && (await this.order?.getLocalOrderByLookup?.(lookup));
+    if ((0, _localEftposState.requiresLocalPaymentRefresh)(params.data) || (0, _localEftposState.requiresLocalPaymentRefresh)(localOrder)) {
+      return {
+        code: 409,
+        status: false,
+        message: _localEftposState.PAYMENT_REFRESH_MESSAGE,
+        data: null
+      };
+    }
     const extractedInvoice = this.extractInvoiceLayoutConfig(params.data, {
       includePublicInvoice: true
     });
@@ -5072,7 +5132,15 @@ class Server {
           order: null
         };
       }
-      await this.order.upsertOrdersFromRemote([fresh]);
+      const localBeforeRefresh = this.order.getLocalOrderFromMemoryByLookup?.(lookup) || (this.shouldForceRemoteSalesDetail(data) ? await this.order.getLocalOrderByLookup(lookup) : null);
+      if ((0, _localEftposState.requiresLocalPaymentRefresh)(localBeforeRefresh)) {
+        if (String(fresh.order_id) !== String(localBeforeRefresh.order_id)) {
+          throw new Error('远端订单身份不匹配，请重新刷新');
+        }
+        await this.order.completeLocalPaymentRefresh(fresh);
+      } else {
+        await this.order.upsertOrdersFromRemote([fresh]);
+      }
       let savedOrder = await this.order.getLocalOrderByLookup(lookup);
       if (!savedOrder && fresh.order_id !== undefined && fresh.order_id !== null && String(fresh.order_id) !== String(lookup)) {
         savedOrder = await this.order.getLocalOrderByLookup(fresh.order_id);

package/lib/server/modules/order/index.d.ts

@@ -123,11 +123,24 @@ export declare class OrderModule extends BaseModule implements Module {
         paymentNumber: OrderId;
         operationId?: string;
         updates: Record<string, any>;
+        finalizeUnsuccessful?: boolean;
     }): Promise<{
         order: OrderData;
         payment: Record<string, any>;
         previousPayment: Record<string, any>;
     } | null>;
+    finalizeLocalEftposPayment(params: {
+        saleId: OrderId;
+        paymentNumber: OrderId;
+        result: 'failed' | 'not_started';
+        failedTransactionNumbers: string[];
+    }): Promise<{
+        order: OrderData;
+        payment: Record<string, any>;
+        previousPayment: Record<string, any>;
+    } | null>;
+    /** Only a successful full detail GET may release the persisted payment gate. */
+    completeLocalPaymentRefresh(fresh: OrderData): Promise<OrderData>;
     loadOrdersByServer(options?: {
         trigger?: string;
     }): Promise<OrderData[]>;

package/lib/server/modules/order/index.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.OrderModule = void 0;
 var _lodashEs = require("lodash-es");
+var _localEftposState = require("../../../modules/Order/localEftposState");
 var _dayjs = _interopRequireDefault(require("dayjs"));
 var _BaseModule = require("../../../modules/BaseModule");
 var _orderCollectionIdentity = require("../../../modules/Order/utils/orderCollectionIdentity");
@@ -259,9 +260,9 @@ class OrderModule extends _BaseModule.BaseModule {
   mergeAuthoritativeOrderCollection(field, existing, incoming, uidRemaps = [], options = {}) {
     const kind = ORDER_COLLECTION_KIND_BY_FIELD[field];
     const existingItems = Array.isArray(existing) ? existing : [];
-    if (field === 'payments' && options.preserveIdentifiedPendingPayments) {
+    if (field === 'payments' && (options.preserveIdentifiedPendingPayments || existingItems.some(_localEftposState.isLocalFinalizedPayment))) {
       return (0, _paymentUtils.mergeOrderPaymentListsByIdentity)(existingItems, incoming, {
-        preserveUnmatchedExistingWhen: _paymentUtils.isIdentifiedPendingOrderPayment
+        preserveUnmatchedExistingWhen: payment => options.preserveIdentifiedPendingPayments === true && (0, _paymentUtils.isIdentifiedPendingOrderPayment)(payment) || (0, _localEftposState.isLocalFinalizedPayment)(payment)
       });
     }
     return incoming.map(incomingItem => {
@@ -753,6 +754,13 @@ class OrderModule extends _BaseModule.BaseModule {
       return null;
     }
     const previousPayment = (0, _lodashEs.cloneDeep)(found.payment);
+    if (params.finalizeUnsuccessful && (found.payment.status === 'paid' || found.payment.metadata?.transactions?.some(transaction => transaction.status === 'success') || (0, _localEftposState.isLocalFinalizedPayment)(found.payment))) {
+      return {
+        order: found.order,
+        payment: found.payment,
+        previousPayment
+      };
+    }
     const nextPayment = (0, _paymentUtils.mergeOrderPaymentRecord)(found.payment, {
       ...params.updates,
       updated_at: params.updates.updated_at || (0, _dayjs.default)().format('YYYY-MM-DD HH:mm:ss')
@@ -762,6 +770,13 @@ class OrderModule extends _BaseModule.BaseModule {
       payments: (found.order.payments || []).map((payment, index) => index === found.paymentIndex ? nextPayment : payment),
       updated_at: (0, _dayjs.default)().format('YYYY-MM-DD HH:mm:ss')
     };
+    if (params.finalizeUnsuccessful && this.hasRealOrderId(found.order) && Number(found.order.need_sync || 0) === 0 && !(nextOrder.payments || []).some(_paymentUtils.isPendingOrderPayment)) {
+      nextOrder.is_draft_order = 0;
+      nextOrder.metadata = {
+        ...nextOrder.metadata,
+        [_localEftposState.LOCAL_EFTPOS_REFRESH_REQUIRED]: true
+      };
+    }
     const paymentContext = {
       ...logContext,
       matched_by: found.matchedBy,
@@ -813,6 +828,60 @@ class OrderModule extends _BaseModule.BaseModule {
       previousPayment
     };
   }
+  async finalizeLocalEftposPayment(params) {
+    const found = await this.getLocalPayment(params);
+    if (!found) throw new Error('未找到本地支付记录');
+    const transactions = found.payment.metadata?.transactions || [];
+    if (transactions.some(transaction => transaction.status !== 'fail' && transaction.status !== 'success' && !params.failedTransactionNumbers.includes(String(transaction.number)))) {
+      throw new Error('仍有结果未知的交易，保留待确认支付');
+    }
+    if (params.result === 'not_started' && transactions.length > 0 && !(0, _localEftposState.isLocalFinalizedPayment)(found.payment) && found.payment.status !== 'paid') {
+      throw new Error('支付已有交易记录，不能按未发起交易结束');
+    }
+    return this.updateLocalPayment({
+      ...params,
+      finalizeUnsuccessful: true,
+      updates: {
+        status: 'voided',
+        metadata: {
+          [_localEftposState.LOCAL_EFTPOS_FINALIZED]: true,
+          transactions: params.failedTransactionNumbers.map(number => ({
+            number,
+            status: 'fail'
+          }))
+        }
+      }
+    });
+  }
+
+  /** Only a successful full detail GET may release the persisted payment gate. */
+  async completeLocalPaymentRefresh(fresh) {
+    const existing = await this.getLocalOrderByLookup(fresh.order_id);
+    if (!existing || !(0, _localEftposState.requiresLocalPaymentRefresh)(existing)) {
+      await this.upsertOrdersFromRemote([fresh]);
+      return (await this.getLocalOrderByLookup(fresh.order_id)) || fresh;
+    }
+    if (this.isPendingSyncOrder(existing) || this.isDraftOrder(existing) || (existing.payments || []).some(_paymentUtils.isPendingOrderPayment)) {
+      throw new Error('订单仍有未结束支付或待同步改动，暂不能刷新');
+    }
+    if (!Array.isArray(fresh.products) || !fresh.summary) {
+      throw new Error('远端订单详情不完整，请重新刷新');
+    }
+    const nextOrder = this.mergeOrderRecords(existing, this.normalizeRemoteSyncedOrder(fresh));
+    nextOrder.metadata = {
+      ...nextOrder.metadata
+    };
+    delete nextOrder.metadata[_localEftposState.LOCAL_EFTPOS_REFRESH_REQUIRED];
+    // Do not publish/clear the gate in memory until SQLite has accepted the full snapshot.
+    await this.updateOrderInSQLite(nextOrder, 'completeLocalPaymentRefresh', {
+      throwOnError: true
+    });
+    const index = this.findOrderIndexByIdentity(this.store.list, existing);
+    this.store.list = index < 0 ? [...this.store.list, nextOrder] : this.store.list.map((order, i) => i === index ? nextOrder : order);
+    this.syncOrdersMap();
+    await this.emitOrdersChanged([nextOrder], 'completeLocalPaymentRefresh');
+    return nextOrder;
+  }
   async loadOrdersByServer(options = {}) {
     let orderList = [];
     let hasFetchedRemoteSnapshot = false;
@@ -1997,7 +2066,7 @@ class OrderModule extends _BaseModule.BaseModule {
     return payments.filter(payment => (0, _paymentUtils.isIdentifiedPendingOrderPayment)(payment));
   }
   shouldProtectLocalOrderFromRemoteSnapshot(order) {
-    return this.isPendingSyncOrder(order) || this.isDraftOrder(order) || this.getIdentifiedPendingPayments(order).length > 0;
+    return this.isPendingSyncOrder(order) || this.isDraftOrder(order) || this.getIdentifiedPendingPayments(order).length > 0 || (0, _localEftposState.requiresLocalPaymentRefresh)(order) || (order.payments || []).some(_localEftposState.isLocalFinalizedPayment);
   }
   getUnmatchedIdentifiedPendingPayments(existing, incoming) {
     const existingPayments = Array.isArray(existing) ? existing : [];
@@ -2019,6 +2088,12 @@ class OrderModule extends _BaseModule.BaseModule {
     const secondaryRecord = secondary;
     const existingRecord = existing;
     const incomingRecord = incoming;
+    if ((0, _localEftposState.requiresLocalPaymentRefresh)(existing)) {
+      mergedRecord.metadata = {
+        ...mergedRecord.metadata,
+        [_localEftposState.LOCAL_EFTPOS_REFRESH_REQUIRED]: true
+      };
+    }
     const childUidRemaps = [];
     for (const field of fieldsToPreserve) {
       if (!this.isBlankIdentityValue(preferredRecord[field])) {

package/lib/solution/BaseSales/index.d.ts

@@ -1,5 +1,6 @@
 import { Module, ModuleOptions, PisellCore } from '../../types';
 import { BaseModule } from '../../modules/BaseModule';
+import { type LocalEftposFinalization } from '../../modules/Order/localEftposState';
 import { BaseSalesOrderProduct, BaseSalesOrderProductIdentity, BaseSalesPaymentStatus, BaseSalesSubmitSalesOrderParams, BaseSalesUpdateOrderProductQuantityParams, BaseSalesCalculateProductBookingPriceParams, BaseSalesPriceRecalculationContextChange, BaseSalesProductBookingPriceResult, BaseSalesQuotationCustomerScopeInfo, BaseSalesScanCodeResult, BaseSalesCashPaymentOptions, BaseSalesCashPaymentConfig, BaseSalesPayCashParams, BaseSalesPayCashResult, BaseSalesCommitPaymentMethodParams, BaseSalesCommitPaymentMethodResult, BaseSalesConfirmWalletPaymentResult } from './types';
 import { OrderModule } from '../../modules/Order';
 import { type PickupTimingBookingInput } from '../../modules/Order/pickupTiming';
@@ -105,6 +106,7 @@ export declare class BaseSalesImpl extends BaseModule implements Module {
     private isCurrentSalesOrderRecord;
     setServerOrderChangeSyncEnabled(enabled: boolean): void;
     private queueLatestServerOrderChange;
+    private shouldSyncServerOrderChanges;
     private drainQueuedServerOrderChanges;
     private syncCurrentSalesDetailFromServerOrderChange;
     private registerServerOrderChangeSync;
@@ -353,6 +355,10 @@ export declare class BaseSalesImpl extends BaseModule implements Module {
      * payments 会交给 OrderModule 统一映射为 Sales 协议支付项。
      */
     submitSalesOrder<T = any>(params?: BaseSalesSubmitSalesOrderParams): Promise<T>;
+    private pendingLocalEftposFinalizations;
+    finalizeLocalEftposPayment(params: LocalEftposFinalization): Promise<any>;
+    /** Entry gate also reads SQLite state, so stale sessions/restarts cannot bypass it. */
+    ensureSalesOrderReadyForPayment(): Promise<void>;
     saveSalesOrderDraft<T = any>(params?: {
         platform?: string;
         businessCode?: string;

package/lib/solution/BaseSales/index.js

@@ -8,6 +8,7 @@ var _exportNames = {
 };
 exports.BaseSalesImpl = void 0;
 var _BaseModule = require("../../modules/BaseModule");
+var _localEftposState = require("../../modules/Order/localEftposState");
 var _types = require("./types");
 Object.keys(_types).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -590,8 +591,12 @@ class BaseSalesImpl extends _BaseModule.BaseModule {
     }
     this.queuedServerOrderChanges.push(snapshot);
   }
+  shouldSyncServerOrderChanges() {
+    const payments = this.store.order?.getTempOrder()?.payments || [];
+    return this.serverOrderChangeSyncEnabled || payments.some(_localEftposState.isLocalFinalizedPayment) && !payments.some(_paymentUtils.isPendingOrderPayment);
+  }
   async drainQueuedServerOrderChanges() {
-    if (!this.serverOrderChangeSyncEnabled || this.salesDetailLoadInFlightCount > 0 || this.serverOrderChangeHydrateInFlight || this.queuedServerOrderChanges.length === 0) return;
+    if (!this.shouldSyncServerOrderChanges() || this.salesDetailLoadInFlightCount > 0 || this.serverOrderChangeHydrateInFlight || this.queuedServerOrderChanges.length === 0) return;
     const changedOrders = this.queuedServerOrderChanges;
     this.queuedServerOrderChanges = [];
     await this.syncCurrentSalesDetailFromServerOrderChange({
@@ -599,8 +604,9 @@ class BaseSalesImpl extends _BaseModule.BaseModule {
     });
   }
   async syncCurrentSalesDetailFromServerOrderChange(payload) {
-    const changedOrders = Array.isArray(payload) ? payload : Array.isArray(payload?.changedOrders) ? payload.changedOrders : payload?.data && typeof payload.data === 'object' ? [payload.data] : [];
-    if (!this.serverOrderChangeSyncEnabled) return;
+    const fullSnapshotAfterFinalization = Array.isArray(payload?.list) && this.store.order?.getTempOrder()?.payments?.some(_localEftposState.isLocalFinalizedPayment);
+    const changedOrders = Array.isArray(payload) ? payload : Array.isArray(payload?.changedOrders) && payload.changedOrders.length > 0 ? payload.changedOrders : fullSnapshotAfterFinalization ? payload.list : payload?.data && typeof payload.data === 'object' ? [payload.data] : [];
+    if (!this.shouldSyncServerOrderChanges()) return;
 
     // 显式详情加载期间 current 可能仍是上一单，先按订单身份 latest-only 缓存；
     // load 完成后再用新的 current 过滤，避免恰好到达的最新支付快照丢失。
@@ -1043,7 +1049,30 @@ class BaseSalesImpl extends _BaseModule.BaseModule {
         customerId: params.customerId,
         channel: params.channel
       });
-      return productIds.map(productId => productId === null ? null : productsById.get(productId) || null);
+      const shouldAlignSelectedVariantPrice = handledByOsServer && this.preferAuthoritativeProductQueryPrice();
+      return productIds.map((productId, index) => {
+        const authoritativeProduct = productId === null ? null : productsById.get(productId) || null;
+        if (!shouldAlignSelectedVariantPrice || !authoritativeProduct) return authoritativeProduct;
+        const selectedProduct = selectedProducts[index];
+        const selectedVariantId = this.getSelectedProductVariantId(selectedProduct);
+        if (!selectedVariantId || this.getSelectedProductVariantId(authoritativeProduct) === selectedVariantId) {
+          return authoritativeProduct;
+        }
+
+        // OS 返回的是目录商品；已命中的智能价格不能被规格基础价覆盖。
+        const appliedFields = authoritativeProduct._dataVariant?.appliedFields;
+        if (Array.isArray(appliedFields) && ['price', 'selling_price', 'original_price', 'base_price'].some(field => appliedFields.includes(field))) {
+          return authoritativeProduct;
+        }
+        const selectedVariant = Array.isArray(authoritativeProduct.variant) ? authoritativeProduct.variant.find(variant => Number(variant?.id) === selectedVariantId) : undefined;
+        const selectedPrice = [selectedVariant?.price, selectedVariant?.selling_price, selectedVariant?.base_price, params.priceQueries[index].fallback_price, selectedProduct.price, selectedProduct.selling_price, selectedProduct.original_price].find(value => (typeof value === 'number' || typeof value === 'string' && value.trim() !== '') && Number.isFinite(Number(value)));
+
+        // 每行独立保留所选规格价格（含 0 元），避免同商品多规格共用目录对象串价。
+        return selectedPrice === undefined ? authoritativeProduct : {
+          ...authoritativeProduct,
+          price: selectedPrice
+        };
+      });
     }
     const queryPayload = this.buildPriceQueryPayload({
       ids,
@@ -2728,6 +2757,102 @@ class BaseSalesImpl extends _BaseModule.BaseModule {
     };
     return this.shouldUseCheckoutSyncTask() ? this.store.order.submitTempOrder(submitParams) : this.store.order.submitTempOrderAsync(submitParams);
   }
+  pendingLocalEftposFinalizations = new Map();
+  async finalizeLocalEftposPayment(params) {
+    const key = `${params.saleId}:${params.paymentNumber}`;
+    // If SQLite rejects the write, retry this known result before another payment can start.
+    this.pendingLocalEftposFinalizations.set(key, params);
+    const response = await this.request.post('/local/finalizeLocalEftposPayment', {
+      sale_id: params.saleId,
+      payment_number: params.paymentNumber,
+      result: params.result,
+      failed_transaction_numbers: params.failedTransactionNumbers
+    }, {
+      osServer: true,
+      customToast: () => {}
+    });
+    if (response?.code !== 200 || !response?.data?.order) {
+      throw new Error(response?.message || '本地支付收尾失败，请刷新订单后重试');
+    }
+    this.pendingLocalEftposFinalizations.delete(key);
+    const {
+      order,
+      payment
+    } = response.data;
+    const temp = this.getTempOrder();
+    const isCurrentOrder = String(temp?.external_sale_number || temp?.order_id) === String(params.saleId) || temp?.order_id && String(temp.order_id) === String(order.order_id);
+    if (isCurrentOrder) {
+      // Persisted by the local route already. Saving a draft here would re-enable protection.
+      if (temp?.payments?.some(item => String(item.payment_number) === params.paymentNumber)) {
+        await this.updateOrderPayment(params.paymentNumber, payment, {
+          persistDraft: false,
+          submitWhenPaid: false
+        });
+      }
+      if ((0, _localEftposState.requiresLocalPaymentRefresh)(order)) {
+        // Set the in-memory gate before the GET so a failed refresh also blocks this page.
+        const currentTemp = this.getTempOrder();
+        if (currentTemp) currentTemp.metadata = {
+          ...currentTemp.metadata,
+          ...order.metadata
+        };
+        try {
+          await this.loadSalesDetail({
+            orderId: order.order_id,
+            forceRemote: true,
+            merge: false
+          });
+        } catch {
+          throw new Error(_localEftposState.PAYMENT_REFRESH_MESSAGE);
+        }
+      }
+    } else if ((0, _localEftposState.requiresLocalPaymentRefresh)(order)) {
+      const refreshed = await this.store.order?.getSalesOrderByLookup({
+        lookup: order.order_id,
+        forceRemote: true
+      });
+      if (refreshed?.code !== 200) throw new Error(_localEftposState.PAYMENT_REFRESH_MESSAGE);
+    }
+    return response.data;
+  }
+
+  /** Entry gate also reads SQLite state, so stale sessions/restarts cannot bypass it. */
+  async ensureSalesOrderReadyForPayment() {
+    const temp = this.getTempOrder();
+    const unfinished = [...this.pendingLocalEftposFinalizations.values()].filter(params => String(params.saleId) === String(temp?.external_sale_number) || String(params.saleId) === String(temp?.order_id));
+    if (unfinished.length > 0) {
+      for (const params of unfinished) await this.finalizeLocalEftposPayment(params);
+      throw new Error('订单已更新，请确认商品和金额后重新付款');
+    }
+    const lookup = temp?.order_id || temp?.external_sale_number;
+    let localOrder = null;
+    if (lookup && this.core?.server?.hasRoute?.('post', '/shop/local/orderPaymentReadiness')) {
+      const response = await this.request.post('/local/orderPaymentReadiness', {
+        sale_id: lookup
+      }, {
+        osServer: true,
+        customToast: () => {}
+      });
+      if (response?.code !== 200) throw new Error(_localEftposState.PAYMENT_REFRESH_MESSAGE);
+      localOrder = response.data;
+    }
+    if (!(0, _localEftposState.requiresLocalPaymentRefresh)(temp) && !(0, _localEftposState.requiresLocalPaymentRefresh)(localOrder)) return;
+    const orderId = localOrder?.order_id || temp?.order_id;
+    if (!orderId || String(orderId) === String(temp?.external_sale_number)) {
+      throw new Error(_localEftposState.PAYMENT_REFRESH_MESSAGE);
+    }
+    try {
+      await this.loadSalesDetail({
+        orderId,
+        forceRemote: true,
+        merge: false
+      });
+    } catch {
+      throw new Error(_localEftposState.PAYMENT_REFRESH_MESSAGE);
+    }
+    // The initiating UI may have captured the old amount before this await.
+    throw new Error('订单已刷新，请确认商品和金额后重新付款');
+  }
   async saveSalesOrderDraft(params) {
     if (!this.store.order) {
       throw new Error('BaseSales 解决方案需要 order 模块支持');

package/lib/solution/BookingByStep/index.d.ts

@@ -328,7 +328,7 @@ export declare class BookingByStepImpl extends BaseModule implements Module {
         date: string;
         status: string;
         week: string;
-        weekNum: 0 | 1 | 2 | 3 | 5 | 4 | 6;
+        weekNum: 0 | 5 | 3 | 1 | 2 | 4 | 6;
     }[]>;
     submitTimeSlot(timeSlots: TimeSliceItem): void;
     private getScheduleDataByIds;

package/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "@pisell/pisellos",
-  "version": "2.3.154",
+  "version": "2.3.156",
   "description": "一个可扩展的前端模块化SDK框架，支持插件系统",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",