187 lines
7.8 KiB
Python
187 lines
7.8 KiB
Python
from dateutil import parser
|
|
from datetime import datetime, timedelta
|
|
from flask import Blueprint, request, jsonify
|
|
from werkzeug.exceptions import BadRequest, NotFound
|
|
|
|
from flaschengeist.modules import Plugin
|
|
from flaschengeist.system.database import db
|
|
from flaschengeist.system.models.event import EventKind
|
|
from flaschengeist.system.decorator import login_required
|
|
from flaschengeist.system.controller import eventController
|
|
|
|
schedule_bp = Blueprint("schedule", __name__, url_prefix="/schedule")
|
|
|
|
|
|
class SchedulePlugin(Plugin):
|
|
def __init__(self, config):
|
|
super().__init__(blueprint=schedule_bp)
|
|
|
|
####################################################################################
|
|
# Routes #
|
|
# #
|
|
# /schedule/events POST: create new #
|
|
# GET: get all events this month #
|
|
# /schedule/events/<year>/<month> GET: get events by month / date #
|
|
# /<year>/<month>/<day> #
|
|
# /schedule/events/<id> GET: get event by ID #
|
|
# DELETE: delete specified event #
|
|
# PUT: modify specified event #
|
|
# /schedule/events/<id>/slots GET: get EventSlots of Event #
|
|
# POST: add new EventSlot to Event #
|
|
# /schedule/events/<id>/slots/<sid> PUT: modify EventSlot #
|
|
# GET: get specified EventSlot #
|
|
# /schedule/events/<id>/slots/<sid>/jobs POST: add User #
|
|
# /schedule/eventKinds
|
|
# /schedule/eventKinds/<id>
|
|
# PUT: modify user #
|
|
# DELETE: remove user #
|
|
####################################################################################
|
|
|
|
@schedule_bp.route("/events/<int:id>", methods=["GET"])
|
|
@login_required() # roles=['schedule_read'])
|
|
def __get_event(self, id, **kwargs):
|
|
event = eventController.get_event(id)
|
|
if not event:
|
|
raise NotFound
|
|
return jsonify(event)
|
|
|
|
@schedule_bp.route("/events", methods=["GET"])
|
|
@schedule_bp.route("/events/<int:year>/<int:month>", methods=["GET"])
|
|
@schedule_bp.route("/events/<int:year>/<int:month>/<int:day>", methods=["GET"])
|
|
@login_required() # roles=['schedule_read'])
|
|
def __get_events(self, year=datetime.now().year, month=datetime.now().month, day=None, **kwrags):
|
|
"""Get Event objects for specified date (or month or year),
|
|
if nothing set then events for current month are returned
|
|
|
|
Args:
|
|
year (int, optional): year to query, defaults to current year
|
|
month (int, optional): month to query (if set), defaults to current month
|
|
day (int, optional): day to query events for (if set)
|
|
**kwrags: contains at least access_token (see flaschengeist.decorator)
|
|
Returns:
|
|
JSON list containing events found
|
|
Raises:
|
|
BadRequest: If date is invalid
|
|
"""
|
|
try:
|
|
begin = datetime(year=year, month=month, day=1)
|
|
if day:
|
|
begin += timedelta(days=day - 1)
|
|
end = begin + timedelta(days=1)
|
|
else:
|
|
if month == 12:
|
|
end = datetime(year=year + 1, month=1, day=1)
|
|
else:
|
|
end = datetime(year=year, month=month + 1, day=1)
|
|
|
|
events = eventController.get_events(begin, end)
|
|
return jsonify(events)
|
|
except ValueError:
|
|
raise BadRequest("Invalid date given")
|
|
|
|
@schedule_bp.route("/eventKinds", methods=["POST"])
|
|
@login_required()
|
|
def __new_event_kind(self, **kwargs):
|
|
data = request.get_json()
|
|
if "name" not in data:
|
|
raise BadRequest
|
|
kind = eventController.create_event_kind(data["name"])
|
|
return jsonify({"ok": "ok", "id": kind.id})
|
|
|
|
@schedule_bp.route("/slotKinds", methods=["POST"])
|
|
@login_required()
|
|
def __new_slot_kind(self, **kwargs):
|
|
data = request.get_json()
|
|
if not data or "name" not in data:
|
|
raise BadRequest
|
|
kind = eventController.create_job_kind(data["name"])
|
|
return jsonify({"ok": "ok", "id": kind.id})
|
|
|
|
@schedule_bp.route("/events", methods=["POST"])
|
|
@login_required()
|
|
def __new_event(self, **kwargs):
|
|
data = request.get_json()
|
|
event = eventController.create_event(
|
|
begin=parser.isoparse(data["begin"]),
|
|
end=parser.isoparse(data["end"]),
|
|
description=data["description"],
|
|
kind=EventKind.query.get(data["kind"]),
|
|
)
|
|
return jsonify({"ok": "ok", "id": event.id})
|
|
|
|
@schedule_bp.route("/events/<int:id>", methods=["DELETE"])
|
|
@login_required()
|
|
def __delete_event(self, id, **kwargs):
|
|
if not eventController.delete_event(id):
|
|
raise NotFound
|
|
db.session.commit()
|
|
return jsonify({"ok": "ok"})
|
|
|
|
@schedule_bp.route("/eventKinds/<int:id>", methods=["PUT"])
|
|
@login_required()
|
|
def __edit_event_kind(self, id, **kwargs):
|
|
data = request.get_json()
|
|
if not data or "name" not in data:
|
|
raise BadRequest
|
|
eventController.rename_event_kind(id, data["name"])
|
|
return jsonify({"ok": "ok"})
|
|
|
|
@schedule_bp.route("/events/<int:event_id>/slots", methods=["GET"])
|
|
@login_required()
|
|
def __get_slots(self, event_id, **kwargs):
|
|
event = eventController.get_event(event_id)
|
|
if not event:
|
|
raise NotFound
|
|
return jsonify({event.slots})
|
|
|
|
@schedule_bp.route("/events/<int:event_id>/slots/<int:slot_id>", methods=["GET"])
|
|
@login_required()
|
|
def __get_slot(self, event_id, slot_id, **kwargs):
|
|
slot = eventController.get_event_slot(slot_id, event_id)
|
|
if slot:
|
|
return jsonify(slot)
|
|
raise NotFound
|
|
|
|
@schedule_bp.route("/events/<int:event_id>/slots/<int:slot_id>", methods=["DELETE"])
|
|
@login_required()
|
|
def __delete_slot(self, event_id, slot_id, **kwargs):
|
|
if eventController.delete_event_slot(slot_id, event_id):
|
|
return jsonify({"ok": "ok"})
|
|
raise NotFound
|
|
|
|
@schedule_bp.route("/events/<int:event_id>/slots/<int:slot_id>", methods=["PUT"])
|
|
@login_required()
|
|
def __update_slot(self, event_id, slot_id, **kwargs):
|
|
data = request.get_json()
|
|
if not data:
|
|
raise BadRequest
|
|
|
|
for job in data["jobs"]:
|
|
eventController.add_job(job.kind, job.user)
|
|
if eventController.delete_event_slot(slot_id, event_id):
|
|
return jsonify({"ok": "ok"})
|
|
raise NotFound
|
|
|
|
@schedule_bp.route("/events/<int:event_id>/slots", methods=["POST"])
|
|
@login_required()
|
|
def __add_slot(self, event_id, **kwargs):
|
|
event = eventController.get_event(event_id)
|
|
if not event:
|
|
raise NotFound
|
|
data = request.get_json()
|
|
attr = {"job_slots": []}
|
|
try:
|
|
if "start" in data:
|
|
attr["start"] = parser.isoparse(data["start"])
|
|
if "end" in data:
|
|
attr["end"] = parser.isoparse(data["end"])
|
|
for job in data["jobs"]:
|
|
attr["job_slots"].append({"needed_persons": job["needed_persons"], "kind": job["kind"]})
|
|
except KeyError:
|
|
raise BadRequest("Missing data in request")
|
|
eventController.add_slot(event, **attr)
|
|
return jsonify({"ok": "ok"})
|
|
|
|
def __edit_event(self):
|
|
...
|