def parameter_update(self): ret_dict = {} if self.request.POST['sensor'] == 'None': self.request.POST['sensor'] = None controls = self.request.POST.items() param_id = self.request.matchdict['param_id'] param = DBSession.query(Parameter).filter_by(_id=param_id).one() form = Form(EditParameterSchema().bind(parameter=param), formid='edit_parameter_form_' + param_id, action=self.request.route_url('parameter_update', param_id=param_id), use_ajax=True, ajax_options='{"success": function (rText, sText, xhr, form) { edit_parameter(rText);}}', buttons=('Save',)) try: vals = form.validate(controls) ret_dict['error'] = False except ValidationFailure as e: ret_dict['error'] = True ret_dict['parameter'] = param.serialize ret_dict['form'] = e.render() return ret_dict if vals['sensor'] is not None: param.sensor = DBSession.query(Sensor).filter_by(_id=vals['sensor']).one() else: param.sensor = None ret_dict['form'] = form.render(parameter=param) ret_dict['parameter'] = param.serialize if param.sensor is not None: ret_dict['sensor_name'] = param.sensor.periphery_controller.name + '-->' + param.sensor.name else: ret_dict['sensor_name'] = 'not connected' self.request.redis.publish('parameter_changes', 'changed ' + str(param.id)) return ret_dict
def calendar_param_entry_save(self): """ save new calendar entry """ ret_dict = {} controls = self.request.POST.items() param = DBSession.query(Parameter).filter_by(_id=self.request.matchdict['param_id']).one() last_entry = DBSession.query(CalendarEntry).filter_by(parameter_id=param.id).order_by( desc(CalendarEntry.entry_number)).first() add_form = Form(CalendarEntrySchema().bind(), formid='add_param_calender_entry', action=self.request.route_url('calendar_param_entry_save', param_id=param.id), use_ajax=True, ajax_options='{"success": function(rt, st, xhr, form) { add_calendar_param_entry(rt);}}', buttons=('Save',)) try: vals = add_form.validate(controls) ret_dict['error'] = False except ValidationFailure as e: ret_dict['error'] = True ret_dict['form'] = e.render() return ret_dict inter = DBSession.query(SetpointInterpolation).filter_by(_id=vals['interpolation']).one() index = 1 if last_entry is not None: index = last_entry.entry_number + 1 new_entry = CalendarEntry(param, index, inter) DBSession.add(new_entry) DBSession.flush() ret_dict['form'] = add_form.render() ret_dict['entry_panel'] = self.request.layout_manager.render_panel('calendar_param_entry', context=new_entry) self.request.redis.publish('calendar_changes', 'param ' + str(param.id)) return ret_dict
def device_link_save(self): ret_dict = {} controls = self.request.POST.items() dis_id = self.request.matchdict['dis_id'] form = Form( DeviceLinkSchema().bind(), formid='add_device_link_form_' + dis_id, action=self.request.route_url('device_link_save', dis_id=dis_id), use_ajax=True, ajax_options= '{"success": function (rt, st, xhr, form) { add_device_link(rt);}}', buttons=('Save', )) try: vals = form.validate(controls) ret_dict['error'] = False except ValidationFailure as e: ret_dict['error'] = True ret_dict['form'] = e.render() return ret_dict display = DBSession.query(Display).filter_by(_id=dis_id).one() device = DBSession.query(Device).filter_by(_id=vals['device']).one() new_device_link = DeviceLink(display, device, vals['target'], vals['color']) DBSession.add(new_device_link) DBSession.flush() ret_dict['form'] = form.render() ret_dict[ 'device_link_panel'] = self.request.layout_manager.render_panel( 'device_link_panel', context=new_device_link) ret_dict['device_link'] = new_device_link.serialize return ret_dict
def device_link_save(self): ret_dict = {} controls = self.request.POST.items() dis_id = self.request.matchdict['dis_id'] form = Form(DeviceLinkSchema().bind(), formid='add_device_link_form_' + dis_id, action=self.request.route_url('device_link_save', dis_id=dis_id), use_ajax=True, ajax_options='{"success": function (rt, st, xhr, form) { add_device_link(rt);}}', buttons=('Save',)) try: vals = form.validate(controls) ret_dict['error'] = False except ValidationFailure as e: ret_dict['error'] = True ret_dict['form'] = e.render() return ret_dict display = DBSession.query(Display).filter_by(_id=dis_id).one() device = DBSession.query(Device).filter_by(_id=vals['device']).one() new_device_link = DeviceLink(display, device, vals['target'], vals['color']) DBSession.add(new_device_link) DBSession.flush() ret_dict['form'] = form.render() ret_dict['device_link_panel'] = self.request.layout_manager.render_panel('device_link_panel', context=new_device_link) ret_dict['device_link'] = new_device_link.serialize return ret_dict
def device_update(self): ret_dict = {} if self.request.POST['actuator'] == 'None': self.request.POST['actuator'] = None controls = self.request.POST.items() dev_id = self.request.matchdict['dev_id'] dev = DBSession.query(Device).filter_by(_id=dev_id).one() form = Form(EditDeviceSchema().bind(device=dev), formid='edit_device_form_' + dev_id, action=self.request.route_url('device_update', dev_id=dev_id), use_ajax=True, ajax_options='{"success": function (rText, sText, xhr, form) {edit_device(rText);}}', buttons=('Save',)) try: vals = form.validate(controls) ret_dict['error'] = False except ValidationFailure as e: ret_dict['error'] = True ret_dict['device'] = dev.serialize ret_dict['form'] = e.render() return ret_dict if vals['actuator'] is not None: dev.actuator = DBSession.query(Actuator).filter_by(_id=vals['actuator']).one() else: dev.actuator = None ret_dict['form'] = form.render(device=dev) ret_dict['device'] = dev.serialize if dev.actuator is not None: ret_dict['actuator_name'] = dev.actuator.periphery_controller.name + '-->' + dev.actuator.name self.request.redis.publish('device_changes', 'changed '+str(dev.id)) return ret_dict
def interpolation_knot_save(self): controls = self.request.POST param = DBSession.query(Parameter).filter_by(_id=self.request.matchdict['parameter_id']).first() inter = DBSession.query(SetpointInterpolation).filter_by(_id=self.request.matchdict['inter_id']).first() add_form = Form(InterpolationKnotSchema().bind()) try: p = add_form.validate(controls.items()) new_inter = InterpolationKnot(inter, p['time'], p['value']) DBSession.add(new_inter) except ValidationFailure as e: return {'error_form': e.render()} filename = self.request.registry.settings['plot_directory'] + '/interpolation_' + str(inter.id) + '.png' inter.plot('', filename) return HTTPFound(location=self.request.route_url('calendar_home', parameter_id=param.id))
def log_diagram_update(self): ret_dict = {} ld_id = self.request.matchdict['ld_id'] ret_dict['log_diagram_id'] = ld_id controls = self.request.POST.items() ld = DBSession.query(LogDiagram).filter_by(_id=ld_id).one() form = Form( LogDiagramSchema().bind(log_diagram=ld), formid='edit_log_diagram_' + ld_id, action=self.request.route_url('log_diagram_update', ld_id=ld_id), use_ajax=True, ajax_options= '{"success": function (rText, sText, xhr, form) {edit_log_diagram(rText);}}', buttons=('Save', )) try: vals = form.validate(controls) ret_dict['form'] = form.render() ret_dict['error'] = False except ValidationFailure as e: ret_dict['form'] = e.render() ret_dict['error'] = True return ret_dict ld.name = vals['name'] ld.description = vals['description'] ld.period = vals['period'] ret_dict['log_diagram'] = ld.serialize return ret_dict
def display_views_home(self): layout = self.request.layout_manager.layout layout.add_javascript( self.request.static_url('farmgui:static/js/jquery.flot.js')) layout.add_javascript( self.request.static_url('farmgui:static/js/jquery.flot.time.js')) layout.add_javascript( self.request.static_url('deform:static/scripts/deform.js')) layout.add_javascript( self.request.static_url('deform:static/scripts/jquery.form.js')) layout.add_javascript( self.request.static_url('farmgui:static/js/display_functions.js')) layout.add_css( self.request.static_url('farmgui:static/css/plot_parameter.css')) add_log_diagram_form = Form( LogDiagramSchema().bind(), action=self.request.route_url('log_diagram_save'), formid='add_log_diagram_form', use_ajax=True, ajax_options='{"success": function (rText, sText, xhr, form) {' 'add_log_diagram(rText);}}', buttons=('Save', )) log_diagrams = DBSession.query(LogDiagram).all() return { 'log_diagrams': log_diagrams, 'add_log_diagram_form': add_log_diagram_form.render() }
def device_link_update(self): ret_dict = {} dl_id = self.request.matchdict['dl_id'] ret_dict['device_link_id'] = dl_id controls = self.request.POST.items() dl = DBSession.query(DeviceLink).filter_by(_id=dl_id).one() form = Form( DeviceLinkSchema().bind(device_link=dl), formid='edit_device_link_' + dl_id, action=self.request.route_url('device_link_update', dl_id=dl_id), use_ajax=True, ajax_options= '{"success": function (rText, sText, xhr, form) {edit_device_link(rText);}}', buttons=('Save', )) try: vals = form.validate(controls) ret_dict['form'] = form.render() ret_dict['error'] = False except ValidationFailure as e: ret_dict['form'] = e.render() ret_dict['error'] = True return ret_dict dl.device_id = vals['device'] dl.target = vals['target'] dl.color = vals['color'] ret_dict['device_link'] = dl.serialize ret_dict['device_link_name'] = dl.device.name + '-->' + dl.target return ret_dict
def component_input_update(self): ret_dict = {} if self.request.POST['connected_output'] == 'None': self.request.POST['connected_output'] = None controls = self.request.POST.items() comp_in_id = self.request.matchdict['comp_in_id'] comp_in = DBSession.query(ComponentInput).filter_by(_id=comp_in_id).one() form = Form(ComponentInputSchema().bind(), formid='edit_component_input_form_' + comp_in_id, action=self.request.route_url('component_input_update', comp_in_id=comp_in_id), use_ajax=True, ajax_options='{"success": function (rText, sText, xhr, form) { edit_component_input(rText);}}', buttons=('Save',)) try: vals = form.validate(controls) ret_dict['error'] = False except ValidationFailure as e: ret_dict['error'] = True ret_dict['component_input'] = comp_in.serialize ret_dict['form'] = e.render() return ret_dict comp_in.connected_output_id = vals['connected_output'] ret_dict['form'] = form.render(component_input=comp_in) ret_dict['component_input'] = comp_in.serialize connected_output_name = 'not connected' if comp_in.connected_output is not None: connected_output_name = comp_in.connected_output.component.name + ': ' + comp_in.connected_output.name ret_dict['connected_output_name'] = connected_output_name self.request.redis.publish('component_input_changes', str(comp_in_id)) return ret_dict
def parameter_save(self): """ save new parameter """ ret_dict = {} controls = self.request.POST.items() form = Form(NewParameterSchema().bind(), formid='add_parameter_form', action=self.request.route_url('parameter_save'), use_ajax=True, ajax_options='{"success": function (rText, sText, xhr, form) { add_parameter(rText);}}', buttons=('Save',)) try: vals = form.validate(controls) ret_dict['error'] = False except ValidationFailure as e: ret_dict['error'] = True ret_dict['form'] = e.render() return ret_dict parameter_type = DBSession.query(ParameterType).filter_by(_id=vals['parameter_type']).one() new_parameter = Parameter(vals['name'], parameter_type, None, vals['description']) DBSession.add(new_parameter) DBSession.flush() ret_dict['form'] = form.render() ret_dict['parameter_panel'] = self.request.layout_manager.render_panel('parameter_panel', context=new_parameter) self.request.redis.publish('parameter_changes', 'added '+str(new_parameter.id)) return ret_dict
def component_update(self): ret_dict = {} controls = self.request.POST.items() comp_id = self.request.matchdict['comp_id'] comp = DBSession.query(Component).filter_by(_id=comp_id).one() form = Form(ComponentSchema().bind(), formid='edit_component_form_' + comp_id, action=self.request.route_url('component_update', comp_id=comp_id), use_ajax=True, ajax_options='{"success": function (rText, sText, xhr, form) { edit_component(rText);}}', buttons=('Save',)) try: vals = form.validate(controls) ret_dict['error'] = False except ValidationFailure as e: ret_dict['error'] = True ret_dict['component'] = comp.serialize ret_dict['form'] = e.render() return ret_dict comp.name = vals['name'] comp.description = vals['description'] ret_dict['form'] = form.render(component=comp) ret_dict['component'] = comp.serialize self.request.redis.publish('component_changes', 'changed '+str(comp_id)) return ret_dict
def device_link_update(self): ret_dict = {} dl_id = self.request.matchdict['dl_id'] ret_dict['device_link_id'] = dl_id controls = self.request.POST.items() dl = DBSession.query(DeviceLink).filter_by(_id=dl_id).one() form = Form(DeviceLinkSchema().bind(device_link=dl), formid='edit_device_link_' + dl_id, action=self.request.route_url('device_link_update', dl_id=dl_id), use_ajax=True, ajax_options='{"success": function (rText, sText, xhr, form) {edit_device_link(rText);}}', buttons=('Save',)) try: vals = form.validate(controls) ret_dict['form'] = form.render() ret_dict['error'] = False except ValidationFailure as e: ret_dict['form'] = e.render() ret_dict['error'] = True return ret_dict dl.device_id = vals['device'] dl.target = vals['target'] dl.color = vals['color'] ret_dict['device_link'] = dl.serialize ret_dict['device_link_name'] = dl.device.name + '-->' + dl.target return ret_dict
def regulator_update(self): ret_dict = {} controls = self.request.POST.items() reg_id = self.request.matchdict['reg_id'] reg = DBSession.query(Regulator).filter_by(_id=reg_id).one() form = Form(EditRegulatorSchema().bind(regulator=reg), formid='edit_regulator_form_' + reg_id, action=self.request.route_url('regulator_update', reg_id=reg_id), use_ajax=True, ajax_options='{"success": function (rText, sText, xhr, form) {edit_regulator(rText);}}', buttons=('Save',)) try: vals = form.validate(controls) ret_dict['error'] = False except ValidationFailure as e: ret_dict['error'] = True ret_dict['regulator'] = reg.serialize ret_dict['form'] = e.render() return ret_dict reg.algorithm_name = vals['algorithm'] real_reg = regulator_factory(reg.algorithm_name) real_reg.initialize_db(reg) DBSession.flush() ret_dict['form'] = form.render(regulator=reg) ret_dict['regulator'] = reg.serialize ret_dict['regulator_panel'] = self.request.layout_manager.render_panel('regulator_panel', context=reg) self.request.redis.publish('regulator_changes', 'changed '+str(reg.id)) return ret_dict
def periphery_controller_delete(self): pc_id = self.request.matchdict['pc_id'] pc = DBSession.query(PeripheryController).filter_by(_id=pc_id).one() DBSession.delete(pc) self.request.redis.publish('periphery_controller_changes', 'deleted ' + str(pc_id)) return {'delete': True}
def periphery_controller_update(self): ret_dict = {} controls = self.request.POST.items() pc = DBSession.query(PeripheryController).filter_by( _id=self.request.matchdict['pc_id']).one() form = Form( PeripheryControllerSchema().bind(), formid='edit_periphery_controller_form_' + str(pc.id), action=self.request.route_url('periphery_controller_update', pc_id=pc.id), use_ajax=True, ajax_options= '{"success": function (rText, sText, xhr, form) { edit_periphery_controller(rText);}}', buttons=('Save', )) try: vals = form.validate(controls) ret_dict['error'] = False except ValidationFailure as e: ret_dict['error'] = True ret_dict['periphery_controller'] = pc.serialize ret_dict['form'] = e.render() return ret_dict pc.name = vals['name'] ret_dict['form'] = form.render(periphery_controller=pc) ret_dict['periphery_controller'] = pc.serialize self.request.redis.publish('periphery_controller_changes', 'changed ' + str(pc.id)) return ret_dict
def component_delete(self): comp_id = self.request.matchdict['comp_id'] component = DBSession.query(Component).filter_by(_id=comp_id).one() channel = component.component_type + '_changes' self.request.redis.publish(channel, 'removed '+str(comp_id)) DBSession.delete(component) return {'delete': True}
def log_diagram_update(self): ret_dict = {} ld_id = self.request.matchdict['ld_id'] ret_dict['log_diagram_id'] = ld_id controls = self.request.POST.items() ld = DBSession.query(LogDiagram).filter_by(_id=ld_id).one() form = Form(LogDiagramSchema().bind(log_diagram=ld), formid='edit_log_diagram_' + ld_id, action=self.request.route_url('log_diagram_update', ld_id=ld_id), use_ajax=True, ajax_options='{"success": function (rText, sText, xhr, form) {edit_log_diagram(rText);}}', buttons=('Save',)) try: vals = form.validate(controls) ret_dict['form'] = form.render() ret_dict['error'] = False except ValidationFailure as e: ret_dict['form'] = e.render() ret_dict['error'] = True return ret_dict ld.name = vals['name'] ld.description = vals['description'] ld.period = vals['period'] ret_dict['log_diagram'] = ld.serialize return ret_dict
def deferred_actuator_widget(node, kw): query = DBSession.query(Actuator) if 'device' in kw: query = query.filter_by(device_type_id=kw['device'].device_type_id) actuators = query.all() choices = [(None, '--select--')] for a in actuators: choices.append((a.id, a.periphery_controller.name + '->' + a.name)) return SelectWidget(values=choices)
def deferred_connected_output_widget(node, kw): query = DBSession.query(ComponentOutput) if 'device' in kw: query = query.filter_by(device_type_id=kw['device'].device_type_id) outputs = query.all() choices = [(None, '--select--')] for outp in outputs: choices.append((outp.id, outp.component.name + '->' + outp.name)) return SelectWidget(values=choices)
def deferred_sensor_widget(node, kw): query = DBSession.query(Sensor) if 'parameter' in kw: query = query.filter_by(parameter_type_id=kw['parameter'].parameter_type_id) sensors = query.all() choices = [(None, '--select--')] for s in sensors: choices.append((s.id, s.periphery_controller.name + '->' + s.name)) return SelectWidget(values=choices)
def periphery_controllers_list(self): layout = self.request.layout_manager.layout layout.add_javascript(self.request.static_url('farmgui:static/js/hardware_functions.js')) layout.add_javascript(self.request.static_url('deform:static/scripts/deform.js')) layout.add_javascript(self.request.static_url('deform:static/scripts/jquery.form.js')) try: periphery_controllers = DBSession.query(PeripheryController).all() except DBAPIError: return Response('database error (query PeripheryControllers)', content_type='text/plain', status_int=500) return {'periphery_controllers': periphery_controllers}
def interpolation_knot_update(self): ret_dict = {} try: knot = DBSession.query(InterpolationKnot).filter_by(_id=self.request.matchdict['knot_id']).first() inter = DBSession.query(SetpointInterpolation).filter_by( _id=self.request.matchdict['inter_id']).first() except DBAPIError: return Response('database error (query InterpolationKnot)', content_type='text/plain', status_int=500) form = Form(InterpolationKnotSchema().bind(knot=knot), buttons=('Save',)) controls = self.request.POST controls['interpolation_id'] = inter.id try: values = form.validate(controls.items()) except ValidationFailure as e: return {'error_form': e.render()} knot.time = values['time'] knot.value = values['value'] filename = self.request.registry.settings['plot_directory'] + '/interpolation_' + str(inter.id) + '.png' inter.plot('', filename) self.request.redis.publish('parameter_changes', 'interpolation changed') ret_dict['form'] = form.render() ret_dict['knot_panel'] = self.request.layout_manager.render_panel('interpolation_knot_panel', context=knot) return ret_dict
def calendar_dev_home(self): layout = self.request.layout_manager.layout layout.add_javascript(self.request.static_url('deform:static/scripts/deform.js')) layout.add_javascript(self.request.static_url('deform:static/scripts/jquery.form.js')) layout.add_javascript(self.request.static_url('farmgui:static/js/jquery.flot.js')) layout.add_javascript(self.request.static_url('farmgui:static/js/jquery.flot.time.js')) dev = DBSession.query(Device).filter_by(_id=self.request.matchdict['dev_id']).one() interpolations = DBSession.query(SetpointInterpolation).all() calendar_schema = CalendarEntrySchema().bind() add_calendar_form = Form(calendar_schema, action=self.request.route_url('calendar_dev_entry_save', dev_id=dev.id), formid='add_calendar_entry_form', buttons=('Save',)) interpolation_schema = SetpointInterpolationSchema().bind() add_interpolation_form = Form(interpolation_schema, action=self.request.route_url('interpolation_save'), formid='add_interpolation_form', buttons=('Save',)) return {"page_title": dev.name + " Calendar", 'calendar': dev.calendar, 'interpolations': interpolations, 'add_calendar_entry_form': add_calendar_form.render(), 'add_interpolation_form': add_interpolation_form.render()}
def setting_views_home(self): """ display a list of all field settings """ layout = self.request.layout_manager.layout layout.add_javascript(self.request.static_url('farmgui:static/js/setting_functions.js')) layout.add_javascript(self.request.static_url('deform:static/scripts/deform.js')) layout.add_javascript(self.request.static_url('deform:static/scripts/jquery.form.js')) try: field_settings = DBSession.query(FieldSetting).all() except DBAPIError: return Response('database error (query FieldSettings)', content_type='text/plain', status_int=500) return {'field_settings': field_settings}
def component_views_home(self): layout = self.request.layout_manager.layout # layout.add_css(self.request.static_url('deform_bootstrap:static/deform_bootstrap.css')) layout.add_javascript(self.request.static_url('farmgui:static/js/component_functions.js')) layout.add_javascript(self.request.static_url('deform:static/scripts/deform.js')) layout.add_javascript(self.request.static_url('deform:static/scripts/jquery.form.js')) add_parameter_form = Form(NewParameterSchema().bind(), action=self.request.route_url('parameter_save'), formid='add_parameter_form', use_ajax=True, ajax_options='{"success": function (rText, sText, xhr, form) {' 'add_parameter(rText);}}', buttons=('Save',)) add_device_form = Form(NewDeviceSchema().bind(), action=self.request.route_url('device_save'), formid='add_device_form', use_ajax=True, ajax_options='{"success": function (rText, sText, xhr, form) {' 'add_device(rText);}}', buttons=('Save',)) add_regulator_form = Form(NewRegulatorSchema().bind(), action=self.request.route_url('regulator_save'), formid='add_regulator_form', use_ajax=True, ajax_options='{"success": function (rText, sText, xhr, form) {' 'add_regulator(rText);}}', buttons=('Save',)) parameters = DBSession.query(Parameter).all() devices = DBSession.query(Device).all() regulators = DBSession.query(Regulator).all() return {'parameters': parameters, 'devices': devices, 'regulators': regulators, 'add_parameter_form': add_parameter_form.render(), 'add_device_form': add_device_form.render(), 'add_regulator_form': add_regulator_form.render()}
def periphery_controllers_list(self): layout = self.request.layout_manager.layout layout.add_javascript( self.request.static_url('farmgui:static/js/hardware_functions.js')) layout.add_javascript( self.request.static_url('deform:static/scripts/deform.js')) layout.add_javascript( self.request.static_url('deform:static/scripts/jquery.form.js')) try: periphery_controllers = DBSession.query(PeripheryController).all() except DBAPIError: return Response('database error (query PeripheryControllers)', content_type='text/plain', status_int=500) return {'periphery_controllers': periphery_controllers}
def display_views_home(self): layout = self.request.layout_manager.layout layout.add_javascript(self.request.static_url('farmgui:static/js/jquery.flot.js')) layout.add_javascript(self.request.static_url('farmgui:static/js/jquery.flot.time.js')) layout.add_javascript(self.request.static_url('deform:static/scripts/deform.js')) layout.add_javascript(self.request.static_url('deform:static/scripts/jquery.form.js')) layout.add_javascript(self.request.static_url('farmgui:static/js/display_functions.js')) layout.add_css(self.request.static_url('farmgui:static/css/plot_parameter.css')) add_log_diagram_form = Form(LogDiagramSchema().bind(), action=self.request.route_url('log_diagram_save'), formid='add_log_diagram_form', use_ajax=True, ajax_options='{"success": function (rText, sText, xhr, form) {' 'add_log_diagram(rText);}}', buttons=('Save',)) log_diagrams = DBSession.query(LogDiagram).all() return {'log_diagrams': log_diagrams, 'add_log_diagram_form': add_log_diagram_form.render()}
def interpolation_update(self): try: spip = DBSession.query(SetpointInterpolation).filter_by( _id=self.request.matchdict['inter_id']).first() except DBAPIError: return Response('database error (query SetpointInterpolation)', content_type='text/plain', status_int=500) form = Form(SetpointInterpolationSchema().bind(interpolation=spip), buttons=('Save',)) controls = self.request.POST controls['name'] = spip.name try: values = form.validate(controls.items()) except ValidationFailure as e: return {'error_form': e.render()} spip.name = values['name'] spip.order = values['order'] spip.start_value = values['start_value'] spip.end_time = values['end_time'] spip.end_value = values['end_value'] spip.description = values['description'] filename = self.request.registry.settings['plot_directory'] + '/interpolation_' + str(spip.id) + '.png' spip.plot('', filename) self.request.redis.publish('calendar_changes', 'interpolation changed') return {'updated': True}
def setting_views_update(self): ret_dict = {} controls = self.request.POST.items() fs = DBSession.query(FieldSetting).filter_by(name=self.request.matchdict['name']).one() form = Form(FieldSettingSchema().bind(), formid='edit_field_setting_form_' + fs.name, action=self.request.route_url('field_setting_update', name=fs.name), use_ajax=True, ajax_options='{"success": function (rText, sText, xhr, form) { edit_field_setting(rText);}}', buttons=('Save',)) try: vals = form.validate(controls) ret_dict['error'] = False except ValidationFailure as e: ret_dict['error'] = True ret_dict['field_setting'] = fs.serialize ret_dict['form'] = e.render() return ret_dict fs.value = vals['value'] ret_dict['form'] = form.render(field_setting=fs) ret_dict['field_setting'] = fs.serialize self.request.redis.publish('field_setting_changes', fs.name) return ret_dict
def periphery_controller_update(self): ret_dict = {} controls = self.request.POST.items() pc = DBSession.query(PeripheryController).filter_by(_id=self.request.matchdict['pc_id']).one() form = Form(PeripheryControllerSchema().bind(), formid='edit_periphery_controller_form_' + str(pc.id), action=self.request.route_url('periphery_controller_update', pc_id=pc.id), use_ajax=True, ajax_options='{"success": function (rText, sText, xhr, form) { edit_periphery_controller(rText);}}', buttons=('Save',)) try: vals = form.validate(controls) ret_dict['error'] = False except ValidationFailure as e: ret_dict['error'] = True ret_dict['periphery_controller'] = pc.serialize ret_dict['form'] = e.render() return ret_dict pc.name = vals['name'] ret_dict['form'] = form.render(periphery_controller=pc) ret_dict['periphery_controller'] = pc.serialize self.request.redis.publish('periphery_controller_changes', 'changed '+str(pc.id)) return ret_dict
def component_property_update(self): ret_dict = {} prop_id = self.request.matchdict['comp_prop_id'] ret_dict['component_property_id'] = prop_id controls = self.request.POST.items() prop = DBSession.query(ComponentProperty).filter_by(_id=prop_id).one() form = Form(ComponentPropertySchema().bind(), formid='edit_component_property_' + prop_id, action=self.request.route_url('component_property_update', comp_prop_id=prop_id), use_ajax=True, ajax_options='{"success": function (rText, sText, xhr, form) {edit_component_property(rText);}}', buttons=('Save',)) try: vals = form.validate(controls) ret_dict['form'] = form.render() ret_dict['error'] = False except ValidationFailure as e: ret_dict['form'] = e.render() ret_dict['error'] = True return ret_dict prop.value = vals['value'] ret_dict['component_property'] = prop.serialize self.request.redis.publish('component_property_changes', str(prop.id)) return ret_dict
def regulator_delete(self): regulator = DBSession.query(Regulator).filter_by(_id=self.request.matchdict['reg_id']).first() DBSession.delete(regulator) return {'delete': True}
def device_delete(self): device = DBSession.query(Device).filter_by(_id=self.request.matchdict['dev_id']).one() dev_id = device.id DBSession.delete(device) self.request.redis.publish('device_changes', 'removed '+str(dev_id)) return {'delete': True}
def device_link_delete(self): device_link = DBSession.query(DeviceLink).filter_by(_id=self.request.matchdict['dl_id']).one() DBSession.delete(device_link) return {'delete': True}
def log_diagram_data(self): period = 0 p_sp_ids = [] p_va_ids = [] d_sp_ids = [] d_va_ids = [] for i in self.request.POST.items(): if i[0] == 'parameter_links': p_id, target = i[1].split(' ') if target == 'value': p_va_ids.append(int(p_id)) elif target == 'setpoint': p_sp_ids.append(int(p_id)) else: print('error detecting parameter link target') elif i[0] == 'plot_period': period = int(i[1]) elif i[0] == 'device_links': d_id, target = i[1].split(' ') if target == 'value': d_va_ids.append(int(d_id)) elif target == 'setpoint': d_sp_ids.append(int(d_id)) else: print('error detecting device link target') now = datetime.now() start_time = now - timedelta(seconds=period) # utc_offset = time.altzone * 1000 #now_millis = int(mktime(now.timetuple())) * 1000 - utc_offset now_millis = int(mktime(now.timetuple())) start_time_millis = now_millis - period * 1000 data = [] for pid in p_va_ids: param = DBSession.query(Parameter).filter_by(_id=pid).one() logs = DBSession.query(ParameterValueLog).filter_by(parameter_id=pid).filter( ParameterValueLog.time >= start_time).order_by(asc(ParameterValueLog.time)).all() series_data = [] for log in logs: #millis = int(mktime(log.time.timetuple()) * 1000) - utc_offset millis = int(mktime(log.time.timetuple()) * 1000) series_data.append([millis, log.value]) #print('series length: '+str(len(series))) data.append({'data': series_data, 'label': param.name + '-->value'}) for pid in p_sp_ids: param = DBSession.query(Parameter).filter_by(_id=pid).one() logs_query = DBSession.query(ParameterSetpointLog).filter_by(parameter_id=pid).filter( ParameterSetpointLog.time >= start_time).order_by(asc(ParameterSetpointLog.time)) logs = logs_query.all() series_data = [] for log in logs: #millis = int(mktime(log.time.timetuple()) * 1000) - utc_offset millis = int(mktime(log.time.timetuple()) * 1000) series_data.append([millis, log.setpoint]) data.append({'data': series_data, 'label': param.name + '-->setpoint'}) for did in d_va_ids: dev = DBSession.query(Device).filter_by(_id=did).one() logs = DBSession.query(DeviceValueLog).filter_by(device_id=did).filter( DeviceValueLog.time >= start_time).order_by(asc(DeviceValueLog.time)).all() series_data = [] for log in logs: #millis = int(mktime(log.time.timetuple()) * 1000) - utc_offset millis = int(mktime(log.time.timetuple()) * 1000) series_data.append([millis, log.value]) #print('series length: '+str(len(series))) data.append({'data': series_data, 'label': dev.name + '-->value'}) for did in d_sp_ids: dev = DBSession.query(Device).filter_by(_id=did).one() logs_query = DBSession.query(DeviceSetpointLog).filter_by(device_id=did).filter( DeviceSetpointLog.time >= start_time).order_by(asc(DeviceSetpointLog.time)) logs = logs_query.all() series_data = [] for log in logs: #millis = int(mktime(log.time.timetuple()) * 1000) - utc_offset millis = int(mktime(log.time.timetuple()) * 1000) series_data.append([millis, log.setpoint]) data.append({'data': series_data, 'label': dev.name + '-->setpoint'}) return {'xmin': start_time_millis, 'xmax': now_millis, 'data': data }
def parameter_delete(self): parameter = DBSession.query(Parameter).filter_by(_id=self.request.matchdict['param_id']).one() self.request.redis.publish('parameter_changes', 'removed ' + str(parameter.id)) DBSession.delete(parameter) return {'delete': True}
def deferred_parameter_widget(node, kw): parameters = DBSession.query(Parameter).all() choices = [(None, '--select--')] for s in parameters: choices.append((s.id, s.name)) return SelectWidget(values=choices)
def deferred_device_widget(node, kw): devices = DBSession.query(Device).all() choices = [(None, '--select--')] for d in devices: choices.append((d.id, d.name)) return SelectWidget(values=choices)