@raxonltd/raxon-core 1.1.7 → 1.1.13

package/core/feature/form-submit/form/form.contact.tsx

@@ -0,0 +1,118 @@
+import { Send } from 'lucide-react';
+
+const labelClass = 'mb-2 block text-[11px] font-bold uppercase tracking-[0.18em] text-gray-500';
+const fieldOk =
+  'w-full rounded-xl border border-gray-200 bg-white px-4 py-3 text-gray-900 transition-all focus:border-black focus:outline-none focus:ring-2 focus:ring-black/10';
+const fieldErr =
+  'w-full rounded-xl border border-red-500 bg-white px-4 py-3 text-gray-900 focus:border-red-500 focus:outline-none focus:ring-2 focus:ring-red-500/20';
+
+export const FormContact = ({ form, onSubmit, isPending }: { form: any; onSubmit: any; isPending: boolean }) => {
+  return (
+    <form onSubmit={form.handleSubmit(onSubmit)} className="space-y-6">
+      <div className="grid grid-cols-1 gap-6 md:grid-cols-2">
+        <div>
+          <label htmlFor="firstName" className={labelClass}>
+            Ad *
+          </label>
+          <input
+            type="text"
+            id="firstName"
+            {...form.register('firstName')}
+            className={form.formState.errors.firstName ? fieldErr : fieldOk}
+            placeholder="Adınız"
+          />
+          {form.formState.errors.firstName && <p className="mt-1 text-sm text-red-600">{form.formState.errors.firstName.message}</p>}
+        </div>
+        <div>
+          <label htmlFor="lastName" className={labelClass}>
+            Soyad *
+          </label>
+          <input
+            type="text"
+            id="lastName"
+            {...form.register('lastName')}
+            className={form.formState.errors.lastName ? fieldErr : fieldOk}
+            placeholder="Soyadınız"
+          />
+          {form.formState.errors.lastName && <p className="mt-1 text-sm text-red-600">{form.formState.errors.lastName.message}</p>}
+        </div>
+        <div className="md:col-span-2">
+          <label htmlFor="email" className={labelClass}>
+            E-posta *
+          </label>
+          <input
+            type="email"
+            id="email"
+            {...form.register('email')}
+            className={form.formState.errors.email ? fieldErr : fieldOk}
+            placeholder="ornek@email.com"
+          />
+          {form.formState.errors.email && <p className="mt-1 text-sm text-red-600">{form.formState.errors.email.message}</p>}
+        </div>
+      </div>
+
+      <div className="grid grid-cols-1 gap-6 md:grid-cols-2">
+        <div>
+          <label htmlFor="phoneNumber" className={labelClass}>
+            Telefon
+          </label>
+          <input
+            type="tel"
+            id="phoneNumber"
+            {...form.register('phoneNumber')}
+            className={form.formState.errors.phoneNumber ? fieldErr : fieldOk}
+            placeholder="Telefon numaranız"
+          />
+          {form.formState.errors.phoneNumber && <p className="mt-1 text-sm text-red-600">{form.formState.errors.phoneNumber.message}</p>}
+        </div>
+        <div>
+          <label htmlFor="subject" className={labelClass}>
+            Konu *
+          </label>
+          <select id="subject" {...form.register('subject')} className={form.formState.errors.subject ? fieldErr : fieldOk}>
+            <option value="">Konu seçin</option>
+            <option value="genel">Genel bilgi</option>
+            <option value="siparis">Sipariş</option>
+            <option value="iade">İade / değişim</option>
+            <option value="urun">Ürün bilgisi</option>
+            <option value="oneri">Öneri / şikayet</option>
+            <option value="diger">Diğer</option>
+          </select>
+          {form.formState.errors.subject && <p className="mt-1 text-sm text-red-600">{form.formState.errors.subject.message}</p>}
+        </div>
+      </div>
+
+      <div>
+        <label htmlFor="message" className={labelClass}>
+          Mesajınız *
+        </label>
+        <textarea
+          id="message"
+          rows={6}
+          {...form.register('message')}
+          className={`resize-none ${form.formState.errors.message ? fieldErr : fieldOk}`}
+          placeholder="Mesajınızı buraya yazın..."
+        />
+        {form.formState.errors.message && <p className="mt-1 text-sm text-red-600">{form.formState.errors.message.message}</p>}
+      </div>
+
+      <button
+        type="submit"
+        disabled={isPending || form.formState.isSubmitting}
+        className="flex w-full items-center justify-center gap-2 rounded-xl border-2 border-black bg-black px-8 py-4 text-sm font-black uppercase tracking-widest text-white shadow-sm transition hover:bg-white hover:text-black focus:outline-none focus:ring-2 focus:ring-black/20 focus:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50"
+      >
+        {isPending || form.formState.isSubmitting ? (
+          <>
+            <div className="h-5 w-5 animate-spin rounded-full border-2 border-white border-t-transparent" />
+            <span>Gönderiliyor…</span>
+          </>
+        ) : (
+          <>
+            <Send className="h-5 w-5" strokeWidth={1.5} />
+            <span>Mesaj gönder</span>
+          </>
+        )}
+      </button>
+    </form>
+  );
+};

package/core/feature/form-submit/hook/use.form.submit.tsx

@@ -0,0 +1,16 @@
+import { nexineAxios } from "@/core/util/nexine.axios";
+import { IData } from "@/core/interface/nexine.interface";
+import { Brand, Category, Faq } from "@/core/interface/prisma.interface";
+import { useMutation, useQuery } from "@tanstack/react-query";
+
+export const useFormSubmit = () => {
+  return {
+    create: (  ) => {
+      return useMutation({
+        mutationFn: async (data: any) => {
+          return await nexineAxios.post("/customer/form/submit", data);
+        },
+      });
+    },
+  };
+};

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

@@ -0,0 +1,51 @@
+import { nexineAxios } from "@/core/util/nexine.axios";
+import { IData } from "@/core/interface/nexine.interface";
+import { Invoice } from "@/core/interface/prisma.interface";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+
+export const useInvoice = () => {
+
+    const queryClient = useQueryClient();
+
+    return {
+        fetch: () => {
+            return useQuery({
+                queryKey: ['web', 'invoice', 'list'],
+                queryFn: async () => {
+                    const response = await nexineAxios.get<IData<Invoice>>('/customer/invoice');
+                    return response.data;
+                },
+            });
+        },
+        detail: (id: string) => {
+            return useQuery({
+                queryKey: ['web', 'invoice', 'detail', id],
+                enabled: !!id && id !== "" && id !== "create",
+                queryFn: async () => {
+                    const response = await nexineAxios.get<Invoice>(`/customer/invoice/${id}`);
+                    return response.data;
+                },
+            });
+        },
+        download: () => {
+            return useMutation({
+                mutationFn: async (id: string) => {
+                    const response = await nexineAxios.get(`/customer/invoice/${id}/download`, {
+                        responseType: 'blob',
+                    });
+                    return response.data;
+                },
+            });
+        },
+        downloadByOrder: () => {
+            return useMutation({
+                mutationFn: async (orderId: string) => {
+                    const response = await nexineAxios.get(`/customer/invoice/order/${orderId}/download`, {
+                        responseType: 'blob',
+                    });
+                    return response.data;
+                },
+            });
+        },
+    };
+};

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

@@ -0,0 +1,124 @@
+import { nexineAxios } from '@/core/util/nexine.axios';
+import { Newsletter } from '@/core/interface/prisma.interface';
+import { useMutation } from '@tanstack/react-query';
+
+export type NewsletterPromoCode = {
+  code: string;
+  amount: number | null;
+  type: string;
+  endDate?: string | null;
+};
+
+export type NewsletterVerifyResult = Newsletter & {
+  promoCode?: NewsletterPromoCode | null;
+};
+
+export type NewsletterVerifyResponse = {
+  info?: {
+    title?: string;
+    message?: string;
+    statusCode?: number;
+  };
+  data?: NewsletterVerifyResult;
+};
+
+export const getNewsletterVerifyCacheKey = (id: string, email: string) =>
+  `kuatto:newsletter-verify:${id}:${email.trim().toLowerCase()}`;
+
+export const readNewsletterVerifyCache = (id: string, email: string): NewsletterVerifyResponse | null => {
+  if (typeof window === 'undefined' || !id || !email) {
+    return null;
+  }
+
+  try {
+    const cached = sessionStorage.getItem(getNewsletterVerifyCacheKey(id, email));
+    return cached ? (JSON.parse(cached) as NewsletterVerifyResponse) : null;
+  } catch {
+    return null;
+  }
+};
+
+export const writeNewsletterVerifyCache = (id: string, email: string, payload: NewsletterVerifyResponse) => {
+  if (typeof window === 'undefined' || !id || !email) {
+    return;
+  }
+
+  try {
+    sessionStorage.setItem(getNewsletterVerifyCacheKey(id, email), JSON.stringify(payload));
+  } catch {
+    // sessionStorage dolu veya devre dışı olabilir
+  }
+};
+
+const inflightVerifyRequests = new Map<string, Promise<NewsletterVerifyResponse>>();
+
+export const verifyNewsletterOnce = async (id: string, email: string) => {
+  const normalizedEmail = email.trim().toLowerCase();
+  const cached = readNewsletterVerifyCache(id, normalizedEmail);
+  if (cached?.data) {
+    return cached;
+  }
+
+  const inflightKey = `${id}:${normalizedEmail}`;
+  const inflight = inflightVerifyRequests.get(inflightKey);
+  if (inflight) {
+    return inflight;
+  }
+
+  const request = nexineAxios
+    .post<NewsletterVerifyResponse>('/global/newsletter/verify', {
+      id,
+      email: normalizedEmail,
+    })
+    .then((response) => {
+      const payload = response.data;
+
+      if (payload.data?.promoCode?.code) {
+        writeNewsletterVerifyCache(id, normalizedEmail, payload);
+      }
+
+      return payload;
+    })
+    .finally(() => {
+      inflightVerifyRequests.delete(inflightKey);
+    });
+
+  inflightVerifyRequests.set(inflightKey, request);
+  return request;
+};
+
+export const useNewsletter = () => {
+  const subscribe = useMutation({
+    mutationFn: async (data: { email: string; userId?: string }) => {
+      const response = await nexineAxios.post<Newsletter>('/customer/newsletter/subscribe', data);
+      return response.data;
+    },
+  });
+
+  const subscribeByVariant = useMutation({
+    mutationFn: async (data: { variantId?: string; productId?: string; email: string }) => {
+      const response = await nexineAxios.post<Newsletter>('/customer/newsletter/subscribe/variant', {
+        variantId: data.variantId,
+        productId: data.productId,
+        email: data.email,
+      });
+      return response.data;
+    },
+  });
+
+  const verify = useMutation({
+    mutationFn: async (data: { id: string; email: string }) => {
+      const response = await nexineAxios.post<NewsletterVerifyResponse>('/global/newsletter/verify', data);
+      return response.data;
+    },
+  });
+
+  const unsubscribe = useMutation({
+    mutationFn: async (data: { id: string; email: string }) => {
+      const response = await nexineAxios.post<Newsletter>('/global/newsletter/unsubscribe', data);
+      return response.data;
+    },
+  });
+
+  return { subscribe, subscribeByVariant, verify, unsubscribe };
+};

package/core/feature/newsletter/modal/modal.newsletter.product.tsx

@@ -0,0 +1,163 @@
+import { useRaxon } from '@/core/raxon.context';
+import { ProductDetail } from '@/core/interface/product.interface';
+import React, { useImperativeHandle, useRef, useState } from 'react';
+import { Modal } from 'rizzui/modal';
+import { Button } from 'rizzui/button';
+import { Input } from 'rizzui/input';
+import { useNewsletter } from '@/core/feature/newsletter/hook/use.newsletter';
+
+export interface ModalVariantArg {
+  id: string;
+  attributeOption1?: { id?: string; label?: string; name?: string } | null;
+  attributeOption2?: { id?: string; label?: string; name?: string } | null;
+  price?: { mainPrice?: number; discountPrice?: number } | null;
+}
+
+export interface ModalNewsletterVariantProductRef {
+  open: (product: ProductDetail, variant: ModalVariantArg | null) => void;
+  close: () => void;
+}
+
+export interface ModalNewsletterVariantProductProps {}
+
+export const ModalNewsletterVariantProduct = React.forwardRef<ModalNewsletterVariantProductRef, ModalNewsletterVariantProductProps>((props, ref) => {
+  const callbackRef = useRef<any>(null);
+
+  const { mutate: subscribeByVariant } = useNewsletter().subscribeByVariant;
+  const { profile } = useRaxon();
+  const [product, setProduct] = useState<ProductDetail | null>(null);
+  const [variant, setVariant] = useState<ModalVariantArg | null>(null);
+  const [isOpen, setIsOpen] = useState(false);
+  const [email, setEmail] = useState('');
+  const [isLoading, setIsLoading] = useState(false);
+
+  const onHandleSubscripeProduct = async () => {
+    if(!product) return;
+
+    const emailToUse = profile?.email || email;
+    if(!emailToUse) return;
+
+    setIsLoading(true);
+    try {
+      // Varyant varsa variantId, yoksa productId ile abone ol
+      if (variant?.id) {
+        await subscribeByVariant({
+          variantId: variant.id,
+          email: emailToUse,
+        });
+      } else {
+        await subscribeByVariant({
+          productId: product.id,
+          email: emailToUse,
+        });
+      }
+      setIsOpen(false);
+      setEmail('');
+    } catch (error) {
+      console.error('Newsletter subscription error:', error);
+    } finally {
+      setIsLoading(false);
+    }
+  }
+  useImperativeHandle(ref, () => ({
+    open: (product: ProductDetail, variant: ModalVariantArg | null) => {
+      setProduct(product);
+      setVariant(variant);
+      setIsOpen(true);
+      setEmail('');
+      return new Promise((resolve, reject) => {
+        callbackRef.current = { resolve, reject };
+        resolve(true);
+      });
+    },
+    close: () => {
+      setIsOpen(false);
+      setProduct(null);
+      setVariant(null);
+      setEmail('');
+    },
+  }));
+
+  return (
+    <Modal
+      isOpen={isOpen}
+      onClose={() => {
+        setIsOpen(false);
+        setProduct(null);
+        setVariant(null);
+        setEmail('');
+      }}
+      size="md"
+    >
+      <div className="p-6">
+        <div className="mb-6">
+          <h2 className="text-xl font-semibold mb-2">
+            Ürün Gelince Haber Ver
+          </h2>
+          <p className="text-gray-600">
+            Bu ürün stoğa geldiğinde size haber verelim
+          </p>
+        </div>
+
+        {product && (
+          <div className="mb-6 p-4 bg-gray-50 rounded-lg">
+            <p className="font-medium mb-2">{product.name}</p>
+            {variant && (
+              <p className="text-sm text-gray-600 mb-1">
+                Varyant: {variant.attributeOption1?.label ?? variant.attributeOption1?.name} {variant.attributeOption2?.label ?? variant.attributeOption2?.name}
+              </p>
+            )}
+            {(variant?.price || product.variant?.[0]?.price) && (
+              <p className="text-sm font-medium text-green-600">
+                ₺{(variant?.price?.discountPrice ?? variant?.price?.mainPrice ?? product.variant?.[0]?.price?.discountPrice ?? product.variant?.[0]?.price?.mainPrice ?? 0).toFixed(2)}
+              </p>
+            )}
+          </div>
+        )}
+
+        {!profile?.email && (
+          <div className="mb-4">
+            <Input
+              label="E-posta Adresiniz"
+              type="email"
+              value={email}
+              onChange={(e) => setEmail(e.target.value)}
+              placeholder="ornek@email.com"
+              required
+            />
+          </div>
+        )}
+
+        {profile?.email && (
+          <div className="mb-4">
+            <p className="text-sm text-gray-600">
+              Bildirim gönderilecek e-posta: <span className="font-medium">{profile.email}</span>
+            </p>
+          </div>
+        )}
+
+        <div className="flex gap-3 justify-end">
+          <Button
+            variant="outline"
+            onClick={() => {
+              setIsOpen(false);
+              setProduct(null);
+              setVariant(null);
+              setEmail('');
+            }}
+            disabled={isLoading}
+          >
+            İptal
+          </Button>
+          <Button
+            onClick={onHandleSubscripeProduct}
+            disabled={isLoading || (!profile?.email && !email)}
+            isLoading={isLoading}
+          >
+            Haber Ver
+          </Button>
+        </div>
+      </div>
+    </Modal>
+  );
+});

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

@@ -0,0 +1,31 @@
+import { nexineAxios } from "@/core/util/nexine.axios";
+import { IData } from "@/core/interface/nexine.interface";
+import { Address, Order } from "@/core/interface/prisma.interface";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+
+export const useOrder = () => {
+    
+    const queryClient = useQueryClient();
+
+    return {
+        fetch :  () => {
+            return useQuery({
+                queryKey: ['web','order','list'],
+                queryFn: async () => {
+                    var response = await nexineAxios.get<IData<Order>>(`/customer/order`)
+                    return response.data;
+                },
+            })
+        },
+        detail :  (id : string) => {
+            return useQuery({
+                queryKey: ['web','order','detail',id],
+                enabled : !!id && id !== "" && id != "create",
+                queryFn: async () => {
+                    var response = await nexineAxios.get<Order>(`/customer/order/${id}`)
+                    return response.data;
+                },
+            })
+        },
+    }
+};

package/core/feature/payment-method/checkout.payment.options.ts

@@ -0,0 +1,117 @@
+import { PaymentMethod, PaymentProvider } from '../../interface/prisma.interface';
+import { PaymentUiType, getPaymentUiType } from '@/core/schema/checkout.schema';
+
+export interface CheckoutPaymentOption {
+  key: PaymentUiType;
+  label: string;
+  paymentMethodId: string | null;
+  method?: PaymentMethod;
+  /** Checkout UI'da seçilebilir (her zaman true) */
+  available: boolean;
+  /** Backend'de karşılık gelen ödeme yöntemi tanımlı mı */
+  configured: boolean;
+}
+
+export function findGarantiPaymentMethod(methods: PaymentMethod[]): PaymentMethod | undefined {
+  return methods.find(
+    (m) =>
+      m.provider === PaymentProvider.GARANTI ||
+      /garanti/i.test(m.name) ||
+      /garanti/i.test(m.provider || '')
+  );
+}
+
+const CHECKOUT_SLOTS: { key: PaymentUiType; label: string }[] = [
+  { key: 'credit_card', label: 'Kredi Kartı' },
+  { key: 'bank_transfer', label: 'Havale' },
+  { key: 'garanti', label: 'GarantiPay' },
+];
+
+function resolveMethodForType(methods: PaymentMethod[], type: PaymentUiType): PaymentMethod | undefined {
+  const byUi = methods.find((m) => getPaymentUiType(m.name, m.provider) === type);
+  if (byUi) return byUi;
+
+  if (type === 'credit_card') {
+    return methods.find(
+      (m) =>
+        m.provider === PaymentProvider.PAYTR ||
+        m.provider === PaymentProvider.STRIPE ||
+        /kredi|kart|card/i.test(m.name)
+    );
+  }
+
+  if (type === 'bank_transfer') {
+    return methods.find(
+      (m) =>
+        m.provider === PaymentProvider.BANK_TRANSFER ||
+        /havale|eft|peşin|pesin|transfer/i.test(m.name)
+    );
+  }
+
+  if (type === 'garanti') {
+    return findGarantiPaymentMethod(methods);
+  }
+
+  return undefined;
+}
+
+/** Checkout'ta gösterilecek ödeme seçenekleri (Kredi Kartı, Havale, GarantiPay). */
+export function buildCheckoutPaymentOptions(methods: PaymentMethod[]): CheckoutPaymentOption[] {
+  const slots = CHECKOUT_SLOTS;
+  const usedIds = new Set<string>();
+
+  const options = slots.map((slot) => {
+    const method = resolveMethodForType(
+      methods.filter((m) => !usedIds.has(m.id)),
+      slot.key
+    );
+    if (method) usedIds.add(method.id);
+
+    const configured =
+      slot.key === 'garanti'
+        ? Boolean(method && method.provider === PaymentProvider.GARANTI)
+        : Boolean(method);
+
+    return {
+      key: slot.key,
+      label: slot.label,
+      paymentMethodId: method?.id ?? null,
+      method,
+      available: true,
+      configured,
+    };
+  });
+
+  // Eşleşmeyen yöntemleri yalnızca uyumlu boş slotlara ata (Garanti slotuna Cari vb. gitmesin)
+  const unused = methods.filter((m) => !usedIds.has(m.id));
+  unused.forEach((method) => {
+    const slotType = getPaymentUiType(method.name, method.provider);
+    const matchingSlot = options.find(
+      (o) => !o.paymentMethodId && o.key === slotType && slotType !== 'other'
+    );
+    if (!matchingSlot) return;
+
+    matchingSlot.paymentMethodId = method.id;
+    matchingSlot.method = method;
+    matchingSlot.configured =
+      matchingSlot.key === 'garanti'
+        ? method.provider === PaymentProvider.GARANTI
+        : true;
+  });
+
+  return options;
+}
+
+export function resolveCheckoutPaymentMethodId(
+  options: CheckoutPaymentOption[],
+  selectedKey: PaymentUiType,
+  allMethods: PaymentMethod[]
+): string | null {
+  const selected = options.find((o) => o.key === selectedKey);
+  if (selected?.paymentMethodId) return selected.paymentMethodId;
+
+  const fallback = resolveMethodForType(allMethods, selectedKey);
+  return fallback?.id ?? null;
+}
+
+export const DEFAULT_CHECKOUT_PAYMENT_KEY: PaymentUiType = 'credit_card';

package/core/feature/payment-method/hook/use.payment.method.tsx

@@ -0,0 +1,44 @@
+import { nexineAxios } from '@/core/util/nexine.axios';
+import { IData } from '@/core/interface/nexine.interface';
+import { PaymentMethod } from '@/core/interface/prisma.interface';
+import { useQuery } from '@tanstack/react-query';
+
+async function fetchPaymentMethods() {
+  const baseParams = { isCompanySpecificVisible: true };
+
+  const [withTags, withoutTags] = await Promise.all([
+    nexineAxios.get<IData<PaymentMethod>>('/customer/payment/method', {
+      params: { ...baseParams, tags: ['WEB'] },
+    }),
+    nexineAxios.get<IData<PaymentMethod>>('/customer/payment/method', {
+      params: baseParams,
+    }),
+  ]);
+
+  const tagged = withTags.data?.data ?? [];
+  const all = withoutTags.data?.data ?? [];
+
+  if (tagged.length === 0) return withoutTags.data;
+
+  // WEB etiketli GarantiPay ile etiketsiz diğer yöntemleri birleştir
+  const merged = new Map<string, PaymentMethod>();
+  all.forEach((method) => merged.set(method.id, method));
+  tagged.forEach((method) => merged.set(method.id, method));
+
+  return {
+    ...withoutTags.data,
+    data: Array.from(merged.values()),
+  };
+}
+
+export const usePaymentMethod = () => {
+  return {
+    fetch: (opts?: { enabled?: boolean }) => {
+      return useQuery({
+        queryKey: ['payment-method'],
+        queryFn: fetchPaymentMethods,
+        enabled: opts?.enabled !== false,
+      });
+    },
+  };
+};