class User(Model, Subject):
'''The user of a system.
The only field required is the :attr:`username`.
which is also unique across all users.
'''
username = odm.SymbolField(unique=True)
password = odm.CharField(required=False, hidden=True)
first_name = odm.CharField()
last_name = odm.CharField()
email = odm.SymbolField(required=False)
is_active = odm.BooleanField(default=True)
can_login = odm.BooleanField(default=True)
is_superuser = odm.BooleanField(default=False)
data = odm.JSONField()
manager_class = UserManager
def __unicode__(self):
return self.username
def fullname(self):
if self.first_name or self.last_name:
return ' '.join(
(n for n in (self.first_name, self.last_name) if n))
else:
return ''
def is_authenticated(self):
return self.can_login
class TaskData(odm.StdModel):
id = odm.SymbolField(primary_key=True)
overlap_id = odm.SymbolField(required=False)
name = odm.SymbolField()
status = odm.SymbolField()
args = odm.PickleObjectField()
kwargs = odm.PickleObjectField()
result = odm.PickleObjectField()
from_task = odm.SymbolField(required=False)
time_executed = odm.DateTimeField(index=False)
time_started = odm.DateTimeField(required=False, index=False)
time_ended = odm.DateTimeField(required=False, index=False)
expiry = odm.DateTimeField(required=False, index=False)
meta = odm.JSONField()
#
# List where all TaskData ids are queued
queue = odm.ListField(class_field=True)
# Set where TaskData ids under execution are stored
executing = odm.SetField(class_field=True)
class Meta:
app_label = 'tasks'
def as_task(self):
params = dict(self.meta or {})
for field in self._meta.scalarfields:
params[field.name] = getattr(self, field.attname, None)
return backends.Task(self.id, **params)
def __unicode__(self):
return '%s (%s)' % (self.name, self.status)
class WordBook(odm.StdModel):
id = odm.CompositeIdField('word', 'book')
word = odm.SymbolField()
book = odm.SymbolField()
def __unicode__(self):
return '%s:%s' % (self.word, self.book)
class Base(odm.StdModel):
name = odm.SymbolField(unique=True)
ccy = odm.SymbolField()
def __unicode__(self):
return self.name
class Meta:
abstract = True
class SimpleModel(odm.StdModel):
code = odm.SymbolField(unique=True)
group = odm.SymbolField(required=False)
description = odm.CharField()
somebytes = odm.ByteField()
object = odm.PickleObjectField(required=False)
cached_data = odm.ByteField(as_cache=True)
timestamp = odm.DateTimeField(as_cache=True)
number = odm.FloatField(required=False)
manager_class = CustomManager
def __unicode__(self):
return self.code
class User(odm.StdModel):
'''A model for holding information about users'''
username = odm.SymbolField(unique=True)
password = odm.SymbolField(index=False)
updates = odm.ListField(model=Post)
following = odm.ManyToManyField(model='self', related_name='followers')
def __unicode__(self):
return self.username
def newupdate(self, message):
session = self.session
p = yield session.router.post.new(data=message, user=self)
yield self.updates.push_front(p)
yield p
class Calendar(odm.StdModel):
name = odm.SymbolField(unique=True)
data = odm.SetField(DateValue, ordered=True)
def add(self, dt, value):
event = DateValue(dt=dt, value=value).save()
self.data.add(event)
class Page(PageModel, ModelBase):
'''The page model holds several information regarding pages
in the sitemap.'''
template = odm.CharField()
site = odm.ForeignKey(Site)
title = odm.CharField()
link = odm.CharField()
url = odm.SymbolField()
in_navigation = odm.IntegerField(default=1)
body_class = odm.CharField()
#
# Access
soft_root = odm.BooleanField(default=False)
in_sitemap = odm.BooleanField(default=True)
published = odm.BooleanField(default=True)
#
# Content is a Json object
content = odm.JSONField()
head = odm.JSONField()
manager_class = PageManger
def __unicode__(self):
return self.url
#return escape(self.url)
def path(self, **urlargs):
return Route(self.url).url(**urlargs)
class Todo2(odm.StdModel):
title = odm.SymbolField(index=False)
description = odm.CharField()
when = odm.DateTimeField(required=False)
def __unicode__(self):
return self.title
class FeedBase(odm.StdModel):
name = odm.SymbolField()
live = odm.ForeignKey(CrossData, required=False)
prev = odm.ForeignKey(CrossData, required=False)
class Meta:
abstract = True
class Instrument2(Base):
type = odm.SymbolField()
class Meta:
ordering = 'id'
app_label = 'examples2'
name = 'instrument'
class Folder(odm.StdModel):
name = odm.SymbolField()
view = odm.ForeignKey(PortfolioView, related_name='folders')
positions = odm.ManyToManyField(Position, related_name='folders')
parent = odm.ForeignKey('self', related_name='children', required=False)
def __unicode__(self):
return self.name
class ObjectAnalytics(odm.StdModel):
model_type = odm.ModelField()
object_id = odm.SymbolField()
@property
def object(self):
if not hasattr(self, '_object'):
self._object = self.model_type.objects.get(id=self.object_id)
return self._object
class Task(odm.StdModel):
id = odm.SymbolField(primary_key=True)
name = odm.CharField()
timestamp = odm.DateTimeField(default=datetime.now)
class Meta:
ordering = '-timestamp'
def clone(self, **kwargs):
instance = super(Task, self).clone(**kwargs)
instance.timestamp = None
return instance
class User(odm.StdModel):
'''The user of a system. The only field required is the :attr:`username`.
which is also unique across all users.'''
username = odm.SymbolField(unique=True)
password = odm.CharField(required=False, hidden=True)
first_name = odm.CharField()
last_name = odm.CharField()
email = odm.CharField()
is_active = odm.BooleanField(default=True)
can_login = odm.BooleanField(default=True)
is_superuser = odm.BooleanField(default=False)
def __unicode__(self):
return self.username
class Alias(odm.StdModel):
id = fields.CompositeSymbolField('name',
'domain',
seperator='@',
primary_key=True)
domain = fields.SortableSymbolField()
name = odm.SymbolField()
to = odm.CharField()
def __unicode__(self):
return self.name + '@' + self.domain
class Meta:
ordering = 'id'
class Content(ModelBase):
'''Model for the content displayed on a page ``position`` element.
.. attribute:: title
Optional title for the content
.. attribute:: slug
Optional slug field for urls
.. attribute:: content_type
Type of content, by default the extension provides:
* ``markdown``
* ``contenturl`` for :ref:`content from a url <cms-contenturl>`
* ``blank`` an empty block
'''
title = odm.CharField(required=True)
content_type = odm.SymbolField()
data = odm.JSONField()
class Meta:
search = ('title', 'keywords')
manager_class = ContentManager
def __unicode__(self):
try:
return '%s %s' % (self.content_type, self.id)
except Exception:
return self.__class__.__name__
def fields(self):
fields = self.tojson()
fields.pop('timestamp', None)
data = fields.pop('data', None)
if data:
fields.update(data)
return fields
def set_fields(self, data):
for name in self._meta.dfields:
if name in data:
value = data.pop(name)
if name not in skip_fields:
self.set(name, value)
self.data.update(data)
class Group(odm.StdModel, Subject):
id = odm.CompositeIdField('name', 'user')
name = odm.SymbolField()
'''Group name. If the group is for a signle user, it can be the
user username'''
user = odm.ForeignKey(User)
'''A group is always `owned` by a :class:`User`. For example the ``admin``
group for a website is owned by the ``website`` user.'''
#
users = odm.ManyToManyField(User, related_name='groups')
'''The :class:`stdnet.odm.ManyToManyField` for linking :class:`User`
and :class:`Group`.'''
roles = odm.ManyToManyField('Role', related_name='subjects')
manager_class = GroupManager
def __unicode__(self):
return self.name
class TimeSeries(odm.StdModel):
ticker = odm.SymbolField(unique=True)
data = odm.TimeSeriesField()
def todate(self, v):
return todatetime(v)
def dates(self):
return self.data
def items(self):
return self.data.items()
def __get_start(self):
r = self.data.front()
if r:
return r[0]
data_start = property(__get_start)
def __get_end(self):
r = self.data.back()
if r:
return r[0]
data_end = property(__get_end)
def size(self):
'''number of dates in timeseries'''
return self.data.size()
def intervals(self, startdate, enddate, parseinterval=None):
'''Given a ``startdate`` and an ``enddate`` dates, evaluate the
date intervals from which data is not available. It return a list
of two-dimensional tuples containing start and end date for the
interval. The list could contain 0, 1 or 2 tuples.'''
return missing_intervals(startdate,
enddate,
self.data_start,
self.data_end,
dateconverter=self.todate,
parseinterval=parseinterval)
class Permission(odm.StdModel):
'''A model which implements permission and operation within
this RBAC implementation.'''
id = odm.CompositeIdField('model_type', 'object_pk', 'operation')
'''The name of the role, for example, ``Editor`` for a role which can
edit a certain :attr:`model_type`.'''
model_type = odm.ModelField()
'''The model (resource) which this permission refers to.'''
operation = odm.IntegerField(default=0)
'''The operation assigned to this permission.'''
object_pk = odm.SymbolField(required=False)
manager_class = PermissionManager
def __unicode__(self):
op = self.operation
if self.object_pk:
return '%s - %s - %s' % (self.model_type, self.object_pk, op)
else:
return '%s - %s' % (self.model_type, op)
class Account(odm.StdModel):
id = fields.CompositeSymbolField('name',
'domain',
seperator='@',
primary_key=True)
domain = fields.SortableSymbolField()
name = odm.SymbolField()
password = odm.CharField()
submission_disabled = odm.BooleanField(default=False)
subaddress_extension = odm.BooleanField(default=False)
spoofing_whitelist = odm.CharField(default='')
def __unicode__(self):
return self.name + '@' + self.domain
def set_password(self, password):
self.password = sha512_crypt.encrypt(password)
class Meta:
ordering = 'id'
class Role(odm.StdModel):
'''A :class:`Role` is uniquely identified by its :attr:`name` and
:attr:`owner`.'''
id = odm.CompositeIdField('name', 'owner')
name = odm.SymbolField()
'''The name of this role.'''
owner = odm.ForeignKey(Group)
'''The owner of this role-permission.'''
permissions = odm.ManyToManyField(Permission, related_name='roles')
'''the set of all :class:`Permission` assigned to this :class:`Role`.'''
def __unicode__(self):
return self.name
def add_permission(self, resource, operation):
'''Add a new :class:`Permission` for ``resource`` to perform an
``operation``. The resource can be either an object or a model.'''
if isclass(resource):
model_type = resource
pk = ''
else:
model_type = resource.__class__
pk = resource.pkvalue()
p = Permission(model_type=model_type, object_pk=pk,
operation=operation)
session = self.session
if session.transaction:
session.add(p)
self.permissions.add(p)
return p
else:
with session.begin() as t:
t.add(p)
self.permissions.add(p)
return t.add_callback(lambda r: p)
def assignto(self, subject):
'''Assign this :class:`Role` to ``subject``.'''
return subject.assign(self)
class Session(Model):
'''A session model with a hash table as data store.'''
serializable = False
TEST_COOKIE_NAME = 'testcookie'
TEST_COOKIE_VALUE = 'worked'
id = odm.SymbolField(primary_key=True)
data = odm.JSONField()
expiry = odm.DateTimeField()
user = odm.ForeignKey(User)
must_save = False
modified = True
def __unicode__(self):
return self.id
@property
def expired(self):
return datetime.now() >= self.expiry
def get(self, key, default=None):
return self.data.get(key, default)
def __contains__(self, key):
return key in self.data
def __getitem__(self, key):
return self.data[key]
def __setitem__(self, key, val):
self.data[key] = val
self.must_save = True
def __delitem__(self, key):
del self.data[key]
def pop(self, key, *arg):
return self.data.pop(key, *arg)
class FinanceTimeSeries(TimeSeries):
ticker = odm.SymbolField(unique=True)
def __unicode__(self):
return '%s - %s' % (self.ticker, self.data.size())
class Parent(odm.StdModel):
name = odm.SymbolField(primary_key=True)
timestamp = odm.DateTimeField(default=datetime.now)
class Child(odm.StdModel):
name = odm.SymbolField()
parent = odm.ForeignKey(Parent)
uncles = odm.ManyToManyField(Parent, related_name='nephews')
class UserDefaultView(odm.StdModel):
user = odm.SymbolField()
view = odm.ForeignKey(PortfolioView)
class Instrument(Base):
type = odm.SymbolField()
description = odm.CharField()
class PortfolioView(odm.StdModel):
name = odm.SymbolField()
portfolio = odm.ForeignKey(Fund)
class CrossData(odm.StdModel):
name = odm.SymbolField()
data = odm.JSONField(as_string=False)
extra = odm.ForeignKey('self', required=False)
