async def create_client(ipc_client=None):
if ipc_client is None:
ipc_client = ipc.Client(host=getenv('IPC_HOST'),
port=getenv('IPC_PORT'),
secret_key=getenv('IPC_PASSWORD'))
try:
await ipc_client.request("get_guild_count")
except ClientConnectorError:
ipc_client = None
except ConnectionResetError:
ipc_client = ipc.Client(host=getenv('IPC_HOST'),
port=getenv('IPC_PORT'),
secret_key=getenv('IPC_PASSWORD'))
return ipc_client
from discord.ext import ipc
from starlette.applications import Starlette
from starlette.responses import PlainTextResponse, Response
from starlette.templating import Jinja2Templates
import config
ipc_client = ipc.Client(secret_key=config.SECRET_KEY)
app = Starlette(debug=True)
templates = Jinja2Templates(directory="templates")
msg_dict = {
"unknown-error": (
"alert-circle",
"Error",
"An unknown error has occurred. Please try again later.",
),
"not-found": (
"alert-circle",
"Error",
"The authorization request was not found. It may have expired. Please try again.",
),
"approved": (
"checkmark-circle",
"Approved",
"You have been approved! You can now close this tab and return to Discord.",
),
"rejected": (
"close-circle",
"Rejected",
from quart import Quart
from discord.ext import ipc
app = Quart(__name__)
ipc_client = ipc.Client(secret_key="my_secret_key") # secret_key must be the same as your server
@app.before_first_request
async def before():
app.ipc_node = await ipc_client.discover() # discover IPC Servers on your network
@app.route("/")
async def index():
member_count = await app.ipc_node.request("get_member_count", guild_id=12345678) # get the member count of server with ID 12345678
return str(member_count) # display member count
if __name__ == "__main__":
app.run()
from dotenv import load_dotenv
logging.basicConfig(
level=logging.INFO,
filename="server.log",
datefmt="%m/%d/%Y %I:%M:%S %p",
format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
filemode="w",
)
load_dotenv()
IPC_SECRET_KEY = os.getenv("IPC_SECRET_KEY")
app = Quart(__name__)
ipc_client = ipc.Client(secret_key=IPC_SECRET_KEY)
def authenticate_request(key):
return key == os.getenv("API_KEY")
@app.route("/test")
def test():
return "this is a test"
@app.route("/submit_application", methods=["POST"])
async def submit_application():
app.logger.info("/submit_application post received.")
from quart import Quart, render_template, request, session, redirect, url_for
from quart_discord import DiscordOAuth2Session
from discord.ext import ipc
app = Quart(__name__)
ipc_client = ipc.Client(secret_key="Swas")
app.config["SECRET_KEY"] = "test123"
app.config["DISCORD_CLIENT_ID"] = 726655948302843934 # Discord client ID.
app.config[
"DISCORD_CLIENT_SECRET"] = "L0hmWrcyZoLUCeY5FIC2dKbwqjqzDrZv" # Discord client secret.
app.config["DISCORD_REDIRECT_URI"] = "http://127.0.0.1:5000/callback"
discord = DiscordOAuth2Session(app)
@app.route("/")
async def home():
return await render_template("index.html")
@app.route("/login")
async def login():
return await discord.create_session()
@app.route("/callback")
async def callback():
try:
await discord.callback()
except:
import os
from datetime import timedelta
import requests
from requests_oauthlib import OAuth2Session
from quart import Quart, request, redirect, render_template, session, url_for
#from flask import Flask, request, redirect, render_template, session, url_for
from quart_discord import DiscordOAuth2Session, requires_authorization, models
from routes.discord_oauth import DiscordOauth
from discord.ext import ipc
app = Quart(__name__)
ipc_client = ipc.Client(secret_key="aswedfghjuygfvcdxs")
app.secret_key = "aswedfghjuygfvcdxs"
os.environ[
"OAUTHLIB_INSECURE_TRANSPORT"] = "true" # !! Only in development environment.
app.config["DISCORD_CLIENT_ID"] = id
app.config["DISCORD_CLIENT_SECRET"] = 'secret'
app.config["DISCORD_BOT_TOKEN"] = 'token'
app.config["DISCORD_REDIRECT_URI"] = "http://127.0.0.1:5000/redirect"
discord = DiscordOAuth2Session(app)
@app.route('/')
async def index():
return redirect('/home')
@app.route('/home')
import hmac
import logging
import toml
from discord.ext import ipc
from quart import Quart, request, Response
logger = logging.getLogger(__name__)
app = Quart(__name__)
config = toml.load('config.toml')
ipc_client = ipc.Client(secret_key=config['global']['ipc_secret'])
@app.route('/webhook', methods=['POST'])
async def respond():
token = request.headers.get('Digest').split("=", 1)[1]
request_data = await request.get_data()
new_digest = hmac.new(key=config['server']['signature'].encode(),
msg=request_data,
digestmod="md5").hexdigest()
comparison = hmac.compare_digest(token, new_digest)
json = await request.json
if comparison:
sent = await ipc_client.request('on_webhook_received',
request_json=json)
if sent:
logger.info(f"[{request.host}] Status: Success")
return Response(status=200, response={"Status": "Success"})
else:
import config
from quart import Quart, render_template, request, session, redirect, url_for
from quart_discord import DiscordOAuth2Session
from discord.ext import ipc
from utils import database
from globals import modules
app = Quart(__name__,
static_folder="web/public",
template_folder="web/templates")
ipc_client = ipc.Client(secret_key=config.ipc_key)
app.config["SECRET_KEY"] = config.secret_key
app.config["DISCORD_CLIENT_ID"] = config.discord_client_id
app.config["DISCORD_CLIENT_SECRET"] = config.discord_client_secret
app.config["DISCORD_REDIRECT_URI"] = config.discord_redirect_uri
discord = DiscordOAuth2Session(app)
################## DASHBOARD ##################
@app.route("/")
async def home():
authorized = await discord.authorized
if authorized == True:
return redirect("/dashboard")
else:
return await render_template("index.html")
'loggers': {
'quart.app': {
'level': 'ERROR',
},
'quart.serving': {
'level': 'ERROR',
},
},
})
template_folder_path = os.path.abspath('Website/src')
static_folder_path = os.path.abspath('Website/static')
app = Quart(__name__,
template_folder=template_folder_path,
static_folder=static_folder_path)
ipc_client = ipc.Client(secret_key=bot.env_vars["IPC_SECRET"])
app.config["SECRET_KEY"] = str(bot.env_vars["SECRET_KEY"])
app.config["DISCORD_CLIENT_ID"] = int(
bot.env_vars["DISCORD_CLIENT_ID"]) # Discord client ID.
app.config["DISCORD_CLIENT_SECRET"] = str(
bot.env_vars["DISCORD_CLIENT_SECRET"]) # Discord client secret.
app.config["DISCORD_REDIRECT_URI"] = str(bot.env_vars["DISCORD_REDIRECT_URI"])
discord_auth = DiscordOAuth2Session(app)
class DiscordClient:
def __init__(self):
self.bot = discord.Client(intents=discord.Intents.all())
async def get_guild(self, id):
await self.bot.wait_until_ready()
import sys, os
from discord.ext import ipc
from quart import jsonify, Quart, request
SCRIPT_DIR = os.path.dirname(os.path.abspath(
__file__)) # This is a necessary hacky fix for importing issues
sys.path.append(os.path.dirname(SCRIPT_DIR))
from static.constants import PASSWORD, IPC_TOKEN
app = Quart(__name__)
ipc_client = ipc.Client(secret_key=IPC_TOKEN)
async def is_authorised(headers: dict) -> bool:
if not "Authorization" in headers:
return False
if headers["Authorization"] != PASSWORD:
return False
return True
@app.route('/vote/', methods=['POST', 'PUT'])
async def vote():
"""Handles a vote event and calls the right function within the bots code"""
if not await is_authorised(request.headers):
return jsonify({"error": "Unauthorised"}), 401
import os
from discord.ext import ipc
from quart import Quart, render_template, redirect, url_for, request, session, flash, abort, send_from_directory, \
jsonify
import davobot
app = Quart(__name__)
ipc_client = ipc.Client(secret_key=davobot.ipc_secret)
app.config.update({
'DEBUG': True,
'SECRET_KEY': '4Zh85UDeI2KwfTMxD4px2hGHjUqy2t1w',
'USERNAME': '******',
'PASSWORD': '******',
})
@app.before_first_request
async def before():
app.ipc_node = await ipc_client.discover() # discover IPC Servers on your network
@app.route('/favicon.ico', methods=['GET'])
async def favicon():
return await send_from_directory(os.path.join(app.root_path, 'static/media'),
'favicon.ico', mimetype='image/vnd.microsoft.icon')
@app.route('/login/', methods=['GET', 'POST'])
from discord.ext import ipc
from . import web_utils
import os, utils
# paths
BASE_DIR = os.path.dirname(__file__)
# connect to discord bot
_config = utils.load_bot_config()
IPC_CLIENT = ipc.Client(secret_key=_config['ipc_key'],
port=_config['ipc_port'])
from quart import Quart, Response
from discord.ext import ipc
import utils
# connect to bot
config = utils.load_bot_config()
ipc_client = ipc.Client(secret_key=config['ipc_key'], port=config['ipc_port'])
# start web app
app = Quart(__name__)
@app.route("/")
async def index():
import time
ping_time = await ipc_client.request('ping')
ping_time = time.time_ns() - ping_time
content = f"Pong in {ping_time / 10**6:.1f} ms!"
return Response(f"""<html>
<head></head>
</body><p>{content}</p></body>
</html>""")
if __name__ == "__main__":
app.run()
from quart import Quart, render_template, request, session, redirect, url_for, jsonify
from quart_discord import DiscordOAuth2Session
from discord.ext import ipc
import html
import json
app = Quart(__name__)
ipc_client = ipc.Client(secret_key="JamEater")
app.config["SECRET_KEY"] = "test123"
app.config["DISCORD_CLIENT_ID"] = 813008914207080449
app.config["DISCORD_CLIENT_SECRET"] = "zn-ifplp8Z8XVatyFN5DGmRsiOMmdnsJ"
app.config["DISCORD_REDIRECT_URI"] = "https://127.0.0.1:5000/callback"
discord = DiscordOAuth2Session(app)
@app.route("/")
async def home():
return await render_template("index.html")
@app.route("/login")
async def login():
return await discord.create_session()
@app.route("/invite/<guildid>")
async def invite(guildid):
return await discord.create_session(scope=["bot"],
permissions=8,
