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=}>'
