class Post(db.Model):
postID = db.Column(db.Integer, primary_key=True)
topicID = db.Column(db.Integer, db.ForeignKey(Topic.topicID))
postingUser = db.Column(db.String(20), db.ForeignKey(User.username))
description = db.Column(db.String(800), nullable=False)
upvoteCount = db.Column(db.Integer, default=0)
createdTime = db.Column(db.DateTime, default=datetime.datetime.now)
postType = db.Column(db.String(10), nullable=False)
@property
def serialize(self):
"""Return object data in easily serializable format"""
return {
'postID': self.postID,
'topicID': self.topicID,
'postingUser': self.postingUser,
'description': self.description,
'upvoteCount': self.upvoteCount,
'createdTime': self.createdTime,
'postType': self.postType,
'timeAgo': self.time_ago
}
@property
def time_ago(self):
import timeago, datetime
now = datetime.datetime.now()
if self.createdTime:
return timeago.format(self.createdTime, now)
def __repr__(self):
return "<Post {}>".format(self.description)
class Cidades(db.Model):
__tablename__ = 'cidades'
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(100))
idmicroregiao = db.Column(db.Integer, db.ForeignKey('microregiao.id'))
iduf = db.Column(db.Integer, db.ForeignKey('uf.id'))
microregiao = db.relationship("MicroRegiao")
class Post(db.Model):
__tablename__ = "posts"
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('User', foreign_keys=user_id) #campo de relacionamento |
def __init__(self, content, user_id):
self.content = content
self.user_id = user_id
def Follow(db.Model):
__tablename__ = "follow"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
follower_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('User', foreign_keys=user_id)
follower = db.relationship('User', foreign_keys=follower_id)
class Chat(db.Model):
__tablename__ = "chat"
id = db.Column(db.Integer, primary_key=True, nullable=False)
message = db.Column(db.String(), nullable=False)
sender = db.Column(db.Integer, db.ForeignKey('user.id'))
receiver = db.Column(db.Integer, db.ForeignKey('user.id'))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
def __init__(self,
message,
sender_id,
receiver_id,
timestamp=datetime.utcnow,
*args,
**kwargs):
self.message = message
self.sender = sender_id
self.receiver = receiver_id
def serialize(self):
return {
"sender": self.sender,
"receiver": self.receiver,
"message": self.message,
"timestamp": str(self.timestamp) + 'Z'
}
def __repr__(self):
return 'Chat object: sender {} and receiver {}'.format(
self.sender, self.receiver)
class Ingredientlist(db.Model):
# Definition of the models
id = db.Column(db.Integer, primary_key=True)
ingredient = db.Column(db.String(64), index=True, unique=True)
category_id = db.Column(db.Integer, db.ForeignKey('categorylist.id'))
supplier_id = db.Column(db.Integer, db.ForeignKey('supplierlist.id'))
bag_size = db.Column(db.Float, index=False, unique=False)
bag_cost = db.Column(db.Float, index=False, unique=False)
unit = db.Column(db.String(5), index=False, unique=False)
cost_unit = db.Column(db.Float, index=False, unique=False)
purchase_date = db.Column(db.DateTime)
first_entry = db.Column(db.DateTime)
last_update = db.Column(db.DateTime)
@staticmethod
def CostPerUnit(bag_size, bag_cost):
return bag_cost/bag_size
@staticmethod
def GetIngID(Ingredient):
ing = Ingredientlist.query.filter_by(ingredient=Ingredient).first()
return ing.id
def __repr__(self): # return id of ingredient
#results = self.ingredient + ':' + str(self.id)
results = self.ingredient
return results
##TODO define a function that will create a dictionnary with the key being a category
## and the value a list of ingredient that have that category
def GetIngredientbyCategory():
return True
class Comment(db.Model):
__tablename__ = "blog_comments"
comments_id = db.Column(db.INT, primary_key=True, autoincrement=True)
comments_contents = db.Column(db.String(300), unique=False)
comments_posttime = db.Column(db.DateTime)
parents_id = db.Column(db.String(300))
comments_level = db.Column(db.INT)
user_id = db.Column(db.INTEGER,
db.ForeignKey('blog_users.user_id')) # 关联用户userID
articls_id = db.Column(db.INTEGER,
db.ForeignKey('articls.articls_id')) # 关联用户userID
def __repr__(self):
return '<User %r>' % self.user_id
def __init__(self, comments_id, comments_contents, comments_posttime,
parents_id, comments_level, user_id, articls_id):
self.comments_id = comments_id
self.comments_contents = comments_contents
self.comments_posttime = comments_posttime
self.parents_id = parents_id
self.comments_level = comments_level
self.user_id = user_id
self.articls_id = articls_id
class Reaction(db.Model):
postID = db.Column(db.Integer,
db.ForeignKey(Post.postID),
primary_key=True)
reactingUser = db.Column(db.String(20),
db.ForeignKey(User.username),
primary_key=True)
reactionType = db.Column(db.String(10), default="upvote")
class Follow(db.Model):
__tablename__ ="follow"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
follower_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('User', foreign_keys=user_id)
follower = db.relationship('User', foreign_keys=follower_id)
class Message(db.Model):
id = db.Column(db.Integer, primary_key=True)
sender_id = db.Column(db.Integer, db.ForeignKey('user.id'))
recipient_id = db.Column(db.Integer, db.ForeignKey('user.id'))
body = db.Column(db.String(200))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
def __repr__(self):
return '<Message {}>'.format(self.body)
class Answer(db.Model):
__tablename__ = 'answer'
id = db.Column(db.Integer, primary_key=True, unique=True, nullable=False)
content = db.Column(db.Text, nullable=False)
question_id = db.Column(db.Integer, db.ForeignKey('question.message_id'))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
question = db.relationship('Question', backref='answere')
user = db.relationship('User', backref='answere')
class ManufStock(db.Model):
mStockid=db.Column(db.Integer, primary_key=True)
manufId=db.Column(db.Integer, db.ForeignKey(Manuf.manufId), unique=False)
availMedId=db.Column(db.Integer, db.ForeignKey(MedStock.medId), unique=False)
availMedName=db.Column(db.String(120), db.ForeignKey(MedStock.medName), unique=False)
availManufQnty=db.Column(db.Integer)
def __repr__(self):
return '<ManufStock {}>'.format(self.availMedName)
class OrderMedFor(db.Model):
orderId= db.Column(db.Integer, primary_key=True)
medId= db.Column(db.Integer, db.ForeignKey(MedStock.medId))
medName= db.Column(db.String(120), db.ForeignKey(MedStock.medName))
toManufId=db.Column(db.Integer, db.ForeignKey(Manuf.manufId))
wantQnty= db.Column(db.Integer)
byDate=db.Column(db.Date )
def __repr__(self):
return '<OrderMedFor {}>'.format(self.medName)
class BoughtBy(db.Model):
cusId= db.Column(db.Integer, primary_key=True)
cusName= db.Column(db.String(120), index=True, unique=True)
medId= db.Column(db.Integer, db.ForeignKey(MedStock.medId))
buyQnty= db.Column(db.Integer)
date= db.Column(db.Date, default=date.today())
CO1=db.Column(db.Integer, db.ForeignKey(MedStock.CO1))
totCost=buyQnty*CO1
def __repr__(self):
return '<BoughtBy {}>'.format(self.cusName)
class MedStock(db.Model):
medId=db.Column(db.Integer, primary_key=True)
medName=db.Column(db.String(120), index=True, unique=True)
manufId=db.Column(db.Integer, db.ForeignKey(Manuf.manufId))
manufName=db.Column(db.String(120), db.ForeignKey(Manuf.manufName))
availQnty=db.Column(db.Integer)
CO1=db.Column(db.Integer) # cost of 1
expDate=db.Column(db.Date )
def __repr__(self):
return '<MedStock {}>'.format(self.medName)
class Case(Base):
__tablename__ = "case"
type = db.Column(db.SmallInteger, default=1, comment="做扩展")
name = db.Column(db.String(32),
nullable=False,
unique=True,
comment="用例名称")
desc = db.Column(db.String(32), nullable=True, comment="desc")
request = db.Column(db.TEXT, comment="测试数据")
project_id = db.Column(db.Integer,
db.ForeignKey("project.id"),
comment="用例項目")
interface_id = db.Column(db.INT,
db.ForeignKey("interfaces.id"),
comment="用例的接口")
author = db.Column(db.String(32), default="", comment="创建者")
pwd = db.Column(db.String(200), nullable=True, comment="测试：报告地址")
def __init__(self,
name,
request,
pid=None,
project_id=None,
interface_id=None,
author=None,
desc=None):
self.name = name
self.request = request
self.project_id = project_id
self.desc = desc
self.author = author
self.interface_id = interface_id
self.project_id = pid
@property
def getInterfaceInfo(self):
interface = Interfaces.query.get(self.interface_id)
return interface
@property
def getProjectInfo(self):
p = Project.query.get(self.project_id)
return p
@classmethod
def assertName(cls, name):
res = cls.query.filter_by(name=name).first()
if res:
handelAbort("caseNamec存在")
def __repr__(self):
return f"name:{self.name}"
class SpecialRequest(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
stock_id = db.Column(db.Integer, db.ForeignKey('stock.id'), nullable=False)
original_quantity = db.Column(db.Integer, nullable=False)
qty = db.Column(db.Integer, nullable=False)
date_applied = db.Column(db.DateTime, nullable=False, default=datetime.now)
status = db.Column(db.Integer, default=0)
admins_comment = db.Column(db.Text, nullable=False, default="No Comments")
users_comment = db.Column(db.Text, nullable=False)
processed_by = db.Column(db.String(255),
nullable=False,
default='Not yet Processed')
class Follow(db.Model):
__tablename__ = 'follows'
follower_id = db.Column(db.Integer,
db.ForeignKey('users.user_id'),
primary_key=True)
followed_id = db.Column(db.Integer,
db.ForeignKey('users.user_id'),
primary_key=True)
timestamp = db.Column(db.DateTime, default=datetime.utcnow)
def __str__(self):
return "<table Follow %s>" % (self.follower_id)
__repr__ = __str__
class Detalle(db.Model):
__tablename__ = 'Detalle'
id = db.Column(db.Integer(), primary_key=True)
codProducto = db.Column(db.Integer,
db.ForeignKey('Productos.Codigo'),
nullable=False)
codingreso = db.Column(db.Integer, db.ForeignKey('Ingreso.cod_ingreso'))
codsalida = db.Column(db.Integer, db.ForeignKey('salida.Codigo'))
Docenas = db.Column(db.Integer, nullable=False)
Unidades = db.Column(db.Integer, nullable=False)
#relaciones
fk_producto = db.relationship("productos")
fk_Ingreso = db.relationship("ingreso")
fk_Salida = db.relationship("Salida")
class Friendship(db.Model):
__tablename__ = "friendship"
id = db.Column(db.Integer, nullable=False, primary_key=True)
from_id = db.Column(db.Integer, db.ForeignKey('user.id'))
to_id = db.Column(db.Integer, db.ForeignKey('user.id'))
status = db.Column(db.Boolean, default=False)
updated = db.Column(db.DateTime, index=True, default=datetime.utcnow)
__table_args__ = (db.UniqueConstraint('from_id', 'to_id',
name='relation'), )
def __repr__(self):
return "from {}, to {} status {}".format(self.from_id, self.to_id,
self.status)
class Article(db.Model):
__tablename__ = "articls"
articls_id = db.Column(db.INT, primary_key=True, autoincrement=True)
articls_title = db.Column(db.String(300), unique=False)
articls_desc = db.Column(db.String(64), nullable=True)
articls_contents = db.Column(db.Text, unique=False)
articls_posttime = db.Column(db.DateTime)
articls_category = db.Column(db.String(99), unique=False, default=None)
articls_headimg = db.Column(db.String(99), unique=False, default=None)
# user_id = db.Column(db.INTEGER, db.ForeignKey('admin_user.user_id')) # 关联用户userID
tag_id = db.Column(db.INTEGER, db.ForeignKey('tag.id')) # 关联标签ID
category_id = db.Column(db.INTEGER, db.ForeignKey('category.id')) # 关联分类ID
comment = db.relationship('Comment', backref='comment', lazy='dynamic')
tag = db.relationship('Tag', backref='tag')
category = db.relationship('Category', backref='status')
class Orders(db.Model):
__tablename__ = "orders"
id = db.Column(db.Integer, primary_key=True, nullable=False)
shop_id = db.Column(db.Integer, db.ForeignKey('shops.id'), nullable=False)
# instead of storing these attributes in the database, we will calculate them in run time, to reduce the number
# of changes made to the database (else, when one makes a change to line items, products, etc, these values all
# need to be recalculated
# total_price = db.Column(db.Float, nullable=False, index=True)
# total_cost = db.Column(db.Float, nullable=False, index=True)
# total_income = db.Column(db.Float, nullable=False, index=True)
lineItems = db.relationship('LineItems',
backref='bill',
lazy='dynamic',
cascade="save-update, merge, delete")
def __repr__(self):
return '<Order {}>'.format(self.id)
@staticmethod
def create_order(store):
order = Orders(shop_id=store.id)
db.session.add(order)
db.session.commit()
return order.id
class Products(db.Model):
__tablename__ = "products"
id = db.Column(db.Integer, primary_key=True, nullable=False)
shop_id = db.Column(db.Integer, db.ForeignKey('shops.id'), nullable=False)
product_name = db.Column(db.String(64), nullable=False)
price = db.Column(db.Float, nullable=False, index=True)
cost = db.Column(db.Float, nullable=False, index=True)
line_items = db.relationship('LineItems',
backref='type',
lazy='dynamic',
cascade="save-update, merge, delete")
def __repr__(self):
return '<Products {}>'.format(self.product_name)
@staticmethod
def create_product(name, store, price, cost):
product = Products.query.filter(Products.shop_id == store.id).filter(
Products.product_name == name).first()
if product is not None:
return False
product = Products(product_name=name,
shop_id=store.id,
price=price,
cost=cost)
db.session.add(product)
db.session.commit()
return product.id
class UF(db.Model):
__tablename__ = 'uf'
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(100))
sigla = db.Column(db.String(2))
idregiao = db.Column(db.Integer, db.ForeignKey('regiao.id'))
regiao = db.relationship("Regiao")
class Interfaces(Base):
__tablename__ = "interfaces"
interface_name = db.Column(db.String(32), nullable=False, comment="接口名")
interface_desc = db.Column(db.String(500), default="", comment='描述')
tester = db.Column(db.String(32), comment='测试人')
project_id = db.Column(db.INT, db.ForeignKey("project.id"))
case = db.relationship("Case", backref="interface", lazy="dynamic")
def __init__(self, name, desc, pid):
self.interface_desc = desc
self.interface_name = name
self.project_id = pid
@classmethod
def assertName(cle, name):
res = cle.query.filter_by(interface_name=name).first()
if res:
handelAbort("interface_name 重复!")
@classmethod
def assertIdExisted(cls, id):
p = cls.query.get(id)
if not p or p.status == 0:
handelAbort("interface 不存在或删除")
def delete(self):
self.status = self.DELETE_STATUS
try:
for case in self.case_records:
case.status = self.DELETE_STATUS
db.session.commit()
except Exception as e:
log.exception(e)
db.session.rollback()
class UMethod(Base):
__tablename__ = 'umethod'
project_id = db.Column(db.Integer,
db.ForeignKey("project.id"),
comment="項目Id")
name = db.Column(db.String(200), unique=True, comment="方法名称")
desc = db.Column(db.String(200), nullable=True, comment="方法描述")
body = db.Column(db.TEXT, comment="步骤step")
creator = db.Column(db.String(20), comment="创建人")
updater = db.Column(db.String(20), comment="修改人")
def __init__(self, pid, name, body, creator, desc=""):
# 验证projectID
Project.assertIdExisted(pid)
# 验证 name
self.assertName(name)
self.project_id = pid
self.name = name
self.desc = desc
self.body = body
self.creator = creator
def __repr__(self):
return f"name:{self.name}"
class User(Base):
__tablename__ = 'user'
username = db.Column(db.String(32), unique=True, index=True, comment="用户名")
password = db.Column(db.String(128))
email = db.Column(db.String(52), nullable=True, unique=False)
phone = db.Column(db.String(12), unique=False, nullable=True)
gender = db.Column(db.Boolean, default=True, nullable=True) # 1 男 2 女
admin = db.Column(db.Boolean, default=False)
# 所属部门
part = db.Column(db.Integer, db.ForeignKey("part.id"), nullable=True)
def __init__(self,
username,
password,
phone=None,
email=None,
partId=None,
admin=None,
gender=None):
self.username = username
self.part = partId
self.admin = admin
self.email = email
self.gender = gender
self.phone = phone
self.hash_password(password)
def get_userId(self):
return self.id
def is_superuser(self):
return self.admin
def hash_password(self, password):
self.password = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password, password)
def generate_auth_token(self, expires_in=30):
return jwt.encode({
'id': self.id,
'exp': time.time() + expires_in
},
current_app.config['SECRET_KEY'],
algorithm='HS256')
@staticmethod
def verify_token(token):
try:
data = jwt.decode(token,
current_app.config['SECRET_KEY'],
algorithms=['HS256'])
except:
return None
return User.query.get(data['id'])
def __repr__(self):
return f"username:{self.username}"
class User(db.Model):
__tablename = 'users'
id = db.Column(db.Integer, primary_key=True, index=True)
username = db.Column(db.String(64), unique=True)
role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
def __repr__(self):
return '<User %r>' % self.username
class Post(SearchableMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(140))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
__searchable__ = ['body']
def __repr__(self):
return '<Post {}>'.format(self.body)
class Family(db.Model):
"""
用户关联的族群实例
"""
__tablename__ = 'familyr'
f_id = db.Column(db.Integer, primary_key=True, autoincrement=True, comment="族群号")
f_member_num = db.Column(db.Integer, default=0, comment="族群人数")
f_create_time = db.Column(db.DateTime, default=datetime.now, comment="创建时间")
f_creator = db.Column(db.String(64), db.ForeignKey('user.u_email'), comment="族群的创建者的邮箱(id)")
u_name = db.Column(db.String(32), db.ForeignKey('user.u_email'), comment="创建者昵称")
def __init__(self, creator):
self.f_creator = creator
def save(self):
db.session.add(self)
db.session.commit()
class Metaatleta(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
descricao = db.Column(db.String(50), nullable=False)
create_on = db.Column(db.DateTime, default=datetime.datetime.now())
pesoinicial = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=2))
pesofinal = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=2))
percentual_gordura = db.Column(
db.NUMERIC(precision=8, asdecimal=False, scale=2))
nivelatividade = db.Column(
db.NUMERIC(precision=8, asdecimal=False, scale=2))
# 0-Harris Benedict Original 1-Harris Benedict Revisada 2-Mifflin St Jeor 3-Katch-McArdle
frmharrisbenedictoriginal = db.Column(db.String(1), nullable=False)
frmharrisbenedictrevisada = db.Column(db.String(1), nullable=False)
frmmifflin = db.Column(db.String(1), nullable=False)
frmkatch = db.Column(db.String(1), nullable=False)
valtmb = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=0))
valgcd = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=0))
# P-perda de peso G-ganho de peso
tipometa = db.Column(db.String(1), nullable=False)
valtotkclmeta = db.Column(db.NUMERIC(precision=8, asdecimal=False,
scale=0))
valtotkclexercicio = db.Column(
db.NUMERIC(precision=8, asdecimal=False, scale=0))
valalvocalorico = db.Column(
db.NUMERIC(precision=8, asdecimal=False, scale=0))
# Proteina
percproteina = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=2))
valkcalproteina = db.Column(
db.NUMERIC(precision=8, asdecimal=False, scale=2))
valgramasproteina = db.Column(
db.NUMERIC(precision=8, asdecimal=False, scale=2))
valgrkgproteina = db.Column(
db.NUMERIC(precision=8, asdecimal=False, scale=2))
# Carboidrato
perccarb = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=2))
valkcalcarb = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=2))
valgramascarbo = db.Column(
db.NUMERIC(precision=8, asdecimal=False, scale=2))
valgrkgcarbo = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=2))
# Gordura
percfat = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=2))
valkcalfat = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=2))
valgramasgordura = db.Column(
db.NUMERIC(precision=8, asdecimal=False, scale=2))
valgrkggordura = db.Column(
db.NUMERIC(precision=8, asdecimal=False, scale=2))
# A-Aberto F-Fechada
status = db.Column(db.String(1), nullable=False)
idatleta = db.Column(db.Integer,
db.ForeignKey('atleta.id', ondelete='CASCADE'))
atleta = db.relationship("Atleta", back_populates="metaatleta")
totaldiasprevisto = db.Column(db.Integer)
dataprevisaofinal = db.Column(db.DateTime)
datafinalizada = db.Column(db.DateTime)
pesofinalizado = db.Column(
db.NUMERIC(precision=8, asdecimal=False, scale=2))
