Refactor vfc-vnfmgr view.py

[vfc/gvnfm/vnfmgr.git] / mgr / mgr / vnfreg / views.py

diff --git a/mgr/mgr/vnfreg/views.py b/mgr/mgr/vnfreg/views.py
index 7524dcf..abfe858 100644 (file)
--- a/mgr/mgr/vnfreg/views.py
+++ b/mgr/mgr/vnfreg/views.py
@@ -12,8 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import logging
 import json
+import logging
 import traceback
 
 from drf_yasg import openapi
@@ -23,38 +23,29 @@ from rest_framework.decorators import api_view
 from rest_framework.response import Response
 from rest_framework.views import APIView
 
-from mgr.pub.utils.values import ignore_case_get
-from mgr.pub.utils.syscomm import fun_name
 from mgr.pub.database.models import VnfRegModel
 from mgr.pub.utils import restcall
-from mgr.vnfreg.serializers import ErrorSerializer, VnfInfoSerializer, ResponseSerializer, NoneSerializer, \
-    VnfConfigSerializer
+from mgr.pub.utils.syscomm import fun_name
+from mgr.pub.utils.values import ignore_case_get
+from mgr.vnfreg.serializers import VnfInfoSerializer, ResponseSerializer, VnfConfigSerializer
 
 logger = logging.getLogger(__name__)
 
 
-def handler_exception(e):
-    logger.error(e.message)
-    logger.error(traceback.format_exc())
-    errorSerializer = ErrorSerializer(data={'error': e.message})
-    errorSerializer.is_valid()
-    return errorSerializer.data
-
-
 class vnfmgr_addvnf(APIView):
     @swagger_auto_schema(request_body=VnfInfoSerializer(),
                          responses={
-                             201: ResponseSerializer(),
-                             500: ErrorSerializer()})
+                             status.HTTP_201_CREATED: ResponseSerializer(),
+                             status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
     def post(self, request):
         logger.info("Enter %s, data is %s", fun_name(), request.data)
-        requestSerializer = VnfInfoSerializer(data=request.data)
-        request_isValid = requestSerializer.is_valid()
+        request_serializer = VnfInfoSerializer(data=request.data)
+        request_isvalid = request_serializer.is_valid()
         try:
-            if not request_isValid:
-                raise Exception(requestSerializer.errors)
+            if not request_isvalid:
+                raise Exception(request_serializer.errors)
 
-            requestData = requestSerializer.data
+            requestData = request_serializer.data
             vnf_inst_id = ignore_case_get(requestData, "vnfInstId")
             if VnfRegModel.objects.filter(id=vnf_inst_id):
                 raise Exception("Vnf(%s) already exists." % vnf_inst_id)
@@ -65,26 +56,27 @@ class vnfmgr_addvnf(APIView):
                 username=ignore_case_get(requestData, "username"),
                 password=ignore_case_get(requestData, "password")).save()
 
-            responseSerializer = ResponseSerializer(data={"vnfInstId": vnf_inst_id})
-            isValid = responseSerializer.is_valid()
-            if not isValid:
-                raise Exception(responseSerializer.errors)
-        except Exception as e:
-            errorData = handler_exception(e)
-            return Response(data=errorData, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+            response_serializer = ResponseSerializer(data={"vnfInstId": vnf_inst_id})
+            resp_isvalid = response_serializer.is_valid()
+            if not resp_isvalid:
+                raise Exception(response_serializer.errors)
 
-        return Response(data=responseSerializer.data, status=status.HTTP_201_CREATED)
+            return Response(data=response_serializer.data, status=status.HTTP_201_CREATED)
+        except Exception as e:
+            logger.error(e.message)
+            logger.error(traceback.format_exc())
+            return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 
 
 @swagger_auto_schema(method='put',
                      request_body=VnfInfoSerializer(),
                      responses={
-                         202: NoneSerializer(),
-                         500: ErrorSerializer()})
+                         status.HTTP_202_ACCEPTED: 'successfully',
+                         status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
 @swagger_auto_schema(method='delete',
                      responses={
-                         204: NoneSerializer(),
-                         500: ErrorSerializer()})
+                         status.HTTP_204_NO_CONTENT: 'successfully',
+                         status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
 @swagger_auto_schema(methods=['get'],
                      manual_parameters=[
                          openapi.Parameter('test',
@@ -93,12 +85,10 @@ class vnfmgr_addvnf(APIView):
                                            type=openapi.TYPE_BOOLEAN
                                            ), ],
                      responses={
-                         200: openapi.Response('response description', VnfInfoSerializer()),
-                         500: ErrorSerializer()})
+                         status.HTTP_200_OK: openapi.Response('response description', VnfInfoSerializer()),
+                         status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
 @api_view(http_method_names=['GET', 'PUT', 'DELETE'])
 def access_vnf(request, *args, **kwargs):
-    requestSerializer = VnfInfoSerializer(data=request.data)
-    request_isValid = requestSerializer.is_valid()
     vnf_inst_id = ignore_case_get(kwargs, "vnfInstId")
     logger.info("Enter %s, method is %s, ", fun_name(), request.method)
     logger.info("vnfInstId is %s, data is %s", vnf_inst_id, request.data)
@@ -115,16 +105,20 @@ def access_vnf(request, *args, **kwargs):
                 "username": vnf[0].username,
                 "password": vnf[0].password
             }
-            responseSerializer = VnfInfoSerializer(data=resp)
-            if not responseSerializer.is_valid():
-                raise Exception(responseSerializer.errors)
-            ret = responseSerializer.data
+            response_serializer = VnfInfoSerializer(data=resp)
+            if not response_serializer.is_valid():
+                raise Exception(response_serializer.errors)
+
+            ret = response_serializer.data
             normal_status = status.HTTP_200_OK
         elif request.method == 'PUT':
-            if not request_isValid:
-                raise Exception(requestSerializer.errors)
+            request_serializer = VnfInfoSerializer(data=request.data)
+            request_isvalid = request_serializer.is_valid()
 
-            requestData = requestSerializer.data
+            if not request_isvalid:
+                raise Exception(request_serializer.errors)
+
+            requestData = request_serializer.data
             ip = ignore_case_get(requestData, "ip")
             port = ignore_case_get(requestData, "port")
             username = ignore_case_get(requestData, "username")
@@ -144,27 +138,29 @@ def access_vnf(request, *args, **kwargs):
             vnf.delete()
             ret = {}
             normal_status = status.HTTP_204_NO_CONTENT
+
+        return Response(data=ret, status=normal_status)
     except Exception as e:
-        errorData = handler_exception(e)
-        return Response(data=errorData, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-    return Response(data=ret, status=normal_status)
+        logger.error(e.message)
+        logger.error(traceback.format_exc())
+        return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 
 
 @swagger_auto_schema(method='post',
                      request_body=VnfConfigSerializer(),
                      responses={
-                         202: NoneSerializer(),
-                         500: ErrorSerializer()})
+                         status.HTTP_202_ACCEPTED: 'successfully',
+                         status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
 @api_view(http_method_names=['POST'])
 def vnf_config(request, *args, **kwargs):
     logger.info("Enter %s, data is %s", fun_name(), request.data)
-    requestSerializer = VnfConfigSerializer(data=request.data)
-    request_isValid = requestSerializer.is_valid()
     try:
-        if not request_isValid:
-            raise Exception(requestSerializer.errors)
+        request_serializer = VnfConfigSerializer(data=request.data)
+        request_isvalid = request_serializer.is_valid()
+        if not request_isvalid:
+            raise Exception(request_serializer.errors)
 
-        requestData = requestSerializer.data
+        requestData = request_serializer.data
         vnf_inst_id = ignore_case_get(requestData, "vnfInstanceId")
         vnf = VnfRegModel.objects.filter(id=vnf_inst_id)
         if not vnf:
@@ -179,7 +175,9 @@ def vnf_config(request, *args, **kwargs):
             content=json.dumps(requestData))
         if ret[0] != 0:
             raise Exception("Failed to config Vnf(%s): %s" % (vnf_inst_id, ret[1]))
+
+        return Response(data={}, status=status.HTTP_202_ACCEPTED)
     except Exception as e:
-        errorData = handler_exception(e)
-        return Response(data=errorData, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-    return Response(data={}, status=status.HTTP_202_ACCEPTED)
+        logger.error(e.message)
+        logger.error(traceback.format_exc())
+        return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)