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()