def wrapper(request, *args, **kwargs): error_message = None try: if hasattr(settings, 'PROXY_API_KEYS'): if request.META.get(proxy_server.HTTP_API_KEY) in settings.PROXY_API_KEYS: if hasattr(settings, 'PROXY_TOKEN_VALIDATION_SERVICE'): if public is True and request.META.get(proxy_server.HTTP_USER_TOKEN) is not None: error_message = 'A public service cannot receive a user token' raise Exception elif public is False and request.META.get(proxy_server.HTTP_USER_TOKEN): try: dot = settings.PROXY_TOKEN_VALIDATION_SERVICE.rindex('.') except ValueError: error_message ='Token validation service not properly configured' raise Exception val_module = import_module(settings.PROXY_TOKEN_VALIDATION_SERVICE[:dot]) val_func = getattr(val_module, settings.PROXY_TOKEN_VALIDATION_SERVICE[dot + 1:]) try: response = val_func(request) except Exception as e: error_message = 'Could not invoke token validation service' raise Exception request.META[proxy_server.HTTP_USER_TOKEN] = response[proxy_server.USER_TOKEN] return api_view(methods)(view_func)(request, *args, **kwargs) elif public is True and request.META.get(proxy_server.HTTP_USER_TOKEN) is None: return api_view(methods)(view_func)(request, *args, **kwargs) else: return api_view(methods)(view_func)(request, *args, **kwargs) else: error_message = 'Received API KEY not found in server API KEYS set' raise Exception else: error_message = 'API KEYS not properly configured' raise Exception except Exception as e: if error_message is None: if e.message is not None: error_message = e.message else: error_message = 'Server encountered an error and cannot proceed with service call' error = { 'error': { 'code': 500, 'type': 'ProxyServerError', 'message': error_message } } return HttpResponseServerError(json.dumps(error), content_type='application/json')
def as_view(cls, *args, **kwargs): view = super(DRFAuthenticatedGraphQLView, cls).as_view(*args, **kwargs) view = permission_classes((IsAuthenticated, ))(view) view = authentication_classes( api_settings.DEFAULT_AUTHENTICATION_CLASSES)(view) view = api_view(['GET', 'POST'])(view) return view
def add_motionActivityPerDay(request): payload = json.loads(request.body) user = request.user dog = Dog.objects.get(id=payload["dog"]) activity = Activity.objects.get(activity_id=payload["activity"]) ConvertedDate = datetime.strptime(payload['date'], "%Y-%m-%d").date() week = ConvertedDate.isocalendar()[1] month = ConvertedDate.month year = ConvertedDate.year try: motion = MotionActivityPerDay.objects.create( user=user, dog=dog, date=payload["date"], activity=payload["activity"], timePeriod=payload["timePeriod"], week=week, month=month, year=year) serializer = MotionActivityPerDaySerializer(motion) return JsonResponse({'motions': serializer.data}, safe=False, status=status.HTTP_201_CREATED) except ObjectDoesNotExist as e: return JsonResponse({'error': str(e)}, safe=False, status=status.HTTP_404_NOT_FOUND) except Exception: return JsonResponse( {Exception}, safe=False, status=status.HTTP_500_INTERNAL_SERVER_ERROR) @ api_view(["POST"])
def tx_swap(request): address = request.GET['address'] amount_beam = request.GET['amount_beam'] amount_btc = request.GET['amount_btc'] _redis.set('receiver', address) for proc in psutil.process_iter(): if "wallet-api".lower() in proc.name().lower(): pinfo = proc.as_dict(attrs=['pid', 'name', 'create_time']) os.kill(int(pinfo['pid']), signal.SIGTERM) # or signal.SIGKILL process = subprocess.Popen( "beam-wallet --wallet_path=\"wallet.db\" " "-n eu-node01.masternet.beam.mw:8100 swap_coins " "--amount " + amount_beam + " --fee 100 -r " + address + " --pass=123 --swap_amount " + amount_btc + " --swap_beam_side --btc_node_addr 127.0.0.1:13300 " "--btc_pass 123 --btc_user Alice", shell=True, stdin=None, stdout=None, stderr=None, close_fds=True) _redis.set("process_id", str(process.pid)) return Response('Completed successfully', status=HTTP_200_OK) @ api_view( ['GET'])
def as_view(cls, *args, **kwargs): """ Set DRF attributes in the view """ view = super(DRFAuthenticatedGraphQLView, cls).as_view(*args, **kwargs) view = permission_classes((AllowAny,))(view) view = authentication_classes(api_settings.DEFAULT_AUTHENTICATION_CLASSES)(view) view = api_view(["GET", "POST"])(view) return view
def as_view(cls, *args, **kwargs): """Add the relevant DRF-view logic to the view.""" view = super(AuthenticatedGraphQLView, cls).as_view(*args, **kwargs) view = permission_classes((IsUserAllowed, ))(view) view = authentication_classes( (CsrfExemptSessionAuthentication, ))(view) view = api_view(["GET", "POST"])(view) return view
def as_view(cls, *args, **kwargs): backend = DepthAnalysisBackend() view = super(GraphQLView, cls).as_view(backend=backend, *args, **kwargs) view = permission_classes((permissions.AllowAny, ))(view) view = api_view(['GET', 'POST'])(view) return view
def view(self): view_func = self._view_function() if self.permission_classes: view_func.permission_classes = self.permission_classes view = api_view([self.REQUEST_METHOD])(view_func) view = add_permission_classes(self.permission_classes)(view) view.authentication_classes = api_settings.DEFAULT_AUTHENTICATION_CLASSES return view
def as_view(task): def view(request, *args, **kwargs): task_id = task_id_from_request(request) register_task(task_id, task, *args, **kwargs) return task_result_response(task_id) view.__name__ = task.__name__.replace('_asr', '') return api_view(['GET'])(view)
class ApiViewAuthenticationMixin(object): @method_decorator(api_view(['POST'])) @method_decorator(authentication_classes(TokenAuthentication)) @method_decorator(permission_classes(IsAuthenticated, )) @method_decorator(csrf_exempt) def dispatch(self, *args, **kwargs): return super(ApiViewAuthenticationMixin, self).dispatch(*args, **kwargs)
def as_view(cls, *args, **kwargs): view = super(PrivateGraphQLView, cls).as_view(*args, **kwargs) view = permission_classes(( TokenHasReadWriteScope, FireBaseAuth, ))(view) view = authentication_classes((OAuth2Authentication, ))(view) view = api_view(['POST', 'GET'])(view) return view
def as_view(cls, *args, **kwargs): view = super(DOTAuthenticatedGraphQLView, cls).as_view(*args, **kwargs) view = permission_classes(( IsAuthenticated, TokenHasReadWriteScope, ))(view) # add permissions to the view view = authentication_classes((OAuth2Authentication, ))(view) view = api_view(['POST'])(view) return view
def as_view(cls, *args, **kwargs): view = super().as_view(*args, **kwargs) view = permission_classes((IsAuthenticated,))(view) view = authentication_classes(api_settings.DEFAULT_AUTHENTICATION_CLASSES)(view) view = parser_classes([JSONParser])(view) view = throttle_classes(api_settings.DEFAULT_THROTTLE_CLASSES)(view) view = api_view(["GET", "POST"])(view) view = csrf_exempt(view) return view
def as_view(cls: "DRFGraphQL", schema: Schema) -> "DRFGraphQL": """Wraps the graphql view in the authentication_classes, permission_classes and api_view functions available from DRF. """ view = super().as_view(graphiql=True, schema=schema) view = authentication_classes(api_settings.DEFAULT_AUTHENTICATION_CLASSES)(view) view = permission_classes(api_settings.DEFAULT_PERMISSION_CLASSES)(view) return api_view(http_method_names=("GET", "POST"))(view)
def as_view(cls, *args, **kwargs): view = super(DRFAuthenticatedGraphQLView, cls).as_view(*args, **kwargs) view = permission_classes((IsAuthenticated, ))(view) view = authentication_classes(( JSONWebTokenAuthentication, TokenAuthentication, ))(view) #view = authentication_classes((TokenAuthentication,))(view) view = api_view(['POST'])(view) return view
def decorator(api_func): wrapped_func = check_authentication(func=api_func) if need_token: wrapped_func = check_token(func=wrapped_func) wrapped_func = pack_response(func=wrapped_func) wrapped_func = prepare_request_data(func=wrapped_func) wrapped_func = api_view(http_method_names=REQUEST_METHOD_LIST)(func=wrapped_func) wrapped_func = require_http_methods(request_method_list=REQUEST_METHOD_LIST)(func=wrapped_func) return wrapped_func
def contract_summary_data(request): sql = """select json_agg(row_to_json(qq)) from (select month_contract, (sum(s))::int total_price , count(*) contract_count from (SELECT (to_char(start_of_contract,'YYYY-MM-01'))::date as month_contract , price_contract s FROM public.contracts_contract where status = 'actual' ) q group by month_contract order by month_contract)qq;""" with connection.cursor() as cursor: cursor.execute(sql) row = cursor.fetchone() return Response(row[0]) \ \ \ @api_view(['GET'])
def _list_view(self): """ Make and return list view function for retrieving/filtering lists of model instances. The view itself accepts a url parameter - `query=...` containing a JSON serialized query. If provided, this is handled by the `interface.Query` class. """ def list_view(request: Request): query_json = request.query_params.get('query') fields_json = request.query_params.get('fields') page_num = request.query_params.get('page') page_size = request.query_params.get('pagesize', 25) queryset = self.queryset() # If no query is provided, all objects will be returned. if query_json: # Todo: find root cause of this. query_json = query_json.replace(u'\ufeff', '') query_data = json.loads(query_json) query = Query(**query_data) queryset = query.apply_to_queryset(queryset=queryset) # If fields are provided, subset the serializer fields accordingly. if page_num: paginator = Paginator(queryset, page_size) num_results = paginator.count num_pages = paginator.num_pages queryset = paginator.get_page(number=page_num) if fields_json: fields = json.loads(fields_json) serializer_cls = subset_serializer( select_fields=fields, serializer_cls=self.serializer_cls) serializer = serializer_cls(queryset, many=True) else: serializer = self._get_serializer(queryset, many=True) if page_num: return Response({ 'num_results': num_results, 'num_pages': num_pages, 'data': serializer.data }) return Response(serializer.data, status=status.HTTP_200_OK) # 'Get' permissions are treated as equivalent to 'list' permissions. if self.get_permissions: list_view.permission_classes = self.get_permissions return api_view(['GET'])(list_view)
def as_view(cls, *args, **kwargs): view = super().as_view(*args, **kwargs) # if settings.DEBUG is False: # view = permission_classes((IsAuthenticated,))(view) # else: # view = permission_classes((AllowAny,))(view) view = permission_classes((IsAuthenticated, ))(view) view = authentication_classes( api_settings.DEFAULT_AUTHENTICATION_CLASSES)(view) view = api_view(["GET", "POST"])(view) return view
def update_action_value_car(data): try: dens = float(data.GET.get("density")) dist = float(data.GET.get("distance")) time = data.GET.get("time") tid = int(data.GET.get("tripID")) isended = data.GET.get("isended") print(type(dist)) return JsonResponse(dist, safe=False) except ValueError as e: return Response(e.args[0], status.HTTP_400_BAD_REQUEST) @ api_view( ["GET"])
def _get_view(self): """ Make and return view function for retrieving data. """ def get_view(request, pk): instance = self.model_cls.objects.get(pk=pk) serializer = self._get_serializer(instance) return Response(serializer.data) if self.get_permissions: get_view.permission_classes = self.get_permissions return api_view(['GET'])(get_view)
def _delete_view(self): """ Make and return the delete view function. """ def delete_view(request, pk): instance = self.model_cls.objects.get(pk=pk) instance.delete() return Response({}, status=status.HTTP_200_OK) if self.delete_permissions: delete_view.permission_classes = self.delete_permissions return api_view(['DELETE'])(delete_view)
def as_view(cls: "RestGraphQL", schema: graphene.Schema) -> "RestGraphQL": """Instantiate the RestGraphQL instance and wrap the view with the DRF authentication_classes, permission_classes and api_view decorators. Args: cls (RestGraphQL): The RestGraphQL class object schema (Schema): A graphene Schema object Returns: A django view """ view = super().as_view(graphiql=True, schema=schema) view = authentication_classes(api_settings.DEFAULT_AUTHENTICATION_CLASSES)(view) view = permission_classes(api_settings.DEFAULT_PERMISSION_CLASSES)(view) return api_view(http_method_names=("GET", "POST"))(view)
def decorator(view): def add_cors(handler): @functools.wraps(handler) def view_with_cors(request, *args, **kw): request.CORS = methods if headers: request.CORS_HEADERS = headers return handler(request, *args, **kw) return view_with_cors # The request.CORS attributes need to be added to the view before # the DRF @api_view handler executes. return add_cors(api_view(methods)(view))
def _create_view(self): """ Make and return view function for creating object of this Type. """ def create_view(request): serializer = self._get_serializer(data=request.data) serializer.is_valid(raise_exception=True) serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) if self.create_permissions: create_view.permission_classes = self.create_permissions return api_view(['POST'])(create_view)
def add_Position(request): payload = json.loads(request.body) try: position = Position.objects.create( name=payload["name"], position_id=payload["position_id"], ) serializer = PositionSerializer(position) return JsonResponse({'position': serializer.data}, safe=False, status=status.HTTP_201_CREATED) except ObjectDoesNotExist as e: return JsonResponse({'error': str(e)}, safe=False, status=status.HTTP_404_NOT_FOUND) except Exception: return JsonResponse({'error': 'Something terrible went wrong'}, safe=False, status=status.HTTP_500_INTERNAL_SERVER_ERROR) @ api_view(["POST"])
def test_ok(self): method = 'POST' input_view = (api_view([method]))(self._dummy_view) output_view = self.decorator(input_view) self.assertIsInstance(output_view, Callable) wrapper_cls = output_view.cls self.assertEqual(wrapper_cls.get_serializer_class(), ExampleSerializer) self.assertEqual(type(wrapper_cls.get_serializer()), ExampleSerializer) schema = wrapper_cls().schema # Ensure that get_link works properly. self.assertIsNotNone(uritemplate) link = schema.get_link('/api/dummy-view/', method, None) self.assertEqual(len(link.fields), 1) self.assertEqual(link.fields[0].name, 'test_field') self.assertTrue(link.fields[0].required)
def reviews_list(request): if request.method == 'GET': reviews = Review.objects.all() serializer = ReviewSerializer2(reviews, many=True) return Response(serializer.data) elif request.method == 'POST': serializer = ReviewSerializer2(data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response( {'error': serializer.errors}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) @ api_view( ['GET', 'POST'])
def _update_view(self): """ Make and return view function for updating object of this Type. """ def update_view(request, pk): instance = self.model_cls.objects.get(pk=pk) serializer = self._get_serializer(data=request.data) serializer.is_valid(raise_exception=True) serializer.update(instance=instance, validated_data=request.data) return Response(serializer.data, status=status.HTTP_200_OK) if self.update_permissions: update_view.permission_classes = self.update_permissions return api_view(['POST'])(update_view)
def decorator(func): @wraps(func) def inner_func(request, *args, **kwargs): result = func(request, *args, **kwargs) if isinstance(result, Response): return result if not serializer: return Response(result) many = isinstance(result, (list, QuerySet)) return Response(serializer(result, many=many, context=dict(request=request)).data) view = api_view(http_method_names)(inner_func) if input_serializer: view_class = view.view_class view_class.serializer_class = input_serializer # Reprise des méthodes d'accès au serializer pour les métadonnées de l'APIView from rest_framework.generics import GenericAPIView view_class.get_serializer = GenericAPIView.get_serializer view_class.get_serializer_context = GenericAPIView.get_serializer_context view_class.get_serializer_class = GenericAPIView.get_serializer_class if validation: # POST post_handler = getattr(view_class, 'post', None) if post_handler: def handler(self, request, *args, **kwargs): serializer_instance = input_serializer(data=request.data) serializer_instance.is_valid(raise_exception=True) request.validated_data = serializer_instance.validated_data return post_handler(self, request, *args, **kwargs) view_class.post = handler # PUT put_handler = getattr(view_class, 'put', None) if put_handler: def handler(self, request, *args, **kwargs): partial = kwargs.pop('partial', False) instance = self.get_object() serializer_instance = input_serializer(instance, data=request.data, partial=partial) serializer_instance.is_valid(raise_exception=True) request.validated_data = serializer_instance.validated_data return post_handler(self, request, *args, **kwargs) view_class.put = handler return view
def test_browsable_renderer_put_render(self): """ Test, that PUT method works with BrowsableAPIRenderer This was not working in the past, because of `_get_serializer` didn't allow `instance parameter. """ data = {'blah': 'blah'} method = 'PUT' request = rest_request.Request(APIRequestFactory().get('blah')) input_view = (api_view([method]))(self._dummy_view) output_view = self.decorator(input_view) wrapper_cls = output_view.cls test_view_instance = wrapper_cls() renderer = renderers.BrowsableAPIRenderer() renderer.accepted_media_type = None renderer.renderer_context = {} response = renderer.get_raw_data_form( data, test_view_instance, method, request, ) self.assertEqual(response.data, {})
url(r'^(?P<project_id>\d+)/neurons/$', neuron.list_neurons), url(r'^(?P<project_id>\d+)/neurons/from-models$', neuron.get_neuron_ids_from_models), ] # Node access urlpatterns += [ url(r'^(?P<project_id>\d+)/node/(?P<node_id>\d+)/reviewed$', record_view("nodes.add_or_update_review")(node.update_location_reviewer)), url(r'^(?P<project_id>\d+)/nodes/most-recent$', node.most_recent_treenode), url(r'^(?P<project_id>\d+)/nodes/location$', node.get_locations), url(r'^(?P<project_id>\d+)/node/nearest$', node.node_nearest), url(r'^(?P<project_id>\d+)/node/update$', record_view("nodes.update_location")(node.node_update)), url(r'^(?P<project_id>\d+)/node/list$', node.node_list_tuples), url(r'^(?P<project_id>\d+)/node/get_location$', node.get_location), url(r'^(?P<project_id>\d+)/node/user-info$', node.user_info), url(r'^(?P<project_id>\d+)/nodes/find-labels$', node.find_labels), url(r'^(?P<project_id>\d+)/nodes/$', api_view(['POST'])(node.node_list_tuples)), ] # Treenode access urlpatterns += [ url(r'^(?P<project_id>\d+)/treenode/create$', record_view("treenodes.create")(treenode.create_treenode)), url(r'^(?P<project_id>\d+)/treenode/insert$', record_view("treenodes.insert")(treenode.insert_treenode)), url(r'^(?P<project_id>\d+)/treenode/delete$', record_view("treenodes.remove")(treenode.delete_treenode)), url(r'^(?P<project_id>\d+)/treenodes/compact-detail$', treenode.compact_detail_list), url(r'^(?P<project_id>\d+)/treenodes/(?P<treenode_id>\d+)/info$', treenode.treenode_info), url(r'^(?P<project_id>\d+)/treenodes/(?P<treenode_id>\d+)/compact-detail$', treenode.compact_detail), url(r'^(?P<project_id>\d+)/treenodes/(?P<treenode_id>\d+)/children$', treenode.find_children), url(r'^(?P<project_id>\d+)/treenodes/(?P<treenode_id>\d+)/confidence$', record_view("treenodes.update_confidence")(treenode.update_confidence)), url(r'^(?P<project_id>\d+)/treenodes/(?P<treenode_id>\d+)/parent$', record_view("treenodes.update_parent")(treenode.update_parent)), url(r'^(?P<project_id>\d+)/treenode/(?P<treenode_id>\d+)/radius$', record_view("treenodes.update_radius")(treenode.update_radius)), url(r'^(?P<project_id>\d+)/treenodes/radius$', record_view("treenodes.update_radius")(treenode.update_radii)),
def superuser_required(function=None, redirect_field_name=REDIRECT_FIELD_NAME, login_url=None): """ Decorator for views that checks that the user is logged in and is super user, redirecting to the log-in page if necessary. """ actual_decorator = user_passes_test( lambda u: u.is_authenticated() and u.is_superuser, login_url=login_url, redirect_field_name=redirect_field_name ) if function: return actual_decorator(function) return actual_decorator require_GET = api_view(["GET"]) require_POST = api_view(["POST"]) require_DELETE = api_view(["DELETE"]) require_PUT = api_view(["PUT"]) def api_enabled(enabled): def decorator(func): @wraps(func) def wrapped_view(*args, **kwargs): if enabled: return func(*args, **kwargs) else:
def api_get_view(func): return api_view()(func)
def api_post_view(func): return api_view(['POST'])(func)
@api_view(['GET']) def image_square_name(request, width, name): """ Get Image by Name as Square """ return create_Repsonse(square_image(width,Image.open(get_Photo(name)))) @api_view(['GET']) def image_rectangle(request, width, height): """ Get Random Image as Rectangle """ return create_Repsonse(rectancle_image(width,height,Image.open(random_Photo()))) @api_view(['GET']) def image_rectangle_name(request, width, height, name): """ Get Image by name as Rectangle """ return create_Repsonse(rectancle_image(width,height,Image.open(get_Photo(name)))) api_view(['GET']) def get_random_image_category(request,category): """ Get Random Image from Category """ if not (category in dict(Photo.CATEGORY)): raise Http404 return create_Repsonse(Image.open(random_Photo_category(category))) api_view(['GET']) def get_random_image_category_square(request,category,width): """ Get random Square Image from Category """ if not (category in dict(Photo.CATEGORY)): raise Http404 return create_Repsonse(square_image(width,Image.open(random_Photo_category(category)))) api_view(['GET']) def get_random_image_category_size(request,category,width,height):
def as_view(cls, *args, **kwargs): view = super(GraphQLView, cls).as_view(*args, **kwargs) view = permission_classes((IsAuthenticated,))(view) view = authentication_classes(api_settings.DEFAULT_AUTHENTICATION_CLASSES)(view) view = api_view(['GET', 'POST'])(view) return view
permission_classes = [IsAdminUser, ] class PermissionViewSet(ModelViewSet): """ A permission that can be given to or revoked from a user """ queryset = Permission.objects.all() serializer_class = PermissionSerializer permission_classes = [IsAdminUser, ] class TokenViewSet(ModelViewSet): """ A token for logging in to the API """ queryset = Token.objects.all() serializer_class = TokenSerializer permission_classes = [IsAdminUser, ] all_views = {} for routine_class in Routine.__subclasses__(): def view_func(request, routine=routine_class()): return Response(routine.to_json()) view_func.__name__ = routine_class.__name__ view_func.__doc__ = routine_class.__doc__ # We can't use `api_view` as a decorator because we can't call it until we # have set the __name__ and __doc__ of `view_func`. Thus, we explicitly # call `api_view` afterwards view_fun = permission_classes((IsAdminUser, ))(view_func) view_func = api_view()(view_func) all_views[slugify(routine_class.title.lower())] = view_func