def format_error(error):
if isinstance(error, GraphQLLocatedError):
try:
error_dict = json.loads(str(error))
except:
return GraphQLView.format_error(GraphQLError("Resolver error"))
return GraphQLView.format_error(error)
def format_error(error):
"""
Static method that modifies the error object returned for
Unauthorized Calendars.
:params error:
"""
try:
if isinstance(error, GraphQLLocatedError):
return format_located_error(error)
return GraphQLView.format_error(error)
except Exception as error:
return GraphQLView.format_error(error)
def format_error(error):
if hasattr(error, 'original_error'):
original_error = error.original_error
if isinstance(original_error, ValidationError):
err_dict = original_error.message_dict
def to_camel(strs):
components = strs.split('_')
return components[0] + ''.join(x.title()
for x in components[1:])
err_dict = {to_camel(k): err_dict[k] for k in err_dict}
return {
"code": "InvalidInput",
"message": "Invalid User Input",
"validations": err_dict
}
if isinstance(original_error, ContestError):
returned_err = {
'code': original_error.__class__.__name__,
'message': original_error.args[0],
}
if len(original_error.args) > 1:
returned_err['extensions'] = original_error.args[1:]
return returned_err
return {
'code': 'Internal Server Error',
'message': 'Internal Server Error',
}
return GraphQLView.format_error(error)
def format_located_error(error):
if isinstance(error.original_error, GraphQLLocatedError):
return format_located_error(error.original_error)
if isinstance(error.original_error, UnauthorizedCalendarError):
return {'message': error.original_error.message,
'AuthUrl': error.original_error.auth_url}
return GraphQLView.format_error(error)
def format_error(error):
formatted = BaseGraphQLView.format_error(error)
if isinstance(error, GraphQLError) and\
error.original_error is not None:
error = error.original_error
if not extensions_settings.SHOW_ERROR_MESSAGE_HANDLER(error):
formatted['message'] = _('Internal server error')
extensions = {
'type': error.__class__.__name__,
'code': getattr(error, 'code', 'error'),
'timestamp': timegm(datetime.utcnow().utctimetuple()),
**formatted.get('extensions', {}),
}
if hasattr(error, 'error_data'):
extensions['data'] = error.error_data
if error.__traceback__ is not None:
info = error.__traceback__.tb_frame.f_locals.get('info')
if info is not None:
extensions['operation'] = info.operation.operation.name
if settings.DEBUG:
extensions['trace'] = traceback.format_list(
traceback.extract_tb(error.__traceback__), )
formatted['extensions'] = extensions
return formatted
def get_response(self, request, data):
"""Extract the information from the request, execute the GraphQL query and form the response.
Args:
request (HttpRequest): Request Object from Django
data (dict): Parsed content of the body of the request.
Returns:
response (dict), status_code (int): Payload of the response to send and the status code.
"""
query, variables, operation_name, id = GraphQLView.get_graphql_params(request, data)
execution_result = self.execute_graphql_request(request, data, query, variables, operation_name)
status_code = 200
if execution_result:
response = {}
if execution_result.errors:
response["errors"] = [GraphQLView.format_error(e) for e in execution_result.errors]
if execution_result.invalid:
status_code = 400
else:
response["data"] = execution_result.data
result = response
else:
result = None
return result, status_code
def format_error(error):
res_error = OriginalGraphQLView.format_error(error)
if "locations" in res_error:
del res_error["locations"]
if hasattr(error, "original_error"):
res_error["type"] = error.original_error.__class__.__name__
return res_error
def format_error(error):
if hasattr(error, 'original_error') and error.original_error:
formatted = {"message": str(error.original_error)}
if isinstance(error.original_error, UnauthorizedError):
formatted['code'] = 401
return formatted
return GraphQLView.format_error(error)
def run(self, request, pk):
try:
query = get_object_or_404(self.queryset, pk=pk)
result = execute_saved_query(query.slug, variables=request.data.get("variables"), request=request).to_dict()
return Response(result)
except GraphQLError as error:
return Response(
{"errors": [GraphQLView.format_error(error)]},
status=status.HTTP_400_BAD_REQUEST,
)
def format_error(error):
try:
if isinstance(error, GraphQLLocatedError):
return format_located_error(error)
elif isinstance(error, GraphQLSyntaxError):
return format_graphql_error(error)
else:
return GraphQLView.format_error(error)
except Exception as e:
return format_internal_error(e)
def run(self, request, pk):
try:
result = execute_saved_query(pk,
variables=request.data,
request=request).to_dict()
return Response(result)
except GraphQLError as error:
return Response(
{"errors": [GraphQLView.format_error(error)]},
status=status.HTTP_400_BAD_REQUEST,
)
def format_error(error):
print(error)
if hasattr(error, 'original_error') and error.original_error:
formatted = {"message": str(error.original_error)}
if isinstance(error.original_error, UnauthorizedError):
formatted['code'] = "401"
elif isinstance(error.original_error, PermissionDeniedError):
formatted['code'] = "403"
return formatted
return GraphQLView.format_error(error)
def format_error(error):
"""
This method is responsible for customising the
error message
sent back to the user.
"""
try:
if isinstance(error, HttpError) or isinstance(error, QueryError) or isinstance(error, GraphQLSyntaxError) or isinstance(error, GraphQLError):
if hasattr(error, 'message'):
config.log.Error(error.message)
elif hasattr(error, 'msg'):
config.log.Error(error.msg)
else:
config.log.Error(str(error))
return format_located_error(error)
except TypeError as error:
config.log.Error(error.message)
return GraphQLView.format_error(error)
else:
config.log.Error(str(error))
return GraphQLView.format_error(error)
def format_error(error):
original_error = getattr(error, 'original_error', None) or error
formatted_error = GraphQLView.format_error(original_error)
if not isinstance(original_error, GraphQLError):
if settings.DEBUG:
formatted_error = {'debug': formatted_error.get('message', '')}
else:
formatted_error = {} # don't send message for non-ui errors to the client
# sentry.captureException(
# exc_info=(type(original_error), original_error, original_error.__traceback__))
return formatted_error
def format_error(error):
# NOTE(prmtl): it seems that in current version of graphene
# errors are multinested so it is not enough to just get
# error.orginial_error and we try until we can find "last one"
original_error = get_original_error(error)
if isinstance(original_error, ServerException):
error.message = original_error.default_message
if isinstance(error, GraphQLError):
logger.exception("Error with GQL\n%s", error)
traceback.print_tb(error.__traceback__)
return _GraphQLView.format_error(error)
def post(self, request, *args, **kwargs):
try:
data = self.parse_body(request)
result, status_code = self.get_response(request, data)
return Response(
result,
status=status_code,
)
except HttpError as e:
return Response(
{"errors": [GraphQLView.format_error(e)]},
status=status.HTTP_400_BAD_REQUEST,
)
def format_error(error):
formatted_error = GraphQLView.format_error(error)
original_error = getattr(error, 'original_error', None)
extensions = {}
if original_error:
if hasattr(original_error, 'code'):
extensions['code'] = str(error.original_error.code)
elif type(original_error) in [
PermissionDenied, DjPermissionDenied
]:
extensions['code'] = str(PermissionDeniedException.code)
formatted_error['message'] = str(
PermissionDeniedException.default_message)
else:
extensions['errorCode'] = str(
status.HTTP_500_INTERNAL_SERVER_ERROR)
formatted_error['extensions'] = extensions
return formatted_error
def format_error(error):
if hasattr(error, 'original_error') and isinstance(
error.original_error, ValidationError):
err_dict = error.original_error.message_dict
def to_camel(strs):
components = strs.split('_')
return components[0] + ''.join(x.title()
for x in components[1:])
err_dict = {to_camel(k): err_dict[k] for k in err_dict}
return {
"code": "InvalidInput",
"message": "Invalid User Input",
"validations": err_dict
}
return GraphQLView.format_error(error)
def format_located_error(error):
"""
Helper method to help error based on type comparison
"""
if isinstance(error, HttpError):
config.log.Error('message: ' + error.message +
'code: ' + str(error.response.status_code))
return {
'error': 'Error de conexión HTTP o no ha enviado una consulta válida',
'message: ': error.message,
'code: ': error.response.status_code
}
if isinstance(error, GraphQLLocatedError):
config.log.Error('message: ' + error.message +
'code: ' + "1001")
return {
'error': 'Ocurrió un error de desarrollador no detectado dentro de la función de resolución / suscripción (por ejemplo, una consulta de base de datos mal escrita)',
'message': error.message,
'code': 1001
}
if isinstance(error, QueryError):
config.log.Error('message: ' + error.msg +
'code: ' + "1002")
return {
'error': 'Error interno en la consulta',
'message': error.msg,
'code': 1002
}
if isinstance(error, GraphQLSyntaxError):
config.log.Error('message: ' + error.message +
'code: ' + "1003")
return {
'error': 'La consulta falla por un error interno de validación (sintaxis, lógica , etc.)',
'message': error.message,
'code': 1003
}
if isinstance(error, CustomFatalError):
# return custom error if it is an instance
# of CustomFatalError
config.log.Error('message: ' + error.message +
'code: ' + "1004")
return {
'error': 'Las variables o el contexto proporcionados por el usuario son incorrectos y la función de resolución / suscripción intencionalmente genera un error (por ejemplo, no se le permite ver al usuario solicitado)',
'message': error.message,
#'cause': error.original_error.cause,
#'code': error.original_error.code
'code': 1004
}
if isinstance(error, GraphQLError):
config.log.Error('message: ' + error.message +
'code: ' + "1000")
return {
'error:': 'La consulta está mal formada',
'message': error.message,
'code': 1000
}
config.log.Error(error)
return GraphQLView.format_error(error)
def format_error(error):
if (hasattr(error, 'original_error') and isinstance(
error.original_error, GraphqlAuthenticationError)):
raise AuthenticationFailed()
return GraphQLView.format_error(error)
