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()