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 Subject(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True, nullable=False)
lessons = db.relationship('Lesson', backref='subject')
def __repr__(self):
return '<Subject %r>' % self.name
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 Authorization(db.Model):
__tablename__ = 'authorization'
id = db.Column(db.Integer, primary_key=True)
create_time = db.Column(db.DateTime, default=datetime.utcnow, index = True)
update_time = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, index = True)
name = db.Column(db.String(64))
root = db.Column(db.Integer)
class WatchRecord(db.Model):
__tablename__ = 'watch_record'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), index = True)
article_id = db.Column(db.Integer, db.ForeignKey('article.id'), index = True)
create_time = db.Column(db.DateTime, default=datetime.utcnow, index = True)
update_time = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, index = True)
class Surveyresponse(db.Model):
surveyResponseID = db.Column(db.Integer,
autoincrement=True,
primary_key=True)
surveyName = db.Column(db.String(100), nullable=True)
surveyID = db.Column(db.Integer,
db.ForeignKey('survey.surveyID'),
nullable=False)
studentID = db.Column(db.Integer,
db.ForeignKey('user.userID'),
nullable=False)
user = db.relationship('User', backref='response_student')
def __repr__(self):
return f"SurveyResponse('{self.surveyResponseID}')"
def get_response_id(self):
return '{}'.format(self.surveyResponseID)
def get_survey_id(self):
return '{}'.format(self.surveyID)
def get_survey_name(self):
return '{}'.format(self.surveyName)
def get_student_id(self):
return '{}'.format(self.studentID)
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 UrlConfigFile(db.Model):
__tablename__ = "url_configfile"
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.Text, nullable=False)
configfile_id = db.Column(db.Integer, db.ForeignKey('configfile.id'))
configfile = relationship("ConfigFile")
@classmethod
def regex_match(cls, url):
domain = get_tld(url,
as_object=True,
fail_silently=True,
fix_protocol=True).domain
# domain = get_tld(url, as_object=True).domain
print("[URL, DOMAIN]", url, domain)
url_models = db.session.query(UrlConfigFile).filter(
and_(UrlConfigFile.configfile.has(active=True),
UrlConfigFile.url.like(
"%{0}%".format(domain)))).limit(100).all()
for url_model in url_models:
m = re.match(url_model.url, url)
if m:
return url_model
def __init__(self, url, configfile):
self.url = url
self.configfile_id = configfile.id
self.configfile = configfile
class ConfigFilePost(Post):
__tablename__ = "configfile_post"
id = db.Column(db.Integer, db.ForeignKey('post.id'), primary_key=True)
title = db.Column(db.String(150), nullable=False)
configfile_id = db.Column(db.Integer, db.ForeignKey('configfile.id'))
configfile = relationship("ConfigFile")
__mapper_args__ = {
'polymorphic_identity': 'cfp',
}
def __repr__(self):
return "ConfigFilePost(%s)" % (self.title)
def __init__(self, title, configfile, *args, **kwargs):
"""
title : str
configfile : Class
user_id : int
"""
super().__init__(*args, **kwargs)
self.title = title
self.configfile = configfile
self.configfile_id = configfile.id
def jsonify(self):
out = super().jsonify()
out.update({
"title": self.title,
"configfile": self.configfile.jsonify()
})
return out
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 GeneralUser(User):
__tablename__ = "general_user"
id = db.Column(db.Integer, db.ForeignKey('user.id'), primary_key=True)
account_type = db.Column(db.String(10), default="regular")
views = relationship("ConfigFileView")
__mapper_args__ = {
'polymorphic_identity': 'gus',
}
def add_post(self, cls, *args, **kwargs):
new_post = cls(*args, **kwargs)
self.posts.append(new_post)
db.session.add(new_post)
db.session.commit()
return new_post
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
print("CREATING NEW GENERAL USER", general_user_permissions)
self.permissions.extend(general_user_permissions)
def jsonify(self):
out = super().jsonify()
out['account_type'] = self.account_type
return out
class Team(db.Model):
TeamID = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
size = db.Column(db.Integer)
def __rep__(self):
return f"team('{self.teamID}','{self.name})'"
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 Follow(db.Model):
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
init_id = db.Column(db.Integer, db.ForeignKey('user.id'))
respond_id = db.Column(db.Integer, db.ForeignKey('user.id'))
init = db.relationship('User', foreign_keys=[init_id])
respond = db.relationship('User', foreign_keys=[respond_id])
class ExternalPrice(Common, db.Model):
"""公司/单位专价模型"""
__tablename__ = 'external_price'
id = db.Column(db.Integer, index=True, primary_key=True)
product_id = db.Column(db.Integer,
db.ForeignKey('product.id'),
nullable=False)
company_id = db.Column(db.Integer,
db.ForeignKey('firm.id'),
nullable=False)
price = db.Column(db.DECIMAL(precision=9, decimal_return_scale=2),
default=0.00,
nullable=False,
comment='产品单价')
unit_id = db.Column(db.SMALLINT,
db.ForeignKey('product_unit.id'),
nullable=False,
comment='产品单位ID')
unit = db.relationship('ProductUnit', lazy='select')
def __init__(self, product_id: int, company_id: int, price: float,
unit_id: int):
self.product_id = product_id
self.company_id = company_id
self.price = price
self.unit_id = unit_id
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 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 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 Optionresponse(db.Model):
optionResponseID = db.Column(db.Integer,
autoincrement=True,
primary_key=True)
content = db.Column(db.Integer, nullable=False)
author_id = db.Column(db.Integer, nullable=False)
author_name = db.Column(db.String(20), nullable=False)
questionResponseID = db.Column(
db.Integer,
db.ForeignKey('questionresponse.questionResponseID'),
nullable=False)
questionresponse = db.relationship('Questionresponse',
backref='question_response')
def __repr__(self):
return f"Optionresponse('{self.optionResponseID}','{self.content}')"
def get_id(self):
return '{}'.format(self.optionResponseID)
def get_content(self):
return '{}'.format(self.content)
def get_author_name(self):
return '{}'.format(self.author_name)
def get_author_id(self):
return '{}'.format(self.author_id)
def get_question_response_id(self):
return '{}'.format(self.questionResponseID)
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 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 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 Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
default = db.Column(db.Boolean, default=False, index=True)
permissions = db.Column(db.Integer)
users = db.relationship('User', backref='role', lazy='dynamic')
@staticmethod
def insert_roles():
roles = {
'User':
(Permission.FOLLOW | Permission.COMMENT | Permission.POST_ARTICLE,
True),
'Moderator':
(Permission.FOLLOW | Permission.COMMENT | Permission.POST_ARTICLE
| Permission.MODIFY_COMMENT, False),
'Admin': (0xff, False)
}
for role in roles:
r = Role.query.filter_by(name=role).first()
if r is None:
r = Role()
# Be able to modify permissions
r.name = role
r.default = roles.get(role)[1]
r.permissions = roles.get(role)[0]
db.session.add(r)
db.session.commit()
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 ListingMappedImages(db.Model):
'''
Use this to join images to their corresponding listing image
'''
__tablename__ = "listing_mapped_images"
id = db.Column(db.Integer, primary_key=True)
listing = db.Column(db.Integer)
listing_image = db.Column(db.Integer)
class Link(PkModel):
__tablename__ = "links"
url = db.Column(db.String(500), nullable=False)
section_id = db.Column(db.Integer,
db.ForeignKey("sections.id"),
nullable=False) # noqa: W292
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
