예제 #1
0
"""Authentication module.
"""

import os

import quart
import quart_cors
import quart_jwt_extended as jwt

api_password = os.getenv("API_PASSWORD")
if not api_password:
    raise RuntimeError("API_PASSWORD env not set")

app = quart.Blueprint("auth", __name__)
app = quart_cors.cors(app)


@app.route("/login", methods=["POST"])
async def login():
    """Gets a JWT token."""
    if not quart.request.is_json:
        return {"error": "missing JSON in request"}, 400

    request = await quart.request.json

    password = request.get("password", None)
    if not password:
        return {"error": "missing password parameter"}, 400

    if password != api_password:
        return {"error": "bad password"}, 401
예제 #2
0
import quart
import datetime
import os
try:
    from app import config
except ImportError:
    pass

blueprint = quart.Blueprint("api", __name__)


async def calc_exam_timestamp() -> float:
    try:
        exam_month = config.EXAM_MONTH
        exam_day = config.EXAM_DAY
        exam_hour = config.EXAM_HOUR
        exam_min = config.EXAM_MIN
        timedelta = config.TIMEDELTA
    except NameError:
        exam_month = int(os.environ["EXAM_MONTH"])
        exam_day = int(os.environ["EXAM_DAY"])
        exam_hour = int(os.environ["EXAM_HOUR"])
        exam_min = int(os.environ["EXAM_MIN"])
        timedelta = int(os.environ["TIMEDELTA"])
    tzinfo = datetime.timezone(datetime.timedelta(hours=timedelta))
    curr_datetime = datetime.datetime.now(tz=tzinfo)
    curr_year = curr_datetime.year
    if curr_datetime > datetime.datetime(
            curr_year, exam_month, exam_day, exam_hour, exam_min,
            tzinfo=tzinfo):
        exam_datetime = datetime.datetime(curr_year + 1,
예제 #3
0
import quart
from app.utils import decorators
from bot.api import tokens as bot_tokens
from bot.api import kicks as bot_kicks

blueprint = quart.Blueprint("kicks", __name__)


@blueprint.route("/api/kicks/kick", methods=["POST"])
@decorators.req_fields({"token": str, "user_id": int})
@decorators.token_verify
async def ban_user():
    req_json = await quart.request.json
    token = req_json["token"]
    chat_id = await bot_tokens.get_chat_id_by_token(token)
    result = await bot_kicks.kick_user(chat_id, req_json["user_id"])
    return quart.jsonify({"result": result})
예제 #4
0
"""Bot module.
"""

import ipc
import quart
import quart_cors
import quart_jwt_extended as jwt

app = quart.Blueprint("bot", __name__)
app = quart_cors.cors(app)


@app.route("/health")
async def health():
    """Runs a health check request on the bot."""
    response = await ipc.ipc_client.request("health")
    return response


@app.route("/describe")
@jwt.jwt_required
async def describe():
    """Runs a describe request on the bot."""
    response = await ipc.ipc_client.request("describe")
    return response


@app.route("/config/main")
@jwt.jwt_required
async def main_config():
    """Runs a main config request on the bot."""
예제 #5
0
"""Blueprint for total endpoint

Contains the endpoint that calculates the total sum
"""
import quart

from app.numbers_api import NumbersAPI

total = quart.Blueprint('total', __name__)


def get_api() -> NumbersAPI:
    """Gets and creates the NumbersAPI client"""
    if 'numbers_api' not in quart.g:
        quart.g.numbers_api = NumbersAPI()
    return quart.g.numbers_api


@total.route('')
async def total_endpoint() -> quart.Response:
    """Endpoint, calculates total sum from the numbers api"""
    numbers = await get_api().get()
    return quart.jsonify({"total": sum(numbers)})
예제 #6
0
import quart

blueprint = quart.Blueprint("root", __name__)


@blueprint.route("/")
async def root():
    return quart.redirect("/index")
예제 #7
0
import quart

blueprint = quart.Blueprint("index", __name__)


@blueprint.route("/index")
async def index():
    if "token" in quart.session:
        return quart.redirect("/chat/dashboard")
    else:
        return quart.redirect("/login")
예제 #8
0
import quart
import quart.flask_patch
import aiohttp
from app import session, config, logger
from app.utils import utils
from app.data import login_form


blueprint = quart.Blueprint("login", __name__)


async def verify_token(token: str):
    url = await utils.join_uri((config.BOT_URI, "api", "tokens", "verify"))
    json = {"token": token}
    async with session.post(url, json=json) as resp:
        json_resp = await resp.json()
        return json_resp["result"]


@blueprint.route("/login", methods=("GET", "POST"))
async def login():
    form = login_form.LoginForm()
    if form.validate_on_submit():
        token = form.token.data
        url = await utils.join_uri((config.BOT_URI, "api", "tokens", "verify"))
        json = {"token": token}
        logger.debug("%s", token)
        logger.debug("%s", url)
        try:
            if await verify_token(token):
                quart.session["token"] = token
예제 #9
0
    request,
    Response,
    flash,
)

import babel
import wtforms

import flask_wtf

from flask_babel import lazy_gettext as _l, _

from . import xmpputil, _version
from .infra import client

bp = quart.Blueprint("main", __name__)


class LoginForm(flask_wtf.FlaskForm):  # type:ignore
    address = wtforms.TextField(
        _l("Address"),
        validators=[wtforms.validators.InputRequired()],
    )

    password = wtforms.PasswordField(
        _l("Password"),
        validators=[wtforms.validators.InputRequired()],
    )

    action_signin = wtforms.SubmitField(_l("Sign in"), )
예제 #10
0
import quart
from app.utils import decorators
from bot.api import tokens as bot_tokens
from bot.api import bans as bot_bans

blueprint = quart.Blueprint("bans", __name__)


@blueprint.route("/api/bans/ban", methods=["POST"])
@decorators.req_fields({"token": str, "user_id": int})
@decorators.token_verify
async def ban_user():
    req_json = await quart.request.json
    token = req_json["token"]
    chat_id = await bot_tokens.get_chat_id_by_token(token)
    result = await bot_bans.ban_user(chat_id, req_json["user_id"])
    return quart.jsonify({"result": result})


@blueprint.route("/api/bans/unban", methods=["POST"])
@decorators.req_fields({"token": str, "user_id": int})
@decorators.token_verify
async def unban_user():
    req_json = await quart.request.json
    token = req_json["token"]
    chat_id = await bot_tokens.get_chat_id_by_token(token)
    result = await bot_bans.unban_user(chat_id, req_json["user_id"])
    return quart.jsonify({"result": result})
예제 #11
0
import quart
import typing
from app import logger
from bot.api import users as bot_users
from app.utils import decorators, utils

blueprint = quart.Blueprint("users", __name__)


@blueprint.route("/api/users/info", methods=["POST"])
@decorators.req_fields({"token": str, "ids": typing.Iterable})
@decorators.token_verify
async def get_user():
    req_json = await quart.request.json
    try:
        users = await bot_users.get_users_info(req_json["ids"])
    except ValueError as exc:
        await quart.abort(400, exc)
    user_dict = {
        user.id: {
            item[0]: item[1]
            for item in vars(user).items() if utils.is_jsonable(item[1])
        }
        for user in users
    }
    return quart.jsonify(user_dict)


@blueprint.route("/api/users/<int:user_id>/photo", methods=["GET"])
async def photo(user_id):
    photo = await bot_users.get_last_photo(user_id)
예제 #12
0
import dataclasses
import logging

import quart
from quart import current_app as app
from quart import render_template

from .indicator import Indicator

log = logging.getLogger(__name__)

bp = quart.Blueprint('view', __name__)


@bp.route('/')
async def index():
    lat = quart.request.args.get('lat')
    lng = quart.request.args.get('lng')

    return await render_template('view/index.html', lat=lat, lng=lng)


@bp.route('/location')
async def location():
    try:
        latitude = str(quart.request.args['lat'])
        longitude = str(quart.request.args['lng'])
    except KeyError:
        log.info('Failed to get coordinates from parameters.')
        return quart.abort(400)
예제 #13
0
#!/usr/bin/python
import quart
from quart import render_template

from . import getTemplateDictBase

err_page = quart.Blueprint("err_page", __name__)


@err_page.route('/500.html')
async def err_page():
    """ Err page. """
    return await render_template("500.html", **getTemplateDictBase())
예제 #14
0
import quart
from bot.api import tokens as bot_tokens
from app.utils import decorators

blueprint = quart.Blueprint("tokens", __name__)


@blueprint.route("/api/tokens/verify", methods=["POST"])
@decorators.req_fields({"token": str})
async def token_verify():
    json_resp = await quart.request.json
    token = json_resp["token"]
    result = await bot_tokens.verify_token(token)
    return quart.jsonify({"result": result})
예제 #15
0
import quart
from app.utils import decorators, utils
from bot.api import tokens as bot_tokens
from bot.api import users as bot_users
from bot.api import chats as bot_chats

blueprint = quart.Blueprint("chats", __name__)


@blueprint.route("/api/chats/users", methods=["POST"])
@decorators.req_fields({"token": str})
@decorators.token_verify
async def users():
    req_json = await quart.request.json
    token = req_json["token"]
    chat_id = await bot_tokens.get_chat_id_by_token(token)
    users = await bot_chats.get_chat_members(chat_id)
    user_dict = {user.id: {item[0]: item[1] for item in vars(user).items() if utils.is_jsonable(item[1])}
                 for user in users}
    return quart.jsonify(user_dict)


@blueprint.route("/api/chats/info", methods=["POST"])
@decorators.req_fields({"token": str})
@decorators.token_verify
async def title():
    req_json = await quart.request.json
    token = req_json["token"]
    chat_id = await bot_tokens.get_chat_id_by_token(token)
    chat = await bot_chats.get_chat_info(chat_id)
    return quart.jsonify(chat)
예제 #16
0
import quart
from app.utils import decorators

blueprint = quart.Blueprint("logout", __name__)


@blueprint.route("/logout")
@decorators.need_token
async def logout():
    del quart.session["token"]
    return quart.redirect("/login")
예제 #17
0
import quart
from app.utils import decorators
from bot.api import promotions as bot_promotions
from bot.api import tokens as bot_tokens

blueprint = quart.Blueprint("promotions", __name__)


@blueprint.route("/api/promotions/promote", methods=["POST"])
@decorators.req_fields({"token": str, "user_id": int})
@decorators.token_verify
async def ban_user():
    req_json = await quart.request.json
    token = req_json["token"]
    chat_id = await bot_tokens.get_chat_id_by_token(token)
    result = await bot_promotions.promote_user(chat_id, req_json["user_id"])
    return quart.jsonify({"result": result})


@blueprint.route("/api/promotions/demote", methods=["POST"])
@decorators.req_fields({"token": str, "user_id": int})
@decorators.token_verify
async def unban_user():
    req_json = await quart.request.json
    token = req_json["token"]
    chat_id = await bot_tokens.get_chat_id_by_token(token)
    result = await bot_promotions.demote_user(chat_id, req_json["user_id"])
    return quart.jsonify({"result": result})