def test_success(self):
testee = TornadoClient(self.get_url('/echo'))
response = yield testee.some_method(1, [2], {
'3': 4,
'5': True,
'6': None
})
self.assertEqual([1, [2], {'3': 4, '6': None, '5': True}], response)
def test_custom_headers(self):
testee = TornadoClient(self.get_url('/echo'))
response = yield testee.send(Request('some_method', 1, [2], {
'3': 4,
'5': True,
'6': None
}),
headers={'foo': 'bar'})
self.assertEqual([1, [2], {'3': 4, '6': None, '5': True}], response)
from tornado.ioloop import IOLoop
from jsonrpcclient.tornado_client import TornadoClient
client = TornadoClient('http://localhost:5000/')
async def main():
response = await client.request('ping')
print(response)
IOLoop.current().run_sync(main)
class Account(GenesisClass):
balance = Balance()
blockchain = Blockchain()
permissions = Permissions()
mailer = Mail()
client_storage = TornadoClient(settings.storageurl)
client_withdraw = TornadoClient(settings.withdrawhost)
validator = {
"QTUM": lambda x: Qtum.public_key_to_hex_address(x),
"ETH": lambda x: R8_Ethereum.public_key_to_checksum_address(x),
"PUT": lambda x: Qtum.public_key_to_hex_address(x),
}
withdraw_address = {
"PUTTEST": lambda x: bip32addresses.Bip32Addresses.address_to_hex(x),
"QTUMTEST": lambda x: x
}
ident_offer = {0: "read_access", 1: "write_access"}
async def withdraw_fee(self, coinid):
if not isinstance(coinid, str):
return {
"error": 400,
"reason": "Coinid type error. Must be string."
}
fees = {
"BTCTEST": 0.001 * pow(10, 8),
"ETH": 0.01 * pow(10, 8),
"QTUMTEST": 0.5 * pow(10, 8),
"PUTTEST": 50 * pow(10, 8),
"LTCTEST": 0.05 * pow(10, 8)
}
try:
fee = fees[coinid]
except KeyError:
fee = 0
return fee
async def logsource(self, **params):
result = await self.client_storage.request(method_name="logsource",
**params)
return result
async def createaccount(self, **params):
result = await self.client_storage.request(method_name="createaccount",
**params)
return result
async def getaccountdata(self, **params):
result = await self.client_storage.request(
method_name="getaccountdata", **params)
return result
async def createwallet(self, **params):
result = await self.client_storage.request(method_name="createwallet",
**params)
return result
async def getnews(self, **params):
result = await self.client_storage.request(method_name="getnews",
**params)
return result
async def setnews(self, **params):
result = await self.client_storage.request(method_name="setnews",
**params)
return result
async def getaccountbywallet(self, **params):
result = await self.client_storage.request(
method_name="getaccountbywallet", **params)
return result
async def updatelevel(self, **params):
result = await self.client_storage.request(method_name="updatelevel",
**params)
return result
async def insertoffer(self, **params):
result = await self.client_storage.request(method_name="insertoffer",
**params)
return result
async def getoffer(self, **params):
result = await self.client_storage.request(method_name="getoffer",
**params)
return result
async def removeoffer(self, **params):
result = await self.client_storage.request(method_name="removeoffer",
**params)
return result
async def updateoffer(self, **params):
result = await self.client_storage.request(method_name="updateoffer",
**params)
return result
async def mailedconfirm(self, **params):
result = await self.client_storage.request(method_name="mailedconfirm",
**params)
return result
async def getoffers(self, **params):
result = await self.client_storage.request(method_name="getoffers",
**params)
return result
async def getuserscontent(self, **params):
result = await self.client_storage.request(
method_name="getuserscontent", **params)
return result
async def setuserscontent(self, **params):
result = await self.client_storage.request(
method_name="setuserscontent", **params)
return result
async def updateuserscontent(self, **params):
result = await self.client_storage.request(
method_name="updateuserscontent", **params)
return result
async def getallcontent(self):
result = await self.client_storage.request(method_name="getallcontent")
return result
async def getsinglecontent(self, cid):
result = await self.client_storage.request(
method_name="getsinglecontent", cid=cid)
return result
async def changecontentowner(self, **params):
result = await self.client_storage.request(
method_name="changecontentowner", **params)
return result
async def setaccessstring(self, **params):
result = await self.client_storage.request(
method_name="setaccessstring", **params)
return result
async def getreviews(self, **params):
result = await self.client_storage.request(method_name="getreviews",
**params)
return result
async def setreview(self, **params):
result = await self.client_storage.request(method_name="setreview",
**params)
return result
async def updatereview(self, **params):
result = await self.client_storage.request(method_name="updatereview",
**params)
return result
async def writedeal(self, **params):
result = await self.client_storage.request(method_name="writedeal",
**params)
return result
async def getdeals(self, **params):
result = await self.client_storage.request(method_name="getdeals",
**params)
return result
async def updatedescription(self, **params):
result = await self.client_storage.request(
method_name="updatedescription", **params)
return result
async def setwriteprice(self, **params):
result = await self.client_storage.request(method_name="setwriteprice",
**params)
return result
async def setreadprice(self, **params):
result = await self.client_storage.request(method_name="setreadprice",
**params)
return result
async def changeowner(self, **params):
result = await self.client_storage.request(method_name="changeowner",
**params)
return result
async def sharecontent(self, **params):
result = await self.client_storage.request(method_name="sharecontent",
**params)
return result
async def withdraw(self, **params):
result = await self.client_withdraw.request(method_name="withdraw",
**params)
return result
def test_failure(self):
testee = TornadoClient(self.get_url('/fail'))
with self.assertRaises(httpclient.HTTPError) as ctx:
yield testee.fail(code=500)
self.assertEqual('HTTP 500: Internal Server Error', str(ctx.exception))
from robin8_billing import robin8_billing
import logging
import json
import os
import settings
from jsonrpcclient.tornado_client import TornadoClient
from tornado_components.web import RobustTornadoClient, SignedTornadoClient
from config import storage_type, storage_host, storage_port, storage_download_time_limit, \
contract_owner, contract_owner_hex, contract_address, blockchain_type, \
decimals, ipc_path, http_provider, pmes_abi, private_key, \
gas_limit, gas_price
from robin8.pmes_eth_contract_handler import PmesEthContractHandler
from robin8.pmes_qtum_contract_handler import PmesQtumContractHandler
from qtum_utils.qtum import Qtum
client_storage = TornadoClient(settings.storageurl)
client_balance = TornadoClient(settings.balanceurl)
coinid = "QTUM"
def get_storage_handler():
if storage_type == 'ipfs':
return R8Storage.init_ipfs(host=storage_host,
port=storage_port,
time_limit=storage_download_time_limit)
else:
return R8Storage.init_no_storage()
def verify(func):
async def incbalance(self, *args, **kwargs):
""" Increments users balance
Accepts:
- message (signed dictionary):
- "address" - str
- "amount" - int
- "uid" - str
- "coinid" - str
Returns:
- dictionary with following fields:
- "address" - str
- "coinid" - str
- "amount" - int
- "uid" - int
- "unconfirmed" - int (0 by default)
- "deposit" - int (0 by default)
- "txid" - None
"""
# Get data from message
message = json.loads(kwargs.get("message", "{}"))
address = message.get("address")
amount = int(message.get("amount", 0))
uid = message.get("uid")
coinid = message.get("coinid")
txid = message.get("txid")
# Connect to database
db = client[coinid]
balances = db[settings.BALANCE]
# Check if amount
if not amount:
return {"error": 400, "reason": "Funds is zero"}
# Get account by uid or address
if uid:
balance = await balances.find_one({"uid": int(uid)})
elif address:
balance = await balances.find_one({"address": address})
# Increment balance if account exists
if not balance:
return {
"error": 404,
"reason": "Increment balance. Balance not found"
}
# Update balance
if not txid:
await balances.find_one_and_update(
{"address": balance["address"]},
{"$inc": {
"amount": int(amount)
}})
result = await balances.find_one({"address": balance["address"]})
else:
db = client["PUT"]
balances = db[settings.BALANCE]
await balances.find_one_and_update(
{"uid": balance["uid"]},
{"$inc": {
"unconfirmed": int(amount)
}})
result = await balances.find_one({"uid": balance["uid"]})
await balances.find_one_and_update({"uid": balance["uid"]},
{"$set": {
"txid": txid
}})
account_client = SignedTornadoClient(settings.storageurl)
account = await account_client.request(method_name="getaccountdata",
**{"id": balance["uid"]})
# Send mail to user
if account.get("email"):
client_email = TornadoClient(settings.emailurl)
email_data = {
"to":
account["email"],
"subject":
"Robin8 Support",
"optional":
"You`ve got %s tokens. Now your balance is %s" %
(amount / pow(10, 8), int(result["amount"]) / pow(10, 8))
}
await client_email.request(method_name="sendmail", **email_data)
# Return result
result = {i: result[i] for i in result if i != "_id"}
result["amount"] = int(result["amount"])
return result
from tornado import ioloop
from jsonrpcclient.tornado_client import TornadoClient
#from casino import get_balance
port = 8001
client = TornadoClient("http://localhost:8001/")
async def get_balance():
await client.request("get_balance")
async def update_balance():
await client.request("update_balance", **balance)
async def test_ping():
await client.request("ping")
# async def main():
# b = await get_balance()
# #assert(b == 274)
# p = await test_ping()
# #assert(p == "pong")
#
# ioloop.IOLoop.current().run_sync(main)
