class AlarmAttribute(db.Model):
"""AlarmAttribute class, used in :py:class:`emonitor.modules.alarms.alarm.Alarm`"""
__tablename__ = 'alarmattributes'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32))
value = db.Column(db.Text)
alarm_id = db.Column(db.Integer, db.ForeignKey('alarms.id'))
def __repr__(self):
return self.name
def __init__(self, name, value):
self.name = name
self.value = value
class Housenumber(db.Model):
"""Housenumber class"""
__tablename__ = 'housenumbers'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
streetid = db.Column(db.Integer, db.ForeignKey('streets.id'))
number = db.Column(db.String(10))
_points = db.Column('points', db.Text)
street = db.relationship("Street", backref="streets", lazy='joined')
def __init__(self, streetid, number, points):
self.streetid = streetid
self.number = number
self._points = points
@property
def points(self):
"""
Get points for housenumber
:return: yaml structure with point positions
"""
return yaml.load(self._points)
@staticmethod
def getHousenumbers(id=0):
"""
Get list of all housenumbers, filtered by paramters
:param optional id: id of housenumber, *0* for all
:return: list of :py:class:`emonitor.modules.streets.housenumber.Housenumber`
"""
if id == 0:
return Housenumber.query.order_by(Housenumber.number).all()
else:
return Housenumber.query.filter_by(id=id).one()
def getPosition(self, index=0):
try:
p = self.points[index]
return dict(lat=p[0], lng=p[1])
except:
return dict(lat=self.street.lat, lng=self.street.lng)
class AlarmHistory(db.Model):
"""AlarmHistory class user in :py:class:`emonitor.modules.alarms.alarm.Alarm`"""
__tablename__ = 'alarmhistory'
__table_args__ = {'extend_existing': True}
historytypes = ['autochangeState', 'message']
id = db.Column(db.Integer, primary_key=True)
timestamp = db.Column(db.DATETIME, default=datetime.datetime.now())
name = db.Column(db.String(32))
value = db.Column(db.Text)
alarm_id = db.Column(db.Integer, db.ForeignKey('alarms.id'))
def __repr__(self):
return self.name
def __init__(self, name, value, dtime):
self.name = name
self.value = value
self.timestamp = dtime
class Person(db.Model):
"""Person class"""
__tablename__ = 'persons'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
firstname = db.Column(db.String(64))
lastname = db.Column(db.String(64))
salutation = db.Column(db.String(16))
grade = db.Column(db.String(32))
position = db.Column(db.String(32))
identifier = db.Column(db.String(32))
active = db.Column(db.BOOLEAN)
birthdate = db.Column(db.DATETIME)
remark = db.Column(db.TEXT)
_dept = db.Column('dept', db.ForeignKey('departments.id'))
_options = db.Column('options', db.TEXT)
dept = db.relationship("Department",
collection_class=attribute_mapped_collection('id'))
def __init__(self, firstname, lastname, salutation, grade, position,
identifier, active, birthdate, remark, dept, **options):
self.firstname = firstname
self.lastname = lastname
self.salutation = salutation
self.grade = grade
self.position = position
self.identifier = identifier
self.active = active
self.birthdate = birthdate
self.remark = remark
self._dept = dept
self._options = yaml.safe_dump(options, encoding='utf-8')
@property
def fullname(self):
"""format fullname"""
return u"{}, {}".format(self.lastname, self.firstname)
@property
def age(self):
"""calculate age in years"""
return int(round((datetime.now() - self.birthdate).days / 365.25, 0))
@property
def birthday(self):
"""
calculate day of birthdate for sorting
caution: use the same year for day calculation (1903/1904) and respect leap year
"""
if calendar.isleap(datetime.now().year):
return int((datetime(1904,
*self.birthdate.timetuple()[1:-2])
).strftime('%j')) # use a leapyear as reference
else:
return int((datetime(1903,
*self.birthdate.timetuple()[1:-2])
).strftime('%j')) # use a non-leapyear as reference
@property
def options(self):
return yaml.load(self._options)
@staticmethod
def getPersons(id=0, identifier=0, dept=0, onlyactive=False):
if id != 0:
return Person.query.filter_by(id=id).first()
elif identifier != 0:
return Person.query.filter_by(identifier=identifier).first()
elif dept != 0:
if onlyactive:
return Person.query.filter_by(
_dept=dept, active=True).order_by('lastname').all()
return Person.query.filter_by(
_dept=dept).order_by('lastname').all()
else:
if onlyactive:
return Person.query.filter_by(
active=True).order_by('lastname').all()
return Person.query.order_by('lastname').all()
@staticmethod
def settings():
return dict(Settings.getYaml('persons.settings'))
class City(db.Model):
"""City class"""
__tablename__ = 'cities'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30))
dept = db.Column('dept', db.Integer, db.ForeignKey('departments.id'))
mapname = db.Column(db.String(30))
default = db.Column(db.Integer)
subcity = db.Column(db.Text)
color = db.Column(db.String(6), default="000000")
osmid = db.Column(db.Integer, default=0)
osmname = db.Column(db.String(30), default="")
streets = db.relationship("Street", collection_class=attribute_mapped_collection('id'), backref=db.backref('City', remote_side=[Street.cityid]), cascade="all, delete-orphan")
department = db.relationship("Department", collection_class=attribute_mapped_collection('id'))
def __init__(self, name, dept, mapname, default, subcity, color, osmid, osmname):
self.name = name
self.dept = dept
self.mapname = mapname
self.default = default
self.subcity = subcity
self.color = color
self.osmid = osmid
self.osmname = osmname
@property
def serialize(self):
return dict(id=self.id, name=self.name)
@property
def subcities(self):
return filter(None, self.subcity.split("\r\n"))
def getColorName(self):
return '#%s' % self.color
def __repr__(self):
return '<City %r>' % self.name
def addStreet(self, street):
"""
Add street to current city
:param street: :py:class:`emonitor.modules.streeets.street.Street`
"""
#cache.delete_memoized('getStreets', self)
if street.id in self.streets:
self.streets[street.id] = street
else:
self.streets[street.id] = street
db.session.commit()
# static part
@staticmethod
def getCities(id=0):
"""
Get list of all cities
:return: list of :py:class:`emonitor.modules.streets.city.City`
"""
if id == 0:
return City.query.order_by(City.default.desc(), City.name).all()
else:
return City.query.filter_by(id=id).first()
@staticmethod
def getCitiesDict():
"""
Get cities as dict
:return: dict of :py:class:`emonitor.modules.streets.city.City`, id as key
"""
ret = dict(db.get(City.id, City).order_by(City.id))
ret[0] = City.getDefaultCity()
return ret
@staticmethod
def getDefaultCity():
"""
Get default city (default=1)
:return: :py:class:`emonitor.modules.streets.city.City`
"""
return City.query.filter_by(default=1).first()
class Street(db.Model):
"""Street class"""
__tablename__ = 'streets'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
navigation = db.Column(db.Text)
cityid = db.Column(db.Integer, db.ForeignKey('cities.id'))
subcity = db.Column(db.String(40))
lat = db.Column(db.Float)
lng = db.Column(db.Float)
zoom = db.Column(db.Integer)
active = db.Column(db.Integer, default=0)
osmid = db.Column(db.Integer, default=0)
city = relationship("City", backref="cities", lazy='joined')
housenumbers = relationship(Housenumber.__name__,
backref="streets",
lazy='subquery',
order_by=Housenumber.number)
def __init__(self, name, navigation, cityid, subcity, lat, lng, zoom,
active, osmid):
self.name = name
self.navigation = navigation
self.cityid = cityid
self.subcity = subcity
self.lat = lat
self.lng = lng
self.zoom = zoom
self.active = active
self.osmid = osmid
def __repr__(self):
return '<Street %r - %r>' % (self.id, self.name)
@property
def serialize(self):
"""
Serialize street object for json calls
:return: dict with street attributes
"""
return dict(id=self.id,
name=self.name,
city=self.city.serialize,
subcity=self.subcity,
lat=self.lat,
lng=self.lng,
zoom=self.zoom,
active=self.active)
def addHouseNumber(self, number, points):
"""
Add housenumber for street
:param number: housenumber as string
:param points: list of points for housenumber
"""
if number not in [hn.number for hn in self.housenumbers]:
db.session.add(Housenumber(self.id, number, yaml.dump(points)))
db.session.commit()
def getHouseNumber(self, **kwargs):
ret = []
if "id" in kwargs:
ret = filter(lambda x: x.id == kwargs['id'], self.housenumbers)
elif "number" in kwargs:
ret = filter(lambda x: x.number == kwargs['number'],
self.housenumbers)
if len(ret) > 0:
return ret[0]
return None
@staticmethod
def getStreets(id=0, cityid=0):
"""
Get all streets of city given by id, *0* for all streets
:param optional id: id of street, *0* for all
:param optional cityid: id of city, *0* for all
:return: list of :py:class:`emonitor.modules.streets.street.Street`
"""
if id != 0:
return Street.query.filter_by(id=id).scalar()
if cityid != 0:
return Street.query.filter_by(cityid=cityid).order_by(
Street.name).all()
else:
return Street.query.order_by(Street.name).all()
@staticmethod
def getStreetsDict():
"""
Get dict of streets, id as key
:return: cict of :py:class:`emonitor.modules.streets.street.Street`
"""
ret = dict(
db.get(Street.id,
Street).filter_by(active=1).order_by(Street.name))
ret[0] = Street('', '', 0, '', 0, 0, 0, 1, 0)
return ret
class AlarmField(db.Model):
__version__ = '0.1'
__tablename__ = 'alarmfields'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
fieldtype = db.Column('type', db.String(32))
name = db.Column(db.String(64))
_parameters = db.Column('parameters', db.Text)
dept = db.Column('dept', db.Integer, db.ForeignKey('departments.id'))
position = db.Column(db.Integer)
department = db.relationship(
"Department", collection_class=attribute_mapped_collection('id'))
@property
def hasEditForm(self):
return True
@declared_attr
def __mapper_args__(self):
return {
'polymorphic_on': self.fieldtype,
'polymorphic_identity': self.__name__
}
def __init__(self, name, dept, parameters, position):
self.fieldtype = self.__class__.__name__
if self.fieldtype == name: # translate if classname an name are same
name = babel.gettext(name)
self.name = name
self.dept = dept
self._parameters = yaml.safe_dump(parameters, encoding='utf-8')
self.position = position
def __repr__(self):
return '{} - {}'.format(self.__class__.__name__, self.id)
@property
def parameters(self):
return yaml.load(self._parameters)
@parameters.setter
def parameters(self, params):
self._parameters = yaml.safe_dump(params, encoding='utf-8')
def getFields(self, **params):
return []
def getFieldValue(self, fieldname, alarm):
if fieldname.startswith('alarm.'):
return ">>", alarm.get(fieldname.split('.')[1]) # TODO
return None
def getExportFields(self):
return []
def configForm(self, dept=0):
return render_template('fields/field.config_{}.html'.format(
self.fieldtype.lower()),
field=self,
dept=dept)
def editForm(self, alarm):
try:
return render_template('fields/field.edit_{}.html'.format(
self.fieldtype.lower()),
field=self,
alarm=alarm)
except TemplateNotFound:
return ""
def saveForm(self, request, alarm):
pass
def renderField(self, alarm, **params):
try:
return render_template('fields/field.render_{}.html'.format(
self.fieldtype.lower()),
field=self,
alarm=alarm,
params=params)
except:
pass
@staticmethod
def getAlarmFields(id=0, dept=0, fieldtype=""):
if id != 0:
return AlarmField.query.filter_by(id=id).first()
elif dept != 0:
return AlarmField.query.filter(
AlarmField.dept == dept).order_by('position').all()
elif fieldtype != "":
return AlarmField.query.filter(
AlarmField.fieldtype == fieldtype).first()
else:
return AlarmField.query.order_by('name').all()
@staticmethod
def getAlarmFieldsDict():
return dict(map(lambda x: [x.id, [x]], AlarmField.query.all()))
@staticmethod
def getAlarmFieldsForDepartment(dept):
ret = []
for field in AlarmField.getAlarmFields(dept=dept):
ret.append(field)
i = 0
for name, cls in inspect.getmembers(sys.modules[__name__]):
if inspect.isclass(cls) and len(
cls.__bases__
) > 0 and cls.__bases__[0].__name__ == 'AlarmField':
if len(filter(lambda c: c.__class__.__name__ == name,
ret)) == 0:
ret.append(cls(name, dept, [], i))
i += 1
return ret
@staticmethod
def getAlarmFieldForType(fieldtype, dept=0):
for name, cls in inspect.getmembers(sys.modules[__name__]):
if inspect.isclass(cls) and cls.__name__ == fieldtype:
position = 0
dbFields = AlarmField.getAlarmFieldsDict()
if int(dept) in dbFields.keys():
position = len(dbFields[int(dept)])
return cls(cls.__name__, int(dept), {}, position)
class Alarmkey(db.Model):
"""Alarmkey class"""
__tablename__ = 'alarmkeys'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
category = db.Column(db.String(40), default='')
key = db.Column(db.String(40), default='')
key_internal = db.Column(db.String(40), default='')
_keyset = db.Column('keyset', db.ForeignKey('alarmkeysets.id'))
keyset = db.relationship(
"AlarmkeySet", collection_class=attribute_mapped_collection('id'))
keysetitem = db.Column(db.INTEGER, default=0)
remark = db.Column(db.Text)
def __init__(self,
category,
key,
key_internal,
remark,
keyset=None,
keysetitem=None):
self.category = category
self.key = key
self.key_internal = key_internal
self.remark = remark
self._keyset = keyset
self.keysetitem = keysetitem
def _getCars(self, cartype, department):
"""
Prototype method for car or material lists
:param cartype: 1|2|3: cars1, cars2, material as integer
:param department: id of department as integer
:return: list of cars, material
"""
alarmcars = AlarmkeyCars.getAlarmkeyCars(kid=self.id or 9999,
dept=department)
if not alarmcars:
# try default
alarmcars = AlarmkeyCars.getAlarmkeyCars(kid=9999, dept=department)
if alarmcars:
if cartype == 1:
return alarmcars.cars1
elif cartype == 2:
return alarmcars.cars2
elif cartype == 3:
return alarmcars.materials
else:
return []
def setCars(self, department, **kwargs):
"""
Set carlist of department
:param department: id of department as integer
:param kwargs:
- *cars1*: list of :py:class:`emonitor.modules.cars.car.Car` objects for cars1
- *cars2*: list of :py:class:`emonitor.modules.cars.car.Car` objects for cars2
- *material*: list of :py:class:`emonitor.modules.cars.car.Car` objects for material
"""
alarmcars = AlarmkeyCars.getAlarmkeyCars(kid=self.id, dept=department)
if not alarmcars:
alarmcars = AlarmkeyCars(self.id, department, '', '', '')
db.session.add(alarmcars)
if "cars1" in kwargs.keys():
alarmcars._cars1 = kwargs['cars1']
if "cars2" in kwargs.keys():
alarmcars._cars2 = kwargs['cars2']
if "material" in kwargs.keys():
alarmcars._material = kwargs['material']
def getCars1(self, department):
"""
Get list of Car objects for cars1 of current alarmkey definition of given department
:param department: id of department as integer
:return: list of :py:class:`emonitor.modules.cars.car.Car` objects
"""
return self._getCars(1, department)
def getCars2(self, department):
"""
Get list of Car objects for cars2 of current alarmkey definition of given department
:param department: id of department as integer
:return: list of :py:class:`emonitor.modules.cars.car.Car` objects
"""
return self._getCars(2, department)
def getMaterial(self, department):
"""
Get list of Car objects for material of current alarmkey definition of given department
:param department: id of department as integer
:return: list of :py:class:`emonitor.modules.cars.car.Car` objects
"""
return self._getCars(3, department)
def hasDefinition(self, department):
"""
Get definition for current alarmkey of given department
:param department: id of department
:return: :py:class:`emonitor.modules.alarmkeys.alarmkey.Alarmkey` or *None*
"""
return AlarmkeyCars.getAlarmkeyCars(kid=self.id or 9999,
dept=department) is None
@staticmethod
def getAlarmkeys(id='', keysetid=None):
"""
Get all alarmkey definitions or single definition with given 'id'
:param id: id of alarmkey
:param keysetid: id of :py:class:`emonitor.modules.alarmkeys.AlarmkeySet` oder *None*
:return: list of defintions or single definition
"""
if id not in ['', 'None']:
return Alarmkey.query.filter_by(id=id).first()
elif keysetid:
if int(keysetid) == 0: # deliver all un-matched items
return Alarmkey.query.filter_by(
_keyset=None).order_by('category').all()
return Alarmkey.query.filter_by(
_keyset=keysetid).order_by('category').all()
else:
keyset = AlarmkeySet.getCurrentKeySet()
if keyset is None:
return Alarmkey.query.order_by('category').all()
else:
return Alarmkey.query.filter_by(
_keyset=keyset.id).order_by('category').all()
@staticmethod
def getOrphanKeys():
"""
Get list of all orphan alarmkeys
:return: list of orphan alarmkeys
"""
return Alarmkey.query.filter_by(keyset=None).all()
@staticmethod
def getAlarmkeysByName(name):
"""
Get Alarmkey object with given name
:param name: name as string (like)
:return: :py:class:`emonitor.modules.alarmkeys.alarmkey.Alarmkey` object
"""
return Alarmkey.query.filter(Alarmkey.key.like('%' + name + '%')).all()
@staticmethod
def getAlarmkeysByCategory(category):
"""
Get all alarmkey definitions of given category
:param category: category as string
:return: :py:class:`emonitor.modules.alarmkeys.alarmkey.Alarmkey` object list
"""
return Alarmkey.query.filter_by(category=category).all()
@staticmethod
def getAlarmkeysByCategoryId(categoryid, keysetid=None):
"""
Get all alarmkey definitions of given category id
:param categoryid: category as string
:param keysetid: keysetid as integer, 0 for un-matched, None for all
:return: :py:class:`emonitor.modules.alarmkeys.alarmkey.Alarmkey` object list
"""
key = Alarmkey.query.filter_by(id=categoryid).one()
if keysetid is None:
return Alarmkey.query.filter_by(category=key.category).all()
elif int(keysetid) == 0:
return Alarmkey.query.filter_by(category=key.category,
_keyset=None).all()
else:
return Alarmkey.query.filter(
Alarmkey.category == key.category
and Alarmkey._keyset == keysetid).all()
@staticmethod
def getAlarmkeysDict():
"""
Get dict of all alarmkeys with alarmkey.id as dict key
:return: dict of alarmkeys
"""
return dict(db.get(Alarmkey.id, Alarmkey).order_by(Alarmkey.key).all())
@staticmethod
def getDefault(department):
"""
Get default alarmkey definition of given department
:param department: id as integer
:return: :py:class:`emonitor.modules.alarmkeys.alarmkey.Alarmkey` object
"""
return AlarmkeyCars.query.filter_by(
kid=9999, dept=department).first() or AlarmkeyCars(
9999, department, '', '', '')
class MonitorLayout(db.Model):
"""MonitorLayout class"""
__tablename__ = 'monitorlayouts'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
mid = db.Column(db.Integer, db.ForeignKey('monitors.id'))
trigger = db.Column(db.TEXT, default='default')
_layout = db.Column('layout', db.Text)
theme = db.Column(db.String(30))
mintime = db.Column(db.Integer, default=0)
maxtime = db.Column(db.Integer, default=0)
nextid = db.Column(db.Integer, default=0)
monitor = relationship("Monitor", backref="monitors", lazy='joined')
@property
def layout(self):
"""
Use yaml for layout
:return: yaml formated data
"""
return yaml.load(self._layout)
@layout.setter
def layout(self, val):
"""
Setter for layout
:param val: value list with parameters for widgets
"""
l = []
for item in val:
if len(item.split(';')) == 5:
i = item.split(';')
l.append(
dict(widget=i[0],
width=int(i[1]),
height=int(i[2]),
col=int(i[3]),
row=int(i[4])))
self._layout = yaml.safe_dump(l, encoding='utf-8')
#@property
#def monitor(self):
# """Build monitor from mid"""
# return Monitor.getMonitors(id=self.mid)
def _get_themes(self):
ret = []
for root, dirs, files in os.walk(
"%s/emonitor/frontend/web/css" %
current_app.config.get('PROJECT_ROOT')):
for name in [f for f in files if f.startswith('monitor_')]:
ret.append(name.split('_')[1][:-4])
return ret
themes = property(_get_themes)
def _get_html_layout(self):
"""
Build default html layout for widget configuration
:return: html string with layout areas for widget content
"""
ret = ""
items, max_x, max_y = MonitorLayout._evalLayout(self.layout)
for l in items:
_l = str(int(ceil((l['startx'] - 1) * (100.0 / max_x)))) + '%'
_t = str(int(ceil((l['starty'] - 1) * (100.0 / max_y)))) + '%'
_r = str(100 - int(ceil((l['endx']) * (100.0 / max_x)))) + '%'
_b = str(100 - int(ceil((l['endy']) * (100.0 / max_y)))) + '%'
ret += '<div id="area" style="position:fixed;left:%s;top:%s;right:%s;bottom:%s;">[[%s]]</div>\n' % (
_l, _t, _r, _b, l['widget'])
return ret
htmllayout = property(_get_html_layout)
def __repr__(self):
return "monitorlayout"
def __init__(self, mid, trigger, layout, theme, mintime, maxtime, nextid):
self.mid = mid
self.trigger = trigger
self.layout = layout
self.theme = theme
self.mintime = mintime
self.maxtime = maxtime
self.nextid = nextid
@staticmethod
def _evalLayout(text):
ret = []
max_x = max_y = 1
if text is None:
return [
dict(startx=1, starty=1, endx=1, endy=1, name='placeholder')
], 1, 1
for l in text:
ret.append(
dict(startx=l['col'],
starty=l['row'],
endx=(l['width'] + l['col'] - 1),
endy=(l['height'] + l['row'] - 1),
widget=l['widget']))
if l['width'] + l['col'] - 1 > max_x:
max_x = l['width'] + l['col'] - 1
if l['height'] + l['row'] - 1 > max_y:
max_y = l['height'] + l['row'] - 1
return ret, max_x, max_y
def getHTMLLayoutScript(self):
ret = '$(function(){'
for l in self.layout:
try:
ret += 'addWidget("%s", %s, %s, %s, %s);\n' % (
l['widget'], l['width'], l['height'], l['col'], l['row'])
except:
pass
return ret + '});'
def getLayoutThumb(self):
"""
Calculate the thumbnail of the layout on-the-fly
:return: stream of image file
"""
dimension = (12, 9)
ret, max_x, max_y = MonitorLayout._evalLayout(self.layout)
img = Image.new('RGB',
(max_x * dimension[0] + 1, max_y * dimension[1] + 1),
(171, 171, 171))
draw = ImageDraw.Draw(img)
for l in ret:
draw.rectangle([((l['startx'] - 1) * dimension[0],
(l['starty'] - 1) * dimension[1]),
((l['endx']) * dimension[0],
(l['endy']) * dimension[1])],
fill="white",
outline='black')
output = StringIO()
img.save(output, format="PNG", dpi=(300, 300))
return output.getvalue()
@staticmethod
def getLayouts(id=0, mid=0):
"""
Get list of layout definitions filtered by parameters
:param optional id: filter only layout with id, *0* for all layouts
:param optional mid: monitorid as integer
:return: list of :py:class:`emonitor.modules.monitors.monitorlyout.MonitorLayout`
"""
if id != 0:
return MonitorLayout.query.filter_by(id=id).first()
elif mid != 0:
return MonitorLayout.query.filter_by(mid=mid).all()
else:
return MonitorLayout.query.order_by('mid').all()
def getTriggerNames(self):
return self.trigger.split(';')
class AlarmObjectFile(db.Model):
"""Files for alarmobjects"""
__tablename__ = 'alarmobjectfile'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
object_id = db.Column(db.Integer, db.ForeignKey('alarmobjects.id'))
filename = db.Column(db.String(80))
filetype = db.Column(db.String(50))
def __repr__(self):
return "<alarmobjectfile %s>" % self.filename
def __init__(self, objectid, filename, filetype):
self.object_id = objectid
self.filename = filename
self.filetype = filetype
@property
def filesize(self):
def sizeof_fmt(num):
for x in ['bytes', 'KB', 'MB', 'GB', 'TB']:
if num < 1024.0:
return "%3.1f %s" % (num, x)
num /= 1024.0
if os.path.exists('%salarmobjects/%s/%s' %
(current_app.config.get('PATH_DATA'), self.object_id,
self.filename)):
return sizeof_fmt(
os.stat('%salarmobjects/%s/%s' %
(current_app.config.get('PATH_DATA'), self.object_id,
self.filename)).st_size)
return sizeof_fmt(0)
@staticmethod
def getFile(id, filename=""):
"""
Get file(s) for alarmobject
:param id: objectid as integer
:param filename: filename as string
:return: :py:class:`emonitor.modules.alarmobjects.alarmobjectfile.AlarmObjectFile`
"""
if filename == "":
return AlarmObjectFile.query.filter_by(id=id).first()
else:
return AlarmObjectFile.query.filter_by(object_id=id,
filename=filename).first()
@staticmethod
def getAlarmObjectTypes(objectid=0):
"""
Get all possible alarmobject types
:param objectid: objectid as integer
:return: list of :py:mod:`emonitor.modules.alarmobjects.alarmobjectfile.AlarmObjectFile`
"""
if objectid != 0:
return AlarmObjectFile.query.filter_by(id=objectid).all()
else:
return AlarmObjectFile.query.order_by(
collate(AlarmObjectFile.name, 'NOCASE')).all()
class Car(db.Model):
"""Car class"""
__tablename__ = 'cars'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64))
description = db.Column(db.Text)
fmsid = db.Column(db.String(8))
active = db.Column(db.Integer)
type = db.Column(db.Text)
_dept = db.Column('dept', db.ForeignKey('departments.id'))
dept = db.relationship("Department",
collection_class=attribute_mapped_collection('id'))
def __init__(self, name, description, fmsid, active, type, dept):
self.name = name
self.description = description
self.fmsid = fmsid
self.active = active
self.type = type
self._dept = dept
def getColor(self):
"""
Get color of car, default *#ffffff*
:return: colorcode
"""
for t in Settings.getCarTypes():
if t[0] == self.type:
return t[1]
return "#ffffff"
def __str__(self):
return self.name
@staticmethod
def getCars(id=0, deptid=0, params=[]):
"""
Get list of cars filtered by given parameters
:param optional id: id of car or 0 for all cars
:param optional deptid: only cars of department with given id
:param optional params: *onlyactive*
:return: list of :py:class:`emonitor.modules.cars.car.Car`
"""
if id != 0:
return Car.query.filter_by(id=int(id)).first()
elif int(deptid) != 0:
return Car.query.filter_by(
_dept=int(deptid)).order_by('name').all()
else:
if 'onlyactive' in params:
return Car.query.filter_by(active=1).order_by('dept',
'name').all()
else:
return Car.query.order_by('dept', 'name').all()
@staticmethod
def getCarsDict():
"""
Get dict of cars, id as key
:return: dict with :py:class:`emonitor.modules.cars.car.Car`
"""
ret = {}
for car in Car.getCars():
ret[car.id] = car
return ret
class AlarmObject(db.Model):
"""AlarmObject class"""
__tablename__ = 'alarmobjects'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
_streetid = db.Column('streetid', db.ForeignKey('streets.id'))
_objecttype = db.Column('typeid', db.ForeignKey('alarmobjecttypes.id'))
_attributes = db.Column('attributes', db.Text)
remark = db.Column(db.Text)
lat = db.Column(db.Float)
lng = db.Column(db.Float)
zoom = db.Column(db.Integer)
alarmplan = db.Column(db.String(5), default='')
streetno = db.Column(db.String(10), default='')
bma = db.Column(db.String(10), default='')
active = db.Column(db.Integer)
street = db.relationship(Street, collection_class=attribute_mapped_collection('id'), lazy='subquery')
objecttype = db.relationship(AlarmObjectType, collection_class=attribute_mapped_collection('id'), lazy='subquery')
files = db.relationship(AlarmObjectFile, collection_class=attribute_mapped_collection('id'), cascade="all, delete-orphan", lazy='subquery')
def __init__(self, name, streetid, remark, lat, lng, zoom, alarmplan, streetno, bma, active, objecttype):
self.name = name
self._streetid = streetid
self.remark = remark
self.lat = lat
self.lng = lng
self.zoom = zoom
self.alarmplan = alarmplan
self.streetno = streetno
self.bma = bma
self.active = active
self._objecttype = objecttype
@property
def serialize(self):
return dict(id=self.id, name=self.name, lat=self.lat, lng=self.lng, zoom=self.zoom, alarmplan=self.alarmplan, street=self.street.serialize, streetno=self.streetno)
def get(self, attribute, default=""):
"""
Getter for attribute names
:param attribute: name of attribute as string
:param optional default: default value
:return: value of attribute
"""
try:
values = yaml.load(self._attributes)
return values[attribute]
except:
return default
def set(self, attribute, val):
"""
Setter for attributes
:param attribute: attribute name as string
:param val: value as string
"""
try:
values = yaml.load(self._attributes)
except:
values = {}
values[attribute] = val
self._attributes = yaml.safe_dump(values, encoding='utf-8')
def get_cars_proto(self, ctype):
"""
Prototype of car, material getter
:param ctype: 1:cars1, 2:cars2, 3:material
:return: list of :py:class:`emonitor.modules.cars.car.Car`
"""
_t = {1: 'cars1', 2: 'cars2', 3: 'material'}
ret = []
cars = Car.getCars()
for _c in [int(c) for c in self.get(_t[ctype]) if c != '']:
try:
ret.append(filter(lambda c: c.id == _c, cars)[0])
except IndexError:
pass
return ret
def getCars1(self):
return self.get_cars_proto(1)
def getCars2(self):
return self.get_cars_proto(2)
def getMaterial(self):
return self.get_cars_proto(3)
def hasOwnAAO(self):
return len(self.get('cars1') + self.get('cars2') + self.get('material')) > 0
@staticmethod
def getAlarmObjectsDict():
return dict((_o.id, _o) for _o in AlarmObject.query.order_by('name'))
@staticmethod
def getAlarmObjects(id=0, active=1):
"""
Get list of alarmobjects with given params
:param id: id of alarmobject or *0* for all objects
:param active: *1* for active objects or *0* for all objects
:return: list of :py:class:`emonitor.modules.alarmobjects.alarmobject.AlarmObject`
"""
if id != 0:
return AlarmObject.query.filter_by(id=id).first()
else:
if active == 1: # only active objects
return AlarmObject.query.filter_by(active=1).order_by('name').all()
else: # deliver all objects
return AlarmObject.query.order_by('name').all()
