def choices_custom_controllers(): """ populate form multi-select choices from Input entries """ choices = [] dict_controllers = parse_controller_information() list_controllers_sorted = generate_form_controller_list(dict_controllers) for each_custom in list_controllers_sorted: value = '{inp}'.format(inp=each_custom) display = '{name}'.format( name=dict_controllers[each_custom]['controller_name']) choices.append({'value': value, 'item': display}) return choices
def get_installed_dependencies(): met_deps = [] list_dependencies = [ parse_controller_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 device_type in each_section: if 'dependencies_module' in each_section[device_type]: dep_mod = each_section[device_type]['dependencies_module'] for (install_type, package, install_id) in dep_mod: entry = '{0} {1}'.format(install_type, install_id) if install_type in ['pip-pypi', 'pip-git']: try: module = importlib.util.find_spec(package) if module is not None and entry not in met_deps: met_deps.append(entry) except Exception: logger.error( 'Exception checking python dependency: ' '{dep}'.format(dep=package)) elif install_type == 'apt': cmd = 'dpkg -l {}'.format(package) _, _, status = cmd_output(cmd, user='******') if not status and entry not in met_deps: met_deps.append(entry) return met_deps
def controller_mod(form, request_form): """Modify a Custom Controller""" error = [] action = '{action} {controller}'.format( action=TRANSLATIONS['modify']['title'], controller=TRANSLATIONS['controller']['title']) dict_controllers = parse_controller_information() try: mod_controller = CustomController.query.filter( CustomController.unique_id == form.function_id.data).first() if mod_controller.is_activated: error.append( gettext("Deactivate controller before modifying its settings")) mod_controller.name = form.name.data mod_controller.log_level_debug = form.log_level_debug.data # Generate string to save from custom options error, custom_options = custom_options_return_string( error, dict_controllers, mod_controller, request_form) if not error: mod_controller.custom_options = custom_options 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 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_controller_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 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_controller_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.startswith('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, test=False) elif function_name.startswith('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.startswith('trigger_'): 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.startswith('function_'): 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: new_func = CustomController() new_func.device = function_name if 'controller_name' in dict_controllers[function_name]: new_func.name = dict_controllers[function_name][ 'controller_name'] else: new_func.name = 'Controller Name' list_options = [] if 'custom_options' in dict_controllers[function_name]: for each_option in dict_controllers[function_name][ 'custom_options']: 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() 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')) if dep_unmet: return 1
def return_dependencies(device_type): unmet_deps = [] met_deps = False list_dependencies = [ parse_controller_information(), parse_input_information(), CALIBRATION_INFO, CAMERA_INFO, FUNCTION_ACTION_INFO, FUNCTION_INFO, LCD_INFO, MATH_INFO, METHOD_INFO, OUTPUT_INFO ] for each_section in list_dependencies: if device_type in each_section: for each_device, each_dict in each_section[device_type].items(): if not each_dict: met_deps = True elif each_device == 'dependencies_module': for (install_type, package, install_id) in each_dict: entry = ( package, '{0} {1}'.format(install_type, install_id), install_type, install_id ) if install_type in ['pip-pypi', 'pip-git']: try: module = importlib.util.find_spec(package) if module is None: if entry not in unmet_deps: unmet_deps.append(entry) else: met_deps = True except ImportError: if entry not in unmet_deps: unmet_deps.append(entry) elif install_type == 'apt': if (not dpkg_package_exists(package) and entry not in unmet_deps): unmet_deps.append(entry) else: met_deps = True elif install_type == 'internal': if package.startswith('file-exists'): filepath = package.split(' ', 1)[1] if not os.path.isfile(filepath): if entry not in unmet_deps: unmet_deps.append(entry) else: met_deps = True elif package.startswith('pip-exists'): py_module = package.split(' ', 1)[1] try: module = importlib.util.find_spec(py_module) if module is None: if entry not in unmet_deps: unmet_deps.append(entry) else: met_deps = True except ImportError: if entry not in unmet_deps: unmet_deps.append(entry) elif package.startswith('apt'): if (not dpkg_package_exists(package) and entry not in unmet_deps): unmet_deps.append(entry) else: met_deps = True return unmet_deps, met_deps