Checking In Attendees

const qrData = [
  ticketId,           // Unique ticket identifier
  eventId,            // Event identifier
  attendeeId,         // Attendee/wallet address
  timestamp,          // Purchase timestamp
  signature           // HMAC signature
].join('|');

// Example:
"TKT-001|event_123|0x742d35...f0bEb|1709234567|a1b2c3d4e5f6"

import { verifyQr, DEFAULT_QR_SECRET_SALT } from '@/utils/ticketing/security';

const result = await verifyQr(
  qrString,                           // QR code data
  DEFAULT_QR_SECRET_SALT,             // Secret salt
  eventId,                            // Expected event ID
  (ticketId) => usedTickets.has(ticketId),  // Check if used
  (ticketId) => usedTickets.add(ticketId),  // Mark as used
  eventStartTime                      // Event start timestamp
);

// Result status:
// - VALID: Ticket is authentic and unused
// - ALREADY_USED: Ticket has been checked in
// - FAKE: Invalid signature
// - TOO_EARLY: Check-in before event start
// - EXPIRED: Ticket expired

function checkIn(uint256 tokenId) external onlyEventStarted {
    // Verify ownership
    if (ownerOf(tokenId) != msg.sender) {
        revert NotTokenOwner();
    }
    
    // Check if already used
    if (ticketUsed[tokenId]) {
        revert TicketAlreadyUsed();
    }

    // Mark as used
    ticketUsed[tokenId] = true;

    // Mint Proof of Attendance NFT
    uint256 poaTokenId = proofOfAttendance.mintPOA(msg.sender, tokenId);
    
    emit TicketCheckedIn(tokenId, msg.sender);
    emit ProofOfAttendanceMinted(msg.sender, tokenId, poaTokenId);
}

function organizerCheckIn(uint256 tokenId) external onlyOwner onlyEventStarted {
    if (ticketUsed[tokenId]) {
        revert TicketAlreadyUsed();
    }

    ticketUsed[tokenId] = true;
    address ticketHolder = ownerOf(tokenId);

    // Mint POA to ticket holder
    uint256 poaTokenId = proofOfAttendance.mintPOA(ticketHolder, tokenId);
    
    emit TicketCheckedIn(tokenId, ticketHolder);
    emit ProofOfAttendanceMinted(ticketHolder, tokenId, poaTokenId);
}

contract ProofOfAttendance is ERC721, Ownable {
    mapping(uint256 => uint256) public originalTicketId;  // POA ID → Ticket ID
    mapping(uint256 => uint256) public ticketToPOA;       // Ticket ID → POA ID
    
    function mintPOA(
        address attendee,
        uint256 ticketId
    ) external onlyAuthorizedMinter returns (uint256) {
        require(ticketToPOA[ticketId] == 0, "POA already minted");
        
        uint256 poaTokenId = tokenCounter++;
        
        originalTicketId[poaTokenId] = ticketId;
        ticketToPOA[ticketId] = poaTokenId;
        
        _safeMint(attendee, poaTokenId);
        
        emit POAMinted(attendee, poaTokenId, ticketId);
        
        return poaTokenId;
    }
}

{
  "name": "Tech Conference 2024 - Proof of Attendance",
  "description": "Proof of attendance for Tech Conference 2024 held on June 15, 2026 at Landmark Center, Lagos",
  "image": "ipfs://QmPOA.../tech-conf-2024.png",
  "attributes": [
    {
      "trait_type": "Event",
      "value": "Tech Conference 2024"
    },
    {
      "trait_type": "Date",
      "value": "2026-06-15"
    },
    {
      "trait_type": "Venue",
      "value": "Landmark Center, Lagos"
    },
    {
      "trait_type": "Original Ticket ID",
      "value": "123"
    },
    {
      "trait_type": "Attendance Type",
      "value": "In-Person"
    }
  ],
  "external_url": "https://gatepass.com/events/tech-conf-2024"
}

interface CheckInStats {
  totalScanned: number;      // Total scans attempted
  validScans: number;        // Successfully checked in
  checkedIn: number;         // Unique attendees
  flagged: number;           // Invalid/duplicate tickets
  offlineQueue: number;      // Pending offline syncs
}

interface ScanResult {
  id: string;
  ticketId: string;
  eventTitle: string;
  attendeeName: string;
  ticketType: string;
  status: 'valid' | 'invalid' | 'used' | 'expired';
  scanTime: string;
  walletAddress: string;
}

model CheckIn {
  id              String   @id @default(cuid())
  checkedInAt     DateTime @default(now())
  checkedInBy     String?  // Staff member ID
  location        String?  // Check-in gate/location
  
  // POA NFT info
  poaTokenId      Int?
  poaContractAddr String?
  poaTxHash       String?
  
  // Relations
  ticket   Ticket @relation(fields: [ticketId], references: [id])
  ticketId String @unique
  
  event    Event  @relation(fields: [eventId], references: [id])
  eventId  String
  
  user     User   @relation(fields: [userId], references: [id])
  userId   String
}

const checkIn = await prisma.checkIn.create({
  data: {
    ticketId: 'ticket_123',
    eventId: 'event_456',
    userId: 'user_789',
    checkedInBy: 'organizer_001',
    location: 'Main Entrance',
    poaTokenId: 42,
    poaContractAddr: '0x...',
    poaTxHash: '0x...'
  }
});

function exportCheckIns(checkIns) {
  const header = [
    'id', 'ticketId', 'eventTitle', 'attendeeName',
    'ticketType', 'seatNumber', 'status', 'scanTime', 'walletAddress'
  ];
  
  const rows = checkIns.map(c => [
    c.id, c.ticketId, c.eventTitle, c.attendeeName,
    c.ticketType, c.seatNumber, c.status, c.scanTime, c.walletAddress
  ]);
  
  const csv = [header, ...rows]
    .map(row => row.map(v => `"${v}"`).join(','))
    .join('\n');
  
  // Download CSV
  const blob = new Blob([csv], { type: 'text/csv' });
  const url = URL.createObjectURL(blob);
  const a = document.createElement('a');
  a.href = url;
  a.download = `checkins-${Date.now()}.csv`;
  a.click();
}