Quest Integration

query GetQuest($id: ID!) {
  quest(id: $id) {
    id
    name
    type
    status
    description
    startTime
    endTime
    cap
    participantsCount
    loyaltyPoints
    space {
      id
      name
    }
    chain
  }
}

{
  "data": {
    "quest": {
      "id": "GChdWUjXX3",
      "name": "Introduction to Web3!",
      "type": "Drop",
      "status": "Active",
      "description": "Welcome to Module 1-Course 1 of Mission Web3!",
      "startTime": 1699200000,
      "endTime": 1699800000,
      "cap": 10000,
      "participantsCount": 234163,
      "loyaltyPoints": 100,
      "space": {
        "id": "40",
        "name": "BNB Chain"
      },
      "chain": "BSC"
    }
  }
}

query GetSpaceQuests($spaceId: ID!, $first: Int!, $statuses: [QuestStatus!]) {
  quests(input: {
    spaceId: $spaceId
    first: $first
    statuses: $statuses
  }) {
    totalCount
    pageInfo {
      hasNextPage
      endCursor
    }
    list {
      id
      name
      type
      status
      participantsCount
      loyaltyPoints
      startTime
      endTime
    }
  }
}

query CheckUserEligibility($questId: ID!, $address: String!) {
  quest(id: $questId) {
    id
    name
    status
    credentialGroups(address: $address) {
      id
      name
      conditionRelation
      conditions {
        expression
        eligible
      }
      rewards {
        expression
        eligible
        rewardType
        rewardCount
      }
    }
  }
}

async function validateQuest(questId, accessToken) {
  const response = await fetch('https://graphigo-business.prd.galaxy.eco/query', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'access-token': accessToken
    },
    body: JSON.stringify({
      query: `query GetQuest($id: ID!) {
        quest(id: $id) {
          id
          name
          status
          startTime
          endTime
          participantsCount
          cap
        }
      }`,
      variables: { id: questId }
    })
  });
  
  const data = await response.json();
  const quest = data.data.quest;
  
  if (!quest) throw new Error('Quest not found');
  
  // Check quest status
  if (quest.status === 'Draft') throw new Error('Quest is in draft mode');
  if (quest.status === 'Deleted') throw new Error('Quest has been deleted');
  if (quest.status === 'Expired') throw new Error('Quest has expired');
  if (quest.status === 'CapReached') throw new Error('Quest capacity reached');
  
  // Check timing for active quests
  if (quest.status === 'Active' && quest.startTime && quest.endTime) {
    const now = Math.floor(Date.now() / 1000);
    if (now < quest.startTime) throw new Error('Quest has not started yet');
    if (now > quest.endTime) throw new Error('Quest has ended');
  }
  
  return quest;
}

async function checkUserEligibility(questId, userAddress, accessToken) {
  const response = await fetch('https://graphigo-business.prd.galaxy.eco/query', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'access-token': accessToken
    },
    body: JSON.stringify({
      query: `query CheckUserEligibility($questId: ID!, $address: String!) {
        quest(id: $questId) {
          id
          name
          status
          credentialGroups(address: $address) {
            id
            name
            conditionRelation
            conditions {
              expression
              eligible
            }
            rewards {
              expression
              eligible
              rewardType
              rewardCount
            }
          }
        }
      }`,
      variables: { questId, address: userAddress }
    })
  });
  
  const data = await response.json();
  const quest = data.data.quest;
  
  if (!quest) throw new Error('Quest not found');
  
  const eligibilityResults = quest.credentialGroups.map(group => {
    // Check conditions based on relation (ALL or ANY)
    const conditionsMet = group.conditionRelation === 'ALL' 
      ? group.conditions.every(c => c.eligible)
      : group.conditions.some(c => c.eligible);
    
    const eligibleRewards = group.rewards.filter(r => r.eligible);
    
    return {
      groupId: group.id,
      groupName: group.name,
      conditionsMet,
      eligibleRewards
    };
  });
  
  const isEligible = eligibilityResults.some(r => r.conditionsMet && r.eligibleRewards.length > 0);
  
  return {
    questId,
    userAddress,
    isEligible,
    eligibilityDetails: eligibilityResults,
    questName: quest.name,
    questStatus: quest.status
  };
}

async function getSpaceQuests(spaceId, accessToken, options = {}) {
  const { 
    limit = 20, 
    cursor = null, 
    statuses = ['Active']
  } = options;
  
  const response = await fetch('https://graphigo-business.prd.galaxy.eco/query', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'access-token': accessToken
    },
    body: JSON.stringify({
      query: `query GetSpaceQuests($input: ListQuestInput!) {
        quests(input: $input) {
          totalCount
          pageInfo {
            hasNextPage
            endCursor
          }
          list {
            id
            name
            type
            status
            participantsCount
            loyaltyPoints
            startTime
            endTime
            cap
          }
        }
      }`,
      variables: {
        input: {
          spaceId,
          first: limit,
          after: cursor,
          statuses
        }
      }
    })
  });
  
  const data = await response.json();
  return data.data.quests;
}

function getQuestPhase(quest) {
  switch (quest.status) {
    case 'NotStarted':
      return 'not_started';
    case 'Active':
      if (quest.startTime && quest.endTime) {
        const now = Math.floor(Date.now() / 1000);
        if (now < quest.startTime) return 'scheduled';
        if (now > quest.endTime) return 'ended_pending';
      }
      return 'active';
    case 'Expired':
      return 'expired';
    case 'CapReached':
      return 'full';
    case 'Draft':
      return 'draft';
    case 'Deleted':
      return 'deleted';
    default:
      return 'unknown';
  }
}

function isQuestParticipable(quest) {
  if (quest.status !== 'Active') return false;
  
  // Check capacity
  if (quest.cap > 0 && quest.participantsCount >= quest.cap) return false;
  
  // Check timing
  if (quest.startTime && quest.endTime) {
    const now = Math.floor(Date.now() / 1000);
    if (now < quest.startTime || now > quest.endTime) return false;
  }
  
  return true;
}

// Validate quest before showing UI
const accessToken = process.env.GALXE_ACCESS_TOKEN;

try {
  const quest = await validateQuest('GChdWUjXX3', accessToken);
  console.log(`Quest "${quest.name}" is ${quest.status}`);
  console.log(`Participants: ${quest.participantsCount}`);
  
  const phase = getQuestPhase(quest);
  const canParticipate = isQuestParticipable(quest);
  
  console.log(`Phase: ${phase}`);
  console.log(`Can participate: ${canParticipate}`);
} catch (error) {
  console.error('Quest validation failed:', error.message);
}

// Check if user can participate
const userAddress = '0x1234567890123456789012345678901234567890';
const eligibility = await checkUserEligibility('GChdWUjXX3', userAddress, accessToken);

if (eligibility.isEligible) {
  console.log('User is eligible for quest');
  console.log('Available rewards:', eligibility.eligibilityDetails
    .flatMap(group => group.eligibleRewards)
    .map(reward => reward.expression)
  );
} else {
  console.log('User is not eligible for this quest');
  console.log('Missing requirements:', eligibility.eligibilityDetails
    .filter(group => !group.conditionsMet)
    .map(group => group.groupName)
  );
}

// Get active quests for a space
const spaceQuests = await getSpaceQuests('40', accessToken, {
  statuses: ['Active'],
  limit: 10
});

console.log(`Found ${spaceQuests.totalCount} active quests`);
console.log('Quest list:');
spaceQuests.list.forEach(quest => {
  console.log(`- ${quest.name} (${quest.loyaltyPoints} points, ${quest.participantsCount} participants)`);
});

async function createQuestDashboard(spaceId, userAddress, accessToken) {
  // Get active quests
  const quests = await getSpaceQuests(spaceId, accessToken, {
    statuses: ['Active'],
    limit: 10
  });
  
  // Check eligibility for top quests
  const eligibilityChecks = await Promise.all(
    quests.list.slice(0, 5).map(quest => 
      checkUserEligibility(quest.id, userAddress, accessToken)
        .then(result => ({ ...quest, eligibility: result }))
        .catch(error => ({ ...quest, eligibility: { error: error.message } }))
    )
  );
  
  const eligibleQuests = eligibilityChecks.filter(q => q.eligibility.isEligible);
  const totalPoints = eligibleQuests.reduce((sum, q) => sum + q.loyaltyPoints, 0);
  
  return {
    space: { id: spaceId },
    totalQuests: quests.totalCount,
    checkedQuests: eligibilityChecks.length,
    eligibleQuests: eligibleQuests.length,
    potentialPoints: totalPoints,
    quests: eligibilityChecks
  };
}