работа с публикацией

app.py

@@ -1,11 +1,14 @@
-from flask import Flask, request, jsonify
+from flask import Flask, request, jsonify, render_template
 from config import Config
-from db import VkAPI, db, MedodsAPI, ApiEndpoint
-from scheduler import start_scheduler
+from db import PostScheduler, UsersMedods, VkAPI, VkPost, db, MedodsAPI, ApiEndpoint
+from medods_handler import updateMedodsUsers
+from scheduler import enable_publish_job, get_scheduler_status, start_scheduler
 from http_client import send_request
 import logging
 import os
 
+from vk_handler import handle_vk_post
+
 app = Flask(__name__)
 app.config.from_object(Config)
 
@@ -24,7 +27,13 @@ logging.basicConfig(
 
 logger = logging.getLogger(__name__)
 
-from flask import render_template
+
+@app.before_request
+def init():
+    db.create_all()
+    start_scheduler()
+    enable_publish_job()
+    logger.info("Приложение запущено")
 
 
 @app.route("/")
@@ -47,7 +56,7 @@ def medods():
     return render_template("medods.html", data=data)
 
 
-@app.route("/vk")
+@app.route("/vk", methods=["GET"])
 def vk():
     vkDB = VkAPI.query.first()
     data = {}
@@ -56,63 +65,85 @@ def vk():
     return render_template("vk.html", data=data)
 
 
-@app.route("/posts")
+@app.route("/posts", methods=["GET"])
 def posts():
-    return render_template("posts.html")
+    medodsUsers = UsersMedods.query.all()
+    if len(medodsUsers) > 0:
+        medodsUsers = [user.toDict() for user in medodsUsers]
+    vkPost = VkPost.query.first()
+    if vkPost:
+        vkPost = vkPost.toDict()
+    schedulerStatus = get_scheduler_status()
+    schedulerSettings = PostScheduler.query.first()
+    if schedulerSettings:
+        schedulerSettings = schedulerSettings.toDict()
+    return render_template(
+        "posts.html",
+        data={
+            "medodsUsers": medodsUsers,
+            "vkPost": vkPost,
+            "schedulerStatus": schedulerStatus,
+            "schedulerSettings": schedulerSettings,
+        },
+    )
 
 
-@app.before_request
-def init():
-    db.create_all()
-    start_scheduler()
-    logger.info("Приложение запущено")
+@app.route("/api/medods", methods=["POST"])
+def api_medods():
+    try:
+        data = request.json
+        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})
+    except Exception as e:
+        logger.error(f"Ошибка при обновлении ключей: {e}")
+        return jsonify({"ok": False}), 500
 
 
-@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():
+@app.route("/api/requests", methods=["GET", "POST", "PATCH", "DELETE"])
+def api_requests():
     requestData = (
         request.json if request.method in ["POST", "PATCH", "DELETE"] else None
     )
     match request.method:
         case "DELETE":
+            try:
+                db.session.execute(
+                    db.delete(ApiEndpoint).where(ApiEndpoint.id == requestData["id"])
+                )
+                db.session.commit()
+            except Exception as e:
+                logger.error(f"Ошибка при удалении запроса {requestData['id']}: {e}")
             logger.info("Удален запрос")
-            logger.info(requestData)
+
             return jsonify({"status": "ok"})
         case "POST":
             logger.info("Добавлен/обновлен запрос")
@@ -145,28 +176,33 @@ def get_requests():
 
         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)
+                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)
+            except Exception as e:
+                logger.error(f"Ошибка при выполнении запроса: {e}")
+            return jsonify({"status": "error"}), 500
 
         case "GET":
             logger.info("Получен список запросов")
 
             requestsDB = ApiEndpoint.query.all()
             requestsList = [r.toDict() for r in requestsDB]
-            logger.info(requestsList)
             return jsonify(
                 {
                     "status": "ok",
@@ -179,10 +215,9 @@ def get_requests():
             return jsonify({"status": "error"}), 405
 
 
-@app.route("/settings/vk", methods=["POST"])
-def settings_vk():
+@app.route("/api/vk", methods=["POST"])
+def api_vk():
     requestData = request.json
-    logger.info(requestData)
     if "id" in requestData:
         logger.info("Обновлен запрос")
         try:
@@ -217,14 +252,77 @@ def settings_vk():
     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})
+@app.route("/api/posts", methods=["POST", "GET"])
+def api_posts():
+    match request.method:
+        case "POST":
+            requestData = request.json
+            logger.info("Настройки публикации и расписания")
+            vkPostData = requestData.get("vkPostData", None)
+            if vkPostData:
+                selectedUsers = vkPostData.get("selectedUsers", None)
+                static_text = vkPostData.get("static_text", None)
+                full_name = vkPostData.get("full_name", None)
+                logger.info("Обновление настроек публикации")
+                try:
+                    vkPost = VkPost.query.first()
+                    if vkPost:
+                        if selectedUsers:
+                            vkPost.selected_users = selectedUsers
+                        if static_text:
+                            vkPost.static_text = static_text
+                        if full_name is not None:
+                            vkPost.full_name = full_name
+                    else:
+                        db.session.merge(VkPost(**vkPostData))
+                    db.session.commit()
+                except Exception as e:
+                    logger.error(f"Ошибка при обновлении настроек публикации: {e}")
+            schedulerData = requestData.get("schedulerData", None)
+            if schedulerData:
+                logger.info("Обновление расписания публикации")
+                try:
+                    scheduler = PostScheduler.query.first()
+                    startTime = schedulerData.get("startTime", None)
+                    endTime = schedulerData.get("endTime", None)
+                    interval_minutes = schedulerData.get("interval_minutes", None)
+                    enabled = schedulerData.get("enabled", None)
+                    if startTime:
+                        scheduler.start_hour = int(startTime)
+                    if endTime:
+                        scheduler.end_hour = int(endTime)
+                    if interval_minutes:
+                        scheduler.interval_minutes = int(interval_minutes)
+                    if enabled is not None:
+                        scheduler.enabled = enabled
+                    db.session.commit()
+                except Exception as e:
+                    logger.error(f"Ошибка при обновлении расписания публикации: {e}")
+            return jsonify({"status": "ok"})
+
+        case "GET":
+            queryParams = request.args.to_dict()
+            action = queryParams.get("action", None)
+            if action:
+                match action:
+                    case "update_users":
+                        logger.info("Обновить список пользователей")
+                        result = updateMedodsUsers()
+                        return jsonify({"ok": result})
+                    case "handle_posts":
+                        logger.info("Выполнить публикацию")
+                        handle_vk_post()
+                        return jsonify({"ok": True})
+                    case _:
+                        logger.error("Неверный метод запроса")
+                        return jsonify({"status": "error"}), 405
+            return jsonify({"ok": False, "status": "error", "message": "no action"})
+
+        case _:
+            logger.error("Неверный метод запроса")
+            return jsonify({"status": "error"}), 405
 
 
 if __name__ == "__main__":
-    app.run(debug=True, host="0.0.0.0", port=5000)
+    app.run(debug=True)
+    # app.run(debug=True, host="0.0.0.0", port=80)