cic-internal-integration/apps/cic-eth/cic_eth/graphql/schema.py

# standard imports
import json
import sys
import uuid

import cic_eth.cli
import redis
from cic_eth.api.api_task import Api
from graphene import (Boolean, Field, Float, Int, List, Mutation, ObjectType,
                      Schema, String)

arg_flags = cic_eth.cli.argflag_std_base
local_arg_flags = cic_eth.cli.argflag_local_taskcallback
argparser = cic_eth.cli.ArgumentParser(arg_flags)

argparser.process_local_flags(local_arg_flags)
args = argparser.parse_args()
config = cic_eth.cli.Config.from_args(args, arg_flags, local_arg_flags)

celery_app = cic_eth.cli.CeleryApp.from_config(config)


def call(method, *args):
    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')

    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

    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,
    )
    print(args)

    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()
    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 = Int()
    balance_incoming = Int(default_value=0)
    balance_outgoing = Int(default_value=0)
    balance_available = Int(default_value=0)

    def resolve_balance_available(parent, info):
        print(parent)
        return (parent.balance_network + parent.balance_incoming) - parent.balance_outgoing


class Query(ObjectType):
    default_token = Field(Token)

    def resolve_default_token(parent, info):
        # always pass an object for `me` field
        data = call('default_token')
        print(data)
        return Token(**data)

    balance = Field(List(TokenBalance), address=String(),
                    token_symbols=List(String), include_pending=Boolean())

    def resolve_balance(root, info, address, token_symbols, include_pending=True):
        data = call('balance', address, token_symbols, include_pending)
        print(data)
        #[{'address': '3ff776b6f888980def9d4220858803f9dc5e341e', 'converters': [], 'balance_network': 0}]
        return map(lambda token: TokenBalance(**token), data)


class CreateAccount(Mutation):
    address = String()

    class Arguments:
        password = String(required=True)
        register = Boolean()

    def mutate(root, info, password, register=True):
        print(password, register)

        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)

        data = call('transfer', from_address,
                    to_address,
                    value,
                    token_symbol)
        print(data)
        return data
# 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):

        data = call('transfer_from', from_address,
                    to_address,
                    value,
                    token_symbol, spender_address)
        return data


class MyMutations(ObjectType):
    create_account = CreateAccount.Field()
    transfer = Transfer.Field()


schema = Schema(query=Query, mutation=MyMutations)


query_with_argument = """
{ 
  defaultToken{
    symbol
  } 
}

"""
result = schema.execute(query_with_argument)
print(result)


mutation_with_argument = """
mutation { 
  createAccount(password:"test"){
    address
  }
}

"""
m_result = schema.execute(mutation_with_argument)
print(m_result)


balance_query = """
query { 
  balance(address:"0x82e66cf2766bf20672a605bbf5a6faaa12d5b907", tokenSymbols:["GFT"]){
    balanceNetwork
    balanceIncoming
    balanceOutgoing
    balanceAvailable
  }
}

"""
balance_query_result = schema.execute(balance_query)
print(balance_query_result)


transfer_mutation = """
mutation { 
  transfer(fromAddress :"0x0000000000000000000000000000000000000000",
toAddress:  "0x82e66cf2766bf20672a605bbf5a6faaa12d5b907"
value: 5000
tokenSymbol: "GFT" ){
    test
  }
}

"""
transfer_mutation_result = schema.execute(transfer_mutation)
print(transfer_mutation_result)


balance_query = """
query { 
  balance(address:"0x82e66cf2766bf20672a605bbf5a6faaa12d5b907", tokenSymbols:["GFT"]){
    balanceNetwork
    balanceIncoming
    balanceOutgoing
    balanceAvailable
  }
}

"""
balance_query_result = schema.execute(balance_query)
print(balance_query_result)