def execute_at_creation(error, new_func, dict_functions=None):
try:
dict_controllers = parse_function_information()
for channel in range(lcd_lines):
new_channel = FunctionChannel()
new_channel.name = "Set 0 Line {}".format(channel)
new_channel.function_id = new_func.unique_id
new_channel.channel = channel
error, custom_options = custom_channel_options_return_json(
error,
dict_controllers,
None,
new_func.unique_id,
channel,
device=new_func.device,
use_defaults=True)
custom_options_dict = json.loads(custom_options)
custom_options_dict["name"] = new_channel.name
new_channel.custom_options = json.dumps(custom_options_dict)
new_channel.save()
except Exception:
error.append("execute_at_modification() Error: {}".format(
traceback.print_exc()))
return error, new_func
def execute_at_modification(mod_function, request_form,
custom_options_dict_presave,
custom_options_channels_dict_presave,
custom_options_dict_postsave,
custom_options_channels_dict_postsave):
"""
This function allows you to view and modify the output and channel settings when the user clicks
save on the user interface. Both the output and channel settings are passed to this function, as
dictionaries. Additionally, both the pre-saved and post-saved options are available, as it's
sometimes useful to know what settings changed and from what values. You can modify the post-saved
options and these will be stored in the database.
:param mod_output: The post-saved output database entry, minus the custom_options settings
:param request_form: The requests.form object the user submitted
:param custom_options_dict_presave: dict of pre-saved custom output options
:param custom_options_channels_dict_presave: dict of pre-saved custom output channel options
:param custom_options_dict_postsave: dict of post-saved custom output options
:param custom_options_channels_dict_postsave: dict of post-saved custom output channel options
:return:
"""
allow_saving = True
page_refresh = False
success = []
error = []
try:
dict_controllers = parse_function_information()
channels = FunctionChannel.query.filter(
FunctionChannel.function_id == mod_function.unique_id)
# Ensure name doesn't get overwritten
selector_set = 0
selector_line = 0
for channel in range(channels.count()):
custom_options_channels_dict_postsave[channel][
"name"] = "Set {} Line {}".format(selector_set, selector_line)
selector_line += 1
if selector_line == lcd_lines:
selector_set += 1
selector_line = 0
end_channel = custom_options_dict_postsave[
'number_line_sets'] * lcd_lines
# Increase number of channels
if (custom_options_dict_postsave['number_line_sets'] >
custom_options_dict_presave['number_line_sets']):
page_refresh = True
start_channel = channels.count()
for index in range(start_channel, end_channel):
new_channel = FunctionChannel()
new_channel.name = "Set {} Line {}".format(
math.trunc(index / lcd_lines),
index - (math.trunc(index / lcd_lines) * lcd_lines))
new_channel.function_id = mod_function.unique_id
new_channel.channel = index
error, custom_options = custom_channel_options_return_json(
error,
dict_controllers,
request_form,
mod_function.unique_id,
index,
device=mod_function.device,
use_defaults=False)
custom_options_dict = json.loads(custom_options)
custom_options_dict["name"] = new_channel.name
new_channel.custom_options = json.dumps(custom_options_dict)
new_channel.save()
# Decrease number of channels
elif (custom_options_dict_postsave['number_line_sets'] <
custom_options_dict_presave['number_line_sets']):
page_refresh = True
for index, each_channel in enumerate(channels.all()):
if index >= end_channel:
delete_entry_with_id(FunctionChannel,
each_channel.unique_id)
except Exception:
error.append("execute_at_modification() Error: {}".format(
traceback.print_exc()))
allow_saving = False
for each_error in error:
flash(each_error, 'error')
for each_success in success:
flash(each_success, 'success')
return (allow_saving, page_refresh, mod_function,
custom_options_dict_postsave,
custom_options_channels_dict_postsave)
def function_add(form_add_func):
action = '{action} {controller}'.format(
action=TRANSLATIONS['add']['title'],
controller=TRANSLATIONS['function']['title'])
error = []
function_name = form_add_func.function_type.data
dict_controllers = parse_function_information()
if current_app.config['TESTING']:
dep_unmet = False
else:
dep_unmet, _ = return_dependencies(function_name)
if dep_unmet:
list_unmet_deps = []
for each_dep in dep_unmet:
list_unmet_deps.append(each_dep[0])
error.append(
"The {dev} device you're trying to add has unmet "
"dependencies: {dep}".format(
dev=function_name, dep=', '.join(list_unmet_deps)))
new_func = None
try:
if function_name == 'conditional_conditional':
new_func = Conditional()
new_func.conditional_statement = '''
# Example code for learning how to use a Conditional. See the manual for more information.
self.logger.info("This INFO log entry will appear in the Daemon Log")
self.logger.error("This ERROR log entry will appear in the Daemon Log")
# Replace "asdf1234" with a Condition ID
measurement = self.condition("{asdf1234}")
self.logger.info("Check this measurement in the Daemon Log. The value is {val}".format(val=measurement))
if measurement is not None: # If a measurement exists
self.message += "This message appears in email alerts and notes.\\n"
if measurement < 23: # If the measurement is less than 23
self.message += "Measurement is too Low! Measurement is {meas}\\n".format(meas=measurement)
self.run_all_actions(message=self.message) # Run all actions sequentially
elif measurement > 27: # Else If the measurement is greater than 27
self.message += "Measurement is too High! Measurement is {meas}\\n".format(meas=measurement)
# Replace "qwer5678" with an Action ID
self.run_action("{qwer5678}", message=self.message) # Run a single specific Action'''
if not error:
new_func.save()
save_conditional_code(
error,
new_func.conditional_statement,
new_func.unique_id,
ConditionalConditions.query.all(),
Actions.query.all(),
test=False)
elif function_name == 'pid_pid':
new_func = PID().save()
for each_channel, measure_info in PID_INFO['measure'].items():
new_measurement = DeviceMeasurements()
if 'name' in measure_info:
new_measurement.name = measure_info['name']
if 'measurement_type' in measure_info:
new_measurement.measurement_type = measure_info['measurement_type']
new_measurement.device_id = new_func.unique_id
new_measurement.measurement = measure_info['measurement']
new_measurement.unit = measure_info['unit']
new_measurement.channel = each_channel
if not error:
new_measurement.save()
elif function_name in ['trigger_edge',
'trigger_output',
'trigger_output_pwm',
'trigger_timer_daily_time_point',
'trigger_timer_daily_time_span',
'trigger_timer_duration',
'trigger_run_pwm_method',
'trigger_sunrise_sunset']:
new_func = Trigger()
new_func.name = '{}'.format(FUNCTION_INFO[function_name]['name'])
new_func.trigger_type = function_name
if not error:
new_func.save()
elif function_name in ['function_spacer',
'function_actions']:
new_func = Function()
if function_name == 'function_spacer':
new_func.name = 'Spacer'
new_func.function_type = function_name
if not error:
new_func.save()
elif function_name in dict_controllers:
# Custom Function Controller
new_func = CustomController()
new_func.device = function_name
if 'function_name' in dict_controllers[function_name]:
new_func.name = dict_controllers[function_name]['function_name']
else:
new_func.name = 'Function Name'
# Generate string to save from custom options
error, custom_options = custom_options_return_json(
error, dict_controllers, device=function_name, use_defaults=True)
new_func.custom_options = custom_options
if not error:
new_func.save()
elif function_name == '':
error.append("Must select a function type")
else:
error.append("Unknown function type: '{}'".format(
function_name))
if not error:
display_order = csv_to_list_of_str(
DisplayOrder.query.first().function)
DisplayOrder.query.first().function = add_display_order(
display_order, new_func.unique_id)
db.session.commit()
if function_name in dict_controllers:
#
# Add measurements defined in the Function Module
#
if ('measurements_dict' in dict_controllers[function_name] and
dict_controllers[function_name]['measurements_dict']):
for each_channel in dict_controllers[function_name]['measurements_dict']:
measure_info = dict_controllers[function_name]['measurements_dict'][each_channel]
new_measurement = DeviceMeasurements()
new_measurement.device_id = new_func.unique_id
if 'name' in measure_info:
new_measurement.name = measure_info['name']
else:
new_measurement.name = ""
if 'measurement' in measure_info:
new_measurement.measurement = measure_info['measurement']
else:
new_measurement.measurement = ""
if 'unit' in measure_info:
new_measurement.unit = measure_info['unit']
else:
new_measurement.unit = ""
new_measurement.channel = each_channel
new_measurement.save()
#
# If there are a variable number of measurements
#
elif ('measurements_variable_amount' in dict_controllers[function_name] and
dict_controllers[function_name]['measurements_variable_amount']):
# Add first default measurement with empty unit and measurement
new_measurement = DeviceMeasurements()
new_measurement.name = ""
new_measurement.device_id = new_func.unique_id
new_measurement.measurement = ""
new_measurement.unit = ""
new_measurement.channel = 0
new_measurement.save()
#
# Add channels defined in the Function Module
#
if 'channels_dict' in dict_controllers[function_name]:
for each_channel, channel_info in dict_controllers[function_name]['channels_dict'].items():
new_channel = FunctionChannel()
new_channel.channel = each_channel
new_channel.function_id = new_func.unique_id
# Generate string to save from custom options
error, custom_options = custom_channel_options_return_json(
error, dict_controllers, None,
new_func.unique_id, each_channel,
device=new_func.device, use_defaults=True)
new_channel.custom_options = custom_options
new_channel.save()
except sqlalchemy.exc.OperationalError as except_msg:
error.append(except_msg)
except sqlalchemy.exc.IntegrityError as except_msg:
error.append(except_msg)
except Exception as except_msg:
logger.exception("Add Function")
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_page.page_function'))
if dep_unmet:
return 1
def function_add(form_add_func):
messages = {"success": [], "info": [], "warning": [], "error": []}
new_function_id = None
list_unmet_deps = []
dep_name = None
dep_message = ''
function_name = form_add_func.function_type.data
dict_controllers = parse_function_information()
if not current_app.config['TESTING']:
dep_unmet, _, dep_message = return_dependencies(function_name)
if dep_unmet:
for each_dep in dep_unmet:
list_unmet_deps.append(each_dep[3])
messages["error"].append(
f"{function_name} has unmet dependencies. "
"They must be installed before the Function can be added.")
if function_name in dict_controllers:
dep_name = dict_controllers[function_name]['function_name']
else:
messages["error"].append(
f"Function not found: {function_name}")
return messages, dep_name, list_unmet_deps, dep_message, None
new_func = None
try:
if function_name == 'conditional_conditional':
new_func = Conditional()
new_func.position_y = 999
new_func.conditional_statement = '''
# Example code for learning how to use a Conditional. See the manual for more information.
self.logger.info("This INFO log entry will appear in the Daemon Log")
self.logger.error("This ERROR log entry will appear in the Daemon Log")
if not hasattr(self, "loop_count"): # Initialize objects saved across executions
self.loop_count = 1
else:
self.loop_count += 1
# Replace "asdf1234" with a Condition ID
measurement = self.condition("{asdf1234}")
self.logger.info(f"Check this measurement in the Daemon Log. The value is {measurement}")
if measurement is not None: # If a measurement exists
self.message += "This message appears in email alerts and notes.\\n"
if measurement < 23: # If the measurement is less than 23
self.message += f"Measurement is too Low! Measurement is {measurement}\\n"
self.run_all_actions(message=self.message) # Run all actions sequentially
elif measurement > 27: # Else If the measurement is greater than 27
self.message += f"Measurement is too High! Measurement is {measurement}\\n"
# Replace "qwer5678" with an Action ID
self.run_action("{qwer5678}", message=self.message) # Run a single specific Action'''
new_func.conditional_status = '''
# Example code to provide a return status for other controllers and widgets.
status_dict = {
'string_status': f"This is the demo status of the conditional controller. "
f"The controller has looped {self.loop_count} times",
'loop_count': self.loop_count,
'error': []
}
return status_dict'''
if not messages["error"]:
new_func.save()
new_function_id = new_func.unique_id
if not current_app.config['TESTING']:
save_conditional_code(messages["error"],
new_func.conditional_statement,
new_func.conditional_status,
new_func.unique_id,
ConditionalConditions.query.all(),
Actions.query.all(),
test=False)
elif function_name == 'pid_pid':
new_func = PID()
new_func.position_y = 999
new_func.save()
new_function_id = new_func.unique_id
for each_channel, measure_info in PID_INFO['measure'].items():
new_measurement = DeviceMeasurements()
if 'name' in measure_info:
new_measurement.name = measure_info['name']
if 'measurement_type' in measure_info:
new_measurement.measurement_type = measure_info[
'measurement_type']
new_measurement.device_id = new_func.unique_id
new_measurement.measurement = measure_info['measurement']
new_measurement.unit = measure_info['unit']
new_measurement.channel = each_channel
if not messages["error"]:
new_measurement.save()
elif function_name in [
'trigger_edge', 'trigger_output', 'trigger_output_pwm',
'trigger_timer_daily_time_point',
'trigger_timer_daily_time_span', 'trigger_timer_duration',
'trigger_run_pwm_method', 'trigger_sunrise_sunset'
]:
new_func = Trigger()
new_func.name = '{}'.format(FUNCTION_INFO[function_name]['name'])
new_func.trigger_type = function_name
new_func.position_y = 999
if not messages["error"]:
new_func.save()
new_function_id = new_func.unique_id
elif function_name == 'function_actions':
new_func = Function()
new_func.position_y = 999
new_func.function_type = function_name
if not messages["error"]:
new_func.save()
new_function_id = new_func.unique_id
elif function_name in dict_controllers:
# Custom Function Controller
new_func = CustomController()
new_func.device = function_name
new_func.position_y = 999
if 'function_name' in dict_controllers[function_name]:
new_func.name = dict_controllers[function_name][
'function_name']
else:
new_func.name = 'Function Name'
# Generate string to save from custom options
messages["error"], custom_options = custom_options_return_json(
messages["error"],
dict_controllers,
device=function_name,
use_defaults=True)
new_func.custom_options = custom_options
new_func.unique_id = set_uuid()
if ('execute_at_creation' in dict_controllers[new_func.device]
and not current_app.config['TESTING']):
messages["error"], new_func = dict_controllers[
new_func.device]['execute_at_creation'](
messages["error"], new_func,
dict_controllers[new_func.device])
if not messages["error"]:
new_func.save()
new_function_id = new_func.unique_id
elif function_name == '':
messages["error"].append("Must select a function type")
else:
messages["error"].append(
f"Unknown function type: '{function_name}'")
if not messages["error"]:
if function_name in dict_controllers:
#
# Add measurements defined in the Function Module
#
if ('measurements_dict' in dict_controllers[function_name] and
dict_controllers[function_name]['measurements_dict']):
for each_channel in dict_controllers[function_name][
'measurements_dict']:
measure_info = dict_controllers[function_name][
'measurements_dict'][each_channel]
new_measurement = DeviceMeasurements()
new_measurement.device_id = new_func.unique_id
if 'name' in measure_info:
new_measurement.name = measure_info['name']
else:
new_measurement.name = ""
if 'measurement' in measure_info:
new_measurement.measurement = measure_info[
'measurement']
else:
new_measurement.measurement = ""
if 'unit' in measure_info:
new_measurement.unit = measure_info['unit']
else:
new_measurement.unit = ""
new_measurement.channel = each_channel
new_measurement.save()
#
# If there are a variable number of measurements
#
elif ('measurements_variable_amount'
in dict_controllers[function_name]
and dict_controllers[function_name]
['measurements_variable_amount']):
# Add first default measurement with empty unit and measurement
new_measurement = DeviceMeasurements()
new_measurement.name = ""
new_measurement.device_id = new_func.unique_id
new_measurement.measurement = ""
new_measurement.unit = ""
new_measurement.channel = 0
new_measurement.save()
#
# Add channels defined in the Function Module
#
if 'channels_dict' in dict_controllers[function_name]:
for each_channel, channel_info in dict_controllers[
function_name]['channels_dict'].items():
new_channel = FunctionChannel()
new_channel.channel = each_channel
new_channel.function_id = new_func.unique_id
# Generate string to save from custom options
messages[
"error"], custom_options = custom_channel_options_return_json(
messages["error"],
dict_controllers,
None,
new_func.unique_id,
each_channel,
device=new_func.device,
use_defaults=True)
new_channel.custom_options = custom_options
new_channel.save()
messages["success"].append(
f"{TRANSLATIONS['add']['title']} {TRANSLATIONS['function']['title']}"
)
except sqlalchemy.exc.OperationalError as except_msg:
messages["error"].append(str(except_msg))
except sqlalchemy.exc.IntegrityError as except_msg:
messages["error"].append(str(except_msg))
except Exception as except_msg:
logger.exception("Add Function")
messages["error"].append(str(except_msg))
return messages, dep_name, list_unmet_deps, dep_message, new_function_id
def controller_mod(form_mod, request_form):
"""Modify a Custom Function"""
error = []
action = '{action} {controller}'.format(
action=TRANSLATIONS['modify']['title'],
controller=TRANSLATIONS['controller']['title'])
dict_controllers = parse_function_information()
try:
channels = FunctionChannel.query.filter(
FunctionChannel.function_id == form_mod.function_id.data).all()
mod_controller = CustomController.query.filter(
CustomController.unique_id == form_mod.function_id.data).first()
if mod_controller.is_activated:
error.append(
gettext("Deactivate controller before modifying its settings"))
mod_controller.name = form_mod.name.data
mod_controller.log_level_debug = form_mod.log_level_debug.data
# Enable/disable Channels
measurements = DeviceMeasurements.query.filter(
DeviceMeasurements.device_id == form_mod.function_id.data).all()
if form_mod.measurements_enabled.data:
for each_measurement in measurements:
if each_measurement.unique_id in form_mod.measurements_enabled.data:
each_measurement.is_enabled = True
else:
each_measurement.is_enabled = False
# Add or delete channels for variable measurement Inputs
if ('measurements_variable_amount'
in dict_controllers[mod_controller.device]
and dict_controllers[
mod_controller.device]['measurements_variable_amount']):
measurements = DeviceMeasurements.query.filter(
DeviceMeasurements.device_id == form_mod.function_id.data)
if measurements.count() != form_mod.num_channels.data:
# Delete measurements/channels
if form_mod.num_channels.data < measurements.count():
for index, each_channel in enumerate(measurements.all()):
if index + 1 >= measurements.count():
delete_entry_with_id(DeviceMeasurements,
each_channel.unique_id)
if ('channel_quantity_same_as_measurements'
in dict_controllers[mod_controller.device]
and dict_controllers[mod_controller.device]
["channel_quantity_same_as_measurements"]):
if form_mod.num_channels.data < channels.count():
for index, each_channel in enumerate(
channels.all()):
if index + 1 >= channels.count():
delete_entry_with_id(
FunctionChannel,
each_channel.unique_id)
# Add measurements/channels
elif form_mod.num_channels.data > measurements.count():
start_number = measurements.count()
for index in range(start_number,
form_mod.num_channels.data):
new_measurement = DeviceMeasurements()
new_measurement.name = ""
new_measurement.device_id = mod_controller.unique_id
new_measurement.measurement = ""
new_measurement.unit = ""
new_measurement.channel = index
new_measurement.save()
if ('channel_quantity_same_as_measurements'
in dict_controllers[mod_controller.device]
and dict_controllers[mod_controller.device]
["channel_quantity_same_as_measurements"]):
new_channel = FunctionChannel()
new_channel.name = ""
new_channel.function_id = mod_controller.unique_id
new_channel.channel = index
error, custom_options = custom_channel_options_return_json(
error,
dict_controllers,
request_form,
mod_controller.unique_id,
index,
device=mod_controller.device,
use_defaults=True)
new_channel.custom_options = custom_options
new_channel.save()
# Parse pre-save custom options for function device and its channels
try:
custom_options_dict_presave = json.loads(
mod_controller.custom_options)
except:
logger.error("Malformed JSON")
custom_options_dict_presave = {}
custom_options_channels_dict_presave = {}
for each_channel in channels:
if each_channel.custom_options and each_channel.custom_options != "{}":
custom_options_channels_dict_presave[
each_channel.channel] = json.loads(
each_channel.custom_options)
else:
custom_options_channels_dict_presave[each_channel.channel] = {}
# Parse post-save custom options for function device and its channels
error, custom_options_json_postsave = custom_options_return_json(
error,
dict_controllers,
request_form=request_form,
device=mod_controller.device,
use_defaults=True)
custom_options_dict_postsave = json.loads(custom_options_json_postsave)
custom_options_channels_dict_postsave = {}
for each_channel in channels:
error, custom_options_channels_json_postsave_tmp = custom_channel_options_return_json(
error,
dict_controllers,
request_form,
form_mod.function_id.data,
each_channel.channel,
device=mod_controller.device,
use_defaults=True)
custom_options_channels_dict_postsave[
each_channel.channel] = json.loads(
custom_options_channels_json_postsave_tmp)
if 'execute_at_modification' in dict_controllers[
mod_controller.device]:
# pass custom options to module prior to saving to database
(allow_saving, mod_controller, custom_options_dict,
custom_options_channels_dict) = dict_controllers[
mod_controller.device]['execute_at_modification'](
mod_controller, request_form, custom_options_dict_presave,
custom_options_channels_dict_presave,
custom_options_dict_postsave,
custom_options_channels_dict_postsave)
custom_options = json.dumps(
custom_options_dict) # Convert from dict to JSON string
custom_channel_options = custom_options_channels_dict
if not allow_saving:
error.append(
"execute_at_modification() would not allow function options to be saved"
)
else:
# Don't pass custom options to module
custom_options = json.dumps(custom_options_dict_postsave)
custom_channel_options = custom_options_channels_dict_postsave
# Finally, save custom options for both function and channels
mod_controller.custom_options = custom_options
for each_channel in channels:
if 'name' in custom_channel_options[each_channel.channel]:
each_channel.name = custom_channel_options[
each_channel.channel]['name']
each_channel.custom_options = json.dumps(
custom_channel_options[each_channel.channel])
if not error:
db.session.commit()
except sqlalchemy.exc.OperationalError as except_msg:
error.append(except_msg)
except sqlalchemy.exc.IntegrityError as except_msg:
error.append(except_msg)
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_page.page_function'))
