zupass fallback

Author: noobG

devconnect-app/src/app/map/venue-map/VenueMap2.tsx

@@ -294,7 +294,7 @@ export const VenueMap = () => {
       ref={containerRef}
       id="venue-container"
       className={cn(
-        'relative w-full overflow-hidden grow flex'
+        'relative w-full overflow-hidden grow flex py-8'
         // hasActiveFilters && css['has-selection-or-hover']
       )}
       onClick={(e) => {

devconnect-app/src/app/wallet/TicketTab.tsx

@@ -36,7 +36,7 @@ export default function TicketTab() {
 
   // Auto-load tickets when component mounts
   useEffect(() => {
-    const fetchTickets = async (forceRefresh = false) => {
+    const fetchTickets = async (forceRefresh = true) => {
       if (isLoadingRef.current) {
         console.log('Already fetching tickets, skipping...');
         return;
@@ -65,10 +65,13 @@ export default function TicketTab() {
         const ticketsData = response.data.tickets || [];
         setTickets(ticketsData);
 
+        console.log('ticketsData', ticketsData);
+
         // Generate QR codes for each ticket
         const newQrCodes: { [key: string]: string } = {};
         for (const order of ticketsData) {
           for (const ticket of order.tickets) {
+            console.log('ticket', ticket);
             if (ticket.secret) {
               try {
                 const qrDataUrl = await QRCode.toDataURL(ticket.secret, {

devconnect/src/common/components/perks/perks-list.ts

@@ -26,6 +26,7 @@ type Perk = {
   wallet_proof?: boolean
   global_coupon?: string
   instructions?: string
+  zupass_disabled?: boolean
 }
 
 const perks: Perk[] = [

devconnect/src/pages/api/coupons/[...collection].tsx

@@ -14,6 +14,8 @@ import { POD } from '@pcd/pod'
 import { PODData } from '@parcnet-js/podspec'
 import { proveWalletOwnership } from './wallet-proof'
 import { eventShops } from 'lib/components/event-schedule-new/zupass/event-shops-list'
+import { supabase } from 'common/supabaseClient'
+import { getPaidTicketsByEmail } from './pretix'
 
 const verifyPodSignature = (podData: PODData): boolean => {
   try {
@@ -58,6 +60,54 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
     perksList.find(perk => perk.coupon_collection === collection) ||
     eventShops.find(event => event.coupon_collection === collection)
 
+  // Zupass gating refers to third party event shops that use zupass to gate their event via our calendar
+  const isZupassGating = eventShops.some(event => event.coupon_collection === collection)
+
+  if (isZupassGating && perk?.zupass_disabled) {
+    console.warn('ZUPASS SKIPPED, USING SUPABASE AUTH INSTEAD: ', collection)
+
+    // Extract token from Authorization header
+    const authHeader = req.headers.authorization
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+      return res.status(401).json({ error: 'Missing or invalid Authorization header' })
+    }
+
+    const token = authHeader.substring(7) // Remove 'Bearer ' prefix
+
+    // Verify supabase token
+    const {
+      data: { user },
+      error: authError,
+    } = await supabase.auth.getUser(token)
+
+    if (authError || !user) {
+      return res.status(401).json({ error: 'Invalid or expired Supabase token' })
+    }
+
+    const claimedBy = user.email
+
+    if (!claimedBy) {
+      return res.status(400).json({ error: 'User email is required' })
+    }
+
+    const tickets = await getPaidTicketsByEmail(claimedBy)
+
+    const hasTickets = tickets && tickets.length > 0
+
+    if (!hasTickets) {
+      return res.status(400).json({ error: 'User does not have a paid ticket' })
+    }
+
+    const coupon = await claimSingleCoupon(perk!.zupass_proof_id ?? '', collection, claimedBy)
+
+    return res.status(200).json({
+      coupon: coupon.coupon,
+      coupon_status: coupon.status,
+      collection,
+      ticket_type: perk!.zupass_proof_id,
+    })
+  }
+
   if (!perk) {
     return res.status(400).json({ error: 'Perk or gated event not found' })
   }
@@ -130,11 +180,13 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
   }
 
   const ticketId = pod.entries.ticketId?.value?.toString()
+  const ticketOwner = pod.entries.attendeeEmail?.value?.toString()
 
-  if (!ticketId) {
-    return res.status(400).json({ error: 'Ticket ID is required' })
+  if (!ticketId || !ticketOwner) {
+    return res.status(400).json({ error: 'Ticket ID and ticket owner are required' })
   }
 
+  // If perk is same for everyone, just return it, no need to claim
   if (perk.global_coupon) {
     return res.status(200).json({
       coupon: perk.global_coupon,
@@ -144,7 +196,10 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
     })
   }
 
-  const coupon = await claimSingleCoupon(perk.zupass_proof_id ?? '', collection, ticketId)
+  // If zupass gating, use ticket owner, otherwise use ticket ID. Why:
+  // This is because the ticket id is zupass specific and not known to pretix - we are building a fallback claiming process if zupass goes down - that means we cannot claim by the ticket id found in the proof, we have to use something that works in either case (email)
+  const claimedBy = isZupassGating ? ticketOwner : ticketId
+  const coupon = await claimSingleCoupon(perk.zupass_proof_id ?? '', collection, claimedBy)
 
   return res.status(200).json({
     coupon: coupon.coupon,

devconnect/src/pages/api/coupons/pretix.ts

@@ -0,0 +1,54 @@
+export async function getPaidTicketsByEmail(email: string) {
+    const apiKey = process.env.PRETIX_API_KEY
+    const baseUrl = process.env.PRETIX_BASE_URL || 'https://ticketh.xyz'
+    const organizerSlug = 'devconnect'
+    const eventSlug = 'cowork'
+  
+    if (!apiKey) {
+      throw new Error('PRETIX_API_KEY is missing')
+    }
+  
+    if (!organizerSlug || !eventSlug) {
+      throw new Error('Missing Pretix configuration in environment variables')
+    }
+  
+    const url = `${baseUrl}/api/v1/organizers/${organizerSlug}/events/${eventSlug}/orders`
+  
+    const params = new URLSearchParams({
+      email: email,
+      status: 'p', // 'p' for paid orders
+    })
+  
+    const response = await fetch(`${url}?${params}`, {
+      method: 'GET',
+      headers: {
+        'Authorization': `Token ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+    })
+  
+    if (!response.ok) {
+      console.error('Pretix API error:', response)
+      throw new Error(`Pretix API error: ${response.status}`)
+    }
+  
+    const data = await response.json()
+    const orders = data.results || []
+    
+    // Return simplified ticket data, filtering out positions without attendee names
+    return orders.map((order: any) => ({
+      orderCode: order.code,
+      orderDate: order.datetime,
+      email: order.email,
+      tickets: order.positions
+        .filter((position: any) => position.attendee_name && position.attendee_name.trim() !== '')
+        .map((position: any) => ({
+          secret: position.secret,
+          attendeeName: position.attendee_name,
+          attendeeEmail: position.attendee_email || order.email,
+          price: position.price,
+          itemName: position.item_name || 'Ticket',
+        }))
+    }))
+  }
+  

lib/components/event-schedule-new/zupass/event-shops-list.ts

@@ -1,16 +1,20 @@
 type EventShop = {
   supabase_id: string
   coupon_collection: string
-  zupass_proof_id?: string
+  zupass_proof_id?: string 
   custom_url_id?: string
   global_coupon?: string
+  zupass_disabled?: boolean
 }
 
+const zupassGatingFallbackOn = process.env.NEXT_PUBLIC_ZUPASS_FALLBACK_ON === "true"
+
 export const eventShops: EventShop[] = [
   {
     supabase_id: "86",
     custom_url_id: 'DSS',
     zupass_proof_id: "Devconnect ARG",
     coupon_collection: "dss-voucher-gating",
+    zupass_disabled: zupassGatingFallbackOn,
   },
 ];