larigira/larigira/dbadmin/__init__.py

'''
This module contains a flask blueprint for db administration stuff

Templates are self-contained in this directory
'''
from __future__ import print_function
from datetime import datetime, timedelta, time
from collections import defaultdict

from flask import current_app, Blueprint, render_template, jsonify, abort, \
    request, redirect, url_for, flash

from larigira.entrypoints_utils import get_avail_entrypoints
from larigira.audiogen import get_audiogenerator
from larigira.timegen_every import FrequencyAlarm
from larigira.timegen import get_timegenerator, timegenerate
from larigira import forms
from larigira.config import get_conf
from .suggestions import get_suggestions
db = Blueprint('db', __name__,
               url_prefix=get_conf()['ROUTE_PREFIX'] + '/db',
               template_folder='templates')


def request_wants_json():
    best = request.accept_mimetypes \
        .best_match(['application/json', 'text/html'])
    return best == 'application/json' and \
        request.accept_mimetypes[best] > \
        request.accept_mimetypes['text/html']


def get_model():
    return current_app.larigira.controller.monitor.model


@db.route('/')
def home():
    return render_template('dbadmin_base.html')


@db.route('/list')
def events_list():
    model = current_app.larigira.controller.monitor.model
    alarms = tuple(model.get_all_alarms())
    events = [(alarm, model.get_actions_by_alarm(alarm))
              for alarm in alarms]
    return render_template('list.html', events=events)


@db.route('/calendar')
def events_calendar():
    model = current_app.larigira.controller.monitor.model
    today = datetime.now().date()
    maxdays = 30
    # {date: {datetime: [(alarm1,actions1), (alarm2,actions2)]}}
    days = defaultdict(lambda: defaultdict(list))
    freq_threshold = get_conf()['UI_CALENDAR_FREQUENCY_THRESHOLD']
    for alarm in model.get_all_alarms():
        if freq_threshold and alarm['kind'] == 'frequency' and \
           FrequencyAlarm(alarm).interval < freq_threshold:
            continue
        actions = tuple(model.get_actions_by_alarm(alarm))
        if not actions:
            continue
        t = datetime.fromtimestamp(int(today.strftime('%s')))
        for t in timegenerate(alarm, now=t, howmany=maxdays):
            if t is None or \
               t > datetime.combine(today+timedelta(days=maxdays), time()):
                break
            days[t.date()][t].append((alarm, actions))

    # { weeknum: [day1, day2, day3] }
    weeks = defaultdict(list)
    for d in sorted(days.keys()):
        weeks[d.isocalendar()[:2]].append(d)

    return render_template('calendar.html', days=days, weeks=weeks)


@db.route('/add/time')
def addtime():
    kinds = get_avail_entrypoints('larigira.timeform_create')

    def gen_info(gen):
        return dict(description=getattr(gen, 'description', ''))
    info = {kind: gen_info(get_timegenerator(kind))
            for kind in kinds}
    return render_template('add_time.html', kinds=kinds, info=info)


@db.route('/edit/time/<int:alarmid>', methods=['GET', 'POST'])
def edit_time(alarmid):
    model = get_model()
    timespec = model.get_alarm_by_id(alarmid)
    kind = timespec['kind']
    Form, receiver = tuple(forms.get_timeform(kind))
    form = Form()
    if request.method == 'GET':
        form.populate_from_timespec(timespec)
    if request.method == 'POST' and form.validate():
        data = receiver(form)
        model.update_alarm(alarmid, data)
        model.reload()
        return redirect(url_for('db.events_list',
                                _anchor='event-%d' % alarmid))
    return render_template('add_time_kind.html',
                           form=form,
                           kind=kind,
                           mode='edit',
                           alarmid=alarmid,
                           )


@db.route('/add/time/<kind>', methods=['GET', 'POST'])
def addtime_kind(kind):
    Form, receiver = tuple(forms.get_timeform(kind))
    form = Form()
    if request.method == 'POST' and form.validate():
        data = receiver(form)
        eid = get_model().add_alarm(data)
        return redirect(url_for('db.edit_event', alarmid=eid))

    return render_template('add_time_kind.html',
                           form=form, kind=kind, mode='add')


@db.route('/add/audio')
def addaudio():
    kinds = get_avail_entrypoints('larigira.audioform_create')

    def gen_info(gen):
        return dict(description=getattr(gen, 'description', ''))
    info = {kind: gen_info(get_audiogenerator(kind))
            for kind in kinds}
    return render_template('add_audio.html', kinds=kinds, info=info)


@db.route('/add/audio/<kind>', methods=['GET', 'POST'])
def addaudio_kind(kind):
    Form, receiver = tuple(forms.get_audioform(kind))
    form = Form()
    if request.method == 'POST' and form.validate():
        data = receiver(form)
        model = current_app.larigira.controller.monitor.model
        eid = model.add_action(data)
        return jsonify(dict(inserted=eid, data=data))

    return render_template('add_audio_kind.html', form=form, kind=kind,
                           suggestions=get_suggestions()
                           )


@db.route('/edit/audio/<int:actionid>', methods=['GET', 'POST'])
def edit_audio(actionid):
    model = get_model()
    audiospec = model.get_action_by_id(actionid)
    kind = audiospec['kind']
    Form, receiver = tuple(forms.get_audioform(kind))
    form = Form()
    if request.method == 'GET':
        form.populate_from_audiospec(audiospec)
    if request.method == 'POST' and form.validate():
        data = receiver(form)
        model.update_action(actionid, data)
        model.reload()
        return redirect(url_for('db.events_list'))
    return render_template('add_audio_kind.html',
                           form=form,
                           kind=kind,
                           mode='edit',
                           suggestions=get_suggestions()
                           )


@db.route('/edit/event/<alarmid>')
def edit_event(alarmid):
    model = current_app.larigira.controller.monitor.model
    alarm = model.get_alarm_by_id(int(alarmid))
    if alarm is None:
        abort(404)
    allactions = model.get_all_actions()
    actions = tuple(model.get_actions_by_alarm(alarm))
    return render_template('edit_event.html',
                           alarm=alarm, all_actions=allactions,
                           actions=actions,
                           routeprefix=get_conf()['ROUTE_PREFIX']
                          )


@db.route('/api/alarm/<alarmid>/actions', methods=['POST'])
def change_actions(alarmid):
    new_actions = request.form.getlist('actions[]')
    if new_actions is None:
        new_actions = []
    model = current_app.larigira.controller.monitor.model
    ret = model.update_alarm(int(alarmid),
                             new_fields={'actions': [int(a) for a in
                                                     new_actions]})
    return jsonify(dict(updated=alarmid, ret=ret))


@db.route('/api/alarm/<int:alarmid>/delete', methods=['POST'])
def delete_alarm(alarmid):
    model = current_app.larigira.controller.monitor.model
    try:
        alarm = model.get_alarm_by_id(int(alarmid))
        print(alarm['nick'])
        model.delete_alarm(alarmid)
    except KeyError:
        abort(404)
    if request_wants_json():
        return jsonify(dict(deleted=alarmid))
    flash('Evento %d `%s` cancellato' % (alarmid, alarm['nick']) )
    return redirect(url_for('db.events_list'))