class main_database(Singleton):
def __init__(self):
try:
if self.loadingdone:
pass
except:
self.loadingdone = True
settings_c = settings.Settings()
self.logging = Logging()
self.data_location = settings_c.get_setting("data", "location")
PATH = os.path.dirname(os.path.abspath(__file__))
self.datafile = PATH + "/../" + self.data_location + "/main_db.pckl"
my_file = Path(self.datafile)
if not my_file.is_file():
self.logging.write("Creating database", level=1)
self.data = {
"last_saved": time.time(),
"settings": {},
"messages": []
}
self.data["settings"]["main_page"] = 0
self.data["settings"]["items_per_page"] = 0
self.data["settings"]["sensors_per_page"] = 0
self.data["settings"]["screen_timeout"] = 1
self.data["settings"]["album_timeout"] = 0
self.data["settings"]["message_timeout"] = 0
self.data["settings"]["mouse"] = 0
self.data["settings"]["screen"] = 0
self.data["settings"]["frame"] = 0
self.data["settings"]["frame_info"] = 0
self.data["settings"]["frame_td"] = 0
self.data["settings"]["frame_display_time"] = 0
self.data["settings"]["toast_timeout"] = 0
self.data["settings"]["clock_type"] = 0
self.data["settings"]["chart_period"] = 0
self.data["settings"]["first_run_messages_flag"] = False
self.data["messages"] = []
self.save_datafile()
self.data = self.load_datafile()
def load_datafile(self):
return pickle.load(open(self.datafile, "rb"))
def save_datafile(self):
self.data["last_saved"] = time.time()
self.logging.write("Saving database", level=2)
pickle.dump(self.data, open(self.datafile, "wb"))
class task_scheduler(Singleton):
def __init__(self):
try:
if self.loadingdone:
pass
except:
self.loadingdone = True
self.logging = Logging()
self.scheduled_tasks = []
self.add_task(self.logging,
"log_rotate", (time.time() + 4 * 60 * 60),
period=24 * 60 * 60)
def check_tasks(self):
self.logging.write("Checking tasks, running scheduler",
level="TRACE",
location="tasks")
cur_time = time.time()
length = len(self.scheduled_tasks)
for h in range(length):
try:
i = length - h - 1 ##reverse iteration
task = self.scheduled_tasks[i]
if cur_time > task[2]: ##task[2] == next_time
class_name = task[0].get_name()
try:
item_name = task[0].get_item().get_name()
self.logging.write("Executing task: " + class_name +
"." + task[1] + " for item: " +
item_name,
level='info',
location="tasks")
except:
self.logging.write("Executing task: " + class_name +
"." + task[1],
level='info',
location="tasks")
try:
getattr(task[0], task[1])()
except Exception as e:
self.logging.write("Processing task failed: " + str(e),
level="error",
location="tasks")
self.logging.write("Could not execute task: " +
class_name + "." + task[1],
level="error",
location="tasks")
if task[3] == 0 and task[4] == 0:
del self.scheduled_tasks[i]
elif task[3] != 0:
task[3] = task[3] - 1 ##repeat n times
task[2] = cur_time + task[
4] ## add period for next time
timestamp = datetime.datetime.fromtimestamp(
task[2]).strftime('%c')
self.logging.write("Repeating task: " + class_name +
"." + task[1] + " scheduled at " +
str(timestamp),
level=2,
location="tasks")
elif task[4] != 0:
if type(task[4]) == str:
task[2] = self.calculatenexttime(task[2], task[4])
else:
task[2] = cur_time + task[
4] ## add period for next time
timestamp = datetime.datetime.fromtimestamp(
task[2]).strftime('%c')
self.logging.write("Repeating task: " + class_name +
"." + task[1] + " scheduled at " +
str(timestamp),
level=4,
location="tasks")
else:
##delete task anyway
del self.scheduled_tasks[i]
gc.collect()
except Exception as e:
self.logging.write("Could not handle task in list: " + str(e),
level="error",
location="tasks")
def add_task(self,
class_item,
functionname,
next_time,
repeat=0,
period=0):
self.scheduled_tasks.append(
[class_item, functionname, next_time, repeat, period])
task = self.scheduled_tasks[-1]
class_name = task[0].get_name()
if type(next_time) == str:
next_time = self.calculatetimestamp(next_time)
timestamp = datetime.datetime.fromtimestamp(next_time).strftime('%c')
self.logging.write("Added task: " + class_name + "." + task[1] +
" scheduled at " + str(timestamp),
level='info',
location="tasks")
def list_tasks(self):
self.logging.write("Listing tasks: " + str(len(self.scheduled_tasks)) +
" tasks active",
level='info',
location="tasks")
tasks = []
for i in range(len(self.scheduled_tasks)):
try:
task = self.scheduled_tasks[i]
class_name = task[0].get_name()
timestamp = datetime.datetime.fromtimestamp(
task[2]).strftime('%c')
try:
item_name = task[0].get_item().get_name()
if len(item_name) > 20:
item_name = item_name[0:19]
task_string = (class_name + "." + task[1]).ljust(
25) + " for item: " + (item_name).ljust(
20) + " scheduled at: " + str(timestamp)
tasks.append([
class_name + "." + task[1],
str(timestamp), item_name
])
except:
task_string = (class_name + "." + task[1]).ljust(
56) + " scheduled at: " + str(timestamp)
tasks.append([class_name + "." + task[1], str(timestamp)])
self.logging.write(
("Task " + str(i + 1) + ": ").ljust(9) + task_string,
level='debug',
location="tasks")
except:
pass
return tasks
def delete_tasks(self):
self.logging.write("Deleting tasks: " +
str(len(self.scheduled_tasks)) + " tasks active",
level="warning",
location="tasks")
self.scheduled_tasks = []
self.add_task(self.logging,
"log_rotate", (time.time() + 4 * 60 * 60),
period=24 * 60 * 60)
def calculatetimestamp(self, next_time):
date = datetime.datetime.strptime(next_time, "%c")
return int(date.strftime("%s"))
def calculatenexttime(self, now, nexttime):
nexttime = str(nexttime).lower()
date = datetime.datetime.fromtimestamp(now)
if "year" in nexttime:
nd = date + datetime.timedelta(
years=int(nexttime[0:nexttime.find(" ")]))
if "mon" in nexttime:
nd = date + datetime.timedelta(
months=int(nexttime[0:nexttime.find(" ")]))
if "week" in nexttime:
nd = date + datetime.timedelta(
weeks=int(nexttime[0:nexttime.find(" ")]))
if "day" in nexttime:
nd = date + datetime.timedelta(
days=int(nexttime[0:nexttime.find(" ")]))
if "hour" in nexttime:
nd = date + datetime.timedelta(
hours=int(nexttime[0:nexttime.find(" ")]))
if "min" in nexttime:
nd = date + datetime.timedelta(
minutes=int(nexttime[0:nexttime.find(" ")]))
return int(nd.strftime("%s"))
def getHourMinuteTomorrow(self, hour, minute, days=1):
dtnow = datetime.datetime.now()
dt6 = None
# If today's hour is < 6 AM
if dtnow.hour < hour - 1:
dt6 = datetime.datetime(dtnow.year, dtnow.month, dtnow.day, hour,
minute, 0, 0)
# If today is past 6 AM, increment date by 1 day
else:
day = datetime.timedelta(days=days)
tomorrow = dtnow + day
dt6 = datetime.datetime(tomorrow.year, tomorrow.month,
tomorrow.day, hour, minute, 0, 0)
timestamp = time.mktime(dt6.timetuple())
return timestamp
class setting_handler(Singleton):
def __init__(self):
try:
if self.loadingdone:
pass
except:
self.loadingdone = True
self.name = "setting_handler"
self.database = main_database()
self.logging = Logging()
self.http = urllib3.PoolManager()
self.settings = {}
#self.settings["main_page"] = ["Front page", ["OpenHAB", "Weather"]]
self.settings["screen_timeout"] = [
"Screen timeout (min)", [1, 3, 5, 10, 15, 30, "off"]
]
self.settings["album_timeout"] = [
"Album timeout (hr)", [1, 3, 5, 10, 15, 30]
]
self.settings["message_timeout"] = [
"Message timeout (s)", [10, 30, 60, 120, 300]
]
self.settings["toast_timeout"] = [
"Info timeout (s)", [7, 10, 15, 20, 30]
]
self.settings["mouse"] = ["Mouse button", ["on", "off"]]
self.settings["items_per_page"] = [
"Number of items per page", [6, 8, 9, 12]
]
self.settings["sensors_per_page"] = [
"Number of sensor items per page", [6, 8, 9, 12]
]
self.settings["screen"] = ["Screen", ["on", "off"]]
self.settings["frame"] = ["Photo / Clock", ["photoframe", "clock"]]
self.settings["frame_info"] = [
"Frame Info", ["none", "load", "album", "both"]
]
self.settings["frame_td"] = [
"Frame Time/Date", ["none", "clock", "date", "both"]
]
self.settings["frame_display_time"] = [
"Photo display time",
["short", "medium", "long", "extra long"]
]
self.settings["clock_type"] = ["Clock type", ["digital", "analog"]]
self.settings["chart_period"] = [
"Default chart period",
["auto", "4 hours", "12 hours", "1 day", "3 days", "1 week"]
]
for key, item in self.settings.items():
value = self.database.data["settings"][key]
self.settings[key].append(int(value))
settings_c = Settings()
self.enable_screen_control = settings_c.get_setting(
"main", "enable_screen_control")
try:
topics = settings_c.get_setting(
"main", "mqtt_control_topic").split(",")
self.mqtt = mqtt()
for topic in topics:
self.mqtt.add_listener(topic, self,
"received_mqtt_message")
except:
self.logging.warn("Mqtt not configured for handling settings",
location="settings_handler")
if self.enable_screen_control in ["pi", "black"]:
pass
elif self.enable_screen_control == "url":
try:
self.screen_control_on_url = settings_c.get_setting(
"main", "screen_on_url")
self.screen_control_off_url = settings_c.get_setting(
"main", "screen_off_url")
self.settings["screen_control_on_url"] = [
0, 0, self.screen_control_on_url
]
self.settings["screen_control_off_url"] = [
0, 0, self.screen_control_off_url
]
except:
self.logging.error(
"Add settings 'screen_on_url' and 'screen_off_url' for external url screen control",
location="settings_handler")
self.enable_screen_control = "black"
elif self.enable_screen_control == "cmd":
try:
self.screen_control_on_cmd = settings_c.get_setting(
"main", "screen_on_cmd")
self.screen_control_off_cmd = settings_c.get_setting(
"main", "screen_off_cmd")
self.settings["screen_control_on_cmd"] = [
0, 0, self.screen_control_on_cmd
]
self.settings["screen_control_off_cmd"] = [
0, 0, self.screen_control_off_cmd
]
except:
self.logging.error(
"Add settings 'screen_on_cmd' and 'screen_off_cmd' for external command screen control",
location="settings_handler")
self.enable_screen_control = "black"
elif self.enable_screen_control != "off":
self.logging.error(
"Incorrect screen control enable settings, screen control is off",
location="settings_handler")
self.enable_screen_control = "off"
self.settings["main_enable_clock"] = [
0, 0, settings_c.get_setting("main", "enable_clock")
]
self.settings["main_enable_album"] = [
0, 0, settings_c.get_setting("main", "enable_album")
]
if settings_c.get_setting("main", "enable_album") == "0":
self.logging.warn("Album not enabled, setting frame to clock",
location="settings_handler")
self.__set_setting("frame", "clock")
elif settings_c.get_setting("main", "enable_clock") == "0":
self.logging.warn(
"clock not enabled, setting frame to photoframe",
location="settings_handler")
self.__set_setting("frame", "photoframe")
if settings_c.get_setting(
"main", "enable_clock") == "0" and settings_c.get_setting(
"main", "enable_album") == "0":
self.logging.warn(
"Album and clock not enabled, turning off screen setting",
location="settings_handler")
self.__set_setting(
"screen", "off"
) ##in this case only the screensaver determines if the screen is turned on or off
self.settings["main_screen_control"] = [
0, 0, self.enable_screen_control
]
def get_name(self):
return self.name
def setting_request(self, request):
if request[0] == "setsetting":
setting = request[1]
if setting == "screen" and self.get_setting(
"main_enable_album") == "0" and self.get_setting(
"main_enable_clock") == "0":
return [
"Enable album or clock to be able to control this setting"
]
if setting == "frame" and (
self.get_setting("main_enable_album") == "0"
or self.get_setting("main_enable_clock") == "0"):
return [
"Enable album and clock to be able to control this setting"
]
cur_value = self.settings[setting][2]
if cur_value + 1 < len(self.settings[setting][1]):
self.settings[setting][2] = cur_value + 1
else:
self.settings[setting][2] = 0
self.save_settings()
self.logging.write(
self.settings[setting][0] + ": " +
str(self.settings[setting][1][self.settings[setting][2]]),
level=2)
return [
self.settings[setting][0] + ": " +
str(self.settings[setting][1][self.settings[setting][2]])
]
elif request[0] == "getsetting":
return [str(self.get_setting(request[1]))]
def set_setting(self, setting, value):
if setting == "screen" and self.get_setting(
"main_enable_album") == "0" and self.get_setting(
"main_enable_clock") == "0":
return ["Enable album or clock to be able to control this setting"]
if setting == "frame" and (self.get_setting("main_enable_album") == "0"
or self.get_setting("main_enable_clock")
== "0"):
return [
"Enable album and clock to be able to control this setting"
]
self.__set_setting(setting, value)
def __set_setting(self, setting, value):
values = self.settings[setting][1]
self.screen_timeout_start = time.time()
for i in range(len(values)):
if values[i] == value:
self.settings[setting][2] = i
self.save_settings()
def get_settings(self):
settings = []
for key, item in self.settings.items():
if (key == "clock_type"
) and self.get_setting("main_enable_clock") == "0":
pass
elif (key == "album_timeout" or key == "frame_info"
or key == "frame_td" or key == "frame_display_time"
) and self.get_setting("main_enable_album") == "0":
pass
elif key == "frame" and (
self.get_setting("main_enable_album") == "0"
or self.get_setting("main_enable_clock") == "0"):
pass
elif key == "screen" and self.get_setting(
"main_enable_album") == "0" and self.get_setting(
"main_enable_clock") == "0":
pass
elif key == "screen" and self.enable_screen_control == "off":
pass
elif item[0] != 0:
settings.append([key, item[0], item[1][item[2]]])
return settings
def save_settings(self):
for key, item in self.settings.items():
self.database.data["settings"][key] = item[2]
self.database.save_datafile()
def get_setting(self, setting):
value = self.settings[setting][2]
if self.settings[setting][0] != 0:
return self.translate_setting(setting,
self.settings[setting][1][value])
else:
return value
def translate_setting(self, setting, value):
if setting == "frame_display_time":
timing = {
"short": 5000,
"medium": 13000,
"long": 20000,
"extra long": 60000
}
if value == 0:
return "short"
return timing[value]
elif setting == "chart_period":
period = {
"auto": "auto",
"4 hours": "4H",
"12 hours": "12H",
"1 day": "1D",
"3 days": "3D",
"1 week": "1W"
}
if value == 0:
return "auto"
return period[value]
return value
def received_mqtt_message(self, topic, payload):
try:
payload_setting = payload['setting']
for setting in self.settings:
if setting == payload_setting:
if "cmd" in topic.lower():
self.set_setting(setting, payload[setting])
self.logging.info(
"Set setting via mqtt message: %s, %s" %
(setting, payload[setting]),
location="settings_handler")
elif "state" in topic.lower():
val = self.get_setting(setting)
topic = topic[0:topic.rfind("/") + 1] + "status"
self.mqtt.publish(
topic, str({
'setting': setting,
'value': val
}))
if payload_setting == "all":
topic = topic[0:topic.rfind("/") + 1] + "status"
self.mqtt.publish(topic, str(list(self.settings.keys())))
except Exception as e:
raise Exception(e)
class message_handler(Singleton):
def __init__(self):
try:
if self.loadingdone:
pass
except:
self.loadingdone = True
self.database = main_database()
self.popupflag = False
self.popupactive = False
self.logging = Logging()
self.setting_handler = setting_handler()
self.setting_popup_timeout = self.setting_handler.get_setting(
"message_timeout")
self.page_handler = page_handler.page_handler()
self.toast_flag = False
self.toast_db = []
self.toast_message = "none"
self.toast_sender = "none"
self.toast_received = 0
self.mqtt = mqtt()
settings_c = Settings()
self.mqtt_topics = settings_c.get_setting("messaging",
"mqtt_topics").split(",")
for topic in self.mqtt_topics:
self.mqtt.add_listener(topic, self, "received_mqtt_message")
##send information messages on first run
if not self.database.data["settings"]["first_run_messages_flag"]:
self.database.data["settings"][
"first_run_messages_flag"] = True
message = "On a black screen, clock or photoframe, click on the bottom left corner to return to the main screen. "
self.database.data["messages"].append([
time.time(), "HABframe", "Return from screensaver",
message, False
])
message = "Thank you for using HABframe!"
self.database.data["messages"].append([
time.time(), "HABframe", "welcome message", message, False
])
self.database.save_datafile()
self.del_popup_flag()
def get_name(self):
return "message_handler"
def message_request(self, request, data_get):
if request[0] == "new":
try:
if "message" in data_get:
message = data_get["message"].replace("@20", "/").replace(
"%3B", ":")
else:
message = request[2].replace("@20",
"/").replace("%3B", ":")
if "sender" in data_get:
sender = data_get["sender"]
else:
sender = request[1]
if "subject" in data_get:
subject = data_get["subject"]
else:
subject = "-"
self.new_message(sender, subject, message)
return ["Message received"]
except Exception as e:
self.logging.error("Error in message: " + str(e),
location="messages")
return ["Invalid new message"]
elif request[0] == "message_popup":
i = 0
found = False
while i < len(self.database.data["messages"]) and not found:
message = self.database.data["messages"][i]
if not message[-1]:
show_message = [i] + message
#we want the last unread message
#found = True
i += 1
n_unread = self.check_amount_unread()
times = datetime.datetime.fromtimestamp(float(
show_message[1])).strftime('%a %d-%m, %H:%M')
return self.page_handler.create_popup("message", {
"id": show_message[0],
"from": show_message[2],
"time": times,
"message": show_message[4],
"subject": show_message[3],
"n_unread": n_unread
},
renew_screensaver=False)
elif request[0] == "markread_popup":
message_id = int(request[1])
self.logging.info("Marking message as read " + str(message_id),
location="messages")
self.database.data["messages"][message_id][-1] = True
self.database.save_datafile()
self.popupactive = False
self.del_popup_flag()
return ["Marked as read"]
elif request[0] == "markallread_popup":
message_id = int(request[1])
self.logging.info("Marking all messages as read ",
location="messages")
for i in range(len(self.database.data["messages"])):
self.database.data["messages"][i][-1] = True
self.database.save_datafile()
self.popupactive = False
self.del_popup_flag()
return ["Marked as read"]
elif request[0] == "message_timeout":
timeout = self.setting_handler.get_setting("message_timeout")
return [str(timeout)]
elif request[0] == "toast_timeout":
timeout = self.setting_handler.get_setting("toast_timeout")
return [str(timeout)]
elif request[0] == "delete_popup":
message_id = int(request[1])
del (self.database.data["messages"][message_id])
self.logging.info("Deleting message: " + str(message_id),
location="messages")
if len(self.database.data["messages"]) == 0:
self.database.data["messages"] = []
#self.database.data["messages"].append([time.time(), "none", "message database is empty", True])
self.database.save_datafile()
self.popupactive = False
self.del_popup_flag()
return ["Message deleted"]
elif request[0] == "deactivate_popup":
self.popupactive = False
return ["popup deactive"]
elif request[0] == "showmessage":
message_id = int(request[1])
return self.format_message(message_id=message_id)
elif request[0] == "deletemessage":
if request[1] == "all":
self.database.data["messages"] = []
#self.database.data["messages"].append([time.time(), "none", "message database is empty", True])
else:
message_id = int(request[1])
del (self.database.data["messages"][message_id])
self.logging.info("Deleting message: " + str(message_id),
location="messages")
if len(self.database.data["messages"]) == 0:
self.database.data["messages"] = []
#self.database.data["messages"].append([time.time(), "none", "message database is empty", True])
self.database.save_datafile()
return self.format_message_list(start=0)
elif request[0] == "showmessagepage":
message_id = int(request[1])
return self.format_message_list(start=message_id)
elif request[0] == "toast":
if "message" in data_get:
self.toast_message = data_get["message"].replace(
"@20", "/").replace("%3B", ":")
else:
self.toast_message = request[2].replace("@20", "/").replace(
"%3B", ":")
if "sender" in data_get:
self.toast_sender = data_get["sender"].replace("@20",
"/").replace(
"%3B", ":")
else:
self.toast_sender = request[1].replace("@20", "/").replace(
"%3B", ":")
self.logging.debug("Received new toast message from http",
location="messages")
self.new_toast()
return ["Toast received"]
elif request[0] == "get_toast":
return self.create_toast(len_max=31)
def new_message(self, sender, subject, message):
self.database.data["messages"].append(
[time.time(), sender, subject, message, False])
self.database.save_datafile()
self.del_popup_flag() ##popup flag when a popup was activated
self.logging.write("Received new message from " + sender + ": " +
message,
level="info",
location="messages")
def new_toast(self):
self.toast_received = time.time()
self.toast_db.append(
[self.toast_sender, self.toast_message,
time.time(), False, 0])
self.logging.info("Received new toast message: " + self.toast_message,
location="messages")
def create_toast(self, len_max):
toast = self.get_toast_message()
data = {
"text": toast[0],
"from": toast[1],
"len": len(toast[0]),
"max": len_max
}
return self.page_handler.create_popup("toast",
data=data,
renew_screensaver=False)
def get_messages(self):
messages = []
for i in reversed(range(len(self.database.data["messages"]))):
m = self.database.data["messages"][i]
messages.append({
"id": i,
"date": m[0],
"from": m[1],
"subject": m[2],
"message": m[3]
})
return messages
def check_amount_unread(self):
unread = 0
for message in self.database.data["messages"]:
if not message[-1]:
unread += 1
return unread
def check_unread(self):
unread = False
for message in self.database.data["messages"]:
if not message[-1]:
unread = True
return unread
def get_popup_flag(
self
): ##The popup flag is set when a new message has generated a popup
return self.popupflag
def set_popup_flag(self):
self.logging.write("Setting popup flag",
level="warn",
location="messages")
self.popupflag = True
def del_popup_flag(self): ##Only a new message can delete a popup
if self.popupflag:
self.logging.write("Removing popup flag",
level="warn",
location="messages")
self.popupflag = False
def get_popup_active(self):
if time.time(
) > self.popup_time_activated + self.setting_popup_timeout + 1: ##seconds
return False
else:
return True
def set_popup_active(self, state):
self.popup_time_activated = time.time()
def check_toast(self):
#print("=========================, checking toast")
timeout = self.setting_handler.get_setting("toast_timeout")
new_toast = False
last_toast_send = 0
for i in range(len(self.toast_db)):
if self.toast_db[i][3]:
last_toast_send = self.toast_db[i][4]
if self.toast_db[i][2] < time.time() - 600:
self.toast_db[i][3] = True
if not self.toast_db[i][3]:
new_toast = True
if len(self.toast_db) > 50:
del self.toast_db[0:25]
if self.toast_received > time.time(
) - 600 and new_toast and last_toast_send < time.time() - timeout - 3:
return True
else:
return False
def get_toast_message(self):
##return the first unread toast message
for i in range(len(self.toast_db)):
if not self.toast_db[i][3]: ##toast is unread
self.toast_db[i][3] = True
self.toast_db[i][4] = time.time()
self.logging.write("Sending toast message: " +
self.toast_db[i][0] + " / " +
self.toast_db[i][1],
level=2,
location="messages")
return [self.toast_db[i][1], self.toast_db[i][0]]
self.logging.write("No unread toast message, sending last one: " +
self.toast_message + " / " + self.toast_sender,
level="warning",
location="messages")
return [self.toast_message, self.toast_sender]
def format_message_list(self, start=0):
messages = self.get_messages()
page_data = {"next_page": False, "prev_page": False, "messages": []}
try:
start_page = int(start)
except:
start_page = 0
if start_page == 0:
start_message = 0
stop_message = 6
else:
page_data["prev_page"] = start_page
start_message = start_page * 5 + 1
stop_message = start_page * 5 + 6
n_messages = len(messages)
if stop_message >= n_messages:
stop_message = n_messages
else:
page_data["next_page"] = start_page + 1
for i in range(start_message, stop_message):
messages[i]["date"] = datetime.datetime.fromtimestamp(
messages[i]["date"]).strftime('%a %d-%m, %H:%M')
page_data["messages"].append(messages[i])
return render_template("message_list.html", data=page_data)
def format_message(self, message_id=0):
messages = self.get_messages()
if message_id == -1:
message_id = len(messages) - 1
if len(messages) > 0:
for m in messages:
if m["id"] == message_id:
message = m
message["date"] = datetime.datetime.fromtimestamp(
message["date"]).strftime('%a %d-%m, %H:%M')
else:
message = {"date": "", "message": "No messages", "from": ""}
if len(messages) > 0 and message["subject"] == "-":
message["subject"] = message["date"]
return render_template("message.html", data=message)
def received_mqtt_message(self, topic, payload):
try:
message = payload['message']
if "message" in topic.lower():
t = "message"
elif "toast" in topic.lower():
t = "toast"
else:
try:
t = payload['type']
except:
t = 'message'
try:
sender = payload['sender']
except:
sender = "unknown"
if t == "message":
subject = payload['subject']
self.new_message(sender, subject, message)
else:
self.toast_sender = sender
self.toast_message = message
self.new_toast()
except Exception as e:
raise Exception(e)
class page_handler():
def __init__(self):
self.openhab = pf_openhab()
self.name = "page_handler"
self.database = main_database()
self.setting_handler = setting_handler()
self.message_handler = message_handler()
self.widgets_handler = widgets_handler()
self.state_handler = state_handler()
self.logging = Logging()
settings_c = Settings()
self.host = settings_c.get_setting("main", "hostname")
self.port = settings_c.get_setting("main", "port")
self.enable_screen_control = settings_c.get_setting(
"main", "enable_screen_control")
self.openhab_host = settings_c.get_setting("main", "openhab_ip")
self.openhab_port = settings_c.get_setting("main", "openhab_port")
def get_page(self, request):
pagelist = request["page"]
dataget = request["data_get"]
page = []
lowerpage = [0]
if len(pagelist) > 3:
lowerpage = pagelist[3:]
subsubpage = pagelist[2]
subpage = pagelist[1]
elif len(pagelist) > 2:
subsubpage = pagelist[2]
subpage = pagelist[1]
elif len(pagelist) > 1:
subpage = pagelist[1]
subsubpage = "none"
else:
subsubpage = "none"
subpage = "none"
pagename = pagelist[0]
if pagename == "main":
self.logging.info("Loading main page: " + subpage + "/" +
subsubpage,
location=self.name)
if self.message_handler.get_popup_flag() and subpage != "reload":
self.message_handler.del_popup_flag()
self.state_handler.toggle_screen(state=True)
self.state_handler.refresh_screensaver()
return self.create_main_page()
elif pagename == "maindiv":
self.logging.info("Loading main div: " + subpage + "/" +
subsubpage,
location=self.name)
##turn on screen
if subpage != "screensaver":
self.state_handler.toggle_screen(state=True)
if not "reload" in pagelist and not "screensaver" in pagelist:
##enable popup of message when there is a new message
self.message_handler.del_popup_flag()
self.state_handler.refresh_screensaver()
if subpage not in [
"none", "popup", "", "reload", "screensaver"
]:
self.state_handler.refresh_screensaver_subpage()
else:
self.logging.info("Not refreshing screensaver",
location=self.name)
if subpage in ["none", "popup", "", "reload", "screensaver"]:
return self.create_main_div()
elif subpage == "settings":
return self.create_settings_page(subpage=subsubpage)
elif subpage == "messages":
return self.create_messages_page()
else:
if subsubpage == "reload":
subsubpage = 0
if lowerpage[0] == "reload":
lowerpage = [0]
return self.create_subpage(subpage, subsubpage, lowerpage[0])
elif pagename == "menuwidget":
self.logging.write("Loading menu widget: " + subpage + "/" +
subsubpage,
level=2,
location=self.name)
if not "reload" in pagelist and not "screensaver" in pagelist:
self.state_handler.toggle_screen(state=True)
self.state_handler.refresh_screensaver_subpage()
try:
widget, title = self.widgets_handler.create_mainpage_popup(
subpage, lowerpage[0], True)
except:
widget = "gotomain"
title = "none"
page_format = {"title": title}
page = render_template("subpage_widget.html", data=page_format)
page = page.replace("[[WIDGET]]", widget)
if (str(lowerpage) != "0"
and str(lowerpage)[0:2] != "m_") and subpage not in [
"none", "items_left", "items_right"
]:
d = self.openhab.get_items(subpage)
pos = 0
for i in range(len(d[0])):
b = d[0][i]
if b["type"] == "Frame" and b["label"] == lowerpage[0]:
pos = i
N_items_pp, sensor_page = self._getNitemsPP(d[1], False)
rb = "%s/%d" % (subpage, int(pos / N_items_pp))
else:
rb = False
page = self.add_bottom_bar(page, rb)
if widget == "widget not in sitemap":
return "widget not in sitemap"
elif widget == "gotomain":
return widget
else:
return page
elif pagename == "popup": ##this is a popup widget
self.logging.write("Loading popup div: " + subpage + "/" +
subsubpage,
level=2,
location=self.name)
if not "reload" in pagelist and not "screensaver" in pagelist:
self.state_handler.toggle_screen(state=True)
self.state_handler.refresh_screensaver_subpage()
page = self.widgets_handler.create_mainpage_popup(
subpage, subsubpage)
if page == "generic_button_page":
return self.create_subpage(subpage, 0, subsubpage, True)
elif page == "widget not in sitemap":
return "widget not in sitemap"
else:
return page
elif pagename in ["clock", "black"]:
cl = self.setting_handler.get_setting("clock_type")
return render_template("clock.html", data={"type_clock": cl})
elif pagename == "clk_widget":
return self.get_clock_page_widget()
elif pagename == "photoframe":
return self.create_photoframe()
pagestr = ""
for i in range(len(page)):
pagestr = pagestr + page[i] + "\n"
return pagestr
def read_file(self, filename):
PATH = os.path.dirname(os.path.abspath(__file__))
with open(PATH + "/../" + filename) as f:
content = f.readlines()
content = [x.strip() for x in content]
return content
def create_main_page(self):
page_data = {}
page_data["host"] = [self.host, self.port]
settings_c = Settings()
page_data["mouse"] = self.setting_handler.get_setting("mouse")
page_data["event_reload"] = settings_c.get_setting(
"page", "event_check_reload")
page_data["page_reload"] = settings_c.get_setting(
"page", "page_reload")
page_data["enable_album"] = settings_c.get_setting(
"main", "enable_album")
if settings_c.get_setting("main", "enable_album") == "1":
page_data["album_display_time"] = self.setting_handler.get_setting(
"frame_display_time")
return render_template("main.html", data=page_data)
def get_clock_page_widget(self):
ml = self.openhab.get_items("clock_page")[0]
data = []
if len(ml) > 0:
itemdata = ml[0]
itemdata.update({"onclick": ""})
itemtype = self.widgets_handler.check_widget_type(
itemdata["label"])
if itemtype[0:6] == "widget": ##special item takes 3 rows
data.append(itemdata)
data[-1]["group"] = itemtype[7:8] + "rows"
data[-1]["label_c"] = itemdata["label"]
data[-1]["label"] = self.widgets_handler.get_widget_label(
itemdata["label"]).upper()
if len(data) > 0:
item = data[0]
page = self.widgets_handler.render_widget("clock_page",
item["label_c"])
return page
return ""
def create_main_div(self):
ml = self.openhab.get_items("items_left")[0]
page_data_ml = self.format_items_frontpage("items_left", ml)
main_left = render_template("maindiv_half.html", data=page_data_ml)
mr = self.openhab.get_items("items_right")[0]
page_data_mr = self.format_items_frontpage("items_right", mr)
main_right = render_template("maindiv_half.html", data=page_data_mr)
page_data = {}
page_data["bottom"] = self.openhab.get_pages("b_")
page = render_template("maindiv.html", data=page_data)
page = page.replace("[[MAINLEFT]]", main_left)
page = page.replace("[[MAINRIGHT]]", main_right)
for item in page_data_ml:
if item["group"][1:] == "rows":
page = page.replace(
"[[%s]]" % item["label"].upper(),
self.widgets_handler.render_widget("items_left",
item["label_c"]))
for item in page_data_mr:
if item["group"][1:] == "rows":
page = page.replace(
"[[%s]]" % item["label"].upper(),
self.widgets_handler.render_widget("items_right",
item["label_c"]))
return self.add_bottom_bar(page)
def format_items_frontpage(self, name, itemdata):
while len(itemdata) < 10:
itemdata.append({
"label": "",
"state": "",
"type": "text",
"id": "",
"icon": "static/pictures/black.png"
})
data = []
row = 1
item = 0
while row < 6:
itemdata[item].update({"onclick": ""})
itemtype = self.widgets_handler.check_widget_type(
itemdata[item]["label"])
if itemtype == "menu_button": ##this is a menu button
itemdata[item].update({
"onclick":
"reload_main_div('page/maindiv/" + name + "/0/" +
itemdata[item]["label"] + "')"
})
data.append(itemdata[item])
data[-1]["group"] = "menu_popup"
data[-1]["label"] = self.widgets_handler.get_widget_label(
itemdata[item]["label"])
if data[-1]["state"] != "":
data[-1]["label"] = data[-1]["state"]
item += 1
data[-1]["fontsize"] = self.determine_text_size(
data[-1]["label"], max_len=13, start_font="xlargefont")
elif itemtype == "widget_subpage": ##this is a menu button
itemdata[item].update({
"onclick":
"reload_main_div('/page/menuwidget/" + name + "/0/" +
itemdata[item]["label"] + "')"
})
data.append(itemdata[item])
data[-1]["group"] = "menu_popup"
data[-1]["label"] = self.widgets_handler.get_widget_label(
itemdata[item]["label"])
if data[-1]["state"] != "":
data[-1]["label"] = data[-1]["state"]
item += 1
data[-1]["fontsize"] = self.determine_text_size(
data[-1]["label"], max_len=13, start_font="xlargefont")
elif itemtype == "menu_popup" or itemtype == "widget_popup": ##this is a menu button
itemdata[item].update({
"onclick":
"frontpage_action('" + name + "', '" +
itemdata[item]["label"] + "')"
})
data.append(itemdata[item])
data[-1]["group"] = "menu_popup"
data[-1]["label"] = self.widgets_handler.get_widget_label(
itemdata[item]["label"])
if data[-1]["state"] != "":
data[-1]["label"] = data[-1]["state"]
item += 1
data[-1]["fontsize"] = self.determine_text_size(
data[-1]["label"], max_len=13, start_font="xlargefont")
elif itemtype[0:6] == "widget" and row < 6 - int(
itemtype[7:8]) + 1: ##special item takes 3 rows
data.append(itemdata[item])
data[-1]["group"] = itemtype[7:8] + "rows"
data[-1]["label_c"] = itemdata[item]["label"]
data[-1]["label"] = self.widgets_handler.get_widget_label(
itemdata[item]["label"]).upper()
item += 1
row += int(itemtype[7:8]) - 1
elif itemtype[0:6] == "widget": ## skip this item
item += 1
row -= 1
else:
col = 0
data.append({"data": [0, 0], "group": "cols"})
while col < 2:
itemtype = self.widgets_handler.check_widget_type(
itemdata[item]["label"])
if itemdata[item]["type"] == "Text":
data[-1]["data"][col] = itemdata[item]
data[-1]["data"][col]["group"] = "text"
item += 1
elif itemtype in ["menu_button", "menu_popup"] or itemtype[
0:
6] == "widget": ##two columns needed for this type
data[-1]["data"][col] = {
"label": "",
"state": "",
"type": "text"
}
data[-1]["data"][col]["group"] = "empty"
else:
itemdata[item].update({
"onclick":
"item_action('" + itemdata[item]["type"] + "', '" +
itemdata[item]["id"] + "', 'main')"
})
data[-1]["data"][col] = itemdata[item]
data[-1]["data"][col]["group"] = "popup"
item += 1
col += 1
if data[-1]["data"][1]["group"] != "empty":
if data[-1]["data"][1]["label"] == "" or (
data[-1]["data"][1]["label"] == "Empty"
and data[-1]["data"][1]["state"] == "Empty"):
d = data[-1]["data"][0]
d.update({"group": "wide_text"})
data[-1] = d
data[-1]["fontsize"] = self.determine_text_size(
data[-1]["state"], max_len=16)
else:
for i in [0, 1]:
data[-1]["data"][i][
"fontsize"] = self.determine_text_size(
data[-1]["data"][i]["state"])
else:
d = data[-1]["data"][0]
d.update({"group": "wide_text"})
data[-1] = d
data[-1]["fontsize"] = self.determine_text_size(
data[-1]["state"], max_len=16)
row += 1
return data
def create_subpage(self,
page,
subpage=0,
lowerpage=0,
handle_as_popup=False):
data = self.openhab.get_items(page, lowerpage)
if subpage == "none":
subpage = 0
else:
subpage = int(subpage)
items = data[0]
page_data = data[1]
#print(page_data[0], self.widgets_handler.get_widget_label(page_data[0]))
N_items_pp, sensor_page = self._getNitemsPP(page_data, handle_as_popup)
page_format = self.__get_page_data__(len(items),
N_items_pp,
sensor_page=sensor_page)
page_format.update({
"title":
self.widgets_handler.get_widget_label(page_data[0]),
"returnbutton":
False,
"linkback":
"",
"linknext":
"",
"showbacknext":
True
})
if handle_as_popup:
sensor_page = False
page_format["showbacknext"] = False
if str(lowerpage) != "0" and str(lowerpage)[0:2] != "m_":
d = self.openhab.get_items(page)
pos = 0
for i in range(len(d[0])):
b = d[0][i]
if b["type"] == "Frame" and b["label"] == lowerpage:
pos = i
page_format["returnbutton"] = "%s/%d" % (page, int(
pos / N_items_pp))
if subpage != 0:
page_format["linkback"] = str(page) + "/" + str(
int(subpage) - 1) + "/" + str(lowerpage)
if subpage < page_format["n_pages"] - 1:
page_format["linknext"] = str(page) + "/" + str(
int(subpage) + 1) + "/" + str(lowerpage)
offset = subpage * N_items_pp
page = render_template("subpage.html", data=page_format)
n = 0
##iterator
for row in range(page_format["n_rows"]):
for col in range(page_format["n_cols"]):
if n + offset < len(items) and (
items[n + offset]["name"] != "Empty"
and items[n + offset]["state"] != "Empty"
and items[n + offset]["label"] != "Empty"):
button = self.create_item_button(items[n + offset],
page_format["small_icon"],
sensor_page)
else:
button = ""
page = page.replace("[[button_" + str(n) + "]]", button)
n += 1
if handle_as_popup:
page += render_template("popups/generic.html")
return page
else:
return self.add_bottom_bar(
page, returnbutton=page_format["returnbutton"])
def create_settings_page(self, subpage=0):
settings = sorted(self.setting_handler.get_settings())
n = {'linkback': "", 'linknext': "", 'n': len(settings)}
try:
subpage = int(subpage)
except:
subpage = 0
if subpage != 0:
n["linkback"] = subpage - 1
if subpage < np.ceil(len(settings) / 12) - 1:
n["linknext"] = subpage + 1
if subpage != 0:
settings = settings[12 * subpage:]
n['n'] = len(settings)
return self.add_bottom_bar(
render_template("settings.html", data=settings, n=n))
def create_messages_page(self, start=0):
page = render_template("messages.html")
page = page.replace(
"[[LIST]]", self.message_handler.format_message_list(start=start))
page = page.replace("[[MESSAGE]]",
self.message_handler.format_message(message_id=-1))
return self.add_bottom_bar(page)
def add_bottom_bar(self, page, returnbutton=False):
pages = self.openhab.get_pages(["m_", "a_", "b_", "c_"])
for i in range(len(pages)):
pages[i]["type"] = self.widgets_handler.check_widget_type(
pages[i]["label"])
page_format = {"bottom": pages}
page_format["returnbutton"] = returnbutton
page_format["habpanel_link"] = Settings().get_setting(
"main", "habpanel_link")
page += "\n\n\n"
page += render_template("bottombar.html", data=page_format)
return page
def __get_page_data__(self, n_items, n_perpage, sensor_page=False):
n_page = np.ceil(n_items / n_perpage)
small_icon = False
page_format = {
"n_pages": n_page,
"n_rows": 2,
"n_cols": 3,
"row_height": "50",
"col_width": "33",
"small_icon": False
}
if n_perpage == 8 and not sensor_page:
page_format.update({
"n_rows": 4,
"n_cols": 2,
"row_height": "25",
"col_width": "50",
"small_icon": True
})
elif n_perpage == 8 and sensor_page:
page_format.update({
"n_rows": 2,
"n_cols": 4,
"row_height": "50",
"col_width": "25"
})
elif n_perpage == 9:
page_format.update({
"n_rows": 3,
"n_cols": 3,
"row_height": "33",
"col_width": "33"
})
elif n_perpage == 12:
page_format.update({
"n_rows": 4,
"n_cols": 3,
"row_height": "25",
"col_width": "33"
})
return page_format
def create_item_button(self,
item_info,
small_icon=False,
sensor_button=False,
header=True):
if not sensor_button:
N_items_pp = self.setting_handler.get_setting("items_per_page")
button_width = int(
self.__get_page_data__(1, N_items_pp,
sensor_button)["col_width"])
else:
N_items_pp = self.setting_handler.get_setting("sensors_per_page")
button_width = int(
float(
self.__get_page_data__(1, N_items_pp,
sensor_button)["col_width"]) * 1.2)
data = {
"icon": item_info["icon"],
"icon_width": 90,
"icon_height": 60,
"action_id": item_info["id"],
"header": header
}
if small_icon:
data.update({"icon_width": 70, "icon_height": 70})
data.update({
"onclick":
"item_action('" + item_info["type"] + "', '" + item_info["id"] +
"')"
})
itemtype = self.widgets_handler.check_widget_type(item_info["label"])
if item_info["type"] == "Frame" and (
itemtype != "widget_subpage") and (
itemtype == "widget_popup" or itemtype[0:6] == "widget"):
data.update({
"onclick":
"frontpage_action('" + str(item_info["page"]) + "', '" +
item_info["label"] + "')"
})
data["text"] = self.widgets_handler.get_widget_label(
item_info["name"])
data["text_width"] = 80
elif item_info["type"] == "Frame" and (itemtype == "widget_subpage"):
data.update({
"onclick":
"reload_main_div('/page/menuwidget/" + str(item_info["page"]) +
"/0/" + str(item_info["subpage"]) + "')"
})
data["text"] = self.widgets_handler.get_widget_label(
item_info["name"])
data["text_width"] = 80
elif item_info["type"] == "Frame":
data.update({
"onclick":
"reload_main_div('/page/maindiv/" + str(item_info["page"]) +
"/0/" + str(item_info["subpage"]) + "')",
"text_width":
80
})
data.update(
self.format_item_string(item_info["label"], item_info["state"],
button_width))
if data["state"] != '':
data.update({"type": "state"})
elif item_info["type"] == "Switch":
data.update({
"text":
self.format_string(item_info["label"],
int(20 * (button_width / 100))),
"state":
item_info["state"].lower(),
"text_width":
60,
"state_width":
20
})
data.update({"type": "switch"})
elif item_info["type"] == "Switch_single":
data.update({
"text":
self.format_string(item_info["label"],
int(20 * (button_width / 100))),
"state":
item_info["state"].lower(),
"text_width":
60,
"state_width":
20
})
elif item_info["type"] == "Colorpicker": ##openhab item type
data.update({
"text":
self.format_string(item_info["label"],
int(20 * (button_width / 100))),
"state":
item_info["state"],
"text_width":
60,
"state_width":
20
})
data.update({"type": "Colorpicker"})
else:
data.update(
self.format_item_string(item_info["label"], item_info["state"],
button_width))
data.update({"type": "state"})
if sensor_button:
data.update({
"text_width": 70,
"state_width": 70,
"icon_width": 80
})
page = render_template("buttons/sensor.html", data=data)
else:
page = render_template("buttons/button.html", data=data)
return page
def create_popup(self, type, data, renew_screensaver=True):
if renew_screensaver:
self.state_handler.refresh_screensaver_subpage()
page = render_template("popups/" + type + ".html", data=data)
return page
def create_photoframe(self):
td = self.setting_handler.get_setting("frame_td")
info = self.setting_handler.get_setting("frame_info")
page_data = {
"time": "none",
"date": "none",
"load": "none",
"album": "none"
}
if td == "clock" or td == "both":
page_data["time"] = ""
if td == "date" or td == "both":
page_data["date"] = ""
if info == "load" or info == "both":
page_data["load"] = ""
if info == "album" or info == "both":
page_data["album"] = ""
return render_template("album.html", data=page_data)
def format_item_string(self, text, state, button_width=50):
if text == "_":
return {
"text":
self.format_string(state,
width=int(54 * (button_width / 100))),
"state":
"",
"text_width":
80,
"state_width":
0
}
elif state == "" and len(text) < 25:
return {
"text": text,
"state": "",
"text_width": 80,
"state_width": 0
}
elif state == "":
return {
"text":
self.format_string(text, width=int(32 * (button_width / 100))),
"state":
"",
"text_width":
80,
"state_width":
0
}
elif len(text) < 13 and len(state) > 7:
return {
"text":
text,
"state":
self.format_string(state,
width=int(26 * (button_width / 100))),
"text_width":
40,
"state_width":
40
}
elif len(text) > 20 and len(state) > 20:
return {
"text":
self.format_string(text, width=int(26 * (button_width / 100))),
"state":
self.format_string(state,
width=int(26 * (button_width / 100))),
"text_width":
40,
"state_width":
40
}
else:
return {
"text":
self.format_string(text, width=int(38 * (button_width / 100))),
"state":
self.format_string(state,
width=int(14 * (button_width / 100))),
"text_width":
40,
"state_width":
40
}
def format_string(self, string, width=27):
position = 0
for i in range(3):
if len(string[position:]) > width:
a = self.find(string[position:], " ")
found = False
for pos in range(len(a)):
val = a[len(a) - pos - 1]
if val < 27 and not found:
string = string[0:position +
val] + "<br>" + string[position + val +
1:]
position = val + position + 4
found = True
return Markup(string)
def find(self, s, ch):
return [i for i, ltr in enumerate(s) if ltr == ch]
def determine_text_size(self, text, max_len=7, start_font="largefont"):
if text == text.upper():
max_len -= 1
if start_font == "largefont":
if len(text) < max_len + 1:
return "largefont"
else:
return "smallfont"
else:
if len(text) < max_len + 1:
return "xlargefont"
else:
return "smallfont"
def _getNitemsPP(self, page_data, handle_as_popup):
if page_data[1] != "temperature" and page_data[
1] != "temp" and page_data[0].find("sensor") == -1:
N_items_pp = self.setting_handler.get_setting("items_per_page")
sensor_page = False
else:
N_items_pp = self.setting_handler.get_setting("sensors_per_page")
if N_items_pp == 12:
sensor_page = False
else:
sensor_page = True
if handle_as_popup:
N_items_pp = self.setting_handler.get_setting("items_per_page")
if int(N_items_pp) < 9:
N_items_pp = 6
else:
N_items_pp = 9
return N_items_pp, sensor_page
#get the output from the remainlist.txt file and use the outputlist as input
'''if we want to use split methods, edit this part'''
#CHANGE BELOW
'''df_remains = pd.read_csv('remainlist.csv')
inputcsvs_all = df_remains.remainlist.tolist()
totalnum = len(inputcsvs_all)
splitnum = int(totalnum/4)
inputcsvs = inputcsvs_all[ : splitnum]'''
#inputcsvs_full = glob.glob(inputParameters.read_directory+'*.csv')
#inputcsvs = [file.split('/')[-1] for file in inputcsvs_full]
#CHANGE ABOVE
totalnum = 1
inputcsvs = ['163610_163610_ice_markets_2016-02-01_2016-02-29.csv']
totalnum = len(inputcsvs)
print('Total csv will be processed: {}'.format(totalnum))
Logger.write('Total csv will be processed: {}'.format(len(inputcsvs)))
Logger.write_separator(2)
#process all the csv step by step
counter = 0
for inputfilename in inputcsvs:
counter += 1
print(str(counter) + '/' + str(totalnum))
print(inputfilename + '..is being processed')
Logger.write(str(counter) + '/' + str(totalnum))
Logger.write(inputfilename + '..is being processed')
try:
#print(inputParameters.read_directory)
#print(inputfilename)
###read in file
try:
class state_handler(Singleton):
def __init__(self):
try:
if self.loadingdone:
pass
except:
self.loadingdone = True
self.openhab = pf_openhab()
self.name = "state_handler"
self.database = main_database()
self.setting_handler = setting_handler()
self.message_handler = message_handler()
self.logging = Logging()
settings_c = Settings()
self.host = settings_c.get_setting("main", "hostname")
self.port = settings_c.get_setting("main", "port")
self.http = urllib3.PoolManager()
self.timeouts = {}
self.update_timeout("screensaver", 60)
self.update_timeout("message", -1)
self.screentrigger = 0
self.screen_state = True
try:
self.im_size = settings_c.get_setting("album", "image_size")
self.album_url = settings_c.get_setting("album", "random_picture_url")
except Exception as e:
self.logging.error("Invalid album settings: " + str(e), location=self.name)
self.album_url = "none"
try:
self.album_info_url = settings_c.get_setting("album", "picture_info_url")
if self.album_info_url == None:
raise Exception("No data")
except:
self.logging.warn("No album info url", location=self.name)
self.album_info_url = "none"
def state_request(self, request):
action = request[0]
if len(request) > 1:
item = request[1]
##handle a button press per type of item:
#print(item)
if action == "photoframe":
if item == "frame":
ans = self.setting_handler.set_setting("frame", request[2])
if ans != None:
return ans[0]
return "Setting saved"
elif item == "screen":
ans = self.setting_handler.set_setting("screen", request[2])
if ans != None:
return ans[0]
return "Setting saved"
elif item == "trigger":
self.screentrigger = time.time()
self.refresh_screensaver()
self.logging.info("Triggered frame on externally", location=self.name)
return "Screen triggered"
else:
return "none_none"
elif action == "icon":
icon = self.openhab.get_icon(item)
return ["jpg", icon]
elif action == "picture":
try:
if item == "new" and self.album_url != "none":
response = requests.get(self.album_url)
with Image.open(BytesIO(response.content)) as image:
imgByteArr = BytesIO()
cover = Image.Image.resize(image, [int(self.im_size.split("x")[0]), int(self.im_size.split("x")[1])])
cover.save(imgByteArr, image.format)
return ["jpg", imgByteArr.getvalue()]
elif item == "info" and self.album_info_url != "none" and self.album_info_url != "":
content = self.http.request('GET', self.album_info_url)
return content.data.decode("utf-8")
elif item == "info":
return "no album info"
except Exception as e:
self.logging.error("Error occured in processing picture for album %s" %e, location=self.name)
return "error"
def state_check(self, request):
page = []
main_page = request[0]
subpage = "none"
if len(request) > 1:
subpage = request[1]
## get used settings
setting_album_timeout = self.setting_handler.get_setting("album_timeout") ##not used
setting_popup_timeout = self.setting_handler.get_setting("message_timeout")
setting_screen_user = self.setting_handler.get_setting("screen") ##screen on or off
main_setting_screen_control = self.setting_handler.get_setting("main_screen_control")
current_screen_state = self.get_screen_state()
screensaver_page = self.get_screensaver_page()
desired_screen_state = "off"
desired_page = "unchanged"
##reset old screen trigger
if self.screentrigger != 0 and time.time() > self.screentrigger + 5*60:
self.screentrigger = 0
##calculate desired screen state (on / off) ##switching is done depending on configuration
if main_page in ["main", "settings", "messages"]:
if self.check_timeout("screensaver") and setting_screen_user == "off":
desired_screen_state = "off"
else:
desired_screen_state = "on"
elif main_page in ["photoframe", "clock", "black"]:
desired_screen_state = setting_screen_user
## check desired screen state for messages
self.logging.debug("Unread messages: %s" %(str(self.message_handler.check_unread())), location=self.name)
self.logging.debug("Popup flag: %s" %(str(self.message_handler.get_popup_flag())), location=self.name)
if self.message_handler.check_unread() and not self.message_handler.get_popup_flag():
self.message_handler.set_popup_active(True)
self.message_handler.set_popup_flag()
self.logging.info("responding new message", location=self.name)
desired_screen_state = "on"
new_message = True ###turn on screen and make popup
elif not self.check_timeout("message"):
desired_screen_state = "on" ##keep screen on for message
new_message = False
else:
new_message = False
##calculate desired page (main, black, album or clock) ##switching is done depending on configuration
if main_page in ["main", "settings", "messages"]:
if self.check_timeout("screensaver") and setting_screen_user == "on" and screensaver_page != "main":
desired_page = screensaver_page
elif main_page == "photoframe" and screensaver_page != "album":
desired_page = screensaver_page
elif main_page == "clock" and screensaver_page != "clock":
desired_page = screensaver_page
elif main_page == "black" and setting_screen_user == "on":
desired_page = screensaver_page
self.logging.debug("Show new messages: %s" %(str(new_message)), location=self.name)
self.logging.debug("Screensaver page: %s" %(screensaver_page), location=self.name)
self.logging.debug("Desired page: %s, desired_screen_state: %s" %(desired_page, desired_screen_state), location=self.name)
self.logging.debug("Message timeout: %s, Subpage timeout: %s" %(self.check_timeout("message"), self.check_timeout("screensaver_subpage")), location=self.name)
## switch screen off is desired state is off
if desired_screen_state == "off" and main_setting_screen_control != "off" and current_screen_state: ##=="on"
return self.switch_off_screen(main_setting_screen_control)
elif desired_screen_state == "off" and current_screen_state: ##=="on"
link = self.get_desired_page_link("clock")
return [link]
elif self.screentrigger != 0:
self.toggle_screen(state = True)
self.screentrigger = 0
self.refresh_screensaver()
self.logging.info("turn on screen for trigger", location=self.name)
return ["close_return_main"]
##actions when we want the screen on
elif new_message:
if not current_screen_state:
self.toggle_screen(state = "on") ##no need for a page change
self.update_timeout("message", self.setting_handler.get_setting("message_timeout") + 2) ##in seconds
return ["new_message"]
elif self.message_handler.check_toast(): ##even if the screen is off
self.logging.write("responding new toast message", level=2, location="item_handle")
return ["new_toast"]
elif desired_screen_state == "on" and desired_page != "unchanged" and self.check_timeout("message"): ##except when there is a message popup
self.toggle_screen(state = setting_screen_user)
link = self.get_desired_page_link(desired_page)
return [link]
elif self.check_timeout("screensaver_subpage") and self.check_timeout("message") and main_page not in ["photoframe", "clock"]: ##except when there is a message popup
self.delete_timeout("screensaver_subpage")
return ["close_return_main"]
elif self.check_timeout("screensaver_subpage") and self.check_timeout("message"):
self.delete_timeout("screensaver_subpage")
##if for some reason it end here;
return ["no_actionHERE"]
def switch_off_screen(self, main_setting_screen_control):
self.toggle_screen(state = "off")
if main_setting_screen_control == "black":
link = self.get_desired_page_link("black")
return [link]
else:
link = self.get_desired_page_link("main")
return [link]
def get_screensaver_page(self):
enable_clock = self.setting_handler.get_setting("main_enable_clock")
enable_album = self.setting_handler.get_setting("main_enable_album")
setting_album_clock = self.setting_handler.get_setting("frame") ##photoframe or clock when screen is on
if enable_album == "1" and setting_album_clock == "photoframe":
return "album"
elif enable_clock == "1" and setting_album_clock == "clock":
return "clock"
else:
return "main"
def get_desired_page_link(self, page):
if page == "album":
self.logging.info("http://"+self.host+":"+self.port+"/page/photoframe", location=self.name)
return "http://"+self.host+":"+self.port+"/page/photoframe"
elif page == "clock":
type_clock = self.setting_handler.get_setting("clock_type")
self.logging.info("http://"+self.host+":"+self.port+"/page/clock/"+type_clock, location=self.name)
return "http://"+self.host+":"+self.port+"/page/clock/"+type_clock
elif page == "main":
main_setting_screen_control = self.setting_handler.enable_screen_control
self.logging.info("External screen control: %s, no action, stay on main page" %main_setting_screen_control, location=self.name)
return "http://"+self.host+":"+self.port+"/page/maindiv/screensaver"
elif page == "black":
self.logging.write("http://"+self.host+":"+self.port+"/black", level=2)
return "http://"+self.host+":"+self.port+"/page/black"
def update_timeout(self, name, delta): ##delta in seconds
self.timeouts[name] = time.time() + delta
def check_timeout(self, name):
if name in self.timeouts:
self.logging.debug(("Timeout %s: "%name).ljust(30) + str(time.ctime(int(self.timeouts[name]))), location=self.name)
if self.timeouts[name] < time.time():
return True
else:
return False
else:
return False
def delete_timeout(self, name):
if name in self.timeouts:
del self.timeouts[name]
else:
self.logging.debug("Timeout %s not deleted, not existing" %name, location=self.name)
def refresh_screensaver(self):
to = self.setting_handler.get_setting("screen_timeout")
if to == "off":
to = 24*60*300
self.logging.info("refreshing screensaver", location=self.name)
self.update_timeout("screensaver", int(to)*60)
self.delete_timeout("screensaver_subpage")
def refresh_screensaver_subpage(self):
self.refresh_screensaver()
self.logging.info("refreshing screensaver for popup", location=self.name)
self.update_timeout("screensaver_subpage", 25)
def toggle_screen(self, state = True):
screen_control = self.setting_handler.get_setting("main_screen_control")
switch = False
if str(self.screen_state) != str(state):
self.logging.info("Switching screen state: %s, %s" %(str(self.screen_state), str(state)), location=self.name)
else:
self.logging.debug("Switching screen state: %s, %s" %(str(self.screen_state), str(state)), location=self.name)
if (state == "off" or state == "0" or state == False) and self.get_screen_state() == True:
state = False
self.screen_state = False
switch = True
elif (state == "on" or state == "1" or state == True) and self.get_screen_state() == False:
state = True
self.screen_state = True
switch = True
if screen_control == "pi":
if not state:
self.logging.write("Turn off screen", level=2)
cmd = "echo 1 > /sys/class/backlight/rpi_backlight/bl_power"
os.system(cmd)
else:
self.logging.write("Turn on screen", level=2)
cmd = "echo 0 > /sys/class/backlight/rpi_backlight/bl_power"
os.system(cmd)
elif screen_control == "url" and switch:
if not state:
self.logging.info("Turn off screen via url", location=self.name)
url = self.setting_handler.get_setting("screen_control_off_url")
else:
self.logging.info("Turn on screen via url", location=self.name)
url = self.setting_handler.get_setting("screen_control_on_url")
self.logging.debug("Screensaver url: %s" %url, location=self.name)
self.http.request('GET', url)
elif screen_control == "cmd" and switch:
if not state:
self.logging.info("Turn off screen via cmd", location=self.name)
cmd = self.setting_handler.get_setting("screen_control_off_cmd")
else:
self.logging.info("Turn on screen via cmd", location=self.name)
cmd = self.setting_handler.get_setting("screen_control_on_cmd")
self.logging.debug("Screensaver cmd: %s" %cmd, location=self.name)
os.system(cmd)
def get_screen_state(self):
return self.screen_state
