220 lines
8.1 KiB
Python
220 lines
8.1 KiB
Python
"""Flask app and routes."""
|
|
import os
|
|
from datetime import datetime, timedelta, timezone
|
|
|
|
from flask import Flask, redirect, render_template, request, url_for
|
|
|
|
from app import models
|
|
|
|
|
|
def _parse_report_dates(from_ts, to_ts, preset):
|
|
"""Parse from/to dates, applying preset if given. Returns (from_ts, to_ts, from_display, to_display)."""
|
|
now = datetime.now(timezone.utc)
|
|
if preset == "24h":
|
|
to_ts = now.isoformat()
|
|
from_ts = (now - timedelta(hours=24)).isoformat()
|
|
elif preset == "7d":
|
|
to_ts = now.isoformat()
|
|
from_ts = (now - timedelta(days=7)).isoformat()
|
|
elif preset == "30d":
|
|
to_ts = now.isoformat()
|
|
from_ts = (now - timedelta(days=30)).isoformat()
|
|
if from_ts and len(from_ts) == 10:
|
|
from_ts = from_ts + "T00:00:00"
|
|
if to_ts and len(to_ts) == 10:
|
|
to_ts = to_ts + "T23:59:59.999999"
|
|
from_display = from_ts[:16] if from_ts else ""
|
|
to_display = to_ts[:16] if to_ts else ""
|
|
return from_ts, to_ts, from_display, to_display
|
|
|
|
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
|
app = Flask(
|
|
__name__,
|
|
template_folder=os.path.join(ROOT, "templates"),
|
|
static_folder=os.path.join(ROOT, "static"),
|
|
)
|
|
VERSION = os.environ.get("VERSION", "dev")
|
|
|
|
|
|
@app.route("/")
|
|
def dashboard():
|
|
services = models.list_services()
|
|
return render_template("dashboard.html", services=services, version=VERSION)
|
|
|
|
|
|
@app.route("/api/services", methods=["GET"])
|
|
def api_list_services():
|
|
services = models.list_services()
|
|
return {"services": services}
|
|
|
|
|
|
@app.route("/api/services", methods=["POST"])
|
|
def api_add_service():
|
|
data = request.get_json(silent=True)
|
|
if data is None and request.form:
|
|
data = request.form.to_dict()
|
|
if not data:
|
|
return {"error": "Request body must be valid JSON (Content-Type: application/json) or form data"}, 415
|
|
name = data.get("name", "").strip()
|
|
target = data.get("target", "").strip()
|
|
protocol = (data.get("protocol") or "https").lower().strip()
|
|
if not name or not target:
|
|
return {"error": "name and target are required"}, 400
|
|
if protocol not in ("http", "https", "tcp"):
|
|
return {"error": "protocol must be http, https, or tcp"}, 400
|
|
interval = int(data.get("interval_seconds", 60))
|
|
interval = max(10, min(3600, interval))
|
|
try:
|
|
sid = models.add_service(name, target, protocol, interval)
|
|
if request.accept_mimetypes.best == "application/json" or request.is_json:
|
|
return {"id": sid, "name": name, "target": target, "protocol": protocol}
|
|
return redirect(url_for("dashboard"))
|
|
except Exception as e:
|
|
return {"error": str(e)}, 500
|
|
|
|
|
|
@app.route("/api/services/<int:service_id>", methods=["DELETE"])
|
|
def api_delete_service(service_id):
|
|
if models.delete_service(service_id):
|
|
return {"deleted": service_id}
|
|
return {"error": "Not found"}, 404
|
|
|
|
|
|
@app.route("/api/services/<int:service_id>", methods=["PATCH"])
|
|
def api_update_service(service_id):
|
|
svc = models.get_service(service_id)
|
|
if not svc:
|
|
return {"error": "Not found"}, 404
|
|
data = request.get_json(silent=True)
|
|
if data is None and request.form:
|
|
data = request.form.to_dict()
|
|
if not data:
|
|
return {"error": "Request body must be valid JSON or form data"}, 415
|
|
updates = {}
|
|
if "name" in data and data["name"] is not None:
|
|
updates["name"] = str(data["name"]).strip()
|
|
if "target" in data and data["target"] is not None:
|
|
updates["target"] = str(data["target"]).strip()
|
|
if "protocol" in data and data["protocol"] is not None:
|
|
p = str(data["protocol"]).lower().strip()
|
|
if p not in ("http", "https", "tcp"):
|
|
return {"error": "protocol must be http, https, or tcp"}, 400
|
|
updates["protocol"] = p
|
|
if "interval_seconds" in data and data["interval_seconds"] is not None:
|
|
updates["interval_seconds"] = max(10, min(3600, int(data["interval_seconds"])))
|
|
if not updates:
|
|
return {"id": service_id, **dict(svc)}
|
|
if updates.get("name") == "" or updates.get("target") == "":
|
|
return {"error": "name and target cannot be empty"}, 400
|
|
if models.update_service(service_id, **updates):
|
|
updated = models.get_service(service_id)
|
|
return dict(updated)
|
|
return {"error": "Update failed"}, 500
|
|
|
|
|
|
@app.route("/api/services/<int:service_id>")
|
|
def api_get_service(service_id):
|
|
svc = models.get_service(service_id)
|
|
if not svc:
|
|
return {"error": "Not found"}, 404
|
|
checks = models.get_checks(service_id, limit=50)
|
|
return {"service": dict(svc), "checks": checks}
|
|
|
|
|
|
@app.route("/api/services/<int:service_id>/edit")
|
|
def edit_service(service_id):
|
|
svc = models.get_service(service_id)
|
|
if not svc:
|
|
return "Service not found", 404
|
|
return render_template("edit.html", service=dict(svc), version=VERSION)
|
|
|
|
|
|
@app.route("/api/services/<int:service_id>/report")
|
|
def report(service_id):
|
|
svc = models.get_service(service_id)
|
|
if not svc:
|
|
return "Service not found", 404
|
|
from_ts = request.args.get("from") or None
|
|
to_ts = request.args.get("to") or None
|
|
preset = request.args.get("preset")
|
|
from_ts, to_ts, from_display, to_display = _parse_report_dates(from_ts, to_ts, preset)
|
|
status_filter = request.args.get("status")
|
|
search = request.args.get("search", "").strip() or None
|
|
page = max(1, int(request.args.get("page", 1)))
|
|
per_page = min(100, max(10, int(request.args.get("per_page", 25))))
|
|
stats = models.get_report_stats(service_id, from_ts=from_ts, to_ts=to_ts)
|
|
checks_total = models.get_checks_count(service_id, from_ts=from_ts, to_ts=to_ts, status_filter=status_filter, search=search)
|
|
checks = models.get_checks(
|
|
service_id,
|
|
limit=per_page,
|
|
offset=(page - 1) * per_page,
|
|
from_ts=from_ts,
|
|
to_ts=to_ts,
|
|
status_filter=status_filter,
|
|
search=search,
|
|
)
|
|
chart_checks = models.get_checks(service_id, limit=200, from_ts=from_ts, to_ts=to_ts)
|
|
period_label = _format_period_label(from_display, to_display) if (from_ts or to_ts) else None
|
|
total_pages = (checks_total + per_page - 1) // per_page if checks_total else 1
|
|
return render_template(
|
|
"report.html",
|
|
service=dict(svc),
|
|
stats=stats,
|
|
checks=checks,
|
|
chart_checks=chart_checks,
|
|
version=VERSION,
|
|
from_date=from_display,
|
|
to_date=to_display,
|
|
period_label=period_label,
|
|
preset=preset,
|
|
status_filter=status_filter or "",
|
|
search=search or "",
|
|
page=page,
|
|
per_page=per_page,
|
|
checks_total=checks_total,
|
|
total_pages=total_pages,
|
|
)
|
|
|
|
|
|
def _format_period_label(from_display, to_display):
|
|
"""Format period for display."""
|
|
if from_display and to_display:
|
|
return f"{from_display} to {to_display}"
|
|
if from_display:
|
|
return f"From {from_display}"
|
|
if to_display:
|
|
return f"Until {to_display}"
|
|
return None
|
|
|
|
|
|
@app.route("/api/services/<int:service_id>/history")
|
|
def api_history(service_id):
|
|
svc = models.get_service(service_id)
|
|
if not svc:
|
|
return {"error": "Not found"}, 404
|
|
limit = min(500, int(request.args.get("limit", 100)))
|
|
from_ts = request.args.get("from") or None
|
|
to_ts = request.args.get("to") or None
|
|
if from_ts and len(from_ts) == 10:
|
|
from_ts = from_ts + "T00:00:00"
|
|
if to_ts and len(to_ts) == 10:
|
|
to_ts = to_ts + "T23:59:59.999999"
|
|
history = models.get_history(service_id, limit=limit, from_ts=from_ts, to_ts=to_ts)
|
|
return {"history": history}
|
|
|
|
|
|
@app.route("/api/services/<int:service_id>/stats")
|
|
def api_report_stats(service_id):
|
|
"""JSON report stats with optional from/to query params for date range."""
|
|
svc = models.get_service(service_id)
|
|
if not svc:
|
|
return {"error": "Not found"}, 404
|
|
from_ts = request.args.get("from") or None
|
|
to_ts = request.args.get("to") or None
|
|
if from_ts and len(from_ts) == 10:
|
|
from_ts = from_ts + "T00:00:00"
|
|
if to_ts and len(to_ts) == 10:
|
|
to_ts = to_ts + "T23:59:59.999999"
|
|
stats = models.get_report_stats(service_id, from_ts=from_ts, to_ts=to_ts)
|
|
return {"service": dict(svc), "stats": stats}
|