Hasscall/app/views/callbacks.py

from html import entities
from flask import redirect, render_template, request, url_for, flash
from grpc import services

from datetime import time

from app import webapp
from app.homeassistant import HomeAssistant
from app.models.callback import Callback
from app.models.schedule import Schedule
from app.models.settings import Setting
from app.views.auth import login_required

@webapp.route('/callbacks')
@login_required
def callbacks():
   hass_url = Setting.get_value(Setting.Keys.HASS_URL)
   hass_token = Setting.get_value(Setting.Keys.HASS_TOKEN)
   
   validConnection = HomeAssistant.testConnection(hass_url, hass_token)
   if not validConnection:
      flash("Valid connection to Home Assistant is required!", "error")
      return redirect(url_for('settings'))
   
   callbacks = Callback.get_callbacks()
   
   return render_template("callbacks.html", callbacks=callbacks)

@webapp.route('/create-callback')
@login_required
def create_callback():
   domain, service, entity = HomeAssistant.getInstance().get_defaults()
   
   callback = Callback("New callback", domain, service, entity)
   callback.save()
   
   flash("Callback created", "success")
   
   return redirect(url_for("callback", uuid=callback.uuid))

@webapp.route('/callback/<uuid>')
@login_required
def callback(uuid:str):
   callback = Callback.get_callback(uuid)
   domains = HomeAssistant.getInstance().get_domains()
   services = HomeAssistant.getInstance().get_services(callback.domain)
   entities = HomeAssistant.getInstance().get_entities(callback.domain)
   
   return render_template("callback.html",callback=callback, domains=domains, services=services, entities=entities)

@webapp.route('/callback/schedule/<uuid>')
@login_required
def schedule(uuid:str):
   callback = Callback.get_callback(uuid)
   schedules = Schedule.get_schedules(uuid)
   
   print(dir(schedules))
   
   return render_template("schedule.html",callback=callback, schedules=schedules)


@webapp.route('/save-callback/<uuid>', methods=['POST'])
@login_required
def save_callback(uuid:str):
   
   callback = None
   
   try:
      callback = Callback.get_callback(uuid=uuid)
   except Exception as e:
      flash("Something went wrong.", "error")
      return redirect(url_for('callbacks'))
   
   if not request.form['name']:
      flash("Name required", "error")
      return redirect(url_for('callback', uuid=callback.uuid))
   
   callback.name = request.form['name']
   callback.domain = request.form['domain']
   callback.service = request.form['service']
   callback.note = request.form['note']
   
   if 'active' in request.form and request.form['active'] == 'true':
      callback.active = True
   else:
      callback.active = False
   
   service = HomeAssistant.getInstance().get_service(callback.domain, callback.service)
   
   entity = None
   if 'entity_id' or 'target' in service.fields:
      entity = request.form['entity']
   callback.entity = entity
   
   data = request.form['data']
   data_formatted = ""
   if data:
      for line in data.split("\n"):
         if line.strip():
            keypair = line.split(":", 1)
            key = ""
            value = ""
            if len(keypair) == 2:
               key = keypair[0].strip()
               value = keypair[1].strip()
            
            if not key or not value:
               flash("Data ({}) incorrectly formatted!".format(key or value), "warning")
            elif key in ['entity_id', 'target'] or key not in service.fields:
               flash("{} ({}) not supported for this service".format(key, value), "error")
            else:
               data_formatted += "{key}: {value}\n".format(key=key, value=value)
   
   callback.data = data_formatted.rstrip()
   callback.save()   
   
   flash("Changes saved successfully", "success")
   return redirect(url_for('callback', uuid=callback.uuid))

@webapp.route('/create_schedule/<uuid>', methods=['POST'])
@login_required
def create_schedule(uuid:str):
   
   callback = None
   
   try:
      callback = Callback.get_callback(uuid=uuid)
   except Exception as e:
      flash("Something went wrong.", "error")
      return redirect(url_for('callbacks'))
   
   if not request.form['name']:
      flash("Name required", "error")
      return redirect(url_for('schedule', uuid=callback.uuid))
   
   name = request.form['name']
   startday = request.form['startday']
   starttime_str = request.form['starttime']
   endday = request.form['endday']
   endtime_str = request.form['endtime']
   
   starttime_split = starttime_str.split(":")
   starttime = time(int(starttime_split[0]), int(starttime_split[1]), 0, 0)
   
   endtime_split = endtime_str.split(":")
   endtime = time(int(endtime_split[0]), int(endtime_split[1]), 0, 0)
   
   if(startday > endday):
      flash("Start day has to be the same or earlier than end day", "error")
      return redirect(url_for('schedule', uuid=callback.uuid))
   if(startday == endday):
      if(starttime >= endtime):
         flash("Start time needs to be earlier than end time", "error")
         return redirect(url_for('schedule', uuid=callback.uuid))
   
   schedule = Schedule(name, uuid, startday, starttime, endday, endtime)
   schedule.save()
   
   flash("Schedule created", "success")
   
   return redirect(url_for('schedule', uuid=callback.uuid))

@webapp.route('/delete_schedule/<id>')
@login_required
def delete_schedule(id:int):
   
   schedule = None
   
   try:
      schedule = Schedule.get_schedule(id=id)
   except Exception as e:
      flash("Something went wrong.", "error")
      return redirect(url_for('callbacks'))
   
   uuid = schedule.callback_id
   
   schedule.delete()
   
   flash("Schedule deleted", "success")
   
   return redirect(url_for('schedule', uuid=uuid))