Vote Webhooks

{
  "userId": "987654321098765432",
  "serverId": "123456789012345678",
  "timestamp": "2025-11-25T10:00:00.000Z",
  "creditsAwarded": true,
  "adBlocker": false,
  "creditDenialReason": null,
  "test": false
}

const express = require('express');
const app = express();

app.use(express.json());

const EXPECTED_AUTH = process.env.RANKLY_WEBHOOK_AUTH;

app.post('/webhook/votes', (req, res) => {
  // Verify authorization header if configured
  const authHeader = req.headers['authorization'];
  if (EXPECTED_AUTH && authHeader !== EXPECTED_AUTH) {
    console.error('Unauthorized webhook request');
    return res.status(401).json({ error: 'Unauthorized' });
  }

  const { userId, serverId, creditsAwarded, adBlocker, test } = req.body;

  // Ignore test webhooks
  if (test) {
    console.log('✅ Test webhook received successfully');
    return res.status(200).json({ received: true, test: true });
  }

  console.log(`Vote: User ${userId} voted for server ${serverId}`);

  // Grant reward if credits were awarded
  if (creditsAwarded && !adBlocker) {
    grantVoteReward(userId, serverId);
  }

  // Always return 200 immediately
  return res.status(200).json({ received: true });
});

async function grantVoteReward(userId, serverId) {
  // Implement your reward logic
  console.log(`Granted reward to ${userId}`);
}

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

import os
from flask import Flask, request, jsonify

app = Flask(__name__)

EXPECTED_AUTH = os.environ.get('RANKLY_WEBHOOK_AUTH')

@app.route('/webhook/votes', methods=['POST'])
def handle_vote():
    # Verify authorization
    auth_header = request.headers.get('Authorization')
    if EXPECTED_AUTH and auth_header != EXPECTED_AUTH:
        return jsonify({'error': 'Unauthorized'}), 401

    payload = request.json
    user_id = payload.get('userId')
    server_id = payload.get('serverId')
    credits_awarded = payload.get('creditsAwarded')
    ad_blocker = payload.get('adBlocker')
    is_test = payload.get('test', False)

    # Ignore test webhooks
    if is_test:
        print('✅ Test webhook received')
        return jsonify({'received': True, 'test': True}), 200

    print(f'Vote: User {user_id} voted for server {server_id}')

    # Grant reward
    if credits_awarded and not ad_blocker:
        grant_vote_reward(user_id, server_id)

    return jsonify({'received': True}), 200

def grant_vote_reward(user_id, server_id):
    # Implement your reward logic
    pass

if __name__ == '__main__':
    app.run(port=3000)

import discord
from discord.ext import commands
from flask import Flask, request, jsonify
import asyncio

app = Flask(__name__)
bot = commands.Bot(command_prefix='!')

VOTE_ROLE_ID = 123456789  # Your role ID
EXPECTED_AUTH = 'your-secret'

@app.route('/webhook/votes', methods=['POST'])
def handle_vote():
    # Verify auth
    if request.headers.get('Authorization') != EXPECTED_AUTH:
        return jsonify({'error': 'Unauthorized'}), 401

    payload = request.json
    user_id = int(payload['userId'])
    server_id = int(payload['serverId'])
    credits_awarded = payload['creditsAwarded']
    is_test = payload.get('test', False)

    if is_test:
        return jsonify({'received': True}), 200

    if not credits_awarded:
        return jsonify({'received': True}), 200

    # Grant role asynchronously
    asyncio.run_coroutine_threadsafe(
        grant_vote_role(user_id, server_id),
        bot.loop
    )

    return jsonify({'received': True}), 200

async def grant_vote_role(user_id, server_id):
    try:
        guild = bot.get_guild(server_id)
        if not guild:
            return

        member = await guild.fetch_member(user_id)
        role = guild.get_role(VOTE_ROLE_ID)

        if member and role:
            await member.add_roles(role)
            await member.send('🎉 Thank you for voting!')
    except Exception as e:
        print(f'Error granting role: {e}')

const express = require('express');
const { Client, GatewayIntentBits, EmbedBuilder } = require('discord.js');

const app = express();
app.use(express.json());

const client = new Client({
  intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMembers]
});

const VOTE_ROLE_ID = 'YOUR_ROLE_ID';
const EXPECTED_AUTH = process.env.RANKLY_WEBHOOK_AUTH;

app.post('/webhook/votes', async (req, res) => {
  // Verify auth
  if (EXPECTED_AUTH && req.headers['authorization'] !== EXPECTED_AUTH) {
    return res.status(401).json({ error: 'Unauthorized' });
  }

  const { userId, serverId, creditsAwarded, test } = req.body;

  if (test) {
    return res.status(200).json({ received: true });
  }

  if (!creditsAwarded) {
    return res.status(200).json({ received: true });
  }

  try {
    const guild = await client.guilds.fetch(serverId);
    const member = await guild.members.fetch(userId);
    const role = guild.roles.cache.get(VOTE_ROLE_ID);

    if (member && role) {
      await member.roles.add(role);

      // Send DM
      const embed = new EmbedBuilder()
        .setColor('#Green')
        .setTitle('🎉 Thank you for voting!')
        .setDescription('You received the Voter role!');

      await member.send({ embeds: [embed] });
    }

    return res.status(200).json({ received: true, rewarded: true });
  } catch (error) {
    console.error('Error:', error);
    return res.status(200).json({ received: true, rewarded: false });
  }
});

client.login(process.env.DISCORD_TOKEN);
app.listen(3000);