API de Resultados Automáticos

<?php
header('Content-Type: application/json; charset=utf-8');
date_default_timezone_set('America/Sao_Paulo');

$token = 'INFORME_AQUI_O_TOKEN_DO_SEU_PAINEL';

$headers = function_exists('getallheaders') ? getallheaders() : [];
$token_recebido = $_SERVER['HTTP_X_AUTH_TOKEN'] ?? $_SERVER['HTTP_TOKEN'] ?? '';

if (!$token_recebido && isset($headers['X-Auth-Token'])) {
	$token_recebido = $headers['X-Auth-Token'];
}
if (!$token_recebido && isset($headers['Token'])) {
	$token_recebido = $headers['Token'];
}
if (!$token_recebido && !empty($_SERVER['HTTP_AUTHORIZATION'])) {
	$auth = trim($_SERVER['HTTP_AUTHORIZATION']);
	if (stripos($auth, 'Bearer ') === 0) {
		$token_recebido = trim(substr($auth, 7));
	}
}

if (!hash_equals($token, (string)$token_recebido)) {
	http_response_code(401);
	echo json_encode(['codigo' => 401, 'mensagem' => 'Token inválido.']);
	exit;
}

$raw = file_get_contents('php://input');
$dados = json_decode($raw, true);

if (!is_array($dados)) {
	http_response_code(400);
	echo json_encode(['codigo' => 400, 'mensagem' => 'POST JSON inválido.']);
	exit;
}

$obrigatorios = ['res_data', 'res_loteria', 'res_extracao', 'res_resultado', 'primeiro_premio', 'segundo_premio', 'terceiro_premio', 'quarto_premio', 'quinto_premio'];
foreach ($obrigatorios as $campo) {
	if (!isset($dados[$campo]) || $dados[$campo] === '') {
		http_response_code(422);
		echo json_encode(['codigo' => 422, 'mensagem' => 'Campo obrigatório ausente: '.$campo]);
		exit;
	}
}

$res_data = preg_replace('/[^0-9\-]/', '', $dados['res_data']);
$res_loteria = preg_replace('/[^a-z0-9_\-]/i', '', $dados['res_loteria']);
$res_extracao = str_pad(preg_replace('/\D/', '', $dados['res_extracao']), 2, '0', STR_PAD_LEFT);
$res_resultado = trim((string)$dados['res_resultado']);

$linha_unica = $res_data.'|'.$res_loteria.'|'.$res_extracao;
$arquivo_duplicados = __DIR__.'/resultados_recebidos_ids.txt';
$ids = file_exists($arquivo_duplicados) ? file($arquivo_duplicados, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES) : [];

if (in_array($linha_unica, $ids, true)) {
	http_response_code(200);
	echo json_encode(['codigo' => 200, 'mensagem' => 'Resultado já foi recebido anteriormente. Registro não duplicado.']);
	exit;
}

file_put_contents(__DIR__.'/resultados_recebidos_payloads.txt', '['.date('Y-m-d H:i:s').'] '.$raw.PHP_EOL, FILE_APPEND);
file_put_contents($arquivo_duplicados, $linha_unica.PHP_EOL, FILE_APPEND);

// A partir daqui você pode salvar no banco de dados do seu sistema.

http_response_code(200);
echo json_encode(['codigo' => 200, 'mensagem' => 'Resultado recebido com sucesso.']);

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

app.use(express.json({ limit: '1mb' }));

const TOKEN = 'INFORME_AQUI_O_TOKEN_DO_SEU_PAINEL';

app.post('/webhook/resultados', (req, res) => {
    const tokenRecebido = req.headers['x-auth-token'] || req.headers['token'] || (req.headers['authorization'] || '').replace(/^Bearer\s+/i, '');

    if (tokenRecebido !== TOKEN) {
        return res.status(401).json({ codigo: 401, mensagem: 'Token inválido.' });
    }

    const dados = req.body;
    const obrigatorios = ['res_data', 'res_loteria', 'res_extracao', 'res_resultado', 'primeiro_premio'];
    const ausente = obrigatorios.find(campo => !dados[campo]);

    if (ausente) {
        return res.status(422).json({ codigo: 422, mensagem: `Campo obrigatório ausente: ${ausente}` });
    }

    console.log('Resultado recebido:', dados.res_loteria, dados.res_extracao, dados.res_resultado);

    // Salve no banco de dados do seu sistema aqui.

    return res.status(200).json({ codigo: 200, mensagem: 'Resultado recebido com sucesso.' });
});

app.listen(3000, () => console.log('Receptor rodando na porta 3000'));

from flask import Flask, request, jsonify

app = Flask(__name__)
TOKEN = 'INFORME_AQUI_O_TOKEN_DO_SEU_PAINEL'

@app.post('/webhook/resultados')
def receber_resultado():
    token_recebido = request.headers.get('X-Auth-Token') or request.headers.get('Token')
    auth = request.headers.get('Authorization', '')

    if not token_recebido and auth.lower().startswith('bearer '):
        token_recebido = auth[7:].strip()

    if token_recebido != TOKEN:
        return jsonify({'codigo': 401, 'mensagem': 'Token inválido.'}), 401

    dados = request.get_json(silent=True)
    if not isinstance(dados, dict):
        return jsonify({'codigo': 400, 'mensagem': 'POST JSON inválido.'}), 400

    obrigatorios = ['res_data', 'res_loteria', 'res_extracao', 'res_resultado', 'primeiro_premio']
    for campo in obrigatorios:
        if not dados.get(campo):
            return jsonify({'codigo': 422, 'mensagem': f'Campo obrigatório ausente: {campo}'}), 422

    print('Resultado recebido:', dados['res_loteria'], dados['res_extracao'], dados['res_resultado'])

    # Salve no banco de dados do seu sistema aqui.

    return jsonify({'codigo': 200, 'mensagem': 'Resultado recebido com sucesso.'}), 200

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

const string TOKEN = "INFORME_AQUI_O_TOKEN_DO_SEU_PAINEL";

app.MapPost("/webhook/resultados", async (HttpRequest request) =>
{
    string tokenRecebido =
        request.Headers["X-Auth-Token"].FirstOrDefault()
        ?? request.Headers["Token"].FirstOrDefault()
        ?? request.Headers["Authorization"].FirstOrDefault()?.Replace("Bearer ", "");

    if (tokenRecebido != TOKEN)
        return Results.Json(new { codigo = 401, mensagem = "Token inválido." }, statusCode: 401);

    var dados = await request.ReadFromJsonAsync<Dictionary<string, object>>();

    if (dados == null)
        return Results.Json(new { codigo = 400, mensagem = "POST JSON inválido." }, statusCode: 400);

    string[] obrigatorios = { "res_data", "res_loteria", "res_extracao", "res_resultado", "primeiro_premio" };

    foreach (var campo in obrigatorios)
    {
        if (!dados.ContainsKey(campo) || string.IsNullOrWhiteSpace(dados[campo]?.ToString()))
            return Results.Json(new { codigo = 422, mensagem = $"Campo obrigatório ausente: {campo}" }, statusCode: 422);
    }

    Console.WriteLine($"Resultado recebido: {dados["res_loteria"]} {dados["res_extracao"]}");

    return Results.Json(new { codigo = 200, mensagem = "Resultado recebido com sucesso." }, statusCode: 200);
});

app.Run();

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"strings"
)

const TOKEN = "INFORME_AQUI_O_TOKEN_DO_SEU_PAINEL"

func receberResultado(w http.ResponseWriter, r *http.Request) {

	w.Header().Set("Content-Type", "application/json")

	if r.Method != http.MethodPost {
		w.WriteHeader(http.StatusMethodNotAllowed)
		json.NewEncoder(w).Encode(map[string]interface{}{
			"codigo": 405,
			"mensagem": "Método não permitido.",
		})
		return
	}

	tokenRecebido := r.Header.Get("X-Auth-Token")

	if tokenRecebido == "" {
		tokenRecebido = r.Header.Get("Token")
	}

	if tokenRecebido == "" {
		tokenRecebido = strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer ")
	}

	if tokenRecebido != TOKEN {
		w.WriteHeader(http.StatusUnauthorized)
		json.NewEncoder(w).Encode(map[string]interface{}{
			"codigo": 401,
			"mensagem": "Token inválido.",
		})
		return
	}

	var dados map[string]interface{}

	if err := json.NewDecoder(r.Body).Decode(&dados); err != nil {
		w.WriteHeader(http.StatusBadRequest)
		json.NewEncoder(w).Encode(map[string]interface{}{
			"codigo": 400,
			"mensagem": "POST JSON inválido.",
		})
		return
	}

	fmt.Println("Resultado recebido:", dados["res_loteria"])

	w.WriteHeader(http.StatusOK)

	json.NewEncoder(w).Encode(map[string]interface{}{
		"codigo": 200,
		"mensagem": "Resultado recebido com sucesso.",
	})
}

func main() {
	http.HandleFunc("/webhook/resultados", receberResultado)
	http.ListenAndServe(":8080", nil)
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.Map;

@SpringBootApplication
@RestController
public class ReceptorResultadosApplication {

    private static final String TOKEN = "INFORME_AQUI_O_TOKEN_DO_SEU_PAINEL";

    public static void main(String[] args) {
        SpringApplication.run(ReceptorResultadosApplication.class, args);
    }

    @PostMapping("/webhook/resultados")
    public ResponseEntity<Map<String, Object>> receberResultado(
            @RequestHeader(value = "X-Auth-Token", required = false) String xAuthToken,
            @RequestBody(required = false) Map<String, Object> dados
    ) {

        if (!TOKEN.equals(xAuthToken)) {
            return ResponseEntity.status(401)
                    .body(Map.of("codigo", 401, "mensagem", "Token inválido."));
        }

        if (dados == null) {
            return ResponseEntity.status(400)
                    .body(Map.of("codigo", 400, "mensagem", "POST JSON inválido."));
        }

        System.out.println("Resultado recebido: " + dados.get("res_loteria"));

        return ResponseEntity.ok(
                Map.of("codigo", 200, "mensagem", "Resultado recebido com sucesso.")
        );
    }
}