class Query(ObjectType):
stream = relay.NodeField(StreamNode)
all_streams = DjangoFilterConnectionField(StreamNode)
task = relay.NodeField(TaskNode)
all_tasks = DjangoFilterConnectionField(TaskNode)
class Meta:
abstract = True
class Query(ObjectType):
category = relay.NodeField(CategoryNode)
all_categories = DjangoFilterConnectionField(CategoryNode)
project = relay.NodeField(ProjectsNode)
all_projects = DjangoFilterConnectionField(ProjectsNode)
class Meta:
abstract = True
class Query(ObjectType):
category = relay.NodeField(CategoryNode)
all_categories = DjangoFilterConnectionField(CategoryNode)
ingredient = relay.NodeField(IngredientNode)
all_ingredients = DjangoFilterConnectionField(IngredientNode)
class Meta:
abstract = True
class Query(ObjectType):
bucketlist = relay.NodeField(BucketlistNode)
all_bucketlist = DjangoFilterConnectionField(BucketlistNode)
Bucketlistitem = relay.NodeField(BucketlistItemNode)
all_bucketlistitem = DjangoFilterConnectionField(BucketlistItemNode)
debug = graphene.Field(DjangoDebug, name='__debug')
class Query(graphene.ObjectType):
my_node = relay.NodeField(MyNode)
my_node_lazy = relay.NodeField('MyNode')
special_node = relay.NodeField(SpecialNode)
all_my_nodes = relay.ConnectionField(
MyNode, connection_type=MyConnection, customArg=graphene.String())
def resolve_all_my_nodes(self, args, info):
custom_arg = args.get('customArg')
assert custom_arg == "1"
return [MyNode(name='my')]
class Query(ObjectType):
category = relay.NodeField(CategoryNode)
all_categories = DjangoFilterConnectionField(CategoryNode)
ingredient = relay.NodeField(IngredientNode)
all_ingredients = DjangoFilterConnectionField(IngredientNode)
debug = graphene.Field(DjangoDebug, name='__debug')
class Meta:
abstract = True
class Query(ObjectType):
project = relay.NodeField(ProjectNode)
all_projects = DjangoFilterConnectionField(ProjectNode)
milestone = relay.NodeField(MilestoneNode)
all_milestones = DjangoFilterConnectionField(MilestoneNode)
ticket = relay.NodeField(TicketNode)
all_tickets = DjangoFilterConnectionField(TicketNode)
class Meta:
abstract = True
class Query(graphene.ObjectType):
node = relay.NodeField()
reporter = graphene.Field(ReporterNode)
article = graphene.Field(ArticleNode)
def resolve_reporter(self, *args, **kwargs):
return ReporterNode(Reporter(id=1, first_name='ABA',
last_name='X'))
class Query(graphene.ObjectType):
"""A user."""
node = relay.NodeField()
me = graphene.Field(User)
@classmethod
def resolve_me(cls, self, stuff, info):
return User(username=str(dictify(info)), id="Foo")
class Query(graphene.ObjectType):
node = relay.NodeField()
reporter = graphene.Field(ReporterNode)
article = graphene.Field(ArticleNode)
all_articles = SQLAlchemyConnectionField(ArticleNode)
def resolve_reporter(self, *args, **kwargs):
return Reporter(id=1, first_name='ABA', last_name='X')
def resolve_article(self, *args, **kwargs):
return Article(id=1, headline='Article node')
class Query(graphene.ObjectType):
rebels = graphene.Field(Faction)
empire = graphene.Field(Faction)
node = relay.NodeField()
@resolve_only_args
def resolve_rebels(self):
return get_rebels()
@resolve_only_args
def resolve_empire(self):
return get_empire()
class Query(ObjectType):
# user
user = relay.NodeField(UserNode)
all_users = DjangoFilterConnectionField(UserNode, s=graphene.String())
# category
section = relay.NodeField(SectionNode)
all_sections = DjangoFilterConnectionField(SectionNode,
filterset_class=SectionFilter,
s=graphene.String())
# category
category = relay.NodeField(CategoryNode)
all_categories = DjangoFilterConnectionField(
CategoryNode, filterset_class=CategoryFilter, s=graphene.String())
# tag
tag = relay.NodeField(TagNode)
all_tags = DjangoFilterConnectionField(TagNode,
filterset_class=TagFilter,
s=graphene.String())
# entry
entry = relay.NodeField(EntryNode)
all_entries = DjangoFilterConnectionField(EntryNode,
filterset_class=EntryFilter,
s=graphene.String())
# entrylink
entrylink = relay.NodeField(EntrylinkNode)
all_entrylinks = DjangoFilterConnectionField(EntrylinkNode,
s=graphene.String())
class Meta:
abstract = True
class Query(graphene.ObjectType):
#institute = graphene.String(round=graphene.String())
all_degrees = SQLAlchemyConnectionField(Degrees,
fundingRound=graphene.String())
all_invested_companies = SQLAlchemyConnectionField(
InvestedCompany, college=graphene.String())
node = relay.NodeField()
def resolve_all_degrees(self, args, info):
fundingRound = args.get('fundingRound')
return models.queryRoundCollege(fundingRound)
def resolve_all_invested_companies(self, args, info):
college = args.get('college')
return models.queryInvestorCompany(college)
class Query(graphene.ObjectType):
rebels = graphene.Field(Faction)
empire = graphene.Field(Faction)
node = relay.NodeField()
ships = relay.ConnectionField(Ship, description='All the ships.')
@resolve_only_args
def resolve_ships(self):
return get_ships()
@resolve_only_args
def resolve_rebels(self):
return get_rebels()
@resolve_only_args
def resolve_empire(self):
return get_empire()
class Query(graphene.ObjectType):
node = relay.NodeField()
cultural_events = relay.ConnectionField(
CulturalEvent,
cities=graphene.List(graphene.String()),
geo_location=graphene.String(),
radius=graphene.Int(),
categories=graphene.List(graphene.String()),
dates=graphene.List(Date()),
datesRange=graphene.List(DateTime()),
text=graphene.String(),
sort_on=graphene.String(),
)
current_user = relay.ConnectionField(User)
categories = graphene.List(graphene.String())
def resolve_current_user(self, args, info):
current = get_current_user(args)
if not current:
return []
return [User(_root=current)]
def resolve_cultural_events(self, args, info):
oids = get_cultural_events(args, info)
return ResolverLazyList(oids, CulturalEvent)
def resolve_categories(self, args, info):
root_folders = [folder for folder in find_entities(
interfaces=[ISmartFolder],
metadata_filter={'states': ['published']},
force_local_control=True) if not folder.parents]
sections = set()
for folder in root_folders:
for filter in folder.filters: #pylint: disable=W0622
if 'cultural_event' in filter[
'metadata_filter'].get('content_types', ()) and \
'Rubrique' in filter['metadata_filter']['tree']:
keywords = list(filter['metadata_filter']['tree'][
'Rubrique'].keys())
for keyword in keywords:
sections.add(keyword)
sections = sorted(sections)
return sections
class Query(graphene.ObjectType):
all_films = DjangoFilterConnectionField(Film)
all_species = DjangoFilterConnectionField(Specie)
all_characters = DjangoFilterConnectionField(Person)
all_vehicles = DjangoFilterConnectionField(Vehicle)
all_planets = DjangoFilterConnectionField(Planet)
all_starships = DjangoFilterConnectionField(Starship)
all_heroes = DjangoFilterConnectionField(Hero)
film = relay.NodeField(Film)
specie = relay.NodeField(Specie)
character = relay.NodeField(Person)
vehicle = relay.NodeField(Vehicle)
planet = relay.NodeField(Planet)
starship = relay.NodeField(Starship)
hero = relay.NodeField(Hero)
node = relay.NodeField()
viewer = graphene.Field('self')
debug = graphene.Field(DjangoDebug, name='__debug')
def resolve_viewer(self, *args, **kwargs):
return self
class Query(ObjectType):
customer = relay.NodeField(CustomerNode)
category = relay.NodeField(CategoryNode)
product = relay.NodeField(ProductNode)
order = relay.NodeField(OrderNode)
cart_item = relay.NodeField(CartItemNode)
order_item = relay.NodeField(OrderItemNode)
all_customers = DjangoFilterConnectionField(CustomerNode)
all_categories = DjangoFilterConnectionField(CategoryNode)
all_products = DjangoFilterConnectionField(ProductNode)
all_orders = DjangoFilterConnectionField(OrderNode)
class Meta:
abstract = True
class Query(graphene.ObjectType):
all_cvs = relay.ConnectionField(CV)
cv = relay.NodeField(CV)
work_experience = relay.NodeField(WorkExperience)
education = relay.NodeField(Education)
language = relay.NodeField(Language)
course = relay.NodeField(Course)
volunteer_work = relay.NodeField(VolunteerWork)
viewer = graphene.Field('self')
@resolve_only_args
def resolve_all_cvs(self, **kwargs):
return models.CV.objects.all()
def resolve_viewer(self, *args, **kwargs):
return self
class Query(graphene.ObjectType):
node = relay.NodeField(EditorNode)
all_editors = SQLAlchemyConnectionField(EditorNode)
class Query(ObjectType):
fundingRound = relay.NodeField(FundingRoundNode)
allFundingRounds = DjangoFilterConnectionField(FundingRoundNode)
object = relay.NodeField(ObjectNode)
allObjects = DjangoFilterConnectionField(ObjectNode)
relationship = relay.NodeField(RelationshipNode)
allRelationships = DjangoFilterConnectionField(RelationshipNode)
degree = relay.NodeField(DegreeNode)
allDegrees = DjangoFilterConnectionField(DegreeNode)
acquisition = relay.NodeField(AcquisitionNode)
allAcquisitions = DjangoFilterConnectionField(AcquisitionNode)
fund = relay.NodeField(FundNode)
allFunds = DjangoFilterConnectionField(FundNode)
investment = relay.NodeField(InvestmentNode)
allInvestments = DjangoFilterConnectionField(InvestmentNode)
ipo = relay.NodeField(IpoNode)
allIpos = DjangoFilterConnectionField(IpoNode)
milestone = relay.NodeField(MilestoneNode)
allMilestones = DjangoFilterConnectionField(MilestoneNode)
office = relay.NodeField(OfficeNode)
allOffices = DjangoFilterConnectionField(OfficeNode)
people = relay.NodeField(PeopleNode)
allPeople = DjangoFilterConnectionField(PeopleNode)
myObjects = relay.ConnectionField(ObjectNode, \
description='Get objects by params.', \
limit=graphene.Int(), \
school=graphene.String(), \
isInvestor=graphene.Boolean()
)
def resolve_myObjects(self, args, info):
limit = args.get('limit')
school = args.get('school')
if (school is not None) and (school != ''):
ret = []
len = 0
degrees = CbDegrees.objects.filter(institution=school)
for degree in degrees:
if len == limit:
break
ret.append(degree.object)
len += 1
return ret
return CbObjects.objects.all()[:limit]
class Meta:
abstract = True
class Query(graphene.ObjectType):
node = relay.NodeField()
viewer = graphene.Field(Viewer)
def resolve_viewer(self, args, info):
return Viewer.instance()
class Query(graphene.ObjectType):
node = relay.NodeField()
class Query(graphene.ObjectType):
node = relay.NodeField()
all_employees = SQLAlchemyConnectionField(Employee)
class NotesQuery(ObjectType):
note = relay.NodeField(NotesNode)
all_notes = DjangoFilterConnectionField(NotesNode)
class ViolationQuery(ObjectType):
violation = relay.NodeField(ViolationNode)
all_violations = DjangoFilterConnectionField(ViolationNode)
class Meta:
abstract = True
