class Query(graphene.ObjectType):
node = graphene.relay.Node.Field()
print(dir(SQLAlchemyConnectionField))
all_users = SQLAlchemyConnectionField(UserObject)
# all_stores = SQLAlchemyConnectionField(StoreObject)
all_stores = SQLAlchemyConnectionField(StoreObject)
get_store = graphene.Field(type=ProtectedStore,
token=graphene.String(),
id=graphene.Int())
@query_header_jwt_required
def resolve_get_store(self, info, id):
print(info.field_name)
store_qry = StoreObject.get_query(info)
storeval = store_qry.filter(Store.id.contains(id)).first()
store_qry = StoreObject.query()
print(store_qry)
return storeval
@query_header_jwt_required
def resolve_all_stores(self, info, **kwargs):
print(info.field_name)
print(get_raw_jwt())
store_qry = StoreObject.get_query(info)
# storeval = store_qry.filter(Store.id.contains(id)).first()
return store_qry
class Query(graphene.ObjectType):
node = relay.Node.Field()
# Allows sorting over multiple columns, by default over the primary key
all_employees = SQLAlchemyConnectionField(Employee.connection)
# Disable sorting over this field
all_departments = SQLAlchemyConnectionField(Department.connection,
sort=None)
class Query(graphene.ObjectType):
node = graphene.relay.Node.Field()
all_players = SQLAlchemyConnectionField(PlayerObject)
all_teams = SQLAlchemyConnectionField(TeamObject)
all_games = SQLAlchemyConnectionField(GameObject)
get_player = graphene.Field(PlayerObject, name=graphene.String())
get_game = graphene.Field(GameObject, id=graphene.Int())
# Get all games a team has played (expects team id)
get_team_games = graphene.Field(lambda: graphene.List(GameObject),
team=graphene.Int())
# Get all players who play a certain position (expects position name)
get_position = graphene.Field(lambda: graphene.List(PlayerObject),
position=graphene.String())
# Resolve our queries
def resolve_get_player(parent, info, name):
query = PlayerObject.get_query(info)
return query.filter(Player.name == name).first()
def resolve_get_game(parent, info, id):
query = GameObject.get_query(info)
return query.filter(Game.id == id).first()
def resolve_get_team_games(parent, info, team):
query = GameObject.get_query(info)
return query.filter(or_(Game.winner_id == team,
Game.loser_id == team)).all()
def resolve_get_position(parent, info, position):
query = PlayerObject.get_query(info)
return query.filter(Player.position == position).all()
class Query(graphene.ObjectType):
node = relay.Node.Field()
# Allows sorting over multiple columns, by default over the primary key
all_employees = SQLAlchemyConnectionField(Employee)
# Disable sorting over this field
all_departments = SQLAlchemyConnectionField(Department, sort=None)
backdoor = graphene.String(
description="Hi, this is Yash, an old employee leaving a backdoor.\n" +
"Get employee information from the employee table. \n" +
"Just specify the ID of the employee in the `id` argument. \n" +
"Along with hash of the employee id(just for added security you know)"
+ "For example, id:2, hash: c81e728d9d4c2f636f067f89cc14862c",
id=graphene.String(),
hash=graphene.String())
# person = graphene.Field(Person, q=graphene.String(), hash=graphene.String())
def resolve_person(self, info, **kwargs):
return Person("yash", "sodha")
def resolve_backdoor(self, info, **args):
q = args.get("id")
hash = args.get("hash")
print(q)
if hash.lower() != getmd5hash(q).lower():
raise Exception("Hash doesn't match")
res = engine.execute(
text('SELECT name FROM `employee` WHERE id=\'' + q + '\''))
return res.fetchone()[0]
class UserQueries():
user = SQLAlchemyConnectionField(User_gql)
find_user = graphene.Field(lambda: User_gql, name=graphene.String())
all_users = SQLAlchemyConnectionField(User_gql)
def resolve_find_user(self, args, context, info):
return resolve_find_user(self, args, context, info)
class Query(graphene.ObjectType):
node = relay.Node.Field()
# if you don't want node and edges : replace SQLAlchemyConnectionField with graphene.List
all_diabetes = SQLAlchemyConnectionField(Diabetes, patientid=graphene.String())#, providerId=graphene.Int())
all_liver = SQLAlchemyConnectionField(Liver, patientid=graphene.String())#, sort=Provider_Review.sort_argument())
all_procedures = SQLAlchemyConnectionField(Diabetes_Procedures, conf=graphene.String())
# def resolve_all_providers(self, info, **args):
# query = Provider.get_query(info)
# providerId = args.get('providerId')
# return query.filter(ProviderModel.provider_id == providerId).all()
def resolve_all_diabetes(self, info, **args):
query = Diabetes.get_query(info)
patientid = args.get('patientid')
return query.filter(DiabetesModel.patientid == patientid).all()
def resolve_all_liver(self, info, **args):
query = Liver.get_query(info)
patientid = args.get('patientid')
return query.filter(LiverModel.patientid == patientid).all()
def resolve_all_procedures(self, info, **args):
query = Diabetes_Procedures.get_query(info)
conf = args.get('conf')
return query.filter(Diabetes_ProceduresModel.conf == conf).all()
class Query(graphene.ObjectType):
node = graphene.relay.Node.Field()
all_posts = SQLAlchemyConnectionField(PostObject)
all_users = SQLAlchemyConnectionField(UserObject)
all_events= SQLAlchemyConnectionField(EventObject)
post = graphene.relay.Node.Field(PostObject)
event = graphene.relay.Node.Field(EventObject)
class PermissionQueries():
permission = SQLAlchemyConnectionField(Permission_gql)
find_permission = graphene.Field(lambda: Permission_gql,
name=graphene.String())
all_permissions = SQLAlchemyConnectionField(Permission_gql)
def resolve_find_permission(self, args, context, info):
return resolve_find_permission(self, args, context, info)
class Query(graphene.ObjectType):
node = relay.Node.Field()
all_datacenters = SQLAlchemyConnectionField(
DataCenter, sort=DataCenter.sort_argument())
all_routers = SQLAlchemyConnectionField(Router, sort=None)
all_switches = SQLAlchemyConnectionField(Switch, sort=None)
all_computers = SQLAlchemyConnectionField(Computer, sort=None)
all_processes = SQLAlchemyConnectionField(Process, sort=None)
class Query(graphene.ObjectType):
'''
description: This is where the ability to query the
sqlite3 database via GraphQL is defined
'''
node = relay.Node.Field()
all_blocks = SQLAlchemyConnectionField(BlockConnections)
all_channels = SQLAlchemyConnectionField(ChannelConnections)
class Query(graphene.ObjectType):
"""Query objects for GraphQL API."""
node = graphene.relay.Node.Field()
people = graphene.relay.Node.Field(schema_people.People)
peopleList = SQLAlchemyConnectionField(schema_people.People)
planet = graphene.relay.Node.Field(schema_planet.Planet)
planetList = SQLAlchemyConnectionField(schema_planet.Planet)
class Query(graphene.ObjectType):
node = relay.Node.Field()
# Disable sorting over this field
all_Brand = SQLAlchemyConnectionField(BrandConnection)
all_Category = SQLAlchemyConnectionField(CategoryConnection)
all_Platform = SQLAlchemyConnectionField(PlatformConnection)
all_Product = SQLAlchemyConnectionField(ProductConnection,
category_name=graphene.String())
class Query(graphene.ObjectType):
node = relay.Node.Field()
employee = relay.Node.Field(ModelEmployee)
department = relay.Node.Field(ModelDepartment)
employeeList = SQLAlchemyConnectionField(ModelEmployee)
departmentList = SQLAlchemyConnectionField(ModelDepartment)
class ProductsQueries():
products = SQLAlchemyConnectionField(Products_gql)
find_products = graphene.Field(lambda: Products_gql,
name=graphene.String())
all_products = SQLAlchemyConnectionField(Products_gql)
def resolve_find_products(self, args, context, info):
return resolve_find_products(self, args, context, info)
class Query(graphene.ObjectType):
node = relay.Node.Field()
all_food = SQLAlchemyConnectionField(FoodConnections)
all_branded_food = SQLAlchemyConnectionField(BrandedFoodConnections)
all_food_attribute = SQLAlchemyConnectionField(FoodAttributeConnections)
all_food_attribute_type = SQLAlchemyConnectionField(
FoodAttributeTypeConnections)
all_food_category = SQLAlchemyConnectionField(FoodCategoryConnections)
class Query(graphene.ObjectType):
node = graphene.relay.Node.Field()
all_users = SQLAlchemyConnectionField(UserObject)
all_recipes = SQLAlchemyConnectionField(RecipeObject)
recipe = graphene.relay.Node.Field(RecipeObject)
images = SQLAlchemyConnectionField(ImageObject)
image = graphene.relay.Node.Field(ImageObject)
recipe_categories = SQLAlchemyConnectionField(RecipeCategoryObject)
class Query(graphene.ObjectType):
node = relay.Node.Field()
all_employees = SQLAlchemyConnectionField(
Employee.connection, sort = Employee.sort_argument())
all_roles = SQLAlchemyConnectionField(Role.connection)
all_departments = SQLAlchemyConnectionField(Department.connection, sort = None)
class Query(graphene.ObjectType):
"""Nodes which can be queried by this API."""
node = graphene.relay.Node.Field()
user = graphene.relay.Node.Field(user_schema.User)
users = SQLAlchemyConnectionField(user_schema.User)
title = graphene.relay.Node.Field(title_schema.Title)
titles = SQLAlchemyConnectionField(title_schema.Title)
class Query(graphene.ObjectType):
node = relay.Node.Field()
# Supports sorting only over one field
all_employees = SQLAlchemyConnectionField(Employee, sort=graphene.Argument(SortEnumEmployee,
default_value=utils.EnumValue('id_asc', EmployeeModel.id.asc())))
# Add sort over multiple fields, sorting by default over the primary key
all_roles = SQLAlchemyConnectionField(Role)
# Disable sorting over this field
all_departments = SQLAlchemyConnectionField(Department, sort=None)
class Query(ObjectType):
node = Node.Field()
all_persons = SQLAlchemyConnectionField(
PersonConnection,
sort=Argument(SortEnumPerson,
default_value=utils.EnumValue('id_asc',
PersonModel.id.asc())))
all_next_person = SQLAlchemyConnectionField(PersonsConnection, sort=None)
all_email = SQLAlchemyConnectionField(EmailsConnection)
class Query(graphene.ObjectType):
node = relay.Node.Field()
employees = SQLAlchemyConnectionField(Employee)
departments = SQLAlchemyConnectionField(Department)
employee = graphene.Field(Employee, name=graphene.String())
def resolve_employee(self, info, name):
query = Employee.get_query(info)
return query.filter(EmployeeModel.name == name).first()
class Query(graphene.ObjectType):
node = relay.Node.Field()
# Allow only single column sorting
all_students = SQLAlchemyConnectionField(Student.connection,
sort=Student.sort_argument())
# Allows sorting over multiple columns, by default over the primary key
all_roles = SQLAlchemyConnectionField(Role.connection)
# Disable sorting over this field
all_class = SQLAlchemyConnectionField(Class.connection, sort=None)
class Query(graphene.ObjectType):
node = relay.Node.Field()
# Allow only single column sorting
all_employees = SQLAlchemyConnectionField(Employee,
sort=Employee.sort_argument())
# Allows sorting over multiple columns, by default over the primary key
all_roles = SQLAlchemyConnectionField(Role)
# Disable sorting over this field
all_departments = SQLAlchemyConnectionField(Department, sort=None)
class Query(graphene.ObjectType):
node = Node.Field()
posts = SQLAlchemyConnectionField(PostConnection, idea_id=graphene.ID())
ideas = SQLAlchemyConnectionField(Idea)
thematics = graphene.List(Thematic,
identifier=graphene.String(required=True))
# agent_profiles = SQLAlchemyConnectionField(AgentProfile)
def resolve_ideas(self, args, context, info):
connection_type = info.return_type.graphene_type # this is IdeaConnection
model = connection_type._meta.node._meta.model # this is models.Idea
query = get_query(model, context)
discussion_id = context.matchdict['discussion_id']
discussion = models.Discussion.get(discussion_id)
root_idea_id = discussion.root_idea.id
descendants_query = model.get_descendants_query(root_idea_id,
inclusive=False)
query = query.filter(model.id.in_(descendants_query)).filter(
model.hidden == False).order_by(model.id)
# pagination is done after that, no need to do it ourself
return query
def resolve_posts(self, args, context, info):
connection_type = info.return_type.graphene_type # this is PostConnection
model = connection_type._meta.node._meta.model # this is models.PostUnion
discussion_id = context.matchdict['discussion_id']
idea_id = args.get('idea_id', None)
if idea_id is not None:
id_ = int(Node.from_global_id(idea_id)[1])
idea = models.Idea.get(id_)
if idea.discussion_id != discussion_id:
return None
else:
discussion = models.Discussion.get(discussion_id)
idea = discussion.root_idea
query = idea.get_related_posts_query().filter(
model.publication_state ==
models.PublicationStates.PUBLISHED).order_by(
desc(model.creation_date), model.id)
# pagination is done after that, no need to do it ourself
return query
def resolve_thematics(self, args, context, info):
identifier = args.get('identifier', None)
model = Thematic._meta.model
discussion_id = context.matchdict['discussion_id']
query = get_query(
model,
context).filter(model.discussion_id == discussion_id).filter(
model.identifier == identifier).filter(
model.hidden == False).filter(
model.tombstone_date == None).order_by(model.id)
return query
class Query(graphene.ObjectType):
node = relay.Node.Field()
# retrieve all countries
all_countries = SQLAlchemyConnectionField(CountryConnection)
# retrieve single country
country = relay.Node.Field(Country)
# retrieve all history
all_history = SQLAlchemyConnectionField(DayDataConnections)
# retrieve all updates
all_updates = SQLAlchemyConnectionField(DatabaseUpdateConnection)
class Query(graphene.ObjectType):
node = relay.Node.Field()
all_workflows = SQLAlchemyConnectionField(Workflow)
all_analyses = SQLAlchemyConnectionField(Analysis)
all_analysis_runs = SQLAlchemyConnectionField(AnalysisRun)
workflow = graphene.Field(Workflow)
analysis = graphene.Field(Analysis)
analysis_run = graphene.Field(AnalysisRun)
configuration = graphene.Field(Configuration)
class Query(graphene.ObjectType):
node = relay.Node.Field()
user = SQLAlchemyConnectionField(Stations)
find_user = graphene.Field(lambda: Stations, username=graphene.String())
all_users = SQLAlchemyConnectionField(Stations)
def resolve_find_station(self, args, context, info):
query = Stations.get_query(context)
username = args.get('username')
return query.filter(StationModel.username == username).first()
class Query(graphene.ObjectType):
node = relay.Node.Field()
user = SQLAlchemyConnectionField(Users)
find_user = graphene.Field(lambda: Users, username=graphene.String())
all_users = SQLAlchemyConnectionField(Users)
def resolve_find_user(self, info, **kwargs):
query = Users.get_query(info.context)
username = kwargs.get('username')
return query.filter(User.username == username).first()
class Query(graphene.ObjectType):
node = relay.Node.Field()
player = graphene.Field(lambda: Player, name=graphene.String())
all_player = SQLAlchemyConnectionField(Player)
all_score = SQLAlchemyConnectionField(Score, sort=None)
def resolve_player(self, info, name):
query = Player.get_query(info)
result = query.filter(PlayerModel.name == name).first()
return result
class Query(graphene.ObjectType):
node = relay.Node.Field()
# Allows sorting over multiple columns, by default over the primary key
parent_stage = SQLAlchemyConnectionField(ParentStage.connection)
parent_asset = SQLAlchemyConnectionField(ParentAsset.connection)
performance_config = SQLAlchemyConnectionField(
PerformanceConfig.connection)
scene = SQLAlchemyConnectionField(Scene.connection)
performance_communication = SQLAlchemyConnectionField(
PerformanceMQTTConfig.connection)
