<Category: parent>]
"""
ancestors = CategoryList()
anc = self.parent
while anc:
if anc is self:
raise CategoryNestingException, 'Category %s is defined as a ' \
'parent of one of its ancestors.' % anc
ancestors.insert(0, anc)
anc = anc.parent
return ancestors
def depth(self):
"""Return this category's distance from the root of the tree."""
return len(self.ancestors())
mapper(Category,
categories,
order_by=categories.c.name,
extension=events.MapperObserver(events.Category),
properties={
'children':
relation(Category,
backref=backref('parent', remote_side=[categories.c.id]),
order_by=categories.c.name.asc(),
collection_class=CategoryList,
join_depth=2),
})
defaults = dict(
name=u'foo',
description=u'foo permission',
groups=None,
)
defaults.update(kwargs)
permission = Permission(**defaults)
DBSession.add(permission)
DBSession.flush()
return permission
mapper(
User,
users,
extension=events.MapperObserver(events.User),
properties={
'id': users.c.user_id,
'password': synonym('_password', map_column=True),
},
)
mapper(
Group,
groups,
properties={
'users': relation(User, secondary=users_groups, backref='groups'),
},
)
mapper(
"""
return self.storage.get_uris(self)
class MediaFullText(object):
query = DBSession.query_property()
mapper(MediaFullText, media_fulltext)
mapper(MediaMeta, media_meta)
mapper(MediaFilesMeta, media_files_meta)
_media_files_mapper = mapper(
MediaFile,
media_files,
extension=events.MapperObserver(events.MediaFile),
properties={
'_meta':
relation(
MediaFilesMeta,
collection_class=attribute_mapped_collection('key'),
passive_deletes=True,
),
},
)
_media_mapper = mapper(
Media,
media,
order_by=media.c.title,
extension=events.MapperObserver(events.Media),
return self.subject
@property
def type(self):
if self.media_id:
return 'media'
return None
def _get_parent(self):
return self.media or None
def _set_parent(self, parent):
self.media = parent
parent = property(
_get_parent, _set_parent, None, """
The object this Comment belongs to, provided for convenience mostly.
If the parent has not been eagerloaded, a query is executed automatically.
""")
mapper(Comment,
comments,
order_by=comments.c.created_on,
extension=events.MapperObserver(events.Comment),
properties={
'author':
composite(AuthorWithIP, comments.c.author_name,
comments.c.author_email, comments.c.author_ip),
})
query = DBSession.query_property(CommentQuery)
def __repr__(self):
return '<Comment: %s subject="%s">' % (self.id, self.subject)
def __unicode__(self):
return self.subject
@property
def type(self):
if self.media_id:
return 'media'
return None
def _get_parent(self):
return self.media or None
def _set_parent(self, parent):
self.media = parent
parent = property(_get_parent, _set_parent, None, """
The object this Comment belongs to, provided for convenience mostly.
If the parent has not been eagerloaded, a query is executed automatically.
""")
mapper(Comment, comments, order_by=comments.c.created_on, extension=events.MapperObserver(events.Comment), properties={
'author': composite(AuthorWithIP,
comments.c.author_name,
comments.c.author_email,
comments.c.author_ip),
})
A MultiSetting
"""
query = DBSession.query_property()
def __init__(self, key=None, value=None):
self.key = key or None
self.value = value or None
def __repr__(self):
return '<MultiSetting: %s = %r>' % (self.key, self.value)
def __unicode__(self):
return self.value
mapper(Setting, settings, extension=events.MapperObserver(events.Setting))
mapper(MultiSetting,
multisettings,
extension=events.MapperObserver(events.MultiSetting))
def insert_settings(defaults):
"""Insert the given setting if they don't exist yet.
XXX: Does not include any support for MultiSetting. This approach
won't work for that. We'll need to use sqlalchemy-migrate.
:type defaults: list
:param defaults: Key and value pairs
:rtype: list
:returns: Any settings that have just been created.
"""
query = DBSession.query_property()
# TODO: replace '_thumb_dir' with something more generic, like 'name',
# so that its other uses throughout the code make more sense.
_thumb_dir = 'podcasts'
def __repr__(self):
return '<Podcast: %r>' % self.slug
@validates('slug')
def validate_slug(self, key, slug):
return slugify(slug)
mapper(Podcast, podcasts, order_by=podcasts.c.title, extension=events.MapperObserver(events.Podcast), properties={
'author': composite(Author,
podcasts.c.author_name,
podcasts.c.author_email,
doc="""An instance of :class:`mediacore.model.authors.Author`.
Although not actually a relation, it is implemented as if it were.
This was decision was made to make it easier to integrate with
:class:`mediacore.model.auth.User` down the road."""),
'media': dynamic_loader(Media, backref='podcast', query_class=MediaQuery, passive_deletes=True, doc=\
"""A query pre-filtered to media published under this podcast.
Returns :class:`mediacore.model.media.MediaQuery`."""),
'media_count':
column_property(
sql.select(
Automatically prints the contained tags separated by commas::
>>> tags = TagList(['abc', 'def', 'ghi'])
>>> tags
abc, def, ghi
"""
def __unicode__(self):
return ', '.join([tag.name for tag in self.values()])
mapper(Tag,
tags,
order_by=tags.c.name,
extension=events.MapperObserver(events.Tag))
excess_whitespace = re.compile('\s\s+', re.M)
def extract_tags(string):
"""Convert a comma separated string into a list of tag names.
NOTE: The space-stripping here is necessary to patch a leaky abstraction.
MySQL's string comparison with varchar columns is pretty fuzzy
when it comes to space characters, and is even inconsistent between
versions. We strip all preceding/trailing/duplicated spaces to be
safe.
"""
# count linebreaks as commas -- we assume user negligence
<Category: parent>
>>> print row.ancestors()
[...,
<Category: great-grand-parent>,
<Category: grand-parent>,
<Category: parent>]
"""
ancestors = CategoryList()
anc = self.parent
while anc:
if anc is self:
raise CategoryNestingException, 'Category %s is defined as a ' \
'parent of one of its ancestors.' % anc
ancestors.insert(0, anc)
anc = anc.parent
return ancestors
def depth(self):
"""Return this category's distance from the root of the tree."""
return len(self.ancestors())
mapper(Category, categories, order_by=categories.c.name, extension=events.MapperObserver(events.Category), properties={
'children': relation(Category,
backref=backref('parent', remote_side=[categories.c.id]),
order_by=categories.c.name.asc(),
collection_class=CategoryList,
join_depth=2),
})
"""Vote Model
"""
query = DBSession.query_property(VoteQuery)
def __repr__(self):
return '<Vote: %r media=%r user=%r>' % (self.id, self.media_id, self.user_name)
def __unicode__(self):
return 'Vote %r' % self.id
def increment_likes(self):
self.likes += 1
return self.likes
def increment_dislikes(self):
self.dislikes += 1
return self.dislikes
def _get_parent(self):
return self.media or None
def _set_parent(self, parent):
self.media = parent
parent = property(_get_parent, _set_parent, None, """
The object this Vote belongs to, provided for convenience mostly.
If the parent has not been eagerloaded, a query is executed automatically.
""")
mapper(Vote, votes, order_by=votes.c.id, extension=events.MapperObserver(events.Vote), properties={})
