mirror of
https://github.com/okunze/Argon40-ArgonOne-Script.git
synced 2025-06-19 21:08:38 +02:00
643 lines
18 KiB
Python
643 lines
18 KiB
Python
#!/usr/bin/python3
|
|
|
|
import os
|
|
import datetime
|
|
|
|
#########
|
|
# Describe Methods
|
|
#########
|
|
|
|
# Helper method to add proper suffix to numbers
|
|
def getNumberSuffix(numval):
|
|
onesvalue = numval % 10
|
|
if onesvalue == 1:
|
|
return "st"
|
|
elif onesvalue == 2:
|
|
return "nd"
|
|
elif onesvalue == 3:
|
|
return "rd"
|
|
return "th"
|
|
|
|
def describeHourMinute(hour, minute):
|
|
if hour < 0:
|
|
return ""
|
|
outstr = ""
|
|
ampmstr = ""
|
|
if hour <= 0:
|
|
hour = 0
|
|
outstr = outstr + "12"
|
|
ampmstr = "am"
|
|
elif hour <= 12:
|
|
outstr = outstr + str(hour)
|
|
if hour == 12:
|
|
ampmstr = "pm"
|
|
else:
|
|
ampmstr = "am"
|
|
else:
|
|
outstr = outstr + str(hour-12)
|
|
ampmstr = "pm"
|
|
|
|
if minute >= 10:
|
|
outstr = outstr+":"
|
|
elif minute > 0:
|
|
outstr = outstr+":0"
|
|
else:
|
|
if hour == 0:
|
|
ampmstr = "mn"
|
|
elif hour == 12:
|
|
ampmstr = "nn"
|
|
return outstr+ampmstr
|
|
|
|
if minute <= 0:
|
|
minute = 0
|
|
outstr = outstr+str(minute)
|
|
|
|
return outstr+ampmstr
|
|
|
|
# Describe Schedule Parameter Values
|
|
def describeSchedule(monthlist, weekdaylist, datelist, hourlist, minutelist):
|
|
weekdaynamelist = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
|
|
monthnamelist = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
|
|
|
|
curprefix = ""
|
|
hasDate = False
|
|
hasMonth = False
|
|
foundvalue = False
|
|
monthdatestr = ""
|
|
for curmonth in monthlist:
|
|
for curdate in datelist:
|
|
if curdate >= 0:
|
|
hasDate = True
|
|
if curmonth >= 0:
|
|
hasMonth = True
|
|
monthdatestr = monthdatestr + "," + monthnamelist[curmonth-1]+" "+str(curdate) + getNumberSuffix(curdate)
|
|
else:
|
|
monthdatestr = monthdatestr + ","+str(curdate) + getNumberSuffix(curdate)
|
|
else:
|
|
if curmonth >= 0:
|
|
monthdatestr = monthdatestr + "," + monthnamelist[curmonth-1]
|
|
|
|
if len(monthdatestr) > 0:
|
|
foundvalue = True
|
|
# Remove Leading Comma
|
|
monthdatestr = monthdatestr[1:]
|
|
if hasMonth == True:
|
|
curprefix = "Annually:"
|
|
else:
|
|
curprefix = "Monthly:"
|
|
monthdatestr = monthdatestr + " of the Month"
|
|
monthdatestr = " Every "+monthdatestr
|
|
|
|
weekdaystr = ""
|
|
for curweekday in weekdaylist:
|
|
if curweekday >= 0:
|
|
hasDate = True
|
|
weekdaystr = weekdaystr + "," + weekdaynamelist[curweekday]
|
|
|
|
if len(weekdaystr) > 0:
|
|
foundvalue = True
|
|
# Remove Leading Comma
|
|
weekdaystr = weekdaystr[1:]
|
|
if len(curprefix) == 0:
|
|
curprefix = "Weekly:"
|
|
weekdaystr = " on " + weekdaystr
|
|
else:
|
|
weekdaystr = ",on " + weekdaystr
|
|
|
|
hasHour = False
|
|
hasMinute = False
|
|
hourminstr = ""
|
|
for curhour in hourlist:
|
|
for curminute in minutelist:
|
|
if curhour >= 0:
|
|
hasHour = True
|
|
if curminute >= 0:
|
|
hasMinute = True
|
|
hourminstr = hourminstr + "," + describeHourMinute(curhour, curminute)
|
|
elif curminute >= 0:
|
|
hasMinute = True
|
|
hourminstr = hourminstr + "," + str(curminute) + getNumberSuffix(curminute)
|
|
|
|
if len(hourminstr) > 0:
|
|
foundvalue = True
|
|
# Remove Leading Comma
|
|
hourminstr = hourminstr[1:]
|
|
if hasHour == True:
|
|
if hasDate == True:
|
|
hourminstr = "at " + hourminstr
|
|
else:
|
|
hourminstr = "Daily: " + hourminstr
|
|
if hasMinute == False:
|
|
hourminstr = hourminstr + " every minute"
|
|
else:
|
|
if hourminstr == "0":
|
|
hourminstr = "At the start of every hour"
|
|
else:
|
|
hourminstr = "Hourly: At " + hourminstr + " minute"
|
|
else:
|
|
hourminstr = "Every minute"
|
|
|
|
if len(curprefix) > 0:
|
|
hourminstr = ","+hourminstr
|
|
|
|
return (curprefix + monthdatestr + weekdaystr + hourminstr).strip()
|
|
|
|
|
|
#########
|
|
# Alarm
|
|
#########
|
|
|
|
# Alarm to UTC/Local time
|
|
def convertAlarmTimezone(weekday, caldate, hour, minute, toutc):
|
|
utcdiffsec = getLocaltimeOffset().seconds
|
|
if toutc == False:
|
|
utcdiffsec = utcdiffsec*(-1)
|
|
|
|
utcdiffsec = utcdiffsec - (utcdiffsec%60)
|
|
utcdiffmin = utcdiffsec % 3600
|
|
utcdiffhour = int((utcdiffsec - utcdiffmin)/3600)
|
|
utcdiffmin = int(utcdiffmin/60)
|
|
|
|
addhour = 0
|
|
if minute >= 0:
|
|
minute = minute - utcdiffmin
|
|
if minute < 0:
|
|
addhour = -1
|
|
minute = minute + 60
|
|
elif minute > 59:
|
|
addhour = 1
|
|
minute = minute - 60
|
|
|
|
addday = 0
|
|
if hour >= 0:
|
|
hour = hour - utcdiffhour
|
|
tmphour = hour + addhour
|
|
if hour < 0:
|
|
hour = hour + 24
|
|
elif hour > 23:
|
|
hour = hour - 24
|
|
if tmphour < 0:
|
|
addday = -1
|
|
elif tmphour > 23:
|
|
addday = 1
|
|
|
|
if addday != 0:
|
|
if weekday >= 0:
|
|
weekday = weekday + addday
|
|
if weekday < 0:
|
|
weekday = weekday + 7
|
|
elif weekday > 6:
|
|
weekday = weekday - 7
|
|
if caldate > 0:
|
|
# Edge cases might not be handled properly though
|
|
curtime = datetime.datetime.now()
|
|
maxmonthdate = getLastMonthDate(curtime.year, curtime.month)
|
|
caldate = caldate + addday
|
|
if caldate == 0:
|
|
# move to end of the month
|
|
caldate = maxmonthdate
|
|
elif caldate > maxmonthdate:
|
|
# move to next month
|
|
caldate = 1
|
|
|
|
return [weekday, caldate, hour, minute]
|
|
|
|
|
|
# Get RTC Alarm Setting (Negative values ignored)
|
|
def getRTCAlarm(weekday, caldate, hour, minute):
|
|
hasError = False
|
|
if caldate < 1 and weekday < 0 and hour < 0 and minute < 0:
|
|
hasError = True
|
|
elif minute > 59:
|
|
hasError = True
|
|
elif hour > 23:
|
|
hasError = True
|
|
elif weekday > 6:
|
|
hasError = True
|
|
elif caldate > 31:
|
|
hasError = True
|
|
|
|
if hasError == True:
|
|
return [-1, -1, -1, -1]
|
|
# Convert to UTC
|
|
return convertAlarmTimezone(weekday, caldate, hour, minute, True)
|
|
|
|
#########
|
|
# Date/Time tools
|
|
#########
|
|
|
|
# Get local time vs UTC
|
|
def getLocaltimeOffset():
|
|
localdatetime = datetime.datetime.now()
|
|
utcdatetime = datetime.datetime.fromtimestamp(localdatetime.timestamp(), datetime.timezone.utc)
|
|
# Remove TZ info to allow subtraction
|
|
utcdatetime = utcdatetime.replace(tzinfo = None)
|
|
|
|
return localdatetime - utcdatetime
|
|
|
|
|
|
# Sync Time to RTC Time (for Daemon use)
|
|
def updateSystemTime(rtctime):
|
|
os.system("date -s '"+rtctime.isoformat()+"' >/dev/null 2>&1")
|
|
|
|
|
|
#########
|
|
# Config
|
|
#########
|
|
|
|
# Load config value as array of integers
|
|
def getConfigValue(valuestr):
|
|
try:
|
|
if valuestr == "*":
|
|
return [-1]
|
|
tmplist = valuestr.split(",")
|
|
map_object = map(int, tmplist)
|
|
return list(map_object)
|
|
except:
|
|
return [-1]
|
|
|
|
# Load config line data as array of Command schedule
|
|
def newCommandSchedule(curline):
|
|
result = []
|
|
linedata = curline.split(" ")
|
|
if len(linedata) < 6:
|
|
return result
|
|
|
|
minutelist = getConfigValue(linedata[0])
|
|
hourlist = getConfigValue(linedata[1])
|
|
datelist = getConfigValue(linedata[2])
|
|
#monthlist = getConfigValue(linedata[3])
|
|
monthlist = [-1] # Certain edge cases will not be handled properly
|
|
weekdaylist = getConfigValue(linedata[4])
|
|
|
|
cmd = ""
|
|
ctr = 5
|
|
while ctr < len(linedata):
|
|
cmd = cmd + " " + linedata[ctr]
|
|
ctr = ctr + 1
|
|
cmd = cmd.strip()
|
|
|
|
for curmin in minutelist:
|
|
for curhour in hourlist:
|
|
for curdate in datelist:
|
|
for curmonth in monthlist:
|
|
for curweekday in weekdaylist:
|
|
result.append({ "minute": curmin, "hour": curhour, "date": curdate, "month":curmonth, "weekday": curweekday, "cmd":cmd })
|
|
|
|
return result
|
|
|
|
# Save updated config file
|
|
def saveConfigList(fname, configlist):
|
|
f = open(fname, "w")
|
|
f.write("#\n")
|
|
f.write("# Argon RTC Configuration\n")
|
|
f.write("# - Follows cron general format, but with only * and csv support\n")
|
|
f.write("# - Each row follows the following format:\n")
|
|
f.write("# min hour date month dayOfWeek Command\n")
|
|
f.write("# e.g. Shutdown daily at 1am\n")
|
|
f.write("# 0 1 * * * off\n")
|
|
f.write("# Shutdown daily at 1am and 1pm\n")
|
|
f.write("# 0 1,13 * * * off\n")
|
|
f.write("# - Commands are currently on or off only\n")
|
|
f.write("# - Limititations\n")
|
|
f.write("# Requires MINUTE value\n")
|
|
f.write("# Month values are ignored (edge cases not supported)\n")
|
|
f.write("#\n")
|
|
|
|
for config in configlist:
|
|
f.write(config+"\n")
|
|
f.close()
|
|
|
|
# Remove config line
|
|
def removeConfigEntry(fname, entryidx):
|
|
configlist = loadConfigList(fname)
|
|
if len(configlist) > entryidx:
|
|
configlist.pop(entryidx)
|
|
saveConfigList(fname, configlist)
|
|
|
|
# Load config list (removes invalid data)
|
|
def loadConfigList(fname):
|
|
try:
|
|
result = []
|
|
with open(fname, "r") as fp:
|
|
for curline in fp:
|
|
if not curline:
|
|
continue
|
|
curline = curline.strip().replace('\t', ' ')
|
|
# Handle special characters that get encoded
|
|
tmpline = "".join([c if 0x20<=ord(c) and ord(c)<=0x7e else "" for c in curline])
|
|
|
|
if not tmpline:
|
|
continue
|
|
if tmpline[0] == "#":
|
|
continue
|
|
checkdata = tmpline.split(" ")
|
|
if len(checkdata) > 5:
|
|
# Don't include every minute type of schedule
|
|
if checkdata[0] != "*":
|
|
result.append(tmpline)
|
|
return result
|
|
except:
|
|
return []
|
|
|
|
# Form Command Schedule list from config list
|
|
def formCommandScheduleList(configlist):
|
|
try:
|
|
result = []
|
|
for config in configlist:
|
|
result = result + newCommandSchedule(config)
|
|
return result
|
|
except:
|
|
return []
|
|
|
|
# Describe config list entry
|
|
def describeConfigListEntry(configlistitem):
|
|
linedata = configlistitem.split(" ")
|
|
if len(linedata) < 6:
|
|
return ""
|
|
|
|
minutelist = getConfigValue(linedata[0])
|
|
hourlist = getConfigValue(linedata[1])
|
|
datelist = getConfigValue(linedata[2])
|
|
#monthlist = getConfigValue(linedata[3])
|
|
monthlist = [-1] # Certain edge cases will not be handled properly
|
|
weekdaylist = getConfigValue(linedata[4])
|
|
|
|
cmd = ""
|
|
ctr = 5
|
|
while ctr < len(linedata):
|
|
cmd = cmd + " " + linedata[ctr]
|
|
ctr = ctr + 1
|
|
cmd = cmd.strip().lower()
|
|
if cmd == "on":
|
|
cmd = "Startup"
|
|
else:
|
|
cmd = "Shutdown"
|
|
|
|
return cmd+" | "+describeSchedule(monthlist, weekdaylist, datelist, hourlist, minutelist)
|
|
|
|
# Describe config list and show indices
|
|
def describeConfigList(fname):
|
|
# 1 is reserved for New schedule
|
|
ctr = 2
|
|
configlist = loadConfigList(fname)
|
|
for config in configlist:
|
|
tmpline = describeConfigListEntry(config)
|
|
if len(tmpline) > 0:
|
|
print(" "+str(ctr)+". ", tmpline)
|
|
ctr = ctr + 1
|
|
if ctr == 2:
|
|
print(" No Existing Schedules")
|
|
|
|
# Check Command schedule if it should fire for the give time
|
|
def checkDateForCommandSchedule(commandschedule, datetimeobj):
|
|
testminute = commandschedule.get("minute", -1)
|
|
testhour = commandschedule.get("hour", -1)
|
|
testdate = commandschedule.get("date", -1)
|
|
testmonth = commandschedule.get("month", -1)
|
|
testweekday = commandschedule.get("weekday", -1)
|
|
|
|
if testminute < 0 or testminute == datetimeobj.minute:
|
|
if testhour < 0 or testhour == datetimeobj.hour:
|
|
if testdate < 0 or testdate == datetimeobj.day:
|
|
if testmonth < 0 or testmonth == datetimeobj.month:
|
|
if testweekday < 0:
|
|
return True
|
|
else:
|
|
# python Sunday = 6, RTC Sunday = 0
|
|
weekDay = datetimeobj.weekday()
|
|
if weekDay == 6:
|
|
weekDay = 0
|
|
else:
|
|
weekDay = weekDay + 1
|
|
if testweekday == weekDay:
|
|
return True
|
|
return False
|
|
|
|
# Get current command
|
|
def getCommandForTime(commandschedulelist, datetimeobj, checkcmd):
|
|
ctr = 0
|
|
while ctr < len(commandschedulelist):
|
|
testcmd = commandschedulelist[ctr].get("cmd", "")
|
|
if (testcmd.lower() == checkcmd or len(checkcmd) == 0) and len(testcmd) > 0:
|
|
if checkDateForCommandSchedule(commandschedulelist[ctr], datetimeobj) == True:
|
|
return testcmd
|
|
ctr = ctr + 1
|
|
return ""
|
|
|
|
# Get Last Date of Month
|
|
def getLastMonthDate(year, month):
|
|
if month < 12:
|
|
testtime = datetime.datetime(year, month+1, 1)
|
|
else:
|
|
testtime = datetime.datetime(year+1, 1, 1)
|
|
testtime = testtime - datetime.timedelta(days=1)
|
|
return testtime.day
|
|
|
|
# Increment to the next iteration of command schedule
|
|
def incrementCommandScheduleTime(commandschedule, testtime, addmode):
|
|
testminute = commandschedule.get("minute", -1)
|
|
testhour = commandschedule.get("hour", -1)
|
|
testdate = commandschedule.get("date", -1)
|
|
testmonth = commandschedule.get("month", -1)
|
|
testweekday = commandschedule.get("weekday", -1)
|
|
|
|
if addmode == "minute":
|
|
testfield = commandschedule.get(addmode, -1)
|
|
if testfield < 0:
|
|
if testtime.minute < 59:
|
|
return testtime + datetime.timedelta(minutes=1)
|
|
else:
|
|
return incrementCommandScheduleTime(commandschedule, testtime.replace(minute=0), "hour")
|
|
else:
|
|
return incrementCommandScheduleTime(commandschedule, testtime, "hour")
|
|
elif addmode == "hour":
|
|
testfield = commandschedule.get(addmode, -1)
|
|
if testfield < 0:
|
|
if testtime.hour < 23:
|
|
return testtime + datetime.timedelta(hours=1)
|
|
else:
|
|
return incrementCommandScheduleTime(commandschedule, testtime.replace(hour=0), "date")
|
|
else:
|
|
return incrementCommandScheduleTime(commandschedule, testtime, "date")
|
|
elif addmode == "date":
|
|
testfield = commandschedule.get(addmode, -1)
|
|
if testfield < 0:
|
|
maxmonthdate = getLastMonthDate(testtime.year, testtime.month)
|
|
if testtime.day < maxmonthdate:
|
|
return testtime + datetime.timedelta(days=1)
|
|
else:
|
|
return incrementCommandScheduleTime(commandschedule, testtime.replace(day=1), "month")
|
|
else:
|
|
return incrementCommandScheduleTime(commandschedule, testtime, "month")
|
|
elif addmode == "month":
|
|
testfield = commandschedule.get(addmode, -1)
|
|
if testfield < 0:
|
|
nextmonth = testtime.month
|
|
nextyear = testtime.year
|
|
while True:
|
|
if nextmonth < 12:
|
|
nextmonth = nextmonth + 1
|
|
else:
|
|
nextmonth = 1
|
|
nextyear = nextyear + 1
|
|
maxmonthdate = getLastMonthDate(nextyear, nextmonth)
|
|
if testtime.day <= maxmonthdate:
|
|
return testtime.replace(month=nextmonth, year=nextyear)
|
|
else:
|
|
return incrementCommandScheduleTime(commandschedule, testtime, "year")
|
|
else:
|
|
# Year
|
|
if testtime.month == 2 and testtime.day == 29:
|
|
# Leap day handling
|
|
nextyear = testtime.year
|
|
while True:
|
|
nextyear = nextyear + 1
|
|
maxmonthdate = getLastMonthDate(nextyear, testtime.month)
|
|
if testtime.day <= maxmonthdate:
|
|
return testtime.replace(year=nextyear)
|
|
else:
|
|
return testtime.replace(year=(testtime.year+1))
|
|
|
|
# Set Next Alarm on RTC
|
|
def getNextAlarm(commandschedulelist, prevdatetime):
|
|
curtime = datetime.datetime.now()
|
|
if prevdatetime > curtime:
|
|
return [prevdatetime, -1, -1, -1, -1]
|
|
|
|
# Divisible by 4 for leap day
|
|
checklimityears = 12
|
|
foundnextcmd = False
|
|
nextcommandschedule = {}
|
|
# To be sure it's later than any schedule
|
|
nextcommandtime = curtime.replace(year=(curtime.year+checklimityears))
|
|
|
|
ctr = 0
|
|
while ctr < len(commandschedulelist):
|
|
testcmd = commandschedulelist[ctr].get("cmd", "").lower()
|
|
if testcmd == "on":
|
|
invaliddata = False
|
|
testminute = commandschedulelist[ctr].get("minute", -1)
|
|
testhour = commandschedulelist[ctr].get("hour", -1)
|
|
testdate = commandschedulelist[ctr].get("date", -1)
|
|
testmonth = commandschedulelist[ctr].get("month", -1)
|
|
testweekday = commandschedulelist[ctr].get("weekday", -1)
|
|
|
|
tmpminute = testminute
|
|
tmphour = testhour
|
|
tmpdate = testdate
|
|
tmpmonth = testmonth
|
|
tmpyear = curtime.year
|
|
|
|
if tmpminute < 0:
|
|
tmpminute = curtime.minute
|
|
|
|
if tmphour < 0:
|
|
tmphour = curtime.hour
|
|
|
|
if tmpdate < 0:
|
|
tmpdate = curtime.day
|
|
|
|
if tmpmonth < 0:
|
|
tmpmonth = curtime.month
|
|
|
|
maxmonthdate = getLastMonthDate(tmpyear, tmpmonth)
|
|
if tmpdate > maxmonthdate:
|
|
# Invalid month date
|
|
if testdate < 0:
|
|
tmpdate = maxmonthdate
|
|
else:
|
|
# Date is fixed
|
|
if testminute < 0:
|
|
tmpminute = 0
|
|
if testhour < 0:
|
|
tmphour = 0
|
|
if testmonth < 0 and testdate <= 31:
|
|
# Look for next valid month
|
|
while tmpdate > maxmonthdate:
|
|
if tmpmonth < 12:
|
|
tmpmonth = tmpmonth + 1
|
|
else:
|
|
tmpmonth = 1
|
|
tmpyear = tmpyear + 1
|
|
maxmonthdate = getLastMonthDate(tmpyear, tmpmonth)
|
|
elif tmpdate == 29 and tmpmonth == 2:
|
|
# Fixed to leap day
|
|
while tmpdate > maxmonthdate:
|
|
tmpyear = tmpyear + 1
|
|
maxmonthdate = getLastMonthDate(tmpyear, tmpmonth)
|
|
else:
|
|
invaliddata = True
|
|
if invaliddata == False:
|
|
try:
|
|
testtime = datetime.datetime(tmpyear, tmpmonth, tmpdate, tmphour, tmpminute)
|
|
except:
|
|
# Force time diff
|
|
testtime = curtime - datetime.timedelta(hours=1)
|
|
tmptimediff = (curtime - testtime).total_seconds()
|
|
else:
|
|
tmptimediff = 0
|
|
|
|
if testweekday >= 0:
|
|
# Day of Week check
|
|
# python Sunday = 6, RTC Sunday = 0
|
|
weekDay = testtime.weekday()
|
|
if weekDay == 6:
|
|
weekDay = 0
|
|
else:
|
|
weekDay = weekDay + 1
|
|
|
|
|
|
if weekDay != testweekday or tmptimediff > 0:
|
|
# Resulting 0-ed time will be <= the testtime
|
|
if testminute < 0:
|
|
testtime = testtime.replace(minute=0)
|
|
if testhour < 0:
|
|
testtime = testtime.replace(hour=0)
|
|
|
|
dayoffset = testweekday-weekDay
|
|
if dayoffset < 0:
|
|
dayoffset = dayoffset + 7
|
|
elif dayoffset == 0:
|
|
dayoffset = 7
|
|
|
|
testtime = testtime + datetime.timedelta(days=dayoffset)
|
|
|
|
# Just look for the next valid weekday; Can be optimized
|
|
while checkDateForCommandSchedule(commandschedulelist[ctr], testtime) == False and (testtime.year - curtime.year) < checklimityears:
|
|
testtime = testtime + datetime.timedelta(days=7)
|
|
|
|
if (testtime.year - curtime.year) >= checklimityears:
|
|
# Too many iterations, abort/ignore
|
|
tmptimediff = 0
|
|
else:
|
|
tmptimediff = (curtime - testtime).total_seconds()
|
|
if tmptimediff > 0:
|
|
# Find next iteration that's greater than the current time (Day of Week check already handled)
|
|
while tmptimediff >= 0:
|
|
testtime = incrementCommandScheduleTime(commandschedulelist[ctr], testtime, "minute")
|
|
tmptimediff = (curtime - testtime).total_seconds()
|
|
|
|
if nextcommandtime > testtime and tmptimediff < 0:
|
|
nextcommandschedule = commandschedulelist[ctr]
|
|
nextcommandtime = testtime
|
|
foundnextcmd = True
|
|
|
|
|
|
ctr = ctr + 1
|
|
if foundnextcmd == True:
|
|
# Schedule Alarm
|
|
# Assume no date,weekday involved just shift the hour and minute accordingly
|
|
paramminute = nextcommandschedule.get("minute", -1)
|
|
paramhour = nextcommandschedule.get("hour", -1)
|
|
if nextcommandschedule.get("weekday", -1) >=0 or nextcommandschedule.get("date", -1) > 0:
|
|
# Set alarm based on hour/minute of next occurrence to factor in timezone changes if any
|
|
paramminute = nextcommandtime.minute
|
|
paramhour = nextcommandtime.hour
|
|
weekday, caldate, hour, minute = getRTCAlarm(nextcommandschedule.get("weekday", -1), nextcommandschedule.get("date", -1), paramhour, paramminute)
|
|
return [nextcommandtime, weekday, caldate, hour, minute]
|
|
|
|
# This will ensure that this will be replaced next iteration
|
|
return [curtime, -1, -1, -1, -1]
|
|
|