def POST(self):
qdict = web.input()
save_to_options(qdict)
if 'master' in qdict:
m = int(qdict['master'])
if m < 0:
stations.master = None
elif m < stations.count():
stations.master = m
if 'old_password' in qdict and qdict['old_password'] != "":
try:
if test_password(qdict['old_password']):
if qdict['new_password'] == "":
raise web.seeother('/options?errorCode=pw_blank')
elif qdict['new_password'] == qdict['check_password']:
options.password_salt = password_salt() # Make a new salt
options.password_hash = password_hash(qdict['new_password'], options.password_salt)
else:
raise web.seeother('/options?errorCode=pw_mismatch')
else:
raise web.seeother('/options?errorCode=pw_wrong')
except KeyError:
pass
raise web.seeother('/')
def POST(self):
qdict = web.input()
recalc = False
for s in xrange(0, stations.count()):
stations[s].name = qdict["%d_name" % s]
stations[s].usage = float(qdict.get("%d_usage" % s, 1.0))
stations[s].precipitation = float(qdict.get("%d_precipitation" % s, 10.0))
stations[s].capacity = float(qdict.get("%d_capacity" % s, 10.0))
stations[s].eto_factor = float(qdict.get("%d_eto_factor" % s, 1.0))
stations[s].enabled = True if qdict.get("%d_enabled" % s, 'off') == 'on' else False
stations[s].ignore_rain = True if qdict.get("%d_ignore_rain" % s, 'off') == 'on' else False
if stations.master is not None or options.master_relay:
stations[s].activate_master = True if qdict.get("%d_activate_master" % s, 'off') == 'on' else False
balance_adjust = float(qdict.get("%d_balance_adjust" % s, 0.0))
if balance_adjust != 0.0:
calc_day = datetime.datetime.now().date() - datetime.timedelta(days=1)
stations[s].balance[calc_day]['intervals'].append({
'program': -1,
'program_name': 'Balance adjustment',
'done': True,
'irrigation': balance_adjust
})
stations[s].balance[calc_day]['total'] += balance_adjust
recalc = True
if recalc:
Timer(0.1, programs.calculate_balances).start()
raise web.seeother('/')
def POST(self):
qdict = web.input()
save_to_options(qdict)
if 'master' in qdict:
m = int(qdict['master'])
if m < 0:
stations.master = None
elif m < stations.count():
stations.master = m
if 'old_password' in qdict and qdict['old_password'] != "":
try:
if test_password(qdict['old_password']):
if qdict['new_password'] == "":
raise web.seeother('/options?errorCode=pw_blank')
elif qdict['new_password'] == qdict['check_password']:
options.password_salt = password_salt() # Make a new salt
options.password_hash = password_hash(qdict['new_password'], options.password_salt)
else:
raise web.seeother('/options?errorCode=pw_mismatch')
else:
raise web.seeother('/options?errorCode=pw_wrong')
except KeyError:
pass
raise web.seeother('/')
def POST(self):
qdict = web.input()
for s in xrange(0, stations.count()):
stations[s].name = qdict["%d_name" % s]
stations[s].usage = float(qdict.get("%d_usage" % s, 1.0))
stations[s].precipitation = float(qdict.get("%d_precipitation" % s, 10.0))
stations[s].capacity = float(qdict.get("%d_capacity" % s, 10.0))
stations[s].enabled = True if qdict.get("%d_enabled" % s, 'off') == 'on' else False
stations[s].ignore_rain = True if qdict.get("%d_ignore_rain" % s, 'off') == 'on' else False
if stations.master is not None or options.master_relay:
stations[s].activate_master = True if qdict.get("%d_activate_master" % s, 'off') == 'on' else False
raise web.seeother('/')
def GET(self):
from ospy import server
qdict = web.input()
stop_all = get_input(qdict, 'stop_all', False, lambda x: True)
scheduler_enabled = get_input(qdict, 'scheduler_enabled', None, lambda x: x == '1')
manual_mode = get_input(qdict, 'manual_mode', None, lambda x: x == '1')
rain_block = get_input(qdict, 'rain_block', None, float)
level_adjustment = get_input(qdict, 'level_adjustment', None, float)
toggle_temp = get_input(qdict, 'toggle_temp', False, lambda x: True)
if stop_all:
if not options.manual_mode:
options.scheduler_enabled = False
programs.run_now_program = None
run_once.clear()
log.finish_run(None)
stations.clear()
if scheduler_enabled is not None:
options.scheduler_enabled = scheduler_enabled
if manual_mode is not None:
options.manual_mode = manual_mode
if rain_block is not None:
options.rain_block = datetime.datetime.now() + datetime.timedelta(hours=rain_block)
if level_adjustment is not None:
options.level_adjustment = level_adjustment / 100
if toggle_temp:
options.temp_unit = "F" if options.temp_unit == "C" else "C"
set_to = get_input(qdict, 'set_to', None, int)
sid = get_input(qdict, 'sid', 0, int) - 1
set_time = get_input(qdict, 'set_time', 0, int)
if set_to is not None and 0 <= sid < stations.count() and options.manual_mode:
if set_to: # if status is on
start = datetime.datetime.now()
new_schedule = {
'active': True,
'program': -1,
'station': sid,
'program_name': "Manual",
'fixed': True,
'cut_off': 0,
'manual': True,
'blocked': False,
'start': start,
'original_start': start,
'end': start + datetime.timedelta(days=3650),
'uid': '%s-%s-%d' % (str(start), "Manual", sid),
'usage': stations.get(sid).usage
}
if set_time > 0: # if an optional duration time is given
new_schedule['end'] = datetime.datetime.now() + datetime.timedelta(seconds=set_time)
log.start_run(new_schedule)
stations.activate(new_schedule['station'])
else: # If status is off
stations.deactivate(sid)
active = log.active_runs()
for interval in active:
if interval['station'] == sid:
log.finish_run(interval)
self._redirect_back()
def predicted_schedule(start_time, end_time):
"""Determines all schedules for the given time range.
To calculate what should currently be active, a start time of some time (a day) ago should be used."""
adjustment = level_adjustments.total_adjustment()
max_usage = options.max_usage
delay_delta = datetime.timedelta(seconds=options.station_delay)
rain_block_start = datetime.datetime.now()
rain_block_end = rain_blocks.block_end()
skip_intervals = log.finished_runs() + log.active_runs()
current_active = [
interval for interval in skip_intervals if not interval['blocked']
]
usage_changes = {}
for active in current_active:
start = active['start']
end = active['end']
if start not in usage_changes:
usage_changes[start] = 0
if end not in usage_changes:
usage_changes[end] = 0
usage_changes[start] += active['usage']
usage_changes[end] -= active['usage']
station_schedules = {}
# Get run-once information:
for station in stations.enabled_stations():
run_once_intervals = run_once.active_intervals(start_time, end_time,
station.index)
for interval in run_once_intervals:
if station.index not in station_schedules:
station_schedules[station.index] = []
program_name = _('Run-Once')
new_schedule = {
'active':
None,
'program':
-1,
'program_name':
program_name,
'fixed':
True,
'cut_off':
0,
'manual':
True,
'blocked':
False,
'start':
interval['start'],
'original_start':
interval['start'],
'end':
interval['end'],
'uid':
'%s-%s-%d' %
(str(interval['start']), str(program_name), station.index),
'usage':
station.usage
}
station_schedules[station.index].append(new_schedule)
# Get run-now information:
if programs.run_now_program is not None:
program = programs.run_now_program
for station in sorted(program.stations):
run_now_intervals = program.active_intervals(
start_time, end_time, station)
for interval in run_now_intervals:
if station >= stations.count(
) or stations.master == station or stations.master_two == station or not stations[
station].enabled:
continue
if station not in station_schedules:
station_schedules[station] = []
program_name = "%s " % program.name + _('Run-Now')
new_schedule = {
'active':
None,
'program':
-1,
'program_name':
program_name,
'fixed':
program.
fixed, # True for ignore water level else program.fixed for use water level in run now-program xx
'cut_off':
0,
'manual':
True,
'blocked':
False,
'start':
interval['start'],
'original_start':
interval['start'],
'end':
interval['end'],
'uid':
'%s-%s-%d' %
(str(interval['start']), str(program_name), station),
'usage':
stations.get(station).usage
}
station_schedules[station].append(new_schedule)
# Aggregate per station:
for program in programs.get():
if not program.enabled:
continue
for station in sorted(program.stations):
program_intervals = program.active_intervals(
start_time, end_time, station)
if station >= stations.count(
) or stations.master == station or stations.master_two == station or not stations[
station].enabled:
continue
if station not in station_schedules:
station_schedules[station] = []
for interval in program_intervals:
if current_active and current_active[-1][
'original_start'] > interval['start']:
continue
new_schedule = {
'active':
None,
'program':
program.index,
'program_name':
program.name, # Save it because programs can be renamed
'fixed':
program.fixed,
'cut_off':
program.cut_off / 100.0,
'manual':
program.manual,
'blocked':
False,
'start':
interval['start'],
'original_start':
interval['start'],
'end':
interval['end'],
'uid':
'%s-%d-%d' %
(str(interval['start']), program.index, station),
'usage':
stations.get(station).usage
}
station_schedules[station].append(new_schedule)
# Make lists sorted on start time, check usage
for station in station_schedules:
if 0 < max_usage < stations.get(station).usage:
station_schedules[station] = [] # Impossible to schedule
else:
station_schedules[station].sort(key=lambda inter: inter['start'])
all_intervals = []
# Adjust for weather and remove overlap:
for station, schedule in station_schedules.iteritems():
for interval in schedule:
if not interval['fixed']:
time_delta = interval['end'] - interval['start']
time_delta = datetime.timedelta(
seconds=(time_delta.days * 24 * 3600 +
time_delta.seconds) * adjustment)
interval['end'] = interval['start'] + time_delta
interval['adjustment'] = adjustment
else:
interval['adjustment'] = 1.0
last_end = datetime.datetime(2000, 1, 1)
for interval in schedule:
if last_end > interval['start']:
time_delta = last_end - interval['start']
interval['start'] += time_delta
interval['end'] += time_delta
last_end = interval['end']
new_interval = {'station': station}
new_interval.update(interval)
all_intervals.append(new_interval)
# Make list of entries sorted on duration and time (stable sorted on station #)
all_intervals.sort(key=lambda inter: inter['end'] - inter['start'])
all_intervals.sort(key=lambda inter: inter['start'])
# If we have processed some intervals before, we should skip all that were scheduled before them
for to_skip in skip_intervals:
index = 0
while index < len(all_intervals):
interval = all_intervals[index]
if interval['original_start'] < to_skip['original_start'] and (
not to_skip['blocked'] or interval['blocked']):
del all_intervals[index]
elif interval['uid'] == to_skip['uid']:
del all_intervals[index]
break
else:
index += 1
# And make sure manual programs get priority:
all_intervals.sort(key=lambda inter: not inter['manual'])
# Try to add each interval
for interval in all_intervals:
if not interval['manual'] and not options.scheduler_enabled:
interval['blocked'] = 'disabled scheduler'
continue
elif not interval['manual'] and not stations.get(interval['station']).ignore_rain and \
rain_block_start <= interval['start'] < rain_block_end:
interval['blocked'] = 'rain delay'
continue
elif not interval['manual'] and not stations.get(
interval['station']).ignore_rain and inputs.rain_sensed():
interval['blocked'] = 'rain sensor'
continue
elif not interval[
'fixed'] and interval['adjustment'] < interval['cut_off']:
interval['blocked'] = 'cut-off'
continue
if max_usage > 0:
usage_keys = sorted(usage_changes.keys())
start_usage = 0
start_key_index = -1
for index, key in enumerate(usage_keys):
if key > interval['start']:
break
start_key_index = index
start_usage += usage_changes[key]
failed = False
finished = False
while not failed and not finished:
parallel_usage = 0
parallel_current = 0
for index in range(start_key_index + 1, len(usage_keys)):
key = usage_keys[index]
if key >= interval['end']:
break
parallel_current += usage_changes[key]
parallel_usage = max(parallel_usage, parallel_current)
if start_usage + parallel_usage + interval[
'usage'] <= max_usage:
start = interval['start']
end = interval['end']
if start not in usage_changes:
usage_changes[start] = 0
if end not in usage_changes:
usage_changes[end] = 0
usage_changes[start] += interval['usage']
usage_changes[end] -= interval['usage']
finished = True
else:
while not failed:
# Shift this interval to next possibility
start_key_index += 1
# No more options
if start_key_index >= len(usage_keys):
failed = True
else:
next_option = usage_keys[start_key_index]
next_change = usage_changes[next_option]
start_usage += next_change
# Lower usage at this starting point:
if next_change < 0:
skip_delay = False
if options.min_runtime > 0:
# Try to determine how long we have been running at this point:
min_runtime_delta = datetime.timedelta(
seconds=options.min_runtime)
temp_usage = 0
running_since = next_option
not_running_since = next_option
for temp_index in range(
0, start_key_index):
temp_usage_key = usage_keys[temp_index]
if temp_usage < 0.01 and usage_changes[
temp_usage_key] > 0 and temp_usage_key - not_running_since > datetime.timedelta(
seconds=3):
running_since = temp_usage_key
temp_usage += usage_changes[
temp_usage_key]
if temp_usage < 0.01 and usage_changes[
temp_usage_key] < 0:
not_running_since = temp_usage_key
if next_option - running_since < min_runtime_delta:
skip_delay = True
if skip_delay:
time_to_next = next_option - interval[
'start']
else:
time_to_next = next_option + delay_delta - interval[
'start']
interval['start'] += time_to_next
interval['end'] += time_to_next
break
if failed:
logging.warning('Could not schedule %s.', interval['uid'])
interval['blocked'] = 'scheduler error'
all_intervals.sort(key=lambda inter: inter['start'])
return all_intervals
def predicted_schedule(start_time, end_time):
"""Determines all schedules for the given time range.
To calculate what should currently be active, a start time of some time (a day) ago should be used."""
adjustment = level_adjustments.total_adjustment()
max_usage = options.max_usage
delay_delta = datetime.timedelta(seconds=options.station_delay)
rain_block_start = datetime.datetime.now()
rain_block_end = rain_blocks.block_end()
skip_intervals = log.finished_runs() + log.active_runs()
current_active = [interval for interval in skip_intervals if not interval['blocked']]
usage_changes = {}
for active in current_active:
start = active['start']
end = active['end']
if start not in usage_changes:
usage_changes[start] = 0
if end not in usage_changes:
usage_changes[end] = 0
usage_changes[start] += active['usage']
usage_changes[end] -= active['usage']
station_schedules = {}
# Get run-once information:
for station in stations.enabled_stations():
run_once_intervals = run_once.active_intervals(start_time, end_time, station.index)
for interval in run_once_intervals:
if station.index not in station_schedules:
station_schedules[station.index] = []
new_schedule = {
'active': None,
'program': -1,
'program_name': "Run-Once",
'fixed': True,
'cut_off': 0,
'manual': True,
'blocked': False,
'start': interval['start'],
'original_start': interval['start'],
'end': interval['end'],
'uid': '%s-%s-%d' % (str(interval['start']), "Run-Once", station.index),
'usage': station.usage
}
station_schedules[station.index].append(new_schedule)
# Get run-now information:
if programs.run_now_program is not None:
program = programs.run_now_program
for station in sorted(program.stations):
run_now_intervals = program.active_intervals(start_time, end_time, station)
for interval in run_now_intervals:
if station >= stations.count() or stations.master == station or not stations[station].enabled:
continue
if station not in station_schedules:
station_schedules[station] = []
program_name = "%s (Run-Now)" % program.name
new_schedule = {
'active': None,
'program': -1,
'program_name': program_name,
'fixed': True,
'cut_off': 0,
'manual': True,
'blocked': False,
'start': interval['start'],
'original_start': interval['start'],
'end': interval['end'],
'uid': '%s-%s-%d' % (str(interval['start']), program_name, station),
'usage': stations.get(station).usage
}
station_schedules[station].append(new_schedule)
# Aggregate per station:
for program in programs.get():
if not program.enabled:
continue
for station in sorted(program.stations):
program_intervals = program.active_intervals(start_time, end_time, station)
if station >= stations.count() or stations.master == station or not stations[station].enabled:
continue
if station not in station_schedules:
station_schedules[station] = []
for interval in program_intervals:
if current_active and current_active[-1]['original_start'] > interval['start']:
continue
new_schedule = {
'active': None,
'program': program.index,
'program_name': program.name, # Save it because programs can be renamed
'fixed': program.fixed,
'cut_off': program.cut_off/100.0,
'manual': program.manual,
'blocked': False,
'start': interval['start'],
'original_start': interval['start'],
'end': interval['end'],
'uid': '%s-%d-%d' % (str(interval['start']), program.index, station),
'usage': stations.get(station).usage
}
station_schedules[station].append(new_schedule)
# Make lists sorted on start time, check usage
for station in station_schedules:
if 0 < max_usage < stations.get(station).usage:
station_schedules[station] = [] # Impossible to schedule
else:
station_schedules[station].sort(key=lambda inter: inter['start'])
all_intervals = []
# Adjust for weather and remove overlap:
for station, schedule in station_schedules.iteritems():
for interval in schedule:
if not interval['fixed']:
time_delta = interval['end'] - interval['start']
time_delta = datetime.timedelta(seconds=(time_delta.days * 24 * 3600 + time_delta.seconds) * adjustment)
interval['end'] = interval['start'] + time_delta
interval['adjustment'] = adjustment
else:
interval['adjustment'] = 1.0
last_end = datetime.datetime(2000, 1, 1)
for interval in schedule:
if last_end > interval['start']:
time_delta = last_end - interval['start']
interval['start'] += time_delta
interval['end'] += time_delta
last_end = interval['end']
new_interval = {
'station': station
}
new_interval.update(interval)
all_intervals.append(new_interval)
# Make list of entries sorted on duration and time (stable sorted on station #)
all_intervals.sort(key=lambda inter: inter['end'] - inter['start'])
all_intervals.sort(key=lambda inter: inter['start'])
# If we have processed some intervals before, we should skip all that were scheduled before them
for to_skip in skip_intervals:
index = 0
while index < len(all_intervals):
interval = all_intervals[index]
if interval['original_start'] < to_skip['original_start'] and (not to_skip['blocked'] or interval['blocked']):
del all_intervals[index]
elif interval['uid'] == to_skip['uid']:
del all_intervals[index]
break
else:
index += 1
# And make sure manual programs get priority:
all_intervals.sort(key=lambda inter: not inter['manual'])
# Try to add each interval
for interval in all_intervals:
if not interval['manual'] and not options.scheduler_enabled:
interval['blocked'] = 'disabled scheduler'
continue
elif not interval['manual'] and not stations.get(interval['station']).ignore_rain and \
rain_block_start <= interval['start'] < rain_block_end:
interval['blocked'] = 'rain delay'
continue
elif not interval['manual'] and not stations.get(interval['station']).ignore_rain and inputs.rain_sensed():
interval['blocked'] = 'rain sensor'
continue
elif not interval['fixed'] and interval['adjustment'] < interval['cut_off']:
interval['blocked'] = 'cut-off'
continue
if max_usage > 0:
usage_keys = sorted(usage_changes.keys())
start_usage = 0
start_key_index = -1
for index, key in enumerate(usage_keys):
if key > interval['start']:
break
start_key_index = index
start_usage += usage_changes[key]
failed = False
finished = False
while not failed and not finished:
parallel_usage = 0
parallel_current = 0
for index in range(start_key_index+1, len(usage_keys)):
key = usage_keys[index]
if key >= interval['end']:
break
parallel_current += usage_changes[key]
parallel_usage = max(parallel_usage, parallel_current)
if start_usage + parallel_usage + interval['usage'] <= max_usage:
start = interval['start']
end = interval['end']
if start not in usage_changes:
usage_changes[start] = 0
if end not in usage_changes:
usage_changes[end] = 0
usage_changes[start] += interval['usage']
usage_changes[end] -= interval['usage']
finished = True
else:
while not failed:
# Shift this interval to next possibility
start_key_index += 1
# No more options
if start_key_index >= len(usage_keys):
failed = True
else:
next_option = usage_keys[start_key_index]
next_change = usage_changes[next_option]
start_usage += next_change
# Lower usage at this starting point:
if next_change < 0:
skip_delay = False
if options.min_runtime > 0:
# Try to determine how long we have been running at this point:
min_runtime_delta = datetime.timedelta(seconds=options.min_runtime)
temp_usage = 0
running_since = next_option
not_running_since = next_option
for temp_index in range(0, start_key_index):
temp_usage_key = usage_keys[temp_index]
if temp_usage < 0.01 and usage_changes[temp_usage_key] > 0 and temp_usage_key - not_running_since > datetime.timedelta(seconds=3):
running_since = temp_usage_key
temp_usage += usage_changes[temp_usage_key]
if temp_usage < 0.01 and usage_changes[temp_usage_key] < 0:
not_running_since = temp_usage_key
if next_option - running_since < min_runtime_delta:
skip_delay = True
if skip_delay:
time_to_next = next_option - interval['start']
else:
time_to_next = next_option + delay_delta - interval['start']
interval['start'] += time_to_next
interval['end'] += time_to_next
break
if failed:
logging.warning('Could not schedule %s.', interval['uid'])
interval['blocked'] = 'scheduler error'
all_intervals.sort(key=lambda inter: inter['start'])
return all_intervals
def GET(self):
from ospy import server
qdict = web.input()
stop_all = get_input(qdict, 'stop_all', False, lambda x: True)
scheduler_enabled = get_input(qdict, 'scheduler_enabled', None, lambda x: x == '1')
manual_mode = get_input(qdict, 'manual_mode', None, lambda x: x == '1')
rain_block = get_input(qdict, 'rain_block', None, float)
level_adjustment = get_input(qdict, 'level_adjustment', None, float)
toggle_temp = get_input(qdict, 'toggle_temp', False, lambda x: True)
if stop_all:
if not options.manual_mode:
options.scheduler_enabled = False
programs.run_now_program = None
run_once.clear()
log.finish_run(None)
stations.clear()
if scheduler_enabled is not None:
options.scheduler_enabled = scheduler_enabled
if manual_mode is not None:
options.manual_mode = manual_mode
if rain_block is not None:
options.rain_block = datetime.datetime.now() + datetime.timedelta(hours=rain_block)
if level_adjustment is not None:
options.level_adjustment = level_adjustment / 100
if toggle_temp:
options.temp_unit = "F" if options.temp_unit == "C" else "C"
set_to = get_input(qdict, 'set_to', None, int)
sid = get_input(qdict, 'sid', 0, int) - 1
set_time = get_input(qdict, 'set_time', 0, int)
if set_to is not None and 0 <= sid < stations.count() and options.manual_mode:
if set_to: # if status is on
start = datetime.datetime.now()
new_schedule = {
'active': True,
'program': -1,
'station': sid,
'program_name': "Manual",
'fixed': True,
'cut_off': 0,
'manual': True,
'blocked': False,
'start': start,
'original_start': start,
'end': start + datetime.timedelta(days=3650),
'uid': '%s-%s-%d' % (str(start), "Manual", sid),
'usage': stations.get(sid).usage
}
if set_time > 0: # if an optional duration time is given
new_schedule['end'] = datetime.datetime.now() + datetime.timedelta(seconds=set_time)
log.start_run(new_schedule)
stations.activate(new_schedule['station'])
else: # If status is off
stations.deactivate(sid)
active = log.active_runs()
for interval in active:
if interval['station'] == sid:
log.finish_run(interval)
self._redirect_back()
def on_message(client, userdata, message):
log.clear(NAME)
log.info(
NAME,
datetime_string() + ' ' + _('Message received') + ': ' +
str(message.payload.decode("utf-8")))
#print("Message topic=",message.topic)
#print("Message qos=",message.qos)
#print("Message retain flag=",message.retain)
if plugin_options["use_mqtt_secondary"]:
if not options.manual_mode: # check operation status
log.info(
NAME,
datetime_string() + ' ' +
_('You must this OSPy switch to manual mode!'))
return
if inputs.rain_sensed(): # check rain sensor
log.info(
NAME,
datetime_string() + ' ' +
_('Skipping command, rain sense is detected!'))
return
if rain_blocks.seconds_left(): # check rain delay
log.info(
NAME,
datetime_string() + ' ' +
_('Skipping command, rain delay is activated!'))
return
try:
rec_data = str(message.payload)
cmd = json.loads(rec_data)
except ValueError as e:
log.info(NAME,
_('Could not decode command:') + ':\n' + message.payload,
e)
return
first = int(
plugin_options["first_station"]) - 1 # first secondary station
count = int(plugin_options["station_count"]) # count secondary station
try:
for i in range(
first, first +
count): # count of station (example on main OSPy: 5 to 10)
zone = cmd[i]["status"] # "off" or "on" state
#station = cmd[i]["station"]
#name = cmd[i]["name"]
#print station, name, zone
sid = i - first
if sid <= stations.count(): # local station size check
if zone == "on":
start = datetime.datetime.now()
mqn = _('MQTT Manual')
new_schedule = {
'active': True,
'program': -1,
'station': sid,
'program_name': mqn,
'fixed': True,
'cut_off': 0,
'manual': True,
'blocked': False,
'start': start,
'original_start': start,
'end': start + datetime.timedelta(days=3650),
'uid': '%s-%s-%d' % (str(start), mqn, sid),
'usage': stations.get(sid).usage
}
# if an optional duration time is given
#set_time = xxx second
#new_schedule['end'] = datetime.datetime.now() + datetime.timedelta(seconds=set_time)
log.start_run(new_schedule)
stations.activate(new_schedule['station'])
if zone == "off":
stations.deactivate(sid)
active = log.active_runs()
for interval in active:
if interval['station'] == i:
log.finish_run(interval)
else:
log.error(
NAME,
_('MQTT plug-in') + ':\n' +
_('Setup stations count is smaler! Set correct first station and station count.'
))
except Exception:
log.error(NAME, _('MQTT plug-in') + ':\n' + traceback.format_exc())
time.sleep(1)
def POST(self):
qdict = web.input()
change = False # if change language -> restart ospy
if 'lang' in qdict and qdict['lang']:
if options.lang != qdict['lang']:
change = True
qdict['name'] = qdict['name']
qdict['location'] = qdict['location']
qdict['darksky_key'] = qdict['darksky_key']
qdict['HTTP_web_ip'] = qdict['HTTP_web_ip']
save_to_options(qdict)
if 'master' in qdict:
m = int(qdict['master'])
if m < 0:
stations.master = None
elif m < stations.count():
stations.master = m
if 'master_two' in qdict:
m = int(qdict['master_two'])
if m < 0:
stations.master_two = None
elif m < stations.count():
stations.master_two = m
if 'old_password' in qdict and qdict['old_password'] != "":
try:
if test_password(qdict['old_password']):
if qdict['new_password'] == "":
raise web.seeother('/options?errorCode=pw_blank')
elif qdict['new_password'] == qdict['check_password']:
options.password_salt = password_salt() # Make a new salt
options.password_hash = password_hash(qdict['new_password'], options.password_salt)
else:
raise web.seeother('/options?errorCode=pw_mismatch')
else:
raise web.seeother('/options?errorCode=pw_wrong')
except KeyError:
pass
if 'rbt' in qdict and qdict['rbt'] == '1':
report_rebooted()
reboot(True) # Linux HW software
return self.core_render.home()
if 'rstrt' in qdict and qdict['rstrt'] == '1':
report_restarted()
restart() # OSPy software
return self.core_render.restarting(home_page)
if 'pwrdwn' in qdict and qdict['pwrdwn'] == '1':
poweroff() # shutdown HW system
return self.core_render.restarting(home_page)
if 'deldef' in qdict and qdict['deldef'] == '1':
OPTIONS_FILE = './ospy/data'
try:
import shutil, time
shutil.rmtree(OPTIONS_FILE) # delete data folder
time.sleep(2)
os.makedirs(OPTIONS_FILE) # create data folder
report_restarted()
restart() # restart OSPy software
return self.core_render.restarting(home_page)
except:
pass
if change:
report_restarted()
restart() # OSPy software
return self.core_render.restarting(home_page)
report_option_change()
raise web.seeother('/')
def POST(self):
qdict = web.input()
change = False # if change language -> restart ospy
if 'lang' in qdict and qdict['lang']:
if options.lang != qdict['lang']:
change = True
newname = qdict['name'] # if name is asci char
try:
from ospy.helpers import ASCI_convert
qdict['name'] = ASCI_convert(newname)
except:
qdict['name'] = ' '
save_to_options(qdict)
if 'master' in qdict:
m = int(qdict['master'])
if m < 0:
stations.master = None
elif m < stations.count():
stations.master = m
if 'master_two' in qdict:
m = int(qdict['master_two'])
if m < 0:
stations.master_two = None
elif m < stations.count():
stations.master_two = m
if 'old_password' in qdict and qdict['old_password'] != "":
try:
if test_password(qdict['old_password']):
if qdict['new_password'] == "":
raise web.seeother('/options?errorCode=pw_blank')
elif qdict['new_password'] == qdict['check_password']:
options.password_salt = password_salt(
) # Make a new salt
options.password_hash = password_hash(
qdict['new_password'], options.password_salt)
else:
raise web.seeother('/options?errorCode=pw_mismatch')
else:
raise web.seeother('/options?errorCode=pw_wrong')
except KeyError:
pass
if 'rbt' in qdict and qdict['rbt'] == '1':
reboot(True) # Linux HW software
return self.core_render.home()
if 'rstrt' in qdict and qdict['rstrt'] == '1':
restart() # OSPy software
return self.core_render.restarting(home_page)
if 'pwrdwn' in qdict and qdict['pwrdwn'] == '1':
poweroff() # shutdown HW system
return self.core_render.restarting(home_page)
if 'deldef' in qdict and qdict['deldef'] == '1':
OPTIONS_FILE = './ospy/data'
try:
import shutil, time
shutil.rmtree(OPTIONS_FILE) # delete data folder
time.sleep(2)
os.makedirs(OPTIONS_FILE) # create data folder
restart() # restart OSPy software
return self.core_render.restarting(home_page)
except:
pass
if change:
restart() # OSPy software
return self.core_render.restarting(home_page)
raise web.seeother('/')