@controleonline/ui-common 1.2.70

package/src/react/utils/cashPayment.js

@@ -0,0 +1,87 @@
+import Formatter from '@controleonline/ui-common/src/utils/formatter';
+import {isCashPaymentOption} from './paymentOptions';
+
+export const parseMoneyInputValue = value => {
+  const numericValue = String(value || '').replace(/\D/g, '');
+  if (!numericValue) {
+    return 0;
+  }
+
+  return Number(numericValue) / 100;
+};
+
+export const formatMoneyInputValue = value => {
+  const normalizedValue = Number(value || 0);
+  if (normalizedValue <= 0) {
+    return '';
+  }
+
+  return Formatter.formatMoney(normalizedValue);
+};
+
+export const normalizeMoneyInputText = text => {
+  const numericValue = String(text || '').replace(/\D/g, '');
+  if (!numericValue) {
+    return '';
+  }
+
+  return Formatter.formatMoney(Number(numericValue) / 100);
+};
+
+export const resolveCashPaymentDetails = ({
+  allowPartial = false,
+  receivedAmount = 0,
+  totalAmount = 0,
+}) => {
+  const normalizedReceivedAmount = Math.max(Number(receivedAmount || 0), 0);
+  const normalizedTotalAmount = Math.max(Number(totalAmount || 0), 0);
+  const appliedAmount = allowPartial
+    ? Math.min(normalizedReceivedAmount, normalizedTotalAmount)
+    : normalizedTotalAmount;
+  const changeAmount = Math.max(normalizedReceivedAmount - appliedAmount, 0);
+  const missingAmount = Math.max(normalizedTotalAmount - normalizedReceivedAmount, 0);
+
+  return {
+    appliedAmount,
+    changeAmount,
+    missingAmount,
+    needsChange: changeAmount > 0.009,
+    receivedAmount: normalizedReceivedAmount,
+  };
+};
+
+const GATEWAY_BYPASS_PAYMENT_CODES = ['DINHEIRO', 'VOUCHER_CORTESIA'];
+
+const normalizePaymentCode = value =>
+  String(value || '')
+    .trim()
+    .toUpperCase();
+
+export const hasIntegratedPaymentCode = payment =>
+  normalizePaymentCode(payment?.paymentCode) !== '';
+
+export const shouldBypassGatewayForPayment = payment =>
+  GATEWAY_BYPASS_PAYMENT_CODES.includes(
+    normalizePaymentCode(payment?.paymentCode),
+  );
+
+export const isGatewayFreePayment = payment =>
+  !!payment?.wallet &&
+  !!payment?.paymentType &&
+  (!hasIntegratedPaymentCode(payment) || shouldBypassGatewayForPayment(payment));
+
+export const isCashPaymentWithoutGateway = payment =>
+  isCashPaymentOption(payment) && isGatewayFreePayment(payment);
+
+export const createInvoiceForGatewayFreePayment = async ({
+  payment,
+  total = 0,
+  createInvoice,
+}) => {
+  if (!isGatewayFreePayment(payment) || typeof createInvoice !== 'function') {
+    return false;
+  }
+
+  await createInvoice(payment, Number(total || 0));
+  return true;
+};

package/src/react/utils/commercialDocumentOrders.js

@@ -0,0 +1,269 @@
+import { api } from '@controleonline/ui-common/src/api';
+
+const normalizeStatusKey = value => String(value || '').trim().toLowerCase();
+
+export const normalizeEntityId = value => {
+  if (!value) {
+    return '';
+  }
+
+  if (typeof value === 'object') {
+    return normalizeEntityId(value?.['@id'] || value?.id);
+  }
+
+  return String(value).replace(/\D/g, '');
+};
+
+export const toEntityIri = (value, resource) => {
+  if (!value) {
+    return null;
+  }
+
+  if (typeof value === 'object') {
+    if (value?.['@id']) {
+      return value['@id'];
+    }
+
+    const nestedId = normalizeEntityId(value?.id);
+    return nestedId ? `/${resource}/${nestedId}` : null;
+  }
+
+  const normalizedValue = String(value).trim();
+  if (normalizedValue.startsWith('/')) {
+    return normalizedValue;
+  }
+
+  const normalizedId = normalizeEntityId(normalizedValue);
+  return normalizedId ? `/${resource}/${normalizedId}` : null;
+};
+
+export const extractCollectionItems = response => {
+  if (Array.isArray(response)) return response;
+  if (Array.isArray(response?.member)) return response.member;
+  if (Array.isArray(response?.['hydra:member'])) return response['hydra:member'];
+  return [];
+};
+
+const buildStatusIriFromId = value => {
+  const normalizedId = normalizeEntityId(value);
+  return normalizedId ? `/statuses/${normalizedId}` : null;
+};
+
+let openOrderStatusIriCache = null;
+
+export const resolveOpenOrderStatusIri = async fallbackStatusId => {
+  if (openOrderStatusIriCache) {
+    return openOrderStatusIriCache;
+  }
+
+  const fallbackIri = buildStatusIriFromId(fallbackStatusId);
+
+  try {
+    const response = await api.fetch('statuses', {
+      params: {
+        context: 'order',
+        realStatus: 'open',
+        status: 'open',
+      },
+    });
+    const items = extractCollectionItems(response);
+    const matchedStatus =
+      items.find(
+        item =>
+          normalizeStatusKey(item?.realStatus) === 'open' &&
+          normalizeStatusKey(item?.status) === 'open',
+      ) || items[0];
+    const resolvedIri =
+      matchedStatus?.['@id'] ||
+      buildStatusIriFromId(matchedStatus?.id) ||
+      fallbackIri;
+
+    if (resolvedIri) {
+      openOrderStatusIriCache = resolvedIri;
+    }
+
+    return resolvedIri;
+  } catch (error) {
+    return fallbackIri;
+  }
+};
+
+export const isOpenCommercialOrder = order =>
+  normalizeStatusKey(order?.status?.realStatus) === 'open' &&
+  normalizeStatusKey(order?.status?.status) === 'open';
+
+export const fetchLinkedOrder = async contractRef => {
+  if (!contractRef) {
+    return null;
+  }
+
+  const response = await api.fetch('orders', {
+    params: {
+      contract: toEntityIri(contractRef, 'contracts'),
+      'order[alterDate]': 'DESC',
+    },
+  });
+
+  return extractCollectionItems(response)[0] || null;
+};
+
+export const fetchOrderProducts = async orderRef => {
+  if (!orderRef) {
+    return [];
+  }
+
+  const response = await api.fetch('order_products', {
+    params: {
+      order: toEntityIri(orderRef, 'orders'),
+    },
+  });
+
+  return extractCollectionItems(response);
+};
+
+export const searchCompanyProducts = async ({ companyId, query = '' }) => {
+  if (!companyId) {
+    return [];
+  }
+
+  const params = {
+    company: toEntityIri(companyId, 'people'),
+    active: 1,
+    'order[product]': 'ASC',
+  };
+
+  if (String(query || '').trim()) {
+    params.product = String(query).trim();
+  }
+
+  const response = await api.fetch('products', { params });
+  return extractCollectionItems(response);
+};
+
+export const createLinkedOrder = async ({
+  contractRef,
+  provider,
+  client,
+  payer,
+  app = 'CRM',
+  orderType = 'sale',
+  fallbackStatusId = null,
+}) => {
+  const status = await resolveOpenOrderStatusIri(fallbackStatusId);
+  const payload = {
+    app,
+    orderType,
+    contract: toEntityIri(contractRef, 'contracts'),
+    provider: toEntityIri(provider, 'people'),
+  };
+
+  if (status) {
+    payload.status = status;
+  }
+
+  const clientIri = toEntityIri(client, 'people');
+  if (clientIri) {
+    payload.client = clientIri;
+  }
+
+  const payerIri = toEntityIri(payer || client, 'people');
+  if (payerIri) {
+    payload.payer = payerIri;
+  }
+
+  return api.fetch('orders', {
+    method: 'POST',
+    body: payload,
+  });
+};
+
+export const ensureLinkedOrder = async ({
+  contractRef,
+  provider,
+  client,
+  payer,
+  app = 'CRM',
+  orderType = 'sale',
+  fallbackStatusId = null,
+}) => {
+  const existingOrder = await fetchLinkedOrder(contractRef);
+  if (existingOrder) {
+    return existingOrder;
+  }
+
+  return createLinkedOrder({
+    contractRef,
+    provider,
+    client,
+    payer,
+    app,
+    orderType,
+    fallbackStatusId,
+  });
+};
+
+export const addProductsToOrder = async ({ orderId, products = [] }) => {
+  const normalizedOrderId = normalizeEntityId(orderId);
+  const normalizedProducts = products
+    .map(item => ({
+      product: normalizeEntityId(item?.product),
+      quantity: Number(item?.quantity || 1),
+    }))
+    .filter(item => item.product);
+
+  if (!normalizedOrderId || normalizedProducts.length === 0) {
+    return null;
+  }
+
+  return api.fetch(`orders/${normalizedOrderId}/add-products`, {
+    method: 'PUT',
+    body: normalizedProducts,
+  });
+};
+
+export const updateOrderProductQuantity = async ({ orderProductId, quantity }) => {
+  const normalizedId = normalizeEntityId(orderProductId);
+  if (!normalizedId) {
+    return null;
+  }
+
+  return api.fetch(`order_products/${normalizedId}`, {
+    method: 'PUT',
+    body: {
+      id: Number(normalizedId),
+      quantity: Number(quantity),
+    },
+  });
+};
+
+export const removeOrderProduct = async orderProductId => {
+  const normalizedId = normalizeEntityId(orderProductId);
+  if (!normalizedId) {
+    return null;
+  }
+
+  return api.fetch(`order_products/${normalizedId}`, {
+    method: 'DELETE',
+  });
+};
+
+export const fetchLatestProposalForClient = async ({ provider, client }) => {
+  const providerIri = toEntityIri(provider, 'people');
+  const clientIri = toEntityIri(client, 'people');
+
+  if (!providerIri || !clientIri) {
+    return null;
+  }
+
+  const response = await api.fetch('contracts', {
+    params: {
+      provider: providerIri,
+      client: clientIri,
+      'contractModel.context': 'proposal',
+      'order[alterDate]': 'DESC',
+    },
+  });
+
+  return extractCollectionItems(response)[0] || null;
+};
+// TODO(store-first): quando este arquivo for mexido, mover a leitura para stores, remover api.fetch e evitar repassar dados em objetos quando o store ja resolver isso.

package/src/react/utils/dateRangeFilter.js

@@ -0,0 +1,264 @@
+const DATE_INPUT_PATTERN_YMD = /^\d{4}-\d{2}-\d{2}$/;
+const DATE_INPUT_PATTERN_DMY = /^\d{2}\/\d{2}\/\d{4}$/;
+
+const DATE_FILTER_LABEL_KEYS = {
+  all: 'period_all',
+  today: 'period_today',
+  yesterday: 'period_yesterday',
+  '7d': 'period_7d',
+  '30d': 'period_30d',
+  '90d': 'period_90d',
+  this_month: 'period_this_month',
+  last_month: 'period_last_month',
+  custom: 'period_custom',
+};
+
+const DATE_FILTER_OPTION_LABELS = {
+  '90d': '90 dias',
+};
+
+const pad2 = value => String(value).padStart(2, '0');
+
+const formatDateToApi = date =>
+  `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())} ${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())}`;
+
+const resolveOrderLabel = key => global.t?.t('orders', 'label', key);
+const resolveYesterdayLabel = () => global.t?.t('users', 'date', 'yesterday');
+
+const createDayStart = date =>
+  new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0, 0);
+
+const createDayEnd = date =>
+  new Date(date.getFullYear(), date.getMonth(), date.getDate(), 23, 59, 59, 999);
+
+const formatDateLabel = date => date.toLocaleDateString('pt-BR');
+const buildNormalizedDate = (year, month, day) => {
+  const parsedDate = new Date(year, month - 1, day, 0, 0, 0, 0);
+
+  if (
+    Number.isNaN(parsedDate.getTime()) ||
+    parsedDate.getFullYear() !== year ||
+    parsedDate.getMonth() !== month - 1 ||
+    parsedDate.getDate() !== day
+  ) {
+    return null;
+  }
+
+  return parsedDate;
+};
+
+const createRangeEnd = (baseDate, useCurrentMoment = false) =>
+  useCurrentMoment ? new Date(baseDate) : createDayEnd(baseDate);
+
+const resolveRelativeStart = (baseDate, days, relativeMode = 'calendar') => {
+  if (relativeMode === 'rolling') {
+    const startDate = new Date(baseDate);
+    startDate.setDate(startDate.getDate() - days);
+    return startDate;
+  }
+
+  const startDate = createDayStart(baseDate);
+  startDate.setDate(startDate.getDate() - (days - 1));
+  return startDate;
+};
+
+// Shared parser for screens that accept YYYY-MM-DD or DD/MM/YYYY input.
+export const parseDateInput = value => {
+  const normalizedValue = String(value || '').trim();
+
+  if (DATE_INPUT_PATTERN_YMD.test(normalizedValue)) {
+    const [year, month, day] = normalizedValue.split('-').map(Number);
+    return buildNormalizedDate(year, month, day);
+  }
+
+  if (DATE_INPUT_PATTERN_DMY.test(normalizedValue)) {
+    const [day, month, year] = normalizedValue.split('/').map(Number);
+    return buildNormalizedDate(year, month, day);
+  }
+
+  return null;
+};
+
+export const normalizeDateInputToYmd = value => {
+  const parsedDate = parseDateInput(value);
+
+  if (!parsedDate) {
+    return null;
+  }
+
+  return `${parsedDate.getFullYear()}-${pad2(parsedDate.getMonth() + 1)}-${pad2(parsedDate.getDate())}`;
+};
+
+// Validation stays centralized so every screen uses the same rules and messages.
+export const validateCustomDateRange = (fromInput, toInput) => {
+  const fromValue = String(fromInput || '').trim();
+  const toValue = String(toInput || '').trim();
+  const fromDate = fromValue ? parseDateInput(fromValue) : null;
+  const toDate = toValue ? parseDateInput(toValue) : null;
+
+  if ((fromValue && !fromDate) || (toValue && !toDate)) {
+    return global.t?.t('orders', 'validation', 'invalid_date_format');
+  }
+
+  if (fromDate && toDate && fromDate > toDate) {
+    return global.t?.t('orders', 'validation', 'invalid_date_range');
+  }
+
+  return '';
+};
+
+const resolveDateObjectsRange = (dateFilterKey, customRange = null, options = {}) => {
+  const {
+    baseDate = new Date(),
+    relativeMode = 'calendar',
+    useCurrentMoment = false,
+  } = options;
+  const now = new Date(baseDate);
+
+  if (dateFilterKey === 'today') {
+    return {
+      afterDate: createDayStart(now),
+      beforeDate: createRangeEnd(now, useCurrentMoment),
+    };
+  }
+
+  if (dateFilterKey === 'yesterday') {
+    const yesterday = new Date(now);
+    yesterday.setDate(yesterday.getDate() - 1);
+
+    return {
+      afterDate: createDayStart(yesterday),
+      beforeDate: createDayEnd(yesterday),
+    };
+  }
+
+  if (dateFilterKey === '7d') {
+    return {
+      afterDate: resolveRelativeStart(now, 7, relativeMode),
+      beforeDate: createRangeEnd(now, useCurrentMoment),
+    };
+  }
+
+  if (dateFilterKey === '30d') {
+    return {
+      afterDate: resolveRelativeStart(now, 30, relativeMode),
+      beforeDate: createRangeEnd(now, useCurrentMoment),
+    };
+  }
+
+  if (dateFilterKey === '90d') {
+    return {
+      afterDate: resolveRelativeStart(now, 90, relativeMode),
+      beforeDate: createRangeEnd(now, useCurrentMoment),
+    };
+  }
+
+  if (dateFilterKey === 'this_month') {
+    return {
+      afterDate: new Date(now.getFullYear(), now.getMonth(), 1, 0, 0, 0, 0),
+      beforeDate: createRangeEnd(now, useCurrentMoment),
+    };
+  }
+
+  if (dateFilterKey === 'last_month') {
+    return {
+      afterDate: new Date(now.getFullYear(), now.getMonth() - 1, 1, 0, 0, 0, 0),
+      beforeDate: new Date(now.getFullYear(), now.getMonth(), 0, 23, 59, 59, 999),
+    };
+  }
+
+  if (dateFilterKey === 'custom') {
+    const afterDate = parseDateInput(customRange?.from);
+    const beforeDate = parseDateInput(customRange?.to);
+
+    if (afterDate) {
+      afterDate.setHours(0, 0, 0, 0);
+    }
+
+    if (beforeDate) {
+      beforeDate.setHours(23, 59, 59, 999);
+    }
+
+    return {
+      afterDate,
+      beforeDate,
+    };
+  }
+
+  return {
+    afterDate: null,
+    beforeDate: null,
+  };
+};
+
+export const DEFAULT_DATE_FILTER_KEY = 'today';
+
+export const DEFAULT_DATE_FILTER_OPTION_KEYS = [
+  'all',
+  'today',
+  'yesterday',
+  '7d',
+  '30d',
+  'this_month',
+  'last_month',
+  'custom',
+];
+
+export const buildDateFilterOptions = (
+  optionKeys = DEFAULT_DATE_FILTER_OPTION_KEYS,
+) => optionKeys.map(key => ({
+  key,
+  label: DATE_FILTER_OPTION_LABELS[key] || (
+    key === 'yesterday'
+      ? resolveYesterdayLabel()
+      : resolveOrderLabel(DATE_FILTER_LABEL_KEYS[key] || key)
+  ),
+}));
+
+export const getDateRange = (
+  dateFilterKey,
+  customRange = null,
+  options = {},
+) => {
+  const { afterDate, beforeDate } = resolveDateObjectsRange(
+    dateFilterKey,
+    customRange,
+    options,
+  );
+
+  return {
+    after: afterDate ? formatDateToApi(afterDate) : null,
+    before: beforeDate ? formatDateToApi(beforeDate) : null,
+  };
+};
+
+export const resolveDateRangeSummary = (
+  dateFilterKey,
+  customRange = null,
+  options = {},
+) => {
+  const { afterDate, beforeDate } = resolveDateObjectsRange(
+    dateFilterKey,
+    customRange,
+    options,
+  );
+
+  if (!afterDate || !beforeDate) {
+    return afterDate ? formatDateLabel(afterDate) : beforeDate ? formatDateLabel(beforeDate) : '';
+  }
+
+  const afterLabel = formatDateLabel(afterDate);
+  const beforeLabel = formatDateLabel(beforeDate);
+
+  if (afterLabel === beforeLabel) {
+    return afterLabel;
+  }
+
+  return `${afterLabel} - ${beforeLabel}`;
+};
+
+export const resolveDateFilterTitle = () =>
+  resolveOrderLabel('period');
+
+export const resolveDateFilterCurrentLabel = () =>
+  resolveOrderLabel('current_date');