class User(db.Model):
FollowedFollowers = db.Table(
'followed_followers', db.Column('id', db.Integer, primary_key=True),
db.Column('followed_id', db.Integer,
db.ForeignKey('users.id', ondelete='cascade')),
db.Column('follower_id', db.Integer,
db.ForeignKey('users.id', ondelete='cascade')))
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.Text, unique=True)
password = db.Column(db.Text)
first_name = db.Column(db.Text)
last_name = db.Column(db.Text)
email = db.Column(db.Text, unique=True)
warbles = db.relationship('Warble',
cascade='all, delete-orphan',
backref='user',
lazy='dynamic')
followers = db.relationship(
'User',
secondary=FollowedFollowers,
primaryjoin=(FollowedFollowers.c.follower_id == id),
secondaryjoin=(FollowedFollowers.c.followed_id == id),
backref=db.backref('following', lazy='dynamic'))
def __init__(self, username, password, first_name, last_name, email):
self.username = username
self.password = bcrypt.generate_password_hash(password).decode('UTF-8')
self.first_name = first_name
self.last_name = last_name
self.email = email
def __repr__(self):
return "User {} {}'s user name is {}, email is {}".format(
self.first_name, self.last_name, self.username, self.email)
from project import db
from datetime import datetime
# from project.users.models import User
Likes = db.Table(
'likes', db.Column('id', db.Integer, primary_key=True),
db.Column('user_id', db.Integer,
db.ForeignKey('users.id', ondelete="cascade")),
db.Column('message_id', db.Integer,
db.ForeignKey('messages.id', ondelete="cascade")),
db.UniqueConstraint('user_id', 'message_id', name="one_time_like"))
class Message(db.Model):
__tablename__ = 'messages'
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(140))
timestamp = db.Column(db.DateTime)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete='CASCADE'))
user_likes = db.relationship('User',
secondary=Likes,
backref=db.backref('message_likes'))
def __init__(self, text, user_id, timestamp=datetime.utcnow()):
self.text = text
self.user_id = user_id
self.timestamp = timestamp
import datetime
import jwt
from flask import current_app
from project import db
from sqlalchemy.ext.hybrid import hybrid_property
user_tag = db.Table(
"user_tag",
db.Column("user_id",
db.Integer,
db.ForeignKey("user.user_id",
onupdate="CASCADE",
ondelete="CASCADE"),
primary_key=True),
db.Column("tag_id",
db.Integer,
db.ForeignKey("tag.tag_id",
onupdate="CASCADE",
ondelete="CASCADE"),
primary_key=True))
class Rating(db.Model):
__tablename__ = "rating"
from_user_id = db.Column(db.Integer,
db.ForeignKey("user.user_id",
onupdate="CASCADE",
ondelete="CASCADE"),
primary_key=True)
to_user_id = db.Column(db.Integer,
from project import db
subs = db.Table(
'subs',
db.Column('author_id',
db.Integer,
db.ForeignKey('author.author_id'),
primary_key=True),
db.Column('book_id',
db.Integer,
db.ForeignKey('book.book_id'),
primary_key=True),
extend_existing=True,
)
class Author(db.Model):
author_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
books = db.relationship('Book', secondary=subs, back_populates='books')
class Book(db.Model):
book_id = db.Column(db.Integer, primary_key=True)
book_name = db.Column(db.String(50))
authors = db.relationship('Author',
secondary=subs,
from project import db, bcrypt
from flask_login import UserMixin
from project.messages.models import Message
FollowersFollowee = db.Table(
'follows', db.Column('id', db.Integer, primary_key=True),
db.Column('followee_id', db.Integer,
db.ForeignKey('users.id', ondelete="cascade")),
db.Column('follower_id', db.Integer,
db.ForeignKey('users.id', ondelete="cascade")),
db.CheckConstraint('follower_id != followee_id', name="no_self_follow"))
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.Text, unique=True)
username = db.Column(db.Text, unique=True)
image_url = db.Column(db.Text)
header_image_url = db.Column(db.Text)
bio = db.Column(db.Text)
location = db.Column(db.Text)
password = db.Column(db.Text)
full_name = db.Column(db.Text)
messages = db.relationship('Message', backref='user', lazy='dynamic')
followers = db.relationship(
"User",
secondary=FollowersFollowee,
from project import db
from project.tags.models import Tag
'''
Oggetti Tabella relativi al modulo "corsi"
'''
# corso_tags - tabella di relazione N:N tra Corso e Tag
tags = db.Table(
"corso_tags",
#__table_args__ = {'extend_existing': True},
db.Column("corso_id",
db.Integer,
db.ForeignKey("corso.id"),
primary_key=True),
db.Column("tag_id", db.Integer, db.ForeignKey("tag.id"), primary_key=True),
)
# corso - tabella con i corsi
class Corso(db.Model):
# Nome della tabella
__tablename__ = "corso"
# Struttura/Attributi
id = db.Column(db.Integer(), primary_key=True)
nome = db.Column(db.String(100), unique=True, nullable=False)
insegnante = db.Column(db.String(100))
livello = db.Column(db.String(100))
descrizione = db.Column(db.String(255))
# Immagine logo da cartella static, se presente
logo_img = db.Column(db.String(100))
company = db.relationship('Company')
created_at = db.Column(db.DateTime, nullable=False)
def __init__(self,
company,
data_score,
company_uid,
created_at=datetime.datetime.utcnow()):
self.company = company
self.company_uid = company_uid
self.data_score = data_score
self.created_at = created_at
roles_users = db.Table(
'roles_users',
db.Column('admin_user_id', db.Integer(), db.ForeignKey('admin_users.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id')))
class Role(db.Model, RoleMixin):
__tablename__ = "role"
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
def __str__(self):
return self.name
class AdminUser(db.Model, UserMixin):
__tablename__ = "admin_users"
# project/models.py
import datetime
from sqlalchemy.ext.hybrid import hybrid_property
from sqlalchemy.sql.functions import sum
from project import db, bcrypt
tag_categories_tags = db.Table(
'tag_categories_tags',
db.Column('tag_category_id', db.Integer(),
db.ForeignKey('tag_category.id')),
db.Column('tag_id', db.Integer(), db.ForeignKey('tag.id')))
components_tags = db.Table(
'components_tags',
db.Column('component_id', db.Integer(), db.ForeignKey('component.id')),
db.Column('tag_id', db.Integer(), db.ForeignKey('tag.id')))
class Base(db.Model):
__abstract__ = True
id = db.Column(db.Integer, primary_key=True)
date_create = 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())
class User(db.Model):
from uuid import uuid4
from datetime import datetime
from project import db
from .config import SIZE_NAME, SIZE_UUID, SIZE_TITLE, SIZE_META
from .config import POST_STATUS_DRAFT, POST_STATUS_PUBLISHED, POST_TEMPLATE_TEXT
tags = db.Table(
'blog_tags',
db.Column('tag_id', db.Integer, db.ForeignKey('blog_tag.tag_id')),
db.Column('post_id', db.Integer, db.ForeignKey('blog_post.post_id')))
categories = db.Table(
'blog_categories',
db.Column('category_id', db.Integer,
db.ForeignKey('blog_category.category_id')),
db.Column('post_id', db.Integer, db.ForeignKey('blog_post.post_id')))
class Tag(db.Model):
__tablename__ = 'blog_tag'
id = db.Column('tag_id', db.Integer, primary_key=True)
uuid = db.Column('uuid', db.String(SIZE_UUID), unique=True)
slug = db.Column('slug', db.String(SIZE_NAME), unique=True, index=True)
name = db.Column('name', db.String(SIZE_NAME), index=True)
added = db.Column('added', db.DateTime)
deleted = db.Column('deleted', db.Boolean, default=False)
def __init__(self, slug, name):
self.uuid = str(uuid4())
self.slug = slug
self.name = name
from project import db, bcrypt
from flask_login import UserMixin
from project.preferences.models import Preference
UserPreference = db.Table(
'user_preferences', db.Column('id', db.Integer, primary_key=True),
db.Column('user_id', db.Integer,
db.ForeignKey('users.id', ondelete='cascade')),
db.Column('preference_id', db.Integer,
db.ForeignKey('preferences.id', ondelete='cascade')))
UserPodcast = db.Table(
'user_podcasts', db.Column('id', db.Integer, primary_key=True),
db.Column('user_id', db.Integer,
db.ForeignKey('users.id', ondelete='cascade')),
db.Column('podcast_id', db.Integer,
db.ForeignKey('podcasts.id', ondelete='cascade')))
LikedPodcasts = db.Table(
'liked_podcasts', db.Column('id', db.Integer, primary_key=True),
db.Column('id_of_user_who_liked_podcast', db.Integer,
db.ForeignKey('users.id', ondelete='cascade')),
db.Column('id_of_podcast_liked', db.Integer,
db.ForeignKey('podcasts.id', ondelete='cascade')))
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.Text, unique=True)
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), unique=True, nullable=False)
found_email_sent = db.Column(db.Integer, default=0)
#The backref will be a column in the Item table
subscribed_items = db.relationship('Item',
secondary='subscribes',
backref=db.backref('subscribed_users'),
lazy='dynamic')
def __repr__(self):
return f"User('{self.email}'"
#helper table
subscribes = db.Table(
'subscribes', db.Column('user_id', db.Integer, db.ForeignKey('users.id')),
db.Column('item_id', db.Integer, db.ForeignKey('items.id')),
db.Column('email_sent', db.Integer, default=0))
class Item(db.Model):
__tablename__ = 'items'
id = db.Column(db.Integer, primary_key=True)
brand = db.Column(db.String(30), nullable=False)
country = db.Column(db.String(15), nullable=False)
sku = db.Column(db.String(30), nullable=False)
is_available = db.Column(db.Boolean, default=False)
#last_time = db.Column(db.DateTime, default=datetime.utcnow)
#users = db.relationship("User", secondary="subscribes")
def now_available(self):
from project import db
from datetime import datetime
# from project.users.models import User
Likes = db.Table(
'likes', db.Column('id', db.Integer, primary_key=True),
db.Column('user_id', db.Integer,
db.ForeignKey('users.id', ondelete="cascade")),
db.Column('message_id', db.Integer,
db.ForeignKey('messages.id', ondelete="cascade")))
class Message(db.Model):
__tablename__ = 'messages'
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(140))
timestamp = db.Column(db.DateTime)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete='CASCADE'))
user_likes = db.relationship("User",
secondary=Likes,
backref=db.backref('message_likes'))
def __init__(self, text, user_id, timestamp=datetime.utcnow()):
self.text = text
self.user_id = user_id
self.timestamp = timestamp
from project import db
class Tag(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(10))
@classmethod
def get_all_tags(cls):
existing_tags = []
tags = cls.query.all()
for tag in tags:
t = (str(tag.id), str(tag.name))
existing_tags.append(t)
return existing_tags
@classmethod
def get_tag_by_id(cls, id):
tag = cls.query.filter_by(id=id).first()
return tag
@classmethod
def get_tag_by_name(cls, name):
tag = cls.query.filter_by(name=name).first()
return tag
assoc_table = db.Table(
'posts_tags', db.Column('post_id', db.Integer, db.ForeignKey('post.id')),
db.Column('tag_id', db.Integer, db.ForeignKey('tag.id')))
from project.models.serate import Serata
from project import db
# Tabella di relazione N:N tra Corso e Tag
tags = db.Table(
"corso_tags",
db.Column("corso_id",
db.Integer,
db.ForeignKey("corso.id"),
primary_key=True),
db.Column("tag_id", db.Integer, db.ForeignKey("tag.id"), primary_key=True),
)
class Corso(db.Model):
# Nome della tabella
__tablename__ = "corso"
# Struttura/Attributi
id = db.Column(db.Integer(), primary_key=True)
nome = db.Column(db.String(100), unique=True, nullable=False)
insegnante = db.Column(db.String(100))
lezioni = db.Column(db.Integer())
livello = db.Column(db.String(100))
descrizione = db.Column(db.String(255))
# Relazione 1:n; ordinamento serate per data
serate = db.relationship("Serata",
order_by="asc(Serata.data)",
backref="corso",
lazy="subquery")
from project import db
from sqlalchemy import UniqueConstraint
collection_guitars = db.Table(
'collection_guitars',
db.Column('collection_id', db.Integer, db.ForeignKey('collections.id')),
db.Column('guitar_id', db.Integer, db.ForeignKey('guitars.id')))
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String, unique=True, nullable=False)
email = db.Column(db.String, unique=True, nullable=False)
password = db.Column(db.String, nullable=False)
role = db.Column(db.Integer, default=1)
collections = db.relationship('Collection',
backref='collections',
lazy='dynamic')
def __init__(self, username, email, password, role=1):
self.username = username
self.email = email
self.password = password
self.role = role
def has_permission_to_edit(self, collection):
if collection is not None:
username = db.Column(db.String(64), index=True, unique=True)
password_hash = db.Column(db.String(128))
invisible = db.Column(db.Boolean, default=False)
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)
auth_users = db.Table(
'auth_users', db.Column('room_id', db.Integer, db.ForeignKey('room.id')),
db.Column('user_id', db.Integer, db.ForeignKey('user.id')))
room_users = db.Table(
'room_users', db.Column('room_id', db.Integer, db.ForeignKey('room.id')),
db.Column('user_id', db.Integer, db.ForeignKey('user.id')))
class Room(db.Model):
id = db.Column(db.Integer, primary_key=True)
room_name = db.Column(db.String(30), default="")
room_id = db.Column(db.String(10), index=True, unique=True)
suggest_list_id = db.Column(db.String(11))
gen_list_id = db.Column(db.String(11))
owner_id = db.Column(db.Integer, db.ForeignKey('user.id'))
password_required = db.Column(db.Boolean(), default=True)
seller = Seller.query.filter_by(email=email).first()
if seller:
return seller
else:
return False
class Product(db.Model):
__tablename__ = 'product'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
product_name = db.Column(db.String(200), nullable=False)
product_price = db.Column(db.String(10), nullable=False)
product_desc = db.Column(db.String(500), nullable=False)
sellers = relationship('Seller',
secondary="seller_product",
backref="products")
def __init__(self, product_name, product_price, product_desc):
self.product_name = product_name
self.product_price = product_price
self.product_desc = product_desc
def __repr__(self):
return '<Product %r>' % self.product_name
seller_product_table = db.Table(
'seller_product',
db.Column('product_id', db.Integer, db.ForeignKey('product.id')),
db.Column('seller_id', db.Integer, db.ForeignKey('seller.id')))
from project import db
import datetime
user_gifts = db.Table('chest_avatars', db.Model.metadata,
db.Column('chest_id', db.ForeignKey('chests.id')),
db.Column('avatar_id', db.ForeignKey('avatars.id')))
from project import db, bcrypt
from flask_login import UserMixin
BodyPartExercise = db.Table('bodypart_exercises',
db.Column('id', db.Integer, primary_key=True),
db.Column('exercise_id', db.Integer, db.ForeignKey('exercises.id', ondelete='cascade')),
db.Column('bodypart_id', db.Integer, db.ForeignKey('bodyparts.id', ondelete='cascade'))
)
class Exercise(db.Model):
__tablename__ = 'exercises'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text, unique = True)
description = db.Column(db.Text)
bodyparts = db.relationship('BodyPart', secondary=BodyPartExercise, backref=db.backref('exercises'))
def __init__(self,name,description):
self.name = name
self.description = description
class BodyPart(db.Model):
__tablename__ = 'bodyparts'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text, unique = True)
def __init__(self,name):
self.name=name
from project import db
EmployeeDepartment = db.Table('employee_departments',
db.Column('id',
db.Integer,
primary_key=True),
db.Column('employee_id',
db.Integer,
db.ForeignKey('employees.id', ondelete="cascade")),
db.Column('department_id',
db.Integer,
db.ForeignKey('departments.id', ondelete="cascade")))
EmployeeBenefit = db.Table('employee_benefits',
db.Column('id', db.Integer, primary_key= True),
db.Column('employee_id', db.Integer, db.ForeignKey('employees.id', ondelete='cascade')),
db.Column('benefit_id', db.Integer, db.ForeignKey('benefits.id', ondelete='cascade')))
class Employee(db.Model):
__tablename__ = 'employees'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text)
years_at_company = db.Column(db.Integer)
departments = db.relationship("Department",
secondary=EmployeeDepartment,
backref=db.backref('employees'))
# benefits = db.relationship("Benefit",
# secondary=EmployeeBenefit,
import datetime
from slugify import slugify
from project import db, bcrypt
student_table = db.Table(
'student',
db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
db.Column('webinar_id', db.Integer, db.ForeignKey('webinar.id'))
)
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String, unique=True, nullable=False)
password = db.Column(db.String, nullable=False)
registered_on = db.Column(db.DateTime, nullable=False)
admin = db.Column(db.Boolean, nullable=False, default=False)
confirmed = db.Column(db.Boolean, nullable=False, default=False)
confirmed_on = db.Column(db.DateTime, nullable=True)
rating = db.Column(db.Float, nullable=True)
webinars = db.relationship("Webinar", backref="user")
def __init__(self, email, password, confirmed,
paid=False, admin=False, confirmed_on=None, rating=None):
self.email = email
self.password = bcrypt.generate_password_hash(password)
self.registered_on = datetime.datetime.now()
# project/models.py
import datetime
from project import db, bcrypt
from sqlalchemy import UniqueConstraint
from utils.utils import random_color, random_pastel
position_assignments = db.Table('position_assignments',
db.Column('user_id', db.Integer, db.ForeignKey('users.id')),
db.Column('position_id', db.Integer, db.ForeignKey('positions.id'))
)
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String, unique=True, nullable=False)
first_name = db.Column(db.String(20))
last_name = db.Column(db.String(20))
password = db.Column(db.String, nullable=False)
registered_on = db.Column(db.DateTime, nullable=False)
admin = db.Column(db.Boolean, nullable=False, default=False)
# relationship with shifts
shifts = db.relationship("Shift", backref="user")
# relationship with organization
orgs_owned = db.relationship('Organization', backref='owner', lazy='dynamic')
from project import db
import datetime
garanty_products = db.Table('garanty_products', db.Model.metadata,
db.Column('garanty_id', db.ForeignKey('garanties.id')),
db.Column('product_id', db.ForeignKey('products.id'))
)
from project import db
from project.api.misc.enums import genres_list
class Genre(db.Model):
__tablename__ = "Genre"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Enum(*genres_list, name="genres"), nullable=False, unique=True)
GenreArtist = db.Table(
"GenreArtist",
db.Column("artist_id", db.Integer, db.ForeignKey("Artist.id"), primary_key=True),
db.Column("genre_id", db.Integer, db.ForeignKey("Genre.id"), primary_key=True),
)
GenreVenue = db.Table(
"GenreVenue",
db.Column("venue_id", db.Integer, db.ForeignKey("Venue.id"), primary_key=True),
db.Column("genre_id", db.Integer, db.ForeignKey("Genre.id"), primary_key=True),
)
from project import db, bcrypt
Followers = db.Table(
'followers', db.Column('follower_id', db.Integer,
db.ForeignKey('users.id')),
db.Column('followed_id', db.Integer, db.ForeignKey('users.id')))
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.Text, unique=True)
username = db.Column(db.Text, unique=True)
name = db.Column(db.Text)
password = db.Column(db.Text)
image_url = db.Column(db.Text)
messages = db.relationship('Warbler',
lazy='dynamic',
backref=db.backref('user'))
followed = db.relationship('User',
secondary=Followers,
primaryjoin=(Followers.c.follower_id == id),
secondaryjoin=(Followers.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'),
lazy='dynamic')
def __init__(self, email, username, name, password, image_url):
self.email = email
self.username = username
self.name = name
from project import db, bcrypt
subs = db.Table(
'subs',
db.Column('user_id',
db.Integer,
db.ForeignKey('usuario.user_id'),
primary_key=True),
db.Column('grupo_id',
db.Integer,
db.ForeignKey('grupos.grupo_id'),
primary_key=True))
element = db.Table(
'element',
db.Column('grupo_id',
db.Integer,
db.ForeignKey('grupos.grupo_id'),
primary_key=True),
db.Column('aparato_id',
db.Integer,
db.ForeignKey('aparatos.aparato_id'),
primary_key=True))
class Usuario(db.Model):
user_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String, nullable=False)
lastname = db.Column(db.String, nullable=False)
email = db.Column(db.String, nullable=False)
password = db.Column(db.String, nullable=False)
from project import db
# from project.tags.models import Tag # May not be necessary
MessageTags = db.Table(
'messages_tags', db.Column('id', db.Integer, primary_key=True),
db.Column('message_id', db.Integer,
db.ForeignKey('messages.id', ondelete="cascade")),
db.Column('tag_id', db.Integer, db.ForeignKey('tags.id',
ondelete="cascade")))
class Message(db.Model):
__tablename__ = "messages"
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.String(100))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
tags = db.relationship('Tag',
secondary=MessageTags,
backref=db.backref('messages'))
def __init__(self, content, user_id):
self.content = content
self.user_id = user_id
# Set a custom string representation of message objects
def __repr__(self):
return f"User {self.user_id} wrote '{self.content}'"
from project import db
UserMessages = db.Table(
"user_messages",
db.Column("id", db.Integer, primary_key=True),
db.Column("user_id", db.Integer,
db.ForeignKey("users.id", ondelete="cascade")),
db.Column("message_id", db.Integer,
db.ForeignKey("messages.id", ondelete="cascade")),
)
MessageTags = db.Table(
"message_tags",
db.Column("id", db.Integer, primary_key=True),
db.Column("message_id", db.Integer,
db.ForeignKey("messages.id", ondelete="cascade")),
db.Column("tag_id", db.Integer, db.ForeignKey("tags.id",
ondelete="cascade")),
)
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.Text)
last_name = db.Column(db.Text)
messages = db.relationship("Message",
secondary=UserMessages,
backref=db.backref("users"))
from project import db
import datetime
user_roles = db.Table('user_roles', db.Model.metadata,
db.Column('user_id', db.ForeignKey('users.id')),
db.Column('role_id', db.ForeignKey('roles.id')))
from locale import currency
import os
from project import app, db
from sqlalchemy_searchable import SearchQueryMixin, make_searchable
from sqlalchemy_utils import UUIDType
from sqlalchemy_utils.types import TSVectorType
from time import time
import uuid
make_searchable()
try:
if int(os.environ['TESTING']) == 1:
restaurants_users = db.Table(
'restaurants_users', db.Column('restaurants_id', db.Integer,
db.ForeignKey('restaurants.id')),
db.Column('users_id', db.Integer, db.ForeignKey('users.id')),
db.PrimaryKeyConstraint('restaurants_id', 'users_id'))
dishes_users = db.Table(
'dishes_users',
db.Column('dishes_id', db.Integer, db.ForeignKey('dishes.id')),
db.Column('users_id', db.Integer, db.ForeignKey('users.id')),
db.PrimaryKeyConstraint('dishes_id', 'users_id'))
except KeyError:
restaurants_users = db.Table(
'restaurants_users',
db.Column('restaurants_id', UUIDType, db.ForeignKey('restaurants.id')),
db.Column('users_id', UUIDType, db.ForeignKey('users.id')),
db.PrimaryKeyConstraint('restaurants_id', 'users_id'))
