async def zabbixWanDelChannel(request): post_data = await request.json() user_id = await get_jwt_info(request, 'user_id') zabbix = post_data['zabbix'] channel_id = str(post_data['channel_id']) api = await async_zabbix_conn(zabbix, 'net') try: channel_info = await api.host.get(hostids=[channel_id], output=['name', 'host']) await api.host.delete(channel_id) await api.close() request.app['zabbix_wan_logger'].info( f'USER ({user_id})| Info in app: del channel {channel_info}') return json_response({ 'result': True, 'text': f"Канал удалён {channel_id}" }) except Exception as err: await api.close() request.app['zabbix_wan_logger'].error( f'USER ({user_id})|Error in app: {str(err)}') return json_response({ 'result': False, 'text': f"Канал не существует {channel_id} {err}" })
async def get_log(request): try: post_data = await request.json() limit = int(post_data['limit']) if post_data['limit'] else 100 conf = request.app['app_config'] engine = sa.create_engine( f"mysql+pymysql://{conf['database']['user']}:{conf['database']['password']}@" f"{conf['database']['ip']}/selfportal") with engine.connect() as conn: res = conn.execute(tbl_app_config.select().with_only_columns( [tbl_app_config.c.value]).where( sa.and_(tbl_app_config.c.keyword == post_data['source'], tbl_app_config.c.type == 'logging'))) result = res.fetchall() path = result[0][0] count = 0 result = [] if post_data['source'] in allowed_logs: for line in readlines_reverse(path): if count < limit: if re.findall(post_data['filter'], line): datetime = ' '.join(line.split()[:2]).split(',')[0] msg = ' '.join(line.split()[6:]) result.append({'datetime': datetime, 'msg': msg}) count += 1 else: break return json_response({'result': True, 'rows': result}) except BaseException as e: request.app['app_logger'].error(f'Error in app: {str(e)}') return json_response({'result': False})
async def get_history(request): try: post_data = await request.json() time = post_data['time'] hosts = post_data['hosts'] hosts_by_source = {} result = {} for host in hosts: if host['source'] not in hosts_by_source: result[host['source']] = {} hosts_by_source[host['source']] = set() hosts_by_source[host['source']].add(host['host']) for source in hosts_by_source: zapi = await async_zabbix_conn(source) zabbix_hosts = await zapi.host.get( output=['hostid', 'host'], filter={'host': list(hosts_by_source[source])}) hostids = {host['hostid']: host['host'] for host in zabbix_hosts} host_history = await zapi.event.get( value='1', hostids=list(hostids.keys()), selectHosts=['extend'], time_from=int( (datetime.datetime.now() - datetime.timedelta(seconds=int(time))).timestamp())) await zapi.close() for event in host_history: if hostids[event['hosts'][0]['hostid']] not in result[source]: result[source][hostids[event['hosts'][0]['hostid']]] = [] result[source][hostids[event['hosts'][0]['hostid']]].append( event) return json_response({'result': True, 'events': result}) except BaseException as e: request.app['eventdashboard_logger'].error(f'Error in app: {str(e)}') return json_response({'result': False, 'text': str(e)})
async def add_maintenance_lite(request): post_data = await request.json() token = request.headers.get('authorization', None).split()[1] jwtd = jwt.decode(token, JWT_SECRET, algorithms=[JWT_ALGORITHM], options={'verify_exp': False}) try: zapi = await async_zabbix_conn(post_data['source'], 'net') host = await zapi.host.get( output=['host', 'hostid'], filter={'name': post_data['value']['hostname']}, limit=1) now = int(time.time()) res = await zapi.maintenance.create( name=jwtd['user_id'] + '_h' + host[0]['hostid'] + '_' + str(now), hostids=[host[0]['hostid']], timeperiods=[{ "timeperiod_type": 0, "period": post_data['value']['time'] }], active_since=now, active_till=now + int(post_data['value']['time']), description=post_data['value']['description']) await zapi.close() request.app['maintenance_logger'].info( f"Created simple maintenance on {post_data['source']} by {jwtd['user_id']} for hostid {host[0]['hostid']} with period from now for {int(post_data['value']['time'])} seconds" ) return json_response({'result': True}) except BaseException as e: request.app['maintenance_logger'].error(f'Error in app: {str(e)}') return json_response({'result': False, 'text': str(e)})
async def update_event(request): try: post_data = await request.json() token = request.headers.get('authorization', None).split()[1] jwtd = jwt.decode(token, JWT_SECRET, algorithms=[JWT_ALGORITHM], options={'verify_exp': False}) ids = post_data['ids'] action = post_data['action'] message = post_data['message'] ids_by_source = {} result = {} errors = [] for id in ids: if id['source'] not in ids_by_source: ids_by_source[id['source']] = {} ids_by_source[id['source']] = set() ids_by_source[id['source']].add(id['id']) for source in ids_by_source: zapi = await async_zabbix_conn(source) try: await zapi.event.acknowledge( action=action, eventids=list(ids_by_source[source]), message=jwtd['user_id'] + ': ' + message) except BaseException as e: errors.append(str(e)) await zapi.close() return json_response({'result': True, 'errors': errors}) except BaseException as e: request.app['eventdashboard_logger'].error(f'Error in app: {str(e)}') return json_response({'result': False, 'text': str(e)})
async def change_power(request): try: post_data = await request.json() ip = post_data['ip'] env = post_data['env'] tag = post_data['tag'] status = post_data['status'] token = request.headers.get('authorization', None).split()[1] jwtd = jwt.decode(token, JWT_SECRET, algorithms=[JWT_ALGORITHM], options={'verify_exp': False}) result, text = await change_power_di( ip, env, tag, status, jwtd['user_id'], request.app['monitoring_add_logger']) if result: request.app['monitoring_add_logger'].info( f"User {jwtd['user_id']} change power for host with ip {ip},env: {env},tag: {tag}. Status: {status}" ) return json_response({'result': True, 'ids': text}) else: return json_response({'result': False, 'text': text}) except BaseException as e: request.app['monitoring_add_logger'].error(f'Error in app: {str(e)}') return json_response({'result': False, 'text': str(e)})
async def get_user_params(request): try: post_data = await request.json() username = post_data['username'] source = post_data['source'] engine = await db_connect() async with engine.acquire() as conn: res = await conn.execute( tbl_users.select().where(tbl_users.c.login == username)) result = await res.fetchall() engine.close() if len(result) > 0: result = result[0] allowed_groups = await get_allowed_grps(source) sigmamail = '' alphamail = '' for mail in result.as_tuple()[4:6]: if '@sberbank.ru' in mail: sigmamail = mail else: alphamail = mail params = dict(mail=alphamail, mail_sigma=sigmamail, allowed_groups=allowed_groups) return json_response({'result': True, 'params': params}) except BaseException as e: request.app['app_logger'].error(f'Error in app: {str(e)}') return json_response({'result': False})
async def add_maintanance(_, request): try: post_data = await request.json() iplist = post_data['iplist'] env, tag, os = post_data['env'], post_data['tag'], post_data['os'] token = request.headers.get('authorization', None).split()[1] jwtd = jwt.decode(token, JWT_SECRET, algorithms=[JWT_ALGORITHM], options={'verify_exp': False}) source = await get_source(env, tag, os) post_data['active_since'] = post_data[ 'start_main'] if 'start_main' in post_data else float(time.time()) period = post_data['period'] post_data['period'] = float(period) * 60 * 60 post_data['active_till'] = post_data['active_since'] + period radd( source, { 'post_data': post_data, 'iplist': iplist, 'method': 'add_maintanance', 'source': source, 'user': jwtd['user_id'] }) return json_response({'result': True}) except BaseException as e: request.app['monitoring_add_logger'].error( f'Error in app: {str(e)}, data {post_data}') return json_response({'result': False, 'text': str(e)})
async def zabbixWanCreateChannels(request): user_id = await get_jwt_info(request, 'user_id') request['user_id'] = user_id post_data = await request.json() zabbix = post_data['zabbix'] chanel = post_data['chanel'] try: api = await async_zabbix_conn(zabbix, 'net') host, group = await get_scheme_to_send(i=chanel, zapi=api, zabbix=zabbix, proxy_balanser=1, request=request) hostid = await api.host.create(host) await update_chanel(api=api, SM_HOSTID=hostid['hostids'][0]) await api.close() await update_cnl_num(db='configs', group=group, zabbix=zabbix) chanel.pop('_showDetails', None) request.app['zabbix_wan_logger'].info( f'USER ({user_id})|Info in app: create channel {chanel}') return json_response({ 'result': True, 'text': f"Данные отправлены успешно" }) except Exception as err: await api.close() if str(err) == 'list index out of range': err = 'Обязательные поля не заполненны' request.app['app_logger'].error(f'Error in app: {str(err)}') request.app['zabbix_wan_logger'].error( f'USER ({user_id})|Error in app: {str(err)}') return json_response({'result': False, 'text': f"{err}"})
async def user_exist_check(request): try: post_data = await request.json() username = post_data['username'] source = post_data['source'] zapi = await async_zabbix_conn(source) user = await zapi.user.get( output='extend', filter={'alias': username}, selectMedias=['mediatypeid', 'sendto', 'active'], selectMediatype='extend', selectUsrgrps=['name']) await zapi.close() except BaseException as e: request.app['app_logger'].error(f'Error in app: {str(e)}') return json_response({'result': False}) else: if len(user) > 0: user = user[0] ZabbixConfig = await get_zabbix_conf() if '(' in user['surname']: res = re.findall('(.*)\((.+)\)', user['surname'])[0] user['surname'] = res[0] user['sigma_login'] = res[1] else: user['sigma_login'] = '' user['phonemedia'] = {'sendto': '', 'active': 1} user['sigmamailmedia'] = {'sendto': '', 'active': 1} user['mailmedia'] = {'sendto': '', 'active': 1} for media in user['medias']: if media['mediatypeid'] == str( ZabbixConfig[source]['phone_media_type']): user['phonemedia'] = media elif media['mediatypeid'] == str( ZabbixConfig[source]['email_media_type']): str_for_chechk = media['sendto'] if isinstance( media['sendto'], str) else media['sendto'][0] if '@sberbank.ru' in str_for_chechk: user['sigmamailmedia'] = media else: user['mailmedia'] = media allowed_groups = await get_allowed_grps(source, with_id=True) user['selected_grps'] = [] for grp in user['usrgrps']: if grp['name'] in allowed_groups: user['selected_grps'].append(grp['name']) elif grp['name'].split('_')[-1] in allowed_groups.values(): user['selected_grps'].append( list(allowed_groups.keys())[list( allowed_groups.values()).index( grp['name'].split('_')[-1])]) return json_response({ 'result': True, 'user': user, 'allowed_groups': list(allowed_groups.keys()) }) else: return json_response({'result': False})
async def run_inventory_task(request): try: post_data = await request.json() config_name = post_data['source'] run_update_inventory(config_name) return json_response({'result': True}) except: return json_response({'result': False})
async def run_task(request): try: post_data = await request.json() config_name = post_data['source'] task_name = post_data['task'] tasks[task_name](config_name) return json_response({'result': True}) except: return json_response({'result': False})
async def get_hostlist_expert(request): post_data = await request.json() try: hostlist = await get_hostlist(post_data['mode'], post_data['value'], post_data['source']) return json_response({'result': True, 'hostnamelist': hostlist}) except BaseException as e: request.app['maintenance_logger'].error(f'Error in app: {str(e)}') return json_response({'result': False, 'text': str(e)})
async def new_problem(request): try: post_data = await request.json() asyncio.get_event_loop().create_task(new_problem_generate(request)) return json_response({'result': True}) except BaseException as e: request.app['eventdashboard_logger'].error( f'Error {str(type(e))}in app: {str(e)}, header: {post_data["id"]}, msg:{post_data["msg"]}' ) return json_response({'result': False})
async def zabbixWanUpdateChannel(request): post_data = await request.json() user_id = await get_jwt_info(request, 'user_id') request['user_id'] = user_id zabbix = post_data['zabbix'] chanel = post_data['chanel'] host_id = chanel['hostid'] host_name = chanel['host'] api = await async_zabbix_conn(zabbix, 'net') try: host, group = await get_scheme_to_send(i=chanel, zapi=api, zabbix=zabbix, proxy_balanser=1, request=request) host['host'] = host_name host["hostid"] = host_id hostinterface = await api.host.get(hostids=[host_id], selectInterfaces=["interfaceid"], output=['interfaces']) host['interfaces'][0]['interfaceid'] = hostinterface[0]['interfaces'][ 0]['interfaceid'] await api.host.update(host) macros = await api.usermacro.get(hostids=[host_id]) macros.extend([{ 'macro': '{$SM_HOSTID}', 'value': host_id }, { 'macro': '{$SCREEN_LINK}', 'value': f'https://zabbix-cssm.sigma.sbrf.ru/zabbix_wan/' f'zabbix.php?action=problem.view&page=1&filter_' f'show=1&filter_hostids[]={host_id}&filter_se' f'verity=2&filter_set=1' }]) await api.host.update({'hostid': host_id, 'macros': macros}) await api.close() host_info = host request.app['zabbix_wan_logger'].info( f'USER ({user_id})|Info in app: update channel {chanel}') return json_response({ 'result': True, 'text': f"Данные ({host_name}) успешно обновлены" }) except Exception as err: await api.close() request.app['zabbix_wan_logger'].error( f'USER ({user_id})|Error in app: {str(err)}') return json_response({'result': False, 'text': f"{err}"})
async def get_templateslist(request): post_data = await request.json() try: zapi = await async_zabbix_conn(post_data['source']) search_query = {} if post_data['hostname']: search_query = {'host': post_data['hostname']} res = await zapi.template.get(output=['name'], search=search_query) hostlist = [host['name'] for host in res] await zapi.close() return json_response({'result': True, 'templatenamelist': hostlist}) except BaseException as e: request.app['app_logger'].error(f'Error in app: {str(e)}') return json_response({'result': False, 'text': str(e)})
async def save_filter(request): try: token = request.headers.get('authorization', None).split()[1] jwtd = jwt.decode(token, JWT_SECRET, algorithms=[JWT_ALGORITHM], options={'verify_exp': False}) post_data = await request.json() filters = post_data['filters'] engine = await db_connect('configs') async with engine.acquire() as conn: try: await conn.execute(tbl_eventdashboard_filters.insert().values( author=jwtd['user_id'], name=filters['name'], query=filters['query'], time=filters['time'], row_count=filters['row_count'], severities=json.dumps(filters['severities'], ensure_ascii=False), selected_cols=json.dumps(filters['selected_cols'], ensure_ascii=False), colors=json.dumps(filters['colors'], ensure_ascii=False), width=json.dumps(filters['width'], ensure_ascii=False))) await conn.execute("commit") except pymysql.err.IntegrityError: await conn.execute(tbl_eventdashboard_filters.update().values( query=filters['query'], time=filters['time'], row_count=filters['row_count'], severities=json.dumps(filters['severities'], ensure_ascii=False), selected_cols=json.dumps(filters['selected_cols'], ensure_ascii=False), colors=json.dumps(filters['colors'], ensure_ascii=False), width=json.dumps( filters['width'], ensure_ascii=False)).where( sa.and_( tbl_eventdashboard_filters.c.name == filters['name'], tbl_eventdashboard_filters.c.author == jwtd['user_id']))) await conn.execute("commit") engine.close() return json_response({'result': True}) except BaseException as e: request.app['eventdashboard_logger'].error(f'Error in app: {str(e)}') return json_response({'result': False, 'text': str(e)})
async def create_host_view(_, request): try: post_data = await request.json() token = request.headers.get('authorization', None).split()[1] jwtd = jwt.decode(token, JWT_SECRET, algorithms=[JWT_ALGORITHM], options={'verify_exp': False}) res = await create_host(post_data, jwtd, request.app['monitoring_add_logger']) return json_response(res) except BaseException as e: request.app['monitoring_add_logger'].error( f'Error in app: {str(e)}, data {post_data}') return json_response({'result': False, 'text': str(e)})
async def get_select(request): try: params = await get_showed_zabbix() dict_params = {} for arr in params: dict_params[arr[0]] = { 'url': arr[1], 'name': arr[2], 'search_url': arr[3], 'zabbixType': arr[4] } return json_response({'result': True, 'params': dict_params}) except BaseException as e: request.app['app_logger'].error(f'Error in app: {str(e)}') return json_response({'result': False})
async def add_maintenance_expert(request): post_data = await request.json() token = request.headers.get('authorization', None).split()[1] jwtd = jwt.decode(token, JWT_SECRET, algorithms=[JWT_ALGORITHM], options={'verify_exp': False}) try: zapi = await async_zabbix_conn(post_data['source'], 'net') if post_data['value']['mode'] == 'host': res = await zapi.host.get( output=['hostid'], filter={'name': post_data['value']['value']}, limit=30) objid = [host['hostid'] for host in res] objkey = 'hostids' mode_str = '_h' else: res = await zapi.hostgroup.get( output=['groupid'], filter={'name': post_data['value']['value']}, limit=30) objid = [host['groupid'] for host in res] objkey = 'groupids' mode_str = '_g' fromtime = int(post_data['value']['date'] / 1000) res = await zapi.maintenance.create( name=jwtd['user_id'] + mode_str + objid[0] + '_' + str(fromtime), **{objkey: objid}, timeperiods=[{ "timeperiod_type": 0, "start_date": fromtime, "period": post_data['value']['time'] }], active_since=fromtime, active_till=fromtime + int(post_data['value']['time']), tags_evaltype=0 if post_data['value']['tags_mode'] == 'And/Or' else 2, tags=post_data['value']['tags'], description=post_data['value']['description']) await zapi.close() request.app['maintenance_logger'].info( f"Created maintenance on {post_data['source']} by {jwtd['user_id']} for object {mode_str + objid[0]} with period from {fromtime} for {int(post_data['value']['time'])} seconds" ) return json_response({'result': True}) except BaseException as e: request.app['maintenance_logger'].error(f'Error in app: {str(e)}') return json_response({'result': False, 'text': str(e)})
async def get_csv(request): post_data = await request.json() query_filter = post_data['params']['filter'] if post_data['params'][ 'filter'] else '' if query_filter: for key in column_mapping: query_filter = query_filter.replace(f"'{key}'", column_mapping[key].lower()) query_filter = query_filter.replace(f"'{key.lower()}'", column_mapping[key].lower()) query_filter = 'where ' + query_filter try: engine = await db_connect('configs') async with engine.acquire() as conn: res = await conn.execute( f"select * from configs.sm_report {query_filter}") result = await res.fetchall() engine.close() csv = 'CI;hostname;dnsname;IP;dnsdomain;OS;env;admingroup;zabbix\n' for line in result: csv += ';'.join(line.as_tuple()) + '\n' resp = web.Response( body=csv, headers=aiohttp.multipart.CIMultiDict({ 'CONTENT-DISPOSITION': 'attachment; filename:"sm_report_%s"' % datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') })) resp.content_type = 'text/csv' return resp except BaseException as e: request.app['app_logger'].error(f'Error in app: {str(e)}') return json_response({'result': False})
async def update_user(request): post_data = await request.json() row = post_data['row'] try: engine = await db_connect() async with engine.acquire() as conn: await conn.execute( tbl_users.update().values(groups=row['groups'], enable=row['enable']).where(tbl_users.c.login == row['login'].lower())) await conn.execute("commit") engine.close() return json_response({'result': 'True'}) except BaseException as e: request.app['app_logger'].error(f'Error in app: {str(e)}') return json_response({'result': False})
async def delete_filter(request): try: post_data = await request.json() author, name = post_data['key'].split(':') engine = await db_connect('configs') async with engine.acquire() as conn: await conn.execute(tbl_eventdashboard_filters.delete().where( sa.and_(tbl_eventdashboard_filters.c.name == name, tbl_eventdashboard_filters.c.author == author))) await conn.execute("commit") engine.close() return json_response({'result': True}) except BaseException as e: request.app['eventdashboard_logger'].error(f'Error in app: {str(e)}') return json_response({'result': False})
async def get_user_list(request): engine = await db_connect() async with engine.acquire() as conn: res = await conn.execute(tbl_users.select()) result = await res.fetchall() engine.close() return json_response({'result': 'True','rows': [dict(r) for r in result]})
async def refresht(request): post_data = await request.json() try: jwtd = jwt.decode(post_data['token'], JWT_SECRET, algorithms=[JWT_ALGORITHM],options={'verify_exp': False}) engine = await db_connect() async with engine.acquire() as conn: res = await conn.execute(tbl_users.select().where(tbl_users.c.login == jwtd['user_id'])) result = await res.fetchone() engine.close() if (jwtd['exp'] < jwtd['orig_iat']) and (get_role(request.app['app_config'],result[6]) == jwtd['role']) and (result[7] == True): jwtd['exp'] = int(time.time()) + JWT_EXP_DELTA_SECONDS jwt_token = jwt.encode(jwtd, JWT_SECRET, JWT_ALGORITHM) return json_response({'token': jwt_token.decode('utf-8')}) except Exception as e: request.app['app_logger'].error(f'Error in app: {str(e)}') return json_response({'result': False}, status=400)
async def get_time(request): try: engine = await db_connect('configs') async with engine.acquire() as conn: res_time = await conn.execute( "select time from report_date where reportname='sm_report'") time = await res_time.fetchall() time = time[0][0] if time > datetime.datetime.now() - datetime.timedelta(days=1): color = 'green' else: color = 'red' time = datetime.datetime.strftime(time, '%Y-%m-%d %H:%M:%S') return json_response({'result': 'True', 'time': time, 'color': color}) except BaseException as e: request.app['app_logger'].error(f'Error in app: {str(e)}') return json_response({'result': False})
async def delete_maintenance(request): post_data = await request.json() token = request.headers.get('authorization', None).split()[1] jwtd = jwt.decode(token, JWT_SECRET, algorithms=[JWT_ALGORITHM], options={'verify_exp': False}) try: zapi = await async_zabbix_conn(post_data['source'], 'net') await zapi.maintenance.delete(post_data['data']['maintenanceid']) await zapi.close() request.app['maintenance_logger'].info( f"Deleted maintenance on {post_data['source']} by {jwtd['user_id']} with name {post_data['data']['name']}" ) return json_response({'result': True}) except BaseException as e: request.app['maintenance_logger'].error(f'Error in app: {str(e)}') return json_response({'result': False, 'text': str(e)})
async def get_data(request): post_data = await request.json() page_length = int(post_data['params']['page_length'] ) if post_data['params']['page_length'] else 10 page_number = int(post_data['params']['page_number'] ) if post_data['params']['page_number'] > 0 else 1 query_filter = post_data['params']['filter'] if post_data['params'][ 'filter'] else '' if query_filter: for key in column_mapping: query_filter = query_filter.replace(f"'{key}'", column_mapping[key].lower()) query_filter = query_filter.replace(f"'{key.lower()}'", column_mapping[key].lower()) query_filter = 'where ' + query_filter try: engine = await db_connect('configs') async with engine.acquire() as conn: res_count = await conn.execute( f'select count(*) from configs.sm_report {query_filter}') result_count = await res_count.fetchall() result_count = result_count[0][0] result_count = result_count if result_count > 0 else 1 res = await conn.execute( f"select * from configs.sm_report {query_filter} limit {(page_number-1) * page_length},{page_length}" ) columns = [column[0] for column in res.cursor.description] result = await res.fetchall() engine.close() result_temp = [] for index in range(len(result)): tmp_dict = {} for col_index in range(len(columns)): tmp_dict[columns[col_index]] = result[index][col_index] result_temp.append(tmp_dict) return json_response({ 'result': 'True', 'rows': result_temp, 'pages': result_count }) except BaseException as e: request.app['app_logger'].error(f'Error in app: {str(e)}') return json_response({'result': False, 'rows': [], 'pages': 1})
async def get_maintenance(request): post_data = await request.json() try: zapi = await async_zabbix_conn(post_data['source'], 'net') if post_data['type'] == 'host': host = await zapi.host.get(output=['host', 'hostid'], selectGroups=['groupid'], filter={'name': post_data['value']}, limit=1) host_grps = [group['groupid'] for group in host[0]['groups']] maintenances = await zapi.maintenance.get( hostids=host[0]['hostid'], groupids=host_grps, selectTags='extend', selectHosts=['host', 'name'], selectGroups=['name'], selectTimeperiods='extend', limit=30) maintenances = [ maintenance for maintenance in maintenances if int(maintenance['active_till']) > int(time.time()) ] else: grp = await zapi.hostgroup.get(output=['groupid'], filter={'name': post_data['value']}, limit=1) maintenances = await zapi.maintenance.get( groupids=grp[0]['groupid'], selectTags='extend', selectHosts=['host', 'name'], selectGroups=['name'], selectTimeperiods='extend', limit=30) maintenances = [ maintenance for maintenance in maintenances if int(maintenance['active_till']) > int(time.time()) ] await zapi.close() return json_response({'result': True, 'maintenances': maintenances}) except BaseException as e: request.app['maintenance_logger'].error(f'Error in app: {str(e)}') return json_response({'result': False, 'text': str(e)})
async def check_stand(request): try: post_data = await request.json() # source = post_data['source'] ZabbixConfig = await get_zabbix_conf() engine = await db_connect('configs') async with engine.acquire() as conn: res = await conn.execute( f"select * from configs.databases where name='ORACLESM'") db_config = await res.fetchall() engine.close() db_config = db_config[0].as_tuple() func_for_execute = partial(getsearch, post_data['query'], ZabbixConfig, post_data['source'], db_config) search_result = await asyncio.get_event_loop().run_in_executor( None, func_for_execute) return json_response({'result': True, 'rows': search_result}) except BaseException as e: request.app['app_logger'].error(f'Error in app: {str(e)}') return json_response({'result': False})