class CarBrand(db.Model):
__tablename__ = 'carbrands'
id = db.Column(db.Integer, primary_key=True)
designation = db.Column(db.String(80), unique=True, index=True)
carmodels = db.relationship('CarModel', backref='carbrand', lazy=False)
cartypes = db.relationship('CarType',
secondary='carbrand_types',
backref='carbrand',
lazy=False)
def get_summary(self):
carbrands = {
'designation': self.designation,
'brand_logos': [i.file_path for i in self.images]
}
if len(self.carmodels) > 0:
carbrands['models'] = [{
model.designation: model
for model in self.carmodels
}] # a tester
"""{'modelname': [model.designation for model in self.carmodels],
'typemodel': [model.type.designation for model in self.carmodels],
'modeldateofprod': [model.date_of_prod for model in self.carmodels]}"""
# ['modelname: ' + i.designation + ' | ' + 'typemodel: ' + i.type.designation for i in self.carmodels]
return carbrands
class WishList(db.Model):
__tablename__ = 'wishlists'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column('User',
db.Integer,
db.ForeignKey('users.id'),
nullable=False)
product = db.relationship('Product', secondary='wishlistitems', lazy=False)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
#account_types = Personal, Professional, Business, Premium
account_type = db.Column(db.String(120), default='Business')
user_type = db.Column(db.String(120), default='Beta')
state = db.Column(db.String(120), default=fake.state_abbr())
country = db.Column(db.String(120),
default=fake.country_code(representation="alpha-2"))
set_path = db.Column(db.String(120), default='default')
company = db.Column(db.String(255), default=fake.company())
plan_id = db.Column(db.Integer, db.ForeignKey('plan.id'), default=1)
plan = db.relationship("Plan", backref="user")
def _set_default_plan(self):
return Plan.query.filter_by(name='free').first()
def __repr__(self):
return '<User {}>'.format(self.username)
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 get_email_hash(self):
return hashlib.md5(self.email.encode()).hexdigest()
def get_ld_user(self):
app_version = current_app.config['VERSION']
milliseconds = int(round(time.time() * 1000))
user_key = self.get_email_hash()
user = {
'key': user_key,
'email': self.email,
"custom": {
'account_type': self.account_type,
'user_type': self.user_type,
'state': self.state,
'country': self.country,
'app_version': app_version,
'company': self.company or 'None',
'date': milliseconds,
'plan': self.plan.name
},
'privateAttributeNames': ['account_type', 'state'],
}
return user
def get_random_ld_user(self):
user = {'key': str(uuid.uuid1())}
return user
class ProductImage(FileUpload):
product_id = db.Column(db.Integer, db.ForeignKey('products.id'), nullable=True)
product = db.relationship('Product', backref='images')
__mapper_args__ = {
'polymorphic_identity': 'ProductImage'
}
class UserImage(FileUpload):
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True)
user = db.relationship('User', backref='images')
__mapper_args__ = {
'polymorphic_identity': 'UserImage'
}
class CarBrandImage(FileUpload):
carbrand_id = db.Column(db.Integer, db.ForeignKey('carbrands.id'), nullable=True)
carbrand = db.relationship('CarBrand', backref='images')
__mapper_args__ = {
'polymorphic_identity': 'CarBrandImage'
}
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
#account_types = Personal, Professional, Business, Premium
account_type = db.Column(db.String(120), default='Business')
user_type = db.Column(db.String(120), default='Beta')
state = db.Column(db.String(120), default=fake.state_abbr())
country = db.Column(db.String(120), default=fake.country_code(representation="alpha-2"))
set_path = db.Column(db.String(120), default='default')
company = db.Column(db.String(255), default=fake.company())
def __repr__(self):
return '<User {}>'.format(self.username)
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 get_email_hash(self):
return hashlib.md5(self.email.encode()).hexdigest()
def get_ld_user(self, random=None):
app_version = current_app.config['VERSION']
if random:
user_key = str(uuid.uuid1())
else:
user_key = self.get_email_hash()
user = {
'key': user_key,
'email': self.email,
"custom": {
'account_type': self.account_type,
'user_type': self.user_type,
'state': self.state,
'country': self.country,
'company': self.company,
'app_version': app_version,
},
'privateAttributes': ['account_type', 'state'],
}
return user
class UserRole(db.Model):
__tablename__ = 'users_roles'
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
role_id = db.Column(db.Integer, db.ForeignKey("roles.id"))
# users = db.relationship("User", foreign_keys=[user_id], backref='roles')
user = db.relationship("User",
foreign_keys=[user_id],
backref='users_roles')
role = db.relationship("Role",
foreign_keys=[role_id],
backref='users_roles')
created_at = db.Column(db.DateTime(),
nullable=False,
default=datetime.utcnow)
__mapper_args__ = {'primary_key': [user_id, role_id]}
class SearchRecord(db.Model):
__tablename__ = f"{Base.DATABASE_TABLE_PREFIX}searchrecord"
search_id = db.Column(INTEGER(10, unsigned=True), primary_key=True)
query = db.Column(db.String(100), nullable=False)
suggest = db.Column(db.String(100), nullable=True)
iterations = db.Column(INTEGER(11), nullable=False)
results = db.Column(INTEGER(11), nullable=False)
timestamp = db.Column(
db.TIMESTAMP,
nullable=False,
server_default=text("CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"))
timetaken = db.Column(INTEGER(11), nullable=False)
remoteaddr = db.Column(db.String(50), nullable=True)
source = db.Column(db.String(10), nullable=True)
class Language(db.Model):
__tablename__ = f"{Base.DATABASE_TABLE_PREFIX}language"
language_id = db.Column(INTEGER(10, unsigned=True), primary_key=True)
code = db.Column(CHAR(2), unique=True, nullable=False)
name = db.Column(db.String(50), nullable=False)
localname = db.Column(db.String(50), nullable=False)
queryurl = db.Column(db.String(255), nullable=True)
hastranslation = db.Column(TINYINT(1), nullable=False)
haslexical = db.Column(TINYINT(1), nullable=False)
class User(BaseModel):
"""
Class representing a user of the system
"""
__tablename__ = "users"
fields_to_serialize = ["id", "email"]
id = db.Column(db.BigInteger, primary_key=True)
email = db.Column(db.String(254), nullable=False, unique=True)
password = db.Column(db.String(60), nullable=False)
@classmethod
def create_hash(cls, plain_password: str) -> str:
"""
Hashes plain password
"""
return bcrypt.hashpw(plain_password.encode("utf-8"),
bcrypt.gensalt()).decode("utf-8")
def check_password(self, plain_password: str) -> bool:
"""
Check if the password is correct
"""
return bcrypt.hashpw(
plain_password.encode("utf-8"),
self.password.encode("utf-8")).decode("utf-8") == self.password
@staticmethod
def check_user(email: str, password: str) -> None:
"""
Check if email and password matches an existing user
"""
try:
user = User.query.filter_by(email=email.lower()).one()
if user.check_password(plain_password=password):
return user
except (SQLAlchemyError, ValueError):
return None
class FileUpload(db.Model):
__tablename__ = 'file_uploads'
id = db.Column('id', db.Integer, primary_key=True)
type = db.Column('type', db.String(15)) # this will be our discriminator
file_path = db.Column(db.String(300), nullable=False)
file_name = db.Column(db.String(255), nullable=False)
file_size = db.Column(db.Integer, nullable=False)
original_name = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow, onupdate=datetime.utcnow)
__mapper_args__ = {
'polymorphic_on': type,
'polymorphic_identity': 'FileUpload'
}
class Plan(db.Model):
"""
Represents a plan type
"""
id = db.Column(db.Integer, primary_key=True, autoincrement=False)
name = db.Column(db.String(120), index=True, unique=True)
description = db.Column(db.String(250), index=True)
cost = db.Column(db.Float())
created_date = db.Column(db.DateTime, index=True, default=datetime.utcnow)
updated_date = db.Column(db.DateTime, index=True, default=datetime.utcnow)
def get_plan_cost(self):
return "{:,.2f}".format(self.cost)
class Message(db.Model):
__tablename__ = 'messages'
id = db.Column(db.Integer, primary_key=True)
content_message = db.Column(db.Text, nullable=False)
send_at = db.Column(db.DateTime(), nullable=False)
read_at = db.Column(db.DateTime, nullable=False)
sender_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
receiver_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
class Comment(db.Model):
__tablename__ = 'comments'
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text, nullable=False)
rating = db.Column(db.Integer, nullable=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
# user = relationship('User', backref=db.backref('comments'))
user = db.relationship('User', foreign_keys=[user_id], lazy=False)
product_id = db.Column(db.Integer,
db.ForeignKey('products.id'),
nullable=False)
# product = relationship('Product', backref=db.backref('comments'))
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow())
updated_at = db.Column(db.DateTime,
nullable=True,
default=datetime.utcnow(),
onupdate=datetime.utcnow())
def get_summary(self, include_product=False, include_user=False):
data = {
'id': self.id,
'content': self.content,
'created_at': self.created_at,
}
if include_product:
data['product'] = {
'id': self.products.id,
'name': self.products.name
}
if include_user:
data['user'] = {'id': self.user_id, 'username': self.user.username}
return data
class CarModel(db.Model):
__tablename__ = 'carmodels'
id = db.Column(db.Integer, primary_key=True)
designation = db.Column(db.String(300),
unique=True,
index=True,
nullable=False)
date_of_prod = db.Column(db.DateTime(), nullable=False)
date_end_of_prod = db.Column(db.DateTime(), nullable=True)
carbrand_id = db.Column(db.Integer,
db.ForeignKey('carbrands.id'),
nullable=False)
type_id = db.Column(db.Integer,
db.ForeignKey('cartypes.id'),
nullable=False)
# carbrand = db.relationship('CarBrand', foreign_keys=[carbrand_id], lazy='dynamic')
type = db.relationship('CarType', foreign_keys=[type_id], lazy=False)
class Category(db.Model):
__tablename__ = 'categories'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
slug = db.Column(db.String(255), index=True, unique=True)
description = db.Column(db.String(300))
created_at = db.Column(db.DateTime(), default=datetime.utcnow(), index=True)
updated_at = db.Column(db.DateTime())
def get_summary(self):
return {
'id': self.id,
'name': self.name,
'description': self.description,
'image_urls': [image.file_path.replace('\\', '/') for image in self.images]
}
def __repr__(self):
return self.name
def slug_generator_for_category(self, name):
self.slug = 'catg-0'+str(random.randint(0, 100))+str(randomString(6))+'-'+str(name)
class Place(db.Model):
__tablename__ = 'openair_place'
uuid = db.Column(UUID(as_uuid=True),
unique=True,
server_default=text("uuid_generate_v4()"))
id = db.Column(db.Integer, index=True, primary_key=True)
name = db.Column(db.String(80), nullable=False)
type = db.Column(db.String(10), nullable=False)
aqi = db.Column(db.Integer, nullable=False)
# 4326: projection defines lat/long coordinate system
geometric_point = db.Column(Geometry(geometry_type='POINT', srid=4326),
nullable=False)
# Raw location
location = db.Column(JSON, nullable=False)
# History Data id: Can be null but must be unique
ref_id = db.Column(db.String(40), unique=True, nullable=True)
# ---- Meta data ---- #
created_at = db.Column(db.DateTime, index=True, server_default=func.now())
updated_at = db.Column(
db.DateTime, index=True,
server_default=func.now()) # ToDo: fix auto updation
# method tells Python how to print objects of this class
def __repr__(self):
return '<Place {}>'.format(self.name)
def from_dict(self, data):
for field in [
'name', 'type', 'aqi', 'ref_id', 'location', 'geometric_point'
]:
if field in data:
setattr(self, field, data[field])
def get_nearby_aqi_node(lat, lng):
# ToDo: Refactor to be more precise: https://stackoverflow.com/a/20936147
dist_in_meters = int(
flask_app.config["CIRCULAR_COVERAGE_DISTANCE_FROM_NODE"])
dist_in_miles = dist_in_meters * 0.621371192 / 1000
dist_in_degree_radius = dist_in_miles * 0.014472
# load longitude & latitude
geo_point = func.ST_GeographyFromText('POINT({} {})'.format(lng, lat))
# Well-Known Binary format
geo_wkb = func.Geometry(geo_point)
# ToDo: split into functions to iterate through multiple points in one session
# print("New session for this single query")
# get closest point
try:
# `distance_centroid` will do an index based Nearest Neighbour (NN) search.
nearby_point = db.session.query(Place.name,
Place.aqi,
Place.location,
Place.updated_at).\
filter(func.ST_DFullyWithin(Place.geometric_point, geo_wkb, dist_in_degree_radius)).\
order_by(
Comparator.distance_centroid(Place.geometric_point, geo_wkb)).limit(1).first()
if (nearby_point is not None):
place_object = {
'name': nearby_point[0],
'aqi': nearby_point[1],
'location': nearby_point[2],
'updated_at': nearby_point[3]
}
return place_object
return None
except SQLAlchemyError as e:
return None
except Exception as err:
print('Unknown error', err)
return None
name = db.Column(db.String(255))
slug = db.Column(db.String(255), index=True, unique=True)
description = db.Column(db.String(300))
created_at = db.Column(db.DateTime(), default=datetime.utcnow(), index=True)
updated_at = db.Column(db.DateTime())
def get_summary(self):
return {
'id': self.id,
'name': self.name,
'description': self.description,
'image_urls': [image.file_path.replace('\\', '/') for image in self.images]
}
def __repr__(self):
return self.name
def slug_generator_for_category(self, name):
self.slug = 'catg-0'+str(random.randint(0, 100))+str(randomString(6))+'-'+str(name)
"""
@event.listens_for(Category.name, 'set')
def receive_set(target, value, oldvalue, initiator):
target.slug = slugify(unicode(value))
"""
products_categories = \
db.Table("products_categories",
db.Column("category_id", db.Integer, db.ForeignKey("categories.id")),
db.Column("product_id", db.Integer, db.ForeignKey("products.id")))
class PartData(db.Model):
__tablename__ = 'partdatas'
id = db.Column(db.Integer, primary_key=True)
ref_part = db.Column(db.String(255), nullable=False, unique=True, index=True)
weight = db.Column(db.Integer, nullable=False)
diameter = db.Column(db.Integer, nullable=True)
dimension = db.Column(db.String(100), nullable=True)
date_of_prod = db.Column(db.DateTime(), nullable=True)
num_oem = db.Column(db.String(300), nullable=False, unique=True, index=True)
country_of_origin = db.Column(db.String(80), nullable=False)
volume_of_part = db.Column(db.Integer)
product_id = db.Column(db.Integer, db.ForeignKey('products.id'), nullable=True)
car_compatibilities = db.relationship(CarModel, secondary='car_part_compts', backref='partdatas', lazy=False)
car_compt = db.Table('car_part_compts',
db.Column('partdata_id', db.Integer, db.ForeignKey('partdatas.id')),
db.Column('carmodel_id', db.Integer, db.ForeignKey('carmodels.id')))
class Entry(db.Model):
__tablename__ = f"{Base.DATABASE_TABLE_PREFIX}entry"
entry_id = db.Column(INTEGER(10, unsigned=True), primary_key=True)
media = db.Column(INTEGER(10, unsigned=True), nullable=False)
class Product(db.Model):
__tablename__ = 'products'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
slug = db.Column(db.String(255), index=True, unique=True)
description = db.Column(db.Text, nullable=False)
availability = db.Column(db.Boolean)
quality = db.Column(db.String(100))
price = db.Column(db.Integer, nullable=False)
stock = db.Column(db.Integer, nullable=False)
rating = db.Column(db.Integer, nullable=True)
# promotion_rate = db.Column(db.Integer, nullable=True) // a voir plus tard
seller_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
manufacturer = db.Column(db.String(100), nullable=False)
created_at = db.Column(db.DateTime(), default=datetime.utcnow, index=True, nullable=False)
updated_at = db.Column(db.DateTime(), default=datetime.utcnow, onupdate=datetime.utcnow, nullable=True)
publish_on = db.Column(db.DateTime(), index=True, default=datetime.utcnow)
categories = db.relationship('Category', secondary=products_categories, backref='products')
comments = db.relationship('Comment', backref='products', lazy=False)
partdata = db.relationship('PartData', uselist=False)
def __repr__(self):
return '<Product %r>' % self.name
def __str__(self):
return '<Product {}>'.format(self.name)
def get_summary(self):
products_infos = {
'id': self.id,
'name': self.name,
'price': self.price,
'stock': self.stock,
'slug': self.slug,
'availability': STATUS[self.availability],
'rating': self.rating,
'quality': self.quality,
'marque': self.manufacturer,
'comments_count': len(self.comments),
'comments': [CommentDetailsSerializer(c, include_user=True).data for c in self.comments],
'categories': [c.name for c in self.categories],
'image_urls': [i.file_path for i in self.images]
}
if self.partdata is not None:
products_infos['ref_part'] = self.partdata.ref_part,
products_infos['weight'] = self.partdata.weight,
products_infos['date_of_prod'] = self.partdata.date_of_prod,
products_infos['num_oem'] = self.partdata.num_oem,
products_infos['country_of_origin'] = self.partdata.country_of_origin,
products_infos['volume_of_part'] = self.partdata.volume_of_part,
products_infos['manufacturer'] = self.partdata.manufacturer
products_infos['dimension'] = self.partdata.dimension
products_infos['list_car_compt'] = [car.designation for car in self.partdata.car_compatibilities]
return products_infos
def slug_generator_for_product(self, seller_id, prd_name):
self.slug = 'product-0' + str(random.randint(0, 100)) + '-' + 'sllr-0' + str(seller_id) + '-' + str(
randomString(3)) + str(prd_name)
class Address(db.Model):
__tablename__ = 'addresses'
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(100), nullable=False)
last_name = db.Column(db.String(100), nullable=False)
city = db.Column(db.String(100), nullable=False)
country = db.Column(db.String(100), nullable=False)
zip_code = db.Column(db.String(100), nullable=False)
street_address = db.Column(db.String(255), nullable=False)
phone_number = db.Column(
db.String(255),
nullable=True) # nullable because I have not implemented it
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True)
user = db.relationship('User', backref='addresses')
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow,
onupdate=datetime.utcnow)
def get_summary(self):
data = {
'id': self.id,
'first_name': self.first_name,
'last_name': self.last_name,
'address': self.street_address,
'zip_code': self.zip_code,
'city': self.city,
'country': self.country,
'created_at': self.created_at,
'updated_at': self.updated_at
}
return data
class QuoteFileUploaded(FileUpload):
quote_id = db.Column(db.Integer, db.ForeignKey('quotes.id'), nullable=True)
quote = db.relationship('Quote', backref='files')
__mapper_args__ = {
'polymorphic_identity': 'QuoteFile'}
class Rank(db.Model):
__tablename__ = f"{Base.DATABASE_TABLE_PREFIX}rank"
rank_id = db.Column(INTEGER(10, unsigned=True), primary_key=True)
name = db.Column(db.String(50), nullable=False)
threshold = db.Column(INTEGER(10, unsigned=True), nullable=False)
__tablename__ = 'carmodels'
id = db.Column(db.Integer, primary_key=True)
designation = db.Column(db.String(300),
unique=True,
index=True,
nullable=False)
date_of_prod = db.Column(db.DateTime(), nullable=False)
date_end_of_prod = db.Column(db.DateTime(), nullable=True)
carbrand_id = db.Column(db.Integer,
db.ForeignKey('carbrands.id'),
nullable=False)
type_id = db.Column(db.Integer,
db.ForeignKey('cartypes.id'),
nullable=False)
# carbrand = db.relationship('CarBrand', foreign_keys=[carbrand_id], lazy='dynamic')
type = db.relationship('CarType', foreign_keys=[type_id], lazy=False)
class CarType(db.Model):
__tablename__ = 'cartypes'
id = db.Column(db.Integer, primary_key=True)
designation = db.Column(db.String(80), unique=True)
carbrand_types = \
db.Table('carbrand_types',
db.Column('carbran_id', db.Integer, db.ForeignKey('carbrands.id')),
db.Column('cartype_id', db.Integer, db.ForeignKey('cartypes.id')))
class User(db.Model):
__tablename__ = f"{Base.DATABASE_TABLE_PREFIX}user"
user_id = db.Column(INTEGER(10, unsigned=True), primary_key=True)
login = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(100), nullable=False)
salt = db.Column(db.String(100), nullable=False)
name = db.Column(db.String(100), nullable=False)
email = db.Column(db.String(255), unique=True, nullable=False)
website = db.Column(db.String(255), nullable=True)
timezone = db.Column(db.String(50), nullable=True)
lastlogin = db.Column(db.TIMESTAMP, nullable=True)
lastloginattempt = db.Column(db.TIMESTAMP, nullable=True)
failedloginattempts = db.Column(INTEGER(11), nullable=False, server_default=text("0"))
remembertoken = db.Column(db.String(100), nullable=True)
voided = db.Column(TINYINT(1), nullable=False, server_default=text("0"))
class CarType(db.Model):
__tablename__ = 'cartypes'
id = db.Column(db.Integer, primary_key=True)
designation = db.Column(db.String(80), unique=True)
class Quote(db.Model):
__tablename__ = 'quotes'
id = db.Column(db.Integer, primary_key=True)
quote_title = db.Column(db.String(80), nullable=False)
slug = db.Column(db.String(80), index=True, unique=True)
content = db.Column(db.Text, nullable=False)
carModel_information = db.Column(db.String(255), nullable=True)
immatricuation = db.Column(db.String(255), nullable=True)
num_chassis = db.Column(db.String(255), nullable=False)
num_vin = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow())
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
user = db.relationship('User', foreign_keys=[user_id], lazy=False)
seller_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
def get_summary(self, include_file=False):
quote_summary = {
'title': self.quote_title,
'content': self.content,
'carmodel_inf': self.carModel_information,
'immatriculation': self.immatricuation,
'num_chassis': self.num_chassis,
'num_vin': self.num_vin,
'created_at': self.created_at
}
if include_file:
quote_summary['files'] = [i.file_path for i in self.files]
return quote_summary
def slug_generator_for_quote(self, username):
self.slug = 'quote-0' + str(random.randint(0, 100)) + str(
randomString(5)) + '-' + str(username)
from app.factory import db
class WishList(db.Model):
__tablename__ = 'wishlists'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column('User',
db.Integer,
db.ForeignKey('users.id'),
nullable=False)
product = db.relationship('Product', secondary='wishlistitems', lazy=False)
wishListItem = db.Table(
'wishlistitems', db.Model.metadata,
db.Column('wishlist_id', db.Integer, db.ForeignKey('wishlists.id')),
db.Column('product_id', db.Integer, db.ForeignKey('products.id')))
