class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100), default="summer", unique=False)
telephone = db.Column(db.BigInteger, nullable=False)
password = db.Column(db.Integer, nullable=False) #d
class GroupProducts(db.Model):
__tablename__ = 'grupoprodutos'
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())
class News(db.Model):
__tablename__ = "News"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
news_cate = db.Column(db.String(300), unique=False)
news_title= db.Column(db.String(300), unique=False)
news_desc = db.Column(db.String(64), nullable=True)
news_content= db.Column(db.String(9999), unique=False)
news_img = db.Column(db.String(9999), unique=False, default=None)
news_imgcounts = db.Column(db.Integer, unique=False, default=None)
news_paltform = db.Column(db.String(64), nullable=True)
news_author = db.Column(db.String(64), nullable=True)
news_readcounts = db.Column(db.String(64), nullable=True)
crawled_time = db.Column(db.DateTime, nullable=True, default=datetime.now)
create_time = db.Column(db.DateTime, nullable=True, default=datetime.now)
def __repr__(self):
return '<User %r>' % self.id
def __init__(self, id, news_cate,news_title, news_desc, news_content,news_img, news_imgcounts, news_paltform,
news_author,crawled_time,create_time):
self.news_cate = news_cate
self.news_title = news_title
self.news_desc = news_desc
self.news_content = news_content
self.news_img = news_img
self.news_imgcounts = news_imgcounts
self.news_paltform = news_paltform
self.news_author = news_author
self.crawled_time = crawled_time
self.create_time = create_time
website_title = db.Column(db.String(191))
website_email = db.Column(db.String(191))
address = db.Column(db.Text)
logo = db.Column(db.String(191))
favicon = db.Column(db.String(191))
# ===========================================================================================
# Auth Models
# ===========================================================================================
# Here exists Many-to-Many relationship between User and Role
# Here exists Many-to-Many relationship between Role and Permission
# Here exists Many-to-Many relationship between User and Permission
roles_users = db.Table(
'roles_users', db.Column('user_id', db.Integer(),
db.ForeignKey('user.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id')))
permissions_roles = db.Table(
'permissions_roles',
db.Column('role_id', db.Integer(), db.ForeignKey('role.id')),
db.Column('permission_id', db.Integer(), db.ForeignKey('permission.id')))
permissions_users = db.Table(
'permissions_users',
db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
db.Column('permission_id', db.Integer(), db.ForeignKey('permission.id')))
class Permission(db.Model):
id = db.Column(db.Integer(), primary_key=True)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(191), unique=True)
password = db.Column(db.String(191))
username = db.Column(db.String(191))
full_name = db.Column(db.String(191))
phone = db.Column(db.String(191))
avatar = db.Column(db.String(191))
socketio_session_id = db.Column(db.String(191))
active = db.Column(db.Boolean(), default=True)
created_at = db.Column(db.DateTime(), default=datetime.utcnow())
verified_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
permissions = db.relationship('Permission',
secondary=permissions_users,
backref=db.backref('users', lazy='dynamic'))
def get_password_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
def verify_password_reset_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
def has_role(self, role_name):
role = Role.query.filter_by(name=role_name).first()
return True if role in self.roles else False
def has_permission(self, permission_name):
p = Permission.query.filter_by(name=permission_name).first()
if p in self.permissions:
return True
for role in self.roles:
if p in role.permissions:
return True
return False
def assign_role(self, role_name):
r = Role.query.filter_by(name=role_name).first()
self.roles.append(r)
def assign_permission(self, permission_name):
p = Permission.query.filter_by(name=permission_name).first()
self.permissions.append(p)
class Response(db.Model):
__tablename__ = "responses"
turkid = db.Column('turkid',
db.String(20),
unique=True,
index=True,
primary_key=True)
fundtype = db.Column('fundtype', db.String(20))
startdate = db.Column('startdate', db.DateTime)
enddate = db.Column('enddate', db.DateTime)
weeknumber = db.Column('weeknumber', db.Integer())
fundpastbalance = db.Column('fundpastbalance', db.Float())
salarypastbalance = db.Column('salarypastbalance', db.Float())
fundhistory = db.Column('fundhistory', ARRAY(db.Float()))
salaryhistory = db.Column('salaryhistory', ARRAY(db.Float()))
foodhistorysalary = db.Column('foodhistorysalary', ARRAY(db.Float()))
foodhistoryfund = db.Column('foodhistoryfund', ARRAY(db.Float()))
miscchoices = db.Column('miscchoices', ARRAY(db.Float()))
timespenthistory = db.Column('timespenthistory', ARRAY(db.Float()))
def __init__(self, turkid, fundtype):
self.turkid = turkid
self.fundtype = fundtype
self.startdate = datetime.utcnow()
self.enddate = datetime.utcnow()
self.weeknumber = 0
self.fundpastbalance = 100
self.salarypastbalance = 0
self.fundhistory = []
self.salaryhistory = []
self.foodhistoryfund = []
self.foodhistorysalary = []
self.miscchoices = []
self.timespenthistory = []
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
@property
def info(self):
info = {}
for key in [
"fundtype", "weeknumber", "fundpastbalance",
"salarypastbalance", "fundhistory", "salaryhistory",
"foodhistoryfund", "foodhistorysalary", "timespenthistory",
"miscchoices"
]:
info[key] = self.__dict__.get(key)
return info
@info.setter
def info(self, dict):
for key in [
"weeknumber", "fundpastbalance", "salarypastbalance",
"fundhistory", "salaryhistory", "foodhistoryfund",
"foodhistorysalary", "timespenthistory", "miscchoices"
]:
if key in ["fundpastbalance", "salarypastbalance"]:
setattr(self, key, float(dict[key]))
elif key == "weeknumber":
setattr(self, key, int(dict[key]))
else:
setattr(self, key, dict[key])
def get_id(self):
return self.turkid
def __repr__(self):
base = "MTurk ID = {}\n".format(self.turkid)
for key, value in self.info.items():
base += "{} = {}\n".format(key, value)
return base
__author__ = 'responsible'
from App import db
from flask.ext.security import UserMixin, RoleMixin
from passlib.handlers.django import django_pbkdf2_sha256
roles_users = db.Table('roles_users', # 用户权限中间表
db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id')))
class Role(db.Model, RoleMixin): # 权限表
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
def __init__(self, name, description):
self.name = name
self.description = description
class User(db.Model, UserMixin): # 用户表
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(11), nullable=False, unique=True)
password = db.Column(db.String(128), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic'))
def __init__(self, username=None, password=None, active=True):
self.username = username
self.password = django_pbkdf2_sha256.encrypt(password)
self.active = True
class VideoDeep(db.Model):
__tablename__ = "video_deep"
video_id = db.Column(db.String(200), primary_key=True)
account = db.Column(db.String(100), primary_key=True)
stand_time = db.Column(db.Time) # 视频停留时间
view_time = db.Column(db.DateTime, primary_key=True) # 浏览时间
class UserTag(db.Model):
__tablename__ = "user_tag"
account = db.Column(db.String(100),
db.ForeignKey("user.account"),
primary_key=True)
favorite_tag = db.Column(db.String(100), primary_key=True)
class Video(db.Model):
__tablename__ = "video"
id = db.Column(db.String(200), primary_key=True)
title = db.Column(db.String(255), unique=True)
url = db.Column(db.String(500), unique=True)
info = db.Column(db.Text) # 视频简介
release_time = db.Column(db.DateTime)
play_num = db.Column(db.BigInteger, default=1) # 播放量
like_num = db.Column(db.BigInteger, default=0) # 点赞量
comment_num = db.Column(db.BigInteger, default=0) # 评论数量
cover_url = db.Column(db.String(200))
# isChecked = db.Column(db.Boolean, default=False)
account = db.Column(db.String(100), db.ForeignKey('user.account')) # 上传者
tags = relationship("VideoTag", backref="video")
state = db.Column(db.String(50), default="未审核")
class LikesCollects(db.Model):
__tablename__ = "user_video_list"
account = db.Column(db.String(100), primary_key=True)
video_id = db.Column(db.String(200), primary_key=True)
if_like = db.Column(db.Boolean, default=False)
like_time = db.Column(db.DateTime)
class Dieta(db.Model):
__tablename__ = 'dieta'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
descricao = db.Column(db.String(50), nullable=False, unique=True)
data = db.Column(db.Date, nullable=False, default=datetime.datetime.now())
mesano = db.Column(db.String(8), nullable=False)
totalcarbo = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
totalproteina = db.Column(db.NUMERIC(precision=8, asdecimal=False,
scale=3))
totalgordura = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
totalfibras = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
totalsodio = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
totalcalorias = db.Column(db.NUMERIC(precision=8, asdecimal=False,
scale=3))
idrefeicao = db.Column(db.Integer, db.ForeignKey('refeicao.id'))
idmetaatleta = db.Column(db.Integer, db.ForeignKey('metaatleta.id'))
create_on = db.Column(db.DateTime, default=datetime.datetime.now())
dieta_refeicao = db.relationship('Refeicao')
metaatleta = db.relationship('Metaatleta')
class Steps(Base):
__tablename__ = 'steps'
case_id = db.Column(db.Integer,
db.ForeignKey('uicase.id'),
nullable=True,
comment='所属用例')
name = db.Column(db.String(200),
nullable=True,
unique=False,
comment="步骤名称")
desc = db.Column(db.String(200), nullable=True, comment="步骤描述")
is_method = db.Column(db.Integer, nullable=True, comment="方法")
type = db.Column(db.String(32), nullable=True, comment="步骤类型")
log = db.Column(db.String(100), nullable=True, comment="这步骤日志")
locator = db.Column(db.String(100), nullable=True, comment="步骤元素")
do = db.Column(db.String(32), nullable=True, comment='步驟操作')
value = db.Column(db.TEXT, nullable=True, comment="请求数据")
variable = db.Column(db.TEXT, nullable=True, comment="变量名称")
validate = db.Column(db.TEXT, nullable=True, comment="认证")
pic = db.Column(db.String(100), nullable=True, comment="截圖地址")
data = db.Column(db.String(100), nullable=True, comment="验证数据")
def __init__(self,
name=None,
desc=None,
is_method=None,
type=None,
locator=None,
do=None,
value=None,
variable=None,
validate=None):
self.name = name
self.desc = desc
self.is_method = is_method
self.type = type
self.locator = locator
if do:
do = self.assertDo(do)
else:
do = do
self.do = do
self.value = value
self.variable = variable
self.validate = validate
def assertDo(self, do: str):
if do not in DO:
handelAbort(f"Parameter:{do} not support")
return do
def __repr__(self):
return f"name:{self.name}"
class UICase(Base):
__tablename__ = 'uicase'
name = db.Column(db.String(200), unique=False, comment="用例名称")
desc = db.Column(db.String(200), nullable=True, default="", comment="用例描述")
creator = db.Column(db.String(20), comment="创建人")
headless = db.Column(db.Boolean, default=False, comment="是否无头测试,默认false")
windowsSize = db.Column(db.String(20),
default="1920,1080",
nullable=True,
comment="窗口大小")
# (stay,running,over)
state = db.Column(db.String(32), default="stay", comment="实时状态")
casesteps = db.relationship("Steps",
backref="uicase",
cascade='all,delete')
project_id = db.Column(db.Integer,
db.ForeignKey('project.id'),
comment='项目Id')
def __init__(self,
name: str,
creator: str,
project_id: str,
desc=None,
headless=None,
windowsSize=None):
self.name = name
self.desc = desc
self.project_id = project_id
self.creator = creator
self.headless = headless
if windowsSize:
self.windowsSize = windowsSize
def delete_steps(self):
try:
for step in self.steps_records:
db.session.delete(step)
db.session.commit()
except Exception as e:
log.exception(e)
db.session.rollback()
@property
def steps_records(self):
return self.casesteps
@property
def caseInfo(self):
info = {
"caseId":
self.id,
"name":
self.name,
"desc":
self.desc,
"creator":
self.creator,
"headless":
self.headless,
"windowsSize":
self.windowsSize,
"status":
self.status,
"state":
self.state,
"steps": [{
"id": s.id,
"name": s.name,
"desc": s.desc,
"methodId": s.is_method,
"type": s.type,
"locator": s.locator,
"do": s.do,
"value": s.value,
"variable": s.variable,
"validate": s.validate
} for s in self.casesteps]
}
return info
@property
def get_steps_info(self):
info = []
for step in self.casesteps:
data = {}
data['stepId'] = step.id
data['name'] = step.name
data['desc'] = step.desc
data['is_method'] = step.is_method
data['type'] = step.type
data['log'] = step.log
data['locator'] = step.locator
data['do'] = step.do
data['value'] = step.value
data['variable'] = step.variable
data['validate'] = step.validate
data['pic'] = step.pic
data['data'] = step.data
info.append(data)
data = {
"caseId": self.id,
'caseName': self.name,
'caseDesc': self.desc,
"caseCreator": self.creator,
"Headless": self.headless,
"windowsSize": self.windowsSize,
"state": self.state,
"status": self.status,
"PorjectId": self.project_id,
"caseSteps": info
}
return data
def __repr__(self):
return f"name:{self.name}"
class Manuf(db.Model):
manufId=db.Column(db.Integer, primary_key=True)
manufName=db.Column(db.String(120), index=True, unique=True)
def __repr__(self):
return '<Manuf {}>'.format(self.manufName)
class VideoTag(db.Model):
__tablename__ = "video_tag"
video_id = db.Column(db.String(200),
db.ForeignKey("video.id"),
primary_key=True)
relevant_tag = db.Column(db.String(100), primary_key=True)
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))
class Follow(db.Model):
__tablename__ = "user_follow"
account = db.Column(db.String(100), primary_key=True)
follower = db.Column(db.String(100), primary_key=True)
class Request(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)
accepted = db.Column(db.Boolean, default=False)
admins_comment = db.Column(db.Text, nullable=False, default="No Comments")
users_comment = db.Column(db.Text, nullable=False)
received_comment = db.Column(db.Text, default="No Comments")
processed_by = db.Column(db.String(255),
nullable=False,
default='Not yet Processed')
class Kartei(db.Model):
id = db.Column(db.Integer, primary_key=True)
id_brief = db.Column(db.Integer, index=True)
rezensionen = db.Column(db.Integer)
status = db.Column(db.String(LENGTH_S))
ist_link = db.Column(db.Integer)
link_jahr = db.Column(db.Integer)
link_monat = db.Column(db.Integer)
link_tag = db.Column(db.Integer)
pfad_OCR = db.Column(db.String(LENGTH_M))
pfad_PDF = db.Column(db.String(LENGTH_M))
anwender = db.Column(db.String(LENGTH_S))
zeit = db.Column(db.String(LENGTH_S))
def __init__(
self, id_brief=None, reviews=0, state=Config.S_OPEN,
path_ocr=None, path_pdf=None,
user=None,
time=datetime.now()
):
self.id_brief = id_brief
self.rezensionen = reviews
self.status = state
self.pfad_OCR = path_ocr
self.pfad_PDF = path_pdf
self.anwender = user
self.zeit = time
@staticmethod
def update_file_status(database, id_brief, state, user, t):
k = Kartei.query.filter_by(id_brief=id_brief).order_by(desc(Kartei.zeit)).first()
if k: database.add(Kartei(id_brief=id_brief, reviews=k.rezensionen+1, state=state, user=user, time=t))
else: database.add(Kartei(id_brief=id_brief, reviews=1, state=state, user=user, time=t))
database.commit()
def __repr__(self):
return "<Kartei {} {} {} {} {} {}>".format(
self.id, self.id_brief, self.rezensionen, self.status, self.pfad_OCR, self.pfad_PDF)
class Alimentos(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
descricao = db.Column(db.String(100), nullable=False)
umidades = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
calorias = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
joule = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
proteina = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
lipidios = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
colesterol = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
carboidrato = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
fibras = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
cinzas = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
calcio = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
magnesio = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
manganes = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
fosforo = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
ferro = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
sodio = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
potasio = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
cobre = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
zinco = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
retinol = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
re = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
rae = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
tiamina = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
riboflavina = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
piridoxina = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
niacina = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
vitaminac = db.Column(db.NUMERIC(precision=8, asdecimal=False, scale=3))
qtdgramasemcima = db.Column(
db.NUMERIC(precision=8, asdecimal=False, scale=3))
idpessoa = db.Column(db.Integer,
db.ForeignKey('pessoa.id', ondelete='CASCADE'))
pessoa = db.relationship("Pessoa")
idunalimento = db.Column(db.Integer,
db.ForeignKey('unidademedidaalimento.id'))
unalimento = db.relationship("Unalimento")
def __init__(self, descricao, umidades, calorias, joule, proteina,
lipidios, colesterol, carboidrato, fibras, cinzas, calcio,
magnesio, manganes, fosforo, ferro, sodio, potasio, cobre,
zinco, retinol, re, rae, tiamina, riboflavina, piridoxina,
niacina, vitaminac, qtdgramasemcima, idpessoa, idunalimento):
self.descricao = descricao
self.umidades = umidades
self.calorias = calorias
self.joule = joule
self.proteina = proteina
self.lipidios = lipidios
self.colesterol = colesterol
self.carboidrato = carboidrato
self.fibras = fibras
self.cinzas = cinzas
self.calcio = calcio
self.magnesio = magnesio
self.manganes = manganes
self.fosforo = fosforo
self.ferro = ferro
self.sodio = sodio
self.potasio = potasio
self.cobre = cobre
self.zinco = zinco
self.retinol = retinol
self.re = re
self.rae = rae
self.tiamina = tiamina
self.riboflavina = riboflavina
self.piridoxina = piridoxina
self.niacina = niacina
self.vitaminac = vitaminac
self.qtdgramasemcima = qtdgramasemcima
self.idpessoa = idpessoa
self.idunalimento = idunalimento
class Datum(db.Model):
id = db.Column(db.Integer, primary_key=True)
id_brief = db.Column(db.Integer, index=True)
jahr_a = db.Column(db.Integer, index=True)
monat_a = db.Column(db.Integer)
tag_a = db.Column(db.Integer)
jahr_b = db.Column(db.Integer, index=True)
monat_b = db.Column(db.Integer)
tag_b = db.Column(db.Integer)
bemerkung = db.Column(db.String(LENGTH_B))
anwender = db.Column(db.String(LENGTH_S))
zeit = db.Column(db.String(LENGTH_S))
def __init__(
self, id_brief=None, year_a=None, month_a=None,
day_a=None, year_b=None, month_b=None, day_b=None,
remark=None, user=None, time=datetime.now()
):
self.id_brief = id_brief
self.jahr_a, self.monat_a, self.tag_a = year_a, month_a, day_a
self.jahr_b, self.monat_b, self.tag_b = year_b, month_b, day_b
self.bemerkung, self.anwender, self.zeit = remark, user, time
def __repr__(self):
return '<Datum {} {} {} {} {} {} {} {} {} {} {}>'.format(
self.id, self.id_brief,
self.jahr_a, self.monat_a, self.tag_a,
self.jahr_b, self.monat_b, self.tag_b,
self.bemerkung, self.anwender, self.zeit
)
class Permission(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
from App import db, login_manager
from datetime import datetime
from flask_login import UserMixin
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
likes = db.Table('likes', db.Column('id', db.Integer,
db.ForeignKey('user.id')),
db.Column('movie_id', db.Integer, db.ForeignKey('movie.id')),
db.Column('rating_given', db.Integer, default=0))
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.png')
password = db.Column(db.String(60), nullable=False)
def __repr__(self):
return f"Name:{self.username},Email:{self.email},id:{self.id}"
class Movie(db.Model):
id = db.Column(db.Integer, primary_key=True)
class User(UserMixin, db.Model):
id_ = db.Column(db.String(30), primary_key=True) #goo
username = db.Column(db.String(20), primary_key=True) #goo
email = db.Column(db.String(50), unique=True) #goo
joinedOnDate = db.Column(db.DateTime,
default=datetime.datetime.now) #added
primaryPostCount = db.Column(db.Integer, default=0)
secondaryPostCount = db.Column(db.Integer, default=0)
profile_pic = db.Column(db.String(200)) #goo
fullname = db.Column(db.String(50), nullable=True) #goo
country = db.Column(db.String(20))
region = db.Column(db.String(20))
# dob=db.Column(db.DateTime, default=datetime.datetime.now)
# gender=db.Column(db.String(2), nullable=True)
# def avatar(self, size):
# digest = md5(self.email.lower().encode('utf-8')).hexdigest()
# return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(digest, size)
@hybrid_property
def total_points(self):
PRIMARY_POST_POINTS = 2
SECONDARY_POST_POINTS = 1
primaryPostCount = 0
secondaryPostCount = 0
if self.primaryPostCount: primaryPostCount = self.primaryPostCount
if self.secondaryPostCount:
secondaryPostCount = self.secondaryPostCount
return PRIMARY_POST_POINTS * primaryPostCount + SECONDARY_POST_POINTS * secondaryPostCount
@hybrid_property
def badge(self):
points = self.total_points
if points < 5:
BADGE = "Contributor"
elif points < 10:
BADGE = "Regular Contributor"
elif points < 50:
BADGE = "Great Contributor"
else:
BADGE = "Ace Contributor"
return BADGE
@property
def serialize(self):
"""Return object data in easily serializable format"""
return {
'username': self.username,
'email': self.email,
'totalPoints': self.total_points,
'badge': self.badge
}
def get_id(self):
return self.id_
def __repr__(self):
return "<User {}>".format(self.username)
class Movie(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
rating = db.Column(db.Float, nullable=False, default=0)
image = db.Column(db.String(90), nullable=False, default='default_img.png')
like = db.relationship('User',
secondary=likes,
backref=db.backref('like', lazy='dynamic'))
Genre = db.Column(db.String(100))
Action = db.Column(db.Integer, nullable=False)
Adventure = db.Column(db.Integer, nullable=False)
Animation = db.Column(db.Integer, nullable=False)
Comedy = db.Column(db.Integer, nullable=False)
Crime = db.Column(db.Integer, nullable=False)
Documentary = db.Column(db.Integer, nullable=False)
Drama = db.Column(db.Integer, nullable=False)
Family = db.Column(db.Integer, nullable=False)
Fantasy = db.Column(db.Integer, nullable=False)
Foreign = db.Column(db.Integer, nullable=False)
History = db.Column(db.Integer, nullable=False)
Horror = db.Column(db.Integer, nullable=False)
Music = db.Column(db.Integer, nullable=False)
Mystery = db.Column(db.Integer, nullable=False)
Romance = db.Column(db.Integer, nullable=False)
Science_Fiction = db.Column(db.Integer, nullable=False)
Tv_Movie = db.Column(db.Integer, nullable=False)
Thriller = db.Column(db.Integer, nullable=False)
War = db.Column(db.Integer, nullable=False)
Western = db.Column(db.Integer, nullable=False)
def __repr__(self):
return f"Movie:{self.name},rating:{self.rating}"
class Users(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, nullable=False)
user_name = db.Column(db.String(64), nullable=False, unique=True)
email = db.Column(db.String(64), nullable=False, unique=True)
access_key = db.Column(db.String(15), index=True, nullable=False)
# account premium level ---> could be used later to enable premium business model
premium_level = db.Column(db.Integer, nullable=False, default=0)
admin = db.Column(db.Boolean, nullable=False, default=False)
shops = db.relationship('Shops',
backref='owner',
lazy='dynamic',
cascade="save-update, merge, delete")
def __repr__(self):
return '<User {}>'.format(self.user_name)
# we could fill this function later to enable premium business model
# ex. each level of premium can own different number of shops etc.
def evaluate_premimum(self, action=""):
return True
def owned_shops(self):
return Shops.query.filter_by(user_id=self.id).all()
def owned_shop_ids(self):
return [shop.id for shop in self.owned_shops()]
def owned_products(self):
shops_ids = self.owned_shop_ids()
return Products.query.filter(Products.shop_id.in_(shops_ids)).all()
def owned_product_ids(self):
return [product.id for product in self.owned_products()]
def owned_orders(self):
shops_ids = self.owned_shop_ids()
return Orders.query.filter(Orders.shop_id.in_(shops_ids)).all()
def owned_order_ids(self):
return [product.id for product in self.owned_orders()]
def owned_items(self):
product_ids = self.owned_product_ids()
order_ids = self.owned_order_ids()
p_items = LineItems.query.filter(
LineItems.product_id.in_(product_ids)).all()
items = LineItems.query.filter(LineItems.order_id.in_(order_ids)).all()
for i in p_items:
is_duplicated = False
for _i in items:
if i.id == _i.id:
is_duplicated = True
break
if not is_duplicated:
items.append(i)
return items
def owned_item_ids(self):
return [item.id for item in self.owned_items()]
@staticmethod
def create_user(name, email, premium_level=1, admin=False, key=None):
user = Users.query.filter(Users.user_name == name
or Users.email == email).first()
if user is not None:
return False
# create a non existing random access key
if key is None:
while True:
key = ''.join([
random.choice(string.ascii_letters + string.digits)
for n in range(15)
])
u = Users.query.filter_by(access_key=key).first()
if u is None:
break
user = Users(user_name=name,
email=email,
access_key=key,
premium_level=premium_level,
admin=admin)
db.session.add(user)
db.session.commit()
return key, user.id
class Categoria(db.Model):
__tablename__ = 'categoria'
id = db.Column(db.Integer, primary_key=True, nullable=False)
Nombre = db.Column(db.String(15), nullable=False)
class Regiao(db.Model):
__tablename__ = 'regiao'
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(100))
sigla = db.Column(db.String(2))
__author__ = 'Alex Galani'
from App import db
from flask_security import UserMixin, RoleMixin
from passlib.hash import bcrypt
roles_users = db.Table(
'roles_users', db.Column('user_id', db.Integer(),
db.ForeignKey('user.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id')))
services_users = db.Table(
'services_users',
db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
db.Column('service_id', db.Integer(), db.ForeignKey('services.id')))
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
active = db.Column(db.Boolean(), default=True, nullable=False)
def __init__(self, name, description):
self.name = name
self.description = description
self.active = True
class User(db.Model, UserMixin):
__tablename__ = "user"
