620 lines
22 KiB
Python
620 lines
22 KiB
Python
import json
|
|
from flask import Flask, redirect, request, jsonify, render_template, url_for
|
|
from config import Config
|
|
from db import (
|
|
BirthdateScheduler,
|
|
PostScheduler,
|
|
Protection,
|
|
UsersBirthdate,
|
|
UsersMedods,
|
|
VkAPI,
|
|
VkPost,
|
|
db,
|
|
MedodsAPI,
|
|
ApiEndpoint,
|
|
)
|
|
from medods_handler import updateMedodsUsers, updateUsersBirthdate
|
|
from scheduler import (
|
|
enable_birthdate_job,
|
|
get_birthdate_scheduler_status,
|
|
get_scheduler_status,
|
|
init_scheduler,
|
|
enable_publish_job,
|
|
)
|
|
from http_client import send_request
|
|
import logging
|
|
import os
|
|
|
|
|
|
app = Flask(__name__)
|
|
app.config.from_object(Config)
|
|
|
|
db.init_app(app)
|
|
init_scheduler(app)
|
|
|
|
os.makedirs("logs", exist_ok=True)
|
|
|
|
|
|
class SmartLogger(logging.Logger):
|
|
def _log(
|
|
self,
|
|
level,
|
|
msg,
|
|
args,
|
|
exc_info=None,
|
|
extra=None,
|
|
stack_info=False,
|
|
stacklevel=2,
|
|
):
|
|
if isinstance(msg, (dict, list)):
|
|
msg = json.dumps(msg, indent=4, ensure_ascii=False)
|
|
super()._log(level, msg, args, exc_info, extra, stack_info, stacklevel)
|
|
|
|
|
|
logging.setLoggerClass(SmartLogger)
|
|
|
|
logging.basicConfig(
|
|
level=logging.INFO,
|
|
format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
|
|
datefmt="%Y-%m-%d %H:%M:%S",
|
|
handlers=[
|
|
logging.FileHandler(Config.LOG_FILE, encoding="utf-8"),
|
|
logging.StreamHandler(),
|
|
],
|
|
)
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def getLogs():
|
|
from collections import deque
|
|
|
|
with open(Config.LOG_FILE, "r", encoding="utf-8") as f:
|
|
last_lines = deque(f, maxlen=500)
|
|
return "".join(reversed(last_lines))
|
|
|
|
|
|
@app.route("/", methods=["GET", "POST"])
|
|
def index():
|
|
match request.method:
|
|
case "GET":
|
|
exitData = {}
|
|
medodsApi = MedodsAPI.query.first()
|
|
if medodsApi:
|
|
exitData["medodsApi"] = {
|
|
"updated_at": medodsApi.updated_at.strftime("%Y-%m-%d %H:%M:%S")
|
|
}
|
|
if medodsApi.url:
|
|
exitData["medodsApi"]["url"] = True
|
|
else:
|
|
exitData["medodsApi"]["url"] = False
|
|
if medodsApi.identity and medodsApi.secretKey:
|
|
exitData["medodsApi"]["apiKey"] = True
|
|
else:
|
|
exitData["medodsApi"]["apiKey"] = False
|
|
apiEndpointsCount = ApiEndpoint.query.count()
|
|
exitData["medodsApi"]["apiEndpointsCount"] = apiEndpointsCount
|
|
vkApi = VkAPI.query.first()
|
|
if vkApi:
|
|
exitData["vkApi"] = {
|
|
"updated_at": vkApi.updated_at.strftime("%Y-%m-%d %H:%M:%S")
|
|
}
|
|
if vkApi.group_id:
|
|
exitData["vkApi"]["group_id"] = True
|
|
else:
|
|
exitData["vkApi"]["group_id"] = False
|
|
if vkApi.access_token:
|
|
exitData["vkApi"]["access_token"] = True
|
|
else:
|
|
exitData["vkApi"]["access_token"] = False
|
|
if vkApi.base_photo_url:
|
|
exitData["vkApi"]["base_photo_url"] = True
|
|
else:
|
|
exitData["vkApi"]["base_photo_url"] = False
|
|
vkPost = VkPost.query.first()
|
|
if vkPost:
|
|
exitData["vkPost"] = {
|
|
"updated_at": vkPost.updated_at.strftime("%Y-%m-%d %H:%M:%S")
|
|
}
|
|
if vkPost.static_text:
|
|
exitData["vkPost"]["static_text"] = True
|
|
else:
|
|
exitData["vkPost"]["static_text"] = False
|
|
if vkPost.selected_users:
|
|
exitData["vkPost"]["selected_users"] = len(vkPost.selected_users)
|
|
else:
|
|
exitData["vkPost"]["selected_users"] = False
|
|
if vkPost.full_name is not None:
|
|
exitData["vkPost"]["full_name"] = vkPost.full_name
|
|
if vkPost.post_id and vkApi and vkApi.group_id:
|
|
exitData["vkPost"][
|
|
"post_link"
|
|
] = f"https://vk.com/wall-{vkApi.group_id}_{vkPost.post_id}"
|
|
else:
|
|
exitData["vkPost"]["post_link"] = False
|
|
if vkPost.publish_at:
|
|
exitData["vkPost"]["publish_at"] = vkPost.publish_at.strftime(
|
|
"%Y-%m-%d %H:%M:%S"
|
|
)
|
|
else:
|
|
exitData["vkPost"]["publish_at"] = False
|
|
usersMedods = UsersMedods.query.count()
|
|
exitData["vkPost"]["usersMedods"] = usersMedods
|
|
exitData["vkPost"]["scheduler"] = get_scheduler_status()
|
|
|
|
return render_template("index.html", exitData=exitData)
|
|
case "POST":
|
|
return jsonify(logs=getLogs())
|
|
case _:
|
|
return "Method not allowed", 405
|
|
|
|
|
|
@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", methods=["GET"])
|
|
def vk():
|
|
vkDB = VkAPI.query.first()
|
|
data = {}
|
|
if vkDB:
|
|
data = {"vk_settings": vkDB.toDict()}
|
|
return render_template("vk.html", data=data)
|
|
|
|
|
|
@app.route("/posts", methods=["GET"])
|
|
def posts():
|
|
medodsUsers = UsersMedods.query.all()
|
|
if medodsUsers:
|
|
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.route("/birthdate", methods=["GET"])
|
|
def birthdate():
|
|
schedulerStatus = get_birthdate_scheduler_status()
|
|
schedulerSettings = BirthdateScheduler.query.first()
|
|
if schedulerSettings:
|
|
schedulerSettings = schedulerSettings.toDict()
|
|
return render_template(
|
|
"birthdate.html",
|
|
data={
|
|
"schedulerStatus": schedulerStatus,
|
|
"schedulerSettings": schedulerSettings,
|
|
},
|
|
)
|
|
|
|
|
|
@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("/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("Удален запрос")
|
|
|
|
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("Выполнен запрос")
|
|
try:
|
|
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()
|
|
if requestsDB:
|
|
requestsList = [r.toDict() for r in requestsDB]
|
|
return jsonify(
|
|
{
|
|
"status": "ok",
|
|
"requests": requestsList,
|
|
}
|
|
)
|
|
|
|
case _:
|
|
logger.error("Неверный метод запроса")
|
|
return jsonify({"status": "error"}), 405
|
|
|
|
|
|
@app.route("/api/birthdate", methods=["GET", "POST", "PATCH"])
|
|
def api_birthdate():
|
|
match request.method:
|
|
case "POST":
|
|
reqData = request.json
|
|
userUpdate = reqData.get("userUpdate", None)
|
|
if userUpdate:
|
|
logger.info("Обновлен пользователь")
|
|
userId = userUpdate["userId"]
|
|
userData = userUpdate["userData"]
|
|
try:
|
|
userDB = UsersBirthdate.query.filter_by(id=userId).first()
|
|
userDB.enabled = userData["enabled"]
|
|
userDB.photo_link = userData["photoLink"]
|
|
userDB.congratulations = userData["congratulations"]
|
|
db.session.commit()
|
|
return jsonify({"status": "ok"})
|
|
except Exception as e:
|
|
logger.error(f"Ошибка при обновлении пользователя: {e}")
|
|
return jsonify({"status": "error"}), 500
|
|
scheduleSettings = reqData.get("scheduleSettings")
|
|
if scheduleSettings:
|
|
logger.info("Обновлены настройки расписания")
|
|
try:
|
|
scheduleDB = BirthdateScheduler.query.first()
|
|
if scheduleDB:
|
|
scheduleDB.hour = scheduleSettings["hour"]
|
|
scheduleDB.minute = scheduleSettings["minute"]
|
|
scheduleDB.enabled = scheduleSettings["enabled"]
|
|
else:
|
|
scheduleDB = BirthdateScheduler(
|
|
hour=scheduleSettings["hour"],
|
|
minute=scheduleSettings["minute"],
|
|
enabled=scheduleSettings["enabled"],
|
|
)
|
|
db.session.add(scheduleDB)
|
|
db.session.commit()
|
|
enable_birthdate_job()
|
|
scheduleInfo = get_birthdate_scheduler_status()
|
|
return jsonify(
|
|
{
|
|
"status": "ok",
|
|
"next_run_time": scheduleInfo.get("next_run_time"),
|
|
}
|
|
)
|
|
except Exception as e:
|
|
logger.error(f"Ошибка при обновлении настройки расписания: {e}")
|
|
return jsonify({"status": "error"}), 500
|
|
|
|
case "GET":
|
|
logger.info("Получен список пользователей")
|
|
|
|
users = UsersBirthdate.query.all()
|
|
if users:
|
|
users = [u.toDict() for u in users]
|
|
return jsonify(
|
|
{
|
|
"status": "ok",
|
|
"users": users,
|
|
}
|
|
)
|
|
|
|
case "PATCH":
|
|
success = updateUsersBirthdate()
|
|
if success:
|
|
return jsonify({"status": "ok"})
|
|
else:
|
|
return jsonify({"status": "error"}), 500
|
|
|
|
case _:
|
|
logger.error("Неверный метод запроса")
|
|
return jsonify({"status": "error"}), 405
|
|
|
|
|
|
@app.route("/api/vk", methods=["POST"])
|
|
def api_vk():
|
|
requestData = request.json
|
|
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("/api/posts", methods=["POST", "GET"])
|
|
def api_posts():
|
|
response = {"status": "ok"}
|
|
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:
|
|
vkPostData["selected_users"] = vkPostData.pop("selectedUsers")
|
|
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()
|
|
hour = schedulerData.get("hour", None)
|
|
minute = schedulerData.get("minute", None)
|
|
enabled = schedulerData.get("enabled", None)
|
|
if scheduler:
|
|
if hour is not None:
|
|
if scheduler.hour != hour:
|
|
scheduler.hour = hour
|
|
if minute is not None:
|
|
if scheduler.minute != minute:
|
|
scheduler.minute = minute
|
|
if enabled is not None:
|
|
if scheduler.enabled != enabled:
|
|
scheduler.enabled = enabled
|
|
else:
|
|
db.session.merge(
|
|
PostScheduler(
|
|
hour=int(hour),
|
|
minute=int(minute),
|
|
enabled=enabled,
|
|
)
|
|
)
|
|
db.session.commit()
|
|
enable_publish_job()
|
|
scheduleInfo = get_scheduler_status()
|
|
response["next_run_time"] = scheduleInfo.get("next_run_time")
|
|
except Exception as e:
|
|
logger.error(f"Ошибка при обновлении расписания публикации: {e}")
|
|
return jsonify(response)
|
|
|
|
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":
|
|
from vk_handler import handle_vk_post
|
|
|
|
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
|
|
|
|
|
|
@app.route("/login", methods=["GET", "POST", "PATCH"])
|
|
def login():
|
|
match request.method:
|
|
case "GET":
|
|
return render_template("login.html")
|
|
case "POST":
|
|
data = request.get_json()
|
|
password = data.get("password")
|
|
|
|
protection = Protection.query.first()
|
|
if protection:
|
|
if not protection.verify_password(password):
|
|
return (
|
|
jsonify({"status": "error", "errorMessage": "Неверный пароль"}),
|
|
401,
|
|
)
|
|
else:
|
|
protection.generate_token()
|
|
db.session.commit()
|
|
else:
|
|
protection = Protection()
|
|
protection.set_password(password)
|
|
protection.generate_token()
|
|
|
|
db.session.add(protection)
|
|
db.session.commit()
|
|
|
|
return jsonify({"status": "ok", "token": protection.token}), 200
|
|
case "PATCH":
|
|
data = request.get_json()
|
|
new_password = data.get("password")
|
|
|
|
if not new_password:
|
|
return {"status": "error", "errorMessage": "Пароль не задан"}, 400
|
|
|
|
protection = Protection.query.first()
|
|
if not protection:
|
|
protection = Protection()
|
|
protection.set_password(new_password)
|
|
protection.generate_token()
|
|
|
|
db.session.add(protection)
|
|
db.session.commit()
|
|
else:
|
|
protection.set_password(new_password)
|
|
db.session.commit()
|
|
|
|
return {"status": "ok"}
|
|
case _:
|
|
logger.error("Неверный метод запроса")
|
|
return jsonify({"status": "error"}), 405
|
|
|
|
|
|
def init_app():
|
|
with app.app_context():
|
|
db.create_all()
|
|
enable_publish_job()
|
|
enable_birthdate_job()
|
|
logger.info("Приложение запущено")
|
|
|
|
|
|
@app.before_request
|
|
def check_auth_cookie():
|
|
endpoint = request.endpoint
|
|
|
|
if endpoint is None:
|
|
return
|
|
|
|
if endpoint == "login" or endpoint.startswith("static"):
|
|
return
|
|
|
|
p = Protection.query.first()
|
|
|
|
if not p or not p.verify_token(request.cookies.get("auth_token")):
|
|
return redirect(url_for("login"))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
init_app()
|
|
app.run(host="0.0.0.0", port=80)
|