class Listing(db.Model): # Columns type = db.Column( db.Enum(ListingTypes), nullable=False, primary_key=True ) user_id = db.Column( db.Integer, db.ForeignKey('user.id'), nullable=False, primary_key=True ) message_id = db.Column( db.Integer, db.ForeignKey('message.id'), nullable=False, primary_key=True ) # Relations user = db.relationship( "User", foreign_keys=user_id, backref='listings' ) message = db.relationship( "Message", foreign_keys=message_id, backref='listings' )
class User(BaseMixin, db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80), unique=True) email = db.Column(db.String(80), unique=True, nullable=False) active = db.Column(db.Boolean, default=True) _password_hash = db.Column(db.String(), nullable=False) # Relationships todos = db.relationship('Todo', backref='user', lazy='dynamic') todo_lists = db.relationship('TodoList', backref='user', lazy='dynamic') @property def is_active(self): return self.active @property def is_authenticated(self): return self.authenticated @property def is_anonymous(self): return False @property def password(self): return self._password_hash.encode('UTF-8') @password.setter def password(self, password): self._password_hash = bcrypt.hashpw(password.encode('UTF-8'), bcrypt.gensalt()) def verify_password(self, password): return bcrypt.hashpw(password.encode('UTF-8'), self.password) == self.password def get_id(self): return self.id @staticmethod def authenticate(username, password): if username and password: user = User.query.filter_by(username=username).first() if user is None: user = DummyUser() if user.verify_password(password): return user @staticmethod def identity(payload): username = payload['identity'] return User.query.filter_by(username=username).first() def __init__(self, username, email, password): self.username = username self.email = email self.password = password def __repr__(self): return "<User: {}>".format(self.username)
class WaitingList(db.Model): waiting_id = db.Column(db.Integer, primary_key=True) approval = db.Column(db.Boolean, nullable=True) method = db.Column(db.String) date = db.Column(db.DateTime, default=datetime.datetime.today) request_Date = db.Column(db.DateTime, nullable=True) borrower = db.Column(db.Integer, db.ForeignKey('user.id')) price = db.Column(db.Integer, nullable=True) price_rate = db.Column(db.Integer, nullable=True) owner_shelf_id = db.Column(db.Integer, db.ForeignKey('bookshelf.bookshelf_id')) bookid = db.Column(db.Integer, db.ForeignKey('books.book_id')) user = db.relationship('User', backref='waitingUsers') bookshelf = db.relationship('Bookshelf', backref='waitingBookshelf') def __init__(self, borrower='', owner_shelf_id='', price='', price_rate='', approval='', method='', bookid='', request_Date=''): self.borrower = borrower self.owner_shelf_id = owner_shelf_id self.approval = approval self.price_rate = price_rate self.price = price self.bookid = bookid self.method = method self.request_Date = request_Date
class Tournament(db.Model): __tablename__ = 'tournaments' id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) tournament_title = db.Column(db.String(300), nullable=False) created_at = db.Column(db.DateTime, default=datetime.utcnow) is_completed = db.Column(db.Boolean, default=False) players = db.relationship('TournamentPlayers', backref='players', lazy='dynamic') matches = db.relationship('Matches', backref='match_round', lazy='dynamic') def __repr__(self): return '<Tournament {}>'.format(self.tournament_title) # sets the tournament completation status. Should pretty much be true as false is default def set_isCompleted(self, isCompleted): self.is_completed = isCompleted def to_dict(self): return dict(id=self.id, userID=self.user_id, tournament_title=self.tournament_title, players=[player.to_dict() for player in self.players], match=[match.to_dict() for match in self.matches], tournamentCompleted=self.is_completed)
class Fund(db.Model): __tablename__ = 'fund' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(128), nullable=False, unique=True) date = db.Column(db.DateTime, default=datetime.now(), nullable=False) # Establish One-to-Many relationship committments = db.relationship( 'Committment', backref='fund', lazy='dynamic' ) # Establish Many-to-Many relationship investments = db.relationship( 'Investment', secondary=FundInvestments, backref=db.backref('fund', lazy='dynamic') ) def __init__(self, name): self.name = name def to_json(self): return { 'id': self.id, 'name': self.name, 'date': self.date.strftime('%Y-%m-%d T%H:%M:%S.%f'), 'committments': [c.to_json() for c in self.committments], }
class BorrowsAssociation(db.Model): __tablename__ = 'borrows' borrowed = db.Column(db.Integer, primary_key=True) borrower = db.Column(db.Integer, db.ForeignKey('user.id')) owner_shelf_id = db.Column(db.Integer, db.ForeignKey('bookshelf.bookshelf_id')) bookid = db.Column(db.Integer, db.ForeignKey('books.book_id')) status = db.Column(db.String) startDate = db.Column(db.DateTime) returnDate = db.Column(db.DateTime) verification = db.Column(db.Boolean) user = db.relationship('User', backref='borrowBookshelfs') bookshelf = db.relationship('Bookshelf', backref='borrowUsers') def __init__(self, borrower='', owner_shelf_id='', status='', bookid='', verification='', startDate='', returnDate=''): self.borrower = borrower self.owner_shelf_id = owner_shelf_id self.status = status self.bookid = bookid self.verification = verification self.startDate = startDate self.returnDate = returnDate
class Client(db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(20), unique=True) id_phone = db.Column(db.Integer, db.ForeignKey('phone.id'), nullable=True) email = db.Column(db.String(50), unique=True) created = db.Column(db.DateTime) # cria uma propriedade # (não faz parte do banco de dados) records = db.relationship( 'Record', # backref='client': um jeito simples de declarar também uma nova propriedade na classe Record # haverá a propriedade record.client para Record backref='client', # Indica quando os dados serão carregados do banco de dados # o lazy='dynamic' retorna um objeto query que pode ser refinado antes de carregar items. lazy='dynamic') # cria uma propriedade que expressa um relacionamento um-para-um (uselist=False) phone = db.relationship('Phone', backref='client', uselist=False) groups = db.relationship('Group', secondary=clients_groups, backref=db.backref('members', lazy='dynamic')) def __init__(self, username, email): self.username = username self.email = email self.created = datetime.now()
class ContainsAssociation(db.Model): __tablename__ = 'contains' contains_id = db.Column(db.Integer, primary_key=True) quantity = db.Column(db.Integer) availability = db.Column(db.String(3)) methods = db.Column(db.String(50)) price = db.Column(db.Integer) date = db.Column(db.DateTime, default=datetime.datetime.today) shelf_id = db.Column(db.Integer, db.ForeignKey('bookshelf.bookshelf_id')) book_id = db.Column(db.Integer, db.ForeignKey('books.book_id')) rateBooks = db.relationship('BookRateAssociation', backref='books_rateBooks') commentBooks = db.relationship('BookCommentAssociation', backref='books_commentBooks') bookshelfcontain = db.relationship('Bookshelf', backref='containingbooks') containsbooks = db.relationship('Books', backref='booksBookshelf') def __init__(self, shelf_id='', book_id='', quantity='', availability='', methods='', price=''): self.shelf_id = shelf_id self.book_id = book_id self.quantity = quantity self.methods = methods self.price = price self.availability = availability
class User(db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(32), index=True, unique=True) email = db.Column(db.String(120), index=True, unique=True) password_hash = db.Column(db.String(128)) gardens = db.relationship('Garden', secondary=ownership, lazy='dynamic', backref=db.backref('owners', lazy='dynamic')) sensors = db.relationship('Sensor', backref='owner', lazy='dynamic') def set_password(self, password): self.password_hash = generate_password_hash(password) def check_password(self, password): return check_password_hash(self.password_hash, password) def generate_auth_token(self, expiration=600): s = Serializer(app.config['SECRET_KEY'], expires_in=expiration) return s.dumps({'id': self.id}) @staticmethod def verify_auth_token(token): s = Serializer(app.config['SECRET_KEY']) try: data = s.loads(token) except SignatureExpired: return None # Valid token but expired except BadSignature: return None # Invalid token user = User.query.get(data['id']) return user def __repr__(self): return '<User {}>'.format(self.username)
class Department(db.Model): __tablename__ = 'departments' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(50)) code = db.Column(db.String(3)) school_id = db.Column(db.Integer, db.ForeignKey('schools.id')) students = db.relationship('Student', backref='department') courses = db.relationship('Course', backref='department') lecturers = db.relationship('Lecturer', backref='department') hod = db.relationship('HOD', backref='department', uselist=False) def __init__(self, name=None, code=None, school_code=None): self.name = name self.code = code self.school = School.query.filter_by(code=school_code).first() @staticmethod def exists(department_code): return Department.query.filter_by(code=department_code).count() > 0 @property def to_dict(self): json_department = { 'code': self.code, 'fullname': self.name, 'school_code': self.school.code, 'school_fullname': self.school.name } return json_department def save(self): db.session.add(self) db.session.commit()
class InterestAssociation(db.Model): __tablename__ = 'hasInterest' interestId = db.Column(db.Integer, primary_key=True) user_Id = db.Column(db.Integer, db.ForeignKey('user.id')) genreId = db.Column(db.Integer, db.ForeignKey('genre.id_genre')) user = db.relationship('User', backref='Interestuser') genre = db.relationship('Genre', backref='Interestgenre')
class Post(db.AlchemyBase): __tablename__ = "post" id = db.Column(db.Integer, primary_key=True) entity_id = db.Column(db.Integer, nullable=False, index=True, unique=True) user_id = db.Column(db.Integer, db.ForeignKey(User.id), nullable=False) section_id = db.Column(db.Integer, db.ForeignKey(Section.id), nullable=False, index=True) title = db.Column(db.String(255), nullable=False) text = db.Column(db.Text) pin_teaser = db.Column(db.Text) is_pinned = db.Column(db.Boolean, nullable=False, default=False, index=True) is_deleted = db.Column(db.Boolean, nullable=False, default=False, index=True) is_moderated = db.Column(db.Boolean, nullable=False, default=False) is_legacy = db.Column(db.Boolean, nullable=False, default=False, index=True) original_title = db.Column(db.String(255)) original_text = db.Column(db.Text) moderation_notes = db.Column(db.Text) created = db.Column(db.DateTime, default=datetime.utcnow, index=True) modified = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow) user = db.relationship(User) section = db.relationship(Section)
class User(db.Model, UserMixin): # Columns id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80), nullable=False) password = db.Column(db.Text, nullable=False) # Relations inbox = db.relationship( "Message", secondary=Listing.__table__, primaryjoin= f"and_(Listing.type=='{ListingTypes.inbox.name}', Listing.user_id==User.id)", order_by="desc(Message.created_at)") outbox = db.relationship( "Message", secondary=Listing.__table__, primaryjoin= f"and_(Listing.type=='{ListingTypes.outbox.name}', Listing.user_id==User.id)", order_by="desc(Message.created_at)") # Methods """ Hash a password and set it as the user's password """ def set_password(self, password): self.password = generate_password_hash(password, method='sha256') """ Check if password matched the hashed password """ def check_password(self, password): return check_password_hash(self.password, password)
class Applicant(db.Model): __tablename__ = 'applicants' # The name of the column is the name you assign it to id = Column(Integer, primary_key=True) email = Column(String(100), unique=True, nullable=False) username = Column(String(100), default='Anonymous Giraffe') bio = Column(String(250)) first_name = Column(String(80)) last_name = Column(String(80)) created_at = Column(DateTime(timezone=True), nullable=False, default=datetime.now()) # One to Many Relationship: messages = db.relationship('Message', backref='applicant', lazy=True) # Many to Many Relationship: skills = db.relationship('Skill', secondary='applicant_skills', lazy='subquery') values = db.relationship('Value', secondary='applicant_values', lazy='subquery')
class User(db.Model): """ Contains information about the user """ __tablename__ = "users" id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(100), unique=True, nullable=False) mobile = db.Column(db.String(15), unique=True, nullable=True) firstname = db.Column(db.String(20), nullable=False) lastname = db.Column(db.String(20), nullable=False) password = db.Column(db.String(128), nullable=False) created = db.Column(db.DateTime, nullable=False, default=datetime.utcnow()) recipes = db.relationship("Recipe", backref="creator", lazy="dynamic") recipe_categories = db.relationship("RecipeCategory", backref="creator", lazy="dynamic") def __init__(self, email, fname, lname, password, mobile=None): """ User initializer """ self.email = email self.firstname = fname self.lastname = lname self.set_password(password) self.mobile = mobile def set_password(self, password): """ Sets user password to a new password""" self.password = generate_password_hash(password, method="pbkdf2:sha256") def verify_password(self, password): """ Checks if user supplied a correct password :param password: Password user has provided :return: True if password is correct false otherwise """ return check_password_hash(self.password, password) def save_user(self): """ saves the current user to the database""" db.session.add(self) db.session.commit() @property def user_details(self): """ Returns the user json representation """ user_details = { "id": self.id, "firstname": self.firstname, "lastname": self.lastname, "email": self.email, "mobile": self.mobile, "url": url_for("get_user", id=self.id, _external=True) } return user_details def __repr__(self): """ User object representation """ return f"<User {self.id} {self.firstname} {self.lastname}>"
class Facturas(db.Model): FacturaID = db.Column(db.Integer, primary_key=True) FechaPago = db.Column(db.DateTime, nullable=False) MetodoPago = db.Column(db.String(), nullable=False) Descripcion = db.Column(db.String(), nullable=False) ClienteID = db.Column(db.Integer(),db.ForeignKey('usuarios.ClienteID')) cliente_id = db.relationship('Usuarios',foreign_keys=ClienteID, backref='Facturas') ProductoID = db.Column(db.Integer(),db.ForeignKey('productos.ProductoID')) producto_id = db.relationship('Productos',foreign_keys=ProductoID, backref='Facturas')
class User(UserMixin, db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(64), index=True, unique=True) email = db.Column(db.String(120), index=True, unique=True) password_hash = db.Column(db.String(128)) about_me = db.Column(db.String(140)) last_seen = db.Column(db.DateTime, default=datetime.utcnow) posts = db.relationship('Entry', backref='author', lazy='dynamic') location_posts = db.relationship('Location', backref='author', lazy='dynamic') def __repr__(self): return '<User {}>'.format(self.username) def serialize(self): return { 'id': self.id, 'username': self.username, 'email': self.email, 'password_hash': 'private!', 'about_me': self.about_me, 'last_seen': self.last_seen } def set_password(self, password): self.password_hash = generate_password_hash(password) def check_password(self, password): return check_password_hash(self.password_hash, password) def avatar(self, size): digest = md5(self.email.lower().encode('utf-8')).hexdigest() return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format( digest, size) def get_reset_password_token(self, expires_in=600): return jwt.encode( { 'reset_password': self.id, 'exp': time() + expires_in }, app.config['SECRET_KEY'], algorithm='HS256') @staticmethod def verify_reset_password_token(token): try: id = jwt.decode(token, app.config['SECRET_KEY'], algorithms=['HS256'])['reset_password'] except: return return db.session.query(User).get(id)
class Business(db.Model): """""" __tablename__ = 'businesses' id = db.Column(db.Integer, primary_key=True, index=True) name = db.Column(db.String(100), nullable=False, unique=True) description = db.Column(db.Text, nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) location_id = db.Column(db.Integer, db.ForeignKey('locations.id')) categories = db.relationship('Category', secondary=business_category, lazy='subquery', backref=db.backref('businesses', lazy=True)) reviews = db.relationship('Review', backref='business', lazy=True) photo = db.Column(db.String(200)) created_at = db.Column(db.DateTime, default=datetime.utcnow()) updated_at = db.Column(db.DateTime, default=datetime.utcnow()) def create(self): db.session.add(self) db.session.commit() def update(self): db.session.commit() business = Business.query.get(self.id) result = { 'message': 'Business updated successfully.', 'code': 200, 'business': Business.get_business_details(business) } return result def delete(self): db.session.delete(self) db.session.commit() @staticmethod def get_business(id): business = Business.query.get(int(id)) return business @staticmethod def get_business_details(business): categories = [ Category.get_categories_details(c) for c in business.categories ] return {'id': business.id, 'name':business.name, 'description': business.description, 'userId':business.user_id, \ 'locationId':business.location_id, 'categories':categories, 'photo':business.photo} @staticmethod def get_businesses(): businesses = Business.query.all() return businesses def __repr__(self): """""" return '<Business : {0} >'.format(self.name)
class Genre(db.Model): __tablename__ = 'genre' id_genre = db.Column(db.Integer, primary_key=True) genre_name = db.Column(db.String, nullable=False, unique=True) genreBooks = db.relationship('HasGenreAssociation', backref='genres_books') genreInterest = db.relationship('InterestAssociation', backref='genre_interest') def __init__(self, genre_name=''): self.genre_name = genre_name
class User(db.Model, UserMixin): __tablename__ = "user" id = db.Column(db.Integer, primary_key=True, unique=True) username = db.Column(db.String(100), index=True, nullable=False) email = db.Column(db.String(100), index=True, nullable=False) password = db.Column(db.String(100), index=True, nullable=False) list = db.relationship('List', backref='user', lazy=True) cat = db.relationship('Category', backref='user', lazy=True) def __repr__(self): return f"<User(name='{self.username}')>"
class Product(db.Model): __tablename__ = 'products' id = db.Column(db.Integer, primary_key=True) image_url = db.Column(db.String(255)) price = db.Column(db.DECIMAL) title = db.Column(db.String(255)) description = db.Column(db.Text, default='') ingredients = db.relationship('Flower', secondary=product_flower, lazy='subquery', backref=db.backref('product', lazy=True)) categories = db.relationship('Category', secondary=product_category, lazy='subquery', backref=db.backref('products', lazy=True))
class HasGenreAssociation(db.Model): __tablename__ = 'hasGenre' genre_book_id = db.Column(db.Integer, primary_key=True) genreId = db.Column(db.Integer, db.ForeignKey('genre.id_genre')) bookId = db.Column(db.Integer, db.ForeignKey('books.book_id')) books = db.relationship('Books', backref='booksGenre') genre = db.relationship('Genre', backref='bookHasGenre') def __init__(self, bookId='', genreId=''): self.bookId = bookId self.genreId = genreId
class Section(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(70), index=True) description = db.Column(db.String(140)) garden_id = db.Column(db.Integer, db.ForeignKey('garden.id')) sensors = db.relationship('Sensor', backref='section', lazy='dynamic') schedule = db.relationship('Schedule', uselist=False, backref ='section') def __repr__(self): return '<Section {}>'.format(self.name)
class WrittenByAssociation(db.Model): __tablename__ = 'writtenBy' book_id = db.Column(db.Integer, db.ForeignKey('books.book_id'), primary_key=True) author_id = db.Column(db.Integer, db.ForeignKey('author.author_id')) author = db.relationship('Author', backref='author_writtenby') books = db.relationship('Books', backref='booksAuthor_writtenby') def __init__(self, author_id='', book_id=''): self.author_id = author_id self.book_id = book_id
class User(db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(20), unique=True, nullable=False) email = db.Column(db.String(100), unique=True, nullable=False) password = db.Column(db.String(20), nullable=False) last_seen = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) last_activity = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) posts = db.relationship('Post', backref='author', lazy=True) likes = db.relationship('Like', backref='likedby', lazy=True) def __repr__(self): return f"User: ('{self.username}', last_seen: '{self.last_seen}')"
class TodoList(db.Model): __tablename__ = 'todolist' id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(80)) todos = db.relationship("Todo", cascade="all,delete", back_populates="todolist") user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) user = db.relationship("User", back_populates="todolists") def __init__(self, user, title): self.user = user self.title = title
class Task(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(255), nullable=False) completed = db.Column(db.Boolean, nullable=False, default=False) created_at = db.Column(db.DateTime, default=datetime.utcnow) updated_at = db.Column(db.DateTime, onupdate=datetime.utcnow) planned_complete_date = db.Column(db.DateTime) completed_at = db.Column(db.DateTime) project_id = db.Column(db.Integer, db.ForeignKey('project.id'), nullable=False) comments = db.relationship('Comment', backref='task', lazy='dynamic') assignees = db.relationship('User', secondary=assignees_for_tasks, backref=db.backref('tasks', lazy='dynamic'), lazy='dynamic' ) def save(self): db.session.add(self) def delete(self): db.session.delete(self) @staticmethod def get_all(): return Task.query.all() def add_assignee(self, assignee): self.assignees.append(assignee) db.session.add(self) def remove_assignee(self, assignee): self.assignees.remove(assignee) db.session.add(self) def update_completed_state(self, old_task_completed): print("Self completed") print(self.completed) print("OG task completed") print(old_task_completed) if self.completed != old_task_completed: print("Got to first if") if self.completed: print("Got to second if") self.completed_at = datetime.utcnow() else: self.completed_at = None return self def __repr__(self): return f'<Task {self.name} | Created at {self.created_at} | {self.completed} | Completed at {self.completed_at}>'
class TrackOut(db.Model): ''' Database Generated Fields ''' id = db.Column(db.Integer, primary_key=True) track_id = db.Column(db.Integer, db.ForeignKey('track.uuid', ondelete='CASCADE')) created_at = db.Column(db.DateTime, default=datetime.utcnow) uuid = db.Column(db.String, default=generate_uuid) ''' Configurable Fields ''' user_id = db.Column(db.Integer) name = db.Column(db.String(1000)) type = db.Column(db.String(50)) settings = db.Column(db.String(1000)) eq = db.relationship("Equalizer", backref=db.backref("eq", passive_deletes=True), lazy='subquery', uselist=False) de = db.relationship("Deesser", backref=db.backref("de", passive_deletes=True), lazy='subquery', uselist=False) co = db.relationship("Compressor", backref=db.backref("co", passive_deletes=True), lazy='subquery', uselist=False) re = db.relationship("Reverb", backref=db.backref("re", passive_deletes=True), lazy='subquery', uselist=False) ''' Wav File Representation ''' path = db.Column(db.String(1000)) file_hash = db.Column(db.LargeBinary, unique=True) def to_dict(self): trackout = { "id": self.id, "uuid": self.uuid, "user_id": self.user_id, "track_id": self.track_id, "created_at": self.created_at, "name": self.name, "type": self.type, "path": self.path, "settings": self.settings } return trackout
class Movies(db.Model): __tablename__ = 'title_basics' id = db.Column('tconst', db.String, primary_key=True) type = db.Column('titleType', db.String) title = db.Column('primaryTitle', db.String) originalTitle = db.Column(db.String) isAdult = db.Column(db.Integer) startYear = db.Column(db.Integer) endYear = db.Column(db.Integer, nullable=True) runtimeMinutes = db.Column(db.Integer) genres = db.Column(db.String) rating = db.relationship("Rating", uselist=False, backref="title_basics") poster = db.relationship("MoviePoster", backref="title_basics")
class Wishlist(db.Model): __tablename__ = "wishlist" wishlist_id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) shelf_id = db.Column(db.Integer, db.ForeignKey('bookshelf.bookshelf_id')) bookId = db.Column(db.Integer) user = db.relationship('User', backref='wishlist_user') bookshelf = db.relationship('Bookshelf', backref='bookshelf_wishlist') def __init__(self, user_id='', shelf_id='', bookId=''): self.user_id = user_id self.shelf_id = shelf_id self.bookId = bookId