def bind_mutation_type_to_resolvers():
mutation = MutationType()
mutation.set_field("createPatient", PatientsMutations.create)
mutation.set_field("updatePatient", PatientsMutations.update)
mutation.set_field("deletePatient", PatientsMutations.soft_delete)
mutation.set_field("activatePatient", PatientsMutations.activate)
mutation.set_field("deactivatePatient", PatientsMutations.deactivate)
return mutation
def setUp(self):
super().setUp()
mutation = MutationType()
mutation.set_field('refreshToken', resolve_refresh)
mutation.set_field('verifyToken', resolve_verify)
mutation.set_field('tokenAuth', resolve_token_auth)
mutation.set_field('revokeToken', resolve_revoke)
self.client.schema(self.type_defs, mutation, GenericScalar)
def bind_mutation_type_to_resolvers():
mutation = MutationType()
mutation.set_field("createDiagnosis", DiagnosisMutations.create)
mutation.set_field("updateDiagnosis", DiagnosisMutations.update)
mutation.set_field("deleteDiagnosis", DiagnosisMutations.soft_delete)
mutation.set_field("unarchiveDiagnosis", DiagnosisMutations.activate)
mutation.set_field("archiveDiagnosis", DiagnosisMutations.deactivate)
return mutation
def test_executing_mutation_using_input_type():
type_defs = """
type Query {
_: String
}
input StaffInput {
name: String
}
type Staff {
name: String
}
type Mutation {
addStaff(data: StaffInput): Staff
}
"""
mutation = MutationType()
@mutation.field("addStaff")
def resolve_add_staff(*_, data): # pylint: disable=unused-variable
assert data == {"name": "Bob"}
return data
schema = make_executable_schema(type_defs, mutation)
result = graphql_sync(
schema, 'mutation { addStaff(data: { name: "Bob" }) { name } }')
assert result.errors is None
assert result.data == {"addStaff": {"name": "Bob"}}
def test_executing_mutation_takes_scalar_arg_and_returns_type():
type_defs = """
type Query {
_: String
}
type Staff {
name: String
}
type Mutation {
addStaff(name: String): Staff
}
"""
mutation = MutationType()
@mutation.field("addStaff")
def resolve_add_staff(*_, name): # pylint: disable=unused-variable
assert name == "Bob"
return {"name": name}
schema = make_executable_schema(type_defs, mutation)
result = graphql_sync(schema,
'mutation { addStaff(name: "Bob") { name } }')
assert result.errors is None
assert result.data == {"addStaff": {"name": "Bob"}}
def test_executing_mutation_takes_scalar_args_and_returns_scalar_sum():
type_defs = """
type Query {
_: String
}
type Mutation {
sum(a: Int, b: Int): Int
}
"""
mutation = MutationType()
mutation.set_field("sum", lambda *_, a, b: a + b)
schema = make_executable_schema(type_defs, mutation)
result = graphql_sync(schema, "mutation { sum(a: 1, b: 2) }")
assert result.errors is None
assert result.data == {"sum": 3}
async def test_date():
schema = gql("""
scalar Date
scalar DateTime
scalar JSON
type Query {
event: Event!
}
type Mutation {
createEvent(date: Date!): Boolean!
}
type Event {
date: Date!
}
""")
query_event = """
query {
event {
date
}
}
"""
mutation_event = """
mutation createEvent($date: Date!) {
createEvent(date: $date)
}
"""
query_type = QueryType()
mutation_type = MutationType()
@mutation_type.field("createEvent")
async def createEvent(obj, parent, **kwargs):
return True
@query_type.field("event")
async def event(obj, parent, **kwargs):
return {"date": datetime.now()}
schema = make_executable_schema(schema, query_type, base_scalars_resolvers,
snake_case_fallback_resolvers)
await graphql(schema=schema, data={"query": query_event})
await graphql(
schema=schema,
data={
"query": mutation_event,
"variables": {
"date": "1789-07-07T12:00:00+02:00"
}, # ISO 8601 datetime string
},
)
from ariadne.constants import PLAYGROUND_HTML
from flask import Flask, request, jsonify
import resolvers as r
from ariadne import MutationType
app = Flask(__name__)
type_defs = load_schema_from_path('schema.graphql')
query = QueryType()
student = ObjectType('Student')
queryClass = QueryType()
classs = ObjectType('Classs')
mutation = MutationType()
mutation.set_field('create_Student', r.resolver_createStudent)
mutationClass = MutationType()
mutationClass.set_field('create_Class', r.resolver_createClass)
mutationAddStudentToClass = MutationType()
mutationAddStudentToClass.set_field('add_Student_to_Class',
r.resolver_add_student_to_class)
query.set_field('student_with_id', r.student_with_id)
queryClass.set_field('class_with_id', r.class_with_id)
schema = make_executable_schema(type_defs, [
student, mutation, query, classs, mutationClass, queryClass,
mutationAddStudentToClass
from flask import Flask, escape, request
from ariadne import QueryType, ObjectType, graphql_sync, make_executable_schema, MutationType, load_schema_from_path
from ariadne.constants import PLAYGROUND_HTML
from flask import Flask, request, jsonify
from ariadne import gql
import resolvers as r
type_defs = load_schema_from_path('schema.py')
query = QueryType()
query.set_field('students', r.get_student)
query.set_field('classes',r.get_class)
mutation = MutationType()
mutation.set_field('create_student', r.create_student)
mutation.set_field('create_class', r.create_class)
mutation.set_field('update_class', r.update_class)
# @query.field("hello")
# def resolve_hello(_, info):
# request = info.context
# user_agent = request.headers.get("User-Agent", "Guest")
# return "Hello, %s!" % user_agent
schema = make_executable_schema(type_defs, query,mutation)
app = Flask(__name__)
@app.route("/graphql", methods=["GET"])
def graphql_playgroud():
from ariadne import MutationType
from .auth import resolve_register_user, \
resolve_login
from .role import resolve_add_permission_to_role, \
resolve_create_new_role
from .user import resolve_update_email, \
resolve_add_blacklist_to_user, \
resolve_add_whitelist_to_user, \
resolve_delete_blacklist_from_user, \
resolve_delete_whitelist_from_user, \
resolve_add_role_to_user, \
resolve_update_users_active_status
from .permission import resolve_create_new_permission
mutation = MutationType()
mutation.set_field("registerUser", resolve_register_user)
mutation.set_field("login", resolve_login)
mutation.set_field("addPermissionToRole", resolve_add_permission_to_role)
mutation.set_field("addRoleToUser", resolve_add_role_to_user)
mutation.set_field("createNewRole", resolve_create_new_role)
mutation.set_field("createNewPermission", resolve_create_new_permission)
mutation.set_field("updateEmail", resolve_update_email)
mutation.set_field("addWhitelistToUser", resolve_add_whitelist_to_user)
mutation.set_field("addBlacklistToUser", resolve_add_blacklist_to_user)
mutation.set_field("deleteBlacklistFromUser",
resolve_delete_blacklist_from_user)
mutation.set_field("deleteWhitelistFromUser",
resolve_delete_whitelist_from_user)
def get_schema(tmdb, database):
# Setup queries
query = QueryType()
register_query_resolvers(query, tmdb)
# Setup mutations
mutation = MutationType()
resolve_favorite, resolve_rating, resolve_number_of_watched_episodes, resolve_watch_status, resolve_country, resolve_language = register_mutation_resolvers(
mutation, tmdb, database)
# Register aliases for mutations
favorite = MutationType()
favorite.set_field("favorite", resolve_favorite)
rating = MutationType()
rating.set_field("rating", resolve_rating)
number_of_watched_episodes = MutationType()
# TODO: Alias
number_of_watched_episodes.set_field("numberOfWatchedEpisodes",
resolve_number_of_watched_episodes)
watch_status = MutationType()
# TODO: Alias
watch_status.set_field("watchStatus", resolve_watch_status)
country = MutationType()
country.set_field("country", resolve_country)
language = MutationType()
language.set_field("language", resolve_language)
# Register aliases for objects
movie = ObjectType("Movie")
movie.set_alias("ratingAverage", "rating_average")
movie.set_alias("ratingCount", "rating_count")
movie.set_alias("releaseInitial", "release_date")
movie.set_alias("backdropPath", "backdrop_path")
movie.set_alias("posterPath", "poster_path")
movie.set_alias("tmdbUrl", "tmdb_url")
movie.set_alias("watchStatus", "watch_status")
movie.set_alias("ratingUser", "rating_user")
tv = ObjectType("TV")
tv.set_alias("ratingAverage", "rating_average")
tv.set_alias("ratingCount", "rating_count")
tv.set_alias("releaseInitial", "first_air_date")
tv.set_alias("releaseFinal", "last_air_date")
tv.set_alias("backdropPath", "backdrop_path")
tv.set_alias("posterPath", "poster_path")
tv.set_alias("numberOfEpisodes", "number_of_episodes")
tv.set_alias("numberOfSeasons", "number_of_seasons")
tv.set_alias("tmdbUrl", "tmdb_url")
tv.set_alias("watchStatus", "watch_status")
tv.set_alias("ratingUser", "rating_user")
tv.set_alias("directors", "creators")
season = ObjectType("Season")
season.set_alias("tvCode", "tv_code")
season.set_alias("seasonNumber", "season_number")
season.set_alias("posterPath", "poster_path")
season.set_alias("numberOfEpisodes", "number_of_episodes")
season.set_alias("airDate", "air_date")
season.set_alias("numberOfWatchedEpisodes", "number_of_watched_episodes")
episode = ObjectType("Episode")
episode.set_alias("episodeNumber", "episode_number")
episode.set_alias("seasonNumber", "season_number")
episode.set_alias("airDate", "air_date")
episode.set_alias("ratingAverage", "rating_average")
episode.set_alias("stillPath", "still_path")
media_page = ObjectType("MediaPage")
media_page.set_alias("totalPages", "total_pages")
director = ObjectType("Director")
director.set_alias("imagePath", "image_path")
cast = ObjectType("Cast")
cast.set_alias("imagePath", "image_path")
searchResult = UnionType("Media")
# Read the GraphQL schema
type_defs = load_schema_from_path(
os.path.join(os.path.dirname(__file__), "api.graphql"))
# Connect the schema to the resolvers
return make_executable_schema(type_defs, query, mutation, rating,
watch_status, movie, tv, season, episode,
media_page, director, cast,
number_of_watched_episodes, favorite)
from ariadne import (
QueryType,
MutationType
)
from crud.permission import (
add_new_permission,
update_permissions_by_id,
get_all_permissions_count_in_db,
get_all_permissions_in_db,
get_permission_by_id
)
permission_query = QueryType()
permission_mutation = MutationType()
@permission_mutation.field("create_permission")
async def resolve_create_permission(
_,
info,
current_user=None,
**kwargs
):
details = kwargs["details"]
added_permission = await add_new_permission(details)
return {
"permission": dict(added_permission)
}
@permission_mutation.field("update_permission")
}
type User {
id : ID!
status: Int!
username : String!
password : String!
email : String!
phone : String!
}
"""
user_query = QueryType()
user_mutation = MutationType()
# QUERY
@user_query.field('currentUser')
async def get_current_user_by_id(ojb, info):
request = info.context['request']
if request.user.is_authenticated:
try:
user = await User.get(pk=request.user.user_id)
except DoesNotExist:
return {
'error': 'user không tồn tại',
}
return {'user': user}
import os
import os.path
import pathlib
import asyncio
from graphql import parse
from ariadne import MutationType, SubscriptionType, load_schema_from_path
from nomine.models import Namer
from nomine.models.folder_entry import FolderEntry, FILE_TYPE, DIRECTORY_TYPE
mutation = MutationType()
subscription = SubscriptionType()
bindables = [mutation, subscription]
schema_file = load_schema_from_path(
pathlib.Path(__file__).parent.joinpath("schema.graphql").absolute())
schema = parse(schema_file)
queue = asyncio.Queue()
def get_or_create_entry(session, folder_id, dir_entry):
if dir_entry.is_file():
entry_type = FILE_TYPE
elif dir_entry.is_dir():
entry_type = DIRECTORY_TYPE
else:
return
existing = (session.query(FolderEntry).filter(
FolderEntry.path == dir_entry.path).first())
if existing:
def start(self):
query = QueryType()
query.set_field('echo', self._echo_resolver())
mutation = MutationType()
mutation.set_field('createTable', self._create_table_resolver())
mutation.set_field('addPlayer', self._add_player_resolver())
mutation.set_field('takeAction', self._take_action_resolver())
mutation.set_field('startGame', self._start_game_resolver())
mutation.set_field('stopGame', self._stop_game_resolver())
mutation.set_field('reset', self._reset_resolver())
subscription = SubscriptionType()
subscription.set_field('subscribe', self._subscribe_resolver())
subscription.set_source('subscribe', self._subscribe_generator())
resolvers = [query, mutation, subscription]
executable_schema = make_executable_schema(self._schema_str, resolvers)
self._app = GraphQL(executable_schema, debug=True)
from ariadne import load_schema_from_path, ObjectType, QueryType, MutationType
from features.Composers.composer import resolve_composer, create_composer, update_composer, get_composers
from features.Songs.song import resolve_songs
from features.Songs.songTypes import songQueries
composerQueries = QueryType()
composerMutations = MutationType()
composerTypes = load_schema_from_path("./features/Composers/composer.gql")
composerObjectType = ObjectType('FBComposer')
composerObjectType.set_field("songs", resolve_songs)
composerQueries.set_field('getComposer', resolve_composer)
songQueries.set_field('getComposers', get_composers)
composerMutations.set_field('createComposer', create_composer)
composerMutations.set_field('updateComposer', update_composer)
from ariadne import QueryType, graphql_sync, make_executable_schema, MutationType, ObjectType
from ariadne.constants import PLAYGROUND_HTML
from flask import Flask, request, jsonify, Response
# from schema import schema
students = {}
classes = {}
studentID = 200
classID = 300
query = QueryType()
mut = MutationType()
student = ObjectType("Student")
classs = ObjectType("Class")
type_defs = """
type Query {
hello: String!
students(id:Int!): Student!
classes(id: Int!): Class!
}
type Mutation {
createStudent(name: String!): Student!
createClass(name: String!): Class!
addStudent(studentID: Int!, classID: Int!): Class!
}
type Student {
id: Int!
name: String!
}
type Class {
id: Int!
from os.path import dirname, join
from ariadne import (MutationType, QueryType,
make_executable_schema, ObjectType,
snake_case_fallback_resolvers, load_schema_from_path)
from .resolvers import resolve_create_review, resolve_get_reviews
from ariadne_extensions import federation
# type_defs = load_schema_from_path("./review/schema.graphql")
query_type = QueryType()
mutation = MutationType()
manager = federation.FederatedManager(
schema_sdl_file=join(dirname(__file__), 'schema.graphql'),
query=query_type)
user_type = federation.FederatedObjectType('User')
product_type = federation.FederatedObjectType('Product')
review_type = ObjectType('Review')
query_type.set_field("reviews", resolve_get_reviews)
mutation.set_field("createReview", resolve_create_review)
manager.add_types(user_type, product_type, review_type, mutation, query_type)
manager.add_types(snake_case_fallback_resolvers)
schema = manager.get_schema()
# schema = make_executable_schema(type_defs, [query, mutation])
from ariadne import load_schema_from_path, ObjectType, QueryType, MutationType
from features.Composers.composer import resolve_composer
from features.Songs.song import resolve_song, create_song, update_song, get_songs
songQueries = QueryType()
songMutations = MutationType()
songTypes = load_schema_from_path("./features/Songs/song.gql")
songObjectType = ObjectType('FBSong')
songObjectType.set_field("composer", resolve_composer)
songQueries.set_field('getSong', resolve_song)
songQueries.set_field('getSongs', get_songs)
songMutations.set_field('createSong', create_song)
songMutations.set_field('updateSong', update_song)
from ariadne import (MutationType, QueryType)
from uuid import uuid4
from crud.author import (create_author, get_all_authors, get_all_authors_count,
find_author_by_id, find_author_by_email)
from crud.user import (create_new_user)
author_mutation = MutationType()
author_query = QueryType()
@author_mutation.field("create_author")
async def resolve_create_author(_, info, current_user=None, **kwargs):
details = kwargs["details"]
resp = {"author": None, "error": "Author was not created"}
author_id = await create_new_user(
obj_in={
"user_name": details["email"],
"group": "author",
"password": details["password"]
})
author = await create_author(values={
"id": author_id,
"email": details["email"],
"phone": details["phone"]
})
resp.update(author=dict(author), error="" if author else resp["error"])
return resp
@author_query.field("authors")
async def resolve_authors(_, info, current_user=None, **kwargs):
# GraphQL
schema_path = (
pathlib.Path(__file__).parent.absolute().joinpath("graphql", "schema.graphql")
)
type_defs = load_schema_from_path("saltapi/graphql/schema.graphql")
datetime_scalar = ScalarType("Datetime")
datetime_scalar.set_serializer(scalars.serialize_datetime)
datetime_scalar.set_value_parser(scalars.parse_datetime)
proposal_code_scalar = ScalarType("ProposalCode")
proposal_code_scalar.set_serializer(scalars.serialize_proposal_code)
proposal_code_scalar.set_value_parser(scalars.parse_proposal_code)
mutation = MutationType()
mutation.set_field("submitProposal", resolvers.resolve_submit_proposal)
subscription = SubscriptionType()
subscription.set_field("submissionProgress", resolvers.resolve_submission_progress)
subscription.set_source("submissionProgress", resolvers.submission_progress_generator)
schema = make_executable_schema(
type_defs,
datetime_scalar,
proposal_code_scalar,
mutation,
subscription,
directives={"permittedFor": PermittedForDirective},
)
from ariadne.asgi import GraphQL
from ariadne import (load_schema_from_path,
make_executable_schema, MutationType, QueryType)
from ariadne.contrib.federation import (
FederatedObjectType, make_federated_schema)
from . import resolvers
# load schema file
type_defs = load_schema_from_path("riderequests/schema.graphql")
mutation = MutationType()
query = QueryType()
riderequest = FederatedObjectType("RideRequest")
mutation.set_field("requestRide", resolvers.resolve_request_ride)
query.set_field("allRideRequests", resolvers.resolve_all_ride_request)
query.set_field("request", resolvers.resolve_ride_request)
riderequest.set_field("passenger", resolvers.resolve_riderequest_passenger)
riderequest.set_field("ride", resolvers.resolve_riderequest_ride)
# bind schema(queries and mutation) to the respective resolvers
schema = make_federated_schema(type_defs, [riderequest, query, mutation])
application = GraphQL(schema, debug=True)
from secrets import token_bytes, token_hex
from time import time
from ariadne import MutationType
from context import ARGON
from classes.user import User
MUTATION = MutationType()
@MUTATION.field("createUser")
async def r_create_user(*_, role: str = "USER") -> User:
"""create a new user and save to db"""
# create api object
password = token_hex(10)
# save to db
user = await User.create(
key=token_bytes(32),
username=token_hex(10),
password_hash=ARGON.hash(password),
role=role,
created=time(),
)
# set password field on user to pass them their password 1 time
user.password = password
# return api object to resolver
return user
def mutations():
mutation = MutationType()
mutation.set_field("upload", resolve_upload)
return mutation
"""Contains mutation resolvers."""
from ariadne import MutationType
from nautilus import utils
from nautilus.validators import validate_profileinput, validate_discord
mutation_type = MutationType()
@mutation_type.field("createProfile")
def resolve_create_profile(*_, discord, profile):
"""mutation createProfile"""
utils.logger.debug(f"createProfile | discord={discord}")
errors = []
if error := utils.errors.check_for([utils.errors.exists], discord):
errors.append(error)
profile, validation_errors = validate_profileinput(profile)
if not validate_discord(discord):
validation_errors.append({"msg": "Discord ID must be a valid snowflake.", "type": "value_error"})
if validation_errors:
errors += validation_errors
if not errors:
return utils.dbh.insert_profile(discord, profile)
return {"status": False, "errors": errors}
@mutation_type.field("updateProfile")
def resolve_update_profile(*_, discord, profile):
"""mutation updateProfile"""
utils.logger.debug(f"updateProfile | discord={discord}")
errors = []
from ariadne import MutationType
from djangocities.pages import mutation as page_mutations
from djangocities.sites import mutation as site_mutations
from djangocities.user import mutation as user_mutations
mutation = MutationType()
# User Mutations
mutation.set_field("login", user_mutations.resolve_login)
mutation.set_field("register", user_mutations.resolve_register)
# Page Mutations
mutation.set_field("createPage", page_mutations.resolve_create_page)
mutation.set_field("updatePage", page_mutations.resolve_update_page)
# Site Mutations
mutation.set_field("createSite", site_mutations.resolve_create_site)
mutation.set_field("updateSite", site_mutations.resolve_update_site)
# pylint: disable=import-error
from backend.api.resolvers import alert, cache, event, me, user, resource
from ariadne import MutationType
MUTATION = MutationType()
MUTATION.set_field('setAlert', alert.resolve_set_alert)
MUTATION.set_field('invalidateCache', cache.resolve_invalidate_cache)
MUTATION.set_field('updateEvent', event.resolve_update_event)
MUTATION.set_field('createEvent', event.resolve_create_event)
MUTATION.set_field('solveEvent', event.resolve_solve_event)
MUTATION.set_field('addEventComment', event.resolve_add_event_comment)
MUTATION.set_field('updateEventEvidence', event.resolve_update_event_evidence)
MUTATION.set_field('downloadEventFile', event.resolve_download_event_file)
MUTATION.set_field('removeEventEvidence', event.resolve_remove_event_evidence)
MUTATION.set_field('signIn', me.resolve_sign_in)
MUTATION.set_field('updateAccessToken', me.resolve_update_access_token)
MUTATION.set_field('invalidateAccessToken', me.resolve_invalidate_access_token)
MUTATION.set_field('acceptLegal', me.resolve_accept_legal)
MUTATION.set_field('addUser', user.resolve_add_user)
MUTATION.set_field('grantUserAccess', user.resolve_grant_user_access)
MUTATION.set_field('removeUserAccess', user.resolve_remove_user_access)
MUTATION.set_field('editUser', user.resolve_edit_user)
MUTATION.set_field('addRepositories', resource.resolve_add_repositories)
MUTATION.set_field('addEnvironments', resource.resolve_add_environments)
from ariadne import graphql_sync, make_executable_schema, load_schema_from_path, ObjectType, QueryType, MutationType
from ariadne.constants import PLAYGROUND_HTML
from flask import Flask, request, jsonify
import resolvers as r
app = Flask(__name__)
type_defs = load_schema_from_path('schema.graphql')
mutation_query_graphql = MutationType()
mutation_query_graphql.set_field('add_student', r.resolve_student_create)
mutation_query_graphql.set_field('add_class', r.resolve_class_create)
mutation_query_graphql.set_field('add_student_to_class', r.resolve_add_student_to_class)
query_graphql = QueryType()
student_type = ObjectType('Student')
class_type = ObjectType('Class')
query_graphql.set_field('student_by_id', r.resolve_student_by_id)
query_graphql.set_field('class_by_id', r.resolve_class_by_id)
query_graphql.set_field('students', r.resolve_students)
query_graphql.set_field('classes', r.resolve_classes)
class_type.set_field('students', r.resolve_students_in_classes)
schema = make_executable_schema(type_defs, [student_type, class_type, query_graphql, mutation_query_graphql])
@app.route('/graphql', methods=['GET'])
def playground():
from ariadne import MutationType
resolver_mutation = MutationType()
from ..models.panel import Panel, PanelSize
@resolver_mutation.field('addPanel')
def resolve_addpanel(*_,
embed_url: str,
size: PanelSize = PanelSize.MEDIUM) -> bool:
try:
# size.value since Django only accepts the values of the enums
p = Panel(embed_url=embed_url, size=size.value)
p.save()
except Exception as e:
print('Error in addPanel mutation: ' + str(e))
return False
return True
@resolver_mutation.field('removePanel')
def resolve_removepanel(*_, id: int) -> bool:
qset = Panel.objects.filter(id=id)
assert (len(qset) <= 1
) # make sure that the id acquired is unique to one panel
if len(qset) == 0:
from django.db import transaction
from django.http import HttpRequest
from django.utils.http import urlsafe_base64_decode
from django_countries import countries
from django_countries.fields import Country
from hexa.core.graphql import result_page
from hexa.core.templatetags.colors import hash_color
from hexa.user_management.countries import get_who_info
from hexa.user_management.models import Membership, Organization, Team, User
identity_type_defs = load_schema_from_path(
f"{pathlib.Path(__file__).parent.resolve()}/graphql/schema.graphql")
identity_query = QueryType()
identity_mutations = MutationType()
@identity_query.field("me")
def resolve_me(_, info):
request = info.context["request"]
principal = request.user
return {
"user":
principal if principal.is_authenticated else None,
"authorized_actions":
filter(
bool,
[
"CREATE_TEAM"
