diff --git a/catalog-fe/pom.xml b/catalog-fe/pom.xml
index 3518779..a3acabb 100644
--- a/catalog-fe/pom.xml
+++ b/catalog-fe/pom.xml
@@ -5,387 +5,306 @@
 	<artifactId>catalog-fe</artifactId>
 	<packaging>war</packaging>
 
-
-
 	<parent>
 		<groupId>org.openecomp.sdc</groupId>
 		<artifactId>sdc-main</artifactId>
 		<version>1.1.0-SNAPSHOT</version>
 	</parent>
 
-
-
 	<dependencies>
 
 		<dependency>
-			<groupId>junit</groupId>
-			<artifactId>junit</artifactId>
-			<version>4.12</version>
-			<scope>test</scope>
-		</dependency>
-
-		<dependency>
-			<groupId>org.testng</groupId>
-			<artifactId>testng</artifactId>
-			<version>6.9.10</version>
-			<scope>test</scope>
-		</dependency>
-
-		<dependency>
-			<groupId>org.springframework</groupId>
-			<artifactId>spring-core</artifactId>
-			<version>${spring.version}</version>
-			<scope>provided</scope>
-		</dependency>
-
-		<dependency>
-			<groupId>org.springframework</groupId>
-			<artifactId>spring-beans</artifactId>
-			<version>${spring.version}</version>
-			<scope>provided</scope>
-		</dependency>
-
-		<dependency>
-			<groupId>org.springframework</groupId>
-			<artifactId>spring-context</artifactId>
-			<version>${spring.version}</version>
-			<scope>provided</scope>
-		</dependency>
-
-		<dependency>
-			<groupId>org.springframework</groupId>
-			<artifactId>spring-context-support</artifactId>
-			<version>${spring.version}</version>
-			<scope>provided</scope>
-		</dependency>
-
-		<dependency>
-			<groupId>org.springframework</groupId>
-			<artifactId>spring-messaging</artifactId>
-			<version>${spring.version}</version>
-			<scope>provided</scope>
-		</dependency>
-
-		<dependency>
-			<groupId>org.springframework</groupId>
-			<artifactId>spring-web</artifactId>
-			<version>${spring.version}</version>
-			<scope>provided</scope>
-		</dependency>
-
-		<dependency>
-			<groupId>org.springframework</groupId>
-			<artifactId>spring-webmvc</artifactId>
-			<version>${spring.version}</version>
-			<scope>provided</scope>
-		</dependency>
-
-		<dependency>
-			<groupId>org.springframework</groupId>
-			<artifactId>spring-aop</artifactId>
-			<version>${spring.version}</version>
-			<scope>provided</scope>
-		</dependency>
-
-		<dependency>
-			<groupId>org.springframework</groupId>
-			<artifactId>spring-aspects</artifactId>
-			<version>${spring.version}</version>
-			<scope>provided</scope>
-		</dependency>
-
-		<dependency>
-			<groupId>org.springframework</groupId>
-			<artifactId>spring-expression</artifactId>
-			<version>${spring.version}</version>
-			<scope>test</scope>
-		</dependency>
-
-
-		<dependency>
 			<groupId>org.functionaljava</groupId>
 			<artifactId>functionaljava</artifactId>
+			<version>${functionaljava.version}</version>
 			<scope>compile</scope>
 		</dependency>
-		
+
 		<dependency>
 			<groupId>org.openecomp.sdc</groupId>
 			<artifactId>security-utils</artifactId>
-			<version>${security-utils.version}</version>
-			<scope>compile</scope>        </dependency>
+			<version>${project.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>org.openecomp.sdc</groupId>
-				<artifactId>common-app-api</artifactId>
-				<version>${common-app-api.version}</version>
-			</dependency>
+		<dependency>
+			<groupId>org.openecomp.sdc</groupId>
+			<artifactId>common-app-api</artifactId>
+			<version>${project.version}</version>
+		</dependency>
 
-			<!-- File changes listener -->
-			<dependency>
-				<groupId>org.slf4j</groupId>
-				<artifactId>slf4j-api</artifactId>
-				<version>1.7.10</version>
-				<scope>compile</scope>
-			</dependency>
+		<!-- File changes listener -->
+		<dependency>
+			<groupId>org.slf4j</groupId>
+			<artifactId>slf4j-api</artifactId>
+			<version>${slf4j-api.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>ch.qos.logback</groupId>
-				<artifactId>logback-classic</artifactId>
-				<version>${logback.version}</version>
-				<scope>compile</scope>
-			</dependency>
+		<dependency>
+			<groupId>ch.qos.logback</groupId>
+			<artifactId>logback-classic</artifactId>
+            <version>${logback.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>ch.qos.logback</groupId>
-				<artifactId>logback-core</artifactId>
-				<version>${logback.version}</version>
-				<scope>compile</scope>
-			</dependency>
-			
-			<dependency>
-				<groupId>org.codehaus.groovy</groupId>
-				<artifactId>groovy-all</artifactId>
-				<version>${groovy.version}</version>
-				<scope>compile</scope>
-			</dependency>
-			
-			<dependency>
-				<groupId>org.codehaus.janino</groupId>
-				<artifactId>janino</artifactId>
-				<version>${janino.version}</version>
-				<scope>compile</scope>
-			</dependency>
+		<dependency>
+			<groupId>ch.qos.logback</groupId>
+			<artifactId>logback-core</artifactId>
+            <version>${logback.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>org.yaml</groupId>
-				<artifactId>snakeyaml</artifactId>
-				<version>1.14</version>
-				<scope>compile</scope>
-			</dependency>
+		<dependency>
+			<groupId>org.codehaus.groovy</groupId>
+			<artifactId>groovy-all</artifactId>
+			<version>${groovy.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>org.apache.commons</groupId>
-				<artifactId>commons-jci-core</artifactId>
-				<scope>compile</scope>
-			</dependency>
+		<dependency>
+			<groupId>org.codehaus.janino</groupId>
+			<artifactId>janino</artifactId>
+			<version>${janino.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>com.google.code.gson</groupId>
-				<artifactId>gson</artifactId>
-				<version>2.3.1</version>
-				<scope>compile</scope>
-			</dependency>
+		<dependency>
+			<groupId>org.yaml</groupId>
+			<artifactId>snakeyaml</artifactId>
+			<version>${snakeyaml.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>org.glassfish.jersey.containers</groupId>
-				<artifactId>jersey-container-servlet</artifactId>
-				<version>2.24</version>
-				<scope>compile</scope>
-			</dependency>
+		<dependency>
+			<groupId>org.apache.commons</groupId>
+			<artifactId>commons-jci-core</artifactId>
+			<version>${commons-jci-core.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>org.glassfish.jersey.media</groupId>
-				<artifactId>jersey-media-multipart</artifactId>
-				<scope>compile</scope>
-			</dependency>
+		<dependency>
+			<groupId>com.google.code.gson</groupId>
+			<artifactId>gson</artifactId>
+			<version>${gson.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>org.glassfish.jersey.media</groupId>
-				<artifactId>jersey-media-moxy</artifactId>
-				<scope>compile</scope>
-			</dependency>
+		<dependency>
+			<groupId>org.glassfish.jersey.containers</groupId>
+			<artifactId>jersey-container-servlet</artifactId>
+            <version>${jersey-bom.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>javax.mail</groupId>
-				<artifactId>javax.mail-api</artifactId>
-				<version>1.5.2</version>
-				<scope>compile</scope>
-			</dependency>
+		<dependency>
+			<groupId>org.glassfish.jersey.media</groupId>
+			<artifactId>jersey-media-multipart</artifactId>
+			<version>${jersey-bom.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>org.glassfish.jersey.media</groupId>
-				<artifactId>jersey-media-json-jackson</artifactId>
-				<scope>compile</scope>
-			</dependency>
+		<dependency>
+			<groupId>org.glassfish.jersey.media</groupId>
+			<artifactId>jersey-media-moxy</artifactId>
+			<version>${jersey-bom.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>com.fasterxml.jackson.core</groupId>
-				<artifactId>jackson-core</artifactId>
-				<version>${jackson.version}</version>
-				<scope>compile</scope>
-			</dependency>
+		<dependency>
+			<groupId>javax.mail</groupId>
+			<artifactId>javax.mail-api</artifactId>
+			<version>1.5.2</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>com.fasterxml.jackson.core</groupId>
-				<artifactId>jackson-databind</artifactId>
-				<version>${jackson.version}</version>
-				<scope>compile</scope>
-			</dependency>
+		<dependency>
+			<groupId>org.glassfish.jersey.media</groupId>
+			<artifactId>jersey-media-json-jackson</artifactId>
+			<version>${jersey-bom.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>com.fasterxml.jackson.core</groupId>
-				<artifactId>jackson-annotations</artifactId>
-				<version>${jackson.version}</version>
-				<scope>compile</scope>
-			</dependency>
+		<dependency>
+			<groupId>com.fasterxml.jackson.core</groupId>
+			<artifactId>jackson-core</artifactId>
+			<version>${jackson.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<!-- http client -->
-			<dependency>
-				<groupId>org.apache.httpcomponents</groupId>
-				<artifactId>httpclient</artifactId>
-				<version>${httpclient.version}</version>
-				<scope>compile</scope>
-			</dependency>
+		<dependency>
+			<groupId>com.fasterxml.jackson.core</groupId>
+			<artifactId>jackson-databind</artifactId>
+			<version>${jackson.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>org.apache.httpcomponents</groupId>
-				<artifactId>httpcore</artifactId>
-				<version>${httpcore.version}</version>
-				<scope>compile</scope>
-			</dependency>
+		<dependency>
+			<groupId>com.fasterxml.jackson.core</groupId>
+			<artifactId>jackson-annotations</artifactId>
+			<version>${jackson.annotations.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>org.apache.httpcomponents</groupId>
-				<artifactId>httpmime</artifactId>
-				<!--<version>4.3.2</version>-->
-				<version>${httpclient.version}</version>
-				<scope>compile</scope>
-			</dependency>
+		<!-- http client -->
+		<dependency>
+			<groupId>org.apache.httpcomponents</groupId>
+			<artifactId>httpclient</artifactId>
+            <version>${httpclient.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>commons-logging</groupId>
-				<artifactId>commons-logging</artifactId>
-				<version>1.2.1-SNAPSHOT</version>
-				<scope>compile</scope>
-			</dependency>
+		<dependency>
+			<groupId>org.apache.httpcomponents</groupId>
+			<artifactId>httpcore</artifactId>
+            <version>${httpcore.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>commons-codec</groupId>
-				<artifactId>commons-codec</artifactId>
-				<version>2.0-SNAPSHOT</version>
-				<scope>compile</scope>
-			</dependency>
-			<!-- http client END -->
+		<dependency>
+			<groupId>org.apache.httpcomponents</groupId>
+			<artifactId>httpmime</artifactId>
+            <version>${httpclient.version}</version>
+			<!--<version>4.3.2</version>-->
+			<scope>compile</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>javax.servlet</groupId>
-				<artifactId>servlet-api</artifactId>
-				<scope>provided</scope>
-			</dependency>
+		<dependency>
+			<groupId>commons-logging</groupId>
+			<artifactId>commons-logging</artifactId>
+			<version>${commons-logging}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<!-- JSON and YAML Parsing -->
-			<dependency>
-				<groupId>com.fasterxml.jackson.dataformat</groupId>
-				<artifactId>jackson-dataformat-yaml</artifactId>
-				<version>${jackson.version}</version>
-				<scope>compile</scope>
-			</dependency>
+		<dependency>
+			<groupId>commons-codec</groupId>
+			<artifactId>commons-codec</artifactId>
+            <version>${commons-codec}</version>
+			<scope>compile</scope>
+		</dependency>
+		<!-- http client END -->
 
-			<!-- Jetty Proxy -->
-			<dependency>
-				<groupId>org.eclipse.jetty</groupId>
-				<artifactId>jetty-proxy</artifactId>
-				<version>${jetty.version}</version>
-				<scope>compile</scope>
-			</dependency>
+		<dependency>
+			<groupId>javax.servlet</groupId>
+			<artifactId>servlet-api</artifactId>
+            <version>${servlet-api.version}</version>
+			<scope>provided</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>org.eclipse.jetty</groupId>
-				<artifactId>jetty-servlets</artifactId>
-				<version>${jetty.servlets.version}</version>
-				<scope>compile</scope>
-			</dependency>
+		<!-- JSON and YAML Parsing -->
+		<dependency>
+			<groupId>com.fasterxml.jackson.dataformat</groupId>
+			<artifactId>jackson-dataformat-yaml</artifactId>
+			<version>${jackson.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<!-- Proxy servlet -->
-			<dependency>
-				<groupId>com.google.guava</groupId>
-				<artifactId>guava</artifactId>
-				<version>${guava.version}</version>
-				<scope>compile</scope>
-			</dependency>
-			
-			<!-- Aspects -->
-			<dependency>
-				<groupId>com.jcabi</groupId>
-				<artifactId>jcabi-aspects</artifactId>
-				<scope>compile</scope>
-			</dependency>
-			<dependency>
-				<groupId>org.aspectj</groupId>
-				<artifactId>aspectjrt</artifactId>
-				<version>${aspectjrt.version}</version>
-				<scope>compile</scope>
-			</dependency>
-			<dependency>
-				<groupId>org.apache.commons</groupId>
-				<artifactId>commons-lang3</artifactId>
-				<version>${lang3.version}</version>
-				<scope>compile</scope>
-			</dependency>
-			
-			<!-- Inserted for ECOMP Portal Integration -->
-			<dependency>
-				<groupId>org.openecomp.ecompsdkos</groupId>
-				<artifactId>ecompFW</artifactId>
-				<version>${ecomp.version}</version>
-				<scope>compile</scope>
-				<exclusions>
-					<exclusion>
-						<groupId>com.att.nsa</groupId>
-						<artifactId>cambriaClient</artifactId>
-					</exclusion>
-					<exclusion>
-						<artifactId>slf4j-log4j12</artifactId>
-						<groupId>org.slf4j</groupId>
-					</exclusion>
-				</exclusions>
-			</dependency>
+		<!-- Jetty Proxy -->
+		<dependency>
+			<groupId>org.eclipse.jetty</groupId>
+			<artifactId>jetty-proxy</artifactId>
+			<version>${jetty.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<!-- TEST -->
-			<dependency>
-				<groupId>org.glassfish.jersey.test-framework.providers</groupId>
-				<artifactId>jersey-test-framework-provider-bundle</artifactId>
-				<type>pom</type>
-				<scope>test</scope>
-			</dependency>
+		<dependency>
+			<groupId>org.eclipse.jetty</groupId>
+			<artifactId>jetty-servlets</artifactId>
+			<version>${jetty.version}</version>
+			<scope>provided</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>org.eclipse.jetty</groupId>
-				<artifactId>jetty-servlet</artifactId>
-				<scope>test</scope>
-			</dependency>
+		<!-- Proxy servlet -->
+		<dependency>
+			<groupId>com.google.guava</groupId>
+			<artifactId>guava</artifactId>
+            <version>${guava.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>org.eclipse.jetty</groupId>
-				<artifactId>jetty-webapp</artifactId>
-				<scope>test</scope>
-			</dependency>
+		<!-- Aspects -->
+		<dependency>
+			<groupId>com.jcabi</groupId>
+			<artifactId>jcabi-aspects</artifactId>
+			<version>${jcabi.version}</version>
+			<scope>compile</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.aspectj</groupId>
+			<artifactId>aspectjrt</artifactId>
+			<version>${aspectjrt.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>org.mockito</groupId>
-				<artifactId>mockito-all</artifactId>
-				<version>1.10.19</version>
-				<scope>test</scope>
-			</dependency>
+		<dependency>
+			<groupId>org.apache.commons</groupId>
+			<artifactId>commons-lang3</artifactId>
+            <version>${lang3.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
-			<dependency>
-				<groupId>org.springframework</groupId>
-				<artifactId>spring-test</artifactId>
-				<version>${spring.version}</version>
-				<scope>test</scope>
-			</dependency>
-		</dependencies>
+		<!-- Inserted for ECOMP Portal Integration -->
+		<dependency>
+			<groupId>org.openecomp.ecompsdkos</groupId>
+			<artifactId>ecompFW</artifactId>
+			<version>${ecomp.version}</version>
+			<scope>compile</scope>
+			<exclusions>
+				<exclusion>
+					<groupId>com.att.nsa</groupId>
+					<artifactId>cambriaClient</artifactId>
+				</exclusion>
+				<exclusion>
+					<artifactId>slf4j-log4j12</artifactId>
+					<groupId>org.slf4j</groupId>
+				</exclusion>
+			</exclusions>
+		</dependency>
+		<!-- System metrics -->
+		<dependency>
+			<groupId>org.fusesource</groupId>
+			<artifactId>sigar</artifactId>
+			<version>${sigar.version}</version>
+			<scope>compile</scope>
+		</dependency>
 
+		<!-- TEST -->
+		<dependency>
+			<groupId>org.glassfish.jersey.test-framework.providers</groupId>
+			<artifactId>jersey-test-framework-provider-bundle</artifactId>
+			<version>${jersey-bom.version}</version>
+			<type>pom</type>
+			<scope>test</scope>
+		</dependency>
 
+		<dependency>
+			<groupId>org.eclipse.jetty</groupId>
+			<artifactId>jetty-servlet</artifactId>
+            <version>${jetty.version}</version>
+			<scope>test</scope>
+		</dependency>
 
+		<dependency>
+			<groupId>org.eclipse.jetty</groupId>
+			<artifactId>jetty-webapp</artifactId>
+            <version>${jetty.version}</version>
+			<scope>test</scope>
+		</dependency>
 
+		<dependency>
+			<groupId>org.mockito</groupId>
+			<artifactId>mockito-all</artifactId>
+			<version>${mockito.version}</version>
+			<scope>test</scope>
+		</dependency>
 
-		<build>
+	</dependencies>
 
-			<finalName>${project.artifactId}-${project.version}</finalName>
+	<build>
 
-			<plugins>
-				
+		<finalName>${project.artifactId}-${project.version}</finalName>
+
+		<plugins>
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-war-plugin</artifactId>
@@ -396,7 +315,7 @@
 							<addDefaultImplementationEntries>true</addDefaultImplementationEntries>
 						</manifest>
 					</archive>
-					
+
 					<webResources>
 						<resource>
 							<directory>src/main/resources</directory>
@@ -405,8 +324,6 @@
 				</configuration>
 			</plugin>
 
-
-
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-dependency-plugin</artifactId>
@@ -439,16 +356,14 @@
 							<outputDirectory>${project.parent.basedir}/sdc-os-chef/sdc-frontend/</outputDirectory>
 						</configuration>
 					</execution>
-
 				</executions>
 			</plugin>
 
-
-
 			<plugin>
 				<groupId>org.eclipse.jetty</groupId>
 				<artifactId>jetty-maven-plugin</artifactId>
-				<version>9.0.6.v20130930</version>
+                <version>${jetty.version}</version>
+				<!--<version>9.0.6.v20130930</version>-->
 				<configuration>
 					<contextPath>/</contextPath>
 					<webApp>
@@ -463,6 +378,9 @@
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-deploy-plugin</artifactId>
 				<version>2.7</version>
+				<configuration>
+					<skip>true</skip>
+				</configuration>
 			</plugin>
 
 			<plugin>
@@ -477,36 +395,12 @@
 					</execution>
 				</executions>
 			</plugin>
-            		<!-- ============================================= -->
-					<!-- Create the TAR file -->
-					<!-- ============================================= -->
-					<plugin>
-						<groupId>org.apache.maven.plugins</groupId>
-						<artifactId>maven-assembly-plugin</artifactId>
-						<version>2.6</version>
-						<configuration>
-							<finalName>${project.artifactId}-${full.release.version}${build.type}</finalName>
-							<appendAssemblyId>false</appendAssemblyId>
-							<descriptor>${project.basedir}/tarball.xml</descriptor>
-						</configuration>
-						
-						<executions>
-							<execution>
-								<id>assembly-tar-file</id>
-								<phase>package</phase>
-								<goals>
-									<goal>single</goal>
-								</goals>
-							</execution>
-						</executions>
-					</plugin>	
 		</plugins>
 
-
 		<pluginManagement>
 			<plugins>
 				<!--This plugin's configuration is used to store Eclipse m2e settings 
-				only. It has no influence on the Maven build itself. -->
+					only. It has no influence on the Maven build itself. -->
 				<plugin>
 					<groupId>org.eclipse.m2e</groupId>
 					<artifactId>lifecycle-mapping</artifactId>
@@ -514,7 +408,7 @@
 					<configuration>
 						<lifecycleMappingMetadata>
 							<pluginExecutions>
-								
+
 								<pluginExecution>
 									<pluginExecutionFilter>
 										<groupId>com.jcabi</groupId>
@@ -528,22 +422,81 @@
 										<execute />
 									</action>
 								</pluginExecution>
-								
+
 							</pluginExecutions>
 						</lifecycleMappingMetadata>
 					</configuration>
 				</plugin>
-				
+
 				<!-- jacbi (log injection) -->
 
 			</plugins>
 		</pluginManagement>
-		
+
 	</build>
 
+	<profiles>
+        <profile>
+            <id>catalog</id>
+            <activation>
+                <activeByDefault>false</activeByDefault>
+            </activation>
 
 
+            <build>
+
+                <finalName>${project.artifactId}-${full.release.version}</finalName>
+
+                <plugins>
+
+                    <!-- ================================================== -->
+                    <!-- Get the next versions from the properties file. -->
+                    <!-- ================================================== -->
+                    <plugin>
+                        <groupId>org.codehaus.mojo</groupId>
+                        <artifactId>properties-maven-plugin</artifactId>
+                        <version>1.0-alpha-2</version>
+
+                        <executions>
+                            <execution>
+                                <inherited>false</inherited>
+                                <phase>initialize</phase>
+                                <goals>
+                                    <goal>read-project-properties</goal>
+                                </goals>
+                                <configuration>
+                                    <files>
+                                        <file>${project.parent.build.directory}/FullReleaseVersion.properties</file>
+                                    </files>
+                                </configuration>
+                            </execution>
+                        </executions>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
 
 
+		<profile>
+			<id>Fortify</id>
+			<activation>
+				<activeByDefault>false</activeByDefault>
+			</activation>
 
+			<build>
+				<plugins>
+					<plugin>
+						<groupId>com.fortify.ps.maven.plugin</groupId>
+						<artifactId>sca-maven-plugin</artifactId>
+						<version>4.30</version>
+						<configuration>
+							<source>1.8</source>
+							<buildId>${project.parent.artifactId}</buildId>
+							<toplevelArtifactId>${project.parent.artifactId}</toplevelArtifactId>
+						</configuration>
+					</plugin>
+				</plugins>
+			</build>
+		</profile>
+	</profiles>
 </project>
diff --git a/catalog-fe/src/main/java/org/openecomp/sdc/fe/Constants.java b/catalog-fe/src/main/java/org/openecomp/sdc/fe/Constants.java
index e157efc..a9f5c12 100644
--- a/catalog-fe/src/main/java/org/openecomp/sdc/fe/Constants.java
+++ b/catalog-fe/src/main/java/org/openecomp/sdc/fe/Constants.java
@@ -1,3 +1,23 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
 package org.openecomp.sdc.fe;
 
 public class Constants {
diff --git a/catalog-fe/src/main/java/org/openecomp/sdc/fe/client/BackendClient.java b/catalog-fe/src/main/java/org/openecomp/sdc/fe/client/BackendClient.java
index 93e1714..92e497d 100644
--- a/catalog-fe/src/main/java/org/openecomp/sdc/fe/client/BackendClient.java
+++ b/catalog-fe/src/main/java/org/openecomp/sdc/fe/client/BackendClient.java
@@ -151,7 +151,7 @@
 				}
 				backendHttpClient.close();
 			} catch (IOException e) {
-				log.error("failed to close httpClient: " + e.getMessage());
+				log.error("failed to close httpClient: {}", e.getMessage());
 			}
 
 		}
@@ -168,7 +168,7 @@
 			if (headerValue != null) {
 				httpPost.setHeader(headerName, headerValue);
 			} else {
-				log.error("missing required header " + headerName);
+				log.error("missing required header {}", headerName);
 				return allHeadersAreSet;
 			}
 		}
diff --git a/catalog-fe/src/main/java/org/openecomp/sdc/fe/servlets/ConfigMgrServlet.java b/catalog-fe/src/main/java/org/openecomp/sdc/fe/servlets/ConfigMgrServlet.java
index 7792225..356f926 100644
--- a/catalog-fe/src/main/java/org/openecomp/sdc/fe/servlets/ConfigMgrServlet.java
+++ b/catalog-fe/src/main/java/org/openecomp/sdc/fe/servlets/ConfigMgrServlet.java
@@ -61,9 +61,9 @@
 
 			Configuration configuration = configurationManager.getConfiguration();
 			if (configuration == null) {
-				log.warn("Configuration of type " + Configuration.class + " was not found");
+				log.warn("Configuration of type {} was not found", Configuration.class);
 			} else {
-				log.info("The value returned from getConfig is " + configuration);
+				log.info("The value returned from getConfig is {}", configuration);
 
 				result = gson.toJson(configuration);
 
@@ -72,9 +72,9 @@
 
 			RestConfigurationInfo configuration = configurationManager.getRestClientConfiguration();
 			if (configuration == null) {
-				log.warn("Configuration of type " + RestConfigurationInfo.class + " was not found");
+				log.warn("Configuration of type {} was not found", RestConfigurationInfo.class);
 			} else {
-				log.info("The value returned from getConfig is " + configuration);
+				log.info("The value returned from getConfig is {}", configuration);
 
 				result = gson.toJson(configuration);
 
diff --git a/catalog-fe/src/main/java/org/openecomp/sdc/fe/servlets/ConfigServlet.java b/catalog-fe/src/main/java/org/openecomp/sdc/fe/servlets/ConfigServlet.java
index 92bb9e8..b8d623b 100644
--- a/catalog-fe/src/main/java/org/openecomp/sdc/fe/servlets/ConfigServlet.java
+++ b/catalog-fe/src/main/java/org/openecomp/sdc/fe/servlets/ConfigServlet.java
@@ -64,13 +64,13 @@
 			Configuration configuration = configurationSource.getAndWatchConfiguration(Configuration.class, null);
 
 			if (configuration == null) {
-				log.warn("Configuration of type " + Configuration.class + " was not found");
+				log.warn("Configuration of type {} was not found", Configuration.class);
 			}
 			log.debug("{}", configuration);
 			if (log.isInfoEnabled()) {
 				log.info("Info level ENABLED...");
 			}
-			log.info("The value returned from getConfig is " + configuration);
+			log.info("The value returned from getConfig is {}", configuration);
 
 			result = gson.toJson(configuration);
 
diff --git a/catalog-fe/src/main/java/org/openecomp/sdc/fe/servlets/FeHealthCheckServlet.java b/catalog-fe/src/main/java/org/openecomp/sdc/fe/servlets/FeHealthCheckServlet.java
index da5b321..1ed6ac5 100644
--- a/catalog-fe/src/main/java/org/openecomp/sdc/fe/servlets/FeHealthCheckServlet.java
+++ b/catalog-fe/src/main/java/org/openecomp/sdc/fe/servlets/FeHealthCheckServlet.java
@@ -35,10 +35,6 @@
 @Loggable(prepend = true, value = Loggable.TRACE, trim = false)
 @Path("/healthCheck")
 public class FeHealthCheckServlet extends BasicServlet {
-
-	// private static Logger log =
-	// LoggerFactory.getLogger(FeHealthCheckServlet.class.getName());
-
 	@GET
 	public Response getFEandBeHealthCheck(@Context final HttpServletRequest request) {
 		ServletContext context = request.getSession().getServletContext();
diff --git a/catalog-fe/src/main/java/org/openecomp/sdc/fe/servlets/FeProxyServlet.java b/catalog-fe/src/main/java/org/openecomp/sdc/fe/servlets/FeProxyServlet.java
index 1cd28de..11d4abf 100644
--- a/catalog-fe/src/main/java/org/openecomp/sdc/fe/servlets/FeProxyServlet.java
+++ b/catalog-fe/src/main/java/org/openecomp/sdc/fe/servlets/FeProxyServlet.java
@@ -85,7 +85,7 @@
 		String serviceInstanceID = httpRequest.getHeader(Constants.X_ECOMP_SERVICE_ID_HEADER);
 
 		if (uuid != null && uuid.length() > 0) {
-			// User Id for logging
+			// UserId for logging
 			String userId = httpRequest.getHeader(Constants.USER_ID_HEADER);
 
 			String remoteAddr = httpRequest.getRemoteAddr();
@@ -201,6 +201,7 @@
 		if (onboardingForwardContext == null || onboardingForwardContext.isEmpty()) {
 			onboardingForwardContext = "/onboarding-api";
 		}
+		redirectedUrl = redirectedUrl.replace("/sdc1/feProxy/dcae-api", "/dcae");
 		redirectedUrl = redirectedUrl.replace("/sdc1/feProxy/onboarding-api", onboardingForwardContext);
 		redirectedUrl = redirectedUrl.replace("/sdc1/feProxy", "/sdc2");
 		return redirectedUrl;
diff --git a/catalog-fe/src/main/java/org/openecomp/sdc/fe/servlets/HealthCheckService.java b/catalog-fe/src/main/java/org/openecomp/sdc/fe/servlets/HealthCheckService.java
index 338e8d4..b7fce8d 100644
--- a/catalog-fe/src/main/java/org/openecomp/sdc/fe/servlets/HealthCheckService.java
+++ b/catalog-fe/src/main/java/org/openecomp/sdc/fe/servlets/HealthCheckService.java
@@ -40,9 +40,9 @@
 import org.apache.http.util.EntityUtils;
 import org.openecomp.sdc.common.api.Constants;
 import org.openecomp.sdc.common.api.HealthCheckInfo;
+import org.openecomp.sdc.common.api.HealthCheckWrapper;
 import org.openecomp.sdc.common.api.HealthCheckInfo.HealthCheckComponent;
 import org.openecomp.sdc.common.api.HealthCheckInfo.HealthCheckStatus;
-import org.openecomp.sdc.common.api.HealthCheckWrapper;
 import org.openecomp.sdc.common.config.EcompErrorName;
 import org.openecomp.sdc.common.impl.ExternalConfiguration;
 import org.openecomp.sdc.fe.config.Configuration;
diff --git a/catalog-fe/src/main/resources/config/configuration.yaml b/catalog-fe/src/main/resources/config/configuration.yaml
index 6be93b3..cd123ca 100644
--- a/catalog-fe/src/main/resources/config/configuration.yaml
+++ b/catalog-fe/src/main/resources/config/configuration.yaml
@@ -17,30 +17,30 @@
 beSslPort: 8443
 
 # threadpool size for handling requests
-threadpoolSize: 50 
+threadpoolSize: 50
 
 # request processing timeout (seconds)
 requestTimeout: 10
 
+# Determines the health check read timeout when invoking health check towards the LB (or BE whatever is configured):
 healthCheckSocketTimeoutInMs: 5000
-
 healthCheckIntervalInSeconds: 5
 
-identificationHeaderFields: 
+identificationHeaderFields:
    -
         - &HTTP_IV_USER HTTP_IV_USER
         - &iv-user iv-user
    -
         - &USER_ID USER_ID
-        - &user-id user-id
+        - &csp-userId csp-userId
    -
         - &HTTP_CSP_ATTUID HTTP_CSP_ATTUID
         - &csp-attuid csp-attuid
    -
-        - &HTTP_CSP_WSTYPE HTTP_CSP_WSTYPE 
+        - &HTTP_CSP_WSTYPE HTTP_CSP_WSTYPE
         - &csp-wstype csp-wstype
 
-optionalHeaderFields: 
+optionalHeaderFields:
    -
         - &HTTP_CSP_FIRSTNAME HTTP_CSP_FIRSTNAME
         - &csp-firstname csp-firstname
diff --git a/catalog-fe/src/main/resources/portal.properties b/catalog-fe/src/main/resources/portal.properties
index 880c4fe..a146d6e 100644
--- a/catalog-fe/src/main/resources/portal.properties
+++ b/catalog-fe/src/main/resources/portal.properties
@@ -1,11 +1,12 @@
 # Portal REST URL, ends "/auxapi"
-ecomp_rest_url = https://portal.api.simpledemo.openecomp.org/ecompportal/auxapi
+ecomp_rest_url = https://ecomp.homer.att.com/ecompportal/auxapi
  
 # Java implementation of interface
 portal.api.impl.class = org.openecomp.sdc.be.ecomp.EcompIntImpl
 
 # CSP-SSO URL
-ecomp_redirect_url = http://portal.api.simpledemo.openecomp.org:8989/ECOMPPORTAL/login.htm
+# ecomp_redirect_url = https://www.e-access.att.com/ecomp_portal_ist/ecompportal/process_csp
+ecomp_redirect_url = http://127.0.0.1:8989/ECOMPPORTAL/login.htm
  
 # Cookie set by CSP-SSO
 csp_cookie_name = attESSec
@@ -13,7 +14,7 @@
 csp_gate_keeper_prod_key = PROD
 
 # Comma-separated list of UEB server names
-ueb_url_list = 
+ueb_url_list = localhost
 # UEB topic where Portal listens
 ecomp_portal_inbox_name = ECOMP-PORTAL-INBOX-TEST
 # UEB key generated while on-boarding
diff --git a/catalog-fe/src/main/webapp/WEB-INF/web.xml b/catalog-fe/src/main/webapp/WEB-INF/web.xml
index f6d709e..c2127dc 100644
--- a/catalog-fe/src/main/webapp/WEB-INF/web.xml
+++ b/catalog-fe/src/main/webapp/WEB-INF/web.xml
@@ -39,146 +39,6 @@
 		<url-pattern>/lbClassicStatus</url-pattern>
 	</servlet-mapping>
 
-	<!-- Proxy Server Only used for tests to simulate webSeal ## Start ## -->
-<!--   	<servlet>
-		<servlet-name>ProxyAdmin1</servlet-name>
-		<servlet-class>org.openecomp.sdc.fe.servlets.websealmock.WebSealSimulatorServletAdmin1</servlet-class>
-		<async-supported>true</async-supported>
-	</servlet>
-
-	<servlet-mapping>
-		<servlet-name>ProxyAdmin1</servlet-name>
-		<url-pattern>/proxy-admin1</url-pattern>
-	</servlet-mapping>
-		<servlet>
-		<servlet-name>ProxyAdmin2</servlet-name>
-		<servlet-class>org.openecomp.sdc.fe.servlets.websealmock.WebSealSimulatorServletAdmin2</servlet-class>
-		<async-supported>true</async-supported>
-	</servlet>
-
-	<servlet-mapping>
-		<servlet-name>ProxyAdmin2</servlet-name>
-		<url-pattern>/proxy-admin2</url-pattern>
-	</servlet-mapping>
-		<servlet>
-		<servlet-name>ProxyAdmin3</servlet-name>
-		<servlet-class>org.openecomp.sdc.fe.servlets.websealmock.WebSealSimulatorServletAdmin3</servlet-class>
-		<async-supported>true</async-supported>
-	</servlet>
-
-	<servlet-mapping>
-		<servlet-name>ProxyAdmin3</servlet-name>
-		<url-pattern>/proxy-admin3</url-pattern>
-	</servlet-mapping>
-
-   	<servlet>
-		<servlet-name>ProxyDesigner1</servlet-name>
-		<servlet-class>org.openecomp.sdc.fe.servlets.websealmock.WebSealSimulatorServletDesigner1</servlet-class>
-		<async-supported>true</async-supported>
-	</servlet>
-
-	<servlet-mapping>
-		<servlet-name>ProxyDesigner1</servlet-name>
-		<url-pattern>/proxy-designer1</url-pattern>
-	</servlet-mapping>
-		<servlet>
-		<servlet-name>ProxyDesigner2</servlet-name>
-		<servlet-class>org.openecomp.sdc.fe.servlets.websealmock.WebSealSimulatorServletDesigner2</servlet-class>
-		<async-supported>true</async-supported>
-	</servlet>
-
-	<servlet-mapping>
-		<servlet-name>ProxyDesigner2</servlet-name>
-		<url-pattern>/proxy-designer2</url-pattern>
-	</servlet-mapping>
-	<servlet>
-		<servlet-name>ProxyDesigner3</servlet-name>
-		<servlet-class>org.openecomp.sdc.fe.servlets.websealmock.WebSealSimulatorServletDesigner3</servlet-class>
-		<async-supported>true</async-supported>
-	</servlet>
-
-	<servlet-mapping>
-		<servlet-name>ProxyDesigner3</servlet-name>
-		<url-pattern>/proxy-designer3</url-pattern>
-	</servlet-mapping>
-
-	<servlet>
-		<servlet-name>ProxyTester1</servlet-name>
-		<servlet-class>org.openecomp.sdc.fe.servlets.websealmock.WebSealSimulatorServletTester1</servlet-class>
-		<async-supported>true</async-supported>
-	</servlet>
-
-	<servlet-mapping>
-		<servlet-name>ProxyTester1</servlet-name>
-		<url-pattern>/proxy-tester1</url-pattern>
-	</servlet-mapping>
-		<servlet>
-		<servlet-name>ProxyTester2</servlet-name>
-		<servlet-class>org.openecomp.sdc.fe.servlets.websealmock.WebSealSimulatorServletTester2</servlet-class>
-		<async-supported>true</async-supported>
-	</servlet>
-
-	<servlet-mapping>
-		<servlet-name>ProxyTester2</servlet-name>
-		<url-pattern>/proxy-tester2</url-pattern>
-	</servlet-mapping>
-
-	<servlet>
-		<servlet-name>ProxyTester3</servlet-name>
-		<servlet-class>org.openecomp.sdc.fe.servlets.websealmock.WebSealSimulatorServletTester3</servlet-class>
-		<async-supported>true</async-supported>
-	</servlet>
-
-	<servlet-mapping>
-		<servlet-name>ProxyTester3</servlet-name>
-		<url-pattern>/proxy-tester3</url-pattern>
-	</servlet-mapping>
-
-	<servlet-mapping>
-		<servlet-name>ProxyGovernor1</servlet-name>
-		<url-pattern>/proxy-governor1</url-pattern>
-	</servlet-mapping>
-
-	<servlet>
-		<servlet-name>ProxyGovernor1</servlet-name>
-		<servlet-class>org.openecomp.sdc.fe.servlets.websealmock.WebSealSimulatorServletGovernor1</servlet-class>
-		<async-supported>true</async-supported>
-	</servlet>
-
-	<servlet-mapping>
-		<servlet-name>ProxyOps1</servlet-name>
-		<url-pattern>/proxy-ops1</url-pattern>
-	</servlet-mapping>
-
-	<servlet>
-		<servlet-name>ProxyOps1</servlet-name>
-		<servlet-class>org.openecomp.sdc.fe.servlets.websealmock.WebSealSimulatorServletOps1</servlet-class>
-		<async-supported>true</async-supported>
-	</servlet>
-
-	<servlet-mapping>
-		<servlet-name>ProxyPs1</servlet-name>
-		<url-pattern>/proxy-ps1</url-pattern>
-	</servlet-mapping>
-
-	<servlet>
-		<servlet-name>ProxyPs1</servlet-name>
-		<servlet-class>org.openecomp.sdc.fe.servlets.websealmock.WebSealSimulatorServletProductStrategist1</servlet-class>
-		<async-supported>true</async-supported>
-	</servlet>
-	<servlet-mapping>
-		<servlet-name>ProxyPm1</servlet-name>
-		<url-pattern>/proxy-pm1</url-pattern>
-	</servlet-mapping>
-
-	<servlet>
-		<servlet-name>ProxyPm1</servlet-name>
-		<servlet-class>org.openecomp.sdc.fe.servlets.websealmock.WebSealSimulatorServletProductManger1</servlet-class>
-		<async-supported>true</async-supported>
-	</servlet> -->
-	
-	<!-- Proxy Server Only used for tests to simulate webSeal ## End ## -->
-
 	<!-- Fe Proxy Servlet -->
 	<servlet>
 		<servlet-name>FeProxy</servlet-name>
@@ -219,35 +79,6 @@
 		<url-pattern>/kibanaProxy/*</url-pattern>
 	</servlet-mapping>
 
-
-
-	<filter>
-		<filter-name>cross-origin-att</filter-name>
-		<filter-class>org.eclipse.jetty.servlets.CrossOriginFilter</filter-class>
-		<async-supported>true</async-supported>
-		<init-param>
-			<param-name>allowedOrigins</param-name>
-			<param-value>*</param-value>
-		</init-param>
-		<init-param>
-			<param-name>allowedMethods</param-name>
-			<param-value>GET,POST,OPTIONS,DELETE,PUT,HEAD</param-value>
-		</init-param>
-		<init-param>
-			<param-name>allowedHeaders</param-name>
-			<param-value>HTTP_CSP_FIRSTNAME, HTTP_CSP_LASTNAME, USER_ID,
-				HTTP_CSP_EMAIL, X-ECOMP-RequestID, origin, content-type, accept, authorization, Content-MD5,X-ECOMP-ServiceID</param-value>
-		</init-param>
-		<init-param>
-			<param-name>allowCredential</param-name>
-			<param-value>true</param-value>
-		</init-param>
-	</filter>
-	<filter-mapping>
-		<filter-name>cross-origin-att</filter-name>
-		<url-pattern>/*</url-pattern>
-	</filter-mapping>
-
 <!--  
 	<filter>
 		<filter-name>GzipFilter</filter-name>
diff --git a/catalog-fe/src/test/jasmine-standalone-2.0.0/lib/jasmine-2.0.0/boot.js b/catalog-fe/src/test/jasmine-standalone-2.0.0/lib/jasmine-2.0.0/boot.js
index b1686af..ec8baa0 100644
--- a/catalog-fe/src/test/jasmine-standalone-2.0.0/lib/jasmine-2.0.0/boot.js
+++ b/catalog-fe/src/test/jasmine-standalone-2.0.0/lib/jasmine-2.0.0/boot.js
@@ -1,23 +1,3 @@
-/*-
- * ============LICENSE_START=======================================================
- * SDC
- * ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
 /**
  Starting with version 2.0, this file "boots" Jasmine, performing all of the necessary initialization before executing the loaded environment and all of a project's specs. This file should be loaded after `jasmine.js`, but before any project source files or spec files are loaded. Thus this file can also be used to customize Jasmine for a project.
 
diff --git a/catalog-fe/src/test/jasmine-standalone-2.0.0/lib/jasmine-2.0.0/console.js b/catalog-fe/src/test/jasmine-standalone-2.0.0/lib/jasmine-2.0.0/console.js
index 4e31320..33c1698 100644
--- a/catalog-fe/src/test/jasmine-standalone-2.0.0/lib/jasmine-2.0.0/console.js
+++ b/catalog-fe/src/test/jasmine-standalone-2.0.0/lib/jasmine-2.0.0/console.js
@@ -1,23 +1,3 @@
-/*-
- * ============LICENSE_START=======================================================
- * SDC
- * ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
 /*
 Copyright (c) 2008-2013 Pivotal Labs
 
diff --git a/catalog-fe/src/test/jasmine-standalone-2.0.0/lib/jasmine-2.0.0/jasmine-html.js b/catalog-fe/src/test/jasmine-standalone-2.0.0/lib/jasmine-2.0.0/jasmine-html.js
index f7469e9..985d0d1 100644
--- a/catalog-fe/src/test/jasmine-standalone-2.0.0/lib/jasmine-2.0.0/jasmine-html.js
+++ b/catalog-fe/src/test/jasmine-standalone-2.0.0/lib/jasmine-2.0.0/jasmine-html.js
@@ -1,23 +1,3 @@
-/*-
- * ============LICENSE_START=======================================================
- * SDC
- * ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
 /*
 Copyright (c) 2008-2013 Pivotal Labs
 
diff --git a/catalog-fe/src/test/jasmine-standalone-2.0.0/lib/jasmine-2.0.0/jasmine.js b/catalog-fe/src/test/jasmine-standalone-2.0.0/lib/jasmine-2.0.0/jasmine.js
index a1390a2..24463ec 100644
--- a/catalog-fe/src/test/jasmine-standalone-2.0.0/lib/jasmine-2.0.0/jasmine.js
+++ b/catalog-fe/src/test/jasmine-standalone-2.0.0/lib/jasmine-2.0.0/jasmine.js
@@ -1,23 +1,3 @@
-/*-
- * ============LICENSE_START=======================================================
- * SDC
- * ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
 /*
 Copyright (c) 2008-2013 Pivotal Labs
 
diff --git a/catalog-fe/src/test/jasmine-standalone-2.0.0/spec/PlayerSpec.js b/catalog-fe/src/test/jasmine-standalone-2.0.0/spec/PlayerSpec.js
index 976c0de..f17521f 100644
--- a/catalog-fe/src/test/jasmine-standalone-2.0.0/spec/PlayerSpec.js
+++ b/catalog-fe/src/test/jasmine-standalone-2.0.0/spec/PlayerSpec.js
@@ -1,23 +1,3 @@
-/*-
- * ============LICENSE_START=======================================================
- * SDC
- * ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
 describe("Player", function() {
   var player;
   var song;
diff --git a/catalog-fe/src/test/jasmine-standalone-2.0.0/spec/SpecHelper.js b/catalog-fe/src/test/jasmine-standalone-2.0.0/spec/SpecHelper.js
index b6b66da..578b3e8 100644
--- a/catalog-fe/src/test/jasmine-standalone-2.0.0/spec/SpecHelper.js
+++ b/catalog-fe/src/test/jasmine-standalone-2.0.0/spec/SpecHelper.js
@@ -1,23 +1,3 @@
-/*-
- * ============LICENSE_START=======================================================
- * SDC
- * ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
 beforeEach(function () {
   jasmine.addMatchers({
     toBePlaying: function () {
diff --git a/catalog-fe/src/test/jasmine-standalone-2.0.0/src/Player.js b/catalog-fe/src/test/jasmine-standalone-2.0.0/src/Player.js
index 20be99a..fcce826 100644
--- a/catalog-fe/src/test/jasmine-standalone-2.0.0/src/Player.js
+++ b/catalog-fe/src/test/jasmine-standalone-2.0.0/src/Player.js
@@ -1,23 +1,3 @@
-/*-
- * ============LICENSE_START=======================================================
- * SDC
- * ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
 function Player() {
 }
 Player.prototype.play = function(song) {
@@ -39,4 +19,4 @@
 
 Player.prototype.makeFavorite = function() {
   this.currentlyPlayingSong.persistFavoriteStatus(true);
-};
+};
\ No newline at end of file
diff --git a/catalog-fe/src/test/jasmine-standalone-2.0.0/src/Song.js b/catalog-fe/src/test/jasmine-standalone-2.0.0/src/Song.js
index c16d77e..a8a3f2d 100644
--- a/catalog-fe/src/test/jasmine-standalone-2.0.0/src/Song.js
+++ b/catalog-fe/src/test/jasmine-standalone-2.0.0/src/Song.js
@@ -1,27 +1,7 @@
-/*-
- * ============LICENSE_START=======================================================
- * SDC
- * ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
 function Song() {
 }
 
 Song.prototype.persistFavoriteStatus = function(value) {
   // something complicated
   throw new Error("not yet implemented");
-};
+};
\ No newline at end of file
diff --git a/catalog-fe/src/test/java/org/openecomp/sdc/ContentDisposiotionDelegator.java b/catalog-fe/src/test/java/org/openecomp/sdc/ContentDisposiotionDelegator.java
index 9b87387..d64aee2 100644
--- a/catalog-fe/src/test/java/org/openecomp/sdc/ContentDisposiotionDelegator.java
+++ b/catalog-fe/src/test/java/org/openecomp/sdc/ContentDisposiotionDelegator.java
@@ -29,7 +29,6 @@
 	public ContentDisposiotionDelegator(String type, String name, String fileName, Date creationDate,
 			Date modificationDate, Date readDate, long size) {
 		super(type, name, fileName, creationDate, modificationDate, readDate, size);
-		// TODO Auto-generated constructor stub
 	}
 
 }
diff --git a/catalog-fe/src/test/java/org/openecomp/sdc/TestExternalConfiguration.java b/catalog-fe/src/test/java/org/openecomp/sdc/TestExternalConfiguration.java
index ecbc055..78622f1 100644
--- a/catalog-fe/src/test/java/org/openecomp/sdc/TestExternalConfiguration.java
+++ b/catalog-fe/src/test/java/org/openecomp/sdc/TestExternalConfiguration.java
@@ -57,7 +57,6 @@
 		try {
 			Thread.currentThread().sleep(100 * 1000);
 		} catch (InterruptedException e) {
-			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 
diff --git a/catalog-fe/src/test/resources/config/catalog-fe/configuration.yaml b/catalog-fe/src/test/resources/config/catalog-fe/configuration.yaml
index 22bfee9..5cc22fd 100644
--- a/catalog-fe/src/test/resources/config/catalog-fe/configuration.yaml
+++ b/catalog-fe/src/test/resources/config/catalog-fe/configuration.yaml
@@ -50,6 +50,16 @@
    -
         - &HTTP_IV_REMOTE_ADDRESS HTTP_IV_REMOTE_ADDRESS
         - &iv-remote-address iv-remote-address
+        
+forwardHeaderFields:
+   - *HTTP_IV_USER
+   - *USER_ID
+   - *HTTP_CSP_FIRSTNAME
+   - *HTTP_CSP_LASTNAME
+   - *HTTP_IV_REMOTE_ADDRESS
+   - *HTTP_CSP_WSTYPE
+   - Content-MD5
+   - Content-Type
 
 
 version: 1.0
diff --git a/catalog-fe/src/test/spec/codeSpec.js b/catalog-fe/src/test/spec/codeSpec.js
index 1cb5da0..b4c4bd6 100644
--- a/catalog-fe/src/test/spec/codeSpec.js
+++ b/catalog-fe/src/test/spec/codeSpec.js
@@ -1,23 +1,3 @@
-/*-
- * ============LICENSE_START=======================================================
- * SDC
- * ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
 describe("General", function() {
 	
 	
diff --git a/catalog-fe/src/test/testScripts/filesContents.js b/catalog-fe/src/test/testScripts/filesContents.js
index b2e7aa2..78de144 100644
--- a/catalog-fe/src/test/testScripts/filesContents.js
+++ b/catalog-fe/src/test/testScripts/filesContents.js
@@ -1,23 +1,3 @@
-/*-
- * ============LICENSE_START=======================================================
- * SDC
- * ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
 var normativeTypesRootYml = "tosca_definitions_version: tosca_simple_yaml_1_0_0_wd03"+
 
 "template_name: tosca-normative-types-root"+
@@ -204,4 +184,4 @@
 'sudo /etc/init.d/mysql stop'+
 'sudo rm -rf /var/lib/apt/lists/*'+
 'sudo rm -rf /var/lib/mysql/*'+
-'echo "MySQL Installation complete."';
+'echo "MySQL Installation complete."';
\ No newline at end of file
diff --git a/catalog-fe/src/test/testScripts/jasmine-fixture.js b/catalog-fe/src/test/testScripts/jasmine-fixture.js
index 18ff8c6..3815731 100644
--- a/catalog-fe/src/test/testScripts/jasmine-fixture.js
+++ b/catalog-fe/src/test/testScripts/jasmine-fixture.js
@@ -1,23 +1,3 @@
-/*-
- * ============LICENSE_START=======================================================
- * SDC
- * ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
 /* jasmine-fixture - 1.2.2
  * Makes injecting HTML snippets into the DOM easy & clean!
  * https://github.com/searls/jasmine-fixture
diff --git a/catalog-fe/tarball.xml b/catalog-fe/tarball.xml
deleted file mode 100644
index 87b944b..0000000
--- a/catalog-fe/tarball.xml
+++ /dev/null
@@ -1,32 +0,0 @@
-<assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0"
-xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
-  <id>bin</id>
-  <formats>
-    <format>tar</format>
-  </formats>
-  <files>
-    <file>
-        <source>${project.build.directory}/${project.artifactId}-${project.version}.war</source>
-        <outputDirectory>./</outputDirectory>
-        <destName>${project.artifactId}-${project.version}.war</destName>
-    </file>
-    <file>
-        <source>src/main/resources/jetty-ipaccess.xml</source>
-        <outputDirectory>./</outputDirectory>
-        <destName>jetty-ipaccess.xml</destName>
-    </file>
-  </files>
-  
-  <fileSets>  
-  	<fileSet>
-		<directory>src/main/resources/config</directory>
-        <outputDirectory>config</outputDirectory>
-	</fileSet>
-	<fileSet>
-		<directory>src/main/resources/scripts</directory>
-        <outputDirectory>scripts</outputDirectory>
-	</fileSet>
-  </fileSets>
-  
-</assembly>
