292 lines
7.7 KiB
Python
292 lines
7.7 KiB
Python
from datetime import datetime, timedelta, timezone
|
|
from typing import Optional
|
|
|
|
from werkzeug.exceptions import BadRequest, Conflict, NotFound
|
|
from sqlalchemy.exc import IntegrityError
|
|
|
|
from flaschengeist import logger
|
|
from flaschengeist.database import db
|
|
from flaschengeist.plugins.events import EventPlugin
|
|
from flaschengeist.plugins.events.models import EventType, Event, Job, JobType, Service
|
|
from flaschengeist.utils.scheduler import scheduled
|
|
|
|
|
|
def update():
|
|
db.session.commit()
|
|
|
|
|
|
def get_event_types():
|
|
return EventType.query.all()
|
|
|
|
|
|
def get_event_type(identifier):
|
|
"""Get EventType by ID (int) or name (string)"""
|
|
|
|
if isinstance(identifier, int):
|
|
et = EventType.query.get(identifier)
|
|
elif isinstance(identifier, str):
|
|
et = EventType.query.filter(EventType.name == identifier).one_or_none()
|
|
else:
|
|
logger.debug("Invalid identifier type for EventType")
|
|
raise BadRequest
|
|
if not et:
|
|
raise NotFound
|
|
return et
|
|
|
|
|
|
def create_event_type(name):
|
|
try:
|
|
event = EventType(name=name)
|
|
db.session.add(event)
|
|
db.session.commit()
|
|
return event
|
|
except IntegrityError:
|
|
raise Conflict("Name already exists")
|
|
|
|
|
|
def rename_event_type(identifier, new_name):
|
|
event_type = get_event_type(identifier)
|
|
event_type.name = new_name
|
|
try:
|
|
db.session.commit()
|
|
except IntegrityError:
|
|
raise Conflict("Name already exists")
|
|
|
|
|
|
def delete_event_type(name):
|
|
event_type = get_event_type(name)
|
|
db.session.delete(event_type)
|
|
try:
|
|
db.session.commit()
|
|
except IntegrityError:
|
|
raise BadRequest("Type still in use")
|
|
|
|
|
|
def get_job_types():
|
|
return JobType.query.all()
|
|
|
|
|
|
def get_job_type(type_id):
|
|
job_type = JobType.query.get(type_id)
|
|
print(job_type)
|
|
if not job_type:
|
|
raise NotFound
|
|
return job_type
|
|
|
|
|
|
def create_job_type(name):
|
|
try:
|
|
job_type = JobType(name=name)
|
|
db.session.add(job_type)
|
|
db.session.commit()
|
|
return job_type
|
|
except IntegrityError:
|
|
raise BadRequest("Name already exists")
|
|
|
|
|
|
def rename_job_type(name, new_name):
|
|
job_type = get_job_type(name)
|
|
job_type.name = new_name
|
|
try:
|
|
db.session.commit()
|
|
except IntegrityError:
|
|
raise BadRequest("Name already exists")
|
|
|
|
|
|
def delete_job_type(name):
|
|
job_type = get_job_type(name)
|
|
db.session.delete(job_type)
|
|
try:
|
|
db.session.commit()
|
|
except IntegrityError:
|
|
raise BadRequest("Type still in use")
|
|
|
|
|
|
def clear_backup(event: Event):
|
|
for job in event.jobs:
|
|
services = []
|
|
for service in job.services:
|
|
if not service.is_backup:
|
|
services.append(service)
|
|
job.services = services
|
|
|
|
|
|
def get_event(event_id, with_backup=False) -> Event:
|
|
event = Event.query.get(event_id)
|
|
if event is None:
|
|
raise NotFound
|
|
if not with_backup:
|
|
clear_backup(event)
|
|
return event
|
|
|
|
|
|
def get_templates():
|
|
return Event.query.filter(Event.is_template == True).all()
|
|
|
|
|
|
def get_events(
|
|
start: Optional[datetime] = None,
|
|
end: Optional[datetime] = None,
|
|
limit: Optional[int] = None,
|
|
offset: Optional[int] = None,
|
|
descending: Optional[bool] = False,
|
|
with_backup=False,
|
|
):
|
|
"""Query events which start from begin until end
|
|
Args:
|
|
start (datetime): Earliest start
|
|
end (datetime): Latest start
|
|
with_backup (bool): Export also backup services
|
|
|
|
Returns: collection of Event objects
|
|
"""
|
|
query = Event.query.filter(Event.is_template.__eq__(False))
|
|
if start is not None:
|
|
query = query.filter(start <= Event.start)
|
|
if end is not None:
|
|
query = query.filter(Event.start < end)
|
|
if descending:
|
|
query = query.order_by(Event.start.desc())
|
|
else:
|
|
query = query.order_by(Event.start)
|
|
if limit is not None:
|
|
query = query.limit(limit)
|
|
if offset is not None and offset > 0:
|
|
query = query.offset(offset)
|
|
events = query.all()
|
|
if not with_backup:
|
|
for event in events:
|
|
clear_backup(event)
|
|
return events
|
|
|
|
|
|
def delete_event(event_id):
|
|
"""Delete event with given ID
|
|
Args:
|
|
event_id: id of Event to delete
|
|
|
|
Raises:
|
|
NotFound if not found
|
|
"""
|
|
event = get_event(event_id, True)
|
|
for job in event.jobs:
|
|
delete_job(job)
|
|
db.session.delete(event)
|
|
db.session.commit()
|
|
|
|
|
|
def create_event(event_type, start, end=None, jobs=[], is_template=None, name=None, description=None):
|
|
try:
|
|
logger.debug(event_type)
|
|
event = Event(
|
|
start=start,
|
|
end=end,
|
|
name=name,
|
|
description=description,
|
|
type=event_type,
|
|
is_template=is_template,
|
|
jobs=jobs,
|
|
)
|
|
db.session.add(event)
|
|
db.session.commit()
|
|
return event
|
|
except IntegrityError:
|
|
logger.debug("Database error when creating new event", exc_info=True)
|
|
raise BadRequest
|
|
|
|
|
|
def get_job(job_id, event_id=None) -> Job:
|
|
query = Job.query.filter(Job.id == job_id)
|
|
if event_id is not None:
|
|
query = query.filter(Job.event_id_ == event_id)
|
|
job = query.one_or_none()
|
|
if job is None:
|
|
raise NotFound
|
|
return job
|
|
|
|
|
|
def add_job(event, job_type, required_services, start, end=None, comment=None):
|
|
job = Job(
|
|
required_services=required_services,
|
|
type=job_type,
|
|
start=start,
|
|
end=end,
|
|
comment=comment,
|
|
)
|
|
event.jobs.append(job)
|
|
update()
|
|
return job
|
|
|
|
|
|
def update():
|
|
try:
|
|
db.session.commit()
|
|
except IntegrityError:
|
|
logger.debug(
|
|
"Error, looks like a Job with that type already exists on an event",
|
|
exc_info=True,
|
|
)
|
|
raise BadRequest()
|
|
|
|
|
|
def delete_job(job: Job):
|
|
for service in job.services:
|
|
unassign_job(service=service, notify=True)
|
|
db.session.delete(job)
|
|
db.session.commit()
|
|
|
|
|
|
def assign_job(job: Job, user, value, is_backup=False):
|
|
assert value > 0
|
|
service = Service.query.get((job.id, user.id_))
|
|
if service:
|
|
service.value = value
|
|
else:
|
|
service = Service(user_=user, value=value, is_backup=is_backup, job_=job)
|
|
db.session.add(service)
|
|
db.session.commit()
|
|
|
|
|
|
def unassign_job(job: Job = None, user=None, service=None, notify=False):
|
|
if service is None:
|
|
assert job is not None and user is not None
|
|
service = Service.query.get((job.id, user.id_))
|
|
else:
|
|
user = service.user_
|
|
if not service:
|
|
raise BadRequest
|
|
|
|
event_id = service.job_.event_id_
|
|
|
|
db.session.delete(service)
|
|
db.session.commit()
|
|
if notify:
|
|
EventPlugin.plugin.notify(user, "Your assignmet was cancelled", {"event_id": event_id})
|
|
|
|
|
|
@scheduled
|
|
def assign_backups():
|
|
logger.debug("Notifications")
|
|
now = datetime.now(tz=timezone.utc)
|
|
# now + backup_time + next cron tick
|
|
start = now + timedelta(hours=16) + timedelta(minutes=30)
|
|
services = Service.query.filter(Service.is_backup == True).join(Job).filter(Job.start <= start).all()
|
|
for service in services:
|
|
if service.job_.start <= now or service.job_.is_full():
|
|
EventPlugin.plugin.notify(
|
|
service.user_,
|
|
"Your backup assignment was cancelled.",
|
|
{"event_id": service.job_.event_id_},
|
|
)
|
|
logger.debug(f"Service is outdated or full, removing. {service.serialize()}")
|
|
db.session.delete(service)
|
|
else:
|
|
service.is_backup = False
|
|
logger.debug(f"Service not full, assigning backup. {service.serialize()}")
|
|
EventPlugin.plugin.notify(
|
|
service.user_,
|
|
"Your backup assignment was accepted.",
|
|
{"event_id": service.job_.event_id_},
|
|
)
|
|
db.session.commit()
|