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
