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 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 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 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 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 interpolation_save(self):
"""
save new setpoint interpolation
"""
ret_dict = {}
controls = self.request.POST.items()
add_form = Form(SetpointInterpolationSchema().bind(),
formid='add_interpolation_form',
action=self.request.route_url('interpolation_save'),
use_ajax=True,
ajax_options='{"success": function(rText, sText, xhr, form) { add_interpolation(rText);}}',
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
new_inter = SetpointInterpolation(vals['name'], vals['order'], vals['start_value'], vals['end_time'],
vals['end_value'], vals['description'])
DBSession.add(new_inter)
DBSession.flush()
ret_dict['form'] = add_form.render()
ret_dict['interpolation_panel'] = self.request.layout_manager.render_panel('interpolation_panel',
context=new_inter)
filename = self.request.registry.settings['plot_directory'] + '/interpolation_' + str(new_inter.id) + '.png'
new_inter.plot('', filename)
self.request.redis.publish('calendar_changes', 'interpolation saved')
return ret_dict
def regulator_save(self):
ret_dict = {}
controls = self.request.POST.items()
form = Form(NewRegulatorSchema().bind(),
formid='add_regulator_form',
action=self.request.route_url('regulator_save'),
use_ajax=True,
ajax_options='{"success": function (rText, sText, xhr, form) {add_regulator(rText);}}',
buttons=('Save',))
try:
vals = form.validate(controls)
ret_dict['error'] = False
except ValidationFailure as e:
ret_dict['form'] = e.render()
ret_dict['error'] = True
return ret_dict
new_reg = Regulator(vals['name'], vals['algorithm'], vals['description'])
real_reg = regulator_factory(new_reg.algorithm_name)
real_reg.initialize_db(new_reg)
DBSession.add(new_reg)
DBSession.flush()
ret_dict['form'] = form.render()
ret_dict['regulator_panel'] = self.request.layout_manager.render_panel('regulator_panel', context=new_reg)
self.request.redis.publish('regulator_changes', 'added '+str(new_reg.id))
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 log_diagram_save(self):
ret_dict = {}
controls = self.request.POST.items()
form = Form(
LogDiagramSchema().bind(),
formid='add_log_diagram_form',
action=self.request.route_url('log_diagram_save'),
use_ajax=True,
ajax_options=
'{"success": function (rText, sText, xhr, form) { add_log_diagram(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
new_log_diagram = LogDiagram(vals['name'], vals['description'],
vals['period'])
DBSession.add(new_log_diagram)
DBSession.flush()
ret_dict['form'] = form.render()
ret_dict[
'log_diagram_panel'] = self.request.layout_manager.render_panel(
'log_diagram_panel', context=new_log_diagram)
return ret_dict
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
settings = get_appsettings(config_uri)
engine = engine_from_config(settings, 'sqlalchemy.', echo=False)
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
# populate databases
with transaction.manager:
print('\ninit_setpoint_interpolations:\n')
init_setpoint_interpolations(DBSession)
print('\ninit_parameter_types:\n')
init_parameter_types(DBSession)
print('\ninit_device_types:\n')
init_device_types(DBSession)
print('\ninit_periphery_controllers:\n')
DBSession.flush()
init_periphery_controllers(DBSession)
DBSession.flush()
print('\ninit_parameters:\n')
init_parameters(DBSession)
print('\ninit_devices:\n')
init_devices(DBSession)
print('\ninit_field_settings:\n')
init_field_settings(DBSession)
print('\ninit_regulators:\n')
DBSession.flush()
init_regulators(DBSession)
init_log_diagrams(DBSession)
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 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 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 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 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 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 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 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 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_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_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 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 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 log_diagram_save(self):
ret_dict = {}
controls = self.request.POST.items()
form = Form(LogDiagramSchema().bind(),
formid='add_log_diagram_form',
action=self.request.route_url('log_diagram_save'),
use_ajax=True,
ajax_options='{"success": function (rText, sText, xhr, form) { add_log_diagram(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
new_log_diagram = LogDiagram(vals['name'], vals['description'], vals['period'])
DBSession.add(new_log_diagram)
DBSession.flush()
ret_dict['form'] = form.render()
ret_dict['log_diagram_panel'] = self.request.layout_manager.render_panel('log_diagram_panel',
context=new_log_diagram)
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 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 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 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 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 regulator_delete(self):
regulator = DBSession.query(Regulator).filter_by(_id=self.request.matchdict['reg_id']).first()
DBSession.delete(regulator)
return {'delete': True}
