@raxonltd/raxon-core 1.1.7 → 1.1.8

package/core/feature/cart/component/cart.promo.code.section.tsx

@@ -0,0 +1,208 @@
+'use client';
+
+import { useCallback, useEffect, useState } from 'react';
+import { useRaxon } from '@/core/raxon.context';
+import { useCart } from '@/core/feature/cart/hook/use.cart';
+import { usePromoCode } from '@/core/feature/promo-code/hook/use.promo.code';
+import { PromoCode, Status } from '@/core/interface/prisma.interface';
+
+const CheckCircle2 = (props: any) => (
+  <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" {...props}>
+    <path d="M12 22c5.523 0 10-4.477 10-10S17.523 2 12 2 2 6.477 2 12s4.477 10 10 10z" /><polyline points="9 11 12 14 22 4" />
+  </svg>
+);
+
+const Loader2 = (props: any) => (
+  <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" {...props}>
+    <path d="M21 12a9 9 0 1 1-6.219-8.56" />
+  </svg>
+);
+
+const X = (props: any) => (
+  <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" {...props}>
+    <line x1="18" y1="6" x2="6" y2="18" /><line x1="6" y1="6" x2="18" y2="18" />
+  </svg>
+);
+
+function formatTRY(amount: number) {
+  return new Intl.NumberFormat('tr-TR', { style: 'currency', currency: 'TRY', maximumFractionDigits: 0 }).format(amount);
+}
+
+type CartPromoCodeSectionProps = {
+  variant?: 'cart' | 'checkout';
+};
+
+export function CartPromoCodeSection({ variant = 'cart' }: CartPromoCodeSectionProps) {
+  const { cart, promoCode, setPromoCode } = useRaxon();
+  const { mutate: updateCart, isPending: isUpdatingCart } = useCart().update();
+  const { mutate: findPromoCode, isPending: isFindingPromoCode } = usePromoCode().findByCode();
+  const [isOpen, setIsOpen] = useState(false);
+  const [promoInput, setPromoInput] = useState('');
+  const [error, setError] = useState<string | null>(null);
+
+  const appliedCode = cart?.promoCode?.code ?? promoCode?.code;
+  const isApplied = Boolean(cart?.promoCode?.id ?? promoCode?.id);
+  const isLoading = isFindingPromoCode || isUpdatingCart;
+
+  useEffect(() => {
+    if (cart?.promoCode?.id) {
+      setPromoInput(cart.promoCode.code);
+      setIsOpen(true);
+    }
+  }, [cart?.promoCode?.id, cart?.promoCode?.code]);
+
+  const applyPromoCode = useCallback(
+    (foundPromoCode: PromoCode) => {
+      if (!cart?.id) {
+        setError('Sepet bilgisi bulunamadı.');
+        return;
+      }
+      if (foundPromoCode.status === Status.ARCHIVED) {
+        setError('Bu promosyon kodu artık geçerli değil.');
+        return;
+      }
+      const currentBasketAmount = cart.info?.basePrice?.pay ?? cart.info?.basePrice?.total ?? 0;
+      if (foundPromoCode.basketLimit > 0 && currentBasketAmount < foundPromoCode.basketLimit) {
+        setError(
+          `Bu kodu kullanabilmek için minimum ${formatTRY(foundPromoCode.basketLimit)} tutarında alışveriş yapmalısınız. Mevcut tutarınız: ${formatTRY(currentBasketAmount)}`
+        );
+        return;
+      }
+      updateCart(
+        {
+          id: cart.id,
+          promoCodeId: foundPromoCode.id,
+          campaignId: cart.campaign?.id ?? undefined,
+        },
+        {
+          onSuccess: () => {
+            setPromoCode(foundPromoCode);
+            setPromoInput(foundPromoCode.code);
+            setError(null);
+            setIsOpen(true);
+          },
+          onError: () => {
+            setError('Promosyon kodu sepete eklenemedi.');
+          },
+        }
+      );
+    },
+    [cart, setPromoCode, updateCart]
+  );
+
+  const handleApply = () => {
+    const trimmed = promoInput.trim();
+    if (!trimmed) {
+      setError('Lütfen bir promosyon kodu girin.');
+      return;
+    }
+    setError(null);
+    findPromoCode(trimmed, {
+      onSuccess: applyPromoCode,
+      onError: () => {
+        setError('Geçersiz promosyon kodu.');
+      },
+    });
+  };
+
+  const handleClear = () => {
+    if (!cart?.id) return;
+    updateCart(
+      {
+        id: cart.id,
+        promoCodeId: null,
+        campaignId: cart.campaign?.id ?? undefined,
+      },
+      {
+        onSuccess: () => {
+          setPromoCode(null);
+          setPromoInput('');
+          setError(null);
+        },
+      }
+    );
+  };
+
+  const toggleLabelClass =
+    variant === 'checkout'
+      ? 'text-left text-xs font-black uppercase tracking-widest text-gray-600 underline-offset-2 transition-colors hover:text-[#CF0A2C] hover:underline'
+      : 'text-left text-xs font-semibold text-gray-500 underline-offset-2 transition-colors hover:text-gray-900 hover:underline';
+
+  const inputClass = (hasError: boolean, applied: boolean) =>
+    `w-full rounded-lg border px-3 py-2 text-sm font-medium uppercase tracking-wide outline-none transition focus:ring-2 focus:ring-gray-900/10 ${
+      applied
+        ? 'border-green-500 bg-green-50 pr-9'
+        : hasError
+          ? 'border-red-300 bg-red-50'
+          : 'border-gray-200 bg-white'
+    }`;
+
+  const applyButtonClass =
+    variant === 'checkout'
+      ? 'shrink-0 rounded-lg bg-gray-900 px-4 py-2 text-xs font-bold uppercase tracking-widest text-white transition hover:bg-gray-800 disabled:cursor-not-allowed disabled:opacity-50'
+      : 'shrink-0 rounded-full bg-black px-4 py-2 text-[10px] font-black uppercase tracking-[0.15em] text-white transition hover:bg-[#CF0A2C] disabled:cursor-not-allowed disabled:opacity-50';
+
+  return (
+    <div className="flex flex-col gap-2">
+      {!isOpen ? (
+        <button type="button" onClick={() => setIsOpen(true)} className={toggleLabelClass}>
+          İndirim kodu ekle
+        </button>
+      ) : (
+        <div className="space-y-2">
+          <span className="text-xs font-medium text-gray-600">İndirim kodu</span>
+          <div className="flex flex-col gap-2 sm:flex-row">
+            <div className="relative flex-1 min-w-0">
+              <input
+                type="text"
+                value={promoInput}
+                onChange={e => {
+                  setPromoInput(e.target.value.toUpperCase());
+                  setError(null);
+                }}
+                onKeyDown={e => {
+                  if (e.key === 'Enter') {
+                    e.preventDefault();
+                    handleApply();
+                  }
+                }}
+                placeholder="Kodu girin"
+                disabled={isApplied || isLoading}
+                className={inputClass(Boolean(error), isApplied)}
+              />
+              {isApplied ? (
+                <CheckCircle2 className="absolute right-2.5 top-1/2 h-4 w-4 -translate-y-1/2 text-green-500" />
+              ) : null}
+            </div>
+            {isApplied ? (
+              <button
+                type="button"
+                onClick={handleClear}
+                disabled={isLoading}
+                className="flex h-9 w-full sm:w-9 shrink-0 items-center justify-center rounded-lg border border-gray-200 text-gray-400 transition hover:border-red-200 hover:bg-red-50 hover:text-red-500 disabled:opacity-50"
+                title="Kodu kaldır"
+              >
+                <X className="h-4 w-4" />
+              </button>
+            ) : (
+              <button
+                type="button"
+                onClick={handleApply}
+                disabled={!promoInput.trim() || isLoading}
+                className={`${applyButtonClass} w-full sm:w-auto`}
+              >
+                {isLoading ? <Loader2 className="h-4 w-4 animate-spin" /> : 'Uygula'}
+              </button>
+            )}
+          </div>
+          {error ? <p className="text-xs text-red-600">{error}</p> : null}
+          {isApplied && appliedCode ? (
+            <p className="text-xs text-green-600">
+              <span className="font-semibold">{appliedCode}</span> kodu uygulandı.
+            </p>
+          ) : null}
+        </div>
+      )}
+    </div>
+  );
+}

package/core/feature/cart/hook/use.cart.tsx

@@ -0,0 +1,267 @@
+import { nexineAxios } from '@/core/util/nexine.axios';
+import { BankTransferCode, Cart, CartItem } from '@/core/interface/prisma.interface';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { globalEmitter, GLOBAL_EVENTS } from '@/core/util/util';
+import { BasketSummaryInterface } from '@/core/interface/basket.interface';
+import { mergeCartWithOptimisticExtras, applyBasketInsertResponse, readCartCache, patchCartCache, CART_QUERY_KEY } from '@/core/feature/cart/util/cart-optimistic';
+import { IData } from '@/core/interface/nexine.interface';
+export type BasketItemBulkInsertInput = {
+  id?: string;
+  productId?: string;
+  productUnitId?: string;
+  variantId?: string | null;
+  quantity?: number;
+  type?: 'increment' | 'decrement' | 'set';
+};
+export type BasketAddressInput = {
+  title?: string;
+  type?: string;
+  firstName?: string;
+  lastName?: string;
+  phoneNumber?: string;
+  postalCode?: string;
+  administrativeAreaLevel1?: string;
+  administrativeAreaLevel2?: string;
+  administrativeAreaLevel3?: string;
+  fullAddress?: string;
+  streetName?: string;
+  buildingName?: string | null;
+  apartmentNumber?: string | null;
+  companyName?: string;
+  taxNumber?: string;
+  country?: string;
+  countryCode?: string;
+};
+
+export const useCart = () => {
+  const queryClient = useQueryClient();
+
+  const handleUnauthorizedError = (error: any) => {
+    if (error?.response?.status === 401) {
+      globalEmitter.emit(GLOBAL_EVENTS.SHOW_LOGIN_MODAL, {
+        message: 'Oturum süreniz dolmuş. Lütfen tekrar giriş yapın.',
+        source: 'cart_operation',
+      });
+    }
+  };
+
+  return {
+    fetch: (params?: { promoCodeId?: string; campaignId?: string; deliveryMethodId?: string; isEnabled: boolean }) => {
+      return useQuery({
+        queryKey: [...CART_QUERY_KEY],
+        staleTime: 15_000,
+        refetchOnWindowFocus: false,
+        enabled: params?.isEnabled,
+        queryFn: async () => {
+          const response = await nexineAxios.get<BasketSummaryInterface>('/customer/basket/me', {
+            params: {
+              promoCodeId: params?.promoCodeId,
+              campaignId: params?.campaignId,
+              deliveryMethodId: params?.deliveryMethodId,
+            },
+          });
+
+          const serverCart = response.data;
+          const cachedCart = readCartCache(queryClient);
+
+          if (!serverCart?.items?.length) {
+            return cachedCart?.items?.length ? cachedCart : serverCart;
+          }
+
+          return mergeCartWithOptimisticExtras(serverCart, cachedCart ?? undefined);
+        },
+      });
+    },
+
+    insert: () => {
+      return useMutation({
+        mutationFn: async (data: any) => {
+          const response = await nexineAxios.post('/customer/basket/me/item', data);
+          return response.data;
+        },
+        onError: (error, _newData, context: any) => {
+          if (context?.previousCarts) {
+            context.previousCarts.forEach(([key, value]: any) => {
+              queryClient.setQueryData(key, value);
+            });
+          }
+          handleUnauthorizedError(error);
+        },
+      });
+    },
+
+    generatePaymentUrl: () => {
+      return useMutation({
+        mutationFn: async (data: any) => {
+          try {
+            var response = await nexineAxios.post('/customer/basket/pay/paytr', data);
+            return response.data;
+          } catch (error) {
+            console.log(error);
+            handleUnauthorizedError(error);
+            return undefined;
+          }
+        },
+      });
+    },
+
+    generateStripePaymentIntent: () => {
+      return useMutation({
+        mutationFn: async (data: any) => {
+          var response = await nexineAxios.post('/customer/basket/pay/stripe', data);
+          return response.data;
+        },
+        onError: handleUnauthorizedError,
+      });
+    },
+
+    generateCashOnDeliveryPayment: () => {
+      return useMutation({
+        mutationFn: async (data: any) => {
+          var response = await nexineAxios.post('/customer/basket/pay/cash-on-delivery', data);
+          return response.data;
+        },
+        onError: handleUnauthorizedError,
+      });
+    },
+
+    pay: () => {
+      return useMutation({
+        mutationFn: async (data?: { platform?: string; webReturnUrl?: string }) => {
+          const response = await nexineAxios.post('/customer/basket/me/pay', {
+            platform: data?.platform ?? 'web',
+            webReturnUrl: data?.webReturnUrl ?? window.location.href,
+          });
+          return response.data;
+        },
+        onError: handleUnauthorizedError,
+      });
+    },
+
+    createTransferCode: () => {
+      return useMutation({
+        mutationFn: async (data: { amount: number; bankAccountId: string }) => {
+          const response = await nexineAxios.post<{ bankTransferCode: BankTransferCode }>(
+            '/customer/payment/bank-transfer',
+            data
+          );
+          return response.data.bankTransferCode;
+        },
+        onError: handleUnauthorizedError,
+      });
+    },
+    bulkInsert: () => {
+      return useMutation({
+        mutationFn: (data: BasketItemBulkInsertInput[]) => {
+          return nexineAxios.patch<IData<CartItem[]>>('/customer/basket/me/item', data);
+        },
+        onSuccess: () => {
+          queryClient.invalidateQueries({ queryKey: ['organization', 'cart'] });
+        },
+        onError: handleUnauthorizedError,
+      });
+    },
+    remove: () => {
+      return useMutation({
+        mutationFn: (id: string) => {
+          return nexineAxios.delete<CartItem>(`/customer/basket/me/item/${id}`);
+        },
+        onMutate: async (id) => {
+          await queryClient.cancelQueries({ queryKey: ['organization', 'cart'] });
+          const previousCarts = queryClient.getQueriesData({ queryKey: ['organization', 'cart'] });
+
+          queryClient.setQueriesData({ queryKey: CART_QUERY_KEY }, (old: any) => {
+            if (!old || !old.items) return old;
+
+            const removedItem = old.items.find((item: any) => String(item.id) === String(id));
+            const priceDiff = removedItem ? -Number(removedItem.linePay || 0) : 0;
+            const updatedItems = old.items.filter((item: any) => String(item.id) !== String(id));
+
+            const newGesamt = updatedItems.reduce((sum: number, item: any) => sum + Number(item.quantity || 0), 0);
+            const newTotal = Number(old.info?.payPrice?.total || 0) + priceDiff;
+            const newPay = Number(old.info?.payPrice?.pay || 0) + priceDiff;
+
+            return {
+              ...old,
+              items: updatedItems,
+              info: {
+                ...old.info,
+                count: {
+                  ...old.info?.count,
+                  Gesamt: newGesamt,
+                  Artikel: updatedItems.length,
+                },
+                payPrice: {
+                  ...old.info?.payPrice,
+                  total: newTotal,
+                  pay: newPay,
+                },
+              },
+            };
+          });
+
+          return { previousCarts };
+        },
+        onSuccess: () => {
+          queryClient.invalidateQueries({ queryKey: ['organization', 'cart'] });
+        },
+        onError: (error, id, context: any) => {
+          if (context?.previousCarts) {
+            context.previousCarts.forEach(([key, value]: any) => {
+              queryClient.setQueryData(key, value);
+            });
+          }
+          handleUnauthorizedError(error);
+        },
+      });
+    },
+
+    update: () => {
+      return useMutation({
+        mutationFn: async (data: {
+          id: string;
+          email?: string;
+          invoiceAddressId?: string | null;
+          deliveryAddressId?: string | null;
+          deliveryMethodId?: string | null;
+          paymentMethodId?: string | null;
+          promoCodeId?: string | null;
+          campaignId?: string | null;
+          deliveryAddress?: BasketAddressInput;
+          invoiceAddress?: BasketAddressInput;
+          bankTransferCodeId?: string | null;
+        }) => {
+          const response = await nexineAxios.put<BasketSummaryInterface>('/customer/basket', data);
+          return response.data;
+        },
+        onSuccess: () => {
+          queryClient.invalidateQueries({ queryKey: ['organization', 'cart'] });
+        },
+        onError: handleUnauthorizedError,
+      });
+    },
+
+    updateItem: () => {
+      return useMutation({
+        mutationFn: async (data: { id: string; quantity: number; productId?: string }) => {
+          const response = await nexineAxios.put<BasketSummaryInterface>(`/customer/basket/me/item`, {
+            itemId: data.id,
+            quantity: Number(data.quantity || 0),
+          });
+          return response.data;
+        },
+        onSuccess: (data) => {
+          patchCartCache(queryClient, (old) => applyBasketInsertResponse(data, old));
+        },
+        onError: (error, _newData, context: any) => {
+          if (context?.previousCarts) {
+            context.previousCarts.forEach(([key, value]: any) => {
+              queryClient.setQueryData(key, value);
+            });
+          }
+          handleUnauthorizedError(error);
+        },
+      });
+    },
+  };
+};

package/core/feature/cart/util/basket-pay.response.ts

@@ -0,0 +1,67 @@
+import { PaymentProvider } from '@/core/interface/prisma.interface';
+
+export type BasketPayResponse = {
+  status?: boolean | string;
+  success?: boolean;
+  info?: Record<string, unknown> | null;
+  data?: Record<string, unknown> | null;
+  provider?: string;
+};
+
+function readString(source: Record<string, unknown> | null, ...keys: string[]): string | null {
+  if (!source) return null;
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value === 'string' && value.trim()) return value;
+  }
+  return null;
+}
+
+export function parseBasketPayResponse(response: unknown) {
+  const payload =
+    response && typeof response === 'object' ? (response as BasketPayResponse) : ({} as BasketPayResponse);
+
+  const ok =
+    payload.status === true ||
+    payload.status === 'true' ||
+    payload.success === true;
+
+  const info =
+    payload.info && typeof payload.info === 'object' ? (payload.info as Record<string, unknown>) : null;
+  const data =
+    payload.data && typeof payload.data === 'object' ? (payload.data as Record<string, unknown>) : null;
+  const root = payload as Record<string, unknown>;
+
+  const provider =
+    readString(info, 'provider', 'paymentProvider') ||
+    readString(data, 'provider', 'paymentProvider') ||
+    readString(root, 'provider', 'paymentProvider');
+
+  const html =
+    readString(info, 'html', 'formHtml', 'paymentHtml') ||
+    readString(data, 'html', 'formHtml', 'paymentHtml');
+
+  const transactionId =
+    readString(info, 'transactionId', 'transaction_id', 'id') ||
+    readString(data, 'transactionId', 'transaction_id', 'id');
+
+  const token = readString(info, 'token') || readString(data, 'token');
+  const orderId = readString(info, 'orderId', 'order_id') || readString(data, 'orderId', 'order_id');
+  const url = readString(info, 'url', 'redirectUrl') || readString(data, 'url', 'redirectUrl');
+
+  return { ok, provider, html, transactionId, token, orderId, url };
+}
+
+export function isGarantiPayResponse(provider: string | null) {
+  return provider === PaymentProvider.GARANTI || provider?.toUpperCase() === 'GARANTI';
+}
+
+/** Provider alanı eksik gelse bile Garanti HTML yanıtını tanı */
+export function isGarantiPayFlow(
+  provider: string | null,
+  html: string | null,
+  transactionId: string | null
+) {
+  if (!html || !transactionId) return false;
+  return isGarantiPayResponse(provider) || /<form/i.test(html);
+}