396 lines
13 KiB
TypeScript
396 lines
13 KiB
TypeScript
import { useAllProducts } from '@/src/hooks/prominent-api-hooks';
|
|
import { useCentralSlotStore } from '@/src/store/centralSlotStore';
|
|
import { Alert } from 'react-native';
|
|
import { useQuery, useMutation, useQueryClient, UseQueryResult, UseMutationResult } from '@tanstack/react-query';
|
|
import { StorageServiceCasual } from 'common-ui/src/services/StorageServiceCasual';
|
|
|
|
// Cart type definition
|
|
export type CartType = "regular" | "flash";
|
|
|
|
const getCartStorageKey = (cartType: CartType = "regular"): string => {
|
|
return cartType === "flash" ? "flash_cart_items" : "cart_items";
|
|
};
|
|
|
|
interface LocalCartItem {
|
|
id: number;
|
|
productId: number;
|
|
quantity: number;
|
|
slotId: number;
|
|
addedAt: string;
|
|
}
|
|
|
|
interface ProductSummary {
|
|
id: number;
|
|
price: string;
|
|
incrementStep: number;
|
|
isOutOfStock: boolean;
|
|
isFlashAvailable: boolean;
|
|
name?: string;
|
|
flashPrice?: string | null;
|
|
images?: string[];
|
|
productQuantity?: number;
|
|
unitNotation?: string;
|
|
marketPrice?: string | null;
|
|
}
|
|
|
|
export interface CartItem {
|
|
id: number;
|
|
productId: number;
|
|
quantity: number;
|
|
addedAt: string;
|
|
product: ProductSummary;
|
|
subtotal: number;
|
|
slotId: number;
|
|
}
|
|
|
|
interface CartData {
|
|
items: CartItem[];
|
|
totalItems: number;
|
|
totalAmount: number;
|
|
}
|
|
|
|
interface UseGetCartOptions {
|
|
refetchOnWindowFocus?: boolean;
|
|
enabled?: boolean;
|
|
}
|
|
|
|
interface UseGetCartReturn {
|
|
data: CartData | undefined;
|
|
isLoading: boolean;
|
|
error: Error | null;
|
|
refetch: () => Promise<UseQueryResult<CartData, Error>>;
|
|
cartItems: CartItem[];
|
|
totalItems: number;
|
|
totalPrice: number;
|
|
isEmpty: boolean;
|
|
hasItems: boolean;
|
|
}
|
|
|
|
interface AddToCartVariables {
|
|
productId: number;
|
|
quantity: number;
|
|
slotId: number;
|
|
}
|
|
|
|
interface UpdateCartVariables {
|
|
itemId: number;
|
|
quantity: number;
|
|
}
|
|
|
|
interface RemoveCartVariables {
|
|
itemId: number;
|
|
}
|
|
|
|
interface MutationOptions<TData, TVariables> {
|
|
onSuccess?: (data: TData, variables: TVariables) => void;
|
|
onError?: (error: Error) => void;
|
|
showSuccessAlert?: boolean;
|
|
showErrorAlert?: boolean;
|
|
refetchCart?: boolean;
|
|
}
|
|
|
|
interface UseAddToCartReturn {
|
|
mutate: UseMutationResult<LocalCartItem[], Error, AddToCartVariables>['mutate'];
|
|
mutateAsync: UseMutationResult<LocalCartItem[], Error, AddToCartVariables>['mutateAsync'];
|
|
isLoading: boolean;
|
|
error: Error | null;
|
|
data: LocalCartItem[] | undefined;
|
|
addToCart: (productId: number, quantity?: number, slotId?: number, onSettled?: (data: LocalCartItem[] | undefined, error: Error | null) => void) => void;
|
|
addToCartAsync: (productId: number, quantity?: number, slotId?: number) => Promise<LocalCartItem[]>;
|
|
}
|
|
|
|
interface UseUpdateCartItemReturn {
|
|
mutate: UseMutationResult<LocalCartItem[], Error, UpdateCartVariables>['mutate'];
|
|
mutateAsync: UseMutationResult<LocalCartItem[], Error, UpdateCartVariables>['mutateAsync'];
|
|
isLoading: boolean;
|
|
error: Error | null;
|
|
data: LocalCartItem[] | undefined;
|
|
updateCartItem: (itemId: number, quantity: number) => void;
|
|
updateCartItemAsync: (itemId: number, quantity: number) => Promise<LocalCartItem[]>;
|
|
}
|
|
|
|
interface UseRemoveFromCartReturn {
|
|
mutate: UseMutationResult<LocalCartItem[], Error, RemoveCartVariables>['mutate'];
|
|
mutateAsync: UseMutationResult<LocalCartItem[], Error, RemoveCartVariables>['mutateAsync'];
|
|
isLoading: boolean;
|
|
error: Error | null;
|
|
data: LocalCartItem[] | undefined;
|
|
removeFromCart: (itemId: number) => void;
|
|
removeFromCartAsync: (itemId: number) => Promise<LocalCartItem[]>;
|
|
}
|
|
|
|
interface AllProductsResponse {
|
|
products: Array<{
|
|
id: number;
|
|
price: number;
|
|
incrementStep: number;
|
|
marketPrice?: number | null;
|
|
name?: string;
|
|
flashPrice?: string | null;
|
|
images?: string[];
|
|
productQuantity?: number;
|
|
unitNotation?: string;
|
|
}>;
|
|
}
|
|
|
|
const getLocalCart = async (cartType: CartType = "regular"): Promise<LocalCartItem[]> => {
|
|
const key = getCartStorageKey(cartType);
|
|
const data = await StorageServiceCasual.getItem(key);
|
|
return data ? JSON.parse(data) : [];
|
|
};
|
|
|
|
const saveLocalCart = async (items: LocalCartItem[], cartType: CartType = "regular"): Promise<void> => {
|
|
const key = getCartStorageKey(cartType);
|
|
await StorageServiceCasual.setItem(key, JSON.stringify(items));
|
|
await getLocalCart(cartType);
|
|
};
|
|
|
|
const getNextCartItemId = (items: LocalCartItem[]): number => {
|
|
const maxId = items.length > 0 ? Math.max(...items.map(item => item.id)) : 0;
|
|
return maxId + 1;
|
|
};
|
|
|
|
const addToLocalCart = async (productId: number, quantity: number, slotId: number | undefined, cartType: CartType = "regular"): Promise<LocalCartItem[]> => {
|
|
const items = await getLocalCart(cartType);
|
|
const existingIndex = items.findIndex(item => item.productId === productId);
|
|
|
|
if (existingIndex >= 0) {
|
|
items[existingIndex].quantity += quantity;
|
|
if (slotId !== undefined) {
|
|
items[existingIndex].slotId = slotId;
|
|
}
|
|
} else {
|
|
const newId = getNextCartItemId(items);
|
|
const cartItem: LocalCartItem = {
|
|
id: newId,
|
|
productId,
|
|
quantity,
|
|
slotId: slotId ?? 0,
|
|
addedAt: new Date().toISOString(),
|
|
};
|
|
|
|
items.push(cartItem);
|
|
}
|
|
|
|
await saveLocalCart(items, cartType);
|
|
return items;
|
|
};
|
|
|
|
const updateLocalCartItem = async (itemId: number, quantity: number, cartType: CartType = "regular"): Promise<LocalCartItem[]> => {
|
|
const items = await getLocalCart(cartType);
|
|
const item = items.find(i => i.id === itemId);
|
|
if (item) {
|
|
item.quantity = quantity;
|
|
await saveLocalCart(items, cartType);
|
|
}
|
|
return items;
|
|
};
|
|
|
|
const removeFromLocalCart = async (itemId: number, cartType: CartType = "regular"): Promise<LocalCartItem[]> => {
|
|
const items = await getLocalCart(cartType);
|
|
const filtered = items.filter(i => i.id !== itemId);
|
|
await saveLocalCart(filtered, cartType);
|
|
return filtered;
|
|
};
|
|
|
|
const clearLocalCart = async (cartType: CartType = "regular"): Promise<void> => {
|
|
const key = getCartStorageKey(cartType);
|
|
await StorageServiceCasual.setItem(key, JSON.stringify([]));
|
|
};
|
|
|
|
export function useGetCart(options: UseGetCartOptions = {}, cartType: CartType = "regular"): UseGetCartReturn {
|
|
const { data: products } = useAllProducts() as { data: AllProductsResponse | undefined };
|
|
const productSlotsMap = useCentralSlotStore((state) => state.productSlotsMap);
|
|
|
|
const query: UseQueryResult<CartData, Error> = useQuery({
|
|
queryKey: [`local-cart-${cartType}`],
|
|
queryFn: async (): Promise<CartData> => {
|
|
const cartItems = await getLocalCart(cartType);
|
|
|
|
const productMap: Record<number, Omit<ProductSummary, 'isOutOfStock' | 'isFlashAvailable'>> = Object.fromEntries(
|
|
products?.products?.map((p) => [
|
|
p.id,
|
|
{
|
|
id: p.id,
|
|
price: String(p.price),
|
|
incrementStep: p.incrementStep,
|
|
marketPrice: p.marketPrice === null || p.marketPrice === undefined ? null : String(p.marketPrice),
|
|
name: p.name,
|
|
flashPrice: p.flashPrice,
|
|
images: p.images,
|
|
productQuantity: p.productQuantity,
|
|
unitNotation: p.unitNotation,
|
|
},
|
|
]) ?? []
|
|
);
|
|
|
|
const items: CartItem[] = cartItems
|
|
.map((cartItem): CartItem | null => {
|
|
const productBasic = productMap[cartItem.productId];
|
|
const productAvailability = productSlotsMap[cartItem.productId];
|
|
|
|
if (!productBasic || !productAvailability) return null;
|
|
|
|
return {
|
|
id: cartItem.id,
|
|
productId: cartItem.productId,
|
|
quantity: cartItem.quantity,
|
|
addedAt: cartItem.addedAt,
|
|
product: {
|
|
...productBasic,
|
|
isOutOfStock: productAvailability.isOutOfStock,
|
|
isFlashAvailable: productAvailability.isFlashAvailable,
|
|
},
|
|
incrementStep: productBasic.incrementStep,
|
|
subtotal: Number(productBasic.price) * cartItem.quantity,
|
|
slotId: cartItem.slotId,
|
|
};
|
|
})
|
|
.filter((item): item is CartItem => item !== null);
|
|
|
|
const totalAmount = items.reduce((sum, item) => sum + item.subtotal, 0);
|
|
|
|
return {
|
|
items,
|
|
totalItems: items.length,
|
|
totalAmount,
|
|
};
|
|
},
|
|
refetchOnWindowFocus: options?.refetchOnWindowFocus ?? true,
|
|
enabled: (options?.enabled ?? true) && !!products,
|
|
});
|
|
|
|
return {
|
|
data: query.data,
|
|
isLoading: query.isLoading,
|
|
error: query.error,
|
|
refetch: query.refetch,
|
|
cartItems: query.data?.items ?? [],
|
|
totalItems: query.data?.totalItems ?? 0,
|
|
totalPrice: query.data?.totalAmount ?? 0,
|
|
isEmpty: !(query.data?.items?.length ?? 0),
|
|
hasItems: Boolean(query.data?.items?.length),
|
|
};
|
|
}
|
|
|
|
export function useAddToCart(options: MutationOptions<LocalCartItem[], AddToCartVariables> = {}, cartType: CartType = "regular"): UseAddToCartReturn {
|
|
const queryClient = useQueryClient();
|
|
|
|
const mutation: UseMutationResult<LocalCartItem[], Error, AddToCartVariables> = useMutation({
|
|
mutationFn: async ({ productId, quantity, slotId }: AddToCartVariables): Promise<LocalCartItem[]> => {
|
|
return await addToLocalCart(productId, quantity, slotId, cartType);
|
|
},
|
|
onSuccess: (data: LocalCartItem[], variables: AddToCartVariables) => {
|
|
queryClient.invalidateQueries({ queryKey: [`local-cart-${cartType}`] });
|
|
if (options?.showSuccessAlert !== false) {
|
|
Alert.alert("Success", "Item added to cart!");
|
|
}
|
|
options?.onSuccess?.(data, variables);
|
|
},
|
|
onError: (error: Error) => {
|
|
if (options?.showErrorAlert !== false) {
|
|
Alert.alert("Error", error.message || "Failed to add item to cart");
|
|
}
|
|
options?.onError?.(error);
|
|
},
|
|
});
|
|
|
|
const addToCart = (productId: number, quantity = 1, slotId?: number, onSettled?: (data: LocalCartItem[] | undefined, error: Error | null) => void): void => {
|
|
if (slotId == null) {
|
|
throw new Error('slotId is required for adding to cart');
|
|
}
|
|
mutation.mutate({ productId, quantity, slotId }, {
|
|
onSettled: (data: LocalCartItem[] | undefined, error: Error | null) => {
|
|
onSettled?.(data, error);
|
|
}
|
|
});
|
|
};
|
|
|
|
return {
|
|
mutate: mutation.mutate,
|
|
mutateAsync: mutation.mutateAsync,
|
|
isLoading: mutation.isPending,
|
|
error: mutation.error,
|
|
data: mutation.data,
|
|
addToCart,
|
|
addToCartAsync: (productId: number, quantity = 1, slotId?: number): Promise<LocalCartItem[]> => {
|
|
if (slotId == null) {
|
|
throw new Error('slotId is required for adding to cart');
|
|
}
|
|
return mutation.mutateAsync({ productId, quantity, slotId });
|
|
},
|
|
};
|
|
}
|
|
|
|
export function useUpdateCartItem(options: MutationOptions<LocalCartItem[], UpdateCartVariables> = {}, cartType: CartType = "regular"): UseUpdateCartItemReturn {
|
|
const queryClient = useQueryClient();
|
|
|
|
const mutation: UseMutationResult<LocalCartItem[], Error, UpdateCartVariables> = useMutation({
|
|
mutationFn: async ({ itemId, quantity }: UpdateCartVariables): Promise<LocalCartItem[]> => {
|
|
return await updateLocalCartItem(itemId, quantity, cartType);
|
|
},
|
|
onSuccess: (data: LocalCartItem[], variables: UpdateCartVariables) => {
|
|
queryClient.invalidateQueries({ queryKey: [`local-cart-${cartType}`] });
|
|
if (options?.showSuccessAlert !== false) {
|
|
Alert.alert("Success", "Cart item updated!");
|
|
}
|
|
options?.onSuccess?.(data, variables);
|
|
},
|
|
onError: (error: Error) => {
|
|
if (options?.showErrorAlert !== false) {
|
|
Alert.alert("Error", error.message || "Failed to update cart item");
|
|
}
|
|
options?.onError?.(error);
|
|
},
|
|
});
|
|
|
|
return {
|
|
mutate: mutation.mutate,
|
|
mutateAsync: mutation.mutateAsync,
|
|
isLoading: mutation.isPending,
|
|
error: mutation.error,
|
|
data: mutation.data,
|
|
updateCartItem: (itemId: number, quantity: number): void =>
|
|
mutation.mutate({ itemId, quantity }),
|
|
updateCartItemAsync: (itemId: number, quantity: number): Promise<LocalCartItem[]> =>
|
|
mutation.mutateAsync({ itemId, quantity }),
|
|
};
|
|
}
|
|
|
|
export function useRemoveFromCart(options: MutationOptions<LocalCartItem[], RemoveCartVariables> = {}, cartType: CartType = "regular"): UseRemoveFromCartReturn {
|
|
const queryClient = useQueryClient();
|
|
|
|
const mutation: UseMutationResult<LocalCartItem[], Error, RemoveCartVariables> = useMutation({
|
|
mutationFn: async ({ itemId }: RemoveCartVariables): Promise<LocalCartItem[]> => {
|
|
return await removeFromLocalCart(itemId, cartType);
|
|
},
|
|
onSuccess: (data: LocalCartItem[], variables: RemoveCartVariables) => {
|
|
queryClient.invalidateQueries({ queryKey: [`local-cart-${cartType}`] });
|
|
if (options?.showSuccessAlert !== false) {
|
|
Alert.alert("Success", "Item removed from cart!");
|
|
}
|
|
options?.onSuccess?.(data, variables);
|
|
},
|
|
onError: (error: Error) => {
|
|
if (options?.showErrorAlert !== false) {
|
|
Alert.alert("Error", error.message || "Failed to remove item from cart");
|
|
}
|
|
options?.onError?.(error);
|
|
},
|
|
});
|
|
|
|
return {
|
|
mutate: mutation.mutate,
|
|
mutateAsync: mutation.mutateAsync,
|
|
isLoading: mutation.isPending,
|
|
error: mutation.error,
|
|
data: mutation.data,
|
|
removeFromCart: (itemId: number): void =>
|
|
mutation.mutate({ itemId }),
|
|
removeFromCartAsync: (itemId: number): Promise<LocalCartItem[]> =>
|
|
mutation.mutateAsync({ itemId }),
|
|
};
|
|
}
|
|
|
|
// Export clear cart function for direct use
|
|
export { clearLocalCart };
|