class Ask(db.document):
createdAt = db.DateTimeField(default=datetime.utcnow)
updatedAt = db.DateTimeField(default=datetime.utcnow)
question = db.EmbeddedDocumentField(Question)
privacy = db.StringField()
answers = db.ListField(db.EmbeddedDocumentField(Answers))
askedBy = db.RefrenceField(User)
class Answers(db.EmbeddedDocument):
body = db.ListField()
comments = db.ListField()
upvotes = db.StringField()
stars = db.StringField()
addedBy = db.RefrenceField(User)
createdAt = db.DateTimeField(default=datetime.utcnow)
updatedAt = db.DateTimeField(default=datetime.utcnow)
class Olympiad(db.EmbeddedDocument):
created_at = db.DateTimeField(default=now(), required=True)
number = db.IntField(min_value=1)
city = db.StringField(max_length=255, required=True)
country = db.StringField(max_length=255, required=True)
start_date = db.DateTimeField(required=True)
end_date = db.DateTimeField(required=True)
file = None
logo = db.FileField()
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 Blog(db.document):
createdAt = db.DateTimeField(default=datetime.utcnow)
updatedAt = db.DateTimeField(default=datetime.utcnow)
writtenBy = db.RefrenceField(User)
title = db.StringField()
subTitle = db.StringField()
body = db.ListField()
tags = db.ListField()
stars = db.StringField()
views = db.StringField()
comments = db.ListField()
class User(db.Document):
username = db.StringField(required=True, unique=True)
pwHash = db.StringField(required=True)
email = db.EmailField(required=True)
first_name = db.StringField()
last_name = db.StringField()
birthday = db.DateTimeField()
address = db.StringField()
@classmethod
def userExists(cls, name):
try:
return User.objects(username=name).get()
except DoesNotExist:
return None
@classmethod
def checkCredentials(cls, name, passwd):
try:
checkedUser = User.objects(username=name).get()
#The passwords are hashed and checked with bcrypt. Bcrypt checking method only accepts byte strings,
#while mongodb stores them as unicode strings, hence the need to reencode them;
encodedPasswd = passwd.encode('utf8')
if bcrypt.checkpw(encodedPasswd,
checkedUser.pwHash.encode('utf8')):
return checkedUser
else:
return None
except DoesNotExist:
return None
class OlympiadCategory(db.Document):
created_at = db.DateTimeField(default=now(), required=True)
name = db.StringField(max_length=255, required=True)
abbreviation = db.StringField(max_length=10)
url = db.URLField()
events = db.ListField(db.EmbeddedDocumentField(Olympiad))
logo = None
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 Artist(db.Document):
name = db.StringField(unique=True, required = True)
email = db.EmailField(unique=True, required=True)
password = db.StringField(required=True)
bio = db.StringField()
link_to_work = db.StringField()
background_photo_path = db.StringField(unique=True)
profile_photo_path = db.StringField(unique=True)
admin = db.BooleanField(default=False)
active = db.BooleanField(default=True)
registered_on = db.DateTimeField(default=datetime.datetime.now())
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return self.id
def __repr__(self):
return '<Artist {0}>'.format(self.name)
class HackerProfile(db.EmbeddedDocument):
gender = db.StringField()
ethnicity = db.StringField()
pronouns = db.StringField()
school = db.StringField()
expected_graduation = db.DateTimeField()
why_attend = db.StringField(max_length=200)
what_learn = db.StringField(max_length=200)
will_need_travel = db.BooleanField()
class ArtInformation(db.Document):
name = db.StringField(required=True)
description = db.StringField()
file_name=db.StringField()
file_URI = db.StringField()
watermarked_URI = db.StringField()
for_sale = db.BooleanField(default=False)
file_type = db.StringField()
date_created = db.DateTimeField(default=datetime.datetime.now())
class User(db.Document, UserMixin):
created_at = db.DateTimeField(default=now(), required=True)
nickname = db.StringField(max_length=255, required=True)
name = db.StringField(max_length=255, required=True)
surname = db.StringField(max_length=255, required=True)
dob = db.DateTimeField()
#contests = [db.ReferenceField(Olympiad)]
medals = None
password_hash = db.StringField(max_length=255, required=True)
google_login = None
photo = db.ImageField(thumbnail_size=(32, 32, True))
#thumbnail = db.FileField()
def get(userid):
try:
u = User.objects.get(id=userid)
except:
u = None
return u
class User(db.Document):
firstName = db.StringField(default=None)
lastName = db.StringField(default=None)
username = db.StringField(unique=True)
email = db.EmailField(unique=True)
password = db.StringField()
phone = db.StringField(max_length=12)
gender = db.StringField(max_length=10)
branch = db.StringField(max_length=10)
year = db.StringField(max_length=10)
newUser = db.BooleanField(default=True)
about = db.EmbeddedDocumentField(About, default=About)
settings = db.EmbeddedDocumentField(Settings, default=Settings)
# connections = db.ListField(db.ReferenceField(User))
image_file = db.ImageField()
cover_img = db.StringField()
createdAt = db.DateTimeField(
default=datetime.utcnow) # utc to keep it universal
updatedAt = db.DateTimeField(default=datetime.utcnow)
def __repr__(self):
return f"User('{self.username}','{self.email}')"
class User(db.Document):
username = db.StringField(unique=True, required = True)
email = db.EmailField(unique=True, required=True)
address = db.StringField(unique=True, required = True)
password = db.StringField()
admin = db.BooleanField(default=False)
active = db.BooleanField(default=True)
registered_on = db.DateTimeField(default=datetime.datetime.now())
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return self.id
def __repr__(self):
return '<User {0}>'.format(self.username)
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 City(db.Document):
created_at = db.DateTimeField(default=now(), required=True)
name = db.StringField(max_length=255, required=True)
country = db.StringField(max_length=255, required=True)
position = db.GeoPointField()
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 Admin(db.Document):
created_at = db.DateTimeField(default=now(), required=True)
user = db.ReferenceField(User)
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 Article(db.Document):
'''A document that represents an article extracted from a feed'''
source_url = db.URLField(verify_exists=True, unique=True)
feed_id = db.ObjectIdField()
features = db.EmbeddedDocumentField('Features')
readers = db.ListField(db.EmbeddedDocumentField('Reader'))
interested_users = db.ListField(db.ObjectIdField())
uninterested_users = db.ListField(db.ObjectIdField())
time_stamp = db.DateTimeField(default=datetime.datetime.now())
def get_words_in_article(self):
'''
Arguments : URL
Function: Gets the article only version of the URL using Instapaper.
Extracts the text in the artcile and removes any non AlphaNumeric characters in the text
Returns a list of words in the article present in the URL.'''
#get article content from instapaper
html_data = BeautifulSoup(
urllib.urlopen("http://www.instapaper.com/m?%s" %
urllib.urlencode({'u': self.source_url})).read())
html_data = html_data.find("body")
content = html_data.findAll(
text=True
) #setting text to True to extract only the text in the <body>
word_list = []
for word in content[
30:]: #Removing redundant content from Instapaper Mobilizer headers
for w in word.split(
" "): #splitting on spcae for multiword strings
wd = (multiword_string_pattern.sub('', w.lower())
) #substituing non alphanumeric characters with ''
if len(wd) > 1:
word_list.append(
wd) #exclude strings of less than 2 characters
filtered_words = [
w for w in word_list
if not w in nltk.corpus.stopwords.words('english')
]
return dict((word, True) for word in word_list)
def get_words_in_title(self):
"Get words in the title of an article"
word_list = []
for w in self.features.title.split(" "):
wd = (multiword_string_pattern.sub('', w.lower()))
if len(wd) > 1: word_list.append(wd)
filtered_words = [
w for w in word_list
if w not in nltk.corpus.stopwords.words('english')
]
return dict((word, True) for word in filtered_words)
def get_score(self, classifier_object):
"Use the trained classifier to find the interest for the new article"
if classifier_object is None:
return 0.5
classifier = pickle.loads(str(classifier_object))
if classifier.classify(self.get_words_in_title()) is True:
return 1
else:
return 0
def get_readers_from(self):
'''
creates a list of reader objects for an article
from a list of feed subscribers
'''
subscribers = []
feed_subscribers = User.objects(subscriptions__feed_id=self.feed_id)
for feed_subscriber in feed_subscribers:
classifier_object = None
for subscription in feed_subscriber.subscriptions:
if subscription.feed_id == self.feed_id:
classifier_object = subscription.classifier_object
new_reader = Reader(\
user_id = feed_subscriber.id \
, score = self.get_score(classifier_object)
) #Set the scores for each user who has not yet read the article
subscribers.append(new_reader)
return subscribers
def get_article_snippet(self, article, max_length=128):
'''
Returns the article snippet to be show next to the article title.
'''
#Make sure char_length a int parameter.
if (type(max_length) is not int):
max_length = 128
html_data = BeautifulSoup(article)
#Join the words from the html content.
words = ''.join(html_data.findAll(text=True))
if len(article) < max_length:
return words + '...'
else:
return words[:max_length] + '...'
