class Node(db.Model):
__tablename__ = 'node'
discriminator = db.Column('type', db.Unicode(50))
__mapper_args__ = {'polymorphic_on': discriminator}
__table_args__ = (db.Index('user_namespace',
'owner_id',
'name',
unique=True), )
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(1000))
summary = db.Column(db.UnicodeText)
meta = db.Column(JSONType, default=dict)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime,
default=datetime.utcnow,
onupdate=datetime.utcnow)
owner_id = db.Column(db.Integer, db.ForeignKey('account.id'))
owner = db.relationship(Account,
backref=db.backref('nodes', lazy='dynamic'))
def to_dict(self):
return {
'id': self.id,
'name': self.name,
'created_at': self.created_at,
'updated_at': self.updated_at,
'type': self.discriminator,
'meta': self.meta,
'owner': self.owner.name
}
class Event(db.Model):
__tablename__ = 'event'
discriminator = db.Column('type', db.Unicode(50))
__mapper_args__ = {'polymorphic_on': discriminator}
id = db.Column(db.Integer, primary_key=True)
message = db.Column(db.UnicodeText)
time = db.Column(db.DateTime, default=datetime.utcnow)
account_id = db.Column(db.Integer, db.ForeignKey('account.id'))
account = db.relationship(Account,
backref=db.backref('events', lazy='dynamic'))
data = db.Column(JSONType, default=dict)
def __init__(self, account, message):
self.account = account
self.message = message
def to_dict(self):
return {'id': self.id,
'message': self.message,
'time': self.time,
'data': self.data,
'type': self.discriminator,
'account': self.account.name}
class EventStreamEntry(db.Model):
""" An event stream entry connects events back to the objects that
they pertain to. """
__tablename__ = 'event_stream_entry'
id = db.Column(db.Integer, primary_key=True)
entity_type = db.Column(db.Unicode)
entity_id = db.Column(db.Unicode)
event_id = db.Column(db.Integer, db.ForeignKey('event.id'))
event = db.relationship(Event, backref=db.backref('stream_entries'))
def __init__(self, entity_type, entity_id, event):
self.entity_type = entity_type
self.entity_id = entity_id
self.event = event
def to_dict(self):
return {'entity_type': self.entity_type,
'entity_id': self.entity_id,
'type': self.discriminator,
'event': self.event.to_dict()}
class Resource(Node):
__mapper_args__ = {'polymorphic_identity': 'resource'}
url = db.Column(db.Unicode(255))
def __init__(self, owner, name, url, summary, meta):
self.owner = owner
self.name = name
self.url = url
self.summary = summary
self.meta = meta
def to_dict(self):
d = super(Resource, self).to_dict()
d['url'] = self.url
return d
def __repr__(self):
return '<Resource %r>' % self.name
class User(Account):
__mapper_args__ = {'polymorphic_identity': 'user'}
password = db.Column(db.Unicode(2000))
def __init__(self, name, full_name, email, password):
self.name = name
self.full_name = full_name
self.email = email
self.password = password
def is_authenticated(self):
return True
def is_anonymous(self):
return False
def is_active(self):
return self.activated
def get_id(self):
return self.name
def __repr__(self):
return '<User %r>' % self.name
from datetime import datetime
from datahub.core import db
from datahub.model.account import Account
from datahub.model.types import JSONType
datasets_resources_table = db.Table(
'datasets_resources',
db.metadata,
db.Column('dataset_id',
db.Integer,
db.ForeignKey("node.id"),
primary_key=True),
db.Column('resource_id',
db.Integer,
db.ForeignKey("node.id"),
primary_key=True),
db.Column('created_at', db.DateTime, default=datetime.utcnow),
)
class Node(db.Model):
__tablename__ = 'node'
discriminator = db.Column('type', db.Unicode(50))
__mapper_args__ = {'polymorphic_on': discriminator}
__table_args__ = (db.Index('user_namespace',
'owner_id',
'name',
unique=True), )
id = db.Column(db.Integer, primary_key=True)
class Account(db.Model):
""" Account is generic base class for normal users and
organizational accounts. """
__tablename__ = 'account'
discriminator = db.Column('type', db.Unicode(50))
__mapper_args__ = {'polymorphic_on': discriminator}
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(255), unique=True)
full_name = db.Column(db.Unicode(2000))
activation_code = db.Column(db.Unicode())
reset_code = db.Column(db.Unicode())
activated = db.Column(db.Boolean())
full_name = db.Column(db.Unicode(2000))
email = db.Column(db.Unicode(2000))
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime,
default=datetime.utcnow,
onupdate=datetime.utcnow)
def to_dict(self):
return {
'id': self.id,
'created_at': self.created_at,
'updated_at': self.updated_at,
'name': self.name,
'type': self.discriminator,
'full_name': self.full_name
}