@eventlook/sdk 1.4.0

package/src/utils/gtm.ts

@@ -0,0 +1,233 @@
+import { isBrowser } from '@utils/isBrowser';
+import Cookies from 'js-cookie';
+import {
+  IPageView,
+  IPageType,
+  ISearchShow,
+  IViewItem,
+  IEcommerce,
+  ICheckout,
+  IEcommerceCartItems,
+  IAddPaymentInfo,
+  IPurchase,
+  IEcommercePurchase,
+  IUserData,
+  IPixels,
+  IViewItemList,
+  ISelectItem,
+  IAddToCart,
+  IRemoveFromCart,
+} from '@utils/types/gtm.type';
+import { UserIpCookie } from '@utils/data/cookie';
+import { IUser } from '@utils/types/user.type';
+
+export const getGtmPageView = (url: string, userData?: IUserData) => {
+  const userIp = Cookies.get(UserIpCookie);
+  const pageEvent: IPageView = {
+    event: 'page_view',
+    page: url,
+    ip: userIp || '',
+    user_data: userData || null,
+  };
+
+  return pageEvent;
+};
+
+export const gtmPageView = (url: string, userData?: IUserData) => {
+  const pageEvent = getGtmPageView(url, userData);
+  if (isBrowser() && window.dataLayer) window.dataLayer.push(pageEvent);
+  return pageEvent;
+};
+
+export const gtmPageType = (type: string) => {
+  const cookie = Cookies.get('_ga');
+  const userIp = Cookies.get(UserIpCookie);
+  const pageEvent: IPageType = {
+    visitorType: cookie ? 'returning' : 'new',
+    clientID: cookie,
+    pageType: type,
+    ip: userIp || '',
+  };
+  if (isBrowser() && window.dataLayer) window.dataLayer.push(pageEvent);
+  return pageEvent;
+};
+
+export const gtmSearchShow = () => {
+  const userIp = Cookies.get(UserIpCookie);
+  const pageEvent: ISearchShow = {
+    event: 'search',
+    eventAction: 'showSearchWindow',
+    ip: userIp || '',
+  };
+  if (isBrowser() && window.dataLayer) window.dataLayer.push(pageEvent);
+  return pageEvent;
+};
+
+export const gtmSearchInSearchWindow = () => {
+  const userIp = Cookies.get(UserIpCookie);
+  const pageEvent: ISearchShow = {
+    event: 'search',
+    eventAction: 'userSearchInSearchWindow',
+    ip: userIp || '',
+  };
+  if (isBrowser() && window.dataLayer) window.dataLayer.push(pageEvent);
+  return pageEvent;
+};
+
+export const gtmViewItem = (item: IEcommerce, pixels?: IPixels, userData?: IUserData) => {
+  const userIp = Cookies.get(UserIpCookie);
+  const pageEvent: IViewItem & IPixels = {
+    event: 'view_item',
+    fb_pixel_id: pixels?.fb_pixel_id || '',
+    tiktok_pixel_id: pixels?.tiktok_pixel_id || '',
+    ecommerce: item,
+    ip: userIp || '',
+    user_data: userData || null,
+  };
+  if (isBrowser() && window.dataLayer) setTimeout(() => window.dataLayer.push(pageEvent), 500);
+  return pageEvent;
+};
+
+export const gtmViewItemList = () => {
+  const userIp = Cookies.get(UserIpCookie);
+  const pageEvent: IViewItemList = {
+    event: 'view_item_list',
+    ip: userIp || '',
+  };
+  if (isBrowser() && window.dataLayer) setTimeout(() => window.dataLayer.push(pageEvent), 500);
+  return pageEvent;
+};
+
+export const gtmSelectItem = () => {
+  const userIp = Cookies.get(UserIpCookie);
+  const pageEvent: ISelectItem = {
+    event: 'select_item',
+    ip: userIp || '',
+  };
+  if (isBrowser() && window.dataLayer) window.dataLayer.push(pageEvent);
+  return pageEvent;
+};
+
+export const getGtmBeginCheckout = (item: IEcommerce, pixels?: IPixels, userData?: IUserData) => {
+  const userIp = Cookies.get(UserIpCookie);
+  const pageEvent: ICheckout & IPixels = {
+    event: 'begin_checkout',
+    fb_pixel_id: pixels?.fb_pixel_id || '',
+    tiktok_pixel_id: pixels?.tiktok_pixel_id || '',
+    ecommerce: item,
+    ip: userIp || '',
+    user_data: userData || null,
+  };
+
+  return pageEvent;
+};
+
+export const gtmBeginCheckout = (item: IEcommerce, pixels?: IPixels, userData?: IUserData) => {
+  const pageEvent = getGtmBeginCheckout(item, pixels, userData);
+  if (isBrowser() && window.dataLayer) window.dataLayer.push(pageEvent);
+  return pageEvent;
+};
+
+export const getGtmViewCart = (item: IEcommerce, pixels?: IPixels) => {
+  const userIp = Cookies.get(UserIpCookie);
+  const pageEvent: ICheckout & IPixels = {
+    event: 'view_cart',
+    fb_pixel_id: pixels?.fb_pixel_id || '',
+    tiktok_pixel_id: pixels?.tiktok_pixel_id || '',
+    ecommerce: item,
+    ip: userIp || '',
+  };
+
+  return pageEvent;
+};
+
+export const gtmViewCart = (item: IEcommerce, pixels?: IPixels) => {
+  const pageEvent = getGtmViewCart(item, pixels);
+  if (isBrowser() && window.dataLayer) setTimeout(() => window.dataLayer.push(pageEvent), 500);
+  return pageEvent;
+};
+
+export const gtmAddToCart = (pixels?: IPixels, userData?: IUserData) => {
+  const userIp = Cookies.get(UserIpCookie);
+  const pageEvent: IAddToCart & IPixels = {
+    event: 'add_to_cart',
+    fb_pixel_id: pixels?.fb_pixel_id || '',
+    tiktok_pixel_id: pixels?.tiktok_pixel_id || '',
+    ip: userIp || '',
+    user_data: userData || null,
+  };
+  if (isBrowser() && window.dataLayer) window.dataLayer.push(pageEvent);
+  return pageEvent;
+};
+
+export const gtmRemoveFromCart = (item: IEcommerceCartItems, pixels?: IPixels) => {
+  const userIp = Cookies.get(UserIpCookie);
+  const pageEvent: IRemoveFromCart & IPixels = {
+    event: 'remove_from_cart',
+    fb_pixel_id: pixels?.fb_pixel_id || '',
+    tiktok_pixel_id: pixels?.tiktok_pixel_id || '',
+    ecommerce: item,
+    ip: userIp || '',
+  };
+  if (isBrowser() && window.dataLayer) window.dataLayer.push(pageEvent);
+  return pageEvent;
+};
+
+export const getGtmAddPaymentInfo = (
+  item: IEcommerceCartItems,
+  pixels?: IPixels,
+  userData?: IUserData
+) => {
+  const userIp = Cookies.get(UserIpCookie);
+  const pageEvent: IAddPaymentInfo & IPixels = {
+    event: 'add_payment_info',
+    fb_pixel_id: pixels?.fb_pixel_id || '',
+    tiktok_pixel_id: pixels?.tiktok_pixel_id || '',
+    ecommerce: item,
+    ip: userIp || '',
+    user_data: userData || null,
+  };
+
+  return pageEvent;
+};
+
+export const gtmAddPaymentInfo = (item: IEcommerceCartItems, pixels?: IPixels) => {
+  const pageEvent = getGtmAddPaymentInfo(item, pixels);
+  if (isBrowser() && window.dataLayer) setTimeout(() => window.dataLayer.push(pageEvent), 500);
+  return pageEvent;
+};
+
+export const getGtmPurchase = (
+  item: IEcommercePurchase | null,
+  pixels?: IPixels,
+  userData?: IUserData
+) => {
+  const userIp = Cookies.get(UserIpCookie);
+  const pageEvent: IPurchase & IPixels = {
+    event: 'purchase',
+    fb_pixel_id: pixels?.fb_pixel_id || '',
+    tiktok_pixel_id: pixels?.tiktok_pixel_id || '',
+    ecommerce: item,
+    user_data: userData || null,
+    ip: userIp || '',
+  };
+
+  return pageEvent;
+};
+
+export const gtmPurchase = (
+  item: IEcommercePurchase | null,
+  pixels?: IPixels,
+  userData?: IUserData
+) => {
+  const pageEvent = getGtmPurchase(item, pixels, userData);
+  if (isBrowser() && window.dataLayer) setTimeout(() => window.dataLayer.push(pageEvent), 500);
+  return pageEvent;
+};
+
+export const mapUserToUserData = (user: IUser) => ({
+  em: user.email,
+  ph: user.phone,
+  ln: user.lastName,
+  fn: user.firstName,
+});

package/src/utils/isBrowser.ts

@@ -0,0 +1 @@
+export const isBrowser = (): boolean => typeof window !== 'undefined';

package/src/utils/place.ts

@@ -0,0 +1,4 @@
+import { IPlace } from '@utils/types/place.type';
+
+export const getPlaceAsString = (place: IPlace) =>
+  `${place.name} - ${place.address}, ${place.zip} ${place.city}`;

package/src/utils/price.ts

@@ -0,0 +1,31 @@
+import { fCurrency, fCurrencyPlain } from '@utils/formatNumber';
+import { Currencies } from '@utils/data/currency';
+
+export const getBetweenPrice = (
+  firstPrice: number,
+  secondPrice: number,
+  currentLangValue: string,
+  currency: Currencies
+) => {
+  if (currentLangValue === 'en') {
+    return `${fCurrency(firstPrice, currentLangValue, currency)} - ${fCurrencyPlain(secondPrice)}`;
+  }
+
+  return `${fCurrencyPlain(firstPrice)} - ${fCurrency(secondPrice, currentLangValue, currency)}`;
+};
+
+export const calculatePriceWithPercentage = (price: number, vatPercentage: number) =>
+  Math.ceil(price * ((100 + vatPercentage) / 100) * 100) / 100;
+
+export const calculatePriceWithoutPercentage = (price: number, vatPercentage: number) =>
+  Math.ceil(price * ((100 - vatPercentage) / 100) * 100) / 100;
+
+export const calculatePriceWithDiscount = (
+  price: number,
+  discountPercent = 0,
+  fixedDiscount = 0
+) => {
+  const discountedPrice = calculatePriceWithoutPercentage(price, discountPercent);
+  const finalPrice = Math.max(discountedPrice - fixedDiscount, 0);
+  return Math.ceil(finalPrice * 100) / 100;
+};

package/src/utils/product.ts

@@ -0,0 +1,30 @@
+import { IEventProductForm } from '@utils/types/product.type';
+import { ITicketFormTicket } from '@utils/types/ticket.type';
+
+export const getSelectedQuantityByVariant = (
+  products: IEventProductForm[],
+  tickets: ITicketFormTicket[]
+) => {
+  const result: Record<number, number> = {};
+  for (const product of products) {
+    if (result[product.eventProductVariantId]) {
+      result[product.eventProductVariantId] += product.quantity;
+    } else {
+      result[product.eventProductVariantId] = product.quantity;
+    }
+  }
+
+  for (const ticket of tickets) {
+    if (ticket.products) {
+      for (const product of ticket.products) {
+        if (result[product.eventProductVariantId]) {
+          result[product.eventProductVariantId] += product.quantity;
+        } else {
+          result[product.eventProductVariantId] = product.quantity;
+        }
+      }
+    }
+  }
+
+  return result;
+};

package/src/utils/translation.ts

@@ -0,0 +1,4 @@
+import { ITranslationValue } from '@utils/types/translation.type';
+
+export const getTranslation = (translation: ITranslationValue[], locale: string): string =>
+  translation.find((t) => t.locale === locale)?.text || '';

package/src/utils/types/animate.ts

@@ -0,0 +1,42 @@
+type EaseType =
+  | 'linear'
+  | 'easeIn'
+  | 'easeOut'
+  | 'easeInOut'
+  | 'circIn'
+  | 'circOut'
+  | 'circInOut'
+  | 'backIn'
+  | 'backOut'
+  | 'backInOut'
+  | 'anticipate'
+  | number[];
+
+export type VariantsType = {
+  distance?: number;
+  durationIn?: number;
+  durationOut?: number;
+  easeIn?: EaseType;
+  easeOut?: EaseType;
+};
+
+export type TranHoverType = {
+  duration?: number;
+  ease?: EaseType;
+};
+
+export type TranEnterType = {
+  durationIn?: number;
+  easeIn?: EaseType;
+};
+
+export type TranExitType = {
+  durationOut?: number;
+  easeOut?: EaseType;
+};
+
+export type BackgroundType = {
+  colors?: string[];
+  duration?: number;
+  ease?: EaseType;
+};

package/src/utils/types/artist.type.ts

@@ -0,0 +1,18 @@
+import { IBase } from '@utils/types/global.type';
+import { IFile } from '@utils/types/file.type';
+import { ITranslation } from '@utils/types/translation.type';
+import { ICountry } from '@utils/types/country.type';
+
+export interface IArtist extends IBase {
+  name: string;
+  slug: string;
+  description: string;
+  image: IFile;
+  category: ITranslation;
+  countEvents: number;
+  countFollowers: number;
+  likedByCurrentUser?: boolean;
+  spotify: string | null;
+  instagram: string | null;
+  nationality: ICountry;
+}

package/src/utils/types/company.type.ts

@@ -0,0 +1,13 @@
+import { IBase } from '@utils/types/global.type';
+
+export interface ICompany extends IBase {
+  name: string;
+  displayName: string;
+  cin: string;
+  tin: string;
+  headquarters: string;
+  instagramUrl: string;
+  facebookUrl: string;
+  active: boolean;
+  verified: boolean;
+}

package/src/utils/types/country.type.ts

@@ -0,0 +1,40 @@
+import { IBase } from '@utils/types/global.type';
+
+export interface ICountry extends IBase {
+  alpha2: string;
+  alpha3: string;
+  ar: string;
+  bg: string;
+  cs: string;
+  da: string;
+  de: string;
+  el: string;
+  en: string;
+  eo: string;
+  es: string;
+  et: string;
+  eu: string;
+  fi: string;
+  fr: string;
+  hr: string;
+  hu: string;
+  hy: string;
+  it: string;
+  ja: string;
+  ko: string;
+  lt: string;
+  nl: string;
+  no: string;
+  pl: string;
+  pt: string;
+  ro: string;
+  ru: string;
+  sk: string;
+  sl: string;
+  sr: string;
+  sv: string;
+  th: string;
+  uk: string;
+  zh: string;
+  zhTw: string;
+}

package/src/utils/types/customer.type.ts

@@ -0,0 +1,11 @@
+import { IBase } from '@utils/types/global.type';
+import { Gender } from '@utils/data/gender';
+
+export interface ICustomer extends IBase {
+  firstName: string;
+  lastName: string;
+  email: string;
+  phone: string;
+  birthdate: Date;
+  gender: Gender;
+}

package/src/utils/types/event-product.type.ts

@@ -0,0 +1,17 @@
+import { IBase } from '@utils/types/global.type';
+import { IProduct } from '@utils/types/product.type';
+import { IProductVariant } from '@utils/types/product-variant.type';
+import { IShippingMethod } from '@utils/types/shipping-method.type';
+
+export interface IEventProduct extends IBase {
+  product: IProduct;
+  eventProductVariants: IEventProductVariant[];
+  excludedShippingMethods: IShippingMethod[];
+}
+
+export interface IEventProductVariant extends IBase {
+  productVariant: IProductVariant;
+  priceWithVat: number;
+  priceWithoutVat: number;
+  vatPercentage: number;
+}

package/src/utils/types/event-timeslot.type.ts

@@ -0,0 +1,18 @@
+import { IBase } from '@utils/types/global.type';
+
+export interface IEventTimeslot extends IBase {
+  uuid: string;
+  startDate: string;
+  endDate: string;
+  isSoldOut: boolean;
+}
+
+export interface IEventTimeslotFilters {
+  startDate?: string;
+  endDate?: string;
+}
+
+export interface IEventTimeslotDate {
+  date: string;
+  timeslots: IEventTimeslot[];
+}

package/src/utils/types/event.type.ts

@@ -0,0 +1,70 @@
+import { IBase } from '@utils/types/global.type';
+import { ICompany } from '@utils/types/company.type';
+import { IFile } from '@utils/types/file.type';
+import { IPlace } from '@utils/types/place.type';
+import { IBaseLocale } from '@utils/types/locale.type';
+import { IProject } from '@utils/types/project.type';
+import { OrderFeeType } from '@utils/data/order';
+import { Currencies } from '@utils/data/currency';
+import { IFacebookPixel, ITiktokPixel } from '@utils/types/pixel.type';
+import { IEventProduct } from '@utils/types/event-product.type';
+import { ITranslation } from '@utils/types/translation.type';
+import { IEventExtraField } from '@utils/types/extra-field.type';
+import { EventType } from '@utils/data/event';
+
+export interface IEvent extends IBase {
+  name: string;
+  slug: string;
+  company: ICompany;
+  startDate: string;
+  endDate: string;
+  releaseDate: string;
+  releaseEndDate: string;
+  place: IPlace;
+  description: string;
+  image: IFile;
+  verified: boolean;
+  ageLimit: number | null;
+  maxReleasePrice: number;
+  minReleasePrice: number;
+  tags: IEventTag[];
+  eventCategory: IEventCategory;
+  isSoldout: boolean;
+  isLocked: boolean;
+  lockedUntil: Date | null;
+  project: IProject | null;
+  orderFeeType: OrderFeeType;
+  orderFeeValue: number;
+  orderFeeValueEur: number;
+  currency: Currencies;
+  dateUnknown: boolean;
+  facebookPixel: IFacebookPixel | null;
+  tiktokPixel: ITiktokPixel | null;
+  hasMerchandise: boolean;
+  eventProducts: IEventProduct[];
+  soldoutTextActive: boolean;
+  soldoutText: ITranslation;
+  extraFields: IEventExtraField[];
+  isCanceled: boolean;
+  seoTitle: string | null;
+  seoDescription: string | null;
+  type: EventType;
+  parents: IEvent[];
+  children: IEvent[];
+}
+
+export interface IEventCategory extends IBase {
+  translation: {
+    name: string;
+  } & IBaseLocale;
+}
+
+export interface IEventTag extends IBase {
+  name: string;
+}
+
+export interface IEventCategory extends IBase {
+  translation: {
+    name: string;
+  } & IBaseLocale;
+}

package/src/utils/types/extra-field.type.ts

@@ -0,0 +1,21 @@
+import { IBase } from '@utils/types/global.type';
+import { ExtraFieldTypes, ExtraFieldValueTypes } from '@utils/data/extra-field';
+import { ITranslationEntity } from '@utils/types/translation.type';
+
+export interface IEventExtraField extends IBase {
+  name: ITranslationEntity;
+  type: ExtraFieldTypes;
+  valueType: ExtraFieldValueTypes;
+  required: boolean;
+  options: IExtraFieldOption[];
+}
+
+export interface IExtraFieldForm {
+  eventExtraFieldId: number;
+  value: string | number;
+}
+
+export interface IExtraFieldOption extends IBase {
+  name: ITranslationEntity;
+  extraField: IEventExtraField;
+}

package/src/utils/types/file.type.ts

@@ -0,0 +1,7 @@
+import { IBase } from '@utils/types/global.type';
+
+export interface IFile extends IBase {
+  name: string;
+  url: string;
+  type: string;
+}

package/src/utils/types/global.type.ts

@@ -0,0 +1,81 @@
+import { ReactNode } from 'react';
+import { Languages } from '@utils/data/language';
+import { IUser } from '@utils/types/user.type.ts';
+
+export type PropsWithChildren<P = unknown> = P & { children?: ReactNode | undefined };
+
+export interface IGlobalContext {
+  lang: Languages;
+  setGlobal: (value: Partial<IGlobalContext>) => void;
+  t: (key: string, params?: Record<string, string | number>) => string;
+  showSnackbar: (text: string, options?: { variant: 'success' | 'error' }) => void;
+  callbacks: IGlobalContextCallbacks;
+  links: IGlobalContextLinks;
+  options?: IGlobalContextOptions;
+  user?: IUser;
+  content?: IContent;
+}
+
+export interface IGlobalContextCallbacks {
+  homepage: () => void;
+  tickets: () => void;
+  detail: () => void;
+}
+
+export interface IGlobalContextLinks {
+  termsAndConditions: string;
+  gdpr: string;
+}
+
+export interface IGlobalContextOptions {
+  packetaApiKey?: string;
+  isIframe?: boolean;
+  stickyHeaderTop?: number;
+  termsAndConditionsCompanies?: string[];
+  autoscrollAfterViewChange?: boolean;
+}
+
+export interface IBase {
+  id: number;
+  createdAt: Date;
+  updatedAt: Date;
+  deletedAt: Date | null;
+}
+
+export interface IResponse<D> {
+  data: D;
+  message: string;
+}
+
+export interface IPaginate<D> {
+  data: D;
+  meta: IMeta;
+}
+
+export interface IMeta {
+  perPage: number;
+  page: number;
+  total: number;
+}
+
+export interface IContent {
+  form?: {
+    disableBirthDate?: boolean;
+    disableGender?: boolean;
+  };
+  orderConfirmation?: {
+    title?: string;
+    image?: IContentImage;
+  };
+  paymentConfirmation?: {
+    title?: string;
+    status?: string;
+    subtitle?: string;
+    image?: IContentImage;
+  };
+}
+
+export interface IContentImage {
+  src: string;
+  maxWidth?: string;
+}