def dashboard_copy(form):
"""Duplicate a dashboard and its widgets"""
action = '{action} {controller}'.format(
action=TRANSLATIONS['duplicate']['title'],
controller=TRANSLATIONS['dashboard']['title'])
error = []
try:
# Get current dashboard and its widgets
dashboard = Dashboard.query.filter(
Dashboard.unique_id == form.dashboard_id.data).first()
widgets = Widget.query.filter(
Widget.dashboard_id == dashboard.unique_id).all()
# Duplicate dashboard with new unique_id and name
new_dashboard = clone_model(dashboard,
unique_id=set_uuid(),
name="New Dashboard")
# Duplicate all widgets and assign them to the new dashboard
for each_widget in widgets:
clone_model(each_widget,
unique_id=set_uuid(),
dashboard_id=new_dashboard.unique_id)
except Exception as msg:
error.append(msg)
logger.exception("Duplicating dashboard")
flash_success_errors(error, action,
url_for('routes_page.page_dashboard_default'))
def execute_at_creation(new_widget, dict_widget):
custom_options_json = json.loads(new_widget.custom_options)
uuid = set_uuid()
new_widget.unique_id = uuid
success, error = save_python_file(custom_options_json, uuid)
for each_error in error:
flash(each_error, 'error')
for each_success in success:
flash(each_success, 'success')
return new_widget
def input_duplicate(form_mod):
messages = {"success": [], "info": [], "warning": [], "error": []}
mod_input = Input.query.filter(
Input.unique_id == form_mod.input_id.data).first()
if not mod_input:
return None, None
# Duplicate dashboard with new unique_id and name
new_input = clone_model(mod_input,
unique_id=set_uuid(),
name=f"Copy of {mod_input.name}")
# Deactivate Input
mod_input = Input.query.filter(
Input.unique_id == new_input.unique_id).first()
if mod_input:
mod_input.is_activated = False
mod_input.save()
dev_measurements = DeviceMeasurements.query.filter(
DeviceMeasurements.device_id == form_mod.input_id.data).all()
for each_dev in dev_measurements:
clone_model(each_dev,
unique_id=set_uuid(),
device_id=mod_input.unique_id)
dev_channels = InputChannel.query.filter(
InputChannel.input_id == form_mod.input_id.data).all()
for each_dev in dev_channels:
clone_model(each_dev,
unique_id=set_uuid(),
input_id=mod_input.unique_id)
messages["success"].append(
f"{TRANSLATIONS['duplicate']['title']} {TRANSLATIONS['input']['title']}"
)
return messages, new_input.unique_id
def note_add(form):
action = '{action} {controller}'.format(
action=TRANSLATIONS['add']['title'],
controller=TRANSLATIONS['note']['title'])
error = []
list_tags = []
new_note = Notes()
if not form.name.data:
error.append("Name cannot be left blank")
if not form.note_tags.data:
error.append("At least one tag must be selected")
if not form.note.data:
error.append("Note cannot be left blank")
try:
for each_tag in form.note_tags.data:
check_tag = NoteTags.query.filter(
NoteTags.unique_id == each_tag).first()
if not check_tag:
error.append("Invalid tag: {}".format(each_tag))
else:
list_tags.append(check_tag.unique_id)
new_note.tags = ",".join(list_tags)
except Exception as msg:
error.append("Invalid tag format: {}".format(msg))
if form.enter_custom_date_time.data:
try:
new_note.date_time = datetime_time_to_utc(form.date_time.data)
except Exception as msg:
error.append("Error while parsing date/time: {}".format(msg))
if form.files.data:
new_note.unique_id = set_uuid()
assure_path_exists(PATH_NOTE_ATTACHMENTS)
filename_list = []
for each_file in form.files.raw_data:
file_name = "{pre}_{name}".format(pre=new_note.unique_id,
name=each_file.filename)
file_save_path = os.path.join(PATH_NOTE_ATTACHMENTS, file_name)
each_file.save(file_save_path)
filename_list.append(file_name)
new_note.files = ",".join(filename_list)
if not error:
new_note.name = form.name.data
new_note.note = form.note.data
new_note.save()
flash_success_errors(error, action, url_for('routes_page.page_notes'))
def note_add(form):
action = '{action} {controller}'.format(
action=TRANSLATIONS['add']['title'],
controller=TRANSLATIONS['note']['title'])
error = []
list_tags = []
new_note = Notes()
if not form.name.data:
error.append("Name cannot be left blank")
if not form.note_tags.data:
error.append("At least one tag must be selected")
if not form.note.data:
error.append("Note cannot be left blank")
try:
for each_tag in form.note_tags.data:
check_tag = NoteTags.query.filter(
NoteTags.unique_id == each_tag).first()
if not check_tag:
error.append("Invalid tag: {}".format(each_tag))
else:
list_tags.append(check_tag.unique_id)
new_note.tags = ",".join(list_tags)
except Exception as msg:
error.append("Invalid tag format: {}".format(msg))
if form.enter_custom_date_time.data:
try:
new_note.date_time = datetime_time_to_utc(form.date_time.data)
except Exception as msg:
error.append("Error while parsing date/time: {}".format(msg))
if form.files.data:
new_note.unique_id = set_uuid()
assure_path_exists(PATH_NOTE_ATTACHMENTS)
filename_list = []
for each_file in form.files.raw_data:
file_name = "{pre}_{name}".format(
pre=new_note.unique_id, name=each_file.filename)
file_save_path = os.path.join(PATH_NOTE_ATTACHMENTS, file_name)
each_file.save(file_save_path)
filename_list.append(file_name)
new_note.files = ",".join(filename_list)
if not error:
new_note.name = form.name.data
new_note.note = form.note.data
new_note.save()
flash_success_errors(error, action, url_for('routes_page.page_notes'))
def execute_at_creation(error, new_widget, dict_widget):
custom_options_json = json.loads(new_widget.custom_options)
uuid = set_uuid()
new_widget.unique_id = uuid
info, warning, success, errors = save_python_file(custom_options_json,
uuid)
for each_success in success:
flash(each_success, 'success')
for each_info in info:
flash(each_info, "info")
for each_warning in warning:
flash(each_warning, "warning")
for each_error in error:
flash(each_error, 'error')
return error, new_widget
def input_add(form_add):
action = '{action} {controller}'.format(
action=TRANSLATIONS['add']['title'],
controller=TRANSLATIONS['input']['title'])
error = []
dict_inputs = parse_input_information()
# only one comma should be in the input_type string
if form_add.input_type.data.count(',') > 1:
error.append("Invalid input module formatting. It appears there is "
"a comma in either 'input_name_unique' or 'interfaces'.")
if form_add.input_type.data.count(',') == 1:
input_name = form_add.input_type.data.split(',')[0]
input_interface = form_add.input_type.data.split(',')[1]
else:
input_name = ''
input_interface = ''
error.append("Invalid input string (must be a comma-separated string)")
if current_app.config['TESTING']:
dep_unmet = False
else:
dep_unmet, _ = return_dependencies(input_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=input_name, dep=', '.join(list_unmet_deps)))
if form_add.validate():
new_input = Input()
new_input.device = input_name
if input_interface:
new_input.interface = input_interface
try:
from RPi import GPIO
if GPIO.RPI_INFO['P1_REVISION'] == 1:
new_input.i2c_bus = 0
else:
new_input.i2c_bus = 1
except:
logger.error("RPi.GPIO and Raspberry Pi required for this action")
if 'input_name' in dict_inputs[input_name]:
new_input.name = dict_inputs[input_name]['input_name']
else:
new_input.name = 'Name'
#
# Set default values for new input being added
#
# input add options
if input_name in dict_inputs:
def dict_has_value(key):
if (key in dict_inputs[input_name]
and (dict_inputs[input_name][key]
or dict_inputs[input_name][key] == 0)):
return True
#
# Interfacing options
#
if input_interface == 'I2C':
if dict_has_value('i2c_location'):
new_input.i2c_location = dict_inputs[input_name][
'i2c_location'][0] # First entry in list
if input_interface == 'FTDI':
if dict_has_value('ftdi_location'):
new_input.ftdi_location = dict_inputs[input_name][
'ftdi_location']
if input_interface == 'UART':
if dict_has_value('uart_location'):
new_input.uart_location = dict_inputs[input_name][
'uart_location']
# UART options
if dict_has_value('uart_baud_rate'):
new_input.baud_rate = dict_inputs[input_name]['uart_baud_rate']
if dict_has_value('pin_cs'):
new_input.pin_cs = dict_inputs[input_name]['pin_cs']
if dict_has_value('pin_miso'):
new_input.pin_miso = dict_inputs[input_name]['pin_miso']
if dict_has_value('pin_mosi'):
new_input.pin_mosi = dict_inputs[input_name]['pin_mosi']
if dict_has_value('pin_clock'):
new_input.pin_clock = dict_inputs[input_name]['pin_clock']
# Bluetooth (BT) options
elif input_interface == 'BT':
if dict_has_value('bt_location'):
new_input.location = dict_inputs[input_name]['bt_location']
if dict_has_value('bt_adapter'):
new_input.bt_adapter = dict_inputs[input_name][
'bt_adapter']
# GPIO options
elif input_interface == 'GPIO':
if dict_has_value('gpio_location'):
new_input.gpio_location = dict_inputs[input_name][
'gpio_location']
# Custom location location
elif dict_has_value('location'):
new_input.location = dict_inputs[input_name]['location'][
'options'][0][0] # First entry in list
#
# General options
#
if dict_has_value('period'):
new_input.period = dict_inputs[input_name]['period']
# Server Ping options
if dict_has_value('times_check'):
new_input.times_check = dict_inputs[input_name]['times_check']
if dict_has_value('deadline'):
new_input.deadline = dict_inputs[input_name]['deadline']
if dict_has_value('port'):
new_input.port = dict_inputs[input_name]['port']
# Signal options
if dict_has_value('weighting'):
new_input.weighting = dict_inputs[input_name]['weighting']
if dict_has_value('sample_time'):
new_input.sample_time = dict_inputs[input_name]['sample_time']
# Analog-to-digital converter options
if dict_has_value('adc_gain'):
if len(dict_inputs[input_name]['adc_gain']) == 1:
new_input.adc_gain = dict_inputs[input_name]['adc_gain'][0]
elif len(dict_inputs[input_name]['adc_gain']) > 1:
new_input.adc_gain = dict_inputs[input_name]['adc_gain'][
0][0]
if dict_has_value('adc_resolution'):
if len(dict_inputs[input_name]['adc_resolution']) == 1:
new_input.adc_resolution = dict_inputs[input_name][
'adc_resolution'][0]
elif len(dict_inputs[input_name]['adc_resolution']) > 1:
new_input.adc_resolution = dict_inputs[input_name][
'adc_resolution'][0][0]
if dict_has_value('adc_sample_speed'):
if len(dict_inputs[input_name]['adc_sample_speed']) == 1:
new_input.adc_sample_speed = dict_inputs[input_name][
'adc_sample_speed'][0]
elif len(dict_inputs[input_name]['adc_sample_speed']) > 1:
new_input.adc_sample_speed = dict_inputs[input_name][
'adc_sample_speed'][0][0]
# Linux command
if dict_has_value('cmd_command'):
new_input.cmd_command = dict_inputs[input_name]['cmd_command']
# Misc options
if dict_has_value('resolution'):
if len(dict_inputs[input_name]['resolution']) == 1:
new_input.resolution = dict_inputs[input_name][
'resolution'][0]
elif len(dict_inputs[input_name]['resolution']) > 1:
new_input.resolution = dict_inputs[input_name][
'resolution'][0][0]
if dict_has_value('resolution_2'):
if len(dict_inputs[input_name]['resolution_2']) == 1:
new_input.resolution_2 = dict_inputs[input_name][
'resolution_2'][0]
elif len(dict_inputs[input_name]['resolution_2']) > 1:
new_input.resolution_2 = dict_inputs[input_name][
'resolution_2'][0][0]
if dict_has_value('sensitivity'):
if len(dict_inputs[input_name]['sensitivity']) == 1:
new_input.sensitivity = dict_inputs[input_name][
'sensitivity'][0]
elif len(dict_inputs[input_name]['sensitivity']) > 1:
new_input.sensitivity = dict_inputs[input_name][
'sensitivity'][0][0]
if dict_has_value('thermocouple_type'):
if len(dict_inputs[input_name]['thermocouple_type']) == 1:
new_input.thermocouple_type = dict_inputs[input_name][
'thermocouple_type'][0]
elif len(dict_inputs[input_name]['thermocouple_type']) > 1:
new_input.thermocouple_type = dict_inputs[input_name][
'thermocouple_type'][0][0]
if dict_has_value('sht_voltage'):
if len(dict_inputs[input_name]['sht_voltage']) == 1:
new_input.sht_voltage = dict_inputs[input_name][
'sht_voltage'][0]
elif len(dict_inputs[input_name]['sht_voltage']) > 1:
new_input.sht_voltage = dict_inputs[input_name][
'sht_voltage'][0][0]
if dict_has_value('ref_ohm'):
new_input.ref_ohm = dict_inputs[input_name]['ref_ohm']
#
# Custom Options
#
# Generate string to save from custom options
error, custom_options = custom_options_return_json(error,
dict_inputs,
device=input_name,
use_defaults=True)
new_input.custom_options = custom_options
#
# Execute at Creation
#
new_input.unique_id = set_uuid()
if ('execute_at_creation' in dict_inputs[new_input.device]
and not current_app.config['TESTING']):
new_input = dict_inputs[new_input.device]['execute_at_creation'](
new_input, dict_inputs[new_input.device])
try:
if not error:
new_input.save()
display_order = csv_to_list_of_str(
DisplayOrder.query.first().inputs)
DisplayOrder.query.first().inputs = add_display_order(
display_order, new_input.unique_id)
db.session.commit()
#
# If there are a variable number of measurements
#
if ('measurements_variable_amount' in dict_inputs[input_name]
and dict_inputs[input_name]
['measurements_variable_amount']):
# Add first default measurement with empty unit and measurement
new_measurement = DeviceMeasurements()
new_measurement.name = ""
new_measurement.device_id = new_input.unique_id
new_measurement.measurement = ""
new_measurement.unit = ""
new_measurement.channel = 0
new_measurement.save()
#
# If measurements defined in the Input Module
#
elif ('measurements_dict' in dict_inputs[input_name]
and dict_inputs[input_name]['measurements_dict'] != []):
for each_channel in dict_inputs[input_name][
'measurements_dict']:
measure_info = dict_inputs[input_name][
'measurements_dict'][each_channel]
new_measurement = DeviceMeasurements()
if 'name' in measure_info:
new_measurement.name = measure_info['name']
new_measurement.device_id = new_input.unique_id
new_measurement.measurement = measure_info[
'measurement']
new_measurement.unit = measure_info['unit']
new_measurement.channel = each_channel
new_measurement.save()
flash(
gettext(
"%(type)s Input with ID %(id)s (%(uuid)s) successfully added",
type=input_name,
id=new_input.id,
uuid=new_input.unique_id), "success")
except sqlalchemy.exc.OperationalError as except_msg:
error.append(except_msg)
except sqlalchemy.exc.IntegrityError as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_page.page_data'))
else:
flash_form_errors(form_add)
if dep_unmet:
return 1
email = input("Email Address: ")
while not passwords_match and not password_valid:
password = getpass("Password: "******"Repeat Password: "******"Password don't math. Try again.")
else:
passwords_match = True
try:
with session_scope(MYCODO_DB_PATH) as db_session:
new_user = User()
new_user.unique_id = set_uuid()
new_user.name = user_name.lower()
new_user.password_hash = set_password(password)
new_user.email = email
new_user.role_id = 1
new_user.theme = 'slate'
new_user.landing_page = 'live'
new_user.language = 'en'
db_session.add(new_user)
print("Admin user '{}' successfully created.".format(user_name.lower()))
except Exception:
print(
"Error creating admin user. Refer the the traceback, below, for the error."
)
traceback.print_exc()
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
email = input("Email Address: ")
while not passwords_match and not password_valid:
password = getpass("Password: "******"Repeat Password: "******"Password don't math. Try again.")
else:
passwords_match = True
try:
with session_scope(MYCODO_DB_PATH) as db_session:
new_user = User()
new_user.unique_id = set_uuid()
new_user.name = user_name.lower()
new_user.password_hash = set_password(password)
new_user.email = email
new_user.role_id = 1
new_user.theme = 'slate'
new_user.landing_page = 'live'
new_user.language = 'en'
db_session.add(new_user)
print("Admin user '{}' successfully created.".format(user_name.lower()))
except Exception:
print("Error creating admin user. Refer the the traceback, below, for the error.")
traceback.print_exc()
def input_add(form_add):
messages = {"success": [], "info": [], "warning": [], "error": []}
new_input_id = None
list_unmet_deps = []
dep_name = None
dep_message = ''
dict_inputs = parse_input_information()
# only one comma should be in the input_type string
if form_add.input_type.data.count(',') > 1:
messages["error"].append(
"Invalid input module formatting. It appears there is "
"a comma in either 'input_name_unique' or 'interfaces'.")
if form_add.input_type.data.count(',') == 1:
input_name = form_add.input_type.data.split(',')[0]
input_interface = form_add.input_type.data.split(',')[1]
else:
input_name = ''
input_interface = ''
messages["error"].append(
"Invalid input string (must be a comma-separated string)")
if not current_app.config['TESTING']:
dep_unmet, _, dep_message = return_dependencies(input_name)
if dep_unmet:
for each_dep in dep_unmet:
list_unmet_deps.append(each_dep[3])
messages["error"].append(
f"{input_name} has unmet dependencies. They must be installed before the Input can be added."
)
if input_name in dict_inputs:
dep_name = dict_inputs[input_name]['input_name']
else:
messages["error"].append(f"Input not found: {input_name}")
return messages, dep_name, list_unmet_deps, dep_message, None
if form_add.validate():
new_input = Input()
new_input.device = input_name
new_input.position_y = 999
if input_interface:
new_input.interface = input_interface
new_input.i2c_bus = 1
if 'input_name_short' in dict_inputs[input_name]:
new_input.name = dict_inputs[input_name]['input_name_short']
elif 'input_name' in dict_inputs[input_name]:
new_input.name = dict_inputs[input_name]['input_name']
else:
new_input.name = 'Name'
#
# Set default values for new input being added
#
# input add options
if input_name in dict_inputs:
def dict_has_value(key):
if (key in dict_inputs[input_name]
and (dict_inputs[input_name][key]
or dict_inputs[input_name][key] == 0)):
return True
#
# Interfacing options
#
if input_interface == 'I2C':
if dict_has_value('i2c_location'):
new_input.i2c_location = dict_inputs[input_name][
'i2c_location'][0] # First entry in list
if input_interface == 'FTDI':
if dict_has_value('ftdi_location'):
new_input.ftdi_location = dict_inputs[input_name][
'ftdi_location']
if input_interface == 'UART':
if dict_has_value('uart_location'):
new_input.uart_location = dict_inputs[input_name][
'uart_location']
# UART options
if dict_has_value('uart_baud_rate'):
new_input.baud_rate = dict_inputs[input_name]['uart_baud_rate']
if dict_has_value('pin_cs'):
new_input.pin_cs = dict_inputs[input_name]['pin_cs']
if dict_has_value('pin_miso'):
new_input.pin_miso = dict_inputs[input_name]['pin_miso']
if dict_has_value('pin_mosi'):
new_input.pin_mosi = dict_inputs[input_name]['pin_mosi']
if dict_has_value('pin_clock'):
new_input.pin_clock = dict_inputs[input_name]['pin_clock']
# Bluetooth (BT) options
elif input_interface == 'BT':
if dict_has_value('bt_location'):
if not re.match(
"[0-9a-fA-F]{2}([:]?)[0-9a-fA-F]{2}(\\1[0-9a-fA-F]{2}){4}$",
dict_inputs[input_name]['bt_location']):
messages["error"].append(
"Please specify device MAC-Address in format AA:BB:CC:DD:EE:FF"
)
else:
new_input.location = dict_inputs[input_name][
'bt_location']
if dict_has_value('bt_adapter'):
new_input.bt_adapter = dict_inputs[input_name][
'bt_adapter']
# GPIO options
elif input_interface == 'GPIO':
if dict_has_value('gpio_location'):
new_input.gpio_location = dict_inputs[input_name][
'gpio_location']
# Custom location location
elif dict_has_value('location'):
new_input.location = dict_inputs[input_name]['location'][
'options'][0][0] # First entry in list
#
# General options
#
if dict_has_value('period'):
new_input.period = dict_inputs[input_name]['period']
# Server Ping options
if dict_has_value('times_check'):
new_input.times_check = dict_inputs[input_name]['times_check']
if dict_has_value('deadline'):
new_input.deadline = dict_inputs[input_name]['deadline']
if dict_has_value('port'):
new_input.port = dict_inputs[input_name]['port']
# Signal options
if dict_has_value('weighting'):
new_input.weighting = dict_inputs[input_name]['weighting']
if dict_has_value('sample_time'):
new_input.sample_time = dict_inputs[input_name]['sample_time']
# Analog-to-digital converter options
if dict_has_value('adc_gain'):
if len(dict_inputs[input_name]['adc_gain']) == 1:
new_input.adc_gain = dict_inputs[input_name]['adc_gain'][0]
elif len(dict_inputs[input_name]['adc_gain']) > 1:
new_input.adc_gain = dict_inputs[input_name]['adc_gain'][
0][0]
if dict_has_value('adc_resolution'):
if len(dict_inputs[input_name]['adc_resolution']) == 1:
new_input.adc_resolution = dict_inputs[input_name][
'adc_resolution'][0]
elif len(dict_inputs[input_name]['adc_resolution']) > 1:
new_input.adc_resolution = dict_inputs[input_name][
'adc_resolution'][0][0]
if dict_has_value('adc_sample_speed'):
if len(dict_inputs[input_name]['adc_sample_speed']) == 1:
new_input.adc_sample_speed = dict_inputs[input_name][
'adc_sample_speed'][0]
elif len(dict_inputs[input_name]['adc_sample_speed']) > 1:
new_input.adc_sample_speed = dict_inputs[input_name][
'adc_sample_speed'][0][0]
# Linux command
if dict_has_value('cmd_command'):
new_input.cmd_command = dict_inputs[input_name]['cmd_command']
# Misc options
if dict_has_value('resolution'):
if len(dict_inputs[input_name]['resolution']) == 1:
new_input.resolution = dict_inputs[input_name][
'resolution'][0]
elif len(dict_inputs[input_name]['resolution']) > 1:
new_input.resolution = dict_inputs[input_name][
'resolution'][0][0]
if dict_has_value('resolution_2'):
if len(dict_inputs[input_name]['resolution_2']) == 1:
new_input.resolution_2 = dict_inputs[input_name][
'resolution_2'][0]
elif len(dict_inputs[input_name]['resolution_2']) > 1:
new_input.resolution_2 = dict_inputs[input_name][
'resolution_2'][0][0]
if dict_has_value('sensitivity'):
if len(dict_inputs[input_name]['sensitivity']) == 1:
new_input.sensitivity = dict_inputs[input_name][
'sensitivity'][0]
elif len(dict_inputs[input_name]['sensitivity']) > 1:
new_input.sensitivity = dict_inputs[input_name][
'sensitivity'][0][0]
if dict_has_value('thermocouple_type'):
if len(dict_inputs[input_name]['thermocouple_type']) == 1:
new_input.thermocouple_type = dict_inputs[input_name][
'thermocouple_type'][0]
elif len(dict_inputs[input_name]['thermocouple_type']) > 1:
new_input.thermocouple_type = dict_inputs[input_name][
'thermocouple_type'][0][0]
if dict_has_value('sht_voltage'):
if len(dict_inputs[input_name]['sht_voltage']) == 1:
new_input.sht_voltage = dict_inputs[input_name][
'sht_voltage'][0]
elif len(dict_inputs[input_name]['sht_voltage']) > 1:
new_input.sht_voltage = dict_inputs[input_name][
'sht_voltage'][0][0]
if dict_has_value('ref_ohm'):
new_input.ref_ohm = dict_inputs[input_name]['ref_ohm']
#
# Custom Options
#
# Generate string to save from custom options
messages["error"], custom_options = custom_options_return_json(
messages["error"],
dict_inputs,
device=input_name,
use_defaults=True)
new_input.custom_options = custom_options
#
# Execute at Creation
#
new_input.unique_id = set_uuid()
if ('execute_at_creation' in dict_inputs[new_input.device]
and not current_app.config['TESTING']):
messages["error"], new_input = dict_inputs[
new_input.device]['execute_at_creation'](
messages["error"], new_input,
dict_inputs[new_input.device])
try:
if not messages["error"]:
new_input.save()
new_input_id = new_input.unique_id
#
# If there are a variable number of measurements
#
if ('measurements_variable_amount' in dict_inputs[input_name]
and dict_inputs[input_name]
['measurements_variable_amount']):
# Add first default measurement with empty unit and measurement
new_measurement = DeviceMeasurements()
new_measurement.name = ""
new_measurement.device_id = new_input.unique_id
new_measurement.measurement = ""
new_measurement.unit = ""
new_measurement.channel = 0
new_measurement.save()
#
# If measurements defined in the Input Module
#
elif ('measurements_dict' in dict_inputs[input_name]
and dict_inputs[input_name]['measurements_dict']):
for each_channel in dict_inputs[input_name][
'measurements_dict']:
measure_info = dict_inputs[input_name][
'measurements_dict'][each_channel]
new_measurement = DeviceMeasurements()
if 'name' in measure_info:
new_measurement.name = measure_info['name']
new_measurement.device_id = new_input.unique_id
new_measurement.measurement = measure_info[
'measurement']
new_measurement.unit = measure_info['unit']
new_measurement.channel = each_channel
new_measurement.save()
if 'channels_dict' in dict_inputs[new_input.device]:
for each_channel, channel_info in dict_inputs[
new_input.device]['channels_dict'].items():
new_channel = InputChannel()
new_channel.channel = each_channel
new_channel.input_id = new_input.unique_id
# Generate string to save from custom options
messages[
"error"], custom_options = custom_channel_options_return_json(
messages["error"],
dict_inputs,
None,
new_input.unique_id,
each_channel,
device=new_input.device,
use_defaults=True)
new_channel.custom_options = custom_options
new_channel.save()
messages["success"].append(
f"{TRANSLATIONS['add']['title']} {TRANSLATIONS['input']['title']}"
)
except sqlalchemy.exc.OperationalError as except_msg:
messages["error"].append(except_msg)
except sqlalchemy.exc.IntegrityError as except_msg:
messages["error"].append(except_msg)
else:
for field, errors in form_add.errors.items():
for error in errors:
messages["error"].append(
gettext("Error in the %(field)s field - %(err)s",
field=getattr(form_add, field).label.text,
err=error))
return messages, dep_name, list_unmet_deps, dep_message, new_input_id
def output_add(form_add, request_form):
action = '{action} {controller}'.format(
action=TRANSLATIONS['add']['title'],
controller=TRANSLATIONS['output']['title'])
error = []
dict_outputs = parse_output_information()
if current_app.config['TESTING']:
dep_unmet = False
else:
dep_unmet, _ = return_dependencies(form_add.output_type.data.split(',')[0])
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=form_add.output_type.data.split(',')[0], dep=', '.join(list_unmet_deps)))
if not is_int(form_add.output_quantity.data, check_range=[1, 20]):
error.append("{error}. {accepted_values}: 1-20".format(
error=gettext("Invalid quantity"),
accepted_values=gettext("Acceptable values")
))
if form_add.output_type.data.count(',') == 1:
output_type = form_add.output_type.data.split(',')[0]
output_interface = form_add.output_type.data.split(',')[1]
else:
output_type = ''
output_interface = ''
error.append("Invalid output string (must be a comma-separated string)")
if not error:
for _ in range(0, form_add.output_quantity.data):
try:
new_output = Output()
try:
from RPi import GPIO
if GPIO.RPI_INFO['P1_REVISION'] == 1:
new_output.i2c_bus = 0
else:
new_output.i2c_bus = 1
except:
logger.error(
"RPi.GPIO and Raspberry Pi required for this action")
new_output.name = "Name"
new_output.output_type = output_type
new_output.interface = output_interface
#
# Set default values for new input being added
#
# input add options
if output_type in dict_outputs:
def dict_has_value(key):
if (key in dict_outputs[output_type] and
dict_outputs[output_type][key] is not None):
return True
#
# Interfacing options
#
if output_interface == 'I2C':
if dict_has_value('i2c_address_default'):
new_output.i2c_location = dict_outputs[output_type]['i2c_address_default']
elif dict_has_value('i2c_location'):
new_output.i2c_location = dict_outputs[output_type]['i2c_location'][0] # First list entry
if output_interface == 'FTDI':
if dict_has_value('ftdi_location'):
new_output.ftdi_location = dict_outputs[output_type]['ftdi_location']
if output_interface == 'UART':
if dict_has_value('uart_location'):
new_output.uart_location = dict_outputs[output_type]['uart_location']
# UART options
if dict_has_value('uart_baud_rate'):
new_output.baud_rate = dict_outputs[output_type]['uart_baud_rate']
if dict_has_value('pin_cs'):
new_output.pin_cs = dict_outputs[output_type]['pin_cs']
if dict_has_value('pin_miso'):
new_output.pin_miso = dict_outputs[output_type]['pin_miso']
if dict_has_value('pin_mosi'):
new_output.pin_mosi = dict_outputs[output_type]['pin_mosi']
if dict_has_value('pin_clock'):
new_output.pin_clock = dict_outputs[output_type]['pin_clock']
# Bluetooth (BT) options
elif output_interface == 'BT':
if dict_has_value('bt_location'):
new_output.location = dict_outputs[output_type]['bt_location']
if dict_has_value('bt_adapter'):
new_output.bt_adapter = dict_outputs[output_type]['bt_adapter']
# GPIO options
elif output_interface == 'GPIO':
if dict_has_value('gpio_pin'):
new_output.pin = dict_outputs[output_type]['gpio_pin']
# Custom location location
elif dict_has_value('location'):
new_output.location = dict_outputs[output_type]['location']['options'][0][0] # First entry in list
# Generate string to save from custom options
error, custom_options = custom_options_return_json(
error, dict_outputs, request_form, device=output_type, use_defaults=True)
new_output.custom_options = custom_options
#
# Execute at Creation
#
new_output.unique_id = set_uuid()
if 'execute_at_creation' in dict_outputs[output_type] and not current_app.config['TESTING']:
dict_outputs[output_type]['execute_at_creation'](
new_output, dict_outputs[output_type])
if not error:
new_output.save()
display_order = csv_to_list_of_str(
DisplayOrder.query.first().output)
DisplayOrder.query.first().output = add_display_order(
display_order, new_output.unique_id)
db.session.commit()
#
# If measurements defined in the Output Module
#
if ('measurements_dict' in dict_outputs[output_type] and
dict_outputs[output_type]['measurements_dict'] != []):
for each_measurement in dict_outputs[output_type]['measurements_dict']:
measure_info = dict_outputs[output_type]['measurements_dict'][each_measurement]
new_measurement = DeviceMeasurements()
if 'name' in measure_info:
new_measurement.name = measure_info['name']
new_measurement.device_id = new_output.unique_id
new_measurement.measurement = measure_info['measurement']
new_measurement.unit = measure_info['unit']
new_measurement.channel = each_measurement
new_measurement.save()
for each_channel, channel_info in dict_outputs[output_type]['channels_dict'].items():
new_channel = OutputChannel()
new_channel.channel = each_channel
new_channel.output_id = new_output.unique_id
# Generate string to save from custom options
error, custom_options = custom_channel_options_return_json(
error, dict_outputs, request_form,
new_output.unique_id, each_channel,
device=output_type, use_defaults=True)
new_channel.custom_options = custom_options
new_channel.save()
# Refresh output settings
if not current_app.config['TESTING']:
manipulate_output('Add', new_output.unique_id)
flash(gettext("{dev} with ID %(id)s successfully added".format(
dev=dict_outputs[output_type]['output_name']), id=new_output.id),
"success")
except sqlalchemy.exc.OperationalError as except_msg:
error.append(except_msg)
except sqlalchemy.exc.IntegrityError as except_msg:
error.append(except_msg)
except Exception:
logger.exception(1)
return dep_unmet
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
new_func.unique_id = set_uuid()
if ('execute_at_creation' in dict_controllers[new_func.device] and
not current_app.config['TESTING']):
error, new_func = dict_controllers[new_func.device]['execute_at_creation'](
error, new_func, dict_controllers[new_func.device])
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 output_add(form_add, request_form):
messages = {
"success": [],
"info": [],
"warning": [],
"error": []
}
output_id = None
dep_name = None
size_y = None
dict_outputs = parse_output_information()
if form_add.output_type.data.count(',') == 1:
output_type = form_add.output_type.data.split(',')[0]
output_interface = form_add.output_type.data.split(',')[1]
else:
output_type = ''
output_interface = ''
messages["error"].append("Invalid output string (must be a comma-separated string)")
if current_app.config['TESTING']:
dep_unmet = False
else:
dep_unmet, _ = return_dependencies(form_add.output_type.data.split(',')[0])
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 Output can be added.".format(
dev=output_type))
if output_type in dict_outputs:
dep_name = dict_outputs[output_type]["output_name"]
else:
messages["error"].append("Output not found: {}".format(output_type))
return messages, dep_name, list_unmet_deps, None, None
if not is_int(form_add.output_quantity.data, check_range=[1, 20]):
messages["error"].append("{error}. {accepted_values}: 1-20".format(
error=gettext("Invalid quantity"),
accepted_values=gettext("Acceptable values")
))
if not messages["error"]:
for _ in range(0, form_add.output_quantity.data):
try:
new_output = Output()
try:
from RPi import GPIO
if GPIO.RPI_INFO['P1_REVISION'] == 1:
new_output.i2c_bus = 0
else:
new_output.i2c_bus = 1
except:
logger.error(
"RPi.GPIO and Raspberry Pi required for this action")
new_output.name = "Name"
new_output.interface = output_interface
size_y = len(dict_outputs[output_type]['channels_dict']) + 1
new_output.size_y = len(dict_outputs[output_type]['channels_dict']) + 1
new_output.output_type = output_type
new_output.position_y = 999
#
# Set default values for new input being added
#
# input add options
if output_type in dict_outputs:
def dict_has_value(key):
if (key in dict_outputs[output_type] and
dict_outputs[output_type][key] is not None):
return True
#
# Interfacing options
#
if output_interface == 'I2C':
if dict_has_value('i2c_address_default'):
new_output.i2c_location = dict_outputs[output_type]['i2c_address_default']
elif dict_has_value('i2c_location'):
new_output.i2c_location = dict_outputs[output_type]['i2c_location'][0] # First list entry
if output_interface == 'FTDI':
if dict_has_value('ftdi_location'):
new_output.ftdi_location = dict_outputs[output_type]['ftdi_location']
if output_interface == 'UART':
if dict_has_value('uart_location'):
new_output.uart_location = dict_outputs[output_type]['uart_location']
# UART options
if dict_has_value('uart_baud_rate'):
new_output.baud_rate = dict_outputs[output_type]['uart_baud_rate']
if dict_has_value('pin_cs'):
new_output.pin_cs = dict_outputs[output_type]['pin_cs']
if dict_has_value('pin_miso'):
new_output.pin_miso = dict_outputs[output_type]['pin_miso']
if dict_has_value('pin_mosi'):
new_output.pin_mosi = dict_outputs[output_type]['pin_mosi']
if dict_has_value('pin_clock'):
new_output.pin_clock = dict_outputs[output_type]['pin_clock']
# Bluetooth (BT) options
elif output_interface == 'BT':
if dict_has_value('bt_location'):
new_output.location = dict_outputs[output_type]['bt_location']
if dict_has_value('bt_adapter'):
new_output.bt_adapter = dict_outputs[output_type]['bt_adapter']
# GPIO options
elif output_interface == 'GPIO':
if dict_has_value('gpio_pin'):
new_output.pin = dict_outputs[output_type]['gpio_pin']
# Custom location location
elif dict_has_value('location'):
new_output.location = dict_outputs[output_type]['location']['options'][0][0] # First entry in list
# Generate string to save from custom options
messages["error"], custom_options = custom_options_return_json(
messages["error"], dict_outputs, request_form, device=output_type, use_defaults=True)
new_output.custom_options = custom_options
#
# Execute at Creation
#
new_output.unique_id = set_uuid()
if 'execute_at_creation' in dict_outputs[output_type] and not current_app.config['TESTING']:
messages["error"], new_output = dict_outputs[output_type]['execute_at_creation'](
messages["error"], new_output, dict_outputs[output_type])
if not messages["error"]:
new_output.save()
output_id = new_output.unique_id
db.session.commit()
messages["success"].append('{action} {controller}'.format(
action=TRANSLATIONS['add']['title'],
controller=TRANSLATIONS['output']['title']))
#
# If measurements defined in the Output Module
#
if ('measurements_dict' in dict_outputs[output_type] and
dict_outputs[output_type]['measurements_dict'] != []):
for each_measurement in dict_outputs[output_type]['measurements_dict']:
measure_info = dict_outputs[output_type]['measurements_dict'][each_measurement]
new_measurement = DeviceMeasurements()
if 'name' in measure_info:
new_measurement.name = measure_info['name']
new_measurement.device_id = new_output.unique_id
new_measurement.measurement = measure_info['measurement']
new_measurement.unit = measure_info['unit']
new_measurement.channel = each_measurement
new_measurement.save()
for each_channel, channel_info in dict_outputs[output_type]['channels_dict'].items():
new_channel = OutputChannel()
new_channel.channel = each_channel
new_channel.output_id = new_output.unique_id
# Generate string to save from custom options
messages["error"], custom_options = custom_channel_options_return_json(
messages["error"], dict_outputs, request_form,
new_output.unique_id, each_channel,
device=output_type, use_defaults=True)
new_channel.custom_options = custom_options
new_channel.save()
# Refresh output settings
if not current_app.config['TESTING']:
new_messages = manipulate_output(
'Add', new_output.unique_id)
messages["error"].extend(new_messages["error"])
messages["success"].extend(new_messages["success"])
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))
logger.exception(1)
return messages, dep_unmet, None, output_id, size_y
