freshyo/apps/admin-web/src/routes/dashboard.products.edit.tsx
2026-10-14 22:38:17 +05:30

262 lines
8.6 KiB
TypeScript

import React, { useRef, useMemo } from 'react'
import { createFileRoute } from '@tanstack/react-router'
import { AppContainer, p as MyText, type ImageUploaderNeoItem, type ImageUploaderNeoPayload } from 'web-components'
import ProductForm, { type ProductFormRef } from '../components/ProductForm'
import GlobalProductForm from '../components/GlobalProductForm'
import { trpc } from '@/lib/trpc-client'
import { useManualRefresh } from '@/lib/refresh-context'
import { useUploadToObjectStorage } from '@/hooks/useUploadToObjectStorage'
export const Route = createFileRoute('/dashboard/products/edit')({
validateSearch: (s: Record<string, unknown>) => ({ id: (s.id as string) ?? '' }),
component: EditProduct,
})
function EditProduct() {
const { id } = Route.useSearch()
const productId = Number(id)
const productFormRef = useRef<ProductFormRef>(null)
const { data: productResponse, isLoading: isFetching, refetch } = trpc.admin.product.getProductById.useQuery(
{ id: productId },
{ enabled: !!productId }
)
const { refetch: refetchProducts } = trpc.admin.product.getProducts.useQuery(undefined, {
enabled: false,
})
const updateProduct = trpc.admin.product.updateProduct.useMutation()
const { upload, isUploading } = useUploadToObjectStorage()
useManualRefresh(() => refetch())
const productData = productResponse?.product
const initialValues = useMemo(() => {
if (!productData) {
return {
name: '',
shortDescription: '',
longDescription: '',
storeId: 0,
productType: 'item' as const,
variants: [],
}
}
return {
name: productData.name,
shortDescription: productData.shortDescription || '',
longDescription: productData.longDescription || '',
storeId: productData.storeId || 0,
productType: (productData.productType as 'item' | 'combo') || 'item',
variants: (productData.skus || []).map((sku) => ({
id: sku.id,
name: sku.name || '',
price: sku.price ? parseFloat(sku.price) : undefined,
marketPrice: sku.marketPrice ? parseFloat(sku.marketPrice) : null,
isFlashAvailable: sku.isFlashAvailable || false,
flashPrice: sku.flashPrice ? parseFloat(sku.flashPrice) : null,
isOffer: sku.isOffer || false,
isComboOnly: sku.isComboOnly || false,
isDeleted: sku.isDeleted || false,
isSuspended: sku.isSuspended || false,
features: (sku.features || []).map((f) => ({
featureName: f.featureName,
featureValue: f.featureValue,
})),
comboItems: (sku.comboItems || []).map((ci: any) => ({
skuId: ci.skuId,
})),
})),
}
}, [productData])
const existingVariantImages = useMemo(() => {
if (!productData) return []
return (productData.skus || []).map((sku) =>
(sku.images || []).map((url) => ({ imgUrl: url, mimeType: null } as ImageUploaderNeoItem))
)
}, [productData])
const existingVariantImageKeys = useMemo(() => {
if (!productData) return []
return (productData.skus || []).map((sku) =>
(sku.imageKeys || []).map(String)
)
}, [productData])
const handleSubmit = async (values: any, variantImages: ImageUploaderNeoPayload[][], deletedImageKeys: string[]) => {
try {
for (const variant of values.variants) {
const price = variant.price
if (price == null || price <= 0) {
window.alert('Please enter a valid price for every variant')
return
}
}
const seenSignatures = new Set<string>()
for (const variant of values.variants) {
const features = variant.features || []
const hasQuantity = features.some(
(a: any) => (a.featureName ?? '').trim().toLowerCase() === 'quantity'
)
if (!hasQuantity) {
window.alert('Every SKU must have a quantity feature')
return
}
const signature = features
.map((a: any) => `${(a.featureName ?? '').trim().toLowerCase()}::${a.featureValue.trim().toLowerCase()}`)
.sort()
.join('|')
if (seenSignatures.has(signature)) {
window.alert('Two variants have the same attributes')
return
}
seenSignatures.add(signature)
}
const allBlobs: { blob: Blob, mimeType: string }[] = []
const imageCounts: number[] = variantImages.map((imgs) =>
imgs.filter((img) => img.mimeType !== null).length
)
for (const imgs of variantImages) {
for (const img of imgs) {
if (img.mimeType === null) continue
const response = await fetch(img.url)
const blob = await response.blob()
allBlobs.push({ blob, mimeType: img.mimeType || 'image/jpeg' })
}
}
let allUploadUrls: string[] = []
if (allBlobs.length > 0) {
const result = await upload({ images: allBlobs, contextString: 'product_info' })
allUploadUrls = result.presignedUrls
}
let urlCursor = 0
const skus = values.variants.map((variant: any, vIndex: number) => {
const count = imageCounts[vIndex]
const newUrls = allUploadUrls.slice(urlCursor, urlCursor + count)
urlCursor += count
const existingUrls = variantImages[vIndex]
?.filter((img) => img.mimeType === null)
.map((img) => img.url) || []
const allUrls = [...existingUrls, ...newUrls]
return {
id: variant.id,
name: variant.name || null,
price: variant.price as number,
marketPrice: variant.marketPrice ?? undefined,
images: allUrls,
isFlashAvailable: variant.isFlashAvailable || false,
flashPrice: variant.flashPrice ?? undefined,
isOffer: variant.isOffer || false,
isComboOnly: variant.isComboOnly || false,
isDeleted: variant.isDeleted || false,
isSuspended: variant.isSuspended || false,
features: variant.features.map((attr: any) => ({
featureName: attr.featureName,
featureValue: attr.featureValue,
})),
comboItems: (variant.comboItems || []).map((ci: any) => ({
skuId: ci.skuId,
})),
}
})
await updateProduct.mutateAsync({
id: productId,
name: values.name,
shortDescription: values.shortDescription || undefined,
longDescription: values.longDescription || undefined,
storeId: values.storeId,
productType: values.productType,
incrementStep: 1,
skus,
deletedImageKeys,
newImageUrls: allUploadUrls,
} as any)
await refetch()
await refetchProducts()
window.alert('Product updated successfully!')
productFormRef.current?.clearImages()
} catch (error: any) {
window.alert(error.message || 'Failed to update product')
}
}
if (isFetching) {
return (
<AppContainer>
<div className="flex flex-1 items-center justify-center">
<MyText className="text-gray-600">Loading product...</MyText>
</div>
</AppContainer>
)
}
if (!productData) {
return (
<AppContainer>
<div className="flex flex-1 items-center justify-center">
<MyText className="text-red-600">Product not found</MyText>
</div>
</AppContainer>
)
}
if (productData.isGlobal) {
const handleGlobalSubmit = async (skus: any[]) => {
try {
await updateProduct.mutateAsync({
id: productId,
name: productData.name,
shortDescription: productData.shortDescription || undefined,
longDescription: productData.longDescription || undefined,
storeId: productData.storeId || 0,
productType: productData.productType,
incrementStep: productData.incrementStep,
skus,
deletedImageKeys: [],
newImageUrls: [],
} as any)
await refetch()
await refetchProducts()
window.alert('Market data updated for your region')
} catch (error: any) {
window.alert(error.message || 'Failed to update product')
}
}
return (
<AppContainer>
<GlobalProductForm
product={productData as any}
onSubmit={handleGlobalSubmit}
isLoading={updateProduct.isPending}
/>
</AppContainer>
)
}
return (
<AppContainer>
<ProductForm
ref={productFormRef}
mode="edit"
initialValues={initialValues}
onSubmit={handleSubmit}
isLoading={updateProduct.isPending || isUploading}
existingVariantImages={existingVariantImages}
existingVariantImageKeys={existingVariantImageKeys}
/>
</AppContainer>
)
}