def function_del(function_id):
"""Delete a Function"""
action = '{action} {controller}'.format(
action=TRANSLATIONS['delete']['title'],
controller=TRANSLATIONS['function']['title'])
error = []
try:
# Delete Actions
actions = Actions.query.filter(
Actions.function_id == function_id).all()
for each_action in actions:
delete_entry_with_id(Actions, each_action.unique_id)
device_measurements = DeviceMeasurements.query.filter(
DeviceMeasurements.device_id == function_id).all()
for each_measurement in device_measurements:
delete_entry_with_id(DeviceMeasurements, each_measurement.unique_id)
delete_entry_with_id(Function, function_id)
display_order = csv_to_list_of_str(DisplayOrder.query.first().function)
display_order.remove(function_id)
DisplayOrder.query.first().function = list_to_csv(display_order)
db.session.commit()
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_page.page_function'))
def math_del(form_mod_math):
action = '{action} {controller}'.format(
action=TRANSLATIONS['delete']['title'],
controller=TRANSLATIONS['math']['title'])
error = []
math_id = form_mod_math.math_id.data
try:
math = Math.query.filter(
Math.unique_id == math_id).first()
if math.is_activated:
controller_activate_deactivate(
'deactivate',
'Math',
form_mod_math.math_id.data)
device_measurements = DeviceMeasurements.query.filter(
DeviceMeasurements.device_id == math_id).all()
for each_measurement in device_measurements:
delete_entry_with_id(DeviceMeasurements, each_measurement.unique_id)
delete_entry_with_id(Math, math_id)
try:
display_order = csv_to_list_of_str(DisplayOrder.query.first().math)
display_order.remove(math_id)
DisplayOrder.query.first().math = list_to_csv(display_order)
except Exception: # id not in list
pass
db.session.commit()
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_input.page_input'))
def lcd_del(lcd_id):
action = '{action} {controller}'.format(
action=TRANSLATIONS['delete']['title'],
controller=TRANSLATIONS['lcd']['title'])
error = []
lcd = LCD.query.filter(
LCD.unique_id == lcd_id).first()
if lcd.is_activated:
error.append(gettext("Deactivate LCD controller before modifying "
"its settings."))
if not error:
try:
# Delete all LCD Displays
lcd_displays = LCDData.query.filter(
LCDData.lcd_id == lcd_id).all()
for each_lcd_display in lcd_displays:
lcd_display_del(each_lcd_display.unique_id, delete_last=True)
# Delete LCD
delete_entry_with_id(LCD, lcd_id)
display_order = csv_to_list_of_str(DisplayOrder.query.first().lcd)
display_order.remove(lcd_id)
DisplayOrder.query.first().lcd = list_to_csv(display_order)
db.session.commit()
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_page.page_lcd'))
def function_del(function_id):
"""Delete a Function"""
action = '{action} {controller}'.format(
action=TRANSLATIONS['delete']['title'],
controller=TRANSLATIONS['function']['title'])
error = []
try:
# Delete Actions
actions = Actions.query.filter(
Actions.function_id == function_id).all()
for each_action in actions:
delete_entry_with_id(Actions,
each_action.unique_id)
delete_entry_with_id(Function, function_id)
display_order = csv_to_list_of_str(DisplayOrder.query.first().function)
display_order.remove(function_id)
DisplayOrder.query.first().function = list_to_csv(display_order)
db.session.commit()
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_page.page_function'))
def input_del(input_id):
action = '{action} {controller}'.format(
action=TRANSLATIONS['delete']['title'],
controller=TRANSLATIONS['input']['title'])
error = []
try:
input_dev = Input.query.filter(
Input.unique_id == input_id).first()
if input_dev.is_activated:
input_deactivate_associated_controllers(input_id)
controller_activate_deactivate('deactivate', 'Input', input_id)
device_measurements = DeviceMeasurements.query.filter(
DeviceMeasurements.device_id == input_id).all()
for each_measurement in device_measurements:
delete_entry_with_id(DeviceMeasurements, each_measurement.unique_id)
delete_entry_with_id(Input, input_id)
try:
display_order = csv_to_list_of_str(
DisplayOrder.query.first().inputs)
display_order.remove(input_id)
DisplayOrder.query.first().inputs = list_to_csv(display_order)
except Exception: # id not in list
pass
db.session.commit()
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_page.page_data'))
def math_del(form_mod_math):
action = '{action} {controller}'.format(
action=TRANSLATIONS['delete']['title'],
controller=TRANSLATIONS['math']['title'])
error = []
math_id = form_mod_math.math_id.data
try:
math = Math.query.filter(
Math.unique_id == math_id).first()
if math.is_activated:
controller_activate_deactivate(
'deactivate',
'Math',
form_mod_math.math_id.data)
device_measurements = DeviceMeasurements.query.filter(
DeviceMeasurements.device_id == math_id).all()
for each_measurement in device_measurements:
delete_entry_with_id(DeviceMeasurements, each_measurement.unique_id)
delete_entry_with_id(Math, math_id)
try:
display_order = csv_to_list_of_str(DisplayOrder.query.first().math)
display_order.remove(math_id)
DisplayOrder.query.first().math = list_to_csv(display_order)
except Exception: # id not in list
pass
db.session.commit()
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_page.page_data'))
def pid_del(pid_id):
action = '{action} {controller}'.format(
action=TRANSLATIONS['delete']['title'],
controller=TRANSLATIONS['pid']['title'])
error = []
try:
pid = PID.query.filter(
PID.unique_id == pid_id).first()
if pid.is_activated:
pid_deactivate(pid_id)
device_measurements = DeviceMeasurements.query.filter(
DeviceMeasurements.device_id == pid_id).all()
for each_measurement in device_measurements:
delete_entry_with_id(DeviceMeasurements, each_measurement.unique_id)
delete_entry_with_id(PID, pid_id)
try:
display_order = csv_to_list_of_str(DisplayOrder.query.first().math)
display_order.remove(pid_id)
DisplayOrder.query.first().function = list_to_csv(display_order)
except Exception: # id not in list
pass
db.session.commit()
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_page.page_function'))
def pid_del(pid_id):
action = '{action} {controller}'.format(
action=TRANSLATIONS['delete']['title'],
controller=TRANSLATIONS['pid']['title'])
error = []
try:
pid = PID.query.filter(PID.unique_id == pid_id).first()
if pid.is_activated:
pid_deactivate(pid_id)
device_measurements = DeviceMeasurements.query.filter(
DeviceMeasurements.device_id == pid_id).all()
for each_measurement in device_measurements:
delete_entry_with_id(DeviceMeasurements,
each_measurement.unique_id)
delete_entry_with_id(PID, pid_id)
try:
display_order = csv_to_list_of_str(DisplayOrder.query.first().math)
display_order.remove(pid_id)
DisplayOrder.query.first().function = list_to_csv(display_order)
except Exception: # id not in list
pass
db.session.commit()
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_page.page_function'))
def lcd_del(lcd_id):
action = '{action} {controller}'.format(
action=TRANSLATIONS['delete']['title'],
controller=TRANSLATIONS['lcd']['title'])
error = []
lcd = LCD.query.filter(LCD.unique_id == lcd_id).first()
if lcd.is_activated:
error.append(
gettext("Deactivate LCD controller before modifying "
"its settings."))
if not error:
try:
# Delete all LCD Displays
lcd_displays = LCDData.query.filter(LCDData.lcd_id == lcd_id).all()
for each_lcd_display in lcd_displays:
lcd_display_del(each_lcd_display.unique_id, delete_last=True)
# Delete LCD
delete_entry_with_id(LCD, lcd_id)
display_order = csv_to_list_of_str(DisplayOrder.query.first().lcd)
display_order.remove(lcd_id)
DisplayOrder.query.first().lcd = list_to_csv(display_order)
db.session.commit()
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_page.page_lcd'))
def input_del(input_id):
action = '{action} {controller}'.format(
action=TRANSLATIONS['delete']['title'],
controller=TRANSLATIONS['input']['title'])
error = []
try:
input_dev = Input.query.filter(Input.unique_id == input_id).first()
if input_dev.is_activated:
input_deactivate_associated_controllers(input_id)
controller_activate_deactivate('deactivate', 'Input', input_id)
device_measurements = DeviceMeasurements.query.filter(
DeviceMeasurements.device_id == input_id).all()
for each_measurement in device_measurements:
delete_entry_with_id(DeviceMeasurements,
each_measurement.unique_id)
delete_entry_with_id(Input, input_id)
try:
display_order = csv_to_list_of_str(
DisplayOrder.query.first().inputs)
display_order.remove(input_id)
DisplayOrder.query.first().inputs = list_to_csv(display_order)
except Exception: # id not in list
pass
db.session.commit()
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_page.page_data'))
def output_del(form_output):
action = '{action} {controller}'.format(
action=TRANSLATIONS['delete']['title'],
controller=TRANSLATIONS['output']['title'])
error = []
try:
device_measurements = DeviceMeasurements.query.filter(
DeviceMeasurements.device_id == form_output.output_id.data).all()
for each_measurement in device_measurements:
delete_entry_with_id(
DeviceMeasurements, each_measurement.unique_id)
delete_entry_with_id(Output, form_output.output_id.data)
channels = OutputChannel.query.filter(
OutputChannel.output_id == form_output.output_id.data).all()
for each_channel in channels:
delete_entry_with_id(OutputChannel, each_channel.unique_id)
display_order = csv_to_list_of_str(DisplayOrder.query.first().output)
display_order.remove(form_output.output_id.data)
DisplayOrder.query.first().output = list_to_csv(display_order)
db.session.commit()
if not current_app.config['TESTING']:
manipulate_output('Delete', form_output.output_id.data)
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_page.page_output'))
def method_delete(method_id):
"""Delete a method."""
action = '{action} {controller}'.format(
action=TRANSLATIONS['delete']['title'],
controller=gettext("Method"))
if not utils_general.user_has_permission('edit_settings'):
return redirect(url_for('routes_method.method_list'))
try:
MethodData.query.filter(
MethodData.method_id == method_id).delete()
MethodData.query.filter(
MethodData.linked_method_id == method_id).delete()
Method.query.filter(
Method.unique_id == method_id).delete()
display_order = csv_to_list_of_str(DisplayOrder.query.first().method)
display_order.remove(method_id)
DisplayOrder.query.first().method = list_to_csv(display_order)
db.session.commit()
flash("Success: {action}".format(action=action), "success")
except Exception as except_msg:
flash("Error: {action}: {err}".format(action=action,
err=except_msg),
"error")
return redirect(url_for('routes_method.method_list'))
def conditional_del(cond_id):
"""Delete a Conditional"""
error = []
action = '{action} {controller}'.format(
action=TRANSLATIONS['delete']['title'],
controller=TRANSLATIONS['conditional']['title'])
cond = Conditional.query.filter(
Conditional.unique_id == cond_id).first()
# Deactivate conditional if active
if cond.is_activated:
conditional_deactivate(cond_id)
try:
if not error:
# Delete conditions
conditions = ConditionalConditions.query.filter(
ConditionalConditions.conditional_id == cond_id).all()
for each_condition in conditions:
delete_entry_with_id(ConditionalConditions,
each_condition.unique_id)
# Delete Actions
actions = Actions.query.filter(
Actions.function_id == cond_id).all()
for each_action in actions:
delete_entry_with_id(Actions,
each_action.unique_id)
delete_entry_with_id(Conditional, cond_id)
display_order = csv_to_list_of_str(DisplayOrder.query.first().function)
display_order.remove(cond_id)
DisplayOrder.query.first().function = list_to_csv(display_order)
try:
file_path = os.path.join(
PATH_PYTHON_CODE_USER, 'conditional_{}.py'.format(
cond.unique_id))
os.remove(file_path)
except:
pass
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 controller_del(cond_id):
"""Delete a Conditional"""
error = []
action = '{action} {controller}'.format(
action=TRANSLATIONS['delete']['title'],
controller=TRANSLATIONS['controller']['title'])
cond = CustomController.query.filter(
CustomController.unique_id == cond_id).first()
# Deactivate controller if active
if cond.is_activated:
controller_deactivate(cond_id)
try:
if not error:
device_measurements = DeviceMeasurements.query.filter(
DeviceMeasurements.device_id == cond_id).all()
for each_measurement in device_measurements:
delete_entry_with_id(DeviceMeasurements,
each_measurement.unique_id)
delete_entry_with_id(CustomController, cond_id)
channels = FunctionChannel.query.filter(
FunctionChannel.function_id == cond_id).all()
for each_channel in channels:
delete_entry_with_id(FunctionChannel, each_channel.unique_id)
display_order = csv_to_list_of_str(
DisplayOrder.query.first().function)
display_order.remove(cond_id)
DisplayOrder.query.first().function = list_to_csv(display_order)
try:
file_path = os.path.join(
PATH_PYTHON_CODE_USER,
'conditional_{}.py'.format(cond.unique_id))
os.remove(file_path)
except:
pass
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 input_del(input_id):
messages = {"success": [], "info": [], "warning": [], "error": []}
try:
input_dev = Input.query.filter(Input.unique_id == input_id).first()
if input_dev.is_activated:
input_deactivate_associated_controllers(input_id)
controller_activate_deactivate('deactivate', 'Input', input_id)
device_measurements = DeviceMeasurements.query.filter(
DeviceMeasurements.device_id == input_id).all()
for each_measurement in device_measurements:
delete_entry_with_id(DeviceMeasurements,
each_measurement.unique_id,
flash_message=False)
delete_entry_with_id(Input, input_id, flash_message=False)
channels = InputChannel.query.filter(
InputChannel.input_id == input_id).all()
for each_channel in channels:
delete_entry_with_id(InputChannel,
each_channel.unique_id,
flash_message=False)
try:
display_order = csv_to_list_of_str(
DisplayOrder.query.first().inputs)
display_order.remove(input_id)
DisplayOrder.query.first().inputs = list_to_csv(display_order)
except Exception: # id not in list
pass
try:
file_path = os.path.join(
PATH_PYTHON_CODE_USER,
'input_python_code_{}.py'.format(input_dev.unique_id))
os.remove(file_path)
except:
pass
db.session.commit()
messages["success"].append('{action} {controller}'.format(
action=TRANSLATIONS['delete']['title'],
controller=TRANSLATIONS['input']['title']))
except Exception as except_msg:
messages["error"].append(str(except_msg))
return messages
def graph_del(form_del_graph):
action = u'{action} {controller}'.format(action=gettext(u"Delete"),
controller=gettext(u"Graph"))
error = []
try:
delete_entry_with_id(Graph, form_del_graph.graph_id.data)
display_order = csv_to_list_of_int(DisplayOrder.query.first().graph)
display_order.remove(int(form_del_graph.graph_id.data))
DisplayOrder.query.first().graph = list_to_csv(display_order)
db.session.commit()
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('page_routes.page_graph'))
def relay_del(form_relay):
action = u'{action} {controller}'.format(action=gettext(u"Delete"),
controller=gettext(u"Output"))
error = []
try:
delete_entry_with_id(Output, form_relay.relay_id.data)
display_order = csv_to_list_of_int(DisplayOrder.query.first().relay)
display_order.remove(int(form_relay.relay_id.data))
DisplayOrder.query.first().relay = list_to_csv(display_order)
db.session.commit()
manipulate_relay('Delete', form_relay.relay_id.data)
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('page_routes.page_output'))
def dashboard_del(form_base):
"""Delete an item on the dashboard"""
action = '{action} {controller}'.format(action=gettext("Delete"),
controller=gettext("Dashboard"))
error = []
try:
delete_entry_with_id(Dashboard, form_base.dashboard_id.data)
display_order = csv_to_list_of_int(DisplayOrder.query.first().graph)
display_order.remove(int(form_base.dashboard_id.data))
DisplayOrder.query.first().graph = list_to_csv(display_order)
db.session.commit()
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_page.page_dashboard'))
def output_del(form_output):
action = '{action} {controller}'.format(action=gettext("Delete"),
controller=gettext("Output"))
error = []
try:
delete_entry_with_id(Output, form_output.output_id.data)
display_order = csv_to_list_of_str(DisplayOrder.query.first().output)
display_order.remove(form_output.output_id.data)
DisplayOrder.query.first().output = list_to_csv(display_order)
db.session.commit()
manipulate_output('Delete', form_output.output_id.data)
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_page.page_output'))
def dashboard_del(form_base):
"""Delete an item on the dashboard"""
action = '{action} {controller}'.format(
action=TRANSLATIONS['delete']['title'],
controller=TRANSLATIONS['dashboard']['title'])
error = []
try:
delete_entry_with_id(Dashboard,
form_base.dashboard_id.data)
display_order = csv_to_list_of_str(DisplayOrder.query.first().dashboard)
display_order.remove(form_base.dashboard_id.data)
DisplayOrder.query.first().dashboard = list_to_csv(display_order)
db.session.commit()
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_page.page_dashboard'))
def timer_del(form_timer):
action = '{action} {controller}'.format(
action=gettext("Delete"),
controller=gettext("Timer"))
error = []
try:
delete_entry_with_id(Timer,
form_timer.timer_id.data)
display_order = csv_to_list_of_int(DisplayOrder.query.first().timer)
display_order.remove(int(form_timer.timer_id.data))
DisplayOrder.query.first().timer = list_to_csv(display_order)
db.session.commit()
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_page.page_timer'))
def remote_host_del(form_setup):
"""Delete a remote Mycodo from the Remote Admin Dashboard"""
if not utils_general.user_has_permission('edit_settings'):
return redirect(url_for('routes_general.home'))
try:
delete_entry_with_id(Remote,
form_setup.remote_id.data)
display_order = csv_to_list_of_str(
DisplayOrder.query.first().remote_host)
display_order.remove(form_setup.remote_id.data)
DisplayOrder.query.first().remote_host = list_to_csv(display_order)
db.session.commit()
except Exception as except_msg:
flash(gettext("Error: %(err)s",
err='Remote Host Delete: {msg}'.format(msg=except_msg)),
"error")
def dashboard_del(form_base):
"""Delete an item on the dashboard"""
action = '{action} {controller}'.format(
action=TRANSLATIONS['delete']['title'],
controller=TRANSLATIONS['dashboard']['title'])
error = []
try:
delete_entry_with_id(Dashboard, form_base.dashboard_id.data)
display_order = csv_to_list_of_str(
DisplayOrder.query.first().dashboard)
display_order.remove(form_base.dashboard_id.data)
DisplayOrder.query.first().dashboard = list_to_csv(display_order)
db.session.commit()
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_page.page_dashboard'))
def output_del(form_output):
action = '{action} {controller}'.format(
action=TRANSLATIONS['delete']['title'],
controller=TRANSLATIONS['output']['title'])
error = []
try:
delete_entry_with_id(Output,
form_output.output_id.data)
display_order = csv_to_list_of_str(DisplayOrder.query.first().output)
display_order.remove(form_output.output_id.data)
DisplayOrder.query.first().output = list_to_csv(display_order)
db.session.commit()
manipulate_output('Delete', form_output.output_id.data)
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_page.page_output'))
def conditional_del(cond_id):
"""Delete a Conditional"""
error = []
action = '{action} {controller}'.format(
action=TRANSLATIONS['delete']['title'],
controller=TRANSLATIONS['conditional']['title'])
cond = Conditional.query.filter(
Conditional.unique_id == cond_id).first()
# Deactivate conditional if active
if cond.is_activated:
conditional_deactivate(cond_id)
try:
if not error:
# Delete conditions
conditions = ConditionalConditions.query.filter(
ConditionalConditions.conditional_id == cond_id).all()
for each_condition in conditions:
delete_entry_with_id(ConditionalConditions,
each_condition.unique_id)
# Delete Actions
actions = Actions.query.filter(
Actions.function_id == cond_id).all()
for each_action in actions:
delete_entry_with_id(Actions,
each_action.unique_id)
delete_entry_with_id(Conditional, cond_id)
display_order = csv_to_list_of_str(DisplayOrder.query.first().function)
display_order.remove(cond_id)
DisplayOrder.query.first().function = list_to_csv(display_order)
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 pid_del(pid_id):
action = '{action} {controller}'.format(action=gettext("Delete"),
controller=gettext("PID"))
error = []
try:
pid = PID.query.filter(PID.unique_id == pid_id).first()
if pid.is_activated:
pid_deactivate(pid_id)
delete_entry_with_id(PID, pid_id)
display_order = csv_to_list_of_str(DisplayOrder.query.first().pid)
display_order.remove(pid_id)
DisplayOrder.query.first().pid = list_to_csv(display_order)
db.session.commit()
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_page.page_function'))
def conditional_del(cond_id):
"""Delete a Conditional"""
error = []
action = '{action} {controller}'.format(action=gettext("Delete"),
controller=gettext("Conditional"))
cond = Conditional.query.filter(Conditional.unique_id == cond_id).first()
# Deactivate conditional if active
if cond.is_activated:
conditional_deactivate(cond_id)
try:
if not error:
# Delete conditional
conditional_actions = ConditionalActions.query.filter(
ConditionalActions.conditional_id == cond.unique_id).all()
for each_cond_action in conditional_actions:
delete_entry_with_id(ConditionalActions,
each_cond_action.unique_id)
delete_entry_with_id(Conditional, cond.unique_id)
try:
display_order = csv_to_list_of_str(
DisplayOrder.query.first().conditional)
display_order.remove(cond.id)
DisplayOrder.query.first().conditional = list_to_csv(
display_order)
except Exception: # id not in list
pass
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 method_delete(method_id):
"""Delete a method"""
action = '{action} {controller}'.format(action=gettext(u"Delete"),
controller=gettext(u"Method"))
if not flaskutils.user_has_permission('edit_settings'):
return redirect(url_for('method_routes.method_list'))
try:
MethodData.query.filter(
MethodData.method_id == int(method_id)).delete()
Method.query.filter(Method.id == int(method_id)).delete()
display_order = csv_to_list_of_int(DisplayOrder.query.first().method)
display_order.remove(int(method_id))
DisplayOrder.query.first().method = list_to_csv(display_order)
db.session.commit()
flash("Success: {action}".format(action=action), "success")
except Exception as except_msg:
flash("Error: {action}: {err}".format(action=action, err=except_msg),
"error")
return redirect(url_for('method_routes.method_list'))
def output_del(form_output):
messages = {"success": [], "info": [], "warning": [], "error": []}
try:
device_measurements = DeviceMeasurements.query.filter(
DeviceMeasurements.device_id == form_output.output_id.data).all()
for each_measurement in device_measurements:
delete_entry_with_id(DeviceMeasurements,
each_measurement.unique_id,
flash_message=False)
delete_entry_with_id(Output,
form_output.output_id.data,
flash_message=False)
channels = OutputChannel.query.filter(
OutputChannel.output_id == form_output.output_id.data).all()
for each_channel in channels:
delete_entry_with_id(OutputChannel,
each_channel.unique_id,
flash_message=False)
display_order = csv_to_list_of_str(DisplayOrder.query.first().output)
display_order.remove(form_output.output_id.data)
DisplayOrder.query.first().output = list_to_csv(display_order)
db.session.commit()
messages["success"].append('{action} {controller}'.format(
action=TRANSLATIONS['delete']['title'],
controller=TRANSLATIONS['output']['title']))
if not current_app.config['TESTING']:
new_messages = manipulate_output('Delete',
form_output.output_id.data)
messages["error"].extend(new_messages["error"])
messages["success"].extend(new_messages["success"])
except Exception as except_msg:
messages["error"].append(except_msg)
return messages
def math_del(form_mod_math):
action = '{action} {controller}'.format(
action=gettext("Delete"),
controller=gettext("Math"))
error = []
try:
math = Math.query.filter(
Math.id == form_mod_math.math_id.data).first()
if math.is_activated:
controller_activate_deactivate(
'deactivate',
'Math',
form_mod_math.math_id.data)
# Delete any conditionals associated with the controller
conditionals = Conditional.query.filter(
Conditional.math_id == form_mod_math.math_id.data).all()
for each_cond in conditionals:
conditional_actions = ConditionalActions.query.filter(
ConditionalActions.conditional_id == each_cond.id).all()
for each_cond_action in conditional_actions:
db.session.delete(each_cond_action)
db.session.delete(each_cond)
db.session.commit()
delete_entry_with_id(Math, form_mod_math.math_id.data)
try:
display_order = csv_to_list_of_int(DisplayOrder.query.first().math)
display_order.remove(int(form_mod_math.math_id.data))
DisplayOrder.query.first().math = list_to_csv(display_order)
except Exception: # id not in list
pass
db.session.commit()
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_page.page_data'))
def math_del(form_mod_math):
action = u'{action} {controller}'.format(action=gettext(u"Delete"),
controller=gettext(u"Math"))
error = []
try:
math = Math.query.filter(Math.id == form_mod_math.math_id.data).first()
if math.is_activated:
controller_activate_deactivate('deactivate', 'Math',
form_mod_math.math_id.data)
delete_entry_with_id(Math, form_mod_math.math_id.data)
try:
display_order = csv_to_list_of_int(DisplayOrder.query.first().math)
display_order.remove(int(form_mod_math.math_id.data))
DisplayOrder.query.first().math = list_to_csv(display_order)
except Exception: # id not in list
pass
db.session.commit()
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('page_routes.page_input'))
def sensor_del(form_mod_sensor):
action = u'{action} {controller}'.format(action=gettext(u"Delete"),
controller=gettext(u"Input"))
error = []
try:
sensor = Input.query.filter(
Input.id == form_mod_sensor.modSensor_id.data).first()
if sensor.is_activated:
sensor_deactivate_associated_controllers(
form_mod_sensor.modSensor_id.data)
controller_activate_deactivate('deactivate', 'Input',
form_mod_sensor.modSensor_id.data)
conditionals = Conditional.query.filter(
Conditional.sensor_id == form_mod_sensor.modSensor_id.data).all()
for each_cond in conditionals:
conditional_actions = ConditionalActions.query.filter(
ConditionalActions.conditional_id == each_cond.id).all()
for each_cond_action in conditional_actions:
db.session.delete(each_cond_action)
db.session.delete(each_cond)
db.session.commit()
delete_entry_with_id(Input, form_mod_sensor.modSensor_id.data)
try:
display_order = csv_to_list_of_int(
DisplayOrder.query.first().sensor)
display_order.remove(int(form_mod_sensor.modSensor_id.data))
DisplayOrder.query.first().sensor = list_to_csv(display_order)
except Exception: # id not in list
pass
db.session.commit()
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('page_routes.page_input'))
def trigger_del(trigger_id):
"""Delete a Trigger"""
error = []
action = '{action} {controller}'.format(
action=TRANSLATIONS['delete']['title'],
controller=TRANSLATIONS['trigger']['title'])
trigger = Trigger.query.filter(
Trigger.unique_id == trigger_id).first()
# Deactivate trigger if active
if trigger.is_activated:
trigger_deactivate(trigger_id)
try:
if not error:
# Delete Actions
actions = Actions.query.filter(
Actions.function_id == trigger_id).all()
for each_action in actions:
delete_entry_with_id(Actions,
each_action.unique_id)
delete_entry_with_id(Trigger, trigger_id)
display_order = csv_to_list_of_str(DisplayOrder.query.first().function)
display_order.remove(trigger_id)
DisplayOrder.query.first().function = list_to_csv(display_order)
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 method_mod(form_mod_method):
action = '{action} {controller}'.format(action=gettext("Modify"),
controller=gettext("Method"))
error = []
method = Method.query.filter(
Method.unique_id == form_mod_method.method_id.data).first()
method_data = MethodData.query.filter(
MethodData.unique_id == form_mod_method.method_data_id.data).first()
display_order = csv_to_list_of_str(method.method_order)
try:
if form_mod_method.Delete.data:
delete_entry_with_id(MethodData,
form_mod_method.method_data_id.data)
if form_mod_method.method_select.data != 'output':
method_order = Method.query.filter(
Method.unique_id == method.unique_id).first()
display_order = csv_to_list_of_str(method_order.method_order)
display_order.remove(method_data.unique_id)
method_order.method_order = list_to_csv(display_order)
db.session.commit()
return 0
if form_mod_method.rename.data:
method.name = form_mod_method.name.data
db.session.commit()
return 0
# Ensure data is valid
if validate_method_data(form_mod_method, method):
return 1
if form_mod_method.method_select.data == 'setpoint':
if method.method_type == 'Date':
start_time = datetime.strptime(form_mod_method.time_start.data,
'%Y-%m-%d %H:%M:%S')
end_time = datetime.strptime(form_mod_method.time_end.data,
'%Y-%m-%d %H:%M:%S')
# Ensure the start time comes after the previous entry's end time
# and the end time comes before the next entry's start time
# method_id_set is the id given to all method entries, 'method_id', not 'id'
previous_method = None
next_method = None
for index, each_order in enumerate(display_order):
if each_order == method_data.unique_id:
if len(display_order) > 1 and index > 0:
previous_method = MethodData.query.filter(
MethodData.unique_id == display_order[
index - 1]).first()
if len(display_order) > index + 1:
next_method = MethodData.query.filter(
MethodData.unique_id == display_order[
index + 1]).first()
if previous_method is not None and previous_method.time_end is not None:
previous_end_time = datetime.strptime(
previous_method.time_end, '%Y-%m-%d %H:%M:%S')
if previous_end_time is not None and start_time < previous_end_time:
error.append(
gettext(
"The entry start time (%(st)s) cannot "
"overlap the previous entry's end time "
"(%(et)s)",
st=start_time,
et=previous_end_time))
if next_method is not None and next_method.time_start is not None:
next_start_time = datetime.strptime(
next_method.time_start, '%Y-%m-%d %H:%M:%S')
if next_start_time is not None and end_time > next_start_time:
error.append(
gettext(
"The entry end time (%(et)s) cannot "
"overlap the next entry's start time "
"(%(st)s)",
et=end_time,
st=next_start_time))
method_data.time_start = start_time.strftime(
'%Y-%m-%d %H:%M:%S')
method_data.time_end = end_time.strftime('%Y-%m-%d %H:%M:%S')
elif method.method_type == 'Duration':
if method_data.duration_sec == 0:
method_data.duration_end = form_mod_method.duration_end.data
else:
method_data.duration_sec = form_mod_method.duration.data
elif method.method_type == 'Daily':
method_data.time_start = form_mod_method.daily_time_start.data
method_data.time_end = form_mod_method.daily_time_end.data
method_data.setpoint_start = form_mod_method.setpoint_start.data
method_data.setpoint_end = form_mod_method.setpoint_end.data
elif form_mod_method.method_select.data == 'output':
if method.method_type == 'Date':
method_data.time_start = form_mod_method.output_time.data
elif method.method_type == 'Duration':
method_data.duration_sec = form_mod_method.duration.data
if form_mod_method.duration_sec.data == 0:
method_data.duration_end = form_mod_method.duration_end.data
if form_mod_method.output_id.data == '':
method_data.output_id = None
else:
method_data.output_id = form_mod_method.output_id.data
method_data.output_state = form_mod_method.output_state.data
method_data.output_duration = form_mod_method.output_duration.data
elif method.method_type == 'DailySine':
if form_mod_method.method_select.data == 'output':
method_data.time_start = form_mod_method.output_time.data
if form_mod_method.output_id.data == '':
method_data.output_id = None
else:
method_data.output_id = form_mod_method.output_id.data
method_data.output_state = form_mod_method.output_state.data
method_data.output_duration = form_mod_method.output_duration.data
if not error:
db.session.commit()
except Exception as except_msg:
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_method.method_list'))
def method_mod(form_mod_method):
action = '{action} {controller}'.format(
action=TRANSLATIONS['modify']['title'],
controller=TRANSLATIONS['method']['title'])
error = []
method = Method.query.filter(
Method.unique_id == form_mod_method.method_id.data).first()
method_data = MethodData.query.filter(
MethodData.unique_id == form_mod_method.method_data_id.data).first()
display_order = csv_to_list_of_str(method.method_order)
try:
if form_mod_method.delete.data:
delete_entry_with_id(MethodData,
form_mod_method.method_data_id.data)
if form_mod_method.method_select.data != 'output':
method_order = Method.query.filter(
Method.unique_id == method.unique_id).first()
display_order = csv_to_list_of_str(method_order.method_order)
display_order.remove(method_data.unique_id)
method_order.method_order = list_to_csv(display_order)
db.session.commit()
return 0
if form_mod_method.rename.data:
method.name = form_mod_method.name.data
db.session.commit()
return 0
# Ensure data is valid
if validate_method_data(form_mod_method, method):
return 1
if form_mod_method.method_select.data == 'setpoint':
if method.method_type == 'Date':
start_time = datetime.strptime(form_mod_method.time_start.data, '%Y-%m-%d %H:%M:%S')
end_time = datetime.strptime(form_mod_method.time_end.data, '%Y-%m-%d %H:%M:%S')
# Ensure the start time comes after the previous entry's end time
# and the end time comes before the next entry's start time
# method_id_set is the id given to all method entries, 'method_id', not 'id'
previous_method = None
next_method = None
for index, each_order in enumerate(display_order):
if each_order == method_data.unique_id:
if len(display_order) > 1 and index > 0:
previous_method = MethodData.query.filter(
MethodData.unique_id == display_order[index-1]).first()
if len(display_order) > index+1:
next_method = MethodData.query.filter(
MethodData.unique_id == display_order[index+1]).first()
if previous_method is not None and previous_method.time_end is not None:
previous_end_time = datetime.strptime(
previous_method.time_end, '%Y-%m-%d %H:%M:%S')
if previous_end_time is not None and start_time < previous_end_time:
error.append(
gettext("The entry start time (%(st)s) cannot "
"overlap the previous entry's end time "
"(%(et)s)",
st=start_time, et=previous_end_time))
if next_method is not None and next_method.time_start is not None:
next_start_time = datetime.strptime(
next_method.time_start, '%Y-%m-%d %H:%M:%S')
if next_start_time is not None and end_time > next_start_time:
error.append(
gettext("The entry end time (%(et)s) cannot "
"overlap the next entry's start time "
"(%(st)s)",
et=end_time, st=next_start_time))
method_data.time_start = start_time.strftime('%Y-%m-%d %H:%M:%S')
method_data.time_end = end_time.strftime('%Y-%m-%d %H:%M:%S')
elif method.method_type == 'Duration':
if method_data.duration_sec == 0:
method_data.duration_end = form_mod_method.duration_end.data
else:
method_data.duration_sec = form_mod_method.duration.data
elif method.method_type == 'Daily':
method_data.time_start = form_mod_method.daily_time_start.data
method_data.time_end = form_mod_method.daily_time_end.data
method_data.setpoint_start = form_mod_method.setpoint_start.data
method_data.setpoint_end = form_mod_method.setpoint_end.data
elif form_mod_method.method_select.data == 'output':
if method.method_type == 'Date':
method_data.time_start = form_mod_method.output_time.data
elif method.method_type == 'Duration':
method_data.duration_sec = form_mod_method.duration.data
if form_mod_method.output_id.data == '':
method_data.output_id = None
else:
method_data.output_id = form_mod_method.output_id.data
method_data.output_state = form_mod_method.output_state.data
method_data.output_duration = form_mod_method.output_duration.data
elif method.method_type == 'DailySine':
if form_mod_method.method_select.data == 'output':
method_data.time_start = form_mod_method.output_time.data
if form_mod_method.output_id.data == '':
method_data.output_id = None
else:
method_data.output_id = form_mod_method.output_id.data
method_data.output_state = form_mod_method.output_state.data
method_data.output_duration = form_mod_method.output_duration.data
if not error:
db.session.commit()
except Exception as except_msg:
logger.exception(1)
error.append(except_msg)
flash_success_errors(error, action, url_for('routes_method.method_list'))