@controleonline/ui-common 1.2.88 → 1.2.90

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@controleonline/ui-common",
-  "version": "1.2.88",
+  "version": "1.2.90",
   "author": "ControleOnline",
   "description": "ControleOnline Common Quasar UI Component",
   "license": "MIT",

package/src/api/localDB.js

@@ -1,131 +1,86 @@
-import { openDB } from "idb";
-
-const DB_NAME = "ControleOnline";
-
-export default class localDB {
-  constructor(state) {
-    this.state = state;
-
-    this.checkAndGetDB();
-  }
-
-  async initDB() {
-    let dbPromise = openDB(DB_NAME, this.currentVersion, {
-      upgrade: (db) => {
-        if (!db.objectStoreNames.contains(this.state.resourceEndpoint)) {
-          const store = db.createObjectStore(this.state.resourceEndpoint, {
-            keyPath: "id",
-          });
-          this.state.columns
-            .filter((col) => col.sortable || col.externalFilter === false)
-            .forEach((col) => {
-              store.createIndex(col.name, col.name, { unique: false });
-            });
-        }
-      },
-    });
-    return dbPromise;
-  }
-
-  async getCurrentVersion() {
-    // Obtém a versão atual do banco de dados
-    return new Promise((resolve) => {
-      const request = indexedDB.open(DB_NAME);
-      request.onsuccess = () => {
-        const db = request.result;
-        const currentVersion = db.currentVersion;
-        db.close();
-        resolve(currentVersion);
-        this.currentVersion = currentVersion;
-      };
-      request.onerror = () => resolve(1);
-    });
-  }
-
-  async checkAndGetDB() {
-    return this.getCurrentVersion().then(() => {
-      return this.initDB().then((db) => {
-        if (!this.storeExists()) {
-          this.currentVersion = db.currentVersion + 1;
-          db.close();
-          return this.initDB();
-        }
-        return db;
-      });
-    });
-  }
-
-  async storeExists() {
-    return this.checkAndGetDB().then((db) => {
-      return db.objectStoreNames.contains(this.state.resourceEndpoint);
-    });
-  }
-
-  async getAll() {
-    if (!(await this.storeExists())) {
-      return null;
-    }
-    const db = await this.checkAndGetDB();
-    return db.getAll(this.state.resourceEndpoint);
-  }
-
-  async getItemsByColumn(columnName, value) {
-    if (!(await this.storeExists())) {
-      return null;
-    }
-    const db = await this.checkAndGetDB();
-    const tx = db.transaction(this.state.resourceEndpoint, "readonly");
-    const store = tx.objectStore(this.state.resourceEndpoint);
-    const index = store.index(columnName);
-    const results = await index.getAll(value);
-    await tx.done;
-    return results;
-  }
-
-  async get(id) {
-    if (!(await this.storeExists())) {
-      return null;
-    }
-    const db = await this.checkAndGetDB();
-    return db.get(this.state.resourceEndpoint, id);
-  }
-
-  async saveItems(items) {
-    const db = await this.checkAndGetDB();
-    const tx = db.transaction(this.state.resourceEndpoint, "readwrite");
-    const store = tx.objectStore(this.state.resourceEndpoint);
-    await Promise.all(items.map((item) => store.put(item)));
-    await tx.done;
-  }
-
-  async saveItem(item) {
-    const db = await this.checkAndGetDB();
-    return db.put(this.state.resourceEndpoint, item);
-  }
-
-  async getItemsByFilters() {
-    if (!(await this.storeExists())) {
-      return null;
-    }
-    const db = await this.checkAndGetDB();
-    if (Object.keys(this.state.filters).length === 0) {
-      return this.getAll();
-    }
-
-    const filterPromises = Object.entries(this.state.filters).map(
-      async ([key, value]) => {
-        const column = this.state.columns.find((col) => col.name === key);
-        if (column && (column.sortable || column.externalFilter === false)) {
-          return this.getItemsByColumn(key, value);
-        }
-        return null;
-      }
-    );
-
-    const filterResults = await Promise.all(filterPromises);
-    return filterResults.reduce((acc, curr) => {
-      if (!acc || acc.length === 0) return curr;
-      return acc.filter((item) => curr.some((result) => result.id === item.id));
-    }, []);
-  }
-}
+import {openDB} from 'idb';
+
+const DB_NAME = 'ControleOnline';
+
+export default class localDB {
+  constructor(state) {
+    this.state = state;
+    this.db = null;
+    this.opening = null;
+  }
+
+  async initDB() {
+    const endpoint = this.state.resourceEndpoint;
+    const upgrade = db => {
+      if (db.objectStoreNames.contains(endpoint)) return;
+      const store = db.createObjectStore(endpoint, {keyPath: 'id'});
+      (this.state.columns || []).forEach(column => {
+        if (column.name && (column.sortable || column.externalFilter === false)) {
+          store.createIndex(column.name, column.name, {unique: false});
+        }
+      });
+    };
+    const blocking = () => { this.db?.close(); this.db = null; };
+    let db = await openDB(DB_NAME, undefined, {upgrade, blocking});
+    if (!db.objectStoreNames.contains(endpoint)) {
+      const version = db.version + 1;
+      db.close();
+      db = await openDB(DB_NAME, version, {upgrade, blocking});
+    }
+    this.db = db;
+    return db;
+  }
+
+  async getCurrentVersion() {
+    return (await this.checkAndGetDB()).version;
+  }
+
+  checkAndGetDB() {
+    if (this.db) return Promise.resolve(this.db);
+    if (!this.opening) {
+      this.opening = this.initDB().finally(() => { this.opening = null; });
+    }
+    return this.opening;
+  }
+
+  async storeExists() {
+    return (await this.checkAndGetDB()).objectStoreNames.contains(this.state.resourceEndpoint);
+  }
+
+  async getAll() {
+    return (await this.checkAndGetDB()).getAll(this.state.resourceEndpoint);
+  }
+
+  async getItemsByColumn(columnName, value) {
+    const db = await this.checkAndGetDB();
+    const tx = db.transaction(this.state.resourceEndpoint, 'readonly');
+    if (!tx.store.indexNames.contains(columnName)) return [];
+    const items = await tx.store.index(columnName).getAll(value);
+    await tx.done;
+    return items;
+  }
+
+  async get(id) {
+    return (await this.checkAndGetDB()).get(this.state.resourceEndpoint, id);
+  }
+
+  async saveItems(items) {
+    const db = await this.checkAndGetDB();
+    const tx = db.transaction(this.state.resourceEndpoint, 'readwrite');
+    await Promise.all(items.map(item => tx.store.put(item)));
+    await tx.done;
+  }
+
+  async saveItem(item) {
+    return (await this.checkAndGetDB()).put(this.state.resourceEndpoint, item);
+  }
+
+  async getItemsByFilters() {
+    const filters = Object.entries(this.state.filters || {});
+    if (!filters.length) return this.getAll();
+    const matches = await Promise.all(filters.map(([key, value]) =>
+      this.getItemsByColumn(key, value)));
+    return matches.reduce((items, next) => items.filter(item =>
+      next.some(result => result.id === item.id)));
+  }
+}

package/src/react/components/CopyDeviceConfigModal.js

@@ -100,10 +100,13 @@ export default function CopyDeviceConfigModal({
           </View>
 
           <Text style={styles.message} testID="copy-device-config-hint">
-            {tt('device_action', 'copyConfigHint') ||
-              `Escolha o device origem. As configurações serão aplicadas em "${
-                destinationAlias || destinationDeviceString || 'destino'
-              }" (identidade do destino não muda).`}
+            {`${
+              tt('device_action', 'copyConfigHint') ||
+              'Escolha o device origem. As configurações serão aplicadas em'
+            } "${destinationAlias || destinationDeviceString || 'destino'}" (${
+              tt('device_action', 'copyConfigIdentityHint') ||
+              'identidade do destino não muda'
+            }).`}
           </Text>
 
           {loading ? (

package/src/react/config/deviceConfigBootstrap.js

@@ -1,237 +1,48 @@
+import {appendScreenMetrics, hasScreenMetricsChanges} from '@controleonline/ui-common/src/react/utils/screenMetrics.js';
+import {normalizeBooleanConfig, SHOP_LOYALTY_COUPONS_ENABLED_CONFIG_KEY} from '@controleonline/ui-common/src/react/utils/shopConfig.js';
 import {
-  appendScreenMetrics,
-  hasScreenMetricsChanges,
-} from '@controleonline/ui-common/src/react/utils/screenMetrics.js';
-import {
-  normalizeBooleanConfig,
-  SHOP_LOYALTY_COUPONS_ENABLED_CONFIG_KEY,
-} from '@controleonline/ui-common/src/react/utils/shopConfig.js';
-
-export const CIELO_DEVICES = ['quantum', 'ingenico', 'positivo'];
-export const SUPPORTED_POS_GATEWAYS = ['cielo', 'infinite-pay'];
-export const DEVICE_ALERT_SOUND_ENABLED_KEY = 'notification-sound-enabled';
-export const DEVICE_ALERT_SOUND_URL_KEY = 'notification-sound-url';
-export const DEVICE_ORDER_VISIBILITY_KEY = 'pos-order-visibility';
-export const DEVICE_ORDER_VISIBILITY_DEVICE = 'device';
-export const DEVICE_ORDER_VISIBILITY_COMPANY = 'company';
-export const POS_DELIVERY_ENABLED_CONFIG_KEY = 'pos-delivery-enabled';
-export const DEVICE_RUNTIME_DEBUG_INFO_ENABLED_KEY =
-  'device-runtime-debug-info-enabled';
-export const DISPLAY_AUTO_PRINT_PRODUCT_CONFIG_KEY =
-  'display-auto-print-product';
-export const DISPLAY_ALLOW_PRINTER_CHANGE_CONFIG_KEY =
-  'display-allow-printer-change';
-export const DISPLAY_SIZE_CONFIG_KEY = 'display-size';
-export const DISPLAY_SIDE_BREAK_CONFIG_KEY = 'display-side-break';
-export const DISPLAY_SIZE_MIN = 1;
-export const DISPLAY_SIZE_MAX = 10;
-export const DISPLAY_SIZE_DEFAULT = 5;
-export const POS_OPERATION_MODE_CONFIG_KEY = 'pos-operation-mode';
-/** Independent of operation mode: whether this device may run local charge/payment. */
-export const POS_LOCAL_CHARGE_ENABLED_CONFIG_KEY = 'pos-local-charge-enabled';
-export const POS_PRODUCT_SHOWCASE_CONFIG_KEY = 'pos-product-showcase-id';
-export const DEVICE_ANDROID_KIOSK_ENABLED_CONFIG_KEY =
-  'android-kiosk-enabled';
-export const DEVICE_ANDROID_LAUNCHER_ENABLED_CONFIG_KEY =
-  'android-launcher-enabled';
-export const POS_AUTO_PRINT_ENABLED_CONFIG_KEY = 'pos-auto-print-enabled';
-export const POS_CASH_MANAGEMENT_MODE_CONFIG_KEY =
-  'pos-cash-management-mode';
-export const POS_CHECK_ORDER_TYPE_CONFIG_KEY = 'check-order-type';
-export const POS_CHECK_ORDER_MANAGEMENT_MODE_CONFIG_KEY =
-  'check-order-management-mode';
-export const POS_OPERATION_MODE_COUNTER = 'counter';
-export const POS_OPERATION_MODE_WAITER = 'waiter';
-export const POS_OPERATION_MODE_TOTEM = 'totem';
-export const POS_OPERATION_MODE_SINGLE_ITEM = 'single-item';
-export const POS_OPERATION_MODE_CASHIER = 'cashier';
-export const POS_CHECK_ORDER_TYPE_NONE = 'none';
-export const POS_CHECK_ORDER_TYPE_TAB = 'tab';
-export const POS_CHECK_ORDER_TYPE_TABLE = 'table';
-export const POS_CHECK_ORDER_TYPE_STAMP = 'stamp';
-export const POS_CHECK_ORDER_MANAGEMENT_MODE_MANAGE = 'manage';
-export const POS_CHECK_ORDER_MANAGEMENT_MODE_EXISTING_ONLY = 'existing-only';
-export const POS_OPERATION_MODE_DEFAULT = POS_OPERATION_MODE_COUNTER;
-export const POS_PRINT_MODE_ORDER = 'order';
-export const POS_PRINT_MODE_FORM = 'form';
-export const POS_PRINT_MODE_DEFAULT = POS_PRINT_MODE_ORDER;
-export const POS_CASH_MANAGEMENT_MODE_CASH_REGISTER = 'cash-register';
-export const POS_CASH_MANAGEMENT_MODE_DAILY = 'daily';
-export const POS_CASH_MANAGEMENT_MODE_DEFAULT =
-  POS_CASH_MANAGEMENT_MODE_CASH_REGISTER;
-export const POS_OPERATION_MODE_OPTIONS = [
-  {
-    value: POS_OPERATION_MODE_COUNTER,
-    translationKey: 'counterService',
-    descriptionKey: 'counterServiceDescription',
-  },
-  {
-    value: POS_OPERATION_MODE_WAITER,
-    translationKey: 'waiterService',
-    descriptionKey: 'waiterServiceDescription',
-  },
-  {
-    value: POS_OPERATION_MODE_TOTEM,
-    translationKey: 'selfServiceKiosk',
-    descriptionKey: 'selfServiceKioskDescription',
-  },
-  {
-    value: POS_OPERATION_MODE_SINGLE_ITEM,
-    translationKey: 'singleItemSale',
-    descriptionKey: 'singleItemSaleDescription',
-  },
-  {
-    value: POS_OPERATION_MODE_CASHIER,
-    translationKey: 'cashierPOS',
-    descriptionKey: 'cashierPOSDescription',
-  },
-];
-
-export const DEFAULT_DEVICE_CONFIGS = {
-  'pos-type': 'full',
-  'print-mode': 'order',
-  'check-type': 'manual',
-  'product-input-type': 'manual',
-  'selection-type': 'single',
-  sound: '0',
-  vibration: '0',
-  [DEVICE_ORDER_VISIBILITY_KEY]: DEVICE_ORDER_VISIBILITY_DEVICE,
-  [POS_DELIVERY_ENABLED_CONFIG_KEY]: '1',
-  [DEVICE_ALERT_SOUND_ENABLED_KEY]: '0',
-  [DEVICE_ALERT_SOUND_URL_KEY]: '',
-  [DEVICE_RUNTIME_DEBUG_INFO_ENABLED_KEY]: '0',
-  [DEVICE_ANDROID_LAUNCHER_ENABLED_CONFIG_KEY]: '0',
-  [DISPLAY_ALLOW_PRINTER_CHANGE_CONFIG_KEY]: '0',
-  [DISPLAY_SIZE_CONFIG_KEY]: String(DISPLAY_SIZE_DEFAULT),
-  [DISPLAY_SIDE_BREAK_CONFIG_KEY]: '0',
-  [POS_CHECK_ORDER_TYPE_CONFIG_KEY]: POS_CHECK_ORDER_TYPE_NONE,
-  [POS_CHECK_ORDER_MANAGEMENT_MODE_CONFIG_KEY]:
-    POS_CHECK_ORDER_MANAGEMENT_MODE_MANAGE,
-  [POS_OPERATION_MODE_CONFIG_KEY]: POS_OPERATION_MODE_DEFAULT,
-  [POS_PRODUCT_SHOWCASE_CONFIG_KEY]: '',
-  [POS_AUTO_PRINT_ENABLED_CONFIG_KEY]: '0',
-  [POS_CASH_MANAGEMENT_MODE_CONFIG_KEY]: POS_CASH_MANAGEMENT_MODE_DEFAULT,
-};
-
-export const isTruthyValue = value =>
-  value === true || value === '1' || value === 1 || value === 'true';
-
-export const isMissingConfigValue = value =>
-  value === undefined || value === null || value === '';
-
-export const parseConfigsObject = configs => {
-  if (!configs) return {};
-
-  if (typeof configs === 'string') {
-    try {
-      const parsed = JSON.parse(configs);
-      return parsed && typeof parsed === 'object' ? parsed : {};
-    } catch {
-      return {};
-    }
-  }
-
-  return typeof configs === 'object' ? {...configs} : {};
-};
-
-export const normalizeDisplaySize = value => {
-  const normalizedValue = String(value ?? '').trim();
-
-  if (normalizedValue === '') {
-    return DISPLAY_SIZE_DEFAULT;
-  }
-
-  const numericValue = Number(normalizedValue);
-
-  if (!Number.isFinite(numericValue)) {
-    return DISPLAY_SIZE_DEFAULT;
-  }
-
-  return Math.min(
-    DISPLAY_SIZE_MAX,
-    Math.max(DISPLAY_SIZE_MIN, Math.round(numericValue)),
-  );
-};
-
-export const resolveDisplaySize = configs =>
-  normalizeDisplaySize(
-    parseConfigsObject(configs)?.[DISPLAY_SIZE_CONFIG_KEY],
-  );
-
-export const isDisplaySideBreakEnabled = configs =>
-  isTruthyValue(
-    parseConfigsObject(configs)?.[DISPLAY_SIDE_BREAK_CONFIG_KEY],
-  );
-
-export const normalizePosOperationMode = value => {
-  const normalizedValue = String(value || '')
-    .trim()
-    .toLowerCase()
-    .normalize('NFD')
-    .replace(/[\u0300-\u036f]/g, '')
-    .replace(/[\s_]/g, '-');
-
-  if (
-    [
-      POS_OPERATION_MODE_COUNTER,
-      'balcao',
-      'counter-service',
-      'front-counter',
-    ].includes(normalizedValue)
-  ) {
-    return POS_OPERATION_MODE_COUNTER;
-  }
-
-  if (
-    [
-      POS_OPERATION_MODE_WAITER,
-      'garcon',
-      'garcom',
-      'table-service',
-    ].includes(normalizedValue)
-  ) {
-    return POS_OPERATION_MODE_WAITER;
-  }
-
-  if (
-    [
-      POS_OPERATION_MODE_TOTEM,
-    ].includes(normalizedValue)
-  ) {
-    return POS_OPERATION_MODE_TOTEM;
-  }
-
-  if (
-    [
-      POS_OPERATION_MODE_SINGLE_ITEM,
-      'single-sale',
-      'single-item-sale',
-      'sale-unit',
-      'sale-single',
-      'venda-unitaria',
-      'venda-unica',
-      'item-unico',
-      'unit-sale',
-      'unitary-sale',
-    ].includes(normalizedValue)
-  ) {
-    return POS_OPERATION_MODE_SINGLE_ITEM;
-  }
-
-  if (
-    [
-      POS_OPERATION_MODE_CASHIER,
-      'pdv',
-      'pos',
-      'checkout',
-      'cashier-pos',
-    ].includes(normalizedValue)
-  ) {
-    return POS_OPERATION_MODE_CASHIER;
-  }
-
-  return '';
-};
+  CIELO_DEVICES,
+  SUPPORTED_POS_GATEWAYS,
+  DEVICE_ORDER_VISIBILITY_KEY,
+  DEVICE_ORDER_VISIBILITY_DEVICE,
+  DEVICE_ORDER_VISIBILITY_COMPANY,
+  POS_DELIVERY_ENABLED_CONFIG_KEY,
+  DEVICE_RUNTIME_DEBUG_INFO_ENABLED_KEY,
+  DISPLAY_ALLOW_PRINTER_CHANGE_CONFIG_KEY,
+  POS_OPERATION_MODE_CONFIG_KEY,
+  POS_LOCAL_CHARGE_ENABLED_CONFIG_KEY,
+  ORDER_CHARGE_ENABLED_CONFIG_KEY,
+  isOrderChargeEnabled,
+  DEVICE_ANDROID_KIOSK_ENABLED_CONFIG_KEY,
+  DEVICE_ANDROID_LAUNCHER_ENABLED_CONFIG_KEY,
+  POS_AUTO_PRINT_ENABLED_CONFIG_KEY,
+  POS_CASH_MANAGEMENT_MODE_CONFIG_KEY,
+  POS_CHECK_ORDER_TYPE_CONFIG_KEY,
+  POS_CHECK_ORDER_MANAGEMENT_MODE_CONFIG_KEY,
+  POS_OPERATION_MODE_COUNTER,
+  POS_OPERATION_MODE_WAITER,
+  POS_OPERATION_MODE_TOTEM,
+  POS_OPERATION_MODE_SINGLE_ITEM,
+  POS_CHECK_ORDER_TYPE_NONE,
+  POS_CHECK_ORDER_TYPE_TAB,
+  POS_CHECK_ORDER_TYPE_TABLE,
+  POS_CHECK_ORDER_TYPE_TABLE_TAB,
+  POS_CHECK_ORDER_TYPE_STAMP,
+  POS_CHECK_ORDER_MANAGEMENT_MODE_MANAGE,
+  POS_CHECK_ORDER_MANAGEMENT_MODE_EXISTING_ONLY,
+  POS_PRINT_MODE_FORM,
+  POS_PRINT_MODE_DEFAULT,
+  POS_CASH_MANAGEMENT_MODE_CASH_REGISTER,
+  POS_CASH_MANAGEMENT_MODE_DAILY,
+  POS_CASH_MANAGEMENT_MODE_DEFAULT,
+  POS_OPERATION_MODE_OPTIONS,
+  DEFAULT_DEVICE_CONFIGS,
+  isTruthyValue,
+  isMissingConfigValue,
+  parseConfigsObject,
+  normalizePosOperationMode,
+} from './deviceConfigValues';
+export * from './deviceConfigValues';
 
 export const resolvePosOperationMode = configs =>
   normalizePosOperationMode(
@@ -264,6 +75,10 @@ export const normalizePosCheckOrderType = value => {
     return POS_CHECK_ORDER_TYPE_TABLE;
   }
 
+  if (normalizedValue === POS_CHECK_ORDER_TYPE_TABLE_TAB) {
+    return POS_CHECK_ORDER_TYPE_TABLE_TAB;
+  }
+
   if (
     [
       POS_CHECK_ORDER_TYPE_STAMP,
@@ -306,6 +121,21 @@ export const resolvePosCheckOrderTypeForShop = (
   return resolvedType;
 };
 
+// A device mode is not an Order.orderType. The current entry starts at the
+// table; the waiter navigation can then resolve a concrete tab under that table.
+export const resolvePosCheckOrderEntryTypeForShop = (deviceConfigs, shopConfigs) => {
+  const type = resolvePosCheckOrderTypeForShop(deviceConfigs, shopConfigs);
+  return type === POS_CHECK_ORDER_TYPE_TABLE_TAB ? POS_CHECK_ORDER_TYPE_TABLE : type;
+};
+
+export const resolvePosCheckOrderTypesForShop = (deviceConfigs, shopConfigs) => {
+  const type = resolvePosCheckOrderTypeForShop(deviceConfigs, shopConfigs);
+  if (type === POS_CHECK_ORDER_TYPE_TABLE_TAB) {
+    return [POS_CHECK_ORDER_TYPE_TABLE, POS_CHECK_ORDER_TYPE_TAB];
+  }
+  return type === POS_CHECK_ORDER_TYPE_NONE ? [] : [type];
+};
+
 export const normalizePosCheckOrderManagementMode = value => {
   const normalizedValue = String(value || '')
     .trim()
@@ -513,6 +343,14 @@ export const isPosLocalChargeEnabled = configs => {
   );
 };
 
+// Entry-point visibility only. The consultation and invoice API enforce capability.
+export const isPosChargeEntryEnabled = configs => {
+  const parsed = parseConfigsObject(configs);
+  return Object.prototype.hasOwnProperty.call(parsed, ORDER_CHARGE_ENABLED_CONFIG_KEY)
+    ? isOrderChargeEnabled(parsed)
+    : isPosLocalChargeEnabled(parsed);
+};
+
 export const getPosOperationModeOption = mode => {
 
   const normalizedMode = normalizePosOperationMode(mode);