def delete_items(title, id):
list = db_session.query(List).filter(List.title == title,
List.id == id).first()
if request.method == "POST":
item = request.form['item']
delete_item = db_session.query(List_Item).filter(
List_Item.content == item, List_Item.list_id == list.id).first()
if delete_item:
db_session.delete(delete_item)
try:
db_session.commit()
except Exception as e:
db_session.rollback()
db_session.flush()
print("error")
flash("an error ocured delting this item")
return redirect(
url_for('routes.delete_items',
title=list.title,
id=list.id))
else:
flash("this is not an item on this list")
return redirect(
url_for('routes.delete_items', title=list.title, id=list.id))
return redirect(url_for('routes.list', title=list.title, id=list.id))
if session.get('logged_in') == False:
return redirect(url_for('routes.login'))
if not list:
return redirect(url_for('routes.list_of_lists'))
items = db_session.query(List_Item).filter(List_Item.list_id == id).all()
list = db_session.query(List).filter(List.id == id).first()
return render_template('editlist.html', items=items, list=list)
def get(self, node_address):
"""
Method for GET request
:param node_address:
"""
# Validate User Input
try:
request = {"node_address": node_address}
validations_result = validate_node_input(node_address)
response = {}
if validations_result is not None and len(validations_result) > 0:
response = {
"ResponseCode":
ResponseCodes.InvalidRequestParameter.value,
"ResponseDesc": ResponseCodes.InvalidRequestParameter.name,
"ValidationErrors": validations_result
}
else: # all valid
# perform the query
transaction_data = db_session.query(Transaction).filter(
or_(Transaction.from_node == node_address,
Transaction.to_node == node_address)).order_by(
Transaction.from_node.asc())
if transaction_data is not None and len(
list(transaction_data)) != 0:
transaction_list = []
for transaction in transaction_data:
token_data = db_session.query(EthereumToken).filter(
EthereumToken.token_id ==
transaction.token_id).first()
transaction_list.append(
serialize_transaction_with_token_data(
transaction, token_data))
response = {
"ResponseCode": ResponseCodes.Success.value,
"ResponseDesc": ResponseCodes.Success.name,
"NumberOfTransactions": len(transaction_list),
"Transactions": transaction_list
}
else:
response = {
"ResponseCode": ResponseCodes.NoDataFound.value,
"ResponseDesc": ResponseCodes.NoDataFound.name,
"ErrorMessage": ResponseDescriptions.NoDataFound.value
}
except Exception as ex:
response = {
"ResponseCode": ResponseCodes.InternalError.value,
"ResponseDesc": ResponseCodes.InternalError.name,
"ErrorMessage": str(ex)
}
finally:
return response
def list_of_lists():
searched = False
search = None
if request.method == "POST":
search = request.form['search']
all_lists = db_session.query(List).filter(List.title == search).all()
print(all_lists)
return render_template('list_of_lists.html', all_lists=all_lists)
all_lists = db_session.query(List).all()
return render_template('list_of_lists.html', all_lists=all_lists)
def get(self):
"""
Method for GET request
"""
# Validate User Input
try:
# perform the query
ponzi_anomaly_data = db_session.query(PonziAnomaly).order_by(PonziAnomaly.id.asc()).all()
if ponzi_anomaly_data is not None and len(list(ponzi_anomaly_data)) != 0:
ponzi_Anomaly_list = []
for ponzi_Anomaly in ponzi_anomaly_data:
ponzi_Anomaly_list.append(serialize_ponzi_data(ponzi_Anomaly))
response = {
"ResponseCode": ResponseCodes.Success.value,
"ResponseDesc": ResponseCodes.Success.name,
"NumberOfRecords": len(ponzi_Anomaly_list),
"Data": ponzi_Anomaly_list}
else:
response = {"ResponseCode": ResponseCodes.NoDataFound.value,
"ResponseDesc": ResponseCodes.NoDataFound.name,
"ErrorMessage": ResponseDescriptions.NoDataFound.value}
except Exception as ex:
response = {"ResponseCode": ResponseCodes.InternalError.value,
"ResponseDesc": ResponseCodes.InternalError.name,
"ErrorMessage": str(ex)}
finally:
return response
def sign_up():
if request.method == "POST":
username = request.form["username"]
password = request.form["password"]
existing_user = db_session.query(User).filter(
User.username == username).first()
if existing_user:
flash("someone has alreay used that username try again")
return redirect(url_for('routes.sign_up'))
else:
new_user = User(username, password)
db_session.add(new_user)
try:
db_session.commit()
session['logged_in'] = True
except Exception as e:
db_session.rollback()
db_session.flush()
print("error")
return redirect(url_for('routes.home'))
msg = Message("Hello Email World",
sender="*****@*****.**",
recipients=["*****@*****.**"])
mail.send(msg)
return render_template('signup.html')
def get(self, block_ids):
try:
# Validate User Input
request = {"block_ids": block_ids}
response = {}
validations_result = ValidateBlockIds(self, block_ids)
if validations_result is not None and len(validations_result) > 0:
response = {
"ResponseCode":
ResponseCodes.InvalidRequestParameter.value,
"ResponseDesc": ResponseCodes.InvalidRequestParameter.name,
"ValidationErrors": validations_result
}
else:
block_transactions_dict = {}
num_of_empty_blocks = 0
for blk_id in sorted(block_ids):
transactions = db_session.query(Transaction).filter(
Transaction.block_id == blk_id).order_by(
Transaction.id.asc())
trans_list = []
for transaction in transactions:
trans_list.append(serialize_transaction(transaction))
if len(trans_list) == 0:
num_of_empty_blocks = num_of_empty_blocks + 1
block_transactions_dict[blk_id] = {
"NumberOfTransactions": len(trans_list),
"Transactions": trans_list
}
if block_transactions_dict is not None and num_of_empty_blocks != len(
block_ids):
response = {
"ResponseCode": ResponseCodes.Success.value,
"ResponseDesc": ResponseCodes.Success.name,
"BlockTransactionData": block_transactions_dict
}
else:
response = {
"ResponseCode": ResponseCodes.NoDataFound.value,
"ResponseDesc": ResponseCodes.NoDataFound.name,
"ErrorMessage": ResponseDescriptions.NoDataFound.value
}
except Exception as ex:
response = {
"ResponseCode": ResponseCodes.InternalError.value,
"ResponseDesc": ResponseCodes.InternalError.name,
"ErrorMessage": str(ex)
}
finally:
# file = open('/Logs/GetTransactionDataByBlockIDLog.txt', 'w')
# file.write("Time:" + str(datetime.now()) + "\r\n")
# file.write("Request : " + request + "\r\n")
# file.write("Response : " + response + "\r\n")
# file.write("\r\n")
# file.write("\r\n")
# file.write("\r\n")
# file.close()
return response
def get(self, Date=None):
"""
Method for GET request
:param Date:
"""
error = self.validateMostActiveEntityInput(Date)
if error is not None:
return {
"ResponseCode": ResponseCodes.InvalidRequestParameter.value,
"ResponseDesc": ResponseCodes.InvalidRequestParameter.name,
"ErrorMessage": error.value
}
most_active_entity = db_session.query(MostActiveEntity).filter(
and_(MostActiveEntity.date == Date)).one_or_none()
if most_active_entity is None:
response = {
"ResponseCode": ResponseCodes.NoDataFound.value,
"ResponseDesc": ResponseCodes.NoDataFound.name,
"ErrorMessage": ResponseDescriptions.NoDataFound.value
}
else:
response = {
"ResponseCode":
ResponseCodes.Success.value,
"ResponseDesc":
ResponseCodes.Success.name,
"MostActiveEntity":
serialize_most_active_entity(most_active_entity)
}
return response
def get(self, Date=None):
"""
Method for GET request
:param Date:
"""
error = self.validateBitcoinCirculationInput(Date)
if error is not None:
return {
"ResponseCode": ResponseCodes.InvalidRequestParameter.value,
"ResponseDesc": ResponseCodes.InvalidRequestParameter.name,
"ErrorMessage": error.value
}
bitcoin_circulation = db_session.query(BitcoinCirculation).filter(
and_(BitcoinCirculation.date == Date)).one_or_none()
if bitcoin_circulation is None:
response = {
"ResponseCode": ResponseCodes.NoDataFound.value,
"ResponseDesc": ResponseCodes.NoDataFound.name,
"ErrorMessage": ResponseDescriptions.NoDataFound.value
}
else:
response = {
"ResponseCode":
ResponseCodes.Success.value,
"ResponseDesc":
ResponseCodes.Success.name,
"BitcoinCirculation":
serialize_bitcoin_circulation(bitcoin_circulation)
}
return response
def get(self, date=None, address=None):
"""
Method for GET request
:param date:
:param address:
"""
error = self.validateAddressFeatureInput(address, date)
if error is not None:
return {
"ResponseCode": ResponseCodes.InvalidRequestParameter.value,
"ResponseDesc": ResponseCodes.InvalidRequestParameter.name,
"ErrorMessage": error.value
}
address_feature = db_session.query(AddressFeature).filter(
and_(AddressFeature.address == address,
AddressFeature.date == date)).one_or_none()
if address_feature is None:
response = {
"ResponseCode": ResponseCodes.NoDataFound.value,
"ResponseDesc": ResponseCodes.NoDataFound.name,
"ErrorMessage": ResponseDescriptions.NoDataFound.value
}
else:
response = {
"ResponseCode": ResponseCodes.Success.value,
"ResponseDesc": ResponseCodes.Success.name,
"AddressFeature": serialize_feature_address(address_feature)
}
return response
def get(self, Date=None):
"""
Method for GET request
:param Date:
"""
error = self.validateCurrentBalanceInput(Date)
if error is not None:
return {
"ResponseCode": ResponseCodes.InvalidRequestParameter.value,
"ResponseDesc": ResponseCodes.InvalidRequestParameter.name,
"ErrorMessage": error.value
}
current_balance = db_session.query(CurrentBalance).filter(
and_(CurrentBalance.date == Date)).one_or_none()
if current_balance is None:
response = {
"ResponseCode": ResponseCodes.NoDataFound.value,
"ResponseDesc": ResponseCodes.NoDataFound.name,
"ErrorMessage": ResponseDescriptions.NoDataFound.value
}
else:
response = {
"ResponseCode": ResponseCodes.Success.value,
"ResponseDesc": ResponseCodes.Success.name,
"CurrentBalance": serialize_current_balance(current_balance)
}
return response
def get(self, Date=None):
"""
Method for GET request
:param Date:
"""
error = self.validateActivityLevelInput(Date)
if error is not None:
return {
"ResponseCode": ResponseCodes.InvalidRequestParameter.value,
"ResponseDesc": ResponseCodes.InvalidRequestParameter.name,
"ErrorMessage": error.value
}
activity_level = db_session.query(ActivityLevel).filter(
and_(ActivityLevel.date == Date)).one_or_none()
if activity_level is None:
response = {
"ResponseCode": ResponseCodes.NoDataFound.value,
"ResponseDesc": ResponseCodes.NoDataFound.name,
"ErrorMessage": ResponseDescriptions.NoDataFound.value
}
else:
response = {
"ResponseCode": ResponseCodes.Success.value,
"ResponseDesc": ResponseCodes.Success.name,
"ActivityLevel": serialize_activity_level(activity_level)
}
return response
def get(self, Date=None):
"""
Method for GET request
:param Date:
"""
error = self.validateTransactionSizeInput(Date)
if error is not None:
return {
"ResponseCode": ResponseCodes.InvalidRequestParameter.value,
"ResponseDesc": ResponseCodes.InvalidRequestParameter.name,
"ErrorMessage": error.value
}
transaction_size = db_session.query(TransactionSize).filter(
and_(TransactionSize.date == Date)).one_or_none()
if transaction_size is None:
response = {
"ResponseCode": ResponseCodes.NoDataFound.value,
"ResponseDesc": ResponseCodes.NoDataFound.name,
"ErrorMessage": ResponseDescriptions.NoDataFound.value
}
else:
response = {
"ResponseCode": ResponseCodes.Success.value,
"ResponseDesc": ResponseCodes.Success.name,
"TransactionSize": serialize_transaction_size(transaction_size)
}
return response
def get(self, Date=None):
"""
Method for GET request
:param Date:
"""
error = self.validateTotalBtcReceivedInput(Date)
if error is not None:
return {
"ResponseCode": ResponseCodes.InvalidRequestParameter.value,
"ResponseDesc": ResponseCodes.InvalidRequestParameter.name,
"ErrorMessage": error.value
}
total_btc_received = db_session.query(TotalBtcReceived).filter(
and_(TotalBtcReceived.date == Date)).one_or_none()
if total_btc_received is None:
response = {
"ResponseCode": ResponseCodes.NoDataFound.value,
"ResponseDesc": ResponseCodes.NoDataFound.name,
"ErrorMessage": ResponseDescriptions.NoDataFound.value
}
else:
response = {
"ResponseCode":
ResponseCodes.Success.value,
"ResponseDesc":
ResponseCodes.Success.name,
"TotalBtcReceived":
serialize_total_btc_received(total_btc_received)
}
return response
def get(self, Date=None):
"""
Method for GET request
:param Date:
"""
error = self.validateClusteringCoefficientInput(Date)
if error is not None:
return {
"ResponseCode": ResponseCodes.InvalidRequestParameter.value,
"ResponseDesc": ResponseCodes.InvalidRequestParameter.name,
"ErrorMessage": error.value
}
clustering_coefficient = db_session.query(
ClusteringCoefficient).filter(
and_(ClusteringCoefficient.date == Date)).one_or_none()
if clustering_coefficient is None:
response = {
"ResponseCode": ResponseCodes.NoDataFound.value,
"ResponseDesc": ResponseCodes.NoDataFound.name,
"ErrorMessage": ResponseDescriptions.NoDataFound.value
}
else:
response = {
"ResponseCode":
ResponseCodes.Success.value,
"ResponseDesc":
ResponseCodes.Success.name,
"ClusteringCoefficient":
serialize_clustering_coefficient(clustering_coefficient)
}
return response
def serialize_transaction_output_address(address_id):
"""
Method to serialize transaction output address data
API: Bitcoin transaction output address API
:param address_id:
"""
address_list = db_session.query(Address).filter(
Address.id == address_id).order_by(Address.id.asc())
for address in address_list:
address_as_dict = serialize_address(address)
return address_as_dict
def login():
if request.method == "POST":
username = request.form["username"]
password = request.form["password"]
user = db_session.query(User).filter(
User.username == username, User.password == password).first()
if user:
session['logged_in'] = True
return redirect(url_for('routes.home'))
else:
return redirect(url_for('routes.login'))
flash("your username or password wash entered incorectly")
return render_template('login.html')
def get(self, year, month, day, date_offset):
"""
Method for GET request
:param year:
:param month:
:param day:
:param date_offset:
"""
# Validate User Input
try:
request = {"day": day, "month": month, "year": year, "date_offset": date_offset}
validations_result = validate_block_input(year, month, day, date_offset)
response = {}
if validations_result is not None and len(validations_result) > 0:
response = {"ResponseCode": ResponseCodes.InvalidRequestParameter.value,
"ResponseDesc": ResponseCodes.InvalidRequestParameter.name,
"ValidationErrors": validations_result}
else: # all valid
from_time = datetime(int(year), int(month), int(day))
to_time = from_time + timedelta(days=int(date_offset))
from_unixtime = time.mktime(from_time.timetuple()) # get the unix time to form the query
to_unixtime = time.mktime(to_time.timetuple())
# perform the query
block_data = db_session.query(Block).filter(
and_(Block.ntime >= from_unixtime, Block.ntime <= to_unixtime)).order_by(Block.ntime.asc())
if block_data is not None and len(list(block_data)) != 0:
block_list = []
for block in block_data:
block_list.append(serialize_block(block))
response = {
"ResponseCode": ResponseCodes.Success.value,
"ResponseDesc": ResponseCodes.Success.name,
"FromDate": from_time.strftime('%Y-%m-%d %H:%M:%S'),
"ToDate": to_time.strftime('%Y-%m-%d %H:%M:%S'),
"NumberOfBlocks": len(block_list),
"Blocks": block_list}
else:
response = {"ResponseCode": ResponseCodes.NoDataFound.value,
"ResponseDesc": ResponseCodes.NoDataFound.name,
"ErrorMessage": ResponseDescriptions.NoDataFound.value}
except Exception as ex:
response = {"ResponseCode": ResponseCodes.InternalError.value,
"ResponseDesc": ResponseCodes.InternalError.name,
"ErrorMessage": str(ex)}
finally:
return response
def add_list():
if request.method == "POST":
title = request.form["title"]
description = request.form["about"]
new_list = List(title, description)
list_items = request.form.getlist('items')
for item in list_items:
print(item)
new_items = List_Item(item)
db_session.add(new_items)
new_list.items.append(new_items)
print("panda")
db_session.add(new_list)
items_created = False
list_created = False
if new_list.title and new_list.description:
list_created = True
else:
flash("your list must have a title and a desciption")
if new_items.content:
list_items = True
else:
flash("your list must have some items")
if list_created and items_created:
try:
db_session.commit()
print("pandas are awsome")
except Exception as e:
print(e)
db_session.rollback()
db_session.flush()
created_list = db_session.query(List).filter(
List.title == title).first()
redirect_id = created_list.id
redirect_title = created_list.title
return redirect(
url_for('routes.list', title=redirect_title, id=redirect_id))
return render_template('add_list.html')
def get(self, block_ids):
"""
Method for GET request
:param block_ids:
"""
try:
# Validate User Input
request = {"block_ids": block_ids}
response = {}
validations_result = validate_block_ids(block_ids)
if validations_result is not None and len(validations_result) > 0:
response = {"ResponseCode": ResponseCodes.InvalidRequestParameter.value,
"ResponseDesc": ResponseCodes.InvalidRequestParameter.name,
"ValidationErrors": validations_result}
else:
block_transactions_dict = {}
num_of_empty_blocks = 0
for blk_id in sorted(block_ids):
transactions = db_session.query(Transaction).filter(Transaction.block_id == blk_id).order_by(
Transaction.id.asc())
trans_list = []
for transaction in transactions:
trans_list.append(serialize_transaction(transaction))
if len(trans_list) == 0:
num_of_empty_blocks = num_of_empty_blocks + 1
block_transactions_dict[blk_id] = {"NumberOfTransactions": len(trans_list),
"Transactions": trans_list}
if block_transactions_dict is not None and num_of_empty_blocks != len(block_ids):
response = {"ResponseCode": ResponseCodes.Success.value,
"ResponseDesc": ResponseCodes.Success.name,
"BlockTransactionData": block_transactions_dict}
else:
response = {"ResponseCode": ResponseCodes.NoDataFound.value,
"ResponseDesc": ResponseCodes.NoDataFound.name,
"ErrorMessage": ResponseDescriptions.NoDataFound.value}
except Exception as ex:
response = {"ResponseCode": ResponseCodes.InternalError.value,
"ResponseDesc": ResponseCodes.InternalError.name,
"ErrorMessage": str(ex)}
finally:
return response
def get(self, Date=None):
"""
Method for GET request
:param Date:
"""
error = self.validateStronglyConnectedComponentInput(Date)
if error is not None:
return {
"ResponseCode": ResponseCodes.InvalidRequestParameter.value,
"ResponseDesc": ResponseCodes.InvalidRequestParameter.name,
"ErrorMessage": error.value
}
strongly_connected_component = db_session.query(
StronglyConnectedComponent).filter(
and_(StronglyConnectedComponent.date == Date)).one_or_none()
if strongly_connected_component is None:
response = {
"ResponseCode": ResponseCodes.NoDataFound.value,
"ResponseDesc": ResponseCodes.NoDataFound.name,
"ErrorMessage": ResponseDescriptions.NoDataFound.value
}
else:
response = {
"ResponseCode":
ResponseCodes.Success.value,
"ResponseDesc":
ResponseCodes.Success.name,
"StronglyConnectedComponent":
serialize_strongly_connected_component(
strongly_connected_component)
}
return response
def get(self, transaction_ids):
try:
transaction_ids = list(set(list(transaction_ids)))
request = {"transaction_ids": transaction_ids}
response = {}
# Validate User Input
validations_result = ValidateTransactionIds(self, transaction_ids)
if validations_result is not None and len(validations_result) > 0:
response = {
"ResponseCode":
ResponseCodes.InvalidRequestParameter.value,
"ResponseDesc": ResponseCodes.InvalidRequestParameter.name,
"ValidationErrors": validations_result
}
else:
transaction_outputs_dict = {}
for transaction_id in sorted(transaction_ids):
transaction_outputs = db_session.query(
TransactionOutput).filter(
TransactionOutput.transaction_id ==
transaction_id).order_by(
TransactionOutput.id.asc()).all()
trans_output_as_list = []
total_num_of_transaction_outputs = 0
for transaction_output in transaction_outputs:
output_address_response = json.loads(
requests.get(
'http://localhost:5000/bitcoin/transactions/outputs/addresses',
{
'transaction_id': transaction_id,
'transaction_output_id':
transaction_output.id
}).text)
if output_address_response[
"ResponseCode"] == ResponseCodes.Success.value:
trans_output_as_list.append(
serialize_transaction_output(
transaction_output,
output_address_response[
"NumberOfOutputAddresses"],
output_address_response["OutputAddresses"])
)
total_num_of_transaction_outputs = total_num_of_transaction_outputs + 1
else:
response = {
"ResponseCode":
output_address_response["ResponseCode"],
"ResponseDesc":
output_address_response["ResponseDesc"],
"ErrorMessage":
"Internal Error in Transaction Output Address Service : "
+ output_address_response["ErrorMessage"]
}
break
transaction_outputs_dict[transaction_id] = {
"NumberOfOutputs": total_num_of_transaction_outputs,
"TransactionOutputs": trans_output_as_list
}
if total_num_of_transaction_outputs > 0:
response = {
"ResponseCode": ResponseCodes.Success.value,
"ResponseDesc": ResponseCodes.Success.name,
"TransactionOutputData": transaction_outputs_dict
}
else:
response = {
"ResponseCode": ResponseCodes.NoDataFound.value,
"ResponseDesc": ResponseCodes.NoDataFound.name,
"ErrorMessage": ResponseDescriptions.NoDataFound.value
}
except Exception as ex:
response = {
"ResponseCode": ResponseCodes.InternalError.value,
"ResponseDesc": ResponseCodes.InternalError.name,
"ErrorMessage": str(ex)
}
finally:
# file = open('/Logs/TransactionOutputLog.txt', 'w')
# file.write("Time:" + str(datetime.now()) + "\r\n")
# file.write("Request : " + request + "\r\n")
# file.write("Response : " + response + "\r\n")
# file.write("\r\n")
# file.write("\r\n")
# file.write("\r\n")
# file.close()
return response
def get(self):
print(db_session.query(Address).first())
return {'hello': 'world'}
def get(self):
"""
Method for GET request
"""
print(db_session.query(Address).first())
return {'hello': 'world'}
def get(self, transaction_ids):
"""
Method for GET request
:param transaction_ids:
"""
try:
transaction_ids = list(set(list(transaction_ids)))
request = {"transaction_ids": transaction_ids}
response = {}
# Validate User Input
validations_result = validate_transaction_ids(transaction_ids)
if validations_result is not None and len(validations_result) > 0:
response = {
"ResponseCode":
ResponseCodes.InvalidRequestParameter.value,
"ResponseDesc": ResponseCodes.InvalidRequestParameter.name,
"ValidationErrors": validations_result
}
else:
transaction_inputs_dict = {}
for transaction_id in sorted(transaction_ids):
transaction_inputs = db_session.query(
TransactionInput).filter(
TransactionInput.transaction_id ==
transaction_id).all()
previous_output_ids = []
trans_input_list = []
total_num_of_inputs = 0
for transaction_input in transaction_inputs:
trans_input_as_dict = serialize_transaction_input(
transaction_input)
prev_output_id = trans_input_as_dict[
"PreviousTransactionOutputId"]
if prev_output_id is not None:
prev_out = db_session.query(Output).filter(
Output.id == prev_output_id).one()
trans_input_as_dict["Value"] = prev_out.value
previous_output_ids.append(prev_output_id)
prev_addresses = []
prev_address = db_session.query(
OutputAddress, Address).filter(
OutputAddress.output_id == prev_output_id
).filter(Address.id ==
OutputAddress.address_id).all()
for address in prev_address:
address_as_dict = serialize_address(
address.Address)
prev_addresses.append(address_as_dict)
trans_input_as_dict[
"InputAddresses"] = prev_addresses
trans_input_list.append(trans_input_as_dict)
total_num_of_inputs = total_num_of_inputs + 1
transaction_inputs_dict[transaction_id] = {
"NumberOfInputs": total_num_of_inputs,
"TransactionInputs": trans_input_list
}
if total_num_of_inputs > 0:
response = {
'ResponseCode': ResponseCodes.Success.value,
'ResponseDesc': ResponseCodes.Success.name,
'TransactionInputData': transaction_inputs_dict
}
else:
response = {
"ResponseCode": ResponseCodes.NoDataFound.value,
"ResponseDesc": ResponseCodes.NoDataFound.name,
"ErrorMessage": ResponseDescriptions.NoDataFound.value
}
except Exception as ex:
response = {
"ResponseCode": ResponseCodes.InternalError.value,
"ResponseDesc": ResponseCodes.InternalError.name,
"ErrorMessage": str(ex)
}
finally:
return response
def home():
lists = db_session.query(List).limit(10).all()
return render_template('home.html', lists=lists)
def list(title, id):
list = db_session.query(List).filter(List.title == title,
List.id == id).first()
list_items = db_session.query(List_Item).filter(
List_Item.list_id == list.id).all()
return render_template('list.html', list=list, items=list_items)
def get(self, transaction_hash):
try:
transaction_hash = transaction_hash.strip()
request = {"transaction_hash": transaction_hash}
response = {}
# Validate User Input
validations_result = ValidateTransactionHash(self, transaction_hash)
if validations_result is not None and len(validations_result) > 0:
response = {"ResponseCode": ResponseCodes.InvalidRequestParameter.value,
"ResponseDesc": ResponseCodes.InvalidRequestParameter.name,
"ValidationErrors": validations_result}
else:
transaction = db_session.query(Transaction).filter(Transaction.hash == transaction_hash).one_or_none()
if transaction is None:
response = {"ResponseCode": ResponseCodes.NoDataFound.value,
"ResponseDesc": ResponseCodes.NoDataFound.name,
"ErrorMessage": ResponseDescriptions.NoDataFound.value}
else:
input_response = json.loads(requests.get('http://localhost:5000/bitcoin/transactions/inputs',
json={'transaction_ids': [transaction.id]}).text)
output_response = json.loads(requests.get('http://localhost:5000/bitcoin/transactions/outputs',
json={'transaction_ids': [transaction.id]}).text)
if input_response["ResponseCode"] == ResponseCodes.Success.value and \
output_response["ResponseCode"] == ResponseCodes.Success.value:
transaction_json = serialize_transaction(transaction, input_response, output_response,
transaction.id)
response = {
"ResponseCode": ResponseCodes.Success.value,
"ResponseDesc": ResponseCodes.Success.name,
"TransactionData": transaction_json
}
if transaction_json is None or (
transaction_json is not None and
(input_response["TransactionInputData"][str(transaction.id)])["NumberOfInputs"] == 0 and
(output_response["TransactionOutputData"][str(transaction.id)])[
"NumberOfOutputs"] == 0):
response = {
"ResponseCode": ResponseCodes.NoDataFound.value,
"ResponseDesc": ResponseCodes.NoDataFound.name,
"ErrorMessage": ResponseDescriptions.NoDataFound.value
}
elif input_response["ResponseCode"] != ResponseCodes.Success.value:
response = {"ResponseCode": input_response["ResponseCode"],
"ResponseDesc": input_response["ResponseDesc"],
"ErrorMessage": "Internal Error in Transaction Input Service : "
+ input_response["ErrorMessage"]
}
elif output_response["ResponseCode"] != ResponseCodes.Success.value:
response = {"ResponseCode": output_response["ResponseCode"],
"ResponseDesc": output_response["ResponseDesc"],
"ErrorMessage": "Internal Error in Transaction Output Service : "
+ output_response["ErrorMessage"]
}
except Exception as ex:
response = {"ResponseCode": ResponseCodes.InternalError.value,
"ResponseDesc": ResponseCodes.InternalError.name,
"ErrorMessage": str(ex)}
finally:
# file = open('/Logs/TransactionByHashLog.txt', 'w')
# file.write("Time:" + str(datetime.now()) + "\r\n")
# file.write("Request : " + request + "\r\n")
# file.write("Response : " + response + "\r\n")
# file.write("\r\n")
# file.write("\r\n")
# file.write("\r\n")
# file.close()
return response
def get(self, transaction_ids):
try:
transaction_ids = list(set(list(transaction_ids)))
request = {"transaction_ids": transaction_ids}
response = {}
# Validate User Input
validations_result = ValidateTransactionIds(self, transaction_ids)
if validations_result is not None and len(validations_result) > 0:
response = {"ResponseCode": ResponseCodes.InvalidRequestParameter.value,
"ResponseDesc": ResponseCodes.InvalidRequestParameter.name,
"ValidationErrors": validations_result}
else:
block_transactions_dict = {}
num_of_empty_transactions = 0
for transaction_id in sorted(transaction_ids):
trans_as_dict = {}
transaction_data = db_session.query(Transaction).filter(Transaction.id == transaction_id).order_by(
Transaction.id.asc())
input_response = json.loads(requests.get('http://localhost:5000/bitcoin/transactions/inputs',
json={'transaction_ids': [transaction_id]}).text)
output_response = json.loads(requests.get('http://localhost:5000/bitcoin/transactions/outputs',
json={'transaction_ids': [transaction_id]}).text)
if input_response["ResponseCode"] == ResponseCodes.Success.value and \
output_response["ResponseCode"] == ResponseCodes.Success.value:
block_transactions_dict[transaction_id] = serialize_transaction(transaction_data[0],
input_response,
output_response, transaction_id)
if trans_as_dict is None or (
trans_as_dict is not None and
(input_response["TransactionInputData"][str(transaction_id)])["NumberOfInputs"] == 0 and
(output_response["TransactionOutputData"][str(transaction_id)])[
"NumberOfOutputs"] == 0):
num_of_empty_transactions = num_of_empty_transactions + 1
elif input_response["ResponseCode"] != ResponseCodes.Success.value:
response = {"ResponseCode": input_response["ResponseCode"],
"ResponseDesc": input_response["ResponseDesc"],
"ErrorMessage": "Internal Error in Transaction Input Service : "
+ input_response["ErrorMessage"]
}
break
elif output_response["ResponseCode"] != ResponseCodes.Success.value:
response = {"ResponseCode": output_response["ResponseCode"],
"ResponseDesc": output_response["ResponseDesc"],
"ErrorMessage": "Internal Error in Transaction Output Service : "
+ output_response["ErrorMessage"]
}
break
if num_of_empty_transactions != len(transaction_ids):
response = {
"ResponseCode": ResponseCodes.Success.value,
"ResponseDesc": ResponseCodes.Success.name,
"TransactionData": block_transactions_dict
}
else:
response = {"ResponseCode": ResponseCodes.NoDataFound.value,
"ResponseDesc": ResponseCodes.NoDataFound.name,
"ErrorMessage": ResponseDescriptions.NoDataFound.value}
except Exception as ex:
response = {"ResponseCode": ResponseCodes.InternalError.value,
"ResponseDesc": ResponseCodes.InternalError.name,
"ErrorMessage": str(ex)}
finally:
# file = open('/Logs/TransactionLog.txt', 'w')
# file.write("Time:" + str(datetime.now()) + "\r\n")
# file.write("Request : " + request + "\r\n")
# file.write("Response : " + response + "\r\n")
# file.write("\r\n")
# file.write("\r\n")
# file.write("\r\n")
# file.close()
return response
def get(self, year, month, day, date_offset, token_name):
"""
Method for GET request
:param year:
:param month:
:param day:
:param date_offset:
:param token_name:
"""
# Validate User Input
try:
request = {
"day": day,
"month": month,
"year": year,
"date_offset": date_offset,
"token_name": token_name
}
validations_result = validate_input(year, month, day, date_offset)
response = {}
if validations_result is not None and len(validations_result) > 0:
response = {
"ResponseCode":
ResponseCodes.InvalidRequestParameter.value,
"ResponseDesc": ResponseCodes.InvalidRequestParameter.name,
"ValidationErrors": validations_result
}
else: # all valid
from_time = datetime(int(year), int(month), int(day))
to_time = from_time + timedelta(days=int(date_offset))
from_unixtime = time.mktime(from_time.timetuple(
)) # get the unix time to form the query
to_unixtime = time.mktime(to_time.timetuple())
token_data = db_session.query(EthereumToken).filter(
EthereumToken.token_name == token_name).first()
# perform the query
transaction_data = db_session.query(Transaction).filter(
and_(Transaction.ntime >= from_unixtime,
Transaction.ntime <= to_unixtime)).order_by(
Transaction.ntime.asc())
if transaction_data is not None and len(
list(transaction_data)) != 0:
transaction_list = []
for transaction in transaction_data:
transaction_list.append(
serialize_transaction(transaction))
response = {
"ResponseCode": ResponseCodes.Success.value,
"ResponseDesc": ResponseCodes.Success.name,
"FromDate":
from_time.strftime('%Y-%m-%d %H:%M:%S'),
"ToDate": to_time.strftime('%Y-%m-%d %H:%M:%S'),
"TokenId": token_data.token_id,
"TokenName": token_data.token_name,
"NumberOfTransactions": len(transaction_list),
"Transactions": transaction_list
}
else:
response = {
"ResponseCode": ResponseCodes.NoDataFound.value,
"ResponseDesc": ResponseCodes.NoDataFound.name,
"ErrorMessage": ResponseDescriptions.NoDataFound.value
}
except Exception as ex:
response = {
"ResponseCode": ResponseCodes.InternalError.value,
"ResponseDesc": ResponseCodes.InternalError.name,
"ErrorMessage": str(ex)
}
finally:
return response
def get(self, transaction_id, transaction_output_id):
"""
Method for GET request
:param transaction_id:
:param transaction_output_id:
"""
try:
request = {
"transaction_id": transaction_id,
"transaction_output_id": transaction_output_id
}
response = {}
# Validate User Input
validations_result = validate_transaction_id_and_transaction_output_id(
transaction_id, transaction_output_id)
if validations_result is not None and len(validations_result) > 0:
response = {
"ResponseCode":
ResponseCodes.InvalidRequestParameter.value,
"ResponseDesc": ResponseCodes.InvalidRequestParameter.name,
"ValidationErrors": validations_result
}
else:
transaction_output_id_list = db_session.query(
TransactionOutput).filter(
TransactionOutput.transaction_id ==
transaction_id).order_by(
TransactionOutput.id.asc()).with_entities(
TransactionOutput.id).all()
trans_output_ids = [
output.id for output in transaction_output_id_list
]
if transaction_output_id in trans_output_ids:
output_address_list = db_session.query(
TransactionOutputAddress).filter(
TransactionOutputAddress.output_id ==
transaction_output_id).order_by(
TransactionOutputAddress.id.asc()).all()
total_num_of_output_addresses = 0
output_addresses = []
for output_address in output_address_list:
output_addresses.append(
serialize_transaction_output_address(
output_address.address_id))
total_num_of_output_addresses = total_num_of_output_addresses + 1
if total_num_of_output_addresses > 0:
response = {
"ResponseCode": ResponseCodes.Success.value,
"ResponseDesc": ResponseCodes.Success.name,
"TransactionId": transaction_id,
"TransactionOutputId": transaction_output_id,
"NumberOfOutputAddresses": len(output_addresses),
"OutputAddresses": output_addresses
}
else:
response = {
"ResponseCode": ResponseCodes.NoDataFound.value,
"ResponseDesc": ResponseCodes.NoDataFound.name,
"ErrorMessage":
ResponseDescriptions.NoDataFound.value
}
else:
response = {
"ResponseCode":
ResponseCodes.InvalidRequestParameter.value,
"ResponseDesc":
ResponseCodes.InvalidRequestParameter.name,
"ErrorMessage":
ResponseDescriptions.OutputDoesNotBelongToTransaction.
value
}
except Exception as ex:
response = {
"ResponseCode": ResponseCodes.InternalError.value,
"ResponseDesc": ResponseCodes.InternalError.name,
"ErrorMessage": str(ex)
}
finally:
return response
