def admin_dependencies(device): """ Display Dependency page """ form_dependencies = forms_dependencies.Dependencies() if device != '0': # Only loading a single dependency page device_unmet_dependencies, _ = utils_general.return_dependencies( device) elif form_dependencies.device.data: device_unmet_dependencies, _ = utils_general.return_dependencies( form_dependencies.device.data) else: device_unmet_dependencies = [] unmet_dependencies = OrderedDict() unmet_exist = False met_dependencies = [] met_exist = False unmet_list = {} install_in_progress = False device_name = None # Read from the dependency status file created by the upgrade script # to indicate if the upgrade is running. try: with open(DEPENDENCY_INIT_FILE) as f: dep = int(f.read(1)) except (IOError, ValueError): try: with open(DEPENDENCY_INIT_FILE, 'w') as f: f.write('0') finally: dep = 0 if dep: install_in_progress = True list_dependencies = [ parse_function_information(), parse_input_information(), parse_output_information(), CALIBRATION_INFO, CAMERA_INFO, FUNCTION_ACTION_INFO, FUNCTION_INFO, LCD_INFO, MATH_INFO, METHOD_INFO, ] for each_section in list_dependencies: for each_device in each_section: if device in each_section: for each_device_, each_val in each_section[device].items(): if each_device_ in ['name', 'input_name']: device_name = each_val # Only get all dependencies when not loading a single dependency page if device == '0': # Determine if there are any unmet dependencies for every device dep_unmet, dep_met = utils_general.return_dependencies( each_device) unmet_dependencies.update({each_device: dep_unmet}) if dep_unmet: unmet_exist = True # Determine if there are any met dependencies if dep_met: if each_device not in met_dependencies: met_dependencies.append(each_device) met_exist = True # Find all the devices that use each unmet dependency if unmet_dependencies[each_device]: for each_dep in unmet_dependencies[each_device]: if each_dep not in unmet_list: unmet_list[each_dep] = [] if each_device not in unmet_list[each_dep]: unmet_list[each_dep].append(each_device) if request.method == 'POST': if not utils_general.user_has_permission('edit_controllers'): return redirect( url_for('routes_admin.admin_dependencies', device=device)) if form_dependencies.install.data: with open(DEPENDENCY_INIT_FILE, 'w') as f: f.write('1') install_deps = threading.Thread(target=install_dependencies, args=(device_unmet_dependencies, )) install_deps.start() return redirect( url_for('routes_admin.admin_dependencies', device=device)) return render_template('admin/dependencies.html', measurements=parse_input_information(), unmet_list=unmet_list, device=device, device_name=device_name, install_in_progress=install_in_progress, unmet_dependencies=unmet_dependencies, unmet_exist=unmet_exist, met_dependencies=met_dependencies, met_exist=met_exist, form_dependencies=form_dependencies, device_unmet_dependencies=device_unmet_dependencies)
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)
from mycodo.config import INSTALL_DIRECTORY from mycodo.scripts.generate_doc_output import generate_controller_doc from mycodo.utils.functions import parse_function_information save_path = os.path.join(INSTALL_DIRECTORY, "docs/Supported-Functions.md") functions_info = OrderedDict() mycodo_info = OrderedDict() def repeat_to_length(s, wanted): return (s * (wanted//len(s) + 1))[:wanted] if __name__ == "__main__": for function_id, function_data in parse_function_information(exclude_custom=True).items(): name_str = "" if 'function_name' in function_data and function_data['function_name']: name_str += ": {}".format(function_data['function_name']) if 'function_library' in function_data and function_data['function_library']: name_str += ": {}".format(function_data['function_library']) if name_str in functions_info and 'dependencies_module' in functions_info[name_str]: # Multiple sets of dependencies, append library functions_info[name_str]['dependencies_module'].append(function_data['dependencies_module']) else: # Only one set of dependencies functions_info[name_str] = function_data if 'dependencies_module' in function_data: functions_info[name_str]['dependencies_module'] = [function_data['dependencies_module']] # turn into list
def controller_mod(form_mod, request_form): """Modify a Custom Function""" messages = { "success": [], "info": [], "warning": [], "error": [], "name": None } page_refresh = False 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: messages["error"].append( gettext("Deactivate controller before modifying its settings")) mod_controller.name = form_mod.name.data messages["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 messages[ "error"], custom_options = custom_channel_options_return_json( messages["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 messages[ "error"], custom_options_json_postsave = custom_options_return_json( messages["error"], dict_controllers, request_form=request_form, mod_dev=mod_controller, 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: messages[ "error"], custom_options_channels_json_postsave_tmp = custom_channel_options_return_json( messages["error"], dict_controllers, request_form, form_mod.function_id.data, each_channel.channel, device=mod_controller.device, use_defaults=False) 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, page_refresh, 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: messages["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 messages["error"]: db.session.commit() messages["success"].append('{action} {controller}'.format( action=TRANSLATIONS['modify']['title'], controller=TRANSLATIONS['controller']['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: messages["error"].append(str(except_msg)) return messages, page_refresh
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' # TODO: Switch to JSON function list_options = [] if 'custom_options' in dict_controllers[function_name]: for each_option in dict_controllers[function_name]['custom_options']: if 'id' not in each_option: continue if each_option['default_value'] is False: default_value = '' else: default_value = each_option['default_value'] option = '{id},{value}'.format( id=each_option['id'], value=default_value) list_options.append(option) new_func.custom_options = ';'.join(list_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 dep_name = None 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]) messages["error"].append( "{dev} has unmet dependencies. They must be installed before the Function can be added." .format(dev=function_name)) if function_name in dict_controllers: dep_name = dict_controllers[function_name]['function_name'] else: messages["error"].append( "Function not found: {}".format(function_name)) return messages, dep_name, list_unmet_deps, 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("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''' new_func.conditional_status = ''' # Example code to provide a return status for other controllers and widgets. status_dict = { 'string_status': "This is the demo status of the conditional controller. " "The controller has looped {} times".format(self.loop_count), '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( "Unknown function type: '{}'".format(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('{action} {controller}'.format( action=TRANSLATIONS['add']['title'], controller=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, dep_unmet, 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: 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 channels = FunctionChannel.query.filter( FunctionChannel.function_id == form_mod.function_id.data) # 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_measurement.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() # Generate string to save from custom options error, custom_options = custom_options_return_json( error, dict_controllers, request_form=request_form, device=mod_controller.device, use_defaults=True) mod_controller.custom_options = custom_options 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'))
def page_function_submit(): """ Submit form for Data page """ messages = {"success": [], "info": [], "warning": [], "error": []} page_refresh = False action_id = None condition_id = None function_id = None dep_unmet = '' dep_name = '' dep_list = [] if not utils_general.user_has_permission('edit_controllers'): messages["error"].append("Your permissions do not allow this action") form_actions = forms_function.Actions() form_add_function = forms_function.FunctionAdd() form_conditional = forms_conditional.Conditional() form_conditional_conditions = forms_conditional.ConditionalConditions() form_function = forms_custom_controller.CustomController() form_function_base = forms_function.FunctionMod() form_mod_pid_base = forms_pid.PIDModBase() form_mod_pid_output_raise = forms_pid.PIDModRelayRaise() form_mod_pid_output_lower = forms_pid.PIDModRelayLower() form_mod_pid_pwm_raise = forms_pid.PIDModPWMRaise() form_mod_pid_pwm_lower = forms_pid.PIDModPWMLower() form_mod_pid_value_raise = forms_pid.PIDModValueRaise() form_mod_pid_value_lower = forms_pid.PIDModValueLower() form_mod_pid_volume_raise = forms_pid.PIDModVolumeRaise() form_mod_pid_volume_lower = forms_pid.PIDModVolumeLower() form_trigger = forms_trigger.Trigger() if not messages["error"]: if form_add_function.function_add.data: (messages, dep_name, dep_list, function_id) = utils_function.function_add(form_add_function) if dep_list: dep_unmet = form_add_function.function_type.data else: function_id = form_function_base.function_id.data controller_type = determine_controller_type(function_id) if form_function_base.function_mod.data: if controller_type == "Conditional": messages = utils_conditional.conditional_mod( form_conditional) elif controller_type == "PID": messages, page_refresh = utils_pid.pid_mod( form_mod_pid_base, form_mod_pid_pwm_raise, form_mod_pid_pwm_lower, form_mod_pid_output_raise, form_mod_pid_output_lower, form_mod_pid_value_raise, form_mod_pid_value_lower, form_mod_pid_volume_raise, form_mod_pid_volume_lower) elif controller_type == "Trigger": messages = utils_trigger.trigger_mod(form_trigger) elif controller_type == "Function": messages = utils_function.function_mod(form_function_base) elif controller_type == "Function_Custom": messages, page_refresh = utils_controller.controller_mod( form_function, request.form) elif form_function_base.function_delete.data: if controller_type == "Conditional": messages = utils_conditional.conditional_del(function_id) elif controller_type == "PID": messages = utils_pid.pid_del(function_id) elif controller_type == "Trigger": messages = utils_trigger.trigger_del(function_id) elif controller_type == "Function": messages = utils_function.function_del(function_id) elif controller_type == "Function_Custom": messages = utils_controller.controller_del(function_id) elif form_function_base.function_activate.data: if controller_type == "Conditional": messages = utils_conditional.conditional_activate( function_id) elif controller_type == "PID": messages = utils_pid.pid_activate(function_id) elif controller_type == "Trigger": messages = utils_trigger.trigger_activate(function_id) elif controller_type == "Function_Custom": messages = utils_controller.controller_activate( function_id) elif form_function_base.function_deactivate.data: if controller_type == "Conditional": messages = utils_conditional.conditional_deactivate( function_id) elif controller_type == "PID": messages = utils_pid.pid_deactivate(function_id) elif controller_type == "Trigger": messages = utils_trigger.trigger_deactivate(function_id) elif controller_type == "Function_Custom": messages = utils_controller.controller_deactivate( function_id) elif form_function_base.execute_all_actions.data: if controller_type == "Conditional": messages = utils_function.action_execute_all( form_conditional) elif controller_type == "Trigger": messages = utils_function.action_execute_all( form_conditional) elif controller_type == "Function": messages = utils_function.action_execute_all( form_conditional) # PID elif form_mod_pid_base.pid_hold.data: messages = utils_pid.pid_manipulate( form_mod_pid_base.function_id.data, 'Hold') elif form_mod_pid_base.pid_pause.data: messages = utils_pid.pid_manipulate( form_mod_pid_base.function_id.data, 'Pause') elif form_mod_pid_base.pid_resume.data: messages = utils_pid.pid_manipulate( form_mod_pid_base.function_id.data, 'Resume') # Actions elif form_function_base.add_action.data: (messages, dep_name, dep_list, action_id, page_refresh) = utils_function.action_add(form_function_base) elif form_actions.save_action.data: messages = utils_function.action_mod(form_actions, request.form) elif form_actions.delete_action.data: messages = utils_function.action_del(form_actions) page_refresh = True action_id = form_actions.function_action_id.data # Conditions elif form_conditional.add_condition.data: (messages, condition_id) = utils_conditional.conditional_condition_add( form_conditional) page_refresh = True function_id = form_actions.function_id.data elif form_conditional_conditions.save_condition.data: messages = utils_conditional.conditional_condition_mod( form_conditional_conditions) elif form_conditional_conditions.delete_condition.data: messages = utils_conditional.conditional_condition_del( form_conditional_conditions) page_refresh = True condition_id = form_conditional_conditions.conditional_condition_id.data # Custom action else: custom_button = False for key in request.form.keys(): if key.startswith('custom_button_'): custom_button = True break if custom_button: messages = utils_general.custom_action( "Function_Custom", parse_function_information(), form_function.function_id.data, request.form) else: messages["error"].append("Unknown function directive") return jsonify( data={ 'action_id': action_id, 'condition_id': condition_id, 'function_id': function_id, 'dep_name': dep_name, 'dep_list': dep_list, 'dep_unmet': dep_unmet, 'messages': messages, "page_refresh": page_refresh })
def page_function(): """ Display Function page options """ function_type = request.args.get('function_type', None) function_id = request.args.get('function_id', None) action_id = request.args.get('action_id', None) condition_id = request.args.get('condition_id', None) each_function = None each_action = None each_condition = None function_page_entry = None function_page_options = None if function_type in ['entry', 'options', 'conditions', 'actions' ] and function_id != '0': controller_type = determine_controller_type(function_id) if controller_type == "Conditional": each_function = Conditional.query.filter( Conditional.unique_id == function_id).first() function_page_entry = 'pages/function_options/conditional_entry.html' function_page_options = 'pages/function_options/conditional_options.html' elif controller_type == "PID": each_function = PID.query.filter( PID.unique_id == function_id).first() function_page_entry = 'pages/function_options/pid_entry.html' function_page_options = 'pages/function_options/pid_options.html' elif controller_type == "Trigger": each_function = Trigger.query.filter( Trigger.unique_id == function_id).first() function_page_entry = 'pages/function_options/trigger_entry.html' function_page_options = 'pages/function_options/trigger_options.html' elif controller_type == "Function": each_function = Function.query.filter( Function.unique_id == function_id).first() function_page_entry = 'pages/function_options/function_entry.html' function_page_options = 'pages/function_options/function_options.html' elif controller_type == "Function_Custom": each_function = CustomController.query.filter( CustomController.unique_id == function_id).first() function_page_entry = 'pages/function_options/custom_function_entry.html' function_page_options = 'pages/function_options/custom_function_options.html' if function_type == 'actions': if action_id: each_action = Actions.query.filter( Actions.unique_id == action_id).first() if function_type == 'conditions': if condition_id: each_condition = ConditionalConditions.query.filter( ConditionalConditions.unique_id == condition_id).first() camera = Camera.query.all() conditional = Conditional.query.all() conditional_conditions = ConditionalConditions.query.all() function = CustomController.query.all() function_channel = FunctionChannel.query.all() function_dev = Function.query.all() actions = Actions.query.all() input_dev = Input.query.all() lcd = LCD.query.all() math = Math.query.all() measurement = Measurement.query.all() method = Method.query.all() tags = NoteTags.query.all() output = Output.query.all() output_channel = OutputChannel.query.all() pid = PID.query.all() trigger = Trigger.query.all() unit = Unit.query.all() user = User.query.all() display_order_function = csv_to_list_of_str( DisplayOrder.query.first().function) form_add_function = forms_function.FunctionAdd() form_mod_pid_base = forms_pid.PIDModBase() form_mod_pid_output_raise = forms_pid.PIDModRelayRaise() form_mod_pid_output_lower = forms_pid.PIDModRelayLower() form_mod_pid_pwm_raise = forms_pid.PIDModPWMRaise() form_mod_pid_pwm_lower = forms_pid.PIDModPWMLower() form_mod_pid_value_raise = forms_pid.PIDModValueRaise() form_mod_pid_value_lower = forms_pid.PIDModValueLower() form_mod_pid_volume_raise = forms_pid.PIDModVolumeRaise() form_mod_pid_volume_lower = forms_pid.PIDModVolumeLower() form_function_base = forms_function.FunctionMod() form_trigger = forms_trigger.Trigger() form_conditional = forms_conditional.Conditional() form_conditional_conditions = forms_conditional.ConditionalConditions() form_function = forms_custom_controller.CustomController() form_actions = forms_function.Actions() dict_controllers = parse_function_information() # Generate all measurement and units used dict_measurements = add_custom_measurements(Measurement.query.all()) dict_units = add_custom_units(Unit.query.all()) dict_outputs = parse_output_information() custom_options_values_controllers = parse_custom_option_values( function, dict_controller=dict_controllers) custom_options_values_function_channels = parse_custom_option_values_function_channels_json( function_channel, dict_controller=function, key_name='custom_channel_options') # TODO: Update actions to use single-file modules and be consistent with other custom_options custom_options_values_actions = {} for each_action in actions: try: custom_options_values_actions[each_action.unique_id] = json.loads( each_action.custom_options) except: custom_options_values_actions[each_action.unique_id] = {} # Create lists of built-in and custom functions choices_functions = [] for choice_function in FUNCTIONS: choices_functions.append({ 'value': choice_function[0], 'item': choice_function[1] }) choices_custom_functions = utils_general.choices_custom_functions() # Combine function lists choices_functions_add = choices_functions + choices_custom_functions # Sort combined list choices_functions_add = sorted(choices_functions_add, key=lambda i: i['item']) custom_actions = {} for choice_function in function: if 'custom_actions' in dict_controllers[choice_function.device]: custom_actions[choice_function.device] = True choices_function = utils_general.choices_functions(function, dict_units, dict_measurements) choices_input = utils_general.choices_inputs(input_dev, dict_units, dict_measurements) choices_input_devices = utils_general.choices_input_devices(input_dev) choices_math = utils_general.choices_maths(math, dict_units, dict_measurements) choices_method = utils_general.choices_methods(method) choices_output = utils_general.choices_outputs(output, dict_units, dict_measurements) choices_output_channels = utils_general.choices_outputs_channels( output, output_channel, dict_outputs) choices_output_channels_measurements = utils_general.choices_outputs_channels_measurements( output, OutputChannel, dict_outputs, dict_units, dict_measurements) choices_pid = utils_general.choices_pids(pid, dict_units, dict_measurements) choices_measurements_units = utils_general.choices_measurements_units( measurement, unit) choices_controller_ids = utils_general.choices_controller_ids() actions_dict = {'conditional': {}, 'trigger': {}} for each_action in actions: if (each_action.function_type == 'conditional' and each_action.unique_id not in actions_dict['conditional']): actions_dict['conditional'][each_action.function_id] = True if (each_action.function_type == 'trigger' and each_action.unique_id not in actions_dict['trigger']): actions_dict['trigger'][each_action.function_id] = True conditions_dict = {} for each_cond in conditional_conditions: if each_cond.unique_id not in conditions_dict: conditions_dict[each_cond.conditional_id] = True controllers = [] controllers_all = [('Input', input_dev), ('Conditional', conditional), ('Function', function), ('LCD', lcd), ('Math', math), ('PID', pid), ('Trigger', trigger)] for each_controller in controllers_all: for each_cont in each_controller[1]: controllers.append((each_controller[0], each_cont.unique_id, each_cont.id, each_cont.name)) # Create dict of Function names names_function = {} all_elements = [conditional, pid, trigger, function_dev, function] for each_element in all_elements: for each_func_name in each_element: names_function[each_func_name.unique_id] = '[{id}] {name}'.format( id=each_func_name.unique_id.split('-')[0], name=each_func_name.name) # Calculate sunrise/sunset times if conditional controller is set up properly sunrise_set_calc = {} for each_trigger in trigger: if each_trigger.trigger_type == 'trigger_sunrise_sunset': sunrise_set_calc[each_trigger.unique_id] = {} try: sun = Sun(latitude=each_trigger.latitude, longitude=each_trigger.longitude, zenith=each_trigger.zenith) sunrise = sun.get_sunrise_time()['time_local'] sunset = sun.get_sunset_time()['time_local'] # Adjust for date offset new_date = datetime.datetime.now() + datetime.timedelta( days=each_trigger.date_offset_days) sun = Sun(latitude=each_trigger.latitude, longitude=each_trigger.longitude, zenith=each_trigger.zenith, day=new_date.day, month=new_date.month, year=new_date.year, offset_minutes=each_trigger.time_offset_minutes) offset_rise = sun.get_sunrise_time()['time_local'] offset_set = sun.get_sunset_time()['time_local'] sunrise_set_calc[each_trigger.unique_id]['sunrise'] = ( sunrise.strftime("%Y-%m-%d %H:%M")) sunrise_set_calc[each_trigger.unique_id]['sunset'] = ( sunset.strftime("%Y-%m-%d %H:%M")) sunrise_set_calc[each_trigger.unique_id]['offset_sunrise'] = ( offset_rise.strftime("%Y-%m-%d %H:%M")) sunrise_set_calc[each_trigger.unique_id]['offset_sunset'] = ( offset_set.strftime("%Y-%m-%d %H:%M")) except: logger.exception(1) sunrise_set_calc[each_trigger.unique_id]['sunrise'] = None sunrise_set_calc[each_trigger.unique_id]['sunrise'] = None sunrise_set_calc[ each_trigger.unique_id]['offset_sunrise'] = None sunrise_set_calc[ each_trigger.unique_id]['offset_sunset'] = None if not function_type: return render_template( 'pages/function.html', and_=and_, actions=actions, actions_dict=actions_dict, camera=camera, choices_controller_ids=choices_controller_ids, choices_custom_functions=choices_custom_functions, choices_function=choices_function, choices_functions=choices_functions, choices_functions_add=choices_functions_add, choices_input=choices_input, choices_input_devices=choices_input_devices, choices_math=choices_math, choices_measurements_units=choices_measurements_units, choices_method=choices_method, choices_output=choices_output, choices_output_channels=choices_output_channels, choices_output_channels_measurements= choices_output_channels_measurements, choices_pid=choices_pid, conditional_conditions_list=CONDITIONAL_CONDITIONS, conditional=conditional, conditional_conditions=conditional_conditions, conditions_dict=conditions_dict, controllers=controllers, function=function, function_channel=function_channel, custom_actions=custom_actions, custom_options_values_actions=custom_options_values_actions, custom_options_values_controllers=custom_options_values_controllers, custom_options_values_function_channels= custom_options_values_function_channels, dict_controllers=dict_controllers, dict_measurements=dict_measurements, dict_outputs=dict_outputs, dict_units=dict_units, display_order_function=display_order_function, form_conditional=form_conditional, form_conditional_conditions=form_conditional_conditions, form_function=form_function, form_actions=form_actions, form_add_function=form_add_function, form_function_base=form_function_base, form_mod_pid_base=form_mod_pid_base, form_mod_pid_pwm_raise=form_mod_pid_pwm_raise, form_mod_pid_pwm_lower=form_mod_pid_pwm_lower, form_mod_pid_output_raise=form_mod_pid_output_raise, form_mod_pid_output_lower=form_mod_pid_output_lower, form_mod_pid_value_raise=form_mod_pid_value_raise, form_mod_pid_value_lower=form_mod_pid_value_lower, form_mod_pid_volume_raise=form_mod_pid_volume_raise, form_mod_pid_volume_lower=form_mod_pid_volume_lower, form_trigger=form_trigger, function_action_info=FUNCTION_ACTION_INFO, function_dev=function_dev, function_types=FUNCTIONS, input=input_dev, lcd=lcd, math=math, method=method, names_function=names_function, output=output, output_types=output_types(), pid=pid, sunrise_set_calc=sunrise_set_calc, table_conversion=Conversion, table_device_measurements=DeviceMeasurements, table_input=Input, table_output=Output, tags=tags, trigger=trigger, units=MEASUREMENTS, user=user) elif function_type == 'entry': return render_template( function_page_entry, and_=and_, actions=actions, actions_dict=actions_dict, camera=camera, choices_controller_ids=choices_controller_ids, choices_custom_functions=choices_custom_functions, choices_function=choices_function, choices_functions=choices_functions, choices_functions_add=choices_functions_add, choices_input=choices_input, choices_input_devices=choices_input_devices, choices_math=choices_math, choices_measurements_units=choices_measurements_units, choices_method=choices_method, choices_output=choices_output, choices_output_channels=choices_output_channels, choices_output_channels_measurements= choices_output_channels_measurements, choices_pid=choices_pid, conditional_conditions_list=CONDITIONAL_CONDITIONS, conditional=conditional, conditional_conditions=conditional_conditions, conditions_dict=conditions_dict, controllers=controllers, function=function, function_channel=function_channel, custom_actions=custom_actions, custom_options_values_actions=custom_options_values_actions, custom_options_values_controllers=custom_options_values_controllers, custom_options_values_function_channels= custom_options_values_function_channels, dict_controllers=dict_controllers, dict_measurements=dict_measurements, dict_outputs=dict_outputs, dict_units=dict_units, display_order_function=display_order_function, each_function=each_function, form_conditional=form_conditional, form_conditional_conditions=form_conditional_conditions, form_function=form_function, form_actions=form_actions, form_add_function=form_add_function, form_function_base=form_function_base, form_mod_pid_base=form_mod_pid_base, form_mod_pid_pwm_raise=form_mod_pid_pwm_raise, form_mod_pid_pwm_lower=form_mod_pid_pwm_lower, form_mod_pid_output_raise=form_mod_pid_output_raise, form_mod_pid_output_lower=form_mod_pid_output_lower, form_mod_pid_value_raise=form_mod_pid_value_raise, form_mod_pid_value_lower=form_mod_pid_value_lower, form_mod_pid_volume_raise=form_mod_pid_volume_raise, form_mod_pid_volume_lower=form_mod_pid_volume_lower, form_trigger=form_trigger, function_action_info=FUNCTION_ACTION_INFO, function_dev=function_dev, function_types=FUNCTIONS, input=input_dev, lcd=lcd, math=math, method=method, names_function=names_function, output=output, output_types=output_types(), pid=pid, sunrise_set_calc=sunrise_set_calc, table_conversion=Conversion, table_device_measurements=DeviceMeasurements, table_input=Input, table_output=Output, tags=tags, trigger=trigger, units=MEASUREMENTS, user=user) elif function_type == 'options': return render_template( function_page_options, and_=and_, actions=actions, actions_dict=actions_dict, camera=camera, choices_controller_ids=choices_controller_ids, choices_custom_functions=choices_custom_functions, choices_function=choices_function, choices_functions=choices_functions, choices_functions_add=choices_functions_add, choices_input=choices_input, choices_input_devices=choices_input_devices, choices_math=choices_math, choices_measurements_units=choices_measurements_units, choices_method=choices_method, choices_output=choices_output, choices_output_channels=choices_output_channels, choices_output_channels_measurements= choices_output_channels_measurements, choices_pid=choices_pid, conditional_conditions_list=CONDITIONAL_CONDITIONS, conditional=conditional, conditional_conditions=conditional_conditions, conditions_dict=conditions_dict, controllers=controllers, each_function=each_function, function=function, function_channel=function_channel, custom_actions=custom_actions, custom_options_values_actions=custom_options_values_actions, custom_options_values_controllers=custom_options_values_controllers, custom_options_values_function_channels= custom_options_values_function_channels, dict_controllers=dict_controllers, dict_measurements=dict_measurements, dict_outputs=dict_outputs, dict_units=dict_units, display_order_function=display_order_function, form_conditional=form_conditional, form_conditional_conditions=form_conditional_conditions, form_function=form_function, form_actions=form_actions, form_add_function=form_add_function, form_function_base=form_function_base, form_mod_pid_base=form_mod_pid_base, form_mod_pid_pwm_raise=form_mod_pid_pwm_raise, form_mod_pid_pwm_lower=form_mod_pid_pwm_lower, form_mod_pid_output_raise=form_mod_pid_output_raise, form_mod_pid_output_lower=form_mod_pid_output_lower, form_mod_pid_value_raise=form_mod_pid_value_raise, form_mod_pid_value_lower=form_mod_pid_value_lower, form_mod_pid_volume_raise=form_mod_pid_volume_raise, form_mod_pid_volume_lower=form_mod_pid_volume_lower, form_trigger=form_trigger, function_action_info=FUNCTION_ACTION_INFO, function_dev=function_dev, function_types=FUNCTIONS, input=input_dev, lcd=lcd, math=math, method=method, names_function=names_function, output=output, output_types=output_types(), pid=pid, sunrise_set_calc=sunrise_set_calc, table_conversion=Conversion, table_device_measurements=DeviceMeasurements, table_input=Input, table_output=Output, tags=tags, trigger=trigger, units=MEASUREMENTS, user=user) elif function_type == 'actions': return render_template( 'pages/function_options/actions.html', and_=and_, actions=actions, actions_dict=actions_dict, camera=camera, choices_controller_ids=choices_controller_ids, choices_custom_functions=choices_custom_functions, choices_function=choices_function, choices_functions=choices_functions, choices_functions_add=choices_functions_add, choices_input=choices_input, choices_input_devices=choices_input_devices, choices_math=choices_math, choices_measurements_units=choices_measurements_units, choices_method=choices_method, choices_output=choices_output, choices_output_channels=choices_output_channels, choices_output_channels_measurements= choices_output_channels_measurements, choices_pid=choices_pid, conditional_conditions_list=CONDITIONAL_CONDITIONS, conditional=conditional, conditional_conditions=conditional_conditions, conditions_dict=conditions_dict, controllers=controllers, each_action=each_action, each_function=each_function, function=function, function_channel=function_channel, custom_actions=custom_actions, custom_options_values_actions=custom_options_values_actions, custom_options_values_controllers=custom_options_values_controllers, custom_options_values_function_channels= custom_options_values_function_channels, dict_controllers=dict_controllers, dict_measurements=dict_measurements, dict_outputs=dict_outputs, dict_units=dict_units, display_order_function=display_order_function, form_conditional=form_conditional, form_conditional_conditions=form_conditional_conditions, form_function=form_function, form_actions=form_actions, form_add_function=form_add_function, form_function_base=form_function_base, form_mod_pid_base=form_mod_pid_base, form_mod_pid_pwm_raise=form_mod_pid_pwm_raise, form_mod_pid_pwm_lower=form_mod_pid_pwm_lower, form_mod_pid_output_raise=form_mod_pid_output_raise, form_mod_pid_output_lower=form_mod_pid_output_lower, form_mod_pid_value_raise=form_mod_pid_value_raise, form_mod_pid_value_lower=form_mod_pid_value_lower, form_mod_pid_volume_raise=form_mod_pid_volume_raise, form_mod_pid_volume_lower=form_mod_pid_volume_lower, form_trigger=form_trigger, function_action_info=FUNCTION_ACTION_INFO, function_dev=function_dev, function_types=FUNCTIONS, input=input_dev, lcd=lcd, math=math, method=method, names_function=names_function, output=output, output_types=output_types(), pid=pid, sunrise_set_calc=sunrise_set_calc, table_conversion=Conversion, table_device_measurements=DeviceMeasurements, table_input=Input, table_output=Output, tags=tags, trigger=trigger, units=MEASUREMENTS, user=user) elif function_type == 'conditions': return render_template( 'pages/function_options/conditional_condition.html', and_=and_, actions=actions, actions_dict=actions_dict, camera=camera, choices_controller_ids=choices_controller_ids, choices_custom_functions=choices_custom_functions, choices_function=choices_function, choices_functions=choices_functions, choices_functions_add=choices_functions_add, choices_input=choices_input, choices_input_devices=choices_input_devices, choices_math=choices_math, choices_measurements_units=choices_measurements_units, choices_method=choices_method, choices_output=choices_output, choices_output_channels=choices_output_channels, choices_output_channels_measurements= choices_output_channels_measurements, choices_pid=choices_pid, conditional_conditions_list=CONDITIONAL_CONDITIONS, conditional=conditional, conditional_conditions=conditional_conditions, conditions_dict=conditions_dict, controllers=controllers, each_action=each_action, each_condition=each_condition, each_function=each_function, function=function, function_channel=function_channel, custom_actions=custom_actions, custom_options_values_actions=custom_options_values_actions, custom_options_values_controllers=custom_options_values_controllers, custom_options_values_function_channels= custom_options_values_function_channels, dict_controllers=dict_controllers, dict_measurements=dict_measurements, dict_outputs=dict_outputs, dict_units=dict_units, display_order_function=display_order_function, form_conditional=form_conditional, form_conditional_conditions=form_conditional_conditions, form_function=form_function, form_actions=form_actions, form_add_function=form_add_function, form_function_base=form_function_base, form_mod_pid_base=form_mod_pid_base, form_mod_pid_pwm_raise=form_mod_pid_pwm_raise, form_mod_pid_pwm_lower=form_mod_pid_pwm_lower, form_mod_pid_output_raise=form_mod_pid_output_raise, form_mod_pid_output_lower=form_mod_pid_output_lower, form_mod_pid_value_raise=form_mod_pid_value_raise, form_mod_pid_value_lower=form_mod_pid_value_lower, form_mod_pid_volume_raise=form_mod_pid_volume_raise, form_mod_pid_volume_lower=form_mod_pid_volume_lower, form_trigger=form_trigger, function_action_info=FUNCTION_ACTION_INFO, function_dev=function_dev, function_types=FUNCTIONS, input=input_dev, lcd=lcd, math=math, method=method, names_function=names_function, output=output, output_types=output_types(), pid=pid, sunrise_set_calc=sunrise_set_calc, table_conversion=Conversion, table_device_measurements=DeviceMeasurements, table_input=Input, table_output=Output, tags=tags, trigger=trigger, units=MEASUREMENTS, user=user) else: return "Could not determine template"