argus-alm 0.14.2__py3-none-any.whl → 0.15.1__py3-none-any.whl

argus/backend/controller/client_api.py

@@ -0,0 +1,109 @@
+from flask import Blueprint, request
+
+from argus.backend.error_handlers import handle_api_exception
+from argus.backend.service.user import api_login_required
+from argus.backend.service.client_service import ClientService
+from argus.backend.util.common import get_payload
+from argus.backend.plugins.loader import AVAILABLE_PLUGINS
+
+bp = Blueprint("client_api", __name__, url_prefix="/client")
+bp.register_error_handler(Exception, handle_api_exception)
+for plugin in AVAILABLE_PLUGINS.values():
+    if plugin.controller:
+        bp.register_blueprint(plugin.controller)
+
+
+@bp.route("/testrun/<string:run_type>/submit", methods=["POST"])
+@api_login_required
+def submit_run(run_type: str):
+    payload = get_payload(request)
+    result = ClientService().submit_run(run_type=run_type, request_data=payload)
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/testrun/<string:run_type>/<string:run_id>/get", methods=["GET"])
+@api_login_required
+def get_run(run_type: str, run_id: str):
+    result = ClientService().get_run(run_type=run_type, run_id=run_id)
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/testrun/<string:run_type>/<string:run_id>/heartbeat", methods=["POST"])
+@api_login_required
+def run_heartbeat(run_type: str, run_id: str):
+    result = ClientService().heartbeat(run_type=run_type, run_id=run_id)
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/testrun/<string:run_type>/<string:run_id>/get_status")
+@api_login_required
+def run_get_status(run_type: str, run_id: str):
+    result = ClientService().get_run_status(run_type=run_type, run_id=run_id)
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/testrun/<string:run_type>/<string:run_id>/set_status", methods=["POST"])
+@api_login_required
+def run_set_status(run_type: str, run_id: str):
+    payload = get_payload(request)
+    result = ClientService().update_run_status(run_type=run_type, run_id=run_id, new_status=payload["new_status"])
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/testrun/<string:run_type>/<string:run_id>/update_product_version", methods=["POST"])
+@api_login_required
+def run_update_product_version(run_type: str, run_id: str):
+    payload = get_payload(request)
+    result = ClientService().submit_product_version(
+        run_type=run_type, run_id=run_id, version=payload["product_version"])
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/testrun/<string:run_type>/<string:run_id>/logs/submit", methods=["POST"])
+@api_login_required
+def run_submit_logs(run_type: str, run_id: str):
+    payload = get_payload(request)
+    result = ClientService().submit_logs(run_type=run_type, run_id=run_id, logs=payload["logs"])
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/testrun/<string:run_type>/<string:run_id>/finalize", methods=["POST"])
+@api_login_required
+def run_finalize(run_type: str, run_id: str):
+    try:
+        payload = get_payload(request)
+    except Exception:
+        payload = None
+    result = ClientService().finish_run(run_type=run_type, run_id=run_id, payload=payload)
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/testrun/<string:run_type>/<string:run_id>/submit_results", methods=["POST"])
+@api_login_required
+def submit_results(run_type: str, run_id: str):
+    payload = get_payload(request)
+    return ClientService().submit_results(run_type=run_type, run_id=run_id, results=payload)

argus/backend/controller/main.py

@@ -0,0 +1,316 @@
+import datetime
+import json
+import logging
+from uuid import UUID
+from flask import (
+    Blueprint, flash, g, redirect, render_template, request, session, url_for, make_response
+)
+from argus.backend.controller.notifications import bp as notifications_bp
+from argus.backend.controller.team_ui import bp as teams_bp
+from argus.backend.service.argus_service import ArgusService
+from argus.backend.models.web import ArgusRelease, WebFileStorage
+from argus.backend.service.testrun import TestRunService
+from argus.backend.service.planner_service import PlanningService
+from argus.backend.service.user import UserService, login_required
+from argus.backend.service.views import UserViewService
+
+LOGGER = logging.getLogger(__name__)
+
+bp = Blueprint('main', __name__)
+bp.register_blueprint(notifications_bp)
+bp.register_blueprint(teams_bp)
+
+
+@bp.route("/test_runs")
+@login_required
+def test_runs():
+    return render_template("test_runs.html.j2")
+
+
+@bp.route("/test_run/<string:run_id>")
+@login_required
+def test_run(run_id: UUID):
+    return render_template("test_run.html.j2", id=run_id)
+
+
+@bp.route("/test/<string:test_id>/runs")
+@login_required
+def runs(test_id: UUID):
+    additional_runs = request.args.getlist("additionalRuns[]")
+    return render_template("standalone_test_with_runs.html.j2", test_id=test_id, additional_runs=additional_runs)
+
+
+@bp.route("/tests/<string:plugin_name>/<string:run_id>", defaults={"tab": "details"})
+@bp.route("/tests/<string:plugin_name>/<string:run_id>/<string:tab>")
+@login_required
+def get_run_by_plugin(plugin_name: str, run_id: UUID | str, tab: str):
+    try:
+        run_id = UUID(run_id)
+    except ValueError:
+        flash(message=f"Invalid UUID: {run_id}", category="error")
+        return redirect(url_for("main.error", type=404))
+    run = TestRunService().get_run(plugin_name, run_id)
+    if not run:
+        flash(f"Run {plugin_name}/{run_id} not found.", "error")
+        return redirect(url_for("main.error", type=404))
+    return render_template("run_view_by_plugin.html.j2", run=run, tab=tab)
+
+
+@bp.route("/")
+def home():
+    return redirect(url_for("main.run_dashboard"))
+
+
+@bp.route("/run_dashboard")
+@bp.route("/workspace")
+@login_required
+def run_dashboard():
+    return render_template('dashboard.html.j2')
+
+
+@bp.route("/releases")
+@login_required
+def releases():
+    service = ArgusService()
+    all_releases = service.get_releases()
+    return render_template("releases.html.j2", releases=all_releases)
+
+
+@bp.route("/views")
+@login_required
+def views():
+    service = UserViewService()
+    all_views = service.get_all_views()
+    return render_template("views.html.j2", views=sorted(all_views, key=lambda view: view.created or datetime.datetime.fromtimestamp(0), reverse=True))
+
+
+@bp.route("/view/<string:view_name>")
+@login_required
+def view_dashboard(view_name: str):
+    service = UserViewService()
+    view = service.get_view_by_name(view_name=view_name)
+    data_json = view
+    view["widget_settings"] = json.loads(view["widget_settings"])
+    return render_template("view_dashboard.html.j2", data=data_json)
+
+
+@bp.route("/plan/<string:plan_id>")
+@login_required
+def plan_dashboard(plan_id: str):
+    service = PlanningService()
+    plan = service.get_plan(plan_id=plan_id)
+    data_json = plan
+    return render_template("plan_dashboard.html.j2", data=data_json)
+
+
+@bp.route("/alert_debug")
+@login_required
+def alert_debug():
+    alert_type = request.args.get("type", "success")
+    message = request.args.get("message", "No message provided")
+    flash(message=message, category=alert_type)
+    return render_template("flash_debug.html.j2")
+
+
+@bp.route("/dashboard/<string:release_name>")
+@login_required
+def release_dashboard(release_name: str):
+    service = ArgusService()
+    release, release_groups, release_tests = service.get_data_for_release_dashboard(
+        release_name=release_name)
+    data_json = {
+        "release": dict(release.items()),
+        "groups": [dict(group.items()) for group in release_groups],
+        "tests": [dict(test.items()) for test in release_tests],
+    }
+    return render_template("release_dashboard.html.j2", release_name=release_name, data=data_json)
+
+
+@bp.route("/release/<string:name>/scheduler")
+@login_required
+def release_scheduler(name: str):
+    service = ArgusService()
+    release, release_groups, release_tests = service.get_data_for_release_dashboard(
+        release_name=name)
+    data_json = {
+        "release": dict(release.items()),
+        "groups": [dict(group.items()) for group in release_groups],
+        "tests": [dict(test.items()) for test in release_tests],
+    }
+    return render_template("release_schedule.html.j2", release_name=name, data=data_json)
+
+
+@bp.route("/release/by-id/<string:id>/planner")
+@login_required
+def release_planner_by_id(id: str):
+    release = ArgusRelease.get(id=id)
+    return redirect(url_for("main.release_planner", name=release.name))
+
+
+@bp.route("/release/<string:name>/planner")
+@login_required
+def release_planner(name: str):
+    service = PlanningService()
+    planner_data = service.release_planner(name)
+    return render_template("release_planner.html.j2", release_name=planner_data["release"]["name"], planner_data=planner_data)
+
+
+@bp.route("/release/<string:name>/duty")
+@login_required
+def duty_planner(name: str):
+    service = ArgusService()
+    release, release_groups, release_tests = service.get_data_for_release_dashboard(
+        release_name=name)
+    data_json = {
+        "release": dict(release.items()),
+        "groups": [dict(group.items()) for group in release_groups],
+        "tests": [dict(test.items()) for test in release_tests],
+    }
+    return render_template("duty_planner.html.j2", release_name=name, data=data_json)
+
+
+@bp.route("/error/")
+def error():
+    return render_template("error.html.j2", type=request.args.get("type", 400))
+
+
+@bp.route("/profile/")
+@login_required
+def profile():
+    first_run = session.pop("first_run_info", None)
+    token_generated = session.pop("token_generated", None)
+
+    return render_template("profile.html.j2", first_run=first_run, token_generated=token_generated)
+
+
+@bp.route("/profile/oauth/github", methods=["GET"])
+def profile_oauth_github_callback():
+    req_state = request.args.get('state', '')
+    if req_state != session["csrf_token"]:
+        return redirect(url_for("main.error", type=403))
+
+    req_code = request.args.get("code", "WTF")
+    service = UserService()
+    try:
+        first_run_info = service.github_callback(req_code)
+    except Exception as exc:
+        LOGGER.error("An error occured in callback", exc_info=True)
+        flash(message=exc.args[0], category="error")
+        return redirect(url_for("main.error", type=403))
+    if first_run_info:
+        session["first_run_info"] = first_run_info
+
+    if path := session.pop("redirect_target"):
+        return redirect(path)
+    return redirect(url_for("main.profile"))
+
+
+@bp.route("/storage/picture/<string:picture_id>")
+@login_required
+def get_picture(picture_id: str):
+    res = make_response()
+    try:
+        picture = WebFileStorage.get(id=picture_id)
+        with open(picture.filepath, "rb") as file:
+            res.set_data(file.read())
+        res.content_type = "image/*"
+        res.status = 200
+    except FileNotFoundError:
+        res.status = 404
+        res.content_type = "text/plain"
+        res.set_data("404 NOT FOUND")
+
+    res.cache_control.max_age = 86400
+    res.cache_control.public = True
+    return res
+
+
+@bp.route("/profile/update/picture", methods=["POST"])
+@login_required
+def upload_file():
+    req_file = request.files.get("filedata")
+    picture_data = req_file.stream.read()
+    picture_name = req_file.filename
+    if not req_file.content_type.startswith("image/"):
+        flash(
+            message=f"Expected image/*, got {req_file.content_type}", category="error")
+        return redirect(url_for("main.profile"))
+    if not picture_data:
+        flash(message="No picture provided", category="error")
+        return redirect(url_for("main.profile"))
+
+    service = UserService()
+    filename, filepath = service.save_profile_picture_to_disk(
+        picture_name, picture_data, g.user.username)
+    service.update_profile_picture(filename, filepath)
+
+    return redirect(url_for("main.profile"))
+
+
+@bp.route("/profile/update/name", methods=["POST"])
+@login_required
+def update_full_name():
+    new_name = request.values.get("new_name")
+    if not new_name:
+        flash(message="Incorrect new name", category="error")
+    else:
+        service = UserService()
+        service.update_name(g.user, new_name)
+        flash("Successfully changed name!", category="success")
+    return redirect(url_for("main.profile"))
+
+
+@bp.route("/profile/update/email", methods=["POST"])
+@login_required
+def update_email():
+    new_email = request.values.get("new_email")
+    if not new_email:
+        flash("Incorrect new email", category="error")
+    else:
+        service = UserService()
+        service.update_email(g.user, new_email)
+        flash("Successfully changed email!", category="success")
+    return redirect(url_for("main.profile"))
+
+
+@bp.route("/profile/update/password", methods=["POST"])
+@login_required
+def update_password():
+    old_password = request.values.get("old_password")
+    new_password = request.values.get("new_password")
+    new_password_confirm = request.values.get("new_password_confirm")
+    if not old_password:
+        flash("Old password wasn't provided", category="error")
+        return redirect(url_for("main.profile"))
+    if not new_password:
+        flash("New password wasn't provided", category="error")
+        return redirect(url_for("main.profile"))
+
+    if not new_password == new_password_confirm:
+        flash("New password doesn't match confirmation!", category="error")
+        return redirect(url_for("main.profile"))
+
+    service = UserService()
+    try:
+        service.update_password(
+            g.user, old_password=old_password, new_password=new_password)
+    except Exception:
+        flash("Old password is incorrect", category="error")
+        return redirect(url_for("main.profile"))
+
+    flash("Successfully changed password!")
+    return redirect(url_for("main.profile"))
+
+
+@bp.route("/profile/jobs", methods=["GET"])
+@login_required
+def profile_jobs():
+    return render_template("profile_jobs.html.j2")
+
+
+@bp.route("/profile/schedules", methods=["GET"])
+@login_required
+def profile_schedules():
+    service = ArgusService()
+    schedules = service.get_schedules_for_user(g.user)
+    return render_template("profile_schedules.html.j2", schedules=schedules)

argus/backend/controller/notification_api.py

@@ -0,0 +1,72 @@
+import logging
+from flask import (
+    Blueprint,
+    g,
+    request,
+)
+from argus.backend.error_handlers import handle_api_exception
+from argus.backend.service.notification_manager import NotificationManagerService
+from argus.backend.service.user import api_login_required
+from argus.backend.util.common import get_payload
+
+bp = Blueprint('notifications', __name__, url_prefix='/notifications')
+LOGGER = logging.getLogger(__name__)
+bp.register_error_handler(Exception, handle_api_exception)
+
+
+@bp.route("/get")
+@api_login_required
+def get_notification():
+    notification_id = request.args.get("id")
+    if not notification_id:
+        raise Exception("No notification id provided")
+    service = NotificationManagerService()
+    notification = service.get_notificaton(
+        receiver=g.user.id, notification_id=notification_id)
+    return {
+        "status": "ok",
+        "response": notification.to_dict()
+    }
+
+
+@bp.route("/get_unread")
+@api_login_required
+def get_unread_count():
+    service = NotificationManagerService()
+    unread_count = service.get_unread_count(receiver=g.user.id)
+    return {
+        "status": "ok",
+        "response": unread_count
+    }
+
+
+@bp.route("/summary")
+@api_login_required
+def get_summary():
+    after = request.args.get("afterId")
+    limit = request.args.get("limit")
+    limit = int(limit) if limit else 20
+    service = NotificationManagerService()
+    notifications = service.get_notifications(
+        receiver=g.user.id,
+        limit=limit,
+        after=after
+    )
+    return {
+        "status": "ok",
+        "response": [n.to_dict_short_summary() for n in notifications]
+    }
+
+
+@bp.route("/read", methods=["POST"])
+@api_login_required
+def read_notification():
+    payload = get_payload(request)
+    service = NotificationManagerService()
+    status = service.read_notification(
+        receiver=g.user.id, notification_id=payload["id"])
+
+    return {
+        "status": "ok",
+        "response": status
+    }

argus/backend/controller/notifications.py

@@ -0,0 +1,13 @@
+from flask import (
+    Blueprint,
+    render_template,
+)
+from argus.backend.service.user import login_required
+
+bp = Blueprint('notifications', __name__, url_prefix='/notifications')
+
+
+@bp.route("/")
+@login_required
+def index():
+    return render_template("profile_notifications.html.j2")

argus/backend/controller/planner_api.py

@@ -0,0 +1,194 @@
+import logging
+from uuid import UUID
+from flask import (
+    Blueprint,
+    request
+)
+from argus.backend.error_handlers import handle_api_exception
+from argus.backend.service.planner_service import CopyPlanPayload, PlanningService, TempPlanPayload
+from argus.backend.service.test_lookup import TestLookup
+from argus.backend.service.user import api_login_required
+from argus.backend.util.common import get_payload
+
+bp = Blueprint('planning_api', __name__, url_prefix='/planning')
+LOGGER = logging.getLogger(__name__)
+bp.register_error_handler(Exception, handle_api_exception)
+
+
+@bp.route("/", methods=["GET"])
+@api_login_required
+def version():
+
+    result = PlanningService().version()
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/plan/<string:plan_id>/copy/check", methods=["GET"])
+@api_login_required
+def is_plan_eligible_for_copy(plan_id: str):
+    release_id = request.args.get("releaseId")
+    if not release_id:
+        raise Exception("Missing release id.")
+
+    result = PlanningService().check_plan_copy_eligibility(plan_id=UUID(plan_id), target_release_id=UUID(release_id))
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/release/<string:release_id>/gridview", methods=["GET"])
+@api_login_required
+def grid_view_for_release(release_id: str):
+
+    result = PlanningService().get_gridview_for_release(release_id=UUID(release_id))
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/search", methods=["GET"])
+@api_login_required
+def search_tests():
+    query = request.args.get("query")
+    release_id = request.args.get('releaseId')
+    service = TestLookup
+    if query:
+        res = service.test_lookup(query, release_id=release_id)
+    else:
+        res = []
+    return {
+        "status": "ok",
+        "response": {
+            "hits": res,
+            "total": len(res)
+        }
+    }
+
+
+@bp.route("/group/<string:group_id>/explode", methods=["GET"])
+@api_login_required
+def explode_group(group_id: str):
+    service = TestLookup
+    res = service.explode_group(group_id=group_id)
+    return {
+        "status": "ok",
+        "response": res
+    }
+
+
+@bp.route("/plan/<string:plan_id>/get", methods=["GET"])
+@api_login_required
+def get_plan(plan_id: str):
+    result = PlanningService().get_plan(plan_id)
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/release/<string:release_id>/all", methods=["GET"])
+@api_login_required
+def get_plans_for_release(release_id: str):
+    result = PlanningService().get_plans_for_release(release_id)
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/plan/create", methods=["POST"])
+@api_login_required
+def create_plan():
+    payload = get_payload(request)
+    result = PlanningService().create_plan(payload)
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/plan/update", methods=["POST"])
+@api_login_required
+def update_plan():
+    payload = get_payload(request)
+    result = PlanningService().update_plan(payload)
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/plan/copy", methods=["POST"])
+@api_login_required
+def copy_plan():
+    payload = get_payload(request)
+    payload["plan"] = TempPlanPayload(**payload["plan"])
+    result = PlanningService().copy_plan(CopyPlanPayload(**payload))
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/plan/<string:plan_id>/delete", methods=["DELETE"])
+@api_login_required
+def delete_plan(plan_id: str):
+    delete_view = bool(int(request.args.get("deleteView", "0")))
+    result = PlanningService().delete_plan(plan_id, delete_view=delete_view)
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/plan/<string:plan_id>/owner/set", methods=["POST"])
+@api_login_required
+def change_plan_owner(plan_id: str):
+    payload = get_payload(request)
+    result = PlanningService().change_plan_owner(plan_id=plan_id, new_owner=payload["newOwner"])
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/plan/<string:plan_id>/resolve_entities", methods=["GET"])
+@api_login_required
+def resolve_plan_entities(plan_id: str):
+
+    service = PlanningService()
+    result = service.resolve_plan(plan_id)
+
+    return {
+        "status": "ok",
+        "response": result,
+    }
+
+
+@bp.route("/plan/trigger", methods=["POST"])
+@api_login_required
+def trigger_jobs_for_plans():
+
+    payload = get_payload(request)
+    service = PlanningService()
+    result = service.trigger_jobs(payload)
+
+    return {
+        "status": "ok",
+        "response": result,
+    }