import datetime
import json
from ariadne import MutationType, QueryType, convert_kwargs_to_snake_case
from ariadne_token_auth.decorators import login_required
from django.contrib.auth import get_user_model
from habits import models as habit_models
from utils.general import get_user
from utils.handlers.errors import ErrorContainer
CUSTOM_USER_MODEL = get_user_model()
query = QueryType()
mutation = MutationType()
@mutation.field("createDailyHabit")
@convert_kwargs_to_snake_case
@login_required
def create_daily_habit(_, info, data):
error_container = ErrorContainer("date_from", "date_to", "name")
status = False
habit = None
user = get_user(info)
name = data.get("name")
description = data.get("description")
date_from = data.get("date_from")
date_to = data.get("date_to")
vault = data.get("vault")
today = datetime.date.today()
if date_from < today:
error_container.update_with_error(
from ariadne.asgi import GraphQL
# This is our schema
type_defs = gql("""
type Book {
title: String!
year: Int!
age: Int!
}
type Query {
books: [Book!]!
}
""")
query = QueryType() # our Query type
@query.field("books") # Query.books
def resolve_books(*_):
return [
{
"title": "The Color of Magic",
"year": 1983
},
{
"title": "The Light Fantastic",
"year": 1986
},
{
"title": "Equal Rites",
from ariadne_token_auth.api import resolvers
from ariadne_token_auth.decorators import login_required
from django.contrib.auth import get_user_model, password_validation
from django.core.exceptions import ValidationError
from utils.general import get_user
from utils.handlers.errors import ErrorContainer
CUSTOM_USER = get_user_model()
auth_type_definitions = [resolvers.type_defs]
auth_mutation = MutationType()
auth_mutation.set_field("getAuthToken", resolvers.get_auth_token)
auth_mutation.set_field("deleteAuthToken", resolvers.delete_auth_token)
accounts_query = QueryType()
accounts_mutation = MutationType()
@accounts_query.field("userProfileDetails")
@convert_kwargs_to_snake_case
def user_profile_details(*_, username_slug, **kwargs):
""" returns basic user data about the user having the specified `username_slug` """
error = None
try:
username = CUSTOM_USER.objects.get(username_slug=username_slug).username
except CUSTOM_USER.DoesNotExist:
username = None
error = "The requested user does not exist"
return {"username": username, "error": error}
from ariadne import ObjectType, QueryType, MutationType
from models.comment import CommentBase
from models.Post.PostUpdates import PostUpdates
from models.User.UserUpdates import UserUpdates
from middlewares.authentication import authentication_required
comment_query = QueryType()
comment_mutation = MutationType()
@comment_query.field("comment")
@authentication_required
async def resolve_comment(_, info, **kwargs):
post_id = kwargs.get("post_id", None)
user_id = kwargs.get("user_id", None)
comment_id = kwargs.get("comment_id", None)
comment = None
if comment_id:
comment = await CommentBase.find_by_id(comment_id)
elif post_id:
comment = await CommentBase.find_by_post_id(post_id)
elif user_id:
comment = await CommentBase.find_by_user_id(user_id)
return comment
@comment_mutation.field("create_comment")
@authentication_required
async def resolve_create_comment(_, info, **kwargs):
user_id = kwargs.get("current_user_id", None)
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_user, resolve_get_users
from ariadne_extensions import federation
# type_defs = load_schema_from_path("./account/schema.graphql")
query_type = QueryType()
mutation = MutationType()
manager = federation.FederatedManager(schema_sdl_file=join(
dirname(__file__), 'schema.graphql'),
query=query_type)
user_type = ObjectType("User")
query_type.set_field("users", resolve_get_users)
mutation.set_field("createUser", resolve_create_user)
manager.add_types(user_type, mutation, query_type)
manager.add_types(snake_case_fallback_resolvers)
schema = manager.get_schema()
# schema = make_executable_schema(type_defs, [query, mutation])
def resolvers():
query = QueryType()
query.set_field("hello", resolve_hello)
query.set_field("status", resolve_status)
query.set_field("testContext", resolve_test_context)
query.set_field("testRoot", resolve_test_root)
query.set_field("testError", resolve_error)
return query
from ariadne import ObjectType, QueryType, MutationType
import datetime
import utils.model_utils.post as PostUtils
from models.comment import CommentBase
from models.Post.PostBase import PostResponse, PostBase
from models.Post.PostUpdates import PostUpdates
from models.User.UserInDB import UserInDB
from models.User.UserUpdates import UserUpdates
from middlewares.authentication import authentication_required
post_query = QueryType()
post_mutation = MutationType()
Post = ObjectType("Post")
@post_query.field("post")
@authentication_required
async def resolve_post(_, info, **kwargs):
request = info.context["request"]
current_user_id = kwargs.get("current_user_id", None)
user_id = kwargs.get("user_id", None)
post_id = kwargs.get("post_id", None)
post = None
is_auth = request.user.is_authenticated and current_user_id == user_id
if post_id:
post = [await PostUtils.find_posts_by_id(post_id, is_auth)]
elif user_id:
post = await PostUtils.find_posts_by_user_id(user_id, is_auth)
return post
from flask import Flask, request, jsonify
from ariadne import QueryType, gql, load_schema_from_path, make_executable_schema, graphql_sync
from ariadne.asgi import GraphQL
from ariadne.constants import PLAYGROUND_HTML
from resolvers import hello, bye
query = QueryType()
type_defs = load_schema_from_path('schema.graphql')
query.set_field('hello', hello)
query.set_field('bye', bye)
schema = make_executable_schema(type_defs, query)
app = Flask(__name__)
@app.route("/graphql", methods=["GET"])
def graphql_playgroud():
return PLAYGROUND_HTML, 200
@app.route("/graphql", methods=["POST"])
def graphql_server():
# GraphQL queries are always sent as POST
data = request.get_json()
# Note: Passing the request to the context is optional.
# In Flask, the current request is always accessible as flask.request
success, result = graphql_sync(
schema,
data,
File,
Fileset,
FilesetRole,
GeographicCoverageAnalysis,
Project,
ProjectPermission,
)
from hexa.plugins.connector_accessmod.queue import validate_fileset_queue
from hexa.plugins.connector_s3.api import generate_download_url, generate_upload_url
from hexa.plugins.connector_s3.models import Bucket
from hexa.user_management.countries import get_who_info
from hexa.user_management.models import Team, User
accessmod_type_defs = load_schema_from_path(
f"{pathlib.Path(__file__).parent.resolve()}/graphql/schema.graphql")
accessmod_query = QueryType()
accessmod_mutations = MutationType()
# Projects
project_object = ObjectType("AccessmodProject")
project_order_by = EnumType(
"AccessmodProjectOrder",
{
"UPDATED_AT_DESC": "-updated_at",
"UPDATED_AT_ASC": "updated_at",
"NAME_DESC": "-name",
"NAME_ASC": "name",
},
)
def test_can_be_used_to_implement_auth_example():
roles = ["UNKNOWN", "USER", "REVIEWER", "ADMIN"]
class User:
def __init__(self, token: str):
self.token_index = roles.index(token)
def has_role(self, role: str):
role_index = roles.index(role)
return self.token_index >= role_index >= 0
def _get_user(token: str):
return User(token)
class AuthDirective(SchemaDirectiveVisitor):
def visit_object(self, object_: GraphQLObjectType):
self.ensure_fields_wrapped(object_)
setattr(object_, "_required_auth_role", self.args["requires"])
def visit_field_definition(
self,
field: GraphQLField,
object_type: Union[GraphQLObjectType, GraphQLInterfaceType],
) -> GraphQLField:
self.ensure_fields_wrapped(object_type)
setattr(field, "_required_auth_role", self.args["requires"])
def ensure_fields_wrapped(self, object_type: GraphQLObjectType):
if hasattr(object_type, "_auth_fields_wrapped"):
return
setattr(object_type, "_auth_fields_wrapped", True)
def _resolver(_, info, *, f=None, o=None):
required_role = getattr(f, "_required_auth_role", None) or getattr(
o, "_required_auth_role", None
)
if not required_role:
return original_resolver(_, info)
context = info.context
user = _get_user(context["headers"]["authToken"])
if not user.has_role(required_role):
raise Exception("not authorized")
return original_resolver(_, info)
for _, field in object_type.fields.items():
original_resolver = field.resolve or default_field_resolver
field.resolve = partial(_resolver, f=field, o=object_type)
type_defs = """
directive @auth(
requires: Role = ADMIN,
) on OBJECT | FIELD_DEFINITION
enum Role {
ADMIN
REVIEWER
USER
UNKNOWN
}
type User @auth(requires: USER) {
name: String
banned: Boolean @auth(requires: ADMIN)
canPost: Boolean @auth(requires: REVIEWER)
}
type Query {
users: [User]
}
"""
query = QueryType()
@query.field("users")
def _users_resolver(_, __):
return [{"banned": True, "canPost": False, "name": "Ben"}]
schema = make_executable_schema(
type_defs, [query], directives={"auth": AuthDirective}
)
def exec_with_role(role: str):
return graphql_sync(
schema,
"""
query {
users {
name
banned
canPost
}
}
""",
context_value={"headers": {"authToken": role}},
)
def _check_results(result, *, data=None, errors=None):
if errors and result.errors:
assert len(errors) == len(result.errors)
for e in result.errors:
assert e.message == "not authorized"
assert e.path[-1] in errors
assert result.data == data
_check_results(
exec_with_role("UNKNOWN"),
data={"users": [{"name": None, "banned": None, "canPost": None}]},
errors=("name", "banned", "canPost"),
)
_check_results(
exec_with_role("USER"),
data={"users": [{"name": "Ben", "banned": None, "canPost": None}]},
errors=("banned", "canPost"),
)
_check_results(
exec_with_role("REVIEWER"),
data={"users": [{"name": "Ben", "banned": None, "canPost": False}]},
errors=("banned",),
)
_check_results(
exec_with_role("ADMIN"),
data={"users": [{"name": "Ben", "banned": True, "canPost": False}]},
)
def test_can_implement_unique_id_directive():
type_defs = """
directive @uniqueID(name: String, from: [String]) on OBJECT
type Query {
people: [Person]
locations: [Location]
}
type Person @uniqueID(name: "uid", from: ["personID"]) {
personID: Int
name: String
}
type Location @uniqueID(name: "uid", from: ["locationID"]) {
locationID: Int
address: String
}
"""
class UniqueIDDirective(SchemaDirectiveVisitor):
def visit_object(self, object_: GraphQLObjectType) -> GraphQLObjectType:
name, from_ = self.args.values()
def _field_resolver(field, _):
hash_ = hashlib.sha1(object_.name.encode())
for field_name in from_:
hash_.update(str(field[field_name]).encode())
return hash_.hexdigest()
object_.fields[name] = GraphQLField(
description="Unique ID", type_=GraphQLID, resolve=_field_resolver
)
query = QueryType()
query.set_field("people", lambda *_: [{"personID": 1, "name": "Ben"}])
query.set_field(
"locations", lambda *_: [{"locationID": 1, "address": "140 10th St"}]
)
schema = make_executable_schema(
type_defs, [query], directives={"uniqueID": UniqueIDDirective}
)
result = graphql_sync(
schema,
"""
{
people {
uid
personID
name
}
locations {
uid
locationID
address
}
}
""",
)
assert result.errors is None
assert result.data == {
"locations": [
{
"uid": "c31b71e6e23a7ae527f94341da333590dd7cba96",
"locationID": 1,
"address": "140 10th St",
}
],
"people": [
{
"uid": "580a207c8e94f03b93a2b01217c3cc218490571a",
"personID": 1,
"name": "Ben",
}
],
}
""")
student_id = 1238125
student_list = {}
def resolve_students(_, info, name):
global student_id
global student_list
student_list[str(student_id)] = name
student_id =+ 1
return name
mutation = MutationType()
mutation.set_field("students", resolve_students)
query = QueryType()
def resolve_student(_, info, sid):
global student_list
return{"id": sid, "name": student_list.get(str(sid))}
query.set_field("students", resolve_student)
class class_info:
def __init__(self, course_name):
self.course_name = course_name
self.student_list = []
class_id = 1122334
class_list = {}
def resolve_classes(_, info, name):
