orionplace-react 0.1.0 → 0.2.0

package/templates/lib/orionplace/serverRecords.ts

@@ -0,0 +1,25 @@
+import { cache } from 'react';
+import { getOrionplaceServerApi } from '@/lib/orionplace/serverApi';
+import { requestProductPage } from '@/lib/orionplace/productPage';
+import {
+  requestPromoProducts,
+  requestPublication,
+  requestTariffs,
+} from '@/lib/orionplace/storefrontRecords';
+
+// The page and its metadata share one request per server render.
+export const getStorefrontProduct       = cache(async (id: number, key = '') =>
+  requestProductPage(await getOrionplaceServerApi(), id, key),
+);
+
+export const getStorefrontPublication   = cache(async (id: number) =>
+  requestPublication(await getOrionplaceServerApi(), id),
+);
+
+export const getStorefrontTariffs       = cache(async (id: number) =>
+  requestTariffs(await getOrionplaceServerApi(), id),
+);
+
+export const getStorefrontPromoProducts = cache(async (id: number, page: number) =>
+  requestPromoProducts(await getOrionplaceServerApi(), id, page),
+);

package/templates/lib/orionplace/serverRoute.tsx

@@ -0,0 +1,51 @@
+import { notFound, redirect } from 'next/navigation';
+import { getOrionplaceAppLoad } from '@/lib/orionplace/appLoadServer';
+import { getOrionplaceServerApi, serverErrorText } from '@/lib/orionplace/serverApi';
+import {
+  getOrionplaceServerLocale,
+  getStorefrontRequestUrl,
+} from '@/lib/orionplace/serverLocale';
+import {
+  getStorefrontProduct,
+  getStorefrontPromoProducts,
+  getStorefrontPublication,
+  getStorefrontTariffs,
+} from '@/lib/orionplace/serverRecords';
+import {
+  loadStorefrontRoute,
+  type StorefrontRoutePattern,
+  type StorefrontRouteQuery,
+} from '@/app/_storefront/storefrontRoutes';
+
+export interface StorefrontPageProps {
+  params?: Promise<Record<string, string>>;
+  searchParams?: Promise<StorefrontRouteQuery>;
+}
+
+/** Renders one storefront page during the website's server render. */
+export async function renderStorefrontRoute(
+  pattern: StorefrontRoutePattern,
+  { params, searchParams }: StorefrontPageProps,
+) {
+  const url    = await getStorefrontRequestUrl();
+  const result = await loadStorefrontRoute(pattern, {
+    params: (await params) ?? {},
+    query: (await searchParams) ?? {},
+    address: url.pathname + url.search,
+    appLoad: await getOrionplaceAppLoad(),
+    locale: getOrionplaceServerLocale,
+    api: getOrionplaceServerApi,
+    errorText: serverErrorText,
+    product: getStorefrontProduct,
+    publication: getStorefrontPublication,
+    tariffs: getStorefrontTariffs,
+    promoProducts: getStorefrontPromoProducts,
+  });
+  if ('redirect' in result) {
+    redirect(result.redirect);
+  }
+  if ('notFound' in result) {
+    notFound();
+  }
+  return result.page;
+}

package/templates/lib/orionplace/sessionLabels.ts

@@ -0,0 +1,27 @@
+export function sessionLabels(locale: string) {
+  return locale.toLowerCase().startsWith('ru')
+    ? {
+        title: 'Выход из аккаунта',
+        pending: 'Завершаем сеанс…',
+        hint: 'После выхода вы вернётесь на главную страницу.',
+        failed: 'Не удалось завершить выход',
+        retryHint:
+          'Повторите попытку. Выход подтверждается только ответом сервера.',
+        refreshFailed: 'Сеанс завершён. Не удалось загрузить магазин.',
+        retry: 'Повторить',
+        done: 'Вы вышли из аккаунта',
+        home: 'Главная',
+      }
+    : {
+        title: 'Signing out',
+        pending: 'Ending your session…',
+        hint: 'You will return to the storefront home page.',
+        failed: 'Could not finish signing out',
+        retryHint: 'Please try again. Sign-out is confirmed by the server.',
+        refreshFailed:
+          'Your session has ended. The storefront could not be reloaded.',
+        retry: 'Retry',
+        done: 'You are signed out',
+        home: 'Home',
+      };
+}

package/templates/lib/orionplace/signInReturn.ts

@@ -0,0 +1,89 @@
+/*
+ * Sign-in can start on any storefront page. The header passes that page to
+ * /profile as `redirect`, and the profile page returns there after the
+ * Application Load refresh confirms the new session. Only same-origin paths
+ * are accepted, so a crafted link cannot send the customer to another site.
+ */
+const origin        = 'http://orionplace.invalid';
+const excludedPaths = ['/profile', '/logout'];
+
+function hasUnsafeCharacters(value: string) {
+  return [...value].some((character) => {
+    const code = character.charCodeAt(0);
+
+    return character === '\\' || code < 32 || code === 127;
+  });
+}
+
+function normalizedPathname(pathname: string) {
+  const trimmed = pathname.replace(/\/+$/, '');
+
+  return (trimmed || '/').toLowerCase();
+}
+
+/** Returns a safe page path such as `/cart?locale=en`, or an empty string. */
+export function signInReturnPath(value: unknown): string {
+  const target        = Array.isArray(value) ? value[0] : value;
+
+  if (typeof target !== 'string' || !target.startsWith('/')) {
+    return '';
+  }
+  if (target.startsWith('//') || hasUnsafeCharacters(target)) {
+    return '';
+  }
+
+  let url: URL;
+
+  try {
+    url = new URL(target, origin);
+  } catch {
+    return '';
+  }
+
+  const isOtherOrigin = url.origin !== origin;
+  const isExcluded    = excludedPaths.includes(normalizedPathname(url.pathname));
+
+  if (isOtherOrigin || isExcluded) {
+    return '';
+  }
+
+  return `${url.pathname}${url.search}${url.hash}`;
+}
+
+/** The page to open after sign-in: the safe target, otherwise the home page. */
+export function signInReturnLocation(value: unknown, locale: string): string {
+  const url = new URL(signInReturnPath(value) || '/', origin);
+
+  if (locale) {
+    url.searchParams.set('locale', locale);
+  }
+
+  return `${url.pathname}${url.search}${url.hash}`;
+}
+
+/**
+ * The sign-in page route that comes back to `returnTo`, for example
+ * `{ path: '/profile', query: { locale: 'en', redirect: '/cart?locale=en' } }`.
+ * An unsafe or excluded target is left out, so sign-in opens the home page.
+ */
+export function signInPageLocation(returnTo: unknown, locale: string) {
+  const redirect                      = signInReturnPath(returnTo);
+  const query: Record<string, string> = { locale };
+  if (redirect) {
+    query.redirect = redirect;
+  }
+
+  return { path: '/profile', query };
+}
+
+/**
+ * The return address that reopens the enrollment dialog of one event, for
+ * example `eventReturnPath('/?locale=en', 4)` gives `/?locale=en&event=4`.
+ */
+export function eventReturnPath(path: string, eventId: number): string {
+  const url = new URL(path, origin);
+
+  url.searchParams.set('event', String(eventId));
+
+  return `${url.pathname}${url.search}${url.hash}`;
+}

package/templates/lib/orionplace/storeDirectory.ts

@@ -0,0 +1,47 @@
+import { deliveryMapPosition } from '@/lib/orionplace/deliveryMap';
+import { getAvailableNestedValueFromObject } from '@/lib/orionplace/presentation';
+import type { IDeliveryMapMarker } from '@/interfaces/orionplace/cart/IDeliveryMap';
+import type { IPhysicalStore } from '@/interfaces/orionplace/stores/IStoreDirectory';
+
+export function storeAddress(item: IPhysicalStore, locale: string) {
+  const city = getAvailableNestedValueFromObject(
+    item.locale,
+    locale,
+    'store_city',
+  );
+
+  return [city, item.line1, item.house_number, item.line2, item.postcode]
+    .filter(Boolean)
+    .join(', ');
+}
+
+export function storeMarkerId(item: IPhysicalStore) {
+  return String(item.id);
+}
+
+export function storeMapMarkers(
+  stores: IPhysicalStore[],
+  locale: string,
+): IDeliveryMapMarker[] {
+  const markers: IDeliveryMapMarker[] = [];
+
+  for (const item of stores) {
+    const position = deliveryMapPosition(
+      item.location?.latitude,
+      item.location?.longitude,
+    );
+    if (position) {
+      markers.push({
+        ...position,
+        id: storeMarkerId(item),
+        title: item.store_name || storeAddress(item, locale),
+      });
+    }
+  }
+
+  return markers;
+}
+
+export function storePhoneLink(value: string) {
+  return `tel:${value.replace(/[^+0-9]/g, '')}`;
+}

package/templates/lib/orionplace/storefrontRecords.ts

@@ -0,0 +1,29 @@
+import type { OrionplaceApi } from '@/lib/orionplace/api';
+import type { IBlogPostsResponse } from '@/interfaces/orionplace/blog/IBlogApi';
+import type { ISubscriptionTariffsResponse } from '@/interfaces/orionplace/subscribes/ISubscriptionApi';
+import type { IProductSearchResponse } from '@/interfaces/orionplace/products/IProductSearchApi';
+
+/** One journal publication, or undefined when the storefront has none with this id. */
+export async function requestPublication(api: OrionplaceApi, id: number) {
+  const data = await api.request<NonNullable<IBlogPostsResponse['page_data']>>(
+    'blog_posts_get',
+    { filters: { id }, paginate: { page: 1, pp_items: 1 } },
+  );
+  return data.posts.data.find((post) => post.id === id);
+}
+
+/** The subscription plan with this id, as the plan page shows it. */
+export function requestTariffs(api: OrionplaceApi, id: number) {
+  return api.request<NonNullable<ISubscriptionTariffsResponse['page_data']>>(
+    'subscriptions_guest_search',
+    { filters: { id } },
+  );
+}
+
+/** One page of the products a promotion applies to, with the promotion itself. */
+export function requestPromoProducts(api: OrionplaceApi, id: number, page: number) {
+  return api.request<NonNullable<IProductSearchResponse['page_data']>>(
+    'products_search',
+    { filters: { is_good_for_promo: id }, paginate: { page, pp_items: 12 } },
+  );
+}

package/templates/lib/orionplace/subscriptionChanges.ts

@@ -0,0 +1,120 @@
+import { tariffAmount, tariffIsOpen } from '@/lib/orionplace/tariffs';
+import type {
+  ISubscribeTariff,
+  ISubscribeTariffOption,
+} from '@/interfaces/orionplace/subscribeTariff/ISubscribeTariff';
+import type { ISubscribe } from '@/interfaces/orionplace/subscribes/ISubscribe';
+import type { ICustomerSubscription } from '@/interfaces/orionplace/subscribes/ISubscriptionApi';
+
+export function subscriptionIsCancelled(
+  subscription: Pick<ICustomerSubscription, 'cancelled_date'>,
+) {
+  return Boolean(subscription.cancelled_date);
+}
+
+export function subscriptionPlanChoices(
+  subscription: Pick<ICustomerSubscription, 'subscription' | 'tariff'>,
+  tariffs: ISubscribeTariff[],
+  subscriptions: ISubscribe[] = [],
+) {
+  return tariffs.filter(
+    (tariff) =>
+      tariff.subscription === subscription.subscription &&
+      tariff.id !== subscription.tariff &&
+      tariffIsOpen(tariff, subscriptions) &&
+      tariff.prices.some((price) => price.days > 0),
+  );
+}
+
+export function subscriptionOptionCost(
+  option: ISubscribeTariffOption,
+  periodId: number,
+) {
+  return option.domain_extras.find(
+    (item) => item.period_id === periodId && item.option_cost_id !== null,
+  );
+}
+
+export interface ISubscriptionChangePeriod {
+  id: number;
+  periodId: number;
+  days: number;
+  amount: number | undefined;
+  optionAmount: number | undefined;
+}
+
+export function subscriptionChangePeriods(
+  plan: ISubscribeTariff | undefined,
+  option: ISubscribeTariffOption | undefined,
+  currencyId: string,
+): ISubscriptionChangePeriod[] {
+  if (!plan) {
+    return [];
+  }
+  return [...plan.prices]
+    .filter((price) => price.days > 0)
+    .filter(
+      (price) =>
+        !option || Boolean(subscriptionOptionCost(option, price.period_id)),
+    )
+    .sort((left, right) => left.days - right.days)
+    .map((price) => {
+      const extra = option
+        ? subscriptionOptionCost(option, price.period_id)
+        : undefined;
+      return {
+        id: price.tariff_cost_id,
+        periodId: price.period_id,
+        days: price.days,
+        amount: tariffAmount(price.amount, currencyId),
+        optionAmount: extra
+          ? tariffAmount(extra.amount, currencyId)
+          : undefined,
+      };
+    });
+}
+
+export function subscriptionOptionChoices(plan: ISubscribeTariff | undefined) {
+  return plan?.options ?? [];
+}
+
+/**
+ * Always false: the storefront backend refuses `subscriptions_change_option`.
+ * Another service option is another server kept in sync with the service, so
+ * a customer who wants it cancels the subscription and subscribes with the
+ * new option.
+ */
+export function subscriptionCanChangeOption(
+  _subscription: Pick<ICustomerSubscription, 'option'>,
+  _plan: ISubscribeTariff | undefined,
+) {
+  return false;
+}
+
+export function subscriptionRefundAmount(
+  subscription: Pick<ICustomerSubscription, 'returned_amount'> | undefined,
+  currencyId: string,
+) {
+  return tariffAmount(subscription?.returned_amount, currencyId);
+}
+
+export function subscriptionChangeTotal(
+  period: ISubscriptionChangePeriod | undefined,
+) {
+  if (!period || period.amount === undefined) {
+    return undefined;
+  }
+  return period.amount + (period.optionAmount ?? 0);
+}
+
+export function subscriptionChangeIsAboveBalance(
+  period: ISubscriptionChangePeriod | undefined,
+  balance: number | undefined,
+  refund?: number,
+) {
+  const total = subscriptionChangeTotal(period);
+  if (total === undefined || balance === undefined) {
+    return false;
+  }
+  return total > balance + (refund ?? 0);
+}

package/templates/lib/orionplace/subscriptionLabels.ts

@@ -0,0 +1,67 @@
+const en = {
+  offers: 'Subscription plans',
+  search: 'Search',
+  mine: 'My subscriptions',
+  emptyOffers: 'No plans match this search.',
+  empty: 'No subscriptions yet.',
+  choose: 'Browse plans',
+  subscription: 'Subscription',
+  created: 'Started',
+  until: 'Active until',
+  renewal: 'Automatic renewal',
+  disabled: 'Off',
+  days: 'days',
+  stop: 'Disable',
+  stopHint: 'Turn off automatic renewal',
+  stopQuestion:
+    'Turn off automatic renewal? Your current paid period will remain available.',
+  confirmed: 'Subscription purchased. Your account has been updated.',
+  refreshRequired:
+    'The action succeeded. Refresh the account details to see the result.',
+  intro:
+    'Choose a plan and a subscription period. Paid periods are charged to the account balance.',
+  noOffers: 'No subscription plans are available yet.',
+  reset: 'Reset',
+  support: 'Subscription support',
+  wallet: 'Top up balance',
+  searchHint: 'Search by plan name',
+  filtered: 'Only the plans from the opened link are shown.',
+  allPlans: 'All',
+  allPlansHint: 'Show all plans',
+  emptyIds: 'The plans from this link are not available.',
+};
+const ru: typeof en = {
+  offers: 'Тарифы подписок',
+  search: 'Найти',
+  mine: 'Мои подписки',
+  emptyOffers: 'По этому запросу тарифов нет.',
+  empty: 'Подписок пока нет.',
+  choose: 'Выбрать тариф',
+  subscription: 'Подписка',
+  created: 'Дата подключения',
+  until: 'Действует до',
+  renewal: 'Автопродление',
+  disabled: 'Выключено',
+  days: 'дней',
+  stop: 'Отключить',
+  stopHint: 'Отключить автопродление',
+  stopQuestion:
+    'Выключить автопродление? Текущий оплаченный период останется доступен.',
+  confirmed: 'Подписка подключена. Данные аккаунта обновлены.',
+  refreshRequired:
+    'Действие выполнено. Обновите данные аккаунта, чтобы увидеть результат.',
+  intro:
+    'Выберите тариф и период подписки. Платные периоды оплачиваются с баланса аккаунта.',
+  noOffers: 'Тарифов подписок пока нет.',
+  reset: 'Сбросить',
+  support: 'Поддержка по подписке',
+  wallet: 'Пополнить баланс',
+  searchHint: 'Поиск по названию тарифа',
+  filtered: 'Показаны только тарифы из открытой ссылки.',
+  allPlans: 'Все',
+  allPlansHint: 'Показать все тарифы',
+  emptyIds: 'Тарифы из этой ссылки недоступны.',
+};
+export function subscriptionLabels(locale: string) {
+  return locale.toLowerCase().startsWith('ru') ? ru : en;
+}