def method_create(form_create_method): """ Create new method table entry (all data stored in method_data table) """ action = '{action} {controller}'.format( action=gettext("Create"), controller=gettext("Method")) error = [] try: # Create method new_method = Method() new_method.name = form_create_method.name.data new_method.method_type = form_create_method.method_type.data db.session.add(new_method) db.session.commit() # Add new method line id to method display order method_order = DisplayOrder.query.first() display_order = csv_to_list_of_int(method_order.method) method_order.method = add_display_order(display_order, new_method.id) db.session.commit() # For tables that require only one entry to configure, # create that single entry now with default values if new_method.method_type == 'DailySine': new_method_data = MethodData() new_method_data.method_id = new_method.id new_method_data.amplitude = 1.0 new_method_data.frequency = 1.0 new_method_data.shift_angle = 0 new_method_data.shift_y = 1.0 db.session.add(new_method_data) db.session.commit() elif new_method.method_type == 'DailyBezier': new_method_data = MethodData() new_method_data.method_id = new_method.id new_method_data.shift_angle = 0.0 new_method_data.x0 = 20.0 new_method_data.y0 = 20.0 new_method_data.x1 = 10.0 new_method_data.y1 = 13.5 new_method_data.x2 = 22.5 new_method_data.y2 = 30.0 new_method_data.x3 = 0.0 new_method_data.y3 = 20.0 db.session.add(new_method_data) db.session.commit() # Add new method data line id to method_data display order if new_method.method_type in ['DailyBezier', 'DailySine']: display_order = csv_to_list_of_int(new_method.method_order) method = Method.query.filter(Method.id == new_method.id).first() method.method_order = add_display_order(display_order, new_method_data.id) db.session.commit() return 0 except Exception as except_msg: error.append(except_msg) flash_success_errors(error, action, url_for('routes_method.method_list'))
def func_add(form_add_func): action = '{action} {controller}'.format( action=gettext("Add"), controller=gettext("Function")) error = [] if form_add_func.validate(): try: if [ur for ur in PIDS if form_add_func.func_type.data == ur[0]]: new_func = PID().save() if not error: display_order = csv_to_list_of_str( DisplayOrder.query.first().pid) DisplayOrder.query.first().pid = add_display_order( display_order, new_func.unique_id) db.session.commit() elif [ur for ur in CONDITIONALS if form_add_func.func_type.data == ur[0]]: new_func = Conditional() new_func.conditional_type = form_add_func.func_type.data new_func.save() if not error: display_order = csv_to_list_of_str( DisplayOrder.query.first().conditional) DisplayOrder.query.first().conditional = 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) flash_success_errors(error, action, url_for('routes_page.page_function')) else: flash_form_errors(form_add_func)
def math_add(form_add_math): action = u'{action} {controller}'.format(action=gettext(u"Add"), controller=gettext(u"Math")) error = [] if form_add_math.validate(): new_math = Math() new_math.name = 'Math {name}'.format(name=form_add_math.math_type.data) new_math.math_type = form_add_math.math_type.data try: new_math.save() display_order = csv_to_list_of_int(DisplayOrder.query.first().math) DisplayOrder.query.first().math = add_display_order( display_order, new_math.id) db.session.commit() flash( gettext( u"%(type)s Math with ID %(id)s (%(uuid)s) successfully added", type=form_add_math.math_type.data, id=new_math.id, uuid=new_math.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('page_routes.page_input')) else: flash_form_errors(form_add_math)
def lcd_add(form): action = '{action} {controller}'.format( action=TRANSLATIONS['add']['title'], controller=TRANSLATIONS['lcd']['title']) error = [] if current_app.config['TESTING']: dep_unmet = False else: dep_unmet, _ = return_dependencies(form.lcd_type.data) 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.lcd_type.data, dep=', '.join(list_unmet_deps))) try: new_lcd = LCD() new_lcd_data = LCDData() if GPIO.RPI_REVISION == 2 or GPIO.RPI_REVISION == 3: new_lcd.i2c_bus = 1 else: new_lcd.i2c_bus = 0 new_lcd.lcd_type = form.lcd_type.data new_lcd.name = str(LCD_INFO[form.lcd_type.data]['name']) if form.lcd_type.data == '128x32_pioled': new_lcd.location = '0x3c' new_lcd.x_characters = 21 new_lcd.y_lines = 4 elif form.lcd_type.data == '128x64_pioled': new_lcd.location = '0x3c' new_lcd.x_characters = 21 new_lcd.y_lines = 8 elif form.lcd_type.data == '16x2_generic': new_lcd.location = '0x27' new_lcd.x_characters = 16 new_lcd.y_lines = 2 elif form.lcd_type.data == '16x4_generic': new_lcd.location = '0x27' new_lcd.x_characters = 16 new_lcd.y_lines = 4 if not error: new_lcd.save() new_lcd_data.lcd_id = new_lcd.unique_id new_lcd_data.save() display_order = csv_to_list_of_str(DisplayOrder.query.first().lcd) DisplayOrder.query.first().lcd = add_display_order( display_order, new_lcd.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) flash_success_errors(error, action, url_for('routes_page.page_lcd')) if dep_unmet: return 1
def lcd_add(quantity): action = '{action} {controller}'.format( action=gettext("Add"), controller=gettext("LCD")) error = [] for _ in range(0, quantity): try: new_lcd = LCD() new_lcd_data = LCDData() if GPIO.RPI_REVISION == 2 or GPIO.RPI_REVISION == 3: new_lcd.i2c_bus = 1 else: new_lcd.i2c_bus = 0 new_lcd.save() new_lcd_data.lcd_id = new_lcd.unique_id new_lcd_data.save() display_order = csv_to_list_of_str(DisplayOrder.query.first().lcd) DisplayOrder.query.first().lcd = add_display_order( display_order, new_lcd.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) flash_success_errors(error, action, url_for('routes_page.page_lcd'))
def math_add(form_add_math): action = '{action} {controller}'.format( action=TRANSLATIONS['add']['title'], controller=TRANSLATIONS['math']['title']) error = [] dep_unmet, _ = return_dependencies(form_add_math.math_type.data) 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_math.math_type.data, dep=', '.join(list_unmet_deps))) if form_add_math.validate(): new_math = Math() new_math.name = str(MATH_INFO[form_add_math.math_type.data]['name']) new_math.math_type = form_add_math.math_type.data try: new_math.save() display_order = csv_to_list_of_str( DisplayOrder.query.first().math) DisplayOrder.query.first().math = add_display_order( display_order, new_math.unique_id) db.session.commit() if not MATH_INFO[form_add_math.math_type.data]['measure']: new_measurement = DeviceMeasurements() new_measurement.device_id = new_math.unique_id new_measurement.channel = 0 new_measurement.save() else: for each_channel, measure_info in MATH_INFO[form_add_math.math_type.data]['measure'].items(): new_measurement = DeviceMeasurements() if 'name' in measure_info and measure_info['name']: new_measurement.name = measure_info['name'] new_measurement.device_id = new_math.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 Math with ID %(id)s (%(uuid)s) successfully added", type=form_add_math.math_type.data, id=new_math.id, uuid=new_math.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_math) if dep_unmet: return 1
def output_add(form_add): action = '{action} {controller}'.format(action=gettext("Add"), controller=gettext("Output")) error = [] dep_unmet, _ = return_dependencies(form_add.output_type.data) 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, dep=', '.join(list_unmet_deps))) if is_int(form_add.output_quantity.data, check_range=[1, 20]): for _ in range(0, form_add.output_quantity.data): try: new_output = Output() new_output.name = OUTPUT_INFO[ form_add.output_type.data]['name'] new_output.output_type = form_add.output_type.data if form_add.output_type.data == 'wired': new_output.on_at_start = False elif form_add.output_type.data == 'wireless_433MHz_pi_switch': new_output.pin = None new_output.protocol = 1 new_output.pulse_length = 189 new_output.on_command = '22559' new_output.off_command = '22558' elif form_add.output_type.data == 'command': new_output.on_command = '/home/pi/script_on.sh' new_output.off_command = '/home/pi/script_off.sh' elif form_add.output_type.data == 'command_pwm': new_output.pwm_command = '/home/pi/script_pwm.sh ((duty_cycle))' elif form_add.output_type.data == 'pwm': new_output.pwm_hertz = 22000 new_output.pwm_library = 'pigpio_any' 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() manipulate_output('Add', new_output.unique_id) except sqlalchemy.exc.OperationalError as except_msg: error.append(except_msg) except sqlalchemy.exc.IntegrityError as except_msg: error.append(except_msg) else: error_msg = "{error}. {accepted_values}: 1-20".format( error=gettext("Invalid quantity"), accepted_values=gettext("Acceptable values")) error.append(error_msg) flash_success_errors(error, action, url_for('routes_page.page_output')) if dep_unmet: return 1
def timer_add(display_order, form_add_timer_base, form_add_timer): action = u'{action} {controller}'.format(action=gettext(u"Add"), controller=gettext(u"Timer")) error = [] if not form_add_timer_base.validate(): error.append("Correct the inputs that are invalid and resubmit") flash_form_errors(form_add_timer_base) if not form_add_timer.validate(): error.append("Correct the inputs that are invalid and resubmit") flash_form_errors(form_add_timer) output = Output.query.filter( Output.unique_id == form_add_timer_base.relay_id.data).first() if (form_add_timer_base.timer_type.data == 'pwm_method' and output.relay_type != 'pwm'): error.append("PWM Method Timers require a PWM Output") elif (form_add_timer_base.timer_type.data != 'pwm_method' and output.relay_type == 'pwm'): error.append("Time and Duration Timers require a non-PWM Output") new_timer = Timer() new_timer.name = form_add_timer_base.name.data new_timer.relay_id = form_add_timer_base.relay_id.data new_timer.timer_type = form_add_timer_base.timer_type.data if form_add_timer_base.timer_type.data == 'time': new_timer.state = form_add_timer.state.data new_timer.time_start = form_add_timer.time_start.data new_timer.duration_on = form_add_timer.time_on_duration.data new_timer.duration_off = 0 elif form_add_timer_base.timer_type.data == 'timespan': new_timer.state = form_add_timer.state.data new_timer.time_start = form_add_timer.time_start_duration.data new_timer.time_end = form_add_timer.time_end_duration.data elif form_add_timer_base.timer_type.data == 'duration': if (form_add_timer.duration_on.data <= 0 or form_add_timer.duration_off.data <= 0): error.append(gettext(u"Durations must be greater than 0")) else: new_timer.duration_on = form_add_timer.duration_on.data new_timer.duration_off = form_add_timer.duration_off.data elif form_add_timer_base.timer_type.data == 'pwm_method': new_timer.method_id = form_add_timer.method_id.data new_timer.method_period = form_add_timer.method_period.data else: error.append("Not a recognized Timer type") if not error: try: new_timer.save() DisplayOrder.query.first().timer = add_display_order( display_order, new_timer.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) flash_success_errors(error, action, url_for('page_routes.page_timer'))
def func_add(form_add_func): action = '{action} {controller}'.format(action=gettext("Add"), controller=gettext("Function")) error = [] if form_add_func.validate(): try: if form_add_func.func_type.data == 'pid': new_func = PID().save() if not error: display_order = csv_to_list_of_int( DisplayOrder.query.first().pid) DisplayOrder.query.first().pid = add_display_order( display_order, new_func.id) db.session.commit() elif form_add_func.func_type.data in [ 'conditional_measurement', 'conditional_output', 'conditional_edge', 'conditional_sunrise_sunset' ]: new_func = Conditional() new_func.conditional_type = form_add_func.func_type.data new_func.save() if not error: display_order = csv_to_list_of_int( DisplayOrder.query.first().conditional) DisplayOrder.query.first().conditional = add_display_order( display_order, new_func.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) flash_success_errors(error, action, url_for('routes_page.page_function')) else: flash_form_errors(form_add_func)
def math_add(form_add_math): action = '{action} {controller}'.format( action=gettext("Add"), controller=gettext("Math")) error = [] unmet_deps = return_dependencies(form_add_math.math_type.data) if unmet_deps: error.append("The {dev} device you're trying to add has unmet dependencies: {dep}".format( dev=form_add_math.math_type.data, dep=unmet_deps)) if form_add_math.validate(): new_math = Math() new_math.name = '' new_math.math_type = form_add_math.math_type.data if form_add_math.math_type.data in MATH_INFO: new_math.name += '{name}'.format(name=MATH_INFO[form_add_math.math_type.data]['name']) new_math.measure = ",".join(MATH_INFO[form_add_math.math_type.data]['measure']) try: new_math.save() display_order = csv_to_list_of_str( DisplayOrder.query.first().math) DisplayOrder.query.first().math = add_display_order( display_order, new_math.unique_id) db.session.commit() flash(gettext( "%(type)s Math with ID %(id)s (%(uuid)s) successfully added", type=form_add_math.math_type.data, id=new_math.id, uuid=new_math.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_math) if unmet_deps: return 1
def output_add(form_add_relay): action = '{action} {controller}'.format(action=gettext("Add"), controller=gettext("Output")) error = [] if is_int(form_add_relay.relay_quantity.data, check_range=[1, 20]): for _ in range(0, form_add_relay.relay_quantity.data): try: new_relay = Output() new_relay.relay_type = form_add_relay.relay_type.data if form_add_relay.relay_type.data == 'wired': new_relay.on_at_start = False elif form_add_relay.relay_type.data == 'wireless_433MHz_pi_switch': new_relay.protocol = 1 new_relay.bit_length = 25 new_relay.pulse_length = 189 new_relay.on_command = '22559' new_relay.off_command = '22558' elif form_add_relay.relay_type.data == 'command': new_relay.on_command = '/home/pi/script_on.sh' new_relay.off_command = '/home/pi/script_off.sh' elif form_add_relay.relay_type.data == 'pwm': new_relay.pwm_hertz = 22000 new_relay.pwm_library = 'pigpio_any' new_relay.save() display_order = csv_to_list_of_int( DisplayOrder.query.first().relay) DisplayOrder.query.first().relay = add_display_order( display_order, new_relay.id) db.session.commit() manipulate_output('Add', new_relay.id) except sqlalchemy.exc.OperationalError as except_msg: error.append(except_msg) except sqlalchemy.exc.IntegrityError as except_msg: error.append(except_msg) else: error_msg = "{error}. {accepted_values}: 1-20".format( error=gettext("Invalid quantity"), accepted_values=gettext("Acceptable values")) error.append(error_msg) flash_success_errors(error, action, url_for('routes_page.page_output'))
def pid_add(form_add_pid): action = u'{action} {controller}'.format( action=gettext(u"Add"), controller=gettext(u"PID")) error = [] if form_add_pid.validate(): for _ in range(0, form_add_pid.numberPIDs.data): try: new_pid = PID().save() display_order = csv_to_list_of_int(DisplayOrder.query.first().pid) DisplayOrder.query.first().pid = add_display_order( display_order, new_pid.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) flash_success_errors(error, action, url_for('page_routes.page_pid')) else: flash_form_errors(form_add_pid)
def math_add(form_add_math): action = '{action} {controller}'.format( action=gettext("Add"), controller=gettext("Math")) error = [] if form_add_math.validate(): new_math = Math() new_math.name = 'Math {name}'.format(name=form_add_math.math_type.data) new_math.math_type = form_add_math.math_type.data if new_math.math_type == 'humidity': new_math.measure = 'humidity,humidity_ratio,specific_enthalpy,specific_volume' new_math.measure_units = '%' try: new_math.save() display_order = csv_to_list_of_int( DisplayOrder.query.first().math) DisplayOrder.query.first().math = add_display_order( display_order, new_math.id) db.session.commit() flash(gettext( "%(type)s Math with ID %(id)s (%(uuid)s) successfully added", type=form_add_math.math_type.data, id=new_math.id, uuid=new_math.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_math)
def lcd_add(form): action = '{action} {controller}'.format( action=TRANSLATIONS['add']['title'], controller=TRANSLATIONS['lcd']['title']) error = [] if current_app.config['TESTING']: dep_unmet = False else: dep_unmet, _ = return_dependencies(form.lcd_type.data) 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.lcd_type.data, dep=', '.join(list_unmet_deps))) try: new_lcd = LCD() new_lcd_data = LCDData() try: from RPi import GPIO if GPIO.RPI_REVISION == 2 or GPIO.RPI_REVISION == 3: new_lcd.i2c_bus = 1 else: new_lcd.i2c_bus = 0 except: logger.error("RPi.GPIO and Raspberry Pi required for this action") lcd_id = form.lcd_type.data.split(",")[0] lcd_interface = form.lcd_type.data.split(",")[1] new_lcd.lcd_type = lcd_id new_lcd.interface = lcd_interface new_lcd.name = str(LCD_INFO[lcd_id]['name']) if lcd_id in ['128x32_pioled', '128x64_pioled' ] and lcd_interface == 'I2C': new_lcd.location = '0x3c' new_lcd.pin_reset = 19 elif lcd_id in ['16x2_generic', '20x4_generic' ] and lcd_interface == 'I2C': new_lcd.location = '0x27' elif lcd_interface == 'SPI': new_lcd.pin_reset = 19 new_lcd.pin_dc = 16 new_lcd.spi_device = 0 new_lcd.spi_bus = 0 if lcd_id == '128x32_pioled': new_lcd.x_characters = 21 new_lcd.y_lines = 4 elif lcd_id == '128x64_pioled': new_lcd.x_characters = 21 new_lcd.y_lines = 8 elif lcd_id == '16x2_generic': new_lcd.x_characters = 16 new_lcd.y_lines = 2 elif lcd_id == '20x4_generic': new_lcd.x_characters = 20 new_lcd.y_lines = 4 if not error: new_lcd.save() new_lcd_data.lcd_id = new_lcd.unique_id new_lcd_data.save() display_order = csv_to_list_of_str(DisplayOrder.query.first().lcd) DisplayOrder.query.first().lcd = add_display_order( display_order, new_lcd.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) flash_success_errors(error, action, url_for('routes_page.page_lcd')) if dep_unmet: return 1
def function_add(form_add_func): action = '{action} {controller}'.format( action=TRANSLATIONS['add']['title'], controller=TRANSLATIONS['function']['title']) error = [] dep_unmet, _ = return_dependencies(form_add_func.function_type.data) 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_func.function_type.data, dep=', '.join(list_unmet_deps))) new_func = None try: if form_add_func.function_type.data.startswith('conditional_'): new_func = Conditional() new_func.conditional_statement = ''' # Replace "asdf1234" with a Condition ID, "qwer5678" with an Action ID. measurement = measure("{asdf1234}") message += "Measure: {meas}".format(meas=measurement) if measurement is not None: # If a measurement exists if measurement < 23: # If the measurement is less than 23 run_all_actions(message=message) # Run all actions else: # If the measurement is greater or equal to 23 run_action("{qwer5678}", message=message) # Run a single Action''' new_func.save() elif form_add_func.function_type.data.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 new_measurement.save() elif form_add_func.function_type.data.startswith('trigger_'): new_func = Trigger() new_func.name = '{}'.format( FUNCTION_INFO[form_add_func.function_type.data]['name']) new_func.trigger_type = form_add_func.function_type.data new_func.save() elif form_add_func.function_type.data.startswith('function_'): new_func = Function() if form_add_func.function_type.data == 'function_spacer': new_func.name = 'Spacer' new_func.function_type = form_add_func.function_type.data new_func.save() elif form_add_func.function_type.data == '': error.append("Must select a function type") else: error.append("Unknown function type: '{}'".format( form_add_func.function_type.data)) 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 output_add(form_add): action = '{action} {controller}'.format( action=TRANSLATIONS['add']['title'], controller=TRANSLATIONS['output']['title']) error = [] dict_outputs = parse_output_information() output_types_dict = output_types() # only one comma should be in the output_type string if form_add.output_type.data.count(',') > 1: error.append("Invalid output module formatting. It appears there is " "a comma in either 'output_name_unique' or 'interfaces'.") 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 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, 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 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 # # Custom Options # list_options = [] if 'custom_options' in dict_outputs[output_type]: for each_option in dict_outputs[output_type][ '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_output.custom_options = ';'.join(list_options) if output_type in output_types_dict['pwm']: new_output.pwm_hertz = 22000 new_output.pwm_library = 'pigpio_any' if output_type in output_types_dict['volume']: new_output.output_mode = 'fastest_flow_rate' new_output.flow_rate = 10 if output_type == 'atlas_ezo_pmp': if output_interface == 'FTDI': new_output.location = '/dev/ttyUSB0' elif output_interface == 'I2C': new_output.location = '0x67' new_output.i2c_bus = 1 elif output_interface == 'UART': new_output.location = '/dev/ttyAMA0' new_output.baud_rate = 9600 if output_type == 'wired': new_output.state_startup = '0' new_output.state_shutdown = '0' elif output_type == 'wireless_rpi_rf': new_output.pin = None new_output.protocol = 1 new_output.pulse_length = 189 new_output.on_command = '22559' new_output.off_command = '22558' new_output.force_command = True elif output_type == 'command': new_output.linux_command_user = '******' new_output.on_command = '/home/pi/script_on.sh' new_output.off_command = '/home/pi/script_off.sh' new_output.force_command = True elif output_type == 'command_pwm': new_output.linux_command_user = '******' new_output.pwm_command = '/home/pi/script_pwm.sh ((duty_cycle))' elif output_type == 'python': new_output.on_command = """ import datetime timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") log_string = "{ts}: ID: {id}: ON".format(id=output_id, ts=timestamp) self.logger.info(log_string)""" new_output.off_command = """ import datetime timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") log_string = "{ts}: ID: {id}: OFF".format(id=output_id, ts=timestamp) self.logger.info(log_string)""" new_output.force_command = True elif output_type == 'python_pwm': new_output.pwm_command = """ import datetime timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") log_string = "{ts}: ID: {id}: {dc} % Duty Cycle".format( dc=duty_cycle, id=output_id, ts=timestamp) self.logger.info(log_string)""" 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) # # If measurements defined in the Output Module # if ('measurements_dict' in dict_outputs[output_type] and dict_outputs[output_type]['measurements_dict'] != []): for each_channel in dict_outputs[output_type][ 'measurements_dict']: measure_info = dict_outputs[output_type][ 'measurements_dict'][each_channel] 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_channel new_measurement.save() db.session.commit() if not current_app.config['TESTING']: manipulate_output('Add', new_output.unique_id) 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_output')) if dep_unmet: return 1
def input_add(form_add): action = '{action} {controller}'.format( action=gettext("Add"), controller=gettext("Input")) error = [] if current_app.config['TESTING']: unmet_deps = False else: unmet_deps = return_dependencies(form_add.input_type.data) if unmet_deps: error.append("The {dev} device you're trying to add has unmet dependencies: {dep}".format( dev=form_add.input_type.data, dep=unmet_deps)) if form_add.validate(): new_sensor = Input() new_sensor.device = form_add.input_type.data if GPIO.RPI_INFO['P1_REVISION'] in [2, 3]: new_sensor.i2c_bus = 1 else: new_sensor.i2c_bus = 0 if form_add.input_type.data in DEVICE_INFO: new_sensor.name = DEVICE_INFO[form_add.input_type.data]['name'] new_sensor.measurements = ",".join(DEVICE_INFO[form_add.input_type.data]['measure']) else: new_sensor.name = 'Name' # # Set default values for new Inputs # # Linux command as sensor if form_add.input_type.data == 'LinuxCommand': new_sensor.cmd_command = 'shuf -i 50-70 -n 1' new_sensor.cmd_measurement = 'Condition' new_sensor.cmd_measurement_units = 'unit' # Server is up or down elif form_add.input_type.data in ['SERVER_PING', 'SERVER_PORT_OPEN']: new_sensor.location = '127.0.0.1' new_sensor.period = 3600 # Process monitors elif form_add.input_type.data == 'MYCODO_RAM': new_sensor.location = 'Mycodo_daemon' elif form_add.input_type.data == 'RPi': new_sensor.location = 'RPi' elif form_add.input_type.data == 'RPiCPULoad': new_sensor.location = 'RPi' elif form_add.input_type.data == 'RPiFreeSpace': new_sensor.location = '/' # Environmental Inputs # Electrical Conductivity elif form_add.input_type.data == 'ATLAS_EC_I2C': new_sensor.location = '0x01' new_sensor.interface = 'I2C' elif form_add.input_type.data == 'ATLAS_EC_UART': new_sensor.location = 'Tx/Rx' new_sensor.interface = 'UART' new_sensor.baud_rate = 9600 if GPIO.RPI_INFO['P1_REVISION'] == 3: new_sensor.device_loc = "/dev/ttyS0" else: new_sensor.device_loc = "/dev/ttyAMA0" # Temperature if form_add.input_type.data == 'TMP006': new_sensor.location = '0x40' elif form_add.input_type.data == 'ATLAS_PT1000_I2C': new_sensor.interface = 'I2C' new_sensor.location = '0x66' elif form_add.input_type.data == 'ATLAS_PT1000_UART': new_sensor.location = 'Tx/Rx' new_sensor.interface = 'UART' new_sensor.baud_rate = 9600 if GPIO.RPI_INFO['P1_REVISION'] == 3: new_sensor.device_loc = "/dev/ttyS0" else: new_sensor.device_loc = "/dev/ttyAMA0" elif form_add.input_type.data in ['MAX31855', 'MAX31856', 'MAX31865']: new_sensor.pin_cs = 8 new_sensor.pin_miso = 9 new_sensor.pin_mosi = 10 new_sensor.pin_clock = 11 if form_add.input_type.data == 'MAX31856': new_sensor.thermocouple_type = 'K' elif form_add.input_type.data == 'MAX31865': new_sensor.thermocouple_type = 'PT100' new_sensor.ref_ohm = 0 # Temperature/Humidity elif form_add.input_type.data in ['AM2315', 'DHT11', 'DHT22', 'HTU21D', 'SHT1x_7x', 'SHT2x']: if form_add.input_type.data == 'AM2315': new_sensor.location = '0x5c' elif form_add.input_type.data == 'HTU21D': new_sensor.location = '0x40' elif form_add.input_type.data == 'SHT2x': new_sensor.location = '0x40' # Chirp moisture sensor elif form_add.input_type.data == 'CHIRP': new_sensor.location = '0x20' # CO2 elif form_add.input_type.data == 'MH_Z16_I2C': new_sensor.location = '0x63' new_sensor.interface = 'I2C' elif form_add.input_type.data in ['K30_UART', 'MH_Z16_UART', 'MH_Z19_UART']: new_sensor.location = 'Tx/Rx' new_sensor.interface = 'UART' new_sensor.baud_rate = 9600 if GPIO.RPI_INFO['P1_REVISION'] == 3: new_sensor.device_loc = "/dev/ttyS0" else: new_sensor.device_loc = "/dev/ttyAMA0" # pH elif form_add.input_type.data == 'ATLAS_PH_I2C': new_sensor.location = '0x63' new_sensor.interface = 'I2C' elif form_add.input_type.data == 'ATLAS_PH_UART': new_sensor.location = 'Tx/Rx' new_sensor.interface = 'UART' new_sensor.baud_rate = 9600 if GPIO.RPI_INFO['P1_REVISION'] == 3: new_sensor.device_loc = "/dev/ttyS0" else: new_sensor.device_loc = "/dev/ttyAMA0" # Pressure if form_add.input_type.data == 'BME280': new_sensor.location = '0x76' elif form_add.input_type.data in ['BMP180', 'BMP280']: new_sensor.location = '0x77' # Light elif form_add.input_type.data in ['BH1750', 'TSL2561', 'TSL2591']: if form_add.input_type.data == 'BH1750': new_sensor.location = '0x23' new_sensor.resolution = 0 # 0=Low, 1=High, 2=High2 new_sensor.sensitivity = 69 elif form_add.input_type.data == 'TSL2561': new_sensor.location = '0x39' elif form_add.input_type.data == 'TSL2591': new_sensor.location = '0x29' # Analog to Digital Converters elif form_add.input_type.data in LIST_DEVICES_ADC: new_sensor.adc_measure = 'Condition' new_sensor.adc_measure_units = 'units' if form_add.input_type.data == 'ADS1x15': new_sensor.location = '0x48' new_sensor.adc_volts_min = -4.096 new_sensor.adc_volts_max = 4.096 elif form_add.input_type.data == 'MCP342x': new_sensor.location = '0x68' new_sensor.adc_volts_min = -2.048 new_sensor.adc_volts_max = 2.048 elif form_add.input_type.data == 'MCP3008': new_sensor.pin_cs = 8 new_sensor.pin_miso = 9 new_sensor.pin_mosi = 10 new_sensor.pin_clock = 11 new_sensor.adc_volts_min = 0 new_sensor.adc_volts_max = 3.3 try: if not error: new_sensor.save() display_order = csv_to_list_of_str( DisplayOrder.query.first().inputs) DisplayOrder.query.first().inputs = add_display_order( display_order, new_sensor.unique_id) db.session.commit() flash(gettext( "%(type)s Input with ID %(id)s (%(uuid)s) successfully added", type=form_add.input_type.data, id=new_sensor.id, uuid=new_sensor.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 unmet_deps: return 1
def method_add(form_add_method): """ Add line to method_data table """ action = '{action} {controller}'.format( action=TRANSLATIONS['add']['title'], controller=TRANSLATIONS['method']['title']) error = [] start_time = None end_time = None method = Method.query.filter( Method.unique_id == form_add_method.method_id.data).first() display_order = csv_to_list_of_str(method.method_order) try: if validate_method_data(form_add_method, method): return 1 if method.method_type == 'DailySine': add_method_data = MethodData.query.filter( MethodData.method_id == form_add_method.method_id.data).first() add_method_data.amplitude = form_add_method.amplitude.data add_method_data.frequency = form_add_method.frequency.data add_method_data.shift_angle = form_add_method.shift_angle.data add_method_data.shift_y = form_add_method.shiftY.data db.session.commit() return 0 elif method.method_type == 'DailyBezier': if not 0 <= form_add_method.shift_angle.data <= 360: flash(gettext("Error: Angle Shift is out of range. It must be " "<= 0 and <= 360."), "error") return 1 if form_add_method.x0.data <= form_add_method.x3.data: flash(gettext("Error: X0 must be greater than X3."), "error") return 1 add_method_data = MethodData.query.filter( MethodData.method_id == form_add_method.method_id.data).first() add_method_data.shift_angle = form_add_method.shift_angle.data add_method_data.x0 = form_add_method.x0.data add_method_data.y0 = form_add_method.y0.data add_method_data.x1 = form_add_method.x1.data add_method_data.y1 = form_add_method.y1.data add_method_data.x2 = form_add_method.x2.data add_method_data.y2 = form_add_method.y2.data add_method_data.x3 = form_add_method.x3.data add_method_data.y3 = form_add_method.y3.data db.session.commit() return 0 if form_add_method.method_select.data == 'setpoint': if method.method_type == 'Date': start_time = datetime.strptime( form_add_method.time_start.data, '%Y-%m-%d %H:%M:%S') end_time = datetime.strptime( form_add_method.time_end.data, '%Y-%m-%d %H:%M:%S') elif method.method_type == 'Daily': start_time = datetime.strptime( form_add_method.daily_time_start.data, '%H:%M:%S') end_time = datetime.strptime( form_add_method.daily_time_end.data, '%H:%M:%S') if method.method_type in ['Date', 'Daily']: # Check if the start time comes after the last entry's end time display_order = csv_to_list_of_str(method.method_order) if display_order: last_method = MethodData.query.filter( MethodData.unique_id == display_order[-1]).first() else: last_method = None if last_method is not None: if method.method_type == 'Date': last_method_end_time = datetime.strptime( last_method.time_end, '%Y-%m-%d %H:%M:%S') elif method.method_type == 'Daily': last_method_end_time = datetime.strptime( last_method.time_end, '%H:%M:%S') else: last_method_end_time = None if (start_time and last_method_end_time and start_time < last_method_end_time): flash(gettext("The new entry start time (%(st)s) " "cannot overlap the last entry's end " "time (%(et)s). Note: They may be the " "same time.", st=last_method_end_time, et=start_time), "error") return 1 elif form_add_method.method_select.data == 'output': if method.method_type == 'Date': start_time = datetime.strptime( form_add_method.output_time.data, '%Y-%m-%d %H:%M:%S') elif method.method_type == 'Daily': start_time = datetime.strptime( form_add_method.output_daily_time.data, '%H:%M:%S') add_method_data = MethodData() add_method_data.method_id = form_add_method.method_id.data if method.method_type == 'Date': if form_add_method.method_select.data == 'setpoint': add_method_data.time_start = start_time.strftime( '%Y-%m-%d %H:%M:%S') add_method_data.time_end = end_time.strftime( '%Y-%m-%d %H:%M:%S') if form_add_method.method_select.data == 'output': add_method_data.time_start = form_add_method.output_time.data elif method.method_type == 'Daily': if form_add_method.method_select.data == 'setpoint': add_method_data.time_start = start_time.strftime('%H:%M:%S') add_method_data.time_end = end_time.strftime('%H:%M:%S') if form_add_method.method_select.data == 'output': add_method_data.time_start = form_add_method.output_daily_time.data elif method.method_type == 'Duration': if form_add_method.restart.data: add_method_data.duration_sec = 0 add_method_data.duration_end = form_add_method.duration_end.data else: add_method_data.duration_sec = form_add_method.duration.data if form_add_method.method_select.data == 'setpoint': add_method_data.setpoint_start = form_add_method.setpoint_start.data add_method_data.setpoint_end = form_add_method.setpoint_end.data elif form_add_method.method_select.data == 'output': add_method_data.output_id = form_add_method.output_id.data add_method_data.output_state = form_add_method.output_state.data add_method_data.output_duration = form_add_method.output_duration.data db.session.add(add_method_data) db.session.commit() # Add line to method data list if not a output duration if form_add_method.method_select.data != 'output': method.method_order = add_display_order( display_order, add_method_data.unique_id) db.session.commit() if form_add_method.method_select.data == 'setpoint': if method.method_type == 'Date': flash(gettext("Added duration to method from %(st)s to " "%(end)s", st=start_time, end=end_time), "success") elif method.method_type == 'Daily': flash(gettext("Added duration to method from %(st)s to " "%(end)s", st=start_time.strftime('%H:%M:%S'), end=end_time.strftime('%H:%M:%S')), "success") elif method.method_type == 'Duration': if form_add_method.restart.data: flash(gettext("Added method restart"), "success") else: flash(gettext("Added duration to method for %(sec)s seconds", sec=form_add_method.duration.data), "success") elif form_add_method.method_select.data == 'output': if method.method_type == 'Date': flash(gettext("Added output modulation to method at start " "time: %(tm)s", tm=start_time), "success") elif method.method_type == 'Daily': flash(gettext("Added output modulation to method at start " "time: %(tm)s", tm=start_time.strftime('%H:%M:%S')), "success") elif method.method_type == 'Duration': flash(gettext("Added output modulation to method at start " "time: %(tm)s", tm=form_add_method.duration.data), "success") except Exception as except_msg: logger.exception(1) error.append(except_msg) flash_success_errors(error, action, url_for('routes_method.method_list'))
def remote_host_add(form_setup, display_order): """ Add a remote Mycodo to the Remote Admin Dashboard Authenticate a remote Mycodo install that will be used on this system's Remote Admin dashboard. The user name and password is sent, and if verified, the password hash and SSL certificate is sent back. The hash is used to authenticate and the certificate is used to perform a verified SSL, in all subsequent connections. """ if not utils_general.user_has_permission('edit_settings'): return redirect(url_for('routes_general.home')) if form_setup.validate(): try: # Send user and password to remote Mycodo to authenticate credentials = { 'user': form_setup.username.data, 'passw': form_setup.password.data } url = 'https://{}/newremote/'.format(form_setup.host.data) try: pw_check = requests.get( url, params=credentials, verify=False).json() except Exception: return 1 if 'status' not in pw_check: flash("Unknown response: {res}".format(res=pw_check), "error") return 1 elif pw_check['status']: flash(pw_check['error_msg'], "error") return 1 # Write remote certificate to file assure_path_exists(STORED_SSL_CERTIFICATE_PATH) public_key = '{path}/{file}'.format( path=STORED_SSL_CERTIFICATE_PATH, file='{add}_cert.pem'.format(add=form_setup.host.data)) file_handler = open(public_key, 'w') file_handler.write(pw_check['certificate']) file_handler.close() new_remote_host = Remote() new_remote_host.host = form_setup.host.data new_remote_host.username = form_setup.username.data new_remote_host.password_hash = pw_check['hash'] try: db.session.add(new_remote_host) db.session.commit() flash(gettext("Remote Host %(host)s with ID %(id)s " "(%(uuid)s) successfully added", host=form_setup.host.data, id=new_remote_host.id, uuid=new_remote_host.unique_id), "success") DisplayOrder.query.first().remote_host = add_display_order( display_order, new_remote_host.unique_id) db.session.commit() except sqlalchemy.exc.OperationalError as except_msg: flash(gettext("Error: %(err)s", err='Remote Host Add: {msg}'.format(msg=except_msg)), "error") except sqlalchemy.exc.IntegrityError as except_msg: flash(gettext("Error: %(err)s", err='Remote Host Add: {msg}'.format(msg=except_msg)), "error") except Exception as except_msg: flash(gettext("Error: %(err)s", err='Remote Host Add: {msg}'.format(msg=except_msg)), "error") else: flash_form_errors(form_setup)
def input_add(form_add, request_form): action = '{action} {controller}'.format(action=gettext("Add"), controller=gettext("Input")) 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 if GPIO.RPI_INFO['P1_REVISION'] in [2, 3]: new_input.i2c_bus = 1 else: new_input.i2c_bus = 0 if 'input_name' in dict_inputs[input_name]: new_input.name = dict_inputs[input_name]['input_name'] else: new_input.name = 'Input Name' if ('measurements_list' in dict_inputs[input_name] and dict_inputs[input_name]['measurements_list'] != []): new_input.measurements = ",".join( dict_inputs[input_name]['measurements_list']) elif input_name == 'LinuxCommand': pass else: error.append("No measurements defined for this input.") # # Set default values for new input being added # # Set the default measurement values list_units = [] if 'measurements_list' in dict_inputs[input_name]: for each_measurement in dict_inputs[input_name][ 'measurements_list']: if each_measurement in MEASUREMENTS: entry = '{measure},{unit}'.format( measure=each_measurement, unit=MEASUREMENTS[each_measurement]['units'][0]) list_units.append(entry) else: error.append( "Measurement '{measure}' not recognized.".format( measure=each_measurement)) new_input.convert_to_unit = ";".join(list_units) # 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 # # I2C 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 # UART options if dict_has_value('uart_location'): new_input.uart_location = dict_inputs[input_name][ 'uart_location'] 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_channel'): if len(dict_inputs[input_name]['adc_channel']) == 1: new_input.adc_channel = dict_inputs[input_name][ 'adc_channel'][0] elif len(dict_inputs[input_name]['adc_channel']) > 1: new_input.adc_channel = dict_inputs[input_name][ 'adc_channel'][0][0] 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] if dict_has_value('adc_volts_min'): new_input.adc_volts_min = dict_inputs[input_name][ 'adc_volts_min'] if dict_has_value('adc_volts_max'): new_input.adc_volts_max = dict_inputs[input_name][ 'adc_volts_max'] if dict_has_value('adc_units_min'): new_input.adc_units_min = dict_inputs[input_name][ 'adc_units_min'] if dict_has_value('adc_units_max'): new_input.adc_units_max = dict_inputs[input_name][ 'adc_units_max'] if dict_has_value('adc_inverse_unit_scale'): new_input.adc_inverse_unit_scale = dict_inputs[input_name][ 'adc_inverse_unit_scale'] # 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 # list_options = [] if 'custom_options' in dict_inputs[input_name]: for each_option in dict_inputs[input_name]['custom_options']: option = '{id},{value}'.format( id=each_option['id'], value=each_option['default_value']) list_options.append(option) new_input.custom_options = ';'.join(list_options) 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() 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
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
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 if GPIO.RPI_INFO['P1_REVISION'] in [2, 3]: new_input.i2c_bus = 1 else: new_input.i2c_bus = 0 if 'input_name' in dict_inputs[input_name]: new_input.name = dict_inputs[input_name]['input_name'] else: new_input.name = 'Input 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 # # I2C 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 # UART options if dict_has_value('uart_location'): new_input.uart_location = dict_inputs[input_name]['uart_location'] if dict_has_value('ftdi_location'): new_input.uart_location = dict_inputs[input_name]['ftdi_location'] 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 # list_options = [] if 'custom_options' in dict_inputs[input_name]: for each_option in dict_inputs[input_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_input.custom_options = ';'.join(list_options) 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 ('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
def input_add(form_add_sensor): action = '{action} {controller}'.format(action=gettext("Add"), controller=gettext("Input")) error = [] if form_add_sensor.validate(): new_sensor = Input() new_sensor.device = form_add_sensor.input_type.data new_sensor.name = '{name} Input'.format( name=form_add_sensor.input_type.data) if GPIO.RPI_INFO['P1_REVISION'] in [2, 3]: new_sensor.i2c_bus = 1 new_sensor.multiplexer_bus = 1 else: new_sensor.i2c_bus = 0 new_sensor.multiplexer_bus = 0 # Linux command as sensor if form_add_sensor.input_type.data == 'LinuxCommand': new_sensor.cmd_command = 'shuf -i 50-70 -n 1' new_sensor.cmd_measurement = 'Condition' new_sensor.cmd_measurement_units = 'unit' # Server is up or down elif form_add_sensor.input_type.data in [ 'SERVER_PING', 'SERVER_PORT_OPEN' ]: new_sensor.measurements = 'boolean' new_sensor.location = '127.0.0.1' new_sensor.period = 3600 # Process monitors elif form_add_sensor.input_type.data == 'MYCODO_RAM': new_sensor.measurements = 'disk_space' new_sensor.location = 'Mycodo_daemon' elif form_add_sensor.input_type.data == 'RPi': new_sensor.measurements = 'temperature' new_sensor.location = 'RPi' elif form_add_sensor.input_type.data == 'RPiCPULoad': new_sensor.measurements = 'cpu_load_1m,' \ 'cpu_load_5m,' \ 'cpu_load_15m' new_sensor.location = 'RPi' elif form_add_sensor.input_type.data == 'RPiFreeSpace': new_sensor.measurements = 'disk_space' new_sensor.location = '/' elif form_add_sensor.input_type.data == 'EDGE': new_sensor.measurements = 'edge' elif form_add_sensor.input_type.data == 'GPIO_STATE': new_sensor.measurements = 'gpio_state' # Signal measuremnt (PWM and RPM) elif form_add_sensor.input_type.data == 'SIGNAL_PWM': new_sensor.measurements = 'frequency,pulse_width,duty_cycle' elif form_add_sensor.input_type.data == 'SIGNAL_RPM': new_sensor.measurements = 'rpm' # Environmental Inputs # Temperature elif form_add_sensor.input_type.data in [ 'ATLAS_PT1000_I2C', 'ATLAS_PT1000_UART', 'DS18B20', 'TMP006' ]: new_sensor.measurements = 'temperature' if form_add_sensor.input_type.data == 'ATLAS_PT1000_I2C': new_sensor.interface = 'I2C' new_sensor.location = '0x66' elif form_add_sensor.input_type.data == 'ATLAS_PT1000_UART': new_sensor.location = 'Tx/Rx' new_sensor.interface = 'UART' new_sensor.baud_rate = 9600 if GPIO.RPI_INFO['P1_REVISION'] == 3: new_sensor.device_loc = "/dev/ttyS0" else: new_sensor.device_loc = "/dev/ttyAMA0" elif form_add_sensor.input_type.data == 'TMP006': new_sensor.measurements = 'temperature_object,' \ 'temperature_die' new_sensor.location = '0x40' # Temperature/Humidity elif form_add_sensor.input_type.data in [ 'AM2315', 'DHT11', 'DHT22', 'HTU21D', 'SHT1x_7x', 'SHT2x' ]: new_sensor.measurements = 'temperature,humidity,dewpoint' if form_add_sensor.input_type.data == 'AM2315': new_sensor.location = '0x5c' elif form_add_sensor.input_type.data == 'HTU21D': new_sensor.location = '0x40' elif form_add_sensor.input_type.data == 'SHT2x': new_sensor.location = '0x40' # Chirp moisture sensor elif form_add_sensor.input_type.data == 'CHIRP': new_sensor.measurements = 'lux,moisture,temperature' new_sensor.location = '0x20' # CO2 elif form_add_sensor.input_type.data == 'MH_Z16_I2C': new_sensor.measurements = 'co2' new_sensor.location = '0x63' new_sensor.interface = 'I2C' elif form_add_sensor.input_type.data in [ 'K30_UART', 'MH_Z16_UART', 'MH_Z19_UART' ]: new_sensor.measurements = 'co2' new_sensor.location = 'Tx/Rx' new_sensor.interface = 'UART' new_sensor.baud_rate = 9600 if GPIO.RPI_INFO['P1_REVISION'] == 3: new_sensor.device_loc = "/dev/ttyS0" else: new_sensor.device_loc = "/dev/ttyAMA0" # pH elif form_add_sensor.input_type.data == 'ATLAS_PH_I2C': new_sensor.measurements = 'ph' new_sensor.location = '0x63' new_sensor.interface = 'I2C' elif form_add_sensor.input_type.data == 'ATLAS_PH_UART': new_sensor.measurements = 'ph' new_sensor.location = 'Tx/Rx' new_sensor.interface = 'UART' new_sensor.baud_rate = 9600 if GPIO.RPI_INFO['P1_REVISION'] == 3: new_sensor.device_loc = "/dev/ttyS0" else: new_sensor.device_loc = "/dev/ttyAMA0" # Pressure elif form_add_sensor.input_type.data in ['BME280', 'BMP180', 'BMP280']: if form_add_sensor.input_type.data == 'BME280': new_sensor.measurements = 'temperature,humidity,' \ 'dewpoint,pressure,altitude' new_sensor.location = '0x76' elif form_add_sensor.input_type.data in ['BMP180', 'BMP280']: new_sensor.measurements = 'temperature,pressure,altitude' new_sensor.location = '0x77' # Light elif form_add_sensor.input_type.data in [ 'BH1750', 'TSL2561', 'TSL2591' ]: new_sensor.measurements = 'lux' if form_add_sensor.input_type.data == 'BH1750': new_sensor.location = '0x23' new_sensor.resolution = 0 # 0=Low, 1=High, 2=High2 new_sensor.sensitivity = 69 elif form_add_sensor.input_type.data == 'TSL2561': new_sensor.location = '0x39' elif form_add_sensor.input_type.data == 'TSL2591': new_sensor.location = '0x29' # Analog to Digital Converters elif form_add_sensor.input_type.data in ['ADS1x15', 'MCP342x']: new_sensor.measurements = 'voltage' if form_add_sensor.input_type.data == 'ADS1x15': new_sensor.location = '0x48' new_sensor.adc_volts_min = -4.096 new_sensor.adc_volts_max = 4.096 elif form_add_sensor.input_type.data == 'MCP342x': new_sensor.location = '0x68' new_sensor.adc_volts_min = -2.048 new_sensor.adc_volts_max = 2.048 try: new_sensor.save() display_order = csv_to_list_of_int( DisplayOrder.query.first().sensor) DisplayOrder.query.first().sensor = add_display_order( display_order, new_sensor.id) db.session.commit() flash( gettext( "%(type)s Input with ID %(id)s (%(uuid)s) successfully added", type=form_add_sensor.input_type.data, id=new_sensor.id, uuid=new_sensor.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_sensor)
def dashboard_add(form_base, form_object, display_order): """ Add an item to the dashboard Either Graph, Gauge, or Camera """ action = '{action} {controller}'.format(action=gettext("Add"), controller=gettext("Dashboard")) error = [] dashboard_type = '' new_graph = Dashboard() new_graph.name = form_base.name.data # Graph if (form_base.dashboard_type.data == 'graph' and (form_base.name.data and form_base.width.data and form_base.height.data and form_object.xaxis_duration.data and form_base.refresh_duration.data)): dashboard_type = 'Graph' error = graph_error_check(form_object, error) new_graph.graph_type = form_base.dashboard_type.data if form_object.math_ids.data: math_ids_joined = ";".join(form_object.math_ids.data) new_graph.math_ids = math_ids_joined if form_object.pid_ids.data: pid_ids_joined = ";".join(form_object.pid_ids.data) new_graph.pid_ids = pid_ids_joined if form_object.output_ids.data: output_ids_joined = ";".join(form_object.output_ids.data) new_graph.output_ids = output_ids_joined if form_object.input_ids.data: input_ids_joined = ";".join(form_object.input_ids.data) new_graph.input_ids_measurements = input_ids_joined new_graph.width = form_base.width.data new_graph.height = form_base.height.data new_graph.x_axis_duration = form_object.xaxis_duration.data new_graph.refresh_duration = form_base.refresh_duration.data new_graph.enable_auto_refresh = form_object.enable_auto_refresh.data new_graph.enable_xaxis_reset = form_object.enable_xaxis_reset.data new_graph.enable_title = form_object.enable_title.data new_graph.enable_navbar = form_object.enable_navbar.data new_graph.enable_rangeselect = form_object.enable_range.data new_graph.enable_export = form_object.enable_export.data new_graph.enable_graph_shift = form_object.enable_graph_shift.data new_graph.enable_manual_y_axis = form_object.enable_manual_y_axis.data # Gauge elif form_base.dashboard_type.data == 'gauge': dashboard_type = 'Gauge' error = gauge_error_check(form_object, error) new_graph.graph_type = form_object.gauge_type.data if form_object.gauge_type.data == 'gauge_solid': new_graph.range_colors = '20,#33CCFF;40,#55BF3B;60,#DDDF0D;80,#DF5353' elif form_object.gauge_type.data == 'gauge_angular': new_graph.range_colors = '0,25,#33CCFF;25,50,#55BF3B;50,75,#DDDF0D;75,100,#DF5353' new_graph.width = form_base.width.data new_graph.height = form_base.height.data new_graph.max_measure_age = form_object.max_measure_age.data new_graph.refresh_duration = form_base.refresh_duration.data new_graph.y_axis_min = form_object.y_axis_min.data new_graph.y_axis_max = form_object.y_axis_max.data new_graph.input_ids_measurements = form_object.input_ids.data new_graph.enable_timestamp = form_object.enable_timestamp.data # Measurement elif form_base.dashboard_type.data == 'measurement': dashboard_type = 'Measurement' error = measurement_error_check(form_object, error) new_graph.graph_type = 'measurement' new_graph.width = form_base.width.data new_graph.height = form_base.height.data new_graph.max_measure_age = form_object.max_measure_age.data new_graph.refresh_duration = form_base.refresh_duration.data new_graph.font_em_value = form_object.font_em_value.data new_graph.font_em_timestamp = form_object.font_em_timestamp.data new_graph.decimal_places = form_object.decimal_places.data new_graph.input_ids_measurements = form_object.measurement_id.data # Output elif form_base.dashboard_type.data == 'output': dashboard_type = 'Output' error = output_error_check(form_object, error) new_graph.graph_type = 'output' new_graph.width = form_base.width.data new_graph.height = form_base.height.data new_graph.max_measure_age = form_object.max_measure_age.data new_graph.refresh_duration = form_base.refresh_duration.data new_graph.font_em_value = form_object.font_em_value.data new_graph.font_em_timestamp = form_object.font_em_timestamp.data new_graph.enable_output_controls = form_object.enable_output_controls.data new_graph.decimal_places = form_object.decimal_places.data new_graph.output_ids = form_object.output_id.data # PID Control elif form_base.dashboard_type.data == 'pid_control': dashboard_type = 'PID Control' error = pid_error_check(form_object, error) new_graph.graph_type = 'pid_control' new_graph.width = form_base.width.data new_graph.height = form_base.height.data new_graph.max_measure_age = form_object.max_measure_age.data new_graph.refresh_duration = form_base.refresh_duration.data new_graph.font_em_value = form_object.font_em_value.data new_graph.font_em_timestamp = form_object.font_em_timestamp.data new_graph.decimal_places = form_object.decimal_places.data new_graph.show_pid_info = form_object.show_pid_info.data new_graph.show_set_setpoint = form_object.show_set_setpoint.data new_graph.pid_ids = form_object.pid_id.data # Camera elif (form_base.dashboard_type.data == 'camera' and form_object.camera_id.data): dashboard_type = 'Camera' new_graph.graph_type = form_base.dashboard_type.data new_graph.width = form_base.width.data new_graph.height = form_base.height.data new_graph.refresh_duration = form_base.refresh_duration.data new_graph.camera_max_age = form_object.camera_max_age.data new_graph.camera_id = form_object.camera_id.data new_graph.camera_image_type = form_object.camera_image_type.data else: flash_form_errors(form_base) return try: if not error: new_graph.save() flash( gettext("{dev} with ID %(id)s successfully added".format( dev=dashboard_type), id=new_graph.id), "success") DisplayOrder.query.first().dashboard = add_display_order( display_order, new_graph.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) flash_success_errors(error, action, url_for('routes_page.page_dashboard'))
def dashboard_add(form_base, form_object, display_order): """ Add an item to the dashboard Either Graph, Gauge, or Camera """ action = '{action} {controller}'.format(action=gettext("Add"), controller=gettext("Dashboard")) error = [] new_graph = Dashboard() new_graph.name = form_base.name.data # Graph if (form_base.dashboard_type.data == 'graph' and (form_base.name.data and form_object.width.data and form_object.height.data and form_object.xaxis_duration.data and form_object.refresh_duration.data)): error = graph_error_check(form_object, error) new_graph.graph_type = form_base.dashboard_type.data if form_object.math_ids.data: math_ids_joined = ";".join(form_object.math_ids.data) new_graph.math_ids = math_ids_joined if form_object.pid_ids.data: pid_ids_joined = ";".join(form_object.pid_ids.data) new_graph.pid_ids = pid_ids_joined if form_object.relay_ids.data: relay_ids_joined = ";".join(form_object.relay_ids.data) new_graph.relay_ids = relay_ids_joined if form_object.sensor_ids.data: sensor_ids_joined = ";".join(form_object.sensor_ids.data) new_graph.sensor_ids_measurements = sensor_ids_joined new_graph.width = form_object.width.data new_graph.height = form_object.height.data new_graph.x_axis_duration = form_object.xaxis_duration.data new_graph.refresh_duration = form_object.refresh_duration.data new_graph.enable_auto_refresh = form_object.enable_auto_refresh.data new_graph.enable_xaxis_reset = form_object.enable_xaxis_reset.data new_graph.enable_title = form_object.enable_title.data new_graph.enable_navbar = form_object.enable_navbar.data new_graph.enable_rangeselect = form_object.enable_range.data new_graph.enable_export = form_object.enable_export.data new_graph.enable_graph_shift = form_object.enable_graph_shift.data new_graph.enable_manual_y_axis = form_object.enable_manual_y_axis.data try: if not error: new_graph.save() flash( gettext("Graph with ID %(id)s successfully added", id=new_graph.id), "success") DisplayOrder.query.first().graph = add_display_order( display_order, new_graph.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) # Gauge elif (form_base.dashboard_type.data == 'gauge' and form_object.sensor_ids.data): error = gauge_error_check(form_object, error) new_graph.graph_type = form_object.gauge_type.data if form_object.gauge_type.data == 'gauge_solid': new_graph.range_colors = '0.2,#33CCFF;0.4,#55BF3B;0.6,#DDDF0D;0.8,#DF5353' elif form_object.gauge_type.data == 'gauge_angular': new_graph.range_colors = '0,25,#33CCFF;25,50,#55BF3B;50,75,#DDDF0D;75,100,#DF5353' new_graph.width = form_object.width.data new_graph.height = form_object.height.data new_graph.max_measure_age = form_object.max_measure_age.data new_graph.refresh_duration = form_object.refresh_duration.data new_graph.y_axis_min = form_object.y_axis_min.data new_graph.y_axis_max = form_object.y_axis_max.data new_graph.sensor_ids_measurements = form_object.sensor_ids.data[0] new_graph.enable_timestamp = form_object.enable_timestamp.data try: if not error: new_graph.save() flash( gettext("Gauge with ID %(id)s successfully added", id=new_graph.id), "success") DisplayOrder.query.first().graph = add_display_order( display_order, new_graph.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) # Camera elif (form_base.dashboard_type.data == 'camera' and form_object.camera_id.data): new_graph.graph_type = form_base.dashboard_type.data new_graph.width = form_object.width.data new_graph.height = form_object.height.data new_graph.refresh_duration = form_object.refresh_duration.data new_graph.camera_max_age = form_object.camera_max_age.data new_graph.camera_id = form_object.camera_id.data new_graph.camera_image_type = form_object.camera_image_type.data try: if not error: new_graph.save() flash( gettext("Camera with ID %(id)s successfully added", id=new_graph.id), "success") DisplayOrder.query.first().graph = add_display_order( display_order, new_graph.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) else: flash_form_errors(form_base) return flash_success_errors(error, action, url_for('routes_page.page_dashboard'))
def function_add(form_add_func): action = '{action} {controller}'.format( action=TRANSLATIONS['add']['title'], controller=TRANSLATIONS['function']['title']) error = [] new_func = None try: if form_add_func.func_type.data.startswith('conditional_'): new_func = Conditional() new_func.conditional_statement = ''' # Replace "asdf1234" with a Condition ID, "qwer5678" with an Action ID. measurement = measure("{asdf1234}") message += "Measure: {meas}".format(meas=measurement) if measurement is not None: # If a measurement exists if measurement < 23: # If the measurement is less than 23 run_all_actions(message=message) # Run all actions else: # If the measurement is greater or equal to 23 run_action("{qwer5678}", message=message) # Run a single Action''' new_func.save() elif form_add_func.func_type.data.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 new_measurement.save() elif form_add_func.func_type.data.startswith('trigger_'): new_func = Trigger() for name_id, name, _ in FUNCTION_TYPES: if form_add_func.func_type.data == name_id: new_func.name = '{}'.format(name) new_func.trigger_type = form_add_func.func_type.data new_func.save() elif form_add_func.func_type.data.startswith('function_'): new_func = Function() if form_add_func.func_type.data == 'function_spacer': new_func.name = 'Spacer' new_func.function_type = form_add_func.func_type.data new_func.save() elif form_add_func.func_type.data == '': error.append("Must select a function type") else: error.append("Unknown function type: '{}'".format( form_add_func.func_type.data)) 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'))
def math_add(form_add_math): action = '{action} {controller}'.format( action=TRANSLATIONS['add']['title'], controller=TRANSLATIONS['math']['title']) error = [] dep_unmet, _ = return_dependencies(form_add_math.math_type.data) 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_math.math_type.data, dep=', '.join(list_unmet_deps))) if form_add_math.validate(): new_math = Math() new_math.name = str(MATH_INFO[form_add_math.math_type.data]['name']) new_math.math_type = form_add_math.math_type.data try: new_math.save() display_order = csv_to_list_of_str(DisplayOrder.query.first().math) DisplayOrder.query.first().math = add_display_order( display_order, new_math.unique_id) db.session.commit() if not MATH_INFO[form_add_math.math_type.data]['measure']: new_measurement = DeviceMeasurements() new_measurement.device_id = new_math.unique_id new_measurement.channel = 0 new_measurement.save() else: for each_channel, measure_info in MATH_INFO[ form_add_math.math_type.data]['measure'].items(): new_measurement = DeviceMeasurements() if 'name' in measure_info and measure_info['name']: new_measurement.name = measure_info['name'] new_measurement.device_id = new_math.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 Math with ID %(id)s (%(uuid)s) successfully added", type=form_add_math.math_type.data, id=new_math.id, uuid=new_math.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_math) if dep_unmet: return 1
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_infrared_remote_input', 'trigger_run_pwm_method', 'trigger_sunrise_sunset' ]: new_func = Trigger() new_func.name = '{}'.format(FUNCTION_INFO[function_name]['name']) new_func.trigger_type = function_name if not error: new_func.save() elif function_name in ['function_spacer', 'function_actions']: new_func = Function() if function_name == 'function_spacer': new_func.name = 'Spacer' new_func.function_type = function_name if not error: new_func.save() elif function_name in dict_controllers: # Custom Function Controller new_func = CustomController() new_func.device = function_name if 'function_name' in dict_controllers[function_name]: new_func.name = dict_controllers[function_name][ 'function_name'] else: new_func.name = 'Function Name' # TODO: Switch to JSON function list_options = [] if 'custom_options' in dict_controllers[function_name]: for each_option in dict_controllers[function_name][ 'custom_options']: if 'id' not in each_option: continue if each_option['default_value'] is False: default_value = '' else: default_value = each_option['default_value'] option = '{id},{value}'.format(id=each_option['id'], value=default_value) list_options.append(option) new_func.custom_options = ';'.join(list_options) if not error: new_func.save() elif function_name == '': error.append("Must select a function type") else: error.append("Unknown function type: '{}'".format(function_name)) if not error: display_order = csv_to_list_of_str( DisplayOrder.query.first().function) DisplayOrder.query.first().function = add_display_order( display_order, new_func.unique_id) db.session.commit() 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 method_create(form_create_method): """ Create new method table entry (all data stored in method_data table) """ action = '{action} {controller}'.format( action=TRANSLATIONS['add']['title'], controller=TRANSLATIONS['method']['title']) error = [] try: # Create method new_method = Method() new_method.name = form_create_method.name.data new_method.method_type = form_create_method.method_type.data db.session.add(new_method) db.session.commit() # Add new method line id to method display order method_order = DisplayOrder.query.first() display_order = csv_to_list_of_str(method_order.method) method_order.method = add_display_order(display_order, new_method.unique_id) db.session.commit() # Add new method data line id to method_data display order if new_method.method_type in ['DailyBezier', 'DailySine']: # For tables that require only one entry to configure, # create that single entry now with default values new_method_data = MethodData() new_method_data.method_id = new_method.unique_id if new_method.method_type == 'DailySine': new_method_data.amplitude = 1.0 new_method_data.frequency = 1.0 new_method_data.shift_angle = 0 new_method_data.shift_y = 1.0 elif new_method.method_type == 'DailyBezier': new_method_data = MethodData() new_method_data.method_id = new_method.unique_id new_method_data.shift_angle = 0.0 new_method_data.x0 = 20.0 new_method_data.y0 = 20.0 new_method_data.x1 = 10.0 new_method_data.y1 = 13.5 new_method_data.x2 = 22.5 new_method_data.y2 = 30.0 new_method_data.x3 = 0.0 new_method_data.y3 = 20.0 db.session.add(new_method_data) db.session.commit() display_order = csv_to_list_of_str(new_method.method_order) method = Method.query.filter( Method.unique_id == new_method.unique_id).first() method.method_order = add_display_order( display_order, new_method_data.unique_id) db.session.commit() return 0 except Exception as except_msg: error.append(except_msg) flash_success_errors(error, action, url_for('routes_method.method_list'))
def graph_add(form_add, display_order): action = u'{action} {controller}'.format(action=gettext(u"Add"), controller=gettext(u"Graph")) error = [] new_graph = Graph() if (form_add.graph_type.data == 'graph' and (form_add.name.data and form_add.width.data and form_add.height.data and form_add.xaxis_duration.data and form_add.refresh_duration.data)): new_graph.graph_type = form_add.graph_type.data new_graph.name = form_add.name.data if form_add.math_ids.data: math_ids_joined = ";".join(form_add.math_ids.data) new_graph.math_ids = math_ids_joined if form_add.pid_ids.data: pid_ids_joined = ";".join(form_add.pid_ids.data) new_graph.pid_ids = pid_ids_joined if form_add.relay_ids.data: relay_ids_joined = ";".join(form_add.relay_ids.data) new_graph.relay_ids = relay_ids_joined if form_add.sensor_ids.data: sensor_ids_joined = ";".join(form_add.sensor_ids.data) new_graph.sensor_ids_measurements = sensor_ids_joined new_graph.width = form_add.width.data new_graph.height = form_add.height.data new_graph.x_axis_duration = form_add.xaxis_duration.data new_graph.refresh_duration = form_add.refresh_duration.data new_graph.enable_auto_refresh = form_add.enable_auto_refresh.data new_graph.enable_xaxis_reset = form_add.enable_xaxis_reset.data new_graph.enable_title = form_add.enable_title.data new_graph.enable_navbar = form_add.enable_navbar.data new_graph.enable_rangeselect = form_add.enable_range.data new_graph.enable_export = form_add.enable_export.data try: new_graph.save() flash( gettext(u"Graph with ID %(id)s successfully added", id=new_graph.id), "success") DisplayOrder.query.first().graph = add_display_order( display_order, new_graph.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) elif (form_add.graph_type.data in ['gauge_angular', 'gauge_solid'] and form_add.sensor_ids.data): if form_add.graph_type.data == 'gauge_solid': new_graph.range_colors = '0.2,#33CCFF;0.4,#55BF3B;0.6,#DDDF0D;0.8,#DF5353' elif form_add.graph_type.data == 'gauge_angular': new_graph.range_colors = '0,25,#33CCFF;25,50,#55BF3B;50,75,#DDDF0D;75,100,#DF5353' new_graph.graph_type = form_add.graph_type.data new_graph.name = form_add.name.data new_graph.width = form_add.width.data new_graph.height = form_add.height.data new_graph.max_measure_age = form_add.max_measure_age.data new_graph.refresh_duration = form_add.refresh_duration.data new_graph.y_axis_min = form_add.y_axis_min.data new_graph.y_axis_max = form_add.y_axis_max.data new_graph.sensor_ids_measurements = form_add.sensor_ids.data[0] try: new_graph.save() flash( gettext(u"Graph with ID %(id)s successfully added", id=new_graph.id), "success") DisplayOrder.query.first().graph = add_display_order( display_order, new_graph.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) else: flash_form_errors(form_add) return flash_success_errors(error, action, url_for('page_routes.page_graph'))
def output_add(form_add): action = '{action} {controller}'.format( action=TRANSLATIONS['add']['title'], controller=TRANSLATIONS['output']['title']) error = [] 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, dep=', '.join(list_unmet_deps))) if len(form_add.output_type.data.split(',')) < 2: error.append("Must select an Output type") 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 not error: for _ in range(0, form_add.output_quantity.data): try: output_type = form_add.output_type.data.split(',')[0] interface = form_add.output_type.data.split(',')[1] new_output = Output() new_output.name = str(OUTPUT_INFO[output_type]['name']) new_output.output_type = output_type new_output.interface = interface if output_type in ['wired', 'wireless_rpi_rf', 'command', 'python']: new_output.measurement = 'duration_time' new_output.unit = 's' elif output_type in ['command_pwm', 'pwm', 'python_pwm']: new_output.measurement = 'duty_cycle' new_output.unit = 'percent' elif output_type == 'atlas_ezo_pmp': new_output.measurement = 'volume' new_output.unit = 'ml' new_output.channel = 0 if output_type == 'wired': new_output.on_at_start = False elif output_type == 'wireless_rpi_rf': new_output.pin = None new_output.protocol = 1 new_output.pulse_length = 189 new_output.on_command = '22559' new_output.off_command = '22558' elif output_type == 'command': new_output.on_command = '/home/pi/script_on.sh' new_output.off_command = '/home/pi/script_off.sh' elif output_type == 'command_pwm': new_output.pwm_command = '/home/pi/script_pwm.sh ((duty_cycle))' elif output_type == 'pwm': new_output.pwm_hertz = 22000 new_output.pwm_library = 'pigpio_any' elif output_type == 'python': new_output.on_command = """ timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") write_string = "{ts}: ID: {id}: ON\\n".format(id=output_id, ts=timestamp) with open("/home/pi/Mycodo/OutputTest.txt", "a") as myfile: myfile.write(write_string)""" new_output.off_command = """ timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") write_string = "{ts}: ID: {id}: OFF\\n".format(id=output_id, ts=timestamp) with open("/home/pi/Mycodo/OutputTest.txt", "a") as myfile: myfile.write(write_string)""" elif output_type == 'python_pwm': new_output.pwm_command = """ timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") write_string = "{ts}: ID: {id}: Duty Cycle: ((duty_cycle)) %\\n".format( id=output_id, ts=timestamp) with open("/home/pi/Mycodo/OutputTest.txt", "a") as myfile: myfile.write(write_string)""" elif output_type == 'atlas_ezo_pmp': new_output.flow_rate = 10 if interface == 'I2C': new_output.location = '0x67' new_output.i2c_bus = 1 elif interface == 'UART': new_output.location = '/dev/ttyAMA0' new_output.baud_rate = 9600 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() manipulate_output('Add', new_output.unique_id) 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_output')) if dep_unmet: return 1
def method_create(form_create_method): """Create new method table entry (all data stored in method_data table)""" action = '{action} {controller}'.format( action=TRANSLATIONS['add']['title'], controller=TRANSLATIONS['method']['title']) error = [] dep_unmet, _, _ = return_dependencies(form_create_method.method_type.data) if dep_unmet: list_unmet_deps = [] for each_dep in dep_unmet: list_unmet_deps.append(each_dep[3]) error.append( "The {dev} device you're trying to add has unmet dependencies: " "{dep}".format(dev=form_create_method.method_type.data, dep=', '.join(list_unmet_deps))) try: # Create method new_method = Method() new_method.name = form_create_method.name.data new_method.method_type = form_create_method.method_type.data if not error: db.session.add(new_method) db.session.commit() # Add new method line id to method display order method_order = DisplayOrder.query.first() display_order = csv_to_list_of_str(method_order.method) method_order.method = add_display_order(display_order, new_method.unique_id) db.session.commit() # Add new method data line id to method_data display order if new_method.method_type in ['DailyBezier', 'DailySine']: # For tables that require only one entry to configure, # create that single entry now with default values new_method_data = MethodData() new_method_data.method_id = new_method.unique_id if new_method.method_type == 'DailySine': new_method_data.amplitude = 1.0 new_method_data.frequency = 1.0 new_method_data.shift_angle = 0 new_method_data.shift_y = 1.0 elif new_method.method_type == 'DailyBezier': new_method_data = MethodData() new_method_data.method_id = new_method.unique_id new_method_data.shift_angle = 0.0 new_method_data.x0 = 20.0 new_method_data.y0 = 20.0 new_method_data.x1 = 10.0 new_method_data.y1 = 13.5 new_method_data.x2 = 22.5 new_method_data.y2 = 30.0 new_method_data.x3 = 0.0 new_method_data.y3 = 20.0 if not error: db.session.add(new_method_data) db.session.commit() display_order = csv_to_list_of_str(new_method.method_order) method = Method.query.filter( Method.unique_id == new_method.unique_id).first() method.method_order = add_display_order( display_order, new_method_data.unique_id) db.session.commit() except Exception as except_msg: error.append(except_msg) flash_success_errors(error, action, url_for('routes_method.method_list')) if dep_unmet: return 1
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 method_add(form_add_method): """ Add line to method_data table """ action = '{action} {controller}'.format(action=gettext("Add"), controller=gettext("Method")) error = [] method = Method.query.filter( Method.unique_id == form_add_method.method_id.data).first() display_order = csv_to_list_of_str(method.method_order) try: if validate_method_data(form_add_method, method): return 1 if method.method_type == 'DailySine': add_method_data = MethodData.query.filter( MethodData.method_id == form_add_method.method_id.data).first() add_method_data.amplitude = form_add_method.amplitude.data add_method_data.frequency = form_add_method.frequency.data add_method_data.shift_angle = form_add_method.shift_angle.data add_method_data.shift_y = form_add_method.shiftY.data db.session.commit() return 0 elif method.method_type == 'DailyBezier': if not 0 <= form_add_method.shift_angle.data <= 360: flash( gettext("Error: Angle Shift is out of range. It must be " "<= 0 and <= 360."), "error") return 1 if form_add_method.x0.data <= form_add_method.x3.data: flash(gettext("Error: X0 must be greater than X3."), "error") return 1 add_method_data = MethodData.query.filter( MethodData.method_id == form_add_method.method_id.data).first() add_method_data.shift_angle = form_add_method.shift_angle.data add_method_data.x0 = form_add_method.x0.data add_method_data.y0 = form_add_method.y0.data add_method_data.x1 = form_add_method.x1.data add_method_data.y1 = form_add_method.y1.data add_method_data.x2 = form_add_method.x2.data add_method_data.y2 = form_add_method.y2.data add_method_data.x3 = form_add_method.x3.data add_method_data.y3 = form_add_method.y3.data db.session.commit() return 0 if form_add_method.method_select.data == 'setpoint': if method.method_type == 'Date': start_time = datetime.strptime(form_add_method.time_start.data, '%Y-%m-%d %H:%M:%S') end_time = datetime.strptime(form_add_method.time_end.data, '%Y-%m-%d %H:%M:%S') elif method.method_type == 'Daily': start_time = datetime.strptime( form_add_method.daily_time_start.data, '%H:%M:%S') end_time = datetime.strptime( form_add_method.daily_time_end.data, '%H:%M:%S') if method.method_type in ['Date', 'Daily']: # Check if the start time comes after the last entry's end time display_order = csv_to_list_of_str(method.method_order) if display_order: last_method = MethodData.query.filter( MethodData.unique_id == display_order[-1]).first() else: last_method = None if last_method is not None: if method.method_type == 'Date': last_method_end_time = datetime.strptime( last_method.time_end, '%Y-%m-%d %H:%M:%S') elif method.method_type == 'Daily': last_method_end_time = datetime.strptime( last_method.time_end, '%H:%M:%S') if start_time < last_method_end_time: flash( gettext( "The new entry start time (%(st)s) " "cannot overlap the last entry's end " "time (%(et)s). Note: They may be the " "same time.", st=last_method_end_time, et=start_time), "error") return 1 elif form_add_method.method_select.data == 'output': if method.method_type == 'Date': start_time = datetime.strptime( form_add_method.output_time.data, '%Y-%m-%d %H:%M:%S') elif method.method_type == 'Daily': start_time = datetime.strptime( form_add_method.output_daily_time.data, '%H:%M:%S') add_method_data = MethodData() add_method_data.method_id = form_add_method.method_id.data if method.method_type == 'Date': if form_add_method.method_select.data == 'setpoint': add_method_data.time_start = start_time.strftime( '%Y-%m-%d %H:%M:%S') add_method_data.time_end = end_time.strftime( '%Y-%m-%d %H:%M:%S') if form_add_method.method_select.data == 'output': add_method_data.time_start = form_add_method.output_time.data elif method.method_type == 'Daily': if form_add_method.method_select.data == 'setpoint': add_method_data.time_start = start_time.strftime('%H:%M:%S') add_method_data.time_end = end_time.strftime('%H:%M:%S') if form_add_method.method_select.data == 'output': add_method_data.time_start = form_add_method.output_daily_time.data elif method.method_type == 'Duration': if form_add_method.restart.data: add_method_data.duration_sec = 0 add_method_data.duration_end = form_add_method.duration_end.data else: add_method_data.duration_sec = form_add_method.duration.data if form_add_method.method_select.data == 'setpoint': add_method_data.setpoint_start = form_add_method.setpoint_start.data add_method_data.setpoint_end = form_add_method.setpoint_end.data elif form_add_method.method_select.data == 'output': add_method_data.output_id = form_add_method.output_id.data add_method_data.output_state = form_add_method.output_state.data add_method_data.output_duration = form_add_method.output_duration.data db.session.add(add_method_data) db.session.commit() # Add line to method data list if not a output duration if form_add_method.method_select.data != 'output': method.method_order = add_display_order(display_order, add_method_data.unique_id) db.session.commit() if form_add_method.method_select.data == 'setpoint': if method.method_type == 'Date': flash( gettext( "Added duration to method from %(st)s to " "%(end)s", st=start_time, end=end_time), "success") elif method.method_type == 'Daily': flash( gettext( "Added duration to method from %(st)s to " "%(end)s", st=start_time.strftime('%H:%M:%S'), end=end_time.strftime('%H:%M:%S')), "success") elif method.method_type == 'Duration': if form_add_method.restart.data: flash(gettext("Added method restart"), "success") else: flash( gettext("Added duration to method for %(sec)s seconds", sec=form_add_method.duration.data), "success") elif form_add_method.method_select.data == 'output': if method.method_type == 'Date': flash( gettext( "Added output modulation to method at start " "time: %(tm)s", tm=start_time), "success") elif method.method_type == 'Daily': flash( gettext( "Added output modulation to method at start " "time: %(tm)s", tm=start_time.strftime('%H:%M:%S')), "success") elif method.method_type == 'Duration': flash( gettext( "Added output modulation to method at start " "time: %(tm)s", tm=form_add_method.duration.data), "success") except Exception as except_msg: logger.exception(1) error.append(except_msg) flash_success_errors(error, action, url_for('routes_method.method_list'))
def dashboard_add(form_base, form_object, display_order): """ Add an item to the dashboard Either Graph, Gauge, or Camera """ action = '{action} {controller}'.format( action=TRANSLATIONS['add']['title'], controller=TRANSLATIONS['dashboard']['title']) error = [] new_graph = Dashboard() new_graph.name = form_base.name.data # Graph if (form_base.dashboard_type.data == 'graph' and (form_base.name.data and form_base.width.data and form_base.height.data and form_object.xaxis_duration.data and form_base.refresh_duration.data)): dashboard_type = 'Graph' error = graph_error_check(form_object, error) new_graph.graph_type = form_base.dashboard_type.data if form_object.math_ids.data: new_graph.math_ids = ";".join(form_object.math_ids.data) if form_object.pid_ids.data: new_graph.pid_ids = ";".join(form_object.pid_ids.data) if form_object.output_ids.data: new_graph.output_ids = ";".join(form_object.output_ids.data) if form_object.input_ids.data: new_graph.input_ids_measurements = ";".join(form_object.input_ids.data) if form_object.note_tag_ids.data: new_graph.note_tag_ids = ";".join(form_object.note_tag_ids.data) new_graph.width = form_base.width.data new_graph.height = form_base.height.data new_graph.x_axis_duration = form_object.xaxis_duration.data new_graph.refresh_duration = form_base.refresh_duration.data new_graph.enable_auto_refresh = form_object.enable_auto_refresh.data new_graph.enable_xaxis_reset = form_object.enable_xaxis_reset.data new_graph.enable_title = form_object.enable_title.data new_graph.enable_navbar = form_object.enable_navbar.data new_graph.enable_rangeselect = form_object.enable_range.data new_graph.enable_export = form_object.enable_export.data new_graph.enable_graph_shift = form_object.enable_graph_shift.data new_graph.enable_manual_y_axis = form_object.enable_manual_y_axis.data # Gauge elif form_base.dashboard_type.data == 'gauge': dashboard_type = 'Gauge' error = gauge_error_check(form_object, error) new_graph.graph_type = form_object.gauge_type.data if form_object.gauge_type.data == 'gauge_solid': new_graph.range_colors = '20,#33CCFF;40,#55BF3B;60,#DDDF0D;80,#DF5353' elif form_object.gauge_type.data == 'gauge_angular': new_graph.range_colors = '0,25,#33CCFF;25,50,#55BF3B;50,75,#DDDF0D;75,100,#DF5353' new_graph.width = form_base.width.data new_graph.height = form_base.height.data new_graph.max_measure_age = form_object.max_measure_age.data new_graph.refresh_duration = form_base.refresh_duration.data new_graph.y_axis_min = form_object.y_axis_min.data new_graph.y_axis_max = form_object.y_axis_max.data new_graph.input_ids_measurements = form_object.input_ids.data new_graph.enable_timestamp = form_object.enable_timestamp.data # Indicator elif form_base.dashboard_type.data == 'indicator': dashboard_type = 'Indicator' error = measurement_error_check(form_object, error) new_graph.graph_type = 'indicator' new_graph.width = form_base.width.data new_graph.height = form_base.height.data new_graph.max_measure_age = form_object.max_measure_age.data new_graph.refresh_duration = form_base.refresh_duration.data new_graph.font_em_timestamp = form_object.font_em_timestamp.data new_graph.input_ids_measurements = form_object.measurement_id.data # Measurement elif form_base.dashboard_type.data == 'measurement': dashboard_type = 'Measurement' error = measurement_error_check(form_object, error) new_graph.graph_type = 'measurement' new_graph.width = form_base.width.data new_graph.height = form_base.height.data new_graph.max_measure_age = form_object.max_measure_age.data new_graph.refresh_duration = form_base.refresh_duration.data new_graph.font_em_value = form_object.font_em_value.data new_graph.font_em_timestamp = form_object.font_em_timestamp.data new_graph.decimal_places = form_object.decimal_places.data new_graph.input_ids_measurements = form_object.measurement_id.data # Output elif form_base.dashboard_type.data == 'output': dashboard_type = 'Output' error = output_error_check(form_object, error) new_graph.graph_type = 'output' new_graph.width = form_base.width.data new_graph.height = form_base.height.data new_graph.max_measure_age = form_object.max_measure_age.data new_graph.refresh_duration = form_base.refresh_duration.data new_graph.font_em_value = form_object.font_em_value.data new_graph.font_em_timestamp = form_object.font_em_timestamp.data new_graph.enable_output_controls = form_object.enable_output_controls.data new_graph.decimal_places = form_object.decimal_places.data new_graph.output_ids = form_object.output_id.data # PID Control elif form_base.dashboard_type.data == 'pid_control': dashboard_type = 'PID Control' error = pid_error_check(form_object, error) new_graph.graph_type = 'pid_control' new_graph.width = form_base.width.data new_graph.height = form_base.height.data new_graph.max_measure_age = form_object.max_measure_age.data new_graph.refresh_duration = form_base.refresh_duration.data new_graph.font_em_value = form_object.font_em_value.data new_graph.font_em_timestamp = form_object.font_em_timestamp.data new_graph.decimal_places = form_object.decimal_places.data new_graph.show_pid_info = form_object.show_pid_info.data new_graph.show_set_setpoint = form_object.show_set_setpoint.data new_graph.pid_ids = form_object.pid_id.data # Camera elif (form_base.dashboard_type.data == 'camera' and form_object.camera_id.data): dashboard_type = 'Camera' new_graph.graph_type = form_base.dashboard_type.data new_graph.width = form_base.width.data new_graph.height = form_base.height.data new_graph.refresh_duration = form_base.refresh_duration.data new_graph.camera_max_age = form_object.camera_max_age.data new_graph.camera_id = form_object.camera_id.data new_graph.camera_image_type = form_object.camera_image_type.data else: flash_form_errors(form_base) return try: if not error: new_graph.save() flash(gettext( "{dev} with ID %(id)s successfully added".format(dev=dashboard_type), id=new_graph.id), "success") DisplayOrder.query.first().dashboard = add_display_order( display_order, new_graph.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) flash_success_errors(error, action, url_for('routes_page.page_dashboard'))
def output_add(form_add): action = '{action} {controller}'.format( action=TRANSLATIONS['add']['title'], controller=TRANSLATIONS['output']['title']) error = [] 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, dep=', '.join(list_unmet_deps))) if len(form_add.output_type.data.split(',')) < 2: error.append("Must select an Output type") 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 not error: for _ in range(0, form_add.output_quantity.data): try: output_type = form_add.output_type.data.split(',')[0] interface = form_add.output_type.data.split(',')[1] new_output = Output() new_output.name = str(OUTPUT_INFO[output_type]['name']) new_output.output_type = output_type new_output.interface = interface if output_type in [ 'wired', 'wireless_rpi_rf', 'command', 'python' ]: new_output.measurement = 'duration_time' new_output.unit = 's' elif output_type in OUTPUTS_PWM: new_output.measurement = 'duty_cycle' new_output.unit = 'percent' new_output.channel = 0 if output_type == 'wired': new_output.state_startup = '0' new_output.state_shutdown = '0' elif output_type == 'wireless_rpi_rf': new_output.pin = None new_output.protocol = 1 new_output.pulse_length = 189 new_output.on_command = '22559' new_output.off_command = '22558' elif output_type == 'command': new_output.on_command = '/home/pi/script_on.sh' new_output.off_command = '/home/pi/script_off.sh' elif output_type == 'command_pwm': new_output.pwm_command = '/home/pi/script_pwm.sh ((duty_cycle))' elif output_type == 'pwm': new_output.pwm_hertz = 22000 new_output.pwm_library = 'pigpio_any' elif output_type == 'python': new_output.on_command = """ timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") write_string = "{ts}: ID: {id}: ON\\n".format(id=output_id, ts=timestamp) with open("/home/pi/Mycodo/OutputTest.txt", "a") as myfile: myfile.write(write_string)""" new_output.off_command = """ timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") write_string = "{ts}: ID: {id}: OFF\\n".format(id=output_id, ts=timestamp) with open("/home/pi/Mycodo/OutputTest.txt", "a") as myfile: myfile.write(write_string)""" elif output_type == 'python_pwm': new_output.pwm_command = """ timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") write_string = "{ts}: ID: {id}: Duty Cycle: ((duty_cycle)) %\\n".format( id=output_id, ts=timestamp) with open("/home/pi/Mycodo/OutputTest.txt", "a") as myfile: myfile.write(write_string)""" elif output_type == 'atlas_ezo_pmp': new_output.output_mode = 'fastest_flow_rate' new_output.flow_rate = 10 if interface == 'FTDI': new_output.location = '/dev/ttyUSB0' elif interface == 'I2C': new_output.location = '0x67' new_output.i2c_bus = 1 elif interface == 'UART': new_output.location = '/dev/ttyAMA0' new_output.baud_rate = 9600 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() # Add device measurements for measurement, measure_data in OUTPUT_INFO[ new_output.output_type]['measure'].items(): for unit, unit_data in measure_data.items(): for channel, _ in unit_data.items(): new_measurement = DeviceMeasurements() new_measurement.device_id = new_output.unique_id new_measurement.name = '' new_measurement.is_enabled = True new_measurement.measurement = measurement new_measurement.unit = unit new_measurement.channel = channel new_measurement.save() manipulate_output('Add', new_output.unique_id) 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_output')) if dep_unmet: return 1
def math_add(form_add_math): action = '{action} {controller}'.format(action=gettext("Add"), controller=gettext("Math")) error = [] dep_unmet, _ = return_dependencies(form_add_math.math_type.data) 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_math.math_type.data, dep=', '.join(list_unmet_deps))) if form_add_math.validate(): new_math = Math() new_math.name = '' new_math.math_type = form_add_math.math_type.data if form_add_math.math_type.data in MATH_INFO: new_math.name += '{name}'.format( name=MATH_INFO[form_add_math.math_type.data]['name']) new_math.measure = ",".join( MATH_INFO[form_add_math.math_type.data]['measure']) # Set the default measurement values list_units = [] for each_measurement in MATH_INFO[ form_add_math.math_type.data]['measure']: if each_measurement in MEASUREMENTS: entry = '{measure},{unit}'.format( measure=each_measurement, unit=MEASUREMENTS[each_measurement]['units'][0]) list_units.append(entry) new_math.measure_units = ";".join(list_units) try: new_math.save() display_order = csv_to_list_of_str(DisplayOrder.query.first().math) DisplayOrder.query.first().math = add_display_order( display_order, new_math.unique_id) db.session.commit() flash( gettext( "%(type)s Math with ID %(id)s (%(uuid)s) successfully added", type=form_add_math.math_type.data, id=new_math.id, uuid=new_math.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_math) if dep_unmet: return 1