class Admin(orm.Document): _db = "lablog" _collection = "client_admins" _indexes = [ orm.Index('email', key=('email', 1), unique=True), ] name = field.Char() email = field.Char() password = field.Char() last_login = field.Date() clients = orm.List(type=ClientRef) social_accounts = orm.List(type=SocialAccount) facebook_pages = orm.List(type=FacebookPage) in_office = field.Boolean(default=False) @staticmethod def passwords_match(pwd, cpwd): return pwd == cpwd def save(self): if self.password: if not password.identify(self.password): self.password = password.encrypt_password(self.password) return super(Admin, self).save() def verify_pwd(self, pwd): return password.check_password(pwd, self.password) def social_account(self, account_type=None): for sa in self.social_accounts: if sa.type == account_type: return sa sa = SocialAccount() sa.type = account_type return sa def get_punchcard(self, influx): try: res = influx.query( "SELECT value from \"lablog\".\"realtime\".\"presence\" where user_id='{}' AND time > now() - 2d" .format(self._id)) r = [p for p in res.get_points()] r.reverse() return r except: return [] def is_authenticated(self): if self._id: return True return False def is_active(self): return True def is_anonymous(self): return False def get_id(self): self.logger.info(unicode(self._id)) return unicode(self._id)
class BadHuman(Human): unique = field.Integer() phone = field.Phone() email = field.Email(dbkey="em") car = field.ModelChoice(type=Car) active = field.Boolean() location = Loca() avatar = field.File(database=Connection().avatars)
class BadHuman(Human): unique = field.Integer() phone = field.Phone() email = field.Email(dbkey="em") car = field.ModelChoice(type=Car) active = field.Boolean() state = field.Char(validate=StateValidator) country = field.Char(validate=orm.FieldValidator) location = Loca() avatar = field.File(database=MongoClient().avatars)
class TriggerInstance(orm.Document): _db = "lablog" _collection = "trigger_instance" _indexes = [ orm.Index('interface', key=('interface', 1), unique=True), orm.Index('trigger', key=('trigger.id', 1)), orm.Index('enabled', key=('enabled', 1)), orm.Index('key', key=('key', 1)), ] enabled = field.Boolean(default=True) interface = field.Char() level = field.Integer() key = field.Char()
class LocationGeo(Location): geo = field.Geo() active = field.Boolean()
class Interface(orm.Document): _db = 'lablog' _collection = 'interfaces' exchange = None measurement_key = None run_delta = None #datetime.timedelta(minutes=5) _last_run = field.Date() _enabled = field.Boolean(default=True) def run(self, db, mq, data=None): now = datetime.datetime.utcnow() if not self.run_delta: logging.info("No Delta") return if not self._last_run or ((now - self._last_run) >= self.run_delta): logging.info("Going") self.go(db, mq, data) logging.info("Updating last run") self._last_run = datetime.datetime.utcnow() self.save() else: logging.info("No need to run") return True def data(self, data=None): raise NotImplemented( 'data method should be overridden in subclass and return data') def parse(self, data): if not data: raise NoData() data = self.parse_data(data) return data def parse_data(self, data): raise NotImplemented( 'parse_data method should be overridden in subclass and needs to return parsed data' ) def log(self, data, db): db.write_points(data) def queue(self, data, mq, exchange): for i in data: key = i['measurement'] messages.publish(mq, i, exchange, routing_key=key) def go(self, db, mq, data=None): raw_data = self.data(data=data) parsed_data = self.parse(raw_data) self.log(parsed_data, db) self.queue(parsed_data, mq, self.exchange) return parsed_data def get_long_history(self, db, _from): historical = "SELECT MEAN(value) as value FROM \"lablog\".\"1hour\"./{}.*/ WHERE time > now() - {} AND interface='{}' GROUP BY time(1d) fill(0)".format( self.measurement_key, _from, self._id) logging.info(historical) try: res = db.query(historical) except Exception as e: res = {} ret = {} for t, g in res.items(): ret.setdefault(t[0], {}) ret[t[0]] = {'historical': [p for p in g]} return ret def get_current(self, db): current = "SELECT LAST(value) as value FROM \"lablog\".\"realtime\"./{}.*/ WHERE interface='{}'".format( self.measurement_key, self._id) res = db.query(current) ret = {} for t, g in res.items(): ret.setdefault(t[0], {}) ret[t[0]].update({'current': [p for p in g]}) return ret def get_values(self, db, _from): historical = "SELECT value FROM \"lablog\".\"1hour\"./{}.*/ WHERE time > now() - {} AND interface='{}'".format( self.measurement_key, _from, self._id) previous = "SELECT FIRST(value) as value FROM \"lablog\".\"1hour\"./{}.*/ WHERE time > now() - {} AND interface='{}'".format( self.measurement_key, _from, self._id) current = "SELECT LAST(value) as value FROM \"lablog\".\"realtime\"./{}.*/ WHERE interface='{}'".format( self.measurement_key, self._id) aggregate = "SELECT MIN(value) as min_value, MAX(value) as max_value, MEAN(value) as mean_value FROM \"lablog\".\"1hour\"./{}.*/ WHERE time > now() - {} AND interface='{}'".format( self.measurement_key, _from, self._id) triggers = TriggerInstance.find({ 'enabled': True, 'interface': str(self._id) }) sql = "{};{};{};{}".format(historical, previous, current, aggregate) try: res = db.query(sql) except Exception as e: res = [{}, {}, {}, {}] ret = {} for t, g in res[0].items(): ret.setdefault(t[0], {}) ret[t[0]] = {'historical': [p for p in g]} for t, g in res[1].items(): ret.setdefault(t[0], {}) ret[t[0]].update({'previous': [p for p in g]}) for t, g in res[2].items(): ret.setdefault(t[0], {}) ret[t[0]].update({'current': [p for p in g]}) for t, g in res[3].items(): ret.setdefault(t[0], {}) ret[t[0]].update({'aggregate': [p for p in g]}) logging.info("Triggers!") for t in triggers: logging.info(t.json()) v = ret.get(t.key) if v: v.update({'trigger': t.level}) return ret