def exception_handler(exc, context):
"""Handle Django ValidationError as an accepted exception
Must be set in settings:
>>> REST_FRAMEWORK = {
... # ...
... 'EXCEPTION_HANDLER': 'mtp.apps.common.drf.exception_handler',
... # ...
... }
For the parameters, see ``exception_handler``
"""
if isinstance(exc, DjangoValidationError):
try:
exc = DRFValidationError(detail=exc.message_dict)
except AttributeError:
exc = DRFValidationError(detail={"validation_error": exc.message})
if isinstance(exc, ProtectedError):
exc = DRFValidationError(detail={"protection_error": exc.args[0]})
return drf_exception_handler(exc, context)
def custom_exception_handler(exc, context):
if isinstance(exc, PermissionDenied):
exc = PermissionDenied(
detail={'message': 'Ошибка доступа. У вас нет прав.'})
if isinstance(exc, NotAuthenticated):
exc = NotAuthenticated(
detail={'message': 'Ошибка доступа. Вы не авторизованы'})
if isinstance(exc, CustomValidation):
field = list(exc.detail.keys())[0]
exc = DRFValidationError(
detail={'message': field + ' ' + exc.detail[field]})
if isinstance(exc, DjangoValidationError):
if hasattr(exc, 'message_dict'):
# TODO: handle many fields
field = list(exc.detail.keys())[0]
exc = DRFValidationError(
detail={'message': field + ' ' + exc.detail[field]})
else:
exc = DRFValidationError(detail={'message': exc.message})
if isinstance(exc, DjangoIntegrityError):
exc = DRFValidationError(detail={'message': str(exc)})
return drf_exception_handler(exc, context)
def create(self, request, *args, **kwargs):
lti_session = getattr(self.request, 'LTI', {})
audit_user_id = lti_session.get('custom_canvas_user_login_id')
account_sis_id = lti_session.get('custom_canvas_account_sis_id')
if not all((audit_user_id, account_sis_id)):
raise DRFValidationError(
'Invalid LTI session: custom_canvas_user_login_id and '
'custom_canvas_account_sis_id required')
account = self.request.data.get('account')
term = self.request.data.get('term')
if not all((account, term)):
raise DRFValidationError('Both account and term are required')
# for the moment, only the current school account can be operated on
if not account_sis_id[len('school:'):] == account:
raise PermissionDenied
selected_courses = self.request.data.get('course_list')
process = Process.enqueue(
bulk_publish_canvas_sites,
settings.RQWORKER_QUEUE_NAME,
account='sis_account_id:school:{}'.format(account),
term='sis_term_id:{}'.format(term),
audit_user=audit_user_id,
course_list=selected_courses)
logger.debug('Enqueued Process job for bulk_publish_canvas_sites: '
'{}'.format(process))
return Response(self.serializer_class(process).data,
status=status.HTTP_201_CREATED)
def exception_handler(exc, context):
if isinstance(exc, DjangoValidationError):
if hasattr(exc, 'message_dict'):
exc = DRFValidationError(detail=exc.message_dict)
else:
exc = DRFValidationError(detail=exc.message)
return drf_exception_handler(exc, context)
def convert_validation_error(error):
"""
Convert a Django ValidationError to a DRF ValidationError.
"""
# TODO: handle Django ValidationError properties other than message
if hasattr(error, 'message'):
return DRFValidationError(error.message)
else:
return DRFValidationError('Validation error on underlying data.')
def exception_handler(exc, context):
if isinstance(exc, DjangoValidationError):
if hasattr(exc, 'message_dict'):
exc = DRFValidationError(detail={'error': exc.message_dict})
elif hasattr(exc, 'message'):
exc = DRFValidationError(detail={'error': exc.message})
elif hasattr(exc, 'messages'):
exc = DRFValidationError(detail={'error': exc.messages})
return drf_exception_handler(exc, context)
def retrieve(self, request, pk=None):
# Método para ver os detalhes de um usuário.
try:
user = User.objects.get(pk=pk)
except User.DoesNotExist:
raise DRFValidationError('Usuário não encontrado.')
if request.user and request.user.is_authenticated:
serializer = UserSerializer(user)
else:
raise DRFValidationError('Você não tem acesso a este usuário.')
return Response(serializer.data)
def filter_queryset(self, request, queryset, view):
if not 'order_by_distance_to' in request.query_params:
return queryset
try:
coordinates = json.loads(request.query_params['order_by_distance_to'])
except JSONDecodeError:
raise DRFValidationError(detail=self.error_message)
if not check_coordinates(coordinates):
raise DRFValidationError(detail=self.error_message)
return queryset.annotate(distance=DistanceFunction('coordinates', Point(coordinates, srid=4326))).order_by('distance')
def exception_handler(exc, context):
"""Custom exception handler for DRF (specified in ``settings.py``).
Main use:
> handling of django.core.ValidationError for better json returns of API
"""
if isinstance(exc, DjangoValidationError):
if hasattr(exc, "message_dict"):
exc = DRFValidationError(detail={"error": exc.message_dict})
elif hasattr(exc, "message"):
exc = DRFValidationError(detail={"error": exc.message})
elif hasattr(exc, "messages"):
exc = DRFValidationError(detail={"error": exc.messages})
return drf_exception_handler(exc, context)
def exception_handler(exc, context):
"""Handle Django ValidationError as an accepted exception
For the parameters, see ``exception_handler``
"""
if isinstance(exc, DjangoValidationError):
if hasattr(exc, 'message_dict'):
exc = DRFValidationError(detail={'error': exc.message_dict})
elif hasattr(exc, 'message'):
exc = DRFValidationError(detail={'error': exc.message})
elif hasattr(exc, 'messages'):
exc = DRFValidationError(detail={'error': exc.messages})
return drf_exception_handler(exc, context)
def exception_handler(exc, context):
"""Handle Django ValidationError as an accepted exception."""
if isinstance(exc, DjangoValidationError):
exc = DRFValidationError(detail=exc.messages)
return drf_exception_handler(exc, context)
def post(self, request, *args, **kwargs):
""" Create a new job from submitted params """
if logger.isEnabledFor(logging.DEBUG):
for key, param in request.data.items():
logger.debug('param key ' + key + ' param:' + str(param))
service_submission = self.get_object()
passed_data = request.data.copy()
ass_email = passed_data.pop('email', None)
try:
passed_data.pop('api_key', None)
from ..serializers.jobs import JobCreateSerializer
from django.db.models import Q
job = Job.objects.create_from_submission(
submission=service_submission,
email_to=ass_email,
submitted_inputs=passed_data,
user=request.user)
# Now job is created (or raise an exception),
serializer = JobSerializer(job,
many=False,
context={'request': request},
fields=(
'slug',
'url',
'created',
'status',
))
return Response(serializer.data, status=201)
except ValidationError as e:
raise DRFValidationError(e.message_dict)
except JobException as e:
logger.fatal("Create Error %s", e.message)
return Response({'error': e.message},
status=status.HTTP_400_BAD_REQUEST)
def exception_handler(exception, context):
# Transform model validation errors into an equivalent DRF ValidationError.
if isinstance(exception, DjangoValidationError):
exception = DRFValidationError(detail=get_error_detail(exception))
# Call REST Framework's default exception handler with the transformed exception.
return drf_exception_handler(exception, context)
def custom_exception_handler(exc, context):
# Call REST framework's default exception handler first,
# to get the standard error response.
if isinstance(exc, DjangoValidationError):
exc = DRFValidationError(detail=exc.message_dict)
return drf_exception_handler(exc, context)
def exception_handler(exception, context):
"""Handle Django ValidationError as an accepted exception
Must be set in settings:
>>> REST_FRAMEWORK = {
... # ...
... 'EXCEPTION_HANDLER': 'Authentication.exception_handler.exception_handler',
... # ...
... }
For the parameters, see ``exception_handler``
"""
if isinstance(exception, DjangoValidationError):
if isinstance(exception, DjangoValidationError):
if hasattr(exception, 'message_dict'):
detail = exception.message_dict
elif hasattr(exception, 'message'):
detail = exception.message
elif hasattr(exception, 'messages'):
detail = exception.messages
else:
logging.error("BAD VALIDATION MESSAGE: %s" % exception)
exception = DRFValidationError(detail={"detail": detail})
return drf_exception_handler(exception, context)
def validate_username(self, username):
user_with_username = User.objects.filter(username=username)
if user_with_username.exists():
raise DRFValidationError("Unable to create user.")
return username
def save(self):
request = self.context['request']
request_user = None
if request.user and request.user.is_authenticated:
request_user = request.user
# Build application class and save record to DB to record the attempt
Application = self.Meta.model
app = Application(**self.validated_data)
# Store the ip address of user sending the request
app.ip_address, _ = get_client_ip(request)
app.user = request_user
app.submitting_user = request_user
app.save()
# Submit application to to Wells
try:
result = actions.submit_credit_application(
app, current_user=request_user)
except core_exceptions.CreditApplicationPending as e:
pending = api_exceptions.CreditApplicationPending()
pending.inquiry = e.inquiry
raise pending
except core_exceptions.CreditApplicationDenied:
raise api_exceptions.CreditApplicationDenied()
except DjangoValidationError as e:
raise DRFValidationError({'non_field_errors': [e.message]})
return result
def exception_handler(exc, context):
"""Handle Django ValidationError as an accepted exception
Must be set in settings:
>>> REST_FRAMEWORK = {
... # ...
... 'EXCEPTION_HANDLER': 'mtp.apps.common.drf.exception_handler',
... # ...
... }
For the parameters, see ``exception_handler``
"""
if isinstance(exc, DjangoValidationError):
if hasattr(exc, "message_dict"):
new_dict = {}
for key, value in exc.message_dict.items():
if type(value) in (list, tuple, set,
frozenset) and len(value) == 1:
new_dict[key] = value[0]
else:
new_dict[key] = value
detail = new_dict
elif hasattr(exc, "message"):
detail = {'detail': exc.message}
elif hasattr(exc, "messages"):
detail = exc.messages
else:
return drf_exception_handler(exc, context)
exc = DRFValidationError(detail=detail)
return drf_exception_handler(exc, context)
def list(self, request, *args, **kwargs):
data = TransmissionForm(request.query_params)
if not data.is_valid():
raise DRFValidationError(data.errors)
requested_timezone = data.cleaned_data.get('timezone')
after = data.cleaned_data['after']
before = data.cleaned_data['before']
tz = requested_timezone or pytz.utc
after_date = tz.localize(
datetime.datetime.combine(after, datetime.time()))
before_date = tz.localize(
datetime.datetime.combine(before, datetime.time(23, 59, 59)))
# Apply filters to the queryset
schedules = self.filter_queryset(self.get_queryset())
# Filter by active calendar if that filter was not provided
if not data.cleaned_data.get('calendar'):
schedules = schedules.filter(calendar__is_active=True)
transmissions = Transmission.between(after_date,
before_date,
schedules=schedules)
serializer = self.get_serializer(transmissions, many=True)
with override(timezone=tz):
return Response(serializer.data)
def extra_exception_handler(exc, context):
# from https://gist.github.com/twidi/9d55486c36b6a51bdcb05ce3a763e79f
# Convert django ValidationError to DRF exceptions. This way, instead of
# returning a 500 error it will return a 400
if isinstance(exc, DjangoValidationError):
errors = getattr(exc, "error_list", None) or getattr(
exc, "error_dict", None)
exc = DRFValidationError(detail=errors)
# Call REST framework's default exception handler first,
# to get the standard error response.
response = exception_handler(exc, context)
# If response is None, add more cases to the exception handler.
if response is None:
if isinstance(exc, IntegrityError):
data = {api_settings.NON_FIELD_ERRORS_KEY: str(exc)}
return Response(data, status=status.HTTP_400_BAD_REQUEST)
elif (isinstance(exc, APIException)
and exc.status_code == status.HTTP_400_BAD_REQUEST):
data = {
api_settings.NON_FIELD_ERRORS_KEY:
exc.get_full_details()["message"],
"code":
exc.get_codes(),
}
return Response(data, status=status.HTTP_400_BAD_REQUEST)
# If the response has APIException inject the exception code in the response
elif response and isinstance(exc, APIException) and exc.get_codes():
response.data["code"] = exc.get_codes()
return response
def clean(self):
self.tags = list(set(t.lower() for t in self.tags))
if len(self.tags) > settings.CHANNEL_MAX_TAGS:
raise DRFValidationError({
'tags':
['Specify a maximum of '
f'{settings.CHANNEL_MAX_TAGS} Tags.']
})
def __call__(self, value):
try:
validate(instance=value, schema=self.schema)
except JSONSchemaValidationError:
# Transform jsonschema ValidationError to DRF ValidationError
raise DRFValidationError()
else:
return value
def rest_exception_handler(exc, context):
if isinstance(exc, DjangoValidationError):
if not settings.DEBUG:
raise exc
if hasattr(exc, 'message_dict'):
exc = DRFValidationError(detail={'error': exc.message_dict})
elif hasattr(exc, 'message'):
exc = DRFValidationError(detail={'error': exc.message})
elif hasattr(exc, 'messages'):
exc = DRFValidationError(detail={'error': exc.messages})
response = exception_handler(exc, context)
if response:
response.data['status'] = response.status_code
response.data['code'] = getattr(exc, 'code', getattr(exc, 'default_code', None)) or response.data['detail'].code
return response
def validate_query_params(self):
if 'only_last_version' in self.query_params:
if len([n for n in self.query_params if 'history_date' in n]) != 2:
raise DRFValidationError(self.ONLY_LAST_VERSION_ERROR_MSG)
self._validate_history_date()
if 'cursor' in self.query_params:
self._validate_cursor()
return self.query_params
def validiate_user_to_follow(self, user_to_follow):
try:
User.objects.get(pk=user_to_follow)
except User.DoesNotExist:
raise DRFValidationError(
"User you are trying to follow does not exist.")
return user_to_follow
def validate_geometrie(self, value):
fail_msg = 'Location coordinates not anywhere near Amsterdam. (in WGS84)'
lat_not_in_adam_area = not 50 < value.coords[1] < 55
lon_not_in_adam_area = not 1 < value.coords[0] < 7
if lon_not_in_adam_area or lat_not_in_adam_area:
raise DRFValidationError(fail_msg)
return value
def exception_handler(exc, context):
"""Handle Django ValidationError as an accepted exception
Must be set in settings:
>>> REST_FRAMEWORK = {
... # ...
... 'EXCEPTION_HANDLER': 'mtp.apps.common.drf.exception_handler',
... # ...
... }
For the parameters, see ``exception_handler``
"""
if isinstance(exc, DjangoValidationError):
if hasattr(exc, 'message_dict'):
exc = DRFValidationError(detail=exc.message_dict)
else:
exc = DRFValidationError(detail=exc.message)
return drf_exception_handler(exc, context)
def _validate_assignments_data(self, assignments):
"""
Raise ValidationError with specified message if `assignments` is not a list of dicts.
"""
if not all(isinstance(item, dict) for item in assignments):
raise DRFValidationError({
'non_field_errors':
['Expected a list of items but got type "dict".']
})
def exception_handler(exc, context):
"""
https://gist.github.com/twidi/9d55486c36b6a51bdcb05ce3a763e79f
This handler is used to change model validation error to serializer's validation error.
"""
if isinstance(exc, DjangoValidationError):
exc = DRFValidationError(detail=exc.message_dict)
return drf_exception_handler(exc, context)
def validate_geometrie(self, value):
fail_msg = 'The location coordinates (WS84) are not inside the bounding box we are accepting signals for.'
lat_not_in_bounding_box = not settings.BOUNDING_BOX[1] <= value.coords[1] <= settings.BOUNDING_BOX[3]
lon_not_in_bounding_box = not settings.BOUNDING_BOX[0] <= value.coords[0] <= settings.BOUNDING_BOX[2]
if lat_not_in_bounding_box or lon_not_in_bounding_box:
raise DRFValidationError(fail_msg)
return value