class SongsBB(db.Model): # On initialise les colonnes de la table __tablename__ = "chansonBB" id = db.Column(db.Integer, primary_key=True, autoincrement=True) title_fr = db.Column(db.String(45)) title_brz = db.Column(db.String(45)) dialect = db.Column(db.String(64)) theme = db.Column(db.String(64)) song_fr = db.Column(db.Text) song_brz = db.Column(db.Text) MusicSheetPath = db.Column(db.String(64)) # On initialise le constructeur de la classe def __init__(self, id, title_fr, title_brz, dialect, theme, song_fr, song_brz, MusicSheetPath): self.id = id self.title_fr = title_fr self.title_brz = title_brz self.dialect = dialect self.theme = theme self.song_fr = song_fr self.song_brz = song_brz self.MusicSheetPath = MusicSheetPath
class UserModel(BaseModel, db.Model): __tablename__ = 'dripbox_user' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(120), unique=True, nullable=False) password = db.Column(db.String(120), nullable=False) files = relationship("FileModel")
class User(UserMixin, db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key = True, autoincrement=True) name = db.Column(db.String(20)) birth = db.Column(db.String(10), nullable = False) username = db.Column(db.String(64), unique=True, index=True) password = db.Column(db.String(128)) recipes = db.relationship('Recipe', backref='users', lazy=True) liked = db.relationship('LikePost', foreign_keys='LikePost.user_id', backref='users', lazy='dynamic') def __init__(self,name,birth,username,password): self.name = name self.birth = birth self.username = username self.password = password def __repr__(self): return '<User %r>' % self.username def like(self, recipe): if LikePost.query.filter(LikePost.user_id == self.id, LikePost.recipe_id == recipe.id).count() > 0: LikePost.query.filter_by(user_id=self.id, recipe_id=recipe.id).delete() recipe.removeLike() db.session.commit() else: like = LikePost(user_id=self.id, recipe_id=recipe.id) db.session.add(like) recipe.addLike() db.session.commit()
class Driver(db.Model): id = db.Column(db.Integer, primary_key=True) first_name = db.Column(db.String(255), nullable=False) last_name = db.Column(db.String(255), nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) user = db.relationship("User", back_populates="driver") trips = db.relationship("Trip", backref="driver", lazy=True)
class UserModel(BaseModel, db.Model): __tablename__ = 'warsaw_user' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(120), unique=True, nullable=False) password = db.Column(db.String(120), nullable=False) is_admin = db.Column(db.Boolean)
class ShoppingList(db.Model): """Model for Shopping Lists""" __tablename__ = 'shoppinglists' id = db.Column(db.Integer, primary_key=True, autoincrement=True) owner_id = db.Column(db.Integer, nullable=False) title = db.Column(db.String(255), nullable=False, unique=True) description = db.Column(db.String(500), nullable=False) date_created = db.Column(db.DateTime, default=db.func.current_timestamp()) date_modified = db.Column(db.DateTime, default=db.func.current_timestamp(), onupdate=db.func.current_timestamp()) def __init__(self, owner_id, title, description): self.owner_id = owner_id self.title = title self.description = description def save_shoppinglist(self): db.session.add(self) db.session.commit() def delete_shoppinglist(self): db.session.delete(self) db.session.commit() def __repr__(self): return '<title {}'.format(self.title)
class Pet(db.Model): """Modelo Mascota Pet(id_pet, name_pet, type_pet, age_pet, name_profile_img) Nota: al registrar una mascota, el valor de adopcion siempre sera False Relaciones: - Mascota tendrá la llave primaria de Persona """ id_pet = db.Column(db.Integer, primary_key = True) name_pet = db.Column(db.String(25), nullable = False) type_pet = db.Column(db.String(25), nullable = False) age_pet = db.Column(db.Integer(), nullable = False) adopt = db.Column(db.Boolean(), nullable = False, default = False) name_profile_img = db.Column(db.String, default = 'default.jpg' , nullable = True) url_profile_img = db.Column(db.String, default = 'http://localhost:5000/static/profile_img/default.jpg' , nullable = True) # Referencia a la clase Persona id_owner = db.Column(db.Integer, db.ForeignKey('person.id_person'), nullable = True) def __repr__(self): return self.name_pet
class Person(db.Model): """Modelo Persona Person(id_person, name_person, last_name_person, telephone_person, email_person, name_profile_img) Relaciones: - Persona tendrá referencias de varias Mascotas Nota: lazy(perezosa) = True define como SQLAlchemy cargará los datos """ id_person = db.Column(db.Integer, primary_key = True) name_person = db.Column(db.String(25), nullable = False) last_name_person = db.Column(db.String(25), nullable = False) telephone_person = db.Column(db.Integer(), nullable = False) email_person = db.Column(db.String(25), unique = True, nullable = False) name_profile_img = db.Column(db.String, default = 'default.jpg' , nullable = True) url_profile_img = db.Column(db.String, default = 'http://localhost:5000/static/profile_img/default.jpg' , nullable = True) # Relacion uno a muchos con la clase Mascota pets = db.relationship('Pet', backref = 'owner', lazy = True) def __repr__(self): return self.name_person
class Trip(db.Model): id = db.Column(db.Integer, primary_key=True) start_location = db.Column(db.String(255), nullable=False) end_location = db.Column(db.String(255), nullable=False) departure_date = db.Column(db.DateTime(timezone=True), nullable=False) return_date = db.Column(db.DateTime(timezone=True), nullable=False) available_seats = db.Column(db.Integer, nullable=False) driver_id = db.Column(db.Integer, db.ForeignKey('driver.id'), nullable=False) riders = db.relationship('Rider', secondary=trip_riders, lazy='subquery', back_populates='trips') def remove_rider_from_trip(self, rider_id): new_riders = [rider for rider in self.riders if rider.id != rider_id] self.riders = new_riders self.available_seats = self.available_seats + 1 db.session.commit() def add_rider_to_trip(self, rider_id): self.riders.append(rider_id) self.available_seats = self.available_seats - 1 db.session.commit()
class Key(db.Model): __tablename__ = 'keys' id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) key_value = db.Column(db.String(50)) key_type = db.Column(db.String(25))
class User(UserMixin, db.Model): """User account model.""" first_name = db.Column(db.String(32)) last_name = db.Column(db.String(32)) username = db.Column(db.String(32), unique=True, index=True) email = db.Column(db.String(50), unique=True, index=True) password = db.Column(db.String(200), primary_key=False, unique=False, nullable=False) created_on = db.Column(db.DateTime, index=False, unique=False, nullable=True) last_login = db.Column(db.DateTime, index=False, unique=False, nullable=True) def set_password(self, password): """Create hashed password.""" self.password = generate_password_hash(password, method='sha256') def check_password(self, password): """Check hashed password.""" return check_password_hash(self.password, password) def __repr__(self): return '<User {}>'.format(self.username)
class Project(db.Model): id = db.Column(db.Integer, primary_key=True) project_name = db.Column(db.String(50), index=True) dataset_location = db.Column(db.String(50), index=True) def __repr__(self): return "<Project name={}>".format(self.project_name)
class User(Base): __tablename__ = 'user' # User Name name = db.Column(db.String(128), nullable=False) # Identification Data: email & password orcid = db.Column(db.String(128), nullable=False, unique=True) token = db.Column(db.String(192), nullable=False) aka = db.Column(db.String(1000), nullable=True) role = db.Column(db.String(128), nullable=True) repos = db.relationship('Repository', backref='user', lazy=True) def __init__(self, name, orcid, aka, token): self.name = name self.orcid = orcid self.token = token self.aka = aka def __repr__(self): return '<User %r>' % self.name def as_dict(self): # return {c.name: getattr(self, c.name) for c in self.__table__.columns} return { c.name: str(getattr(self, c.name)) for c in self.__table__.columns } # to support datetime
class CollateDataSave(db.Model): id = db.Column(db.Integer, primary_key=True) project_id = db.Column(db.Integer, db.ForeignKey("project.id"), index=True) save_name = db.Column(db.String(50), index=False) condition = db.Column(db.String(50), index=False) condition_col = db.Column(db.String(50), index=False) action = db.Column(db.String(50), index=False) action_col = db.Column(db.String(50), index=False)
class User(db.Model): 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)) def __repr__(self): return '<User {}>'.format(self.username)
class Resource(db.Model): id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(64), index=True, unique=True) home_page = db.Column(db.String(120), index=True, unique=True) news = db.relationship('News', backref='source', lazy='dynamic') def __repr__(self): return f'<Resource {self.title}>'
class User(db.Model): """This class defines the users table """ __tablename__ = 'users' # Define the columns of the users table, starting with the primary key id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(256), nullable=False, unique=True) password = db.Column(db.String(256), nullable=False) bucketlists = db.relationship('Bucketlist', order_by='Bucketlist.id', cascade="all, delete-orphan") def hash_password(self, entered_password): ''' function for hashing a password ''' self.password = pwd_context.encrypt(entered_password) def verify_password(self, entered_password): ''' function for verifying a hashed a password ''' return pwd_context.verify(entered_password, self.password) def generate_token(self, user_id): ''' Generates the access token to be used as the Authorization header ''' try: # set up a payload with an expiration time payload = { 'exp': datetime.utcnow() + timedelta(minutes=10), 'iat': datetime.utcnow(), 'sub': user_id } # encode the payload to get an byte string token jwt_string = jwt.encode(payload, current_app.config.get('SECRET'), algorithm='HS256') return jwt_string except Exception as e: # return an error in string format if an exception occurs return str(e) @staticmethod def decode_token(token): ''' Decode the access token from the Authorization header ''' try: payload = jwt.decode(token, current_app.config.get('SECRET')) return payload['sub'] except jwt.ExpiredSignatureError: return "Expired token. Please log in to get a new token" except jwt.InvalidTokenError: return "Invalid token. Please register or login"
class Order(Model): __tablename__ = 'order' order_id = db.Column(db.Integer, primary_key=True, autoincrement=True) buyer_id = db.Column(db.Integer, db.ForeignKey('buyer.buyer_id'), nullable=True) buyer = db.relationship('Buyer', backref=db.backref('orders', lazy=True)) supplier_id = db.Column(db.Integer, db.ForeignKey('supplier.supplier_id'), nullable=True) supplier = db.relationship('Supplier', backref=db.backref('orders', lazy=True)) date_created = db.Column(db.Date) time_created = db.Column(db.Time) accepted = db.Column(db.Boolean) status = db.Column(db.String(45)) price = db.Column(db.Float) rate = db.Column(db.Integer) comment = db.Column(db.String(255)) ship_price_buyer = db.Column(db.Float) ship_price_supplier = db.Column(db.Float) ship_price = db.Column(db.Float) def __init__(self, buyer_id=None, supplier_id=None, date_created=None, time_created=None, accepted=None, status=None, price=None, rate=None, comment=None, ship_price_buyer=None, ship_price_supplier=None, ship_price=None): self.buyer_id = buyer_id self.supplier_id = supplier_id self.date_created = date_created self.time_created = time_created self.accepted = accepted self.status = status self.price = price self.rate = rate self.comment = comment self.ship_price_buyer = ship_price_buyer self.ship_price_supplier = ship_price_supplier self.ship_price = ship_price
class Unit(db.Model): __tablename__ = 'units' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(100), nullable=False) abbreviation = db.Column(db.String(10)) product = db.relationship('Product', backref='units') def __str__(self): return self.name
class Result(db.Model): """Create a user table.""" __tablename__ = 'result' id = db.Column(db.Integer, primary_key=True) status = db.Column(db.String(60)) timestamp = db.Column(db.DateTime()) spec_name = db.Column(db.String(60)) time = db.Column(db.Integer) test_id = db.Column(db.Integer, db.ForeignKey('test.id'))
class Restaurant(db.Model): __tablename__ = "restaurant" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(64), index=True, unique=True) url = db.Column(db.String(255)) want_to_go = db.Column(db.Boolean) ratings = db.relationship("Rating", backref="score", lazy="dynamic") def __repr__(self): return f"Restaurant {self.name}"
class User(db.Model, UserMixin): __tablename__ = "users" id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(100), nullable=False, unique=True) password = db.Column(db.String(255), nullable=False, server_default="") active = db.Column(db.Boolean(), nullable=False, server_default="0") roles = db.relationship("Role", secondary="user_roles") def __repr__(self): return f"{self.username}"
class Column(db.Model): id = db.Column(db.Integer, primary_key=True) project_id = db.Column(db.Integer, db.ForeignKey("project.id"), index=True) position = db.Column(db.Integer) name = db.Column(db.String(50)) d_type = db.Column(db.String(20)) format = db.Column(db.String(50), nullable=True) def __repr__(self): return "<Column project_id={} position={}>".format( self.project_id, self.position)
class Test(db.Model): """Create a test table.""" __tablename__ = 'test' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(60), index=True, unique=True) test_type = db.Column(db.String(60)) data = db.Column(db.Text()) execute_date = db.Column(db.DateTime()) scenario_id = db.Column(db.Integer, db.ForeignKey('scenario.id')) result = db.relationship("Result") group = db.relationship('Group')
class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) user_name = db.Column(db.String(20)) user_email = db.Column(db.String(60), unique=True, index=True) user_password = db.Column(db.String(80)) create_date = db.Column(db.DateTime, default=datetime.now) last_login_date = db.Column(db.DateTime, default=datetime.utcnow()) is_confirmed = db.Column(db.Boolean, default=False, nullable=False) role = db.Column(db.String(25), default='Guest', nullable=False) keys = db.relationship('Key', backref='user', lazy=True)
class User(db.Model): 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)) rider = db.relationship("Rider", uselist=False, back_populates="user") driver = db.relationship("Driver", uselist=False, back_populates="user") def set_password(self, password): self.password_hash = bcrypt.generate_password_hash(password).decode('UTF-8') def check_password(self, password): return bcrypt.check_password_hash(self.password_hash, password)
class Changelog(db.Model): def __init__(self, commit_id, version, date, body, release_link): self.commit_id = commit_id self.version = version self.date = date self.body = body self.release_link = release_link commit_id = db.Column(db.String(120), primary_key=True) version = db.Column(db.String(120), primary_key=True) date = db.Column(db.String(120)) body = db.Column(db.String(120)) release_link = db.Column(db.String(128))
class Feedback(db.Model): __tablename__ = 'feedback' id = db.Column(db.Integer, primary_key=True) customer = db.Column(db.String(200), unique=True) dealer = db.Column(db.String(200)) rating = db.Column(db.Integer) comments = db.Column(db.Text()) def __init__(self, customer, dealer, rating, comments): self.customer = customer self.dealer = dealer self.rating = rating self.comments = comments
class User(Base): __tablename__ = 'souvu_user' ''' Email address will be the username ''' email = db.Column(db.String(50), unique=True, nullable=False) ''' Encrypted password for the user. ''' password_hash = db.Column(db.String(128)) authenticated = db.Column(db.Boolean, default=False) admin = db.Column(db.Boolean, default=False) first_name = db.Column(db.String(25), nullable=True) last_name = db.Column(db.String(25), nullable=True) test_account = db.Column(db.Boolean, default=False) def check_password(self, password): """ Check's whether the specified password is correct """ print("checking password") return check_password_hash(self.password, password) def is_admin(self): return self.admin def is_active(self): """True, as all users are active.""" return True def is_authenticated(self): """Return True if the user is authenticated.""" return self.authenticated def is_anonymous(self): """False, as anonymous users aren't supported.""" return False def get_id(self): """Return the email address to satisfy Flask-Login's requirements.""" return self.email @property def password(self): raise AttributeError('password is not a readable attribute') @password.setter def password(self, password): self.password_hash = generate_password_hash(password)
class Task(db.Model): id_ = db.Column(db.Integer, primary_key=True) url = db.Column(db.String(150), nullable=False) status = db.Column(db.String(30), nullable=False, default='in progress') filename = db.Column(db.String(50)) @property def completed(self): if self.status.lower() in ['completed', 'done', 'finished']: return True return False def __repr__(self): return f'Task<{self.id_=}, {self.url=}, {self.status=}, {self.filename=}>'