class Adapter:
def __init__(self, input):
self.id = input.get('id', '1')
self.request_data = input.get('data')
if self.validate_request_data():
self.bridge = Bridge()
self.create_request()
else:
self.result_error('Invalid data provided')
def validate_request_data(self):
""" Validates the incoming data against a pre-defined schema
:return: True if the data provided is a valid JSON containing a
dataset key, False otherwise
"""
schema = Schema(
{
'dataset': str,
Optional('rows'): And(int, lambda n: 0 < n)
},
ignore_extra_keys=True)
return schema.is_valid(self.request_data)
def create_request(self):
try:
data = self.request_data
data['result'] = self.bridge.request(self.request_data)
self.result_success(data)
except Exception as e:
self.result_error(e)
def result_success(self, data):
self.result = {
'jobRunID': self.id,
'data': data,
'statusCode': 200,
}
def result_error(self, error):
self.result = {
'jobRunID': self.id,
'status': 'errored',
'error': f'There was an error: {error}',
'statusCode': 500,
}
def __repr__(self):
return f'Adapter({self.id!r}, {self.request_data!r})'
class Adapter:
base_url = 'https://sandbox.swift.com/swift-apitracker/v4/payments' # '/{uetr}/status' needs to be appended
from_params = ['ID', 'UETR', 'transaction']
action_params = ['cancellation', 'status', 'transactions']
oauth_token = ['oauth', 'token', 'oauth_token']
def __init__(self, input):
self.id = input.get('id', '1')
self.request_data = input.get('data')
self.result_json = "N/A"
if self.validate_request_data():
self.bridge = Bridge()
self.set_params()
self.create_request()
else:
self.result_error('No data provided')
def validate_request_data(self):
if self.request_data is None:
return False
if self.request_data == {}:
return False
return True
def set_params(self):
for param in self.from_params:
self.from_param = self.request_data.get(param)
if self.from_param is not None:
break
for param in self.action_params:
self.to_param = self.request_data.get(param)
if self.to_param is not None:
break
for param in self.oauth_token:
self.oauth = self.request_data.get(param)
if self.oauth is not None:
break
def create_request(self):
try:
headers = {"Authorization": "Basic "+self.oauth}
self.base_url += "/"+self.from_param+"/"+self.to_param
response = self.bridge.request(self.base_url, headers)
data = response.json()
self.result_json = data
switcher = {
"transactions": "transaction_status",
"cancellation": "cancellation_reason_information",
"status": "transaction_status"
}
print("switch case: "+switcher.get(self.to_param, ""))
self.result = data[switcher.get(self.to_param, "")]
data['result'] = self.result
self.result_success(data)
except Exception as e:
self.result_error(e)
finally:
self.bridge.close()
def result_success(self, data):
self.result = {
'jobRunID': self.id,
'data': data,
'result': self.result,
'statusCode': 200,
}
def result_error(self, error):
self.result = {
'jobRunID': self.id,
'status': 'errored',
'error': f'There was an error: {error}',
'data': self.result_json,
'statusCode': 500,
}
class Adapter:
base_url = 'https://min-api.cryptocompare.com/data/price'
from_params = ['base', 'from', 'coin']
to_params = ['quote', 'to', 'market']
def __init__(self, input):
self.id = input.get('id', '1')
self.request_data = input.get('data')
if self.validate_request_data():
self.bridge = Bridge()
self.set_params()
self.create_request()
else:
self.result_error('No data provided')
def validate_request_data(self):
if self.request_data is None:
return False
if self.request_data == {}:
return False
return True
def set_params(self):
for param in self.from_params:
self.from_param = self.request_data.get(param)
if self.from_param is not None:
break
for param in self.to_params:
self.to_param = self.request_data.get(param)
if self.to_param is not None:
break
def create_request(self):
try:
params = {
'fsym': self.from_param,
'tsyms': self.to_param,
}
response = self.bridge.request(self.base_url, params)
data = response.json()
self.result = data[self.to_param]
data['result'] = self.result
self.result_success(data)
except Exception as e:
self.result_error(e)
finally:
self.bridge.close()
def result_success(self, data):
self.result = {
'jobRunID': self.id,
'data': data,
'result': self.result,
'statusCode': 200,
}
def result_error(self, error):
self.result = {
'jobRunID': self.id,
'status': 'errored',
'error': f'There was an error: {error}',
'statusCode': 500,
}
class Adapter:
def __init__(self, input):
self.base_url = "https://api.openai.com/v1/engines/davinci/completions"
self.id = input.get('id', '1')
self.request_data = input.get('data')
if self.validate_request_data():
self.bridge = Bridge()
self.set_params()
self.create_request()
else:
self.result_error('No data provided')
def validate_request_data(self):
if self.request_data is None:
return False
if self.request_data == {}:
return False
return True
def set_params(self):
self.prompt = self.request_data.get("prompt")
def create_request(self):
print(pre_prompt + self.prompt)
try:
headers={
"Authorization": f"Bearer {config.API_KEY}",
"Content-Type": 'application/json'
}
json={
"prompt": pre_prompt + self.prompt,
"max_tokens": 40,
"temperature": 0.5,
"top_p": 1,
"n": 1,
"stop": ["#"]
}
response = self.bridge.request(self.base_url, json=json, headers=headers)
data = response.json()['choices'][0]['text']
if ':' in data:
data = data.split(':')[1][1:]
hex_data = binascii.hexlify(data.encode('utf8'))
bytes_data = '0x' + str(hex_data)[2:-1]
self.result = bytes_data
self.result_success(bytes_data)
except Exception as e:
self.result_error(e)
finally:
self.bridge.close()
def result_success(self, data):
self.result = {
'jobRunID': self.id,
'data': data,
'result': self.result,
'statusCode': 200,
}
def result_error(self, error):
self.result = {
'jobRunID': self.id,
'status': 'errored',
'error': f'There was an error: {error}',
'statusCode': 500,
}
class Adapter:
base_url = 'http://kibana.log4analytics.com:9080/1.0/identifiers/'
from_params = ['DID_userid']
to_params = ['quote', 'to', 'market']
def __init__(self, input):
self.id = input.get('id', '1')
self.request_data = input.get('data')
if self.validate_request_data():
self.bridge = Bridge()
self.set_params()
self.create_request()
else:
self.result_error('No data provided')
def validate_request_data(self):
if self.request_data is None:
return False
if self.request_data == {}:
return False
return True
def set_params(self):
for param in self.from_params:
self.from_param = self.request_data.get(param)
if self.from_param is not None:
break
for param in self.to_params:
self.to_param = self.request_data.get(param)
if self.to_param is not None:
break
def create_request(self):
try:
params = {
'fsym': self.from_param,
'tsyms': self.to_param,
}
print(self.from_param)
self.base_url = self.base_url + self.from_param
print(self.base_url)
response = self.bridge.request(self.base_url, params)
data = response.json()
self.result = data['didDocument']['id']
data['result'] = self.result
self.result_success(data)
except Exception as e:
self.result_error(e)
finally:
self.bridge.close()
def result_success(self, data):
self.result = {
'jobRunID': self.id,
'data': data,
'result': self.result,
'statusCode': 200,
}
def result_error(self, error):
self.result = {
'jobRunID': self.id,
'status': 'errored',
'error': f'There was an error: {error}',
'statusCode': 500,
}
class Adapter:
base_url = FRAXSES_API_GATEWAY
def __init__(self, input):
self.id = input.get('id', '1')
self.request_data = input.get('data')
if self.validate_request_data():
self.bridge = Bridge()
self.set_params()
self.create_request()
else:
self.result_error('No data provided')
def validate_request_data(self):
if self.request_data is None:
return False
if self.request_data == {}:
return False
if self.request_data.get('action') is None:
return False
return True
def set_params(self):
self.param = {}
self.action = self.request_data.get('action')
self.params = {
k: v
for k, v in self.request_data.items() if k != 'action'
}
for key, value in self.params.items():
self.param[value] = self.request_data.get(key)
if self.param is None:
break
def create_request(self):
try:
token = usr_aut(gateway=FRAXSES_API_GATEWAY,
username=FRAXSES_USERNAME,
password=FRAXSES_PASSWORD)
logging.info('Token success, token is ' + str(token))
if token:
token = token['records'][0]['tok']
params = {
"token": token,
"action": self.action,
"parameters": self.params
}
response = self.bridge.request(self.base_url, params)
logging.info(params)
data = response.json()
logging.info(data)
self.result = data['result'][0]['serviceresult']['id']
self.result_success(
data=data['result'][0]['serviceresult']['response'],
job_run_id=data['result'][0]['serviceresult']['id'])
else:
self.result_error(
'Fraxses gateway failed to authenticate, token is ' +
str(token))
except Exception as e:
self.result_error(e)
finally:
self.bridge.close()
def result_success(self, data, job_run_id):
self.result = {
'jobRunID': self.id,
'data': data,
'result': self.result,
'statusCode': 200,
}
def result_error(self, error):
self.result = {
'jobRunID': 1,
'status': 'errored',
'error': f'There was an error: {error}',
'statusCode': 500,
}
class Adapter:
base_url = 'https://api.twitter.com/1.1/search/tweets.json'
def __init__(self, input):
self.id = input.get('id', '1')
self.request_data = input.get('data')
if self.validate_request_data():
self.bridge = Bridge()
self.hashtag = self.request_data.get('hashtag', '')
self.username = self.request_data.get('username', '')
self.create_request()
else:
self.result_error('No data provided')
def validate_request_data(self):
if self.request_data is None:
return False
if self.request_data == {}:
return False
return True
def create_request(self):
try:
if not self.hashtag:
raise Exception('No hashtag provided')
params = {
'q': '#' + self.hashtag,
}
headers = {
"Authorization": "Bearer " + os.environ.get('BEARER_TOKEN')
}
response = self.bridge.request(self.base_url,
params,
headers=headers)
data = response.json()
self.result = ''
if self.username:
for status in data['statuses']:
if status['user']['screen_name'] == self.username:
self.result = self.username
break
elif data['statuses']:
self.result = data['statuses'][0]['user']['screen_name']
data['result'] = self.result
self.result_success(data)
except Exception as e:
self.result_error(e)
finally:
self.bridge.close()
def result_success(self, data):
self.result = {
'jobRunID': self.id,
'data': data,
'result': self.result,
'statusCode': 200,
}
def result_error(self, error):
self.result = {
'jobRunID': self.id,
'status': 'errored',
'error': f'There was an error: {error}',
'statusCode': 500,
}
