def post_transaction(request, key):
if request.method == 'POST':
ser = PaymentPOSTData(data=request.data)
if ser.is_valid():
logger.debug('data is ' + str(ser.data))
amount = ser.validated_data.get('amount')
payment_method_name = ser.validated_data.get('name')
method = get_method_by_name(payment_method_name)
payment_nonce = ser.validated_data.get('payment_nonce')
name = "Urongo Krompf"
email = "*****@*****.**" # ser.validated_data.get('email1')
show_name = True # not ser.validated_data['hide_name']
# Create a new payment transaction with a random ID.
transaction_id = str(uuid.uuid4())
perk_id = None
# if perk != None:
# perk_id = perk.id
BeginPayment(transaction_id, key, amount, email, perk_id, name,
show_name, payment_method_name)
transaction = Transaction.objects.get(
transaction_id=transaction_id)
if method.validate_nonce(amount, payment_nonce):
logger.debug('transaction is good')
ReceivePayment(transaction_id, amount, request)
return Response(TransactionSerializer(transaction).data)
else:
logger.debug('transaction is bad')
return Response(TransactionSerializer(transaction).data)
else:
logger.debug("got a wrong http method")
return Response({'result': 'error', 'errors': ser.errors})
def post_addresses_transactions(addresses_hash):
# Start must be declared None, in case that start doesn't
# exist in the post body
start = None
if not check_if_address_post_key_is_valid(addresses_hash):
return "Bad post request", 400
addresses_hash_no_json = addresses_hash['addresses']
for address_hash in addresses_hash_no_json:
if not validate_address(address_hash):
return "Invalid address hash", 400
if 'start' in addresses_hash:
start = addresses_hash['start']
if start and (not isinstance(start, int)):
return "Start too large", 400
trs = db.post_addresses_transactions(addresses_hash_no_json,
start,
limit=50)
if len(trs) == 50:
last_transaction = trs[len(trs) - 1]
return {
"transactions": [TransactionSerializer.to_web(tr) for tr in trs],
"next": last_transaction['blocktime']
}
else:
return {
"transactions": [TransactionSerializer.to_web(tr) for tr in trs],
"next": None
}
def get_transaction_by_txid(txid):
if not validate_sha256_hash(txid):
return "Invalid transaction ID", 400
try:
return TransactionSerializer.to_web(db.get_transaction_by_txid(txid))
except KeyError:
return "Transaction with given ID not found", 404
def post(self, request, format=None):
data = json.loads(request.body)
print(data['owner'])
print(data['fromAccountNumber'])
print(data['pending'])
owner = data.get('owner', None)
fromAccountNumber = data.get('fromAccountNumber', None)
pending = data.get('pending', None)
transactions = None
headers = {'Content-Type': 'application/json'}
if (owner != None and fromAccountNumber != None and pending != None):
transactions = Transaction.objects.filter(
owner=owner,
fromAccountNumber=fromAccountNumber,
pending=pending)
serializer = TransactionSerializer(transactions, many=True)
return Response(serializer.data,
headers=headers,
status=status.HTTP_200_OK)
else:
return Response(
{
'status': 'Not acceptable',
'message': 'Cannot find request parameters!'
},
headers=headers,
status=status.HTTP_406_NOT_ACCEPTABLE)
def get(self, request):
if request.user.is_authenticated:
transactions = Transaction.objects.all()
serializer = TransactionSerializer(transactions, many=True)
return Response(serializer.data)
else:
return HttpResponseRedirect('/login/')
def flush_cache(self):
if self.block_cache:
self.blocks.insert_many([BlockSerializer.to_database(block) for block in self.block_cache.values()])
if self.tr_cache:
self.transactions.insert_many([TransactionSerializer.to_database(tr) for tr in self.tr_cache.values()])
self.block_cache = {}
self.tr_cache = {}
def setUp(self):
self.db.blocks.insert_many(
[BlockSerializer.to_database(block) for block in self.blocks])
self.db.transactions.insert_many([
TransactionSerializer.to_database(tr) for tr in self.transactions
])
self.db_gateway = MongoDatabaseGateway(database=self.db,
config=self.config)
def get_transactions_by_blockhash(blockhash):
if not validate_sha256_hash(blockhash):
return "Invalid block hash", 400
try:
return [
TransactionSerializer.to_web(tr)
for tr in db.get_transactions_by_blockhash(blockhash)
]
except KeyError:
return []
async def transactions_handler(request):
username = request.query.get('username')
transactions = db.get_transactions(username)
response = TransactionSerializer(transactions, many=True).serialize()
return web.Response(
text=response,
content_type=CTYPE,
)
def get_address_transactions(address_hash, start=None):
if start and (not isinstance(start, int)):
return "Start too large", 400
if not validate_address(address_hash):
return "Invalid address hash", 400
trs = db.get_address_transactions(address_hash, start, limit=51)
if len(trs) == 51:
last_transaction = trs[len(trs) - 1]
return {
"transactions": [TransactionSerializer.to_web(tr) for tr in trs],
"next":
"/addresses/%s?start=%s" %
(address_hash, last_transaction['blocktime'])
}
else:
return {
"transactions": [TransactionSerializer.to_web(tr) for tr in trs],
"next": None
}
def put_transaction(self, tr):
if self.cache:
self.tr_cache[tr.txid] = (TransactionSerializer.to_database(tr))
for vin in tr.vin:
self.vin_cache.append(VinSerializer.to_database(vin, tr.txid))
for (index, vout) in enumerate(tr.vout):
self.vout_cache += VoutSerializer.to_database(
vout, tr.txid, index)
else:
vins = []
vouts = []
for vin in tr.vin:
vins.append(VinSerializer.to_database(vin, tr.txid))
for vout in tr.vout:
vouts += VoutSerializer.to_database(vout, tr.txid, tr.index)
self.transactions.insert_one(TransactionSerializer.to_database(tr))
self.vin.insert_many(vins)
self.vout.insert_many(vouts)
def setUp(self):
self.db.blocks.insert_many(
[BlockSerializer.to_database(block) for block in self.blocks])
self.db.transactions.insert_many([
TransactionSerializer.to_database(tr) for tr in self.transactions
])
for tr in self.transactions:
self.db.vin.insert_many(
[VinSerializer.to_database(vin, tr.txid) for vin in tr.vin])
list_of_lists = [
VoutSerializer.to_database(vout, tr.txid, index)
for (index, vout) in enumerate(tr.vout)
]
self.db.vout.insert_many(
[item for sublist in list_of_lists for item in sublist])
self.db_gateway = MongoDatabaseGateway(database=self.db,
cache=True,
cache_size=5)
def get_latest_transactions(limit, offset):
if not isinstance(offset, int):
return "Offset too large", 400
transactions = db.get_latest_transactions(limit, offset)
return [TransactionSerializer.to_web(tr) for tr in transactions]
