class CoreMarketQuery(graphene.ObjectType):
coremarket = graphene.Field(CoreMarket, host=graphene.String(), cycleNum=graphene.Int())
coremarkets = CustomMongoengineConnectionField(CoreMarket)
lastcoremarkets = CustomMongoengineConnectionField(CoreMarket)
# totalincome = graphene.Float()
# incomeperround = graphene.Float()
# risk = graphene.Float()
# def resolve_totalincome(self, info, host):
def resolve_coremarket(self, info, host, cycleNum):
return CoreMarketModel.objects(host=host, cycleNum=cycleNum).first()
def resolve_coremarkets(self, info, args):
qs = CoreMarketModel.objects()
return qs;
def resolve_lastcoremarkets(self, info, args):
host = args.get('host', 'none')
last = CoreMarketModel.objects(host=host).first()
if (last):
qs = CoreMarketModel.objects(cycle_num = last.cycle_num)
return qs;
else:
return [];
class PostQuery(graphene.ObjectType):
post = graphene.Field(Post, identifier=CommentIdentifier())
posts = CustomMongoengineConnectionField(Post,
meta=MetaFilterInput(),
orderBy=PostOrderingEnum())
comments = CustomMongoengineConnectionField(Comment)
comment = graphene.Field(Comment, identifier=graphene.String())
def resolve_posts(self, info, args):
qs = CommentModel.objects()
meta = args.get('meta', {})
if 'orderBy' in args:
qs = qs.order_by(args['orderBy'])
tags = meta.get('tags')
app = meta.get('app')
if tags:
qs = qs.filter(json__tags__all=tags)
if app:
qs = qs.filter(json__app=app)
return qs_ab_filter(qs, args)
def resolve_post(self, context, identifier=None):
author, permlink = identifier[1:].split('/')
return CommentModel.objects(author=author, permlink=permlink).first()
class AccountQuery(graphene.ObjectType):
account = graphene.Field(Account, name=graphene.String())
accounts = CustomMongoengineConnectionField(Account,
meta=AccountMetaFilterInput())
account_authority = graphene.Field(AccountAuthority,
account=graphene.String())
def resolve_accounts(self, info, args):
qs = AccountModel.objects()
meta = args.get('meta', {})
not_null = meta.get('not_null')
if not_null:
qs = qs.filter(
__raw__={f'json_metadata.{not_null}': {
'$exists': True
}})
return qs
def resolve_account(self, info, name):
return AccountModel.objects(name=name).first()
def resolve_account_authority(self, info, account):
return AccountAuthorityModel.objects(account=account).first()
class LevelQuery(graphene.ObjectType):
level = graphene.Field(Level,
username=graphene.String(),
blockchain=graphene.String(required=True))
levels = CustomMongoengineConnectionField(Level)
# powers = CustomMongoengineConnectionField(Power)
# def resolve_powers(self, info, args):
# qs = PowerModel.objects()
# return qs;
# lev = graphene.Int(0)
# def resolve_accounts(self, info, args):
# qs = AccountModel.objects()
# meta = args.get('meta', {})
# not_null = meta.get('not_null')
# if not_null:
# qs = qs.filter(
# __raw__={f'json_metadata.{not_null}': {'$exists': True}}
# )
# return qs
# def resolve_lev(self, info, args):
# if self.lev:
# return self.lev + 1
# else:
# return 1
def resolve_level(self, info, username, blockchain):
return LevelModel.objects(username=username,
blockchain=blockchain).first()
def resolve_levels(self, info, args):
qs = LevelModel.objects()
# sort_type = args.get('sorttype', 'is1min')
# qs = qs.filter(is1min = True)
# qs = qs.filter(
# __raw__={f'cost': {'$exists': True}}
# )
# print(qs)
# for key in qs:
# pprint(getmembers(key))
# # qs = qs.filter(
# # __raw__={f'json_metadata.{not_null}': {'$exists': True}}
# # )
return qs
class MarketQuery(graphene.ObjectType):
market = graphene.Field(Market, host=graphene.String())
markets = CustomMongoengineConnectionField(Market)
# def resolve_accounts(self, info, args):
# qs = AccountModel.objects()
# meta = args.get('meta', {})
# not_null = meta.get('not_null')
# if not_null:
# qs = qs.filter(
# __raw__={f'json_metadata.{not_null}': {'$exists': True}}
# )
# return qs
def resolve_market(self, info, host):
return MarketModel.objects(host=host).first()
def resolve_markets(self, info, args):
qs = MarketModel.objects()
# sort_type = args.get('sorttype', 'is1min')
# qs = qs.filter(is1min = True)
# qs = qs.filter(
# __raw__={f'cost': {'$exists': True}}
# )
# print(qs)
# for key in qs:
# pprint(getmembers(key))
# # qs = qs.filter(
# # __raw__={f'json_metadata.{not_null}': {'$exists': True}}
# # )
return qs;
# def resolve_account_authority(self, info, account):
# return AccountAuthorityModel.objects(account=account).first()
class PowerQuery(graphene.ObjectType):
# powers = graphene.Field(Power)
powers = CustomMongoengineConnectionField(Power, minpower=graphene.Int())
# powers = graphene.List('levels.types.Power',
# blockchain=graphene.String(required=True),
# minpower=graphene.Int(),
# first=graphene.Int(),
# last=graphene.Int())
badges = graphene.List('badges.types.Badge',
first=graphene.Int(),
last=graphene.Int(),
host=graphene.String())
def resolve_badges(self, info, host):
if (host):
qs = BadgeModel.objects(blockchain=self.blockchain,
username=self.username,
host=host)
else:
qs = BadgeModel.objects(blockchain=self.blockchain,
username=self.username)
#TODO find badges and construct
return qs
def resolve_powers(self, info, args):
minpower = args.get('minpower', 0)
# row = {f'power': {'$gte': minpower}}
# print(row)
qs = PowerModel.objects(__raw__={f'power': {'$gte': minpower}})
# qs = PowerModel.objects()
# qs = qs.filter(
# __raw__={f'power': {'$gte': power}}
# )
return qs
class HostQuery(graphene.ObjectType):
hosts = CustomMongoengineConnectionField(Host)
def resolve_hosts(self, info, args):
qs = HostModel.objects()
return qs
class Post(MongoengineObjectType):
author = graphene.Field(Account)
meta = graphene.Field(PostMeta)
thumb = graphene.String(description='First image in post body')
total_pending_payout = graphene.Float()
votes = CustomMongoengineConnectionField(Vote)
body = graphene.String(linkify_images=graphene.Boolean())
is_voted = graphene.Boolean(
description='Check whether the account was voted for this post',
account=graphene.String(),
)
comments = graphene.List('post.types.Post',
first=graphene.Int(),
last=graphene.Int())
class Meta:
description = '''
All posts.
Pagination - posts is divided into pages,
use page param: page=2
'''
model = CommentModel
interfaces = (Node, )
def resolve_total_pending_payout(self, info):
dgp = DGPModel.objects.first()
tpp = self['vote_rshares']
tpp *= dgp.total_reward_fund_steem_value
tpp /= dgp.total_reward_shares2
return tpp
def resolve_is_voted(self, info, account):
vote = VoteModel.objects(comment=self.id, voter=account).first()
return vote is not None
def resolve_comments(self, info, first=None, last=None):
# TODO Написать простой пагинатор для комментов
comments = find_comments(self)[::-1]
if first is not None:
comments = comments[:first]
elif last is not None:
comments = comments[max(0, len(comments) - last):]
return comments
def resolve_image(self, info):
return self.json_metadata['image'][0]
def resolve_meta(self, info):
return self.json_metadata or {}
def resolve_thumb(self, info):
return find_images(self.body, first=True)
def resolve_author(self, info):
return AccountModel.objects(name=self.author).first()
def resolve_votes(self, info, args):
return VoteModel.objects(permlink=self.permlink, author=self.author)
def resolve_body(self, info, linkify_images=False):
format = prepare_json(self.json_metadata).get('format', 'html')
if linkify_images:
return utils.linkify_images(self.body, format)
else:
return self.body
class BadgesQuery(graphene.ObjectType):
badges = CustomMongoengineConnectionField(Badge)
def resolve_badges(self, info, args):
qs = BadgeModel.objects()
return qs
class SpiralQuery(graphene.ObjectType):
spiral = CustomMongoengineConnectionField(Spiral)
def resolve_spiral(self, info, args):
qs = SpiralModel.objects()
return qs
class RatesQuery(graphene.ObjectType):
rates = CustomMongoengineConnectionField(Rates)
def resolve_rates(self, info, args):
qs = RatesModel.objects()
return qs