class User(db.Model, UserMixin):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32), unique=True, nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
password = db.Column(db.String(128), nullable=False)
is_admin = db.Column(db.Integer, default=0, nullable=False) # 是否管理员 0 不是 1 是
status = db.Column(db.Integer, default=1, nullable=False) # 是否有效 0 无效 1有效
roles = db.relationship(
"Role",
secondary=user_role,
lazy='subquery',
backref=db.backref('users', lazy=True),
)
# 功能模块-用户关联部分
# 定义一对多关系
# blogs: 一个用户有多个博客，字段：复数
# author：一篇博客只能属于一个用户，字段：单数
blogs = db.relationship(
'Blog',
backref='author',
)
def __repr__(self):
return self.username
class Admin(db.Model, UserMixin):
"""Admin model for the admins.
The admin model is extended by the UserMixin model supplied by the
Flask-Login package. The UserMixin model contains several commonly
used fields like is_authenticated, is_annonymous, and others which
are commonly needed for authenticating a user.
The application requires atleast one superadmin throughout its life-
cycle as only they can create or remove other admins. Default value
of is_superadmin is false.
An Admin is related to two other models so far. First one is to a
Staff through one-to-many relationship. An Admin can create many
staffs. Another is to the GithubAccessHistory, also through a one-
to-many relationship. An Admin can invoke or revoke permissions of
many Staffs many times.
Any history of invoking or revoking github permissions on any staff
by the Admin can be accessed through github_actions field.
"""
__tablename__ = 'admins'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(128), nullable=False, unique=True)
password = db.Column(db.String(128), nullable=False)
is_superadmin = db.Column(db.Boolean(), default=True, nullable=False)
added_staffs = db.relationship('Staff', backref='added_by')
github_actions = db.relationship('GithubAccessHistory', backref='action_by')
def __init__(self, email, password, is_super=False):
self.email = email
self.password = password
self.is_superadmin = is_super
class Staff(db.Model):
"""Staff model for the staffs.
Staff is a simple model for the staffs, where each staff is
identified by his email. It contains a github_status field
which contains the current access status of the staff to the
organization's github repositories. This field can contain
one of the following values:
1. 'uninvited': the staff has not been invited yet
2. 'pending': the staff is invited but not accepted invitation
3. 'granted': the staff has access to the github repos
This model is backreferenced by an Admin who created the Staff.
During initialization, it is required to pass the Admin through
added_by parameter.
Any history of invoked or revoked permissions on this Staff can be
accessed through github_actions field.
"""
__tablename__ = 'staffs'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(128), nullable=False, unique=True)
github_status = db.Column(db.String(128), nullable=False)
admin_id = db.Column(db.Integer, db.ForeignKey('admins.id'))
github_actions = db.relationship('GithubAccessHistory', backref='action_on')
def __init__(self, email, added_by, github_status='uninvited'):
self.email = email
self.github_status = github_status
self.added_by = added_by
class JobDetail(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(500))
href = db.Column(URLType)
main_text = db.Column(db.Text)
salary = db.Column(db.String(50))
skill_tag = db.Column(db.String(500))
sector = db.Column(db.String(200))
newbie = db.Column(db.Boolean)
career = db.Column(db.String(50))
deadline = db.Column(db.Date)
company_name = db.Column(db.String(100))
company_address = db.Column(db.String(500))
logo_image = db.Column(db.String(500))
big_company = db.Column(db.Boolean)
platform = db.Column(db.String(100))
crawl_date = db.Column(db.DateTime)
@property
def get_data(self):
dictionary = self.__dict__
try:
del dictionary['_sa_instance_state']
if dictionary['deadline'] != None:
dictionary['deadline'] = str(dictionary['deadline'])
dictionary['crawl_date'] = str(dictionary['crawl_date'])
dictionary['skill_tag'] = dictionary['skill_tag'].split(',')
except:
pass
return dictionary
class TokenMapping(db.Model):
__tablename__ = "user_token_mapping"
id = db.Column(db.Integer,
primary_key=True,
nullable=False,
unique=True,
autoincrement=True)
uuid = db.Column(db.String(40), nullable=False)
token = db.Column(db.String(250), nullable=False)
created = db.Column(db.DateTime, nullable=False, default=datetime.now)
modified = db.Column(db.DateTime, nullable=False, default=datetime.now)
def __init__(self, uuid, token):
self.uuid = uuid
self.token = token
class Resume(db.Model):
id = db.Column(db.Integer, primary_key=True)
main_flag = db.Column(db.Boolean, nullable=False)
mongo_key = db.Column(db.String(100), nullable=False)
user_id = db.Column(db.String(32), db.ForeignKey('user.id'))
@property
def get_data(self):
dictionary = self.__dict__
try:
del dictionary['_sa_instance_state']
dictionary['user_id'] = self.user_id.hex
except:
pass
return dictionary
class GithubAccessHistory(db.Model):
"""History of Github access permission by Admins on Staffs.
Contains all the detailed invoked or revoked histories of
github permission on staffs. The action field will contain any
comments about the action such as invoked permission, revoked
permission, cancelled pending, etc.
This model is backreferenced by Admin through action_by field,
and Staff through action_on field. Therefore, the Admin and the
Staff related to a particular history should be supplied to the
initializer through the respected arguments.
admin_id and staff_id will then automatically contain the ids of
respective models related to the particular history.
"""
__tablename__ = 'githubaccesshistory'
id = db.Column(db.Integer, primary_key=True)
action = db.Column(db.String(128), nullable=False)
datetime = db.Column(db.DateTime, nullable=False)
admin_id = db.Column(db.Integer, db.ForeignKey('admins.id'))
staff_id = db.Column(db.Integer, db.ForeignKey('staffs.id'))
def __init__(self, action, datetime, action_by, action_on):
self.action = action
self.datetime = datetime
self.action_by = action_by
self.action_on = action_on
class Role(db.Model):
__tablename__ = 'user_role'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(15), nullable=False)
cname = db.Column(db.String(30))
def __init__(self, role_id, name, cname=None):
self.id = role_id
self.name = name
self.cname = cname
@staticmethod
def _get_name(role_id):
role = db.session.query(Role).filter(Role.id == role_id).first()
return role.cname
class Blog(db.Model):
__tablename__ = 'blog'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(64), unique=True)
content = db.Column(db.Text, )
author_id = db.Column(db.Integer, db.ForeignKey('user.id'), comment=u'作者')
def __repr__(self):
return self.title
class User(db.Model):
id = db.Column(UUIDType(binary=False), default=uuid.uuid4, primary_key=True)
# use a regular string field, for which we can specify a list of available choices later on
type = db.Column(db.String(100))
# fixed choices can be handled in a number of different ways:
enum_choice_field = db.Column(db.Enum(EnumChoices), nullable=True)
sqla_utils_choice_field = db.Column(ChoiceType(AVAILABLE_USER_TYPES), nullable=True)
sqla_utils_enum_choice_field = db.Column(ChoiceType(EnumChoices, impl=db.Integer()), nullable=True)
first_name = db.Column(db.String(100))
last_name = db.Column(db.String(100))
# some sqlalchemy_utils data types (see https://sqlalchemy-utils.readthedocs.io/)
email = db.Column(EmailType, unique=True, nullable=False)
website = db.Column(URLType)
ip_address = db.Column(IPAddressType)
currency = db.Column(CurrencyType, nullable=True, default=None)
timezone = db.Column(TimezoneType(backend='pytz'))
dialling_code = db.Column(db.Integer())
local_phone_number = db.Column(db.String(10))
featured_post_id = db.Column(db.Integer, db.ForeignKey('post.id'))
featured_post = db.relationship('Post', foreign_keys=[featured_post_id])
@hybrid_property
def phone_number(self):
if self.dialling_code and self.local_phone_number:
number = str(self.local_phone_number)
return "+{} ({}) {} {} {}".format(self.dialling_code, number[0], number[1:3], number[3:6], number[6::])
return
@phone_number.expression
def phone_number(cls):
return sql.operators.ColumnOperators.concat(cast(cls.dialling_code, db.String), cls.local_phone_number)
def __str__(self):
return "{}, {}".format(self.last_name, self.first_name)
def __repr__(self):
return "{}: {}".format(self.id, self.__str__())
class Tree(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64))
# recursive relationship
parent_id = db.Column(db.Integer, db.ForeignKey('tree.id'))
parent = db.relationship('Tree', remote_side=[id], backref='children')
def __str__(self):
return "{}".format(self.name)
class Role(db.Model):
__tablename__ = 'role'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32), unique=True, nullable=False)
status = db.Column(db.Integer, default=1, nullable=False) # 是否有效 0 无效 1有效
def __repr__(self):
return self.name
def __str__(self):
return self.name
class CompanyInfo(db.Model):
__tablename__ = "company_info"
id = db.Column(db.Integer, primary_key=True)
crawl_date = db.Column(db.DateTime)
name = db.Column(db.String(200))
sector = db.Column(db.String(200))
scale = db.Column(db.String(200))
employees = db.Column(db.String(100))
establishment_date = db.Column(db.Date)
review_count = db.Column(db.Integer)
star_point = db.Column(db.Float)
salary_count = db.Column(db.Integer)
salary_average = db.Column(db.Integer)
interview_count = db.Column(db.Integer)
interview_level = db.Column(db.String(100))
interview_feel = db.Column(db.String(100))
def __str__(self):
return "{}".format(self.name)
@property
def get_data(self):
dictionary = self.__dict__
try:
del dictionary['_sa_instance_state']
dictionary['crawl_date'] = str(dictionary['crawl_date'])
dictionary['establishment_date'] = str(
dictionary['establishment_date'])
except:
pass
return dictionary
class Operation(db.Model):
"""
可以把此看作权限表，但我将其定义为 操作某种资源(资源的定义参考 restfull api设计理念)的一系列动作，
如 查看 某个 资源， 如 新增 一个资源
而把 某动作 授予 某个角色，即完成了权限的管理(绑定)
"""
__tablename__ = 'operation'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
method = db.Column(db.String(32), default='GET', )
uri = db.Column(db.String(256), default='/', nullable=False)
roles = db.relationship(
"Role",
secondary=role_operation,
lazy='subquery',
backref=db.backref('operations', lazy=True),
)
description = db.Column(db.Text, comment=u'描述信息')
def __repr__(self):
return self.name
class User(db.Model):
id = db.Column(UUIDType(binary=False),
default=uuid.uuid4,
primary_key=True)
password = db.Column(db.String(128))
auth = db.Column(db.String(100))
email = db.Column(EmailType, unique=True, nullable=False)
nickname = db.Column(db.String(100), nullable=False)
thumbnail = db.Column(URLType, default='/static/img/wdticon.png')
create_date = db.Column(db.DateTime)
resume = db.relationship('Resume')
@property
def is_authenticated(self):
return True
@property
def is_admin(self):
if self.auth == u'admin':
return True
else:
return False
@property
def is_active(self):
return True
@property
def is_anonymous(self):
return False
def get_id(self):
return self.id
# Required for administrative interface
def __unicode__(self):
return self.username
class Selector(db.Model):
__tablename__ = 'user_selector'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50), nullable=False)
cname = db.Column(db.String(50))
kind = db.Column(db.String(50))
def __init__(self, name, cname, kind):
self.name = name
self.cname = cname
self.kind = kind
def _to_dict(self):
return {
col.name: getattr(self, col.name, None)
for col in self.__table__.columns
}
@staticmethod
def _from_dict(selector_dict):
return Selector(name=selector_dict.get('name'),
cname=selector_dict.get('cname'),
kind=selector_dict.get('kind'))
class Group(db.Model):
__tablename__ = 'user_group'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50), nullable=False)
cname = db.Column(db.String(100))
selectors = db.Column(db.Text)
def __init__(self, name, cname=None, selectors=None):
self.name = name
self.cname = cname
self.selectors = selectors
def _to_dict(self):
return {
col.name: getattr(self, col.name, None)
for col in self.__table__.columns
}
@staticmethod
def _from_dict(group_dict):
return Group(name=group_dict.get('name'),
cname=group_dict.get('cname'),
selectors=group_dict.get('selectors'))
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(120))
text = db.Column(db.Text, nullable=False)
date = db.Column(db.Date)
# some sqlalchemy_utils data types (see https://sqlalchemy-utils.readthedocs.io/)
background_color = db.Column(ColorType)
created_at = db.Column(ArrowType, default=arrow.utcnow())
user_id = db.Column(UUIDType(binary=False), db.ForeignKey(User.id))
user = db.relationship(User, foreign_keys=[user_id], backref='posts')
tags = db.relationship('Tag', secondary=post_tags_table)
def __str__(self):
return "{}".format(self.title)
class JobSector(db.Model):
__tablename__ = "jobsector"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200))
skills = db.relationship('JobSkill', secondary=skills_sector_table)
def __str__(self):
return "{}".format(self.name)
@property
def get_data(self):
dictionary = self.__dict__
try:
del dictionary['_sa_instance_state']
except:
pass
return dictionary
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(70), unique=True, nullable=False)
email = db.Column(db.String(100), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
type = db.Column(db.String(15), unique=True, nullable=True)
class User(UserMixin, db.Model):
__tablename__ = 'user_user'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50), nullable=False)
cname = db.Column(db.String(50))
email = db.Column(db.String(200))
mobile = db.Column(db.String(50))
department = db.Column(db.String(200))
# company = db.Column(db.String(200))
# rid = db.Column(db.Integer)
group_ids = db.Column(db.String(250))
password = db.Column(db.String(100))
scan_key = db.Column(db.String(100))
created = db.Column(db.DateTime, nullable=False, default=datetime.now)
modified = db.Column(db.DateTime, nullable=False, default=datetime.now)
status = db.Column(db.Boolean, default=True)
def __init__(self,
name,
cname=None,
email=None,
mobile=None,
department=None,
group_ids=None,
password=None,
scan_key=None,
status=None):
self.name = name
self.cname = cname
self.email = email
self.mobile = mobile
self.department = department
# self.company = company
# self.rid = rid
self.group_ids = group_ids
self.password = password
self.scan_key = scan_key
self.status = status
def _to_dict(self):
return dict(id=self.id,
name=self.name,
cname=self.cname,
email=self.email,
mobile=self.mobile,
department=self.department,
group_ids=self.group_ids,
status=self.status)
@staticmethod
def _from_dict(user_dict):
return User(name=user_dict.get('name'),
cname=user_dict.get('cname'),
email=user_dict.get('email'),
mobile=user_dict.get('mobile'),
department=user_dict.get('department'),
group_ids=user_dict.get('group_ids'),
status=user_dict.get('status'))
def gen_password_hash(self, password):
return generate_password_hash(password)
def check_password_hash(self, password):
return check_password_hash(self.password, password)
def gen_auth_token(self):
s = Serializer(SECRET_KEY, expires_in=SESSION_LIFETIME)
return s.dumps({'name': self.name})
def generate_auth_uuid(self):
token = self.gen_auth_token()
s_uuid = uuid.uuid1()
l_uuid = str(s_uuid).split('-')
s_uuid = ''.join(l_uuid)
tokenMapping = TokenMapping(
uuid=s_uuid,
token=token,
)
db.session.add(tokenMapping)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
logger.error(e)
return s_uuid
class Social(db.Model):
id = db.Column(db.String(128), primary_key=True)
name = db.Column(db.String(100), primary_key=True)
user_id = db.Column(db.String(32), db.ForeignKey('user.id'))