diff --git a/docs/swagger/swagger.json b/docs/swagger/swagger.json
index a52fe8c..64b43ab 100644
--- a/docs/swagger/swagger.json
+++ b/docs/swagger/swagger.json
@@ -4,13 +4,13 @@
     "version" : "5.0.0-SNAPSHOT",
     "title" : "Clamp Rest API"
   },
-  "host" : "localhost:33631",
+  "host" : "localhost:37295",
   "basePath" : "/restservices/clds/",
   "schemes" : [ "http" ],
   "paths" : {
     "/v2/dictionary" : {
       "get" : {
-        "operationId" : "route80",
+        "operationId" : "route18",
         "produces" : [ "application/json" ],
         "responses" : {
           "200" : {
@@ -20,11 +20,11 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
-        "x-routeId" : "route80"
+        "x-camelContextId" : "camel-1",
+        "x-routeId" : "route18"
       },
       "put" : {
-        "operationId" : "route82",
+        "operationId" : "route20",
         "consumes" : [ "application/json" ],
         "produces" : [ "application/json" ],
         "parameters" : [ {
@@ -43,8 +43,8 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
-        "x-routeId" : "route82"
+        "x-camelContextId" : "camel-1",
+        "x-routeId" : "route20"
       }
     },
     "/v2/dictionary/{dictionaryName}" : {
@@ -64,7 +64,7 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
+        "x-camelContextId" : "camel-1",
         "x-routeId" : null
       }
     },
@@ -93,11 +93,11 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
+        "x-camelContextId" : "camel-1",
         "x-routeId" : null
       },
       "delete" : {
-        "operationId" : "route84",
+        "operationId" : "route22",
         "produces" : [ "application/json" ],
         "parameters" : [ {
           "name" : "name",
@@ -108,8 +108,8 @@
         "responses" : {
           "200" : { }
         },
-        "x-camelContextId" : "camel-3",
-        "x-routeId" : "route84"
+        "x-camelContextId" : "camel-1",
+        "x-routeId" : "route22"
       }
     },
     "/v2/dictionary/{name}/elements/{shortName}" : {
@@ -129,7 +129,7 @@
         "responses" : {
           "200" : { }
         },
-        "x-camelContextId" : "camel-3",
+        "x-camelContextId" : "camel-1",
         "x-routeId" : null
       }
     },
@@ -147,13 +147,13 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
+        "x-camelContextId" : "camel-1",
         "x-routeId" : null
       }
     },
     "/v2/loop/{loopName}" : {
       "get" : {
-        "operationId" : "route65",
+        "operationId" : "route3",
         "produces" : [ "application/json" ],
         "parameters" : [ {
           "name" : "loopName",
@@ -169,13 +169,13 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
-        "x-routeId" : "route65"
+        "x-camelContextId" : "camel-1",
+        "x-routeId" : "route3"
       }
     },
     "/v2/loop/delete/{loopName}" : {
       "put" : {
-        "operationId" : "route76",
+        "operationId" : "route14",
         "parameters" : [ {
           "name" : "loopName",
           "in" : "path",
@@ -185,13 +185,13 @@
         "responses" : {
           "200" : { }
         },
-        "x-camelContextId" : "camel-3",
-        "x-routeId" : "route76"
+        "x-camelContextId" : "camel-1",
+        "x-routeId" : "route14"
       }
     },
     "/v2/loop/deploy/{loopName}" : {
       "put" : {
-        "operationId" : "route70",
+        "operationId" : "route8",
         "produces" : [ "application/json" ],
         "parameters" : [ {
           "name" : "loopName",
@@ -207,13 +207,13 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
-        "x-routeId" : "route70"
+        "x-camelContextId" : "camel-1",
+        "x-routeId" : "route8"
       }
     },
     "/v2/loop/getAllNames" : {
       "get" : {
-        "operationId" : "route64",
+        "operationId" : "route2",
         "produces" : [ "application/json" ],
         "responses" : {
           "200" : {
@@ -226,13 +226,13 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
-        "x-routeId" : "route64"
+        "x-camelContextId" : "camel-1",
+        "x-routeId" : "route2"
       }
     },
     "/v2/loop/getstatus/{loopName}" : {
       "get" : {
-        "operationId" : "route77",
+        "operationId" : "route15",
         "produces" : [ "application/json" ],
         "parameters" : [ {
           "name" : "loopName",
@@ -248,13 +248,13 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
-        "x-routeId" : "route77"
+        "x-camelContextId" : "camel-1",
+        "x-routeId" : "route15"
       }
     },
     "/v2/loop/refreshOpPolicyJsonSchema/{loopName}" : {
       "put" : {
-        "operationId" : "route71",
+        "operationId" : "route9",
         "produces" : [ "application/json" ],
         "parameters" : [ {
           "name" : "loopName",
@@ -270,13 +270,13 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
-        "x-routeId" : "route71"
+        "x-camelContextId" : "camel-1",
+        "x-routeId" : "route9"
       }
     },
     "/v2/loop/restart/{loopName}" : {
       "put" : {
-        "operationId" : "route74",
+        "operationId" : "route12",
         "produces" : [ "application/json" ],
         "parameters" : [ {
           "name" : "loopName",
@@ -292,13 +292,13 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
-        "x-routeId" : "route74"
+        "x-camelContextId" : "camel-1",
+        "x-routeId" : "route12"
       }
     },
     "/v2/loop/stop/{loopName}" : {
       "put" : {
-        "operationId" : "route73",
+        "operationId" : "route11",
         "produces" : [ "application/json" ],
         "parameters" : [ {
           "name" : "loopName",
@@ -314,13 +314,13 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
-        "x-routeId" : "route73"
+        "x-camelContextId" : "camel-1",
+        "x-routeId" : "route11"
       }
     },
     "/v2/loop/submit/{loopName}" : {
       "put" : {
-        "operationId" : "route75",
+        "operationId" : "route13",
         "produces" : [ "application/json" ],
         "parameters" : [ {
           "name" : "loopName",
@@ -336,13 +336,13 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
-        "x-routeId" : "route75"
+        "x-camelContextId" : "camel-1",
+        "x-routeId" : "route13"
       }
     },
     "/v2/loop/svgRepresentation/{loopName}" : {
       "get" : {
-        "operationId" : "route66",
+        "operationId" : "route4",
         "produces" : [ "application/xml" ],
         "parameters" : [ {
           "name" : "loopName",
@@ -358,13 +358,13 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
-        "x-routeId" : "route66"
+        "x-camelContextId" : "camel-1",
+        "x-routeId" : "route4"
       }
     },
     "/v2/loop/undeploy/{loopName}" : {
       "put" : {
-        "operationId" : "route72",
+        "operationId" : "route10",
         "produces" : [ "application/json" ],
         "parameters" : [ {
           "name" : "loopName",
@@ -380,13 +380,13 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
-        "x-routeId" : "route72"
+        "x-camelContextId" : "camel-1",
+        "x-routeId" : "route10"
       }
     },
     "/v2/loop/updateGlobalProperties/{loopName}" : {
       "post" : {
-        "operationId" : "route67",
+        "operationId" : "route5",
         "consumes" : [ "application/json" ],
         "produces" : [ "application/json" ],
         "parameters" : [ {
@@ -410,13 +410,13 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
-        "x-routeId" : "route67"
+        "x-camelContextId" : "camel-1",
+        "x-routeId" : "route5"
       }
     },
     "/v2/loop/updateMicroservicePolicy/{loopName}" : {
       "post" : {
-        "operationId" : "route69",
+        "operationId" : "route7",
         "consumes" : [ "application/json" ],
         "produces" : [ "application/json" ],
         "parameters" : [ {
@@ -440,13 +440,13 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
-        "x-routeId" : "route69"
+        "x-camelContextId" : "camel-1",
+        "x-routeId" : "route7"
       }
     },
     "/v2/loop/updateOperationalPolicies/{loopName}" : {
       "post" : {
-        "operationId" : "route68",
+        "operationId" : "route6",
         "consumes" : [ "application/json" ],
         "produces" : [ "application/json" ],
         "parameters" : [ {
@@ -470,13 +470,13 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
-        "x-routeId" : "route68"
+        "x-camelContextId" : "camel-1",
+        "x-routeId" : "route6"
       }
     },
     "/v2/policyToscaModels" : {
       "get" : {
-        "operationId" : "route87",
+        "operationId" : "route25",
         "produces" : [ "application/json" ],
         "responses" : {
           "200" : {
@@ -486,8 +486,8 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
-        "x-routeId" : "route87"
+        "x-camelContextId" : "camel-1",
+        "x-routeId" : "route25"
       }
     },
     "/v2/policyToscaModels/{policyModelType}" : {
@@ -507,11 +507,11 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
+        "x-camelContextId" : "camel-1",
         "x-routeId" : null
       },
       "put" : {
-        "operationId" : "route88",
+        "operationId" : "route26",
         "consumes" : [ "plain/text" ],
         "produces" : [ "application/json" ],
         "parameters" : [ {
@@ -535,8 +535,8 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
-        "x-routeId" : "route88"
+        "x-camelContextId" : "camel-1",
+        "x-routeId" : "route26"
       }
     },
     "/v2/policyToscaModels/yaml/{policyModelType}" : {
@@ -556,13 +556,13 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
+        "x-camelContextId" : "camel-1",
         "x-routeId" : null
       }
     },
     "/v2/templates" : {
       "get" : {
-        "operationId" : "route91",
+        "operationId" : "route29",
         "produces" : [ "application/json" ],
         "responses" : {
           "200" : {
@@ -572,8 +572,8 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
-        "x-routeId" : "route91"
+        "x-camelContextId" : "camel-1",
+        "x-routeId" : "route29"
       }
     },
     "/v2/templates/{templateName}" : {
@@ -593,7 +593,7 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
+        "x-camelContextId" : "camel-1",
         "x-routeId" : null
       }
     },
@@ -611,13 +611,13 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
+        "x-camelContextId" : "camel-1",
         "x-routeId" : null
       }
     },
     "/v1/healthcheck" : {
       "get" : {
-        "operationId" : "route92",
+        "operationId" : "route30",
         "produces" : [ "application/json" ],
         "responses" : {
           "200" : {
@@ -627,19 +627,19 @@
             }
           }
         },
-        "x-camelContextId" : "camel-3",
-        "x-routeId" : "route92"
+        "x-camelContextId" : "camel-1",
+        "x-routeId" : "route30"
       }
     },
     "/v1/user/getUser" : {
       "get" : {
-        "operationId" : "route93",
+        "operationId" : "route31",
         "produces" : [ "text/plain" ],
         "responses" : {
           "200" : { }
         },
-        "x-camelContextId" : "camel-3",
-        "x-routeId" : "route93"
+        "x-camelContextId" : "camel-1",
+        "x-routeId" : "route31"
       }
     }
   },
@@ -809,19 +809,20 @@
         "number" : {
           "type" : "boolean"
         },
-        "string" : {
-          "type" : "boolean"
-        },
-        "boolean" : {
-          "type" : "boolean"
-        },
         "asString" : {
           "type" : "string"
         },
+        "asNumber" : {
+          "$ref" : "#/definitions/Number"
+        },
         "asDouble" : {
           "type" : "number",
           "format" : "double"
         },
+        "asFloat" : {
+          "type" : "number",
+          "format" : "float"
+        },
         "asLong" : {
           "type" : "integer",
           "format" : "int64"
@@ -830,13 +831,6 @@
           "type" : "integer",
           "format" : "int32"
         },
-        "asNumber" : {
-          "$ref" : "#/definitions/Number"
-        },
-        "asFloat" : {
-          "type" : "number",
-          "format" : "float"
-        },
         "asByte" : {
           "type" : "string",
           "format" : "byte"
@@ -854,6 +848,15 @@
           "type" : "integer",
           "format" : "int32"
         },
+        "boolean" : {
+          "type" : "boolean"
+        },
+        "string" : {
+          "type" : "boolean"
+        },
+        "asJsonArray" : {
+          "$ref" : "#/definitions/JsonArray"
+        },
         "asJsonObject" : {
           "$ref" : "#/definitions/JsonObject"
         },
@@ -869,9 +872,6 @@
         "jsonNull" : {
           "type" : "boolean"
         },
-        "asJsonArray" : {
-          "$ref" : "#/definitions/JsonArray"
-        },
         "asJsonPrimitive" : {
           "$ref" : "#/definitions/JsonPrimitive"
         },
@@ -909,6 +909,9 @@
         "pdpGroup" : {
           "type" : "string"
         },
+        "pdpSubGroup" : {
+          "type" : "string"
+        },
         "name" : {
           "type" : "string"
         },
@@ -952,23 +955,14 @@
         "asBoolean" : {
           "type" : "boolean"
         },
-        "asJsonObject" : {
-          "$ref" : "#/definitions/JsonObject"
-        },
         "asString" : {
           "type" : "string"
         },
-        "asDouble" : {
-          "type" : "number",
-          "format" : "double"
+        "asJsonArray" : {
+          "$ref" : "#/definitions/JsonArray"
         },
-        "asLong" : {
-          "type" : "integer",
-          "format" : "int64"
-        },
-        "asInt" : {
-          "type" : "integer",
-          "format" : "int32"
+        "asJsonObject" : {
+          "$ref" : "#/definitions/JsonObject"
         },
         "jsonArray" : {
           "type" : "boolean"
@@ -982,9 +976,6 @@
         "jsonNull" : {
           "type" : "boolean"
         },
-        "asJsonArray" : {
-          "$ref" : "#/definitions/JsonArray"
-        },
         "asJsonPrimitive" : {
           "$ref" : "#/definitions/JsonPrimitive"
         },
@@ -994,10 +985,22 @@
         "asNumber" : {
           "$ref" : "#/definitions/Number"
         },
+        "asDouble" : {
+          "type" : "number",
+          "format" : "double"
+        },
         "asFloat" : {
           "type" : "number",
           "format" : "float"
         },
+        "asLong" : {
+          "type" : "integer",
+          "format" : "int64"
+        },
+        "asInt" : {
+          "type" : "integer",
+          "format" : "int32"
+        },
         "asByte" : {
           "type" : "string",
           "format" : "byte"
@@ -1056,6 +1059,9 @@
           "items" : {
             "$ref" : "#/definitions/LoopElementModel"
           }
+        },
+        "policyPdpGroup" : {
+          "$ref" : "#/definitions/JsonObject"
         }
       },
       "x-className" : {
@@ -1127,6 +1133,9 @@
         "pdpGroup" : {
           "type" : "string"
         },
+        "pdpSubGroup" : {
+          "type" : "string"
+        },
         "name" : {
           "type" : "string"
         },
@@ -1144,23 +1153,14 @@
         "asBoolean" : {
           "type" : "boolean"
         },
-        "asJsonObject" : {
-          "$ref" : "#/definitions/JsonObject"
-        },
         "asString" : {
           "type" : "string"
         },
-        "asDouble" : {
-          "type" : "number",
-          "format" : "double"
+        "asJsonArray" : {
+          "$ref" : "#/definitions/JsonArray"
         },
-        "asLong" : {
-          "type" : "integer",
-          "format" : "int64"
-        },
-        "asInt" : {
-          "type" : "integer",
-          "format" : "int32"
+        "asJsonObject" : {
+          "$ref" : "#/definitions/JsonObject"
         },
         "jsonArray" : {
           "type" : "boolean"
@@ -1174,9 +1174,6 @@
         "jsonNull" : {
           "type" : "boolean"
         },
-        "asJsonArray" : {
-          "$ref" : "#/definitions/JsonArray"
-        },
         "asJsonPrimitive" : {
           "$ref" : "#/definitions/JsonPrimitive"
         },
@@ -1186,10 +1183,22 @@
         "asNumber" : {
           "$ref" : "#/definitions/Number"
         },
+        "asDouble" : {
+          "type" : "number",
+          "format" : "double"
+        },
         "asFloat" : {
           "type" : "number",
           "format" : "float"
         },
+        "asLong" : {
+          "type" : "integer",
+          "format" : "int64"
+        },
+        "asInt" : {
+          "type" : "integer",
+          "format" : "int32"
+        },
         "asByte" : {
           "type" : "string",
           "format" : "byte"
@@ -1218,10 +1227,17 @@
         "asString" : {
           "type" : "string"
         },
+        "asNumber" : {
+          "$ref" : "#/definitions/Number"
+        },
         "asDouble" : {
           "type" : "number",
           "format" : "double"
         },
+        "asFloat" : {
+          "type" : "number",
+          "format" : "float"
+        },
         "asLong" : {
           "type" : "integer",
           "format" : "int64"
@@ -1230,13 +1246,6 @@
           "type" : "integer",
           "format" : "int32"
         },
-        "asNumber" : {
-          "$ref" : "#/definitions/Number"
-        },
-        "asFloat" : {
-          "type" : "number",
-          "format" : "float"
-        },
         "asByte" : {
           "type" : "string",
           "format" : "byte"
@@ -1254,6 +1263,9 @@
           "type" : "integer",
           "format" : "int32"
         },
+        "asJsonArray" : {
+          "$ref" : "#/definitions/JsonArray"
+        },
         "asJsonObject" : {
           "$ref" : "#/definitions/JsonObject"
         },
@@ -1269,9 +1281,6 @@
         "jsonNull" : {
           "type" : "boolean"
         },
-        "asJsonArray" : {
-          "$ref" : "#/definitions/JsonArray"
-        },
         "asJsonPrimitive" : {
           "$ref" : "#/definitions/JsonPrimitive"
         },
diff --git a/docs/swagger/swagger.pdf b/docs/swagger/swagger.pdf
index 18a6316..394b7c6 100644
--- a/docs/swagger/swagger.pdf
+++ b/docs/swagger/swagger.pdf
Binary files differ
diff --git a/extra/sql/dump/test-data.sql b/extra/sql/dump/test-data.sql
index dd79eff..41ca89a 100644
--- a/extra/sql/dump/test-data.sql
+++ b/extra/sql/dump/test-data.sql
@@ -63,7 +63,7 @@
 
 LOCK TABLES `loop_element_models` WRITE;
 /*!40000 ALTER TABLE `loop_element_models` DISABLE KEYS */;
-INSERT INTO `loop_element_models` VALUES ('onap.policies.monitoring.cdap.tca.hi.lo.app',NULL,'2020-02-26 04:12:57.965164','Not found','2020-02-26 04:12:58.942851',NULL,NULL,'MICRO_SERVICE_TYPE',NULL);
+INSERT INTO `loop_element_models` VALUES ('onap.policies.monitoring.cdap.tca.hi.lo.app',NULL,'2020-02-27 15:08:46.764261','Not found','2020-02-27 15:08:48.172681',NULL,NULL,'MICRO_SERVICE_TYPE',NULL);
 /*!40000 ALTER TABLE `loop_element_models` ENABLE KEYS */;
 UNLOCK TABLES;
 
@@ -82,9 +82,9 @@
 
 LOCK TABLES `loop_templates` WRITE;
 /*!40000 ALTER TABLE `loop_templates` DISABLE KEYS */;
-INSERT INTO `loop_templates` VALUES ('LOOP_TEMPLATE_ur2KW_v1_0_ResourceInstanceName1_tca','Not found','2020-02-26 04:12:58.533953','Not found','2020-02-26 04:12:58.533953','CLOSED','tosca_definitions_version: cloudify_dsl_1_3\nimports:\n- http://www.getcloudify.org/spec/cloudify/3.4/types.yaml\n- https://onap.org:8443/repository/solutioning01-mte2-raw/type_files/docker/2.2.0/node-type.yaml\n- https://onap.org:8443/repository/solutioning01-mte2-raw/type_files/relationship/1.0.0/node-type.yaml\n- http://onap.org:8081/repository/solutioning01-mte2-raw/type_files/dmaap/dmaap_mr.yaml\ninputs:\n  location_id:\n    type: string\n  service_id:\n    type: string\n  policy_id:\n    type: string\nnode_templates:\n  policy_0:\n    type: dcae.nodes.policy\n    properties:\n      policy_id: \n        get_input: policy_id\n      policy_model_id: \"onap.policies.monitoring.cdap.tca.hi.lo.app\"\n  cdap_host_host:\n    type: dcae.nodes.StreamingAnalytics.SelectedCDAPInfrastructure\n    properties:\n      location_id:\n        get_input: location_id\n      scn_override: cdap_broker.solutioning-central.dcae.onap.org\n    interfaces:\n      cloudify.interfaces.lifecycle: {\n        }\n  tca_tca:\n    type: dcae.nodes.MicroService.cdap\n    properties:\n      app_config:\n        appDescription: DCAE Analytics Threshold Crossing Alert Application\n        appName: dcae-tca\n        tcaSubscriberOutputStreamName: TCASubscriberOutputStream\n        tcaVESAlertsTableName: TCAVESAlertsTable\n        tcaVESAlertsTableTTLSeconds: \'1728000\'\n        tcaVESMessageStatusTableName: TCAVESMessageStatusTable\n        tcaVESMessageStatusTableTTLSeconds: \'86400\'\n        thresholdCalculatorFlowletInstances: \'2\'\n      app_preferences:\n        publisherContentType: application/json\n        publisherHostName: mrlocal-mtnjftle01.onap.org\n        publisherHostPort: \'3905\'\n        publisherMaxBatchSize: \'10\'\n        publisherMaxRecoveryQueueSize: \'100000\'\n        publisherPollingInterval: \'20000\'\n        publisherProtocol: https\n        publisherTopicName: org.onap.dcae.dmaap.mtnje2.DcaeTestVESPub\n        publisherUserName: test@tca.af.dcae.onap.org\n        publisherUserPassword: password\n        subscriberConsumerGroup: OpenDCAE-c12\n        subscriberConsumerId: c12\n        subscriberContentType: application/json\n        subscriberHostName: mrlocal-mtnjftle01.onap.org\n        subscriberHostPort: \'3905\'\n        subscriberMessageLimit: \'-1\'\n        subscriberPollingInterval: \'20000\'\n        subscriberProtocol: https\n        subscriberTimeoutMS: \'-1\'\n        subscriberTopicName: org.onap.dcae.dmaap.mtnje2.DcaeTestVESSub\n        subscriberUserName: test@tca.af.dcae.onap.org\n        subscriberUserPassword: password\n        tca_policy: null\n      artifact_name: dcae-analytics-tca\n      artifact_version: 1.0.0\n      connections:\n        streams_publishes: [\n          ]\n        streams_subscribes: [\n          ]\n      jar_url: http://somejar\n      location_id:\n        get_input: location_id\n      namespace: cdap_tca_hi_lo\n      programs:\n      - program_id: TCAVESCollectorFlow\n        program_type: flows\n      - program_id: TCADMaaPMRSubscriberWorker\n        program_type: workers\n      - program_id: TCADMaaPMRPublisherWorker\n        program_type: workers\n      service_component_type: cdap_app_tca\n      service_id:\n        get_input: service_id\n      streamname: TCASubscriberOutputStream\n    relationships:\n    - target: topic0\n      type: dcae.relationships.subscribe_to_events\n    - target: topic1\n      type: dcae.relationships.publish_events\n    - target: cdap_host_host\n      type: dcae.relationships.component_contained_in\n    - target: policy_0\n      type: dcae.relationships.depends_on\n  topic0:\n    type: dcae.nodes.Topic\n    properties:\n      topic_name: \'\'\n  topic1:\n    type: dcae.nodes.Topic\n    properties:\n      topic_name: \'\'\n      \n','typeId-88bbf402-1252-419f-a115-7bad5c78f150',0,'<svg xmlns=\"http://www.w3.org/2000/svg\"><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"start-circle\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><circle fill=\"none\" r=\"17\" cx=\"18\" cy=\"41\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"Arrow-c77ad93c-11f4-42b3-8ee4-587086fe3f7d\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><line y2=\"41\" fill=\"none\" x1=\"35\" x2=\"123\" y1=\"41\"/><polygon fill=\"none\" points=\" 121 39 121 43 125 41\"/><polygon points=\" 121 39 121 43 125 41\" stroke=\"none\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"VES\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><rect fill=\"none\" x=\"127\" width=\"123\" y=\"1\" height=\"82\"/></g><g fill-opacity=\"0\" fill=\"rgb(0,0,0)\" text-rendering=\"optimizeQuality\" shape-rendering=\"geometricPrecision\" stroke=\"rgb(0,0,0)\" stroke-opacity=\"0\" stroke-width=\"2\"><rect x=\"127\" width=\"123\" y=\"1\" height=\"82\" stroke=\"none\"/></g><g text-rendering=\"optimizeQuality\" stroke-width=\"2\" shape-rendering=\"geometricPrecision\" font-family=\"sans-serif\"><text x=\"177.5\" xml:space=\"preserve\" y=\"46.5\" stroke=\"none\">VES</text><line y2=\"83\" fill=\"none\" x1=\"147\" x2=\"147\" y1=\"1\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"Arrow-56bb4fd3-6354-4d81-813f-9d495ed81773\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><line y2=\"41\" fill=\"none\" x1=\"250\" x2=\"338\" y1=\"41\"/><polygon fill=\"none\" points=\" 336 39 336 43 340 41\"/><polygon points=\" 336 39 336 43 340 41\" stroke=\"none\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"onap.policies.monitoring.cdap.tca.hi.lo.app\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><rect fill=\"none\" x=\"342\" width=\"123\" y=\"1\" height=\"82\"/></g><g fill-opacity=\"0\" fill=\"rgb(0,0,0)\" text-rendering=\"optimizeQuality\" shape-rendering=\"geometricPrecision\" stroke=\"rgb(0,0,0)\" stroke-opacity=\"0\" stroke-width=\"2\"><rect x=\"342\" width=\"123\" y=\"1\" height=\"82\" stroke=\"none\"/></g><g text-rendering=\"optimizeQuality\" stroke-width=\"2\" shape-rendering=\"geometricPrecision\" font-family=\"sans-serif\"><text x=\"393\" xml:space=\"preserve\" y=\"46.5\" stroke=\"none\">app</text><line y2=\"61\" fill=\"none\" x1=\"342\" x2=\"465\" y1=\"61\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"stop-circle\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"4\"><circle fill=\"none\" r=\"17\" cx=\"482\" cy=\"41\"/></g></g></g></svg>',1,'63cac700-ab9a-4115-a74f-7eac85e3fce0');
-INSERT INTO `loop_templates` VALUES ('LOOP_TEMPLATE_ur2KW_v1_0_ResourceInstanceName1_tca_3','Not found','2020-02-26 04:12:58.264588','Not found','2020-02-26 04:12:58.264588','CLOSED','tosca_definitions_version: cloudify_dsl_1_3\n\ndescription: >\n  This blueprint deploys/manages the TCA module as a Docker container\n\nimports:\n  - http://www.getcloudify.org/spec/cloudify/3.4/types.yaml\n  - https://nexus.onap.org/service/local/repositories/raw/content/org.onap.dcaegen2.platform.plugins/R4/k8splugin/1.4.12/k8splugin_types.yaml\n  - https://nexus.onap.org/service/local/repositories/raw/content/org.onap.dcaegen2.platform.plugins/R4/dcaepolicyplugin/2.3.0/dcaepolicyplugin_types.yaml\ninputs:\n  aaiEnrichmentHost:\n    type: string\n    default: \"aai.onap.svc.cluster.local\"\n  aaiEnrichmentPort:\n    type: string\n    default: \"8443\"\n  enableAAIEnrichment:\n    type: string\n    default: true\n  dmaap_host:\n    type: string\n    default: message-router.onap.svc.cluster.local\n  dmaap_port:\n    type: string\n    default: \"3904\"\n  enableRedisCaching:\n    type: string\n    default: false\n  redisHosts:\n    type: string\n    default: dcae-redis.onap.svc.cluster.local:6379\n  tag_version:\n    type: string\n    default: \"nexus3.onap.org:10001/onap/org.onap.dcaegen2.deployments.tca-cdap-container:1.1.0-STAGING-latest\"\n  consul_host:\n    type: string\n    default: consul-server.onap.svc.cluster.local\n  consul_port:\n    type: string\n    default: \"8500\"\n  cbs_host:\n    type: string\n    default: \"config-binding-service.dcae.svc.cluster.local\"\n  cbs_port:\n    type: string\n    default: \"10000\"\n  policy_id:\n    type: string\n    default: \"none\"\n  external_port:\n    type: string\n    description: Kubernetes node port on which CDAPgui is exposed\n    default: \"32012\"\n  policy_model_id:\n    type: string\n    default: \"onap.policies.monitoring.cdap.tca.hi.lo.app\"\n\nnode_templates:\n  tca_k8s:\n    type: dcae.nodes.ContainerizedServiceComponent\n    relationships:\n      - target: tca_policy\n        type: cloudify.relationships.depends_on\n    properties:\n        service_component_type: \'dcaegen2-analytics-tca\'\n        application_config: {}\n        docker_config: {}\n        image:\n          get_input: tag_version\n        log_info:\n          log_directory: \"/opt/app/TCAnalytics/logs\"\n        application_config:\n            app_config:\n                appDescription: DCAE Analytics Threshold Crossing Alert Application\n                appName: dcae-tca\n                tcaAlertsAbatementTableName: TCAAlertsAbatementTable\n                tcaAlertsAbatementTableTTLSeconds: \'1728000\'\n                tcaSubscriberOutputStreamName: TCASubscriberOutputStream\n                tcaVESAlertsTableName: TCAVESAlertsTable\n                tcaVESAlertsTableTTLSeconds: \'1728000\'\n                tcaVESMessageStatusTableName: TCAVESMessageStatusTable\n                tcaVESMessageStatusTableTTLSeconds: \'86400\'\n                thresholdCalculatorFlowletInstances: \'2\'\n            app_preferences:\n                aaiEnrichmentHost:\n                    get_input: aaiEnrichmentHost\n                aaiEnrichmentIgnoreSSLCertificateErrors: \'true\'\n                aaiEnrichmentPortNumber: \'8443\'\n                aaiEnrichmentProtocol: https\n                aaiEnrichmentUserName: dcae@dcae.onap.org\n                aaiEnrichmentUserPassword: demo123456!\n                aaiVMEnrichmentAPIPath: /aai/v11/search/nodes-query\n                aaiVNFEnrichmentAPIPath: /aai/v11/network/generic-vnfs/generic-vnf\n                enableAAIEnrichment:\n                    get_input: enableAAIEnrichment\n                enableRedisCaching:\n                    get_input: enableRedisCaching\n                redisHosts:\n                    get_input: redisHosts\n                enableAlertCEFFormat: \'false\'\n                publisherContentType: application/json\n                publisherHostName:\n                    get_input: dmaap_host\n                publisherHostPort:\n                    get_input: dmaap_port\n                publisherMaxBatchSize: \'1\'\n                publisherMaxRecoveryQueueSize: \'100000\'\n                publisherPollingInterval: \'20000\'\n                publisherProtocol: http\n                publisherTopicName: unauthenticated.DCAE_CL_OUTPUT\n                subscriberConsumerGroup: OpenDCAE-c12\n                subscriberConsumerId: c12\n                subscriberContentType: application/json\n                subscriberHostName:\n                    get_input: dmaap_host\n                subscriberHostPort:\n                    get_input: dmaap_port\n                subscriberMessageLimit: \'-1\'\n                subscriberPollingInterval: \'30000\'\n                subscriberProtocol: http\n                subscriberTimeoutMS: \'-1\'\n                subscriberTopicName: unauthenticated.VES_MEASUREMENT_OUTPUT\n                tca_policy: \'\'\n        service_component_type: dcaegen2-analytics_tca\n    interfaces:\n      cloudify.interfaces.lifecycle:\n        start:\n          inputs:\n            envs:\n                DMAAPHOST:\n                    { get_input: dmaap_host }\n                DMAAPPORT:\n                    { get_input: dmaap_port }\n                DMAAPPUBTOPIC: \"unauthenticated.DCAE_CL_OUTPUT\"\n                DMAAPSUBTOPIC: \"unauthenticated.VES_MEASUREMENT_OUTPUT\"\n                AAIHOST:\n                    { get_input: aaiEnrichmentHost }\n                AAIPORT:\n                    { get_input: aaiEnrichmentPort }\n                CONSUL_HOST:\n                    { get_input: consul_host }\n                CONSUL_PORT:\n                    { get_input: consul_port }\n                CBS_HOST:\n                    { get_input: cbs_host }\n                CBS_PORT:\n                    { get_input: cbs_port }\n                CONFIG_BINDING_SERVICE: \"config_binding_service\"\n            ports:\n              - concat: [\"11011:\", { get_input: external_port }]\n  tca_policy:\n    type: dcae.nodes.policy\n    properties:\n      policy_id:\n           get_input: policy_id\n      policy_model_id: \n           get_input: policy_model_id\n','typeId-f5efa9dc-a7ad-4c64-a765-bc91d9a55211',0,'<svg xmlns=\"http://www.w3.org/2000/svg\"><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"start-circle\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><circle fill=\"none\" r=\"17\" cx=\"18\" cy=\"41\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"Arrow-981b9707-f880-4e4f-ae5f-79a76dbdaab2\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><line y2=\"41\" fill=\"none\" x1=\"35\" x2=\"123\" y1=\"41\"/><polygon fill=\"none\" points=\" 121 39 121 43 125 41\"/><polygon points=\" 121 39 121 43 125 41\" stroke=\"none\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"VES\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><rect fill=\"none\" x=\"127\" width=\"123\" y=\"1\" height=\"82\"/></g><g fill-opacity=\"0\" fill=\"rgb(0,0,0)\" text-rendering=\"optimizeQuality\" shape-rendering=\"geometricPrecision\" stroke=\"rgb(0,0,0)\" stroke-opacity=\"0\" stroke-width=\"2\"><rect x=\"127\" width=\"123\" y=\"1\" height=\"82\" stroke=\"none\"/></g><g text-rendering=\"optimizeQuality\" stroke-width=\"2\" shape-rendering=\"geometricPrecision\" font-family=\"sans-serif\"><text x=\"177.5\" xml:space=\"preserve\" y=\"46.5\" stroke=\"none\">VES</text><line y2=\"83\" fill=\"none\" x1=\"147\" x2=\"147\" y1=\"1\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"Arrow-54008f91-e57b-4990-8c1e-71be596f0298\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><line y2=\"41\" fill=\"none\" x1=\"250\" x2=\"338\" y1=\"41\"/><polygon fill=\"none\" points=\" 336 39 336 43 340 41\"/><polygon points=\" 336 39 336 43 340 41\" stroke=\"none\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"onap.policies.monitoring.cdap.tca.hi.lo.app\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><rect fill=\"none\" x=\"342\" width=\"123\" y=\"1\" height=\"82\"/></g><g fill-opacity=\"0\" fill=\"rgb(0,0,0)\" text-rendering=\"optimizeQuality\" shape-rendering=\"geometricPrecision\" stroke=\"rgb(0,0,0)\" stroke-opacity=\"0\" stroke-width=\"2\"><rect x=\"342\" width=\"123\" y=\"1\" height=\"82\" stroke=\"none\"/></g><g text-rendering=\"optimizeQuality\" stroke-width=\"2\" shape-rendering=\"geometricPrecision\" font-family=\"sans-serif\"><text x=\"393\" xml:space=\"preserve\" y=\"46.5\" stroke=\"none\">app</text><line y2=\"61\" fill=\"none\" x1=\"342\" x2=\"465\" y1=\"61\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"stop-circle\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"4\"><circle fill=\"none\" r=\"17\" cx=\"482\" cy=\"41\"/></g></g></g></svg>',1,'63cac700-ab9a-4115-a74f-7eac85e3fce0');
-INSERT INTO `loop_templates` VALUES ('LOOP_TEMPLATE_ur2KW_v1_0_ResourceInstanceName2_tca_2','Not found','2020-02-26 04:12:57.917717','Not found','2020-02-26 04:12:57.917717','CLOSED','#\n# ============LICENSE_START====================================================\n# =============================================================================\n# Copyright (c) 2019 AT&T Intellectual Property. All rights reserved.\n# =============================================================================\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n#      http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ============LICENSE_END======================================================\n\ntosca_definitions_version: cloudify_dsl_1_3\n\ndescription: >\n  This blueprint deploys/manages the TCA module as a Docker container\n\nimports:\n  - http://www.getcloudify.org/spec/cloudify/3.4/types.yaml\n  - https://nexus.onap.org/service/local/repositories/raw/content/org.onap.dcaegen2.platform.plugins/R4/k8splugin/1.4.12/k8splugin_types.yaml\n#  - https://nexus.onap.org/service/local/repositories/raw/content/org.onap.dcaegen2.platform.plugins/R4/dcaepolicyplugin/2.3.0/dcaepolicyplugin_types.yaml\n  - https://nexus.onap.org/service/local/repositories/raw/content/org.onap.dcaegen2.platform.plugins/R4/clamppolicyplugin/1.0.0/clamppolicyplugin_types.yaml\ninputs:\n  aaiEnrichmentHost:\n    type: string\n    default: \"aai.onap.svc.cluster.local\"\n  aaiEnrichmentPort:\n    type: string\n    default: \"8443\"\n  enableAAIEnrichment:\n    type: string\n    default: true\n  dmaap_host:\n    type: string\n    default: message-router.onap\n  dmaap_port:\n    type: string\n    default: \"3904\"\n  enableRedisCaching:\n    type: string\n    default: false\n  redisHosts:\n    type: string\n    default: dcae-redis.onap.svc.cluster.local:6379\n  tag_version:\n    type: string\n    default: \"nexus3.onap.org:10001/onap/org.onap.dcaegen2.deployments.tca-cdap-container:1.1.1\"\n  consul_host:\n    type: string\n    default: consul-server.onap\n  consul_port:\n    type: string\n    default: \"8500\"\n  cbs_host:\n    type: string\n    default: \"config-binding-servicel\"\n  cbs_port:\n    type: string\n    default: \"10000\"\n  policy_id:\n    type: string\n    default: \"onap.restart.tca\"\n  external_port:\n    type: string\n    description: Kubernetes node port on which CDAPgui is exposed\n    default: \"32012\"\n  policy_model_id:\n    type: string\n    default: \"onap.policies.monitoring.cdap.tca.hi.lo.app\"\nnode_templates:\n  tca_k8s:\n    type: dcae.nodes.ContainerizedServiceComponent\n    relationships:\n      - target: tca_policy\n        type: cloudify.relationships.depends_on\n    properties:\n        service_component_type: \'dcaegen2-analytics-tca\'\n        application_config: {}\n        docker_config: {}\n        image:\n          get_input: tag_version\n        log_info:\n          log_directory: \"/opt/app/TCAnalytics/logs\"\n        application_config:\n            app_config:\n                appDescription: DCAE Analytics Threshold Crossing Alert Application\n                appName: dcae-tca\n                tcaAlertsAbatementTableName: TCAAlertsAbatementTable\n                tcaAlertsAbatementTableTTLSeconds: \'1728000\'\n                tcaSubscriberOutputStreamName: TCASubscriberOutputStream\n                tcaVESAlertsTableName: TCAVESAlertsTable\n                tcaVESAlertsTableTTLSeconds: \'1728000\'\n                tcaVESMessageStatusTableName: TCAVESMessageStatusTable\n                tcaVESMessageStatusTableTTLSeconds: \'86400\'\n                thresholdCalculatorFlowletInstances: \'2\'\n            app_preferences:\n                aaiEnrichmentHost:\n                    get_input: aaiEnrichmentHost\n                aaiEnrichmentIgnoreSSLCertificateErrors: \'true\'\n                aaiEnrichmentPortNumber: \'8443\'\n                aaiEnrichmentProtocol: https\n                aaiEnrichmentUserName: dcae@dcae.onap.org\n                aaiEnrichmentUserPassword: demo123456!\n                aaiVMEnrichmentAPIPath: /aai/v11/search/nodes-query\n                aaiVNFEnrichmentAPIPath: /aai/v11/network/generic-vnfs/generic-vnf\n                enableAAIEnrichment:\n                    get_input: enableAAIEnrichment\n                enableRedisCaching:\n                    get_input: enableRedisCaching\n                redisHosts:\n                    get_input: redisHosts\n                enableAlertCEFFormat: \'false\'\n                publisherContentType: application/json\n                publisherHostName:\n                    get_input: dmaap_host\n                publisherHostPort:\n                    get_input: dmaap_port\n                publisherMaxBatchSize: \'1\'\n                publisherMaxRecoveryQueueSize: \'100000\'\n                publisherPollingInterval: \'20000\'\n                publisherProtocol: http\n                publisherTopicName: unauthenticated.DCAE_CL_OUTPUT\n                subscriberConsumerGroup: OpenDCAE-clamp\n                subscriberConsumerId: c12\n                subscriberContentType: application/json\n                subscriberHostName:\n                    get_input: dmaap_host\n                subscriberHostPort:\n                    get_input: dmaap_port\n                subscriberMessageLimit: \'-1\'\n                subscriberPollingInterval: \'30000\'\n                subscriberProtocol: http\n                subscriberTimeoutMS: \'-1\'\n                subscriberTopicName: unauthenticated.VES_MEASUREMENT_OUTPUT\n#                tca_policy: \'{\"domain\":\"measurementsForVfScaling\",\"metricsPerEventName\":[{\"eventName\":\"vFirewallBroadcastPackets\",\"controlLoopSchemaType\":\"VNF\",\"policyScope\":\"DCAE\",\"policyName\":\"DCAE.Config_tca-hi-lo\",\"policyVersion\":\"v0.0.1\",\"thresholds\":[{\"closedLoopControlName\":\"ControlLoop-vFirewall-d0a1dfc6-94f5-4fd4-a5b5-4630b438850a\",\"version\":\"1.0.2\",\"fieldPath\":\"$.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta\",\"thresholdValue\":300,\"direction\":\"LESS_OR_EQUAL\",\"severity\":\"MAJOR\",\"closedLoopEventStatus\":\"ONSET\"},{\"closedLoopControlName\":\"ControlLoop-vFirewall-d0a1dfc6-94f5-4fd4-a5b5-4630b438850a\",\"version\":\"1.0.2\",\"fieldPath\":\"$.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta\",\"thresholdValue\":700,\"direction\":\"GREATER_OR_EQUAL\",\"severity\":\"CRITICAL\",\"closedLoopEventStatus\":\"ONSET\"}]},{\"eventName\":\"vLoadBalancer\",\"controlLoopSchemaType\":\"VM\",\"policyScope\":\"DCAE\",\"policyName\":\"DCAE.Config_tca-hi-lo\",\"policyVersion\":\"v0.0.1\",\"thresholds\":[{\"closedLoopControlName\":\"ControlLoop-vDNS-6f37f56d-a87d-4b85-b6a9-cc953cf779b3\",\"version\":\"1.0.2\",\"fieldPath\":\"$.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta\",\"thresholdValue\":300,\"direction\":\"GREATER_OR_EQUAL\",\"severity\":\"CRITICAL\",\"closedLoopEventStatus\":\"ONSET\"}]},{\"eventName\":\"Measurement_vGMUX\",\"controlLoopSchemaType\":\"VNF\",\"policyScope\":\"DCAE\",\"policyName\":\"DCAE.Config_tca-hi-lo\",\"policyVersion\":\"v0.0.1\",\"thresholds\":[{\"closedLoopControlName\":\"ControlLoop-vCPE-48f0c2c3-a172-4192-9ae3-052274181b6e\",\"version\":\"1.0.2\",\"fieldPath\":\"$.event.measurementsForVfScalingFields.additionalMeasurements[*].arrayOfFields[0].value\",\"thresholdValue\":0,\"direction\":\"EQUAL\",\"severity\":\"MAJOR\",\"closedLoopEventStatus\":\"ABATED\"},{\"closedLoopControlName\":\"ControlLoop-vCPE-48f0c2c3-a172-4192-9ae3-052274181b6e\",\"version\":\"1.0.2\",\"fieldPath\":\"$.event.measurementsForVfScalingFields.additionalMeasurements[*].arrayOfFields[0].value\",\"thresholdValue\":0,\"direction\":\"GREATER\",\"severity\":\"CRITICAL\",\"closedLoopEventStatus\":\"ONSET\"}]}]}\'\n        service_component_type: dcaegen2-analytics_tca\n    interfaces:\n      cloudify.interfaces.lifecycle:\n        start:\n          inputs:\n            envs:\n                DMAAPHOST:\n                    { get_input: dmaap_host }\n                DMAAPPORT:\n                    { get_input: dmaap_port }\n                DMAAPPUBTOPIC: \"unauthenticated.DCAE_CL_OUTPUT\"\n                DMAAPSUBTOPIC: \"unauthenticated.VES_MEASUREMENT_OUTPUT\"\n                AAIHOST:\n                    { get_input: aaiEnrichmentHost }\n                AAIPORT:\n                    { get_input: aaiEnrichmentPort }\n                CONSUL_HOST:\n                    { get_input: consul_host }\n                CONSUL_PORT:\n                    { get_input: consul_port }\n                CBS_HOST:\n                    { get_input: cbs_host }\n                CBS_PORT:\n                    { get_input: cbs_port }\n                CONFIG_BINDING_SERVICE: \"config_binding_service\"\n            ports:\n              - concat: [\"11011:\", { get_input: external_port }]\n  tca_policy:\n    type: clamp.nodes.policy\n    properties:\n      policy_id:\n           get_input: policy_id\n      policy_model_id: \"onap.policies.monitoring.cdap.tca.hi.lo.app\"\n','typeId-73b380f7-c715-47c8-bf42-90aef749701c',0,'<svg xmlns=\"http://www.w3.org/2000/svg\"><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"start-circle\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><circle fill=\"none\" r=\"17\" cx=\"18\" cy=\"41\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"Arrow-4636db5f-4f0b-4d2e-9fef-69387f5961c3\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><line y2=\"41\" fill=\"none\" x1=\"35\" x2=\"123\" y1=\"41\"/><polygon fill=\"none\" points=\" 121 39 121 43 125 41\"/><polygon points=\" 121 39 121 43 125 41\" stroke=\"none\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"VES\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><rect fill=\"none\" x=\"127\" width=\"123\" y=\"1\" height=\"82\"/></g><g fill-opacity=\"0\" fill=\"rgb(0,0,0)\" text-rendering=\"optimizeQuality\" shape-rendering=\"geometricPrecision\" stroke=\"rgb(0,0,0)\" stroke-opacity=\"0\" stroke-width=\"2\"><rect x=\"127\" width=\"123\" y=\"1\" height=\"82\" stroke=\"none\"/></g><g text-rendering=\"optimizeQuality\" stroke-width=\"2\" shape-rendering=\"geometricPrecision\" font-family=\"sans-serif\"><text x=\"177.5\" xml:space=\"preserve\" y=\"46.5\" stroke=\"none\">VES</text><line y2=\"83\" fill=\"none\" x1=\"147\" x2=\"147\" y1=\"1\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"Arrow-af706c28-e283-4e73-a283-ba92b28fb028\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><line y2=\"41\" fill=\"none\" x1=\"250\" x2=\"338\" y1=\"41\"/><polygon fill=\"none\" points=\" 336 39 336 43 340 41\"/><polygon points=\" 336 39 336 43 340 41\" stroke=\"none\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"onap.policies.monitoring.cdap.tca.hi.lo.app\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><rect fill=\"none\" x=\"342\" width=\"123\" y=\"1\" height=\"82\"/></g><g fill-opacity=\"0\" fill=\"rgb(0,0,0)\" text-rendering=\"optimizeQuality\" shape-rendering=\"geometricPrecision\" stroke=\"rgb(0,0,0)\" stroke-opacity=\"0\" stroke-width=\"2\"><rect x=\"342\" width=\"123\" y=\"1\" height=\"82\" stroke=\"none\"/></g><g text-rendering=\"optimizeQuality\" stroke-width=\"2\" shape-rendering=\"geometricPrecision\" font-family=\"sans-serif\"><text x=\"393\" xml:space=\"preserve\" y=\"46.5\" stroke=\"none\">app</text><line y2=\"61\" fill=\"none\" x1=\"342\" x2=\"465\" y1=\"61\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"stop-circle\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"4\"><circle fill=\"none\" r=\"17\" cx=\"482\" cy=\"41\"/></g></g></g></svg>',1,'63cac700-ab9a-4115-a74f-7eac85e3fce0');
+INSERT INTO `loop_templates` VALUES ('LOOP_TEMPLATE_lCoAC_v1_0_ResourceInstanceName1_tca','Not found','2020-02-27 15:08:47.793512','Not found','2020-02-27 15:08:47.793512','CLOSED','tosca_definitions_version: cloudify_dsl_1_3\nimports:\n- http://www.getcloudify.org/spec/cloudify/3.4/types.yaml\n- https://onap.org:8443/repository/solutioning01-mte2-raw/type_files/docker/2.2.0/node-type.yaml\n- https://onap.org:8443/repository/solutioning01-mte2-raw/type_files/relationship/1.0.0/node-type.yaml\n- http://onap.org:8081/repository/solutioning01-mte2-raw/type_files/dmaap/dmaap_mr.yaml\ninputs:\n  location_id:\n    type: string\n  service_id:\n    type: string\n  policy_id:\n    type: string\nnode_templates:\n  policy_0:\n    type: dcae.nodes.policy\n    properties:\n      policy_id: \n        get_input: policy_id\n      policy_model_id: \"onap.policies.monitoring.cdap.tca.hi.lo.app\"\n  cdap_host_host:\n    type: dcae.nodes.StreamingAnalytics.SelectedCDAPInfrastructure\n    properties:\n      location_id:\n        get_input: location_id\n      scn_override: cdap_broker.solutioning-central.dcae.onap.org\n    interfaces:\n      cloudify.interfaces.lifecycle: {\n        }\n  tca_tca:\n    type: dcae.nodes.MicroService.cdap\n    properties:\n      app_config:\n        appDescription: DCAE Analytics Threshold Crossing Alert Application\n        appName: dcae-tca\n        tcaSubscriberOutputStreamName: TCASubscriberOutputStream\n        tcaVESAlertsTableName: TCAVESAlertsTable\n        tcaVESAlertsTableTTLSeconds: \'1728000\'\n        tcaVESMessageStatusTableName: TCAVESMessageStatusTable\n        tcaVESMessageStatusTableTTLSeconds: \'86400\'\n        thresholdCalculatorFlowletInstances: \'2\'\n      app_preferences:\n        publisherContentType: application/json\n        publisherHostName: mrlocal-mtnjftle01.onap.org\n        publisherHostPort: \'3905\'\n        publisherMaxBatchSize: \'10\'\n        publisherMaxRecoveryQueueSize: \'100000\'\n        publisherPollingInterval: \'20000\'\n        publisherProtocol: https\n        publisherTopicName: org.onap.dcae.dmaap.mtnje2.DcaeTestVESPub\n        publisherUserName: test@tca.af.dcae.onap.org\n        publisherUserPassword: password\n        subscriberConsumerGroup: OpenDCAE-c12\n        subscriberConsumerId: c12\n        subscriberContentType: application/json\n        subscriberHostName: mrlocal-mtnjftle01.onap.org\n        subscriberHostPort: \'3905\'\n        subscriberMessageLimit: \'-1\'\n        subscriberPollingInterval: \'20000\'\n        subscriberProtocol: https\n        subscriberTimeoutMS: \'-1\'\n        subscriberTopicName: org.onap.dcae.dmaap.mtnje2.DcaeTestVESSub\n        subscriberUserName: test@tca.af.dcae.onap.org\n        subscriberUserPassword: password\n        tca_policy: null\n      artifact_name: dcae-analytics-tca\n      artifact_version: 1.0.0\n      connections:\n        streams_publishes: [\n          ]\n        streams_subscribes: [\n          ]\n      jar_url: http://somejar\n      location_id:\n        get_input: location_id\n      namespace: cdap_tca_hi_lo\n      programs:\n      - program_id: TCAVESCollectorFlow\n        program_type: flows\n      - program_id: TCADMaaPMRSubscriberWorker\n        program_type: workers\n      - program_id: TCADMaaPMRPublisherWorker\n        program_type: workers\n      service_component_type: cdap_app_tca\n      service_id:\n        get_input: service_id\n      streamname: TCASubscriberOutputStream\n    relationships:\n    - target: topic0\n      type: dcae.relationships.subscribe_to_events\n    - target: topic1\n      type: dcae.relationships.publish_events\n    - target: cdap_host_host\n      type: dcae.relationships.component_contained_in\n    - target: policy_0\n      type: dcae.relationships.depends_on\n  topic0:\n    type: dcae.nodes.Topic\n    properties:\n      topic_name: \'\'\n  topic1:\n    type: dcae.nodes.Topic\n    properties:\n      topic_name: \'\'\n      \n','typeId-49bf6c16-46a7-4962-a667-8be63b66f549',0,'<svg xmlns=\"http://www.w3.org/2000/svg\"><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"start-circle\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><circle fill=\"none\" r=\"17\" cx=\"18\" cy=\"41\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"Arrow-1a5feff5-6b1c-4099-9abe-991ed90d0385\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><line y2=\"41\" fill=\"none\" x1=\"35\" x2=\"123\" y1=\"41\"/><polygon fill=\"none\" points=\" 121 39 121 43 125 41\"/><polygon points=\" 121 39 121 43 125 41\" stroke=\"none\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"VES\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><rect fill=\"none\" x=\"127\" width=\"123\" y=\"1\" height=\"82\"/></g><g fill-opacity=\"0\" fill=\"rgb(0,0,0)\" text-rendering=\"optimizeQuality\" shape-rendering=\"geometricPrecision\" stroke=\"rgb(0,0,0)\" stroke-opacity=\"0\" stroke-width=\"2\"><rect x=\"127\" width=\"123\" y=\"1\" height=\"82\" stroke=\"none\"/></g><g text-rendering=\"optimizeQuality\" stroke-width=\"2\" shape-rendering=\"geometricPrecision\" font-family=\"sans-serif\"><text x=\"177.5\" xml:space=\"preserve\" y=\"46.5\" stroke=\"none\">VES</text><line y2=\"83\" fill=\"none\" x1=\"147\" x2=\"147\" y1=\"1\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"Arrow-3ce74d04-7349-4318-ac9e-7e002fe56ec0\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><line y2=\"41\" fill=\"none\" x1=\"250\" x2=\"338\" y1=\"41\"/><polygon fill=\"none\" points=\" 336 39 336 43 340 41\"/><polygon points=\" 336 39 336 43 340 41\" stroke=\"none\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"onap.policies.monitoring.cdap.tca.hi.lo.app\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><rect fill=\"none\" x=\"342\" width=\"123\" y=\"1\" height=\"82\"/></g><g fill-opacity=\"0\" fill=\"rgb(0,0,0)\" text-rendering=\"optimizeQuality\" shape-rendering=\"geometricPrecision\" stroke=\"rgb(0,0,0)\" stroke-opacity=\"0\" stroke-width=\"2\"><rect x=\"342\" width=\"123\" y=\"1\" height=\"82\" stroke=\"none\"/></g><g text-rendering=\"optimizeQuality\" stroke-width=\"2\" shape-rendering=\"geometricPrecision\" font-family=\"sans-serif\"><text x=\"393\" xml:space=\"preserve\" y=\"46.5\" stroke=\"none\">app</text><line y2=\"61\" fill=\"none\" x1=\"342\" x2=\"465\" y1=\"61\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"Arrow-ae12f7f4-adf7-40d7-86d5-8e5d28171a89\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><line y2=\"41\" fill=\"none\" x1=\"465\" x2=\"553\" y1=\"41\"/><polygon fill=\"none\" points=\" 551 39 551 43 555 41\"/><polygon points=\" 551 39 551 43 555 41\" stroke=\"none\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"stop-circle\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"4\"><circle fill=\"none\" r=\"17\" cx=\"574\" cy=\"41\"/></g></g></g></svg>',1,'63cac700-ab9a-4115-a74f-7eac85e3fce0');
+INSERT INTO `loop_templates` VALUES ('LOOP_TEMPLATE_lCoAC_v1_0_ResourceInstanceName1_tca_3','Not found','2020-02-27 15:08:47.303168','Not found','2020-02-27 15:08:47.303168','CLOSED','tosca_definitions_version: cloudify_dsl_1_3\n\ndescription: >\n  This blueprint deploys/manages the TCA module as a Docker container\n\nimports:\n  - http://www.getcloudify.org/spec/cloudify/3.4/types.yaml\n  - https://nexus.onap.org/service/local/repositories/raw/content/org.onap.dcaegen2.platform.plugins/R4/k8splugin/1.4.12/k8splugin_types.yaml\n  - https://nexus.onap.org/service/local/repositories/raw/content/org.onap.dcaegen2.platform.plugins/R4/dcaepolicyplugin/2.3.0/dcaepolicyplugin_types.yaml\ninputs:\n  aaiEnrichmentHost:\n    type: string\n    default: \"aai.onap.svc.cluster.local\"\n  aaiEnrichmentPort:\n    type: string\n    default: \"8443\"\n  enableAAIEnrichment:\n    type: string\n    default: true\n  dmaap_host:\n    type: string\n    default: message-router.onap.svc.cluster.local\n  dmaap_port:\n    type: string\n    default: \"3904\"\n  enableRedisCaching:\n    type: string\n    default: false\n  redisHosts:\n    type: string\n    default: dcae-redis.onap.svc.cluster.local:6379\n  tag_version:\n    type: string\n    default: \"nexus3.onap.org:10001/onap/org.onap.dcaegen2.deployments.tca-cdap-container:1.1.0-STAGING-latest\"\n  consul_host:\n    type: string\n    default: consul-server.onap.svc.cluster.local\n  consul_port:\n    type: string\n    default: \"8500\"\n  cbs_host:\n    type: string\n    default: \"config-binding-service.dcae.svc.cluster.local\"\n  cbs_port:\n    type: string\n    default: \"10000\"\n  policy_id:\n    type: string\n    default: \"none\"\n  external_port:\n    type: string\n    description: Kubernetes node port on which CDAPgui is exposed\n    default: \"32012\"\n  policy_model_id:\n    type: string\n    default: \"onap.policies.monitoring.cdap.tca.hi.lo.app\"\n\nnode_templates:\n  tca_k8s:\n    type: dcae.nodes.ContainerizedServiceComponent\n    relationships:\n      - target: tca_policy\n        type: cloudify.relationships.depends_on\n    properties:\n        service_component_type: \'dcaegen2-analytics-tca\'\n        application_config: {}\n        docker_config: {}\n        image:\n          get_input: tag_version\n        log_info:\n          log_directory: \"/opt/app/TCAnalytics/logs\"\n        application_config:\n            app_config:\n                appDescription: DCAE Analytics Threshold Crossing Alert Application\n                appName: dcae-tca\n                tcaAlertsAbatementTableName: TCAAlertsAbatementTable\n                tcaAlertsAbatementTableTTLSeconds: \'1728000\'\n                tcaSubscriberOutputStreamName: TCASubscriberOutputStream\n                tcaVESAlertsTableName: TCAVESAlertsTable\n                tcaVESAlertsTableTTLSeconds: \'1728000\'\n                tcaVESMessageStatusTableName: TCAVESMessageStatusTable\n                tcaVESMessageStatusTableTTLSeconds: \'86400\'\n                thresholdCalculatorFlowletInstances: \'2\'\n            app_preferences:\n                aaiEnrichmentHost:\n                    get_input: aaiEnrichmentHost\n                aaiEnrichmentIgnoreSSLCertificateErrors: \'true\'\n                aaiEnrichmentPortNumber: \'8443\'\n                aaiEnrichmentProtocol: https\n                aaiEnrichmentUserName: dcae@dcae.onap.org\n                aaiEnrichmentUserPassword: demo123456!\n                aaiVMEnrichmentAPIPath: /aai/v11/search/nodes-query\n                aaiVNFEnrichmentAPIPath: /aai/v11/network/generic-vnfs/generic-vnf\n                enableAAIEnrichment:\n                    get_input: enableAAIEnrichment\n                enableRedisCaching:\n                    get_input: enableRedisCaching\n                redisHosts:\n                    get_input: redisHosts\n                enableAlertCEFFormat: \'false\'\n                publisherContentType: application/json\n                publisherHostName:\n                    get_input: dmaap_host\n                publisherHostPort:\n                    get_input: dmaap_port\n                publisherMaxBatchSize: \'1\'\n                publisherMaxRecoveryQueueSize: \'100000\'\n                publisherPollingInterval: \'20000\'\n                publisherProtocol: http\n                publisherTopicName: unauthenticated.DCAE_CL_OUTPUT\n                subscriberConsumerGroup: OpenDCAE-c12\n                subscriberConsumerId: c12\n                subscriberContentType: application/json\n                subscriberHostName:\n                    get_input: dmaap_host\n                subscriberHostPort:\n                    get_input: dmaap_port\n                subscriberMessageLimit: \'-1\'\n                subscriberPollingInterval: \'30000\'\n                subscriberProtocol: http\n                subscriberTimeoutMS: \'-1\'\n                subscriberTopicName: unauthenticated.VES_MEASUREMENT_OUTPUT\n                tca_policy: \'\'\n        service_component_type: dcaegen2-analytics_tca\n    interfaces:\n      cloudify.interfaces.lifecycle:\n        start:\n          inputs:\n            envs:\n                DMAAPHOST:\n                    { get_input: dmaap_host }\n                DMAAPPORT:\n                    { get_input: dmaap_port }\n                DMAAPPUBTOPIC: \"unauthenticated.DCAE_CL_OUTPUT\"\n                DMAAPSUBTOPIC: \"unauthenticated.VES_MEASUREMENT_OUTPUT\"\n                AAIHOST:\n                    { get_input: aaiEnrichmentHost }\n                AAIPORT:\n                    { get_input: aaiEnrichmentPort }\n                CONSUL_HOST:\n                    { get_input: consul_host }\n                CONSUL_PORT:\n                    { get_input: consul_port }\n                CBS_HOST:\n                    { get_input: cbs_host }\n                CBS_PORT:\n                    { get_input: cbs_port }\n                CONFIG_BINDING_SERVICE: \"config_binding_service\"\n            ports:\n              - concat: [\"11011:\", { get_input: external_port }]\n  tca_policy:\n    type: dcae.nodes.policy\n    properties:\n      policy_id:\n           get_input: policy_id\n      policy_model_id: \n           get_input: policy_model_id\n','typeId-41007420-32ac-4d57-8541-12faa3554315',0,'<svg xmlns=\"http://www.w3.org/2000/svg\"><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"start-circle\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><circle fill=\"none\" r=\"17\" cx=\"18\" cy=\"41\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"Arrow-5b934835-48c1-42f0-aad0-36908cbea8d3\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><line y2=\"41\" fill=\"none\" x1=\"35\" x2=\"123\" y1=\"41\"/><polygon fill=\"none\" points=\" 121 39 121 43 125 41\"/><polygon points=\" 121 39 121 43 125 41\" stroke=\"none\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"VES\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><rect fill=\"none\" x=\"127\" width=\"123\" y=\"1\" height=\"82\"/></g><g fill-opacity=\"0\" fill=\"rgb(0,0,0)\" text-rendering=\"optimizeQuality\" shape-rendering=\"geometricPrecision\" stroke=\"rgb(0,0,0)\" stroke-opacity=\"0\" stroke-width=\"2\"><rect x=\"127\" width=\"123\" y=\"1\" height=\"82\" stroke=\"none\"/></g><g text-rendering=\"optimizeQuality\" stroke-width=\"2\" shape-rendering=\"geometricPrecision\" font-family=\"sans-serif\"><text x=\"177.5\" xml:space=\"preserve\" y=\"46.5\" stroke=\"none\">VES</text><line y2=\"83\" fill=\"none\" x1=\"147\" x2=\"147\" y1=\"1\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"Arrow-b0f3df35-6549-4de0-95d3-f274ed3e16f3\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><line y2=\"41\" fill=\"none\" x1=\"250\" x2=\"338\" y1=\"41\"/><polygon fill=\"none\" points=\" 336 39 336 43 340 41\"/><polygon points=\" 336 39 336 43 340 41\" stroke=\"none\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"onap.policies.monitoring.cdap.tca.hi.lo.app\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><rect fill=\"none\" x=\"342\" width=\"123\" y=\"1\" height=\"82\"/></g><g fill-opacity=\"0\" fill=\"rgb(0,0,0)\" text-rendering=\"optimizeQuality\" shape-rendering=\"geometricPrecision\" stroke=\"rgb(0,0,0)\" stroke-opacity=\"0\" stroke-width=\"2\"><rect x=\"342\" width=\"123\" y=\"1\" height=\"82\" stroke=\"none\"/></g><g text-rendering=\"optimizeQuality\" stroke-width=\"2\" shape-rendering=\"geometricPrecision\" font-family=\"sans-serif\"><text x=\"393\" xml:space=\"preserve\" y=\"46.5\" stroke=\"none\">app</text><line y2=\"61\" fill=\"none\" x1=\"342\" x2=\"465\" y1=\"61\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"Arrow-d73cb3bb-6f38-4edd-89a9-004c3fb11c01\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><line y2=\"41\" fill=\"none\" x1=\"465\" x2=\"553\" y1=\"41\"/><polygon fill=\"none\" points=\" 551 39 551 43 555 41\"/><polygon points=\" 551 39 551 43 555 41\" stroke=\"none\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"stop-circle\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"4\"><circle fill=\"none\" r=\"17\" cx=\"574\" cy=\"41\"/></g></g></g></svg>',1,'63cac700-ab9a-4115-a74f-7eac85e3fce0');
+INSERT INTO `loop_templates` VALUES ('LOOP_TEMPLATE_lCoAC_v1_0_ResourceInstanceName2_tca_2','Not found','2020-02-27 15:08:46.692894','Not found','2020-02-27 15:08:46.692894','CLOSED','#\n# ============LICENSE_START====================================================\n# =============================================================================\n# Copyright (c) 2019 AT&T Intellectual Property. All rights reserved.\n# =============================================================================\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n#      http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ============LICENSE_END======================================================\n\ntosca_definitions_version: cloudify_dsl_1_3\n\ndescription: >\n  This blueprint deploys/manages the TCA module as a Docker container\n\nimports:\n  - http://www.getcloudify.org/spec/cloudify/3.4/types.yaml\n  - https://nexus.onap.org/service/local/repositories/raw/content/org.onap.dcaegen2.platform.plugins/R4/k8splugin/1.4.12/k8splugin_types.yaml\n#  - https://nexus.onap.org/service/local/repositories/raw/content/org.onap.dcaegen2.platform.plugins/R4/dcaepolicyplugin/2.3.0/dcaepolicyplugin_types.yaml\n  - https://nexus.onap.org/service/local/repositories/raw/content/org.onap.dcaegen2.platform.plugins/R4/clamppolicyplugin/1.0.0/clamppolicyplugin_types.yaml\ninputs:\n  aaiEnrichmentHost:\n    type: string\n    default: \"aai.onap.svc.cluster.local\"\n  aaiEnrichmentPort:\n    type: string\n    default: \"8443\"\n  enableAAIEnrichment:\n    type: string\n    default: true\n  dmaap_host:\n    type: string\n    default: message-router.onap\n  dmaap_port:\n    type: string\n    default: \"3904\"\n  enableRedisCaching:\n    type: string\n    default: false\n  redisHosts:\n    type: string\n    default: dcae-redis.onap.svc.cluster.local:6379\n  tag_version:\n    type: string\n    default: \"nexus3.onap.org:10001/onap/org.onap.dcaegen2.deployments.tca-cdap-container:1.1.1\"\n  consul_host:\n    type: string\n    default: consul-server.onap\n  consul_port:\n    type: string\n    default: \"8500\"\n  cbs_host:\n    type: string\n    default: \"config-binding-servicel\"\n  cbs_port:\n    type: string\n    default: \"10000\"\n  policy_id:\n    type: string\n    default: \"onap.restart.tca\"\n  external_port:\n    type: string\n    description: Kubernetes node port on which CDAPgui is exposed\n    default: \"32012\"\n  policy_model_id:\n    type: string\n    default: \"onap.policies.monitoring.cdap.tca.hi.lo.app\"\nnode_templates:\n  tca_k8s:\n    type: dcae.nodes.ContainerizedServiceComponent\n    relationships:\n      - target: tca_policy\n        type: cloudify.relationships.depends_on\n    properties:\n        service_component_type: \'dcaegen2-analytics-tca\'\n        application_config: {}\n        docker_config: {}\n        image:\n          get_input: tag_version\n        log_info:\n          log_directory: \"/opt/app/TCAnalytics/logs\"\n        application_config:\n            app_config:\n                appDescription: DCAE Analytics Threshold Crossing Alert Application\n                appName: dcae-tca\n                tcaAlertsAbatementTableName: TCAAlertsAbatementTable\n                tcaAlertsAbatementTableTTLSeconds: \'1728000\'\n                tcaSubscriberOutputStreamName: TCASubscriberOutputStream\n                tcaVESAlertsTableName: TCAVESAlertsTable\n                tcaVESAlertsTableTTLSeconds: \'1728000\'\n                tcaVESMessageStatusTableName: TCAVESMessageStatusTable\n                tcaVESMessageStatusTableTTLSeconds: \'86400\'\n                thresholdCalculatorFlowletInstances: \'2\'\n            app_preferences:\n                aaiEnrichmentHost:\n                    get_input: aaiEnrichmentHost\n                aaiEnrichmentIgnoreSSLCertificateErrors: \'true\'\n                aaiEnrichmentPortNumber: \'8443\'\n                aaiEnrichmentProtocol: https\n                aaiEnrichmentUserName: dcae@dcae.onap.org\n                aaiEnrichmentUserPassword: demo123456!\n                aaiVMEnrichmentAPIPath: /aai/v11/search/nodes-query\n                aaiVNFEnrichmentAPIPath: /aai/v11/network/generic-vnfs/generic-vnf\n                enableAAIEnrichment:\n                    get_input: enableAAIEnrichment\n                enableRedisCaching:\n                    get_input: enableRedisCaching\n                redisHosts:\n                    get_input: redisHosts\n                enableAlertCEFFormat: \'false\'\n                publisherContentType: application/json\n                publisherHostName:\n                    get_input: dmaap_host\n                publisherHostPort:\n                    get_input: dmaap_port\n                publisherMaxBatchSize: \'1\'\n                publisherMaxRecoveryQueueSize: \'100000\'\n                publisherPollingInterval: \'20000\'\n                publisherProtocol: http\n                publisherTopicName: unauthenticated.DCAE_CL_OUTPUT\n                subscriberConsumerGroup: OpenDCAE-clamp\n                subscriberConsumerId: c12\n                subscriberContentType: application/json\n                subscriberHostName:\n                    get_input: dmaap_host\n                subscriberHostPort:\n                    get_input: dmaap_port\n                subscriberMessageLimit: \'-1\'\n                subscriberPollingInterval: \'30000\'\n                subscriberProtocol: http\n                subscriberTimeoutMS: \'-1\'\n                subscriberTopicName: unauthenticated.VES_MEASUREMENT_OUTPUT\n#                tca_policy: \'{\"domain\":\"measurementsForVfScaling\",\"metricsPerEventName\":[{\"eventName\":\"vFirewallBroadcastPackets\",\"controlLoopSchemaType\":\"VNF\",\"policyScope\":\"DCAE\",\"policyName\":\"DCAE.Config_tca-hi-lo\",\"policyVersion\":\"v0.0.1\",\"thresholds\":[{\"closedLoopControlName\":\"ControlLoop-vFirewall-d0a1dfc6-94f5-4fd4-a5b5-4630b438850a\",\"version\":\"1.0.2\",\"fieldPath\":\"$.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta\",\"thresholdValue\":300,\"direction\":\"LESS_OR_EQUAL\",\"severity\":\"MAJOR\",\"closedLoopEventStatus\":\"ONSET\"},{\"closedLoopControlName\":\"ControlLoop-vFirewall-d0a1dfc6-94f5-4fd4-a5b5-4630b438850a\",\"version\":\"1.0.2\",\"fieldPath\":\"$.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta\",\"thresholdValue\":700,\"direction\":\"GREATER_OR_EQUAL\",\"severity\":\"CRITICAL\",\"closedLoopEventStatus\":\"ONSET\"}]},{\"eventName\":\"vLoadBalancer\",\"controlLoopSchemaType\":\"VM\",\"policyScope\":\"DCAE\",\"policyName\":\"DCAE.Config_tca-hi-lo\",\"policyVersion\":\"v0.0.1\",\"thresholds\":[{\"closedLoopControlName\":\"ControlLoop-vDNS-6f37f56d-a87d-4b85-b6a9-cc953cf779b3\",\"version\":\"1.0.2\",\"fieldPath\":\"$.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta\",\"thresholdValue\":300,\"direction\":\"GREATER_OR_EQUAL\",\"severity\":\"CRITICAL\",\"closedLoopEventStatus\":\"ONSET\"}]},{\"eventName\":\"Measurement_vGMUX\",\"controlLoopSchemaType\":\"VNF\",\"policyScope\":\"DCAE\",\"policyName\":\"DCAE.Config_tca-hi-lo\",\"policyVersion\":\"v0.0.1\",\"thresholds\":[{\"closedLoopControlName\":\"ControlLoop-vCPE-48f0c2c3-a172-4192-9ae3-052274181b6e\",\"version\":\"1.0.2\",\"fieldPath\":\"$.event.measurementsForVfScalingFields.additionalMeasurements[*].arrayOfFields[0].value\",\"thresholdValue\":0,\"direction\":\"EQUAL\",\"severity\":\"MAJOR\",\"closedLoopEventStatus\":\"ABATED\"},{\"closedLoopControlName\":\"ControlLoop-vCPE-48f0c2c3-a172-4192-9ae3-052274181b6e\",\"version\":\"1.0.2\",\"fieldPath\":\"$.event.measurementsForVfScalingFields.additionalMeasurements[*].arrayOfFields[0].value\",\"thresholdValue\":0,\"direction\":\"GREATER\",\"severity\":\"CRITICAL\",\"closedLoopEventStatus\":\"ONSET\"}]}]}\'\n        service_component_type: dcaegen2-analytics_tca\n    interfaces:\n      cloudify.interfaces.lifecycle:\n        start:\n          inputs:\n            envs:\n                DMAAPHOST:\n                    { get_input: dmaap_host }\n                DMAAPPORT:\n                    { get_input: dmaap_port }\n                DMAAPPUBTOPIC: \"unauthenticated.DCAE_CL_OUTPUT\"\n                DMAAPSUBTOPIC: \"unauthenticated.VES_MEASUREMENT_OUTPUT\"\n                AAIHOST:\n                    { get_input: aaiEnrichmentHost }\n                AAIPORT:\n                    { get_input: aaiEnrichmentPort }\n                CONSUL_HOST:\n                    { get_input: consul_host }\n                CONSUL_PORT:\n                    { get_input: consul_port }\n                CBS_HOST:\n                    { get_input: cbs_host }\n                CBS_PORT:\n                    { get_input: cbs_port }\n                CONFIG_BINDING_SERVICE: \"config_binding_service\"\n            ports:\n              - concat: [\"11011:\", { get_input: external_port }]\n  tca_policy:\n    type: clamp.nodes.policy\n    properties:\n      policy_id:\n           get_input: policy_id\n      policy_model_id: \"onap.policies.monitoring.cdap.tca.hi.lo.app\"\n','typeId-e3a75307-db43-4d5a-869d-75ff38d86dda',0,'<svg xmlns=\"http://www.w3.org/2000/svg\"><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"start-circle\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><circle fill=\"none\" r=\"17\" cx=\"18\" cy=\"41\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"Arrow-d29c82c3-4632-4f4a-8817-19b82649e34c\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><line y2=\"41\" fill=\"none\" x1=\"35\" x2=\"123\" y1=\"41\"/><polygon fill=\"none\" points=\" 121 39 121 43 125 41\"/><polygon points=\" 121 39 121 43 125 41\" stroke=\"none\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"VES\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><rect fill=\"none\" x=\"127\" width=\"123\" y=\"1\" height=\"82\"/></g><g fill-opacity=\"0\" fill=\"rgb(0,0,0)\" text-rendering=\"optimizeQuality\" shape-rendering=\"geometricPrecision\" stroke=\"rgb(0,0,0)\" stroke-opacity=\"0\" stroke-width=\"2\"><rect x=\"127\" width=\"123\" y=\"1\" height=\"82\" stroke=\"none\"/></g><g text-rendering=\"optimizeQuality\" stroke-width=\"2\" shape-rendering=\"geometricPrecision\" font-family=\"sans-serif\"><text x=\"177.5\" xml:space=\"preserve\" y=\"46.5\" stroke=\"none\">VES</text><line y2=\"83\" fill=\"none\" x1=\"147\" x2=\"147\" y1=\"1\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"Arrow-a05e8625-c40d-4d24-b50c-2c65734399ea\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><line y2=\"41\" fill=\"none\" x1=\"250\" x2=\"338\" y1=\"41\"/><polygon fill=\"none\" points=\" 336 39 336 43 340 41\"/><polygon points=\" 336 39 336 43 340 41\" stroke=\"none\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"onap.policies.monitoring.cdap.tca.hi.lo.app\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><rect fill=\"none\" x=\"342\" width=\"123\" y=\"1\" height=\"82\"/></g><g fill-opacity=\"0\" fill=\"rgb(0,0,0)\" text-rendering=\"optimizeQuality\" shape-rendering=\"geometricPrecision\" stroke=\"rgb(0,0,0)\" stroke-opacity=\"0\" stroke-width=\"2\"><rect x=\"342\" width=\"123\" y=\"1\" height=\"82\" stroke=\"none\"/></g><g text-rendering=\"optimizeQuality\" stroke-width=\"2\" shape-rendering=\"geometricPrecision\" font-family=\"sans-serif\"><text x=\"393\" xml:space=\"preserve\" y=\"46.5\" stroke=\"none\">app</text><line y2=\"61\" fill=\"none\" x1=\"342\" x2=\"465\" y1=\"61\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"Arrow-412a95e2-554a-4f62-9887-21105c8d0bb8\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"2\"><line y2=\"41\" fill=\"none\" x1=\"465\" x2=\"553\" y1=\"41\"/><polygon fill=\"none\" points=\" 551 39 551 43 555 41\"/><polygon points=\" 551 39 551 43 555 41\" stroke=\"none\"/></g></g></g><g fill-opacity=\"1\" color-rendering=\"auto\" color-interpolation=\"auto\" text-rendering=\"auto\" stroke=\"black\" stroke-linecap=\"square\" stroke-miterlimit=\"10\" shape-rendering=\"auto\" stroke-opacity=\"1\" fill=\"black\" stroke-dasharray=\"none\" font-weight=\"normal\" stroke-width=\"1\" font-family=\"\'Dialog\'\" font-style=\"normal\" data-element-id=\"stop-circle\" stroke-linejoin=\"miter\" font-size=\"12px\" image-rendering=\"auto\" stroke-dashoffset=\"0\"><!--Generated by the Batik Graphics2D SVG Generator--><defs id=\"genericDefs\"/><g><g shape-rendering=\"geometricPrecision\" text-rendering=\"optimizeQuality\" stroke-width=\"4\"><circle fill=\"none\" r=\"17\" cx=\"574\" cy=\"41\"/></g></g></g></svg>',1,'63cac700-ab9a-4115-a74f-7eac85e3fce0');
 /*!40000 ALTER TABLE `loop_templates` ENABLE KEYS */;
 UNLOCK TABLES;
 
@@ -122,9 +122,9 @@
 
 LOCK TABLES `looptemplates_to_loopelementmodels` WRITE;
 /*!40000 ALTER TABLE `looptemplates_to_loopelementmodels` DISABLE KEYS */;
-INSERT INTO `looptemplates_to_loopelementmodels` VALUES ('onap.policies.monitoring.cdap.tca.hi.lo.app','LOOP_TEMPLATE_ur2KW_v1_0_ResourceInstanceName1_tca',0);
-INSERT INTO `looptemplates_to_loopelementmodels` VALUES ('onap.policies.monitoring.cdap.tca.hi.lo.app','LOOP_TEMPLATE_ur2KW_v1_0_ResourceInstanceName1_tca_3',0);
-INSERT INTO `looptemplates_to_loopelementmodels` VALUES ('onap.policies.monitoring.cdap.tca.hi.lo.app','LOOP_TEMPLATE_ur2KW_v1_0_ResourceInstanceName2_tca_2',0);
+INSERT INTO `looptemplates_to_loopelementmodels` VALUES ('onap.policies.monitoring.cdap.tca.hi.lo.app','LOOP_TEMPLATE_lCoAC_v1_0_ResourceInstanceName1_tca',0);
+INSERT INTO `looptemplates_to_loopelementmodels` VALUES ('onap.policies.monitoring.cdap.tca.hi.lo.app','LOOP_TEMPLATE_lCoAC_v1_0_ResourceInstanceName1_tca_3',0);
+INSERT INTO `looptemplates_to_loopelementmodels` VALUES ('onap.policies.monitoring.cdap.tca.hi.lo.app','LOOP_TEMPLATE_lCoAC_v1_0_ResourceInstanceName2_tca_2',0);
 /*!40000 ALTER TABLE `looptemplates_to_loopelementmodels` ENABLE KEYS */;
 UNLOCK TABLES;
 
@@ -152,15 +152,15 @@
 
 LOCK TABLES `policy_models` WRITE;
 /*!40000 ALTER TABLE `policy_models` DISABLE KEYS */;
-INSERT INTO `policy_models` VALUES ('onap.policies.controlloop.Guard','1.0.0','Not found','2020-02-26 04:13:02.073313','Not found','2020-02-26 04:13:02.073313','Guard','{\"policyTypeId\": \"onap.policies.controlloop.operational\",\"policyTypeVersion\": \"1.0.0\",\"policyId\": \"OPERATIONAL_z711F_v1_0_ResourceInstanceName1_tca\"}');
-INSERT INTO `policy_models` VALUES ('onap.policies.controlloop.guard.Blacklist','1.0.0','Not found','2020-02-26 04:13:02.320782','Not found','2020-02-26 04:13:02.320782','Blacklist','{\"policyTypeId\": \"onap.policies.controlloop.operational\",\"policyTypeVersion\": \"1.0.0\",\"policyId\": \"OPERATIONAL_z711F_v1_0_ResourceInstanceName1_tca\"}');
-INSERT INTO `policy_models` VALUES ('onap.policies.controlloop.guard.FrequencyLimiter','1.0.0','Not found','2020-02-26 04:13:02.008960','Not found','2020-02-26 04:13:02.008960','FrequencyLimiter','{\"policyTypeId\": \"onap.policies.controlloop.operational\",\"policyTypeVersion\": \"1.0.0\",\"policyId\": \"OPERATIONAL_z711F_v1_0_ResourceInstanceName1_tca\"}');
-INSERT INTO `policy_models` VALUES ('onap.policies.controlloop.guard.MinMax','1.0.0','Not found','2020-02-26 04:13:01.997505','Not found','2020-02-26 04:13:01.997505','MinMax','{\"policyTypeId\": \"onap.policies.controlloop.operational\",\"policyTypeVersion\": \"1.0.0\",\"policyId\": \"OPERATIONAL_z711F_v1_0_ResourceInstanceName1_tca\"}');
-INSERT INTO `policy_models` VALUES ('onap.policies.controlloop.Operational','1.0.0','Not found','2020-02-26 04:13:02.471738','Not found','2020-02-26 04:13:02.471738','Operational','{\"policyTypeId\": \"onap.policies.controlloop.operational\",\"policyTypeVersion\": \"1.0.0\",\"policyId\": \"OPERATIONAL_z711F_v1_0_ResourceInstanceName1_tca\"}');
-INSERT INTO `policy_models` VALUES ('onap.policies.controloop.operational.Apex','1.0.0','Not found','2020-02-26 04:13:02.380152','Not found','2020-02-26 04:13:02.380152','Apex','{\"policyTypeId\": \"onap.policies.controlloop.operational\",\"policyTypeVersion\": \"1.0.0\",\"policyId\": \"OPERATIONAL_z711F_v1_0_ResourceInstanceName1_tca\"}');
-INSERT INTO `policy_models` VALUES ('onap.policies.controloop.operational.Drools','1.0.0','Not found','2020-02-26 04:13:02.001488','Not found','2020-02-26 04:13:02.001488','Drools','{\"policyTypeId\": \"onap.policies.controlloop.operational\",\"policyTypeVersion\": \"1.0.0\",\"policyId\": \"OPERATIONAL_z711F_v1_0_ResourceInstanceName1_tca\"}');
-INSERT INTO `policy_models` VALUES ('onap.policies.Monitoring','1.0.0','Not found','2020-02-26 04:13:02.553548','Not found','2020-02-26 04:13:02.553548','Monitoring','{\"policyTypeId\": \"onap.policies.controlloop.operational\",\"policyTypeVersion\": \"1.0.0\",\"policyId\": \"OPERATIONAL_z711F_v1_0_ResourceInstanceName1_tca\"}');
-INSERT INTO `policy_models` VALUES ('onap.policies.monitoring.cdap.tca.hi.lo.app','1.0.0','Not found','2020-02-26 04:12:57.983305','Not found','2020-02-26 04:12:57.983305','app','{\"policyTypeId\": \"onap.policies.controlloop.operational\",\"policyTypeVersion\": \"1.0.0\",\"policyId\": \"OPERATIONAL_z711F_v1_0_ResourceInstanceName1_tca\"}');
+INSERT INTO `policy_models` VALUES ('onap.policies.controlloop.Guard','1.0.0','Not found','2020-02-27 15:09:20.557489','Not found','2020-02-27 15:09:21.051644','Guard','tosca_definitions_version: tosca_simple_yaml_1_0_0\npolicy_types:\n    onap.policies.Monitoring:\n        derived_from: tosca.policies.Root\n        description: a base policy type for all policies that governs monitoring provisioning\n    onap.policies.monitoring.cdap.tca.hi.lo.app:\n        derived_from: onap.policies.Monitoring\n        version: 1.0.0\n        properties:\n            tca_policy:\n                type: map\n                description: TCA Policy JSON\n                entry_schema:\n                    type: onap.datatypes.monitoring.tca_policy\ndata_types:\n    onap.datatypes.monitoring.metricsPerEventName:\n        derived_from: tosca.datatypes.Root\n        properties:\n            controlLoopSchemaType:\n                type: string\n                required: true\n                description: Specifies Control Loop Schema Type for the event Name e.g. VNF, VM\n                constraints:\n                  - valid_values:\n                      - VM\n                      - VNF\n            eventName:\n                type: string\n                required: true\n                description: Event name to which thresholds need to be applied\n            policyName:\n                type: string\n                required: true\n                description: TCA Policy Scope Name\n            policyScope:\n                type: string\n                required: true\n                description: TCA Policy Scope\n            policyVersion:\n                type: string\n                required: true\n                description: TCA Policy Scope Version\n            thresholds:\n                type: list\n                required: true\n                description: Thresholds associated with eventName\n                entry_schema:\n                    type: onap.datatypes.monitoring.thresholds\n    onap.datatypes.monitoring.tca_policy:\n        derived_from: tosca.datatypes.Root\n        properties:\n            domain:\n                type: string\n                required: true\n                description: Domain name to which TCA needs to be applied\n                default: measurementsForVfScaling\n                constraints:\n                  - equal: measurementsForVfScaling\n            metricsPerEventName:\n                type: list\n                required: true\n                description: Contains eventName and threshold details that need to be applied to given eventName\n                entry_schema:\n                    type: onap.datatypes.monitoring.metricsPerEventName\n    onap.datatypes.monitoring.thresholds:\n        derived_from: tosca.datatypes.Root\n        properties:\n            closedLoopControlName:\n                type: string\n                required: true\n                description: Closed Loop Control Name associated with the threshold\n            closedLoopEventStatus:\n                type: string\n                required: true\n                description: Closed Loop Event Status of the threshold\n                constraints:\n                  - valid_values:\n                      - ONSET\n                      - ABATED\n            direction:\n                type: string\n                required: true\n                description: Direction of the threshold\n                constraints:\n                  - valid_values:\n                      - LESS\n                      - LESS_OR_EQUAL\n                      - GREATER\n                      - GREATER_OR_EQUAL\n                      - EQUAL\n            fieldPath:\n                type: string\n                required: true\n                description: Json field Path as per CEF message which needs to be analyzed for TCA\n                constraints:\n                  - valid_values:\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuIdle\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageInterrupt\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageNice\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSoftIrq\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSteal\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSystem\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuWait\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].percentUsage\n                      - $.event.measurementsForVfScalingFields.meanRequestLatency\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryBuffered\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryCached\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryConfigured\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryFree\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryUsed\n                      - $.event.measurementsForVfScalingFields.additionalMeasurements[*].arrayOfFields[0].value\n            severity:\n                type: string\n                required: true\n                description: Threshold Event Severity\n                constraints:\n                  - valid_values:\n                      - CRITICAL\n                      - MAJOR\n                      - MINOR\n                      - WARNING\n                      - NORMAL\n            thresholdValue:\n                type: integer\n                required: true\n                description: Threshold value for the field Path inside CEF message\n            version:\n                type: string\n                required: true\n                description: Version number associated with the threshold\n','{\n  \"supportedPdpGroups\": [\n    {\n      \"controlloop\": [\n        \"xacml\"\n      ]\n    }\n  ]\n}');
+INSERT INTO `policy_models` VALUES ('onap.policies.controlloop.guard.Blacklist','1.0.0','Not found','2020-02-27 15:09:20.518533','Not found','2020-02-27 15:09:20.518533','Blacklist','tosca_definitions_version: tosca_simple_yaml_1_0_0\npolicy_types:\n    onap.policies.Monitoring:\n        derived_from: tosca.policies.Root\n        description: a base policy type for all policies that governs monitoring provisioning\n    onap.policies.monitoring.cdap.tca.hi.lo.app:\n        derived_from: onap.policies.Monitoring\n        version: 1.0.0\n        properties:\n            tca_policy:\n                type: map\n                description: TCA Policy JSON\n                entry_schema:\n                    type: onap.datatypes.monitoring.tca_policy\ndata_types:\n    onap.datatypes.monitoring.metricsPerEventName:\n        derived_from: tosca.datatypes.Root\n        properties:\n            controlLoopSchemaType:\n                type: string\n                required: true\n                description: Specifies Control Loop Schema Type for the event Name e.g. VNF, VM\n                constraints:\n                  - valid_values:\n                      - VM\n                      - VNF\n            eventName:\n                type: string\n                required: true\n                description: Event name to which thresholds need to be applied\n            policyName:\n                type: string\n                required: true\n                description: TCA Policy Scope Name\n            policyScope:\n                type: string\n                required: true\n                description: TCA Policy Scope\n            policyVersion:\n                type: string\n                required: true\n                description: TCA Policy Scope Version\n            thresholds:\n                type: list\n                required: true\n                description: Thresholds associated with eventName\n                entry_schema:\n                    type: onap.datatypes.monitoring.thresholds\n    onap.datatypes.monitoring.tca_policy:\n        derived_from: tosca.datatypes.Root\n        properties:\n            domain:\n                type: string\n                required: true\n                description: Domain name to which TCA needs to be applied\n                default: measurementsForVfScaling\n                constraints:\n                  - equal: measurementsForVfScaling\n            metricsPerEventName:\n                type: list\n                required: true\n                description: Contains eventName and threshold details that need to be applied to given eventName\n                entry_schema:\n                    type: onap.datatypes.monitoring.metricsPerEventName\n    onap.datatypes.monitoring.thresholds:\n        derived_from: tosca.datatypes.Root\n        properties:\n            closedLoopControlName:\n                type: string\n                required: true\n                description: Closed Loop Control Name associated with the threshold\n            closedLoopEventStatus:\n                type: string\n                required: true\n                description: Closed Loop Event Status of the threshold\n                constraints:\n                  - valid_values:\n                      - ONSET\n                      - ABATED\n            direction:\n                type: string\n                required: true\n                description: Direction of the threshold\n                constraints:\n                  - valid_values:\n                      - LESS\n                      - LESS_OR_EQUAL\n                      - GREATER\n                      - GREATER_OR_EQUAL\n                      - EQUAL\n            fieldPath:\n                type: string\n                required: true\n                description: Json field Path as per CEF message which needs to be analyzed for TCA\n                constraints:\n                  - valid_values:\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuIdle\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageInterrupt\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageNice\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSoftIrq\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSteal\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSystem\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuWait\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].percentUsage\n                      - $.event.measurementsForVfScalingFields.meanRequestLatency\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryBuffered\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryCached\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryConfigured\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryFree\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryUsed\n                      - $.event.measurementsForVfScalingFields.additionalMeasurements[*].arrayOfFields[0].value\n            severity:\n                type: string\n                required: true\n                description: Threshold Event Severity\n                constraints:\n                  - valid_values:\n                      - CRITICAL\n                      - MAJOR\n                      - MINOR\n                      - WARNING\n                      - NORMAL\n            thresholdValue:\n                type: integer\n                required: true\n                description: Threshold value for the field Path inside CEF message\n            version:\n                type: string\n                required: true\n                description: Version number associated with the threshold\n',NULL);
+INSERT INTO `policy_models` VALUES ('onap.policies.controlloop.guard.FrequencyLimiter','1.0.0','Not found','2020-02-27 15:09:20.386878','Not found','2020-02-27 15:09:20.386878','FrequencyLimiter','tosca_definitions_version: tosca_simple_yaml_1_0_0\npolicy_types:\n    onap.policies.Monitoring:\n        derived_from: tosca.policies.Root\n        description: a base policy type for all policies that governs monitoring provisioning\n    onap.policies.monitoring.cdap.tca.hi.lo.app:\n        derived_from: onap.policies.Monitoring\n        version: 1.0.0\n        properties:\n            tca_policy:\n                type: map\n                description: TCA Policy JSON\n                entry_schema:\n                    type: onap.datatypes.monitoring.tca_policy\ndata_types:\n    onap.datatypes.monitoring.metricsPerEventName:\n        derived_from: tosca.datatypes.Root\n        properties:\n            controlLoopSchemaType:\n                type: string\n                required: true\n                description: Specifies Control Loop Schema Type for the event Name e.g. VNF, VM\n                constraints:\n                  - valid_values:\n                      - VM\n                      - VNF\n            eventName:\n                type: string\n                required: true\n                description: Event name to which thresholds need to be applied\n            policyName:\n                type: string\n                required: true\n                description: TCA Policy Scope Name\n            policyScope:\n                type: string\n                required: true\n                description: TCA Policy Scope\n            policyVersion:\n                type: string\n                required: true\n                description: TCA Policy Scope Version\n            thresholds:\n                type: list\n                required: true\n                description: Thresholds associated with eventName\n                entry_schema:\n                    type: onap.datatypes.monitoring.thresholds\n    onap.datatypes.monitoring.tca_policy:\n        derived_from: tosca.datatypes.Root\n        properties:\n            domain:\n                type: string\n                required: true\n                description: Domain name to which TCA needs to be applied\n                default: measurementsForVfScaling\n                constraints:\n                  - equal: measurementsForVfScaling\n            metricsPerEventName:\n                type: list\n                required: true\n                description: Contains eventName and threshold details that need to be applied to given eventName\n                entry_schema:\n                    type: onap.datatypes.monitoring.metricsPerEventName\n    onap.datatypes.monitoring.thresholds:\n        derived_from: tosca.datatypes.Root\n        properties:\n            closedLoopControlName:\n                type: string\n                required: true\n                description: Closed Loop Control Name associated with the threshold\n            closedLoopEventStatus:\n                type: string\n                required: true\n                description: Closed Loop Event Status of the threshold\n                constraints:\n                  - valid_values:\n                      - ONSET\n                      - ABATED\n            direction:\n                type: string\n                required: true\n                description: Direction of the threshold\n                constraints:\n                  - valid_values:\n                      - LESS\n                      - LESS_OR_EQUAL\n                      - GREATER\n                      - GREATER_OR_EQUAL\n                      - EQUAL\n            fieldPath:\n                type: string\n                required: true\n                description: Json field Path as per CEF message which needs to be analyzed for TCA\n                constraints:\n                  - valid_values:\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuIdle\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageInterrupt\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageNice\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSoftIrq\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSteal\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSystem\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuWait\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].percentUsage\n                      - $.event.measurementsForVfScalingFields.meanRequestLatency\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryBuffered\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryCached\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryConfigured\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryFree\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryUsed\n                      - $.event.measurementsForVfScalingFields.additionalMeasurements[*].arrayOfFields[0].value\n            severity:\n                type: string\n                required: true\n                description: Threshold Event Severity\n                constraints:\n                  - valid_values:\n                      - CRITICAL\n                      - MAJOR\n                      - MINOR\n                      - WARNING\n                      - NORMAL\n            thresholdValue:\n                type: integer\n                required: true\n                description: Threshold value for the field Path inside CEF message\n            version:\n                type: string\n                required: true\n                description: Version number associated with the threshold\n',NULL);
+INSERT INTO `policy_models` VALUES ('onap.policies.controlloop.guard.MinMax','1.0.0','Not found','2020-02-27 15:09:20.483188','Not found','2020-02-27 15:09:20.483188','MinMax','tosca_definitions_version: tosca_simple_yaml_1_0_0\npolicy_types:\n    onap.policies.Monitoring:\n        derived_from: tosca.policies.Root\n        description: a base policy type for all policies that governs monitoring provisioning\n    onap.policies.monitoring.cdap.tca.hi.lo.app:\n        derived_from: onap.policies.Monitoring\n        version: 1.0.0\n        properties:\n            tca_policy:\n                type: map\n                description: TCA Policy JSON\n                entry_schema:\n                    type: onap.datatypes.monitoring.tca_policy\ndata_types:\n    onap.datatypes.monitoring.metricsPerEventName:\n        derived_from: tosca.datatypes.Root\n        properties:\n            controlLoopSchemaType:\n                type: string\n                required: true\n                description: Specifies Control Loop Schema Type for the event Name e.g. VNF, VM\n                constraints:\n                  - valid_values:\n                      - VM\n                      - VNF\n            eventName:\n                type: string\n                required: true\n                description: Event name to which thresholds need to be applied\n            policyName:\n                type: string\n                required: true\n                description: TCA Policy Scope Name\n            policyScope:\n                type: string\n                required: true\n                description: TCA Policy Scope\n            policyVersion:\n                type: string\n                required: true\n                description: TCA Policy Scope Version\n            thresholds:\n                type: list\n                required: true\n                description: Thresholds associated with eventName\n                entry_schema:\n                    type: onap.datatypes.monitoring.thresholds\n    onap.datatypes.monitoring.tca_policy:\n        derived_from: tosca.datatypes.Root\n        properties:\n            domain:\n                type: string\n                required: true\n                description: Domain name to which TCA needs to be applied\n                default: measurementsForVfScaling\n                constraints:\n                  - equal: measurementsForVfScaling\n            metricsPerEventName:\n                type: list\n                required: true\n                description: Contains eventName and threshold details that need to be applied to given eventName\n                entry_schema:\n                    type: onap.datatypes.monitoring.metricsPerEventName\n    onap.datatypes.monitoring.thresholds:\n        derived_from: tosca.datatypes.Root\n        properties:\n            closedLoopControlName:\n                type: string\n                required: true\n                description: Closed Loop Control Name associated with the threshold\n            closedLoopEventStatus:\n                type: string\n                required: true\n                description: Closed Loop Event Status of the threshold\n                constraints:\n                  - valid_values:\n                      - ONSET\n                      - ABATED\n            direction:\n                type: string\n                required: true\n                description: Direction of the threshold\n                constraints:\n                  - valid_values:\n                      - LESS\n                      - LESS_OR_EQUAL\n                      - GREATER\n                      - GREATER_OR_EQUAL\n                      - EQUAL\n            fieldPath:\n                type: string\n                required: true\n                description: Json field Path as per CEF message which needs to be analyzed for TCA\n                constraints:\n                  - valid_values:\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuIdle\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageInterrupt\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageNice\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSoftIrq\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSteal\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSystem\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuWait\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].percentUsage\n                      - $.event.measurementsForVfScalingFields.meanRequestLatency\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryBuffered\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryCached\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryConfigured\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryFree\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryUsed\n                      - $.event.measurementsForVfScalingFields.additionalMeasurements[*].arrayOfFields[0].value\n            severity:\n                type: string\n                required: true\n                description: Threshold Event Severity\n                constraints:\n                  - valid_values:\n                      - CRITICAL\n                      - MAJOR\n                      - MINOR\n                      - WARNING\n                      - NORMAL\n            thresholdValue:\n                type: integer\n                required: true\n                description: Threshold value for the field Path inside CEF message\n            version:\n                type: string\n                required: true\n                description: Version number associated with the threshold\n',NULL);
+INSERT INTO `policy_models` VALUES ('onap.policies.controlloop.Operational','1.0.0','Not found','2020-02-27 15:09:20.358225','Not found','2020-02-27 15:09:21.072743','Operational','tosca_definitions_version: tosca_simple_yaml_1_0_0\npolicy_types:\n    onap.policies.Monitoring:\n        derived_from: tosca.policies.Root\n        description: a base policy type for all policies that governs monitoring provisioning\n    onap.policies.monitoring.cdap.tca.hi.lo.app:\n        derived_from: onap.policies.Monitoring\n        version: 1.0.0\n        properties:\n            tca_policy:\n                type: map\n                description: TCA Policy JSON\n                entry_schema:\n                    type: onap.datatypes.monitoring.tca_policy\ndata_types:\n    onap.datatypes.monitoring.metricsPerEventName:\n        derived_from: tosca.datatypes.Root\n        properties:\n            controlLoopSchemaType:\n                type: string\n                required: true\n                description: Specifies Control Loop Schema Type for the event Name e.g. VNF, VM\n                constraints:\n                  - valid_values:\n                      - VM\n                      - VNF\n            eventName:\n                type: string\n                required: true\n                description: Event name to which thresholds need to be applied\n            policyName:\n                type: string\n                required: true\n                description: TCA Policy Scope Name\n            policyScope:\n                type: string\n                required: true\n                description: TCA Policy Scope\n            policyVersion:\n                type: string\n                required: true\n                description: TCA Policy Scope Version\n            thresholds:\n                type: list\n                required: true\n                description: Thresholds associated with eventName\n                entry_schema:\n                    type: onap.datatypes.monitoring.thresholds\n    onap.datatypes.monitoring.tca_policy:\n        derived_from: tosca.datatypes.Root\n        properties:\n            domain:\n                type: string\n                required: true\n                description: Domain name to which TCA needs to be applied\n                default: measurementsForVfScaling\n                constraints:\n                  - equal: measurementsForVfScaling\n            metricsPerEventName:\n                type: list\n                required: true\n                description: Contains eventName and threshold details that need to be applied to given eventName\n                entry_schema:\n                    type: onap.datatypes.monitoring.metricsPerEventName\n    onap.datatypes.monitoring.thresholds:\n        derived_from: tosca.datatypes.Root\n        properties:\n            closedLoopControlName:\n                type: string\n                required: true\n                description: Closed Loop Control Name associated with the threshold\n            closedLoopEventStatus:\n                type: string\n                required: true\n                description: Closed Loop Event Status of the threshold\n                constraints:\n                  - valid_values:\n                      - ONSET\n                      - ABATED\n            direction:\n                type: string\n                required: true\n                description: Direction of the threshold\n                constraints:\n                  - valid_values:\n                      - LESS\n                      - LESS_OR_EQUAL\n                      - GREATER\n                      - GREATER_OR_EQUAL\n                      - EQUAL\n            fieldPath:\n                type: string\n                required: true\n                description: Json field Path as per CEF message which needs to be analyzed for TCA\n                constraints:\n                  - valid_values:\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuIdle\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageInterrupt\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageNice\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSoftIrq\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSteal\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSystem\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuWait\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].percentUsage\n                      - $.event.measurementsForVfScalingFields.meanRequestLatency\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryBuffered\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryCached\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryConfigured\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryFree\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryUsed\n                      - $.event.measurementsForVfScalingFields.additionalMeasurements[*].arrayOfFields[0].value\n            severity:\n                type: string\n                required: true\n                description: Threshold Event Severity\n                constraints:\n                  - valid_values:\n                      - CRITICAL\n                      - MAJOR\n                      - MINOR\n                      - WARNING\n                      - NORMAL\n            thresholdValue:\n                type: integer\n                required: true\n                description: Threshold value for the field Path inside CEF message\n            version:\n                type: string\n                required: true\n                description: Version number associated with the threshold\n','{\n  \"supportedPdpGroups\": [\n    {\n      \"controlloop\": [\n        \"apex\",\n        \"drools\"\n      ]\n    }\n  ]\n}');
+INSERT INTO `policy_models` VALUES ('onap.policies.controloop.operational.Apex','1.0.0','Not found','2020-02-27 15:09:20.354431','Not found','2020-02-27 15:09:20.354431','Apex','tosca_definitions_version: tosca_simple_yaml_1_0_0\npolicy_types:\n    onap.policies.Monitoring:\n        derived_from: tosca.policies.Root\n        description: a base policy type for all policies that governs monitoring provisioning\n    onap.policies.monitoring.cdap.tca.hi.lo.app:\n        derived_from: onap.policies.Monitoring\n        version: 1.0.0\n        properties:\n            tca_policy:\n                type: map\n                description: TCA Policy JSON\n                entry_schema:\n                    type: onap.datatypes.monitoring.tca_policy\ndata_types:\n    onap.datatypes.monitoring.metricsPerEventName:\n        derived_from: tosca.datatypes.Root\n        properties:\n            controlLoopSchemaType:\n                type: string\n                required: true\n                description: Specifies Control Loop Schema Type for the event Name e.g. VNF, VM\n                constraints:\n                  - valid_values:\n                      - VM\n                      - VNF\n            eventName:\n                type: string\n                required: true\n                description: Event name to which thresholds need to be applied\n            policyName:\n                type: string\n                required: true\n                description: TCA Policy Scope Name\n            policyScope:\n                type: string\n                required: true\n                description: TCA Policy Scope\n            policyVersion:\n                type: string\n                required: true\n                description: TCA Policy Scope Version\n            thresholds:\n                type: list\n                required: true\n                description: Thresholds associated with eventName\n                entry_schema:\n                    type: onap.datatypes.monitoring.thresholds\n    onap.datatypes.monitoring.tca_policy:\n        derived_from: tosca.datatypes.Root\n        properties:\n            domain:\n                type: string\n                required: true\n                description: Domain name to which TCA needs to be applied\n                default: measurementsForVfScaling\n                constraints:\n                  - equal: measurementsForVfScaling\n            metricsPerEventName:\n                type: list\n                required: true\n                description: Contains eventName and threshold details that need to be applied to given eventName\n                entry_schema:\n                    type: onap.datatypes.monitoring.metricsPerEventName\n    onap.datatypes.monitoring.thresholds:\n        derived_from: tosca.datatypes.Root\n        properties:\n            closedLoopControlName:\n                type: string\n                required: true\n                description: Closed Loop Control Name associated with the threshold\n            closedLoopEventStatus:\n                type: string\n                required: true\n                description: Closed Loop Event Status of the threshold\n                constraints:\n                  - valid_values:\n                      - ONSET\n                      - ABATED\n            direction:\n                type: string\n                required: true\n                description: Direction of the threshold\n                constraints:\n                  - valid_values:\n                      - LESS\n                      - LESS_OR_EQUAL\n                      - GREATER\n                      - GREATER_OR_EQUAL\n                      - EQUAL\n            fieldPath:\n                type: string\n                required: true\n                description: Json field Path as per CEF message which needs to be analyzed for TCA\n                constraints:\n                  - valid_values:\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuIdle\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageInterrupt\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageNice\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSoftIrq\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSteal\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSystem\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuWait\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].percentUsage\n                      - $.event.measurementsForVfScalingFields.meanRequestLatency\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryBuffered\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryCached\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryConfigured\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryFree\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryUsed\n                      - $.event.measurementsForVfScalingFields.additionalMeasurements[*].arrayOfFields[0].value\n            severity:\n                type: string\n                required: true\n                description: Threshold Event Severity\n                constraints:\n                  - valid_values:\n                      - CRITICAL\n                      - MAJOR\n                      - MINOR\n                      - WARNING\n                      - NORMAL\n            thresholdValue:\n                type: integer\n                required: true\n                description: Threshold value for the field Path inside CEF message\n            version:\n                type: string\n                required: true\n                description: Version number associated with the threshold\n',NULL);
+INSERT INTO `policy_models` VALUES ('onap.policies.controloop.operational.Drools','1.0.0','Not found','2020-02-27 15:09:20.354507','Not found','2020-02-27 15:09:20.354507','Drools','tosca_definitions_version: tosca_simple_yaml_1_0_0\npolicy_types:\n    onap.policies.Monitoring:\n        derived_from: tosca.policies.Root\n        description: a base policy type for all policies that governs monitoring provisioning\n    onap.policies.monitoring.cdap.tca.hi.lo.app:\n        derived_from: onap.policies.Monitoring\n        version: 1.0.0\n        properties:\n            tca_policy:\n                type: map\n                description: TCA Policy JSON\n                entry_schema:\n                    type: onap.datatypes.monitoring.tca_policy\ndata_types:\n    onap.datatypes.monitoring.metricsPerEventName:\n        derived_from: tosca.datatypes.Root\n        properties:\n            controlLoopSchemaType:\n                type: string\n                required: true\n                description: Specifies Control Loop Schema Type for the event Name e.g. VNF, VM\n                constraints:\n                  - valid_values:\n                      - VM\n                      - VNF\n            eventName:\n                type: string\n                required: true\n                description: Event name to which thresholds need to be applied\n            policyName:\n                type: string\n                required: true\n                description: TCA Policy Scope Name\n            policyScope:\n                type: string\n                required: true\n                description: TCA Policy Scope\n            policyVersion:\n                type: string\n                required: true\n                description: TCA Policy Scope Version\n            thresholds:\n                type: list\n                required: true\n                description: Thresholds associated with eventName\n                entry_schema:\n                    type: onap.datatypes.monitoring.thresholds\n    onap.datatypes.monitoring.tca_policy:\n        derived_from: tosca.datatypes.Root\n        properties:\n            domain:\n                type: string\n                required: true\n                description: Domain name to which TCA needs to be applied\n                default: measurementsForVfScaling\n                constraints:\n                  - equal: measurementsForVfScaling\n            metricsPerEventName:\n                type: list\n                required: true\n                description: Contains eventName and threshold details that need to be applied to given eventName\n                entry_schema:\n                    type: onap.datatypes.monitoring.metricsPerEventName\n    onap.datatypes.monitoring.thresholds:\n        derived_from: tosca.datatypes.Root\n        properties:\n            closedLoopControlName:\n                type: string\n                required: true\n                description: Closed Loop Control Name associated with the threshold\n            closedLoopEventStatus:\n                type: string\n                required: true\n                description: Closed Loop Event Status of the threshold\n                constraints:\n                  - valid_values:\n                      - ONSET\n                      - ABATED\n            direction:\n                type: string\n                required: true\n                description: Direction of the threshold\n                constraints:\n                  - valid_values:\n                      - LESS\n                      - LESS_OR_EQUAL\n                      - GREATER\n                      - GREATER_OR_EQUAL\n                      - EQUAL\n            fieldPath:\n                type: string\n                required: true\n                description: Json field Path as per CEF message which needs to be analyzed for TCA\n                constraints:\n                  - valid_values:\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuIdle\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageInterrupt\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageNice\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSoftIrq\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSteal\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSystem\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuWait\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].percentUsage\n                      - $.event.measurementsForVfScalingFields.meanRequestLatency\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryBuffered\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryCached\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryConfigured\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryFree\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryUsed\n                      - $.event.measurementsForVfScalingFields.additionalMeasurements[*].arrayOfFields[0].value\n            severity:\n                type: string\n                required: true\n                description: Threshold Event Severity\n                constraints:\n                  - valid_values:\n                      - CRITICAL\n                      - MAJOR\n                      - MINOR\n                      - WARNING\n                      - NORMAL\n            thresholdValue:\n                type: integer\n                required: true\n                description: Threshold value for the field Path inside CEF message\n            version:\n                type: string\n                required: true\n                description: Version number associated with the threshold\n',NULL);
+INSERT INTO `policy_models` VALUES ('onap.policies.Monitoring','1.0.0','Not found','2020-02-27 15:09:20.514460','Not found','2020-02-27 15:09:20.514460','Monitoring','',NULL);
+INSERT INTO `policy_models` VALUES ('onap.policies.monitoring.cdap.tca.hi.lo.app','1.0.0','Not found','2020-02-27 15:08:46.796072','Not found','2020-02-27 15:09:21.107687','app','tosca_definitions_version: tosca_simple_yaml_1_0_0\npolicy_types:\n    onap.policies.Monitoring:\n        derived_from: tosca.policies.Root\n        description: a base policy type for all policies that governs monitoring provisioning\n    onap.policies.monitoring.cdap.tca.hi.lo.app:\n        derived_from: onap.policies.Monitoring\n        version: 1.0.0\n        properties:\n            tca_policy:\n                type: map\n                description: TCA Policy JSON\n                entry_schema:\n                    type: onap.datatypes.monitoring.tca_policy\ndata_types:\n    onap.datatypes.monitoring.metricsPerEventName:\n        derived_from: tosca.datatypes.Root\n        properties:\n            controlLoopSchemaType:\n                type: string\n                required: true\n                description: Specifies Control Loop Schema Type for the event Name e.g. VNF, VM\n                constraints:\n                  - valid_values:\n                      - VM\n                      - VNF\n            eventName:\n                type: string\n                required: true\n                description: Event name to which thresholds need to be applied\n            policyName:\n                type: string\n                required: true\n                description: TCA Policy Scope Name\n            policyScope:\n                type: string\n                required: true\n                description: TCA Policy Scope\n            policyVersion:\n                type: string\n                required: true\n                description: TCA Policy Scope Version\n            thresholds:\n                type: list\n                required: true\n                description: Thresholds associated with eventName\n                entry_schema:\n                    type: onap.datatypes.monitoring.thresholds\n    onap.datatypes.monitoring.tca_policy:\n        derived_from: tosca.datatypes.Root\n        properties:\n            domain:\n                type: string\n                required: true\n                description: Domain name to which TCA needs to be applied\n                default: measurementsForVfScaling\n                constraints:\n                  - equal: measurementsForVfScaling\n            metricsPerEventName:\n                type: list\n                required: true\n                description: Contains eventName and threshold details that need to be applied to given eventName\n                entry_schema:\n                    type: onap.datatypes.monitoring.metricsPerEventName\n    onap.datatypes.monitoring.thresholds:\n        derived_from: tosca.datatypes.Root\n        properties:\n            closedLoopControlName:\n                type: string\n                required: true\n                description: Closed Loop Control Name associated with the threshold\n            closedLoopEventStatus:\n                type: string\n                required: true\n                description: Closed Loop Event Status of the threshold\n                constraints:\n                  - valid_values:\n                      - ONSET\n                      - ABATED\n            direction:\n                type: string\n                required: true\n                description: Direction of the threshold\n                constraints:\n                  - valid_values:\n                      - LESS\n                      - LESS_OR_EQUAL\n                      - GREATER\n                      - GREATER_OR_EQUAL\n                      - EQUAL\n            fieldPath:\n                type: string\n                required: true\n                description: Json field Path as per CEF message which needs to be analyzed for TCA\n                constraints:\n                  - valid_values:\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsDelta\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsAccumulated\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuIdle\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageInterrupt\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageNice\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSoftIrq\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSteal\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSystem\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuWait\n                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].percentUsage\n                      - $.event.measurementsForVfScalingFields.meanRequestLatency\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryBuffered\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryCached\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryConfigured\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryFree\n                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryUsed\n                      - $.event.measurementsForVfScalingFields.additionalMeasurements[*].arrayOfFields[0].value\n            severity:\n                type: string\n                required: true\n                description: Threshold Event Severity\n                constraints:\n                  - valid_values:\n                      - CRITICAL\n                      - MAJOR\n                      - MINOR\n                      - WARNING\n                      - NORMAL\n            thresholdValue:\n                type: integer\n                required: true\n                description: Threshold value for the field Path inside CEF message\n            version:\n                type: string\n                required: true\n                description: Version number associated with the threshold\n','{\n  \"supportedPdpGroups\": [\n    {\n      \"monitoring\": [\n        \"xacml\"\n      ]\n    }\n  ]\n}');
 /*!40000 ALTER TABLE `policy_models` ENABLE KEYS */;
 UNLOCK TABLES;
 
@@ -182,4 +182,4 @@
 /*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
 /*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;
 
--- Dump completed on 2020-02-26 12:14:24
+-- Dump completed on 2020-02-27 23:10:22
diff --git a/src/main/java/org/onap/clamp/clds/util/drawing/Painter.java b/src/main/java/org/onap/clamp/clds/util/drawing/Painter.java
index 5ec59db..509d4e4 100755
--- a/src/main/java/org/onap/clamp/clds/util/drawing/Painter.java
+++ b/src/main/java/org/onap/clamp/clds/util/drawing/Painter.java
@@ -83,13 +83,12 @@
 
         for (MicroServicePolicy ms : microServices) {
             ib.arrow().rectangle(ms.getName(),
-                    RectTypes.MICROSERVICE, ms.getPolicyModel().getPolicyAcronym()).arrow();
+                    RectTypes.MICROSERVICE, ms.getPolicyModel().getPolicyAcronym());
         }
         for (OperationalPolicy policy : policies) {
-            ib.arrow().rectangle(policy.getName(), RectTypes.POLICY, policy.getPolicyModel().getPolicyAcronym())
-                    .arrow();
+            ib.arrow().rectangle(policy.getName(), RectTypes.POLICY, policy.getPolicyModel().getPolicyAcronym());
         }
-        ib.circle("stop-circle", THICK_LINE);
+        ib.arrow().circle("stop-circle", THICK_LINE);
     }
 
     private void adjustGraphics2DProperties() {
diff --git a/src/main/java/org/onap/clamp/loop/LoopController.java b/src/main/java/org/onap/clamp/loop/LoopController.java
index 7b037da..7ee088c 100644
--- a/src/main/java/org/onap/clamp/loop/LoopController.java
+++ b/src/main/java/org/onap/clamp/loop/LoopController.java
@@ -26,10 +26,8 @@
 import com.google.gson.JsonArray;
 import com.google.gson.JsonObject;
 import com.google.gson.reflect.TypeToken;
-
 import java.lang.reflect.Type;
 import java.util.List;
-
 import org.onap.clamp.clds.util.JsonUtils;
 import org.onap.clamp.policy.microservice.MicroServicePolicy;
 import org.onap.clamp.policy.operational.OperationalPolicy;
@@ -41,11 +39,10 @@
 
     private final LoopService loopService;
     private static final Type OPERATIONAL_POLICY_TYPE = new TypeToken<List<OperationalPolicy>>() {
-    }
-            .getType();
+    }.getType();
+
     private static final Type MICROSERVICE_POLICY_TYPE = new TypeToken<List<MicroServicePolicy>>() {
-    }
-            .getType();
+    }.getType();
 
     @Autowired
     public LoopController(LoopService loopService) {
@@ -103,6 +100,27 @@
     }
 
     /**
+     * This method add an operational policy to a loop instance.
+     *
+     * @param loopName      The loop name
+     * @param policyType    The policy model type
+     * @param policyVersion The policy model  version
+     * @return The loop modified
+     */
+    public Loop addOperationalPolicy(String loopName, String policyType, String policyVersion) {
+        return loopService.addOperationalPolicy(loopName, policyType, policyVersion);
+    }
+
+    /**
+     * This method deletes the loop.
+     *
+     * @param loopName The loop Name
+     */
+    public void deleteLoop(String loopName) {
+        loopService.deleteLoop(loopName);
+    }
+
+    /**
      * Update one MicroService policy properties.
      *
      * @param loopName              The loop name
diff --git a/src/main/java/org/onap/clamp/loop/LoopService.java b/src/main/java/org/onap/clamp/loop/LoopService.java
index 34be203..0be3132 100644
--- a/src/main/java/org/onap/clamp/loop/LoopService.java
+++ b/src/main/java/org/onap/clamp/loop/LoopService.java
@@ -102,8 +102,16 @@
         loopsRepository.save(loop);
     }
 
+    /**
+     * This method add an operational policy to a loop instance.
+     *
+     * @param loopName The loop name
+     * @param policyType The policy model type
+     * @param policyVersion The policy model  version
+     * @return The loop modified
+     */
     Loop addOperationalPolicy(String loopName, String policyType, String policyVersion) {
-        Loop loop = findClosedLoopByName(loopName);
+        Loop loop = getLoop(loopName);
         PolicyModel policyModel = policyModelsService.getPolicyModel(policyType, policyVersion);
         if (policyModel == null) {
             return null;
diff --git a/src/main/java/org/onap/clamp/loop/template/PolicyModelsService.java b/src/main/java/org/onap/clamp/loop/template/PolicyModelsService.java
index 7e21cc3..aeea55d 100644
--- a/src/main/java/org/onap/clamp/loop/template/PolicyModelsService.java
+++ b/src/main/java/org/onap/clamp/loop/template/PolicyModelsService.java
@@ -44,7 +44,7 @@
 
     @Autowired
     public PolicyModelsService(PolicyModelsRepository policyModelrepo,
-                               ToscaYamlToJsonConvertor convertor) {
+        ToscaYamlToJsonConvertor convertor) {
         policyModelsRepository = policyModelrepo;
         toscaYamlToJsonConvertor = convertor;
     }
@@ -72,40 +72,37 @@
     /**
      * Creates or updates the Tosca Policy Model.
      *
-     * @param policyModelType  The policyModeltype in Tosca yaml
      * @param policyModelTosca The Policymodel object
      * @return The Policy Model created
      */
-    public PolicyModel createNewPolicyModelFromTosca(String policyModelType,
-                                                     String policyModelTosca) {
+    public PolicyModel createNewPolicyModelFromTosca(String policyModelTosca) {
         JsonObject jsonObject = toscaYamlToJsonConvertor.validateAndConvertToJson(policyModelTosca);
         String policyModelTypeFromTosca = toscaYamlToJsonConvertor.getValueFromMetadata(jsonObject,
-                ToscaSchemaConstants.METADATA_POLICY_MODEL_TYPE);
-        String policyModelTypeToUse = policyModelTypeFromTosca != null ? policyModelTypeFromTosca : policyModelType;
-        Iterable<PolicyModel> models = getAllPolicyModelsByType(policyModelTypeToUse);
+            ToscaSchemaConstants.METADATA_POLICY_MODEL_TYPE);
+        Iterable<PolicyModel> models = getAllPolicyModelsByType(policyModelTypeFromTosca);
         Collections.sort((List<PolicyModel>) models);
-        PolicyModel newPolicyModel = new PolicyModel(policyModelTypeToUse, policyModelTosca,
-                SemanticVersioning.incrementMajorVersion(
-                        ((ArrayList) models).isEmpty() ? null : ((ArrayList<PolicyModel>) models).get(0).getVersion()),
-                toscaYamlToJsonConvertor.getValueFromMetadata(jsonObject,
-                        ToscaSchemaConstants.METADATA_ACRONYM));
+        PolicyModel newPolicyModel = new PolicyModel(policyModelTypeFromTosca, policyModelTosca,
+            SemanticVersioning.incrementMajorVersion(((ArrayList) models).isEmpty() ? null
+                : ((ArrayList<PolicyModel>) models).get(0).getVersion()),
+            toscaYamlToJsonConvertor.getValueFromMetadata(jsonObject,
+                ToscaSchemaConstants.METADATA_ACRONYM));
         return saveOrUpdatePolicyModel(newPolicyModel);
     }
 
     /**
      * Update an existing Tosca Policy Model.
      *
-     * @param policyModelType    The policy Model type in Tosca yaml
+     * @param policyModelType The policy Model type in Tosca yaml
      * @param policyModelVersion The policy Version to update
-     * @param policyModelTosca   The Policy Model tosca
+     * @param policyModelTosca The Policy Model tosca
      * @return The Policy Model updated
      */
     public PolicyModel updatePolicyModelTosca(String policyModelType, String policyModelVersion,
-                                              String policyModelTosca) {
+        String policyModelTosca) {
         JsonObject jsonObject = toscaYamlToJsonConvertor.validateAndConvertToJson(policyModelTosca);
         PolicyModel thePolicyModel = getPolicyModelByType(policyModelType, policyModelVersion);
         thePolicyModel.setPolicyAcronym(toscaYamlToJsonConvertor.getValueFromMetadata(jsonObject,
-                ToscaSchemaConstants.METADATA_ACRONYM));
+            ToscaSchemaConstants.METADATA_ACRONYM));
         thePolicyModel.setPolicyModelTosca(policyModelTosca);
         return saveOrUpdatePolicyModel(thePolicyModel);
     }
@@ -133,13 +130,13 @@
     /**
      * Retrieves the Tosca model Yaml string.
      *
-     * @param type    The Policy Model Type
+     * @param type The Policy Model Type
      * @param version The policy model version
      * @return The Tosca model Yaml string
      */
     public String getPolicyModelTosca(String type, String version) {
-        return policyModelsRepository.findById(new PolicyModelId(type, version)).orElse(new PolicyModel())
-                .getPolicyModelTosca();
+        return policyModelsRepository.findById(new PolicyModelId(type, version))
+            .orElse(new PolicyModel()).getPolicyModelTosca();
     }
 
     /**
@@ -149,8 +146,8 @@
      */
     @Transactional(propagation = Propagation.REQUIRES_NEW)
     public void createPolicyInDbIfNeeded(PolicyModel policyModel) {
-        if (!policyModelsRepository
-                .existsById(new PolicyModelId(policyModel.getPolicyModelType(), policyModel.getVersion()))) {
+        if (!policyModelsRepository.existsById(
+            new PolicyModelId(policyModel.getPolicyModelType(), policyModel.getVersion()))) {
             policyModelsRepository.save(policyModel);
         }
     }
@@ -165,8 +162,8 @@
         for (PolicyModel policyModel : policyModelList) {
             JsonArray supportedPdpGroups = new JsonArray();
             for (PdpGroup pdpGroup : pdpGroupList) {
-                JsonObject supportedPdpGroup = pdpGroup.getSupportedSubgroups(policyModel.getPolicyModelType(),
-                        policyModel.getVersion());
+                JsonObject supportedPdpGroup = pdpGroup.getSupportedSubgroups(
+                    policyModel.getPolicyModelType(), policyModel.getVersion());
                 if (supportedPdpGroup != null) {
                     supportedPdpGroups.add(supportedPdpGroup);
                 }
diff --git a/src/main/java/org/onap/clamp/policy/operational/LegacyOperationalPolicy.java b/src/main/java/org/onap/clamp/policy/operational/LegacyOperationalPolicy.java
index 725bfe8..ff7777f 100644
--- a/src/main/java/org/onap/clamp/policy/operational/LegacyOperationalPolicy.java
+++ b/src/main/java/org/onap/clamp/policy/operational/LegacyOperationalPolicy.java
@@ -173,7 +173,7 @@
      * @param loop               The parent loop object
      */
     public static void preloadConfiguration(JsonObject configurationsJson, Loop loop) {
-        if (configurationsJson.entrySet().isEmpty()) {
+        if (configurationsJson != null && configurationsJson.entrySet().isEmpty()) {
             JsonObject controlLoopName = new JsonObject();
             controlLoopName.addProperty("controlLoopName",
                     loop != null ? loop.getName() : "Empty (NO loop loaded yet)");
diff --git a/src/main/java/org/onap/clamp/policy/operational/OperationalPolicy.java b/src/main/java/org/onap/clamp/policy/operational/OperationalPolicy.java
index 52b8772..1c78405 100644
--- a/src/main/java/org/onap/clamp/policy/operational/OperationalPolicy.java
+++ b/src/main/java/org/onap/clamp/policy/operational/OperationalPolicy.java
@@ -32,7 +32,6 @@
 import com.google.gson.JsonObject;
 import com.google.gson.JsonSyntaxException;
 import com.google.gson.annotations.Expose;
-
 import java.io.IOException;
 import java.io.Serializable;
 import java.io.UnsupportedEncodingException;
@@ -40,7 +39,6 @@
 import java.nio.charset.StandardCharsets;
 import java.util.HashMap;
 import java.util.Map;
-
 import javax.persistence.Column;
 import javax.persistence.Entity;
 import javax.persistence.FetchType;
@@ -50,7 +48,6 @@
 import javax.persistence.ManyToOne;
 import javax.persistence.Table;
 import javax.persistence.Transient;
-
 import org.hibernate.annotations.TypeDef;
 import org.hibernate.annotations.TypeDefs;
 import org.onap.clamp.dao.model.jsontype.StringJsonUserType;
@@ -94,12 +91,13 @@
 
     /**
      * The constructor.
-     *  @param name               The name of the operational policy
+     *
+     * @param name               The name of the operational policy
      * @param loop               The loop that uses this operational policy
      * @param configurationsJson The operational policy property in the format of
- *                           json
+     *                           json
      * @param policyModel        The policy model associated if any, can be null
-     * @param loopElementModel The loop element from which this instance is supposed to be created
+     * @param loopElementModel   The loop element from which this instance is supposed to be created
      */
     public OperationalPolicy(String name, Loop loop, JsonObject configurationsJson, PolicyModel policyModel,
                              LoopElementModel loopElementModel) {
@@ -108,7 +106,9 @@
         this.setPolicyModel(policyModel);
         this.setConfigurationsJson(configurationsJson);
         this.setLoopElementModel(loopElementModel);
-        LegacyOperationalPolicy.preloadConfiguration(configurationsJson, loop);
+        if (policyModel != null && policyModel.getPolicyModelType().contains("legacy")) {
+            LegacyOperationalPolicy.preloadConfiguration(configurationsJson, loop);
+        }
         try {
             this.setJsonRepresentation(
                     OperationalPolicyRepresentationBuilder.generateOperationalPolicySchema(loop.getModelService()));
diff --git a/src/main/java/org/onap/clamp/tosca/Dictionary.java b/src/main/java/org/onap/clamp/tosca/Dictionary.java
index 44b5b6f..cf514c4 100644
--- a/src/main/java/org/onap/clamp/tosca/Dictionary.java
+++ b/src/main/java/org/onap/clamp/tosca/Dictionary.java
@@ -65,9 +65,7 @@
     private String subDictionaryType;
 
     @Expose
-    @ManyToMany(
-        fetch = FetchType.EAGER,
-        cascade = {CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH})
+    @ManyToMany(fetch = FetchType.EAGER, cascade = {CascadeType.ALL})
     @JoinTable(
         name = "dictionary_to_dictionaryelements",
         joinColumns = @JoinColumn(name = "dictionary_name", referencedColumnName = "name"),
@@ -150,6 +148,15 @@
     }
 
     /**
+     * Method to set dictionaryElements.
+     *
+     * @param dictionaryElements The dictionary elements set
+     */
+    public void setDictionaryElements(Set<DictionaryElement> dictionaryElements) {
+        this.dictionaryElements = dictionaryElements;
+    }
+
+    /**
      * Method to delete a dictionaryElement from the list.
      *
      * @param dictionaryElement The dictionary element
diff --git a/src/main/java/org/onap/clamp/tosca/DictionaryService.java b/src/main/java/org/onap/clamp/tosca/DictionaryService.java
index 5b24def..98e3516 100644
--- a/src/main/java/org/onap/clamp/tosca/DictionaryService.java
+++ b/src/main/java/org/onap/clamp/tosca/DictionaryService.java
@@ -26,6 +26,7 @@
 import com.google.common.collect.Sets;
 import java.util.List;
 import java.util.Set;
+import java.util.stream.Collectors;
 import javax.persistence.EntityNotFoundException;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
@@ -63,20 +64,19 @@
 
         Set<DictionaryElement> newDictionaryElements = dictionary.getDictionaryElements();
 
-        for (DictionaryElement dictionaryElement : newDictionaryElements) {
-            if (dict.getDictionaryElements().contains(dictionaryElement)) {
-                // Update the Dictionary Element
-                getAndUpdateDictionaryElement(dict, dictionaryElement);
-            } else {
-                // Create the Dictionary Element
-                dict.addDictionaryElements(getAndUpdateDictionaryElement(dict, dictionaryElement));
-                dictionaryRepository.save(dict);
-            }
-        }
+        if (newDictionaryElements != null && !newDictionaryElements.isEmpty()) {
+            Set<DictionaryElement> updatedDictionaryElements = newDictionaryElements.stream()
+                .map(dictionaryElement -> getAndUpdateDictionaryElement(dict, dictionaryElement))
+                .collect(Collectors.toSet());
 
-        // Fetch again to get Dictionary with most recent updates.
-        return dictionaryRepository.findById(dictionaryName).orElseThrow(
-            () -> new EntityNotFoundException("Couldn't find Dictionary named: " + dictionaryName));
+            dict.getDictionaryElements().forEach(dictElement -> {
+                if (!updatedDictionaryElements.contains(dictElement)) {
+                    updatedDictionaryElements.add(dictElement);
+                }
+            });
+            dict.setDictionaryElements(updatedDictionaryElements);
+        }
+        return dictionaryRepository.save(dict);
 
     }
 
diff --git a/src/main/resources/META-INF/resources/swagger.html b/src/main/resources/META-INF/resources/swagger.html
index 74322f3..23844cb 100644
--- a/src/main/resources/META-INF/resources/swagger.html
+++ b/src/main/resources/META-INF/resources/swagger.html
@@ -444,25 +444,25 @@
 </li>
 <li><a href="#_paths">2. Paths</a>
 <ul class="sectlevel2">
-<li><a href="#_route92">2.1. GET /v1/healthcheck</a>
+<li><a href="#_route30">2.1. GET /v1/healthcheck</a>
 <ul class="sectlevel3">
 <li><a href="#_responses">2.1.1. Responses</a></li>
 <li><a href="#_produces">2.1.2. Produces</a></li>
 </ul>
 </li>
-<li><a href="#_route93">2.2. GET /v1/user/getUser</a>
+<li><a href="#_route31">2.2. GET /v1/user/getUser</a>
 <ul class="sectlevel3">
 <li><a href="#_responses_2">2.2.1. Responses</a></li>
 <li><a href="#_produces_2">2.2.2. Produces</a></li>
 </ul>
 </li>
-<li><a href="#_route80">2.3. GET /v2/dictionary</a>
+<li><a href="#_route18">2.3. GET /v2/dictionary</a>
 <ul class="sectlevel3">
 <li><a href="#_responses_3">2.3.1. Responses</a></li>
 <li><a href="#_produces_3">2.3.2. Produces</a></li>
 </ul>
 </li>
-<li><a href="#_route82">2.4. PUT /v2/dictionary</a>
+<li><a href="#_route20">2.4. PUT /v2/dictionary</a>
 <ul class="sectlevel3">
 <li><a href="#_parameters">2.4.1. Parameters</a></li>
 <li><a href="#_responses_4">2.4.2. Responses</a></li>
@@ -491,7 +491,7 @@
 <li><a href="#_produces_7">2.7.4. Produces</a></li>
 </ul>
 </li>
-<li><a href="#_route84">2.8. DELETE /v2/dictionary/{name}</a>
+<li><a href="#_route22">2.8. DELETE /v2/dictionary/{name}</a>
 <ul class="sectlevel3">
 <li><a href="#_parameters_4">2.8.1. Parameters</a></li>
 <li><a href="#_responses_8">2.8.2. Responses</a></li>
@@ -505,75 +505,75 @@
 <li><a href="#_produces_9">2.9.3. Produces</a></li>
 </ul>
 </li>
-<li><a href="#_route76">2.10. PUT /v2/loop/delete/{loopName}</a>
+<li><a href="#_route14">2.10. PUT /v2/loop/delete/{loopName}</a>
 <ul class="sectlevel3">
 <li><a href="#_parameters_6">2.10.1. Parameters</a></li>
 <li><a href="#_responses_10">2.10.2. Responses</a></li>
 </ul>
 </li>
-<li><a href="#_route70">2.11. PUT /v2/loop/deploy/{loopName}</a>
+<li><a href="#_route8">2.11. PUT /v2/loop/deploy/{loopName}</a>
 <ul class="sectlevel3">
 <li><a href="#_parameters_7">2.11.1. Parameters</a></li>
 <li><a href="#_responses_11">2.11.2. Responses</a></li>
 <li><a href="#_produces_10">2.11.3. Produces</a></li>
 </ul>
 </li>
-<li><a href="#_route64">2.12. GET /v2/loop/getAllNames</a>
+<li><a href="#_route2">2.12. GET /v2/loop/getAllNames</a>
 <ul class="sectlevel3">
 <li><a href="#_responses_12">2.12.1. Responses</a></li>
 <li><a href="#_produces_11">2.12.2. Produces</a></li>
 </ul>
 </li>
-<li><a href="#_route77">2.13. GET /v2/loop/getstatus/{loopName}</a>
+<li><a href="#_route15">2.13. GET /v2/loop/getstatus/{loopName}</a>
 <ul class="sectlevel3">
 <li><a href="#_parameters_8">2.13.1. Parameters</a></li>
 <li><a href="#_responses_13">2.13.2. Responses</a></li>
 <li><a href="#_produces_12">2.13.3. Produces</a></li>
 </ul>
 </li>
-<li><a href="#_route71">2.14. PUT /v2/loop/refreshOpPolicyJsonSchema/{loopName}</a>
+<li><a href="#_route9">2.14. PUT /v2/loop/refreshOpPolicyJsonSchema/{loopName}</a>
 <ul class="sectlevel3">
 <li><a href="#_parameters_9">2.14.1. Parameters</a></li>
 <li><a href="#_responses_14">2.14.2. Responses</a></li>
 <li><a href="#_produces_13">2.14.3. Produces</a></li>
 </ul>
 </li>
-<li><a href="#_route74">2.15. PUT /v2/loop/restart/{loopName}</a>
+<li><a href="#_route12">2.15. PUT /v2/loop/restart/{loopName}</a>
 <ul class="sectlevel3">
 <li><a href="#_parameters_10">2.15.1. Parameters</a></li>
 <li><a href="#_responses_15">2.15.2. Responses</a></li>
 <li><a href="#_produces_14">2.15.3. Produces</a></li>
 </ul>
 </li>
-<li><a href="#_route73">2.16. PUT /v2/loop/stop/{loopName}</a>
+<li><a href="#_route11">2.16. PUT /v2/loop/stop/{loopName}</a>
 <ul class="sectlevel3">
 <li><a href="#_parameters_11">2.16.1. Parameters</a></li>
 <li><a href="#_responses_16">2.16.2. Responses</a></li>
 <li><a href="#_produces_15">2.16.3. Produces</a></li>
 </ul>
 </li>
-<li><a href="#_route75">2.17. PUT /v2/loop/submit/{loopName}</a>
+<li><a href="#_route13">2.17. PUT /v2/loop/submit/{loopName}</a>
 <ul class="sectlevel3">
 <li><a href="#_parameters_12">2.17.1. Parameters</a></li>
 <li><a href="#_responses_17">2.17.2. Responses</a></li>
 <li><a href="#_produces_16">2.17.3. Produces</a></li>
 </ul>
 </li>
-<li><a href="#_route66">2.18. GET /v2/loop/svgRepresentation/{loopName}</a>
+<li><a href="#_route4">2.18. GET /v2/loop/svgRepresentation/{loopName}</a>
 <ul class="sectlevel3">
 <li><a href="#_parameters_13">2.18.1. Parameters</a></li>
 <li><a href="#_responses_18">2.18.2. Responses</a></li>
 <li><a href="#_produces_17">2.18.3. Produces</a></li>
 </ul>
 </li>
-<li><a href="#_route72">2.19. PUT /v2/loop/undeploy/{loopName}</a>
+<li><a href="#_route10">2.19. PUT /v2/loop/undeploy/{loopName}</a>
 <ul class="sectlevel3">
 <li><a href="#_parameters_14">2.19.1. Parameters</a></li>
 <li><a href="#_responses_19">2.19.2. Responses</a></li>
 <li><a href="#_produces_18">2.19.3. Produces</a></li>
 </ul>
 </li>
-<li><a href="#_route67">2.20. POST /v2/loop/updateGlobalProperties/{loopName}</a>
+<li><a href="#_route5">2.20. POST /v2/loop/updateGlobalProperties/{loopName}</a>
 <ul class="sectlevel3">
 <li><a href="#_parameters_15">2.20.1. Parameters</a></li>
 <li><a href="#_responses_20">2.20.2. Responses</a></li>
@@ -581,7 +581,7 @@
 <li><a href="#_produces_19">2.20.4. Produces</a></li>
 </ul>
 </li>
-<li><a href="#_route69">2.21. POST /v2/loop/updateMicroservicePolicy/{loopName}</a>
+<li><a href="#_route7">2.21. POST /v2/loop/updateMicroservicePolicy/{loopName}</a>
 <ul class="sectlevel3">
 <li><a href="#_parameters_16">2.21.1. Parameters</a></li>
 <li><a href="#_responses_21">2.21.2. Responses</a></li>
@@ -589,7 +589,7 @@
 <li><a href="#_produces_20">2.21.4. Produces</a></li>
 </ul>
 </li>
-<li><a href="#_route68">2.22. POST /v2/loop/updateOperationalPolicies/{loopName}</a>
+<li><a href="#_route6">2.22. POST /v2/loop/updateOperationalPolicies/{loopName}</a>
 <ul class="sectlevel3">
 <li><a href="#_parameters_17">2.22.1. Parameters</a></li>
 <li><a href="#_responses_22">2.22.2. Responses</a></li>
@@ -597,14 +597,14 @@
 <li><a href="#_produces_21">2.22.4. Produces</a></li>
 </ul>
 </li>
-<li><a href="#_route65">2.23. GET /v2/loop/{loopName}</a>
+<li><a href="#_route3">2.23. GET /v2/loop/{loopName}</a>
 <ul class="sectlevel3">
 <li><a href="#_parameters_18">2.23.1. Parameters</a></li>
 <li><a href="#_responses_23">2.23.2. Responses</a></li>
 <li><a href="#_produces_22">2.23.3. Produces</a></li>
 </ul>
 </li>
-<li><a href="#_route87">2.24. GET /v2/policyToscaModels</a>
+<li><a href="#_route25">2.24. GET /v2/policyToscaModels</a>
 <ul class="sectlevel3">
 <li><a href="#_responses_24">2.24.1. Responses</a></li>
 <li><a href="#_produces_23">2.24.2. Produces</a></li>
@@ -624,7 +624,7 @@
 <li><a href="#_produces_25">2.26.3. Produces</a></li>
 </ul>
 </li>
-<li><a href="#_route88">2.27. PUT /v2/policyToscaModels/{policyModelType}</a>
+<li><a href="#_route26">2.27. PUT /v2/policyToscaModels/{policyModelType}</a>
 <ul class="sectlevel3">
 <li><a href="#_parameters_21">2.27.1. Parameters</a></li>
 <li><a href="#_responses_27">2.27.2. Responses</a></li>
@@ -632,7 +632,7 @@
 <li><a href="#_produces_26">2.27.4. Produces</a></li>
 </ul>
 </li>
-<li><a href="#_route91">2.28. GET /v2/templates</a>
+<li><a href="#_route29">2.28. GET /v2/templates</a>
 <ul class="sectlevel3">
 <li><a href="#_responses_28">2.28.1. Responses</a></li>
 <li><a href="#_produces_27">2.28.2. Produces</a></li>
@@ -692,7 +692,7 @@
 <div class="sect2">
 <h3 id="_uri_scheme"><a class="anchor" href="#_uri_scheme"></a><a class="link" href="#_uri_scheme">1.2. URI scheme</a></h3>
 <div class="paragraph">
-<p><em>Host</em> : localhost:33631<br>
+<p><em>Host</em> : localhost:37295<br>
 <em>BasePath</em> : /restservices/clds/<br>
 <em>Schemes</em> : HTTP</p>
 </div>
@@ -703,7 +703,7 @@
 <h2 id="_paths"><a class="anchor" href="#_paths"></a><a class="link" href="#_paths">2. Paths</a></h2>
 <div class="sectionbody">
 <div class="sect2">
-<h3 id="_route92"><a class="anchor" href="#_route92"></a><a class="link" href="#_route92">2.1. GET /v1/healthcheck</a></h3>
+<h3 id="_route30"><a class="anchor" href="#_route30"></a><a class="link" href="#_route30">2.1. GET /v1/healthcheck</a></h3>
 <div class="sect3">
 <h4 id="_responses"><a class="anchor" href="#_responses"></a><a class="link" href="#_responses">2.1.1. Responses</a></h4>
 <table class="tableblock frame-all grid-all stretch">
@@ -740,7 +740,7 @@
 </div>
 </div>
 <div class="sect2">
-<h3 id="_route93"><a class="anchor" href="#_route93"></a><a class="link" href="#_route93">2.2. GET /v1/user/getUser</a></h3>
+<h3 id="_route31"><a class="anchor" href="#_route31"></a><a class="link" href="#_route31">2.2. GET /v1/user/getUser</a></h3>
 <div class="sect3">
 <h4 id="_responses_2"><a class="anchor" href="#_responses_2"></a><a class="link" href="#_responses_2">2.2.1. Responses</a></h4>
 <table class="tableblock frame-all grid-all stretch">
@@ -774,7 +774,7 @@
 </div>
 </div>
 <div class="sect2">
-<h3 id="_route80"><a class="anchor" href="#_route80"></a><a class="link" href="#_route80">2.3. GET /v2/dictionary</a></h3>
+<h3 id="_route18"><a class="anchor" href="#_route18"></a><a class="link" href="#_route18">2.3. GET /v2/dictionary</a></h3>
 <div class="sect3">
 <h4 id="_responses_3"><a class="anchor" href="#_responses_3"></a><a class="link" href="#_responses_3">2.3.1. Responses</a></h4>
 <table class="tableblock frame-all grid-all stretch">
@@ -811,7 +811,7 @@
 </div>
 </div>
 <div class="sect2">
-<h3 id="_route82"><a class="anchor" href="#_route82"></a><a class="link" href="#_route82">2.4. PUT /v2/dictionary</a></h3>
+<h3 id="_route20"><a class="anchor" href="#_route20"></a><a class="link" href="#_route20">2.4. PUT /v2/dictionary</a></h3>
 <div class="sect3">
 <h4 id="_parameters"><a class="anchor" href="#_parameters"></a><a class="link" href="#_parameters">2.4.1. Parameters</a></h4>
 <table class="tableblock frame-all grid-all stretch">
@@ -1060,7 +1060,7 @@
 </div>
 </div>
 <div class="sect2">
-<h3 id="_route84"><a class="anchor" href="#_route84"></a><a class="link" href="#_route84">2.8. DELETE /v2/dictionary/{name}</a></h3>
+<h3 id="_route22"><a class="anchor" href="#_route22"></a><a class="link" href="#_route22">2.8. DELETE /v2/dictionary/{name}</a></h3>
 <div class="sect3">
 <h4 id="_parameters_4"><a class="anchor" href="#_parameters_4"></a><a class="link" href="#_parameters_4">2.8.1. Parameters</a></h4>
 <table class="tableblock frame-all grid-all stretch">
@@ -1184,7 +1184,7 @@
 </div>
 </div>
 <div class="sect2">
-<h3 id="_route76"><a class="anchor" href="#_route76"></a><a class="link" href="#_route76">2.10. PUT /v2/loop/delete/{loopName}</a></h3>
+<h3 id="_route14"><a class="anchor" href="#_route14"></a><a class="link" href="#_route14">2.10. PUT /v2/loop/delete/{loopName}</a></h3>
 <div class="sect3">
 <h4 id="_parameters_6"><a class="anchor" href="#_parameters_6"></a><a class="link" href="#_parameters_6">2.10.1. Parameters</a></h4>
 <table class="tableblock frame-all grid-all stretch">
@@ -1233,7 +1233,7 @@
 </div>
 </div>
 <div class="sect2">
-<h3 id="_route70"><a class="anchor" href="#_route70"></a><a class="link" href="#_route70">2.11. PUT /v2/loop/deploy/{loopName}</a></h3>
+<h3 id="_route8"><a class="anchor" href="#_route8"></a><a class="link" href="#_route8">2.11. PUT /v2/loop/deploy/{loopName}</a></h3>
 <div class="sect3">
 <h4 id="_parameters_7"><a class="anchor" href="#_parameters_7"></a><a class="link" href="#_parameters_7">2.11.1. Parameters</a></h4>
 <table class="tableblock frame-all grid-all stretch">
@@ -1295,7 +1295,7 @@
 </div>
 </div>
 <div class="sect2">
-<h3 id="_route64"><a class="anchor" href="#_route64"></a><a class="link" href="#_route64">2.12. GET /v2/loop/getAllNames</a></h3>
+<h3 id="_route2"><a class="anchor" href="#_route2"></a><a class="link" href="#_route2">2.12. GET /v2/loop/getAllNames</a></h3>
 <div class="sect3">
 <h4 id="_responses_12"><a class="anchor" href="#_responses_12"></a><a class="link" href="#_responses_12">2.12.1. Responses</a></h4>
 <table class="tableblock frame-all grid-all stretch">
@@ -1332,7 +1332,7 @@
 </div>
 </div>
 <div class="sect2">
-<h3 id="_route77"><a class="anchor" href="#_route77"></a><a class="link" href="#_route77">2.13. GET /v2/loop/getstatus/{loopName}</a></h3>
+<h3 id="_route15"><a class="anchor" href="#_route15"></a><a class="link" href="#_route15">2.13. GET /v2/loop/getstatus/{loopName}</a></h3>
 <div class="sect3">
 <h4 id="_parameters_8"><a class="anchor" href="#_parameters_8"></a><a class="link" href="#_parameters_8">2.13.1. Parameters</a></h4>
 <table class="tableblock frame-all grid-all stretch">
@@ -1394,7 +1394,7 @@
 </div>
 </div>
 <div class="sect2">
-<h3 id="_route71"><a class="anchor" href="#_route71"></a><a class="link" href="#_route71">2.14. PUT /v2/loop/refreshOpPolicyJsonSchema/{loopName}</a></h3>
+<h3 id="_route9"><a class="anchor" href="#_route9"></a><a class="link" href="#_route9">2.14. PUT /v2/loop/refreshOpPolicyJsonSchema/{loopName}</a></h3>
 <div class="sect3">
 <h4 id="_parameters_9"><a class="anchor" href="#_parameters_9"></a><a class="link" href="#_parameters_9">2.14.1. Parameters</a></h4>
 <table class="tableblock frame-all grid-all stretch">
@@ -1456,7 +1456,7 @@
 </div>
 </div>
 <div class="sect2">
-<h3 id="_route74"><a class="anchor" href="#_route74"></a><a class="link" href="#_route74">2.15. PUT /v2/loop/restart/{loopName}</a></h3>
+<h3 id="_route12"><a class="anchor" href="#_route12"></a><a class="link" href="#_route12">2.15. PUT /v2/loop/restart/{loopName}</a></h3>
 <div class="sect3">
 <h4 id="_parameters_10"><a class="anchor" href="#_parameters_10"></a><a class="link" href="#_parameters_10">2.15.1. Parameters</a></h4>
 <table class="tableblock frame-all grid-all stretch">
@@ -1518,7 +1518,7 @@
 </div>
 </div>
 <div class="sect2">
-<h3 id="_route73"><a class="anchor" href="#_route73"></a><a class="link" href="#_route73">2.16. PUT /v2/loop/stop/{loopName}</a></h3>
+<h3 id="_route11"><a class="anchor" href="#_route11"></a><a class="link" href="#_route11">2.16. PUT /v2/loop/stop/{loopName}</a></h3>
 <div class="sect3">
 <h4 id="_parameters_11"><a class="anchor" href="#_parameters_11"></a><a class="link" href="#_parameters_11">2.16.1. Parameters</a></h4>
 <table class="tableblock frame-all grid-all stretch">
@@ -1580,7 +1580,7 @@
 </div>
 </div>
 <div class="sect2">
-<h3 id="_route75"><a class="anchor" href="#_route75"></a><a class="link" href="#_route75">2.17. PUT /v2/loop/submit/{loopName}</a></h3>
+<h3 id="_route13"><a class="anchor" href="#_route13"></a><a class="link" href="#_route13">2.17. PUT /v2/loop/submit/{loopName}</a></h3>
 <div class="sect3">
 <h4 id="_parameters_12"><a class="anchor" href="#_parameters_12"></a><a class="link" href="#_parameters_12">2.17.1. Parameters</a></h4>
 <table class="tableblock frame-all grid-all stretch">
@@ -1642,7 +1642,7 @@
 </div>
 </div>
 <div class="sect2">
-<h3 id="_route66"><a class="anchor" href="#_route66"></a><a class="link" href="#_route66">2.18. GET /v2/loop/svgRepresentation/{loopName}</a></h3>
+<h3 id="_route4"><a class="anchor" href="#_route4"></a><a class="link" href="#_route4">2.18. GET /v2/loop/svgRepresentation/{loopName}</a></h3>
 <div class="sect3">
 <h4 id="_parameters_13"><a class="anchor" href="#_parameters_13"></a><a class="link" href="#_parameters_13">2.18.1. Parameters</a></h4>
 <table class="tableblock frame-all grid-all stretch">
@@ -1704,7 +1704,7 @@
 </div>
 </div>
 <div class="sect2">
-<h3 id="_route72"><a class="anchor" href="#_route72"></a><a class="link" href="#_route72">2.19. PUT /v2/loop/undeploy/{loopName}</a></h3>
+<h3 id="_route10"><a class="anchor" href="#_route10"></a><a class="link" href="#_route10">2.19. PUT /v2/loop/undeploy/{loopName}</a></h3>
 <div class="sect3">
 <h4 id="_parameters_14"><a class="anchor" href="#_parameters_14"></a><a class="link" href="#_parameters_14">2.19.1. Parameters</a></h4>
 <table class="tableblock frame-all grid-all stretch">
@@ -1766,7 +1766,7 @@
 </div>
 </div>
 <div class="sect2">
-<h3 id="_route67"><a class="anchor" href="#_route67"></a><a class="link" href="#_route67">2.20. POST /v2/loop/updateGlobalProperties/{loopName}</a></h3>
+<h3 id="_route5"><a class="anchor" href="#_route5"></a><a class="link" href="#_route5">2.20. POST /v2/loop/updateGlobalProperties/{loopName}</a></h3>
 <div class="sect3">
 <h4 id="_parameters_15"><a class="anchor" href="#_parameters_15"></a><a class="link" href="#_parameters_15">2.20.1. Parameters</a></h4>
 <table class="tableblock frame-all grid-all stretch">
@@ -1844,7 +1844,7 @@
 </div>
 </div>
 <div class="sect2">
-<h3 id="_route69"><a class="anchor" href="#_route69"></a><a class="link" href="#_route69">2.21. POST /v2/loop/updateMicroservicePolicy/{loopName}</a></h3>
+<h3 id="_route7"><a class="anchor" href="#_route7"></a><a class="link" href="#_route7">2.21. POST /v2/loop/updateMicroservicePolicy/{loopName}</a></h3>
 <div class="sect3">
 <h4 id="_parameters_16"><a class="anchor" href="#_parameters_16"></a><a class="link" href="#_parameters_16">2.21.1. Parameters</a></h4>
 <table class="tableblock frame-all grid-all stretch">
@@ -1922,7 +1922,7 @@
 </div>
 </div>
 <div class="sect2">
-<h3 id="_route68"><a class="anchor" href="#_route68"></a><a class="link" href="#_route68">2.22. POST /v2/loop/updateOperationalPolicies/{loopName}</a></h3>
+<h3 id="_route6"><a class="anchor" href="#_route6"></a><a class="link" href="#_route6">2.22. POST /v2/loop/updateOperationalPolicies/{loopName}</a></h3>
 <div class="sect3">
 <h4 id="_parameters_17"><a class="anchor" href="#_parameters_17"></a><a class="link" href="#_parameters_17">2.22.1. Parameters</a></h4>
 <table class="tableblock frame-all grid-all stretch">
@@ -2000,7 +2000,7 @@
 </div>
 </div>
 <div class="sect2">
-<h3 id="_route65"><a class="anchor" href="#_route65"></a><a class="link" href="#_route65">2.23. GET /v2/loop/{loopName}</a></h3>
+<h3 id="_route3"><a class="anchor" href="#_route3"></a><a class="link" href="#_route3">2.23. GET /v2/loop/{loopName}</a></h3>
 <div class="sect3">
 <h4 id="_parameters_18"><a class="anchor" href="#_parameters_18"></a><a class="link" href="#_parameters_18">2.23.1. Parameters</a></h4>
 <table class="tableblock frame-all grid-all stretch">
@@ -2062,7 +2062,7 @@
 </div>
 </div>
 <div class="sect2">
-<h3 id="_route87"><a class="anchor" href="#_route87"></a><a class="link" href="#_route87">2.24. GET /v2/policyToscaModels</a></h3>
+<h3 id="_route25"><a class="anchor" href="#_route25"></a><a class="link" href="#_route25">2.24. GET /v2/policyToscaModels</a></h3>
 <div class="sect3">
 <h4 id="_responses_24"><a class="anchor" href="#_responses_24"></a><a class="link" href="#_responses_24">2.24.1. Responses</a></h4>
 <table class="tableblock frame-all grid-all stretch">
@@ -2223,7 +2223,7 @@
 </div>
 </div>
 <div class="sect2">
-<h3 id="_route88"><a class="anchor" href="#_route88"></a><a class="link" href="#_route88">2.27. PUT /v2/policyToscaModels/{policyModelType}</a></h3>
+<h3 id="_route26"><a class="anchor" href="#_route26"></a><a class="link" href="#_route26">2.27. PUT /v2/policyToscaModels/{policyModelType}</a></h3>
 <div class="sect3">
 <h4 id="_parameters_21"><a class="anchor" href="#_parameters_21"></a><a class="link" href="#_parameters_21">2.27.1. Parameters</a></h4>
 <table class="tableblock frame-all grid-all stretch">
@@ -2301,7 +2301,7 @@
 </div>
 </div>
 <div class="sect2">
-<h3 id="_route91"><a class="anchor" href="#_route91"></a><a class="link" href="#_route91">2.28. GET /v2/templates</a></h3>
+<h3 id="_route29"><a class="anchor" href="#_route29"></a><a class="link" href="#_route29">2.28. GET /v2/templates</a></h3>
 <div class="sect3">
 <h4 id="_responses_28"><a class="anchor" href="#_responses_28"></a><a class="link" href="#_responses_28">2.28.1. Responses</a></h4>
 <table class="tableblock frame-all grid-all stretch">
@@ -3544,6 +3544,11 @@
 <td class="tableblock halign-left valign-middle"><p class="tableblock">string</p></td>
 </tr>
 <tr>
+<td class="tableblock halign-left valign-middle"><p class="tableblock"><strong>pdpSubGroup</strong><br>
+<em>optional</em></p></td>
+<td class="tableblock halign-left valign-middle"><p class="tableblock">string</p></td>
+</tr>
+<tr>
 <td class="tableblock halign-left valign-middle"><p class="tableblock"><strong>policyModel</strong><br>
 <em>optional</em></p></td>
 <td class="tableblock halign-left valign-middle"><p class="tableblock"><a href="#_policymodel">PolicyModel</a></p></td>
@@ -3632,6 +3637,11 @@
 <td class="tableblock halign-left valign-middle"><p class="tableblock">string</p></td>
 </tr>
 <tr>
+<td class="tableblock halign-left valign-middle"><p class="tableblock"><strong>pdpSubGroup</strong><br>
+<em>optional</em></p></td>
+<td class="tableblock halign-left valign-middle"><p class="tableblock">string</p></td>
+</tr>
+<tr>
 <td class="tableblock halign-left valign-middle"><p class="tableblock"><strong>policyModel</strong><br>
 <em>optional</em></p></td>
 <td class="tableblock halign-left valign-middle"><p class="tableblock"><a href="#_policymodel">PolicyModel</a></p></td>
@@ -3689,6 +3699,11 @@
 <td class="tableblock halign-left valign-middle"><p class="tableblock">string</p></td>
 </tr>
 <tr>
+<td class="tableblock halign-left valign-middle"><p class="tableblock"><strong>policyPdpGroup</strong><br>
+<em>optional</em></p></td>
+<td class="tableblock halign-left valign-middle"><p class="tableblock"><a href="#_jsonobject">JsonObject</a></p></td>
+</tr>
+<tr>
 <td class="tableblock halign-left valign-middle"><p class="tableblock"><strong>updatedBy</strong><br>
 <em>optional</em></p></td>
 <td class="tableblock halign-left valign-middle"><p class="tableblock">string</p></td>
diff --git a/src/main/resources/clds/camel/rest/clamp-api-v2.xml b/src/main/resources/clds/camel/rest/clamp-api-v2.xml
index 280b808..3ed272e 100644
--- a/src/main/resources/clds/camel/rest/clamp-api-v2.xml
+++ b/src/main/resources/clds/camel/rest/clamp-api-v2.xml
@@ -502,7 +502,7 @@
 						</split>
 					</split>
 					<to
-						uri="bean:org.onap.clamp.loop.log.LoopService?method=deleteLoop(${header.loopName})" />
+						uri="bean:org.onap.clamp.loop.log.LoopController?method=deleteLoop(${header.loopName})" />
 					<log loggingLevel="INFO"
 						message="DELETE request successfully executed for loop: ${header.loopName}" />
 					<to
@@ -569,29 +569,21 @@
 			</route>
 		</get>
 
-		<put uri="/v2/loop/addOperationaPolicy/{loopName}/policyModel/{policyType}/{policyVersion}"
-			 outType="org.onap.clamp.loop.Loop" produces="application/json">
+		<put uri="/v2/loop/addOperationaPolicy/{loopName}/policyModel/{policyType}/{policyVersion}" outType="org.onap.clamp.loop.Loop" produces="application/json">
 			<route>
-				<removeHeaders pattern="*" excludePattern="loopName" />
+				<removeHeaders pattern="*" excludePattern="loopName|policyType|policyVersion" />
 				<doTry>
-					<log loggingLevel="INFO"
-						 message="ADD OperationalPolicy request for loop: ${header.loopName}" />
 					<to
-							uri="bean:org.onap.clamp.flow.log.FlowLogOperation?method=startLog(*, 'ADD OperationalPolicy request')" />
+							uri="bean:org.onap.clamp.flow.log.FlowLogOperation?method=startLog(*, 'Add operational Policy')" />
 					<to
-							uri="bean:org.onap.clamp.authorization.AuthorizationController?method=authorize(*,'cl','','write')" />
+							uri="bean:org.onap.clamp.authorization.AuthorizationController?method=authorize(*,'cl','','update')" />
 					<to uri="direct:load-loop" />
 					<to
-							uri="bean:org.onap.clamp.loop.log.LoopLogService?method=addLog('ADD OperationalPolicy request','INFO',${exchangeProperty[loopObject]})" />
-					<doTry>
-						<to
-								uri="bean:org.onap.clamp.loop.LoopService?method=addOperationalPolicy(${loopName},${policyType},${policyVersion})" />
-
-						<to
-								uri="bean:org.onap.clamp.loop.log.LoopLogService?method=addLog('ADD OperationalPolicy request successfully executed','INFO',${exchangeProperty[loopObject]})" />
-						<to
-								uri="bean:org.onap.clamp.flow.log.FlowLogOperation?method=endLog()" />
-					</doTry>
+							uri="bean:org.onap.clamp.loop.LoopController?method=addOperationalPolicy(${header.loopName},${header.policyType},${header.policyVersion})" />
+					<to
+							uri="bean:org.onap.clamp.loop.log.LoopLogService?method=addLog('ADD OperationalPolicy request successfully executed','INFO',${exchangeProperty[loopObject]})" />
+					<to
+							uri="bean:org.onap.clamp.flow.log.FlowLogOperation?method=endLog()" />
 					<doCatch>
 						<exception>java.lang.Exception</exception>
 						<handled>
@@ -602,13 +594,8 @@
 						<log loggingLevel="ERROR"
 							 message="ADD OperationalPolicy request failed for loop: ${header.loopName}" />
 						<to
-								uri="bean:org.onap.clamp.loop.log.LoopLogService?method=addLog('ADD OperationalPolicy request, Error reported: ${exception} - Body: ${exception.responseBody}','ERROR',${exchangeProperty[loopObject]})" />
+								uri="bean:org.onap.clamp.loop.log.LoopLogService?method=addLog('ADD OperationalPolicy request failed','ERROR',${exchangeProperty[loopObject]})" />
 					</doCatch>
-					<doFinally>
-						<setBody>
-							<simple>${exchangeProperty[loopObject]}</simple>
-						</setBody>
-					</doFinally>
 				</doTry>
 			</route>
 		</put>
@@ -923,13 +910,12 @@
 			</route>
 		</get>
 
-		<post uri="/v2/policyToscaModels/{policyModelType}"
+		<post uri="/v2/policyToscaModels"
 			type="java.lang.String"
 			outType="org.onap.clamp.loop.template.PolicyModel"
 			consumes="plain/text" produces="application/json">
 			<route>
-				<removeHeaders pattern="*"
-					excludePattern="policyModelType" />
+				<removeHeaders pattern="*"/>
 				<doTry>
 					<to
 						uri="bean:org.onap.clamp.flow.log.FlowLogOperation?method=startLog(*, 'Upload New or Update Tosca Policy Model')" />
@@ -939,7 +925,7 @@
 						<simple>${body}</simple>
 					</setProperty>
 					<to
-						uri="bean:org.onap.clamp.loop.template.PolicyModelsService?method=createNewPolicyModelFromTosca(${header.policyModelType},${exchangeProperty[PolicyModelTosca]})" />
+						uri="bean:org.onap.clamp.loop.template.PolicyModelsService?method=createNewPolicyModelFromTosca(${exchangeProperty[PolicyModelTosca]})" />
 					<to
 						uri="bean:org.onap.clamp.flow.log.FlowLogOperation?method=endLog()" />
 					<doCatch>
diff --git a/src/main/resources/clds/camel/routes/loop-flows.xml b/src/main/resources/clds/camel/routes/loop-flows.xml
index 48febfc..a4b6e29 100644
--- a/src/main/resources/clds/camel/routes/loop-flows.xml
+++ b/src/main/resources/clds/camel/routes/loop-flows.xml
@@ -38,7 +38,7 @@
 				<simple>${body.getName()}</simple>
 			</setProperty>
 			<setProperty propertyName="policyType">
-				<simple>${body.getModelType()}</simple>
+				<simple>${body.getPolicyModel().getPolicyModelType()}</simple>
 			</setProperty>
 			<setProperty propertyName="policyVersion">
 				<simple>1.0.0</simple>
diff --git a/src/main/resources/clds/camel/routes/policy-flows.xml b/src/main/resources/clds/camel/routes/policy-flows.xml
index ce37fe1..afc5f95 100644
--- a/src/main/resources/clds/camel/routes/policy-flows.xml
+++ b/src/main/resources/clds/camel/routes/policy-flows.xml
@@ -213,9 +213,9 @@
 								</simple>
 						</setHeader>
 						<log loggingLevel="INFO"
-								message="Endpoint to create microservice policy: {{clamp.config.policy.api.url}}/policy/api/v1/policytypes/${exchangeProperty[microServicePolicy].getModelType()}/versions/1.0.0/policies"></log>
+								message="Endpoint to create microservice policy: {{clamp.config.policy.api.url}}/policy/api/v1/policytypes/${exchangeProperty[microServicePolicy].getPolicyModel().getPolicyModelType()}/versions/1.0.0/policies"></log>
 						<toD
-								uri="{{clamp.config.policy.api.url}}/policy/api/v1/policytypes/${exchangeProperty[microServicePolicy].getModelType()}/versions/1.0.0/policies?bridgeEndpoint=true&amp;useSystemProperties=true&amp;mapHttpMessageHeaders=false&amp;throwExceptionOnFailure=${exchangeProperty[raiseHttpExceptionFlag]}&amp;authUsername={{clamp.config.policy.api.userName}}&amp;authPassword={{clamp.config.policy.api.password}}&amp;connectionTimeToLive=5000&amp;httpClient.connectTimeout=10000&amp;httpClient.socketTimeout=20000&amp;authenticationPreemptive=true&amp;connectionClose=true"/>
+								uri="{{clamp.config.policy.api.url}}/policy/api/v1/policytypes/${exchangeProperty[microServicePolicy].getPolicyModel().getPolicyModelType()}/versions/1.0.0/policies?bridgeEndpoint=true&amp;useSystemProperties=true&amp;mapHttpMessageHeaders=false&amp;throwExceptionOnFailure=${exchangeProperty[raiseHttpExceptionFlag]}&amp;authUsername={{clamp.config.policy.api.userName}}&amp;authPassword={{clamp.config.policy.api.password}}&amp;connectionTimeToLive=5000&amp;httpClient.connectTimeout=10000&amp;httpClient.socketTimeout=20000&amp;authenticationPreemptive=true&amp;connectionClose=true"/>
 						<doFinally>
 								<to uri="direct:reset-raise-http-exception-flag"/>
 								<to
@@ -259,9 +259,9 @@
 								</simple>
 						</setHeader>
 						<log loggingLevel="INFO"
-								message="Endpoint to delete microservice policy: {{clamp.config.policy.api.url}}/policy/api/v1/policytypes/${exchangeProperty[microServicePolicy].getModelType()}/versions/1.0.0/policies/${exchangeProperty[microServicePolicy].getName()}/versions/1.0.0"></log>
+								message="Endpoint to delete microservice policy: {{clamp.config.policy.api.url}}/policy/api/v1/policytypes/${exchangeProperty[microServicePolicy].getPolicyModel().getPolicyModelType()}/versions/1.0.0/policies/${exchangeProperty[microServicePolicy].getName()}/versions/1.0.0"></log>
 						<toD
-								uri="{{clamp.config.policy.api.url}}/policy/api/v1/policytypes/${exchangeProperty[microServicePolicy].getModelType()}/versions/1.0.0/policies/${exchangeProperty[microServicePolicy].getName()}/versions/1.0.0?bridgeEndpoint=true&amp;useSystemProperties=true&amp;mapHttpMessageHeaders=false&amp;throwExceptionOnFailure=${exchangeProperty[raiseHttpExceptionFlag]}&amp;deleteWithBody=false&amp;mapHttpMessageBody=false&amp;mapHttpMessageFormUrlEncodedBody=false&amp;authUsername={{clamp.config.policy.api.userName}}&amp;authPassword={{clamp.config.policy.api.password}}&amp;connectionTimeToLive=5000&amp;httpClient.connectTimeout=10000&amp;httpClient.socketTimeout=20000&amp;authenticationPreemptive=true&amp;connectionClose=true"/>
+								uri="{{clamp.config.policy.api.url}}/policy/api/v1/policytypes/${exchangeProperty[microServicePolicy].getPolicyModel().getPolicyModelType()}/versions/1.0.0/policies/${exchangeProperty[microServicePolicy].getName()}/versions/1.0.0?bridgeEndpoint=true&amp;useSystemProperties=true&amp;mapHttpMessageHeaders=false&amp;throwExceptionOnFailure=${exchangeProperty[raiseHttpExceptionFlag]}&amp;deleteWithBody=false&amp;mapHttpMessageBody=false&amp;mapHttpMessageFormUrlEncodedBody=false&amp;authUsername={{clamp.config.policy.api.userName}}&amp;authPassword={{clamp.config.policy.api.password}}&amp;connectionTimeToLive=5000&amp;httpClient.connectTimeout=10000&amp;httpClient.socketTimeout=20000&amp;authenticationPreemptive=true&amp;connectionClose=true"/>
 
 						<doFinally>
 								<to uri="direct:reset-raise-http-exception-flag"/>
diff --git a/src/test/java/org/onap/clamp/clds/tosca/ToscaYamlToJsonConvertorTestItCase.java b/src/test/java/org/onap/clamp/clds/tosca/ToscaYamlToJsonConvertorTestItCase.java
index f426c76..db6fd5c 100644
--- a/src/test/java/org/onap/clamp/clds/tosca/ToscaYamlToJsonConvertorTestItCase.java
+++ b/src/test/java/org/onap/clamp/clds/tosca/ToscaYamlToJsonConvertorTestItCase.java
@@ -24,6 +24,9 @@
 
 package org.onap.clamp.clds.tosca;
 
+import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import com.google.gson.JsonObject;
 import java.io.IOException;
 import javax.transaction.Transactional;
@@ -39,9 +42,6 @@
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
-import static org.junit.Assert.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
 @RunWith(SpringJUnit4ClassRunner.class)
 @SpringBootTest(classes = Application.class)
 public class ToscaYamlToJsonConvertorTestItCase {
diff --git a/src/test/java/org/onap/clamp/loop/LoopTemplatesServiceItCase.java b/src/test/java/org/onap/clamp/loop/LoopTemplatesServiceItCase.java
index 3a36a5d..cabc778 100644
--- a/src/test/java/org/onap/clamp/loop/LoopTemplatesServiceItCase.java
+++ b/src/test/java/org/onap/clamp/loop/LoopTemplatesServiceItCase.java
@@ -130,6 +130,19 @@
             .isEqualTo("microService1");
         assertThat(loopTemplateLoopElementModel.getLoopTemplate().getName())
             .isEqualTo("TemplateName");
+        assertNull(actualLoopTemplate.getBlueprint());
+        assertNull(actualLoopTemplate.getModelService());
+    }
+
+    @Test
+    @Transactional
+    public void shouldReturnLoopemplateSvg() {
+        LoopTemplate loopTemplate = getLoopTemplate("TemplateName", null, "svg", "xyz", -1);
+        loopTemplatesService.saveOrUpdateLoopTemplate(loopTemplate);
+        String svgRepresentation = loopTemplatesService.getSvgRepresentation("TemplateName");
+
+        assertNotNull(svgRepresentation);
+        assertThat(svgRepresentation).isEqualTo(loopTemplate.getSvgRepresentation());
     }
 
     @Test
diff --git a/src/test/java/org/onap/clamp/loop/PolicyModelServiceItCase.java b/src/test/java/org/onap/clamp/loop/PolicyModelServiceItCase.java
index 80545c1..d918a8e 100644
--- a/src/test/java/org/onap/clamp/loop/PolicyModelServiceItCase.java
+++ b/src/test/java/org/onap/clamp/loop/PolicyModelServiceItCase.java
@@ -26,6 +26,7 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 import com.google.gson.JsonObject;
+import java.io.IOException;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.SortedSet;
@@ -36,6 +37,7 @@
 import org.junit.runner.RunWith;
 import org.onap.clamp.clds.Application;
 import org.onap.clamp.clds.util.JsonUtils;
+import org.onap.clamp.clds.util.ResourceFileUtil;
 import org.onap.clamp.loop.template.PolicyModel;
 import org.onap.clamp.loop.template.PolicyModelId;
 import org.onap.clamp.loop.template.PolicyModelsRepository;
@@ -66,8 +68,8 @@
     private static final String POLICY_MODEL_TYPE_3_VERSION_1 = "1.0.0";
     private static final String POLICY_MODEL_TYPE_2_VERSION_2 = "2.0.0";
 
-    private PolicyModel getPolicyModel(String policyType, String policyModelTosca, String version, String policyAcronym,
-                                       String policyVariant, String createdBy) {
+    private PolicyModel getPolicyModel(String policyType, String policyModelTosca, String version,
+        String policyAcronym, String policyVariant, String createdBy) {
         PolicyModel policyModel = new PolicyModel();
         policyModel.setCreatedBy(createdBy);
         policyModel.setPolicyAcronym(policyAcronym);
@@ -85,8 +87,8 @@
     @Transactional
     public void shouldCreatePolicyModel() {
         // given
-        PolicyModel policyModel = getPolicyModel(POLICY_MODEL_TYPE_1, "yaml", POLICY_MODEL_TYPE_1_VERSION_1, "TEST",
-                "VARIANT", "user");
+        PolicyModel policyModel = getPolicyModel(POLICY_MODEL_TYPE_1, "yaml",
+            POLICY_MODEL_TYPE_1_VERSION_1, "TEST", "VARIANT", "user");
 
         // when
         PolicyModel actualPolicyModel = policyModelsService.saveOrUpdatePolicyModel(policyModel);
@@ -94,19 +96,63 @@
         // then
         assertThat(actualPolicyModel).isNotNull();
         assertThat(actualPolicyModel).isEqualTo(policyModelsRepository
-                .findById(new PolicyModelId(actualPolicyModel.getPolicyModelType(), actualPolicyModel.getVersion()))
-                .get());
-        assertThat(actualPolicyModel.getPolicyModelType()).isEqualTo(policyModel.getPolicyModelType());
+            .findById(new PolicyModelId(actualPolicyModel.getPolicyModelType(),
+                actualPolicyModel.getVersion()))
+            .get());
+        assertThat(actualPolicyModel.getPolicyModelType())
+            .isEqualTo(policyModel.getPolicyModelType());
         assertThat(actualPolicyModel.getCreatedBy()).isEqualTo("Not found");
         assertThat(actualPolicyModel.getCreatedDate()).isNotNull();
         assertThat(actualPolicyModel.getPolicyAcronym()).isEqualTo(policyModel.getPolicyAcronym());
-        assertThat(actualPolicyModel.getPolicyModelTosca()).isEqualTo(policyModel.getPolicyModelTosca());
+        assertThat(actualPolicyModel.getPolicyModelTosca())
+            .isEqualTo(policyModel.getPolicyModelTosca());
         assertThat(actualPolicyModel.getUpdatedBy()).isEqualTo("Not found");
         assertThat(actualPolicyModel.getUpdatedDate()).isNotNull();
         assertThat(actualPolicyModel.getVersion()).isEqualTo(policyModel.getVersion());
 
-        assertThat(policyModelsService.getPolicyModel(POLICY_MODEL_TYPE_1, POLICY_MODEL_TYPE_1_VERSION_1))
-                .isEqualToIgnoringGivenFields(policyModel, "createdDate", "updatedDate", "createdBy", "updatedBy");
+        assertThat(
+            policyModelsService.getPolicyModel(POLICY_MODEL_TYPE_1, POLICY_MODEL_TYPE_1_VERSION_1))
+                .isEqualToIgnoringGivenFields(policyModel, "createdDate", "updatedDate",
+                    "createdBy", "updatedBy");
+    }
+
+    /**
+     * This tests a create Policy Model from Tosca.
+     *
+     * @throws IOException
+     */
+    @Test
+    @Transactional
+    public void shouldCreatePolicyModelFromTosca() throws IOException {
+        String toscaModelYaml =
+            ResourceFileUtil.getResourceAsString("tosca/tosca_with_metadata.yaml");
+        PolicyModel policyModel = policyModelsService.createNewPolicyModelFromTosca(toscaModelYaml);
+
+        assertThat(policyModelsService.getAllPolicyModels()).contains(policyModel);
+
+        assertThat(policyModelsService.getPolicyModelTosca(policyModel.getPolicyModelType(),
+            policyModel.getVersion())).contains(toscaModelYaml);
+    }
+
+    /**
+     * This tests a update Policy Model.
+     *
+     * @throws IOException
+     */
+    @Test
+    @Transactional
+    public void shouldUpdatePolicyModel() throws IOException {
+        String toscaModelYaml =
+            ResourceFileUtil.getResourceAsString("tosca/tosca_with_metadata.yaml");
+        PolicyModel policyModel = policyModelsService.createNewPolicyModelFromTosca(toscaModelYaml);
+        String newToscaModelYaml =
+            ResourceFileUtil.getResourceAsString("tosca/tosca_metadata_clamp_possible_values.yaml");
+
+        PolicyModel updatedPolicyModel = policyModelsService.updatePolicyModelTosca(
+            policyModel.getPolicyModelType(), policyModel.getVersion(), newToscaModelYaml);
+
+        assertThat(updatedPolicyModel.getPolicyModelTosca()).isEqualTo(newToscaModelYaml);
+
     }
 
     /**
@@ -116,15 +162,16 @@
     @Transactional
     public void shouldReturnAllPolicyModelTypes() {
         // given
-        PolicyModel policyModel1 = getPolicyModel(POLICY_MODEL_TYPE_2, "yaml", POLICY_MODEL_TYPE_2_VERSION_1, "TEST",
-                "VARIANT", "user");
+        PolicyModel policyModel1 = getPolicyModel(POLICY_MODEL_TYPE_2, "yaml",
+            POLICY_MODEL_TYPE_2_VERSION_1, "TEST", "VARIANT", "user");
         policyModelsService.saveOrUpdatePolicyModel(policyModel1);
-        PolicyModel policyModel2 = getPolicyModel(POLICY_MODEL_TYPE_2, "yaml", POLICY_MODEL_TYPE_2_VERSION_2, "TEST",
-                "VARIANT", "user");
+        PolicyModel policyModel2 = getPolicyModel(POLICY_MODEL_TYPE_2, "yaml",
+            POLICY_MODEL_TYPE_2_VERSION_2, "TEST", "VARIANT", "user");
         policyModelsService.saveOrUpdatePolicyModel(policyModel2);
         List<String> policyModelTypesList = policyModelsService.getAllPolicyModelTypes();
 
-        assertThat(policyModelTypesList).contains(policyModel1.getPolicyModelType(), policyModel2.getPolicyModelType());
+        assertThat(policyModelTypesList).contains(policyModel1.getPolicyModelType(),
+            policyModel2.getPolicyModelType());
     }
 
     /**
@@ -133,11 +180,11 @@
     @Test
     @Transactional
     public void shouldReturnAllPolicyModels() {
-        PolicyModel policyModel1 = getPolicyModel(POLICY_MODEL_TYPE_2, "yaml", POLICY_MODEL_TYPE_2_VERSION_1, "TEST",
-                "VARIANT", "user");
+        PolicyModel policyModel1 = getPolicyModel(POLICY_MODEL_TYPE_2, "yaml",
+            POLICY_MODEL_TYPE_2_VERSION_1, "TEST", "VARIANT", "user");
         policyModelsService.saveOrUpdatePolicyModel(policyModel1);
-        PolicyModel policyModel2 = getPolicyModel(POLICY_MODEL_TYPE_2, "yaml", POLICY_MODEL_TYPE_2_VERSION_2, "TEST",
-                "VARIANT", "user");
+        PolicyModel policyModel2 = getPolicyModel(POLICY_MODEL_TYPE_2, "yaml",
+            POLICY_MODEL_TYPE_2_VERSION_2, "TEST", "VARIANT", "user");
         policyModelsService.saveOrUpdatePolicyModel(policyModel2);
 
         assertThat(policyModelsService.getAllPolicyModels()).contains(policyModel1, policyModel2);
@@ -149,15 +196,15 @@
     @Test
     @Transactional
     public void shouldReturnAllModelsByType() {
-        PolicyModel policyModel1 = getPolicyModel(POLICY_MODEL_TYPE_2, "yaml", POLICY_MODEL_TYPE_2_VERSION_1, "TEST",
-                "VARIANT", "user");
+        PolicyModel policyModel1 = getPolicyModel(POLICY_MODEL_TYPE_2, "yaml",
+            POLICY_MODEL_TYPE_2_VERSION_1, "TEST", "VARIANT", "user");
         policyModelsService.saveOrUpdatePolicyModel(policyModel1);
-        PolicyModel policyModel2 = getPolicyModel(POLICY_MODEL_TYPE_2, "yaml", POLICY_MODEL_TYPE_2_VERSION_2, "TEST",
-                "VARIANT", "user");
+        PolicyModel policyModel2 = getPolicyModel(POLICY_MODEL_TYPE_2, "yaml",
+            POLICY_MODEL_TYPE_2_VERSION_2, "TEST", "VARIANT", "user");
         policyModelsService.saveOrUpdatePolicyModel(policyModel2);
 
-        assertThat(policyModelsService.getAllPolicyModelsByType(POLICY_MODEL_TYPE_2)).contains(policyModel1,
-                policyModel2);
+        assertThat(policyModelsService.getAllPolicyModelsByType(POLICY_MODEL_TYPE_2))
+            .contains(policyModel1, policyModel2);
     }
 
     /**
@@ -166,21 +213,23 @@
     @Test
     @Transactional
     public void shouldReturnSortedSet() {
-        PolicyModel policyModel1 = getPolicyModel(POLICY_MODEL_TYPE_2, "yaml", POLICY_MODEL_TYPE_2_VERSION_1, "TEST",
-                "VARIANT", "user");
+        PolicyModel policyModel1 = getPolicyModel(POLICY_MODEL_TYPE_2, "yaml",
+            POLICY_MODEL_TYPE_2_VERSION_1, "TEST", "VARIANT", "user");
         policyModelsService.saveOrUpdatePolicyModel(policyModel1);
-        PolicyModel policyModel2 = getPolicyModel(POLICY_MODEL_TYPE_2, "yaml", POLICY_MODEL_TYPE_2_VERSION_2, "TEST",
-                "VARIANT", "user");
+        PolicyModel policyModel2 = getPolicyModel(POLICY_MODEL_TYPE_2, "yaml",
+            POLICY_MODEL_TYPE_2_VERSION_2, "TEST", "VARIANT", "user");
         policyModelsService.saveOrUpdatePolicyModel(policyModel2);
-        PolicyModel policyModel3 = getPolicyModel(POLICY_MODEL_TYPE_3, "yaml", POLICY_MODEL_TYPE_3_VERSION_1, "TEST",
-                "VARIANT", "user");
+        PolicyModel policyModel3 = getPolicyModel(POLICY_MODEL_TYPE_3, "yaml",
+            POLICY_MODEL_TYPE_3_VERSION_1, "TEST", "VARIANT", "user");
         policyModelsService.saveOrUpdatePolicyModel(policyModel3);
 
         SortedSet<PolicyModel> sortedSet = new TreeSet<>();
         policyModelsService.getAllPolicyModels().forEach(sortedSet::add);
-        List<PolicyModel> listToCheck = sortedSet.stream()
-                .filter(policy -> policy.equals(policyModel3) || policy.equals(policyModel2)
-                        || policy.equals(policyModel1)).collect(Collectors.toList());
+        List<PolicyModel> listToCheck =
+            sortedSet
+                .stream().filter(policy -> policy.equals(policyModel3)
+                    || policy.equals(policyModel2) || policy.equals(policyModel1))
+                .collect(Collectors.toList());
         assertThat(listToCheck.get(0)).isEqualByComparingTo(policyModel2);
         assertThat(listToCheck.get(1)).isEqualByComparingTo(policyModel1);
         assertThat(listToCheck.get(2)).isEqualByComparingTo(policyModel3);
@@ -192,17 +241,16 @@
     @Test
     @Transactional
     public void shouldAddPdpGroupInfo() {
-        PolicyModel policyModel1 = getPolicyModel(POLICY_MODEL_TYPE_1, "yaml", POLICY_MODEL_TYPE_1_VERSION_1, "TEST",
-                "VARIANT", "user");
+        PolicyModel policyModel1 = getPolicyModel(POLICY_MODEL_TYPE_1, "yaml",
+            POLICY_MODEL_TYPE_1_VERSION_1, "TEST", "VARIANT", "user");
         policyModelsService.saveOrUpdatePolicyModel(policyModel1);
-        PolicyModel policyModel2 = getPolicyModel(POLICY_MODEL_TYPE_2, "yaml", POLICY_MODEL_TYPE_2_VERSION_2, "TEST",
-                "VARIANT", "user");
+        PolicyModel policyModel2 = getPolicyModel(POLICY_MODEL_TYPE_2, "yaml",
+            POLICY_MODEL_TYPE_2_VERSION_2, "TEST", "VARIANT", "user");
         policyModelsService.saveOrUpdatePolicyModel(policyModel2);
-        PolicyModel policyModel3 = getPolicyModel(POLICY_MODEL_TYPE_3, "yaml", POLICY_MODEL_TYPE_3_VERSION_1, "TEST",
-                "VARIANT", "user");
+        PolicyModel policyModel3 = getPolicyModel(POLICY_MODEL_TYPE_3, "yaml",
+            POLICY_MODEL_TYPE_3_VERSION_1, "TEST", "VARIANT", "user");
         policyModelsService.saveOrUpdatePolicyModel(policyModel3);
 
-
         PolicyModelKey type1 = new PolicyModelKey("org.onap.testos", "1.0.0");
         PolicyModelKey type2 = new PolicyModelKey("org.onap.testos2", "2.0.0");
 
@@ -242,19 +290,22 @@
         pdpGroupList.add(pdpGroup2);
         policyModelsService.updatePdpGroupInfo(pdpGroupList);
 
-        JsonObject res1 = policyModelsService.getPolicyModel("org.onap.testos", "1.0.0").getPolicyPdpGroup();
+        JsonObject res1 =
+            policyModelsService.getPolicyModel("org.onap.testos", "1.0.0").getPolicyPdpGroup();
         String expectedRes1 =
-                "{\"supportedPdpGroups\":[{\"pdpGroup1\":[\"subGroup1\"]},{\"pdpGroup2\":[\"subGroup1\"]}]}";
+            "{\"supportedPdpGroups\":[{\"pdpGroup1\":[\"subGroup1\"]},{\"pdpGroup2\":[\"subGroup1\"]}]}";
         JsonObject expectedJson1 = JsonUtils.GSON.fromJson(expectedRes1, JsonObject.class);
         assertThat(res1).isEqualTo(expectedJson1);
 
-        JsonObject res2 = policyModelsService.getPolicyModel("org.onap.testos2", "2.0.0").getPolicyPdpGroup();
+        JsonObject res2 =
+            policyModelsService.getPolicyModel("org.onap.testos2", "2.0.0").getPolicyPdpGroup();
         String expectedRes2 =
-                "{\"supportedPdpGroups\":[{\"pdpGroup1\":[\"subGroup1\"]},{\"pdpGroup2\":[\"subGroup1\",\"subGroup2\"]}]}";
+            "{\"supportedPdpGroups\":[{\"pdpGroup1\":[\"subGroup1\"]},{\"pdpGroup2\":[\"subGroup1\",\"subGroup2\"]}]}";
         JsonObject expectedJson2 = JsonUtils.GSON.fromJson(expectedRes2, JsonObject.class);
         assertThat(res2).isEqualTo(expectedJson2);
 
-        JsonObject res3 = policyModelsService.getPolicyModel("org.onap.testos3", "1.0.0").getPolicyPdpGroup();
+        JsonObject res3 =
+            policyModelsService.getPolicyModel("org.onap.testos3", "1.0.0").getPolicyPdpGroup();
         assertThat(res3).isNull();
     }
 }
diff --git "a/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.Guard/versions/1.0.0&\04363;connectionTimeToLive=5000/.file" "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.Guard/versions/1.0.0&\04363;connectionTimeToLive=5000/.file"
new file mode 100644
index 0000000..b0119f8
--- /dev/null
+++ "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.Guard/versions/1.0.0&\04363;connectionTimeToLive=5000/.file"
@@ -0,0 +1,158 @@
+tosca_definitions_version: tosca_simple_yaml_1_0_0
+policy_types:
+    onap.policies.Monitoring:
+        derived_from: tosca.policies.Root
+        description: a base policy type for all policies that governs monitoring provisioning
+    onap.policies.monitoring.cdap.tca.hi.lo.app:
+        derived_from: onap.policies.Monitoring
+        version: 1.0.0
+        properties:
+            tca_policy:
+                type: map
+                description: TCA Policy JSON
+                entry_schema:
+                    type: onap.datatypes.monitoring.tca_policy
+data_types:
+    onap.datatypes.monitoring.metricsPerEventName:
+        derived_from: tosca.datatypes.Root
+        properties:
+            controlLoopSchemaType:
+                type: string
+                required: true
+                description: Specifies Control Loop Schema Type for the event Name e.g. VNF, VM
+                constraints:
+                  - valid_values:
+                      - VM
+                      - VNF
+            eventName:
+                type: string
+                required: true
+                description: Event name to which thresholds need to be applied
+            policyName:
+                type: string
+                required: true
+                description: TCA Policy Scope Name
+            policyScope:
+                type: string
+                required: true
+                description: TCA Policy Scope
+            policyVersion:
+                type: string
+                required: true
+                description: TCA Policy Scope Version
+            thresholds:
+                type: list
+                required: true
+                description: Thresholds associated with eventName
+                entry_schema:
+                    type: onap.datatypes.monitoring.thresholds
+    onap.datatypes.monitoring.tca_policy:
+        derived_from: tosca.datatypes.Root
+        properties:
+            domain:
+                type: string
+                required: true
+                description: Domain name to which TCA needs to be applied
+                default: measurementsForVfScaling
+                constraints:
+                  - equal: measurementsForVfScaling
+            metricsPerEventName:
+                type: list
+                required: true
+                description: Contains eventName and threshold details that need to be applied to given eventName
+                entry_schema:
+                    type: onap.datatypes.monitoring.metricsPerEventName
+    onap.datatypes.monitoring.thresholds:
+        derived_from: tosca.datatypes.Root
+        properties:
+            closedLoopControlName:
+                type: string
+                required: true
+                description: Closed Loop Control Name associated with the threshold
+            closedLoopEventStatus:
+                type: string
+                required: true
+                description: Closed Loop Event Status of the threshold
+                constraints:
+                  - valid_values:
+                      - ONSET
+                      - ABATED
+            direction:
+                type: string
+                required: true
+                description: Direction of the threshold
+                constraints:
+                  - valid_values:
+                      - LESS
+                      - LESS_OR_EQUAL
+                      - GREATER
+                      - GREATER_OR_EQUAL
+                      - EQUAL
+            fieldPath:
+                type: string
+                required: true
+                description: Json field Path as per CEF message which needs to be analyzed for TCA
+                constraints:
+                  - valid_values:
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuIdle
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageInterrupt
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageNice
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSoftIrq
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSteal
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSystem
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuWait
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].percentUsage
+                      - $.event.measurementsForVfScalingFields.meanRequestLatency
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryBuffered
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryCached
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryConfigured
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryFree
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryUsed
+                      - $.event.measurementsForVfScalingFields.additionalMeasurements[*].arrayOfFields[0].value
+            severity:
+                type: string
+                required: true
+                description: Threshold Event Severity
+                constraints:
+                  - valid_values:
+                      - CRITICAL
+                      - MAJOR
+                      - MINOR
+                      - WARNING
+                      - NORMAL
+            thresholdValue:
+                type: integer
+                required: true
+                description: Threshold value for the field Path inside CEF message
+            version:
+                type: string
+                required: true
+                description: Version number associated with the threshold
diff --git "a/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.Guard/versions/1.0.0&\04363;connectionTimeToLive=5000/.header" "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.Guard/versions/1.0.0&\04363;connectionTimeToLive=5000/.header"
new file mode 100644
index 0000000..6a280d9
--- /dev/null
+++ "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.Guard/versions/1.0.0&\04363;connectionTimeToLive=5000/.header"
@@ -0,0 +1 @@
+{"Transfer-Encoding": "chunked", "Set-Cookie": "JSESSIONID=158qxkdtdobkd1umr3ikkgrmlx;Path=/", "Expires": "Thu, 01 Jan 1970 00:00:00 GMT", "Server": "Jetty(9.3.21.v20170918)", "Content-Type": "application/json", "X-ECOMP-RequestID": "e2ddb3c8-994f-47df-b4dc-097d4fb55c08"}
\ No newline at end of file
diff --git "a/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.Operational/versions/1.0.0&\04363;connectionTimeToLive=5000/.file" "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.Operational/versions/1.0.0&\04363;connectionTimeToLive=5000/.file"
new file mode 100644
index 0000000..b0119f8
--- /dev/null
+++ "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.Operational/versions/1.0.0&\04363;connectionTimeToLive=5000/.file"
@@ -0,0 +1,158 @@
+tosca_definitions_version: tosca_simple_yaml_1_0_0
+policy_types:
+    onap.policies.Monitoring:
+        derived_from: tosca.policies.Root
+        description: a base policy type for all policies that governs monitoring provisioning
+    onap.policies.monitoring.cdap.tca.hi.lo.app:
+        derived_from: onap.policies.Monitoring
+        version: 1.0.0
+        properties:
+            tca_policy:
+                type: map
+                description: TCA Policy JSON
+                entry_schema:
+                    type: onap.datatypes.monitoring.tca_policy
+data_types:
+    onap.datatypes.monitoring.metricsPerEventName:
+        derived_from: tosca.datatypes.Root
+        properties:
+            controlLoopSchemaType:
+                type: string
+                required: true
+                description: Specifies Control Loop Schema Type for the event Name e.g. VNF, VM
+                constraints:
+                  - valid_values:
+                      - VM
+                      - VNF
+            eventName:
+                type: string
+                required: true
+                description: Event name to which thresholds need to be applied
+            policyName:
+                type: string
+                required: true
+                description: TCA Policy Scope Name
+            policyScope:
+                type: string
+                required: true
+                description: TCA Policy Scope
+            policyVersion:
+                type: string
+                required: true
+                description: TCA Policy Scope Version
+            thresholds:
+                type: list
+                required: true
+                description: Thresholds associated with eventName
+                entry_schema:
+                    type: onap.datatypes.monitoring.thresholds
+    onap.datatypes.monitoring.tca_policy:
+        derived_from: tosca.datatypes.Root
+        properties:
+            domain:
+                type: string
+                required: true
+                description: Domain name to which TCA needs to be applied
+                default: measurementsForVfScaling
+                constraints:
+                  - equal: measurementsForVfScaling
+            metricsPerEventName:
+                type: list
+                required: true
+                description: Contains eventName and threshold details that need to be applied to given eventName
+                entry_schema:
+                    type: onap.datatypes.monitoring.metricsPerEventName
+    onap.datatypes.monitoring.thresholds:
+        derived_from: tosca.datatypes.Root
+        properties:
+            closedLoopControlName:
+                type: string
+                required: true
+                description: Closed Loop Control Name associated with the threshold
+            closedLoopEventStatus:
+                type: string
+                required: true
+                description: Closed Loop Event Status of the threshold
+                constraints:
+                  - valid_values:
+                      - ONSET
+                      - ABATED
+            direction:
+                type: string
+                required: true
+                description: Direction of the threshold
+                constraints:
+                  - valid_values:
+                      - LESS
+                      - LESS_OR_EQUAL
+                      - GREATER
+                      - GREATER_OR_EQUAL
+                      - EQUAL
+            fieldPath:
+                type: string
+                required: true
+                description: Json field Path as per CEF message which needs to be analyzed for TCA
+                constraints:
+                  - valid_values:
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuIdle
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageInterrupt
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageNice
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSoftIrq
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSteal
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSystem
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuWait
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].percentUsage
+                      - $.event.measurementsForVfScalingFields.meanRequestLatency
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryBuffered
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryCached
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryConfigured
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryFree
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryUsed
+                      - $.event.measurementsForVfScalingFields.additionalMeasurements[*].arrayOfFields[0].value
+            severity:
+                type: string
+                required: true
+                description: Threshold Event Severity
+                constraints:
+                  - valid_values:
+                      - CRITICAL
+                      - MAJOR
+                      - MINOR
+                      - WARNING
+                      - NORMAL
+            thresholdValue:
+                type: integer
+                required: true
+                description: Threshold value for the field Path inside CEF message
+            version:
+                type: string
+                required: true
+                description: Version number associated with the threshold
diff --git "a/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.Operational/versions/1.0.0&\04363;connectionTimeToLive=5000/.header" "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.Operational/versions/1.0.0&\04363;connectionTimeToLive=5000/.header"
new file mode 100644
index 0000000..6a280d9
--- /dev/null
+++ "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.Operational/versions/1.0.0&\04363;connectionTimeToLive=5000/.header"
@@ -0,0 +1 @@
+{"Transfer-Encoding": "chunked", "Set-Cookie": "JSESSIONID=158qxkdtdobkd1umr3ikkgrmlx;Path=/", "Expires": "Thu, 01 Jan 1970 00:00:00 GMT", "Server": "Jetty(9.3.21.v20170918)", "Content-Type": "application/json", "X-ECOMP-RequestID": "e2ddb3c8-994f-47df-b4dc-097d4fb55c08"}
\ No newline at end of file
diff --git "a/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.guard.Blacklist/versions/1.0.0&\04363;connectionTimeToLive=5000/.file" "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.guard.Blacklist/versions/1.0.0&\04363;connectionTimeToLive=5000/.file"
new file mode 100644
index 0000000..b0119f8
--- /dev/null
+++ "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.guard.Blacklist/versions/1.0.0&\04363;connectionTimeToLive=5000/.file"
@@ -0,0 +1,158 @@
+tosca_definitions_version: tosca_simple_yaml_1_0_0
+policy_types:
+    onap.policies.Monitoring:
+        derived_from: tosca.policies.Root
+        description: a base policy type for all policies that governs monitoring provisioning
+    onap.policies.monitoring.cdap.tca.hi.lo.app:
+        derived_from: onap.policies.Monitoring
+        version: 1.0.0
+        properties:
+            tca_policy:
+                type: map
+                description: TCA Policy JSON
+                entry_schema:
+                    type: onap.datatypes.monitoring.tca_policy
+data_types:
+    onap.datatypes.monitoring.metricsPerEventName:
+        derived_from: tosca.datatypes.Root
+        properties:
+            controlLoopSchemaType:
+                type: string
+                required: true
+                description: Specifies Control Loop Schema Type for the event Name e.g. VNF, VM
+                constraints:
+                  - valid_values:
+                      - VM
+                      - VNF
+            eventName:
+                type: string
+                required: true
+                description: Event name to which thresholds need to be applied
+            policyName:
+                type: string
+                required: true
+                description: TCA Policy Scope Name
+            policyScope:
+                type: string
+                required: true
+                description: TCA Policy Scope
+            policyVersion:
+                type: string
+                required: true
+                description: TCA Policy Scope Version
+            thresholds:
+                type: list
+                required: true
+                description: Thresholds associated with eventName
+                entry_schema:
+                    type: onap.datatypes.monitoring.thresholds
+    onap.datatypes.monitoring.tca_policy:
+        derived_from: tosca.datatypes.Root
+        properties:
+            domain:
+                type: string
+                required: true
+                description: Domain name to which TCA needs to be applied
+                default: measurementsForVfScaling
+                constraints:
+                  - equal: measurementsForVfScaling
+            metricsPerEventName:
+                type: list
+                required: true
+                description: Contains eventName and threshold details that need to be applied to given eventName
+                entry_schema:
+                    type: onap.datatypes.monitoring.metricsPerEventName
+    onap.datatypes.monitoring.thresholds:
+        derived_from: tosca.datatypes.Root
+        properties:
+            closedLoopControlName:
+                type: string
+                required: true
+                description: Closed Loop Control Name associated with the threshold
+            closedLoopEventStatus:
+                type: string
+                required: true
+                description: Closed Loop Event Status of the threshold
+                constraints:
+                  - valid_values:
+                      - ONSET
+                      - ABATED
+            direction:
+                type: string
+                required: true
+                description: Direction of the threshold
+                constraints:
+                  - valid_values:
+                      - LESS
+                      - LESS_OR_EQUAL
+                      - GREATER
+                      - GREATER_OR_EQUAL
+                      - EQUAL
+            fieldPath:
+                type: string
+                required: true
+                description: Json field Path as per CEF message which needs to be analyzed for TCA
+                constraints:
+                  - valid_values:
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuIdle
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageInterrupt
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageNice
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSoftIrq
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSteal
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSystem
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuWait
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].percentUsage
+                      - $.event.measurementsForVfScalingFields.meanRequestLatency
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryBuffered
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryCached
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryConfigured
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryFree
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryUsed
+                      - $.event.measurementsForVfScalingFields.additionalMeasurements[*].arrayOfFields[0].value
+            severity:
+                type: string
+                required: true
+                description: Threshold Event Severity
+                constraints:
+                  - valid_values:
+                      - CRITICAL
+                      - MAJOR
+                      - MINOR
+                      - WARNING
+                      - NORMAL
+            thresholdValue:
+                type: integer
+                required: true
+                description: Threshold value for the field Path inside CEF message
+            version:
+                type: string
+                required: true
+                description: Version number associated with the threshold
diff --git "a/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.guard.Blacklist/versions/1.0.0&\04363;connectionTimeToLive=5000/.header" "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.guard.Blacklist/versions/1.0.0&\04363;connectionTimeToLive=5000/.header"
new file mode 100644
index 0000000..6a280d9
--- /dev/null
+++ "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.guard.Blacklist/versions/1.0.0&\04363;connectionTimeToLive=5000/.header"
@@ -0,0 +1 @@
+{"Transfer-Encoding": "chunked", "Set-Cookie": "JSESSIONID=158qxkdtdobkd1umr3ikkgrmlx;Path=/", "Expires": "Thu, 01 Jan 1970 00:00:00 GMT", "Server": "Jetty(9.3.21.v20170918)", "Content-Type": "application/json", "X-ECOMP-RequestID": "e2ddb3c8-994f-47df-b4dc-097d4fb55c08"}
\ No newline at end of file
diff --git "a/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.guard.FrequencyLimiter/versions/1.0.0&\04363;connectionTimeToLive=5000/.file" "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.guard.FrequencyLimiter/versions/1.0.0&\04363;connectionTimeToLive=5000/.file"
new file mode 100644
index 0000000..b0119f8
--- /dev/null
+++ "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.guard.FrequencyLimiter/versions/1.0.0&\04363;connectionTimeToLive=5000/.file"
@@ -0,0 +1,158 @@
+tosca_definitions_version: tosca_simple_yaml_1_0_0
+policy_types:
+    onap.policies.Monitoring:
+        derived_from: tosca.policies.Root
+        description: a base policy type for all policies that governs monitoring provisioning
+    onap.policies.monitoring.cdap.tca.hi.lo.app:
+        derived_from: onap.policies.Monitoring
+        version: 1.0.0
+        properties:
+            tca_policy:
+                type: map
+                description: TCA Policy JSON
+                entry_schema:
+                    type: onap.datatypes.monitoring.tca_policy
+data_types:
+    onap.datatypes.monitoring.metricsPerEventName:
+        derived_from: tosca.datatypes.Root
+        properties:
+            controlLoopSchemaType:
+                type: string
+                required: true
+                description: Specifies Control Loop Schema Type for the event Name e.g. VNF, VM
+                constraints:
+                  - valid_values:
+                      - VM
+                      - VNF
+            eventName:
+                type: string
+                required: true
+                description: Event name to which thresholds need to be applied
+            policyName:
+                type: string
+                required: true
+                description: TCA Policy Scope Name
+            policyScope:
+                type: string
+                required: true
+                description: TCA Policy Scope
+            policyVersion:
+                type: string
+                required: true
+                description: TCA Policy Scope Version
+            thresholds:
+                type: list
+                required: true
+                description: Thresholds associated with eventName
+                entry_schema:
+                    type: onap.datatypes.monitoring.thresholds
+    onap.datatypes.monitoring.tca_policy:
+        derived_from: tosca.datatypes.Root
+        properties:
+            domain:
+                type: string
+                required: true
+                description: Domain name to which TCA needs to be applied
+                default: measurementsForVfScaling
+                constraints:
+                  - equal: measurementsForVfScaling
+            metricsPerEventName:
+                type: list
+                required: true
+                description: Contains eventName and threshold details that need to be applied to given eventName
+                entry_schema:
+                    type: onap.datatypes.monitoring.metricsPerEventName
+    onap.datatypes.monitoring.thresholds:
+        derived_from: tosca.datatypes.Root
+        properties:
+            closedLoopControlName:
+                type: string
+                required: true
+                description: Closed Loop Control Name associated with the threshold
+            closedLoopEventStatus:
+                type: string
+                required: true
+                description: Closed Loop Event Status of the threshold
+                constraints:
+                  - valid_values:
+                      - ONSET
+                      - ABATED
+            direction:
+                type: string
+                required: true
+                description: Direction of the threshold
+                constraints:
+                  - valid_values:
+                      - LESS
+                      - LESS_OR_EQUAL
+                      - GREATER
+                      - GREATER_OR_EQUAL
+                      - EQUAL
+            fieldPath:
+                type: string
+                required: true
+                description: Json field Path as per CEF message which needs to be analyzed for TCA
+                constraints:
+                  - valid_values:
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuIdle
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageInterrupt
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageNice
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSoftIrq
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSteal
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSystem
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuWait
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].percentUsage
+                      - $.event.measurementsForVfScalingFields.meanRequestLatency
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryBuffered
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryCached
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryConfigured
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryFree
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryUsed
+                      - $.event.measurementsForVfScalingFields.additionalMeasurements[*].arrayOfFields[0].value
+            severity:
+                type: string
+                required: true
+                description: Threshold Event Severity
+                constraints:
+                  - valid_values:
+                      - CRITICAL
+                      - MAJOR
+                      - MINOR
+                      - WARNING
+                      - NORMAL
+            thresholdValue:
+                type: integer
+                required: true
+                description: Threshold value for the field Path inside CEF message
+            version:
+                type: string
+                required: true
+                description: Version number associated with the threshold
diff --git "a/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.guard.FrequencyLimiter/versions/1.0.0&\04363;connectionTimeToLive=5000/.header" "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.guard.FrequencyLimiter/versions/1.0.0&\04363;connectionTimeToLive=5000/.header"
new file mode 100644
index 0000000..6a280d9
--- /dev/null
+++ "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.guard.FrequencyLimiter/versions/1.0.0&\04363;connectionTimeToLive=5000/.header"
@@ -0,0 +1 @@
+{"Transfer-Encoding": "chunked", "Set-Cookie": "JSESSIONID=158qxkdtdobkd1umr3ikkgrmlx;Path=/", "Expires": "Thu, 01 Jan 1970 00:00:00 GMT", "Server": "Jetty(9.3.21.v20170918)", "Content-Type": "application/json", "X-ECOMP-RequestID": "e2ddb3c8-994f-47df-b4dc-097d4fb55c08"}
\ No newline at end of file
diff --git "a/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.guard.MinMax/versions/1.0.0&\04363;connectionTimeToLive=5000/.file" "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.guard.MinMax/versions/1.0.0&\04363;connectionTimeToLive=5000/.file"
new file mode 100644
index 0000000..b0119f8
--- /dev/null
+++ "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.guard.MinMax/versions/1.0.0&\04363;connectionTimeToLive=5000/.file"
@@ -0,0 +1,158 @@
+tosca_definitions_version: tosca_simple_yaml_1_0_0
+policy_types:
+    onap.policies.Monitoring:
+        derived_from: tosca.policies.Root
+        description: a base policy type for all policies that governs monitoring provisioning
+    onap.policies.monitoring.cdap.tca.hi.lo.app:
+        derived_from: onap.policies.Monitoring
+        version: 1.0.0
+        properties:
+            tca_policy:
+                type: map
+                description: TCA Policy JSON
+                entry_schema:
+                    type: onap.datatypes.monitoring.tca_policy
+data_types:
+    onap.datatypes.monitoring.metricsPerEventName:
+        derived_from: tosca.datatypes.Root
+        properties:
+            controlLoopSchemaType:
+                type: string
+                required: true
+                description: Specifies Control Loop Schema Type for the event Name e.g. VNF, VM
+                constraints:
+                  - valid_values:
+                      - VM
+                      - VNF
+            eventName:
+                type: string
+                required: true
+                description: Event name to which thresholds need to be applied
+            policyName:
+                type: string
+                required: true
+                description: TCA Policy Scope Name
+            policyScope:
+                type: string
+                required: true
+                description: TCA Policy Scope
+            policyVersion:
+                type: string
+                required: true
+                description: TCA Policy Scope Version
+            thresholds:
+                type: list
+                required: true
+                description: Thresholds associated with eventName
+                entry_schema:
+                    type: onap.datatypes.monitoring.thresholds
+    onap.datatypes.monitoring.tca_policy:
+        derived_from: tosca.datatypes.Root
+        properties:
+            domain:
+                type: string
+                required: true
+                description: Domain name to which TCA needs to be applied
+                default: measurementsForVfScaling
+                constraints:
+                  - equal: measurementsForVfScaling
+            metricsPerEventName:
+                type: list
+                required: true
+                description: Contains eventName and threshold details that need to be applied to given eventName
+                entry_schema:
+                    type: onap.datatypes.monitoring.metricsPerEventName
+    onap.datatypes.monitoring.thresholds:
+        derived_from: tosca.datatypes.Root
+        properties:
+            closedLoopControlName:
+                type: string
+                required: true
+                description: Closed Loop Control Name associated with the threshold
+            closedLoopEventStatus:
+                type: string
+                required: true
+                description: Closed Loop Event Status of the threshold
+                constraints:
+                  - valid_values:
+                      - ONSET
+                      - ABATED
+            direction:
+                type: string
+                required: true
+                description: Direction of the threshold
+                constraints:
+                  - valid_values:
+                      - LESS
+                      - LESS_OR_EQUAL
+                      - GREATER
+                      - GREATER_OR_EQUAL
+                      - EQUAL
+            fieldPath:
+                type: string
+                required: true
+                description: Json field Path as per CEF message which needs to be analyzed for TCA
+                constraints:
+                  - valid_values:
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuIdle
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageInterrupt
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageNice
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSoftIrq
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSteal
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSystem
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuWait
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].percentUsage
+                      - $.event.measurementsForVfScalingFields.meanRequestLatency
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryBuffered
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryCached
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryConfigured
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryFree
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryUsed
+                      - $.event.measurementsForVfScalingFields.additionalMeasurements[*].arrayOfFields[0].value
+            severity:
+                type: string
+                required: true
+                description: Threshold Event Severity
+                constraints:
+                  - valid_values:
+                      - CRITICAL
+                      - MAJOR
+                      - MINOR
+                      - WARNING
+                      - NORMAL
+            thresholdValue:
+                type: integer
+                required: true
+                description: Threshold value for the field Path inside CEF message
+            version:
+                type: string
+                required: true
+                description: Version number associated with the threshold
diff --git "a/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.guard.MinMax/versions/1.0.0&\04363;connectionTimeToLive=5000/.header" "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.guard.MinMax/versions/1.0.0&\04363;connectionTimeToLive=5000/.header"
new file mode 100644
index 0000000..6a280d9
--- /dev/null
+++ "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controlloop.guard.MinMax/versions/1.0.0&\04363;connectionTimeToLive=5000/.header"
@@ -0,0 +1 @@
+{"Transfer-Encoding": "chunked", "Set-Cookie": "JSESSIONID=158qxkdtdobkd1umr3ikkgrmlx;Path=/", "Expires": "Thu, 01 Jan 1970 00:00:00 GMT", "Server": "Jetty(9.3.21.v20170918)", "Content-Type": "application/json", "X-ECOMP-RequestID": "e2ddb3c8-994f-47df-b4dc-097d4fb55c08"}
\ No newline at end of file
diff --git "a/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controloop.operational.Apex/versions/1.0.0&\04363;connectionTimeToLive=5000/.file" "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controloop.operational.Apex/versions/1.0.0&\04363;connectionTimeToLive=5000/.file"
new file mode 100644
index 0000000..b0119f8
--- /dev/null
+++ "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controloop.operational.Apex/versions/1.0.0&\04363;connectionTimeToLive=5000/.file"
@@ -0,0 +1,158 @@
+tosca_definitions_version: tosca_simple_yaml_1_0_0
+policy_types:
+    onap.policies.Monitoring:
+        derived_from: tosca.policies.Root
+        description: a base policy type for all policies that governs monitoring provisioning
+    onap.policies.monitoring.cdap.tca.hi.lo.app:
+        derived_from: onap.policies.Monitoring
+        version: 1.0.0
+        properties:
+            tca_policy:
+                type: map
+                description: TCA Policy JSON
+                entry_schema:
+                    type: onap.datatypes.monitoring.tca_policy
+data_types:
+    onap.datatypes.monitoring.metricsPerEventName:
+        derived_from: tosca.datatypes.Root
+        properties:
+            controlLoopSchemaType:
+                type: string
+                required: true
+                description: Specifies Control Loop Schema Type for the event Name e.g. VNF, VM
+                constraints:
+                  - valid_values:
+                      - VM
+                      - VNF
+            eventName:
+                type: string
+                required: true
+                description: Event name to which thresholds need to be applied
+            policyName:
+                type: string
+                required: true
+                description: TCA Policy Scope Name
+            policyScope:
+                type: string
+                required: true
+                description: TCA Policy Scope
+            policyVersion:
+                type: string
+                required: true
+                description: TCA Policy Scope Version
+            thresholds:
+                type: list
+                required: true
+                description: Thresholds associated with eventName
+                entry_schema:
+                    type: onap.datatypes.monitoring.thresholds
+    onap.datatypes.monitoring.tca_policy:
+        derived_from: tosca.datatypes.Root
+        properties:
+            domain:
+                type: string
+                required: true
+                description: Domain name to which TCA needs to be applied
+                default: measurementsForVfScaling
+                constraints:
+                  - equal: measurementsForVfScaling
+            metricsPerEventName:
+                type: list
+                required: true
+                description: Contains eventName and threshold details that need to be applied to given eventName
+                entry_schema:
+                    type: onap.datatypes.monitoring.metricsPerEventName
+    onap.datatypes.monitoring.thresholds:
+        derived_from: tosca.datatypes.Root
+        properties:
+            closedLoopControlName:
+                type: string
+                required: true
+                description: Closed Loop Control Name associated with the threshold
+            closedLoopEventStatus:
+                type: string
+                required: true
+                description: Closed Loop Event Status of the threshold
+                constraints:
+                  - valid_values:
+                      - ONSET
+                      - ABATED
+            direction:
+                type: string
+                required: true
+                description: Direction of the threshold
+                constraints:
+                  - valid_values:
+                      - LESS
+                      - LESS_OR_EQUAL
+                      - GREATER
+                      - GREATER_OR_EQUAL
+                      - EQUAL
+            fieldPath:
+                type: string
+                required: true
+                description: Json field Path as per CEF message which needs to be analyzed for TCA
+                constraints:
+                  - valid_values:
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuIdle
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageInterrupt
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageNice
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSoftIrq
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSteal
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSystem
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuWait
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].percentUsage
+                      - $.event.measurementsForVfScalingFields.meanRequestLatency
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryBuffered
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryCached
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryConfigured
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryFree
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryUsed
+                      - $.event.measurementsForVfScalingFields.additionalMeasurements[*].arrayOfFields[0].value
+            severity:
+                type: string
+                required: true
+                description: Threshold Event Severity
+                constraints:
+                  - valid_values:
+                      - CRITICAL
+                      - MAJOR
+                      - MINOR
+                      - WARNING
+                      - NORMAL
+            thresholdValue:
+                type: integer
+                required: true
+                description: Threshold value for the field Path inside CEF message
+            version:
+                type: string
+                required: true
+                description: Version number associated with the threshold
diff --git "a/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controloop.operational.Apex/versions/1.0.0&\04363;connectionTimeToLive=5000/.header" "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controloop.operational.Apex/versions/1.0.0&\04363;connectionTimeToLive=5000/.header"
new file mode 100644
index 0000000..6a280d9
--- /dev/null
+++ "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controloop.operational.Apex/versions/1.0.0&\04363;connectionTimeToLive=5000/.header"
@@ -0,0 +1 @@
+{"Transfer-Encoding": "chunked", "Set-Cookie": "JSESSIONID=158qxkdtdobkd1umr3ikkgrmlx;Path=/", "Expires": "Thu, 01 Jan 1970 00:00:00 GMT", "Server": "Jetty(9.3.21.v20170918)", "Content-Type": "application/json", "X-ECOMP-RequestID": "e2ddb3c8-994f-47df-b4dc-097d4fb55c08"}
\ No newline at end of file
diff --git "a/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controloop.operational.Drools/versions/1.0.0&\04363;connectionTimeToLive=5000/.file" "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controloop.operational.Drools/versions/1.0.0&\04363;connectionTimeToLive=5000/.file"
new file mode 100644
index 0000000..b0119f8
--- /dev/null
+++ "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controloop.operational.Drools/versions/1.0.0&\04363;connectionTimeToLive=5000/.file"
@@ -0,0 +1,158 @@
+tosca_definitions_version: tosca_simple_yaml_1_0_0
+policy_types:
+    onap.policies.Monitoring:
+        derived_from: tosca.policies.Root
+        description: a base policy type for all policies that governs monitoring provisioning
+    onap.policies.monitoring.cdap.tca.hi.lo.app:
+        derived_from: onap.policies.Monitoring
+        version: 1.0.0
+        properties:
+            tca_policy:
+                type: map
+                description: TCA Policy JSON
+                entry_schema:
+                    type: onap.datatypes.monitoring.tca_policy
+data_types:
+    onap.datatypes.monitoring.metricsPerEventName:
+        derived_from: tosca.datatypes.Root
+        properties:
+            controlLoopSchemaType:
+                type: string
+                required: true
+                description: Specifies Control Loop Schema Type for the event Name e.g. VNF, VM
+                constraints:
+                  - valid_values:
+                      - VM
+                      - VNF
+            eventName:
+                type: string
+                required: true
+                description: Event name to which thresholds need to be applied
+            policyName:
+                type: string
+                required: true
+                description: TCA Policy Scope Name
+            policyScope:
+                type: string
+                required: true
+                description: TCA Policy Scope
+            policyVersion:
+                type: string
+                required: true
+                description: TCA Policy Scope Version
+            thresholds:
+                type: list
+                required: true
+                description: Thresholds associated with eventName
+                entry_schema:
+                    type: onap.datatypes.monitoring.thresholds
+    onap.datatypes.monitoring.tca_policy:
+        derived_from: tosca.datatypes.Root
+        properties:
+            domain:
+                type: string
+                required: true
+                description: Domain name to which TCA needs to be applied
+                default: measurementsForVfScaling
+                constraints:
+                  - equal: measurementsForVfScaling
+            metricsPerEventName:
+                type: list
+                required: true
+                description: Contains eventName and threshold details that need to be applied to given eventName
+                entry_schema:
+                    type: onap.datatypes.monitoring.metricsPerEventName
+    onap.datatypes.monitoring.thresholds:
+        derived_from: tosca.datatypes.Root
+        properties:
+            closedLoopControlName:
+                type: string
+                required: true
+                description: Closed Loop Control Name associated with the threshold
+            closedLoopEventStatus:
+                type: string
+                required: true
+                description: Closed Loop Event Status of the threshold
+                constraints:
+                  - valid_values:
+                      - ONSET
+                      - ABATED
+            direction:
+                type: string
+                required: true
+                description: Direction of the threshold
+                constraints:
+                  - valid_values:
+                      - LESS
+                      - LESS_OR_EQUAL
+                      - GREATER
+                      - GREATER_OR_EQUAL
+                      - EQUAL
+            fieldPath:
+                type: string
+                required: true
+                description: Json field Path as per CEF message which needs to be analyzed for TCA
+                constraints:
+                  - valid_values:
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuIdle
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageInterrupt
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageNice
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSoftIrq
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSteal
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSystem
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuWait
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].percentUsage
+                      - $.event.measurementsForVfScalingFields.meanRequestLatency
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryBuffered
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryCached
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryConfigured
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryFree
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryUsed
+                      - $.event.measurementsForVfScalingFields.additionalMeasurements[*].arrayOfFields[0].value
+            severity:
+                type: string
+                required: true
+                description: Threshold Event Severity
+                constraints:
+                  - valid_values:
+                      - CRITICAL
+                      - MAJOR
+                      - MINOR
+                      - WARNING
+                      - NORMAL
+            thresholdValue:
+                type: integer
+                required: true
+                description: Threshold value for the field Path inside CEF message
+            version:
+                type: string
+                required: true
+                description: Version number associated with the threshold
diff --git "a/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controloop.operational.Drools/versions/1.0.0&\04363;connectionTimeToLive=5000/.header" "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controloop.operational.Drools/versions/1.0.0&\04363;connectionTimeToLive=5000/.header"
new file mode 100644
index 0000000..6a280d9
--- /dev/null
+++ "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.controloop.operational.Drools/versions/1.0.0&\04363;connectionTimeToLive=5000/.header"
@@ -0,0 +1 @@
+{"Transfer-Encoding": "chunked", "Set-Cookie": "JSESSIONID=158qxkdtdobkd1umr3ikkgrmlx;Path=/", "Expires": "Thu, 01 Jan 1970 00:00:00 GMT", "Server": "Jetty(9.3.21.v20170918)", "Content-Type": "application/json", "X-ECOMP-RequestID": "e2ddb3c8-994f-47df-b4dc-097d4fb55c08"}
\ No newline at end of file
diff --git "a/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.monitoring.cdap.tca.hi.lo.app/versions/1.0.0&\04363;connectionTimeToLive=5000/.file" "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.monitoring.cdap.tca.hi.lo.app/versions/1.0.0&\04363;connectionTimeToLive=5000/.file"
new file mode 100644
index 0000000..b0119f8
--- /dev/null
+++ "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.monitoring.cdap.tca.hi.lo.app/versions/1.0.0&\04363;connectionTimeToLive=5000/.file"
@@ -0,0 +1,158 @@
+tosca_definitions_version: tosca_simple_yaml_1_0_0
+policy_types:
+    onap.policies.Monitoring:
+        derived_from: tosca.policies.Root
+        description: a base policy type for all policies that governs monitoring provisioning
+    onap.policies.monitoring.cdap.tca.hi.lo.app:
+        derived_from: onap.policies.Monitoring
+        version: 1.0.0
+        properties:
+            tca_policy:
+                type: map
+                description: TCA Policy JSON
+                entry_schema:
+                    type: onap.datatypes.monitoring.tca_policy
+data_types:
+    onap.datatypes.monitoring.metricsPerEventName:
+        derived_from: tosca.datatypes.Root
+        properties:
+            controlLoopSchemaType:
+                type: string
+                required: true
+                description: Specifies Control Loop Schema Type for the event Name e.g. VNF, VM
+                constraints:
+                  - valid_values:
+                      - VM
+                      - VNF
+            eventName:
+                type: string
+                required: true
+                description: Event name to which thresholds need to be applied
+            policyName:
+                type: string
+                required: true
+                description: TCA Policy Scope Name
+            policyScope:
+                type: string
+                required: true
+                description: TCA Policy Scope
+            policyVersion:
+                type: string
+                required: true
+                description: TCA Policy Scope Version
+            thresholds:
+                type: list
+                required: true
+                description: Thresholds associated with eventName
+                entry_schema:
+                    type: onap.datatypes.monitoring.thresholds
+    onap.datatypes.monitoring.tca_policy:
+        derived_from: tosca.datatypes.Root
+        properties:
+            domain:
+                type: string
+                required: true
+                description: Domain name to which TCA needs to be applied
+                default: measurementsForVfScaling
+                constraints:
+                  - equal: measurementsForVfScaling
+            metricsPerEventName:
+                type: list
+                required: true
+                description: Contains eventName and threshold details that need to be applied to given eventName
+                entry_schema:
+                    type: onap.datatypes.monitoring.metricsPerEventName
+    onap.datatypes.monitoring.thresholds:
+        derived_from: tosca.datatypes.Root
+        properties:
+            closedLoopControlName:
+                type: string
+                required: true
+                description: Closed Loop Control Name associated with the threshold
+            closedLoopEventStatus:
+                type: string
+                required: true
+                description: Closed Loop Event Status of the threshold
+                constraints:
+                  - valid_values:
+                      - ONSET
+                      - ABATED
+            direction:
+                type: string
+                required: true
+                description: Direction of the threshold
+                constraints:
+                  - valid_values:
+                      - LESS
+                      - LESS_OR_EQUAL
+                      - GREATER
+                      - GREATER_OR_EQUAL
+                      - EQUAL
+            fieldPath:
+                type: string
+                required: true
+                description: Json field Path as per CEF message which needs to be analyzed for TCA
+                constraints:
+                  - valid_values:
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuIdle
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageInterrupt
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageNice
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSoftIrq
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSteal
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSystem
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuWait
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].percentUsage
+                      - $.event.measurementsForVfScalingFields.meanRequestLatency
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryBuffered
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryCached
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryConfigured
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryFree
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryUsed
+                      - $.event.measurementsForVfScalingFields.additionalMeasurements[*].arrayOfFields[0].value
+            severity:
+                type: string
+                required: true
+                description: Threshold Event Severity
+                constraints:
+                  - valid_values:
+                      - CRITICAL
+                      - MAJOR
+                      - MINOR
+                      - WARNING
+                      - NORMAL
+            thresholdValue:
+                type: integer
+                required: true
+                description: Threshold value for the field Path inside CEF message
+            version:
+                type: string
+                required: true
+                description: Version number associated with the threshold
diff --git "a/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.monitoring.cdap.tca.hi.lo.app/versions/1.0.0&\04363;connectionTimeToLive=5000/.header" "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.monitoring.cdap.tca.hi.lo.app/versions/1.0.0&\04363;connectionTimeToLive=5000/.header"
new file mode 100644
index 0000000..6a280d9
--- /dev/null
+++ "b/src/test/resources/http-cache/example/policy/api/v1/policytypes/onap.policies.monitoring.cdap.tca.hi.lo.app/versions/1.0.0&\04363;connectionTimeToLive=5000/.header"
@@ -0,0 +1 @@
+{"Transfer-Encoding": "chunked", "Set-Cookie": "JSESSIONID=158qxkdtdobkd1umr3ikkgrmlx;Path=/", "Expires": "Thu, 01 Jan 1970 00:00:00 GMT", "Server": "Jetty(9.3.21.v20170918)", "Content-Type": "application/json", "X-ECOMP-RequestID": "e2ddb3c8-994f-47df-b4dc-097d4fb55c08"}
\ No newline at end of file
diff --git a/src/test/resources/http-cache/third_party_proxy.py b/src/test/resources/http-cache/third_party_proxy.py
index 79e152e..97a2a1a 100755
--- a/src/test/resources/http-cache/third_party_proxy.py
+++ b/src/test/resources/http-cache/third_party_proxy.py
@@ -237,7 +237,7 @@
         with open(cached_file_content, 'w+') as f:
                 f.write(self.data_string)
         return True
-     elif (self.path.startswith("/policy/api/v1/policytypes/") or self.path.startswith("/policy/pap/v1/policies/deployed/")) and http_type == "GET":
+     elif (self.path.startswith("/policy/pap/v1/policies/deployed/")) and http_type == "GET":
         print "self.path start with /policy/api/v1/policytypes/, generating response json..."
         jsonGenerated =  "{\"policyTypeId\": \"onap.policies.controlloop.operational\",\"policyTypeVersion\": \"1.0.0\",\"policyId\": \"OPERATIONAL_z711F_v1_0_ResourceInstanceName1_tca\"}"
         print "jsonGenerated: " + jsonGenerated
diff --git a/src/test/resources/tosca/tosca_with_metadata.yaml b/src/test/resources/tosca/tosca_with_metadata.yaml
new file mode 100644
index 0000000..5967d15
--- /dev/null
+++ b/src/test/resources/tosca/tosca_with_metadata.yaml
@@ -0,0 +1,162 @@
+tosca_definitions_version: tosca_simple_yaml_1_0_0
+policy_types:
+    onap.policies.Monitoring:
+        derived_from: tosca.policies.Root
+        description: a base policy type for all policies that governs monitoring provisioning
+    onap.policies.monitoring.cdap.tca.hi.lo.app:
+        derived_from: onap.policies.Monitoring
+        version: 1.0.0
+        properties:
+            tca_policy:
+                type: map
+                description: TCA Policy JSON
+                entry_schema:
+                    type: onap.datatypes.monitoring.tca_policy
+        metadata:
+            policy_model_type: onap.policies.monitoring.cdap.tca.hi.lo.app
+            acronym: tca
+            
+data_types:
+    onap.datatypes.monitoring.metricsPerEventName:
+        derived_from: tosca.datatypes.Root
+        properties:
+            controlLoopSchemaType:
+                type: string
+                required: true
+                description: Specifies Control Loop Schema Type for the event Name e.g. VNF, VM
+                constraints:
+                  - valid_values:
+                      - VM
+                      - VNF
+            eventName:
+                type: string
+                required: true
+                description: Event name to which thresholds need to be applied
+            policyName:
+                type: string
+                required: true
+                description: TCA Policy Scope Name
+            policyScope:
+                type: string
+                required: true
+                description: TCA Policy Scope
+            policyVersion:
+                type: string
+                required: true
+                description: TCA Policy Scope Version
+            thresholds:
+                type: list
+                required: true
+                description: Thresholds associated with eventName
+                entry_schema:
+                    type: onap.datatypes.monitoring.thresholds
+    onap.datatypes.monitoring.tca_policy:
+        derived_from: tosca.datatypes.Root
+        properties:
+            domain:
+                type: string
+                required: true
+                description: Domain name to which TCA needs to be applied
+                default: measurementsForVfScaling
+                constraints:
+                  - equal: measurementsForVfScaling
+            metricsPerEventName:
+                type: list
+                required: true
+                description: Contains eventName and threshold details that need to be applied to given eventName
+                entry_schema:
+                    type: onap.datatypes.monitoring.metricsPerEventName
+    onap.datatypes.monitoring.thresholds:
+        derived_from: tosca.datatypes.Root
+        properties:
+            closedLoopControlName:
+                type: string
+                required: true
+                description: Closed Loop Control Name associated with the threshold
+            closedLoopEventStatus:
+                type: string
+                required: true
+                description: Closed Loop Event Status of the threshold
+                constraints:
+                  - valid_values:
+                      - ONSET
+                      - ABATED
+            direction:
+                type: string
+                required: true
+                description: Direction of the threshold
+                constraints:
+                  - valid_values:
+                      - LESS
+                      - LESS_OR_EQUAL
+                      - GREATER
+                      - GREATER_OR_EQUAL
+                      - EQUAL
+            fieldPath:
+                type: string
+                required: true
+                description: Json field Path as per CEF message which needs to be analyzed for TCA
+                constraints:
+                  - valid_values:
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedTotalPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedOctetsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedUnicastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedMulticastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedBroadcastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedDiscardedPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].receivedErrorPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsDelta
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedTotalPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedOctetsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedUnicastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedMulticastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedBroadcastPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedDiscardedPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.vNicPerformanceArray[*].transmittedErrorPacketsAccumulated
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuIdle
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageInterrupt
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageNice
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSoftIrq
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSteal
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuUsageSystem
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].cpuWait
+                      - $.event.measurementsForVfScalingFields.cpuUsageArray[*].percentUsage
+                      - $.event.measurementsForVfScalingFields.meanRequestLatency
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryBuffered
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryCached
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryConfigured
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryFree
+                      - $.event.measurementsForVfScalingFields.memoryUsageArray[*].memoryUsed
+                      - $.event.measurementsForVfScalingFields.additionalMeasurements[*].arrayOfFields[0].value
+            severity:
+                type: string
+                required: true
+                description: Threshold Event Severity
+                constraints:
+                  - valid_values:
+                      - CRITICAL
+                      - MAJOR
+                      - MINOR
+                      - WARNING
+                      - NORMAL
+            thresholdValue:
+                type: integer
+                required: true
+                description: Threshold value for the field Path inside CEF message
+            version:
+                type: string
+                required: true
+                description: Version number associated with the threshold
diff --git a/ui-react-lib/libIndex.js b/ui-react-lib/libIndex.js
index 89bf831..20dc074 100755
--- a/ui-react-lib/libIndex.js
+++ b/ui-react-lib/libIndex.js
@@ -22,6 +22,7 @@
  */
 
 export { default as ConfigurationPolicyModal } from './src/components/dialogs/ConfigurationPolicy/ConfigurationPolicyModal';
+export { default as PolicyModal } from './src/components/dialogs/Policy/PolicyModal';
 export { default as DeployLoopModal } from './src/components/dialogs/Loop/DeployLoopModal';
 export { default as LoopActionService } from './src/api/LoopActionService';
 export { default as LoopCache }  from './src/api/LoopCache';
@@ -35,6 +36,7 @@
 export { default as MenuBar } from './src/components/menu/MenuBar';
 export { default as NotFound } from './src/NotFound';
 export { default as OpenLoopModal } from './src/components/dialogs/Loop/OpenLoopModal';
+export { default as CreateLoopModal } from './src/components/dialogs/Loop/CreateLoopModal';
 export { default as OperationalPolicyModal } from './src/components/dialogs/OperationalPolicy/OperationalPolicyModal';
 export { default as PerformActions } from './src/components/dialogs/PerformActions';
 export { default as RefreshStatus } from './src/components/dialogs/RefreshStatus';
diff --git a/ui-react/src/api/LoopCache.js b/ui-react/src/api/LoopCache.js
index b177230..03cec9f 100644
--- a/ui-react/src/api/LoopCache.js
+++ b/ui-react/src/api/LoopCache.js
@@ -31,7 +31,7 @@
 	updateMicroServiceProperties(name, newMsProperties) {
 			for (var policy in this.loopJsonCache["microServicePolicies"]) {
 				if (this.loopJsonCache["microServicePolicies"][policy]["name"] === name) {
-					this.loopJsonCache["microServicePolicies"][policy]["properties"] = newMsProperties;
+					this.loopJsonCache["microServicePolicies"][policy]["configurationsJson"] = newMsProperties;
 				}
 			}
 	}
@@ -91,7 +91,7 @@
 	getOperationalPolicyPropertiesForName(name) {
 		var opConfig = this.getOperationalPolicyForName(name);
 		if (opConfig !== null) {
-			return opConfig["properties"];
+			return opConfig["configurationsJson"];
 		}
 		return null;
 	}
@@ -118,7 +118,7 @@
 	getMicroServicePropertiesForName(name) {
 		var msConfig = this.getMicroServiceForName(name);
 		if (msConfig !== null) {
-			return msConfig["properties"];
+			return msConfig["configurationsJson"];
 		}
 		return null;
 	}
diff --git a/ui-react/src/api/LoopCache.test.js b/ui-react/src/api/LoopCache.test.js
index 471fa4d..97c09fa 100644
--- a/ui-react/src/api/LoopCache.test.js
+++ b/ui-react/src/api/LoopCache.test.js
@@ -103,7 +103,7 @@
       const msJson = {
           "name": "TCA_h2NMX_v1_0_ResourceInstanceName1_tca",
           "modelType": "onap.policies.monitoring.cdap.tca.hi.lo.app",
-          "properties": {"domain": "measurementsForVfScaling"},
+          "configurationsJson": {"domain": "measurementsForVfScaling"},
           "shared": false,
           "jsonRepresentation": {"schema": {}}
       };
diff --git a/ui-react/src/api/LoopCache_mokeLoopJsonCache.json b/ui-react/src/api/LoopCache_mokeLoopJsonCache.json
index 087ab5d..23ea354 100644
--- a/ui-react/src/api/LoopCache_mokeLoopJsonCache.json
+++ b/ui-react/src/api/LoopCache_mokeLoopJsonCache.json
@@ -103,7 +103,7 @@
     {
       "name": "TCA_h2NMX_v1_0_ResourceInstanceName1_tca",
       "modelType": "onap.policies.monitoring.cdap.tca.hi.lo.app",
-      "properties": {"domain": "measurementsForVfScaling"},
+      "configurationsJson": {"domain": "measurementsForVfScaling"},
       "shared": false,
       "jsonRepresentation": {"schema": {}}
     }
diff --git a/ui-react/src/api/PolicyToscaService.js b/ui-react/src/api/PolicyToscaService.js
index 52e68fa..610a114 100644
--- a/ui-react/src/api/PolicyToscaService.js
+++ b/ui-react/src/api/PolicyToscaService.js
@@ -78,8 +78,8 @@
  			});
   }
 
-  static createPolicyModelFromToscaModel(policyModelType, jsonData) {
-       return fetch('/restservices/clds/v2/policyToscaModels/' + policyModelType, {
+  static createPolicyModelFromToscaModel(jsonData) {
+       return fetch('/restservices/clds/v2/policyToscaModels', {
            method: 'POST',
            credentials: 'same-origin',
            headers: {
diff --git a/ui-react/src/components/dialogs/Tosca/UploadToscaPolicyModal.js b/ui-react/src/components/dialogs/Tosca/UploadToscaPolicyModal.js
index 2e0460f..1937485 100644
--- a/ui-react/src/components/dialogs/Tosca/UploadToscaPolicyModal.js
+++ b/ui-react/src/components/dialogs/Tosca/UploadToscaPolicyModal.js
@@ -39,12 +39,10 @@
 
 		this.handleCreateFromToscaPolicyModel = this.handleCreateFromToscaPolicyModel.bind(this);
 		this.handleClose = this.handleClose.bind(this);
-		this.handlePolicyModelType = this.handlePolicyModelType.bind(this);
 		this.fileSelectedHandler = this.fileSelectedHandler.bind(this);
 		this.state = {
 				show: true,
 				selectedFile: '',
-				policyModelType: '',
 				policyModelTosca: [],
 				apiResponseStatus: '',
 				apiResponseMessage: '',
@@ -56,7 +54,7 @@
 				if (event.target.files && event.target.files[0]) {
 					const scope = this;
   				    let reader = new FileReader();
-					this.setState({policyModelType: '', policyModelTosca: '' });
+					this.setState({policyModelTosca: '' });
 					reader.onload = function(e) {
 					    scope.setState({ policyModelTosca:  reader.result});
 					};
@@ -73,9 +71,8 @@
 
 	handleCreateFromToscaPolicyModel(e) {
         e.preventDefault();
-		console.log("Policy Model Type is", this.state.policyModelType);
-		if(this.state.policyModelType && this.state.policyModelTosca) {
- 		PolicyToscaService.createPolicyModelFromToscaModel(this.state.policyModelType, this.state.policyModelTosca).then(resp => {
+		if(this.state.policyModelTosca) {
+ 		PolicyToscaService.createPolicyModelFromToscaModel(this.state.policyModelTosca).then(resp => {
 			if(resp.status === 200) {
 			this.setState({apiResponseStatus: resp.status, apiResponseMessage: resp.message, upldBtnClicked: true});
 		} else {
@@ -87,12 +84,6 @@
 	}
 }
 
-	handlePolicyModelType = event => {
-    this.setState({
-      policyModelType: event.target.value
-    })
-  }
-
 	render() {
 		return (
 			<ModalStyled size="lg" show={this.state.show} onHide={this.handleClose}>
@@ -108,11 +99,6 @@
 							<Alert variant="secondary">
 								<p>{this.state.selectedFile.name}</p>
 							</Alert>
-							<Form.Label column sm="2">Policy Model Type:</Form.Label>
-							<input type="text" style={{width: '50%'}}
-								value={this.state.policyModelType}
-								onChange={this.handlePolicyModelType}
-							/>
 						</Col>
 					</Form.Group>
 				</Modal.Body>
diff --git a/ui-react/src/components/dialogs/Tosca/UploadToscaPolicyModal.test.js b/ui-react/src/components/dialogs/Tosca/UploadToscaPolicyModal.test.js
index dac8ac9..e484206 100644
--- a/ui-react/src/components/dialogs/Tosca/UploadToscaPolicyModal.test.js
+++ b/ui-react/src/components/dialogs/Tosca/UploadToscaPolicyModal.test.js
@@ -27,22 +27,6 @@
 
 describe('Test Upload Tosca Policy Model', () => {
 
-      it('Test handleMicroServiceName', () => {
-
-      const component = shallow(<UploadToscaPolicyModal />);
-
-        const inputValue = 'TCA'
-
-        const button = component.find('input').at(1);
-
-        button.simulate('change', { target: { value: inputValue }});
-
-        expect(component.state('policyModelType')).toEqual(inputValue);
-
-        expect(component).toMatchSnapshot();
-
-    });
-
     it('Test handleUploadToscaPolicyModel for Tosca Model', () => {
 
       const component = shallow(<UploadToscaPolicyModal />);
diff --git a/ui-react/src/components/dialogs/Tosca/__snapshots__/UploadToscaPolicyModal.test.js.snap b/ui-react/src/components/dialogs/Tosca/__snapshots__/UploadToscaPolicyModal.test.js.snap
deleted file mode 100644
index 8e80136..0000000
--- a/ui-react/src/components/dialogs/Tosca/__snapshots__/UploadToscaPolicyModal.test.js.snap
+++ /dev/null
@@ -1,111 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`Test Upload Tosca Policy Model Test handleMicroServiceName 1`] = `
-<Styled(Bootstrap(Modal))
-  onHide={[Function]}
-  show={true}
-  size="lg"
->
-  <ModalHeader
-    closeButton={true}
-    closeLabel="Close"
-  >
-    <ModalTitle>
-      Upload Tosca Model
-    </ModalTitle>
-  </ModalHeader>
-  <ModalBody>
-    <FormGroup
-      as={
-        Object {
-          "$$typeof": Symbol(react.forward_ref),
-          "defaultProps": Object {
-            "noGutters": false,
-          },
-          "render": [Function],
-        }
-      }
-      controlId="formPlaintextEmail"
-    >
-      <Col
-        sm="10"
-      >
-        <input
-          accept=".yaml"
-          name="file"
-          onChange={[Function]}
-          style={
-            Object {
-              "display": "none",
-            }
-          }
-          type="file"
-        />
-        <button
-          onClick={[Function]}
-        >
-          Pick Tosca File
-        </button>
-        <Alert
-          closeLabel="Close alert"
-          show={true}
-          transition={
-            Object {
-              "$$typeof": Symbol(react.forward_ref),
-              "defaultProps": Object {
-                "appear": false,
-                "in": false,
-                "mountOnEnter": false,
-                "timeout": 300,
-                "unmountOnExit": false,
-              },
-              "displayName": "Fade",
-              "render": [Function],
-            }
-          }
-          variant="secondary"
-        >
-          <p />
-        </Alert>
-        <FormLabel
-          column={true}
-          sm="2"
-          srOnly={false}
-        >
-          Policy Model Type:
-        </FormLabel>
-        <input
-          onChange={[Function]}
-          style={
-            Object {
-              "width": "50%",
-            }
-          }
-          type="text"
-          value="TCA"
-        />
-      </Col>
-    </FormGroup>
-  </ModalBody>
-  <ModalFooter>
-    <Button
-      active={false}
-      disabled={false}
-      onClick={[Function]}
-      type="null"
-      variant="secondary"
-    >
-      Cancel
-    </Button>
-    <Button
-      active={false}
-      disabled={true}
-      onClick={[Function]}
-      type="submit"
-      variant="primary"
-    >
-      Create
-    </Button>
-  </ModalFooter>
-</Styled(Bootstrap(Modal))>
-`;
diff --git a/ui-react/src/components/menu/MenuBar.js b/ui-react/src/components/menu/MenuBar.js
index 2f13cfe..92380ab 100644
--- a/ui-react/src/components/menu/MenuBar.js
+++ b/ui-react/src/components/menu/MenuBar.js
@@ -107,6 +107,7 @@
 							<NavDropdown.Item as={StyledLink} to="/stop" disabled={this.state.disabled}>Undeploy from Policy Engine (STOP)</NavDropdown.Item>
 							<NavDropdown.Item as={StyledLink} to="/restart" disabled={this.state.disabled}>ReDeploy to Policy Engine (RESTART)</NavDropdown.Item>
 							<NavDropdown.Item as={StyledLink} to="/delete" disabled={this.state.disabled}>Delete loop instance (DELETE)</NavDropdown.Item>
+							<NavDropdown.Divider />
 							<NavDropdown.Item as={StyledLink} to="/deploy" disabled={this.state.disabled}>Deploy to DCAE (DEPLOY)</NavDropdown.Item>
 							<NavDropdown.Item as={StyledLink} to="/undeploy" disabled={this.state.disabled}>UnDeploy to DCAE (UNDEPLOY)</NavDropdown.Item>
 					</StyledNavDropdown>
diff --git a/ui-react/src/components/menu/__snapshots__/MenuBar.test.js.snap b/ui-react/src/components/menu/__snapshots__/MenuBar.test.js.snap
index 63d3f65..dfc6a56 100644
--- a/ui-react/src/components/menu/__snapshots__/MenuBar.test.js.snap
+++ b/ui-react/src/components/menu/__snapshots__/MenuBar.test.js.snap
@@ -680,6 +680,9 @@
     >
       Delete loop instance (DELETE)
     </DropdownItem>
+    <DropdownDivider
+      role="separator"
+    />
     <DropdownItem
       as={
         Object {
