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