def post(self):
print("ApiGetTxByConHashId")
contract_hash_id = request.get_json()["contract_hash_id"]
if not check_request(request, "contract_hash_id"):
return make_response(constant.RESPONSE_STATUS_PARAM_ERROE,
constant.RESPONSE_CODE_PARAM_ERROE,
"param contract_hash_id not exist")
pool = current_app.config['bigchain_pool']
with pool() as bigchain:
try:
result = bigchain.get_tx_by_contract_hash_id(contract_hash_id)
# print(result)
except(Exception):
return make_response(constant.RESPONSE_STATUS_SERVER_ERROE,
constant.RESPONSE_CODE_SERVER_ERROR,
"get output failed.")
if not result:
result = {}
return make_response(constant.RESPONSE_STATUS_SUCCESS_NODATA,
constant.RESPONSE_CODE_SUCCESS_NODATA,
"no asset exist!",
result)
else:
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS,
"query success",
list(result))
def post(self):
print("txCreateAvgTime")
if not check_request(request, "beginTime"):
return make_response(constant.RESPONSE_STATUS_PARAM_ERROE,
constant.RESPONSE_CODE_PARAM_ERROE,
"param beginTime not exist")
if not check_request(request, "endTime"):
return make_response(constant.RESPONSE_STATUS_PARAM_ERROE,
constant.RESPONSE_CODE_PARAM_ERROE,
"param endTime not exist")
begintime = request.json.get("beginTime")
endtime = request.json.get("endTime")
pool = current_app.config['bigchain_pool']
with pool() as unichain:
avgtime, status = unichain.get_txCreateAvgTimeByRange(
begintime, endtime)
if not status:
return make_response(constant.RESPONSE_STATUS_SERVER_ERROR,
constant.RESPONSE_CODE_SERVER_ERROR,
"response is none")
avgtime_dict = {'avgTime': avgtime}
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS, "query success",
avgtime_dict)
def post(self):
# 获取指定时间区间内的无效区块集
if not check_request(request, "beginTime"):
return make_response(constant.RESPONSE_STATUS_PARAM_ERROE,
constant.RESPONSE_CODE_PARAM_ERROE,
"param beginTime not exist")
if not check_request(request, "endTime"):
return make_response(constant.RESPONSE_STATUS_PARAM_ERROE,
constant.RESPONSE_CODE_PARAM_ERROE,
"param endTime not exist")
startTime = request.json.get("beginTime")
endTime = request.json.get("endTime")
pool = current_app.config['bigchain_pool']
with pool() as b:
try:
invalidBlockIdList = b.get_invalidBlockIdList(
startTime=startTime, endTime=endTime)
except:
return make_response(constant.RESPONSE_STATUS_SERVER_ERROR,
constant.RESPONSE_CODE_SERVER_ERROR,
"None")
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS, "query success",
list(invalidBlockIdList))
def post(self):
pool = current_app.config['bigchain_pool']
with pool() as b:
try:
pubkeyList = b.get_allPublicKey()
except:
return make_response(constant.RESPONSE_STATUS_SERVER_ERROR,
constant.RESPONSE_CODE_SERVER_ERROR,
"None")
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS, "query success",
pubkeyList)
def post(self):
# 获取区块链中的总区块数
pool = current_app.config['bigchain_pool']
with pool() as b:
try:
number = b.get_BlockNumber()
except:
return make_response(constant.RESPONSE_STATUS_SERVER_ERROR,
constant.RESPONSE_CODE_SERVER_ERROR,
"None")
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS, "query success",
number)
def post(self):
# 获取所有无效区块集
pool = current_app.config['bigchain_pool']
with pool() as b:
try:
invalidBlockIdList = b.get_invalidBlockIdList()
except:
return make_response(constant.RESPONSE_STATUS_SERVER_ERROR,
constant.RESPONSE_CODE_SERVER_ERROR,
"None")
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS, "query success",
list(invalidBlockIdList))
def get(self):
print('ApiGetFreezeUnspentTx')
parser = reqparse.RequestParser()
parser.add_argument('public_key',
type=parameters.valid_ed25519,
required=True)
parser.add_argument('unspent', type=parameters.valid_bool)
parser.add_argument('contract_id')
parser.add_argument('task_id')
parser.add_argument('task_num')
args = parser.parse_args()
include_spent = not args['unspent']
contract_id = args['contract_id']
task_id = args['task_id']
pub_key = args['public_key']
task_num = args['task_num']
pool = current_app.config['bigchain_pool']
with pool() as bigchain:
outputs = bigchain.get_freeze_output(pub_key, contract_id, task_id,
task_num, include_spent)
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS, "sucess",
outputs)
def post(self):
# print("ApiOnlySaveData:--",request.get_json())
pool = current_app.config['bigchain_pool']
monitor = current_app.config['monitor']
fromuser = request.get_json()['fromUser']
touser = request.get_json()['toUser']
amount = int(request.get_json()['amount'])
metadata = request.get_json(force=True)['dataStr']
with pool() as b:
tx = Transaction.savedata([fromuser], [([touser], amount)],
metadata)
rate = bigchaindb.config['statsd']['rate']
with monitor.timer('write_transaction', rate=rate):
b.write_transaction(tx)
# tx = tx.to_dict()
# return rapidjson.dumps(tx)
if not tx:
tx_result = {}
result_messages = "tx not exist!"
else:
tx_result = tx.to_dict()
result_messages = "create transaction success"
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS, result_messages,
tx_result)
def post(self):
# 单条payload创建交易
# @common_api.route('/createTxByPayload/', methods=['POST'])
# def createTxByPayload():
pool = current_app.config['bigchain_pool']
monitor = current_app.config['monitor']
payload_dict = request.get_json(force=True)
with pool() as b:
tx = Transaction.create([b.me], [([b.me], 1)],
metadata=payload_dict)
tx = tx.sign([b.me_private])
rate = bigchaindb.config['statsd']['rate']
with monitor.timer('write_transaction', rate=rate):
b.write_transaction(tx)
# tx = tx.to_dict()
# return rapidjson.dumps(tx)
if not tx:
tx_result = {}
result_messages = "tx not exist!"
else:
tx_result = tx.to_dict()
result_messages = "create transaction success"
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS, result_messages,
tx_result)
def post(self):
# 根据区块ID获取区块中的交易条数
if not check_request(request, "block_id"):
return make_response(constant.RESPONSE_STATUS_PARAM_ERROE,
constant.RESPONSE_CODE_PARAM_ERROE,
"param block id not exist")
block_id = request.get_json()["block_id"]
pool = current_app.config['bigchain_pool']
with pool() as b:
try:
number = b.get_txNumber(block_id)
except:
return make_response(constant.RESPONSE_STATUS_SERVER_ERROR,
constant.RESPONSE_CODE_SERVER_ERROR,
"None")
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS, "query success",
number)
def post(self):
if not check_request(request, "block_id"):
return make_response(constant.RESPONSE_STATUS_PARAM_ERROE,
constant.RESPONSE_CODE_PARAM_ERROE,
"param block id not exist")
block_id = request.json.get("block_id")
pool = current_app.config['bigchain_pool']
with pool() as unichain:
avgtime, status = unichain.get_voteTimeByBlockID(block_id)
if not status:
return make_response(constant.RESPONSE_STATUS_SUCCESS_NODATA,
constant.RESPONSE_CODE_SUCCESS_NODATA,
"response is none")
avgtime_dict = {'avgTime': avgtime}
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS, "query success",
avgtime_dict)
def post(self):
# 获取区块链中的总交易条数
# @common_api.route('/getTxNumberInUnichain/', methods=['POST'])
# def getTxNumberInUnichain():
pool = current_app.config['bigchain_pool']
with pool() as b:
number = b.get_txNumber()
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS, "query success",
number)
def post(self):
# 根据交易ID获取交易
# @common_api.route('/getTxById/', methods=['POST'])
# def getTxById():
type = request.get_json()["type"]
if not check_request(request, "type"):
return make_response(constant.RESPONSE_STATUS_PARAM_ERROE,
constant.RESPONSE_CODE_PARAM_ERROE,
"param type not exist.")
tx_id = request.get_json()["tx_id"]
if not check_request(request, "tx_id"):
return make_response(constant.RESPONSE_STATUS_PARAM_ERROE,
constant.RESPONSE_CODE_PARAM_ERROE,
"param tx_id not exist")
pool = current_app.config['bigchain_pool']
with pool() as b:
if type == '0':
# get single tx by txid without vaildate
tx = list(b.get_transaction_no_valid(tx_id))
if type == '1':
# get all block which contains the tx without validate.
tx = list(b.get_tx_by_id(tx_id))
elif type == '2':
# get block status which contains the tx
tx = b.get_blocks_status_containing_tx(tx_id)
elif type == '3':
# get signle validate tx in validate block
tx = b.get_transaction(tx_id)
tx = tx.to_dict()
if not tx:
tx = {}
return make_response(constant.RESPONSE_STATUS_SUCCESS_NODATA,
constant.RESPONSE_CODE_SUCCESS_NODATA,
"tx not exist!", tx)
else:
# tx_result = tx.to_dict()
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS,
"query success", tx)
def post(self):
# 根据区块ID获取区块中的交易
if not check_request(request, "block_id"):
return make_response(constant.RESPONSE_STATUS_PARAM_ERROE,
constant.RESPONSE_CODE_PARAM_ERROE,
"param block id not exist")
block_id = request.get_json()["block_id"]
pool = current_app.config['bigchain_pool']
with pool() as b:
try:
block = b.get_block(block_id)
except:
return make_response(constant.RESPONSE_STATUS_SERVER_ERROR,
constant.RESPONSE_CODE_SERVER_ERROR,
"None")
print(block)
txList = block["block"]['transactions']
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS, "query success",
txList)
def get(self):
pool = current_app.config['bigchain_pool']
with pool() as bigchain:
new_keypair = generate_key_pair()
new_keypair_dict = {
'private': new_keypair[0],
'public': new_keypair[1]
}
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS,
"generate success", new_keypair_dict)
def post(self):
print("ApiUserAccountChangeRecord")
pool = current_app.config['bigchain_pool']
param = request.get_json(force=True)
print("1:", param)
with pool() as bigchain:
account_record = bigchain.getAccountRecord(param)
print(account_record)
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS, "query success",
list(account_record))
def post(self):
# 获取每区块中包含的交易条数
# @common_api.route('/getTxNumOfAllBlock/', methods=['POST'])
# def getTxNumOfAllBlock():
pool = current_app.config['bigchain_pool']
with pool() as b:
blockIdTxList = b.get_txNumberOfAllBlock()
blockIdTxList = list(blockIdTxList)
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS,
"query success",
blockIdTxList) \
def post(self):
# 根据指定时间区间获取交易集
# @common_api.route('/getTxsByTime/', methods=['POST'])
# def getTxsByTime():
startTime = request.get_json()['beginTime']
if not check_request(request, "beginTime"):
return make_response(constant.RESPONSE_STATUS_PARAM_ERROE,
constant.RESPONSE_CODE_PARAM_ERROE,
"param beginTime not exist")
endTime = request.get_json()['endTime']
if not check_request(request, "endTime"):
return make_response(constant.RESPONSE_STATUS_PARAM_ERROE,
constant.RESPONSE_CODE_PARAM_ERROE,
"param endTime not exist")
pool = current_app.config['bigchain_pool']
with pool() as b:
txIdList = b.get_TxIdByTime(startTime, endTime)
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS, "query success",
txIdList)
def post(self):
print("getContractTx")
tx_id = request.get_json()["tx_id"]
if not check_request(request, "tx_id"):
return make_response(constant.RESPONSE_STATUS_PARAM_ERROE,
constant.RESPONSE_CODE_PARAM_ERROE,
"param tx_id not exist")
pool = current_app.config['bigchain_pool']
with pool() as bigchain:
txs = bigchain.get_contract_txs_by_tx_id(tx_id)
if not txs:
txs = {}
return make_response(constant.RESPONSE_STATUS_SUCCESS_NODATA,
constant.RESPONSE_CODE_SUCCESS_NODATA,
"contract or tx not exist!",
list(txs))
else:
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS,
"query success",
list(txs))
def post(self):
print("getContract")
contract_id = request.get_json()["contract_id"]
if not check_request(request, "contract_id"):
return make_response(constant.RESPONSE_STATUS_PARAM_ERROE,
constant.RESPONSE_CODE_PARAM_ERROE,
"param contract_id not exist")
pool = current_app.config['bigchain_pool']
with pool() as bigchain:
contract = bigchain.get_contract_by_id(contract_id)
if not contract:
contract = {}
return make_response(constant.RESPONSE_STATUS_SUCCESS_NODATA,
constant.RESPONSE_CODE_SUCCESS_NODATA,
"contract not exist!",
list(contract))
else:
res = list(contract)
# print("getContract return", res)
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS,
"query success",
res)
def post(self):
print("createContractTx")
pool = current_app.config['bigchain_pool']
contractTx = request.get_json(force=True)
# print(111)
print(contractTx)
contractTx_obj = Transaction.from_dict(contractTx)
# TODO validate data structure /version=2;opercation=create/transfer; has relation and contact?
print("222====",contractTx_obj)
with pool() as bigchain:
try:
# print("333")
bigchain.validate_transaction(contractTx_obj)
# print("444")
except (ValueError,
OperationError,
TransactionDoesNotExist,
TransactionOwnerError,
FulfillmentNotInValidBlock,
DoubleSpend,
InvalidHash,
InvalidSignature,
AmountError) as e:
return make_response(constant.RESPONSE_STATUS_PARAM_ERROE,
constant.RESPONSE_CODE_PARAM_ERROE,
"invalidate contract transaction.")
# print(contractTx_obj.metadata.to_dict())
tx_result = bigchain.write_transaction(contractTx_obj)
result_messages = "add contract transaction success"
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS,
result_messages,
tx_result)
def get(self):
print('ApiGetFreezeByTransId')
parser = reqparse.RequestParser()
parser.add_argument('unspent', type=parameters.valid_bool)
parser.add_argument('transaction_id')
args = parser.parse_args()
include_spent = not args['unspent']
transaction_id = args['transaction_id']
pool = current_app.config['bigchain_pool']
with pool() as bigchain:
outputs = bigchain.get_freeze_output_by_id(transaction_id,
include_spent)
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS, "sucess",
outputs)
def get(self):
"""API endpoint to retrieve a list of links to transaction
outputs.
Returns:
A :obj:`list` of :cls:`str` of links to outputs.
"""
parser = reqparse.RequestParser()
parser.add_argument('public_key',
type=parameters.valid_ed25519,
required=True)
parser.add_argument('unspent', type=parameters.valid_bool)
args = parser.parse_args()
pool = current_app.config['bigchain_pool']
include_spent = not args['unspent']
with pool() as bigchain:
outputs = bigchain.get_outputs_filtered_not_include_freeze(
args['public_key'], include_spent)
# NOTE: We pass '..' as a path to create a valid relative URI
return make_response(constant.RESPONSE_STATUS_SUCCESS,
constant.RESPONSE_CODE_SUCCESS, "sucess",
outputs)
