class Board(db.Document):
name = db.StringField(required=True, unique=True)
status = db.StringField(required=True)
cards = db.ListField(db.ReferenceField('Card'))
date_created = db.DateTimeField(default=datetime.utcnow)
owner = db.ReferenceField(User)
visible = db.ListField(db.ReferenceField(User))
class Clubs(db.document):
clubAddress: db.StringField(unique=True)
name: db.StringField()
description: db.StringField()
image_file = db.ImageField()
coverImage = db.StringField()
members: db.ListField(db.ReferenceField(User))
admins: db.ListField(db.ReferenceField(User))
createdAt = db.DateTimeField(
default=datetime.utcnow) # utc to keep it universal
updatedAt = db.DateTimeField(default=datetime.utcnow)
class Card(db.Document):
title = db.StringField(required=True)
content = db.ListField(db.EmbeddedDocumentField(Comment))
start_date = db.DateTimeField()
end_date = db.DateTimeField()
date_created = db.DateTimeField(default=datetime.utcnow)
date_completed = db.DateTimeField()
owner = db.ReferenceField(User)
assigned = db.ReferenceField(User)
# User.register_delete_rule(Board, 'owner', db.CASCADE)
# User.register_delete_rule(Board, 'visible', db.CASCADE)
class Feed(db.Document):
'''A document that represents the feeds we are keeping track of'''
name = db.StringField(required = True)
site_url = db.URLField(verify_exists = True)
rss_url = db.URLField(verify_exists = True, unique = True, required = True)
last_update = db.DateTimeField(default = datetime.datetime.now)
last_new_article = db.ReferenceField('Article', dbref = True)#lazily dereferenced on access
def save(self, *args, **kwargs):
'''
this overrides the default save method so that the last_update field
is set to the current time and then calls the default save method
'''
self.last_update = datetime.datetime.now()
return super(Feed, self).save(*args, **kwargs)
@staticmethod
def get_or_construct(rssUrl):
'''
attempts to get a Feed object based on the rssUrl provided, in case it is not found,
attempts to construct a new Feed object and return that
'''
try:
feed = Feed.objects.get(rss_url = rssUrl)
except DoesNotExist:
rss_dict = feedparser.parse(rssUrl)
if rss_dict.version == '':
raise NotAFeed('the given url was not a recognized feed format')
new_feed = Feed(\
#get title from rss feed(or atom feed)
name = rss_dict.feed.get('title', rss_dict['channel']['title'])\
#get site url from rss feed(or atom feed)
, site_url = rss_dict.feed.get('link', rss_dict['channel']['link'])\
, rss_url = rssUrl\
)
new_feed.save()
feed = new_feed
return feed
def update_articles(self):
'''Update articles for the Feed'''
parsed_feed = feedparser.parse(self.rss_url)
if parsed_feed.bozo is 1:
#there were errors parsing the feed
print 'Illformed XML detected for '\
+ feed.name +'('+ feed.site_url +') at '+ self.rss_url
return
if self.last_new_article != None:
#last_new_article exists
last_link_from_previous_run = self.last_new_article.source_url
else:
last_link_from_previous_run = None
for entry in parsed_feed.entries:
#create new article object for this entry and save it,
#if it's not the last new article
if entry.link == last_link_from_previous_run:
#we have this article already
print "found last_link_from_previous_run"
break
new_article = Article(\
source_url = entry.link\
, feed_id = self.id\
, time_stamp = parse(entry.published)\
)
article_features = Features(\
title = entry.title\
, content_snippet = new_article.get_article_snippet(entry.description,128)\
)
new_article.features = article_features
new_article.readers = new_article.get_readers_from()
try:
new_article.save()
self.last_new_article = new_article
print '+',
except db.ValidationError as e:
print 'Validation error occured'
if e.errors.get('source_url'):
print new_article.source_url+" may be broken."
except db.NotUniqueError:
#we have already retrieved this article, so do nothing
print '.'
#save to keep track of the last new article, so no need to validate
self.save(validate = False)
class Entry(db.Document):
title = db.StringField()
slug = db.StringField(unique=True, default='temp_slug')
content = db.StringField()
published = db.BooleanField()
timestamp = db.DateTimeField(default=datetime.datetime.now)
authors = db.ListField(db.ReferenceField(User))
@property
def html_content(self):
"""
Generate HTML representation of the markdown-formatted blog entry,
and also convert any media URLs into rich media objects such as video
players or images."""
hilite = CodeHiliteExtension(linenums=False, css_class='highlight')
extras = ExtraExtension()
markdown_content = markdown(self.content, extensions=[hilite, extras])
oembed_content = parse_html(markdown_content,
oembed_providers,
urlize_all=True,
maxwidth=app.config['SITE_WIDTH'])
return Markup(oembed_content)
@classmethod
def public(cls):
return Entry.objects(published=True)
@classmethod
def drafts(cls):
return Entry.objects(published=False)
@classmethod
def get_entry(cls, slug, public=True):
try:
if public:
return Entry.objects(published=True, slug=slug).first()
else:
return Entry.objects(slug=slug).first()
except DoesNotExist:
return None
def get_author_names(self):
author_names = []
for author_ref in self.authors:
author = User.objects(username=author_ref.id).get()
author_names.append(author.username)
return author_names
def get_short_text(self):
if len(self.content) <= 150:
return self.content
else:
for i in range(150, len(self.content)):
if self.content[i] == ' ':
return self.content[:i]
return self.content
def is_shortened(self):
return len(self.content) > 150
def isAuthor(self, username):
for author_ref in self.authors:
if author_ref.id == username:
return True
return False
class Comment(db.EmbeddedDocument):
id = db.ObjectIdField(required=True, default=lambda: ObjectId())
text = db.StringField(required=True)
date_created = db.DateTimeField(default=datetime.utcnow)
sender = db.ReferenceField(User)
class Admin(db.Document):
created_at = db.DateTimeField(default=now(), required=True)
user = db.ReferenceField(User)