medods_vk/app.py

from flask import Flask, request, jsonify
from config import Config
from db import VkAPI, db, MedodsAPI, ApiEndpoint
from scheduler import start_scheduler
from http_client import send_request
import logging
import os

app = Flask(__name__)
app.config.from_object(Config)

db.init_app(app)

os.makedirs("logs", exist_ok=True)

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
    handlers=[
        logging.FileHandler(Config.LOG_FILE, encoding="utf-8"),
        logging.StreamHandler(),
    ],
)

logger = logging.getLogger(__name__)

from flask import render_template


@app.route("/")
def index():
    return render_template("index.html")


@app.route("/medods", methods=["GET"])
def medods():
    medods_api = MedodsAPI.query.first()
    data = {}
    if medods_api:
        apiKey = False
        if medods_api.identity and medods_api.secretKey:
            apiKey = True
        data = {
            "url": medods_api.url,
            "apiKey": apiKey,
        }
    return render_template("medods.html", data=data)


@app.route("/vk")
def vk():
    vkDB = VkAPI.query.first()
    data = {}
    if vkDB:
        data = {"vk_settings": vkDB.toDict()}
    return render_template("vk.html", data=data)


@app.route("/posts")
def posts():
    return render_template("posts.html")


@app.before_request
def init():
    db.create_all()
    start_scheduler()
    logger.info("Приложение запущено")


@app.route("/settings/medods", methods=["POST"])
def medods_url():
    data = request.json
    logger.info(data)
    apiKey = data.get("apiKey", None)
    url = data.get("url", None)
    if url is not None:
        logger.info("Получен url")
        try:
            medodsRecord = MedodsAPI.query.first()
            medodsRecord.url = url
            db.session.commit()
            logger.info("Обновлен url")
        except Exception:
            db.session.merge(MedodsAPI(url=url))
            db.session.commit()
            logger.info("Добавлен url")

    if apiKey:
        logger.info("Получены ключи")
        try:
            medodsRecord = MedodsAPI.query.first()
            medodsRecord.identity = apiKey["identity"]
            medodsRecord.secretKey = apiKey["secretKey"]
            db.session.commit()
            logger.info("Обновлены ключи")
        except Exception:
            db.session.merge(
                MedodsAPI(identity=apiKey["identity"], secretKey=apiKey["secretKey"])
            )
            db.session.commit()
            logger.info("Добавлены ключи")
    return jsonify({"ok": True})
    # return jsonify({"ok": False}), 400


@app.route("/settings/requests", methods=["GET", "POST", "PATCH", "DELETE"])
def get_requests():
    requestData = (
        request.json if request.method in ["POST", "PATCH", "DELETE"] else None
    )
    match request.method:
        case "DELETE":
            logger.info("Удален запрос")
            logger.info(requestData)
            return jsonify({"status": "ok"})
        case "POST":
            logger.info("Добавлен/обновлен запрос")
            if "id" in requestData:
                logger.info("Обновлен запрос")
                try:
                    db.session.execute(
                        db.update(ApiEndpoint)
                        .where(ApiEndpoint.id == requestData["id"])
                        .values(
                            method=requestData.get("method"),
                            title=requestData.get("title"),
                            url_path=requestData.get("url_path"),
                            payload=requestData.get("payload", {}),
                            query_params=requestData.get("query_params", {}),
                        )
                    )
                    db.session.commit()
                except Exception as e:
                    logger.error(f"Ошибка при обновлении запроса: {e}")
                return jsonify({"status": "ok"})
            else:
                logger.info("Добавлен запрос")
                try:
                    db.session.merge(ApiEndpoint(**requestData))
                    db.session.commit()
                except Exception as e:
                    logger.error(f"Ошибка при добавлении запроса: {e}")
            return jsonify({"status": "ok"})

        case "PATCH":
            logger.info("Выполнен запрос")
            requestParams = ApiEndpoint.query.filter_by(id=requestData["id"]).first()
            medodsDB = MedodsAPI.query.first()
            baseUrl = medodsDB.url
            response = send_request(
                requestParams.method,
                f"{baseUrl}{requestParams.url_path}",
                requestParams.payload,
                requestParams.query_params,
            )
            exitData = {}
            try:
                exitData = response.json()
            except:
                exitData = response.text
            return jsonify(exitData)

        case "GET":
            logger.info("Получен список запросов")

            requestsDB = ApiEndpoint.query.all()
            requestsList = [r.toDict() for r in requestsDB]
            logger.info(requestsList)
            return jsonify(
                {
                    "status": "ok",
                    "requests": requestsList,
                }
            )

        case _:
            logger.error("Неверный метод запроса")
            return jsonify({"status": "error"}), 405


@app.route("/settings/vk", methods=["POST"])
def settings_vk():
    requestData = request.json
    logger.info(requestData)
    if "id" in requestData:
        logger.info("Обновлен запрос")
        try:
            db.session.execute(
                db.update(VkAPI)
                .where(VkAPI.id == requestData["id"])
                .values(
                    group_id=(
                        int(requestData.get("group_id", 0))
                        if requestData.get("group_id")
                        else 0
                    ),
                    access_token=requestData.get("access_token"),
                    base_photo_url=(
                        int(requestData.get("base_photo_url", 0))
                        if requestData.get("base_photo_url")
                        else 0
                    ),
                )
            )
            db.session.commit()
        except Exception as e:
            logger.error(f"Ошибка при обновлении запроса: {e}")
        return jsonify({"status": "ok"})
    else:
        logger.info("Добавлен запрос")
        try:
            db.session.merge(VkAPI(**requestData))
            db.session.commit()
        except Exception as e:
            logger.error(f"Ошибка при добавлении запроса: {e}")
    return jsonify({"status": "ok"})


@app.route("/request", methods=["POST"])
def make_request():
    data = request.json
    response = send_request(
        data["method"], data["url"], data.get("payload"), data.get("headers")
    )
    return jsonify({"status": response.status_code})


if __name__ == "__main__":
    app.run(debug=True)