class ProjectModel(SurrogatePK, Model):
# 表的名字:
__tablename__ = 'projects'
current_time = datetime.now()
status_close = 0
status_open = 1
task_audit_true = 1
task_audit_false = 0
# 表的结构:
id = db.Column(Integer, primary_key=True, autoincrement=True)
user_id = db.Column(Integer)
name = db.Column(String(100))
environment_id = db.Column(Integer)
space_id = db.Column(Integer)
status = db.Column(Integer)
master = db.Column(String(100))
version = db.Column(String(40))
excludes = db.Column(Text)
target_user = db.Column(String(50))
target_port = db.Column(String(20))
target_root = db.Column(String(200))
target_releases = db.Column(String(200))
server_ids = db.Column(Text)
task_vars = db.Column(Text)
prev_deploy = db.Column(Text)
post_deploy = db.Column(Text)
prev_release = db.Column(Text)
post_release = db.Column(Text)
keep_version_num = db.Column(Integer)
repo_url = db.Column(String(200))
repo_username = db.Column(String(50))
repo_password = db.Column(String(50))
repo_mode = db.Column(String(50))
repo_type = db.Column(String(10))
notice_type = db.Column(String(10))
notice_hook = db.Column(Text)
task_audit = db.Column(Integer)
created_at = db.Column(DateTime, default=current_time)
updated_at = db.Column(DateTime,
default=current_time,
onupdate=current_time)
def list(self,
page=0,
size=10,
kw=None,
space_id=None,
environment_id=None):
"""
获取分页列表
:param page:
:param size:
:return:
"""
query = self.query.filter(
ProjectModel.status.notin_([self.status_remove]))
if kw:
query = query.filter(ProjectModel.name.like('%' + kw + '%'))
# 关联 environments
EnvironmentModel = model.environment.EnvironmentModel
query = query.join(EnvironmentModel,
EnvironmentModel.id == ProjectModel.environment_id)
query = query.filter(
EnvironmentModel.status.notin_([self.status_remove]))
# 关联 spaces
SpaceModel = model.space.SpaceModel
query = query.join(SpaceModel, SpaceModel.id == ProjectModel.space_id)
query = query.filter(SpaceModel.status.notin_([self.status_remove]))
if environment_id:
query = query.filter(ProjectModel.environment_id == environment_id)
if space_id:
query = query.filter(ProjectModel.space_id == space_id)
query = query.add_columns(EnvironmentModel.name, SpaceModel.name)
count = query.count()
data = query.order_by(ProjectModel.id.desc()).offset(
int(size) * int(page)).limit(size).all()
project_list = []
for p in data:
item = p[0].to_json()
item['environment_name'] = p[1]
item['space_name'] = p[2]
project_list.append(item)
return project_list, count
def item(self, id=None):
"""
获取单条记录
:param role_id:
:return:
"""
id = id if id else self.id
data = self.query.filter(
ProjectModel.status.notin_([self.status_remove
])).filter_by(id=id).first()
current_app.logger.info(data)
if not data:
return []
project_info = data.to_json()
ServerModel = model.server.ServerModel
server_ids = project_info['server_ids']
project_info['servers_info'] = ServerModel.fetch_by_id(
map(int, server_ids.split(',')))
return project_info
def add(self, *args, **kwargs):
data = dict(*args)
current_app.logger.info(data)
project = ProjectModel(**data)
db.session.add(project)
db.session.commit()
return project.to_json()
self.id = project.id
return self.id
def update(self, *args, **kwargs):
# todo permission_ids need to be formated and checked
# a new type to update a model
update_data = dict(*args)
return super(ProjectModel, self).update(**update_data)
def remove(self, role_id=None):
"""
:param role_id:
:return:
"""
role_id = role_id if role_id else self.id
ProjectModel.query.filter_by(id=role_id).update(
{'status': self.status_remove})
ret = db.session.commit()
return ret
def to_json(self):
item = {
'id':
self.id,
'user_id':
self.user_id,
'name':
self.name,
'environment_id':
self.environment_id,
'space_id':
self.space_id,
'status':
self.status,
'master':
UserModel.fetch_by_uid(self.master.split(','))
if self.master else '',
'version':
self.version,
'excludes':
self.excludes,
'target_user':
self.target_user,
'target_port':
self.target_port,
'target_root':
self.target_root,
'target_releases':
self.target_releases,
'server_ids':
self.server_ids,
'task_vars':
self.task_vars,
'prev_deploy':
self.prev_deploy,
'post_deploy':
self.post_deploy,
'prev_release':
self.prev_release,
'post_release':
self.post_release,
'keep_version_num':
self.keep_version_num,
'repo_url':
self.repo_url,
'repo_username':
self.repo_username,
'repo_password':
self.repo_password,
'repo_mode':
self.repo_mode,
'repo_type':
self.repo_type,
'notice_type':
self.notice_type,
'notice_hook':
self.notice_hook,
'task_audit':
self.task_audit,
'created_at':
self.created_at.strftime('%Y-%m-%d %H:%M:%S'),
'updated_at':
self.updated_at.strftime('%Y-%m-%d %H:%M:%S'),
}
item.update(self.enable())
return item
def enable(self):
return {
'enable_view':
True,
'enable_update':
permission.role_upper_developer(),
'enable_delete':
permission.enable_uid(self.user_id)
or permission.role_upper_developer(),
'enable_create':
False,
'enable_online':
False,
'enable_audit':
False,
'enable_block':
False,
}
class TaskModel(SurrogatePK, Model):
__tablename__ = 'tasks'
current_time = datetime.now
# 状态：0新建提交，1审核通过，2审核拒绝，3上线中，4上线完成，5上线失败
status_new = 0
status_pass = 1
status_reject = 2
status_doing = 3
status_success = 4
status_fail = 5
status_memo = {
status_new: '新建提交',
status_pass: '******',
status_reject: '审核拒绝',
status_doing: '上线中',
status_success: '上线完成',
status_fail: '上线失败',
}
rollback_count = {}
keep_version_num = 3
# 表的结构:
id = db.Column(Integer, primary_key=True, autoincrement=True)
name = db.Column(String(100))
user_id = db.Column(Integer)
user_name = db.Column(String(10))
project_id = db.Column(Integer)
action = db.Column(Integer)
status = db.Column(Integer)
link_id = db.Column(String(100))
ex_link_id = db.Column(String(100))
servers = db.Column(Text)
commit_id = db.Column(String(40))
branch = db.Column(String(100))
tag = db.Column(String(100))
file_transmission_mode = db.Column(Integer)
file_list = db.Column(Text)
is_rollback = db.Column(Integer)
created_at = db.Column(DateTime, default=datetime.now)
updated_at = db.Column(DateTime,
default=datetime.now,
onupdate=datetime.now)
taskMdl = None
def table_name(self):
return self.__tablename__
#
# def list(self, page=0, size=10, kw=''):
# data = Task.query.order_by('id').offset(int(size) * int(page)).limit(size).all()
# return [p.to_json() for p in data]
#
# def one(self):
# project_info = Project.query.filter_by(id=self.taskMdl.get('project_id')).one().to_json()
# return dict(project_info, **self.taskMdl)
#
def list(self, page=0, size=10, space_id=None, user_id=None, kw=None):
"""
获取分页列表
:param page:
:param size:
:param kw:
:return:
"""
self.rollback_count.clear()
query = TaskModel.query.filter(
TaskModel.status.notin_([self.status_remove]))
if kw:
query = query.filter(TaskModel.name.like('%' + kw + '%'))
# 关联 projects
ProjectModel = model.project.ProjectModel
query = query.join(ProjectModel,
TaskModel.project_id == ProjectModel.id)
query = query.filter(ProjectModel.status.notin_([self.status_remove]))
# 关联 environments
EnvironmentModel = model.environment.EnvironmentModel
query = query.join(EnvironmentModel,
EnvironmentModel.id == ProjectModel.environment_id)
query = query.filter(
EnvironmentModel.status.notin_([self.status_remove]))
if space_id:
query = query.filter(ProjectModel.space_id == space_id)
if user_id:
query = query.filter(TaskModel.user_id.in_(user_id))
query = query.add_columns(ProjectModel.name, EnvironmentModel.name,
ProjectModel.keep_version_num)
count = query.count()
data = query.order_by(TaskModel.id.desc()) \
.offset(int(size) * int(page)).limit(size) \
.all()
task_list = []
for p in data:
p[0].keep_version_num = p[3]
item = p[0].to_json()
item['project_name'] = p[1]
item['environment_name'] = p[2]
# self.keep_version_num = p[3]
task_list.append(item)
return task_list, count
def item(self, id=None):
"""
获取单条记录
:param role_id:
:return:
"""
id = id if id else self.id
data = self.query.filter(TaskModel.status.notin_(
[self.status_remove])).filter_by(id=id).first()
if not data:
return []
task = data.to_json()
ProjectModel = model.project.ProjectModel
project = ProjectModel().item(task['project_id'])
task['project_name'] = project['name'] if project else '未知项目'
task['project_info'] = project
return task
def add(self, *args, **kwargs):
data = dict(*args)
project = TaskModel(**data)
db.session.add(project)
db.session.commit()
if project.id:
self.id = project.id
return project.to_json()
def update(self, *args, **kwargs):
update_data = dict(*args)
return super(TaskModel, self).update(**update_data)
def remove(self, id=None):
"""
:param role_id:
:return:
"""
id = id if id else self.id
self.query.filter_by(id=id).update({'status': self.status_remove})
ret = db.session.commit()
return ret
def to_json(self):
ServerModel = model.server.ServerModel
item = {
'id':
self.id,
'name':
self.name,
'user_id':
int(self.user_id),
'user_name':
self.user_name,
'project_id':
int(self.project_id),
'project_name':
self.project_id if self.project_id else '',
'action':
self.action,
'status':
self.status,
'link_id':
self.link_id,
'ex_link_id':
self.ex_link_id,
'servers':
self.servers,
'servers_info':
ServerModel.fetch_by_id(self.servers.split(','))
if self.servers else '',
'commit_id':
self.commit_id,
'branch':
self.branch,
'tag':
self.tag,
'file_transmission_mode':
self.file_transmission_mode,
'file_list':
self.file_list,
'is_rollback':
self.is_rollback,
'created_at':
self.created_at.strftime('%Y-%m-%d %H:%M:%S'),
'updated_at':
self.updated_at.strftime('%Y-%m-%d %H:%M:%S'),
}
item.update(self.enable())
return item
def enable(self):
is_project_master = self.project_id in session['project_master']
if self.project_id not in self.rollback_count:
self.rollback_count[self.project_id] = 0
if self.status in [
self.status_doing, self.status_fail, self.status_success
]:
self.rollback_count[self.project_id] += 1
if self.rollback_count[self.project_id] <= self.keep_version_num \
and self.status in [self.status_doing, self.status_fail, self.status_success] \
and self.ex_link_id:
enable_rollback = True
else:
enable_rollback = False
return {
'enable_view':
True if self.status in [
self.status_doing, self.status_fail, self.status_success
] else False,
'enable_update':
(permission.enable_uid(self.user_id)
or permission.role_upper_developer() or is_project_master)
and (self.status in [self.status_new, self.status_reject]),
'enable_delete':
(permission.enable_uid(self.user_id)
or permission.role_upper_developer() or is_project_master)
and (self.status
in [self.status_new, self.status_pass, self.status_reject]),
'enable_create':
False,
'enable_online':
(permission.enable_uid(self.user_id)
or permission.role_upper_developer() or is_project_master)
and (self.status
in [self.status_pass, self.status_fail, self.status_doing]),
'enable_audit':
(permission.role_upper_developer() or is_project_master)
and (self.status in [self.status_new]),
'enable_rollback':
enable_rollback
}
@classmethod
def task_default_status(cls, project_id):
ProjectModel = model.project.ProjectModel
project_info = ProjectModel.query.filter_by(id=project_id).first()
if project_info.task_audit == ProjectModel.task_audit_true:
return TaskModel.status_new
else:
return TaskModel.status_pass
class MemberModel(SurrogatePK, Model):
__tablename__ = 'members'
current_time = datetime.now()
group_id = None
project_id = None
source_type_project = 'project'
source_type_group = 'group'
# 表的结构:
id = db.Column(Integer, primary_key=True, autoincrement=True)
user_id = db.Column(Integer, db.ForeignKey('users.id'))
source_id = db.Column(Integer)
source_type = db.Column(String(10))
access_level = db.Column(String(10))
status = db.Column(Integer)
created_at = db.Column(DateTime, default=current_time)
updated_at = db.Column(DateTime, default=current_time, onupdate=current_time)
group_name = None
def spaces(self, user_id=None):
"""
获取分页列表
:param page:
:param size:
:return:
"""
SpaceModel = model.space.SpaceModel
filters = {
MemberModel.status.notin_([self.status_remove]),
MemberModel.source_type == self.source_type_group
}
query = self.query.filter(*filters).with_labels()\
.with_entities(MemberModel.source_id, MemberModel.access_level, SpaceModel.name)
if user_id:
query = query.filter_by(user_id=user_id)
query = query.join(SpaceModel, SpaceModel.id == MemberModel.source_id)
spaces = query.all()
current_app.logger.info(spaces)
return {space[0]: {'id': space[0], 'role': space[1], 'name': space[2]} for space in spaces}
def projects(self, user_id=None, space_id=None):
"""
获取分页列表
:param page:
:param size:
:return:
"""
filters = {
MemberModel.status.notin_([self.status_remove]),
MemberModel.source_type == self.source_type_project
}
query = self.query.filter(*filters)
if user_id:
query = query.filter_by(user_id=user_id)
projects = query.all()
current_app.logger.info(projects)
return projects
def project_master(self):
filters = {
MemberModel.status.notin_([self.status_remove]),
MemberModel.source_type == self.source_type_project,
MemberModel.user_id == current_user.id,
MemberModel.access_level == MASTER,
}
query = self.query.filter(*filters)
projects = query.with_entities(MemberModel.source_id).all()
current_app.logger.error(projects)
return [project[0] for project in projects]
def update_group(self, members, group_name=None):
SpaceModel = model.space.SpaceModel
# 修复空间名称
if group_name:
SpaceModel(id=self.group_id).update({'name': group_name})
# # 修改tag信息
# if group_name:
# tag_model = TagModel.query.filter_by(label='user_group').filter_by(id=self.group_id).first()
# if tag_model.name != group_name:
# tag_model.name = group_name
# 修改用户组成员
# clean up
filters = {
MemberModel.source_id == self.group_id,
MemberModel.source_type == self.source_type_group,
}
MemberModel.query.filter(*filters).delete()
current_app.logger.info(members)
# insert all
for member in members:
current_app.logger.info(member)
current_app.logger.info(member['role'])
update = {
'user_id': member['user_id'],
'source_id': self.group_id,
'source_type': self.source_type_group,
'access_level': member['role'].upper(),
'status': self.status_available,
}
m = MemberModel(**update)
db.session.add(m)
ret = db.session.commit()
return ret
def update_project(self, project_id, members, group_name=None):
space_info = model.project.ProjectModel.query.filter_by(id=project_id).first().to_json()
space_members, count, user_ids = self.members(group_id=space_info['space_id'])
update_uids = []
for member in members:
update_uids.append(member['user_id'])
current_app.logger.info(user_ids)
current_app.logger.info(update_uids)
# project新增用户是否在space's group中,无则抛出
if list(set(update_uids).difference(set(user_ids))):
raise WalleError(Code.user_not_in_space)
# 修改用户组成员
# clean up
filters = {
MemberModel.source_id == project_id,
MemberModel.source_type == self.source_type_project,
}
MemberModel.query.filter(*filters).delete()
# insert all
for member in members:
insert = {
'user_id': member['user_id'],
'source_id': project_id,
'source_type': self.source_type_project,
'access_level': member['role'].upper(),
'status': self.status_available,
}
group = MemberModel(**insert)
db.session.add(group)
ret = db.session.commit()
return ret
def members(self, group_id=None, project_id=None, page=0, size=10, kw=None):
"""
获取单条记录
:param role_id:
:return:
"""
group_id = group_id if group_id else self.group_id
project_id = project_id if project_id else self.project_id
source_id = group_id if group_id else project_id
source_type = self.source_type_group if group_id else self.source_type_project
query = UserModel.query \
.filter(UserModel.status.notin_([self.status_remove])) \
.filter(MemberModel.source_id == source_id) \
.filter(MemberModel.source_type == source_type)
query = query.join(MemberModel, UserModel.id == MemberModel.user_id)
if kw:
query = query.filter(or_(UserModel.username.like('%' + kw + '%'), UserModel.email.like('%' + kw + '%')))
query = query.add_columns(MemberModel.access_level, UserModel.id)
count = query.count()
data = query.order_by(MemberModel.id.asc()).offset(int(size) * int(page)).limit(size).all()
current_app.logger.info(data)
list = []
user_ids = []
for p in data:
item = p[0].to_json()
item['role'] = p[1]
user_ids.append(p[2])
list.append(item)
current_app.logger.info(list)
return list, count, user_ids
def member(self, user_id, role, group_id=None, project_id=None):
query = self.query
if group_id:
query = query.filter_by(source_id=group_id).filter_by(source_type=self.source_type_group)
elif project_id:
query = query.filter_by(project_id=project_id).filter_by(source_type=self.source_type_project)
if user_id:
query = query.filter_by(user_id=user_id)
if query.count():
query.update({'access_level': role})
else:
source_type = self.source_type_project if project_id else self.source_type_group
source_id = project_id if project_id else group_id
insert = {
'user_id': user_id,
'source_id': source_id,
'source_type': source_type,
'access_level': role.upper(),
'status': self.status_available,
}
current_app.logger.info(insert)
group = MemberModel(**insert)
db.session.add(group)
db.session.commit()
return self.members(group_id=group_id)
def remove(self, group_id=None, user_id=None, project_id=None):
"""
:param role_id:
:return:
"""
if group_id:
MemberModel.query.filter_by(group_id=group_id).update({'status': self.status_remove})
elif user_id:
MemberModel.query.filter_by(user_id=user_id).update({'status': self.status_remove})
elif self.group_id:
MemberModel.query.filter_by(group_id=self.group_id).update({'status': self.status_remove})
elif project_id:
MemberModel.query.filter_by(project_id=project_id).update({'status': self.status_remove})
ret = db.session.commit()
return ret
def to_json(self):
return {
'id': self.id,
'user_id': self.user_id,
'group_id': self.group_id,
'group_name': self.group_name,
'created_at': self.created_at.strftime('%Y-%m-%d %H:%M:%S'),
'updated_at': self.updated_at.strftime('%Y-%m-%d %H:%M:%S'),
}
class ServerModel(SurrogatePK, Model):
__tablename__ = 'servers'
current_time = datetime.now()
# 表的结构:
id = db.Column(Integer, primary_key=True, autoincrement=True)
name = db.Column(String(100))
host = db.Column(String(100))
status = db.Column(Integer)
created_at = db.Column(DateTime, default=current_time)
updated_at = db.Column(DateTime,
default=current_time,
onupdate=current_time)
def list(self, page=0, size=10, kw=None):
"""
获取分页列表
:param page:
:param size:
:param kw:
:return:
"""
query = self.query.filter(
ServerModel.status.notin_([self.status_remove]))
if kw:
query = query.filter(ServerModel.name.like('%' + kw + '%'))
count = query.count()
data = query.order_by(ServerModel.id.desc()) \
.offset(int(size) * int(page)).limit(size) \
.all()
server_list = [p.to_json() for p in data]
return server_list, count
def item(self, id=None):
"""
获取单条记录
:param role_id:
:return:
"""
id = id if id else self.id
data = self.query.filter(
ServerModel.status.notin_([self.status_remove
])).filter_by(id=id).first()
return data.to_json() if data else []
def add(self, name, host):
# todo permission_ids need to be formated and checked
server = ServerModel(name=name,
host=host,
status=self.status_available)
db.session.add(server)
db.session.commit()
if server.id:
self.id = server.id
return server.id
def update(self, name, host, id=None):
# todo permission_ids need to be formated and checked
id = id if id else self.id
role = ServerModel.query.filter_by(id=id).first()
if not role:
return False
role.name = name
role.host = host
ret = db.session.commit()
return ret
def remove(self, id=None):
"""
:param role_id:
:return:
"""
id = id if id else self.id
self.query.filter_by(id=id).update({'status': self.status_remove})
ret = db.session.commit()
return ret
@classmethod
def fetch_by_id(cls, ids=None):
"""
用户列表
:param uids: []
:return:
"""
if not ids:
return None
query = ServerModel.query.filter(ServerModel.id.in_(ids))
data = query.order_by(ServerModel.id.desc()).all()
return [p.to_json() for p in data]
def to_json(self):
item = {
'id': self.id,
'name': self.name,
'host': self.host,
'created_at': self.created_at.strftime('%Y-%m-%d %H:%M:%S'),
'updated_at': self.updated_at.strftime('%Y-%m-%d %H:%M:%S'),
}
item.update(self.enable())
return item
def enable(self):
# current_app.logger.info(dir(permission.app))
# current_app.logger.info(permission.enable_uid(3))
return {
'enable_update': permission.role_upper_developer(),
'enable_delete': permission.role_upper_developer(),
'enable_create': False,
'enable_online': False,
'enable_audit': permission.role_upper_owner(),
'enable_block': False,
}
class EnvironmentModel(Model):
# 表的名字:
__tablename__ = 'environments'
__table_args__ = {"useexisting": True}
status_open = 1
status_close = 2
current_time = datetime.now
# 表的结构:
id = db.Column(Integer, primary_key=True, autoincrement=True)
name = db.Column(String(20))
space_id = db.Column(Integer)
status = db.Column(Integer)
created_at = db.Column(DateTime, default=current_time)
updated_at = db.Column(DateTime, default=current_time, onupdate=current_time)
def list(self, page=0, size=10, kw=None, space_id=None):
"""
获取分页列表
:param page:
:param size:
:param kw:
:return:
"""
query = self.query.filter(EnvironmentModel.status.notin_([self.status_remove]))
if kw:
query = query.filter(EnvironmentModel.name.like('%' + kw + '%'))
if space_id:
query = query.filter(EnvironmentModel.space_id == space_id)
SpaceModel = model.space.SpaceModel
query = query.join(SpaceModel, SpaceModel.id == EnvironmentModel.space_id)
query = query.add_columns(SpaceModel.name)
count = query.count()
data = query.order_by(EnvironmentModel.id.desc()).offset(int(size) * int(page)).limit(size).all()
env_list = []
for p in data:
item = p[0].to_json()
item['space_name'] = p[1]
env_list.append(item)
return env_list, count
def item(self, env_id=None):
"""
获取单条记录
:param role_id:
:return:
"""
data = self.query.filter(EnvironmentModel.status.notin_([self.status_remove])).filter_by(id=self.id).first()
return data.to_json() if data else []
def add(self, *args, **kwargs):
data = dict(*args)
env = EnvironmentModel(**data)
db.session.add(env)
db.session.commit()
return env.to_json()
def update(self, env_name, status, env_id=None):
role = EnvironmentModel.query.filter_by(id=self.id).first()
role.name = env_name
role.status = status
ret = db.session.commit()
return ret
def remove(self, env_id=None):
"""
:param role_id:
:return:
"""
self.query.filter_by(id=self.id).update({'status': self.status_remove})
ret = db.session.commit()
return ret
def to_json(self):
item = {
'id': self.id,
'status': self.status,
'space_id': self.space_id,
'env_name': self.name,
'created_at': self.created_at.strftime('%Y-%m-%d %H:%M:%S'),
'updated_at': self.updated_at.strftime('%Y-%m-%d %H:%M:%S'),
}
item.update(self.enable())
return item
def enable(self):
return {
'enable_view': True,
'enable_update': permission.role_upper_developer(),
'enable_delete': permission.role_upper_developer(),
'enable_create': False,
'enable_online': False,
'enable_audit': False,
'enable_block': False,
}
class MenuModel(SurrogatePK, Model):
__tablename__ = 'menus'
type_module = 'module'
type_controller = 'controller'
type_action = 'action'
status_open = 1
status_close = 2
current_time = datetime.now()
# 表的结构:
id = db.Column(Integer, primary_key=True, autoincrement=True)
name_cn = db.Column(String(30))
name_en = db.Column(String(30))
pid = db.Column(Integer)
type = db.Column(String(30))
sequence = db.Column(Integer)
archive = db.Column(Integer)
icon = db.Column(String(30))
url = db.Column(String(30))
visible = db.Column(Integer)
role = db.Column(Integer)
created_at = db.Column(DateTime, default=current_time)
updated_at = db.Column(DateTime,
default=current_time,
onupdate=current_time)
def menu(self, role):
RoleModel = model.role.RoleModel
data = {}
filters = {MenuModel.visible == 1, MenuModel.role <= role}
query = self.query \
.filter(*filters) \
.order_by('sequence asc') \
.all()
for item in query:
if item.type == self.type_module:
module = {
'title': item.name_cn,
'icon': item.icon,
'sub_menu': [],
}
if item.url:
module['url'] = RoleModel.menu_url(item.url)
data[item.id] = module
elif item.type == self.type_controller:
data[item.pid]['sub_menu'].append({
'title':
item.name_cn,
'icon':
item.icon,
'url':
RoleModel.menu_url(item.url),
})
return data.values()
def to_json(self):
return {
'id': self.id,
'name_cn': self.name_cn,
'name_en': self.name_en,
'pid': self.pid,
'type': self.type,
'sequence': self.sequence,
'archive': self.archive,
'icon': self.icon,
'url': self.url,
'visible': self.visible,
'created_at': self.created_at.strftime('%Y-%m-%d %H:%M:%S'),
'updated_at': self.updated_at.strftime('%Y-%m-%d %H:%M:%S'),
}
class ServerModel(SurrogatePK, Model):
__tablename__ = 'servers'
current_time = datetime.now
# 表的结构:
id = db.Column(Integer, primary_key=True, autoincrement=True)
name = db.Column(String(100))
host = db.Column(String(100))
user = db.Column(String(100))
port = db.Column(Integer)
status = db.Column(Integer)
created_at = db.Column(DateTime, default=current_time)
updated_at = db.Column(DateTime,
default=current_time,
onupdate=current_time)
def list(self, page=0, size=10, kw=None):
"""
获取分页列表
:param page:
:param size:
:param kw:
:return:
"""
query = self.query.filter(
ServerModel.status.notin_([self.status_remove]))
if kw:
query = query.filter(ServerModel.name.like('%' + kw + '%'))
count = query.count()
data = query.order_by(ServerModel.id.desc()) \
.offset(int(size) * int(page)).limit(size) \
.all()
server_list = [p.to_json() for p in data]
return server_list, count
def item(self, id=None):
"""
获取单条记录
:param role_id:
:return:
"""
id = id if id else self.id
data = self.query.filter(
ServerModel.status.notin_([self.status_remove
])).filter_by(id=id).first()
return data.to_json() if data else []
def add(self, *args, **kwargs):
data = dict(*args)
server = ServerModel(**data)
db.session.add(server)
db.session.commit()
if server.id:
self.id = server.id
return server.id
def update(self, *args, **kwargs):
update_data = dict(*args)
return super(ServerModel, self).update(**update_data)
def remove(self, id=None):
"""
:param role_id:
:return:
"""
id = id if id else self.id
self.query.filter_by(id=id).update({'status': self.status_remove})
ret = db.session.commit()
return ret
@classmethod
def fetch_by_id(cls, ids=None):
"""
用户列表
:param uids: []
:return:
"""
if not ids:
return None
query = ServerModel.query.filter(ServerModel.id.in_(ids))\
.filter(ServerModel.status.notin_([cls.status_remove]))
data = query.order_by(ServerModel.id.desc()).all()
return [p.to_json() for p in data]
def to_json(self):
item = {
'id': self.id,
'name': self.name,
'host': self.host,
'user': self.user,
'port': self.port,
'created_at': self.created_at.strftime('%Y-%m-%d %H:%M:%S'),
'updated_at': self.updated_at.strftime('%Y-%m-%d %H:%M:%S'),
}
item.update(self.enable())
return item
def enable(self):
return {
'enable_view': True,
'enable_update': permission.role_upper_developer(),
'enable_delete': permission.role_upper_developer(),
'enable_create': False,
'enable_online': False,
'enable_audit': permission.role_upper_owner(),
'enable_block': False,
}
class MemberModel(SurrogatePK, Model):
__tablename__ = 'members'
current_time = datetime.now()
group_id = None
project_id = None
source_type_project = 'project'
source_type_group = 'group'
# 表的结构:
id = db.Column(Integer, primary_key=True, autoincrement=True)
user_id = db.Column(Integer, db.ForeignKey('users.id'))
source_id = db.Column(Integer)
source_type = db.Column(String(10))
access_level = db.Column(String(10))
status = db.Column(Integer)
created_at = db.Column(DateTime, default=current_time)
updated_at = db.Column(DateTime,
default=current_time,
onupdate=current_time)
group_name = None
# TODO group id全局化
def spaces(self, user_id=None):
"""
获取分页列表
:param page:
:param size:
:return:
"""
filters = {
MemberModel.status.notin_([self.status_remove]),
MemberModel.source_type == self.source_type_group
}
query = self.query.filter(*filters).with_labels().with_entities(
MemberModel.source_id, MemberModel.access_level, SpaceModel.name)
if user_id:
query = query.filter_by(user_id=user_id)
query = query.join(SpaceModel, SpaceModel.id == MemberModel.source_id)
spaces = query.all()
current_app.logger.info(spaces)
return {
space[0]: {
'id': space[0],
'role': space[1],
'name': space[2]
}
for space in spaces
}
def projects(self, user_id=None, space_id=None):
"""
获取分页列表
:param page:
:param size:
:return:
"""
filters = {
MemberModel.status.notin_([self.status_remove]),
MemberModel.source_type == self.source_type_project
}
query = self.query.filter(*filters)
if user_id:
query = query.filter_by(user_id=user_id)
# if project_id:
# query = query.filter_by(source_id=project_id)
projects = query.all()
current_app.logger.info(projects)
return projects
group, count = MemberModel.query_paginate(page=page,
limit=size,
filter_name_dict=filters)
list = [p.to_json() for p in group]
return list, count
def add(self, space_name, members):
"""
:param space_name:
:param members: [{'user_id': 1, 'project_id': 2}]
:return:
"""
tag = TagModel(name=space_name, label='user_group')
db.session.add(tag)
db.session.commit()
for member in members:
user_group = MemberModel(group_id=tag.id,
user_id=member['user_id'],
project_id=member['project_id'])
db.session.add(user_group)
db.session.commit()
if tag.id:
self.group_id = tag.id
return tag.id
def update_group(self, members, group_name=None):
# 修复空间名称
if group_name:
SpaceModel(id=self.group_id).update({'name': group_name})
# # 修改tag信息
# if group_name:
# tag_model = TagModel.query.filter_by(label='user_group').filter_by(id=self.group_id).first()
# if tag_model.name != group_name:
# tag_model.name = group_name
# 修改用户组成员
# clean up
filters = {
MemberModel.source_id == self.group_id,
MemberModel.source_type == self.source_type_group,
}
MemberModel.query.filter(*filters).delete()
# insert all
for member in members:
update = {
'user_id': member['user_id'],
'source_id': self.group_id,
'source_type': self.source_type_group,
'access_level': member['role'].upper(),
'status': self.status_available,
}
m = MemberModel(**update)
db.session.add(m)
ret = db.session.commit()
return ret
def update_project(self, project_id, members, group_name=None):
space_info = walle.model.deploy.ProjectModel.query.filter_by(
id=project_id).first().to_json()
group_model = self.members(group_id=space_info['space_id'])
user_update = []
for member in members:
user_update.append(member['user_id'])
current_app.logger.info(group_model['user_ids'])
current_app.logger.info(user_update)
# project新增用户是否在space's group中,无则抛出
if list(set(user_update).difference(set(group_model['user_ids']))):
raise ValueError('用户不存在')
# 修改用户组成员
# clean up
filters = {
MemberModel.source_id == project_id,
MemberModel.source_type == self.source_type_project,
}
MemberModel.query.filter(*filters).delete()
# insert all
for member in members:
insert = {
'user_id': member['user_id'],
'source_id': project_id,
'source_type': self.source_type_project,
'access_level': member['role'].upper(),
'status': self.status_available,
}
group = MemberModel(**insert)
db.session.add(group)
ret = db.session.commit()
return ret
def members(self, group_id=None, project_id=None):
"""
获取单条记录
:param role_id:
:return:
"""
group_id = group_id if group_id else self.group_id
project_id = project_id if project_id else self.project_id
source_id = group_id if group_id else project_id
source_type = self.source_type_group if group_id else self.source_type_project
filters = {
'status': {
'nin': [self.status_remove]
},
'source_id': {
'=': source_id
},
'source_type': {
'=': source_type
},
}
# TODO
page = 1
size = 10
groups, count = MemberModel.query_paginate(page=page,
limit=size,
filter_name_dict=filters)
user_ids = []
user_role = members = {}
current_app.logger.info(groups)
for group_info in groups:
user_ids.append(group_info.user_id)
# TODO
user_role[group_info.user_id] = group_info.access_level
current_app.logger.info(user_ids)
user_model = UserModel()
user_info = user_model.fetch_by_uid(uids=set(user_ids))
if user_info:
for user in user_info:
if user_role.has_key(user['id']):
user['role'] = user_role[user['id']]
members['user_ids'] = user_ids
members['members'] = user_info
members['users'] = len(user_ids)
return members
def remove(self, group_id=None, user_id=None, project_id=None):
"""
:param role_id:
:return:
"""
if group_id:
MemberModel.query.filter_by(group_id=group_id).update(
{'status': self.status_remove})
elif user_id:
MemberModel.query.filter_by(user_id=user_id).update(
{'status': self.status_remove})
elif self.group_id:
MemberModel.query.filter_by(group_id=self.group_id).update(
{'status': self.status_remove})
elif project_id:
MemberModel.query.filter_by(project_id=project_id).update(
{'status': self.status_remove})
ret = db.session.commit()
return ret
def to_json(self):
return {
'id': self.id,
'user_id': self.user_id,
'group_id': self.group_id,
'group_name': self.group_name,
'created_at': self.created_at.strftime('%Y-%m-%d %H:%M:%S'),
'updated_at': self.updated_at.strftime('%Y-%m-%d %H:%M:%S'),
}
class SpaceModel(SurrogatePK, Model):
# 表的名字:
__tablename__ = 'spaces'
current_time = datetime.now()
status_close = 0
status_open = 1
# 表的结构:
id = db.Column(Integer, primary_key=True, autoincrement=True)
user_id = db.Column(Integer)
name = db.Column(String(100))
status = db.Column(Integer)
created_at = db.Column(DateTime, default=current_time)
updated_at = db.Column(DateTime,
default=current_time,
onupdate=current_time)
def list(self, page=0, size=10, kw=None):
"""
获取分页列表
:param page:
:param size:
:return:
"""
query = self.query.filter(
SpaceModel.status.notin_([self.status_remove]))
if kw:
query = query.filter(SpaceModel.name.like('%' + kw + '%'))
# TODO 如果是超管,可以全量,否则需要过滤自己有权限的空间列表
if current_user.role != SUPER:
query = query.filter_by(user_id=current_user.id)
count = query.count()
data = query.order_by(SpaceModel.id.desc()).offset(
int(size) * int(page)).limit(size).all()
uid2name = UserModel.uid2name(data=data)
list = [p.to_json(uid2name) for p in data]
return list, count
def item(self, id=None):
"""
获取单条记录
:param role_id:
:return:
"""
MemberModel = model.member.MemberModel
id = id if id else self.id
data = self.query.filter_by(id=id).first()
members = MemberModel(group_id=id).members()
if not data:
return []
data = data.to_json()
return dict(data, **members)
def add(self, *args, **kwargs):
# todo permission_ids need to be formated and checked
data = dict(*args)
# tag = TagModel(name=data['name'], label='user_group')
# db.session.add(tag)
# db.session.commit()
data = dict(*args)
space = SpaceModel(**data)
db.session.add(space)
db.session.commit()
self.id = space.id
return self.id
def update(self, *args, **kwargs):
# todo permission_ids need to be formated and checked
# a new type to update a model
update_data = dict(*args)
return super(SpaceModel, self).update(**update_data)
def remove(self, space_id=None):
"""
:param space_id:
:return:
"""
space_id = space_id if space_id else self.id
SpaceModel.query.filter_by(id=space_id).update(
{'status': self.status_remove})
ret = db.session.commit()
return ret
def to_json(self, uid2name=None):
item = {
'id':
self.id,
'user_id':
self.user_id,
'user_name':
uid2name[self.user_id]
if uid2name and uid2name.has_key(self.user_id) else '',
# TODO
'group_id':
'self.group_id',
'name':
self.name,
'status':
self.status,
'created_at':
self.created_at.strftime('%Y-%m-%d %H:%M:%S'),
'updated_at':
self.updated_at.strftime('%Y-%m-%d %H:%M:%S'),
}
item.update(self.enable())
return item
def enable(self):
return {
'enable_update':
permission.enable_uid(self.user_id)
or permission.enable_role(OWNER),
'enable_delete':
permission.enable_uid(self.user_id)
or permission.enable_role(OWNER),
'enable_create':
False,
'enable_online':
False,
'enable_audit':
False,
'enable_block':
permission.enable_role(MASTER),
}
class MenuModel(SurrogatePK, Model):
__tablename__ = 'menus'
type_module = 'module'
type_controller = 'controller'
type_action = 'action'
status_open = 1
status_close = 2
current_time = datetime.now()
# 表的结构:
id = db.Column(Integer, primary_key=True, autoincrement=True)
name_cn = db.Column(String(30))
name_en = db.Column(String(30))
pid = db.Column(Integer)
type = db.Column(String(30))
sequence = db.Column(Integer)
archive = db.Column(Integer)
icon = db.Column(String(30))
url = db.Column(String(30))
visible = db.Column(Integer)
role = db.Column(Integer)
created_at = db.Column(DateTime, default=current_time)
updated_at = db.Column(DateTime,
default=current_time,
onupdate=current_time)
def menu(self, role):
data = {}
filters = {MenuModel.visible == 1, MenuModel.role >= role}
query = self.query \
.filter(*filters) \
.order_by('sequence asc') \
.all()
for item in query:
if item.type == self.type_module:
module = {
'title': item.name_cn,
'icon': item.icon,
'sub_menu': [],
}
if item.url:
module['url'] = RoleModel.menu_url(item.url)
data[item.id] = module
elif item.type == self.type_controller:
data[item.pid]['sub_menu'].append({
'title':
item.name_cn,
'icon':
item.icon,
'url':
RoleModel.menu_url(item.url),
})
return data.values()
def list(self):
"""
获取分页列表
:param page:
:param size:
:param kw:
:return:
"""
menus_module = {}
menus_controller = {}
module = aliased(MenuModel)
controller = aliased(MenuModel)
action = aliased(MenuModel)
data = db.session.query(module.id, module.name_cn, controller.id, controller.name_cn, action.id, action.name_cn) \
.outerjoin(controller, controller.pid == module.id) \
.outerjoin(action, action.pid == controller.id) \
.filter(module.type == self.type_module) \
.all()
for m_id, m_name, c_id, c_name, a_id, a_name in data:
# module
if not menus_module.has_key(m_id):
menus_module[m_id] = {
'id': m_id,
'title': m_name,
'sub_menu': {},
}
# controller
if not menus_module[m_id]['sub_menu'].has_key(c_id) and c_name:
menus_module[m_id]['sub_menu'][c_id] = {
'id': c_id,
'title': c_name,
'sub_menu': {},
}
# action
if not menus_controller.has_key(c_id):
menus_controller[c_id] = []
if a_name:
menus_controller[c_id].append({
'id': a_id,
'title': a_name,
})
menus = []
for m_id, m_info in menus_module.items():
for c_id, c_info in m_info['sub_menu'].items():
m_info['sub_menu'][c_id]['sub_menu'] = menus_controller[c_id]
menus.append({
'id': m_id,
'title': m_info['title'],
'sub_menu': m_info['sub_menu'].values(),
})
return menus
def to_json(self):
return {
'id': self.id,
'name_cn': self.name_cn,
'name_en': self.name_en,
'pid': self.pid,
'type': self.type,
'sequence': self.sequence,
'archive': self.archive,
'icon': self.icon,
'url': self.url,
'visible': self.visible,
'created_at': self.created_at.strftime('%Y-%m-%d %H:%M:%S'),
'updated_at': self.updated_at.strftime('%Y-%m-%d %H:%M:%S'),
}
class UserModel(UserMixin, SurrogatePK, Model):
# 表的名字:
__tablename__ = 'users'
status_active = 1
status_blocked = 2
current_time = datetime.now()
password_hash = 'sadfsfkk'
# 表的结构:
id = db.Column(Integer, primary_key=True, autoincrement=True)
username = db.Column(String(50))
is_email_verified = db.Column(Integer, default=0)
email = db.Column(String(50), unique=True, nullable=False)
password = db.Column(String(50), nullable=False)
avatar = db.Column(String(100))
role = db.Column(String(10))
status = db.Column(Integer, default=1)
last_space = db.Column(Integer, default=0)
# role_info = relationship("walle.model.user.RoleModel", back_populates="users")
created_at = db.Column(DateTime, default=current_time)
updated_at = db.Column(DateTime,
default=current_time,
onupdate=current_time)
status_mapping = {
-1: '删除',
0: '新建',
1: '正常',
2: '冻结',
}
'''
current_user 基础方法
"__abstract__",
"__class__",
"__delattr__",
"__dict__",
"__doc__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init__",
"__mapper__",
"__module__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__table__",
"__table_args__",
"__tablename__",
"__weakref__",
"_cached_tablename",
"_decl_class_registry",
"_sa_class_manager",
"_sa_instance_state",
"avatar",
"avatar_url",
"block_active",
"column_name_set",
"create",
"create_from_dict",
"create_or_update",
"created_at",
"current_time",
"delete",
"dump_schema",
"email",
"enable",
"fetch_access_list_by_role_id",
"fetch_by_uid",
"general_password",
"get_by_id",
"get_common_fields",
"get_id",
"id",
"is_active",
"is_anonymous",
"is_authenticated",
"is_email_verified",
"item",
"list",
"metadata",
"password",
"password_hash",
"query",
"query_class",
"query_paginate",
"query_paginate_and_dump_schema",
"remove",
"save",
"set_password",
"status",
"status_active",
"status_available",
"status_blocked",
"status_default",
"status_mapping",
"status_remove",
"to_dict",
"to_json",
"uid2name",
"update",
"update_avatar",
"update_name_pwd",
"updated_at",
"username",
"verify_password"
'''
def add(self, *args, **kwargs):
data = dict(*args)
user = UserModel(**data)
db.session.add(user)
db.session.commit()
return user
def item(self, user_id=None):
"""
获取单条记录
:param role_id:
:return:
"""
data = self.query.filter_by(id=self.id).filter(
UserModel.status.notin_([self.status_remove])).first()
return data.to_json() if data else []
def update(self, *args, **kwargs):
# todo permission_ids need to be formated and checked
# a new type to update a model
update_data = dict(*args)
return super(UserModel, self).update(**update_data)
def update_avatar(self, avatar):
d = {'avatar': avatar}
user = self.query.get(self.id).update(**d)
current_app.logger.info(user)
def update_name_pwd(self, username, password=None):
# todo permission_ids need to be formated and checked
user = self.query.filter_by(id=self.id).first()
user.username = username
if password:
self.set_password(password)
db.session.commit()
return user.to_json()
def block_active(self, status):
user = self.query.filter_by(id=self.id).first()
user.status = status
db.session.commit()
return user.to_json()
def remove(self):
"""
:param role_id:
:return:
"""
self.query.filter_by(id=self.id).update({'status': self.status_remove})
ret = db.session.commit()
return ret
def verify_password(self, password):
"""
检查密码是否正确
:param password:
:return:
"""
if self.password is None:
return False
return check_password_hash(self.password, password)
def set_password(self, password):
"""Set password."""
self.password = generate_password_hash(password)
def general_password(self, password):
"""
检查密码是否正确
:param password:
:return:
"""
self.password = generate_password_hash(password)
return generate_password_hash(password)
def fetch_access_list_by_role_id(self, role_id):
module = aliased(MenuModel)
controller = aliased(MenuModel)
action = aliased(MenuModel)
role = RoleModel.query.get(role_id)
access_ids = role.access_ids.split(',')
data = db.session \
.query(controller.name_en, controller.name_cn,
action.name_en, action.name_cn) \
.outerjoin(action, action.pid == controller.id) \
.filter(module.type == MenuModel.type_module) \
.filter(controller.id.in_(access_ids)) \
.filter(action.id.in_(access_ids)) \
.all()
return [
AccessRbac.resource(a_en, c_en) for c_en, c_cn, a_en, a_cn in data
if c_en and a_en
]
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
try:
return unicode(self.id) # python 2
except NameError:
return str(self.id) # python 3
def list(self, uids=[], page=0, size=10, kw=None):
"""
获取分页列表
:param page:
:param size:
:return:
"""
query = UserModel.query.filter(
UserModel.status.notin_([self.status_remove]))
if kw:
query = query.filter(
or_(UserModel.username.like('%' + kw + '%'),
UserModel.email.like('%' + kw + '%')))
if uids:
query = query.filter(UserModel.id.in_(uids))
count = query.count()
data = query.order_by('id desc').offset(int(size) *
int(page)).limit(size).all()
user_list = [p.to_json() for p in data]
return user_list, count
def has_spaces(self):
return MemberModel().spaces(user_id=self.id)
@classmethod
def fresh_session(cls):
# 0.超管
if current_user.role == SUPER:
return True
spaces = current_user.has_spaces()
# 1.无空间权限且非超管
if not spaces and current_user.role <> SUPER:
raise WalleError(Code.space_empty)
default_space = spaces.keys()[0]
# 2.第一次登录无空间
if not current_user.last_space:
current_user.last_space = default_space
current_user.save()
session['space_id'] = default_space
session['space_info'] = spaces[session['space_id']]
# 3.空间权限有修改
if current_user.last_space and current_user.last_space not in spaces.keys(
):
raise WalleError(Code.space_error)
session['space_id'] = current_user.last_space
session['space_info'] = spaces[current_user.last_space]
session['space_list'] = spaces.values()
current_app.logger.info(
'============ SecurityResource.__init__ ============')
@classmethod
def avatar_url(cls, avatar):
avatar = avatar if avatar else 'default.jpg'
return '/' + current_app.config['AVATAR_PATH'] + avatar
@classmethod
def fetch_by_uid(cls, uids=None):
"""
用户列表
:param uids: []
:return:
"""
if not uids:
return []
query = UserModel.query.filter(UserModel.id.in_(uids)).filter(
UserModel.status.notin_([cls.status_remove]))
data = query.order_by('id desc').all()
return [p.to_json() for p in data]
@classmethod
def uid2name(cls, data):
"""
把uid转换成名字
:param data: [{'user_id':1, 'xx':'yy'}] 至少包含user_id
:return:
"""
user_ids = []
uid2name = {}
for items in data:
user_ids.append(items.user_id)
user_info = cls.fetch_by_uid(uids=user_ids)
for user in user_info:
uid2name[user['id']] = user['username']
return uid2name
def to_json(self):
item = {
'id': int(self.id),
'user_id': int(self.id),
'username': self.username,
'is_email_verified': self.is_email_verified,
'email': self.email,
'avatar': self.avatar_url(self.avatar),
# TODO 当前登录用户的空间
# 'role_id': self.role_id,
'status': self.status_mapping[self.status],
'last_space': self.last_space,
# 'status': self.status,
# 'role_name': self.role_id,
'created_at': self.created_at.strftime('%Y-%m-%d %H:%M:%S'),
'updated_at': self.updated_at.strftime('%Y-%m-%d %H:%M:%S'),
}
item.update(self.enable())
return item
def enable(self):
return {
'enable_update': permission.enable_role(DEVELOPER),
'enable_delete': permission.enable_role(DEVELOPER),
'enable_create': False,
'enable_online': False,
'enable_audit': False,
'enable_block': False,
}
class RecordModel(Model):
# 表的名字:
__tablename__ = 'records'
current_time = datetime.now
#
stage_end = 'end'
#
status_success = 0
#
status_fail = 1
# 表的结构:
id = db.Column(Integer, primary_key=True, autoincrement=True)
stage = db.Column(String(20))
sequence = db.Column(Integer)
user_id = db.Column(Integer)
task_id = db.Column(Integer)
status = db.Column(Integer)
command = db.Column(String(200))
host = db.Column(String(200))
user = db.Column(String(200))
success = db.Column(String(2000))
error = db.Column(String(2000))
created_at = db.Column(DateTime, default=current_time)
updated_at = db.Column(DateTime,
default=current_time,
onupdate=current_time)
def save_record(self,
stage,
sequence,
user_id,
task_id,
status,
host,
user,
command,
success=None,
error=None):
record = RecordModel(stage=stage,
sequence=sequence,
user_id=user_id,
task_id=task_id,
status=status,
host=host,
user=user,
command=command,
success=success,
error=error)
db.session.add(record)
ret = db.session.commit()
return ret
def fetch(self, task_id):
data = self.query.filter_by(task_id=task_id).order_by(
RecordModel.id.asc()).all()
return [p.to_json() for p in data]
@classmethod
def logs(cls, host, user, command, status, stage, sequence, success, error,
*args, **kwargs):
return {
'host': host,
'user': user,
'cmd': command,
'status': status,
'stage': stage,
'sequence': sequence,
'success': success,
'error': error,
}
def to_json(self):
return {
'id': self.id,
'stage': self.stage,
'sequence': self.sequence,
'user_id': self.user_id,
'task_id': self.task_id,
'status': self.status,
'host': self.host,
'user': self.user,
'command': self.command,
'success': self.success,
'error': self.error,
'created_at': self.created_at.strftime('%Y-%m-%d %H:%M:%S'),
'updated_at': self.updated_at.strftime('%Y-%m-%d %H:%M:%S'),
}
class UserModel(UserMixin, SurrogatePK, Model):
# 表的名字:
__tablename__ = 'users'
status_active = 1
status_blocked = 2
current_time = datetime.now
password_hash = 'sadfsfkk'
# 表的结构:
id = db.Column(Integer, primary_key=True, autoincrement=True)
username = db.Column(String(50))
is_email_verified = db.Column(Integer, default=0)
email = db.Column(String(50), unique=True, nullable=False)
password = db.Column(String(50), nullable=False)
avatar = db.Column(String(100))
role = db.Column(String(10))
status = db.Column(Integer, default=1)
last_space = db.Column(Integer, default=0)
# role_info = relationship("walle.model.user.RoleModel", back_populates="users")
created_at = db.Column(DateTime, default=current_time)
updated_at = db.Column(DateTime,
default=current_time,
onupdate=current_time)
status_mapping = {
-1: '删除',
0: '新建',
1: '正常',
2: '冻结',
}
def add(self, *args, **kwargs):
data = dict(*args)
user = UserModel(**data)
db.session.add(user)
db.session.commit()
return user
def item(self, user_id=None):
"""
获取单条记录
:param role_id:
:return:
"""
data = self.query.filter_by(id=self.id).filter(
UserModel.status.notin_([self.status_remove])).first()
return data.to_json() if data else []
def update(self, *args, **kwargs):
update_data = dict(*args)
return super(UserModel, self).update(**update_data)
def update_avatar(self, avatar):
d = {'avatar': avatar}
user = self.query.get(self.id).update(**d)
current_app.logger.info(user)
def update_name_pwd(self, username, password=None):
user = self.query.filter_by(id=self.id).first()
if username:
user.username = username
if password:
user.password = self.get_password(password)
db.session.commit()
return user.to_json()
def block_active(self, status):
user = self.query.filter_by(id=self.id).first()
user.status = status
db.session.commit()
return user.to_json()
def remove(self):
"""
:param role_id:
:return:
"""
self.query.filter_by(id=self.id).update({'status': self.status_remove})
ret = db.session.commit()
return ret
def verify_password(self, password):
"""
检查密码是否正确
:param password:
:return:
"""
if self.password is None:
return False
return check_password_hash(self.password, password)
def get_password(self, password):
"""Set password."""
return generate_password_hash(password)
def general_password(self, password):
"""
检查密码是否正确
:param password:
:return:
"""
self.password = generate_password_hash(password)
return generate_password_hash(password)
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
try:
return unicode(self.id) # python 2
except NameError:
return str(self.id) # python 3
def list(self, uids=[], page=0, size=10, space_id=None, kw=None):
"""
获取分页列表
:param page:
:param size:
:return:
"""
query = UserModel.query.filter(
UserModel.status.notin_([self.status_remove]))
if kw:
query = query.filter(
or_(UserModel.username.like('%' + kw + '%'),
UserModel.email.like('%' + kw + '%')))
if uids:
query = query.filter(UserModel.id.in_(uids))
count = query.count()
data = query.order_by(UserModel.id.desc()).offset(
int(size) * int(page)).limit(size).all()
user_list = [p.to_json() for p in data]
return user_list, count
def has_spaces(self):
MemberModel = model.member.MemberModel
return MemberModel().spaces(user_id=self.id)
def space_id(self):
return session['space_id']
@classmethod
def fresh_session(cls):
session['project_master'] = []
# 0.超管
if current_user.role == SUPER:
return True
spaces = current_user.has_spaces()
# 1.无空间权限且非超管
if not spaces and current_user.role != SUPER:
raise WalleError(Code.space_empty)
default_space = list(spaces.keys())[0]
# 2.第一次登录无空间
if not current_user.last_space:
current_user.last_space = default_space
current_user.save()
session['space_id'] = default_space
session['space_info'] = spaces[session['space_id']]
# 3.空间权限有修改（上次登录的空格没有权限了）
if current_user.last_space not in list(spaces.keys()):
current_user.last_space = default_space
# 4.项目管理员
MemberModel = model.member.MemberModel()
session['project_master'] = MemberModel.project_master()
session['space_id'] = current_user.last_space
session['space_info'] = spaces[current_user.last_space]
session['space_list'] = list(spaces.values())
@classmethod
def avatar_url(cls, avatar):
avatar = avatar if avatar else 'default.jpg'
return current_app.config['AVATAR_PATH'] + avatar
@classmethod
def fetch_by_uid(cls, uids=None):
"""
用户列表
:param uids: []
:return:
"""
if not uids:
return []
query = UserModel.query.filter(UserModel.id.in_(uids)).filter(
UserModel.status.notin_([cls.status_remove]))
data = query.order_by(UserModel.id.desc()).all()
return [p.to_json() for p in data]
@classmethod
def uid2name(cls, data):
"""
把uid转换成名字
:param data: [{'user_id':1, 'xx':'yy'}] 至少包含user_id
:return:
"""
user_ids = []
uid2name = {}
for items in data:
user_ids.append(items.user_id)
user_info = cls.fetch_by_uid(uids=user_ids)
for user in user_info:
uid2name[user['id']] = user['username']
return uid2name
def to_json(self):
item = {
'id': int(self.id),
'user_id': int(self.id),
'username': self.username,
'is_email_verified': self.is_email_verified,
'email': self.email,
'avatar': self.avatar_url(self.avatar),
'status': self.status_mapping[self.status],
'last_space': self.last_space,
# 'status': self.status,
# 'role_name': self.role_id,
'created_at': self.created_at.strftime('%Y-%m-%d %H:%M:%S'),
'updated_at': self.updated_at.strftime('%Y-%m-%d %H:%M:%S'),
}
item.update(self.enable())
return item
def enable(self):
return {
'enable_view': True,
'enable_update': permission.role_upper_master(),
'enable_delete': permission.role_upper_master(),
'enable_create': False,
'enable_online': False,
'enable_audit': False,
'enable_block': False,
}
class TaskModel(SurrogatePK, Model):
__tablename__ = 'tasks'
current_time = datetime.now()
# 状态：0新建提交，1审核通过，2审核拒绝，3上线中，4上线完成，5上线失败
status_new = 0
status_pass = 1
status_reject = 2
status_doing = 3
status_success = 4
status_fail = 5
# 表的结构:
id = db.Column(Integer, primary_key=True, autoincrement=True)
name = db.Column(String(100))
user_id = db.Column(Integer)
project_id = db.Column(Integer)
action = db.Column(Integer)
status = db.Column(Integer)
link_id = db.Column(String(100))
ex_link_id = db.Column(String(100))
servers = db.Column(Text)
commit_id = db.Column(String(40))
branch = db.Column(String(100))
tag = db.Column(String(100))
file_transmission_mode = db.Column(Integer)
file_list = db.Column(Text)
enable_rollback = db.Column(Integer)
created_at = db.Column(DateTime, default=current_time)
updated_at = db.Column(DateTime, default=current_time, onupdate=current_time)
taskMdl = None
def table_name(self):
return self.__tablename__
#
# def list(self, page=0, size=10, kw=''):
# data = Task.query.order_by('id').offset(int(size) * int(page)).limit(size).all()
# return [p.to_json() for p in data]
#
# def one(self):
# project_info = Project.query.filter_by(id=self.taskMdl.get('project_id')).one().to_json()
# return dict(project_info, **self.taskMdl)
#
def list(self, page=0, size=10, space_id=None, kw=None):
"""
获取分页列表
:param page:
:param size:
:param kw:
:return:
"""
query = TaskModel.query.filter(TaskModel.status.notin_([self.status_remove]))
if kw:
query = query.filter(TaskModel.name.like('%' + kw + '%'))
# 关联 projects
ProjectModel = model.project.ProjectModel
query = query.join(ProjectModel, TaskModel.project_id == ProjectModel.id)
query = query.filter(ProjectModel.status.notin_([self.status_remove]))
# 关联 environments
EnvironmentModel = model.environment.EnvironmentModel
query = query.join(EnvironmentModel, EnvironmentModel.id == ProjectModel.environment_id)
query = query.filter(EnvironmentModel.status.notin_([self.status_remove]))
if space_id:
query = query.filter(ProjectModel.space_id == space_id)
query = query.add_columns(ProjectModel.name, EnvironmentModel.name)
count = query.count()
data = query.order_by(TaskModel.id.desc()) \
.offset(int(size) * int(page)).limit(size) \
.all()
task_list = []
for p in data:
item = p[0].to_json()
item['project_name'] = p[1]
item['environment_name'] = p[2]
task_list.append(item)
return task_list, count
def item(self, id=None):
"""
获取单条记录
:param role_id:
:return:
"""
id = id if id else self.id
data = self.query.filter(TaskModel.status.notin_([self.status_remove])).filter_by(id=id).first()
if not data:
return []
task = data.to_json()
ProjectModel = model.project.ProjectModel
project = ProjectModel().item(task['project_id'])
task['project_name'] = project['name'] if project else u'未知项目'
task['project_info'] = project
return task
def add(self, *args, **kwargs):
# todo permission_ids need to be formated and checked
data = dict(*args)
project = TaskModel(**data)
db.session.add(project)
db.session.commit()
if project.id:
self.id = project.id
return project.id
def update(self, *args, **kwargs):
# todo permission_ids need to be formated and checked
# a new type to update a model
update_data = dict(*args)
return super(TaskModel, self).update(**update_data)
def remove(self, id=None):
"""
:param role_id:
:return:
"""
id = id if id else self.id
self.query.filter_by(id=id).update({'status': self.status_remove})
ret = db.session.commit()
return ret
def to_json(self):
ServerModel = model.server.ServerModel
item = {
'id': self.id,
'name': self.name,
'user_id': int(self.user_id),
'project_id': int(self.project_id),
'project_name': self.project_id if self.project_id else '',
'action': self.action,
'status': self.status,
'link_id': self.link_id,
'ex_link_id': self.ex_link_id,
'servers': self.servers,
'servers_info': ServerModel.fetch_by_id(self.servers.split(',')) if self.servers else '',
'commit_id': self.commit_id,
'branch': self.branch,
'tag': self.tag,
'file_transmission_mode': self.file_transmission_mode,
'file_list': self.file_list,
'enable_rollback': self.enable_rollback,
'created_at': self.created_at.strftime('%Y-%m-%d %H:%M:%S'),
'updated_at': self.updated_at.strftime('%Y-%m-%d %H:%M:%S'),
}
item.update(self.enable())
return item
def enable(self):
return {
'enable_update': (permission.enable_uid(self.user_id) or permission.enable_role(DEVELOPER)) and (self.status in [self.status_new, self.status_reject]),
'enable_delete': (permission.enable_uid(self.user_id) or permission.enable_role(DEVELOPER)) and (self.status in [self.status_new]),
'enable_create': False,
'enable_online': (permission.enable_uid(self.user_id) or permission.enable_role(DEVELOPER)) and (self.status in [self.status_pass]),
'enable_audit': permission.enable_role(DEVELOPER) and (self.status in [self.status_new]),
'enable_block': False,
}
