def __init__(self, obj_repo):
self.repo = obj_repo
self.obj_utils = Utils()
self.boto_client = BotoUtils(region_name=REGION_NAME)
import json
import re
import traceback
from service_status.config import NETWORKS, NETWORK_ID
from common.repository import Repository
from common.utils import Utils
from service_status.service_status import ServiceStatus
NETWORKS_NAME = dict(
(NETWORKS[netId]['name'], netId) for netId in NETWORKS.keys())
obj_util = Utils()
db = dict((netId, Repository(net_id=netId, NETWORKS=NETWORKS))
for netId in NETWORKS.keys())
def request_handler(event, context):
print(event)
try:
obj_srvc_st = ServiceStatus(repo=db[NETWORK_ID], net_id=NETWORK_ID)
obj_srvc_st.update_service_status()
except Exception as e:
print(repr(e))
obj_util.report_slack(
1, "Error in updating service status::NETWORK_ID:" + NETWORK_ID +
"|err:" + e)
traceback.print_exc()
return
import json
import traceback
from time import sleep
from common.constant import TransactionStatus
from common.logger import get_logger
from common.repository import Repository
from common.utils import Utils
from wallets.config import NETWORKS, NETWORK_ID, SLACK_HOOK
from wallets.dao.channel_dao import ChannelDAO
from wallets.service.wallet_service import WalletService
connection = Repository(net_id=NETWORK_ID, NETWORKS=NETWORKS)
channel_dao = ChannelDAO(connection)
utils = Utils()
logger = get_logger(__name__)
class ManageCreateChannelEvent:
def __init__(self):
pass
@staticmethod
def manage_create_channel_event():
create_channel_event_from_orchestrator = channel_dao.get_one_create_channel_event(
TransactionStatus.PENDING)
if not bool(create_channel_event_from_orchestrator):
return
wallet_manager = WalletService(connection)
payload = json.loads(create_channel_event_from_orchestrator["payload"])
def wrapper(*args, **kwargs):
handler_name = decorator_kwargs.get("handler_name", func.__name__)
path = kwargs.get("event", {}).get("path", None)
path_parameters = kwargs.get("event", {}).get("pathParameters", {})
query_string_parameters = kwargs.get("event", {}).get(
"queryStringParameters", {})
body = kwargs.get("event", {}).get("body", "{}")
error_message = f"Error Reported! \n" \
f"network_id: {NETWORK_ID}\n" \
f"path: {path}, \n" \
f"handler: {handler_name} \n" \
f"pathParameters: {path_parameters} \n" \
f"queryStringParameters: {query_string_parameters} \n" \
f"body: {body} \n" \
f"x-ray-trace-id: None \n" \
f"error_description: \n"
try:
return func(*args, **kwargs)
except EXCEPTIONS as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
exc_tb_lines = traceback.format_tb(exc_tb)
error_message = error_message + e.error_message + "\n"
logger.exception(error_message)
slack_message = error_message
for exc_lines in exc_tb_lines:
slack_message = slack_message + exc_lines
slack_message = f"```{slack_message}```"
Utils().report_slack(type=0,
slack_msg=slack_message,
SLACK_HOOK=SLACK_HOOK)
return generate_lambda_response(
StatusCode.INTERNAL_SERVER_ERROR, {
"status": "failed",
"data": "",
"error": {
"message": e.error_message,
"details": e.error_details
}
},
cors_enabled=True)
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
exc_tb_lines = traceback.format_tb(exc_tb)
logger.exception(error_message)
slack_message = error_message
for exc_lines in exc_tb_lines:
slack_message = slack_message + exc_lines
slack_message = f"```{slack_message}```"
Utils().report_slack(type=0,
slack_msg=slack_message,
SLACK_HOOK=SLACK_HOOK)
return generate_lambda_response(
StatusCode.INTERNAL_SERVER_ERROR, {
"status": "failed",
"data": "",
"error": {
"code": 0,
"message": repr(e),
"details": {}
}
},
cors_enabled=True)
from common.blockchain_util import BlockChainUtil
from common.utils import Utils
from rfai.config import NETWORK
from rfai.dao.foundation_member_data_access_object import FoundationMemberDAO
from rfai.dao.request_data_access_object import RequestDAO
from rfai.dao.solution_data_access_object import SolutionDAO
from rfai.dao.stake_data_access_object import StakeDAO
from rfai.dao.vote_data_access_object import VoteDAO
from rfai.dao.rfai_request_repository import RFAIRequestRepository
from rfai.rfai_status import RFAIStatusCodes
import json
from common.logger import get_logger
obj_utils = Utils()
obj_blockchain_utils = BlockChainUtil(provider_type="HTTP_PROVIDER", provider=NETWORK["http_provider"])
logger = get_logger(__name__)
class RFAIService:
def __init__(self, repo):
self.request_dao = RequestDAO(repo=repo)
self.vote_dao = VoteDAO(repo=repo)
self.solution_dao = SolutionDAO(repo=repo)
self.stake_dao = StakeDAO(repo=repo)
self.foundation_member_dao = FoundationMemberDAO(repo=repo)
self.rfai_request_dao = RFAIRequestRepository(repo=repo)
def _format_filter_params(self, query_parameters):
filter_params = {}
# if "requester" in query_parameters.keys():
# filter_params["requester"] = query_parameters["requester"]
from common.constant import StatusCode
from common.logger import get_logger
from common.utils import Utils
from rfai.config import SLACK_HOOK, NETWORK_ID, NETWORK, IPFS_URL
from rfai.consumers.rfai_request_event_consumer import RFAIApproveRequestEventConsumer, RFAICreateRequestEventConsumer, \
RFAIRejectRequestEventConsumer, RFAIAddSolutionRequestEventConsumer, RFAIAddFoundationMemberEventConsumer, \
RFAIFundRequestEventConsumer, RFAIExtendRequestEventConsumer, RFAIVoteRequestEventConsumer, \
RFAICloseRequestEventConsumer, RFAIClaimBackRequestEventConsumer, RFAIClaimRequestEventConsumer
logger = get_logger(__name__)
util = Utils()
def create_request_consumer_handler(event, context):
try:
logger.info(f"Got Create Request Event {event}")
RFAICreateRequestEventConsumer(NETWORK_ID, NETWORK['ws_provider'], IPFS_URL['url'], IPFS_URL['port']).on_event(
event)
return util.generate_lambda_response(StatusCode.OK, "Event processed")
except Exception as e:
logger.exception(f"error {str(e)} while processing event {event}")
util.report_slack(f"got error : {str(e)} \n for event : {event}", SLACK_HOOK)
return util.generate_lambda_response(500, str(e))
def extend_request_consumer_handler(event, context):
try:
logger.info(f"Got Extend Request Event {event}")
def send_slack_alert(self, unsuccessful_files):
slack_msg = f"Failed to delete files\n```{unsuccessful_files}```"
return Utils().report_slack(slack_msg=slack_msg, SLACK_HOOK=SLACK_HOOK)
def __init__(self, err_obj, net_id):
self.err_obj = err_obj
self.repo = Repository(net_id)
self.util_obj = Utils()
def __init__(self, obj_repo, net_id):
self.repo = obj_repo
self.net_id = net_id
self.lambda_client = boto3.client('lambda')
self.obj_utils = Utils()
def send_slack_message(self, slack_msg):
Utils().report_slack(slack_msg, APPROVAL_SLACK_HOOK)
def _search_query_data(self, sub_qry, sort_by, order_by, offset, limit,
filter_query, values):
try:
if filter_query != "":
filter_query = " AND " + filter_query
srch_qry = "SELECT * FROM service A, (SELECT M.org_id, M.service_id, group_concat(T.tag_name) AS tags FROM " \
"service_metadata M LEFT JOIN service_tags T ON M.service_row_id = T.service_row_id " \
"LEFT JOIN service_endpoint E ON M.service_row_id = E.service_row_id WHERE (" \
+ sub_qry.replace('%', '%%') + ")" + filter_query + \
" GROUP BY M.org_id, M.service_id ORDER BY E.is_available DESC, " + sort_by + " " + order_by + \
" ) B WHERE A.service_id = B.service_id AND A.org_id=B.org_id AND A.is_curated= 1 LIMIT %s , %s"
qry_dta = self.repo.execute(srch_qry, values +
[int(offset), int(limit)])
org_srvc_tuple = ()
rslt = {}
for rec in qry_dta:
org_id = rec['org_id']
service_id = rec['service_id']
tags = rec['tags']
org_srvc_tuple = org_srvc_tuple + ((org_id, service_id), )
if org_id not in rslt.keys():
rslt[org_id] = {}
if service_id not in rslt[org_id].keys():
rslt[org_id][service_id] = {}
rslt[org_id][service_id]["tags"] = tags
qry_part = " AND (S.org_id, S.service_id) IN " + \
str(org_srvc_tuple).replace(',)', ')')
qry_part_where = " AND (org_id, service_id) IN " + \
str(org_srvc_tuple).replace(',)', ')')
print("qry_part::", qry_part)
sort_by = sort_by.replace("org_id", "M.org_id")
if org_srvc_tuple:
services = self.repo.execute(
"SELECT DISTINCT M.row_id, M.service_row_id, M.org_id, M.service_id, M.display_name, M.description, M.url, M.json, M.model_ipfs_hash, M.encoding, M.`type`,"
" M.mpe_address,M.service_rating, M.ranking, M.contributors, M.short_description,"
"O.organization_name,O.org_assets_url FROM service_endpoint E, service_metadata M, service S "
", organization O WHERE O.org_id = S.org_id AND S.row_id = M.service_row_id AND "
"S.row_id = E.service_row_id " + qry_part +
"ORDER BY E.is_available DESC, " + sort_by + " " +
order_by)
services_media = self.repo.execute(
"select org_id ,service_id,file_type ,asset_type,url,alt_text ,`order`,row_id from service_media where asset_type = 'hero_image' "
+ qry_part_where)
else:
services = []
services_media = []
obj_utils = Utils()
obj_utils.clean(services)
available_service = self._get_is_available_service()
for rec in services:
self._convert_service_metadata_str_to_json(rec)
org_id = rec["org_id"]
service_id = rec["service_id"]
tags = []
is_available = 0
if rslt.get(org_id, {}).get(service_id,
{}).get("tags", None) is not None:
tags = rslt[org_id][service_id]["tags"].split(",")
if (org_id, service_id) in available_service:
is_available = 1
asset_media = []
if len(services_media) > 0:
asset_media = [
x for x in services_media
if x['service_id'] == service_id
]
if len(asset_media) > 0:
asset_media = asset_media[0]
rec.update({"tags": tags})
rec.update({"is_available": is_available})
rec.update({"media": asset_media})
return services
except Exception as err:
raise err
def __init__(self):
self.preprocessing = Preprocessing()
self.utils = Utils()
def __init__(self, repo, net_id):
self.repo = repo
self.route = "/encoding"
self.rex_for_pb_ip = "^(http://)*(https://)*127.0.0.1|^(http://)*(https://)*localhost|^(http://)*(https://)*192.|^(http://)*(https://)*172.|^(http://)*(https://)*10."
self.obj_util = Utils()
self.net_id = net_id
from common.utils import Utils
import requests
common_utils = Utils()
"""
*********************************************************************************************
Author | Muhammad Umair *
Date Created | 9/1/2019 *
*********************************************************************************************
"""
class Pet:
"""
Description:
| This class contains methods for testing API calls for pet endpoint
"""
def __init__(self):
"""
Description:
| This is the Constructor method for the class Pet.
"""
self.base_url = "https://petstore.swagger.io/v2"
def find_pet_by_status(self, param):
"""
Description:
| This method will find a pet by its availability status -- Available values : available, pending, sold
| This method builds the request URL through utils method build_get_request_url(), for query paramaters recieved in param (string)
| It then initiates a GET call & returns the response
"""
def __init__(self, obj_repo):
self.repo = obj_repo
self.obj_utils = Utils()
self.ssm_client = boto3.client('ssm', region_name="us-east-1")
def __init__(self, obj_repo):
self.repo = obj_repo
self.obj_utils = Utils()
def __init__(self, net_id, obj_repo):
self.repo = obj_repo
self.objSrvc = Service(obj_repo=obj_repo)
self.ws_provider = NETWORKS[net_id]['ws_provider']
self.obj_util = Utils()
class BaseApi:
conf_path = os.path.join(CONF_DIR, 'config.yaml')
# 配置文件数据
conf_data = Utils().handle_yaml(conf_path)
host = conf_data['env']['host']
headers = conf_data['request_headers']['headers']
account = conf_data['account']
investor_account = conf_data['investor_account']
mysql_conf = conf_data['mysql']
def send_http(self, data: dict):
"""
发送http请求
:param data: 请求数据
:return:
"""
try:
self.__api_log(**data)
response = requests.request(**data)
logger.info(f"响应结果为：{response.status_code}")
except Exception as e:
logger.error(f'发送请求失败，请求参数为：{data}')
logger.exception(f'发生的错误为：{e}')
raise e
else:
return response
@staticmethod
def get_yaml(file_name):
"""
读取yaml文件
:param file_name: 文件路径名称
:return: dict
"""
return Utils.handle_yaml(file_name)
@staticmethod
def get_token(response):
"""
处理并提取token
:param response:
:return:
"""
return Utils.handle_token(response)
@staticmethod
@allure.step('step:数据替换')
def template(source_data: str, data: dict):
"""
替换数据
:param source_data: 源数据
:param data: 替换内容，如{data:new_data}
:return:
"""
return Utils.handle_template(source_data, data)
@staticmethod
def to_two_decimal(data):
"""
将整数或浮点数转化为两位数decimal
:param data:
:return:
"""
return Utils.handle_decimal(data)
@staticmethod
def random_phone():
"""
生成随机手机号
:return:
"""
return Utils.handle_random_phone()
@staticmethod
def __api_log(method, url, headers=None, params=None, json=None):
logger.info(f"请求方式：{method}")
logger.info(f"请求地址：{url}")
logger.info(f"请求头：{headers}")
logger.info(f"请求参数：{params}")
logger.info(f"请求体：{json}")
@staticmethod
def assert_equal(ex, re):
"""
断言相等
:param ex:预期结果
:param re:实际结果
:return:
"""
return HandleAssert.eq(ex, re)
@staticmethod
def assert_contains(content, target):
"""
断言包含
:param content: 文本内容
:param target: 目标文本
:return:
"""
return HandleAssert.contains(content, target)
def setUp(self):
"""Call before every test case."""
self.utils = Utils()
self._out_dir = os.getcwd() + '/temp/'
self._teardown_flag = False
