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)