orionplace-react 0.1.0 → 0.2.1

package/templates/lib/orionplace/tariffLabels.ts

@@ -0,0 +1,123 @@
+import { getAvailableValueFromObject } from '@/lib/orionplace/presentation';
+
+const labels = {
+  en: {
+    trial: 'Trial',
+    free: 'Free',
+    periods: 'Subscription period',
+    noPeriods: 'No subscription periods are available.',
+    adminOnly:
+      'This plan is assigned by the store administrator. It cannot be subscribed to online.',
+    closed: 'New subscriptions to this plan are closed.',
+    subscribe: 'Subscribe',
+    tryTrial: 'Try',
+    perPeriod: 'for {days}',
+    trialBadge: 'Free trial · {days}',
+    subscribeAria: 'Subscribe to {name} for {days}',
+    trialAria: 'Try {name} free for {days}',
+    features: 'Included in the plan',
+    notIncluded: 'not included',
+    options: 'Options',
+    details: 'Details',
+    title: 'Subscription details',
+    option: 'Additional option',
+    noOption: 'Without an additional option',
+    promo: 'Promo code',
+    base: 'Plan',
+    extra: 'Option',
+    total: 'Total',
+    beforePromo: 'Total before promo code',
+    payment:
+      'Paid subscriptions are charged to your account balance. The final amount includes any applicable promo discount.',
+    trialInfo: 'A trial is available once per subscription for your account.',
+    wallet: 'Top up balance',
+    confirm: 'Subscribe',
+    confirmTrial: 'Start',
+    pending: 'Submitting…',
+    complete: 'Subscription activated',
+    mine: 'My subscriptions',
+    close: 'Close',
+    invalid: 'This period or option is no longer available.',
+    plans: 'Subscription plans',
+    gallery: 'Plan media',
+    previousMedia: 'Previous media',
+    nextMedia: 'Next media',
+    image: 'Plan image',
+    video: 'Plan video',
+    about: 'About this plan',
+    unavailableMedia: 'No plan media is available.',
+    notFound: 'This subscription plan is not available.',
+  },
+  ru: {
+    trial: 'Пробный период',
+    free: 'Бесплатно',
+    periods: 'Период подписки',
+    noPeriods: 'Доступных периодов подписки нет.',
+    adminOnly:
+      'Этот тариф подключает администратор магазина. Самостоятельное подключение недоступно.',
+    closed: 'Новые подключения к этому тарифу закрыты.',
+    subscribe: 'Подключить',
+    tryTrial: 'Попробовать',
+    perPeriod: 'за {days}',
+    trialBadge: 'Пробный период · {days}',
+    subscribeAria: 'Подключить тариф «{name}» на {days}',
+    trialAria: 'Попробовать тариф «{name}» бесплатно: {days}',
+    features: 'Что входит в тариф',
+    notIncluded: 'не входит',
+    options: 'Опции',
+    details: 'Подробнее',
+    title: 'Оформление подписки',
+    option: 'Дополнительная опция',
+    noOption: 'Без дополнительной опции',
+    promo: 'Промокод',
+    base: 'Тариф',
+    extra: 'Опция',
+    total: 'Итого',
+    beforePromo: 'Итого до применения промокода',
+    payment:
+      'Платная подписка оплачивается с баланса аккаунта. Итоговая сумма учитывает доступную скидку по промокоду.',
+    trialInfo: 'Пробный период доступен аккаунту один раз для каждой подписки.',
+    wallet: 'Пополнить баланс',
+    confirm: 'Подключить',
+    confirmTrial: 'Начать',
+    pending: 'Отправка…',
+    complete: 'Подписка подключена',
+    mine: 'Мои подписки',
+    close: 'Закрыть',
+    invalid: 'Этот период или опция больше недоступны.',
+    plans: 'Тарифы подписок',
+    gallery: 'Материалы тарифа',
+    previousMedia: 'Предыдущий материал',
+    nextMedia: 'Следующий материал',
+    image: 'Изображение тарифа',
+    video: 'Видео тарифа',
+    about: 'О тарифе',
+    unavailableMedia: 'У тарифа нет изображений или видео.',
+    notFound: 'Этот тариф недоступен.',
+  },
+};
+
+const dayWords = {
+  en: { one: 'day', other: 'days' },
+  ru: { one: 'день', few: 'дня', many: 'дней', other: 'дней' },
+};
+
+export function tariffLabels(locale: string) {
+  return getAvailableValueFromObject(labels, locale) ?? labels.en;
+}
+
+export function tariffDays(days: number, locale: string) {
+  const russian = locale.toLowerCase().startsWith('ru');
+  const words: Record<string, string> = russian ? dayWords.ru : dayWords.en;
+  const category = new Intl.PluralRules(russian ? 'ru' : 'en').select(days);
+  return `${days} ${words[category] ?? words.other}`;
+}
+
+export function tariffText(
+  template: string,
+  values: Record<string, string | number>,
+) {
+  return template.replace(/\{(\w+)\}/g, (match, key: string) =>
+    key in values ? String(values[key]) : match,
+  );
+}

package/templates/lib/orionplace/tariffPage.ts

@@ -0,0 +1,54 @@
+import type { ISubscribeTariff } from '@/interfaces/orionplace/subscribeTariff/ISubscribeTariff';
+import { getAvailableNestedValueFromObject } from '@/lib/orionplace/presentation';
+
+/** Public path for one plan, using its localized slug when one is available. */
+export function tariffPagePath(tariff: ISubscribeTariff, locale: string) {
+  const slug = getAvailableNestedValueFromObject(
+    tariff.locales,
+    locale,
+    'tariff_slug',
+  );
+
+  return `/tariffs/${encodeURIComponent(slug || 'plan')}/${tariff.id}`;
+}
+
+export function tariffPageHref(tariff: ISubscribeTariff, locale: string) {
+  const query = locale ? `?locale=${encodeURIComponent(locale)}` : '';
+
+  return `${tariffPagePath(tariff, locale)}${query}`;
+}
+
+export type TariffMediaItem =
+  | { kind: 'image'; key: string; src: string }
+  | {
+      kind: 'video';
+      key: string;
+      src: string;
+      preview: string | null;
+    };
+
+/** Full plan images first, followed by videos in display order. */
+export function tariffMediaItems(
+  tariff: ISubscribeTariff | undefined,
+): TariffMediaItem[] {
+  const images = tariff?.tariff_image;
+  const sources = images?.full?.length ? images.full : (images?.small ?? []);
+  const items: TariffMediaItem[] = sources.map((src, index) => ({
+    kind: 'image',
+    key: `image-${index}`,
+    src,
+  }));
+  const videos = [...(tariff?.tariff_videos ?? [])].sort(
+    (left, right) => left.display_order - right.display_order,
+  );
+  for (const video of videos) {
+    items.push({
+      kind: 'video',
+      key: `video-${video.id}`,
+      src: video.video,
+      preview: video.preview,
+    });
+  }
+
+  return items;
+}

package/templates/lib/orionplace/tariffVariables.ts

@@ -0,0 +1,136 @@
+import { getAvailableValueFromObject } from '@/lib/orionplace/presentation';
+
+interface TariffVariableCopy {
+  name: string;
+  hint: string;
+  unit?: 'megabytes' | 'count';
+  unlimited?: boolean;
+}
+
+const copy: Record<string, Record<string, TariffVariableCopy>> = {
+  en: {
+    sales_module: {
+      name: 'Sales module',
+      hint: 'Everything needed to sell: catalog, cart, orders, payments and sellers.',
+    },
+    blog_module: {
+      name: 'Blog module',
+      hint: 'A content section with categories, comments and paid reading.',
+    },
+    qr_module: {
+      name: 'QR module',
+      hint: 'QR labelling of physical stock for warehouse and retail operations, together with the stock settings of the management dashboard.',
+    },
+    max_files_size: {
+      name: 'File storage',
+      hint: 'Total storage of the project. Every upload is added to the storage already used, and an upload that would pass this total is refused.',
+      unit: 'megabytes',
+      unlimited: true,
+    },
+    max_api_requests: {
+      name: 'API requests per month',
+      hint: 'How many API requests the project can make during one calendar month. The counter starts again on the first day of the next month.',
+      unit: 'count',
+      unlimited: true,
+    },
+    max_front_hosts: {
+      name: 'Storefront domains',
+      hint: 'How many storefront domains can be connected at the same time.',
+      unit: 'count',
+    },
+    max_sellers: {
+      name: 'Sellers',
+      hint: 'How many seller accounts the store can use. One seller activates the simplified single-store interface.',
+      unit: 'count',
+      unlimited: true,
+    },
+  },
+  ru: {
+    sales_module: {
+      name: 'Модуль Sales',
+      hint: 'Всё для продаж: каталог, корзина, заказы, оплата и продавцы.',
+    },
+    blog_module: {
+      name: 'Модуль Blog',
+      hint: 'Контентный раздел с рубриками, комментариями и платным чтением.',
+    },
+    qr_module: {
+      name: 'Модуль QR',
+      hint: 'QR-маркировка физических остатков для склада и розницы вместе с настройками склада в панели управления.',
+    },
+    max_files_size: {
+      name: 'Файловое хранилище',
+      hint: 'Общий объём хранилища проекта. Каждая загрузка добавляется к уже занятому объёму, и загрузка сверх этого объёма отклоняется.',
+      unit: 'megabytes',
+      unlimited: true,
+    },
+    max_api_requests: {
+      name: 'API-запросов в месяц',
+      hint: 'Сколько API-запросов проект может сделать за один календарный месяц. Счётчик начинается заново в первый день следующего месяца.',
+      unit: 'count',
+      unlimited: true,
+    },
+    max_front_hosts: {
+      name: 'Домены магазина',
+      hint: 'Сколько доменов магазина можно подключить одновременно.',
+      unit: 'count',
+    },
+    max_sellers: {
+      name: 'Продавцы',
+      hint: 'Сколько аккаунтов продавцов может использовать магазин. Один продавец включает упрощённый интерфейс обычного магазина.',
+      unit: 'count',
+      unlimited: true,
+    },
+  },
+};
+
+const units = {
+  en: { megabytes: 'MB', gigabytes: 'GB', unlimited: 'Unlimited' },
+  ru: { megabytes: 'МБ', gigabytes: 'ГБ', unlimited: 'Без ограничений' },
+};
+
+export function tariffVariableCopy(locale: string) {
+  return getAvailableValueFromObject(copy, locale) ?? copy.en!;
+}
+
+function formatNumber(value: number, locale: string) {
+  try {
+    return new Intl.NumberFormat(locale || 'en').format(value);
+  } catch {
+    return String(value);
+  }
+}
+
+function formatAmount(key: string, value: number, locale: string) {
+  const entry = tariffVariableCopy(locale)[key];
+  const unitText = getAvailableValueFromObject(units, locale) ?? units.en;
+  if (entry?.unit === 'megabytes') {
+    return value >= 1024 && value % 1024 === 0
+      ? `${formatNumber(value / 1024, locale)} ${unitText.gigabytes}`
+      : `${formatNumber(value, locale)} ${unitText.megabytes}`;
+  }
+  return formatNumber(value, locale);
+}
+
+export function tariffVariableDetail(
+  key: string,
+  value: boolean | number,
+  locale: string,
+) {
+  if (typeof value === 'boolean') {
+    return '';
+  }
+  const entry = tariffVariableCopy(locale)[key];
+  const unitText = getAvailableValueFromObject(units, locale) ?? units.en;
+  return entry?.unlimited && value === 0
+    ? unitText.unlimited
+    : formatAmount(key, value, locale);
+}
+
+export function tariffUsageDetail(
+  limitKey: string,
+  value: number,
+  locale: string,
+) {
+  return formatAmount(limitKey, value, locale);
+}

package/templates/lib/orionplace/tariffs.ts

@@ -0,0 +1,192 @@
+import { formatCurrency } from '@/lib/orionplace/currency';
+import { getAvailableValueFromObject } from '@/lib/orionplace/presentation';
+import {
+  tariffVariableCopy,
+  tariffVariableDetail,
+} from '@/lib/orionplace/tariffVariables';
+import type { IAppLoadCommonCurrency } from '@/interfaces/orionplace/appBase/appLoadCommon/IAppLoadCommonCurrency';
+import type {
+  ISubscribeTariff,
+  ISubscribeTariffOption,
+} from '@/interfaces/orionplace/subscribeTariff/ISubscribeTariff';
+import type { ISubscribe } from '@/interfaces/orionplace/subscribes/ISubscribe';
+import type { ITransformValue } from '@/interfaces/orionplace/shared/ITransformValue';
+import type {
+  ITariffSelection,
+  ITariffSubscribeRequest,
+} from '@/interfaces/orionplace/subscribeTariff/ITariffSelection';
+
+export type TariffAvailability = 'open' | 'admin' | 'closed';
+
+export function tariffAvailability(
+  tariff: ISubscribeTariff,
+  subscriptions: ISubscribe[] = [],
+): TariffAvailability {
+  const subscription = subscriptions.find(
+    (entry) => entry.id === tariff.subscription,
+  );
+  if (
+    tariff.only_admin_can_subscribe === true ||
+    subscription?.only_admin_can_subscribe === true
+  ) {
+    return 'admin';
+  }
+  return tariff.is_new_subs_allowed === true &&
+    tariff.only_admin_can_subscribe === false &&
+    subscription?.is_new_subs_allowed === true &&
+    subscription.only_admin_can_subscribe === false
+    ? 'open'
+    : 'closed';
+}
+
+export function tariffIsOpen(
+  tariff: ISubscribeTariff,
+  subscriptions: ISubscribe[] = [],
+) {
+  return tariffAvailability(tariff, subscriptions) === 'open';
+}
+
+export function tariffPaidPeriods(tariff: ISubscribeTariff) {
+  return [...tariff.prices].sort((left, right) => left.days - right.days);
+}
+
+export function tariffReturnPath(selection: ITariffSelection, locale: string) {
+  const query = new URLSearchParams();
+  if (locale) {
+    query.set('locale', locale);
+  }
+  query.set('tariff', String(selection.tariff));
+  query.set(
+    'period',
+    selection.price === null ? 'trial' : String(selection.price),
+  );
+  return `/tariffs?${query.toString()}`;
+}
+
+export function tariffAmount(
+  values: Record<string, ITransformValue> | undefined,
+  currencyId: string,
+) {
+  const amount = values?.[currencyId]?.transform_value;
+  return typeof amount === 'number' && Number.isFinite(amount)
+    ? amount
+    : undefined;
+}
+
+export function tariffMoney(
+  amount: number | undefined,
+  locale: string,
+  currency?: IAppLoadCommonCurrency,
+) {
+  if (amount === undefined) {
+    return '—';
+  }
+  // Written for the reader's language like every price: «443,26 ₽», «$ 25».
+  return formatCurrency(amount, currency, locale || 'en');
+}
+
+export function tariffOptions(tariff: ISubscribeTariff, price: number | null) {
+  return tariff.options.filter(
+    (option) => price !== null || option.eligiable_for_trial,
+  );
+}
+
+export function tariffOptionAmount(
+  option: ISubscribeTariffOption | undefined,
+  periodId: number,
+  currencyId: string,
+) {
+  if (!option) {
+    return 0;
+  }
+  const extra = option.domain_extras.find(
+    (entry) => entry.period_id === periodId,
+  );
+  return tariffAmount(extra?.amount, currencyId);
+}
+
+export function tariffSubscribeRequest(
+  tariff: ISubscribeTariff,
+  price: number | null,
+  optionId?: number,
+  promo = '',
+): ITariffSubscribeRequest | undefined {
+  const trial = price === null;
+  if (
+    trial
+      ? tariff.trial_days <= 0
+      : !tariff.prices.some((entry) => entry.tariff_cost_id === price)
+  ) {
+    return undefined;
+  }
+  if (
+    optionId !== undefined &&
+    !tariffOptions(tariff, price).some((entry) => entry.id === optionId)
+  ) {
+    return undefined;
+  }
+  return {
+    tariff: tariff.id,
+    ...(!trial ? { period: price } : {}),
+    ...(optionId !== undefined ? { option: optionId } : {}),
+    ...(!trial && promo.trim() ? { attach_issue: promo.trim() } : {}),
+  };
+}
+
+export interface TariffFeature {
+  key: string;
+  label: string;
+  value: boolean | number;
+  detail: string;
+  hint: string;
+}
+
+function featureLabel(
+  subscription: ISubscribe | undefined,
+  key: string,
+  locale: string,
+) {
+  const entry = subscription?.translations[key];
+  if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+    return '';
+  }
+  const names = entry.trans;
+  if (!names || typeof names !== 'object' || Array.isArray(names)) {
+    return '';
+  }
+  const label = getAvailableValueFromObject(names, locale);
+  return typeof label === 'string' ? label.trim() : '';
+}
+
+export function tariffFeatures(
+  tariff: ISubscribeTariff,
+  subscriptions: ISubscribe[] = [],
+  locale: string,
+): TariffFeature[] {
+  const subscription = subscriptions.find(
+    (entry) => entry.id === tariff.subscription,
+  );
+  const described = tariffVariableCopy(locale);
+  const features: TariffFeature[] = [];
+  for (const [key, value] of Object.entries(tariff.tariff_variables_json)) {
+    if (
+      (typeof value !== 'boolean' && typeof value !== 'number') ||
+      (typeof value === 'number' && !Number.isFinite(value))
+    ) {
+      continue;
+    }
+    const known = described[key];
+    const label = known?.name || featureLabel(subscription, key, locale);
+    if (!label || label === key) {
+      continue;
+    }
+    features.push({
+      key,
+      label,
+      value,
+      detail: tariffVariableDetail(key, value, locale),
+      hint: known?.hint ?? '',
+    });
+  }
+  return features;
+}

package/templates/lib/orionplace/ticketItems.ts

@@ -0,0 +1,75 @@
+import type { ICurrencyAmounts } from '@/interfaces/orionplace/cart/ICartData';
+import type {
+  IOrder,
+  OrderRefundWindow,
+} from '@/interfaces/orionplace/orders/IOrderHistory';
+import type { IProduct } from '@/interfaces/orionplace/products/IProduct';
+import type { ICustomerTicket } from '@/interfaces/orionplace/tickets/ICustomerTicketApi';
+import { getAvailableNestedValueFromObject } from '@/lib/orionplace/presentation';
+import { orderRefundWindow } from '@/lib/orionplace/orderPresentation';
+
+export interface TicketOrderLine {
+  key: string;
+  product: IProduct | null;
+  quantity: number;
+  option: string;
+  amount: ICurrencyAmounts | null;
+  refundWindow: OrderRefundWindow | null;
+}
+
+export function orderTicketLines(
+  order: Pick<IOrder, 'delivery_froms'> | null | undefined,
+  locale: string,
+): TicketOrderLine[] {
+  const lines: TicketOrderLine[] = [];
+
+  for (const shipment of order?.delivery_froms ?? []) {
+    for (const item of shipment.shipment_items ?? []) {
+      lines.push({
+        key: `item-${item.id}`,
+        product: item.product,
+        quantity: item.quantity,
+        option: '',
+        amount: item.prices?.products_price_after_promo ?? null,
+        refundWindow: orderRefundWindow(item),
+      });
+
+      for (const group of item.option_groups ?? []) {
+        const name = getAvailableNestedValueFromObject(
+          group.option_name,
+          locale,
+          'option_group_display_name',
+        );
+
+        for (const option of group.options ?? []) {
+          lines.push({
+            key: `option-${option.id}`,
+            product: option.product,
+            quantity: option.quantity,
+            option: name || '',
+            amount: option.prices?.options_price_after_promo ?? null,
+            refundWindow: orderRefundWindow(option),
+          });
+        }
+      }
+    }
+  }
+
+  return lines;
+}
+
+export function ticketOrderLine(
+  ticket: Pick<
+    ICustomerTicket,
+    'related_dlf_item_id' | 'related_option_item_id'
+  >,
+  lines: TicketOrderLine[],
+) {
+  const key = ticket.related_option_item_id
+    ? `option-${ticket.related_option_item_id}`
+    : ticket.related_dlf_item_id
+      ? `item-${ticket.related_dlf_item_id}`
+      : '';
+
+  return key ? lines.find((line) => line.key === key) : undefined;
+}