def init(app):
discord = DiscordOAuth2Session(app)
@app.route("/login")
def discord_login():
session["state"] = request.args.get("n") or request.referrer or "/"
return discord.create_session()
@app.route("/login/error")
def login_error():
return render_template("login_error.html")
@app.route("/login/authorized")
def discord_auth():
discord.callback()
user = discord.fetch_user()
with DBManager.create_session_scope(expire_on_commit=False) as db_session:
session["user"] = User._create_or_get_by_discord_id(
db_session, str(user.id), str(user)
).jsonify()
session["user_displayname"] = str(user)
next_url = session.get("state", "/")
return redirect(next_url)
@app.route("/logout")
def logout():
discord.revoke()
session.pop("user_displayname", None)
session.pop("user", None)
next_url = request.args.get("n") or request.referrer or "/"
if next_url.startswith("/admin"):
next_url = "/"
return redirect(next_url)
def app(monkeypatch):
app = flask.Flask(__name__)
app.config['TESTING'] = True
app.secret_key = b"%\xe0'\x01\xdeH\x8e\x85m|\xb3\xffCN\xc9g"
monkeypatch.setenv('OAUTHLIB_INSECURE_TRANSPORT', 'true')
app.config["DISCORD_CLIENT_ID"] = 490732332240863233
app.config["DISCORD_CLIENT_SECRET"] = "TEST_DISCORD_CLIENT_SECRET"
app.config["DISCORD_BOT_TOKEN"] = "TEST_DISCORD_BOT_TOKEN"
app.config["DISCORD_REDIRECT_URI"] = "http://127.0.0.1:5000/callback"
discord = DiscordOAuth2Session(app)
@app.route("/me/guilds/")
def user_guilds():
guilds = discord.fetch_guilds()
guilds = guilds.return_value
return "<br />".join([
f"[ADMIN] {g.name}" if g.permissions.administrator else g.name
for g in guilds
])
@app.route("/add_to/<int:guild_id>/")
def add_to_guild(guild_id):
user = discord.fetch_user()
return user.add_to_guild(guild_id)
return app
def __init__(self, app: flask.Flask):
self.app = app
self.sio = flask_socketio.SocketIO(app)
self.discord = DiscordOAuth2Session(app)
self.metrics = PrometheusMetrics(app)
self.fernet_encrypt = Fernet(app.config["FERNET_KEY"])
if app.config["GUEST_KEY"] is not None:
self.guest_encrypt = Fernet(app.config["GUEST_KEY"])
def __init__(self, session: DiscordOAuth2Session):
self.session = session
self.user = session.fetch_user()
table_factory = TableFactory()
self.player = table_factory.get_players_table().get_player_by_id(
self.user.id)
self.raidteam = table_factory.get_raid_teams_table().get_raidteam(
self.player.selected_guild_id, self.player.selected_team_name)
def app(monkeypatch, data_login_with_data, data_invite_bot, data_invite_oauth):
app = flask.Flask(__name__)
app.config['TESTING'] = True
app.secret_key = b"%\xe0'\x01\xdeH\x8e\x85m|\xb3\xffCN\xc9g"
monkeypatch.setenv('OAUTHLIB_INSECURE_TRANSPORT', 'true')
app.config["DISCORD_CLIENT_ID"] = 490732332240863233
app.config["DISCORD_CLIENT_SECRET"] = "TEST_DISCORD_CLIENT_SECRET"
app.config["DISCORD_BOT_TOKEN"] = "TEST_DISCORD_BOT_TOKEN"
app.config["DISCORD_REDIRECT_URI"] = "http://127.0.0.1:5000/callback"
discord = DiscordOAuth2Session(app)
@app.route("/")
def index():
pass
@app.route("/login/")
def login():
return discord.create_session()
@app.route("/login-prompt/")
def login_prompt():
return discord.create_session(scope=data_invite_bot['scope'],
prompt=False)
@app.route("/login-data/")
def login_with_data():
return discord.create_session(data=data_login_with_data)
@app.route("/invite-bot/")
def invite_bot():
return discord.create_session(
scope=data_invite_bot['scope'],
permissions=data_invite_bot['permissions'],
guild_id=data_invite_bot['guild_id'],
disable_guild_select=data_invite_bot['disable_guild_select'])
@app.route("/invite-bot-invalid-permissions/")
def invite_bot_invalid_permissions():
return discord.create_session(
scope=data_invite_bot['scope'],
permissions='raise_value_error',
guild_id=data_invite_bot['guild_id'],
disable_guild_select=data_invite_bot['disable_guild_select'])
@app.route("/invite-oauth/")
def invite_oauth():
return discord.create_session(
scope=data_invite_oauth['scope'],
permissions=data_invite_oauth['permissions'])
@app.route("/logout/")
def logout():
discord.revoke()
return redirect(url_for(".index"))
return app
def app(monkeypatch):
app = flask.Flask(__name__)
app.config['TESTING'] = True
app.secret_key = b"%\xe0'\x01\xdeH\x8e\x85m|\xb3\xffCN\xc9g"
monkeypatch.setenv('OAUTHLIB_INSECURE_TRANSPORT', 'true')
app.config["DISCORD_CLIENT_ID"] = 490732332240863233
app.config["DISCORD_CLIENT_SECRET"] = "TEST_DISCORD_CLIENT_SECRET"
app.config["DISCORD_BOT_TOKEN"] = "TEST_DISCORD_BOT_TOKEN"
app.config["DISCORD_REDIRECT_URI"] = "http://127.0.0.1:5000/callback"
discord = DiscordOAuth2Session(app)
@app.route("/me/")
def me():
user = discord.fetch_user()
if user is None:
abort(401)
return jsonify(user_name=user.name,
avatar_url=user.avatar_url or user.default_avatar_url,
is_avatar_animated=user.is_avatar_animated)
@app.route("/me/connections/")
def my_connections():
user = discord.fetch_user()
connections = discord.fetch_connections()
if user is None or connections is None:
abort(401)
return jsonify(user_name=user.name,
connections=[
f"{connection.name} - {connection.type}"
for connection in connections
])
@app.route("/me/guilds/")
def user_guilds():
guilds = discord.fetch_guilds()
guilds = guilds.return_value
return "<br />".join([
f"[ADMIN] {g.name}" if g.permissions.administrator else g.name
for g in guilds
])
@app.route("/add_to/<int:guild_id>/")
def add_to_guild(guild_id):
user = discord.fetch_user()
return user.add_to_guild(guild_id)
return app
def create_app():
app = Flask(__name__)
if os.path.isfile("/config/config.py"):
app.config.from_pyfile("/config/config.py")
else:
logging.error("No config file found in /config/config.py")
sys.exit(0)
with app.app_context():
from piracymoe import api
app.register_blueprint(api.bp)
from piracymoe import editor
app.register_blueprint(editor.bp)
app.discord = DiscordOAuth2Session(app)
return app
def create_app():
app = Flask(__name__)
# setting flask_secret#
with open(os.path.join("/config", ".flask_secret"), "rb") as secret:
app.secret_key = secret.read()
# discord oauth-2 config
app.config["DISCORD_CLIENT_ID"] = os.environ.get("DISCORD_CLIENT_ID")
app.config["DISCORD_CLIENT_SECRET"] = os.environ.get("DISCORD_CLIENT_SECRET")
app.config["DISCORD_REDIRECT_URI"] = os.environ.get("DISCORD_REDIRECT_URI")
app.config["DISCORD_BOT_TOKEN"] = os.environ.get("DISCORD_BOT_TOKEN")
with app.app_context():
from piracymoe import api
app.register_blueprint(api.bp)
from piracymoe import editor
app.register_blueprint(editor.bp)
app.discord = DiscordOAuth2Session(app)
return app
def create_app():
app = Flask(__name__,
template_folder=os.path.join("piracymoe", "templates"),
static_folder=os.path.join("piracymoe", "static"))
app.secret_key = "CHANGE THIS IN PRODUCTION 11111"
if os.path.isfile("/config/config.py"):
app.config.from_pyfile("/config/config.py")
else:
app.config.from_pyfile("config.py")
logging.error(app.config)
with app.app_context():
from piracymoe.views import editor
from piracymoe.views import index
from piracymoe import api
app.register_blueprint(editor.bp)
app.register_blueprint(index.bp)
app.register_blueprint(api.bp)
app.discord = DiscordOAuth2Session(app)
return app
from main import app
from card_site.forms import UploadCard
from card_site.helpers import save_card_data, validate_card
from flask import render_template, redirect, flash
from werkzeug.exceptions import Forbidden
from flask_discord import DiscordOAuth2Session
discord = DiscordOAuth2Session(app)
@app.route("/upload", methods=["GET", "POST"])
def upload():
if not discord.authorized:
return Forbidden
user = discord.fetch_user()
form = UploadCard()
if form.validate_on_submit():
card_id = form.card_id.data
if card_id:
if validate_card(card_id):
save_card_data(card_id, discord.user_id)
return redirect("/view")
else:
flash("Invalid Order ID")
else:
# The user somehow inputted nothing and it accepted it
flash("Error Uploading Card")
def app(monkeypatch):
app = flask.Flask(__name__)
app.config['TESTING'] = True
app.secret_key = b"%\xe0'\x01\xdeH\x8e\x85m|\xb3\xffCN\xc9g"
monkeypatch.setenv('OAUTHLIB_INSECURE_TRANSPORT', 'true')
app.config["DISCORD_CLIENT_ID"] = 836357504018677810
app.config["DISCORD_CLIENT_SECRET"] = "vPX6jZdr1e1c74vB-JLZE1V1vU0EKoFF"
app.config[
"DISCORD_BOT_TOKEN"] = "ODM2MzU3NTA0MDE4Njc3ODEw.YIc0nw.vGlRUnpML0-upoG83Vy3DindqyM"
app.config["DISCORD_REDIRECT_URI"] = "http://127.0.0.1:5000/callback"
discord = DiscordOAuth2Session(app)
@app.route("/")
def index():
pass
@app.route("/login/")
def login():
return discord.create_session()
@app.route("/logout/")
def logout():
discord.revoke()
return redirect(url_for(".index"))
@app.route("/callback/")
def callback():
data = discord.callback()
redirect_to = data.get("redirect", "/me/")
return redirect(redirect_to)
@app.route("/me/")
def me():
user = discord.fetch_user()
if user is None:
abort(401)
return jsonify(user_name=user.name,
avatar_url=user.avatar_url or user.default_avatar_url,
is_avatar_animated=user.is_avatar_animated)
@app.route("/me/connections/")
def my_connections():
user = discord.fetch_user()
connections = discord.fetch_connections()
if user is None or connections is None:
abort(401)
return jsonify(user_name=user.name,
connections=[
f"{connection.name} - {connection.type}"
for connection in connections
])
@app.route("/secret/")
@requires_authorization
def secret():
return jsonify(secret=str(os.urandom(16)))
@app.route("/me/guilds/")
def user_guilds():
guilds = discord.fetch_guilds()
guilds = guilds.return_value
return "<br />".join([
f"[ADMIN] {g.name}" if g.permissions.administrator else g.name
for g in guilds
])
@app.route("/add_to/<int:guild_id>/")
def add_to_guild(guild_id):
user = discord.fetch_user()
return user.add_to_guild(guild_id)
return app
import dash
import os
from flask import Flask, redirect, url_for
from flask_discord import DiscordOAuth2Session, requires_authorization, Unauthorized
from dashboard.LoginUtils import BaseConfig
os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'
external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']
server = Flask(__name__)
server.config.from_object(BaseConfig)
server.secret_key = b"random bytes representing flask secret key"
discord = DiscordOAuth2Session(server)
def create_app():
register_dashapps(server)
return server
def register_dashapps(app):
from dashboard.Layout import index_layout, get_layout
dash_app1 = dash.Dash(__name__, server=app, url_base_pathname='/')
dash_app2 = dash.Dash(__name__,
server=app,
url_base_pathname='/dashboard_view/',
external_stylesheets=external_stylesheets)
with app.app_context():
dash_app1.title = 'Home'
from flask import Flask
from config import config
from .main import main as main_blp
from .command import command as command_blp
from flask_discord import DiscordOAuth2Session, requires_authorization
discord_oauth = DiscordOAuth2Session()
def create_app(config_name="default"):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
app.secret_key = b"%\xe0'\x01\xdeH\x8e\x85m|\xb3\xffCN\xc9g"
discord_oauth.init_app(app)
app.register_blueprint(main_blp)
app.register_blueprint(command_blp)
return app
def create_admin_blueprint(app):
admin = Blueprint('admin', __name__,
template_folder='webapp/templates',
static_folder='webapp/static',
root_path='src')
discord_session = DiscordOAuth2Session(app=app)
def raid_controller():
return ControllerFactory(discord_session).create_raid_controller()
def home_controller():
return ControllerFactory(discord_session).create_home_controller()
def player_controller():
return ControllerFactory(discord_session).create_player_controller()
def guild_controller():
return ControllerFactory(discord_session).create_guild_controller()
@admin.route('/')
def home():
return home_controller().home()
@admin.route('/guilds')
@requires_authorization
def guilds():
return guild_controller().index()
@admin.route('/guild/<int:guild_id>')
@requires_authorization
def guild(guild_id):
return guild_controller().show(guild_id)
@admin.route('/raids', methods=["GET", "POST"])
@requires_authorization
def raids():
if request.method == "GET":
return raid_controller().index()
return raid_controller().store(request.form)
@admin.route('/raids/create')
@requires_authorization
def create():
return raid_controller().create()
@admin.route('/raids/<team_id>/<name>/<int:timestamp>')
@requires_authorization
def raid(team_id, name, timestamp):
return raid_controller().show(team_id, name, timestamp)
@admin.route('/raids/<team_id>/<name>/<int:timestamp>/signup-remind')
@requires_authorization
def send_reminder(team_id, name, timestamp):
return raid_controller().send_reminder(team_id, name, timestamp)
@admin.route('/raids/<team_id>/<name>/<int:timestamp>/create-roster')
@requires_authorization
def create_roster(team_id, name, timestamp):
return raid_controller().create_roster(team_id, name, timestamp)
@admin.route('/raids/<team_id>/<name>/<int:timestamp>/invite-player')
@requires_authorization
def invite_player(team_id, name, timestamp):
return raid_controller().invite_player(team_id, name, timestamp)
@admin.route('/players')
@requires_authorization
def players():
return player_controller().index()
@admin.route('/player/<int:discord_id>')
@requires_authorization
def player(discord_id):
return player_controller().show(discord_id)
@admin.route("/login/")
def login():
return discord_session.create_session()
@admin.route("/logout/")
def logout():
discord_session.revoke()
return redirect(url_for('.home'))
@admin.route("/dokbot/redirect")
def callback():
discord_session.callback()
return redirect(url_for(".home"))
@admin.errorhandler(Unauthorized)
def redirect_unauthorized(e):
return redirect(url_for(".login"))
return admin
import os
from flask import Flask
from flask_discord import DiscordOAuth2Session
discord = DiscordOAuth2Session(client_id=490732332240863233)
def get_app():
app = Flask(__name__)
app.secret_key = b"%\xe0'\x01\xdeH\x8e\x85m|\xb3\xffCN\xc9g"
os.environ["OAUTHLIB_INSECURE_TRANSPORT"] = "true" # !! Only in development environment.
# app.config["DISCORD_CLIENT_ID"] = 490732332240863233
app.config["DISCORD_CLIENT_SECRET"] = os.getenv("DISCORD_CLIENT_SECRET")
app.config["DISCORD_BOT_TOKEN"] = os.getenv("DISCORD_BOT_TOKEN")
app.config["DISCORD_REDIRECT_URI"] = "http://127.0.0.1:5000/callback"
discord.init_app(app)
return app
app = Flask(__name__)
load_dotenv()
TOKENBOT = os.getenv("DISCORD_TOKEN")
app.secret_key = b"random bytes representing flask secret key"
os.environ[
"OAUTHLIB_INSECURE_TRANSPORT"] = "true" # !! Only in development environment.
app.config["DISCORD_CLIENT_ID"] = 671612079106424862 # Discord client ID.
app.config["DISCORD_CLIENT_SECRET"] = "put your own" # Discord client secret.
app.config[
"DISCORD_REDIRECT_URI"] = "http://127.0.0.1:5000/callback" # URL to your callback endpoint.
app.config["DISCORD_BOT_TOKEN"] = TOKENBOT # Required to access BOT resources.
discordoauth = DiscordOAuth2Session(app)
@app.route("/")
async def index():
return "Guild add completed"
@app.route("/login/")
def login():
return discord.create_session()
@app.route("/callback/")
def callback():
discordoauth.callback()
def configure_extensions(app):
"""Configures the extensions."""
# Flask-Allows
allows.init_app(app)
allows.identity_loader(lambda: current_user)
# Flask-WTF CSRF
csrf.init_app(app)
# Flask-SQLAlchemy
db.init_app(app)
# Flask-Alembic
alembic.init_app(app, command_name="db")
# Flask-Mail
mail.init_app(app)
# Flask-Cache
cache.init_app(app)
# Flask-Debugtoolbar
debugtoolbar.init_app(app)
# Flask-Themes
themes.init_themes(app,
app_identifier="flaskbb",
theme_url_prefix="/themes")
# Flask-And-Redis
redis_store.init_app(app)
# Flask-Limiter
limiter.init_app(app)
# Flask-Whooshee
whooshee.init_app(app)
whooshee.reindex()
# not needed for unittests - and it will speed up testing A LOT
if True: #not app.testing:
whooshee.register_whoosheer(PostWhoosheer)
whooshee.register_whoosheer(TopicWhoosheer)
whooshee.register_whoosheer(ForumWhoosheer)
whooshee.register_whoosheer(UserWhoosheer)
# Flask-Login
login_manager.login_view = app.config["LOGIN_VIEW"]
login_manager.refresh_view = app.config["REAUTH_VIEW"]
login_manager.login_message_category = app.config["LOGIN_MESSAGE_CATEGORY"]
login_manager.needs_refresh_message_category = app.config[
"REFRESH_MESSAGE_CATEGORY"]
login_manager.anonymous_user = Guest
@login_manager.user_loader
def load_user(user_id):
"""Loads the user. Required by the `login` extension."""
user_instance = User.query.filter_by(id=user_id).first()
if user_instance:
return user_instance
else:
return None
login_manager.init_app(app)
app.discord = DiscordOAuth2Session(app)
from utils.logger import logger
from client import client as bot
import datetime
from config import version, cfg
from db import collection
app = Flask('')
os.environ["OAUTHLIB_INSECURE_TRANSPORT"] = "true"
app.config["DISCORD_CLIENT_ID"] = os.environ.get("CLIENTID")
app.config["DISCORD_CLIENT_SECRET"] = os.environ.get("CLIENTSECRET")
app.config["DISCORD_REDIRECT_URI"] = f"{cfg['Hosting']['host-url']}/callback"
app.config["DISCORD_BOT_TOKEN"] = os.environ.get("TOKEN")
app.config["SECRET_KEY"] = secrets.token_hex(20)
discordflask = DiscordOAuth2Session(app)
def divide_chunks(l, n):
# looping till length l
for i in range(0, len(l), n):
yield l[i:i + n]
@app.route('/')
def main():
with open("comrade_primary.log", "r", encoding="utf-8") as f:
content = f.read()
uptime = datetime.timedelta(seconds=round(get_uptime()))
