def get_task_info(list_id, task_group, exec_ip, this_host_list): scheduler_list = [] hosts_status = {} with DBContext('r') as session: for h in this_host_list: scheduler_info = session.query(TaskSched).filter( TaskSched.list_id == list_id, TaskSched.task_group == task_group, TaskSched.exec_ip == h).order_by(TaskSched.task_level).all() status_list = [] for msg in scheduler_info: data_dict = model_to_dict(msg) status_list.append(data_dict.get("task_status")) if exec_ip == data_dict.get("exec_ip"): scheduler_list.append(data_dict) status = '4' if '0' in status_list: status = '0' if '1' in status_list: status = '1' if '2' in status_list: status = '2' if '5' in status_list and '1' not in status_list and '2' not in status_list: status = '5' if '6' in status_list: status = '6' if '7' in status_list: status = '7' if '4' in status_list: status = '4' if '3' in status_list and len(list(set(status_list))) == 1: status = '3' hosts_status[str(h)] = status return scheduler_list, hosts_status
def get_user_rules(user_id, is_superuser=False): page_data = {} component_data = {} with DBContext('r') as session: if is_superuser: components_info = session.query(Components.component_name).filter(Components.status == '0').all() page_data['all'] = True component_data['all'] = True for msg in components_info: component_data[msg[0]] = True else: this_menus = session.query(Menus.menu_name).outerjoin(RoleMenus, Menus.menu_id == RoleMenus.menu_id).outerjoin( UserRoles, RoleMenus.role_id == UserRoles.role_id).filter(UserRoles.user_id == user_id, UserRoles.status == '0', Menus.status == '0').all() this_components = session.query(Components.component_name).outerjoin(RolesComponents, Components.comp_id == RolesComponents.comp_id ).outerjoin( UserRoles, RolesComponents.role_id == UserRoles.role_id).filter(UserRoles.user_id == user_id, UserRoles.status == '0', Components.status == '0').all() ## 如果不是超级用户 插入一个没有权限的 page_data['all'] = False component_data['all'] = False for p in this_menus: page_data[p[0]] = True for c in this_components: component_data[c[0]] = True redis_conn = cache_conn() redis_conn.hmset("{}_rules".format(user_id), dict(page=page_data, component=component_data))
def get(self, *args, **kwargs): page_size = self.get_argument('page', default=1, strip=True) limit = self.get_argument('limit', default=100, strip=True) limit_start = (int(page_size) - 1) * int(limit) task_list = [] this_list = [] username = self.get_current_user() nickname = self.get_current_nickname() ### 超级管理员 和模板关联过的用户可以查看 with DBContext('r') as session: count = session.query(TaskList).filter( TaskList.schedule != 'OK').count() task_info = session.query(TaskList).filter( TaskList.schedule != 'OK').order_by( -TaskList.start_time, -TaskList.list_id).offset(limit_start).limit(int(limit)) for msg in task_info: data_dict = model_to_dict(msg) user_list = [] for i in list( literal_eval(data_dict.get("associated_user")).values()): user_list.extend(i) if username in user_list or nickname in user_list or self.is_superuser: data_dict['create_time'] = str(data_dict['create_time']) data_dict['start_time'] = str(data_dict['start_time']) this_list.append(data_dict.get("list_id")) task_list.append(data_dict) list_id = "" if len(this_list) < 1 else this_list[0] return self.write( dict(code=0, msg="获取成功", data=task_list, count=count, list_id=list_id))
def put(self, *args, **kwargs): if not self.is_superuser: return self.write(dict(code=-1, msg='不是超级管理员,没有权限')) data = json.loads(self.request.body.decode("utf-8")) user_list = data.get('user_list', None) if len(user_list) < 1: return self.write(dict(code=-2, msg='用户不能为空')) redis_conn = cache_conn() configs_init('all') config_info = redis_conn.hgetall(const.APP_SETTINGS) config_info = convert(config_info) obj = SendMail( mail_host=config_info.get(const.EMAIL_HOST), mail_port=config_info.get(const.EMAIL_PORT), mail_user=config_info.get(const.EMAIL_HOST_USER), mail_password=config_info.get(const.EMAIL_HOST_PASSWORD), mail_ssl=True if config_info.get(const.EMAIL_USE_SSL) == '1' else False, mail_tls=True if config_info.get(const.EMAIL_USE_TLS) == '1' else False) with DBContext('w', None, True) as session: for user_id in user_list: md5_password = shortuuid.uuid() new_password = gen_md5(md5_password) session.query(Users).filter(Users.user_id == user_id).update( {Users.password: new_password}) mail_to = session.query( Users.email).filter(Users.user_id == user_id).first() obj.send_mail(mail_to[0], '修改密码', md5_password, subtype='plain') return self.write(dict(code=0, msg='重置密码成功,新密码已经发送到邮箱'))
def put(self, *args, **kwargs): data = json.loads(self.request.body.decode("utf-8")) paid_id = data.get('id') paid_name = data.get('paid_name', None) paid_start_time = data.get('paid_start_time', None) paid_end_time = data.get('paid_end_time', None) reminder_day = data.get('reminder_day', None) nicknames = data.get('nicknames', None) if not paid_name or not paid_start_time or not paid_end_time or not reminder_day or not nicknames: return self.write(dict(code=-2, msg='关键参数不能为空')) if nicknames: nicknames = ','.join(nicknames) update_info = { "paid_start_time": paid_start_time, "paid_end_time": paid_end_time, "reminder_day": reminder_day, "nicknames": nicknames } if re.search('000Z', paid_start_time): paid_start_time = datetime.datetime.strptime( paid_start_time, "%Y-%m-%dT%H:%M:%S.%fZ") + datetime.timedelta(hours=8) update_info['paid_start_time'] = paid_start_time if re.search('000Z', paid_end_time): paid_end_time = datetime.datetime.strptime( paid_end_time, "%Y-%m-%dT%H:%M:%S.%fZ") + datetime.timedelta(hours=8) update_info['paid_end_time'] = paid_end_time with DBContext('w', None, True) as session: session.query(PaidMG).filter( PaidMG.paid_name == paid_name).update(update_info) self.write(dict(code=0, msg='更新成功'))
def put(self, *args, **kwargs): data = json.loads(self.request.body.decode("utf-8")) id = data.get('id', None) name = data.get('name', None) # 名称,也是唯一 system_user = data.get('system_user', None) # 系统用户 platform_users = data.get('platform_users', []) # 平台用户 priority = data.get('priority', None) # 优先级 sudo_list = data.get('sudo_list', None) # sudo权限 bash_shell = data.get('bash_shell', None) # sudo权限 remarks = data.get('remarks', None) # 备注 if not name or not system_user or not priority or not sudo_list or not bash_shell: return self.write(dict(code=-2, msg='关键参数不能为空')) if not platform_users: return self.write(dict(code=-2, msg='请至少选择一个关联用户')) if not is_number(priority): return self.write(dict(code=-2, msg='优先级必须是数字')) with DBContext('w', None, True) as session: exist_sudo_list = session.query( SystemUser.sudo_list).filter(SystemUser.id == id).first() if exist_sudo_list[0] != sudo_list: # 存在修改sudo_list,更新新的sudo_list到主机上 obj = PushSystemUser() obj.update_user_sudo(system_user, sudo_list) session.query(SystemUser).filter(SystemUser.id == id).update({ SystemUser.platform_users: ','.join(platform_users), SystemUser.priority: priority, SystemUser.sudo_list: sudo_list, SystemUser.remarks: remarks }) return self.write(dict(code=0, msg='编辑成功'))
def get_user_rules(user_id): page_data = {} component_data = {} with DBContext('r') as session: this_menus = session.query(Menus.menu_name ).outerjoin(RoleMenus, Menus.menu_id == RoleMenus.menu_id).outerjoin( UserRoles, RoleMenus.role_id == UserRoles.role_id).filter(UserRoles.user_id == user_id).all() this_components = session.query(Components.component_name ).outerjoin(RolesComponents, Components.comp_id == RolesComponents.comp_id).outerjoin( UserRoles, RolesComponents.role_id == UserRoles.role_id).filter(UserRoles.user_id == user_id).all() for p in this_menus: page_data[p[0]] = True for c in this_components: component_data[c[0]] = True ## 插入一个没有权限的 page_data['all'] = False component_data['all'] = False redis_conn = cache_conn() redis_conn.hmset("{}_rules".format(user_id), dict(page=page_data, component=component_data))
def get(self, *args, **kwargs): role_id = self.get_argument('role_id', default=None, strip=True) data_list = [] if not role_id: return self.write(dict(code=-1, msg='角色不能为空')) with DBContext('r') as session: role_func = session.query(Functions).outerjoin( RoleFunctions, Functions.func_id == RoleFunctions.func_id).filter( RoleFunctions.role_id == role_id, RoleFunctions.status == '0').all() for msg in role_func: menu_dict = {} data_dict = model_to_dict(msg) menu_dict["func_id"] = data_dict["func_id"] menu_dict["func_name"] = data_dict["func_name"] menu_dict["method_type"] = data_dict["method_type"] menu_dict["uri"] = data_dict["uri"] data_list.append(menu_dict) return self.write(dict(code=0, msg='获取成功', data=data_list))
def post(self, *args, **kwargs): with DBContext('w', None, True) as session: zabbix_generator_list = get_zabbix_hosts() if zabbix_generator_list: for zabbix_gen in zabbix_generator_list: for host_info in zabbix_gen: host_name = host_info.get('host_name') exist_hostname = session.query(ZabbixHosts).filter( ZabbixHosts.host_name == host_name).first() if not exist_hostname: session.add( ZabbixHosts(zabbix_url=host_info.get('zabbix_url'), group_id=host_info.get('group_id'), group_name=host_info.get('group_name'), host_id=host_info.get('host_id'), host_name=host_name)) else: session.query(ZabbixHosts).filter( ZabbixHosts.host_name == host_name).update( host_info) session.commit() self.write(dict(code=0, msg='刷新成功'))
def get(self, *args, **kwargs): key = self.get_argument('key', default=None, strip=True) value = self.get_argument('value', default=None, strip=True) page_size = self.get_argument('page', default=1, strip=True) limit = self.get_argument('limit', default=10, strip=True) limit_start = (int(page_size) - 1) * int(limit) role_list = [] with DBContext('r') as session: if key and value: count = session.query(Roles).filter(Roles.status != '10').filter_by(**{key: value}).count() role_info = session.query(Roles).filter(Roles.status != '10').filter_by(**{key: value}).order_by( Roles.role_id).offset( limit_start).limit(int(limit)) else: count = session.query(Roles).filter(Roles.status != '10').count() role_info = session.query(Roles).filter(Roles.status != '10').order_by(Roles.role_id).offset( limit_start).limit(int(limit)) for msg in role_info: data_dict = model_to_dict(msg) data_dict['ctime'] = str(data_dict['ctime']) role_list.append(data_dict) return self.write(dict(code=0, msg='获取角色成功', count=count, data=role_list))
def update_resource(data: dict): try: valid_data = ResourceUpdateModel(**data) except ValidationError as e: return dict(code=-1, msg=str(e)) try: with DBContext('w', None, True) as db: db.query(ResourceOrm).filter( ResourceOrm.id == valid_data.id).update({ 'name': valid_data.name, 'code': valid_data.code, 'expand': valid_data.expand, 'entity': valid_data.entity }) except Exception as err: return dict(code=-2, msg='修改失败, {}'.format(str(err))) return dict(code=0, msg="修改成功")
def put(self, *args, **kwargs): data = json.loads(self.request.body.decode("utf-8")) admin_user_id = data.get('id') admin_user = data.get('admin_user', None) system_user = data.get('system_user', None) # password = data.get('password', None) user_key = data.get('user_key', None) remarks = data.get('remarks', None) if not admin_user or not system_user or not user_key: return self.write(dict(code=-2, msg='关键参数不能为空')) update_info = { "admin_user": admin_user, "system_user": system_user, "user_key": user_key, "remarks": remarks, } with DBContext('w', None, True) as session: session.query(AdminUser).filter( AdminUser.id == admin_user_id).update(update_info) self.write(dict(code=0, msg='更新成功'))
def get(self, *args, **kwargs): key = self.get_argument('key', default=None, strip=True) idc_list = [] with DBContext('w') as session: if key: idc_data = session.query(AssetIDC).filter( or_(AssetIDC.name.like('%{}%'.format(key)), AssetIDC.contact.like('%{}%'.format(key)), AssetIDC.email.like('%{}%'.format(key)), AssetIDC.phone.like('%{}%'.format(key)), AssetIDC.address.like('%{}%'.format(key)), AssetIDC.network.like('%{}%'.format(key)), AssetIDC.bandwidth.like('%{}%'.format(key)), AssetIDC.ip_range.like('%{}%'.format(key)), AssetIDC.remarks.like('%{}%'.format(key)))).order_by( AssetIDC.id) else: idc_data = session.query(AssetIDC).order_by(AssetIDC.id).all() for data in idc_data: data_dict = model_to_dict(data) idc_list.append(data_dict) return self.write(dict(code=0, msg='获取成功', data=idc_list))
def get(self, *args, **kwargs): role_id = self.get_argument('role_id', default=None, strip=True) data_list = [] if not role_id: return self.write(dict(code=-1, msg='角色不能为空')) with DBContext('r') as session: comp_info = session.query(Components).outerjoin( RolesComponents, Components.comp_id == RolesComponents.comp_id).filter( RolesComponents.role_id == role_id, RolesComponents.status == '0', Components.status == '0').all() for msg in comp_info: comp_dict = {} data_dict = model_to_dict(msg) comp_dict["comp_id"] = data_dict["comp_id"] comp_dict["component_name"] = data_dict["component_name"] data_list.append(comp_dict) return self.write(dict(code=0, msg='获取成功', data=data_list))
def write_verify(self): if self.is_superuser: user_method = self.user_id + 'ALL' self.redis_conn.sadd(user_method, '/') self.redis_conn.expire(user_method, time=3 * 86400) return '权限已经写入缓存' for method in self.method_list: user_method = self.user_id + method self.redis_conn.delete(user_method) with DBContext('r') as session: func_list = session.query(Functions.method_type, Functions.uri ).outerjoin(RoleFunctions, Functions.func_id == RoleFunctions.func_id).outerjoin( UserRoles, RoleFunctions.role_id == UserRoles.role_id).filter(UserRoles.user_id == self.user_id, Functions.status == '0', RoleFunctions.status == '0', UserRoles.status == '0').all() for func in func_list: ### 把权限写入redis self.redis_conn.sadd(self.user_id + func[0], func[1]) self.redis_conn.expire(self.user_id + func[0], time=3 * 86400) return '权限已经写入缓存'
def put(self, *args, **kwargs): data = json.loads(self.request.body.decode("utf-8")) hook_tag = data.get('hook_tag').strip() temp_id = data.get('temp_id') schedule = data.get('schedule', 'new') hook_args = data.get('hook_args') the_id = data.get('the_id') if not hook_tag or not temp_id or not the_id: return self.write(dict(code=1, msg='关键参数不能为空')) if hook_args: try: hook_args_dict = json.loads(hook_args) except Exception as e: return self.write(dict(code=2, msg='参数字典格式不正确')) else: hook_args_dict = dict() with DBContext('w', None, True) as session: git_hooks_info = session.query(GitRepo.git_hooks).filter(GitRepo.id == the_id).first() hook_dict = git_hooks_info[0] if git_hooks_info else {} if hook_dict: try: hook_dict = json.loads(hook_dict) except Exception as e: return self.write(dict(code=2, msg='钩子参数转化为字典的时候出错,请仔细检查相关内容' + str(e))) if not hook_dict: hook_dict = {hook_tag: dict(temp_id=temp_id, schedule=schedule, hook_args=hook_args_dict)} else: hook_dict[hook_tag] = dict(temp_id=temp_id, schedule=schedule, hook_args=hook_args_dict) hook_dict = json.dumps(hook_dict) session.query(GitRepo.git_hooks).filter(GitRepo.id == the_id).update({GitRepo.git_hooks: hook_dict}) self.write(dict(code=0, msg='更新钩子成功'))
def get(self, *args, **kwargs): key = self.get_argument('key', default=None, strip=True) pageNum = int(self.get_argument('page', default='1', strip=True)) pageSize = int(self.get_argument('limit', default='10', strip=True)) with DBContext('r') as session: if key: elasticache_data = session.query(ElastiCache).filter( or_( ElastiCache.idc.like('%{}%'.format(key)), ElastiCache.db_code.like('%{}%'.format(key)), ElastiCache.db_class.like('%{}%'.format(key)), ElastiCache.db_host.like('%{}%'.format(key)), ElastiCache.db_port.like('%{}%'.format(key)), ElastiCache.db_user.like('%{}%'.format(key)), ElastiCache.db_region.like('%{}%'.format(key)), ElastiCache.db_type.like('%{}%'.format(key)), ElastiCache.db_version.like('%{}%'.format(key)), ElastiCache.state.like('%{}%'.format(key)), ElastiCache.db_detail.like('%{}%'.format(key)), ElastiCache.tag_list.like('%{}%'.format(key)), ElastiCache.db_node_num.like('%{}%'.format(key)), )).all() else: elasticache_data = session.query(ElastiCache).all() data_dict = list() for msg in elasticache_data: msg = model_to_dict(msg) msg.pop("create_time") msg.pop("update_time") data_dict.append(msg) elasticache_list_re = data_dict[(pageNum - 1) * pageSize:pageNum * pageSize] self.write( dict(code=0, msg='获取成功', count=len(data_dict), data=elasticache_list_re))
def get(self, *args, **kwargs): data_list = [] key = self.get_argument('key', default=None, strip=True) value = self.get_argument('value', default=None, strip=True) page_size = self.get_argument('page', default=1, strip=True) limit = self.get_argument('limit', default=30, strip=True) limit_start = (int(page_size) - 1) * int(limit) user_list = [] with DBContext('r') as session: conditions = [] if key == "typename": conditions.append(TypeList.typename.like('%{}%'.format(value))) if key == "remarks": conditions.append(TypeList.remarks.like('%{}%'.format(value))) if key == "chart": conditions.append(TypeList.chart.like('%{}%'.format(value))) todata = session.query(TypeList).filter(*conditions).order_by( TypeList.ctime.desc()).offset(limit_start).limit( int(limit)).all() tocount = session.query(TypeList).filter(*conditions).count() for msg in todata: case_dict = {} data_dict = model_to_dict(msg) case_dict["id"] = data_dict["id"] case_dict["typename"] = data_dict["typename"] case_dict["remarks"] = data_dict["remarks"] case_dict["chart"] = data_dict["chart"] case_dict["ctime"] = str(data_dict["ctime"]) data_list.append(case_dict) if len(data_list) > 0: return self.write( dict(code=0, msg='获取成功', count=tocount, data=data_list)) else: return self.write(dict(code=-1, msg='没有相关数据', count=0, data=[]))
def get(self, *args, **kwargs): project_code = self.get_argument('project_code', default=None, strip=True) with DBContext('r') as session: config_info = session.query(BusinessModel).filter(BusinessModel.project_code == project_code).all() config_list = [model_to_dict(msg) for msg in config_info] _tree = [{"expand": True, "title": project_code, "children": [], "data_type": 'project'}] if config_list: tmp_tree = {"environ": {}, "service": {}} for t in config_list: service, environ = t['service'], t["environment"] # 因为是第一层所以没有parent tmp_tree["environ"][environ] = { "expand": False, "title": environ, "parent": "root", "children": [], "data_type": 'env' } # 父节点是对应的environ tmp_tree["service"][environ + "|" + service] = { "expand": False, "title": service, "parent": environ, "children": [], "data_type": 'service' } # service的数据插入到environ的children中 for tmpService in tmp_tree["service"].values(): tmp_tree["environ"][tmpService["parent"]]["children"].append(tmpService) for tmpEnviron in tmp_tree["environ"].values(): if tmpEnviron not in ["all", "all_env"]: _tree[0]["children"].append(tmpEnviron) return self.write(dict(code=0, msg='获取项目Tree成功', data=_tree)) else: return self.write(dict(code=0, msg='获取项目Tree失败', data=_tree))
def get(self, *args, **kwargs): """查询出用户登录记录接口""" search_key = self.get_argument('search_key', default=None, strip=True) login_list = [] with DBContext('r') as session: if search_key: # 模糊查所有 login_info = session.query(LoginRecord).filter( or_(LoginRecord.ID.like('%{}%'.format(search_key)), LoginRecord.name.like('%{}%'.format(search_key)), LoginRecord.ip_address.like('%{}%'.format(search_key)), LoginRecord.login_date.like('%{}%'.format(search_key))) ).order_by( LoginRecord.ID ).all() else: login_info = session.query(LoginRecord).order_by( LoginRecord.ID ).all() if login_info: for data in login_info: data_dict = model_to_dict(data) login_list.append(data_dict) return login_list
def get(self, *args, **kwargs): value = self.get_argument('value', default=None, strip=True) db_list = [] with DBContext('r') as session: db_info = session.query(DB).outerjoin( DBTag, DB.id == DBTag.db_id).outerjoin( Tag, Tag.id == DBTag.tag_id).filter( Tag.tag_name == str(value), DB.db_type == 'mysql').all() proxy_host = session.query( Tag.proxy_host).filter(Tag.tag_name == value).first()[0] if not proxy_host: return self.write(dict(code=-1, msg='请给选择标签添加代理主机')) for msg in db_info: data_dict = model_to_dict(msg) db_list.append(data_dict['db_code']) ### 这里需要获取库 未完成 if len(db_list) == 0: return self.write(dict(code=-2, msg='当前标签下没有MySQL库')) self.write(dict(code=0, msg='获取成功', data=db_list))
def put(self, *args, **kwargs): data = json.loads(self.request.body.decode("utf-8")) event_name = data.get('event_name', None) event_status = data.get('event_status', None) event_level = data.get('event_level', None) event_processing = data.get('event_processing', None) event_start_time = data.get('event_start_time', None) event_end_time = data.get('event_end_time', None) if not event_name or not event_status or not event_level or not event_processing or not event_start_time or not event_end_time: return self.write(dict(code=-2, msg='关键参数不能为空')) update_info = { "event_status": event_status, "event_level": event_level, "event_processing": event_processing, "event_start_time": event_start_time, "event_end_time": event_end_time, } if re.search('000Z', event_start_time): event_start_time = datetime.datetime.strptime( event_start_time, "%Y-%m-%dT%H:%M:%S.%fZ") + datetime.timedelta(hours=8) update_info['event_start_time'] = event_start_time if re.search('000Z', event_end_time): event_end_time = datetime.datetime.strptime( event_end_time, "%Y-%m-%dT%H:%M:%S.%fZ") + datetime.timedelta(hours=8) update_info['event_end_time'] = event_end_time with DBContext('w', None, True) as session: session.query(EventRecord).filter( EventRecord.event_name == event_name).update(update_info) self.write(dict(code=0, msg='更新成功'))
def patch(self, *args, **kwargs): # 启用 暂停 data = json.loads(self.request.body.decode("utf-8")) domain_id = data.get('domain_id') domain_state = data.get('domain_state') if not domain_id or not domain_state: return self.write(dict(code=1, msg='关键参数不能为空')) with DBContext('w', None, True) as session: session.query(DNSDomainName).filter( DNSDomainName.domain_id == domain_id).update( {DNSDomainName.domain_state: domain_state}) ### log domain_info = session.query(DNSDomainName).filter( DNSDomainName.domain_id == domain_id).first() log_msg = '{}:{} 用户:{}'.format(domain_state, domain_info.domain_name, self.get_current_nickname()) session.add( DNSDomainLog(domain_name=domain_info.domain_name, log_data=log_msg)) self.write(dict(code=0, msg='{}成功'.format(domain_state)))
def sync_host_usage_from_zabbix(): uz = UserZbx() usage_info = uz.get_ec2_usage_info() d = (datetime.now() - timedelta(days=1)).replace(hour=0, minute=0, second=0, microsecond=0) with DBContext('w', const.DEFAULT_DB_KEY, need_commit=True) as session: for k, v in usage_info.items(): exist_usage = session \ .query(ResourceUsage) \ .filter(ResourceUsage.ec2_id == v["ec2_id"], ResourceUsage.date == d, ).first() if exist_usage: session \ .query(ResourceUsage) \ .filter(ResourceUsage.ec2_id == v["ec2_id"], ResourceUsage.date == d, ).update( { ResourceUsage.ec2_id: v["ec2_id"], ResourceUsage.cpu_usage: v["cpu"], ResourceUsage.mem_usage: v["mem"], ResourceUsage.disk_usage: v["disk"], ResourceUsage.date: d, } ) else: new_record = ResourceUsage(ec2_id=v["ec2_id"], cpu_usage=v["cpu"], mem_usage=v["mem"], disk_usage=v["disk"], date=d) session.add(new_record) session.commit()
def delete(self, *args, **kwargs): data = json.loads(self.request.body.decode("utf-8")) the_id = data.get('the_id') tag_index = data.get('tag_index') with DBContext('w', None, True) as session: hook_info = session.query(GitRepo.git_hooks).filter(GitRepo.id == the_id).first() if not hook_info: return self.write(dict(code=-1, msg='No related items were found')) if not hook_info[0]: return self.write(dict(code=-2, msg='No hooks, ignore')) else: try: hook_dict = json.loads(hook_info[0]) except Exception as e: session.query(GitRepo).filter(GitRepo.id == the_id).update({GitRepo.git_hooks: ""}) return self.write(dict(code=2, msg='钩子出错')) hook_dict.pop(tag_index) hook_dict = json.dumps(hook_dict) session.query(GitRepo).filter(GitRepo.id == the_id).update({GitRepo.git_hooks: hook_dict}) self.write(dict(code=0, msg='删除成功'))
def get(self, *args, **kwargs): key = self.get_argument('key', default=None, strip=True) value = self.get_argument('value', default=None, strip=True) asset_configs_list = [] with DBContext('r') as session: if key and value: asset_configs_data = session.query(AssetConfigs).filter_by( **{ key: value }).all() else: asset_configs_data = session.query(AssetConfigs).all() for data in asset_configs_data: data_dict = model_to_dict(data) data_dict['create_time'] = str(data_dict['create_time']) data_dict['update_time'] = str(data_dict['update_time']) # 解密AccessKey if data_dict.get('access_key'): data_dict['access_key'] = mc.my_decrypt( data_dict.get('access_key')) asset_configs_list.append(data_dict) return self.write(dict(code=0, msg='获取成功', data=asset_configs_list))
def put(self, *args, **kwargs): """管理员修改标签value数据接口""" tag_key = self.get_argument('tag_key', default=None, strip=True) services_name = self.get_argument('services_name', default=None, strip=True) resource_id = self.get_argument('resource_id', default=None, strip=True) tag_value = self.get_argument('tag_value', default=None, strip=True) with DBContext('w') as session: tag_info = session.query(ResultList).filter_by( services_name=services_name, services_resource_id=resource_id, key=tag_key).first() tag_info.value = tag_value session.commit() # 把修改的数据记录到修改数据库 new_order_tag = ChangeResultList(key=tag_key, services_name=services_name, services_resource_id=resource_id, value=tag_value) session.add(new_order_tag) session.commit()
def post(self, *args, **kwargs): data = json.loads(self.request.body.decode("utf-8")) alias_name = data.get('alias_name') cloud_name = data.get('cloud_name') cloud_code = data.get('cloud_code') access_id = data.get('access_id') access_key = data.get('access_key') if not alias_name or not cloud_name or not access_id or not access_key: return self.write(dict(code=-1, msg='关键参数不能为空')) with DBContext('w', None, True) as session: is_exist = session.query(DomainCloudConf.id).filter( DomainCloudConf.alias_name == alias_name).first() if is_exist: return self.write(dict(code=-2, msg='当前账号已经存在,别名不能重复')) session.add( DomainCloudConf(alias_name=alias_name, cloud_name=cloud_name, cloud_code=cloud_code, access_id=access_id, access_key=access_key)) self.write(dict(code=0, msg='添加成功'))
def put(self, *args, **kwargs): data = json.loads(self.request.body.decode("utf-8")) project_name = data.get('project_name', None) project_status = data.get('project_status', None) project_requester = data.get('project_requester', None) project_processing = data.get('project_processing', None) project_start_time = data.get('project_start_time', None) project_end_time = data.get('project_end_time', None) if not project_name or not project_status or not project_requester or not project_processing or not project_start_time or not project_end_time: return self.write(dict(code=-2, msg='关键参数不能为空')) update_info = { "project_status": project_status, "project_requester": project_requester, "project_processing": project_processing, "project_start_time": project_start_time, "project_end_time": project_end_time, } if re.search('000Z', project_start_time): project_start_time = datetime.datetime.strptime( project_start_time, "%Y-%m-%dT%H:%M:%S.%fZ") + datetime.timedelta(hours=8) update_info['project_start_time'] = project_start_time if re.search('000Z', project_end_time): project_end_time = datetime.datetime.strptime( project_end_time, "%Y-%m-%dT%H:%M:%S.%fZ") + datetime.timedelta(hours=8) update_info['project_end_time'] = project_end_time with DBContext('w', None, True) as session: session.query(ProjectMG).filter( ProjectMG.project_name == project_name).update(update_info) self.write(dict(code=0, msg='更新成功'))
def get(self, *args, **kwargs): page_size = self.get_argument('page', default=1, strip=True) limit = self.get_argument('limit', default=500, strip=True) limit_start = (int(page_size) - 1) * int(limit) task_list = [] this_list = [] with DBContext('r') as session: count = session.query(TaskList).filter( TaskList.schedule == 'OK').count() task_info = session.query(TaskList).filter( TaskList.schedule == 'OK').order_by(-TaskList.list_id).offset( limit_start).limit(int(limit)) for msg in task_info: data_dict = model_to_dict(msg) data_dict['create_time'] = str(data_dict['create_time']) data_dict['start_time'] = str(data_dict['start_time']) this_list.append(data_dict.get("list_id")) task_list.append(data_dict) return self.write( dict(code=0, msg="获取成功", data=task_list, count=count, history=True))