class Query(object):
"""
User queries.
"""
users = List(UserType)
user = Field(UserType, id=UUID())
@staticmethod
def resolve_users(self, info, **kwargs):
"""
Resolves all users.
"""
return User.objects.all()
@staticmethod
def resolve_user(self, info, **kwargs):
"""
Resolves a single user by ID.
"""
return User.objects.get_by_id(**kwargs)
@staticmethod
def resolve_me(self, info):
"""
Resolves the logged in user
"""
user = info.context.user
if user.is_anonymous:
raise Exception('You are not logged in')
return user
def convert_field_to_uuid(field,
registry=None,
required=None,
field_many_to_many_extras=None,
field_foreign_key_extras=None):
return UUID(description=field.help_text,
required=is_required(field, required))
def convert_field_to_uuid(field,
registry=None,
input_flag=None,
nested_field=False):
return UUID(
description=field.help_text or field.verbose_name,
required=is_required(field) and input_flag == "create",
)
def convert_field_to_uuid(field, registry=None, input_flag=None):
if input_flag == "order_by":
return OrderEnum(description=field.help_text or field.verbose_name, )
if input_flag == "where":
return UUIDFilter(description=field.help_text or field.verbose_name, )
return UUID(
description=field.help_text or field.verbose_name,
required=is_required(field) and input_flag == "create",
)
class UserQuery(ObjectType):
current_user = Field(User)
users = List(User)
get_user = Field(User, id=ID(required=True))
authenticate_user = Field(User,
login=String(required=True),
password=String(required=True))
identity_user = Field(User, uuid=UUID(required=True))
@permissions_required(UserPermissions.read)
def resolve_users(self, info):
return UserCRUD.objects(db.session)
@permissions_required(UserPermissions.read)
def resolve_get_user(self, info, id: int):
return UserCRUD.get(db.session, id)
@auth_required
def resolve_current_user(self, info):
return UserCRUD.get(db.session, current_identity.id)
@permissions_required(UserPermissions.read)
def resolve_authenticate_user(self, info, login: str, password: str):
user = UserCRUD.get_by_login(db.session, login)
if user is None:
abort(HTTPStatus.NOT_FOUND)
if not user.check_password(password):
abort(HTTPStatus.BAD_REQUEST)
user_status = UserCRUD.is_global_active(db.session, user.id)
if not user_status:
abort(HTTPStatus.LOCKED)
return user
@permissions_required(UserPermissions.read)
def resolve_identity_user(self, info, uuid: UUID):
user = UserCRUD.get_by_uuid(db.session, uuid)
if not user:
abort(HTTPStatus.NOT_FOUND)
return user
class CreateUser(Mutation):
"""
Create a user mutation.
Attributes for the class define the mutation response.
"""
id = UUID()
email = String()
first_name = String()
last_name = String()
class Arguments:
"""
Input arguments to create a user.
"""
email = String(required=True)
password = String(required=True)
first_name = String(required=True)
last_name = String()
@staticmethod
def mutate(_, info, email, password, first_name, last_name):
"""
Use the create_user method and return the
attributes we specified.
"""
user = User.objects.create_user(email=email,
password=password,
first_name=first_name,
last_name=last_name)
return CreateUser(id=user.id,
email=user.email,
first_name=user.first_name,
last_name=user.last_name)
def convert_field_to_uuid(field, registry=None):
return UUID(description=field.help_text, required=not field.null)
def convert_form_field_to_uuid(field):
return UUID(description=get_form_field_description(field),
required=field.required)
def convert_field_to_uuid(field, registry=None):
return UUID(description=get_django_field_description(field),
required=not field.null)
def convert_form_field_to_uuid(field):
return UUID(description=field.help_text, required=field.required)
def convert_form_field_to_uuid(field):
return UUID()
