class Follow(db.Model): __tablename__ = "follow" id = db.column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('users.id')) follower_id = db.Column(db.Integer, db.ForeignKey('users.id')) user = db.relationship('User', foreign_keys=user_id) follower = db.relationship('User', foreign_keys=follower_id)
class Artist(db.Model): id = db.Column(db.Integer, primary_key=True) artist = db.Column(db.String(100), index=True) about = db.Column(db.String(200)) disc_artist = db.relationship("Disc", backref="artist", lazy="dynamic") disc_a_d = db.relationship("ArtistDisc", backref="artist", lazy="dynamic") def __str__(self): return f"<Artist: {self.name}>"
class Disc(db.Model): id = db.Column(db.Integer, primary_key=True) title = db.Column(db.Text, index=True) genre = db.Column(db.Text) year = db.Column(db.Integer) description = db.Column(db.Text) artist_id = db.Column(db.Integer, db.ForeignKey('artist.id')) artists = db.relationship("ArtistDisc", backref="disc", lazy="dynamic") rented = db.relationship("Rented", backref="disc", lazy="dynamic") def __str__(self): return f"<Book: {self.id} {self.title[:50]}...>"
class Project(db.Model): __tablename__ = "project" id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(120), nullable=False) description = db.Column(db.Text()) goal = db.Column(db.Float) current_amount = db.Column(db.Float) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) school_id = db.Column(db.String(120), db.ForeignKey('school.id')) transactions = db.relationship('Transaction') reports = db.relationship('Report') def __repr__(self): return '<Project %r>' % self.title
class ItemModel(db.Model): __tablename__ = 'items' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80)) price = db.Column(db.Float(precision=2)) store_id = db.Column(db.Integer, db.ForeignKey("stores.id")) store = db.relationship('StoreModel') def __init__(self, name, price,store_id): self.name = name self.price = price self.store_id = store_id def json(self): return {'name': self.name, 'price': self.price} @classmethod def find_by_name(cls, name): # SELECT * FROM items WHERE name=name LIMIT 1 return ItemModel.query.filter_by(name=name).first() def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class School(db.Model): __tablename__ = "school" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(120), nullable=False) logo = db.Column(db.String(240), nullable=False) color = db.Column(db.String(120), nullable=False) members = db.relationship('User')
class User(db.Model, UserMixin): id = db.Column(db.Integer(), primary_key=True) name = db.Column(db.String(255)) 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()) last_login_at = db.Column(db.DateTime()) current_login_at = db.Column(db.DateTime()) last_login_ip = db.Column(db.String(100)) current_login_ip = db.Column(db.String(100)) login_count = db.Column(db.Integer()) roles = db.relationship( 'Role', secondary=role_users, backref=db.backref('users', lazy='dynamic') ) def get_security_payload(self): return { 'id': self.id, 'name': self.name, 'email': self.email, } def __str__(self): return self.email
class StoreModel(db.Model): __tablename__ = 'stores' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80)) items = db.relationship('ItemModel', lazy='dynamic') def __init__(self, name, price): self.name = name self.price = price def json(self): return {'name': self.name, 'items': [item.json() for item in self.items.all()]} @classmethod def find_by_name(cls, name): return cls.query.filter_by(name=name).first() def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class Role(db.Model): __tablename__ = 'roles' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(64), unique=True) users = db.relationship('User', backref='role', lazy='dynamic') def __repr__(self): return '<Role %r>' % self.name
class OAuth(OAuthConsumerMixin, db.Model): """Data model for oauth accounts.""" __tablename__ = 'oauth' provider_user_id = db.Column(db.String(256), unique=True, nullable=False) user_id = db.Column(db.Integer, db.ForeignKey(User.id), nullable=False) user = db.relationship("User", back_populates="oauth", uselist=False)
class Log(OurMixin, db.Model): __tablename__ = 'logs' id = db.Column(db.VARCHAR(length=36), primary_key=True) action = db.Column(db.VARCHAR(length=5120)) user_id = db.Column(db.VARCHAR(length=36), db.ForeignKey('users.id', ondelete='CASCADE'), nullable=False) user = db.relationship("User", cascade='delete')
class Article(db.Model): id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(100), nullable=False) content = db.Column(db.Text(), nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) user = db.relationship(User, backref=db.backref('articles', uselist=True)) def __repr__(self): return '<Article %s>' % self.title
class Tag(SurrogatePK, Model): __tablename__ = 'tags' tag = db.Column(db.Text) posts = db.relationship('Post', secondary=tags_posts, backref=db.backref('tags_br', lazy='dynamic')) def __init__(self, tag, **kwargs): db.Model.__init__(self, tag=tag, **kwargs)
class User(UserMixin, db.Model): __tablename__ = 'user' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.Unicode(20), unique=True) email = db.Column(db.Unicode(40), unique=True) password = db.Column(db.Unicode(30), unique=True) listings = db.relationship('Items', backref='user', lazy=True) def __repr__(self): return '<User: %r>' % self.username + self.email + self.password
class ItemModel(db.Model): __tablename__ = 'items' id = db.Column(db.Integer, primary_key= True) name = db.Column(db.String(80)) price = db.Column(db.Float(precision=2)) store_id = db.Column(db.Integer, db.ForeignKey('stores.id')) store = db.relationship('StoreModel') def __init__(self, name, price, store_id): self.name = name self.price = price self.store_id = store_id def json(self): return {'name': self.name, 'price': self.price} @classmethod def find_by_name(cls, name): # connection = sqlite3.connect('data.db') # cursor = connection.cursor() # query = "SELECT * FROM items WHERE name=?" # result = cursor.execute(query, (name,)) # row = result.fetchone() # connection.close() # # if row: # return cls(*row) return ItemModel.query.filter_by(name=name).first() def save_to_db(self): # connection = sqlite3.connect('data.db') # cursor = connection.cursor() # query = 'INSERT INTO items VALUES(?,?)' # cursor.execute(query, (self.name, self.price)) # # connection.commit() # connection.close() db.session.add(self) db.session.commit() # def update(self): # connection = sqlite3.connect('data.db') # cursor = connection.cursor() # # query = 'UPDATE items SET price=? WHERE NAME=?' # cursor.execute(query, (self.name, self.price)) # # connection.commit() # connection.close() def delete_from_db(self): db.session.delete(self) db.session.commit()
class StoreModel(db.Model): __tablename__ = 'stores' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80)) items = db.relationship('ItemModel', lazy='dynamic') def __init__(self,name): self.name = name
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(120), unique=True, nullable=False) image_file = db.Column(db.String(20), nullable=False, default='default.jpg') password = db.Column(db.String(60), nullable=False) posts = db.relationship('Post', backref='author', lazy=True) def __repr__(self): return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class Puppy(db.Model): __tablename__ = 'puppies' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.Text) owner = db.relationship('Owner', backref='Puppy', uselist=False) date = db.Column(db.DateTime, default=est_now) def __init__(self, name): self.name = name def __repr__(self): return f'{self.name}'
class User(db.Model): __tablename__ = "user" id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80), unique=True, nullable=False) firstname = db.Column(db.String(80), nullable=False) lastname = db.Column(db.String(80), nullable=False) email = db.Column(db.String(120), unique=True, nullable=False) password = db.Column(db.String(120)) userType = db.Column(db.Integer, nullable=False) paypal = db.Column(db.String(250)) verified = db.Column(db.Boolean, nullable=False) school = db.Column(db.Integer, db.ForeignKey('school.id')) pic = db.Column(db.Text()) projects = db.relationship('Project') # reports_made = db.relationship('Report', foreign_keys=['reports.reporting_user']) # reports_against = db.relationship('Report', foreign_keys=['reports.reportee_id']) messages = db.relationship('Message') ##Lazy loading refers to objects are returned from a ##query without the related objects loaded at first. def __repr__(self): return '<User %r>' % self.username
class Post(SurrogatePK, Model): __tablename__ = 'posts' title = db.Column(db.Text) slug = db.Column(db.Text) body = db.Column(db.Text) created_at = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow) user_id = db.Column(db.Integer, db.ForeignKey('users.id')) tags = db.relationship('Tag', secondary=tags_posts, backref=db.backref('posts_br', lazy='dynamic')) def __init__(self, title, slug, body, **kwargs): db.Model.__init__(self, title=title, slug=slug, body=body, **kwargs)
class File(OurMixin, db.Model): __tablename__ = 'files' id = db.Column(db.VARCHAR(length=36), primary_key=True) name = db.Column(db.VARCHAR(length=256), nullable=False) path = db.Column(db.VARCHAR(length=512), nullable=True) thumbnail_name = db.Column(db.VARCHAR(length=256), nullable=True) thumbnail_path = db.Column(db.VARCHAR(length=512), nullable=True) width = db.Column(db.Integer(), default=0, server_default='0') height = db.Column(db.Integer(), default=0, server_default='0') size = db.Column(db.Integer(), default=0, server_default='0') user_id = db.Column(db.VARCHAR(length=36), db.ForeignKey('users.id'), nullable=False) user = db.relationship("User") mimetype = db.Column(db.VARCHAR(length=256), nullable=False)
class Post(db.Model): __tablename__ = "posts" id = db.Column(db.Integer, primary_key=True) content = db.Column(db.Text) user_id = db.Column(dm.Integer, db.ForeignKey('users.id')) user = db.relationship('User', foreign_keys=user_id) def __init__(self, content, user_id): self.content = content self.user_id = user_id def __repr(self): return f"<Post {self.id}>"
class User(db.Model, UserMixin): """Data model for user accounts.""" __tablename__ = 'user' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80), index=False, unique=False, nullable=False) email = db.Column(db.String(80), index=True, unique=False, nullable=False) created = db.Column(db.DateTime, index=False, unique=False, nullable=False) password = db.Column(db.String(255), nullable=False) token = db.Column(db.String(80), index=True, unique=True) token_expiration = db.Column(db.DateTime) oauth = db.relationship("OAuth", back_populates="user", uselist=False) def __init__(self, **kwargs): super(User, self).__init__(**kwargs) self.created = DATE self.token = token_urlsafe() self.token_expiration = DATE self.password = generate_password_hash(self.password, method='sha256') def __repr__(self): return '<User {}>'.format(self.username) def set_password(self, password): self.password = generate_password_hash(password, method='sha256') def check_password(self, password): return check_password_hash(self.password, password) @property def to_dict(self): return { 'user_id': self.id, 'username': self.username, 'email': self.email, 'created': str(self.created), } def verify_expiration_token(self): now = datetime.now() if now > self.token_expiration + timedelta(minutes=60): self.token = token_urlsafe() self.token_expiration = now return self.token
class TokenBlocklist(db.Model): """Blocklist representation""" id = db.Column(db.Integer, primary_key=True) jti = db.Column(db.String(36), nullable=False, unique=True) token_type = db.Column(db.String(10), nullable=False) user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False) revoked = db.Column(db.Boolean, nullable=False) expires = db.Column(db.DateTime, nullable=False) user = db.relationship("User", lazy="joined") def to_dict(self): return { "token_id": self.id, "jti": self.jti, "token_type": self.token_type, "user_identity": self.user_identity, "revoked": self.revoked, "expires": self.expires, }
class Tarea(db.Base): __tablename__ = 'tarea' id = Column(Integer, primary_key = True) titulo = Column(String(60)) descripcion = Column(String(255)) estado = Column(String(60)) fecha_creacion = Column(String(60)) responsable = db.Column(db.Integer, db.ForeignKey('usuario.id')) usuario = db.relationship("Usuario", backref = "tarea") def __init__ (self, titulo, descripcion, estado, responsable, fecha_creacion): self.titulo = titulo self.descripcion = descripcion self.estado = estado self.responsable = responsable self.fecha_creacion = fecha_creacion def __repr__(self): return f'{self.id}, {self.titulo}, {self.descripcion}, {self.estado}, {self.responsable}, {self.fecha_creacion}'
class TokenBlacklist(db.Model): """Blacklist representation """ id = db.Column(db.Integer, primary_key=True) jti = db.Column(db.String(36), nullable=False, unique=True) token_type = db.Column(db.String(10), nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) revoked = db.Column(db.Boolean, nullable=False) expires = db.Column(db.DateTime, nullable=False) user = db.relationship('User', lazy='joined') def to_dict(self): return { 'token_id': self.id, 'jti': self.jti, 'token_type': self.token_type, 'user_identity': self.user_identity, 'revoked': self.revoked, 'expires': self.expires }
class Role(OurMixin, db.Model): """ Subclass this for your roles """ __tablename__ = 'roles' id = db.Column(db.VARCHAR(length=36), primary_key=True) name = db.Column(db.String(120), unique=True) abilities = db.relationship( 'Ability', secondary=role_abilities_table, backref='roles') def __init__(self, name): self.name = name.lower() # self.id = uuid() super(Role, self).__init__() def add_abilities(self, *abilities): for ability in abilities: existing_ability = Ability.query.filter_by( name=ability).first() if not existing_ability: existing_ability = Ability(ability) existing_ability.insert() # safe_commit() # db.session.commit() self.abilities.append(existing_ability) def remove_abilities(self, *abilities): for ability in abilities: existing_ability = Ability.query.filter_by(name=ability).first() if existing_ability and existing_ability in self.abilities: self.abilities.remove(existing_ability) def __repr__(self): return '<Role {}>'.format(self.name) def __str__(self): return self.name
class Role(db.Model): __tablename__ = 'roles' id = db.Column(db.Integer, primary_key=True) users = db.relationship('User', backref='role')
class User(UserMixin, OurMixin, db.Model): __tablename__ = 'users' id = db.Column(db.VARCHAR(length=36), primary_key=True) username = db.Column(db.String()) firstname = db.Column(db.String(32)) lastname = db.Column(db.String(32)) password = db.Column(db.String()) active = db.Column(db.Boolean(), default=True, server_default='1') _roles = db.relationship( 'Role', secondary=user_role_table, backref='users') type = db.Column(db.String(50)) roles = association_proxy('_roles', 'name', creator=_role_find_or_create) def __init__(self, **kwargs): # A bit of duplication here keeps the kwargs being # set but encrypts the password. for k, v in kwargs.items(): if k != 'password': setattr(self, k, v) else: self.set_password(v) OurMixin.__init__(self) UserMixin.__init__(self) def validate(self): return_value = success() not_unique = User.filter(User.username == self.username).count() if not_unique: return_value['success'] = False return_value['messages'].append("That user exists already.") if not self.email: return_value['success'] = False return_value['messages'].append("An email address is required to create a user.") return return_value def set_password(self, password): self.password = generate_password_hash(password) def check_password(self, value): return check_password_hash(self.password, value) def is_authenticated(self): if isinstance(self, AnonymousUserMixin): return False else: return True def is_active(self): return self.active def is_anonymous(self): if isinstance(self, AnonymousUserMixin): return True else: return False def add_roles(self, *roles): self.roles.extend([role for role in roles if role not in self.roles]) def remove_roles(self, *roles): self.roles = [role for role in self.roles if role not in roles] def has_role(self, role): return True if role in self.roles else False def get_id(self): return self.id def __repr__(self): return '<User {}:{}>'.format(self.id, self.username)
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic'))