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