class Module(db.Model): __tablename__ = 'Modules' id = db.Column(db.Integer, primary_key=True) ticketInclude = db.Column(db.Boolean, default=False) paymentInclude = db.Column(db.Boolean, default=False) donationInclude = db.Column(db.Boolean, default=False) def __init__(self, ticketInclude=True, paymentInclude=True, donationInclude=True): self.id = 1 self.donationInclude = donationInclude self.paymentInclude = paymentInclude self.ticketInclude = ticketInclude @classmethod def set_default(cls): if len(Module.query.filter_by(id=1).all()) == 0: db.session.add(Module()) db.session.commit() else: print('Module already created') def save_to_db(self): db.session.add(self) try: db.session.commit() except Exception as e: db.session.rollback() db.session.flush() print(e)
class Admin(db.Model): __tablename__ = 'Admin' id = db.Column(db.String(100), primary_key=True) username = db.Column(db.String(80)) password = db.Column(db.String(100)) email = db.Column(db.String(100)) photoURL = db.Column(db.String()) def __init__(self, id_, username, password, email, photoURL=None): self.id = id_ self.username = username if password: self.password = generate_password_hash(password) self.email = email if photoURL: self.photoURL = photoURL else: self.photoURL = 'Some default asset' def save_to_db(self): db.session.add(self) try: db.session.commit() except Exception as e: db.session.rollback() db.session.flush() print(e) @classmethod def getAdmin(cls, admin_id=None, username=None): if username is None: return cls.query.filter_by(id=admin_id).first() if admin_id is None: return cls.query.filter_by(username=username).first()
class MessageModel(db.Model): __tablename__ = "messages" id = db.Column(db.Integer, primary_key=True) message = db.Column(db.String(140)) sender_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False) recipient_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False) recipient = db.relationship("UserModel", foreign_keys=[recipient_id]) sender = db.relationship("UserModel", foreign_keys=[sender_id]) def save_to_db(self): db.session.add(self) db.session.commit() def json(self): return { "id": self.id, "message": self.message, "sender_id": self.sender_id, "recipient_id": self.recipient_id, } @classmethod def find_recent_from(cls, recipient_id, sender_id): return (cls.query.filter_by( sender_id=sender_id, recipient_id=recipient_id).limit(100).all()) @classmethod def find_recent(cls, recipient_id): return cls.query.filter_by(recipient_id=recipient_id).limit(100).all()
class Pigment(Model, db.Model): __tablename__ = 'pigments' id = db.Column(db.Integer, db.Sequence('pigments_id_seq'), primary_key=True) spectrum = db.Column(db.ARRAY(db.Float)) name = db.Column(db.String) def color(self): return Color(self.spectrum, 1, self.name) def short_dict(self): return { 'id': self.id, 'rgb': self.color().to_rgb(), 'hex': self.color().to_hex(), 'name': self.name, 'url': route_for('pigment', pigment_id=self.id) } def full_dict(self): return { 'id': self.id, 'rgb': self.color().to_rgb(), 'hex': self.color().to_hex(), 'name': self.name, 'spectrum': self.spectrum, 'url': route_for('pigment', pigment_id=self.id) }
class Permissions(db.Model): __tablename__ = 'Permissions' id = db.Column(db.String(100), primary_key=True) isUser = db.Column(db.Boolean, default=False) isAdmin = db.Column(db.Boolean, default=False) isSales = db.Column(db.Boolean, default=False) user_id = db.Column(db.String(100), db.ForeignKey('User.id', ondelete='CASCADE')) def save_to_db(self): self.id = str(uuid.uuid4()) db.session.add(self) try: db.session.commit() except Exception as e: db.session.rollback() db.session.flush() print(e) @classmethod def getPermissions(cls, permissions_id): return cls.query.filter_by(id=permissions_id).first() @classmethod def get_by_uid(cls, uid=None): return cls.query.filter_by(user_id=uid).first()
class DocumentTags(db.Model): id = db.Column(db.Integer, primary_key=True) itemId = db.Column(db.Integer, db.ForeignKey("documents.itemId")) tagId = db.Column(db.Integer, db.ForeignKey("tags.tagId")) def serialize(self): tag = Tag.query.get(self.tagId) return tag.to_dict()
class CategoryModel(db.Model, CRUDMixin): __tablename__ = "api_category" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80), nullable=False) def __repr__(self): return '<id {}>'.format(self.id)
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(255), unique=True) password = db.Column(db.String(255)) active = db.Column(db.Boolean()) confirmed_at = db.Column(db.DateTime()) roles = db.relationship("Role", secondary=roles_users, backref=db.backref("users", lazy="dynamic"))
class ArticleModel(db.Model, CRUDMixin): __tablename__ = 'api_article' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80), nullable=False) description = db.Column(db.Text) categories = db.relationship('CategoryModel', secondary=api_category_article, lazy='subquery', backref=db.backref('articles', lazy=True)) def __repr__(self): return '<id {}>'.format(self.id)
class Committee(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String) posts = db.relationship("CommitteePost", back_populates="committee") events = db.relationship("Event", back_populates="committee") logo = db.Column(db.String) description = db.Column(db.String) facebook_url = db.Column(db.String) instagram_url = db.Column(db.String) page_id = db.Column(db.Integer, db.ForeignKey("page.id")) page = db.relationship("Page", back_populates="committee") category_id = db.Column(db.Integer, db.ForeignKey('CommitteeCategory.id')) category = db.relationship("CommitteeCategory") def to_dict(self): posts = [post.to_dict() for post in self.posts] events = [event.to_dict() for event in self.events] if self.page != None: page = self.page.to_dict() else: page = None return { "id": self.id, "name": self.name, "posts": sorted(posts, key=lambda p: p["weight"], reverse=True), "logo": self.logo, "description": self.description, "facebookUrl": self.facebook_url if not RECEPTION_MODE else None, "instagramUrl": self.instagram_url if not RECEPTION_MODE else None, "page": page, "events": events, } def to_dict_without_page(self): posts = [post.to_dict() for post in self.posts] events = [event.to_dict() for event in self.events] return { "id": self.id, "name": self.name, "posts": sorted(posts, key=lambda p: p["weight"], reverse=True), "logo": self.logo, "description": self.description, "facebookUrl": self.facebook_url if not RECEPTION_MODE else None, "instagramUrl": self.instagram_url if not RECEPTION_MODE else None, "events": events, } def to_basic_dict(self): return { "id": self.id, "name": self.name, "logo": self.logo, "description": self.description, "facebookUrl": self.facebook_url if not RECEPTION_MODE else None, "instagramUrl": self.instagram_url if not RECEPTION_MODE else None, "pageSlug": self.page.slug if self.page else None }
class User(db.Model): __tablename__ = 'user' id = db.Column(Integer, primary_key=True) username = db.Column(String(64), unique=False, nullable=False) password = db.Column(String(255), unique=False, nullable=False) def __init__(self, username=None, password=None): self.username = username self.password = password def __repr__(self): return 'User(id = {0}, username = {1})'.format(self.id, self.username) def as_dict(self): return {c.name: getattr(self, c.name) for c in self.__table__.columns}
class Utilities(db.Model): __tablename__ = 'Utilities' id = db.Column(db.String(100), primary_key=True) pricing = db.Column(db.Float) def save_to_db(self): self.id = str(uuid.uuid4()) db.session.add(self) try: db.session.commit() except Exception as e: db.session.rollback() db.session.flush() print(e)
class CommitteeCategory(db.Model): __tablename__ = 'CommitteeCategory' id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String, nullable=False, unique=True) email = db.Column(db.String, nullable=True) weight = db.Column(db.Integer, default=1) committees = db.relationship("Committee") def to_dict(self): return { "id": self.id, "title": self.title, "email": self.email, "weight": self.weight }
class Settings(db.Model): __tablename__ = 'Settings' environment = ['Development', 'Production', 'Staging'] id = db.Column(db.DateTime, default=datetime.datetime.utcnow, primary_key=True) appEnvironment = db.Column(db.Integer, nullable=False) appName = db.Column(db.String, default='Badgeyay', nullable=False) secretKey = db.Column(db.String, nullable=False) # Firebase config firebaseStorageBucket = db.Column(db.String, nullable=False) firebaseDatabaseURL = db.Column(db.String, nullable=False) # Email settings fromMail = db.Column(db.String, default="*****@*****.**") # Send Grid config sendGridApiKey = db.Column(db.String) def __init__(self, appEnvironment, appName, secretKey, firebaseDatabaseURL, firebaseStorageBucket, **kwargs): self.appEnvironment = appEnvironment self.appName = appName self.secretKey = secretKey self.firebaseStorageBucket = firebaseStorageBucket self.firebaseDatabaseURL = firebaseDatabaseURL if 'fromMail' in kwargs.keys(): self.fromMail = kwargs['fromMail'] if 'sendGridApiKey' in kwargs.keys(): self.sendGridApiKey = kwargs['sendGridApiKey'] def save_to_db(self): try: db.session.add(self) db.session.commit() except Exception as e: print(e) db.session.rollback() db.session.flush() @staticmethod def init_setup(): if len(Settings.query.all()) == 0: settings = Settings(0, 'Badgeyay', config.POSTGRES['secret'], 'https://badgeyay-195bf.firebaseio.com', 'badgeyay-195bf.appspot.com') settings.save_to_db() else: settings = Settings.latest_settings() return settings @staticmethod def latest_settings(): return Settings.query.order_by(Settings.id.desc()).first()
class Tag(db.Model): __tablename__ = "tags" tagId = db.Column(db.Integer, primary_key=True) title = db.Column(db.String) title_en = db.Column(db.String) def to_dict(self): return { "id": self.tagId, "title": { "se": self.title, "en": self.title_en } } def __repr__(self): return "Tag with title %s and id %s" % (self.title, self.tagId)
class Review(db.Model): """Class to create a Review class object""" __tablename__ = 'reviews' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(50), unique=True, nullable=False) description = db.Column(db.String(256), nullable=False) business = db.Column(db.Integer, db.ForeignKey('businesses.id')) created_by = db.Column(db.Integer, db.ForeignKey('users.id')) created_at = db.Column(db.DateTime, default=db.func.current_timestamp()) updated_at = db.Column(db.DateTime, default=db.func.current_timestamp( ), onupdate=db.func.current_timestamp()) author = db.relationship("User") def __init__(self, name, description, business): self.name = name self.description = description self.business = business self.created_by = session["user_id"] def __repr__(self): return '<Review: {}>'.format(self.name) def review_as_dict(self): """Represent the review as a dict""" review = {r.name: getattr(self, r.name) for r in self.__table__.columns} review['author'] = self.author.first_name + ' ' + self.author.last_name return review
class User(UserMixin, db.Model): """Class to create a User class object""" __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True, autoincrement=True) first_name = db.Column(db.String(50), nullable=False) last_name = db.Column(db.String(50), nullable=False) username = db.Column(db.String(50), nullable=False, unique=True) password_hash = db.Column(db.String(256), nullable=False) created_at = db.Column(db.DateTime, default=db.func.current_timestamp()) updated_at = db.Column(db.DateTime, default=db.func.current_timestamp(), onupdate=db.func.current_timestamp()) businesses = db.relationship('Business', order_by='Business.id', cascade='all, delete-orphan') def __init__(self, first_name, last_name, username, password): self.first_name = first_name self.last_name = last_name self.username = username self.password_hash = generate_password_hash(password) def __repr__(self): return '<User: {}>'.format(self.username) def user_as_dict(self): """Represent the user as a dict""" return {u.name: getattr(self, u.name) for u in self.__table__.columns}
class File(db.Model): __tablename__ = 'File' id = db.Column(db.String(100)) filename = db.Column(db.String(100), nullable=False, primary_key=True) filetype = db.Column(db.String(100), nullable=False) user_id = db.Column(db.String(100), db.ForeignKey('User.id', ondelete='CASCADE')) def save_to_db(self): self.id = str(uuid.uuid4()) db.session.add(self) try: db.session.commit() except Exception as e: db.session.rollback() db.session.flush() print(e)
class UserModel(db.Model): __tablename__ = "users" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80)) @classmethod def find_all(cls): return cls.query.all() @classmethod def find_by_id(cls, user_id): return cls.query.get(user_id) def save_to_db(self): db.session.add(self) db.session.commit() def json(self): return {"id": self.id, "name": self.name}
class CommitteePostTerm(db.Model): __tablename__ = "committee_post_term" id = db.Column(db.Integer, primary_key=True) post_id = db.Column(db.Integer, db.ForeignKey('committee_post.id')) post = db.relationship("CommitteePost", back_populates="terms") start_date = db.Column(db.DateTime) end_date = db.Column(db.DateTime) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) user = db.relationship("User", back_populates="post_terms") def to_dict(self): return { "id": self.id, "startDate": self.start_date.strftime("%Y-%m-%d"), "endDate": self.end_date.strftime("%Y-%m-%d"), "post": self.post.to_dict_without_terms(), "user": self.user.to_dict_without_terms(), "isCurrent": self.start_date < datetime.now() < self.end_date }
class ResetPasswordToken(db.Model): __tablename__ = 'Reset Password Token' id = db.Column(db.String, primary_key=True) token = db.Column(db.String, nullable=False) def __init__(self, uid, token): self.id = uid self.token = token def save_to_db(self): try: db.session.add(self) db.session.commit() except Exception as e: db.session.rollback() db.session.flush() print(e)
class SocialContent(db.Model): __tablename__ = 'SocialContent' name = db.Column(db.String, primary_key=True) description = db.Column(db.String, nullable=False) link = db.Column(db.String, nullable=False) icon = db.Column(db.String, nullable=False) # Semantic ui class for the icon of media def __init__(self, name, description, link, icon): self.name = name.lower() self.description = description self.link = link self.icon = icon def save_to_db(self): db.session.add(self) try: db.session.commit() except Exception as e: db.session.rollback() db.session.flush() print(e) @classmethod def populate_initial(cls): if not SocialContent.check_key('github'): db.session.add( SocialContent('github', 'Social network for developers', 'https://github.com/fossasia/badgeyay', 'github icon')) db.session.commit() if not SocialContent.check_key('twitter'): db.session.add( SocialContent('twitter', 'Online news and social networking service', 'https://twitter.com/badgeyay', 'twitter icon')) db.session.commit() @staticmethod def check_key(key): return SocialContent.query.filter_by(name=key.lower()).first()
class Blacklist(db.Model): """Class for blacklisted tokens""" __tablename__ = 'blacklists' id = db.Column(db.Integer, primary_key=True, autoincrement=True) token = db.Column(db.String(500), unique=True, nullable=False) created_at = db.Column(db.DateTime, default=db.func.current_timestamp()) def __init__(self, token): self.token = token # Represent the object when it is queried def __repr__(self): return '<Token: {}>'.format(self.token) def token_as_dict(self): """Represent the token as a dict""" return {t.name: getattr(self, t.name) for t in self.__table__.columns}
class Business(db.Model): """Class to create a Business class object""" __tablename__ = 'businesses' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(50), unique=True, nullable=False) description = db.Column(db.String(256), nullable=False) category = db.Column(db.Integer, db.ForeignKey('categories.id')) location = db.Column(db.Integer, db.ForeignKey('locations.id')) photo = db.Column(db.String(256)) created_by = db.Column(db.Integer, db.ForeignKey('users.id')) created_at = db.Column(db.DateTime, default=db.func.current_timestamp()) updated_at = db.Column(db.DateTime, default=db.func.current_timestamp(), onupdate=db.func.current_timestamp()) reviews = db.relationship('Review', order_by='Review.id', cascade='all, delete-orphan') author = db.relationship("User") category_relationship = db.relationship("Category") location_relationship = db.relationship("Location") def __init__(self, name, description, category, location, photo): self.name = name self.description = description self.category = category self.location = location self.photo = photo self.created_by = session["user_id"] def __repr__(self): return '<Business: {}>'.format(self.name) def business_as_dict(self): """Represent the business as a dict""" business = { b.name: getattr(self, b.name) for b in self.__table__.columns } business[ 'author'] = self.author.first_name + ' ' + self.author.last_name business['category_name'] = self.category_relationship.name business['location_name'] = self.location_relationship.name return business
class Log(db.Model): """Class for database changes logs""" __tablename__ = 'logs' id = db.Column(db.Integer, primary_key=True, autoincrement=True) action = db.Column(db.String(50), nullable=False) message = db.Column(db.String(256), nullable=False) table = db.Column(db.String(50), nullable=False) created_by = db.Column(db.Integer, db.ForeignKey('users.id')) created_at = db.Column(db.DateTime, default=db.func.current_timestamp()) author = db.relationship("User") def __init__(self, action, message, table, user_id): self.action = action self.message = message self.table = table self.created_by = user_id def __repr__(self): return '<Log: {}>'.format(self.message) def log_as_dict(self): """Represent the log as a dict""" log = {l.name: getattr(self, l.name) for l in self.__table__.columns} log['author'] = self.author.first_name + ' ' + self.author.last_name return log
class Category(db.Model): """Class to create a Category class object""" __tablename__ = 'categories' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(50), unique=True, nullable=False) description = db.Column(db.String(256), nullable=False) created_by = db.Column(db.Integer, db.ForeignKey('users.id')) created_at = db.Column(db.DateTime, default=db.func.current_timestamp()) updated_at = db.Column(db.DateTime, default=db.func.current_timestamp(), onupdate=db.func.current_timestamp()) author = db.relationship("User") def __init__(self, name, description): self.name = name self.description = description self.created_by = session["user_id"] def __repr__(self): return '<Category: {}>'.format(self.name) def category_as_dict(self): """Represent the category as a dict""" category = { c.name: getattr(self, c.name) for c in self.__table__.columns } category[ 'author'] = self.author.first_name + ' ' + self.author.last_name return category
class User(db.Model): """Class to create a User class object""" __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True, autoincrement=True) first_name = db.Column(db.String(50), nullable=False) last_name = db.Column(db.String(50), nullable=False) username = db.Column(db.String(50), nullable=False, unique=True) created_at = db.Column(db.DateTime, default=db.func.current_timestamp()) updated_at = db.Column(db.DateTime, default=db.func.current_timestamp( ), onupdate=db.func.current_timestamp()) def __init__(self, first_name, last_name, username): self.first_name = first_name self.last_name = last_name self.username = username def __repr__(self): return '<User: {}>'.format(self.username) def user_as_dict(self): """Represent the user as a dict""" return {u.name: getattr(self, u.name) for u in self.__table__.columns}
class Note(db.Model): __tablename__ = 'note' id = db.Column(Integer, primary_key=True) author_id = db.Column(Integer, unique=False, nullable=False) root_note_id = db.Column(Integer, unique=False, nullable=True) created = db.Column(DateTime, unique=False, nullable=False, server_default=current_timestamp()) updated = db.Column(DateTime, unique=False, nullable=False, server_default=current_timestamp()) kind = db.Column(Integer, unique=False, nullable=False) sentence = db.Column(Text, unique=False, nullable=False) def __init__(self, author_id=None, root_note_id=None, created=None, updated=None, kind=None, sentence=None): self.author_id = author_id self.root_note_id = root_note_id self.created = created self.updated = updated self.kind = kind self.sentence = sentence def __repr__(self): return ('Note(id = {0}, author_id = {1}, root_note_id = {2}, '\ 'created = {3}, updated = {4}, kind = {5}, sentence ={6})' .format( self.id, self.author_id, self.root_note_id, self.created, self.updated, self.kind, self.sentence )) def as_dict(self): return {c.name: getattr(self, c.name) for c in self.__table__.columns}
class Stripe(db.Model): __tablename__ = 'Stripe' id = db.Column(db.Integer, primary_key=True) stripe_secret_key = db.Column(db.String) stripe_refresh_token = db.Column(db.String) stripe_publishable_key = db.Column(db.String) stripe_user_id = db.Column(db.String) stripe_auth_code = db.Column(db.String) amount = db.Column(db.String) currency = db.Column(db.String) def __init__(self, stripe_secret_key=None, stripe_refresh_token=None, stripe_publishable_key=None, stripe_user_id=None, stripe_auth_code=None, amount=None, currency=None): self.stripe_secret_key = stripe_secret_key self.stripe_refresh_token = stripe_refresh_token self.stripe_publishable_key = stripe_publishable_key self.stripe_user_id = stripe_user_id self.stripe_auth_code = stripe_auth_code self.amount = amount self.currency = currency def save_to_db(self): db.session.add(self) try: db.session.commit() except Exception as e: db.session.rollback() db.session.flush() print(e)
class Image(db.Model): __tablename__ = "images" imageId = db.Column(db.Integer, primary_key=True) url = db.Column(db.String) photographer = db.Column( db.String) #TODO: reformat to foreignKey linked to user date = db.Column(db.DateTime, default=datetime.datetime.now) needsCred = db.Column(db.Boolean) editingAllowed = db.Column(db.Boolean) def to_dict(self): return { "id": self.imageId, "url": self.url, "photographer": self.photographer, "date": self.date, "needsCrediting": self.needsCred, "editingAllowed": self.editingAllowed }