class People(Common, db.Model):
"""人员模型"""
__tablename__ = 'people'
id = db.Column(db.Integer, index=True, primary_key=True)
name = db.Column(db.String(length=50), nullable=False, comment='人名')
telephone = db.Column(db.String(length=13), nullable=False, comment='联系方式')
company_id = db.Column(db.Integer,
db.ForeignKey('firm.id'),
nullable=False)
remarks = db.Column(db.String(length=255), default='', comment='人员备注')
order_form_all = db.relationship('OrderForm',
lazy='select',
backref='person')
def __init__(self,
name: str,
telephone: str,
company_id: int,
remarks: str = None):
self.name = name
self.telephone = telephone
self.company_id = company_id
self.remarks = remarks
class Survey(db.Model):
surveyID = db.Column(db.Integer, autoincrement=True, primary_key=True)
instructorName = db.Column(db.String(64), nullable=False)
name = db.Column(db.String(64), nullable=False)
date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
instructorID = db.Column(db.Integer,
db.ForeignKey('instructor.instructorID'),
nullable=False)
instructor = db.relationship('Instructor', backref='survey_instructor')
def __repr__(self):
return f"Survey('{self.instructorName}','{self.name})'"
def get_id(self):
return '{}'.format(self.surveyID)
def get_instructor(self):
return '{}'.format(self.instructorName)
def get_name(self):
return '{}'.format(self.name)
def get_date(self):
return '{}'.format(self.date)
class PlayListSongs(db.Model):
__tablename__ = 'playlistitem'
id = db.Column(db.String(), primary_key=True)
playlist_id = db.Column(db.String())
song_id = db.Column(db.String())
user_id = db.Column(db.String())
created = db.Column(db.DateTime())
updated = db.Column(db.DateTime())
def __init__(self, _id, playlist_id, song_id, user_id, created, updated):
self.id = _id
self.playlist_id = playlist_id
self.song_id = song_id
self.user_id = user_id
self.created = created
self.updated = updated
def __repr__(self):
return '<id {}>'.format(self.id)
def serialize(self):
return {
'id': self.id,
'song_id': self.song_id,
'user_id': self.user_id,
'playlist_id': self.playlist_id
}
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(100))
password = db.Column(db.String(128))
name = db.Column(db.String(120))
role = db.Column(db.String(120))
files = db.relationship('File', backref='owner', lazy=True,
cascade="all, delete, delete-orphan")
def set_hash(self, password):
self.password = generate_password_hash(password, method="sha256")
def check_hash(self, password):
return check_password_hash(self.password, password)
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Usuario(db.Model):
iusu_id = db.Column(db.Integer, primary_key=True)
vusu_nom = db.Column(db.String(100))
vusu_ape = db.Column(db.String(100))
vusu_usu = db.Column(db.String(100), unique=True)
vusu_cla = db.Column(db.String(32))
def generate_auth_token(self, expiration=6000):
s = Serializer(app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps({'id': self.iusu_id})
@staticmethod
def verify_auth_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
data = s.loads(token)
except SignatureExpired:
return None # token valido pero expiro
except BadSignature:
return None # token invalido
user = Usuario.query.get(data['id'])
return user
def __repr__(self):
return "<Usuario %r>" % self.vusu_usu
def login(self, clave):
return self.vusu_cla == clave
class Songs(db.Model):
__tablename__ = 'song'
id = db.Column(db.String(), primary_key=True)
title = db.Column(db.String())
artist = db.Column(db.String())
album = db.Column(db.String())
duration = db.Column(db.String())
created = db.Column(db.DateTime())
updated = db.Column(db.DateTime())
def __init__(self, _id, title, artist, album, duration, created, updated):
self.id = _id
self.title = title
self.artist = artist
self.album = album
self.duration = duration
self.created = created
self.updated = updated
def __repr__(self):
return '<id {}>'.format(self.id)
def serialize(self):
return {
'id': self.id,
'title': self.title,
'artist': self.artist,
'album': self.album,
'duration': self.duration
}
class File(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), index=True)
owner = db.Column(db.Integer, db.ForeignKey('user.id'))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
drive_file_id = db.Column(db.String(512))
def download(self):
return googledrive.download_file(self.name, self.drive_file_id)
def upload(file, image=False, fileimage=None):
savepath = os.path.join(UPLOAD_DIR, file.filename)
file.save(savepath)
drive_id_file = googledrive.upload_file(current_user.drive_folder_id,
UPLOAD_DIR, file.filename)
if image:
fileimage.save(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
'static', 'images', 'volume',
drive_id_file + '.jpg'))
os.remove(savepath)
return File(name=file.filename,
owner=current_user.id,
drive_file_id=drive_id_file)
def __repr__(self):
return '<File {}>'.format(self.name)
class Guia(db.Model):
igui_id = db.Column(db.Integer, primary_key=True)
dgui_fee = db.Column(db.DateTime)
cgui_ser = db.Column(db.String(3))
cgui_num = db.Column(db.String(11))
icli_id = db.Column(db.Integer, db.ForeignKey("contacto.id"))
contacto = db.relationship("Contacto",
backref=db.backref('guia', lazy='dynamic'))
tipo_id = db.Column(db.Integer, db.ForeignKey("guia_tipo.id"))
tipo = db.relationship("GuiaTipo",
backref=db.backref("guia", lazy="dynamic"))
cia_id = db.Column(db.Integer, db.ForeignKey("cia.id"))
cerrado = db.Column(db.Integer)
vgui_est = db.Column(db.String(11))
def __repr__(self):
return '<Guia %r-%r>' % (self.cgui_ser, self.cgui_num)
def getNumero(self):
if self.cerrado == 0:
return "EN PROCESO"
else:
return '%s-%s' % (self.cgui_ser, self.cgui_num)
def getFecha(self):
return self.dgui_fee.strftime('%d-%m-%Y')
def isAnulado(self):
return "N" if self.vgui_est == "GENERADO" else "S"
class CommonRoleInfo(db.Model):
"""
角色表
"""
__tablename__ = 'common_role_info'
id = db.Column(db.Integer, primary_key=True)
#角色代码
role_code = db.Column(db.String(64), unique=True)
#角色名称
role_name = db.Column(db.String(64))
#角色顺序
role_order = db.Column(db.Integer)
#备注
role_remark = db.Column(db.Text)
# 角色装
role_status = db.Column(db.Integer)
# 所属系统
sys_id = db.Column(db.Integer)
# 用户状态
status = db.Column(db.Integer)
# 操作人
operate_user_id = db.Column(db.Integer)
# 操作时间
operate_time = db.Column(db.DateTime(), default=datetime.now)
def __repr__(self):
return '<common_role_info %r>' % self.role_name
class CommonMenuOptInfo(db.Model):
"""
菜单操作表
"""
__tablename__ = 'common_menu_opt_info'
id = db.Column(db.Integer, primary_key=True)
#操作编号
menu_id = db.Column(db.Integer)
#操作代码
opt_code = db.Column(db.String(64))
#操作名称
opt_name = db.Column(db.String(64))
#操作url
opt_url = db.Column(db.String(64))
#操作方法
opt_method = db.Column(db.String(64))
#操作状态
opt_status = db.Column(db.Integer)
#操作备注
opt_remark = db.Column(db.String(64))
#排序
opt_order = db.Column(db.Integer)
# 状态
status = db.Column(db.Integer)
# 操作人
operate_user_id = db.Column(db.Integer)
# 操作时间
operate_time = db.Column(db.DateTime(), default=datetime.now)
def __repr__(self):
return '<common_org_info %r>' % self.opt_name
class Users(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32), unique=True)
password = db.Column(db.String(32), unique=False)
phone = db.Column(db.String(32), unique=True)
email = db.Column(db.String(32), unique=True)
token = db.Column(db.String(32), unique=True)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
login = db.Column(db.String(20))
email = db.Column(db.String(100), unique=True)
pw_hash = db.Column(db.String(64))
location = db.Column(db.String(40))
short_bio = db.Column(db.String(200))
def follow_state(self, other):
if self.id == other:
return 'self'
forward = Follow.query.filter_by(init_id=self.id,
respond_id=other).first()
if forward:
return 'following'
else:
return 'none'
@property
def grav_hash(self):
hash = hashlib.md5()
hash.update(self.email.strip().lower().encode('utf8'))
return hash.hexdigest()
@property
def jsonable(self):
return {'id': self.id, 'grav_hash': self.grav_hash, 'name': self.name}
class User(ExportableMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
enabled = db.Column(db.Boolean, default=True, nullable=False)
username = db.Column(db.String(80), unique=True, nullable=False)
fullname = db.Column(db.String(80), nullable=False)
email = db.Column(db.String(80), unique=True, nullable=False)
color = db.Column(db.String(20), default='black', nullable=False)
picture = db.Column(db.String(80), default='generic.png')
balance = db.Column(db.Float, default='0', nullable=False)
created = db.Column(db.DateTime, default=db.func.now())
transactions = db.relationship('Transaction',
backref='user',
order_by=lambda: Transaction.date.desc())
export_blacklist = ['fullname', 'email', 'transactions', 'created']
@property # short prefix of full name that allows a broad search (privacy)
def namePrefix(self):
return self.fullname[:3]
@property # hash email to allow comparisons (privacy)
def emailDigest(self):
return sha256(self.email.lower().encode('utf-8')).hexdigest()
@property
def lastActivity(self):
if self.transactions and len(self.transactions) > 0:
return self.transactions[0].date
return self.created
def __repr__(self):
return '<User {}>'.format(self.username)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(20))
pw_hash = db.Column(db.String(64))
photo = db.Column(db.BLOB)
photo_type = db.Column(db.String(50))
class User(UserMixin, db.Model):
""" модель пользователя """
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(100), nullable=False)
name = db.Column(db.String(254), nullable=False)
roles = db.relationship('Role', secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
user_client = db.relationship('UserClient', backref='user_client')
def __init__(self, **kwargs):
self.email = kwargs.get('email')
self.name = kwargs.get('name')
self.password = bcrypt.hash(kwargs.get('password'))
@classmethod
def authenticate(cls, email, password):
user = cls.query.filter(cls.email == email).one()
if not bcrypt.verify(password, user.password):
raise Exception('Invalid password')
return user
class ProFeedback(db.Model):
feedbackID = db.Column(db.Integer, autoincrement=True, primary_key=True)
surveyName = db.Column(db.String(64), nullable=False)
dt_time = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
content = db.Column(db.String(500), nullable=False)
userID = db.Column(db.Integer, db.ForeignKey('user.userID'))
surveyID = db.Column(db.Integer, db.ForeignKey('survey.surveyID'))
survey = db.relationship('Survey', backref='survey_feedback')
def __repr__(self):
return f"Feedback('{self.feedbackID}','{self.surveyName}')"
def get_id(self):
return '{}'.format(self.feedbackID)
def get_survey_name(self):
return '{}'.format(self.surveyName)
def get_content(self):
return '{}'.format(self.content)
def get_date(self):
return '{}'.format(self.dt_time)
def get_user_id(self):
return '{}'.format(self.userID)
def get_survey_id(self):
return '{}'.format(self.surveyID)
class Playlist(db.Model):
__tablename__ = 'playlist'
id = db.Column(db.String(), primary_key=True)
name = db.Column(db.String())
user_id = db.Column(db.String())
created = db.Column(db.DateTime())
updated = db.Column(db.DateTime())
def __init__(self, _id, name, user_id, created, updated):
self.id = _id
self.name = name
self.user_id = user_id
self.created = created
self.updated = updated
def __repr__(self):
return '<id {}>'.format(self.id)
def serialize(self):
return {
'id': self.id,
'name': self.name,
'user_id': self.user_id,
'created_date': self.created
}
class Producto(db.Model):
id = db.Column(db.Integer, primary_key=True)
serie = db.Column(db.String(255), unique=True)
familia_id = db.Column(db.Integer, db.ForeignKey("familia.id"))
familia = db.relationship("Familia",
backref=db.backref("producto", lazy="dynamic"))
marca_id = db.Column(db.Integer, db.ForeignKey("marca.id"))
marca = db.relationship("Marca",
backref=db.backref("producto", lazy="dynamic"))
modelo_id = db.Column(db.Integer, db.ForeignKey("modelo.id"))
modelo = db.relationship("Modelo",
backref=db.backref("producto", lazy="dynamic"))
tipo_id = db.Column(db.Integer, db.ForeignKey("tipo_producto.id"))
tipo = db.relationship("TipoProducto",
backref=db.backref("producto", lazy="dynamic"))
guia_id = db.Column(db.Integer, db.ForeignKey("guia.igui_id"))
guia = db.relationship("Guia",
backref=db.backref("producto", lazy="dynamic"))
producto_id = db.Column(db.Integer)
#producto_id = db.Column(db.Integer, db.ForeignKey("producto.id"))
#producto = db.relationship("Producto", backref=db.backref("producto", lazy="dynamic"))
capacidad = db.Column(db.String(255))
def __repr__(self):
return "<Producto %r>" % self.serie
class Question(db.Model):
questionID = db.Column(db.Integer, autoincrement=True, primary_key=True)
label = db.Column(db.String(64))
type = db.Column(db.String(10), nullable=False)
repetition = db.Column(db.String(15))
content = db.Column(db.String(300), nullable=True)
surveyID = db.Column(db.Integer,
db.ForeignKey('survey.surveyID'),
nullable=False)
survey = db.relationship('Survey', backref='survey_questions')
def __repr__(self):
return f"Question('{self.questionID}','{self.type}','{self.repetition}','{self.content}','{self.surveyID}')"
def get_id(self):
return '{}'.format(self.questionID)
def get_survey_id(self):
return '{}'.format(self.surveyID)
def get_label(self):
return '{}'.format(self.label)
def get_type(self):
return '{}'.format(self.type)
def get_repetition(self):
return '{}'.format(self.repetition)
def get_content(self):
return '{}'.format(self.content)
class Request(db.Model):
__tablename__ = "requests"
goal = db.Column(db.String(), nullable=False)
time = db.Column(db.String(), nullable=False)
name = db.Column(db.String(), nullable=False)
phone = db.Column(db.String(), nullable=False, primary_key=True)
class Resource(db.Model):
__tablename__ = "resources"
id = db.Column(db.Integer, primary_key=True)
filename = db.Column(db.String(50), nullable=False)
type = db.Column(db.String(50), nullable=False)
category = db.Column(db.String(50), nullable=False)
created_date = db.Column(
db.DateTime, default=datetime.datetime.now(), nullable=False
)
def set_hash(self, password):
self.password = generate_password_hash(password, method="sha256")
def check_hash(self, password):
return check_password_hash(self.password, password)
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Image(db.Model):
__tablename__ = "images"
id = db.Column(db.Integer, primary_key=True)
filename = db.Column(db.String(50), nullable=False)
thumbnail = db.Column(db.String(50), nullable=False)
file_size = db.Column(db.Integer, nullable=False)
file_width = db.Column(db.Integer, nullable=False)
file_height = db.Column(db.Integer, nullable=False)
create_date = db.Column(
db.DateTime, default=datetime.datetime.now(), nullable=False
)
def set_hash(self, password):
self.password = generate_password_hash(password, method="sha256")
def check_hash(self, password):
return check_password_hash(self.password, password)
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def getImage(self, image_id):
return Images.query.filter_by(id=image_id).first()
class Path(PkModel):
__tablename__ = "paths"
slug = db.Column(db.String(200), nullable=False)
title = db.Column(db.String(200), nullable=False)
sections = db.relationship("Section",
backref="section_path",
lazy=True,
cascade="all, delete-orphan")
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
is_visible = db.Column(db.Boolean, default=True)
like_list = db.relationship("LikeList",
backref="like_list_path",
lazy=True,
uselist=False)
bookmark_list = db.relationship("BookmarkList",
backref="bookmark_list_path",
lazy=True,
uselist=False)
def get_url(self):
return url_for("www.path",
username=self.path_user.username,
path_slug=self.slug)
class users(db.Model, UserMixin):
_id = db.Column("id", db.Integer, primary_key=True)
name = db.Column(db.String(100))
email = db.Column(db.String(100))
password = db.Column(db.String(100))
def __init__(self, name, email, password):
self.name = name
self.email = email
self.password = password
def __repr__(self):
return f"users('{self.name}', '{self.email}' ,'{self.password}')"
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
def verify_reset_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return users.query.get(user_id)
def get_name(self):
return self.name
def get_id(self):
return self._id
def get_email(self):
return self.email
class Article(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
intro = db.Column(db.String(300), nullable=False)
text = db.Column(db.Text, nullable=False)
date = db.Column(db.DateTime, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
class UserModel(db.Model):
"""用户对象"""
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(64),
index=True,
nullable=False,
unique=True,
comment="用户名称")
email = db.Column(db.String(120),
index=True,
nullable=False,
unique=True,
comment="用户有限")
password_hash = db.Column(db.String(128), nullable=False, comment="用户哈希密码")
is_active = db.Column(db.Boolean, default=True, comment="用户是否激活")
is_super = db.Column(db.Boolean, default=False, comment="用户是否管理员")
created_at = db.Column(db.DateTime, default=datetime.now, comment="创建时间")
updated_at = db.Column(db.DateTime,
default=datetime.now,
onupdate=datetime.now,
comment="更新时间")
@staticmethod
def generate_password(password):
"""密码哈希"""
return generate_password_hash(password)
@staticmethod
def check_password(password_hash, password):
"""检查密码"""
return check_password_hash(password_hash, password)
def __str__(self):
return '<User {}>'.format(self.username)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
password_hash = db.Column(db.String(100), nullable=False)
login = db.Column(db.String(100), nullable=False, unique=True)
posts = db.relationship('Posts', cascade="all, delete", backref='user')
def __repr__(self):
return f"{self.id}:{self.login}"
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), unique=True)
password = db.Column(db.String(200))
def __init__(self, name, password):
self.name = name
self.password = password
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
session_id = db.Column(db.String(300)) # 300 chosen randomly.
budget = db.Column(db.Integer)
city = db.Column(db.String(300))
date_period = db.Column(db.String(300))
number_rooms = db.Column(db.Integer)
class Cia(db.Model):
id = db.Column(db.Integer, primary_key=True)
ruc = db.Column(db.String(11), unique=True)
razon = db.Column(db.String(255), unique=True)
comercial = db.Column(db.String(255), unique=True)
def __repr__(self):
return '<Cia %r>' % self.comercial
