class President(db.Model):
__tablename__='presidents'
id=db.Column(db.Integer, primary_key=True )
name=db.Column(db.Text)
articles=db.relationship('Article', back_populates="president")
article_id=db.Column(db.Integer, db.ForeignKey('articles.id'))
#a president can have many articles
keywords=db.relationship('Keyword', back_populates='president')
keyword_id=db.Column(db.Integer, db.ForeignKey('keywords.id'))
class Song(db.Model):
__tablename__ = 'songs'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text)
shows = db.relationship('Show',
secondary='show_song',
back_populates='songs')
artist = db.relationship('Artist', back_populates='songs')
artist_id = db.Column(db.Integer, db.ForeignKey('artists.id'))
class ArticleKeyword(db.Model):
__tablename__='articlekeywords'
id=db.Column(db.Integer, primary_key=True )
article_id=db.Column(db.Integer, db.ForeignKey('articles.nyt_id'))
keyword_id=db.Column(db.Integer, db.ForeignKey('keywords.id'))
# article=db.relationship('Article', backref="articlekeywords", cascade='all, delete-orphan', single_parent=True)
# keyword=db.relationship('Keyword', backref="articlekeywords", cascade='all, delete-orphan', single_parent=True)
article=db.relationship('Article', backref="articlekeywords")
keyword=db.relationship('Keyword', backref="articlekeywords")
class Customer(db.Model):
__tablename__ = 'customers'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text)
hometown = db.Column(db.Text)
birthyear = db.Column(db.Integer)
orders = db.relationship(Order, back_populates="customer", lazy="dynamic")
bartenders = db.relationship("Bartender",
secondary="orders",
back_populates="customers")
class Keyword (db.Model):
__tablename__='keywords'
id=db.Column(db.Integer, primary_key=True )
category= db.Column(db.Text)
value=db.Column(db.Text)
# article_id=db.Column(db.String)
# articles=db.relationship('Article', back_populates='keywords')
president_id = db.Column(db.Integer)
president=db.relationship('President', back_populates='keywords')
article=db.relationship('Article', secondary='articlekeywords')
class Manufactures(db.Model):
id = db.Column(db.Integer(), primary_key=True)
manufacture_name = db.Column(db.String(128), nullable=False)
manufacture_longname = db.Column(db.String(255))
country = db.Column(db.String(128))
tubes = db.relationship('Tubes', backref='manufacture', lazy=True)
generators = db.relationship('Generator', backref='manufacture', lazy=True)
tables = db.relationship('Tables', backref='manufacture', lazy=True)
technologies = db.relationship('Technologies',
backref='manufacture',
lazy=True)
tomog = db.relationship('Tomog', backref='manufacture', lazy=True)
def __repr__(self):
return '{}'.format(self.manufacture_name)
class Artist(db.Model):
__tablename__ = 'artists'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text, nullable=False)
songs = db.relationship('Song', back_populates='artist')
def does_artist_have_show_in_country(self, countryname):
country = Country.query.filter(Country.name == countryname).first()
for show in country.shows:
if show.songs[0].artist.name == self.name:
return True
return False
def an_artists_number_of_countries(self):
count = 0
for c in Country.query.all():
if self.does_artist_have_show_in_country(c.name):
count += 1
return count
@classmethod
def make_dict(cls):
dict = {}
for a in cls.query.all():
dict.update({a.name: a.an_artists_number_of_countries()})
return dict
class Player(db.Model):
__tablename__ = "players"
id = db.Column(db.Integer, primary_key=True)
team_id = db.Column(db.Integer, db.ForeignKey('teams.id'))
team = db.relationship('Team', back_populates='players')
team_code = db.Column(db.Integer)
name = db.Column(db.String)
position = db.Column(db.String)
cost = db.Column(db.Float)
total_points = db.Column(db.Integer)
roi = db.Column(db.Float)
bonus = db.Column(db.Integer)
red_cards = db.Column(db.Integer)
minutes = db.Column(db.Integer)
status = db.Column(db.String)
transfers_out = db.Column(db.Integer)
transfers_in = db.Column(db.Integer)
def to_dict(self):
player_d = {
'id': self.id,
'name': self.name,
'position': self.position,
'cost': self.cost,
'total_points': self.total_points,
'roi': self.roi,
'bonus': self.bonus,
'red_cards': self.red_cards,
'minutes': self.minutes,
'status': self.status,
'transfers_out': self.transfers_out,
'transfers_in': self.transfers_in,
'team': self.team.name
}
return player_d
class Tomog(db.Model):
id = db.Column(db.Integer(), primary_key=True)
manufacture_id = db.Column(db.Integer,
db.ForeignKey('manufactures.id'),
nullable=False)
tomog_model = db.Column(db.String(128), nullable=False)
spiraltype = db.Column(db.String(128))
tubecount = db.Column(db.String(128))
gantry = db.Column(db.Integer())
slicecount = db.Column(db.Integer())
slice_thicness = db.Column(db.Float())
fov_x = db.Column(db.Integer())
fov_z = db.Column(db.Integer())
spatial_resolution = db.Column(db.Float())
rotation_time = db.Column(db.Float())
fps = db.Column(db.Integer())
room_size = db.Column(db.Float())
performance = db.Column(db.Float())
tube_id = db.Column(db.Integer, db.ForeignKey('tubes.id'), nullable=False)
generator_id = db.Column(db.Integer,
db.ForeignKey('generator.id'),
nullable=False)
table_id = db.Column(db.Integer,
db.ForeignKey('tables.id'),
nullable=False)
technologies = db.relationship('Technologies',
secondary=tomog_techno,
backref=db.backref('tomog', lazy='dynamic'))
image_id = db.Column(db.Integer, db.ForeignKey('image.id'))
def __repr__(self):
return '{}'.format(self.tomog_model)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(20), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default="default.jpg")
password = db.Column(db.String(60), nullable=False)
is_admin = db.Column(db.Boolean, default=False)
poll = db.relationship('Poll', backref='parti', lazy=True)
def __repr__(self):
return f"User('{self.username}','{self.email}','{self.image_file}')"
def get_reset_token(self, expires_sec=1800):
s = Serializer(app.config["SECRET_KEY"], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod #not to expect self
def verify_reset_token(token):
s = Serializer(app.config["SECRET_KEY"])
try:
auser_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
class Path(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100))
track = db.Column(db.Integer, db.ForeignKey('tracks.id'), nullable=False)
rela = db.relationship('Post', backref='course', lazy=True)
def __repr__(self):
return f"Course({self.title},{self.track})"
class Bartender(db.Model):
__tablename__ = 'bartenders'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
hometown = db.Column(db.String(100))
birthyear = db.Column(db.Integer)
customers = db.relationship("Customer",
secondary="orders",
back_populates="bartenders")
class User(db.Model, UserMixin):
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)
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}')"
class Show(db.Model):
__tablename__ = 'shows'
id = db.Column(db.Integer, primary_key=True)
fmid = db.Column(db.Text, nullable=False)
date = db.Column(db.Text, nullable=False)
venue = db.Column(db.Text)
city = db.Column(db.Text)
lat = db.Column(db.Integer)
lng = db.Column(db.Integer)
songs = db.relationship('Song',
secondary='show_song',
back_populates='shows')
country_id = db.Column(db.Integer, db.ForeignKey('countries.id'))
country = db.relationship('Country', back_populates='shows')
@classmethod
def venue_locations(cls):
return {show.venue: [show.lat, show.lng] for show in Show.query.all()}
class User(db.Model, UserMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(128), unique=True)
email = db.Column(db.String(128), unique=True)
password = db.Column(db.String(128), )
active = db.Column(db.Boolean())
roles = db.relationship('Role',
secondary=role_user,
backref=db.backref('user', lazy='dynamic'))
class Order(db.Model):
__tablename__ = 'orders'
id = db.Column(db.Integer, primary_key=True)
customer_id = db.Column(db.Integer,
db.ForeignKey('customers.id'),
default=None)
customer = db.relationship('Customer', back_populates="orders")
bartender_id = db.Column(db.Integer, db.ForeignKey('bartenders.id'))
drink_id = db.Column(db.Integer, db.ForeignKey('drinks.id'))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
login = db.Column(db.String(128), nullable=False, unique=True)
email = db.Column(db.String(length=120))
fullname = db.Column(db.String(128), nullable=False)
password = db.Column(db.String(255), nullable=False)
group_user_id = db.Column(db.Integer, db.ForeignKey('usergroup.id'))
Claims = db.relationship('Claim',
primaryjoin="Claim.source_user_id==User.id",
foreign_keys=[Claim.source_user_id],
backref=db.backref('user', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
Claims_executer = db.relationship(
'Claim',
primaryjoin="Claim.executer_user_id==User.id",
foreign_keys=[Claim.executer_user_id],
backref=db.backref('executer_user', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
class Admin(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(40), nullable=False)
email = db.Column(db.String(40), nullable=False, unique=True)
username = db.Column(db.String(20), nullable=False)
password = db.Column(db.String(60), nullable=False)
phone = db.Column(db.String(), nullable=False)
rele = db.relationship('Post', backref='author', lazy=True)
def __repr__(self):
return f"Admin('{self.id}, {self.name}, {self.email}, {self.username}')"
class Tables(db.Model):
id = db.Column(db.Integer(), primary_key=True)
manufacture_id = db.Column(db.Integer,
db.ForeignKey('manufactures.id'),
nullable=False)
table_name = db.Column(db.String(128), nullable=False)
horizont_range = db.Column(db.Integer())
max_weight = db.Column(db.Integer())
tomog = db.relationship('Tomog', backref='table', lazy=True)
def __repr__(self):
return '{}'.format(self.table_name)
class Image(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.Unicode(64), nullable=False)
path = db.Column(db.Unicode(128), nullable=False)
tomograph = db.relationship('Tomog', backref='image', lazy=True)
def __unicode__(self):
return self.name
def __repr__(self):
return '{}'.format(self.name)
class Tracks(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.Text)
intro = db.Column(db.Text)
image = db.Column(db.String(100))
message = db.Column(db.Text)
paths = db.relationship('Path', backref='line', lazy=True)
# rel = db.relationship('Post', backref = '', lazy = True)
def __repr__(self):
return f"Track('Track Number = {self.id}, Title = {self.title}')"
class Article(db.Model):
__tablename__='articles'
id=db.Column(db.Integer, primary_key=True )
headline=db.Column(db.Text)
url = db.Column(db.String)
nyt_id = db.Column(db.String)
president_id = db.Column(db.Integer)
word_count = db.Column(db.Integer)
section=db.Column(db.Text)
# num_hits=db.Column(db.Integer)
date=db.Column(db.String)
president=db.relationship('President', back_populates='articles')
# section=db.relationship('Section', back_populates='articles', lazy='dynamic')
#an article can only be in one section
keywords=db.relationship('Keyword', secondary='articlekeywords')
#an article could have many keywords
def to_dict(self):
article={'id': self.id, 'headline': self.headline, 'url':self.url, 'nyt_id': self.nyt_id, 'word_count': self.word_count, 'num_hits': self.num_hits, 'date': self.date, 'section': self.section.section_name
# ,'keywords': [keyword.to_dict() for keyword in self.keywords]
}
return article
class Generator(db.Model):
id = db.Column(db.Integer(), primary_key=True)
manufacture_id = db.Column(db.Integer,
db.ForeignKey('manufactures.id'),
nullable=False)
generator_name = db.Column(db.String(128), nullable=False)
power = db.Column(db.Integer())
current = db.Column(db.Integer())
voltage = db.Column(db.Integer())
tomog = db.relationship('Tomog', backref='generator', lazy=True)
def __repr__(self):
return '{}'.format(self.generator_name)
class Tubes(db.Model):
id = db.Column(db.Integer(), primary_key=True)
manufacture_id = db.Column(db.Integer,
db.ForeignKey('manufactures.id'),
nullable=False)
tube_model = db.Column(db.String(128), nullable=False)
focus = db.Column(db.String(128))
capacity = db.Column(db.Float())
coolingrate = db.Column(db.Float())
servise_life = db.Column(db.Integer())
tomog = db.relationship('Tomog', backref='tube', lazy=True)
def __repr__(self):
return '{}'.format(self.tube_model)
class User(UserMixin, 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))
posts = db.relationship('Post', backref='author', lazy='dynamic')
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)
class Team(db.Model):
__tablename__ = "teams"
id = db.Column(db.Integer, primary_key=True)
# table_id = db.Column(db.Integer, Foreign_Key('epl_table.id'))
code = db.Column(db.Integer)
position = db.Column(db.Integer)
name = db.Column(db.String)
GP = db.Column(db.Integer)
W = db.Column(db.Integer)
D = db.Column(db.Integer)
L = db.Column(db.Integer)
points = db.Column(db.Integer)
GF = db.Column(db.Integer)
GA = db.Column(db.Integer)
GD = db.Column(db.Integer)
player_points = db.Column(db.Integer)
logo = db.Column(db.String)
players = db.relationship('Player', back_populates='team')
def to_dict(self):
team_d = {
'id': self.id,
'name': self.name,
'position': self.position,
'points': self.points,
'GP': self.GP,
'W': self.W,
'D': self.D,
'L': self.L,
'GF': self.GF,
'GA': self.GA,
'GD': self.GD,
'player_points': self.player_points,
'logo': self.logo,
}
return team_d
class Country(db.Model):
__tablename__ = 'countries'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text, nullable=False)
shows = db.relationship('Show', back_populates='country')
class Usergroup(db.Model):
id = db.Column(db.Integer, primary_key=True)
group_name = db.Column(db.String(128), nullable=False, unique=True)
Users = db.relationship('User', backref=db.backref('usergroup', lazy=True))
