Introduction Certainly! I'll provide you with the full code and logic implementation for…
- User
Introduction
Certainly! I'll provide you with the full code and logic implementation for the Sustainable Fashion Recommendation System, ensuring type safety by using TypeScript throughout the application. We'll use the following technologies:
Next.js with the App Router for both frontend and backend. TypeScript for type safety. Tailwind CSS for styling. Prisma ORM connected to PostgreSQL running in Docker. NextAuth.js for authentication. Zustand for state management. Axios for HTTP requests. Project Setup
- Initialize the Next.js Project with TypeScript Create a new Next.js project with TypeScript support:
npx create-next-app@latest sustainable-fashion-app --use-npm --typescript --experimental-app cd sustainable-fashion-app 2. Install Dependencies
npm install tailwindcss postcss autoprefixer prisma @prisma/client next-auth axios zustand 3. Initialize Tailwind CSS
npx tailwindcss init -p Configure tailwind.config.js:
/** @type {import('tailwindcss').Config} / module.exports = { content: [ './app/**/.{js,ts,jsx,tsx}', // Include the 'app' directory './components/**/*.{js,ts,jsx,tsx}', ], theme: { extend: {}, }, plugins: [], }; Include Tailwind CSS in app/globals.css:
@tailwind base; @tailwind components; @tailwind utilities; Database Setup with Prisma and PostgreSQL
- Setting up PostgreSQL in Docker If you haven't set up PostgreSQL in Docker, run:
docker run --name postgres
-e POSTGRES_USER=postgres
-e POSTGRES_PASSWORD=yourpassword
-p 5432:5432
-d postgres 2. Configure the DATABASE_URL In your .env file, add:DATABASE_URL="postgresql://postgres:yourpassword@localhost:5432/postgres?schema=public" 3. Initialize Prisma
npx prisma init 4. Define the Prisma Schema in prisma/schema.prisma
datasource db { provider = "postgresql" url = env("DATABASE_URL") }
generator client { provider = "prisma-client-js" }
model User { id Int @id @default(autoincrement()) name String? email String @unique password String tokens Int @default(0) preferences Preferences? quests QuestProgress[] investments Investment[] interactions Interaction[] }
model Preferences { id Int @id @default(autoincrement()) preferredStyles String[] sustainabilityValues String[] user User @relation(fields: [userId], references: [id]) userId Int @unique }
model Product { id Int @id @default(autoincrement()) name String description String price Float styles String[] sustainabilityRating Int }
model Quest { id Int @id @default(autoincrement()) name String description String reward Int action String goal Int questProgress QuestProgress[] }
model QuestProgress { id Int @id @default(autoincrement()) progress Int @default(0) isCompleted Boolean @default(false) quest Quest @relation(fields: [questId], references: [id]) questId Int user User @relation(fields: [userId], references: [id]) userId Int }
model Investment { id Int @id @default(autoincrement()) projectName String amount Int expectedReturn Int investedAt DateTime @default(now()) maturityDate DateTime isMatured Boolean @default(false) user User @relation(fields: [userId], references: [id]) userId Int }
model Interaction { id Int @id @default(autoincrement()) action String createdAt DateTime @default(now()) product Product @relation(fields: [productId], references: [id]) productId Int user User @relation(fields: [userId], references: [id]) userId Int } 5. Run Migrations
npx prisma migrate dev --name init 6. Generate Prisma Client
npx prisma generate Implementing the Full Logic
- User Authentication and Onboarding 1.1 Setting Up NextAuth.js Create a file at app/api/auth/[...nextauth]/route.ts:
// app/api/auth/[...nextauth]/route.ts
import NextAuth from 'next-auth'; import { NextAuthOptions } from 'next-auth'; import CredentialsProvider from 'next-auth/providers/credentials'; import { PrismaAdapter } from '@next-auth/prisma-adapter'; import { prisma } from '@/lib/prisma';
export const authOptions: NextAuthOptions = { adapter: PrismaAdapter(prisma), providers: [ CredentialsProvider({ name: 'Credentials', credentials: { email: { label: 'Email', type: 'email', placeholder: 'email@example.com' }, password: { label: 'Password', type: 'password' }, }, async authorize(credentials) { if (!credentials) return null; const user = await prisma.user.findUnique({ where: { email: credentials.email }, });
if (user && user.password === credentials.password) { return user; } throw new Error('Invalid email or password'); }, }),], pages: { signIn: '/auth/signin', signUp: '/auth/signup', }, session: { strategy: 'jwt', }, secret: process.env.NEXTAUTH_SECRET, };
const handler = NextAuth(authOptions);
export { handler as GET, handler as POST }; Note: In a production environment, you must use password hashing (e.g., bcrypt).
1.2 Create Authentication Pages 1.2.1 Sign-Up Page Create app/auth/signup/page.tsx:
// app/auth/signup/page.tsx
'use client';
import { useState, FormEvent } from 'react'; import { useRouter } from 'next/navigation'; import { signIn } from 'next-auth/react'; import axios from 'axios';
export default function SignUpPage() { const [email, setEmail] = useState(''); const [password, setPassword] = useState(''); const router = useRouter();
const handleSignUp = async (e: FormEvent) => { e.preventDefault();
try { await axios.post('/api/auth/signup', { email, password, }); const res = await signIn('credentials', { redirect: false, email, password, }); if (res && !res.error) { router.push('/onboarding/personal-info'); } else { alert(res?.error || 'An error occurred'); } } catch (error: any) { alert(error.response?.data?.error || 'An error occurred'); }};
return ( Sign Up Email: <input type="email" value={email} onChange={(e) => setEmail(e.target.value)} required className="w-full border p-2" /> Password: <input type="password" value={password} onChange={(e) => setPassword(e.target.value)} required className="w-full border p-2" /> Sign Up ); } 1.2.2 Sign-Up API Route Create app/api/auth/signup/route.ts:
// app/api/auth/signup/route.ts
import { NextResponse } from 'next/server'; import { prisma } from '@/lib/prisma';
export async function POST(request: Request) { const { email, password } = await request.json();
const existingUser = await prisma.user.findUnique({ where: { email }, });
if (existingUser) { return NextResponse.json({ error: 'User already exists' }, { status: 400 }); }
const user = await prisma.user.create({ data: { email, password, }, });
return NextResponse.json({ userId: user.id }, { status: 201 }); } 1.2.3 Sign-In Page Create app/auth/signin/page.tsx:
// app/auth/signin/page.tsx
'use client';
import { useState, FormEvent } from 'react'; import { signIn } from 'next-auth/react'; import { useRouter } from 'next/navigation';
export default function SignInPage() { const [email, setEmail] = useState(''); const [password, setPassword] = useState(''); const router = useRouter();
const handleSignIn = async (e: FormEvent) => { e.preventDefault();
const res = await signIn('credentials', { redirect: false, email, password, }); if (res && !res.error) { router.push('/products'); } else { alert(res?.error || 'An error occurred'); }};
return ( Sign In Email: <input type="email" value={email} onChange={(e) => setEmail(e.target.value)} required className="w-full border p-2" /> Password: <input type="password" value={password} onChange={(e) => setPassword(e.target.value)} required className="w-full border p-2" /> Sign In ); } 1.3 Onboarding Process Create onboarding pages in app/onboarding:
personal-info/page.tsx style-preferences/page.tsx sustainability-values/page.tsx 1.3.1 Personal Information Page Create app/onboarding/personal-info/page.tsx:
// app/onboarding/personal-info/page.tsx
'use client';
import { useState, FormEvent } from 'react'; import { useSession } from 'next-auth/react'; import { useRouter } from 'next/navigation'; import axios from 'axios';
export default function PersonalInfoPage() { const { data: session } = useSession(); const router = useRouter(); const [name, setName] = useState('');
const handleSubmit = async (e: FormEvent) => { e.preventDefault();
await axios.put(`/api/user/${session?.user.id}`, { name, }); router.push('/onboarding/style-preferences');};
return ( Tell us about yourself Name: <input type="text" value={name} onChange={(e) => setName(e.target.value)} required className="w-full border p-2" /> Next ); } Create the API route app/api/user/[id]/route.ts:
// app/api/user/[id]/route.ts
import { NextResponse } from 'next/server'; import { prisma } from '@/lib/prisma';
interface Params { params: { id: string; }; }
export async function PUT(request: Request, { params }: Params) { const { name } = await request.json();
await prisma.user.update({ where: { id: parseInt(params.id) }, data: { name }, });
return NextResponse.json({ success: true }); } 1.3.2 Style Preferences Page Create app/onboarding/style-preferences/page.tsx:
// app/onboarding/style-preferences/page.tsx
'use client';
import { useState, FormEvent } from 'react'; import { useSession } from 'next-auth/react'; import { useRouter } from 'next/navigation'; import axios from 'axios';
const availableStyles = ['Casual', 'Formal', 'Sporty', 'Vintage', 'Bohemian'];
export default function StylePreferencesPage() { const { data: session } = useSession(); const router = useRouter(); const [preferredStyles, setPreferredStyles] = useState<string[]>([]);
const toggleStyle = (style: string) => { setPreferredStyles((prev) => prev.includes(style) ? prev.filter((s) => s !== style) : [...prev, style] ); };
const handleSubmit = async (e: FormEvent) => { e.preventDefault();
await axios.post('/api/user/preferences', { userId: session?.user.id, preferredStyles, }); router.push('/onboarding/sustainability-values');};
return ( Select Your Preferred Styles {availableStyles.map((style) => ( <input type="checkbox" checked={preferredStyles.includes(style)} onChange={() => toggleStyle(style)} className="mr-2" /> {style} ))} Next ); } 1.3.3 Sustainability Values Page Create app/onboarding/sustainability-values/page.tsx:
// app/onboarding/sustainability-values/page.tsx
'use client';
import { useState, FormEvent } from 'react'; import { useSession } from 'next-auth/react'; import { useRouter } from 'next/navigation'; import axios from 'axios';
const sustainabilityOptions = [ 'Organic Materials', 'Fair Trade', 'Eco-Friendly Manufacturing', 'Recycled Materials', ];
export default function SustainabilityValuesPage() { const { data: session } = useSession(); const router = useRouter(); const [sustainabilityValues, setSustainabilityValues] = useState<string[]>([]);
const toggleValue = (value: string) => { setSustainabilityValues((prev) => prev.includes(value) ? prev.filter((v) => v !== value) : [...prev, value] ); };
const handleSubmit = async (e: FormEvent) => { e.preventDefault();
await axios.put(`/api/user/preferences/${session?.user.id}`, { sustainabilityValues, }); // Reward tokens for completing onboarding await axios.post('/api/user/tokens', { userId: session?.user.id, amount: 100, }); router.push('/products');};
return ( Select Your Sustainability Values {sustainabilityOptions.map((value) => ( <input type="checkbox" checked={sustainabilityValues.includes(value)} onChange={() => toggleValue(value)} className="mr-2" /> {value} ))} Finish ); } Create the API route app/api/user/preferences/[id]/route.ts:
// app/api/user/preferences/[id]/route.ts
import { NextResponse } from 'next/server'; import { prisma } from '@/lib/prisma';
interface Params { params: { id: string; }; }
export async function PUT(request: Request, { params }: Params) { const { sustainabilityValues } = await request.json();
await prisma.preferences.update({ where: { userId: parseInt(params.id) }, data: { sustainabilityValues }, });
return NextResponse.json({ success: true }); } 1.3.4 Adjust Tokens API Create app/api/user/tokens/route.ts:
// app/api/user/tokens/route.ts
import { NextResponse } from 'next/server'; import { prisma } from '@/lib/prisma';
export async function POST(request: Request) { const { userId, amount } = await request.json();
await prisma.user.update({ where: { id: parseInt(userId) }, data: { tokens: { increment: amount } }, });
return NextResponse.json({ success: true }); } 2. Product Catalog and Recommendation Engine 2.1 Seeding Products Create prisma/seed.ts:
// prisma/seed.ts
import { PrismaClient } from '@prisma/client';
const prisma = new PrismaClient();
const products = [ { name: 'Eco-Friendly T-Shirt', description: 'Organic cotton t-shirt', price: 25.99, styles: ['Casual'], sustainabilityRating: 5, }, { name: 'Recycled Jeans', description: 'Jeans made from recycled materials', price: 49.99, styles: ['Casual', 'Vintage'], sustainabilityRating: 4, }, // Add more products ];
async function main() { for (const product of products) { await prisma.product.create({ data: product }); } }
main() .catch((e) => console.error(e)) .finally(() => prisma.$disconnect()); Run the seed file:
ts-node prisma/seed.ts 2.2 Displaying Recommended Products Create app/products/page.tsx:
// app/products/page.tsx
import { prisma } from '@/lib/prisma'; import { getServerSession } from 'next-auth'; import { authOptions } from '../api/auth/[...nextauth]/route'; import ProductCard from '@/components/ProductCard'; import { Product } from '@prisma/client';
export default async function ProductsPage() { const session = await getServerSession(authOptions); let products: Product[];
if (session) { const preferences = await prisma.preferences.findUnique({ where: { userId: parseInt(session.user.id) }, });
if (preferences) { products = await prisma.product.findMany({ where: { AND: [ { styles: { hasSome: preferences.preferredStyles, }, }, { sustainabilityRating: { gte: 3, // Example threshold }, }, ], }, }); } else { products = await prisma.product.findMany(); }} else { products = await prisma.product.findMany(); }
return ( Recommended Products {products.map((product) => ( ))} ); } Create components/ProductCard.tsx:
// components/ProductCard.tsx
'use client';
import { Product } from '@prisma/client'; import { useCartStore } from '@/store/useCartStore'; import Link from 'next/link';
interface ProductCardProps { product: Product; }
export default function ProductCard({ product }: ProductCardProps) { const addToCart = useCartStore((state) => state.addItem);
return ( {product.name} {product.description} Price: {product.price.toFixed(2)}</p> <div className="mt-4"> <button onClick={() => addToCart(product)} className="bg-blue-500 text-white px-4 py-2 mr-2" > Add to Cart </button> <Link href={`/products/{product.id}`} className="text-blue-500"> View Details ); } 2.3 Product Details Page Create app/products/[id]/page.tsx:
// app/products/[id]/page.tsx
import { prisma } from '@/lib/prisma'; import { notFound } from 'next/navigation'; import { Product } from '@prisma/client';
interface Params { params: { id: string; }; }
export default async function ProductDetailsPage({ params }: Params) { const product: Product | null = await prisma.product.findUnique({ where: { id: parseInt(params.id) }, });
if (!product) { return notFound(); }
return ( {product.name} {product.description} Price: ${product.price.toFixed(2)} ); } 3. Gamification Features 3.1 Implementing the Token System We've already created an API route to adjust tokens at app/api/user/tokens/route.ts.
Display tokens in the user interface, for example, in the navigation bar.
Create components/Navbar.tsx:
// components/Navbar.tsx
'use client';
import Link from 'next/link'; import { useSession } from 'next-auth/react'; import { useEffect, useState } from 'react'; import axios from 'axios';
export default function Navbar() { const { data: session } = useSession(); const [tokens, setTokens] = useState(0);
useEffect(() => { const fetchTokens = async () => { if (session) { const response = await axios.get(
/api/user/${session.user.id}/tokens); setTokens(response.data.tokens); } }; fetchTokens(); }, [session]);return ( Sustainable Fashion {session ? ( Tokens: {tokens} Profile Sign Out ) : ( Sign In )} ); } Create the tokens API route app/api/user/[id]/tokens/route.ts:
// app/api/user/[id]/tokens/route.ts
import { NextResponse } from 'next/server'; import { prisma } from '@/lib/prisma';
interface Params { params: { id: string; }; }
export async function GET(request: Request, { params }: Params) { const user = await prisma.user.findUnique({ where: { id: parseInt(params.id) }, select: { tokens: true }, });
return NextResponse.json({ tokens: user?.tokens || 0 }); } 3.2 Implementing Quests and Achievements Due to the length constraints, I'll provide an outline of how to implement quests.
Define Quest Data: Seed quests into the database similar to products. Start a Quest: Create an API route to start a quest by creating a QuestProgress record. Update Quest Progress: Whenever a user performs an action (e.g., rates a product), call a function updateQuestProgress(userId, 'rate_product') to update relevant quests. Complete a Quest: When the quest's goal is met, mark it as completed and reward the user with tokens. Example: Update Quest Progress Function
// lib/questManager.ts
import { prisma } from '@/lib/prisma';
export async function updateQuestProgress(userId: number, action: string) { const activeQuests = await prisma.questProgress.findMany({ where: { userId, isCompleted: false, quest: { action }, }, include: { quest: true }, });
for (const questProgress of activeQuests) { const newProgress = questProgress.progress + 1; const isCompleted = newProgress >= questProgress.quest.goal;
await prisma.questProgress.update({ where: { id: questProgress.id }, data: { progress: newProgress, isCompleted, }, }); if (isCompleted) { // Reward tokens await prisma.user.update({ where: { id: userId }, data: { tokens: { increment: questProgress.quest.reward } }, } ); }} } 4. Shopping Cart with Custom Test Payment 4.1 Cart Store with Zustand Create store/useCartStore.ts:
// store/useCartStore.ts
import create from 'zustand'; import { Product } from '@prisma/client';
interface CartItem { product: Product; quantity: number; }
interface CartState { items: CartItem[]; addItem: (product: Product) => void; removeItem: (productId: number) => void; clearCart: () => void; }
export const useCartStore = create((set) => ({ items: [], addItem: (product) => set((state) => { const existingItem = state.items.find((item) => item.product.id === product.id); if (existingItem) { // Increase quantity return { items: state.items.map((item) => item.product.id === product.id ? { ...item, quantity: item.quantity + 1 } : item ), }; } else { // Add new item return { items: [...state.items, { product, quantity: 1 }] }; } }), removeItem: (productId) => set((state) => ({ items: state.items.filter((item) => item.product.id !== productId), })), clearCart: () => set({ items: [] }), })); 4.2 Cart Page Create app/cart/page.tsx:
// app/cart/page.tsx
'use client';
import { useCartStore } from '@/store/useCartStore'; import { useRouter } from 'next/navigation';
export default function CartPage() { const { items, removeItem, clearCart } = useCartStore(); const router = useRouter();
const totalPrice = items.reduce( (total, item) => total + item.product.price * item.quantity, 0 );
const handleCheckout = () => { alert('Payment Successful! Thank you for your purchase.'); clearCart(); router.push('/products'); };
return ( Your Cart {items.length === 0 ? ( Your cart is empty. ) : ( <> Product Price Quantity Total {items.map(({ product, quantity }) => ( {product.name} {(product.price * quantity).toFixed(2)} <button onClick={() => removeItem(product.id)} className="text-red-500" > Remove ))} Total: ${totalPrice.toFixed(2)} Proceed to Payment </> )} ); } Conclusion This implementation provides the full code and logic for the Sustainable Fashion Recommendation System with Gamification, ensuring type safety using TypeScript. All core functionalities are covered, including:
User authentication and onboarding. Product catalog with a basic recommendation engine based on user preferences. Token-based gamification features. Simplified shopping cart with a custom test payment process. Note: Due to constraints in this format, some code (like the quests implementation) is outlined rather than fully detailed. For a complete application, you'd need to expand on these sections, handle errors, and secure the application appropriately.
If you need assistance with any specific parts or further details on certain functionalities, please let me know, and I'll be happy to help!
Where is interaction model? make it detailed full implementation using logic.
- Assistant
You're absolutely right, and I apologize for the oversight. The Interaction model was defined in the Prisma schema but not fully implemented in the code. Let's address that by providing a detailed, full implementation of the Interaction model, including how it connects with the recommendation engine and the gamification features.
Overview
We'll implement the Interaction model to:
- Record User Interactions: Whenever a user interacts with a product (views, adds to cart, purchases, rates), we'll record this interaction in the database.
- Update Quest Progress: Certain quests require users to perform actions, like viewing products or making purchases. We'll use interactions to track and update quest progress.
- Enhance Recommendations: We'll use interaction data to improve product recommendations.
Implementation Steps
- Update the Prisma Schema (already done)
- Create Interaction Logging Functions
- Modify Components to Log Interactions
- Update Quest Progress Based on Interactions
- Use Interactions in the Recommendation Engine
Let's go through each step in detail.
1. Update the Prisma Schema (Already Done)
The Interaction model is defined in the
prisma/schema.prismafile:model Interaction { id Int @id @default(autoincrement()) action String createdAt DateTime @default(now()) product Product @relation(fields: [productId], references: [id]) productId Int user User @relation(fields: [userId], references: [id]) userId Int }This model will store interactions such as product views, additions to cart, purchases, etc.
Run the migration to update your database schema:
npx prisma migrate dev --name add-interactions
2. Create Interaction Logging Functions
We'll create utility functions to log interactions whenever they occur.
2.1 Create Interaction Service
Create a new directory
libat the root of your project if it doesn't exist, and add a filelib/interactionService.ts:// lib/interactionService.ts import { prisma } from '@/lib/prisma'; export enum InteractionAction { VIEW = 'view', ADD_TO_CART = 'add_to_cart', PURCHASE = 'purchase', RATE = 'rate', } export async function logInteraction( userId: number, productId: number, action: InteractionAction ) { await prisma.interaction.create({ data: { action, user: { connect: { id: userId } }, product: { connect: { id: productId } }, }, }); }This function logs an interaction to the database.
3. Modify Components to Log Interactions
We'll modify components where user interactions occur to log those interactions.
3.1 Logging Product Views
When a user views a product details page, we'll log a 'view' interaction.
Modify
app/products/[id]/page.tsx:// app/products/[id]/page.tsx import { prisma } from '@/lib/prisma'; import { notFound } from 'next/navigation'; import { Product } from '@prisma/client'; import { getServerSession } from 'next-auth'; import { authOptions } from '@/app/api/auth/[...nextauth]/route'; import { logInteraction, InteractionAction } from '@/lib/interactionService'; interface Params { params: { id: string; }; } export default async function ProductDetailsPage({ params }: Params) { const product: Product | null = await prisma.product.findUnique({ where: { id: parseInt(params.id) }, }); if (!product) { return notFound(); } // Get the session to identify the user const session = await getServerSession(authOptions); if (session) { // Log the interaction await logInteraction( parseInt(session.user.id), product.id, InteractionAction.VIEW ); // Update quest progress await updateQuestProgress(parseInt(session.user.id), InteractionAction.VIEW); } return ( <div className="max-w-3xl mx-auto mt-8"> <h1 className="text-3xl font-bold">{product.name}</h1> <p className="mt-4">{product.description}</p> <p className="mt-2 font-bold text-xl">Price: ${product.price.toFixed(2)}</p> </div> ); }3.2 Logging Add to Cart
In
components/ProductCard.tsx, when a user clicks 'Add to Cart', we'll log an 'add_to_cart' interaction.Modify the
ProductCardcomponent:// components/ProductCard.tsx 'use client'; import { Product } from '@prisma/client'; import { useCartStore } from '@/store/useCartStore'; import Link from 'next/link'; import { useSession } from 'next-auth/react'; import { logInteraction, InteractionAction } from '@/lib/interactionService'; import { updateQuestProgress } from '@/lib/questManager'; interface ProductCardProps { product: Product; } export default function ProductCard({ product }: ProductCardProps) { const addToCart = useCartStore((state) => state.addItem); const { data: session } = useSession(); const handleAddToCart = async () => { addToCart(product); if (session) { const userId = parseInt(session.user.id); // Log interaction await logInteraction(userId, product.id, InteractionAction.ADD_TO_CART); // Update quest progress await updateQuestProgress(userId, InteractionAction.ADD_TO_CART); } }; return ( <div className="border p-4"> <h2 className="text-xl font-semibold">{product.name}</h2> <p className="mt-2">{product.description}</p> <p className="mt-1 font-bold">Price: ${product.price.toFixed(2)}</p> <div className="mt-4"> <button onClick={handleAddToCart} className="bg-blue-500 text-white px-4 py-2 mr-2" > Add to Cart </button> <Link href={`/products/${product.id}`} className="text-blue-500"> View Details </Link> </div> </div> ); }3.3 Logging Purchases
When the user completes a purchase, we'll log a 'purchase' interaction.
Modify
app/cart/page.tsx:// app/cart/page.tsx 'use client'; import { useCartStore } from '@/store/useCartStore'; import { useRouter } from 'next/navigation'; import { useSession } from 'next-auth/react'; import { logInteraction, InteractionAction } from '@/lib/interactionService'; import { updateQuestProgress } from '@/lib/questManager'; export default function CartPage() { const { items, removeItem, clearCart } = useCartStore(); const router = useRouter(); const { data: session } = useSession(); const totalPrice = items.reduce( (total, item) => total + item.product.price * item.quantity, 0 ); const handleCheckout = async () => { if (session) { const userId = parseInt(session.user.id); // Log purchase interactions for each product for (const item of items) { await logInteraction(userId, item.product.id, InteractionAction.PURCHASE); // Update quest progress await updateQuestProgress(userId, InteractionAction.PURCHASE); } } alert('Payment Successful! Thank you for your purchase.'); clearCart(); router.push('/products'); }; return ( // ... rest of the component ); }3.4 Logging Ratings (If Implemented)
Suppose we have a feature where users can rate products. When a user rates a product, we'll log a 'rate' interaction.
4. Update Quest Progress Based on Interactions
Earlier, we had an outline for the
updateQuestProgressfunction inlib/questManager.ts. Let's implement it in detail.4.1 Implement updateQuestProgress Function
Update
lib/questManager.ts:// lib/questManager.ts import { prisma } from '@/lib/prisma'; import { InteractionAction } from '@/lib/interactionService'; export async function updateQuestProgress( userId: number, action: InteractionAction ) { const activeQuests = await prisma.questProgress.findMany({ where: { userId, isCompleted: false, quest: { action }, }, include: { quest: true }, }); for (const questProgress of activeQuests) { const newProgress = questProgress.progress + 1; const isCompleted = newProgress >= questProgress.quest.goal; await prisma.questProgress.update({ where: { id: questProgress.id }, data: { progress: newProgress, isCompleted, }, }); if (isCompleted) { // Reward tokens await prisma.user.update({ where: { id: userId }, data: { tokens: { increment: questProgress.quest.reward } }, }); // Notify the user (Optional: Can be implemented with a notification system) } } }4.2 Seeding Quests
Create quests that are tied to interactions.
Add to
prisma/seed.ts:// prisma/seed.ts // ... existing code const quests = [ { name: 'First View', description: 'View a product for the first time', reward: 10, action: InteractionAction.VIEW, goal: 1, }, { name: 'Shopaholic', description: 'Purchase 5 products', reward: 50, action: InteractionAction.PURCHASE, goal: 5, }, // Add more quests as needed ]; async function main() { // ... existing product seeding code for (const quest of quests) { await prisma.quest.create({ data: quest }); } } main() .catch((e) => console.error(e)) .finally(() => prisma.$disconnect());Then rerun the seed:
ts-node prisma/seed.ts4.3 Starting Quests for New Users
When a user signs up, we'll automatically start quests for them.
Modify
app/api/auth/signup/route.ts:// app/api/auth/signup/route.ts import { NextResponse } from 'next/server'; import { prisma } from '@/lib/prisma'; export async function POST(request: Request) { const { email, password } = await request.json(); const existingUser = await prisma.user.findUnique({ where: { email }, }); if (existingUser) { return NextResponse.json({ error: 'User already exists' }, { status: 400 }); } const user = await prisma.user.create({ data: { email, password, }, }); // Start all quests for the new user const quests = await prisma.quest.findMany(); for (const quest of quests) { await prisma.questProgress.create({ data: { userId: user.id, questId: quest.id, }, }); } return NextResponse.json({ userId: user.id }, { status: 201 }); }
5. Use Interactions in the Recommendation Engine
We can enhance the recommendation engine to consider user interactions. For simplicity, we'll modify the product recommendation logic to prioritize products the user has interacted with less.
5.1 Updating the Recommendation Logic
Modify
app/products/page.tsx:// app/products/page.tsx import { prisma } from '@/lib/prisma'; import { getServerSession } from 'next-auth'; import { authOptions } from '../api/auth/[...nextauth]/route'; import ProductCard from '@/components/ProductCard'; import { Product } from '@prisma/client'; export default async function ProductsPage() { const session = await getServerSession(authOptions); let products: Product[]; if (session) { const userId = parseInt(session.user.id); const preferences = await prisma.preferences.findUnique({ where: { userId }, }); // Fetch products that match user preferences const preferredProducts = await prisma.product.findMany({ where: { AND: [ { styles: { hasSome: preferences?.preferredStyles || [], }, }, { sustainabilityRating: { gte: 3, // Example threshold }, }, ], }, }); // Exclude products the user has already interacted with const interactedProductIds = await prisma.interaction.findMany({ where: { userId }, select: { productId: true }, }); const excludedIds = interactedProductIds.map((interaction) => interaction.productId); products = preferredProducts.filter((product) => !excludedIds.includes(product.id)); } else { products = await prisma.product.findMany(); } return ( <div className="max-w-5xl mx-auto"> <h1 className="text-3xl font-bold mt-8">Recommended Products</h1> <div className="grid grid-cols-1 md:grid-cols-3 gap-4 mt-4"> {products.map((product) => ( <ProductCard key={product.id} product={product} /> ))} </div> </div> ); }This logic:
- Fetches preferred products based on styles and sustainability ratings.
- Excludes products the user has already interacted with, promoting product discovery.
5.2 Advanced Recommendation Logic (Optional)
For a more sophisticated recommendation engine, you could:
- Analyze interaction data to find products frequently viewed or purchased by other users with similar preferences.
- Use machine learning algorithms to suggest products.
Implementing such advanced features would require more complex logic and is beyond this scope, but this demonstrates how interactions can enhance recommendations.
6. Additional Considerations
6.1 Security and Performance
-
Ensure that API routes that log interactions are protected. Since we're using the server components, and we're getting the session data on the server, we can trust the user ID.
-
Limit the logging of interactions to authenticated users.
6.2 Handling Edge Cases
- If a user hasn't set preferences yet, default to showing popular products.
6.3 Caching and Optimization
- For better performance, consider caching heavy database queries or using database indices.
Conclusion
We've provided a detailed, full implementation of the Interaction model, including:
- Logging Interactions: Recording when users view products, add them to the cart, or make purchases.
- Updating Quest Progress: Using interactions to update the user's progress on quests and reward them accordingly.
- Enhancing Recommendations: Utilizing interaction data to exclude already interacted products, encouraging users to discover new items.
This completes the implementation of the Interaction model in our Sustainable Fashion Recommendation System.
If you have any questions about specific parts of the implementation or need further assistance with any functionality, please let me know!