genericparser/packages/views/nsdm_subscription_views.py

   1 # Copyright (C) 2019 Verizon. All Rights Reserved
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #         http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 import logging
  16 import traceback
  17
  18 from drf_yasg.utils import swagger_auto_schema, no_body
  19 from rest_framework import status
  20 from rest_framework.decorators import api_view
  21 from rest_framework.response import Response
  22
  23 from genericparser.packages.serializers.nsdm_filter_data \
  24     import NsdmNotificationsFilter
  25 from genericparser.packages.serializers.nsdm_subscription import \
  26     NsdmSubscriptionsSerializer, \
  27     NsdmSubscriptionIdSerializer, \
  28     NsdmSubscriptionSerializer, \
  29     NsdmSubscriptionRequestSerializer
  30 from genericparser.packages.serializers.response \
  31     import ProblemDetailsSerializer
  32 from genericparser.pub.exceptions import \
  33     ResourceNotFoundException, \
  34     NsdmBadRequestException, NsdmDuplicateSubscriptionException
  35 from genericparser.packages.biz.nsdm_subscription import NsdmSubscription
  36
  37
  38 logger = logging.getLogger(__name__)
  39
  40
  41 def validate_data(data, serializer):
  42     serialized_data = serializer(data=data)
  43     if not serialized_data.is_valid():
  44         logger.error('Data validation failed.')
  45         raise NsdmBadRequestException(serialized_data.errors)
  46     return serialized_data
  47
  48
  49 def get_problem_details_serializer(title, status_code, error_message):
  50     problem_details = {
  51         "title": title,
  52         "status": status_code,
  53         "detail": error_message
  54     }
  55     problem_details_serializer = ProblemDetailsSerializer(data=problem_details)
  56     problem_details_serializer.is_valid()
  57     return problem_details_serializer
  58
  59
  60 @swagger_auto_schema(
  61     method='POST',
  62     operation_description="Create Subscription for NSD Management",
  63     request_body=NsdmSubscriptionRequestSerializer(),
  64     responses={
  65         status.HTTP_201_CREATED: NsdmSubscriptionSerializer,
  66         status.HTTP_303_SEE_OTHER: ProblemDetailsSerializer(),
  67         status.HTTP_400_BAD_REQUEST: ProblemDetailsSerializer(),
  68         status.HTTP_500_INTERNAL_SERVER_ERROR: ProblemDetailsSerializer()
  69     }
  70 )
  71 @swagger_auto_schema(
  72     method='GET',
  73     operation_description="Query subscriptions for Nsd Management",
  74     request_body=no_body,
  75     responses={
  76         status.HTTP_200_OK: NsdmSubscriptionsSerializer(),
  77         status.HTTP_400_BAD_REQUEST: ProblemDetailsSerializer(),
  78         status.HTTP_404_NOT_FOUND: ProblemDetailsSerializer(),
  79         status.HTTP_500_INTERNAL_SERVER_ERROR: ProblemDetailsSerializer(),
  80     }
  81 )
  82 @api_view(http_method_names=['POST', 'GET'])
  83 def nsd_subscription_rc(request):
  84     if request.method == 'POST':
  85         logger.debug("SubscribeNotification--post::> %s" % request.data)
  86         try:
  87             title = 'Creating Subscription Failed!'
  88             nsdm_subscription_request = \
  89                 validate_data(request.data,
  90                               NsdmSubscriptionRequestSerializer)
  91             subscription = NsdmSubscription().create(
  92                 nsdm_subscription_request.data)
  93             subscription_resp = validate_data(subscription,
  94                                               NsdmSubscriptionSerializer)
  95             return Response(data=subscription_resp.data,
  96                             status=status.HTTP_201_CREATED)
  97         except NsdmDuplicateSubscriptionException as e:
  98             logger.error(e.message)
  99             problem_details_serializer = \
 100                 get_problem_details_serializer(title,
 101                                                status.HTTP_303_SEE_OTHER,
 102                                                e.message)
 103             return Response(data=problem_details_serializer.data,
 104                             status=status.HTTP_303_SEE_OTHER)
 105         except NsdmBadRequestException as e:
 106             problem_details_serializer = \
 107                 get_problem_details_serializer(title,
 108                                                status.HTTP_400_BAD_REQUEST,
 109                                                e.message)
 110             return Response(data=problem_details_serializer.data,
 111                             status=status.HTTP_400_BAD_REQUEST)
 112         except Exception as e:
 113             logger.error(e.message)
 114             logger.error(traceback.format_exc())
 115             problem_details_serializer = \
 116                 get_problem_details_serializer(
 117                     title,
 118                     status.HTTP_500_INTERNAL_SERVER_ERROR,
 119                     e.message)
 120             return Response(data=problem_details_serializer.data,
 121                             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 122     if request.method == 'GET':
 123         logger.debug("Subscription Notification GET %s" % request.query_params)
 124         try:
 125             title = 'Query Subscription Failed!'
 126             request_query_params = {}
 127             if request.query_params:
 128                 request_query_params = \
 129                     validate_data(request.query_params,
 130                                   NsdmNotificationsFilter).data
 131             subscription_data = \
 132                 NsdmSubscription().query_multi_subscriptions(
 133                     request_query_params)
 134             subscriptions = validate_data(subscription_data,
 135                                           NsdmSubscriptionsSerializer)
 136             return Response(data=subscriptions.data, status=status.HTTP_200_OK)
 137         except NsdmBadRequestException as e:
 138             logger.error(e.message)
 139             problem_details_serializer = \
 140                 get_problem_details_serializer(title,
 141                                                status.HTTP_400_BAD_REQUEST,
 142                                                e.message)
 143             return Response(data=problem_details_serializer.data,
 144                             status=status.HTTP_400_BAD_REQUEST)
 145         except ResourceNotFoundException as e:
 146             problem_details_serializer = \
 147                 get_problem_details_serializer(title,
 148                                                status.HTTP_404_NOT_FOUND,
 149                                                e.message)
 150             return Response(data=problem_details_serializer.data,
 151                             status=status.HTTP_404_NOT_FOUND)
 152         except Exception as e:
 153             logger.error(e.message)
 154             problem_details_serializer = \
 155                 get_problem_details_serializer(
 156                     title,
 157                     status.HTTP_500_INTERNAL_SERVER_ERROR,
 158                     traceback.format_exc())
 159             return Response(data=problem_details_serializer.data,
 160                             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 161
 162
 163 @swagger_auto_schema(
 164     method='GET',
 165     operation_description="Query subscriptions for Nsd Management",
 166     request_body=no_body,
 167     responses={
 168         status.HTTP_200_OK: NsdmSubscriptionSerializer(),
 169         status.HTTP_400_BAD_REQUEST: ProblemDetailsSerializer(),
 170         status.HTTP_404_NOT_FOUND: ProblemDetailsSerializer(),
 171         status.HTTP_500_INTERNAL_SERVER_ERROR: ProblemDetailsSerializer()
 172     }
 173 )
 174 @swagger_auto_schema(
 175     method='DELETE',
 176     operation_description="Delete subscription for Nsd Management",
 177     request_body=no_body,
 178     responses={
 179         status.HTTP_204_NO_CONTENT: 'No_Content',
 180         status.HTTP_400_BAD_REQUEST: ProblemDetailsSerializer(),
 181         status.HTTP_404_NOT_FOUND: ProblemDetailsSerializer(),
 182         status.HTTP_500_INTERNAL_SERVER_ERROR: ProblemDetailsSerializer()
 183     }
 184 )
 185 @api_view(http_method_names=['GET', 'DELETE'])
 186 def nsd_subscription_rd(request, **kwargs):
 187     subscription_id = kwargs.get("subscriptionId")
 188     if request.method == 'GET':
 189         try:
 190             title = 'Query Subscription Failed!'
 191             validate_data({'subscription_id': subscription_id},
 192                           NsdmSubscriptionIdSerializer)
 193             subscription_data = \
 194                 NsdmSubscription().query_single_subscription(subscription_id)
 195             subscription = validate_data(subscription_data,
 196                                          NsdmSubscriptionSerializer)
 197             return Response(data=subscription.data, status=status.HTTP_200_OK)
 198         except NsdmBadRequestException as e:
 199             logger.error(e.message)
 200             problem_details_serializer = \
 201                 get_problem_details_serializer(title,
 202                                                status.HTTP_400_BAD_REQUEST,
 203                                                e.message)
 204             return Response(data=problem_details_serializer.data,
 205                             status=status.HTTP_400_BAD_REQUEST)
 206         except ResourceNotFoundException as e:
 207             logger.error(e.message)
 208             problem_details_serializer = \
 209                 get_problem_details_serializer(title,
 210                                                status.HTTP_404_NOT_FOUND,
 211                                                e.message)
 212             return Response(data=problem_details_serializer.data,
 213                             status=status.HTTP_404_NOT_FOUND)
 214         except Exception as e:
 215             logger.error(e.message)
 216             logger.error(traceback.format_exc())
 217             problem_details_serializer = \
 218                 get_problem_details_serializer(
 219                     title,
 220                     status.HTTP_500_INTERNAL_SERVER_ERROR,
 221                     "Query of subscriptioni(%s) Failed"
 222                     % subscription_id)
 223             return Response(data=problem_details_serializer.data,
 224                             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 225     elif request.method == 'DELETE':
 226         try:
 227             title = 'Delete Subscription Failed!'
 228             validate_data({'subscription_id': subscription_id},
 229                           NsdmSubscriptionIdSerializer)
 230             subscription_data = NsdmSubscription().\
 231                 delete_single_subscription(subscription_id)
 232             return Response(status=status.HTTP_204_NO_CONTENT)
 233         except NsdmBadRequestException as e:
 234             logger.error(e.message)
 235             problem_details_serializer = \
 236                 get_problem_details_serializer(title,
 237                                                status.HTTP_400_BAD_REQUEST,
 238                                                e.message)
 239             return Response(data=problem_details_serializer.data,
 240                             status=status.HTTP_400_BAD_REQUEST)
 241         except ResourceNotFoundException as e:
 242             logger.error(e.message)
 243             problem_details_serializer = \
 244                 get_problem_details_serializer(title,
 245                                                status.HTTP_404_NOT_FOUND,
 246                                                e.message)
 247             return Response(data=problem_details_serializer.data,
 248                             status=status.HTTP_404_NOT_FOUND)
 249         except Exception as e:
 250             logger.error(e.message)
 251             logger.error(traceback.format_exc())
 252             problem_details_serializer = \
 253                 get_problem_details_serializer(
 254                     title,
 255                     status.HTTP_500_INTERNAL_SERVER_ERROR,
 256                     "Delete of subscription(%s) Failed"
 257                     % subscription_id)
 258             return Response(data=problem_details_serializer.data,
 259                             status=status.HTTP_500_INTERNAL_SERVER_ERROR)