class Scion(Car):
any_owner = field.DynamicDocument()
color = field.Choice(choices=["Red", "Blue", "Green"])
make = field.Char(default="Scion")
model = field.Char(default="xA")
year = field.Date(default=datetime.datetime(2007, 1, 1))
silly_date = field.TimeStamp()
class Car(orm.Document):
_db = "test"
_collection = "cars"
owner = field.DocumentId(type=Human)
make = field.Char()
model = field.Char()
year = field.Date()
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 Token(orm.Document):
_db = 'lablog'
_collection = 'tokens'
_indexes = [
orm.Index('access_token', key=('access_token', 1), unique=True),
orm.Index('refresh_token', key=('refresh_token', 1), unique=True),
orm.Index('client', key=('client', 1)),
orm.Index('user', key=('user', 1)),
orm.Index('user_agent', key=('user_agent', 1)),
]
access_token = field.Char()
refresh_token = field.Char()
client = field.DocumentId(type=Client)
scopes = orm.List(type=unicode)
expires = field.Date()
user = field.DocumentId(type=Admin)
user_agent = field.Char()
_type = field.Char()
@property
def token_type(self):
return self._type
def delete(self):
self.remove()
class Car(orm.Document):
_db = "test"
_collection = "cars"
owner = field.DynamicDocument()
make = field.Char()
model = field.Char()
year = field.Date()
silly_date = field.TimeStamp()
class Car(orm.Document):
_db = "test"
_collection = "cars"
owner = field.DocumentId(type=Human)
make = field.Char()
model = field.Char()
year = field.Date()
features = orm.List(type=unicode)
properties = orm.List(type=Property)
class Experiment(orm.Document):
"""
Base class for various experiments
"""
_db = "os_mongo"
_collection = "experiments"
experiment_id = field.AutoIncrement(collection="experiment")
organization = field.Char(required=True)
title = field.Char(required=True)
description = field.Char(required=False)
date = field.Date(required=True)
class Grant(orm.Document):
_db = 'lablog'
_collection = 'grants'
client = field.DocumentId(type=Client)
code = field.Char()
user = field.DocumentId(type=Admin)
scopes = orm.List(type=unicode)
expires = field.Date()
redirect_url = field.Char()
def delete(self):
self.remove()
class Admin(orm.Document):
_db = "entropealabs"
_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()
client = field.DocumentId(type=Client)
social = SocialAccounts(type=SocialAccount)
facebook_pages = orm.List(type=FacebookPage)
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
@staticmethod
def passwords_match(pwd, cpwd):
if pwd == cpwd: return True
return False
def save(self):
if not password.identify(self.password):
self.password = password.encrypt_password(self.password)
return super(Admin, self).save()
def verify_pwd(self, pwd):
self.logger.info(password.encrypt_password(pwd))
self.logger.info(self.password)
return password.check_password(pwd, self.password)
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 Trigger(orm.Document):
_db = "lablog"
_collection = "triggers"
_indexes = [
orm.Index('name', key=('name', 1), unique=True),
orm.Index('key', key=('key', 1)),
]
name = field.Char()
key = field.Char()
last_run = field.Date()
_me = field.DynamicDocument()
def save(self, *args, **kwargs):
if not self._id:
self._me = {}
self.last_run = datetime.utcnow() - timedelta(minutes=60)
super(Trigger, self).save(*args, **kwargs)
self._me = self
return super(Trigger, self).save(*args, **kwargs)
def _run(self, message):
interface = message['tags']['interface']
try:
ret = self._me.run(message)
except TriggerEnabled as e:
ti = TriggerInstance.find_one({
'interface': interface,
'trigger.id': self._id
})
if not ti: ti = TriggerInstance()
ti.enabled = True
ti.interface = interface
ti.level = e.level
ti.key = self._me.key
ti.trigger = self._me
ti.save()
self.last_run = datetime.utcnow()
self.save()
except TriggerDisabled as e:
ti = TriggerInstance.find_one({
'interface': interface,
'trigger.id': self._id
})
if not ti: return
ti.enabled = False
ti.save()
return
class SocialAccount(orm.EmbeddedDocument):
TWITTER = 'twitter'
FACEBOOK = 'facebook'
GOOGLE = 'google'
LINKEDIN = 'linkedin'
type = field.Char()
id = field.Char()
name = field.Char()
app_id = field.Char()
token = orm.Field()
secret = field.Char()
avatar = field.Char()
permissions = orm.List(type=unicode)
categories = orm.List(type=PageCategory)
last_sync = field.Date()
def __call__(self, *args, **kwargs):
data = kwargs.pop('data', {})
self._map(data)
return self
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