class Query(graphene.ObjectType):
node = relay.Node.Field()
all_employees = SQLAlchemyConnectionField(Employee)
all_roles = SQLAlchemyConnectionField(Role)
all_departments = SQLAlchemyConnectionField(Department)
all_pokemon = SQLAlchemyConnectionField(Pokemon)
role = graphene.Field(Role)
class Query(graphene.ObjectType):
node = relay.Node.Field()
all_users = SQLAlchemyConnectionField(Users)
all_activities = SQLAlchemyConnectionField(Activities)
all_contacts = SQLAlchemyConnectionField(Contacts)
# NOT SURE HOW THESE WORK
find_user = graphene.Field(lambda: Users, user_id=graphene.Int())
find_contacts = graphene.Field(lambda: Contacts, contact_id=graphene.Int())
find_activity = graphene.Field(lambda: Activities,
activity_id=graphene.Int())
# NOT SURE HOW THESE WORK
@staticmethod
def resolve_find_user(args, context):
query = Users.get_query(context)
user_id = args.get('user_id')
# you can also use and_ with filter() eg: filter(and_(param1, param2)).first()
return query.filter(UsersModel.user_id == user_id).first()
@staticmethod
def resolve_find_contact(args, context):
print(args)
print(context)
query = Contacts.get_query(context)
contact_id = args.get('contact_id')
return query.filter(ContactsModel.contact_id == contact_id).first()
class Query(graphene.ObjectType):
node = relay.Node.Field()
contact = SQLAlchemyConnectionField(ContactObject)
court = SQLAlchemyConnectionField(ContactObject)
customer = SQLAlchemyConnectionField(ContactObject)
reservation = SQLAlchemyConnectionField(ContactObject)
vendor = SQLAlchemyConnectionField(ContactObject)
class Query(graphene.ObjectType):
node = graphene.relay.Node.Field()
all_Patients = SQLAlchemyConnectionField(PatientsObject)
all_children = SQLAlchemyConnectionField(ChildObject)
all_Doctors = SQLAlchemyConnectionField(DoctorObject)
all_Connections = SQLAlchemyConnectionField(ConnectionObject)
all_Immunizations = SQLAlchemyConnectionField(ImmunizationObject)
class Query(graphene.ObjectType):
node = relay.Node.Field()
search = graphene.List(SearchResult, q=graphene.String())
studies = SQLAlchemyConnectionField(Study)
analyses = SQLAlchemyConnectionField(Analysis)
images = SQLAlchemyConnectionField(Image)
def resolve_search(self, info, **args):
q = args.get("q")
# Get queries
study_q = Study.get_query(info)
analysis_q = Analysis.get_query(info)
studies = study_q.filter(
(StudyModel.name.contains(q))
| (StudyModel.description.contains(q))
| (StudyModel.analyses.any(
AnalysisModel.name.contains(q)
| AnalysisModel.description.contains(q)))).all()
authors = analysis_q.filter(
AnalysisModel.name.contains(q)
| AnalysisModel.description.contains(q)).all()
return studies + authors
class Query(graphene.ObjectType):
node = relay.Node.Field()
# Allows sorting over multiple columns, by default over the primary key
all_employees = SQLAlchemyConnectionField(EmployeeConnection)
# Disable sorting over this field
all_departments = SQLAlchemyConnectionField(DepartmentConnection,
sort=None)
class Query(graphene.ObjectType):
node = graphene.relay.Node.Field()
all_titles = SQLAlchemyConnectionField(TitlesType.connection)
all_salaries = SQLAlchemyConnectionField(SalariesType)
all_employees = SQLAlchemyConnectionField(EmployeesType)
all_departments = SQLAlchemyConnectionField(DepartmentsType)
employeeByName = Field(lambda: graphene.List(EmployeesType),
name=String(required=True),
description="Seleciona os funcionários pelo nome.")
employeeByDept = Field(
lambda: graphene.List(EmployeesType),
dpto_no=String(required=True),
description="Seleciona os funcionários pelo departamento.")
departmentsByNo = Field(
lambda: graphene.List(DepartmentsType),
dept_no=String(required=True),
description="Seleciona os departamentos pelo número.")
def resolve_departmentsByNo(parent, info, dept_no):
query = DepartmentsType.get_query(info)
return query.filter(Departments.dept_no.contains(dept_no)).all()
def resolve_employeeByName(parent, info, name):
filters = (or_(Employees.first_name.contains(name),
Employees.last_name.contains(name)))
query = EmployeesType.get_query(info)
return query.filter(filters).all()
def resolve_employeeByDept(parent, info, dpto_no):
query = EmployeesType.get_query(info)
return query.filter(DeptEmp.dept_no == dpto_no).\
filter(DeptEmp.emp_no == Employees.emp_no).limit(100).all()
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)
# 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_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 = 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 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_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):
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):
'''
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 = 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()
employee = relay.Node.Field(ModelEmployee)
department = relay.Node.Field(ModelDepartment)
employeeList = SQLAlchemyConnectionField(ModelEmployee)
departmentList = SQLAlchemyConnectionField(ModelDepartment)
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 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_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(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()
# 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):
"""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()
# 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()
# 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(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 = 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
