cic-internal-integration/apps/cic-eth/cic_eth/graphql/schema.py
2021-11-02 18:50:14 +03:00

208 lines
6.0 KiB
Python

# standard imports
import json
import logging
import sys
import uuid
import redis
from cic_eth.api.api_task import Api
from cic_eth.graphql.config import config
from graphene import (Boolean, Field, Float, Int, List, Mutation, ObjectType,
Schema, String)
chain_spec = config.get('CHAIN_SPEC')
redis_host = config.get('REDIS_HOST')
redis_port = config.get('REDIS_PORT')
redis_db = config.get('REDIS_DB')
celery_queue = config.get('CELERY_QUEUE')
logging.basicConfig(level=logging.DEBUG)
log = logging.getLogger(__name__)
def call(method, *args):
redis_channel = str(uuid.uuid4())
r = redis.Redis(redis_host, redis_port, redis_db)
ps = r.pubsub()
ps.subscribe(redis_channel)
ps.get_message() # Subscription Object
print(f"Channel init {redis_channel}")
print(args)
api = Api(
chain_spec,
queue=celery_queue,
callback_param='{}:{}:{}:{}'.format(
redis_host, redis_port, redis_db, redis_channel),
callback_task='cic_eth.callbacks.redis.redis',
callback_queue=celery_queue,
)
getattr(api, method)(*args)
ps.get_message() # returns None !?
try:
o = ps.get_message(timeout=config.get('REDIS_TIMEOUT'))
except TimeoutError as e:
sys.stderr.write(
'got no new address from cic-eth before timeout: {}\n'.format(e))
sys.exit(1)
ps.unsubscribe()
print(o)
m = json.loads(o['data'])
return m["result"]
class Token(ObjectType):
symbol = String()
address = String()
name = String()
decimals = Int()
class TokenBalance(ObjectType):
address = String()
converters = List(String)
balance_network = String(default_value="0")
balance_incoming = String(default_value="0")
balance_outgoing = String(default_value="0")
balance_available = String(default_value="0")
def resolve_balance_available(parent, info):
print(parent)
return str(int(parent.balance_network) + int(parent.balance_incoming) - int(parent.balance_outgoing))
class Query(ObjectType):
default_token = Field(Token)
def resolve_default_token(parent, info):
# always pass an object for `me` field
api = Api(
chain_spec,
queue=celery_queue,
)
task = api.default_token()
data = task.get()
print(data)
return Token(**data)
balance = Field(List(TokenBalance), address=String(),
token_symbol=String(), include_pending=Boolean())
def resolve_balance(root, info, address, token_symbol, include_pending=True):
api = Api(
chain_spec,
queue=celery_queue,
)
task = api.balance(address=address, token_symbol=token_symbol, include_pending=include_pending)
data = task.get() #api call('balance', address, token_symbol, include_pending)
log.debug(data)
print(data, file=sys.stdout)
#[{'address': '3ff776b6f888980def9d4220858803f9dc5e341e', 'converters': [], 'balance_network': 0}]
return map(lambda token: TokenBalance(
address=token.get("address"),
converters=token.get("converters"),
balance_network=str(token.get("balance_network") or "0"),
balance_incoming=str(token.get("balance_incoming") or "0"),
balance_outgoing=str(token.get("balance_outgoing") or "0"),
balance_available=str(token.get("balance_available" or "0"))
), data)
transactions = Field(String, address=String(
required=True), limit=Int(default_value=10))
def resolve_transactions(root, info, address, limit):
api = Api(
chain_spec,
queue=celery_queue,
)
task = api.list(address=address, limit=limit)
data = task.get()
print(data)
#[{'address': '3ff776b6f888980def9d4220858803f9dc5e341e', 'converters': [], 'balance_network': 0}]
return "test"
class CreateAccount(Mutation):
address = String()
class Arguments:
password = String(required=True)
register = Boolean()
def mutate(root, info, password, register=True):
print(password, register)
api = Api(
chain_spec,
queue=celery_queue,
)
address = call('create_account',password, register)
return CreateAccount(address=f"0x{address}")
class Transfer(Mutation):
test = String(default_value="test")
class Arguments:
from_address = String(required=True)
to_address = String(required=True)
value = Int(required=True)
token_symbol = String(required=True)
def mutate(root, info, from_address,
to_address,
value,
token_symbol):
print(from_address, to_address, value, token_symbol)
api = Api(
chain_spec,
queue=celery_queue,
)
t = api.transfer(from_address, to_address,
int(value * (10**6)), token_symbol)
print(f"t {t}")
print(f"transfer {t.get_leaf()}")
print(f"transfer {t.successful()}")
return t.get()
# 0x0000000000000000000000000000000000000000
class TransferFrom(Mutation):
address = String()
class Arguments:
from_address = String(required=True)
to_address = String(required=True)
value = Int(required=True)
token_symbol = String(required=True)
spender_address = String(required=True)
def mutate(root, info, from_address,
to_address,
value,
token_symbol, spender_address):
api = Api(
chain_spec,
queue=celery_queue,
)
task = api.transfer_from(from_address=from_address,
to_address=to_address,
value=value,
token_symbol=token_symbol, spender_address=spender_address)
return task.get()
class MyMutations(ObjectType):
create_account = CreateAccount.Field()
transfer = Transfer.Field()
schema = Schema(query=Query, mutation=MyMutations)