def verify_is_admin(self):
try:
user = sqlsession.query(User).filter_by(userid=self.userid,password=self.password).one()
return sqlsession.query(UserRoleMapping).filter_by(userid=self.userid,roleid=Role.ADMIN.id).count()>0
except:
print "No such user"
return False
def copy_to(self, displayname):
sqlsession.commit()
name=self.dao.name
user=self.dao.user
self.dao=None
self.dao=TelemetryWindowModel(user = user, name=name, displayname=displayname).dao
sqlsession.commit()
def set_display(self, display):
self._model.set_parent(display.get_name())
sqlsession.commit()
for row in self.tiles:
for tile in row:
if tile!=None:
tile.tile.set_display(display)
tile.properties.set_display(display)
def copy_to(self, displayname):
sqlsession.commit()
for model in self.filtermodels:
model.copy_to(displayname)
newview=MonitorView(name=self.dao.name, user=self.dao.user, parentname=self.dao.parent,displayname=displayname, format=self.format, index=self.index)
self.dao=None
self.dao=newview.dao
sqlsession.commit()
def delete(self):
for model in self.filtermodels:
model.delete()
self.filtermodels=[]
self.filteredattrs=[]
sqlsession.delete(self.dao)
sqlsession.commit()
del self.dao
def set_value( self, value ):
self.dao.set_value(str(value))
try:
sqlsession.add(self.dao)
except:
pass
sqlsession.commit()
print "SET VALUE OF " +self.dao.parent +" TO " + self.dao.name + " TO " + self.dao.value
def __init__(self,id,name):
self.id = id
self.name = name
try:
if (sqlsession.query(Role).filter_by(id=self.id).count() == 0):
sqlsession.add(self)
except:
sqlsession.add(self)
def __init__(self, user, name, parentname, displayname, type):
self.type = type
self.user = user
self.display=displayname
self.parent=parentname
self.name=name
sqlsession.add(self)
sqlsession.commit()
def __init__(self, user,role):
self.userid=user.userid
try:
self.id=sqlsession.query(UserRoleMapping).filter_by(userid=user.userid, roleid=role.id).first().id
except:
self.roleid=role.id
UserRoleMapping.id = UserRoleMapping.id+1
self.id = UserRoleMapping.id
sqlsession.add(self)
def __init__(self,name,password):
self.password=password
self.userid = name
try:
self.lastname=sqlsession.query(User).filter_by(userid=self.userid).one().lastname
self.firstname=sqlsession.query(User).filter_by(userid=self.userid).one().firstname
except:
self.lastname=self.userid
self.firstname=''
def append(self, monitorview):
if not(isinstance(monitorview, MonitorView)):
raise Exception("Type mismatch")
for index in range(len(self.monitors)):
mon=self.monitors[index]
if mon.monitor().get_name()==monitorview.monitor().get_name():
self.monitors[index]=monitorview
return
self.monitors.append(monitorview)
sqlsession.commit()
def copy_to(self, displayname):
sqlsession.commit()
name=self.dao.name
type = self.dao.type
parentname=self.dao.parent
for mon in self.monitors:
mon.copy_to(displayname=displayname)
user=self.dao.user
self.dao=None
self.dao=TileModel(name=name, user=user, type=type,parentname=parentname, displayname=displayname).dao
sqlsession.commit()
def render_html(self,for_editing=False, format=None):
sqlsession.flush()
c.name = self.get_name()
c.tiles = self.tiles
if format==None:
c.format = calypso.Session.session.get_display().format
else:
c.format=format
if for_editing:
return render('/tlm/develop/Visualization.html')
else:
return render ('/tlm/telemetrydisplay.html')
def __init__(self, name, user, ownername, displayname, value, type):
self.name=name
self.user=user
self.parent=ownername
self.display=displayname
self.type=type
if value==None:
self.value='0'
else:
self.value=value
sqlsession.add(self)
sqlsession.commit()
def place_monitor(self, monitor, index):
if (monitor in self.monitors):
del self.monitors[index]
self.monitors.insert(index,monitor)
else:
if index > len(self.monitors):
#add to end
self.monitors.append(monitor)
else:
#insert new monitor
self.monitors.insert(index,monitor)
print self.monitors
sqlsession.commit()
def __init__(self, user, name, parentname, displayname, type):
daos = sqlsession.query(TileModel.DAO).filter_by(user=user, display=displayname, parent=parentname, name=name).all()
if len(daos)>0:
self.dao=daos[0]
self.dao.type=type
else:
self.dao = TileModel.DAO(name=name, user=user, parentname=parentname, displayname=displayname, type=type)
monitors=sqlsession.query(MonitorView.DAO).filter_by \
(display=displayname, parent=name).order_by(MonitorView.DAO.index).all()
self.monitors=[]
for mon in monitors:
try:
self.monitors.append(MonitorView(name=mon.name, user=user, parentname=self.get_name(), displayname=displayname))
except:
del mon
def __init__(self, user, name, displayname):
daos= sqlsession.query(TelemetryWindowModel.DAO).filter_by(user=user,display=displayname, name=name).all()
if len(daos)>0:
self.dao = daos[0]
else:
self.dao = TelemetryWindowModel.DAO(user=user,name=name, displayname=displayname)
index=0
def set_filtered(self, filteredattrs):
self.filteredattrs=filteredattrs
if filteredattrs==None:
self.filtermodels=[]
return
try:
for filter in self.filtermodels:
if not(filter.dao.name in filteredattrs):
filter.delete()
except:
pass
self.filtermodels=[]
for attrname in filteredattrs:
self.filtermodels.append(MonitorFilter(user=self.dao.user, name=attrname, parentname=self.get_name(),
tilename=self.dao.parent, displayname=self.dao.display))
sqlsession.commit()
def get_properties(user, parent, display):
daos= sqlsession.query(DisplayPropertyItem.DAO).filter_by( user=user, display=display.get_name(), parent=parent.get_name()).all()
params={}
for dao in daos:
tag=dao.name
if tag != "name":
params[tag]=dao.value
return DisplayProperties(name=parent, user=user, parent=parent, display=display, **params)
def delete(self):
sqlsession.flush()
sqlsession.delete(self.dao)
sqlsession.flush()
for monitor in self.monitors:
monitor.delete()
del self.monitors
sqlsession.commit()
del self.dao
self.monitors=[]
def __init__(self, user, name, parentname, tilename, displayname):
if not(isinstance(parentname,basestring)):
raise Exception("Type Mismatch")
daos=sqlsession.query(MonitorFilter.DAO).filter_by \
(user=user, display=displayname, parent=parentname, tile=tilename, name=name).all()
if len(daos)>0:
self.dao = daos[0]
else:
self.dao=MonitorFilter.DAO(name=name,user=user, displayname=displayname, tilename=tilename, parentname=parentname)
def __init__(self, user, name, format):
daos = sqlsession.query(DisplayModel.DAO).filter_by(user=user, name=name).all()
if len(daos) > 0:
self.dao = daos[0]
else:
if format == None:
self.dao = DisplayModel.DAO(name=name, format=Format.DEFAULT_FORMAT.get_name(), user=user)
else:
self.dao = DisplayModel.DAO(name=name, format=format, user=user)
def __call__(self):
"""
Treat this class like a function to be called with no parameters
It will return the value of the property item it holds
"""
try:
sqlsession.add(self.dao)
except:
pass
try:
if self.name=='x_pos' or self.name=='y_pos' or \
self.name=='col_span' or self.name=='row_span':
return int(self.dao.value)
else:
return self.dao.value
except:
import traceback
traceback.print_exception(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
return ''
def __init__(self, name, user, owner, displayname, value, type):
self.name=name
self.owner=owner
daos= sqlsession.query(DisplayPropertyItem.DAO).filter_by(name=name, user=user, display=displayname, parent=owner.get_name()).all()
if len(daos)>0:
self.dao =daos[0]
self.dao.type=type
else:
if (name=='col_span' or name=='row_span') and value==None:
value=1
elif value==None:
value=0
self.dao=DisplayPropertyItem.DAO(name=name, user=user, ownername=owner.get_name(), displayname=displayname, value=value, type=type)
def __init__(self,name):
"""
Load a format from the database given a name for the format
"""
if (name.startswith('<')):
raise Exception("invalid type")
self.name=name
self.monitors=sqlsession.query(Monitor).filter_by(format=name).all()
self.monitortable={}
for monitor in self.monitors:
self.monitortable[monitor.name]=monitor
Format.everything[monitor.name]=monitor
Format.formats[name]=self
def get_name(self):
try:
return self.dao.name
except:
sqlsession.commit()
sqlsession.add(self.dao)
sqlsession.commit()
return self.dao.name
def __init__(self, name, user, parentname, displayname,format=None):
if not(isinstance(parentname,basestring)):
raise Exception("Type Mismatch")
daos=sqlsession.query(MonitorView.DAO).filter_by \
(user=user, display=displayname, parent=parentname, name=name).all()
if len(daos)>0:
self.dao = sqlsession.query(MonitorView.DAO).filter_by \
(user=user, display=displayname, parent=parentname, name=name).one()
else:
self.dao=MonitorView.DAO(name=name, user=user, displayname=displayname, parentname=parentname)
self._monitor=Monitor(name,format)
self.format=format
filtermodels=sqlsession.query(MonitorFilter.DAO).filter_by \
(user=user, display=displayname, parent=name, tile=parentname).all()
self.filtermodels=[]
for filter in filtermodels:
self.filtermodels.append(MonitorFilter(user=user, name=filter.name, parentname=filter.parent,
tilename=filter.tile, displayname=filter.display))
self.filteredattrs=None
if len(self.filtermodels)>0:
self.filteredattrs=[]
for attr in self.filtermodels:
self.filteredattrs.append(attr.get_name())
def render_html(self, properties, for_editing=False):
sqlsession.flush()
sqlsession.commit()
c.formatview= self.get_name().replace(' ','_')
c.properties=properties
c.monitors=self.monitors()
c.flatattrs={}
c.x_pos=properties.x_pos()
c.y_pos=properties.y_pos()
for mon in c.monitors:
for attr in mon.attrs():
if not(c.flatattrs.has_key(attr[0])):
c.flatattrs[attr[0]]=attr
c.content_type = 'html'
c.name = self.display.format.name
c.tile = self
c.display_ops=for_editing
try:
return render('/tlm/develop/Visualization-tile_view.html');
except:
import traceback
traceback.print_exception(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
return "<b><i>ERROR rendering tile</i></b>"
def __init__(self, user, name, parentname,displayname,index=None):
self.display=displayname
self.parent=parentname
self.name=name
self.user=user
self.index=index
sqlsession.commit()
sqlsession.add(self)
sqlsession.commit()
def delete(self):
"""
Remove from database
"""
if self.dao != None:
sqlsession.flush()
sqlsession.delete(self.dao)
sqlsession.commit()
del self.dao
