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, }