class Quantity(db.Model):
id = db.Column(db.Integer, primary_key=True)
quantity = db.Column(db.Float)
recipe_id = db.Column(db.Integer,
db.ForeignKey('recipe.id', ondelete="CASCADE"),
nullable=False)
recipe = db.relationship('Recipe',
backref=db.backref('quantities',
cascade="all,delete",
lazy=True))
ingredient_id = db.Column(db.Integer,
db.ForeignKey('ingredient.id'),
nullable=False)
ingredient = db.relationship('Ingredient',
backref=db.backref('quantities', lazy=True))
measurement_id = db.Column(db.Integer,
db.ForeignKey('measurement.id'),
nullable=False)
measurement = db.relationship('Measurement',
backref=db.backref('quantities', lazy=True))
def __init__(self, quantity, recipe, ingredient, measurement):
self.quantity = quantity
self.recipe = recipe
self.ingredient = ingredient
self.measurement = measurement
def __repr__(self):
return '<Quantity %r>' % self.quantity
class House(db.Model):
__tablename__ = 'house'
houseID = db.Column(db.String(20), primary_key=True)
housetitle = db.Column(db.String(40), nullable=False)
city = db.Column(db.String(10), nullable=False)
district = db.Column(db.String(10), nullable=False)
area = db.Column(db.String(50), nullable=False)
street = db.Column(db.String(50), nullable=False)
community = db.Column(db.String(50), nullable=False)
room = db.Column(db.String(10), nullable=False)
lng = db.Column(db.String(30), nullable=False)
lat = db.Column(db.String(30), nullable=False)
housepic = db.Column(db.String(200), nullable=False)
housearea = db.Column(db.Float, nullable=False)
housedirect = db.Column(db.String(5), nullable=False)
housefloor = db.Column(db.String(5), nullable=False)
househall = db.Column(db.String(10), nullable=False)
balcony = db.Column(db.Boolean, nullable=False)
bathroom = db.Column(db.Boolean, nullable=False)
housestatus = db.Column(db.Boolean, nullable=False)
housetype = db.Column(db.String(5), nullable=False)
housearound = db.Column(db.Text)
# 外码
tenanttel = db.Column(db.String(11), db.ForeignKey('user.usertel'))
# relationship
tenant = db.relationship('User', backref=db.backref('renthouse'))
pics = db.relationship('Housepic', backref=db.backref('house'))
prices = db.relationship('Payment', backref=db.backref('house'))
class Artist(db.Model):
__tablename__ = 'Artist'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False, unique=True)
city_id = db.Column(db.Integer, db.ForeignKey('City.id'), nullable=False)
phone = db.Column(db.String(120), nullable=True)
image_link = db.Column(db.String(500), nullable=True)
facebook_link = db.Column(db.String(120), nullable=True)
website = db.Column(db.String(120), nullable=True)
seeking_venue = db.Column(db.Boolean, nullable=True)
seeking_description = db.Column(db.String, nullable=True)
genres = db.relationship('Genre', secondary=artist_genres,
backref=db.backref('artists', lazy=True))
regitration_time = db.Column(db.DateTime, default=datetime.datetime.utcnow)
@aggregated('upcoming_shows', db.Column(db.Integer))
def num_upcoming_shows(self):
return db.func.count(Show.id)
upcoming_shows = db.relationship('Show',
primaryjoin='and_(Artist.id == Show.artist_id, cast(Show.start_time, Date) >= func.current_date())',
order_by='Show.start_time')
@aggregated('past_shows', db.Column(db.Integer))
def num_past_shows(self):
return db.func.count(Show.id)
past_shows = db.relationship('Show',
primaryjoin='and_(Artist.id == Show.artist_id, cast(Show.start_time, Date) < func.current_date())',
order_by='Show.start_time')
shows = db.relationship('Show', cascade="delete", backref=db.backref('artist', lazy=True))
class Recipe(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=True)
user = db.relationship('User', backref=db.backref('recipes', lazy=True))
recipe_name = db.Column(String(150), nullable=False, unique=True)
recipe_description = db.Column(Text)
preparation_time = db.Column(db.Integer)
cooking_time = db.Column(db.Integer)
servings = db.Column(db.Integer)
category_id = db.Column(db.Integer,
db.ForeignKey('category.id'),
nullable=False)
category = db.relationship('Category',
backref=db.backref('recipes', lazy=True))
course_id = db.Column(db.Integer,
db.ForeignKey('course.id'),
nullable=False)
course = db.relationship('Course',
backref=db.backref('recipes', lazy=True))
cuisine_id = db.Column(db.Integer,
db.ForeignKey('cuisine.id'),
nullable=False)
cuisine = db.relationship('Cuisine',
backref=db.backref('recipes', lazy=True))
author_id = db.Column(db.Integer,
db.ForeignKey('author.id'),
nullable=False)
author = db.relationship('Author',
backref=db.backref('recipes', lazy=True))
image_filename = db.Column(db.String, default=None, nullable=True)
image_url = db.Column(db.String, default=None, nullable=True)
def __init__(self, user, recipe_name, recipe_description, preparation_time,
cooking_time, servings, category, course, cuisine, author,
image_filename, image_url):
self.user = user
self.recipe_name = recipe_name
self.recipe_description = recipe_description
self.preparation_time = preparation_time
self.cooking_time = cooking_time
self.servings = servings
self.category = category
self.course = course
self.cuisine = cuisine
self.author = author
self.image_filename = image_filename
self.image_url = image_url
def __repr__(self):
return '<Recipe %r>' % self.recipe_name
class Comment(db.Model):
__tablename__ = 'comment'
id = db.Column(db.Integer,primary_key=True,autoincrement=True) ##评论ID
content = db.Column(db.Text,nullable=False) ##评论内容
itemid = db.Column(db.Integer,db.ForeignKey('item.id')) ##评论物品的ID
ownerid = db.Column(db.Integer,db.ForeignKey('user.id')) ##评论发布者ID
create_time = db.Column(db.DateTime,default=datetime.now) ##评论发布时间
item = db.relationship('Item',backref=db.backref('comments',order_by=id.desc())) ##评论物品
owner = db.relationship('User',backref=db.backref('comments')) ##评论发布者
class User(db.Model):
__tablename__ = 'user'
usertel = db.Column(db.String(11), primary_key=True)
username = db.Column(db.String(20), nullable=False)
userpsw = db.Column(db.String(10), nullable=False)
usersex = db.Column(db.Boolean, nullable=False)
useremail = db.Column(db.String(30))
useravatar = db.Column(db.String(100))
userjob = db.Column(db.String(20))
# relationship
userrecord = db.relationship('Userrecord', backref=db.backref("user"))
rentrecord = db.relationship('Rentrecord', backref=db.backref("user"))
class Team(db.Model, IdModel):
__tablename__ = 'team'
name = Column(String, unique=True)
users = db.relationship('User', backref=db.backref('team'))
class Colonne(db.Model):
numCol = db.Column(db.Integer, primary_key=True)
graphId = db.Column(db.Integer, db.ForeignKey('graphique.graphId'))
graphique = db.relationship("Graphique",
backref=db.backref("colonnes", lazy="dynamic"))
colName = db.Column(db.String(255))
dateDebut = db.Column(db.Date())
dateFin = db.Column(db.Date())
agregatSimple = db.Column(db.String(255))
capteur_id = db.Column(db.Integer, db.ForeignKey('capteur.captId'))
capteur = db.relationship("Capteur")
def __repr__(self):
return "<Colonne (%d) (%s) >" % (self.numCol, self.colName)
@property
def aggreger(self):
return agregats.get(self.agregatSimple, lambda x: 0)
@property
def valeurs(self):
valeurs = [m.valeur for m in self.capteur.mesures.all()]
if not self.agregatSimple:
return valeurs
else:
v = self.aggreger(valeurs)
return [v for _ in range(len(self.capteur.mesures.all()))]
@property
def valeurs_datees(self):
return list(zip(self.dates, self.valeurs))
@property
def dates(self):
return [m.date for m in self.capteur.mesures.all()]
class MonsterCard(Card):
__tablename__ = 'monsters'
attack = db.Column(db.String(4))
defense = db.Column(db.String(4))
stars = db.Column(db.Integer)
attribute = db.Column(db.Enum('dark', 'divine', 'earth', 'fire', 'light', 'water', 'wind', name='attribute'))
species = db.Column(db.Enum('aqua', 'beast', 'beast-warrior', 'creator god', 'cyberse', 'dinosaur', 'divine-beast', 'dragon', 'fairy', 'fiend', 'fish', 'insect', 'machine', 'plant', 'psychic', 'pyro', 'reptile', 'rock', 'sea serpent', 'spellcaster', 'thunder', 'warrior', 'winged beast', 'wyrm', 'zombie'))
types = db.relationship('MonsterType', secondary=monsterstypes, backref=db.backref('monsters', lazy='dynamic'))
__mapper_args__ = {'polymorphic_identity': 'monster'}
def __init__ (self, codepass, name, text, image, thumbnail, illegal, has_name_condition, attack, defense, stars, attribute, species):
self.codepass = codepass
self.name = name
self.text = text
self.image = image
self.thumbnail = thumbnail
self.illegal = illegal
self.has_name_condition = has_name_condition
self.attack = attack
self.defense = defense
self.stars = stars
self.attribute = attribute
self.species = species
class Capteur(db.Model):
captId = db.Column(db.Integer, primary_key=True)
cName = db.Column(db.String(100))
cTel = db.Column(db.String(20))
cType = db.Column(db.String(100))
frequence = db.Column(db.Float(5, 2))
formule = db.Column(db.String(255))
owner_id = db.Column(db.Integer, db.ForeignKey('user.id'), index=True)
owner = db.relationship('User',
backref=db.backref('capteurs', lazy='dynamic'))
# méthode d'affichage
def __repr__(self):
return "<Capteur (%d) %s>" % (self.captId, self.cName)
@property
def position(self):
return self.positions.first()
def serialize(self):
return {
'captId': self.captId,
'cName': self.cName,
'cTel': self.cTel,
'cType': self.cType,
'frequence': self.frequence,
'formule': self.frequence,
'pos_x': self.position.position_x,
'pos_y': self.position.position_y,
}
class Pin(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
source = db.Column(db.String(255), nullable=False)
code = db.Column(db.String(255), nullable=False)
# 所在的机器
address = db.Column(db.String(255))
create_time = db.Column(db.DateTime, nullable=False, default=datetime.datetime.now)
expire_time = db.Column(db.DateTime)
remain_try_times = db.Column(db.Integer)
user = db.relationship('User', backref=db.backref('pins', order_by=db.desc(create_time)))
__table_args__ = (
UniqueConstraint('user_id', 'source', name='_user_source'),
)
@classmethod
def create_code(cls, length):
"""
创建code
:return:
"""
chars = '0123456789'
return ''.join([random.choice(chars) for i in xrange(length)])
def __unicode__(self):
return u'<%s %s-%s-%s>' % (type(self).__name__, self.user_id, self.source, self.code)
class Kindness(db.Model):
__tablename__ = "Kindness"
id_kindness = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(50))
identifier = db.Column(db.String(40), unique=True, nullable=False)
body = db.Column(db.Text, nullable=False)
latitude = db.Column(db.Float, nullable=False)
longitude = db.Column(db.Float, nullable=False)
post_date = db.Column(db.DateTime, default=datetime.datetime.now)
user_id = db.Column(db.Integer, db.ForeignKey('Users.id'), nullable=False)
unnamed = db.Column(db.Boolean, default=False)
likes = db.relationship('Likes', backref='likes', lazy='dynamic')
files = db.relationship('Kindness_Files', backref='file', lazy=True)
tags = db.relationship('Tags',
secondary=kindness_tags_association,
lazy='subquery',
backref=db.backref('kindness', lazy=True))
def __repr__(self):
return '<Kindness {}>'.format(self.title)
def to_json(self):
return {
"idPost": self.identifier,
"title": self.title,
"body": self.body,
"latitude": self.latitude,
"longitude": self.longitude,
"postDate": self.post_date,
"userId": self.user_id
}
class SavedRecipe(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user = db.relationship('User',
backref=db.backref('savedrecipes', lazy=True))
recipe_id = db.Column(db.Integer,
db.ForeignKey('recipe.id', ondelete="CASCADE"),
nullable=False)
recipe = db.relationship('Recipe',
backref=db.backref('savedrecipes', lazy=True))
UniqueConstraint('user_id', 'recipe_id', name='savedrecipe_user_recipe_uc')
def __init__(self, user, recipe):
self.user = user
self.recipe = recipe
class Readability(db.Model):
__tablename__ = 'readability'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# foreignKey link with table 'user'
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
url_add = db.Column(db.String(500), nullable=False)
readability_rate = db.Column(db.Integer, nullable=False)
# relation link with Class 'User'
user = db.relationship('User', backref=db.backref('readability'))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship(
'Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
class Organism(db.Model, IdModel):
__tablename__ = 'organism'
common_name = Column(String, nullable=False)
latin_name = Column(String)
embl_name = Column(String)
reference_genomes = db.relationship('ReferenceGenome',
backref=db.backref('organism'))
class Graphique(db.Model):
graphId = db.Column(db.Integer, primary_key=True)
uId = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship("User",
backref=db.backref("graphiques", lazy="dynamic"))
titre = db.Column(db.String(255))
def __repr__(self):
return "<Graphique (%d) (%d) (%s) >" % (self.graphId, self.uId,
self.titre)
class Tasks(db.Model):
id = db.Column(db.Integer, primary_key=True)
teams_id = db.Column(db.ForeignKey("teams.id"), nullable=False)
team = db.relationship("Teams",
foreign_keys=[teams_id],
backref=db.backref("Tasks"))
name = db.Column(db.String(124), unique=False, nullable=False)
items = db.Column(db.String(512), unique=False, nullable=True)
def __repr__(self):
return '<Task %r>' % self.name
class DataSet(db.Model, IdModel):
__tablename__ = 'dataset'
location = Column(String)
filetype = Column(String)
experiment_id = Column(Integer, ForeignKey('experiment.id'))
tool_id = Column(Integer, ForeignKey('tool.id'))
files = db.relationship('DataFile', backref=db.backref('dataset'))
class Item(db.Model):
__tablename__ = 'item'
id = db.Column(db.Integer,primary_key=True,autoincrement=True) ##物品ID
name = db.Column(db.String(30),nullable=False) ##物品名称
description = db.Column(db.Text,nullable=True) ##物品详细描述
price = db.Column(db.Float,nullable=False) ##物品价格
imgpath = db.Column(db.String(300),nullable=True) ##物品图片url
ownerid = db.Column(db.Integer,db.ForeignKey('user.id')) ##物品发布者id
owner = db.relationship('User',backref=db.backref('items')) ##物品发布者
create_time = db.Column(db.DateTime,default=datetime.now) ##物品发布时间
isclosed = db.Column(db.Integer,nullable=False,default=0) ##物品交易是否被关闭，1为关闭
class Buy(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user = db.relationship('User', backref=db.backref('users', lazy=True))
product_id = db.Column(db.Integer,
db.ForeignKey('product.id'),
nullable=False)
product = db.relationship('Product',
backref=db.backref('products', lazy=True))
n_items = db.Column(db.Integer, nullable=False)
def __init__(self, user, product, n_items):
self.user = user
self.product = product
self.n_items = n_items
def __repr__(self):
return "<Buy %r:%r>" % (self.user, self.product)
class Comment(db.Model):
__tablename__ = 'comment'
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(500), nullable=False)
# created = db.Column(db.DateTime(timezone=True), nullable=False)
# modified = db.Column(db.DateTime(timezone=True), nullable=False)
created = db.Column(ArrowType, nullable=False)
modified = db.Column(ArrowType, nullable=False)
# http://docs.sqlalchemy.org/en/rel_1_0/orm/basic_relationships.html
thread_id = db.Column(db.Integer,
db.ForeignKey('thread.id'),
nullable=False)
author_id = db.Column(db.Integer,
db.ForeignKey('author.id'),
nullable=False)
likes = db.Column(db.Integer, default=0)
dislikes = db.Column(db.Integer, default=0)
parent_id = db.Column(db.Integer,
db.ForeignKey('comment.id'),
nullable=True)
children = db.relationship('Comment',
backref=db.backref('parent', remote_side=[id]))
hidden = db.Column(db.Boolean(), default=False)
def set_vote(self, author_id, like):
vote = db.session.query(Vote).filter_by(comment_id=self.id,
author_id=author_id).first()
if vote:
if vote.like == like:
# Vote exists and is the same
return True
else:
# Vote exists but changed
vote.like = like
if like:
# changed to a like
self.likes += 1
self.dislikes -= 1
else:
# changed to a dislike
self.likes -= 1
self.dislikes += 1
else:
# New vote
vote = Vote(comment_id=self.id, author_id=author_id, like=like)
db.session.add(vote)
if like:
self.likes += 1
else:
self.dislikes += 1
db.session.commit()
class Measurement(db.Model):
__tablename__ = 'measurements'
id = db.Column(db.Integer, primary_key=True)
time = db.Column(db.DateTime, nullable=True)
heart_rate = db.Column(db.Integer)
gram_id = db.Column(db.Integer, db.ForeignKey('gram.id'), nullable=False)
gram = db.relationship('Gram', backref=db.backref('measurements', lazy=True))
@staticmethod
def get_all_measurements():
return Measurement.query.all()
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer(), primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=UsersRoles,
backref=db.backref('users', lazy='dynamic'))
def __str__(self):
return self.email
class Mesure(db.Model):
capt_id = db.Column(db.Integer,
db.ForeignKey('capteur.captId'),
primary_key=True)
capteur = db.relationship('Capteur',
backref=db.backref('mesures', lazy='dynamic'))
date = db.Column(db.DateTime,
index=True,
primary_key=True,
server_default=db.func.now(),
default=datetime.datetime.utcnow)
valeur = db.Column(db.Float)
class Profile(db.Model):
def __init__(self, name, address, phone):
self.name = name
self.address = address
self.phone = phone
id = db.Column(db.String(), primary_key=True, default=str(uuid.uuid4()))
name = db.Column(db.String())
address = db.Column(db.String())
phone = db.Column(db.String())
user_id = db.Column(db.String(), db.ForeignKey('user.id'))
user = db.relationship('User',
backref=db.backref('profile', uselist=False))
class Geolocalisation(db.Model):
position_x = db.Column(db.Float)
position_y = db.Column(db.Float)
capt_id = db.Column(db.Integer,
db.ForeignKey('capteur.captId'),
primary_key=True)
capteur = db.relationship('Capteur',
backref=db.backref('positions', lazy='dynamic'))
date = db.Column(db.DateTime,
primary_key=True,
index=True,
server_default=db.func.now(),
default=datetime.datetime.utcnow)
class Blogpost(db.Model):
id = db.Column(db.Integer, primary_key=True)
parentId = db.Column(db.Integer, default=-1)
title = db.Column(db.String(100))
text = db.Column(db.Text())
date = db.Column(db.DateTime())
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
replies = db.relationship('Blogpost',
secondary=replies,
primaryjoin='Blogpost.id==replies.c.original_id',
secondaryjoin='Blogpost.id==replies.c.reply_id',
backref=db.backref('posts', lazy='dynamic'),
lazy='dynamic')
def __init__(self, user_id, text, date, title=''):
self.user_id = user_id
self.title = title
self.text = text
self.date = date
def set_parentId(self, pid):
self.parentId = pid
def __repr__(self):
return '<Blogpost - {}>'.format(self.title)
def serialize(self):
if self.user_id != None:
user = User.query.get(self.user_id)
delta = datetime.datetime.now() - self.date
diff = ''
if delta.days > 0:
diff = str(int(delta.days)) + ' day(s) ago'
else:
diff_time = delta.seconds
if diff_time < 60:
diff = str(int(delta.seconds)) + ' second(s) ago'
elif diff_time < 3600:
diff = str(int(delta.seconds / 60)) + ' minute(s) ago'
else:
diff = str(int(delta.seconds / 3600)) + ' second(s) ago'
return {
'id': self.id,
'username': user.username,
'fname': user.first_name,
'title': self.title,
'text': self.text,
'date': diff,
'parentId': self.parentId
}
class Article(db.Model):
__tablename__ = 'article'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(100), nullable=False)
content = db.Column(db.String(5000), nullable=False)
url_add = db.Column(db.String(500), nullable=False)
date_tweeter = db.Column(db.String(100), nullable=False)
tf_idf = db.Column(db.String(100), nullable=False)
key_words = db.Column(db.String(100), nullable=False)
# new_feature1 = db.Column(db.Integer,nullable=True)
#foreignKey link with table 'user'
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
#relation link with Class 'User'
user = db.relationship('User', backref=db.backref('articles'))
class Author(db.Model):
id = db.Column(db.Integer, primary_key=True)
author_name = db.Column(String(150), nullable=False, unique=True)
country_id = db.Column(db.Integer,
db.ForeignKey('country.id'),
nullable=False)
country = db.relationship('Country',
backref=db.backref('authors', lazy=True))
def __init__(self, author_name):
self.author_name = author_name
def __repr__(self):
return '<Author %r>' % self.author_name
