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 About(db.EmbeddedDocument):
bio = db.StringField(default="Hey, I'm using HBTU Connect")
birthday = db.StringField(default=None)
hostel = db.StringField(default=None)
homeTown = db.StringField(default=None)
school = db.StringField(default=None)
socialHandles = db.DictField(default=None)
class Hacker(db.Document):
first_name = db.StringField()
last_name = db.StringField()
username = db.StringField(unique=True)
password = db.StringField()
email = db.EmailField(unique=True)
phone_number = db.StringField(validation=validate_phone_number)
profile = db.EmbeddedDocumentField(HackerProfile)
resume = db.URLField()
emergency_contact = db.EmbeddedDocumentField(HackerEmergencyContact)
accepted_forms = db.BooleanField()
active_participant = db.BooleanField()
def to_json(self):
return {
"first_name": self.first_name,
"last_name": self.last_name,
"username": self.username,
"password": self.password,
"email": self.email,
"phone_number": self.phone_number,
"profile": self.profile,
"resume": self.resume,
"emergency_contact": self.emergency_contact,
"accepted_forms": self.accepted_forms,
"active_participant": self.active_participant
}
class Resource(db.Document):
rid = db.IntField(unique=True)
title = db.StringField()
link = db.StringField()
tags = db.ListField(db.EmbeddedDocumentField('Tags'))
description = db.StringField()
def __unicode__(self):
return str(self.rid)
def get_dict(self):
return {
'rid': self.rid,
'title': self.title,
'link': self.link,
'tags': self.tags,
'description': self.description
}
def __repr__(self):
return 'rid ' + str(self.rid)
def save(self, *args, **kwargs):
if self.rid == None:
try:
self.rid = self.__class__.objects.order_by('-rid')[0].rid + 1
except IndexError:
self.rid = Resource.objects.count() + 1
super(Resource, self).save(*args, **kwargs)
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 Question(db.EmbeddedDocument):
body = db.ListField()
title = db.StringField()
tags = db.ListField()
comments = db.ListField()
upvotes = db.StringField()
stars = db.ListField()
views = db.StringField()
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 User(db.Document, UserMixin):
'''
A class that represents users who will use this system, their subscriptions
and is used to manage their sessions
'''
name = db.StringField(required=True)
email = db.EmailField(required=True, unique=True)
password_hash = db.StringField(max_length=160)
subscriptions = db.ListField(db.EmbeddedDocumentField(Subscription))
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 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 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 User(db.Document):
email = db.EmailField(required=True, unique=True)
password = db.StringField(required=True, min_length=6)
def hash_password(self):
self.password = generate_password_hash(self.password).decode('utf8')
def check_password(self, password):
return check_password_hash(self.password, password)
class Tags(db.EmbeddedDocument):
tag_name = db.StringField()
def __unicode__(self):
return str(self.tag_name)
def get_dict(self):
return {'tag_name': self.tag_name}
def __repr__(self):
return 'tag_name ' + str(self.tag_name)
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 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 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 User(db.Document):
first_name = db.StringField()
last_name = db.StringField()
username = db.StringField(unique=True)
password = db.StringField()
email = db.EmailField(unique=True)
role = db.StringField(choices=UserRole)
@staticmethod
def findOne(*args, **kwargs):
"""Finds one User"""
excludes = kwargs.pop("excludes", [])
return User.objects(*args, **kwargs).exclude("id", *excludes).first()
def encode_auth_token(self) -> str:
"""Generates the auth token"""
expires_at = datetime.utcnow() + timedelta(
days=current_app.config["TOKEN_EXPIRATION_DAYS"],
seconds=current_app.config["TOKEN_EXPIRATION_SECONDS"])
payload = {
"exp": expires_at,
"iat": datetime.utcnow(),
"sub": self.username
}
return jwt.encode(payload,
current_app.config.get("SECRET_KEY", "vivalapluto"),
algorithm="HS256"), expires_at
@staticmethod
def decode_auth_token(auth_token):
"""Decodes the auth token"""
try:
payload = jwt.decode(auth_token,
current_app.config.get("SECRET_KEY"))
return payload["sub"]
except jwt.ExpiredSignatureError:
return Forbidden()
except jwt.InvalidTokenError:
return Forbidden()
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 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 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):
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 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 Subscription(db.EmbeddedDocument):
'''
TODO: need to add other fields for storing classifier
'''
feed_id = db.ObjectIdField(required=True)
classifier_object = db.StringField()
class Features(db.EmbeddedDocument):
'''An embedded document that represents the features of an article'''
title = db.StringField(required=True)
article_words = db.DictField()
content_snippet = db.StringField()
class JWTBlacklist(db.Document):
jti = db.StringField()
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 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 Auction(db.Document):
initial_price = db.FloatField()
max_time = db.FloatField()
id_for_painting = db.StringField()
bidders = db.ListField()
