orionplace-react 0.1.0 → 0.2.0

package/templates/hooks/useOrionplaceTariffPurchase.ts

@@ -0,0 +1,152 @@
+'use client';
+
+import { useEffect, useRef, useState } from 'react';
+import type { IProfileResponse } from '@/interfaces/orionplace/accounts/IProfileData';
+import type { ITariffSubscribeRequest } from '@/interfaces/orionplace/subscribeTariff/ITariffSelection';
+import type { ICustomerSubscriptionsResponse } from '@/interfaces/orionplace/subscribes/ISubscriptionApi';
+import { apiErrorMessage } from '@/lib/orionplace/api';
+
+type SubscriptionsPage = NonNullable<
+  ICustomerSubscriptionsResponse['page_data']
+>;
+type ProfilePage = NonNullable<IProfileResponse['page_data']>;
+
+export interface TariffSubscribeAction {
+  endpoint: 'subscriptions_subscribe';
+  request: ITariffSubscribeRequest;
+  signal: AbortSignal;
+}
+
+export interface TariffSubscriptionsRefreshAction {
+  endpoint: 'subscriptions_get';
+  request: Record<string, never>;
+  signal: AbortSignal;
+}
+
+export interface TariffProfileRefreshAction {
+  endpoint: 'profile_get';
+  request: { filters: Record<string, never> };
+  signal: AbortSignal;
+}
+
+export interface TariffPurchaseActions {
+  onSubscribe: (action: TariffSubscribeAction) => Promise<void> | void;
+  onLoadSubscriptions: (
+    action: TariffSubscriptionsRefreshAction,
+  ) => Promise<SubscriptionsPage> | SubscriptionsPage;
+  onLoadProfile: (
+    action: TariffProfileRefreshAction,
+  ) => Promise<ProfilePage> | ProfilePage;
+  onAccountLoaded?: (
+    subscriptions: SubscriptionsPage,
+    profile: ProfilePage,
+  ) => void;
+}
+
+export function useOrionplaceTariffPurchase(
+  actions: TariffPurchaseActions,
+  fallbackError: string,
+) {
+  const callbacks = useRef(actions);
+  callbacks.current = actions;
+  const active = useRef<AbortController | undefined>(undefined);
+  const purchased = useRef('');
+  const [pending, setPending] = useState(false);
+  const [error, setError] = useState('');
+  const [completed, setCompleted] = useState(false);
+  const [needsRefresh, setNeedsRefresh] = useState(false);
+
+  async function loadAccount(controller: AbortController) {
+    const subscriptions = await callbacks.current.onLoadSubscriptions({
+      endpoint: 'subscriptions_get',
+      request: {},
+      signal: controller.signal,
+    });
+    const profile = await callbacks.current.onLoadProfile({
+      endpoint: 'profile_get',
+      request: { filters: {} },
+      signal: controller.signal,
+    });
+    if (controller.signal.aborted) {
+      return;
+    }
+    callbacks.current.onAccountLoaded?.(subscriptions, profile);
+    setNeedsRefresh(false);
+  }
+
+  async function run(work: (controller: AbortController) => Promise<void>) {
+    if (active.current) {
+      return;
+    }
+    const controller = new AbortController();
+    active.current = controller;
+    setPending(true);
+    setError('');
+    try {
+      await work(controller);
+    } catch (reason) {
+      if (!controller.signal.aborted) {
+        setError(
+          apiErrorMessage(reason) || fallbackError,
+        );
+      }
+    } finally {
+      if (active.current === controller) {
+        active.current = undefined;
+        setPending(false);
+      }
+    }
+  }
+
+  function subscribe(request: ITariffSubscribeRequest) {
+    const payload = JSON.stringify(request);
+    if (
+      pending ||
+      needsRefresh ||
+      (completed && purchased.current === payload)
+    ) {
+      return;
+    }
+    purchased.current = payload;
+    setCompleted(false);
+    return run(async (controller) => {
+      await callbacks.current.onSubscribe({
+        endpoint: 'subscriptions_subscribe',
+        request,
+        signal: controller.signal,
+      });
+      if (controller.signal.aborted) {
+        return;
+      }
+      setCompleted(true);
+      setNeedsRefresh(true);
+      await loadAccount(controller);
+    });
+  }
+
+  function refresh() {
+    if (!needsRefresh || pending) {
+      return;
+    }
+    return run(loadAccount);
+  }
+
+  function resetFeedback() {
+    if (!pending) {
+      setCompleted(false);
+      setError('');
+    }
+  }
+
+  useEffect(() => () => active.current?.abort(), []);
+
+  return {
+    pending,
+    error,
+    completed,
+    needsRefresh,
+    subscribe,
+    refresh,
+    resetFeedback,
+  };
+}

package/templates/interfaces/orionplace/accounts/IContact.ts

@@ -0,0 +1,21 @@
+import type { ApiFormError } from '@/interfaces/orionplace/transport';
+
+export interface IContactRequest {
+  email: string;
+  full_name: string;
+  message: string;
+  captcha: string;
+}
+
+export interface IUnsubscribeRequest {
+  hash: string;
+  unsubcribe_type: 'newsletter' | 'products';
+}
+
+export interface ICaptchaResponse {
+  form_errors: Record<string, ApiFormError[]> | null;
+  success_message: string | null;
+  page_data: {
+    image: string;
+  } | null;
+}

package/templates/interfaces/orionplace/accounts/IEmailNotificationLocale.ts

@@ -0,0 +1,17 @@
+import type { ApiFormError } from '@/interfaces/orionplace/transport';
+
+export interface IEmailNotificationLocaleRequest {
+  email_notification_locale: string;
+}
+
+export interface IEmailNotificationLocaleResponse {
+  form_errors: Record<string, ApiFormError[]> | null;
+  success_message: string | null;
+  page_data: {
+    email_notification_locale: {
+      id: number;
+      locale_key: string;
+      human_name: string;
+    };
+  } | null;
+}

package/templates/interfaces/orionplace/accounts/IEmailVerification.ts

@@ -0,0 +1,59 @@
+import type { ApiFormError } from '@/interfaces/orionplace/transport';
+
+export interface IAuthOtpResendRequest {
+  purpose: 'auth' | 'reg';
+}
+
+export interface IAuthOtpResendResponse {
+  form_errors: Record<string, ApiFormError[]> | null;
+  success_message: string | null;
+  page_data: {
+    otp_delay: number;
+    code_type?: 'sms' | 'call' | 'email';
+    email?: string;
+  } | null;
+}
+
+export type IEmailEnrollRequest =
+  | {
+      step: 'step_email';
+      email: string;
+    }
+  | {
+      step: 'step_email_code';
+      code: string;
+    };
+
+export interface IEmailEnrollResponse {
+  form_errors: Record<string, ApiFormError[]> | null;
+  success_message: string | null;
+  page_data: {
+    next_step: 'step_email' | 'step_email_code';
+  } | null;
+}
+
+export interface IProfileNotificationSetting {
+  template_type: string;
+  label: string;
+  description: string;
+  icon: string;
+  enabled: boolean;
+  eligible: boolean;
+  required: boolean;
+}
+
+export interface IProfileNotificationSettingsRequest {
+  settings?: Array<
+    Pick<IProfileNotificationSetting, 'template_type' | 'enabled'>
+  >;
+  enabled?: boolean;
+}
+
+export interface IProfileNotificationSettingsResponse {
+  form_errors: Record<string, ApiFormError[]> | null;
+  success_message: string | null;
+  page_data: {
+    settings?: IProfileNotificationSetting[];
+    notifications_enabled?: boolean;
+  } | null;
+}

package/templates/interfaces/orionplace/accounts/IProfileActions.ts

@@ -0,0 +1,38 @@
+import type { ApiFormError } from '@/interfaces/orionplace/transport';
+
+export interface ICustomerMutationResponse {
+  form_errors: Record<string, ApiFormError[]> | null;
+  success_message: string | null;
+  page_data: null;
+}
+
+export interface IProfilePasswordRequest {
+  old_password?: string;
+  new_password: string;
+  confirm_password: string;
+}
+
+// The password is sent only when the account has one.
+export interface IProfileDeleteRequest {
+  password?: string;
+  confirm: true;
+}
+
+export interface IProfileUpdateRequest {
+  first_name: string;
+  last_name: string;
+  dob?: string;
+  email_notification_locale?: string;
+}
+
+export interface IProfileSearchUpdateRequest {
+  ls_history: string[] | string;
+}
+
+export interface IProfileSearchUpdateResponse {
+  form_errors: Record<string, ApiFormError[]> | null;
+  success_message: string | null;
+  page_data: {
+    added_updated: number;
+  } | null;
+}

package/templates/interfaces/orionplace/accounts/IProfileData.ts

@@ -0,0 +1,123 @@
+import type { ApiFormError } from '@/interfaces/orionplace/transport';
+import type { ITransformValue } from '@/interfaces/orionplace/shared/ITransformValue';
+
+export interface IApiPaginationRequest {
+  page?: number;
+  pp_items?: number;
+}
+
+export interface IApiPagination {
+  has_next: boolean;
+  has_previous: boolean;
+  has_other_pages: boolean;
+  next_page_number: number | true | null;
+  previous_page_number: number | null;
+  start_index: number;
+  end_index: number;
+  page: number;
+  total_count?: number;
+  selected_count?: number;
+  pages?: number;
+}
+
+export interface IApiDateTime {
+  date: string;
+  time: string;
+  days_ago: number | string;
+  minutes_ago?: number | string;
+  word: [number, string] | string;
+}
+
+export interface IProfileData {
+  id: number;
+  phone: string;
+  first_name: string;
+  last_name: string;
+  email: string;
+  email_notification_locale: string;
+  last_login: IApiDateTime | null;
+  date_joined: IApiDateTime | null;
+  dob: string;
+  profile_avatar: string | null;
+  notifications_enabled: boolean;
+  orders_allowed: boolean;
+  subscriptions_allowed: boolean;
+  wallet: Record<string, ITransformValue>;
+}
+
+export interface IProfileRequest {
+  filters?: {
+    phone?: string;
+    first_name?: string;
+    last_name?: string;
+    email?: string;
+  };
+}
+
+export interface IProfileResponse {
+  form_errors: Record<string, ApiFormError[]> | null;
+  success_message: string | null;
+  page_data: {
+    profile_info: IProfileData[];
+  } | null;
+}
+
+export interface IProfileSearchHistoryRequest {
+  filters?: {
+    query?: string;
+  };
+  paginate?: IApiPaginationRequest;
+}
+
+export interface IProfileSearchHistoryResponse {
+  form_errors: Record<string, ApiFormError[]> | null;
+  success_message: string | null;
+  page_data: {
+    data: {
+      id: number;
+      q: string;
+    }[];
+    rpag: IApiPagination | null;
+  } | null;
+}
+
+export interface IProfileLogsRequest {
+  filters?: {
+    remote_addr?: string;
+    remote_ua?: string;
+    time_of_log_from?: string;
+    time_of_log_to?: string;
+    ordering?: 'id' | '-id' | 'time_of_log' | '-time_of_log';
+  };
+  paginate?: IApiPaginationRequest;
+}
+
+export interface IProfileLog {
+  id: number;
+  remote_addr: string;
+  remote_city: string;
+  remote_ua: string;
+  time_of_log: IApiDateTime | null;
+  log_type: 'SUCCESS';
+  browser_family: string | null;
+  browser_version: string | null;
+  os_family: string | null;
+  os_version: string | null;
+  device_family: string | null;
+  device_brand: string | null;
+  device_model: string | null;
+  is_mobile: boolean;
+  is_tablet: boolean;
+  is_pc: boolean;
+  is_touch_capable: boolean;
+  domain_id: number | null;
+}
+
+export interface IProfileLogsResponse {
+  form_errors: Record<string, ApiFormError[]> | null;
+  success_message: string | null;
+  page_data: {
+    data: IProfileLog[];
+    rpag: IApiPagination | null;
+  } | null;
+}

package/templates/interfaces/orionplace/accounts/IProfileMedia.ts

@@ -0,0 +1,17 @@
+import type { ApiFormError } from '@/interfaces/orionplace/transport';
+
+export interface IProfileAvatarRequest {
+  profile_avatar: File;
+}
+
+export interface IProfileAvatarResponse {
+  form_errors: Record<string, ApiFormError[]> | null;
+  success_message: string | null;
+  page_data: {
+    avatar: string | null;
+  } | null;
+}
+
+export interface IProfileEventRequest {
+  event: number | string;
+}

package/templates/interfaces/orionplace/accounts/IStorefrontProfile.ts

@@ -0,0 +1,54 @@
+import type {
+  IProfileUpdateRequest,
+  IProfilePasswordRequest,
+  IProfileDeleteRequest,
+} from './IProfileActions';
+
+export interface IStorefrontProfileState {
+  loaded: boolean;
+  pending: string;
+  error: string;
+  errors: Record<string, string>;
+  message: string;
+  saved: number;
+  emailStep: 'step_email' | 'step_email_code';
+  notificationLocale: string;
+  authStep: 'step_phone' | 'step_password' | 'step_otp' | 'step_additional';
+  authPurpose: 'auth' | 'reg';
+  authCodeType: '' | 'sms' | 'call' | 'email';
+  authEmail: string;
+  otpDelay: number;
+  refreshRequired: boolean;
+}
+
+export type IStorefrontProfileAction =
+  | {
+      action:
+        'load' | 'refresh' | 'avatar-delete' | 'auth-resend' | 'auth-restart';
+    }
+  | { action: 'details'; data: IProfileUpdateRequest }
+  | { action: 'password'; data: IProfilePasswordRequest }
+  | { action: 'delete-account'; data: IProfileDeleteRequest }
+  | { action: 'avatar-add'; file: File }
+  | {
+      action: 'email';
+      data:
+        | { step: 'step_email'; email: string }
+        | { step: 'step_email_code'; code: string };
+    }
+  | { action: 'notifications'; data: { enabled: boolean } }
+  | {
+      action: 'notification-locale';
+      data: { email_notification_locale: string };
+    }
+  | {
+      action: 'authenticate';
+      data: {
+        step: IStorefrontProfileState['authStep'];
+        phone?: string;
+        auth_password?: string;
+        otp_code?: string;
+        first_name?: string;
+        last_name?: string;
+      };
+    };

package/templates/interfaces/orionplace/address/IAddressCitySuggestion.ts

@@ -0,0 +1,19 @@
+import type { ApiFormError } from '@/interfaces/orionplace/transport';
+
+export interface IAddressCitySuggestionRequest {
+  country: number | string;
+  region: number | string;
+  search_string: string;
+}
+
+export interface IAddressCitySuggestion {
+  city: string;
+  postal_code: string | null;
+}
+
+export interface IAddressCitySuggestionResponse {
+  form_errors: Record<string, ApiFormError[]> | null;
+  success_message: string | null;
+  page_data: IAddressCitySuggestion[] | null;
+  url_name?: 'address_hints_suggest_city';
+}

package/templates/interfaces/orionplace/address/IAddressEditor.ts

@@ -0,0 +1,9 @@
+import type { IAddressCountry } from '@/interfaces/orionplace/address/IUserAddress';
+
+export interface IAddressCountryOption {
+  value: number;
+  locale: IAddressCountry['locale'];
+  iso_3166_1_a2: string;
+  suggestions: boolean;
+  is_shipping_country: boolean;
+}

package/templates/interfaces/orionplace/address/IAddressLocationSuggestion.ts

@@ -0,0 +1,22 @@
+import type { ApiFormError } from '@/interfaces/orionplace/transport';
+
+export interface IAddressLocationSuggestionRequest {
+  longitude: number | string;
+  latitude: number | string;
+}
+
+export interface IAddressLocationSuggestion {
+  country_code: string | null;
+  region_code: string | null;
+  postal_code: string | null;
+  city: string | null;
+  street: string | null;
+  house: string | null;
+}
+
+export interface IAddressLocationSuggestionResponse {
+  form_errors: Record<string, ApiFormError[]> | null;
+  success_message: string | null;
+  page_data: IAddressLocationSuggestion[] | null;
+  url_name?: 'address_hints_suggest_location';
+}

package/templates/interfaces/orionplace/address/IAddressRegionSearch.ts

@@ -0,0 +1,30 @@
+import type { ApiFormError } from '@/interfaces/orionplace/transport';
+
+export interface IAddressRegionSearchFilters {
+  region_name?: string;
+  country?: number;
+  ordering?: 'id' | '-id';
+}
+
+export interface IAddressRegionSearchRequest {
+  filters?: IAddressRegionSearchFilters;
+}
+
+export interface IAddressRegionLocale {
+  region_name?: string;
+}
+
+export interface IAddressRegion {
+  id: number;
+  locales: Record<string, IAddressRegionLocale>;
+  country: string;
+  country_id: number;
+  region_iso: string;
+}
+
+export interface IAddressRegionSearchResponse {
+  form_errors: Record<string, ApiFormError[]> | null;
+  success_message: string | null;
+  page_data: IAddressRegion[] | null;
+  url_name?: 'address_hints_region_search';
+}

package/templates/interfaces/orionplace/address/IAddressSuggestion.ts

@@ -0,0 +1,20 @@
+import type { ApiFormError } from '@/interfaces/orionplace/transport';
+
+export interface IAddressSuggestionRequest {
+  country: number | string;
+  region: number | string;
+  city: string;
+  address_string: string;
+}
+
+export interface IAddressSuggestion {
+  street: string;
+  postal_code: string | null;
+}
+
+export interface IAddressSuggestionResponse {
+  form_errors: Record<string, ApiFormError[]> | null;
+  success_message: string | null;
+  page_data: IAddressSuggestion[] | null;
+  url_name?: 'address_hints_suggest';
+}

package/templates/interfaces/orionplace/address/IUserAddress.ts

@@ -0,0 +1,87 @@
+import type { ApiFormError } from '@/interfaces/orionplace/transport';
+import type { IAddressRegion } from '@/interfaces/orionplace/address/IAddressRegionSearch';
+
+export interface IAddressCountry {
+  id: number;
+  iso_3166_1_a2: string;
+  iso_3166_1_a3: string;
+  iso_3166_1_numeric: string;
+  locale: Record<string, {
+    printable_name?: string;
+  }>;
+  is_shipping_country: boolean;
+}
+
+export interface IUserAddress {
+  id: number;
+  address_label: string;
+  line1: string;
+  line2: string;
+  city: string;
+  state: IAddressRegion | null;
+  postcode: string;
+  country: IAddressCountry | null;
+  house_number: string;
+  entrance: string;
+  intercom: string;
+  floor: string;
+  apt_number: string;
+  is_default_for_shipping: boolean;
+  is_default_for_billing: boolean;
+}
+
+export interface IUserAddressRequest {
+  address_label: string;
+  line1: string;
+  line2?: string;
+  city: string;
+  state: number;
+  postcode?: string;
+  country: number;
+  house_number: string;
+  entrance?: string;
+  intercom?: string;
+  floor?: string;
+  apt_number?: string;
+  is_default_for_shipping?: boolean;
+}
+
+export interface IUserAddressListRequest {
+  filters?: {
+    id?: number;
+    ordering?: 'id' | '-id';
+  };
+}
+
+export interface IUserAddressShippingRequest {
+  is_default_for_shipping: boolean;
+}
+
+export interface IUserAddressListResponse {
+  form_errors: Record<string, ApiFormError[]> | null;
+  success_message: string | null;
+  page_data: {
+    countries: IAddressCountry[];
+    addresses: IUserAddress[];
+  } | null;
+}
+
+export interface IUserAddressSaveResponse {
+  form_errors: Record<string, ApiFormError[]> | null;
+  success_message: string | null;
+  page_data: IUserAddress[] | null;
+}
+
+export interface IUserAddressDeleteResponse {
+  form_errors: Record<string, ApiFormError[]> | null;
+  success_message: string | null;
+  page_data: {
+    another_default: number;
+  } | null;
+}
+
+export interface IUserAddressShippingResponse {
+  form_errors: Record<string, ApiFormError[]> | null;
+  success_message: string | null;
+  page_data: null;
+}

package/templates/interfaces/orionplace/appBase/IAppLoad.ts

@@ -1,12 +1,13 @@
-import type { IAppLoadCommon } from './IAppLoadCommon';
-import type { IApploadUserProfile } from './IApploadUserProfile';
-import type { IAppLoadPathsRecord } from './appLoadCommon/IAppLoadCommonPath';
+import type { IAppLoadCommon } from '@/interfaces/orionplace/appBase/IAppLoadCommon';
+import type { IApploadUserProfile } from '@/interfaces/orionplace/appBase/IApploadUserProfile';
+import type { IAppLoadPathsRecord } from '@/interfaces/orionplace/appBase/appLoadCommon/IAppLoadCommonPath';
 
 export interface IAppLoad {
 	init: IAppLoadCommon;
 	unauth: IAppLoadPathsRecord;
 	user?: IApploadUserProfile;
 	auth?: IAppLoadPathsRecord;
+	seller_panel_enabled?: boolean;
 	view_key?: string;
 	spent_total?: number;
 	spent_init?: number;