@licklist/design 0.71.18-dev.3 → 0.71.18-dev.4

package/src/iframe/ProductWithModifierModal/ModifierSetModal/controll/ModifierSetControll.tsx

@@ -0,0 +1,471 @@
+import { Col, Form } from 'react-bootstrap'
+import { useTranslation } from 'react-i18next'
+import { OrderModifier } from '@licklist/core/dist/DataMapper/Order/OrderModifierDataMapper'
+import { Modifier } from '@licklist/core/dist/DataMapper/Product/ModifierDataMapper'
+import { ModifierSet } from '@licklist/core/dist/DataMapper/Product/ModifierSetDataMapper'
+import { ChangeEvent, useEffect, useMemo } from 'react'
+import { useId } from '@mantine/hooks'
+import {
+  Controller,
+  FieldErrors,
+  FieldValues,
+  useFormContext,
+} from 'react-hook-form'
+import { xor, uniqBy } from 'lodash'
+import clsx from 'clsx'
+import { Currency } from '@licklist/core/dist/Config'
+import { useIntl } from 'react-intl'
+import { MAX_PRODUCT_NUMBER } from 'src/iframe/order-process/components/CategoryProduct/constants'
+import { NumberInputHorizontal } from 'src/sales'
+
+interface ModifiersSetControllProps {
+  modifiers?: Modifier[]
+  modifierSet: ModifierSet
+  modifiersSetWithErrors?: FieldErrors<FieldValues>
+  isLoading?: boolean
+  isEditMode?: boolean
+  productId: number
+  orderProductModifierSets?: OrderModifier[]
+}
+
+type selectModifierType = 'radio' | 'checkbox' | 'selector'
+
+export const ModifiersSetControl = ({
+  modifierSet,
+  modifiers,
+  modifiersSetWithErrors,
+  productId,
+  isLoading = false,
+  isEditMode = false,
+  orderProductModifierSets,
+}: ModifiersSetControllProps) => {
+  const { control, watch, setValue, trigger } = useFormContext()
+  const { t } = useTranslation('App')
+
+  const filteredOrderModifierSets = (
+    modifiersSet: OrderModifier[],
+  ): OrderModifier[] => {
+    if (!modifiersSet) return []
+    const orderModifier = modifiersSet
+      .flat()
+      .filter((modifier) => !!modifier?.quantity)
+
+    return uniqBy(
+      orderModifier,
+      (item) => `${item.modifierId}-${item.modifierSetId}`,
+    )
+  }
+
+  const orderModifiersSets = watch(`${productId}.orderProductModifiers`)
+  const { formatNumber } = useIntl()
+  const formatToCurrency = (value: number) =>
+    formatNumber(value, { style: 'currency', currency: Currency.GBP })
+
+  const orderProductModifiersQuantity = (orderModifiersSets) => {
+    const filteredOrderModifier = filteredOrderModifierSets(orderModifiersSets)
+    return filteredOrderModifier
+      .flat()
+      .filter((item) => item && item.modifierSetId === modifierSet.id).length
+  }
+
+  const orderProductModifiersMaxQuantity =
+    orderProductModifiersQuantity(orderModifiersSets)
+
+  const currentOrderModifiersSets = useMemo(
+    () =>
+      orderProductModifierSets?.filter(
+        (modifier) => modifier.modifierSetId === modifierSet.id,
+      ) || [],
+    [orderProductModifierSets, modifierSet.id],
+  )
+
+  const onChangeModifiers = (
+    e: ChangeEvent<HTMLInputElement>,
+    type: selectModifierType,
+    quantity?: number,
+  ) => {
+    if (!modifiers) return
+
+    const selectedModifier = modifiers?.find(
+      (item) => item.id === Number(e.target.defaultValue || e.target.id),
+    )
+    const checkSelectedModifier =
+      orderModifiersSets?.find(
+        (modifier) => modifier?.modifierId === selectedModifier?.id,
+      )?.quantity === 1
+
+    if (selectedModifier && type === 'radio') {
+      modifiers.forEach((modifier) => {
+        const isSelected = modifier.id === selectedModifier.id
+        const orderModifiers: OrderModifier = {
+          modifierId: modifier.id,
+          price: modifier.price,
+          productId,
+          name: modifier.name,
+          quantity: isSelected ? 1 : 0,
+          modifierSetId: modifierSet.id,
+        }
+        setValue(
+          `${productId}.orderProductModifiers.${modifierSet.id}`,
+          orderModifiers,
+        )
+      })
+    }
+
+    if (selectedModifier && type === 'checkbox') {
+      const orderModifiers: OrderModifier = {
+        modifierId: selectedModifier.id,
+        price: selectedModifier.price,
+        productId,
+        name: selectedModifier.name,
+        quantity: checkSelectedModifier ? 0 : 1,
+        modifierSetId: modifierSet.id,
+      }
+      setValue(
+        `${productId}.orderProductModifiers.${modifierSet.id}.${selectedModifier.id}`,
+        orderModifiers,
+      )
+    }
+
+    if (selectedModifier && type === 'selector' && quantity) {
+      const orderModifiers: OrderModifier = {
+        modifierId: selectedModifier.id,
+        price: selectedModifier.price,
+        productId,
+        quantity,
+        name: selectedModifier.name,
+        modifierSetId: modifierSet.id,
+      }
+      setValue(
+        `${productId}.orderProductModifiers.${modifierSet.id}.${selectedModifier.id}`,
+        orderModifiers,
+      )
+    }
+  }
+
+  useEffect(() => {
+    if (!orderProductModifierSets?.length) return
+    orderProductModifierSets.forEach((orderModifier) =>
+      setValue(
+        `${productId}.orderProductModifiers.${orderModifier.modifierSetId}.${orderModifier.modifierId}`,
+        orderModifier,
+      ),
+    )
+  }, [isEditMode])
+
+  const modifiersErrors = modifiersSetWithErrors?.modifiers
+
+  return (
+    <>
+      {modifierSet?.maxItems === 1 &&
+      modifiers.every((modifier) => modifier.maxItems === 1) &&
+      !currentOrderModifiersSets?.find((modifier) => !!modifier?.quantity) ? (
+        <>
+          <Controller
+            name={`${modifierSet.id}`}
+            data-testid='modifierSet-values-select'
+            control={control}
+            rules={{
+              required: !!modifierSet.minItems
+            }}
+            render={({ field }) => {
+              const onChange = (e: ChangeEvent<HTMLInputElement>) => {
+                onChangeModifiers(e, 'radio')
+                field.onChange(e.target.id)
+              }
+              return (
+                <>
+                  {modifiers?.map((modifier) => {
+                    const selectedOrderModifierId = currentOrderModifiersSets
+                      ?.find(
+                        (orderModifier) =>
+                          orderModifier.modifierId === modifier.id,
+                      )
+                      ?.modifierId?.toString()
+
+                    return (
+                      <Col key={modifier.id.toString()}>
+                        <>
+                          <div className='modifier-container d-flex justify-content-between align-items-center p-2'>
+                            <Form.Check
+                              className='custom-radio'
+                              inline
+                              id={modifier.id.toString()}
+                              defaultChecked={!!selectedOrderModifierId}
+                              defaultValue={modifier.id.toString()}
+                              checked={field.value === modifier.id.toString()}
+                              onChange={onChange}
+                              type='radio'
+                              label={modifier.name}
+                              name={modifier.name}
+                            />
+                          </div>
+                          <div className='mt-3 w-100 pl-2'>
+                            <p>{modifier.description}</p>
+                            <div className='price'>
+                              + {formatToCurrency(modifier.price)}
+                            </div>
+                          </div>
+                        </>
+                      </Col>
+                    )
+                  })}
+                </>
+              )
+            }}
+          />
+
+          {modifiersErrors?.message && (
+            <Col>
+              <div className='invalid-feedback field-values-error'>
+                {modifiersSetWithErrors.message || 'test'}
+              </div>
+            </Col>
+          )}
+        </>
+      ) : (
+        <>
+          {modifiers?.map((modifier, index) => {
+            const selectedOrderModifier = currentOrderModifiersSets?.find(
+              (orderModifier) => orderModifier.modifierId === modifier.id,
+            )?.quantity
+            const requiredModifierSet = modifierSet?.minItems > currentOrderModifiersSets.length
+            const errorMessage = (modifiersErrors as FieldError[])?.find(
+              (modifier) =>
+                modifier.ref && modifier.ref.name === `modifiers[${index}]`,
+            )?.message
+
+            return (
+              <>
+                {modifier.maxItems === 1 ? (
+                  <>
+                    <Controller
+                      name={`modifiers[${index}]`}
+                      control={control}
+                      rules={{
+                        required: !!modifier.minItems || requiredModifierSet,
+                        validate: (value) => {
+                          if (!value) return true
+                          const {
+                            maxItems: maxModifierSet,
+                            minItems: minModifierSet,
+                          } = modifierSet
+
+                          if (
+                            orderProductModifiersMaxQuantity < minModifierSet
+                          ) {
+                            return t('Validation:quantityMinNumberModifier', {
+                              min: minModifierSet,
+                            }) as string
+                          }
+
+                          if (
+                            orderProductModifiersMaxQuantity > maxModifierSet
+                          ) {
+                            return t('Validation:quantityMaxNumberModifier', {
+                              max: maxModifierSet,
+                            }) as string
+                          }
+
+                          const { maxItems, minItems } = modifier
+                          if (value?.length > maxItems) {
+                            return t('Validation:quantityMaxNumberModifier', {
+                              max: maxItems,
+                            }) as string
+                          }
+
+                          if (value?.length < minItems) {
+                            return t('Validation:quantityMinNumberModifier', {
+                              min: minItems,
+                            }) as string
+                          }
+
+                          return true
+                        },
+                      }}
+                      render={({ field }) => {
+                        const onChange = (e: ChangeEvent<HTMLInputElement>) => {
+                          onChangeModifiers(e, 'checkbox')
+                          field.onChange(
+                            xor(field.value, [Number(e.target.value)]),
+                          )
+                        }
+
+                        return (
+                          <Col
+                            className='modifier-container pl-6'
+                            key={modifier.id.toString()}
+                          >
+                            <div className='d-flex justify-content-between align-items-center'>
+                              <Checkbox
+                                value={modifier.id}
+                                onChange={onChange}
+                                label={modifier.name}
+                                defaultChecked={!!selectedOrderModifier}
+                              />
+                            </div>
+                            <div className='mt-3 w-100 pl-2'>
+                              <p>{modifier.description}</p>
+                              <div className='price'>
+                                + {formatToCurrency(modifier.price)}
+                              </div>
+                            </div>
+                            {errorMessage && (
+                              <div className='invalid-feedback d-flex'>
+                                {errorMessage}
+                              </div>
+                            )}
+                          </Col>
+                        )
+                      }}
+                    />
+                  </>
+                ) : (
+                  <>
+                    <div className='modifier-header m-0'>
+                      <div className='title'>{modifier.name}</div>
+                    </div>
+                    <Controller
+                      control={control}
+                      name={`${productId}.${modifierSet.id}.modifiers[${index}].quantity`}
+                      rules={{
+                        required: !!modifier.minItems || requiredModifierSet,
+                        validate: (value) => {
+                          // if (!value) return true
+                          const {
+                            maxItems: maxModifierSet,
+                            minItems: minModifierSet,
+                          } = modifierSet
+                          if (
+                            orderProductModifiersMaxQuantity < minModifierSet
+                          ) {
+                            return t('Validation:quantityMinNumberModifier', {
+                              min: minModifierSet,
+                            }) as string
+                          }
+
+                          if (
+                            orderProductModifiersMaxQuantity > maxModifierSet
+                          ) {
+        
+                            return t('Validation:quantityMaxNumberModifier', {
+                              max: maxModifierSet,
+                            }) as string
+                          }
+
+                          const { maxItems, minItems } = modifier
+                          if (value > maxItems) {
+                            return t('Validation:quantityMaxNumberModifier', {
+                              max: maxItems,
+                            }) as string
+                          }
+
+                          if (value < minItems) {
+                            return t('Validation:quantityMinNumberModifier', {
+                              min: minItems,
+                            }) as string
+                          }
+
+                          return true
+                        },
+                      }}
+                      render={({
+                        field: { onChange, value, ref },
+                        fieldState: { invalid, error },
+                      }) => {
+                        const onChangeProductQuantity = (val: number) => {
+                          const quantity = Math.min(
+                            MAX_PRODUCT_NUMBER,
+                            Math.max(0, Math.ceil(val)),
+                          )
+                          onChange(quantity)
+                          trigger(
+                            `${productId}.${modifierSet.id}.modifiers[${index}].quantity`,
+                          )
+                          onChangeModifiers(
+                            { target: { id: modifier.id.toString() } },
+                            'selector',
+                            quantity,
+                          )
+                        }
+
+                        return (
+                          <div className='modifier-container'>
+                            <div className='d-flex align-items-center column mb-8 pl-6 pt-2'>
+                              <div className='quantity-container mb-0'>
+                                <NumberInputHorizontal
+                                  ref={ref}
+                                  size='big'
+                                  onChange={onChangeProductQuantity}
+                                  onMinusClick={onChangeProductQuantity}
+                                  onPlusClick={onChangeProductQuantity}
+                                  min={0}
+                                  max={MAX_PRODUCT_NUMBER}
+                                  value={value ?? selectedOrderModifier ?? 0}
+                                  className={clsx(invalid && 'error')}
+                                  isLoading={isLoading}
+                                />
+                              </div>
+                            </div>
+                            <div className='p-2 mt-3 w-100 pl-4'>
+                              <p className='pl-2'>{modifier.description}</p>
+                              <div className='pl-2 price'>
+                                + {formatToCurrency(modifier.price)}
+                              </div>
+                              {error?.message && (
+                                <div className='d-flex mt-3 w-100'>
+                                  <p className='iframe-event__message-error'>
+                                    {error.message}
+                                  </p>
+                                </div>
+                              )}
+                            </div>
+                          </div>
+                        )
+                      }}
+                    />
+                  </>
+                )}
+                {modifiersErrors?.message && (
+                  <Col>
+                    <div className='invalid-feedback field-values-error'>
+                      {modifiersSetWithErrors.message || 'test'}
+                    </div>
+                  </Col>
+                )}
+              </>
+            )
+          })}
+        </>
+      )}
+    </>
+  )
+}
+
+type CheckboxProps = {
+  onChange: (e: ChangeEvent<HTMLInputElement>) => void
+  value: number
+  label: string
+  defaultChecked: boolean
+}
+
+const Checkbox = ({
+  onChange,
+  value,
+  label,
+  defaultChecked,
+}: CheckboxProps) => {
+  const checkboxId = useId()
+
+  return (
+    <Form.Group controlId={checkboxId} className='custom-checkbox mt-0'>
+      <Form.Check
+        label={label}
+        value={value}
+        defaultChecked={defaultChecked}
+        onChange={onChange}
+        type='checkbox'
+      />
+    </Form.Group>
+  )
+}

package/src/iframe/ProductWithModifierModal/ModifierSetModal/controll/ProductControll.tsx

@@ -0,0 +1,55 @@
+import {
+  useFormContext,
+  Controller,
+  FieldErrors,
+  FieldValues,
+} from 'react-hook-form'
+import { OrderModifierByProduct } from '@licklist/core/dist/DataMapper/Order/OrderModifiierByProduct'
+import { Product } from '@licklist/plugins/dist/types/context/sale/menuSteps'
+import { ModifiersSetControl } from './ModifierSetControll'
+
+interface ProductControlProps {
+  product: Product
+  isLoading?: boolean
+  editOrderModifier?: OrderModifierByProduct
+  errors?: FieldErrors<FieldValues>
+}
+
+export const ProductControl = ({
+  product,
+  isLoading = false,
+  editOrderModifier,
+  errors,
+}: ProductControlProps) => {
+  const { control } = useFormContext()
+  const modifiersSet = product?.modifiersSet || []
+
+  return (
+    <Controller
+      control={control}
+      name='product'
+      render={() => (
+        <div className='mb-8 pt-4'>
+          <div className=' d-flex  flex-column'>
+            {modifiersSet.map((modifierSet) => (
+              <>
+                <div className='modifier-header'>
+                  <div className='title'>{modifierSet.name}</div>
+                </div>
+                <ModifiersSetControl
+                  modifierSet={modifierSet}
+                  productId={product.id}
+                  modifiers={modifierSet.modifiers}
+                  isEditMode={!!editOrderModifier?.modifiers}
+                  orderProductModifierSets={editOrderModifier?.modifiers}
+                  modifiersSetWithErrors={errors}
+                  isLoading={isLoading}
+                />
+              </>
+            ))}
+          </div>
+        </div>
+      )}
+    />
+  )
+}

package/src/iframe/ProductWithModifierModal/ModifierSetModal/index.ts

@@ -0,0 +1 @@
+import './ProductWithModifierSetModal.js'

package/src/iframe/ProductWithModifierModal/index.ts

@@ -0,0 +1 @@
+export { ProductWithModifierSetModal } from './ModifierSetModal/ProductWithModifierSetModal'

package/src/iframe/event/ticket-description/TicketDescription.tsx

@@ -12,6 +12,7 @@ interface TicketDescriptionProps {
   title: string
   description: string
   className?: string
+  classNameProductModal?: string
   images: Image[] | null
   price?: ReactNode
   isRequired?: boolean
@@ -24,6 +25,7 @@ export function TicketDescription({
   title,
   description,
   className = '',
+  classNameProductModal = '',
   images,
   price,
   isRequired = false,
@@ -47,10 +49,10 @@ export function TicketDescription({
         className='ticket-description__wrapper'
         style={descriptionWrapperStyle}
       >
-        <div className='ticket-description__wrapper-children'>
+        <div className={clsx('ticket-description__wrapper-children', classNameProductModal)}>
           {imageSrc && (
-            <div className='image-wrapper'>
-              <img src={imageSrc} alt={title} />
+            <div className={clsx('image-wrapper', classNameProductModal && 'w-100 h-25')}>
+              <img className={clsx(classNameProductModal && 'w-100')} src={imageSrc} alt={title} />
             </div>
           )}
           {canExpand && description.length > DESCRIPTION_MAX_LENGTH ? (

package/src/iframe/order-process/components/BookingSummary/components/ProductSummary/ProductSummary.tsx

@@ -2,6 +2,7 @@ import { useTranslation } from 'react-i18next'
 import { useIntl } from 'react-intl'
 import * as Config from '@licklist/core/dist/Config'
 import { OrderItem } from '@licklist/plugins/dist/types/context/Iframe/orderItems'
+import { calculateTotalModifiersPrice } from '../../utils'
 
 type ProductSummaryProps = {
   name?: string
@@ -19,11 +20,32 @@ export const ProductSummary = ({
 
   const priceForOneProduct = orderProduct?.price
 
+  const modifierSetsPrice = calculateTotalModifiersPrice(
+    orderProduct?.orderModifiersSets,
+  )
+
   const fullPrice = formatNumber(priceForOneProduct * orderProduct?.quantity, {
     style: 'currency',
     currency: Config.Currency.GBP,
   })
 
+  const modifiersName = `${orderProduct.orderModifiersSets
+    ?.map((modifierProduct) =>
+      modifierProduct?.modifiers
+        .map((item) =>
+          item?.quantity > 1
+            ? `${item?.quantity}x - ${item?.name}`
+            : item?.name,
+        )
+        .join(', '),
+    )
+    .join(', ')}`
+
+  const fullModifiersPrice = formatNumber(modifierSetsPrice, {
+    style: 'currency',
+    currency: Config.Currency.GBP,
+  })
+
   return (
     <div className='product'>
       <p className='m-0 name'>{name ?? orderProduct?.name}</p>
@@ -32,9 +54,18 @@ export const ProductSummary = ({
           {t('shortQuantity')}:&nbsp;{orderProduct?.quantity}
         </p>
 
-        <p className='price'>{fullPrice}</p>
+        {modifierSetsPrice && <p className='price'>{fullPrice}</p>}
       </div>
 
+      {fullModifiersPrice && (
+        <>
+          <p className='mt-2'>{modifiersName}</p>
+          <div className='d-flex justify-content-end'>
+            <p className='price'>{fullModifiersPrice}</p>
+          </div>
+        </>
+      )}
+
       {productQuantityError && (
         <p className='iframe-event__message-error'>{productQuantityError}</p>
       )}

package/src/iframe/order-process/components/BookingSummary/utils/index.ts

@@ -1,3 +1,7 @@
+import { OrderModifier } from '@licklist/core/dist/DataMapper/Order/OrderModifierDataMapper'
+import {
+  OrderModifierByProduct
+} from '@licklist/core/dist/DataMapper/Order/OrderModifiierByProduct'
 import { QuantityCheckProductInfo } from '@licklist/plugins/dist/types/Api/verifyStock'
 import { OrderItem } from '@licklist/plugins/dist/types/context/Iframe/orderItems'
 
@@ -14,16 +18,56 @@ export const cartSumByOrderProducts = ({
   return orderProducts.reduce((prevSumValue: number, product) => {
     if (!product) return 0
 
+    const modifiersPrice = calculateTotalModifiersPrice(
+      product?.orderModifiersSets,
+    )
+
     const price = isTotalSum
       ? product?.price
       : product.hasDeposit
         ? product?.deposit
         : product?.price
 
-    return prevSumValue + price * product.quantity
+    return prevSumValue + price * product.quantity + modifiersPrice
   }, 0)
 }
 
+export const getModifierName = (
+  modifier: OrderModifierByProduct,
+  isManualBooking: boolean,
+) => {
+  const modifierName = (orderModifier: OrderModifier) =>
+    !isManualBooking ? orderModifier?.name : orderModifier.modifier.name
+  return `${modifier.modifiers.map((item) => (
+    item?.quantity > 1 ? `${item?.quantity}x - ${modifierName(item)}` : modifierName(item))).join(', ')}`
+}
+
+export const calculateTotalModifiersPrice = (
+  orderModifiersSets: OrderModifierByProduct[],
+) =>
+  orderModifiersSets
+    ?.map((set) =>
+      set.modifiers.reduce(
+        (sum, modifier) =>
+          sum + modifier.price * modifier.quantity * set.productQuantity,
+        0,
+      ),
+    )
+    .reduce((total, setTotal) => total + setTotal, 0)
+
+export const getOrderProductModifiersPrice = (
+  modifierFromProduct: OrderModifierByProduct,
+) => {
+  const { modifiers, productQuantity } = modifierFromProduct
+  const modifiersPrices = modifiers.reduce(
+    (prevSumModifier: number, modifier: OrderModifier) =>
+      prevSumModifier + modifier.price * modifier.quantity,
+    0,
+  )
+
+  return modifiersPrices * productQuantity
+}
+
 export const getProductError = (
   productsWithErrors: QuantityCheckProductInfo[],
   productId: OrderItem['id'],