def error_response(self, exc_type, exc, traceback):
if isinstance(exc, PermissionDenied):
return TemplateResponse('403.html', status=403, data={
'path': self.request.path,
})
elif isinstance(exc, NotFound):
return TemplateResponse('404.html', status=404, data={
'path': self.request.path,
})
elif isinstance(exc, ValidationError):
response = serialize_validation_error(exc)
return JSONResponse(response, status=exc.status_code)
elif isinstance(exc, APIException):
return JSONResponse({
'error': exc.detail,
'error_code': exc.code
}, status=exc.status_code)
else:
if settings.DEBUG:
ctx = {
'path': self.request.path if self.request else None,
'full_path': self.request.protocol + '://' + self.request.host + self.request.path if self.request else None,
'method': self.request.method if self.request else None,
'type': configuration.get_type(),
'version': configuration.get_version(),
'current_datetime': datetime.now().strftime('%c'),
'python_version': platform.python_version(),
'python_executable': sys.executable,
'python_path': sys.path
}
if exc:
ctx.update({
'exception_type': exc_type.__name__,
'exception_value': six.text_type(exc)
})
if traceback:
last_traceback = traceback
while last_traceback.tb_next:
last_traceback = last_traceback.tb_next
frame = last_traceback.tb_frame
func_name = frame.f_code.co_name
file_name = frame.f_code.co_filename
line_number = frame.f_lineno
ctx.update({
'exception_last_traceback_line': line_number,
'exception_last_traceback_func': func_name,
'exception_last_traceback_file': file_name,
})
logger.exception(exc)
return TemplateResponse('500.debug.html', status=500, data=ctx)
else:
return TemplateResponse('500.html', status=500)
def post(self, *args, **kwargs):
if 'queries' in self.request.data:
serializer = SqlsSerializer(data=self.request.data, context={'request': self.request})
else:
serializer = SqlSerializer(data=self.request.data, context={'request': self.request})
serializer.is_valid(raise_exception=True)
try:
return JSONResponse(serializer.execute(serializer.validated_data))
except SqlError as e:
return JSONResponse({'error': str(e.detail)}, status=HTTP_400_BAD_REQUEST)
def aggregate(self, request, *args, **kwargs):
queryset = self.filter_queryset(request, self.get_queryset(request))
y_func = request.get_argument('_y_func').lower()
y_column = request.get_argument('_y_column', self.lookup_field)
model_serializer = self.get_serializer(request)
y_serializers = list(
filter(lambda x: x.field_name == y_column,
model_serializer.fields))
y_serializer = y_serializers[0]
filter_instance = ModelAggregateFilter()
filter_instance.model = self.get_model(request)
try:
queryset = filter_instance.filter(queryset, {
'y_func': y_func,
'y_column': y_column
}).one()
except SQLAlchemyError:
queryset.session.rollback()
raise
result = y_serializer.to_representation(
queryset[0]) # TODO: Refactor serializer
return JSONResponse({'y_func': result})
def group(self, *args, **kwargs):
queryset = self.filter_queryset(self.get_queryset())
x_column = self.request.get_argument('_x_column')
x_lookup_name = self.request.get_argument('_x_lookup', None)
y_func = self.request.get_argument('_y_func').lower()
y_column = self.request.get_argument('_y_column', self.lookup_field)
model_serializer = self.get_serializer()
# x_serializers = list(filter(lambda x: x.field_name == x_column, model_serializer.fields))
# x_serializer = x_serializers[0]
# y_serializers = list(filter(lambda x: x.field_name == y_column, model_serializer.fields))
# y_serializer = y_serializers[0]
filter_instance = ModelGroupFilter()
filter_instance.model = self.model
queryset = filter_instance.filter(
queryset, {
'x_column': x_column,
'x_lookup': x_lookup_name,
'y_func': y_func,
'y_column': y_column
})
serializer = ModelGroupSerializer(
instance=queryset,
many=True,
# TODO: Refactor serializer
# group_serializer=x_serializer,
# y_func_serializer=y_serializer
)
return JSONResponse(serializer.representation_data)
def list(self, request, *args, **kwargs):
queryset = self.filter_queryset(request, self.get_queryset(request))
paginate = not request.get_argument('_no_pagination', False)
page = self.paginate_queryset(request, queryset) if paginate else None
if page is not None:
try:
instance = list(page)
serializer = self.get_serializer(request, instance=instance, many=True)
return self.get_paginated_response(request, serializer.representation_data)
except SQLAlchemyError:
request.session.rollback()
raise
if queryset._limit is None:
queryset = queryset.limit(10000)
try:
instance = list(queryset)
serializer = self.get_serializer(request, instance=instance, many=True)
data = serializer.representation_data
return JSONResponse(data)
except SQLAlchemyError:
request.session.rollback()
raise
def get_siblings(self, request, *args, **kwargs):
queryset = self.filter_queryset(request, self.get_queryset(request))
obj = self.get_object(request)
Model = self.get_model(request)
result = get_model_siblings(request, Model, obj, queryset)
return JSONResponse(result)
def get_paginated_response(self, data):
return JSONResponse(OrderedDict([
('count', self.count),
('next', self.get_next_link()),
('previous', self.get_previous_link()),
('results', data),
('num_pages', self.get_pages_count()),
('per_page', self.page_size),
]))
def update(self, *args, **kwargs):
partial = kwargs.pop('partial', False)
instance = self.get_object()
serializer = self.get_serializer(instance=instance,
data=self.request.data,
partial=partial)
serializer.is_valid(raise_exception=True)
self.perform_update(serializer)
return JSONResponse(serializer.representation_data)
def reset_order(self, *args, **kwargs):
queryset = self.filter_queryset(self.get_queryset())
ResetOrderSerializer = get_reset_order_serializer(self.get_model(), queryset, self.session)
serializer = ResetOrderSerializer(data=self.request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return JSONResponse(serializer.representation_data)
def list(self, *args, **kwargs):
queryset = self.filter_queryset(self.get_queryset())
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(instance=page, many=True)
return self.get_paginated_response(serializer.representation_data)
serializer = self.get_serializer(instance=queryset, many=True)
return JSONResponse(serializer.representation_data)
def list(self, *args, **kwargs):
queryset = self.filter_queryset(self.get_queryset())
paginate = not self.request.get_argument('_no_pagination', False)
page = self.paginate_queryset(queryset) if paginate else None
if page is not None:
serializer = self.get_serializer(instance=page, many=True)
return self.get_paginated_response(serializer.representation_data)
if queryset._limit is None:
queryset = queryset.limit(10000)
serializer = self.get_serializer(instance=queryset, many=True)
data = serializer.representation_data
return JSONResponse(data)
def post(self, *args, **kwargs):
# TODO: Move to serializer
original_filename, file = self.request.files.get('file', None)
path = self.request.get_body_argument('path')
filename = self.request.get_body_argument('filename', original_filename)
upload_path = os.path.join(path, filename)
upload_path = configuration.media_get_available_name(upload_path)
# TODO: Add validations
configuration.media_save(upload_path, file)
return JSONResponse({
'uploaded_path': upload_path,
'uploaded_url': configuration.media_url(upload_path, self.request)
})
def group(self, request, *args, **kwargs):
queryset = self.filter_queryset(request, self.get_queryset(request))
x_column = request.get_argument('_x_column')
x_lookup_name = request.get_argument('_x_lookup', None)
y_func = request.get_argument('_y_func').lower()
y_column = request.get_argument('_y_column', self.lookup_field)
model_serializer = self.get_serializer(request)
# x_serializers = list(filter(lambda x: x.field_name == x_column, model_serializer.fields))
# x_serializer = x_serializers[0]
# y_serializers = list(filter(lambda x: x.field_name == y_column, model_serializer.fields))
# y_serializer = y_serializers[0]
filter_instance = ModelGroupFilter()
filter_instance.model = self.get_model(request)
queryset = filter_instance.filter(
queryset, {
'x_column': x_column,
'x_lookup': x_lookup_name,
'y_func': y_func,
'y_column': y_column
})
try:
instance = list(queryset)
except SQLAlchemyError:
queryset.session.rollback()
raise
serializer = ModelGroupSerializer(
instance=instance,
many=True,
# TODO: Refactor serializer
# group_serializer=x_serializer,
# y_func_serializer=y_serializer
)
return JSONResponse(serializer.representation_data)
def aggregate(self, *args, **kwargs):
queryset = self.filter_queryset(self.get_queryset())
y_func = self.request.get_argument('_y_func').lower()
y_column = self.request.get_argument('_y_column', self.lookup_field)
model_serializer = self.get_serializer()
y_serializers = list(filter(lambda x: x.field_name == y_column, model_serializer.fields))
y_serializer = y_serializers[0]
filter_instance = ModelAggregateFilter()
filter_instance.model = self.model
queryset = filter_instance.filter(queryset, {
'y_func': y_func,
'y_column': y_column
})
result = y_serializer.to_representation(queryset[0]) # TODO: Refactor serializer
return JSONResponse({
'y_func': result
})
def get(self, request, *args, **kwargs):
return JSONResponse({
'version': configuration.get_version(),
'type': configuration.get_type(),
'media_url_template': configuration.media_url('{}', request)
})
def post(self, *args, **kwargs):
result = dispose_connection(self.request)
get_request_connection(self.request)
return JSONResponse({
'success': result
})
def retrieve(self, *args, **kwargs):
instance = self.get_object()
serializer = self.get_serializer(instance=instance)
return JSONResponse(serializer.representation_data)
def get(self, *args, **kwargs):
queryset = self.get_queryset()
serializer = self.serializer_class(instance=queryset, many=True)
return JSONResponse(serializer.representation_data)
def delete(self, *args, **kwargs):
instance = self.get_object()
self.perform_destroy(instance)
return JSONResponse(status=status.HTTP_204_NO_CONTENT)
def get_siblings(self, *args, **kwargs):
queryset = self.filter_queryset(self.get_queryset())
obj = self.get_object()
return JSONResponse(
get_model_siblings(self.request, self.model, obj, queryset))
def create(self, *args, **kwargs):
serializer = self.get_serializer(data=self.request.data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
return JSONResponse(serializer.representation_data, status=status.HTTP_201_CREATED)
