Initial OpenECOMP SDC commit

Change-Id: I0924d5a6ae9cdc161ae17c68d3689a30d10f407b
Signed-off-by: Michael Lando <ml636r@att.com>

27 files changed, 7831 insertions, 0 deletions

diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/Utils.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/Utils.java
new file mode 100644
index 0000000000..3b7d3ec11d
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/Utils.java
@@ -0,0 +1,152 @@
+/*-
+ * ============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.asdctool;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.ResponseBuilder;
+
+import org.apache.commons.configuration.Configuration;
+import org.apache.tinkerpop.gremlin.structure.Element;
+import org.apache.tinkerpop.gremlin.structure.Property;
+import org.apache.tinkerpop.gremlin.structure.util.ElementHelper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.thinkaurelius.titan.core.TitanFactory;
+import com.thinkaurelius.titan.core.TitanGraph;
+
+//import org.openecomp.sdc.be.auditing.impl.AuditingManager;
+
+//import org.openecomp.sdc.be.info.errors.ResponseFormat;
+
+public class Utils {
+
+	private static Logger log = LoggerFactory.getLogger(Utils.class.getName());
+
+	public static String NEW_LINE = System.getProperty("line.separator");
+
+	public static Response buildOkResponse(
+			/*
+			 * ResponseFormat errorResponseWrapper,
+			 */int status, Object entity, Map<String, String> additionalHeaders) {
+		// int status = errorResponseWrapper.getStatus();
+		ResponseBuilder responseBuilder = Response.status(status);
+		if (entity != null) {
+			log.trace("returned entity is {}", entity.toString());
+			responseBuilder = responseBuilder.entity(entity);
+		}
+		if (additionalHeaders != null) {
+			for (Entry<String, String> additionalHeader : additionalHeaders.entrySet()) {
+				String headerName = additionalHeader.getKey();
+				String headerValue = additionalHeader.getValue();
+				log.trace("Adding header {} with value {} to the response", headerName, headerValue);
+				responseBuilder.header(headerName, headerValue);
+			}
+		}
+		return responseBuilder.build();
+	}
+
+	public static TitanGraph openGraph(Configuration conf) {
+
+		TitanGraph graph = null;
+		try {
+
+			graph = TitanFactory.open(conf);
+
+		} catch (Exception e) {
+			log.error("Failed to start open graph", e);
+		}
+
+		return graph;
+
+	}
+
+	public static boolean vertexLeftContainsRightProps(Map<String, Object> leftProps, Map<String, Object> rightProps) {
+
+		if (rightProps != null) {
+
+			for (Entry<String, Object> entry : rightProps.entrySet()) {
+				String key = entry.getKey();
+				Object leftValue = leftProps.get(key);
+				Object rightValue = entry.getValue();
+				if (leftValue == null) {
+					if (rightValue == null) {
+						continue;
+					} else {
+						log.debug("The key {} cannot be found in the properties {}", key, leftProps);
+						return false;
+					}
+				}
+
+				// if (false == leftValue instanceof Map && false == leftValue
+				// instanceof List) {
+				if (false == leftValue.equals(rightValue)) {
+					log.trace("The value of key {} is different between properties {} vs {}", key, leftValue, rightValue);
+					return false;
+				}
+				// }
+			}
+
+		}
+
+		return true;
+	}
+
+	public static void setProperties(Element element, Map<String, Object> properties) {
+
+		if (properties != null && false == properties.isEmpty()) {
+
+			Object[] propertyKeyValues = new Object[properties.size() * 2];
+			int i = 0;
+			for (Entry<String, Object> entry : properties.entrySet()) {
+				propertyKeyValues[i++] = entry.getKey();
+				propertyKeyValues[i++] = entry.getValue();
+			}
+
+			ElementHelper.attachProperties(element, propertyKeyValues);
+
+		}
+
+	}
+
+	public static Map<String, Object> getProperties(Element element) {
+
+		Map<String, Object> result = new HashMap<String, Object>();
+		;
+
+		if (element.keys() != null && element.keys().size() > 0) {
+			Map<String, Property> propertyMap = ElementHelper.propertyMap(element,
+					element.keys().toArray(new String[element.keys().size()]));
+
+			for (Entry<String, Property> entry : propertyMap.entrySet()) {
+				String key = entry.getKey();
+				Object value = entry.getValue().value();
+
+				result.put(key, value);
+			}
+		}
+		return result;
+	}
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/DataMigration.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/DataMigration.java
new file mode 100644
index 0000000000..a78ea9bc18
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/DataMigration.java
@@ -0,0 +1,830 @@
+/*-
+ * ============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.asdctool.impl;
+
+import com.carrotsearch.hppc.cursors.ObjectCursor;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+import fj.data.Either;
+import org.apache.commons.lang.SystemUtils;
+import org.elasticsearch.action.search.SearchResponse;
+import org.elasticsearch.cluster.metadata.IndexMetaData;
+import org.elasticsearch.common.collect.ImmutableOpenMap;
+import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.common.unit.TimeValue;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.search.SearchHit;
+import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao;
+import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao;
+import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
+import org.openecomp.sdc.be.dao.cassandra.schema.Table;
+import org.openecomp.sdc.be.dao.es.ElasticSearchClient;
+import org.openecomp.sdc.be.resources.data.ESArtifactData;
+import org.openecomp.sdc.be.resources.data.auditing.*;
+import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import java.io.*;
+import java.lang.reflect.Type;
+import java.net.MalformedURLException;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.EnumMap;
+import java.util.Map;
+import java.util.TimeZone;
+
+/**
+ * Created by mlando on 5/16/2016.
+ */
+public class DataMigration {
+
+	private Gson gson = new Gson();
+
+	private ObjectMapper jsonMapper = new ObjectMapper();
+
+	private static Logger log = LoggerFactory.getLogger(DataMigration.class.getName());
+
+	protected ElasticSearchClient elasticSearchClient;
+	@Autowired
+	protected AuditCassandraDao auditCassandraDao;
+	@Autowired
+	protected ArtifactCassandraDao artifactCassandraDao;
+	private static final String dateFormatPattern = "yyyy-MM-dd HH:mm:ss.SSS z";
+	private static SimpleDateFormat simpleDateFormat;
+
+	/**
+	 * the method exports and imports the records from ES to cassandra the flow
+	 * will check to see if the files are not empty if the files are not empty
+	 * the export will be skiped and the flow will use the existing files. the
+	 * flow will check if the tables in cassandra are empty, if the tables are
+	 * not empty the proces will stop and exit. if the tables are empty the
+	 * method will import the records from the files. in case of a fail the flow
+	 * will exit and clear all the Cassandra tables.
+	 *
+	 * @param appConfigDir
+	 *            the location of the dir in wich the output files will be
+	 *            stored
+	 * @param exportFromEs
+	 *            should the es be exported again and overwrite the old export
+	 * @param importToCassandra
+	 *            should we import the data into cassandra
+	 * @return true in case the operation was successful.
+	 */
+	public boolean migrateDataESToCassndra(String appConfigDir, boolean exportFromEs, boolean importToCassandra) {
+		initFormater();
+		if (!initEsClient())
+			return false;
+		Map<Table, File> files = createOutPutFiles(appConfigDir, exportFromEs);
+		if (files == null) {
+			return false;
+		}
+		if (exportFromEs && filesEmpty(files)) {
+			Map<Table, PrintWriter> printerWritersMap = createWriters(files);
+			if (printerWritersMap == null) {
+				return false;
+			}
+			try {
+				ImmutableOpenMap<String, IndexMetaData> indexData = getIndexData();
+				for (ObjectCursor<String> key : indexData.keys()) {
+					if ("resources".equalsIgnoreCase(key.value)) {
+						if (!exportArtifacts(key.value, printerWritersMap)) {
+							return false;
+						}
+					} else if (key.value.startsWith("auditingevents")) {
+						if (!exportAudit(key.value, printerWritersMap)) {
+							return false;
+						}
+					}
+				}
+			} finally {
+				if (elasticSearchClient != null) {
+					elasticSearchClient.close();
+				}
+				for (PrintWriter writer : printerWritersMap.values()) {
+					writer.close();
+				}
+			}
+		}
+		if (importToCassandra && !importToCassndra(files)) {
+			return false;
+		}
+
+		return true;
+	}
+
+	private void initFormater() {
+		simpleDateFormat = new SimpleDateFormat(dateFormatPattern);
+		simpleDateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
+	}
+
+	private boolean initEsClient() {
+		String configHome = System.getProperty("config.home");
+		URL url = null;
+		Settings settings = null;
+		try {
+			if (SystemUtils.IS_OS_WINDOWS) {
+				url = new URL("file:///" + configHome + "/elasticsearch.yml");
+			} else {
+				url = new URL("file:" + configHome + "/elasticsearch.yml");
+			}
+			log.debug("URL {}", url);
+			settings = Settings.settingsBuilder().loadFromPath(Paths.get(url.toURI())).build();
+		} catch (MalformedURLException | URISyntaxException e1) {
+			log.error("Failed to create URL in order to load elasticsearch yml", e1);
+			return true;
+		}
+
+		this.elasticSearchClient = new ElasticSearchClient();
+		this.elasticSearchClient.setClusterName(settings.get("cluster.name"));
+		this.elasticSearchClient.setLocal(settings.get("elasticSearch.local"));
+		this.elasticSearchClient.setTransportClient(settings.get("elasticSearch.transportclient"));
+		try {
+			elasticSearchClient.initialize();
+		} catch (URISyntaxException e) {
+			e.printStackTrace();
+			return false;
+		}
+		return true;
+	}
+
+	/**
+	 * the method clears all the cassandra tables
+	 */
+	private void truncateCassandraTable() {
+		log.info("import failed. truncating Cassandra tables.");
+		artifactCassandraDao.deleteAllArtifacts();
+		auditCassandraDao.deleteAllAudit();
+	}
+
+	/**
+	 * the method imports the records from the files into cassandra
+	 * 
+	 * @param files
+	 *            a map of files holding
+	 * @return true if the operation was successful
+	 */
+	private boolean importToCassndra(Map<Table, File> files) {
+		log.info("starting to import date into Cassandra.");
+		if (!validtaTablsNotEmpty(files))
+			return true;
+		for (Table table : files.keySet()) {
+			log.info("importing recordes into {}", table.getTableDescription().getTableName());
+			if (!handleImport(files, table)) {
+				truncateCassandraTable();
+				return false;
+			}
+		}
+		log.info("finished to import date into Cassandra.");
+		return true;
+	}
+
+	private boolean validtaTablsNotEmpty(Map<Table, File> files) {
+		for (Table table : files.keySet()) {
+			Either<Boolean, CassandraOperationStatus> isTableEmptyRes = checkIfTableIsEmpty(table);
+			if (isTableEmptyRes.isRight() || !isTableEmptyRes.left().value()) {
+				log.error("Cassandra table {} is not empty operation aborted.",
+						table.getTableDescription().getTableName());
+				return false;
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * the method retrieves the fields from the given map and praprs them for
+	 * storage as an audit according to the table name
+	 * 
+	 * @param map
+	 *            the map from which we will retrive the fields enum values
+	 * @param table
+	 *            the table we are going to store the record in.
+	 * @return a enummap representing the audit record that is going to be
+	 *         created.
+	 */
+	private EnumMap<AuditingFieldsKeysEnum, Object> createAuditMap(Map<String, String> map, Table table) {
+		EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<>(AuditingFieldsKeysEnum.class);
+		switch (table) {
+		case USER_ADMIN_EVENT:
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, map.get("SERVICE_INSTANCE_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_USER_AFTER, map.get("USER_AFTER"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_USER_BEFORE, map.get("USER_BEFORE"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, map.get("MODIFIER"));
+			break;
+		case USER_ACCESS_EVENT:
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, map.get("SERVICE_INSTANCE_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_USER_UID, map.get("USER"));
+			break;
+		case RESOURCE_ADMIN_EVENT:
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, map.get("SERVICE_INSTANCE_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_INVARIANT_UUID, map.get("INVARIANT_UUID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_VERSION, map.get("CURR_VERSION"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_STATE, map.get("CURR_STATE"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ID, map.get("DID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, map.get("MODIFIER"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_PREV_VERSION, map.get("PREV_VERSION"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_PREV_STATE, map.get("PREV_STATE"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, map.get("RESOURCE_NAME"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, map.get("RESOURCE_TYPE"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_DPREV_STATUS, map.get("DPREV_STATUS"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_DCURR_STATUS, map.get("DCURR_STATUS"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TOSCA_NODE_TYPE, map.get("TOSCA_NODE_TYPE"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_COMMENT, map.get("COMMENT"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ARTIFACT_DATA, map.get("ARTIFACT_DATA"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_PREV_ARTIFACT_UUID, map.get("PREV_ARTIFACT_UUID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_CURR_ARTIFACT_UUID, map.get("CURR_ARTIFACT_UUID"));
+			break;
+		case DISTRIBUTION_DOWNLOAD_EVENT:
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, map.get("SERVICE_INSTANCE_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_RESOURCE_URL, map.get("RESOURCE_URL"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_CONSUMER_ID, map.get("CONSUMER_ID"));
+			break;
+		case DISTRIBUTION_ENGINE_EVENT:
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, map.get("SERVICE_INSTANCE_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
+			if (map.get("TOPIC_NAME") != null) {
+				if (map.get("TOPIC_NAME").contains("-STATUS-")) {
+					auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_STATUS_TOPIC_NAME,
+							map.get("TOPIC_NAME"));
+				} else {
+					auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_NOTIFICATION_TOPIC_NAME,
+							map.get("TOPIC_NAME"));
+				}
+			} else {
+				auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_STATUS_TOPIC_NAME,
+						map.get("DSTATUS_TOPIC"));
+				auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_NOTIFICATION_TOPIC_NAME,
+						map.get("DNOTIF_TOPIC"));
+			}
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_TOPIC_NAME, map.get("TOPIC_NAME"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ROLE, map.get("ROLE"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_API_KEY, map.get("API_KEY"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ENVRIONMENT_NAME, map.get("D_ENV"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_CONSUMER_ID, map.get("CONSUMER_ID"));
+			break;
+		case DISTRIBUTION_NOTIFICATION_EVENT:
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, map.get("SERVICE_INSTANCE_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_STATE, map.get("CURR_STATE"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_VERSION, map.get("CURR_VERSION"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ID, map.get("DID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, map.get("MODIFIER"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, map.get("RESOURCE_NAME"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, map.get("RESOURCE_TYPE"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_TOPIC_NAME, map.get("TOPIC_NAME"));
+			break;
+		case DISTRIBUTION_STATUS_EVENT:
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, map.get("SERVICE_INSTANCE_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_RESOURCE_URL, map.get("RESOURCE_URL"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ID, map.get("DID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_TOPIC_NAME, map.get("TOPIC_NAME"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_CONSUMER_ID, map.get("CONSUMER_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_STATUS_TIME, map.get("STATUS_TIME"));
+			break;
+		case DISTRIBUTION_DEPLOY_EVENT:
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, map.get("SERVICE_INSTANCE_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ID, map.get("DID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, map.get("RESOURCE_NAME"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, map.get("RESOURCE_TYPE"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, map.get("MODIFIER"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_VERSION, map.get("CURR_VERSION"));
+			break;
+		case DISTRIBUTION_GET_UEB_CLUSTER_EVENT:
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, map.get("SERVICE_INSTANCE_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
+			if (map.get("STATUS_DESC") != null) {
+				auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("STATUS_DESC"));
+			} else {
+				auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
+			}
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_CONSUMER_ID, map.get("CONSUMER_ID"));
+			break;
+		case AUTH_EVENT:
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_AUTH_USER, map.get("USER"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_AUTH_URL, map.get("URL"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_AUTH_STATUS, map.get("AUTH_STATUS"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_AUTH_REALM, map.get("REALM"));
+			break;
+		case CONSUMER_EVENT:
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, map.get("MODIFIER"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ECOMP_USER, map.get("ECOMP_USER"));
+			break;
+		case CATEGORY_EVENT:
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, map.get("MODIFIER"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, map.get("SERVICE_INSTANCE_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_CATEGORY_NAME, map.get("CATEGORY_NAME"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SUB_CATEGORY_NAME, map.get("SUB_CATEGORY_NAME"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_GROUPING_NAME, map.get("GROUPING_NAME"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, map.get("RESOURCE_TYPE"));
+			break;
+		case GET_USERS_LIST_EVENT:
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, map.get("MODIFIER"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DETAILS, map.get("DETAILS"));
+			break;
+		case GET_CATEGORY_HIERARCHY_EVENT:
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, map.get("TIMESTAMP"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, map.get("ACTION"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, map.get("DESC"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, map.get("STATUS"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, map.get("MODIFIER"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, map.get("REQUEST_ID"));
+			auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DETAILS, map.get("DETAILS"));
+			break;
+		default:
+			auditingFields = null;
+			break;
+		}
+		return auditingFields;
+	}
+
+	/**
+	 * the method reads the content of the file intended for a given table, and
+	 * sores them in cassandra
+	 * 
+	 * @param files
+	 *            a map of files from which the recordes will be retrieved.
+	 * @param table
+	 *            the name of the table we want to look up in the files and sore
+	 *            in Cassandra // * @param store the function to call when
+	 *            storing recordes in cassndra
+	 * @return true if the operation was successful
+	 */
+	private boolean handleImport(Map<Table, File> files, Table table) {
+		BufferedReader br = null;
+		try {
+			br = new BufferedReader(new FileReader(files.get(table)));
+			String line = null;
+			while ((line = br.readLine()) != null) {
+				CassandraOperationStatus res = null;
+				if (Table.ARTIFACT.equals(table)) {
+					res = artifactCassandraDao.saveArtifact(jsonMapper.readValue(line, ESArtifactData.class));
+				} else {
+					Type type = new TypeToken<Map<String, String>>() {
+					}.getType();
+					Map<String, String> map = gson.fromJson(line, type);
+					EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = createAuditMap(map, table);
+					AuditingGenericEvent recordForCassandra = null;
+					try {
+						recordForCassandra = createAuditRecord(auditingFields);
+					} catch (ParseException e) {
+						log.error("filed to parse time stemp in recored {}", auditingFields);
+						return false;
+					}
+
+					res = auditCassandraDao.saveRecord(recordForCassandra);
+				}
+				if (!res.equals(CassandraOperationStatus.OK)) {
+					log.error("save recored to cassndra {} failed with status {} aborting.",
+							table.getTableDescription().getTableName(), res);
+					return false;
+				}
+			}
+			return true;
+		} catch (IOException e) {
+			log.error("failed to read file", e);
+			return false;
+		} finally {
+			if (br != null) {
+				try {
+					br.close();
+				} catch (IOException e) {
+					log.error("failed to close file reader", e);
+				}
+			}
+		}
+	}
+
+	/**
+	 * the method checks if the given table is empty
+	 * 
+	 * @param table
+	 *            the name of the table we want to check
+	 * @return true if the table is empty
+	 */
+	private Either<Boolean, CassandraOperationStatus> checkIfTableIsEmpty(Table table) {
+		if (Table.ARTIFACT.equals(table)) {
+			return artifactCassandraDao.isTableEmpty(table.getTableDescription().getTableName());
+		} else {
+			return auditCassandraDao.isTableEmpty(table.getTableDescription().getTableName());
+		}
+	}
+
+	private boolean filesEmpty(Map<Table, File> files) {
+		for (Table table : files.keySet()) {
+			File file = files.get(table);
+			if (file.length() != 0) {
+				log.info("file:{} is not empty skipping export", table.getTableDescription().getTableName());
+				return false;
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * the method reads the records from es index of audit's into a file as
+	 * json's.
+	 * 
+	 * @param value
+	 *            the name of the index we want
+	 * @param printerWritersMap
+	 *            a map of the writers we use to write to a file.
+	 * @return true in case the export was successful.
+	 */
+	private boolean exportAudit(String value, Map<Table, PrintWriter> printerWritersMap) {
+		log.info("stratng to export audit data from es index{} to file.", value);
+		QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
+		SearchResponse scrollResp = elasticSearchClient.getClient().prepareSearch(value).setScroll(new TimeValue(60000))
+				.setQuery(queryBuilder).setSize(100).execute().actionGet();
+		while (true) {
+			for (SearchHit hit : scrollResp.getHits().getHits()) {
+				PrintWriter out = printerWritersMap.get(TypeToTableMapping.getTableByType(hit.getType()));
+				out.println(hit.getSourceAsString());
+			}
+			scrollResp = elasticSearchClient.getClient().prepareSearchScroll(scrollResp.getScrollId())
+					.setScroll(new TimeValue(60000)).execute().actionGet();
+			if (scrollResp.getHits().getHits().length == 0) {
+				break;
+
+			}
+		}
+
+		log.info("export audit data from es to file. finished succsesfully");
+		return true;
+	}
+
+	/**
+	 * the method reads the records from es index of resources into a file as
+	 * json's.
+	 *
+	 * @param index
+	 *            the name of the index we want to read
+	 * @param printerWritersMap
+	 *            a map of the writers we use to write to a file.
+	 * @return true in case the export was successful.
+	 */
+	private boolean exportArtifacts(String index, Map<Table, PrintWriter> printerWritersMap) {
+		log.info("stratng to export artifact data from es to file.");
+		PrintWriter out = printerWritersMap.get(Table.ARTIFACT);
+		QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
+		SearchResponse scrollResp = elasticSearchClient.getClient().prepareSearch(index).setScroll(new TimeValue(60000))
+				.setQuery(queryBuilder).setSize(100).execute().actionGet();
+		while (true) {
+			for (SearchHit hit : scrollResp.getHits().getHits()) {
+				;
+				out.println(hit.getSourceAsString());
+			}
+			scrollResp = elasticSearchClient.getClient().prepareSearchScroll(scrollResp.getScrollId())
+					.setScroll(new TimeValue(60000)).execute().actionGet();
+			if (scrollResp.getHits().getHits().length == 0) {
+				break;
+
+			}
+		}
+
+		log.info("export artifact data from es to file. finished succsesfully");
+		return true;
+	}
+
+	/**
+	 * the method retrieves all the indexes from elasticsearch
+	 * 
+	 * @return a map of indexes and there metadata
+	 */
+	private ImmutableOpenMap<String, IndexMetaData> getIndexData() {
+		return elasticSearchClient.getClient().admin().cluster().prepareState().get().getState().getMetaData()
+				.getIndices();
+	}
+
+	/**
+	 * the method creates all the files and dir which holds them. in case the
+	 * files exist they will not be created again.
+	 * 
+	 * @param appConfigDir
+	 *            the base path under which the output dir will be created and
+	 *            the export result files the created filesa are named according
+	 *            to the name of the table into which it will be imported.
+	 * @param exportToEs
+	 *            if true all the export files will be recreated
+	 * @returnthe returns a map of tables and the files representing them them
+	 */
+	private Map<Table, File> createOutPutFiles(String appConfigDir, boolean exportToEs) {
+		Map<Table, File> result = new EnumMap<Table, File>(Table.class);
+		File outputDir = new File(appConfigDir + "/output/");
+		if (!createOutPutFolder(outputDir)) {
+			return null;
+		}
+		for (Table table : Table.values()) {
+			File file = new File(outputDir + "/" + table.getTableDescription().getTableName());
+			if (exportToEs) {
+				try {
+					if (file.exists()) {
+						Files.delete(file.toPath());
+					}
+				} catch (IOException e) {
+					log.error("failed to delete output file " + file.getAbsolutePath(), e);
+					return null;
+				}
+				file = new File(outputDir + "/" + table.getTableDescription().getTableName());
+			}
+			if (!file.exists()) {
+				try {
+					file.createNewFile();
+				} catch (IOException e) {
+					log.error("failed to create output file " + file.getAbsolutePath(), e);
+					return null;
+				}
+			}
+			result.put(table, file);
+
+		}
+		return result;
+	}
+
+	/**
+	 * the method create the writers to each file
+	 * 
+	 * @param files
+	 *            a map of the files according to table
+	 * @return returns a map of writers according to table.
+	 */
+	private Map<Table, PrintWriter> createWriters(Map<Table, File> files) {
+		Map<Table, PrintWriter> printerWritersMap = new EnumMap<>(Table.class);
+		try {
+			for (Table table : files.keySet()) {
+				log.info("creating writer for {}", table);
+				File file = files.get(table);
+				FileWriter fw = new FileWriter(file, true);
+				BufferedWriter bw = new BufferedWriter(fw);
+				PrintWriter out = new PrintWriter(bw);
+				printerWritersMap.put(table, out);
+				log.info("creating writer for {} was successful", table);
+			}
+		} catch (IOException e) {
+			log.error("create writer to file failed", e);
+			return null;
+		}
+		return printerWritersMap;
+	}
+
+	/**
+	 * the method creates the output dir in case it does not exist
+	 * 
+	 * @param outputDir
+	 *            the path under wich the directory will be created.
+	 * @return true in case the create was succsesful or the dir already exists
+	 */
+	private boolean createOutPutFolder(File outputDir) {
+		if (!outputDir.exists()) {
+			log.info("creating output dir" + outputDir.getAbsolutePath());
+			try {
+				Files.createDirectories(outputDir.toPath());
+			} catch (IOException e) {
+				log.error("failed to create output dir" + outputDir.getAbsolutePath(), e);
+				return false;
+			}
+		}
+		return true;
+	}
+
+	public enum TypeToTableMapping {
+		USER_ADMIN_EVENT_TYPE(AuditingTypesConstants.USER_ADMIN_EVENT_TYPE,
+				Table.USER_ADMIN_EVENT), USER_ACCESS_EVENT_TYPE(AuditingTypesConstants.USER_ACCESS_EVENT_TYPE,
+						Table.USER_ACCESS_EVENT), RESOURCE_ADMIN_EVENT_TYPE(
+								AuditingTypesConstants.RESOURCE_ADMIN_EVENT_TYPE,
+								Table.RESOURCE_ADMIN_EVENT), DISTRIBUTION_DOWNLOAD_EVENT_TYPE(
+										AuditingTypesConstants.DISTRIBUTION_DOWNLOAD_EVENT_TYPE,
+										Table.DISTRIBUTION_DOWNLOAD_EVENT), DISTRIBUTION_ENGINE_EVENT_TYPE(
+												AuditingTypesConstants.DISTRIBUTION_ENGINE_EVENT_TYPE,
+												Table.DISTRIBUTION_ENGINE_EVENT), DISTRIBUTION_NOTIFICATION_EVENT_TYPE(
+														AuditingTypesConstants.DISTRIBUTION_NOTIFICATION_EVENT_TYPE,
+														Table.DISTRIBUTION_NOTIFICATION_EVENT), DISTRIBUTION_STATUS_EVENT_TYPE(
+																AuditingTypesConstants.DISTRIBUTION_STATUS_EVENT_TYPE,
+																Table.DISTRIBUTION_STATUS_EVENT), DISTRIBUTION_DEPLOY_EVENT_TYPE(
+																		AuditingTypesConstants.DISTRIBUTION_DEPLOY_EVENT_TYPE,
+																		Table.DISTRIBUTION_DEPLOY_EVENT), DISTRIBUTION_GET_UEB_CLUSTER_EVENT_TYPE(
+																				AuditingTypesConstants.DISTRIBUTION_GET_UEB_CLUSTER_EVENT_TYPE,
+																				Table.DISTRIBUTION_GET_UEB_CLUSTER_EVENT), AUTH_EVENT_TYPE(
+																						AuditingTypesConstants.AUTH_EVENT_TYPE,
+																						Table.AUTH_EVENT), CONSUMER_EVENT_TYPE(
+																								AuditingTypesConstants.CONSUMER_EVENT_TYPE,
+																								Table.CONSUMER_EVENT), CATEGORY_EVENT_TYPE(
+																										AuditingTypesConstants.CATEGORY_EVENT_TYPE,
+																										Table.CATEGORY_EVENT), GET_USERS_LIST_EVENT_TYPE(
+																												AuditingTypesConstants.GET_USERS_LIST_EVENT_TYPE,
+																												Table.GET_USERS_LIST_EVENT), GET_CATEGORY_HIERARCHY_EVENT_TYPE(
+																														AuditingTypesConstants.GET_CATEGORY_HIERARCHY_EVENT_TYPE,
+																														Table.GET_CATEGORY_HIERARCHY_EVENT);
+
+		String typeName;
+		Table table;
+
+		TypeToTableMapping(String typeName, Table table) {
+			this.typeName = typeName;
+			this.table = table;
+		}
+
+		public String getTypeName() {
+			return typeName;
+		}
+
+		public Table getTable() {
+			return table;
+		}
+
+		public static Table getTableByType(String type) {
+			for (TypeToTableMapping mapping : TypeToTableMapping.values()) {
+				if (mapping.getTypeName().equalsIgnoreCase(type)) {
+					return mapping.getTable();
+				}
+			}
+			return null;
+		}
+	}
+
+	public static AuditingGenericEvent createAuditRecord(EnumMap<AuditingFieldsKeysEnum, Object> auditingFields)
+			throws ParseException {
+		AuditingActionEnum actionEnum = AuditingActionEnum
+				.getActionByName((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_ACTION));
+		String tableName = actionEnum.getAuditingEsType();
+		AuditingGenericEvent event = null;
+		Date date = null;
+		switch (tableName) {
+		case AuditingTypesConstants.USER_ADMIN_EVENT_TYPE:
+			UserAdminEvent userAdminEvent = new UserAdminEvent(auditingFields);
+			date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
+			userAdminEvent.setTimestamp1(date);
+			event = userAdminEvent;
+			break;
+		case AuditingTypesConstants.AUTH_EVENT_TYPE:
+			AuthEvent authEvent = new AuthEvent(auditingFields);
+			date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
+			authEvent.setTimestamp1(date);
+			event = authEvent;
+			break;
+		case AuditingTypesConstants.CATEGORY_EVENT_TYPE:
+			CategoryEvent categoryEvent = new CategoryEvent(auditingFields);
+			date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
+			categoryEvent.setTimestamp1(date);
+			event = categoryEvent;
+			break;
+		case AuditingTypesConstants.RESOURCE_ADMIN_EVENT_TYPE:
+			ResourceAdminEvent resourceAdminEvent = new ResourceAdminEvent(auditingFields);
+			date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
+			resourceAdminEvent.setTimestamp1(date);
+			event = resourceAdminEvent;
+			break;
+		case AuditingTypesConstants.USER_ACCESS_EVENT_TYPE:
+			event = new UserAccessEvent(auditingFields);
+			UserAccessEvent userAccessEvent = new UserAccessEvent(auditingFields);
+			date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
+			userAccessEvent.setTimestamp1(date);
+			event = userAccessEvent;
+			break;
+		case AuditingTypesConstants.DISTRIBUTION_STATUS_EVENT_TYPE:
+			DistributionStatusEvent distributionStatusEvent = new DistributionStatusEvent(auditingFields);
+			date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
+			distributionStatusEvent.setTimestamp1(date);
+			event = distributionStatusEvent;
+			break;
+		case AuditingTypesConstants.DISTRIBUTION_DOWNLOAD_EVENT_TYPE:
+			DistributionDownloadEvent distributionDownloadEvent = new DistributionDownloadEvent(auditingFields);
+			date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
+			distributionDownloadEvent.setTimestamp1(date);
+			event = distributionDownloadEvent;
+			break;
+		case AuditingTypesConstants.DISTRIBUTION_ENGINE_EVENT_TYPE:
+			DistributionEngineEvent distributionEngineEvent = new DistributionEngineEvent(auditingFields);
+			date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
+			distributionEngineEvent.setTimestamp1(date);
+			event = distributionEngineEvent;
+			break;
+		case AuditingTypesConstants.DISTRIBUTION_NOTIFICATION_EVENT_TYPE:
+			DistributionNotificationEvent distributionNotificationEvent = new DistributionNotificationEvent(
+					auditingFields);
+			date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
+			distributionNotificationEvent.setTimestamp1(date);
+			event = distributionNotificationEvent;
+			break;
+		case AuditingTypesConstants.DISTRIBUTION_DEPLOY_EVENT_TYPE:
+			DistributionDeployEvent distributionDeployEvent = new DistributionDeployEvent(auditingFields);
+			date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
+			distributionDeployEvent.setTimestamp1(date);
+			event = distributionDeployEvent;
+			break;
+		case AuditingTypesConstants.DISTRIBUTION_GET_UEB_CLUSTER_EVENT_TYPE:
+			AuditingGetUebClusterEvent auditingGetUebClusterEvent = new AuditingGetUebClusterEvent(auditingFields);
+			date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
+			auditingGetUebClusterEvent.setTimestamp1(date);
+			event = auditingGetUebClusterEvent;
+			break;
+		case AuditingTypesConstants.CONSUMER_EVENT_TYPE:
+			ConsumerEvent consumerEvent = new ConsumerEvent(auditingFields);
+			date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
+			consumerEvent.setTimestamp1(date);
+			event = consumerEvent;
+			break;
+		case AuditingTypesConstants.GET_USERS_LIST_EVENT_TYPE:
+			GetUsersListEvent getUsersListEvent = new GetUsersListEvent(auditingFields);
+			date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
+			getUsersListEvent.setTimestamp1(date);
+			event = getUsersListEvent;
+			break;
+		case AuditingTypesConstants.GET_CATEGORY_HIERARCHY_EVENT_TYPE:
+			GetCategoryHierarchyEvent getCategoryHierarchyEvent = new GetCategoryHierarchyEvent(auditingFields);
+			date = simpleDateFormat.parse((String) auditingFields.get(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP));
+			getCategoryHierarchyEvent.setTimestamp1(date);
+			event = getCategoryHierarchyEvent;
+			break;
+
+		}
+		return event;
+	}
+
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/EsToCassandraDataMigrationConfig.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/EsToCassandraDataMigrationConfig.java
new file mode 100644
index 0000000000..2c0471fb17
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/EsToCassandraDataMigrationConfig.java
@@ -0,0 +1,51 @@
+/*-
+ * ============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.asdctool.impl;
+
+import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao;
+import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao;
+import org.openecomp.sdc.be.dao.cassandra.CassandraClient;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class EsToCassandraDataMigrationConfig {
+	@Bean(name = "DataMigrationBean")
+	public DataMigration dataMigration() {
+		return new DataMigration();
+	}
+
+	@Bean(name = "artifact-cassandra-dao")
+	public ArtifactCassandraDao artifactCassandraDao() {
+		return new ArtifactCassandraDao();
+	}
+
+	@Bean(name = "audit-cassandra-dao")
+	public AuditCassandraDao auditCassandraDao() {
+		return new AuditCassandraDao();
+	}
+
+	@Bean(name = "cassandra-client")
+	public CassandraClient cassandraClient() {
+		return new CassandraClient();
+	}
+
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/GraphMLConverter.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/GraphMLConverter.java
new file mode 100644
index 0000000000..bf62072235
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/GraphMLConverter.java
@@ -0,0 +1,694 @@
+/*-
+ * ============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.asdctool.impl;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.apache.commons.configuration.BaseConfiguration;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.tinkerpop.gremlin.structure.Direction;
+import org.apache.tinkerpop.gremlin.structure.Edge;
+import org.apache.tinkerpop.gremlin.structure.Element;
+import org.apache.tinkerpop.gremlin.structure.Graph;
+import org.apache.tinkerpop.gremlin.structure.Property;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.structure.io.IoCore;
+import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper;
+import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONReader;
+import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONWriter;
+import org.apache.tinkerpop.gremlin.structure.util.ElementHelper;
+import org.openecomp.sdc.asdctool.Utils;
+import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.gson.Gson;
+import com.thinkaurelius.titan.core.TitanEdge;
+import com.thinkaurelius.titan.core.TitanFactory;
+import com.thinkaurelius.titan.core.TitanGraph;
+import com.thinkaurelius.titan.core.TitanGraphQuery;
+import com.thinkaurelius.titan.core.TitanVertex;
+//import com.tinkerpop.blueprints.Direction;
+//import com.tinkerpop.blueprints.Edge;
+//import com.tinkerpop.blueprints.Vertex;
+//import com.tinkerpop.blueprints.util.ElementHelper;
+//import com.tinkerpop.blueprints.util.io.graphson.GraphSONReader;
+//import com.tinkerpop.blueprints.util.io.graphson.GraphSONWriter;
+
+public class GraphMLConverter {
+
+	private static Logger log = LoggerFactory.getLogger(GraphMLConverter.class.getName());
+
+	private Gson gson = new Gson();
+
+	public boolean importGraph(String[] args) {
+
+		TitanGraph graph = null;
+		try {
+			String titanFileLocation = args[1];
+			String inputFile = args[2];
+			graph = openGraph(titanFileLocation);
+
+			List<ImmutablePair<String, String>> propertiesCriteriaToDelete = new ArrayList<>();
+			ImmutablePair<String, String> immutablePair1 = new ImmutablePair<String, String>("healthcheckis", "GOOD");
+			ImmutablePair<String, String> immutablePair2 = new ImmutablePair<String, String>("nodeLabel", "user");
+			ImmutablePair<String, String> immutablePair3 = new ImmutablePair<String, String>("nodeLabel",
+					"resourceCategory");
+			ImmutablePair<String, String> immutablePair4 = new ImmutablePair<String, String>("nodeLabel",
+					"serviceCategory");
+
+			propertiesCriteriaToDelete.add(immutablePair1);
+			propertiesCriteriaToDelete.add(immutablePair2);
+			propertiesCriteriaToDelete.add(immutablePair3);
+			propertiesCriteriaToDelete.add(immutablePair4);
+
+			boolean result = importJsonGraph(graph, inputFile, propertiesCriteriaToDelete);
+
+			return result;
+
+		} catch (Exception e) {
+			e.printStackTrace();
+			return false;
+		} finally {
+			if (graph != null) {
+				// graph.shutdown();
+				graph.close();
+			}
+		}
+
+	}
+
+	public boolean exportGraph(String[] args) {
+
+		TitanGraph graph = null;
+		try {
+			String titanFileLocation = args[1];
+			String outputDirectory = args[2];
+			graph = openGraph(titanFileLocation);
+
+			String result = exportJsonGraph(graph, outputDirectory);
+
+			if (result == null) {
+				return false;
+			}
+
+			System.out.println("Exported file=" + result);
+		} catch (Exception e) {
+			e.printStackTrace();
+			return false;
+		} finally {
+			if (graph != null) {
+				// graph.shutdown();
+				graph.close();
+			}
+		}
+
+		return true;
+	}
+
+	public String exportGraphMl(String[] args) {
+
+		TitanGraph graph = null;
+		String result = null;
+		try {
+			String titanFileLocation = args[1];
+			String outputDirectory = args[2];
+			graph = openGraph(titanFileLocation);
+
+			result = exportGraphMl(graph, outputDirectory);
+
+			System.out.println("Exported file=" + result);
+		} catch (Exception e) {
+			e.printStackTrace();
+			return null;
+		} finally {
+			if (graph != null) {
+				graph.close();
+			}
+		}
+
+		return result;
+	}
+
+	public boolean findErrorInJsonGraph(String[] args) {
+
+		TitanGraph graph = null;
+		try {
+			String titanFileLocation = args[1];
+			String outputDirectory = args[2];
+			graph = openGraph(titanFileLocation);
+
+			String result = findErrorInJsonGraph(graph, outputDirectory);
+
+			if (result == null) {
+				return false;
+			}
+
+			System.out.println("Exported file=" + result);
+		} catch (Exception e) {
+			e.printStackTrace();
+			return false;
+		} finally {
+			if (graph != null) {
+				// graph.shutdown();
+				graph.close();
+			}
+		}
+
+		return true;
+	}
+
+	public TitanGraph openGraph(String titanFileLocation) {
+
+		TitanGraph graph = TitanFactory.open(titanFileLocation);
+
+		return graph;
+
+	}
+
+	public String exportJsonGraph(TitanGraph graph, String outputDirectory) {
+
+		String result = null;
+
+		// GraphMLWriter graphMLWriter = new GraphMLWriter(graph);
+
+		String outputFile = outputDirectory + File.separator + "exportGraph." + System.currentTimeMillis() + ".json";
+
+		OutputStream out = null;
+		try {
+			out = new BufferedOutputStream(new FileOutputStream(outputFile));
+
+			// GraphSONWriter.outputGraph(graph, outputFile);
+			final GraphSONWriter.Builder builder = GraphSONWriter.build();
+			final GraphSONMapper mapper = newGraphSONMapper(graph);
+			builder.mapper(mapper);
+			final GraphSONWriter writer = builder.create();
+			writer.writeGraph(out, graph);
+
+			// GraphSONWriter create = GraphSONWriter.build(). create();
+			// create.writeGraph(out, graph);
+
+			// graph.commit();
+			graph.tx().commit();
+
+			result = outputFile;
+
+		} catch (Exception e) {
+			e.printStackTrace();
+			graph.tx().rollback();
+		} finally {
+			try {
+				if (out != null) {
+					out.close();
+				}
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+		return result;
+
+	}
+
+	public String exportGraphMl(TitanGraph graph, String outputDirectory) {
+		String result = null;
+		String outputFile = outputDirectory + File.separator + "exportGraph." + System.currentTimeMillis() + ".graphml";
+		try {
+			try (final OutputStream os = new BufferedOutputStream(new FileOutputStream(outputFile))) {
+				graph.io(IoCore.graphml()).writer().normalize(true).create().writeGraph(os, graph);
+			}
+			result = outputFile;
+			graph.tx().commit();
+		} catch (Exception e) {
+			graph.tx().rollback();
+			e.printStackTrace();
+		}
+		return result;
+
+	}
+
+	private static GraphSONMapper newGraphSONMapper(final Graph graph) {
+		final GraphSONMapper.Builder builder = graph.io(IoCore.graphson()).mapper();
+		// Different failure with embedded type info.
+		// builder.embedTypes(true);
+		return builder.create();
+	}
+
+	public boolean importJsonGraph(TitanGraph graph, String graphJsonFile,
+			List<ImmutablePair<String, String>> propertiesCriteriaToDelete) {
+
+		boolean result = false;
+
+		InputStream is = null;
+
+		try {
+
+			if (propertiesCriteriaToDelete != null) {
+				for (Entry<String, String> entry : propertiesCriteriaToDelete
+
+				) {
+
+					String key = entry.getKey();
+					String value = entry.getValue();
+					Iterator iterator = graph.query().has(key, value).vertices().iterator();
+					while (iterator.hasNext()) {
+						Vertex vertex = (Vertex) iterator.next();
+						vertex.remove();
+						System.out.println("Remove vertex of type " + key + " and value " + value);
+					}
+
+				}
+			}
+			File file = new File(graphJsonFile);
+			if (false == file.isFile()) {
+				System.out.println("File " + graphJsonFile + " cannot be found.");
+				return result;
+			}
+
+			is = new BufferedInputStream(new FileInputStream(graphJsonFile));
+			System.out.println("Before importing file " + graphJsonFile);
+
+			// GraphSONReader.inputGraph(graph, graphJsonFile);
+			GraphSONReader create = GraphSONReader.build().create();
+			create.readGraph(is, graph);
+
+			// graph.commit();
+			graph.tx().commit();
+
+			result = true;
+
+		} catch (Exception e) {
+			System.out.println("Failed to import graph " + e.getMessage());
+			e.printStackTrace();
+			// graph.rollback();
+			graph.tx().rollback();
+		} finally {
+			try {
+				if (is != null) {
+					is.close();
+				}
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+
+		return result;
+
+	}
+
+	public String findErrorInJsonGraph(TitanGraph graph, String outputDirectory) {
+
+		boolean runVertexScan = false;
+		boolean runEdgeScan = false;
+
+		String result = null;
+
+		// GraphMLWriter graphMLWriter = new GraphMLWriter(graph);
+
+		String outputFile = outputDirectory + File.separator + "exportGraph." + System.currentTimeMillis() + ".json";
+
+		OutputStream out = null;
+		try {
+			out = new BufferedOutputStream(new FileOutputStream(outputFile));
+
+			if (runEdgeScan) {
+
+				Vertex vertexFrom = null;
+				Vertex vertexTo = null;
+				Edge edge = null;
+
+				// Iterable<Edge> edges = graph.getEdges();
+				// Iterable<Edge> edges = graph.query().edges();
+				Iterable<TitanEdge> edges = graph.query().edges();
+				// Iterator<Edge> iterator = edges.iterator();
+				Iterator<TitanEdge> iterator = edges.iterator();
+				while (iterator.hasNext()) {
+
+					try {
+
+						edge = iterator.next();
+
+						// vertexFrom = edge.getVertex(Direction.OUT);
+						// vertexTo = edge.getVertex(Direction.IN);
+						vertexFrom = edge.outVertex();
+						vertexTo = edge.inVertex();
+
+						BaseConfiguration conf = new BaseConfiguration();
+						conf.setProperty("storage.backend", "inmemory");
+						TitanGraph openGraph = Utils.openGraph(conf);
+
+						TitanVertex addVertexFrom = openGraph.addVertex();
+						// ElementHelper.setProperties(addVertexFrom,
+						// ElementHelper.getProperties(vertexFrom));
+						Utils.setProperties(addVertexFrom, Utils.getProperties(vertexFrom));
+
+						TitanVertex addVertexTo = openGraph.addVertex();
+						// ElementHelper.setProperties(addVertexTo,
+						// ElementHelper.getProperties(vertexTo));
+						Utils.setProperties(addVertexTo, Utils.getProperties(vertexTo));
+
+						// Edge addEdge = openGraph.addEdge(null, addVertexFrom,
+						// addVertexTo, edge.getLabel());
+
+						// Edge edge = tGraph.addEdge(null,
+						// fromV.left().value(), toV.left().value(), type);
+
+						Edge addEdge = addVertexFrom.addEdge(edge.label(), addVertexTo);
+						// ElementHelper.setProperties(addEdge,
+						// ElementHelper.getProperties(edge));
+						Utils.setProperties(addEdge, Utils.getProperties(edge));
+
+						// log.info("fromVertex=" +
+						// ElementHelper.getProperties(vertexFrom));
+						log.info("fromVertex=" + Utils.getProperties(vertexFrom));
+						// log.info("toVertex=" +
+						// ElementHelper.getProperties(vertexTo));
+						log.info("toVertex=" + Utils.getProperties(vertexTo));
+						// log.info("edge=" + edge.getLabel() + " " +
+						// ElementHelper.getProperties(edge));
+						log.info("edge=" + edge.label() + " " + Utils.getProperties(edge));
+
+						// GraphSONWriter.outputGraph(openGraph, outputFile);
+						GraphSONWriter create = GraphSONWriter.build().create();
+						create.writeGraph(out, openGraph);
+
+						// openGraph.rollback();
+						openGraph.tx().rollback();
+
+					} catch (Exception e) {
+						e.printStackTrace();
+
+						// log.error("fromVertex=" +
+						// ElementHelper.getProperties(vertexFrom));
+						log.error("fromVertex=" + Utils.getProperties(vertexFrom));
+						// log.error("toVertex=" +
+						// ElementHelper.getProperties(vertexTo));
+						log.error("toVertex=" + Utils.getProperties(vertexTo));
+						// log.error("edge=" + edge.getLabel() + " " +
+						// ElementHelper.getProperties(edge));
+						log.error("edge=" + edge.label() + " " + Utils.getProperties(edge));
+
+						break;
+
+					}
+				}
+
+				// graph.rollback();
+				graph.tx().rollback();
+
+			}
+
+			if (runVertexScan) {
+
+				Vertex vertex = null;
+				// Iterable<Vertex> vertices = graph.getVertices();
+
+				// Iterator<Vertex> iteratorVertex = vertices.iterator();
+				Iterator<Vertex> iteratorVertex = graph.vertices();
+				while (iteratorVertex.hasNext()) {
+
+					try {
+
+						vertex = iteratorVertex.next();
+
+						// Iterable<Edge> edges2 =
+						// vertex.getEdges(Direction.BOTH);
+
+						// Iterator<Edge> iterator2 = edges2.iterator();
+						Iterator<Edge> iterator2 = vertex.edges(Direction.BOTH);
+						if (false == iterator2.hasNext()) {
+
+							BaseConfiguration conf = new BaseConfiguration();
+							conf.setProperty("storage.backend", "inmemory");
+							TitanGraph openGraph = Utils.openGraph(conf);
+
+							TitanVertex addVertexFrom = openGraph.addVertex();
+							// ElementHelper.setProperties(addVertexFrom,
+							// ElementHelper.getProperties(vertex));
+							Utils.setProperties(addVertexFrom, Utils.getProperties(vertex));
+
+							// log.info("fromVertex=" +
+							// ElementHelper.getProperties(addVertexFrom));
+							log.info("fromVertex=" + Utils.getProperties(addVertexFrom));
+
+							// GraphSONWriter.outputGraph(openGraph,
+							// outputFile);
+							GraphSONWriter create = GraphSONWriter.build().create();
+							create.writeGraph(out, openGraph);
+
+							// openGraph.rollback();
+							openGraph.tx().rollback();
+
+						}
+
+					} catch (Exception e) {
+						e.printStackTrace();
+
+						// log.error("vertex=" +
+						// ElementHelper.getProperties(vertex));
+
+						GraphPropertiesDictionary[] values = GraphPropertiesDictionary.values();
+
+						// Object property1 =
+						// vertex.getProperty(GraphPropertiesDictionary.HEALTH_CHECK.getProperty());
+						Object property1 = vertex.value(GraphPropertiesDictionary.HEALTH_CHECK.getProperty());
+						System.out.println(property1);
+
+						// Object property2 = vertex.getProperty("healthcheck");
+						Object property2 = vertex.value("healthcheck");
+						System.out.println(property2);
+
+						// for (GraphPropertiesDictionary value : values) {
+						//
+						// System.out.println(property);
+						// }
+
+						break;
+
+					}
+				}
+
+				// graph.rollback();
+				graph.tx().rollback();
+
+			}
+
+			// Iterable<Vertex> vertices2 =
+			// graph.getVertices(GraphPropertiesDictionary.HEALTH_CHECK.getProperty(),
+			// "GOOD");
+			Iterable<TitanVertex> vertices2 = graph.query()
+					.has(GraphPropertiesDictionary.HEALTH_CHECK.getProperty(), "GOOD").vertices();
+			;
+			Vertex next = vertices2.iterator().next();
+
+			BaseConfiguration conf = new BaseConfiguration();
+			conf.setProperty("storage.backend", "inmemory");
+			TitanGraph openGraph = Utils.openGraph(conf);
+
+			// TitanVertex addVertexFrom = openGraph.addVertex();
+			//
+			// addVertexFrom.setProperty(GraphPropertiesDictionary.HEALTH_CHECK.getProperty(),
+			// "GOOD");
+			// addVertexFrom.setProperty("healthcheck",
+			// next.getProperty("healthcheck"));
+			//
+			// //next.remove();
+			//
+			// next.removeProperty("healthcheck");
+			// next.removeProperty("healthcheckis");
+			//
+			// next.remove();
+
+			// GraphSONWriter.outputGraph(openGraph, outputFile);
+
+			for (NodeTypeEnum nodeTypeEnum : NodeTypeEnum.values()) {
+				removeNodesByLabel(graph, nodeTypeEnum.getName());
+			}
+
+			// GraphSONWriter.outputGraph(graph, outputFile);
+
+			GraphSONWriter create = GraphSONWriter.build().create();
+			create.writeGraph(out, graph);
+
+			// graph.rollback();
+			graph.tx().rollback();
+
+		} catch (Exception e) {
+			e.printStackTrace();
+			// graph.rollback();
+			graph.tx().rollback();
+		} finally {
+			try {
+				if (out != null) {
+					out.close();
+				}
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+		return result;
+
+	}
+
+	private void removeNodesByLabel(TitanGraph graph, String label) {
+		Iterable<TitanVertex> vertices = graph.query().has(GraphPropertiesDictionary.LABEL.getProperty(), label)
+				.vertices();
+		Iterator<TitanVertex> iterator = vertices.iterator();
+		while (iterator.hasNext()) {
+			Vertex next2 = iterator.next();
+			next2.remove();
+		}
+	}
+
+	public static void clearGraph(TitanGraph graph) {
+
+		Iterable<TitanVertex> vertices = graph.query().vertices();
+
+		long erased = 0;
+
+		if (vertices != null) {
+			Iterator<TitanVertex> iterator = vertices.iterator();
+			while (iterator.hasNext()) {
+				Vertex vertex = iterator.next();
+				// graph.removeVertex(vertex);
+				vertex.remove();
+				erased++;
+			}
+
+		}
+
+		System.out.println("After erasing " + erased + " vertices.");
+		// graph.commit();
+		graph.tx().commit();
+	}
+
+	public String exportUsers(TitanGraph graph, String outputDirectory) {
+
+		List<Map<String, Object>> users = new ArrayList<>();
+		String result = null;
+
+		// GraphMLWriter graphMLWriter = new GraphMLWriter(graph);
+
+		String outputFile = outputDirectory + File.separator + "users." + System.currentTimeMillis() + ".json";
+
+		FileWriter fileWriter = null;
+		try {
+
+			TitanGraphQuery graphQuery = graph.query().has(GraphPropertiesDictionary.LABEL.getProperty(),
+					NodeTypeEnum.User.getName());
+
+			@SuppressWarnings("unchecked")
+			Iterable<TitanVertex> vertices = graphQuery.vertices();
+
+			if (vertices != null) {
+				for (Vertex v : vertices) {
+					Map<String, Object> properties = getProperties(v);
+					properties.remove(GraphPropertiesDictionary.LABEL.getProperty());
+					users.add(properties);
+				}
+			}
+
+			graph.tx().commit();
+
+			String jsonUsers = gson.toJson(users);
+
+			fileWriter = new FileWriter(outputFile);
+			fileWriter.write(jsonUsers);
+
+			result = outputFile;
+
+		} catch (Exception e) {
+			e.printStackTrace();
+			graph.tx().rollback();
+		} finally {
+			try {
+				if (fileWriter != null) {
+					fileWriter.close();
+				}
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+		return result;
+
+	}
+
+	public Map<String, Object> getProperties(Element element) {
+
+		Map<String, Object> result = new HashMap<String, Object>();
+		;
+
+		if (element.keys() != null && element.keys().size() > 0) {
+			Map<String, Property> propertyMap = ElementHelper.propertyMap(element,
+					element.keys().toArray(new String[element.keys().size()]));
+
+			for (Entry<String, Property> entry : propertyMap.entrySet()) {
+				String key = entry.getKey();
+				Object value = entry.getValue().value();
+
+				result.put(key, value);
+			}
+		}
+		return result;
+	}
+
+	public boolean exportUsers(String[] args) {
+
+		TitanGraph graph = null;
+		try {
+			String titanFileLocation = args[1];
+			String outputDirectory = args[2];
+			graph = openGraph(titanFileLocation);
+
+			String result = exportUsers(graph, outputDirectory);
+
+			if (result == null) {
+				return false;
+			}
+
+			System.out.println("Exported file=" + result);
+		} catch (Exception e) {
+			e.printStackTrace();
+			return false;
+		} finally {
+			if (graph != null) {
+				// graph.shutdown();
+				graph.close();
+			}
+		}
+
+		return true;
+	}
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/GraphMLDataAnalyzer.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/GraphMLDataAnalyzer.java
new file mode 100644
index 0000000000..77163b4cc5
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/GraphMLDataAnalyzer.java
@@ -0,0 +1,364 @@
+/*-
+ * ============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.asdctool.impl;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
+import org.apache.poi.ss.usermodel.Row;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.apache.poi.ss.usermodel.Workbook;
+import org.jdom2.Document;
+import org.jdom2.Element;
+import org.jdom2.filter.ElementFilter;
+import org.jdom2.input.SAXBuilder;
+import org.jdom2.util.IteratorIterable;
+
+public class GraphMLDataAnalyzer {
+
+	private static final String[] COMPONENT_SHEET_HEADER = { "uniqueId", "type", "name", "toscaResourceName",
+			"resourceType", "version", "deleted", "hasNonCalculatedReqCap" };
+	private static final String[] COMPONENT_INSTANCES_SHEET_HEADER = { "uniqueId", "name", "originUid", "originType",
+			"containerUid" };
+
+	public String analyzeGraphMLData(String[] args) {
+		String result = null;
+		try {
+			String mlFileLocation = args[0];
+			result = _analyzeGraphMLData(mlFileLocation);
+			System.out.println("Analyzed ML file=" + mlFileLocation + ", XLS result=" + result);
+		} catch (Exception e) {
+			e.printStackTrace();
+			return null;
+		}
+		return result;
+	}
+
+	private String _analyzeGraphMLData(String mlFileLocation) throws Exception {
+
+		// Parse ML file
+		SAXBuilder builder = new SAXBuilder();
+		File xmlFile = new File(mlFileLocation);
+		Document document = (Document) builder.build(xmlFile);
+
+		// XLS data file name
+		String outputFile = mlFileLocation.replace(".graphml", ".xls");
+		Workbook wb = new HSSFWorkbook();
+		FileOutputStream fileOut = new FileOutputStream(outputFile);
+		writeComponents(wb, document);
+		writeComponentInstances(wb, document);
+		wb.write(fileOut);
+		fileOut.close();
+		return outputFile;
+	}
+
+	private void writeComponents(Workbook wb, Document document) {
+		Sheet componentsSheet = wb.createSheet("Components");
+		Row currentRow = componentsSheet.createRow(0);
+		for (int i = 0; i < COMPONENT_SHEET_HEADER.length; i++) {
+			currentRow.createCell(i).setCellValue(COMPONENT_SHEET_HEADER[i]);
+		}
+
+		List<ComponentRow> components = getComponents(document);
+		int rowNum = 1;
+		for (ComponentRow row : components) {
+			currentRow = componentsSheet.createRow(rowNum++);
+			currentRow.createCell(0).setCellValue(row.getUniqueId());
+			currentRow.createCell(1).setCellValue(row.getType());
+			currentRow.createCell(2).setCellValue(row.getName());
+			currentRow.createCell(3).setCellValue(row.getToscaResourceName());
+			currentRow.createCell(4).setCellValue(row.getResourceType());
+			currentRow.createCell(5).setCellValue(row.getVersion());
+			currentRow.createCell(6).setCellValue(row.getIsDeleted() != null ? row.getIsDeleted().toString() : "false");
+			currentRow.createCell(7).setCellValue(row.getHasNonCalculatedReqCap());
+		}
+	}
+
+	private void writeComponentInstances(Workbook wb, Document document) {
+		Sheet componentsSheet = wb.createSheet("ComponentInstances");
+		Row currentRow = componentsSheet.createRow(0);
+		for (int i = 0; i < COMPONENT_INSTANCES_SHEET_HEADER.length; i++) {
+			currentRow.createCell(i).setCellValue(COMPONENT_INSTANCES_SHEET_HEADER[i]);
+		}
+		List<ComponentInstanceRow> components = getComponentInstances(document);
+		int rowNum = 1;
+		for (ComponentInstanceRow row : components) {
+			currentRow = componentsSheet.createRow(rowNum++);
+			currentRow.createCell(0).setCellValue(row.getUniqueId());
+			currentRow.createCell(1).setCellValue(row.getName());
+			currentRow.createCell(2).setCellValue(row.getOriginUid());
+			currentRow.createCell(3).setCellValue(row.getOriginType());
+			currentRow.createCell(4).setCellValue(row.getContainerUid());
+		}
+	}
+
+	private List<ComponentRow> getComponents(Document document) {
+		List<ComponentRow> res = new ArrayList<>();
+		Element root = document.getRootElement();
+		ElementFilter filter = new ElementFilter("graph");
+		Element graph = root.getDescendants(filter).next();
+		filter = new ElementFilter("edge");
+		IteratorIterable<Element> edges = graph.getDescendants(filter);
+		Set<String> componentsHavingReqOrCap = new HashSet<>();
+		filter = new ElementFilter("data");
+		for (Element edge : edges) {
+			IteratorIterable<Element> dataNodes = edge.getDescendants(filter);
+			for (Element data : dataNodes) {
+				String attributeValue = data.getAttributeValue("key");
+				switch (attributeValue) {
+				case "labelE":
+					String edgeLabel = data.getText();
+					if (edgeLabel.equals("REQUIREMENT") || edgeLabel.equals("CAPABILITY")) {
+						componentsHavingReqOrCap.add(edge.getAttributeValue("source"));
+					}
+					break;
+				}
+			}
+		}
+
+		filter = new ElementFilter("node");
+		IteratorIterable<Element> nodes = graph.getDescendants(filter);
+		filter = new ElementFilter("data");
+		for (Element element : nodes) {
+			IteratorIterable<Element> dataNodes = element.getDescendants(filter);
+			ComponentRow componentRow = new ComponentRow();
+			boolean isComponent = false;
+			for (Element data : dataNodes) {
+				String attributeValue = data.getAttributeValue("key");
+				switch (attributeValue) {
+				case "nodeLabel":
+					String nodeLabel = data.getText();
+					if (nodeLabel.equals("resource") || nodeLabel.equals("service")) {
+						isComponent = true;
+						componentRow.setType(nodeLabel);
+						String componentId = element.getAttributeValue("id");
+						componentRow.setHasNonCalculatedReqCap(componentsHavingReqOrCap.contains(componentId));
+					}
+					break;
+				case "uid":
+					componentRow.setUniqueId(data.getText());
+					break;
+				case "name":
+					componentRow.setName(data.getText());
+					break;
+				case "toscaResourceName":
+					componentRow.setToscaResourceName(data.getText());
+					break;
+				case "resourceType":
+					componentRow.setResourceType(data.getText());
+					break;
+				case "version":
+					componentRow.setVersion(data.getText());
+					break;
+				case "deleted":
+					componentRow.setIsDeleted(Boolean.parseBoolean(data.getText()));
+					break;
+				default:
+					break;
+				}
+			}
+			if (isComponent) {
+				res.add(componentRow);
+			}
+		}
+		return res;
+	}
+
+	private List<ComponentInstanceRow> getComponentInstances(Document document) {
+		List<ComponentInstanceRow> res = new ArrayList<>();
+		Element root = document.getRootElement();
+		ElementFilter filter = new ElementFilter("graph");
+		Element graph = root.getDescendants(filter).next();
+		filter = new ElementFilter("node");
+		IteratorIterable<Element> nodes = graph.getDescendants(filter);
+		filter = new ElementFilter("data");
+		for (Element element : nodes) {
+			IteratorIterable<Element> dataNodes = element.getDescendants(filter);
+			ComponentInstanceRow componentInstRow = new ComponentInstanceRow();
+			boolean isComponentInst = false;
+			for (Element data : dataNodes) {
+				String attributeValue = data.getAttributeValue("key");
+				switch (attributeValue) {
+				case "nodeLabel":
+					String nodeLabel = data.getText();
+					if (nodeLabel.equals("resourceInstance")) {
+						isComponentInst = true;
+					}
+					break;
+				case "uid":
+					componentInstRow.setUniqueId(data.getText());
+					break;
+				case "name":
+					componentInstRow.setName(data.getText());
+					break;
+				case "originType":
+					componentInstRow.setOriginType(data.getText());
+					break;
+				default:
+					break;
+				}
+			}
+			if (isComponentInst) {
+				// Assuming the uid is in standard form of
+				// <container>.<origin>.<name>
+				String uniqueId = componentInstRow.getUniqueId();
+				if (uniqueId != null) {
+					String[] split = uniqueId.split("\\.");
+					if (split.length == 3) {
+						componentInstRow.setContainerUid(split[0]);
+						componentInstRow.setOriginUid(split[1]);
+					}
+				}
+				res.add(componentInstRow);
+			}
+		}
+		return res;
+	}
+
+	private class ComponentRow {
+
+		private String uniqueId;
+		private String type;
+		private String name;
+		private String toscaResourceName;
+		private String resourceType;
+		private String version;
+		private Boolean isDeleted;
+		private Boolean hasNonCalculatedReqCap;
+
+		public Boolean getHasNonCalculatedReqCap() {
+			return hasNonCalculatedReqCap;
+		}
+
+		public void setHasNonCalculatedReqCap(Boolean hasNonCalculatedReqCap) {
+			this.hasNonCalculatedReqCap = hasNonCalculatedReqCap;
+		}
+
+		public String getType() {
+			return type;
+		}
+
+		public void setType(String type) {
+			this.type = type;
+		}
+
+		public String getUniqueId() {
+			return uniqueId;
+		}
+
+		public void setUniqueId(String uniqueId) {
+			this.uniqueId = uniqueId;
+		}
+
+		public String getName() {
+			return name;
+		}
+
+		public void setName(String name) {
+			this.name = name;
+		}
+
+		public String getToscaResourceName() {
+			return toscaResourceName;
+		}
+
+		public void setToscaResourceName(String toscaResourceName) {
+			this.toscaResourceName = toscaResourceName;
+		}
+
+		public String getResourceType() {
+			return resourceType;
+		}
+
+		public void setResourceType(String resourceType) {
+			this.resourceType = resourceType;
+		}
+
+		public String getVersion() {
+			return version;
+		}
+
+		public void setVersion(String version) {
+			this.version = version;
+		}
+
+		public Boolean getIsDeleted() {
+			return isDeleted;
+		}
+
+		public void setIsDeleted(Boolean deleted) {
+			this.isDeleted = deleted;
+		}
+	}
+
+	private class ComponentInstanceRow {
+		private String uniqueId;
+		private String name;
+		private String originUid;
+		private String originType;
+		private String containerUid;
+
+		public String getContainerUid() {
+			return containerUid;
+		}
+
+		public void setContainerUid(String containerUid) {
+			this.containerUid = containerUid;
+		}
+
+		public String getUniqueId() {
+			return uniqueId;
+		}
+
+		public void setUniqueId(String uniqueId) {
+			this.uniqueId = uniqueId;
+		}
+
+		public String getName() {
+			return name;
+		}
+
+		public void setName(String name) {
+			this.name = name;
+		}
+
+		public String getOriginUid() {
+			return originUid;
+		}
+
+		public void setOriginUid(String componentUid) {
+			this.originUid = componentUid;
+		}
+
+		public String getOriginType() {
+			return originType;
+		}
+
+		public void setOriginType(String originType) {
+			this.originType = originType;
+		}
+	}
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/PopulateComponentCache.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/PopulateComponentCache.java
new file mode 100644
index 0000000000..812d534f49
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/PopulateComponentCache.java
@@ -0,0 +1,388 @@
+/*-
+ * ============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.asdctool.impl;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+
+import org.apache.tinkerpop.gremlin.structure.VertexProperty;
+import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
+import org.openecomp.sdc.be.dao.cassandra.ComponentCassandraDao;
+import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
+import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.Product;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.be.model.Service;
+import org.openecomp.sdc.be.model.cache.ComponentCache;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.ProductOperation;
+import org.openecomp.sdc.be.model.operations.impl.ResourceOperation;
+import org.openecomp.sdc.be.model.operations.impl.ServiceOperation;
+import org.openecomp.sdc.be.resources.data.ComponentCacheData;
+import org.openecomp.sdc.be.resources.data.ESArtifactData;
+import org.openecomp.sdc.common.util.SerializationUtils;
+import org.openecomp.sdc.common.util.ZipUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import com.thinkaurelius.titan.core.TitanGraph;
+import com.thinkaurelius.titan.core.TitanVertex;
+
+import fj.data.Either;
+
+/**
+ * Created by esofer on 9/1/2016.
+ */
+public class PopulateComponentCache {
+
+	private static Logger log = LoggerFactory.getLogger(PopulateComponentCache.class.getName());
+
+	@Autowired
+	protected ComponentCassandraDao componentCassandraDao;
+
+	@Autowired
+	protected ResourceOperation resourceOperation;
+
+	@Autowired
+	protected ServiceOperation serviceOperation;
+
+	@Autowired
+	protected ProductOperation productOperation;
+
+	@Autowired
+	protected ComponentCache componentCache;
+
+	private void exit(String stage, int i) {
+		log.error("Failed on " + stage);
+		System.exit(i);
+
+	}
+
+	public void populateCache() {
+		populateCache(ComponentTypeEnum.RESOURCE);
+		populateCache(ComponentTypeEnum.SERVICE);
+		populateCache(ComponentTypeEnum.PRODUCT);
+	}
+
+	private void populateCache(ComponentTypeEnum componentTypeEnum) {
+
+		List<String> list = new ArrayList<>();
+		Either<TitanGraph, TitanOperationStatus> graph = resourceOperation.getTitanGenericDao().getGraph();
+		TitanGraph titanGraph = graph.left().value();
+		Iterable vertices = titanGraph.query()
+				.has(GraphPropertiesDictionary.LABEL.getProperty(), componentTypeEnum.name().toLowerCase()).vertices();
+
+		Iterator iterator = vertices.iterator();
+		while (iterator.hasNext()) {
+			TitanVertex vertex = (TitanVertex) iterator.next();
+
+			// VertexProperty<Object> state =
+			// vertex.property(GraphPropertiesDictionary.STATE.getProperty());
+			// String stateValue = (String)state.value();
+
+			// if (false ==
+			// stateValue.equalsIgnoreCase(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())
+			// ) {
+			VertexProperty<Object> uid = vertex.property(GraphPropertiesDictionary.UNIQUE_ID.getProperty());
+			String uidValue = (String) uid.value();
+
+			list.add(uidValue);
+			// }
+		}
+
+		int counter = 0;
+		for (String componentUid : list) {
+
+			long time1 = System.currentTimeMillis();
+
+			/////////////////////////////////////////////////////////////////////////////////////
+			// Pay attention. The component is fetched from the cache in case it
+			///////////////////////////////////////////////////////////////////////////////////// is
+			///////////////////////////////////////////////////////////////////////////////////// already
+			///////////////////////////////////////////////////////////////////////////////////// there.
+			/////////////////////////////////////////////////////////////////////////////////////
+			Component component = null;
+			switch (componentTypeEnum) {
+			case RESOURCE:
+				Either<Resource, StorageOperationStatus> resourceRes = resourceOperation.getComponent(componentUid,
+						false);
+				if (resourceRes.isRight()) {
+					exit("get resource", 1);
+				}
+				component = resourceRes.left().value();
+				break;
+			case SERVICE:
+				Either<Service, StorageOperationStatus> serviceRes = serviceOperation.getComponent(componentUid, false);
+				if (serviceRes.isRight()) {
+					exit("get service", 1);
+				}
+				component = serviceRes.left().value();
+				break;
+			case PRODUCT:
+				Either<Product, StorageOperationStatus> productRes = productOperation.getComponent(componentUid, false);
+				if (productRes.isRight()) {
+					exit("get product", 1);
+				}
+				component = productRes.left().value();
+				break;
+			default:
+				break;
+			}
+
+			if (component == null) {
+				exit("get component", 1);
+			}
+
+			long time2 = System.currentTimeMillis();
+			// System.out.println("fetch resource " + resource.getName());
+			// System.out.println("fetch resource time is " + (time2 - time1) +
+			// " ms");
+
+			boolean setComponent = componentCache.setComponent(component, componentTypeEnum.getNodeType());
+			if (setComponent) {
+				counter++;
+			}
+
+			/*
+			 * Either<byte[], Boolean> valueRes =
+			 * SerializationUtils.serializeExt(component);
+			 * 
+			 * if (valueRes.isRight()) { exit("serialize component " +
+			 * component.getName(), 2); } byte[] value =
+			 * valueRes.left().value(); log.info("byte[] size is " +
+			 * value.length); //System.out.println("byte[] size is " +
+			 * value.length);
+			 * 
+			 * byte[] zipped = null; try { zipped = ZipUtil.zipBytes(value);
+			 * //System.out.println("byte[] size after zip is " +
+			 * zipped.length);
+			 * 
+			 * ComponentCacheData componentCacheData = new ComponentCacheData();
+			 * componentCacheData.setDataAsArray(zipped);
+			 * componentCacheData.setIsZipped(true);
+			 * componentCacheData.setId(componentUid);
+			 * componentCacheData.setModificationTime(new
+			 * Date(component.getLastUpdateDate()));
+			 * componentCacheData.setType(component.getComponentType().name().
+			 * toLowerCase());
+			 * 
+			 * long averageInsertTimeInMilli =
+			 * writeResourceToCassandraComponent(componentCacheData); log.
+			 * info("After adding component {} to cassandra. Insert time is {} ms."
+			 * , componentUid, averageInsertTimeInMilli);
+			 * 
+			 * } catch (IOException e) { // TODO Auto-generated catch block
+			 * e.printStackTrace(); }
+			 */
+
+		}
+
+		log.debug("The number of saved components of type {} is {}. Total size is {}", componentTypeEnum, counter,
+				list.size());
+
+	}
+
+	private long writeResourceToCassandraComponent(ComponentCacheData componentCacheData) {
+
+		long startTime = System.currentTimeMillis();
+
+		// call to cassandra read
+		CassandraOperationStatus saveArtifact = componentCassandraDao.saveComponent(componentCacheData);
+		if (saveArtifact != CassandraOperationStatus.OK) {
+			exit("writeResourceToCassandra", 3);
+		}
+
+		long endTime = System.currentTimeMillis();
+
+		return (endTime - startTime);
+	}
+
+	private void deserializeByThreads(List<ESArtifactData> list, ExecutorService executor, int threadNumber) {
+
+		long fullSearchStart = System.currentTimeMillis();
+		// for (int k =0; k < parts; k++) {
+
+		List<List<ESArtifactData>> lists = new ArrayList<>();
+		for (int i = 0; i < threadNumber; i++) {
+			lists.add(new ArrayList<>());
+		}
+
+		List<Future<List<Resource>>> results = new ArrayList<>();
+		for (int i = 0; i < list.size(); i++) {
+			lists.get(i % threadNumber).add(list.get(i));
+		}
+
+		for (int i = 0; i < threadNumber; i++) {
+
+			// Callable<List<Resource>> worker = new
+			// MyDesrializabletCallable(lists.get(i), i);
+			Callable<List<Resource>> worker = new My3rdPartyDesrializabletCallable(lists.get(i), i);
+			Future<List<Resource>> submit = executor.submit(worker);
+			results.add(submit);
+		}
+
+		long fullSearchStart2 = System.currentTimeMillis();
+		for (Future<List<Resource>> future : results) {
+			try {
+				while (false == future.isDone()) {
+					Thread.sleep(1);
+				}
+
+			} catch (InterruptedException e) {
+				e.printStackTrace();
+			}
+		}
+		long fullSearchEnd2 = System.currentTimeMillis();
+		log.info("esofer time wait to threads finish " + ((fullSearchEnd2 - fullSearchStart2)) + " ms");
+		// }
+		long fullSearchEnd = System.currentTimeMillis();
+
+		log.info("esofer full desrialize time " + ((fullSearchEnd - fullSearchStart)) + " ms");
+		System.out.println("esofer full desrialize time " + ((fullSearchEnd - fullSearchStart)) + " ms");
+	}
+
+	public class MyDesrializabletCallable implements Callable<List<Resource>> {
+
+		List<ESArtifactData> list;
+		int i;
+
+		public MyDesrializabletCallable(List<ESArtifactData> list, int i) {
+			super();
+			this.list = list;
+			this.i = i;
+		}
+
+		@Override
+		public List<Resource> call() throws Exception {
+			List<Resource> resources = new ArrayList<>();
+			long startSer = System.currentTimeMillis();
+			long endSer = System.currentTimeMillis();
+			long startUnzip = System.currentTimeMillis();
+			long endUnzip = System.currentTimeMillis();
+
+			long avgUnzip = 0;
+			long avgSer = 0;
+			for (ESArtifactData esArtifactData : list) {
+
+				byte[] dataAsArray = esArtifactData.getDataAsArray();
+				startUnzip = System.nanoTime();
+				dataAsArray = ZipUtil.unzip(dataAsArray);
+				endUnzip = System.nanoTime();
+				avgUnzip += (endUnzip - startUnzip);
+
+				startSer = System.nanoTime();
+				Either<Object, Boolean> deserialize = SerializationUtils.deserialize(dataAsArray);
+				endSer = System.nanoTime();
+				avgSer += (endSer - startSer);
+				// Either<Object, Boolean> deserialize =
+				// SerializationUtils.deserialize(esArtifactData.getDataAsArray());
+				if (deserialize.isRight()) {
+					exit("convertByteArrayToResource " + deserialize.right().value(), 5);
+				}
+
+				Resource resource = (Resource) deserialize.left().value();
+				resources.add(resource);
+				// System.out.println("After desrialize T[" + i + "]resource " +
+				// resource.getUniqueId());
+			}
+
+			System.out.println("After desrialize average desrialize " + list.size() + " T[" + i + "] "
+					+ (avgSer / 1000 / list.size()) + " micro");
+			System.out.println(
+					"After desrialize average unzip T[" + i + "] " + (avgUnzip / 1000 / list.size()) + " micro");
+
+			////////////////////////
+			// maybe register most frequently used classes on conf
+			// write
+			// byte barray[] = conf.asByteArray(mySerializableObject);
+			// read
+			// MyObject object = (MyObject)conf.asObject(barray);
+
+			return resources;
+		}
+	}
+
+	public class My3rdPartyDesrializabletCallable implements Callable<List<Resource>> {
+
+		List<ESArtifactData> list;
+		int i;
+
+		public My3rdPartyDesrializabletCallable(List<ESArtifactData> list, int i) {
+			super();
+			this.list = list;
+			this.i = i;
+		}
+
+		@Override
+		public List<Resource> call() throws Exception {
+			List<Resource> resources = new ArrayList<>();
+			long startSer = System.currentTimeMillis();
+			long endSer = System.currentTimeMillis();
+			long startUnzip = System.currentTimeMillis();
+			long endUnzip = System.currentTimeMillis();
+
+			long avgUnzip = 0;
+			long avgSer = 0;
+			for (ESArtifactData esArtifactData : list) {
+
+				byte[] dataAsArray = esArtifactData.getDataAsArray();
+				startUnzip = System.nanoTime();
+				dataAsArray = ZipUtil.unzip(dataAsArray);
+				endUnzip = System.nanoTime();
+				avgUnzip += (endUnzip - startUnzip);
+
+				startSer = System.nanoTime();
+
+				Either<Resource, Boolean> deserializeExt = SerializationUtils.deserializeExt(dataAsArray,
+						Resource.class, "");
+
+				if (deserializeExt.isLeft()) {
+					Resource resource = deserializeExt.left().value();
+					// System.out.println("=============================================");
+					// System.out.println(resource.getCapabilities().size());
+					// System.out.println(resource.getRequirements().size());
+					endSer = System.nanoTime();
+					avgSer += (endSer - startSer);
+					resources.add(resource);
+					// System.out.println("After desrialize T[" + i + "]resource
+					// " + resource.getUniqueId());
+				}
+			}
+
+			System.out.println("After desrialize average desrialize " + list.size() + " T[" + i + "] "
+					+ (avgSer / 1000 / list.size()) + " micro");
+			System.out.println(
+					"After desrialize average unzip T[" + i + "] " + (avgUnzip / 1000 / list.size()) + " micro");
+
+			return resources;
+		}
+	}
+
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/ProductLogic.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/ProductLogic.java
new file mode 100644
index 0000000000..9f15c83dd8
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/ProductLogic.java
@@ -0,0 +1,103 @@
+/*-
+ * ============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.asdctool.impl;
+
+import com.thinkaurelius.titan.core.TitanFactory;
+import com.thinkaurelius.titan.core.TitanGraph;
+import com.thinkaurelius.titan.core.TitanVertex;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Created by mlando on 2/23/2016.
+ */
+public class ProductLogic {
+
+	private static Logger log = LoggerFactory.getLogger(ProductLogic.class.getName());
+
+	public boolean deleteAllProducts(String titanFile, String beHost, String bePort, String adminUser) {
+		log.debug("retrieving all products from graph");
+		RestUtils restUtils = null;
+		try {
+			List<String> productList = getAllProducts(titanFile);
+			restUtils = new RestUtils();
+			if (productList != null) {
+				for (String productUid : productList) {
+					Integer status = restUtils.deleteProduct(productUid, beHost, bePort, adminUser);
+				}
+				return true;
+			} else {
+				log.error("failed to get products from graph");
+				return false;
+			}
+		} finally {
+			if (restUtils != null) {
+				restUtils.closeClient();
+			}
+		}
+	}
+
+	private List<String> getAllProducts(String titanFile) {
+		TitanGraph graph = null;
+		try {
+			graph = openGraph(titanFile);
+			List<String> productsToDelete = new ArrayList<String>();
+			Iterable vertices = graph.query()
+					.has(GraphPropertiesDictionary.LABEL.getProperty(), NodeTypeEnum.Product.getName()).vertices();
+			if (vertices != null) {
+				Iterator<TitanVertex> iter = vertices.iterator();
+				while (iter.hasNext()) {
+					Vertex vertex = iter.next();
+					String id = vertex.value(GraphPropertiesDictionary.UNIQUE_ID.getProperty());
+					productsToDelete.add(id);
+				}
+			}
+
+			graph.tx().commit();
+			return productsToDelete;
+		} catch (Exception e) {
+			e.printStackTrace();
+			graph.tx().rollback();
+			return null;
+
+		} finally {
+			if (graph != null) {
+				graph.close();
+			}
+		}
+	}
+
+	private TitanGraph openGraph(String titanFileLocation) {
+
+		TitanGraph graph = TitanFactory.open(titanFileLocation);
+
+		return graph;
+
+	}
+
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/RestUtils.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/RestUtils.java
new file mode 100644
index 0000000000..c256ca09a4
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/RestUtils.java
@@ -0,0 +1,83 @@
+/*-
+ * ============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.asdctool.impl;
+
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpDelete;
+import org.apache.http.client.methods.HttpUriRequest;
+
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClients;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+
+/**
+ * Created by mlando on 2/23/2016.
+ */
+public class RestUtils {
+
+	final String DELETE_PRODUCT = "http://%s:%s/sdc2/rest/v1/catalog/products/%s";
+	final Integer DELETE_SUCCSES_RESPONSE = 200;
+
+	private static Logger log = LoggerFactory.getLogger(RestUtils.class.getName());
+	CloseableHttpClient httpClient;
+
+	public RestUtils() {
+		this.httpClient = HttpClients.createDefault();
+	}
+
+	private CloseableHttpResponse exacuteRequest(HttpUriRequest httpRequest) throws IOException {
+		log.debug("received http request: {}", httpRequest.toString());
+		return httpClient.execute(httpRequest);
+	}
+
+	public void closeClient() {
+		log.debug("closing http client");
+		try {
+			this.httpClient.close();
+			log.debug("closed http client");
+		} catch (IOException e) {
+			log.debug("close http client failed", e);
+
+		}
+	}
+
+	public Integer deleteProduct(String productUid, String beHost, String bePort, String adminUser) {
+		String url = String.format(DELETE_PRODUCT, beHost, bePort, productUid);
+		HttpDelete deleteRequest = new HttpDelete(url);
+		deleteRequest.setHeader("USER_ID", adminUser);
+		try (CloseableHttpResponse response = this.httpClient.execute(deleteRequest)) {
+			int status = response.getStatusLine().getStatusCode();
+			if (DELETE_SUCCSES_RESPONSE.equals(status)) {
+				log.debug("Product uid:{} succsesfully deleted", productUid);
+			} else {
+				log.error("Product uid:{} delete failed status {}", productUid, status);
+			}
+			return status;
+		} catch (IOException e) {
+			log.error("Product uid:" + productUid + " delete failed with exception", e);
+		}
+		return null;
+	}
+
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/UpdatePropertyOnVertex.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/UpdatePropertyOnVertex.java
new file mode 100644
index 0000000000..b480091723
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/UpdatePropertyOnVertex.java
@@ -0,0 +1,180 @@
+/*-
+ * ============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.asdctool.impl;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.openecomp.sdc.asdctool.Utils;
+import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
+import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.thinkaurelius.titan.core.TitanFactory;
+import com.thinkaurelius.titan.core.TitanGraph;
+import com.thinkaurelius.titan.core.TitanGraphQuery;
+
+public class UpdatePropertyOnVertex {
+
+	private static Logger log = LoggerFactory.getLogger(UpdatePropertyOnVertex.class.getName());
+
+	public Integer updatePropertyOnServiceAtLeastCertified(String titanFile, Map<String, Object> keyValueToSet,
+			List<Map<String, Object>> orCriteria) {
+
+		TitanGraph graph = null;
+
+		Integer numberOfUpdatedVertexes = 0;
+
+		try {
+			graph = openGraph(titanFile);
+
+			if (orCriteria != null && false == orCriteria.isEmpty()) {
+
+				for (Map<String, Object> criteria : orCriteria) {
+
+					TitanGraphQuery<? extends TitanGraphQuery> query = graph.query();
+
+					if (criteria != null && !criteria.isEmpty()) {
+						for (Map.Entry<String, Object> entry : criteria.entrySet()) {
+							query = query.has(entry.getKey(), entry.getValue());
+						}
+					}
+
+					Iterator iterator = query
+							.has(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFIED.name())
+							.vertices().iterator();
+
+					boolean isFoundAtLeastOneCertifiedService = false;
+					while (iterator.hasNext()) {
+						Vertex vertex = (Vertex) iterator.next();
+
+						Map<String, Object> leftProps = Utils.getProperties(vertex);
+						boolean vertexLeftContainsRightProps = Utils.vertexLeftContainsRightProps(leftProps, criteria);
+						if (false == vertexLeftContainsRightProps) {
+							log.debug("Ignore vertex since properties it does not contains properties {}. Vertex properties are: {}", criteria, leftProps);
+							continue;
+						}
+
+						isFoundAtLeastOneCertifiedService = true;
+						break;
+					}
+
+					if (true == isFoundAtLeastOneCertifiedService) {
+
+						Integer currentNumberOfUpdates = updateVertexes(keyValueToSet, graph, criteria);
+
+						if (currentNumberOfUpdates != null) {
+							numberOfUpdatedVertexes += currentNumberOfUpdates;
+						}
+
+					} else {
+						log.debug("No certified service was found for criteria {}", criteria);
+					}
+				}
+
+			}
+
+			// graph.commit();
+			graph.tx().commit();
+
+			return numberOfUpdatedVertexes;
+
+		} catch (Exception e) {
+			e.printStackTrace();
+			// graph.rollback();
+			graph.tx().rollback();
+
+			return null;
+
+		} finally {
+			if (graph != null) {
+				// graph.shutdown();
+				graph.close();
+			}
+		}
+
+	}
+
+	private Integer updateVertexes(Map<String, Object> keyValueToSet, TitanGraph graph, Map<String, Object> criteria) {
+		Integer numberOfUpdatedVertexesPerService = 0;
+
+		TitanGraphQuery<? extends TitanGraphQuery> updateQuery = graph.query();
+
+		if (criteria != null && !criteria.isEmpty()) {
+			for (Map.Entry<String, Object> entry : criteria.entrySet()) {
+				updateQuery = updateQuery.has(entry.getKey(), entry.getValue());
+			}
+		}
+		Iterator updateIterator = updateQuery.vertices().iterator();
+
+		while (updateIterator.hasNext()) {
+
+			Vertex vertex = (Vertex) updateIterator.next();
+
+			Map<String, Object> leftProps = Utils.getProperties(vertex);
+
+			boolean vertexLeftContainsRightProps = Utils.vertexLeftContainsRightProps(leftProps, criteria);
+			if (false == vertexLeftContainsRightProps) {
+				log.debug("Ignore vertex since properties it does not contains properties {}. Vertex properties are {}", criteria, leftProps);
+				continue;
+			}
+
+			if (keyValueToSet != null) {
+				for (Entry<String, Object> entry : keyValueToSet.entrySet()) {
+					String key = entry.getKey();
+					Object value = entry.getValue();
+
+					// vertex.setProperty(key, value);
+					vertex.property(key, value);
+					//if(log.isDebugEnabled()){
+					// log.debug("After setting vertex: {} {} with key value: {}, {}", 
+					// vertex.getProperty(GraphPropertiesDictionary.NAME.getProperty()), 
+					// vertex.getProperty(GraphPropertiesDictionary.VERSION.getProperty()),
+					// key, value);
+					//}
+					log.debug("After setting vertex: {} {} with key value: {}, {}", 
+							vertex.property(GraphPropertiesDictionary.NAME.getProperty()),
+							vertex.property(GraphPropertiesDictionary.VERSION.getProperty()),
+							key, value);
+					numberOfUpdatedVertexesPerService++;
+				}
+			}
+
+		}
+
+		log.info(
+				"The number of updated services for criteria " + criteria + " is " + numberOfUpdatedVertexesPerService);
+		return numberOfUpdatedVertexesPerService;
+	}
+
+	public TitanGraph openGraph(String titanFileLocation) {
+
+		TitanGraph graph = TitanFactory.open(titanFileLocation);
+
+		return graph;
+
+	}
+
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/AddGroupUuid.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/AddGroupUuid.java
new file mode 100644
index 0000000000..db8fee0fa2
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/AddGroupUuid.java
@@ -0,0 +1,132 @@
+/*-
+ * ============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.asdctool.impl.migration.v1604;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.stream.Collectors;
+
+import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
+import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
+import org.openecomp.sdc.be.resources.data.GroupData;
+import org.slf4j.Logger;
+
+import fj.data.Either;
+
+public class AddGroupUuid {
+
+	public static boolean addGroupUuids(TitanGenericDao titanGenericDao, Logger log, boolean inTrsansaction) {
+
+		boolean result = true;
+
+		try {
+
+			log.debug("========================================================");
+			log.debug("Before find all groups");
+
+			Either<List<GroupData>, TitanOperationStatus> allGroups = titanGenericDao.getByCriteria(NodeTypeEnum.Group,
+					null, null, GroupData.class);
+
+			if (allGroups.isRight()) {
+				TitanOperationStatus status = allGroups.right().value();
+				log.debug("After finding all groups. Status is {}", status);
+				if (status != TitanOperationStatus.NOT_FOUND && status != TitanOperationStatus.OK) {
+					result = false;
+					return result;
+				} else {
+					return result;
+				}
+			}
+
+			List<GroupData> groups = allGroups.left().value();
+
+			log.info("The number of groups fetched is {}", groups == null ? 0 : groups.size());
+
+			int numberOfUpdates = 0;
+			if (false == groups.isEmpty()) {
+				Map<String, List<GroupData>> invariantIdToGroups = groups.stream()
+						.collect(Collectors.groupingBy(p -> p.getGroupDataDefinition().getInvariantUUID()));
+
+				// All the groups with the same invariantUUID should have the
+				// same group UUID since update VF flow with CSAR was not
+				// supported in the E2E environment.
+
+				log.info("The number of different invariantUuids is {}",
+						invariantIdToGroups == null ? 0 : invariantIdToGroups.size());
+
+				for (Entry<String, List<GroupData>> entry : invariantIdToGroups.entrySet()) {
+
+					String invariantUuid = entry.getKey();
+					List<GroupData> groupsData = entry.getValue();
+
+					StringBuilder builder = new StringBuilder();
+					groupsData.forEach(p -> builder.append(p.getGroupDataDefinition().getUniqueId() + ","));
+
+					String groupUUID = groupsData.get(0).getGroupDataDefinition().getGroupUUID();
+
+					if (groupUUID == null) {
+
+						groupUUID = UniqueIdBuilder.generateUUID();
+
+						log.debug("Before updating groups {} with groupUUID {}", builder.toString(), groupUUID);
+
+						for (GroupData groupData : groupsData) {
+
+							numberOfUpdates++;
+							groupData.getGroupDataDefinition().setGroupUUID(groupUUID);
+							Either<GroupData, TitanOperationStatus> updateNode = titanGenericDao.updateNode(groupData,
+									GroupData.class);
+							if (updateNode.isRight()) {
+								log.error("Failed to update group " + groupData + ". Error is {}",
+										updateNode.right().value().toString());
+								result = false;
+								return result;
+							}
+
+						}
+
+						log.debug("After updating groups {} with groupUUID {}", builder.toString(), groupUUID);
+					}
+
+				}
+			}
+
+			log.info("The number of groups updated with groupUUID is " + numberOfUpdates);
+
+			return result;
+
+		} finally {
+			log.info("Finish updating groupUUIDs. Status is {}.", result);
+			if (inTrsansaction == false) {
+				if (result == false) {
+					titanGenericDao.rollback();
+				} else {
+					titanGenericDao.commit();
+				}
+			}
+		}
+	}
+
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/AllowMultipleHeats.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/AllowMultipleHeats.java
new file mode 100644
index 0000000000..561cfb5a5b
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/AllowMultipleHeats.java
@@ -0,0 +1,144 @@
+/*-
+ * ============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.asdctool.impl.migration.v1604;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
+import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
+import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.resources.data.ArtifactData;
+import org.slf4j.Logger;
+
+import fj.data.Either;
+
+public class AllowMultipleHeats {
+
+	public static boolean removeAndUpdateHeatPlaceHolders(TitanGenericDao titanGenericDao, Logger log,
+			boolean inTrsansaction) {
+
+		boolean result = true;
+
+		try {
+
+			List<ArtifactData> artifactsToDelete = new ArrayList<>();
+			List<ArtifactData> artifactsToUpdate = new ArrayList<>();
+
+			String[] phLabels = { "heat", "heatvol", "heatnet" };
+
+			for (String artifactLabel : phLabels) {
+				Map<String, Object> properties = new HashMap<>();
+
+				properties.put(GraphPropertiesDictionary.ARTIFACT_LABEL.getProperty(), artifactLabel);
+
+				Either<List<ArtifactData>, TitanOperationStatus> allHeatArtifacts = titanGenericDao
+						.getByCriteria(NodeTypeEnum.ArtifactRef, properties, null, ArtifactData.class);
+
+				if (allHeatArtifacts.isRight()) {
+					TitanOperationStatus status = allHeatArtifacts.right().value();
+					if (status == TitanOperationStatus.NOT_FOUND) {
+						continue;
+					} else {
+						result = false;
+						return result;
+					}
+
+				}
+
+				List<ArtifactData> list = allHeatArtifacts.left().value();
+				log.debug("Found {} artifacts with label {}", (list == null ? 0 : list.size()), artifactLabel);
+
+				if (list != null && false == list.isEmpty()) {
+
+					for (ArtifactData artifactData : list) {
+						String esId = artifactData.getArtifactDataDefinition().getEsId();
+						if (esId == null || true == esId.isEmpty()) {
+							artifactsToDelete.add(artifactData);
+						} else {
+							artifactsToUpdate.add(artifactData);
+						}
+					}
+				}
+			}
+
+			if (false == artifactsToDelete.isEmpty()) {
+				for (ArtifactData artifactData : artifactsToDelete) {
+					// System.out.println("Going to delete artifact " +
+					// artifactData);
+					log.debug("Going to delete artifact {}", artifactData);
+					Either<ArtifactData, TitanOperationStatus> deleteNode = titanGenericDao.deleteNode(artifactData,
+							ArtifactData.class);
+					if (deleteNode.isRight()) {
+						log.error("Failed to delete artifact node {}", deleteNode.left().value());
+						result = false;
+						return result;
+					} else {
+						log.debug("Delete artifact node {}", deleteNode.left().value());
+					}
+				}
+			}
+
+			log.debug("Number of deleted artifacts is {}", artifactsToDelete.size());
+
+			int counter = 0;
+			if (false == artifactsToUpdate.isEmpty()) {
+				for (ArtifactData artifactData : artifactsToUpdate) {
+					// System.out.println("Going to update artifact " +
+					// artifactData);
+
+					if (artifactData.getArtifactDataDefinition().getMandatory() != null
+							&& true == artifactData.getArtifactDataDefinition().getMandatory()) {
+						log.debug("Going to update artifact {}", artifactData);
+						counter++;
+						artifactData.getArtifactDataDefinition().setMandatory(false);
+						Either<ArtifactData, TitanOperationStatus> updatedNode = titanGenericDao
+								.updateNode(artifactData, ArtifactData.class);
+						if (updatedNode.isRight()) {
+							log.error("Failed to update artifact node {}", updatedNode.left().value());
+							result = false;
+							return result;
+						} else {
+							log.debug("Update artifact node {}", updatedNode.left().value());
+						}
+					}
+				}
+			}
+
+			log.debug("Number of updated artifacts is {}", counter);
+
+			return result;
+
+		} finally {
+			if (inTrsansaction == false) {
+				if (result == false) {
+					titanGenericDao.rollback();
+				} else {
+					titanGenericDao.commit();
+				}
+			}
+		}
+	}
+
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/AppConfig.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/AppConfig.java
new file mode 100644
index 0000000000..b529935a38
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/AppConfig.java
@@ -0,0 +1,538 @@
+/*-
+ * ============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.asdctool.impl.migration.v1604;
+
+import org.openecomp.sdc.asdctool.impl.PopulateComponentCache;
+import org.openecomp.sdc.asdctool.impl.migration.v1607.CsarMigration;
+import org.openecomp.sdc.asdctool.impl.migration.v1610.TitanFixUtils;
+import org.openecomp.sdc.asdctool.impl.migration.v1610.ToscaArtifactsAlignment;
+import org.openecomp.sdc.be.auditing.api.IAuditingManager;
+import org.openecomp.sdc.be.auditing.impl.AuditingManager;
+import org.openecomp.sdc.be.components.distribution.engine.IDistributionEngine;
+import org.openecomp.sdc.be.components.distribution.engine.ServiceDistributionArtifactsBuilder;
+import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic;
+import org.openecomp.sdc.be.components.impl.CompositionBusinessLogic;
+import org.openecomp.sdc.be.components.impl.GroupBusinessLogic;
+import org.openecomp.sdc.be.components.impl.InputsBusinessLogic;
+import org.openecomp.sdc.be.components.impl.ProductBusinessLogic;
+import org.openecomp.sdc.be.components.impl.ProductComponentInstanceBusinessLogic;
+import org.openecomp.sdc.be.components.impl.ResourceBusinessLogic;
+import org.openecomp.sdc.be.components.impl.ResourceImportManager;
+import org.openecomp.sdc.be.components.impl.ServiceBusinessLogic;
+import org.openecomp.sdc.be.components.impl.ServiceComponentInstanceBusinessLogic;
+import org.openecomp.sdc.be.components.impl.VFComponentInstanceBusinessLogic;
+import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
+import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao;
+import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao;
+import org.openecomp.sdc.be.dao.cassandra.CassandraClient;
+import org.openecomp.sdc.be.dao.cassandra.ComponentCassandraDao;
+import org.openecomp.sdc.be.dao.es.ElasticSearchClient;
+import org.openecomp.sdc.be.dao.impl.AuditingDao;
+import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
+import org.openecomp.sdc.be.dao.titan.TitanGraphClient;
+import org.openecomp.sdc.be.impl.ComponentsUtils;
+import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
+import org.openecomp.sdc.be.model.cache.ComponentCache;
+import org.openecomp.sdc.be.model.operations.api.IAdditionalInformationOperation;
+import org.openecomp.sdc.be.model.operations.api.IElementOperation;
+import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
+import org.openecomp.sdc.be.model.operations.api.IUserAdminOperation;
+import org.openecomp.sdc.be.model.operations.impl.AdditionalInformationOperation;
+import org.openecomp.sdc.be.model.operations.impl.ArtifactOperation;
+import org.openecomp.sdc.be.model.operations.impl.AttributeOperation;
+import org.openecomp.sdc.be.model.operations.impl.CacheMangerOperation;
+import org.openecomp.sdc.be.model.operations.impl.CapabilityInstanceOperation;
+import org.openecomp.sdc.be.model.operations.impl.CapabilityOperation;
+import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
+import org.openecomp.sdc.be.model.operations.impl.ComponentInstanceOperation;
+import org.openecomp.sdc.be.model.operations.impl.CsarOperation;
+import org.openecomp.sdc.be.model.operations.impl.ElementOperation;
+import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
+import org.openecomp.sdc.be.model.operations.impl.GroupOperation;
+import org.openecomp.sdc.be.model.operations.impl.GroupTypeOperation;
+import org.openecomp.sdc.be.model.operations.impl.HeatParametersOperation;
+import org.openecomp.sdc.be.model.operations.impl.InputsOperation;
+import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
+import org.openecomp.sdc.be.model.operations.impl.LifecycleOperation;
+import org.openecomp.sdc.be.model.operations.impl.OnboardingClient;
+import org.openecomp.sdc.be.model.operations.impl.ProductOperation;
+import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
+import org.openecomp.sdc.be.model.operations.impl.RequirementOperation;
+import org.openecomp.sdc.be.model.operations.impl.ResourceOperation;
+import org.openecomp.sdc.be.model.operations.impl.ServiceOperation;
+import org.openecomp.sdc.be.model.operations.impl.UserAdminOperation;
+import org.openecomp.sdc.be.tosca.CsarUtils;
+import org.openecomp.sdc.be.tosca.ToscaExportHandler;
+import org.openecomp.sdc.be.user.IUserBusinessLogic;
+import org.openecomp.sdc.be.user.UserBusinessLogic;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class AppConfig {
+	@Bean(name = "serviceMigrationBean")
+	public ServiceMigration serviceMigration() {
+		return new ServiceMigration();
+	}
+
+	@Bean(name = "vfcNamingAlignmentBean")
+	public VfcNamingAlignment vfcNamingAlignment() {
+		return new VfcNamingAlignment();
+	}
+
+	@Bean(name = "derivedFromAlignment")
+	public DerivedFromAlignment derivedFromAlignment() {
+		return new DerivedFromAlignment();
+	}
+
+	@Bean(name = "groupsAlignment")
+	public GroupsAlignment groupsAlignment() {
+		return new GroupsAlignment();
+	}
+
+	@Bean(name = "csarMigration")
+	public CsarMigration csarMigration() {
+		return new CsarMigration();
+	}
+
+	@Bean(name = "titan-generic-dao")
+	public TitanGenericDao titanGenericDao() {
+		return new TitanGenericDao();
+	}
+
+	@Bean(name = "titan-client", initMethod = "createGraph")
+	public TitanGraphClient titanClient() {
+		return new TitanGraphClient();
+	}
+
+	@Bean(name = "resource-operation")
+	public ResourceOperation resourceOperation() {
+		return new ResourceOperation();
+	}
+
+	@Bean(name = "service-operation")
+	public ServiceOperation serviceOperation() {
+		return new ServiceOperation();
+	}
+
+	@Bean(name = "component-instance-operation")
+	public ComponentInstanceOperation componentInstanceOperation() {
+		return new ComponentInstanceOperation();
+	}
+
+	@Bean(name = "capability-instanceOperation")
+	public CapabilityInstanceOperation capabilityInstanceOperation() {
+		return new CapabilityInstanceOperation();
+	}
+
+	@Bean(name = "property-operation")
+	public PropertyOperation propertyOperation() {
+		return new PropertyOperation();
+	}
+
+	@Bean(name = "attribute-operation")
+	public AttributeOperation attribueOperation() {
+		return new AttributeOperation();
+	}
+
+	@Bean(name = "application-datatype-cache")
+	public ApplicationDataTypeCache applicationDataTypeCache() {
+		return new ApplicationDataTypeCache();
+	}
+
+	@Bean(name = "requirement-operation")
+	public RequirementOperation requirementOperation() {
+		return new RequirementOperation();
+	}
+
+	@Bean(name = "capability-operation")
+	public CapabilityOperation capabilityOperation() {
+		return new CapabilityOperation();
+	}
+
+	@Bean(name = "interface-operation")
+	public InterfaceLifecycleOperation interfaceLifecycleOperation() {
+		return new InterfaceLifecycleOperation();
+	}
+
+	@Bean(name = "element-operation")
+	public IElementOperation elementOperation() {
+		return new ElementOperation();
+	}
+
+	@Bean(name = "additional-information-operation")
+	public IAdditionalInformationOperation addioAdditionalInformationOperation() {
+		return new AdditionalInformationOperation();
+	}
+
+	@Bean(name = "capability-type-operation")
+	public CapabilityTypeOperation capabilityTypeOperation() {
+		return new CapabilityTypeOperation();
+	}
+
+	@Bean(name = "artifact-operation")
+	public ArtifactOperation artifactOperation() {
+		return new ArtifactOperation();
+	}
+
+	@Bean(name = "heat-parameter-operation")
+	public HeatParametersOperation heatParametersOperation() {
+		return new HeatParametersOperation();
+	}
+
+	@Bean(name = "product-operation")
+	public ProductOperation productOperation() {
+		return new ProductOperation();
+	}
+
+	@Bean(name = "lifecycle-operation")
+	public LifecycleOperation lifecycleOperation() {
+		return new LifecycleOperation();
+	}
+
+	@Bean(name = "group-operation")
+	public GroupOperation groupOperation() {
+		return new GroupOperation();
+	}
+
+	@Bean(name = "group-type-operation")
+	public GroupTypeOperation groupTypeOperation() {
+		return new GroupTypeOperation();
+	}
+
+	@Bean(name = "attribute-operation")
+	public AttributeOperation attributeOperation() {
+		return new AttributeOperation();
+	}
+
+	@Bean(name = "titanFixUtils")
+	public TitanFixUtils titanFixUtils() {
+		return new TitanFixUtils();
+	}
+
+	@Bean(name = "populateComponentCache")
+	public PopulateComponentCache populateComponentCache() {
+		return new PopulateComponentCache();
+	}
+
+	@Bean(name = "artifact-cassandra-dao")
+	public ArtifactCassandraDao artifactCassandraDao() {
+		return new ArtifactCassandraDao();
+	}
+
+	@Bean(name = "component-cassandra-dao")
+	public ComponentCassandraDao componentCassandraDao() {
+		return new ComponentCassandraDao();
+	}
+
+	@Bean(name = "cassandra-client")
+	public CassandraClient cassandraClient() {
+		return new CassandraClient();
+	}
+
+	@Bean(name = "cacheManger-operation")
+	public CacheMangerOperation cacheMangerOperation() {
+		return new CacheMangerOperation();
+	}
+
+	@Bean(name = "component-cache")
+	public ComponentCache componentCache() {
+		return new ComponentCache();
+	}
+
+	@Bean(name = "input-operation")
+	public InputsOperation inputsOperation() {
+		return new InputsOperation();
+	}
+
+	/**
+	 * Returns new instance of AuditCassandraDao
+	 * 
+	 * @return
+	 */
+	@Bean(name = "audit-cassandra-dao")
+	public AuditCassandraDao auditCassandraDao() {
+		return new AuditCassandraDao();
+	}
+
+	/**
+	 * Returns new instance of UserBusinessLogic
+	 * 
+	 * @return
+	 */
+	@Bean(name = "userBusinessLogic")
+	public IUserBusinessLogic userBusinessLogic() {
+		return new UserBusinessLogic();
+	}
+
+	/**
+	 * Returns new instance of UserAdminOperation
+	 * 
+	 * @return
+	 */
+	@Bean(name = "user-operation")
+	public IUserAdminOperation userOperation() {
+		return new UserAdminOperation();
+	}
+
+	/**
+	 * Returns new instance of GraphLockOperation
+	 * 
+	 * @return
+	 */
+	@Bean(name = "graph-lock-operation")
+	public IGraphLockOperation graphLockOperation() {
+		return new GraphLockOperation();
+	}
+
+	/**
+	 * Returns new instance of AuditingDao
+	 * 
+	 * @return
+	 */
+	@Bean(name = "auditingDao")
+	public AuditingDao auditingDao() {
+		return new AuditingDao();
+	}
+
+	/**
+	 * Returns new instance of AuditingManager
+	 * 
+	 * @return
+	 */
+	@Bean(name = "auditingManager")
+	public IAuditingManager auditingManager() {
+		return new AuditingManager();
+	}
+
+	/**
+	 * Returns new instance of ServiceBusinessLogic
+	 * 
+	 * @return
+	 */
+	@Bean(name = "serviceBusinessLogic")
+	public ServiceBusinessLogic serviceBusinessLogic() {
+		return new ServiceBusinessLogic();
+	}
+
+	/**
+	 * Returns new instance of ComponentsUtils
+	 * 
+	 * @return
+	 */
+	@Bean(name = "componentUtils")
+	public ComponentsUtils componentUtils() {
+		return new ComponentsUtils();
+	}
+
+	/**
+	 * Returns new instance of ToscaArtifactsAlignment
+	 * 
+	 * @return
+	 */
+	@Bean(name = "toscaArtifactsAlignment")
+	public ToscaArtifactsAlignment toscaArtifactsAlignment() {
+		return new ToscaArtifactsAlignment();
+	}
+
+	/**
+	 * Returns new instance of ArtifactsBusinessLogic
+	 * 
+	 * @return
+	 */
+	@Bean(name = "artifactBusinessLogic")
+	public ArtifactsBusinessLogic artifactBusinessLogic() {
+		return new ArtifactsBusinessLogic();
+	}
+
+	/**
+	 * Returns new instance of ResourceBusinessLogic
+	 * 
+	 * @return
+	 */
+	@Bean(name = "resourceBusinessLogic")
+	public ResourceBusinessLogic resourceBusinessLogic() {
+		return new ResourceBusinessLogic();
+	}
+
+	/**
+	 * Returns new instance of LifecycleBusinessLogic
+	 * 
+	 * @return
+	 */
+	@Bean(name = "lifecycleBusinessLogic")
+	public LifecycleBusinessLogic lifecycleBusinessLogic() {
+		return new LifecycleBusinessLogic();
+	}
+
+	/**
+	 * Returns new instance of ServiceDistributionArtifactsBuilder
+	 * 
+	 * @return
+	 */
+	@Bean(name = "serviceDistributionArtifactsBuilder")
+	public ServiceDistributionArtifactsBuilder serviceDistributionArtifactsBuilder() {
+		return new ServiceDistributionArtifactsBuilder();
+	}
+
+	/**
+	 * Returns new instance of DistributionEngine
+	 * 
+	 * @return
+	 */
+	@Bean(name = "distributionEngine")
+	public IDistributionEngine distributionEngine() {
+		// This dependency is needed for initializing context but is not used
+		return null;
+	}
+
+	/**
+	 * Returns new instance of ElasticSearchClient
+	 * 
+	 * @return
+	 */
+	@Bean(name = "elasticsearch-client")
+	public ElasticSearchClient elasticsearchClient() {
+		// This dependency is needed for initializing context but is not used
+		return null;
+	}
+
+	/**
+	 * Returns new instance of ProductBusinessLogic
+	 * 
+	 * @return
+	 */
+	@Bean(name = "productBusinessLogic")
+	public ProductBusinessLogic productBusinessLogic() {
+		return new ProductBusinessLogic();
+	}
+
+	/**
+	 * Returns new instance of ProductComponentInstanceBusinessLogic
+	 * 
+	 * @return
+	 */
+	@Bean(name = "productComponentInstanceBusinessLogic")
+	public ProductComponentInstanceBusinessLogic productComponentInstanceBusinessLogic() {
+		return new ProductComponentInstanceBusinessLogic();
+	}
+
+	/**
+	 * Returns new instance of ToscaExportHandler
+	 * 
+	 * @return
+	 */
+	@Bean(name = "tosca-export-handler")
+	public ToscaExportHandler toscaExportHandler() {
+		return new ToscaExportHandler();
+	}
+
+	/**
+	 * Returns new instance of CsarOperation
+	 * 
+	 * @return
+	 */
+	@Bean(name = "csar-operation")
+	public CsarOperation csarOperation() {
+		return new CsarOperation();
+	}
+
+	/**
+	 * Returns new instance of OnboardingClient
+	 * 
+	 * @return
+	 */
+	@Bean(name = "onboarding-client")
+	public OnboardingClient onboardingClient() {
+		return new OnboardingClient();
+	}
+
+	/**
+	 * Returns new instance of VFComponentInstanceBusinessLogic
+	 * 
+	 * @return
+	 */
+	@Bean(name = "vfComponentInstanceBusinessLogic")
+	public VFComponentInstanceBusinessLogic vfComponentInstanceBusinessLogic() {
+		return new VFComponentInstanceBusinessLogic();
+	}
+
+	/**
+	 * Returns new instance of ResourceImportManager
+	 * 
+	 * @return
+	 */
+	@Bean(name = "resourceImportManager")
+	public ResourceImportManager resourceImportManager() {
+		return new ResourceImportManager();
+	}
+
+	/**
+	 * Returns new instance of GroupBusinessLogic
+	 * 
+	 * @return
+	 */
+	@Bean(name = "groupBusinessLogic")
+	public GroupBusinessLogic groupBusinessLogic() {
+		return new GroupBusinessLogic();
+	}
+
+	/**
+	 * Returns new instance of InputsBusinessLogic
+	 * 
+	 * @return
+	 */
+	@Bean(name = "inputsBusinessLogic")
+	public InputsBusinessLogic inputsBusinessLogic() {
+		return new InputsBusinessLogic();
+	}
+
+	/**
+	 * Returns new instance of CompositionBusinessLogic
+	 * 
+	 * @return
+	 */
+	@Bean(name = "compositionBusinessLogic")
+	public CompositionBusinessLogic compositionBusinessLogic() {
+		return new CompositionBusinessLogic();
+	}
+
+	/**
+	 * Returns new instance of CsarUtils
+	 * 
+	 * @return
+	 */
+	@Bean(name = "csar-utils")
+	public CsarUtils csarUtils() {
+		return new CsarUtils();
+	}
+
+	/**
+	 * Returns new instance of ServiceComponentInstanceBusinessLogic
+	 * 
+	 * @return
+	 */
+	@Bean(name = "serviceComponentInstanceBusinessLogic")
+	public ServiceComponentInstanceBusinessLogic serviceComponentInstanceBusinessLogic() {
+		return new ServiceComponentInstanceBusinessLogic();
+	}
+
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/DerivedFromAlignment.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/DerivedFromAlignment.java
new file mode 100644
index 0000000000..c1ddc4fee0
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/DerivedFromAlignment.java
@@ -0,0 +1,232 @@
+/*-
+ * ============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.asdctool.impl.migration.v1604;
+
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
+import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
+import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
+import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
+import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
+import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
+import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import fj.data.Either;
+
+public class DerivedFromAlignment {
+	private static Logger log = LoggerFactory.getLogger(VfcNamingAlignment.class.getName());
+	private Map<String, String> newDerivedFromValuesHM = new HashMap<String, String>();
+	@Autowired
+	protected TitanGenericDao titanGenericDao;
+
+	public boolean alignDerivedFrom1604(String appConfigDir, String dataInputFileDir) {
+		log.debug("Started alignDerivedFrom1604 procedure..");
+		boolean result = false;
+		try {
+			if (!getDerivedFromValuesFromFile(dataInputFileDir)) {
+				log.error("Started alignDerivedFrom1604 procedure was failed. Missing data in the input data file.");
+				return result;
+			}
+			result = changeDerivedFrom();
+		} finally {
+			if (!result) {
+				titanGenericDao.rollback();
+				log.debug("**********************************************");
+				log.debug("alignDerivedFrom1604 procedure FAILED!!");
+				log.debug("**********************************************");
+			} else {
+				titanGenericDao.commit();
+				log.debug("**********************************************");
+				log.debug("alignDerivedFrom1604 procedure ended successfully!");
+				log.debug("**********************************************");
+			}
+		}
+		return result;
+	}
+
+	private boolean changeDerivedFrom() {
+		Map<String, ResourceMetadataData> resourcesHM = getLatestVersionsOfResources();
+		if (resourcesHM == null)
+			return false;
+		Map<String, ResourceMetadataData> derivedFromResourcesHM = getLatestCertifiedVersionsOfDerivedFromResources();
+		if (derivedFromResourcesHM == null)
+			return false;
+		return updateEdges(resourcesHM, derivedFromResourcesHM);
+	}
+
+	private boolean updateEdges(Map<String, ResourceMetadataData> resourcesHM,
+			Map<String, ResourceMetadataData> derivedFromResourcesHM) {
+		log.debug("Updating of Edges has been started..");
+		for (Entry<String, ResourceMetadataData> pair : resourcesHM.entrySet()) {
+			ResourceMetadataData curResource = pair.getValue();
+			String uniqeID = (String) curResource.getUniqueId();
+			Either<ImmutablePair<ResourceMetadataData, GraphEdge>, TitanOperationStatus> parentResourceRes = titanGenericDao
+					.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), uniqeID,
+							GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Resource, ResourceMetadataData.class);
+			if (parentResourceRes.isLeft()) {
+				ImmutablePair<ResourceMetadataData, GraphEdge> value = parentResourceRes.left().value();
+				ResourceMetadataData parentResourceData = value.getKey();
+				log.debug("Deleting old relation..");
+				Either<GraphRelation, TitanOperationStatus> deletingRelationRes = titanGenericDao
+						.deleteRelation(curResource, parentResourceData, GraphEdgeLabels.DERIVED_FROM);
+				if (deletingRelationRes.isRight()) {
+					log.error("Couldn't delete relation from resource {} to resource {}, error: {}",
+							curResource.getMetadataDataDefinition().getName(),
+							parentResourceData.getMetadataDataDefinition().getName(),
+							deletingRelationRes.right().value());
+					return false;
+				}
+				ResourceMetadataData newDerivedFromResource = derivedFromResourcesHM.get(pair.getKey());
+				Either<GraphRelation, TitanOperationStatus> creatingRelationRes = titanGenericDao
+						.createRelation(curResource, newDerivedFromResource, GraphEdgeLabels.DERIVED_FROM, null);
+				if (creatingRelationRes.isRight()) {
+					log.error("Couldn't create relation from resource {} to resource {}, error: {}",
+							curResource.getMetadataDataDefinition().getName(),
+							newDerivedFromResource.getMetadataDataDefinition().getName(),
+							creatingRelationRes.right().value());
+					return false;
+				}
+			} else {
+				log.error("Couldn't get derived from resource for child resource {}, error: {}", pair.getKey(),
+						parentResourceRes.right().value());
+				return false;
+			}
+		}
+		return true;
+	}
+
+	private Map<String, ResourceMetadataData> getLatestCertifiedVersionsOfDerivedFromResources() {
+		log.debug("Getting latest certified versions of derived from resources according input file");
+		Map<String, ResourceMetadataData> resourcesHM = new HashMap<String, ResourceMetadataData>();
+		Map<String, Object> props = null;
+		for (Entry<String, String> pair : newDerivedFromValuesHM.entrySet()) {
+			props = new HashMap<String, Object>();
+			props.put(GraphPropertiesDictionary.TOSCA_RESOURCE_NAME.getProperty(), pair.getValue());
+			props.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true);
+			Either<List<ResourceMetadataData>, TitanOperationStatus> highestVersionResource = titanGenericDao
+					.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
+			if (highestVersionResource.isRight()) {
+				log.error("Couldn't get resource {} from DB, error: {}", pair.getValue(),
+						highestVersionResource.right().value());
+				return null;
+			}
+			List<ResourceMetadataData> highestVersionResourceAL = highestVersionResource.left().value();
+			if (highestVersionResourceAL == null) {
+				log.error("Couldn't get resource {}. No resource found", pair.getValue());
+				return null;
+			}
+			ResourceMetadataData resource = highestVersionResourceAL.get(0);
+			String state = resource.getMetadataDataDefinition().getState();
+			if (!state.equals(LifecycleStateEnum.CERTIFIED.name())) {
+				log.error(
+						"alignDerivedFrom1604 procedure FAILED!! Derived from resource {} is not certified. Please certify manually and repeat the procedure.",
+						pair.getValue());
+				return null;
+			}
+			resourcesHM.put(pair.getKey(), resource);
+		}
+		return resourcesHM;
+	}
+
+	private Map<String, ResourceMetadataData> getLatestVersionsOfResources() {
+		log.debug("Getting latest versions of resources according input file");
+		Map<String, ResourceMetadataData> resourcesHM = new HashMap<String, ResourceMetadataData>();
+		ResourceMetadataData foundResource = null;
+		Map<String, Object> props = null;
+		for (Entry<String, String> pair : newDerivedFromValuesHM.entrySet()) {// filter
+			props = new HashMap<String, Object>();
+			props.put(GraphPropertiesDictionary.NAME.getProperty(), pair.getKey());
+			props.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true);
+
+			Either<List<ResourceMetadataData>, TitanOperationStatus> highestVersionResource = titanGenericDao
+					.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
+			if (highestVersionResource.isRight()) {
+				log.error("Couldn't get resource {} from DB, error: {}", pair.getKey(),
+						highestVersionResource.right().value());
+				return null;
+			}
+			List<ResourceMetadataData> highestVersionResourceAL = highestVersionResource.left().value();
+			if (highestVersionResourceAL == null) {
+				log.error("Couldn't get resource {}. No resource found", pair.getKey());
+				return null;
+			}
+			if (highestVersionResourceAL.size() > 2) {
+				log.error("Invalid response. Found more than two highest version resources with name {}.",
+						pair.getKey());
+				return null;
+			}
+			foundResource = highestVersionResourceAL.get(0);
+			if (highestVersionResourceAL.size() == 2) {
+				foundResource = foundResource.getMetadataDataDefinition().getState()
+						.equals(LifecycleStateEnum.CERTIFIED.name()) ? highestVersionResourceAL.get(1) : foundResource;
+			}
+			resourcesHM.put(pair.getKey(), foundResource);
+		}
+		return resourcesHM;
+	}
+
+	private boolean getDerivedFromValuesFromFile(String dataInputFileDir) {
+		BufferedReader br = null;
+		String curPair = null;
+		try {
+			br = new BufferedReader(new FileReader(dataInputFileDir));
+			while ((curPair = br.readLine()) != null) {
+				String[] pair = curPair.split(" ");
+				if (pair.length < 2) {
+					log.error(
+							"Expected at least two tokens in every line. Usage: <resource_name> <new_derived_from_name>");
+					return false;
+				}
+				String derivedFrom = pair[pair.length - 1];
+				String name = curPair.substring(0, curPair.length() - derivedFrom.length() - 1);
+				newDerivedFromValuesHM.put(name, derivedFrom);
+			}
+			return true;
+		} catch (FileNotFoundException e) {
+			log.error("Started alignDerivedFrom1604 procedure was failed. Missing input data file.", e);
+		} catch (IOException e) {
+			log.error("Started alignDerivedFrom1604 procedure was failed. The input data file is empty.", e);
+		} finally {
+			if (br != null) {
+				try {
+					br.close();
+				} catch (IOException e) {
+					log.debug("failed to close file reader", e);
+				}
+			}
+		}
+		return false;
+	}
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/GroupsAlignment.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/GroupsAlignment.java
new file mode 100644
index 0000000000..aebcddfee2
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/GroupsAlignment.java
@@ -0,0 +1,201 @@
+/*-
+ * ============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.asdctool.impl.migration.v1604;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
+import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
+import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
+import org.openecomp.sdc.be.model.ArtifactDefinition;
+import org.openecomp.sdc.be.model.GroupDefinition;
+import org.openecomp.sdc.be.model.GroupTypeDefinition;
+import org.openecomp.sdc.be.model.operations.api.IArtifactOperation;
+import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.GroupTypeOperation;
+import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
+import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
+import org.openecomp.sdc.common.api.ArtifactTypeEnum;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import fj.data.Either;
+
+public class GroupsAlignment {
+
+	private static Logger log = LoggerFactory.getLogger(ServiceMigration.class.getName());
+
+	public static String INITIAL_VERSION = "1.0";
+	private static final String DEFAULT_GROUP_VF_MODULE = "org.openecomp.groups.VfModule";
+	private static final String MODULE = "::module-";
+
+	@Autowired
+	protected TitanGenericDao titanGenericDao;
+	@Autowired
+	protected IArtifactOperation artifactOperation;
+	@Autowired
+	protected IGroupOperation groupOperation;
+	@Autowired
+	protected GroupTypeOperation groupTypeOperation;
+
+	public boolean alignGroups(String appConfigDir) {
+
+		log.debug("Started the align groups procedure ...");
+		log.debug("Getting all resources with resources");
+		boolean result = false;
+		try {
+
+			Map<String, Object> properties = new HashMap<>();
+			properties.put(GraphPropertiesDictionary.RESOURCE_TYPE.getProperty(), ResourceTypeEnum.VF.name());
+			Either<List<ResourceMetadataData>, TitanOperationStatus> allVfResources = titanGenericDao
+					.getByCriteria(NodeTypeEnum.Resource, properties, ResourceMetadataData.class);
+
+			if (allVfResources.isRight()) {
+				log.error("Couldn't get VF resources from DB, error: {}", allVfResources.right().value());
+				result = false;
+				return result;
+			}
+			List<ResourceMetadataData> resourcesList = allVfResources.left().value();
+			if (resourcesList == null) {
+				log.error("Couldn't get VF resources from DB, no resources found");
+				result = false;
+				return result;
+			}
+			log.debug("Found {} VF resources", resourcesList.size());
+			for (ResourceMetadataData resource : resourcesList) {
+				result = createGroupIfContainsArtifacts(resource);
+			}
+		} finally {
+			if (!result) {
+				titanGenericDao.rollback();
+				log.debug("**********************************************");
+				log.debug("The align groups procedure FAILED!!");
+				log.debug("**********************************************");
+			} else {
+				titanGenericDao.commit();
+				log.debug("**********************************************");
+				log.debug("The align groups procedure ended successfully!");
+				log.debug("**********************************************");
+			}
+		}
+
+		return result;
+	}
+
+	private boolean createGroupIfContainsArtifacts(ResourceMetadataData resource) {
+
+		String uniqueId = resource.getMetadataDataDefinition().getUniqueId();
+		StorageOperationStatus result = StorageOperationStatus.OK;
+		Either<Map<String, ArtifactDefinition>, StorageOperationStatus> allArtifactsRes = artifactOperation
+				.getArtifacts(uniqueId, NodeTypeEnum.Resource, true);
+		if (allArtifactsRes.isRight()) {
+			log.error("Couldn't get resource artifacts from DB, error: {}", allArtifactsRes.right().value());
+			return false;
+		}
+		Map<String, ArtifactDefinition> artifactsHM = allArtifactsRes.left().value();
+		ArrayList<String> foundArtifactsAL = new ArrayList<String>();
+		for (ArtifactDefinition curArtifact : artifactsHM.values()) {
+			String atrifactType = curArtifact.getArtifactType();
+			if (atrifactType.equalsIgnoreCase(ArtifactTypeEnum.HEAT_VOL.getType())
+					|| atrifactType.equalsIgnoreCase(ArtifactTypeEnum.HEAT_NET.getType())
+					|| atrifactType.equalsIgnoreCase(ArtifactTypeEnum.HEAT.getType())) {
+				foundArtifactsAL.add(curArtifact.getUniqueId());
+			}
+		}
+		if (foundArtifactsAL.size() > 0) {
+			Either<List<GroupDefinition>, TitanOperationStatus> allGroupsRes = groupOperation
+					.getAllGroupsFromGraph(uniqueId, NodeTypeEnum.Resource);
+			int groupCounter = 1;
+			if (allGroupsRes.isRight()) {
+				if (allGroupsRes.right().value().name().equals(TitanOperationStatus.OK.name())
+						|| allGroupsRes.right().value().name().equals(TitanOperationStatus.NOT_FOUND.name())) {
+					log.debug("Not found groups resource related to resource {}, response: {}",
+							resource.getMetadataDataDefinition().getName(), allGroupsRes.right().value());
+				} else {
+					log.error("Not found groups resource related to resource {}, DB error: {}",
+							resource.getMetadataDataDefinition().getName(), allGroupsRes.right().value());
+					return false;
+				}
+			} else if (allGroupsRes.left().value() != null && allGroupsRes.left().value().size() > 0) {
+				groupCounter += allGroupsRes.left().value().size();
+				for (GroupDefinition curGroup : allGroupsRes.left().value()) {
+					for (String curGroupArtifact : curGroup.getArtifacts()) {
+						if (foundArtifactsAL.contains(curGroupArtifact)) {
+							foundArtifactsAL.remove(curGroupArtifact);
+						}
+					}
+				}
+			}
+			if (foundArtifactsAL.size() > 0) {
+				GroupDefinition groupDefinition = new GroupDefinition();
+				groupDefinition.setName(resource.getMetadataDataDefinition().getName() + MODULE + groupCounter);
+				groupDefinition.setType(DEFAULT_GROUP_VF_MODULE);
+				groupDefinition.setArtifacts(foundArtifactsAL);
+				log.debug("Creating new group {} for VF resource {}", groupDefinition.getName(),
+						resource.getMetadataDataDefinition().getName());
+				return createGroup(resource.getUniqueId(), ComponentTypeEnum.RESOURCE, groupDefinition);
+
+			}
+		}
+		return true;
+	}
+
+	private boolean createGroup(Object uniqueId, ComponentTypeEnum componentType, GroupDefinition groupDefinition) {
+
+		NodeTypeEnum nodeTypeEnum = componentType.getNodeType();
+		String groupType = groupDefinition.getType();
+
+		Either<GroupTypeDefinition, StorageOperationStatus> getGroupTypeRes = groupTypeOperation
+				.getLatestGroupTypeByType(groupType, true);
+		if (getGroupTypeRes.isRight()) {
+			log.error("Couldn't get grouptype by type {} from DB, error: {}", groupType,
+					getGroupTypeRes.right().value());
+			return false;
+		}
+
+		GroupTypeDefinition groupTypeDefinition = getGroupTypeRes.left().value();
+
+		String invariantUUID = UniqueIdBuilder.buildInvariantUUID();
+		groupDefinition.setInvariantUUID(invariantUUID);
+		groupDefinition.setVersion(INITIAL_VERSION);
+		groupDefinition.setTypeUid(groupTypeDefinition.getUniqueId());
+
+		Either<GroupDefinition, StorageOperationStatus> addGroupToGraphRes = groupOperation.addGroup(nodeTypeEnum,
+				(String) uniqueId, groupDefinition, true);
+
+		if (addGroupToGraphRes.isRight()) {
+			log.error("Couldn't add group {} to graph, error: {}", groupDefinition.getName(),
+					addGroupToGraphRes.right().value());
+			return false;
+		}
+		log.debug("The group {} has been created", groupDefinition.getName());
+		return true;
+	}
+
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/MigrationCategory.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/MigrationCategory.java
new file mode 100644
index 0000000000..5605f0980d
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/MigrationCategory.java
@@ -0,0 +1,48 @@
+/*-
+ * ============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.asdctool.impl.migration.v1604;
+
+import java.util.List;
+
+import org.openecomp.sdc.be.datatypes.category.CategoryDataDefinition;
+
+public class MigrationCategory extends CategoryDataDefinition {
+	private String oldName;
+
+	List<MigrationSubCategory> subcategories;
+
+	public String getOldName() {
+		return oldName;
+	}
+
+	public void setOldName(String oldName) {
+		this.oldName = oldName;
+	}
+
+	public List<MigrationSubCategory> getSubcategories() {
+		return subcategories;
+	}
+
+	public void setSubcategories(List<MigrationSubCategory> subcategories) {
+		this.subcategories = subcategories;
+	}
+
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/MigrationSubCategory.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/MigrationSubCategory.java
new file mode 100644
index 0000000000..f1886622be
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/MigrationSubCategory.java
@@ -0,0 +1,36 @@
+/*-
+ * ============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.asdctool.impl.migration.v1604;
+
+import org.openecomp.sdc.be.datatypes.category.SubCategoryDataDefinition;
+
+public class MigrationSubCategory extends SubCategoryDataDefinition {
+	private String oldName;
+
+	public String getOldName() {
+		return oldName;
+	}
+
+	public void setOldName(String oldName) {
+		this.oldName = oldName;
+	}
+
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/ServiceMigration.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/ServiceMigration.java
new file mode 100644
index 0000000000..cb7f05ddfd
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/ServiceMigration.java
@@ -0,0 +1,1703 @@
+/*-
+ * ============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.asdctool.impl.migration.v1604;
+
+import static java.nio.file.Files.readAllBytes;
+import static java.nio.file.Paths.get;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.UUID;
+
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.tinkerpop.gremlin.structure.Direction;
+import org.apache.tinkerpop.gremlin.structure.Edge;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.openecomp.sdc.be.dao.api.ActionStatus;
+import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
+import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
+import org.openecomp.sdc.be.dao.graph.datatype.RelationEndPoint;
+import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
+import org.openecomp.sdc.be.dao.neo4j.GraphEdgePropertiesDictionary;
+import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
+import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
+import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition;
+import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
+import org.openecomp.sdc.be.model.AdditionalInformationDefinition;
+import org.openecomp.sdc.be.model.CapabilityDefinition;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.RequirementDefinition;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.be.model.User;
+import org.openecomp.sdc.be.model.category.CategoryDefinition;
+import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
+import org.openecomp.sdc.be.model.operations.api.IElementOperation;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.AdditionalInformationOperation;
+import org.openecomp.sdc.be.model.operations.impl.ComponentInstanceOperation;
+import org.openecomp.sdc.be.model.operations.impl.ComponentOperation;
+import org.openecomp.sdc.be.model.operations.impl.LifecycleOperation;
+import org.openecomp.sdc.be.model.operations.impl.ProductOperation;
+import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
+import org.openecomp.sdc.be.model.operations.impl.ResourceOperation;
+import org.openecomp.sdc.be.model.operations.impl.ServiceOperation;
+import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
+import org.openecomp.sdc.be.resources.data.CapabilityData;
+import org.openecomp.sdc.be.resources.data.ComponentInstanceData;
+import org.openecomp.sdc.be.resources.data.ComponentMetadataData;
+import org.openecomp.sdc.be.resources.data.ProductMetadataData;
+import org.openecomp.sdc.be.resources.data.RelationshipInstData;
+import org.openecomp.sdc.be.resources.data.RequirementData;
+import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
+import org.openecomp.sdc.be.resources.data.ServiceMetadataData;
+import org.openecomp.sdc.be.resources.data.TagData;
+import org.openecomp.sdc.be.resources.data.category.CategoryData;
+import org.openecomp.sdc.be.resources.data.category.SubCategoryData;
+import org.openecomp.sdc.be.utils.CommonBeUtils;
+import org.openecomp.sdc.common.util.ValidationUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.yaml.snakeyaml.Yaml;
+
+import com.thinkaurelius.titan.core.TitanEdge;
+import com.thinkaurelius.titan.core.TitanGraph;
+import com.thinkaurelius.titan.core.TitanVertex;
+
+import fj.data.Either;
+
+public class ServiceMigration {
+
+	private static final String[] NORMATIVE_OLD_NAMES = { 
+			"tosca.nodes.network.Network", "tosca.nodes.network.Port",
+			"tosca.nodes.BlockStorage", "tosca.nodes.Compute", "tosca.nodes.Container.Application",
+			"tosca.nodes.Container.Runtime", "tosca.nodes.Database", "tosca.nodes.DBMS", "tosca.nodes.LoadBalancer",
+			"tosca.nodes.ObjectStorage", "tosca.nodes.Root", "tosca.nodes.SoftwareComponent",
+			"tosca.nodes.WebApplication", "tosca.nodes.WebServer", };
+
+	private static Logger log = LoggerFactory.getLogger(ServiceMigration.class.getName());
+
+	@Autowired
+	protected TitanGenericDao titanGenericDao;
+	@Autowired
+	protected ResourceOperation resourceOperation;
+	@Autowired
+	protected ServiceOperation serviceOperation;
+	@Autowired
+	protected ProductOperation productOperation;
+	@Autowired
+	protected LifecycleOperation lifecycleOperaion;
+	@Autowired
+	protected PropertyOperation propertyOperation;
+	@Autowired
+	protected AdditionalInformationOperation additionalInformationOperation;
+	@Autowired
+	protected ComponentInstanceOperation componentInstanceOperaion;
+	@Autowired
+	protected IElementOperation elementOperation;
+
+	public boolean migrate1602to1604(String appConfigDir) {
+
+		boolean result = false;
+
+		try {
+
+			if (!addResourceCounterToResources()) {
+				log.debug("Failed to update resource instance counter on resources");
+				result = false;
+				return result;
+			}
+			if (!updateComponentInstanceType()) {
+				log.debug("Failed to update component instance type");
+				result = false;
+				return result;
+			}
+			// fix VF
+			if (!fixDerivedVf()) {
+				log.debug("Failed to fix VFs");
+				result = false;
+				return result;
+			}
+			// update instances and relation
+			if (!updateCalculatedEdges()) {
+				log.debug("Failed to update calculated edges for VF instances");
+				result = false;
+				return result;
+			}
+			// update instances and relation
+			if (!updateRelations()) {
+				log.debug("Failed to update Instance And Relations in services");
+				result = false;
+				return result;
+			}
+			if (!updateCategories(appConfigDir)) {
+				log.debug("Failed to update categories");
+				result = false;
+				return result;
+			}
+
+			if (!AllowMultipleHeats.removeAndUpdateHeatPlaceHolders(titanGenericDao, log, true)) {
+				log.error("Failed to update heat place holders");
+				result = false;
+				return result;
+			}
+
+			if (!AddGroupUuid.addGroupUuids(titanGenericDao, log, true)) {
+				log.error("Failed to update group UUIDs");
+				result = false;
+				return result;
+			}
+
+			result = true;
+		} finally {
+			if (!result) {
+				titanGenericDao.rollback();
+			} else {
+				titanGenericDao.commit();
+			}
+		}
+		return result;
+	}
+
+	private boolean updateCategories(String appConfigDir) {
+		// String categoryMigrationFile = appConfigDir + File.separator +
+		// "categoryMigration.yaml";
+		String categoryMigrationFile = appConfigDir + "categoryMigration.yaml";
+
+		Map<String, List<MigrationCategory>> categoriesFromYml;
+		try {
+			categoriesFromYml = createCategoriesFromYml(categoryMigrationFile);
+			if (categoriesFromYml == null || categoriesFromYml.isEmpty()) {
+				log.debug("updateCategories failed to load categories form migration file {}", categoryMigrationFile);
+				return false;
+			}
+		} catch (Exception e) {
+			log.debug("Failed to load category migration file :{} error: {}",categoryMigrationFile, e);
+			return false;
+		}
+		for (Map.Entry<String, List<MigrationCategory>> entry : categoriesFromYml.entrySet()) {
+			ComponentTypeEnum componentType = ComponentTypeEnum.findByParamName(entry.getKey());
+			if (componentType != null) {
+				switch (componentType) {
+				case RESOURCE:
+					if (updateResourceCategories(entry.getValue()) == false) {
+						log.debug("updateCategories failed to update resource categories");
+						return false;
+					}
+					break;
+				case SERVICE:
+					if (updateServiceCategories(entry.getValue()) == false) {
+						log.debug("updateCategories failed to update service categories");
+						return false;
+					}
+					break;
+				default:
+					log.debug("updateCategories no changes for categories from type {}", componentType);
+				}
+			} else {
+				log.debug("updateCategories failed not supported component file in migration categories file {}", entry.getKey());
+				return false;
+			}
+		}
+		return true;
+	}
+
+	private boolean updateServiceCategories(List<MigrationCategory> categories) {
+		log.debug("updateServiceCategories STARTED");
+		Either<List<CategoryDefinition>, ActionStatus> serviceCategories = elementOperation
+				.getAllCategories(NodeTypeEnum.ServiceNewCategory, true);
+		if (serviceCategories.isRight()) {
+			log.debug("updateServiceCategories failed fetch all service categories ,error: {}", serviceCategories.right().value());
+			return false;
+		}
+		for (MigrationCategory newCat : categories) {
+
+			if (newCat.getOldName() == null) {
+				// add new
+				boolean exist = false;
+				for (CategoryDefinition catInDB : serviceCategories.left().value()) {
+					if (newCat.getName().equals(catInDB.getName())) {
+						exist = true;
+						break;
+					}
+				}
+				if (!exist) {
+					CategoryDefinition categoryDefinition = new CategoryDefinition(newCat);
+					Either<CategoryDefinition, ActionStatus> result = elementOperation
+							.createCategory(categoryDefinition, NodeTypeEnum.ServiceNewCategory, true);
+					if (result.isRight()) {
+						log.debug("Failed to create service category {}, error: {}", categoryDefinition, result.right().value());
+						return false;
+					}
+					log.debug("service category {} created", categoryDefinition);
+				}
+			} else {
+				// update exist
+				for (CategoryDefinition catInDB : serviceCategories.left().value()) {
+					if (newCat.getOldName().equals(catInDB.getName())) {
+						Either<CategoryData, TitanOperationStatus> updateSingleResult = updateSingleResourceCategory(
+								newCat, NodeTypeEnum.ServiceNewCategory);
+						if (updateSingleResult.isRight()) {
+							return false;
+						}
+						break;
+					}
+				}
+			}
+		}
+		log.debug("updateServiceCategories ENDED");
+		return true;
+	}
+
+	private Either<CategoryData, TitanOperationStatus> updateSingleResourceCategory(MigrationCategory newCat,
+			NodeTypeEnum nodetype) {
+		Map<String, Object> properties = new HashMap<>();
+		properties.put(GraphPropertiesDictionary.NAME.getProperty(), newCat.getOldName());
+		Either<List<CategoryData>, TitanOperationStatus> categoryEither = titanGenericDao.getByCriteria(nodetype,
+				properties, CategoryData.class);
+		if (categoryEither.isRight() && categoryEither.right().value() != TitanOperationStatus.NOT_FOUND) {
+			log.debug("Failed to get {} categories, for name {} error {}", nodetype, newCat.getOldName(),
+					categoryEither.right().value());
+			return Either.right(categoryEither.right().value());
+		}
+		List<CategoryData> categoryList = (categoryEither.isLeft() ? categoryEither.left().value() : null);
+		if (categoryList == null) {
+			log.debug("No {} categories, for name {} error {}", nodetype, newCat.getOldName());
+			return Either.right(TitanOperationStatus.NOT_FOUND);
+		}
+		CategoryData categoryData = categoryList.get(0);
+		categoryData.getCategoryDataDefinition().setName(newCat.getName());
+		categoryData.getCategoryDataDefinition().setIcons(newCat.getIcons());
+		categoryData.getCategoryDataDefinition()
+				.setNormalizedName(ValidationUtils.normalizeCategoryName4Uniqueness(newCat.getName()));
+		Either<CategoryData, TitanOperationStatus> updateNode = titanGenericDao.updateNode(categoryData,
+				CategoryData.class);
+		if (updateNode.isRight()) {
+			log.debug("Failed to update {} category {} error {}", nodetype, categoryData, updateNode.right().value());
+			return Either.right(updateNode.right().value());
+		}
+		log.debug("Update {} category {} ", nodetype, categoryData);
+		return Either.left(updateNode.left().value());
+	}
+
+	private boolean updateResourceCategories(List<MigrationCategory> categories) {
+		log.debug("updateResourceCategories STARTED");
+		Either<List<CategoryDefinition>, ActionStatus> resourceCategories = elementOperation
+				.getAllCategories(NodeTypeEnum.ResourceNewCategory, true);
+		if (resourceCategories.isRight()) {
+			log.debug("updateResourceCategories failed fetch all resource categories ,error "
+					+ resourceCategories.right().value());
+			return false;
+		}
+		for (MigrationCategory newCat : categories) {
+			if (newCat.getOldName() == null) {
+				// add new
+				// check if already created in previous running
+				boolean exist = false;
+				for (CategoryDefinition catInDB : resourceCategories.left().value()) {
+					if (newCat.getName().equals(catInDB.getName())) {
+						exist = true;
+					}
+				}
+				if (!exist) {
+					CategoryDefinition categoryDefinition = new CategoryDefinition(newCat);
+					Either<CategoryDefinition, ActionStatus> resultCat = elementOperation
+							.createCategory(categoryDefinition, NodeTypeEnum.ResourceNewCategory, true);
+					if (resultCat.isRight()) {
+						log.debug("Failed to create resource category {}, error: {}", categoryDefinition, resultCat.right().value());
+						return false;
+					}
+					log.debug("resource category {} created", categoryDefinition);
+
+					List<MigrationSubCategory> nSubCat = newCat.getSubcategories();
+					List<MigrationSubCategory> newSubcat = nSubCat;
+					List<MigrationSubCategory> subcategories = newSubcat;
+					for (MigrationSubCategory msubcat : subcategories) {
+						SubCategoryDefinition subcat = new SubCategoryDefinition(msubcat);
+						Either<SubCategoryDefinition, ActionStatus> resultSubcat = elementOperation.createSubCategory(
+								resultCat.left().value().getUniqueId(), subcat, NodeTypeEnum.ResourceSubcategory, true);
+						if (resultSubcat.isRight()) {
+							log.debug("Failed to create resource sub category {} error: {}", subcat, resultSubcat.right().value());
+							return false;
+						}
+						log.debug("resource sub category {} created for category {}", categoryDefinition, resultCat.left().value().getName());
+					}
+				}
+			} else {
+				// update exist
+				for (CategoryDefinition catInDB : resourceCategories.left().value()) {
+					if (newCat.getOldName().equals(catInDB.getName())) {
+						Either<CategoryData, TitanOperationStatus> updateSingleResult = updateSingleResourceCategory(
+								newCat, NodeTypeEnum.ResourceNewCategory);
+						if (updateSingleResult.isRight()) {
+							return false;
+						}
+
+						CategoryData categoryData = updateSingleResult.left().value();
+						for (MigrationSubCategory migSubCat : newCat.getSubcategories()) {
+							if (migSubCat.getOldName() == null) {
+								// create new one
+								boolean existSub = false;
+								for (SubCategoryDefinition subCatInDb : catInDB.getSubcategories()) {
+									if (subCatInDb.getName().equals(migSubCat.getName())) {
+										existSub = true;
+									}
+								}
+								if (!existSub) {
+									SubCategoryDefinition subcat = new SubCategoryDefinition(migSubCat);
+
+									Either<SubCategoryDefinition, ActionStatus> resultSubcat = elementOperation
+											.createSubCategory((String) categoryData.getUniqueId(), subcat,
+													NodeTypeEnum.ResourceSubcategory, true);
+									if (resultSubcat.isRight()) {
+										log.debug("Failed to create resource sub category {} error: {}", subcat, resultSubcat.right().value());
+										return false;
+									}
+									log.debug("resource sub category {}", categoryData, resultSubcat.left().value().getName());
+								}
+							} else {
+								if (updateSingleSubCategory(newCat, migSubCat,
+										updateSingleResult.left().value()) == false) {
+									return false;
+								}
+							}
+						}
+						break;
+					}
+				}
+			}
+		}
+		return true;
+	}
+
+	private boolean updateSingleSubCategory(MigrationCategory newCat, MigrationSubCategory migSubCat,
+			CategoryData categoryData) {
+
+		Either<List<ImmutablePair<SubCategoryData, GraphEdge>>, TitanOperationStatus> subcategories = titanGenericDao
+				.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceNewCategory),
+						(String) categoryData.getUniqueId(), GraphEdgeLabels.SUB_CATEGORY,
+						NodeTypeEnum.ResourceSubcategory, SubCategoryData.class);
+
+		if (subcategories.isRight()) {
+			log.debug("Failed to get resource sub categories, for name {} error {}", newCat.getOldName(),
+					subcategories.right().value());
+			return false;
+		}
+
+		for (ImmutablePair<SubCategoryData, GraphEdge> pair : subcategories.left().value()) {
+			if (pair.getKey().getSubCategoryDataDefinition().getName().equals(migSubCat.getOldName())) {
+				SubCategoryData subCategoryData = pair.getKey();
+				subCategoryData.getSubCategoryDataDefinition().setName(migSubCat.getName());
+				subCategoryData.getSubCategoryDataDefinition().setIcons(migSubCat.getIcons());
+				subCategoryData.getSubCategoryDataDefinition()
+						.setNormalizedName(ValidationUtils.normalizeCategoryName4Uniqueness(migSubCat.getName()));
+				Either<SubCategoryData, TitanOperationStatus> updateSubNode = titanGenericDao
+						.updateNode(subCategoryData, SubCategoryData.class);
+				if (updateSubNode.isRight()) {
+					log.debug("Failed to update resource sub category {} error {}", subCategoryData,
+							updateSubNode.right().value());
+					return false;
+				}
+				log.debug("Update resource subcategory category {} ", subCategoryData);
+				break;
+			}
+		}
+		return true;
+	}
+
+	private Map<String, List<MigrationCategory>> createCategoriesFromYml(String categoriesTypesYml) {
+		String yamlAsString;
+		try {
+			yamlAsString = new String(readAllBytes(get(categoriesTypesYml)));
+		} catch (Exception e) {
+			log.debug("Failed to load category import file exception : ", e);
+			return null;
+		}
+
+		log.debug("received yaml: {}", yamlAsString);
+
+		Map<String, Object> toscaJson = (Map<String, Object>) new Yaml().load(yamlAsString);
+		Map<String, List<MigrationCategory>> allCategories = new HashMap<>();
+
+		Iterator<Entry<String, Object>> categoryEntryItr = toscaJson.entrySet().iterator();
+		while (categoryEntryItr.hasNext()) {
+			Entry<String, Object> categoryTypeEntry = categoryEntryItr.next();
+			String categoryType = categoryTypeEntry.getKey();
+			List<MigrationCategory> categoriesPerType = null;
+			Map<String, Object> categoryPerType = null;
+			switch (categoryType) {
+			case ComponentTypeEnum.SERVICE_PARAM_NAME:
+				categoryPerType = (Map<String, Object>) categoryTypeEntry.getValue();
+				categoriesPerType = createServiceCategories(categoryPerType);
+				break;
+			case ComponentTypeEnum.RESOURCE_PARAM_NAME:
+				categoryPerType = (Map<String, Object>) categoryTypeEntry.getValue();
+				categoriesPerType = createResourceCategories(categoryPerType);
+				break;
+			case ComponentTypeEnum.PRODUCT_PARAM_NAME:
+				// TODO
+				break;
+			default:
+				log.debug("Not supported category type - {}", categoryType);
+				break;
+			}
+			if (categoriesPerType != null) {
+				allCategories.put(categoryType, categoriesPerType);
+			}
+		}
+		return allCategories;
+	}
+
+	private List<MigrationCategory> createServiceCategories(Map<String, Object> categories) {
+		List<MigrationCategory> categroiesDef = new ArrayList<>();
+		String catName = null;
+		List<String> icons = null;
+		String oldName = null;
+		for (Entry<String, Object> entry : categories.entrySet()) {
+			MigrationCategory catDef = new MigrationCategory();
+			Map<String, Object> category = (Map<String, Object>) entry.getValue();
+			catName = (String) category.get("name");
+			catDef.setName(catName);
+			icons = (List<String>) category.get("icons");
+			catDef.setIcons(icons);
+			String normalizedName = ValidationUtils.normalizeCategoryName4Uniqueness(catName);
+			catDef.setNormalizedName(normalizedName);
+			oldName = (String) category.get("oldName");
+			catDef.setOldName(oldName);
+			categroiesDef.add(catDef);
+		}
+
+		return categroiesDef;
+	}
+
+	private List<MigrationCategory> createResourceCategories(Map<String, Object> categoryPerType) {
+		List<MigrationCategory> categroiesDef = new ArrayList<>();
+		for (Map.Entry<String, Object> entry : categoryPerType.entrySet()) {
+			Map<String, Object> category = (Map<String, Object>) entry.getValue();
+			MigrationCategory catDef = new MigrationCategory();
+			String catName = (String) category.get("name");
+			catDef.setName(catName);
+			String normalizedName = ValidationUtils.normalizeCategoryName4Uniqueness(catName);
+			catDef.setNormalizedName(normalizedName);
+			String oldName = (String) category.get("oldName");
+			catDef.setOldName(oldName);
+
+			Map<String, Object> subcategories = (Map<String, Object>) category.get("subcategories");
+			List<MigrationSubCategory> subcateDef = new ArrayList<>();
+			for (Entry<String, Object> subcategory : subcategories.entrySet()) {
+				Map<String, Object> subcategoryInfo = (Map<String, Object>) subcategory.getValue();
+				MigrationSubCategory subDef = new MigrationSubCategory();
+				String subcategoryName = (String) subcategoryInfo.get("name");
+				subDef.setName(subcategoryName);
+				List<String> subcategoryIcons = (List<String>) subcategoryInfo.get("icons");
+				subDef.setIcons(subcategoryIcons);
+				normalizedName = ValidationUtils.normalizeCategoryName4Uniqueness(subcategoryName);
+				subDef.setNormalizedName(normalizedName);
+				oldName = (String) subcategoryInfo.get("oldName");
+				subDef.setOldName(oldName);
+
+				subcateDef.add(subDef);
+			}
+
+			catDef.setSubcategories(subcateDef);
+			categroiesDef.add(catDef);
+		}
+		return categroiesDef;
+	}
+
+	private boolean updateCalculatedEdges() {
+		log.debug("update calculated edges STARTED");
+
+		Either<List<ComponentInstanceData>, TitanOperationStatus> allInstances = titanGenericDao
+				.getByCriteria(NodeTypeEnum.ResourceInstance, null, ComponentInstanceData.class);
+		if (allInstances.isRight() && !allInstances.right().value().equals(TitanOperationStatus.NOT_FOUND)) {
+			log.debug(
+					"updateCalculatedEdges failed fetch all resource instances ,error " + allInstances.right().value());
+			return false;
+		}
+		if (allInstances.isRight() && allInstances.right().value().equals(TitanOperationStatus.NOT_FOUND)) {
+			log.debug("updateCalculatedEdges - no VFs");
+			return true;
+		}
+		List<ComponentInstanceData> listOfInstances = allInstances.left().value();
+		for (ComponentInstanceData instance : listOfInstances) {
+			// check if already have calculated edges
+			log.debug("start handle instance {}", instance.getUniqueId());
+			boolean needProcess = true;
+			Either<List<ImmutablePair<CapabilityData, GraphEdge>>, TitanOperationStatus> vfci = titanGenericDao
+					.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance),
+							instance.getUniqueId(), GraphEdgeLabels.CALCULATED_CAPABILITY, NodeTypeEnum.Capability,
+							CapabilityData.class);
+			if (vfci.isRight()) {
+				if (!vfci.right().value().equals(TitanOperationStatus.NOT_FOUND)) {
+					log.debug("createCalculatedCapabilitiesForInstance failed to fetch instance for resource {} error: {}", 
+							instance.getComponentInstDataDefinition().getComponentUid(),
+							vfci.right().value());
+					return false;
+				}
+			} else {
+				if (vfci.left().value().size() > 0) {
+					needProcess = false;
+				}
+			}
+			Either<List<ImmutablePair<RequirementData, GraphEdge>>, TitanOperationStatus> vfciReq = titanGenericDao
+					.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance),
+							instance.getUniqueId(), GraphEdgeLabels.CALCULATED_REQUIREMENT, NodeTypeEnum.Requirement,
+							RequirementData.class);
+			if (vfciReq.isRight()) {
+				if (!vfciReq.right().value().equals(TitanOperationStatus.NOT_FOUND)) {
+					log.debug("createCalculatedCapabilitiesForInstance failed to fetch instance for resource {} error: {}",
+							instance.getComponentInstDataDefinition().getComponentUid(),
+							vfciReq.right().value());
+					return false;
+				}
+			} else {
+				if (vfciReq.left().value().size() > 0) {
+					needProcess = false;
+				}
+			}
+			Either<List<ImmutablePair<RequirementData, GraphEdge>>, TitanOperationStatus> vfciReqFF = titanGenericDao
+					.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance),
+							instance.getUniqueId(), GraphEdgeLabels.CALCULATED_REQUIREMENT_FULLFILLED,
+							NodeTypeEnum.Requirement, RequirementData.class);
+			if (vfciReqFF.isRight()) {
+
+				if (!vfciReqFF.right().value().equals(TitanOperationStatus.NOT_FOUND)) {
+					log.debug("createCalculatedCapabilitiesForInstance failed to fetch instance for resource "
+							+ instance.getComponentInstDataDefinition().getComponentUid() + " error "
+							+ vfciReqFF.right().value());
+					return false;
+				}
+			} else {
+				if (vfciReqFF.left().value().size() > 0) {
+					needProcess = false;
+				}
+			}
+
+			if (needProcess == false) {
+				log.debug("updateCalculatedEdges : for instance {} calculated capabilty/requirement already created", instance.getUniqueId());
+				continue;
+			}
+			String originId = instance.getComponentInstDataDefinition().getComponentUid();
+			Either<Resource, StorageOperationStatus> resourceE = resourceOperation.getResource(originId, true);
+			if (resourceE.isRight()) {
+				log.debug("updateCalculatedEdges failed to fetch origin resource with id {} error: {}", originId, resourceE.right().value());
+				return false;
+			}
+			Resource resource = resourceE.left().value();
+			Map<String, List<RequirementDefinition>> requirements = resource.getRequirements();
+			if (createCalculatedRequirementsForInstance(instance, requirements) != true) {
+				return false;
+			}
+			Map<String, List<CapabilityDefinition>> capabilities = resource.getCapabilities();
+			if (createCalculatedCapabilitiesForInstance(instance, capabilities) != true) {
+				return false;
+			}
+			log.debug("finish handle instance {}", instance.getUniqueId());
+		}
+		log.debug("update calculated edges ENDED");
+		return true;
+	}
+
+	private boolean createCalculatedCapabilitiesForInstance(ComponentInstanceData instance,
+			Map<String, List<CapabilityDefinition>> capabilities) {
+		for (Map.Entry<String, List<CapabilityDefinition>> entry : capabilities.entrySet()) {
+			for (CapabilityDefinition capability : entry.getValue()) {
+				Either<CapabilityData, TitanOperationStatus> capNode = titanGenericDao.getNode(
+						UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Capability), capability.getUniqueId(),
+						CapabilityData.class);
+				if (capNode.isRight()) {
+					log.debug("createCalculatedCapabilitiesForInstance failed to fetch capability node  with id "
+							+ capability.getUniqueId() + " error " + capNode.right().value());
+					return false;
+				}
+				Map<String, Object> props = new HashMap<>();
+				props.put(GraphEdgePropertiesDictionary.NAME.getProperty(), capability.getName());
+				if (fillEdgeProperties(instance, props) != true) {
+					return false;
+				}
+
+				Either<GraphRelation, TitanOperationStatus> createRelation = titanGenericDao.createRelation(instance,
+						capNode.left().value(), GraphEdgeLabels.CALCULATED_CAPABILITY, props);
+				if (createRelation.isRight()) {
+					TitanOperationStatus titanOperationStatus = createRelation.right().value();
+					log.debug(
+							"Failed to create calculated requirement from component instance {} to requirement {}, error: {}",
+							instance.getUniqueId(), capNode.left().value().getUniqueId(), titanOperationStatus);
+					return false;
+				}
+				log.debug("CALCULATED_CAPABILITY was created from {} to {} with props: {}", capNode.left().value().getUniqueId(), instance.getUniqueId(), props);
+			}
+		}
+		return true;
+	}
+
+	private boolean fillEdgeProperties(ComponentInstanceData instance, Map<String, Object> props) {
+		if (instance.getComponentInstDataDefinition().getOriginType().equals(OriginTypeEnum.VF)) {
+			Either<List<ImmutablePair<ComponentInstanceData, GraphEdge>>, TitanOperationStatus> vfci = titanGenericDao
+					.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource),
+							instance.getComponentInstDataDefinition().getComponentUid(), GraphEdgeLabels.RESOURCE_INST,
+							NodeTypeEnum.ResourceInstance, ComponentInstanceData.class);
+			if (vfci.isRight()) {
+				log.debug("createCalculatedCapabilitiesForInstance failed to fetch instance for resource {} error: {}",
+						instance.getComponentInstDataDefinition().getComponentUid(),
+						vfci.right().value());
+				return false;
+			}
+			ImmutablePair<ComponentInstanceData, GraphEdge> immutablePair = vfci.left().value().get(0);
+			String vfciId = immutablePair.getLeft().getUniqueId();
+			props.put(GraphEdgePropertiesDictionary.OWNER_ID.getProperty(), vfciId);
+			props.put(GraphEdgePropertiesDictionary.SOURCE.getProperty(),
+					immutablePair.getLeft().getComponentInstDataDefinition().getComponentUid());
+
+		} else {
+			props.put(GraphEdgePropertiesDictionary.OWNER_ID.getProperty(), instance.getUniqueId());
+			props.put(GraphEdgePropertiesDictionary.SOURCE.getProperty(),
+					instance.getComponentInstDataDefinition().getComponentUid());
+		}
+		return true;
+	}
+
+	private boolean createCalculatedRequirementsForInstance(ComponentInstanceData instance,
+			Map<String, List<RequirementDefinition>> requirements) {
+		for (Map.Entry<String, List<RequirementDefinition>> entry : requirements.entrySet()) {
+			for (RequirementDefinition requirement : entry.getValue()) {
+				Either<RequirementData, TitanOperationStatus> reqNode = titanGenericDao.getNode(
+						UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Requirement), requirement.getUniqueId(),
+						RequirementData.class);
+				if (reqNode.isRight()) {
+					log.debug("updateCalculatedEdges failed to fetch requirement node  with id {} error: {}", requirement.getUniqueId(), reqNode.right().value());
+					return false;
+				}
+				Map<String, Object> props = new HashMap<>();
+				props.put(GraphEdgePropertiesDictionary.NAME.getProperty(), requirement.getName());
+
+				if (fillEdgeProperties(instance, props) != true) {
+					return false;
+				}
+
+				Either<GraphRelation, TitanOperationStatus> createRelation = titanGenericDao.createRelation(instance,
+						reqNode.left().value(), GraphEdgeLabels.CALCULATED_REQUIREMENT, props);
+				if (createRelation.isRight()) {
+					TitanOperationStatus titanOperationStatus = createRelation.right().value();
+					log.debug(
+							"Failed to create calculated requirement from component instance {} to requirement {}, error: {}",
+							instance.getUniqueId(), reqNode.left().value().getUniqueId(), titanOperationStatus);
+					return false;
+				}
+				log.debug("CALCULATED_REQUIREMENT was created from {} to {} with props: {}", reqNode.left().value().getUniqueId(), instance.getUniqueId(), props);
+			}
+		}
+		return true;
+	}
+
+	private boolean updateRelations() {
+		log.debug("update relations and edges STARTED");
+		Either<List<RelationshipInstData>, TitanOperationStatus> allRelations = titanGenericDao
+				.getByCriteria(NodeTypeEnum.RelationshipInst, null, RelationshipInstData.class);
+		if (allRelations.isRight()) {
+			if (allRelations.right().value().equals(TitanOperationStatus.NOT_FOUND)) {
+				log.debug("updateRelations : No relations to update. updateRelations ENDED");
+				return true;
+			}
+			log.debug("updateRelations : failed to fetch all relation nodes , error ", allRelations.right().value());
+			return false;
+		}
+		for (RelationshipInstData rel : allRelations.left().value()) {
+			// rel.set
+			if (rel.getCapabilityOwnerId() != null && rel.getRequirementOwnerId() != null) {
+				log.debug("updateRelations : for relation {} all fields alredy fixed -> {}", rel.getUniqueId(), rel);
+				continue;
+			}
+			// update capability parameters
+			if (updateCapabiltyFieldsInRelation(rel) != true) {
+				return false;
+			}
+
+			// update requirement parameters and set calculated edge to full
+			// filled
+			if (updateRequirementFieldsInRelation(rel) != true) {
+				return false;
+			}
+
+			Either<RelationshipInstData, TitanOperationStatus> updateNode = titanGenericDao.updateNode(rel,
+					RelationshipInstData.class);
+			if (updateNode.isRight()) {
+				log.debug("updateRelations : failed to update relation node with id {}, error: {}", rel.getUniqueId(), updateNode.right().value());
+				return false;
+			}
+			log.debug("Relations was updated with values {}", rel);
+		}
+		log.debug("update relations and edges ENDED");
+		return true;
+	}
+
+	private boolean updateRequirementFieldsInRelation(RelationshipInstData rel) {
+		Either<ImmutablePair<ComponentInstanceData, GraphEdge>, TitanOperationStatus> reqInst = titanGenericDao
+				.getParentNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.RelationshipInst), rel.getUniqueId(),
+						GraphEdgeLabels.RELATIONSHIP_INST, NodeTypeEnum.ResourceInstance, ComponentInstanceData.class);
+		if (reqInst.isRight()) {
+			log.debug("updateRelations : failed to fetch capabilty component instance for relation {}, error: {}", rel.getUniqueId(), reqInst.right().value());
+			return false;
+		}
+		ComponentInstanceData requirementInstanceData = reqInst.left().value().getLeft();
+		ComponentInstanceDataDefinition reqRI = requirementInstanceData.getComponentInstDataDefinition();
+		if (reqRI.getOriginType().equals(OriginTypeEnum.VF)) {
+			Either<ImmutablePair<ComponentInstanceData, GraphEdge>, TitanOperationStatus> vfcInstInOrigVf = titanGenericDao
+					.getChildByEdgeCriteria(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource),
+							reqRI.getComponentUid(), GraphEdgeLabels.RESOURCE_INST, NodeTypeEnum.ResourceInstance,
+							ComponentInstanceData.class, null);
+			if (vfcInstInOrigVf.isRight()) {
+				log.debug("updateRelations : failed to fetch VFC instance in origin VF with id {}, error: {}", reqRI.getComponentUid(), vfcInstInOrigVf.right().value());
+				return false;
+			}
+			rel.setRequirementOwnerId(vfcInstInOrigVf.left().value().getLeft().getUniqueId());
+		} else {
+			rel.setRequirementOwnerId(reqRI.getUniqueId());
+		}
+		// get vertex
+		Either<TitanVertex, TitanOperationStatus> vertexReqRI = titanGenericDao.getVertexByProperty(
+				UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), requirementInstanceData.getUniqueId());
+		if (vertexReqRI.isRight()) {
+			log.debug("updateRelations : failed to fetch veterx for instance {}, error: {}", requirementInstanceData.getUniqueId(), vertexReqRI.right().value());
+			return false;
+		}
+		String[] splitIds = rel.getUniqueId().split("\\.");
+		String reqName = splitIds[splitIds.length - 1];
+		Map<String, Object> props = new HashMap<>();
+		props.put(GraphEdgePropertiesDictionary.NAME.getProperty(), reqName);
+		Either<List<Edge>, TitanOperationStatus> edgesForNode = titanGenericDao
+				.getOutgoingEdgesByCriteria(vertexReqRI.left().value(), GraphEdgeLabels.CALCULATED_REQUIREMENT, props);
+		if (edgesForNode.isRight()) {
+			log.debug("updateRelations : failed to fetch edges for instance {}, error: {}", requirementInstanceData.getUniqueId(), edgesForNode.right().value());
+			return false;
+		}
+		Edge edge = edgesForNode.left().value().get(0);
+		String reqId = (String) titanGenericDao.getProperty((TitanVertex) edge.inVertex(),
+				GraphPropertiesDictionary.UNIQUE_ID.getProperty());
+		rel.setRequirementId(reqId);
+
+		// change edge label
+		TitanEdge newEdge = (TitanEdge) vertexReqRI.left().value()
+				.addEdge(GraphEdgeLabels.CALCULATED_REQUIREMENT_FULLFILLED.getProperty(), edge.inVertex());
+		titanGenericDao.setProperties(newEdge, titanGenericDao.getProperties(edge));
+		edge.remove();
+
+		log.debug("Edge was changed to CALCULATED_REQUIREMENT_FULLFILLED for relation between {} and {}", reqId, requirementInstanceData.getUniqueId());
+
+		return true;
+	}
+
+	public boolean updateCapabiltyFieldsInRelation(RelationshipInstData rel) {
+		// update capability parameters
+		Either<ImmutablePair<ComponentInstanceData, GraphEdge>, TitanOperationStatus> capInst = titanGenericDao
+				.getChildByEdgeCriteria(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.RelationshipInst),
+						rel.getUniqueId(), GraphEdgeLabels.CAPABILITY_NODE, NodeTypeEnum.ResourceInstance,
+						ComponentInstanceData.class, null);
+		if (capInst.isRight()) {
+			log.debug("updateRelations : failed to fetch capabilty component instance for relation {}, error: {}", rel.getUniqueId(), capInst.right().value());
+			return false;
+		}
+		ComponentInstanceData capabiltyInstanceData = capInst.left().value().getLeft();
+		ComponentInstanceDataDefinition capRI = capabiltyInstanceData.getComponentInstDataDefinition();
+		if (capRI.getOriginType().equals(OriginTypeEnum.VF)) {
+			Either<ImmutablePair<ComponentInstanceData, GraphEdge>, TitanOperationStatus> vfcInstInOrigVf = titanGenericDao
+					.getChildByEdgeCriteria(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource),
+							capRI.getComponentUid(), GraphEdgeLabels.RESOURCE_INST, NodeTypeEnum.ResourceInstance,
+							ComponentInstanceData.class, null);
+			if (vfcInstInOrigVf.isRight()) {
+				log.debug("updateRelations : failed to fetch VFC instance in origin VF with id {}, error: {}", capRI.getComponentUid(), vfcInstInOrigVf.right().value());
+				return false;
+			}
+			rel.setCapabilityOwnerId(vfcInstInOrigVf.left().value().getLeft().getUniqueId());
+		} else {
+			rel.setCapabilityOwnerId(capRI.getUniqueId());
+		}
+
+		// get vertex
+		Either<TitanVertex, TitanOperationStatus> vertexCapRI = titanGenericDao.getVertexByProperty(
+				UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), capabiltyInstanceData.getUniqueId());
+		if (vertexCapRI.isRight()) {
+			log.debug("updateRelations : failed to fetch veterx for instance {}, error: {}", capabiltyInstanceData.getUniqueId(), vertexCapRI.right().value());
+			return false;
+		}
+		// String[] splitIds = rel.getUniqueId().split("\\.");
+		String capName = (String) capInst.left().value().getRight().getProperties()
+				.get(GraphEdgePropertiesDictionary.NAME.getProperty());// splitIds[splitIds.length
+																		// - 1];
+		Map<String, Object> props = new HashMap<>();
+		props.put(GraphEdgePropertiesDictionary.NAME.getProperty(), capName);
+		Either<List<Edge>, TitanOperationStatus> edgesForNode = titanGenericDao
+				.getOutgoingEdgesByCriteria(vertexCapRI.left().value(), GraphEdgeLabels.CALCULATED_CAPABILITY, props);
+		if (edgesForNode.isRight()) {
+			log.debug("updateRelations : failed to fetch edges for instance {}, error: {}", capabiltyInstanceData.getUniqueId(), edgesForNode.right().value());
+			return false;
+		}
+		Edge edge = edgesForNode.left().value().get(0);
+		String capId = (String) titanGenericDao.getProperty((TitanVertex) edge.inVertex(),
+				GraphPropertiesDictionary.UNIQUE_ID.getProperty());
+		rel.setCapabiltyId(capId);
+
+		return true;
+	}
+
+	// private boolean fixDerivedFv() {
+	// Map<String, Object> props = new HashMap<String, Object>();
+	// props.put(GraphPropertiesDictionary.RESOURCE_TYPE.getProperty(),
+	// ResourceTypeEnum.VF.name());
+	// Either<List<ResourceMetadataData>, TitanOperationStatus> allVF =
+	// titanGenericDao.getByCriteria(NodeTypeEnum.Resource, props,
+	// ResourceMetadataData.class);
+	// if (allVF.isRight() &&
+	// !allVF.right().value().equals(TitanOperationStatus.NOT_FOUND)) {
+	// log.debug("fixDerivedFv failed fetch all VF resources,error {}", allVF.right().value());
+	// return false;
+	// }
+	// if ( allVF.right().value().equals(TitanOperationStatus.NOT_FOUND) ){
+	// log.debug("fixDerivedFv - no VF");
+	// return true;
+	// }
+	// Set<String> finishedResources = new HashSet<>();
+	//
+	// for (ResourceMetadataData metadata : allVF.left().value()) {
+	// ComponentMetadataDataDefinition metadataDD =
+	// metadata.getMetadataDataDefinition();
+	//
+	// if (!finishedResources.contains(metadataDD.getUniqueId())) {
+	// Either<List<String>, StorageOperationStatus> processedIds =
+	// handleVfGroup(metadata);
+	// if (processedIds.isRight()) {
+	// log.debug("fixDerivedFv failed to process FV group {}", processedIds.right().value());
+	// return false;
+	// }
+	// finishedResources.addAll(processedIds.left().value());
+	// }
+	// }
+	// return true;
+	// }
+
+	private Either<List<String>, StorageOperationStatus> handleVfGroup(ResourceMetadataData metadata) {
+		Map<String, Object> props = new HashMap<String, Object>();
+		props.put(GraphPropertiesDictionary.RESOURCE_TYPE.getProperty(), ResourceTypeEnum.VF.name());
+		props.put(GraphPropertiesDictionary.NAME.getProperty(), metadata.getMetadataDataDefinition().getName());
+
+		List<String> finished = new ArrayList<>();
+
+		Either<List<ResourceMetadataData>, TitanOperationStatus> allVFByName = titanGenericDao
+				.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
+		if (allVFByName.isRight()) {
+			log.debug("fixDerivedFv failed fetch all VF resources,error {}", allVFByName.right().value());
+			return Either.right(StorageOperationStatus.GENERAL_ERROR);
+		}
+		Set<String> nonDuplicatedId = new HashSet<>();
+		String uuid10 = null;
+		for (ResourceMetadataData mdata : allVFByName.left().value()) {
+			String version = mdata.getMetadataDataDefinition().getVersion();
+			if (version.equals("1.0")) {
+				uuid10 = mdata.getMetadataDataDefinition().getUUID();
+				// break;
+			}
+			nonDuplicatedId.add((String) mdata.getUniqueId());
+		}
+		if (uuid10 == null) {
+			uuid10 = allVFByName.left().value().get(0).getMetadataDataDefinition().getUUID();
+		}
+		props.put(GraphPropertiesDictionary.RESOURCE_TYPE.getProperty(), ResourceTypeEnum.VF.name());
+		props.put(GraphPropertiesDictionary.UUID.getProperty(), uuid10);
+
+		Either<List<ResourceMetadataData>, TitanOperationStatus> allVFByUUID = titanGenericDao
+				.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
+		if (allVFByUUID.isRight()) {
+			log.debug("fixDerivedFv failed fetch all VF resources by UUID  {}, error: {}", uuid10, allVFByUUID.right().value());
+			return Either.right(StorageOperationStatus.GENERAL_ERROR);
+		}
+		for (ResourceMetadataData mdata : allVFByUUID.left().value()) {
+			nonDuplicatedId.add((String) mdata.getUniqueId());
+		}
+		Either<TitanGraph, TitanOperationStatus> graph = titanGenericDao.getGraph();
+		if (graph.isRight()) {
+			log.debug("fixDerivedFv failed - No titan graph ,error {}", graph.right().value());
+			return Either.right(StorageOperationStatus.GENERAL_ERROR);
+		}
+		// Map<String, String> derivedMapping = new HashMap<>();
+		for (String resourceId : nonDuplicatedId) {
+			// StorageOperationStatus handleSingleVfResult =
+			// handleSingleVf(finished, derivedMapping, resourceId);
+			StorageOperationStatus handleSingleVfResult = handleSingleVf(finished, resourceId);
+			if (!handleSingleVfResult.equals(StorageOperationStatus.OK)) {
+				log.debug("fixDerivedFv failed - handleSingleVfResult failed for resource {}, error: {}", resourceId, handleSingleVfResult);
+				return Either.right(StorageOperationStatus.GENERAL_ERROR);
+			}
+		}
+		return Either.left(finished);
+	}
+
+	// private StorageOperationStatus handleSingleVf(List<String> finished,
+	// Map<String, String> derivedMapping, String resourceId) {
+	private StorageOperationStatus handleSingleVf(List<String> finished, String resourceId) {
+		Either<TitanVertex, TitanOperationStatus> vertexByProperty = titanGenericDao
+				.getVertexByProperty(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), resourceId);
+		if (vertexByProperty.isRight()) {
+			log.debug("fixDerivedFv failed to fetch resource by id {}, error: {}", resourceId, vertexByProperty.right().value());
+			return StorageOperationStatus.GENERAL_ERROR;
+		}
+		Vertex vertexR = vertexByProperty.left().value();
+		Iterator<Vertex> vertexDIter = vertexR.vertices(Direction.OUT, GraphEdgeLabels.DERIVED_FROM.getProperty());
+		if (vertexDIter != null && vertexDIter.hasNext()) {
+			// move edges
+			// must be only one
+			TitanVertex vertexD = (TitanVertex) vertexDIter.next();
+			String idDerived = (String) titanGenericDao.getProperty(vertexD,
+					GraphPropertiesDictionary.UNIQUE_ID.getProperty());
+
+			// TODO clone resource
+
+			// TODO add instance of new resource to VF
+
+			// add to vf instance of vfc
+			finished.add(resourceId);
+		} else {
+			log.debug("No derived edges for resource  id {}", resourceId);
+		}
+		return StorageOperationStatus.OK;
+	}
+
+	private boolean updateComponentInstanceType() {
+		log.debug("update component instances type STARTED");
+		Either<List<ComponentInstanceData>, TitanOperationStatus> allInstances = titanGenericDao
+				.getByCriteria(NodeTypeEnum.ResourceInstance, null, ComponentInstanceData.class);
+		if (allInstances.isRight()) {
+			if (allInstances.right().value().equals(TitanOperationStatus.NOT_FOUND)) {
+				log.debug("updateComponentInstanceType:  no instances ti update ");
+				return true;
+			}
+			log.debug("updateComponentInstanceType failed fetch all resource instances ,error {}", allInstances.right().value());
+			return false;
+		}
+
+		List<ComponentInstanceData> listOfInstances = allInstances.left().value();
+		for (ComponentInstanceData instance : listOfInstances) {
+			String originId = instance.getComponentInstDataDefinition().getComponentUid();
+			Either<ComponentMetadataData, TitanOperationStatus> nodeResource = titanGenericDao.getNode(
+					UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), originId, ComponentMetadataData.class);
+			if (nodeResource.isRight()) {
+				log.debug("updateComponentInstanceType failed to fetch origin resource with id {}, error: {}", originId, nodeResource.right().value());
+				return false;
+			}
+			ResourceTypeEnum resourceType = ((ResourceMetadataDataDefinition) nodeResource.left().value()
+					.getMetadataDataDefinition()).getResourceType();
+			if (resourceType == null) {
+				log.debug("updateComponentInstanceType failed, no resource type for origin resource with id {}", originId);
+				return false;
+			}
+			OriginTypeEnum originType;
+			switch (resourceType) {
+			case VF:
+				originType = OriginTypeEnum.VF;
+				break;
+			case VFC:
+				originType = OriginTypeEnum.VFC;
+				break;
+			case VL:
+				originType = OriginTypeEnum.VL;
+				break;
+			case CP:
+				originType = OriginTypeEnum.CP;
+				break;
+			default:
+				log.debug("updateComponentInstanceType failed, no supported resource type {} for origin resource with id {}", resourceType, originId);
+				return false;
+			}
+			instance.getComponentInstDataDefinition().setOriginType(originType);
+
+			Either<ComponentInstanceData, TitanOperationStatus> updateNode = titanGenericDao.updateNode(instance,
+					ComponentInstanceData.class);
+			if (updateNode.isRight()) {
+				log.debug("updateComponentInstanceType failed, failed to update component instance node with id {}, error: {}", instance.getUniqueId(), updateNode.right().value());
+				return false;
+			}
+			log.debug("For instance with id {} the origin type was detected as {}", instance.getUniqueId(), originType);
+		}
+		log.debug("update component instances type ENDED");
+		return true;
+	}
+
+	private boolean addResourceCounterToResources() {
+
+		Either<List<ResourceMetadataData>, TitanOperationStatus> allResources = titanGenericDao
+				.getByCriteria(NodeTypeEnum.Resource, null, ResourceMetadataData.class);
+		if (allResources.isRight()) {
+			if (allResources.right().value().equals(TitanOperationStatus.NOT_FOUND)) {
+				log.debug("addResourceCounterToResources - no resources");
+				return true;
+			}
+			log.debug("addResourceCounterToResources failed fetch all resources,error {}", allResources.right().value());
+			return false;
+		}
+		for (ResourceMetadataData resource : allResources.left().value()) {
+			Either<TitanVertex, TitanOperationStatus> vertexByProperty = titanGenericDao.getVertexByProperty(
+					UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resource.getUniqueId());
+			if (vertexByProperty.isRight()) {
+				log.error("failed to add instanceCounter to VF {} . error is: {}", resource.getUniqueId(),
+						vertexByProperty.right().value().name());
+				return false;
+			}
+			Vertex vfVertex = vertexByProperty.left().value();
+			if (!vfVertex.property(GraphPropertiesDictionary.INSTANCE_COUNTER.getProperty()).isPresent()) {
+				vfVertex.property(GraphPropertiesDictionary.INSTANCE_COUNTER.getProperty(), 0);
+			}
+		}
+		return true;
+	}
+
+	private boolean fixDerivedVf() {
+
+		Map<String, Object> props = new HashMap<String, Object>();
+		props.put(GraphPropertiesDictionary.RESOURCE_TYPE.getProperty(), ResourceTypeEnum.VF.name());
+		Either<List<ResourceMetadataData>, TitanOperationStatus> allVF = titanGenericDao
+				.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
+		if (allVF.isRight()) {
+			if (allVF.right().value().equals(TitanOperationStatus.NOT_FOUND)) {
+				log.debug("fixDerivedVf - no VFs");
+				return true;
+			}
+			log.debug("fixDerivedFv failed fetch all VF resources,error {}", allVF.right().value());
+			return false;
+		}
+
+		Map<String, String> vfUuidToVfcUuid = new HashMap<String, String>();
+		for (ResourceMetadataData metadata : allVF.left().value()) {
+			Either<Resource, StorageOperationStatus> eitherResource = resourceOperation
+					.getResource(metadata.getMetadataDataDefinition().getUniqueId(), true);
+			if (eitherResource.isRight()) {
+				log.error("failed to migrate VF {} from version 1602 to version 1604. error is: {}",
+						metadata.getMetadataDataDefinition().getUniqueId(), eitherResource.right().value().name());
+				return false;
+			}
+			Resource vfResource = eitherResource.left().value();
+			if (vfResource.getDerivedFrom() == null || vfResource.getDerivedFrom().isEmpty()) {
+				continue;
+			}
+			Boolean isVfDeleted = vfResource.getIsDeleted();
+			String vfUUID = vfResource.getUUID();
+			String vfcUUID = vfUuidToVfcUuid.getOrDefault(vfUUID, null);
+			if (vfcUUID == null) {
+				vfcUUID = UUID.randomUUID().toString();
+				vfUuidToVfcUuid.put(vfUUID, vfcUUID);
+			}
+
+			// handle lifecycle
+			String vfUniqueId = vfResource.getUniqueId();
+			LifecycleStateEnum vfcTargetState = vfResource.getLifecycleState();
+			if (vfcTargetState.equals(LifecycleStateEnum.READY_FOR_CERTIFICATION)
+					|| vfcTargetState.equals(LifecycleStateEnum.CERTIFICATION_IN_PROGRESS)) {
+				User user = new User();
+				user.setUserId(vfResource.getLastUpdaterUserId());
+				Either<? extends Component, StorageOperationStatus> checkinComponent = lifecycleOperaion
+						.checkinComponent(NodeTypeEnum.Resource, vfResource, user, user, true);
+				if (checkinComponent.isRight()) {
+					log.error("failed to checkin VF {}. error={}", vfUniqueId, checkinComponent.right().value().name());
+					return false;
+				}
+			} else if (vfcTargetState.equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT)) {
+				vfcTargetState = LifecycleStateEnum.NOT_CERTIFIED_CHECKIN;
+			}
+
+			// delete VF Properties
+			List<PropertyDefinition> properties = vfResource.getProperties();
+			if (properties != null && !properties.isEmpty()) {
+				Either<Map<String, PropertyDefinition>, StorageOperationStatus> deleteAllProperties = propertyOperation
+						.deleteAllPropertiesAssociatedToNode(NodeTypeEnum.Resource, vfUniqueId);
+				if (deleteAllProperties.isRight()
+						&& !deleteAllProperties.right().value().equals(StorageOperationStatus.NOT_FOUND)
+						&& !deleteAllProperties.right().value().equals(StorageOperationStatus.OK)) {
+					log.error("failed to delete properties of VF {} . error is: {}",
+							metadata.getMetadataDataDefinition().getUniqueId(),
+							deleteAllProperties.right().value().name());
+					return false;
+				}
+			}
+			// delete VF Additional Info
+			List<AdditionalInformationDefinition> additionalInformation = vfResource.getAdditionalInformation();
+			if (additionalInformation != null && !additionalInformation.isEmpty()) {
+				Either<AdditionalInformationDefinition, StorageOperationStatus> deleteAllAdditionalInformationParameters = additionalInformationOperation
+						.deleteAllAdditionalInformationParameters(NodeTypeEnum.Resource, vfUniqueId, true);
+				if (deleteAllAdditionalInformationParameters.isRight()
+						&& !deleteAllAdditionalInformationParameters.right().value().equals(StorageOperationStatus.OK)
+						&& !deleteAllAdditionalInformationParameters.right().value()
+								.equals(StorageOperationStatus.NOT_FOUND)) {
+					log.error("failed to delete properties of VF {} . error is: {}",
+							metadata.getMetadataDataDefinition().getUniqueId(),
+							deleteAllAdditionalInformationParameters.right().value().name());
+					return false;
+				}
+			}
+			// delete VF derivedFrom
+			GraphRelation derivedFromRelation = new GraphRelation(GraphEdgeLabels.DERIVED_FROM.getProperty());
+			derivedFromRelation.setFrom(new RelationEndPoint(NodeTypeEnum.Resource,
+					UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), vfUniqueId));
+			Either<GraphRelation, TitanOperationStatus> deleteDerivedFromRelation = titanGenericDao
+					.deleteOutgoingRelation(derivedFromRelation);
+			if (deleteDerivedFromRelation.isRight()) {
+				log.error("failed to delete derivedFrom relation of VF {} . error is: {}",
+						metadata.getMetadataDataDefinition().getUniqueId(),
+						deleteDerivedFromRelation.right().value().name());
+				return false;
+			}
+
+			// create VFC
+			Either<Resource, StorageOperationStatus> createVFC = createVFC(metadata, vfResource, vfcUUID,
+					vfcTargetState);
+			if (createVFC.isRight()) {
+				log.error("failed to split VF {} to VFC. error is: {}",
+						metadata.getMetadataDataDefinition().getUniqueId(), createVFC.right().value().name());
+				return false;
+			}
+			Resource vfcResource = createVFC.left().value();
+			if (!createVfcInstanceOnVf(vfcResource, vfUniqueId)) {
+				return false;
+			}
+			// update VFC to deleted if required
+			if (isVfDeleted != null && isVfDeleted) {
+				Either<Component, StorageOperationStatus> markResourceToDelete = resourceOperation
+						.markComponentToDelete(vfcResource, true);
+				if (markResourceToDelete.isRight()) {
+					log.error("failed to mark isDeleted on VFC {} . error is: {}", vfcResource.getUniqueId(),
+							markResourceToDelete.right().value().name());
+					return false;
+				}
+			}
+
+		}
+		return true;
+	}
+
+	private Either<Resource, StorageOperationStatus> createVFC(ResourceMetadataData metadata, Resource vfcResource,
+			String uuid, LifecycleStateEnum vfcTargetState) {
+
+		Boolean highestVersion = vfcResource.isHighestVersion();
+		// Resource vfcResource = new Resource((ResourceMetadataDefinition)
+		// vfResource.getComponentMetadataDefinition());
+		// String componentName = vfcResource.getName()+"VFC";
+		// vfcResource.setName(componentName);
+		// vfcResource.setNormalizedName(ValidationUtils.normaliseComponentName(componentName));
+		// vfcResource.setSystemName(ValidationUtils.convertToSystemName(componentName));
+		vfcResource.setUniqueId(null);
+		vfcResource.setUUID(uuid);
+		vfcResource.setAllVersions(null);
+		vfcResource.setArtifacts(null);
+		vfcResource.setDeploymentArtifacts(null);
+		vfcResource.setComponentInstances(null);
+		vfcResource.setComponentInstancesProperties(null);
+		vfcResource.setComponentInstancesRelations(null);
+		vfcResource.setResourceType(ResourceTypeEnum.VFC);
+		vfcResource.setIsDeleted(false);
+
+		vfcResource.setLifecycleState(vfcTargetState);
+		// vfcResource.setDerivedFrom(vfResource.getDerivedFrom());
+		// vfcResource.setProperties(vfResource.getProperties());
+		// vfcResource.setAdditionalInformation(vfResource.getAdditionalInformation());
+		// vfcResource.setCategories(vfResource.getCategories());
+		// vfcResource.setTags(vfResource.getTags());
+
+		Either<Resource, StorageOperationStatus> createResource = resourceOperation.createResource(vfcResource, true);
+		if (createResource.isRight()) {
+			return createResource;
+		}
+		Resource afterCreateResource = createResource.left().value();
+		Either<TitanVertex, TitanOperationStatus> vertexByProperty = titanGenericDao.getVertexByProperty(
+				UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), afterCreateResource.getUniqueId());
+		if (vertexByProperty.isRight()) {
+			return createResource;
+		}
+		Vertex newVfcVertex = vertexByProperty.left().value();
+		newVfcVertex.property(GraphPropertiesDictionary.UUID.getProperty(), uuid);
+		if (!highestVersion) {
+			newVfcVertex.property(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), false);
+		}
+		return createResource;
+	}
+
+	private boolean createVfcInstanceOnVf(Resource vfcResource, String vfUniqueId) {
+		// create VFC instance on VF
+		ComponentInstance componentInstance = new ComponentInstance();
+		componentInstance.setComponentUid(vfcResource.getUniqueId());
+		componentInstance.setPosX("550");
+		componentInstance.setPosY("300");
+		componentInstance.setName(vfcResource.getName());
+		componentInstance.setIcon(vfcResource.getIcon());
+		componentInstance.setToscaComponentName(vfcResource.getToscaResourceName());
+		Either<String, Boolean> handleNameLogic = handleNameLogic(componentInstance, vfUniqueId, vfcResource.getName());
+		if (handleNameLogic.isRight()) {
+			log.error("failed to create logical name for vfc instance");
+			return false;
+		}
+		Either<ComponentInstance, StorageOperationStatus> createComponentInstance = componentInstanceOperaion
+				.createComponentInstance(vfUniqueId, NodeTypeEnum.Resource, handleNameLogic.left().value(),
+						componentInstance, NodeTypeEnum.Resource, true);
+
+		if (createComponentInstance.isRight()) {
+			log.error("failed to create vfc instance on vf {}. error: {}", vfUniqueId,
+					createComponentInstance.right().value().name());
+			return false;
+		}
+		return true;
+	}
+
+	private Either<String, Boolean> handleNameLogic(ComponentInstance componentInstance, String containerComponentId,
+			String resourceName) {
+
+		Either<Integer, StorageOperationStatus> componentInNumberStatus = resourceOperation
+				.increaseAndGetComponentInstanceCounter(containerComponentId, true);
+
+		if (componentInNumberStatus.isRight()) {
+			log.debug("Failed to get component instance number for container component {} ", containerComponentId);
+			return Either.right(false);
+		}
+		String resourceInNumber = componentInNumberStatus.left().value().toString();
+		componentInstance.setComponentName(resourceName);
+		componentInstance.setName(resourceName);
+		String logicalName = componentInstanceOperaion.createComponentInstLogicalName(resourceInNumber, resourceName);
+
+		Boolean eitherValidation = validateComponentInstanceName(logicalName, componentInstance, true);
+		if (!eitherValidation) {
+			return Either.right(false);
+		}
+
+		return Either.left(resourceInNumber);
+	}
+
+	private Boolean validateComponentInstanceName(String resourceInstanceName, ComponentInstance resourceInstance,
+			boolean isCreate) {
+
+		if (!ValidationUtils.validateStringNotEmpty(resourceInstanceName)) {
+			return false;
+		}
+		resourceInstance.setNormalizedName(ValidationUtils.normaliseComponentInstanceName(resourceInstanceName));
+		if (!isCreate) {
+			if (!ValidationUtils.validateResourceInstanceNameLength(resourceInstanceName)) {
+				return false;
+			}
+			if (!ValidationUtils.validateResourceInstanceName(resourceInstanceName)) {
+				return false;
+			}
+		}
+
+		return true;
+
+	}
+
+	public boolean migrate1604to1607(String appConfigDir) {
+		log.debug("Started the migration procedure from version 1604 to version 1607 ...");
+		log.debug("Getting all resources with resources");
+		boolean result = false;
+		Either<Boolean, StorageOperationStatus> resourceEither = null;
+		try {
+			Either<List<ResourceMetadataData>, TitanOperationStatus> allResources = titanGenericDao
+					.getByCriteria(NodeTypeEnum.Resource, null, ResourceMetadataData.class);
+			if (allResources.isRight()) {
+				log.error("Couldn't get resources from DB, error: {}", allResources.right().value());
+				result = false;
+				return result;
+			}
+			List<ResourceMetadataData> resourcesList = allResources.left().value();
+			if (resourcesList == null) {
+				log.error("Couldn't get resources from DB, no resources found");
+				result = false;
+				return result;
+			}
+			log.debug("Found {} resources", resourcesList.size());
+			for (ResourceMetadataData resource : resourcesList) {
+				String resourceName = resource.getMetadataDataDefinition().getName();
+				log.debug("Checking resource {}", resourceName);
+				if (isNormative(resourceName)) {
+					resourceEither = changeNormativeTypeName(resource);
+					if (resourceEither.isRight()) {
+						log.error("DB error during name changing");
+						result = false;
+						return result;
+					}
+				}
+				if (((ResourceMetadataDataDefinition) resource.getMetadataDataDefinition()).getResourceType().name()
+						.equals("VF")) {
+					resourceEither = setVfToscaResourceName(resource);
+					if (resourceEither.isRight()) {
+						log.error("DB error during tosca resource name setting");
+						result = false;
+						return result;
+					}
+				}
+			}
+			result = addInvariantUUIDs(appConfigDir);
+		} finally {
+			if (!result) {
+				titanGenericDao.rollback();
+				log.debug("**********************************************");
+				log.debug("The migration procedure from version 1604 to version 1607 FAILED!!");
+				log.debug("**********************************************");
+			} else {
+				titanGenericDao.commit();
+				log.debug("**********************************************");
+				log.debug("The migration procedure from version 1604 to version 1607 ended successfully!");
+				log.debug("**********************************************");
+			}
+		}
+
+		return result;
+	}
+
+	private boolean addInvariantUUIDs(String appConfigDir) {
+		log.debug("Started adding of InvariantUUID ...");
+		log.debug("Getting all resources with highest version");
+
+		Map<String, Object> props = new HashMap<>();
+		props.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true);
+
+		List<ComponentMetadataData> fullComponentList = new ArrayList<ComponentMetadataData>();
+
+		// getting resources
+		Either<List<ResourceMetadataData>, TitanOperationStatus> allHighestVersionResources = titanGenericDao
+				.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
+		if (allHighestVersionResources.isRight()) {
+			log.error("Couldn't get resources with highest version from DB, error: {}",
+					allHighestVersionResources.right().value());
+			return false;
+		}
+		List<ResourceMetadataData> allHighestVersionResourcesAL = allHighestVersionResources.left().value();
+		if (allHighestVersionResourcesAL == null) {
+			log.error("Couldn't get resources with highest version from DB, no resources found");
+			return false;
+		}
+		log.debug("Found {} resources", allHighestVersionResourcesAL.size());
+		fullComponentList.addAll(allHighestVersionResourcesAL);
+
+		// getting services
+		Either<List<ServiceMetadataData>, TitanOperationStatus> allHighestVersionServices = titanGenericDao
+				.getByCriteria(NodeTypeEnum.Service, props, ServiceMetadataData.class);
+		if (allHighestVersionServices.isRight()) {
+			log.error("Couldn't get services with highest version from DB, error: {}",
+					allHighestVersionServices.right().value());
+			return false;
+		}
+		List<ServiceMetadataData> allHighestVersionServicesAL = allHighestVersionServices.left().value();
+		if (allHighestVersionServicesAL == null) {
+			log.error("Couldn't get services with highest version from DB, no services found");
+			return false;
+		}
+		log.debug("Found {} services", allHighestVersionServicesAL.size());
+		fullComponentList.addAll(allHighestVersionServicesAL);
+
+		List<ComponentMetadataData> reducedComponentsAL = reduceHighestVersionResourcesList(fullComponentList);
+
+		// getting products
+		Either<List<ProductMetadataData>, TitanOperationStatus> allHighestVersionProducts = titanGenericDao
+				.getByCriteria(NodeTypeEnum.Product, props, ProductMetadataData.class);
+		if (allHighestVersionProducts.isRight()) {
+			log.error("Couldn't get products with highest version from DB, error: {}",
+					allHighestVersionProducts.right().value());
+			return false;
+		}
+		List<ProductMetadataData> allHighestVersionProductsAL = allHighestVersionProducts.left().value();
+		if (allHighestVersionProductsAL == null) {
+			log.error("Couldn't get products with highest version from DB, no products found");
+			return false;
+		}
+		log.debug("Found {} products", allHighestVersionProductsAL.size());
+
+		List<ComponentMetadataData> fullProductList = new ArrayList<ComponentMetadataData>();
+		fullProductList.addAll(allHighestVersionProductsAL);
+		List<ComponentMetadataData> reducedProductAL = reduceHighestVersionResourcesList(fullProductList);
+
+		for (ComponentMetadataData product : reducedProductAL) {
+			if (!setProductInvariantUUIDIfExists((ProductMetadataData) product)) {
+				return false;
+			}
+		}
+		reducedComponentsAL.addAll(reducedProductAL);
+
+		log.debug("Reduced list of Highest Version Components contains {} components", reducedComponentsAL.size());
+		for (ComponentMetadataData componentMetaData : reducedComponentsAL) {
+
+			String invariantUUID = componentMetaData.getMetadataDataDefinition().getInvariantUUID();
+			log.debug("old invariantUUID {}", invariantUUID);
+			if (invariantUUID == null || invariantUUID.isEmpty()) {
+				invariantUUID = UniqueIdBuilder.buildInvariantUUID();
+				componentMetaData.getMetadataDataDefinition().setInvariantUUID(invariantUUID);
+			}
+			log.debug("new invariantUUID {}", componentMetaData.getMetadataDataDefinition().getInvariantUUID());
+			Either<ComponentMetadataData, TitanOperationStatus> updateNode = titanGenericDao
+					.updateNode(componentMetaData, ComponentMetadataData.class);
+			if (updateNode.isRight()) {
+				log.error("DB error during while updating component {}, error: {}",
+						componentMetaData.getMetadataDataDefinition().getName(), updateNode.right().value());
+				return false;
+			}
+			log.debug("updated invariantUUID {}",
+					updateNode.left().value().getMetadataDataDefinition().getInvariantUUID());
+			if (!isOnlyVersion(componentMetaData)) {
+				ComponentOperation componentOperation = null;
+				switch (NodeTypeEnum.getByName(componentMetaData.getLabel())) {
+				case Resource:
+					componentOperation = resourceOperation;
+					break;
+				case Service:
+					componentOperation = serviceOperation;
+					break;
+				case Product:
+					componentOperation = productOperation;
+					break;
+				default:
+					break;
+				}
+				Either<Component, StorageOperationStatus> getComponentResult = componentOperation
+						.getComponent((String) componentMetaData.getUniqueId(), true);
+				if (getComponentResult.isRight()) {
+					log.error("DB error during while getting component with uniqueID {}, error: {}",
+							componentMetaData.getUniqueId(), getComponentResult.right().value());
+					return false;
+				}
+				Component component = getComponentResult.left().value();
+				if (component == null) {
+					log.error("The component received from DB is empty");
+					return false;
+				}
+
+				Map<String, String> allVersions = component.getAllVersions();
+				log.debug("found {} versions for component {}", allVersions.size(), component.getName());
+				Either<Boolean, StorageOperationStatus> resEither = updateAllVersions(allVersions, invariantUUID);
+				if (resEither.isRight()) {
+					log.error("DB error during invariantUUID adding");
+					return false;
+				}
+			}
+		}
+		return true;
+	}
+
+	private boolean isOnlyVersion(ComponentMetadataData componentMetaData) {
+		String version = componentMetaData.getMetadataDataDefinition().getVersion();
+		if (version.equals("0.1"))
+			return true;
+		return false;
+	}
+
+	private boolean setProductInvariantUUIDIfExists(ProductMetadataData product) {
+		Either<TitanVertex, TitanOperationStatus> getVertexRes = titanGenericDao
+				.getVertexByProperty(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), product.getUniqueId());
+		if (getVertexRes.isRight()) {
+			log.error("DB error during retrieving product vertex {}", product.getMetadataDataDefinition().getName());
+			return false;
+		}
+		Vertex productVertex = getVertexRes.left().value();
+		String invariantUUID = productVertex.value(GraphPropertiesDictionary.CONSTANT_UUID.getProperty());
+		if (invariantUUID != null && !invariantUUID.isEmpty()) {
+			product.getMetadataDataDefinition().setInvariantUUID(invariantUUID);
+		}
+		return true;
+	}
+
+	private Either<Boolean, StorageOperationStatus> updateAllVersions(Map<String, String> allVersions,
+			String invariantUUID) {
+
+		if (allVersions != null) {
+			for (String uniqueID : allVersions.values()) {
+				Either<ComponentMetadataData, TitanOperationStatus> getNodeResult = titanGenericDao.getNode(
+						GraphPropertiesDictionary.UNIQUE_ID.getProperty(), uniqueID, ComponentMetadataData.class);
+				if (getNodeResult.isRight()) {
+					log.error("DB error during while getting component with uniqueID {}, error: {}", uniqueID,
+							getNodeResult.right().value());
+					return Either.right(StorageOperationStatus.GENERAL_ERROR);
+				}
+				ComponentMetadataData component = getNodeResult.left().value();
+				component.getMetadataDataDefinition().setInvariantUUID(invariantUUID);
+				Either<ComponentMetadataData, TitanOperationStatus> updateNodeResult = titanGenericDao
+						.updateNode(component, ComponentMetadataData.class);
+				log.debug("updated child invariantUUID {}",
+						updateNodeResult.left().value().getMetadataDataDefinition().getInvariantUUID());
+				if (updateNodeResult.isRight()) {
+					log.error("DB error during while updating component {}, error: {}",
+							component.getMetadataDataDefinition().getName(), updateNodeResult.right().value());
+					return Either.right(StorageOperationStatus.GENERAL_ERROR);
+				}
+			}
+		}
+		return Either.left(true);
+	}
+
+	private List<ComponentMetadataData> reduceHighestVersionResourcesList(
+			List<ComponentMetadataData> allHighestVersionResources) {
+		List<ComponentMetadataData> resultList = null;
+		Map<String, ComponentMetadataData> resultHM = new HashMap<String, ComponentMetadataData>();
+		for (ComponentMetadataData resource : allHighestVersionResources) {
+			if (resource.getMetadataDataDefinition().getInvariantUUID() != null
+					&& !resource.getMetadataDataDefinition().getInvariantUUID().isEmpty()) {
+				log.debug("invariantUUID {} ", resource.getMetadataDataDefinition().getInvariantUUID());
+				continue;
+			}
+			String curUUID = resource.getMetadataDataDefinition().getUUID();
+			if (resultHM.containsKey(curUUID)) {
+				int isHighest = resultHM.get(curUUID).getMetadataDataDefinition().getVersion()
+						.compareTo(resource.getMetadataDataDefinition().getVersion());
+				if (isHighest > 0) {
+					log.debug("version {} is great than {} ",
+							resultHM.get(curUUID).getMetadataDataDefinition().getVersion(),
+							resource.getMetadataDataDefinition().getVersion());
+					continue;
+				}
+			}
+			resultHM.put(curUUID, resource);
+		}
+		resultList = new ArrayList<ComponentMetadataData>(resultHM.values());
+		return resultList;
+	}
+
+	private boolean isNormative(String resourceName) {
+		for (int i = 0; i < NORMATIVE_OLD_NAMES.length; ++i) {
+			if (NORMATIVE_OLD_NAMES[i].equals(resourceName))
+				return true;
+		}
+		return false;
+	}
+
+	private Either<Boolean, StorageOperationStatus> changeNormativeTypeName(ResourceMetadataData resource) {
+
+		String resourceName = resource.getMetadataDataDefinition().getName();
+
+		if (resourceName != null && !resourceName.isEmpty()) {
+			log.debug("Found normative type to change - {}", resourceName);
+			String oldName = resourceName;
+			String[] splitedName = resourceName.split("\\.");
+			String newName = splitedName[splitedName.length - 1];
+			String newSystemName = ValidationUtils.convertToSystemName(newName);
+			String newNormalizedName = ValidationUtils.normaliseComponentName(newName);
+			log.debug("Setting name to be {}", newName);
+
+			resource.getMetadataDataDefinition().setName(newName);
+			log.debug("Setting system name to be {}", newSystemName);
+			resource.getMetadataDataDefinition().setSystemName(newSystemName);
+			log.debug("Setting normalized name to be {}", newNormalizedName);
+			resource.getMetadataDataDefinition().setNormalizedName(newNormalizedName);
+			log.debug("Updating tag in metadata to be {}", newName);
+			resource.getMetadataDataDefinition().getTags().remove(oldName);
+			resource.getMetadataDataDefinition().getTags().add(newName);
+
+			log.debug("Creating tag node with name {}", newName);
+			TagData tagData = new TagData();
+			tagData.setName(newName);
+			Either<TagData, TitanOperationStatus> createNode = titanGenericDao.createNode(tagData, TagData.class);
+			if (createNode.isRight()) {
+				log.error("Error while creating tag node {}, error: {}.", newName, createNode.right().value());
+				return Either.right(StorageOperationStatus.GENERAL_ERROR);
+			}
+			
+			Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanGenericDao.updateNode(resource,
+					ResourceMetadataData.class);
+			if (updateNode.isRight()) {
+				log.error("DB error during while updating normative type {}, error: {}",
+						resource.getMetadataDataDefinition().getName(), updateNode.right().value());
+				return Either.right(StorageOperationStatus.GENERAL_ERROR);
+			}
+			log.debug("Normative type {} was successfully updated", resource.getMetadataDataDefinition().getName());
+			return Either.left(true);
+		}
+
+		return Either.left(false);
+	}
+
+	private Either<Boolean, StorageOperationStatus> generateAndSetToscaResourceName(ResourceMetadataData resource,
+			String toscaResourceName) {
+		if (toscaResourceName == null) {
+			toscaResourceName = CommonBeUtils.generateToscaResourceName(
+					((ResourceMetadataDataDefinition) resource.getMetadataDataDefinition()).getResourceType().name(),
+					resource.getMetadataDataDefinition().getSystemName());
+		}
+		Either<Boolean, StorageOperationStatus> validateToscaResourceNameExists = resourceOperation
+				.validateToscaResourceNameExists(toscaResourceName);
+		if (validateToscaResourceNameExists.isRight()) {
+			StorageOperationStatus storageOperationStatus = validateToscaResourceNameExists.right().value();
+			log.error("Couldn't validate toscaResourceName uniqueness - error: {}", storageOperationStatus);
+			return Either.right(storageOperationStatus);
+		}
+		if (validateToscaResourceNameExists.left().value()) {
+			log.debug("Setting tosca resource name to be {}", toscaResourceName);
+			((ResourceMetadataDataDefinition) resource.getMetadataDataDefinition())
+					.setToscaResourceName(toscaResourceName);
+			return Either.left(true);
+		} else {
+			// As agreed with Renana - cannot be fixed automatically
+			log.warn("toscaResourceName {} is not unique! Cannot set it. Continuing...");
+			return Either.left(false);
+		}
+	}
+
+	public boolean testRemoveHeatPlaceHolders(String appConfigDir) {
+
+		if (!AllowMultipleHeats.removeAndUpdateHeatPlaceHolders(titanGenericDao, log, false)) {
+			log.error("Failed to update heat place holders");
+			return false;
+		}
+		return true;
+	}
+
+	private Either<Boolean, StorageOperationStatus> setVfToscaResourceName(ResourceMetadataData resource) {
+		String resourceName = resource.getMetadataDataDefinition().getName();
+		String resourceType = ((ResourceMetadataDataDefinition) resource.getMetadataDataDefinition()).getResourceType()
+				.name();
+		String toscaResourceName = CommonBeUtils.generateToscaResourceName(resourceType,
+				resource.getMetadataDataDefinition().getSystemName());
+		log.debug("Setting tosca resource name {} to VF {}", toscaResourceName, resourceName);
+		((ResourceMetadataDataDefinition) resource.getMetadataDataDefinition()).setToscaResourceName(toscaResourceName);
+
+		Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanGenericDao.updateNode(resource,
+				ResourceMetadataData.class);
+		if (updateNode.isRight()) {
+			log.error("DB error during while updating VF tosca resource name {}, error: {}",
+					resource.getMetadataDataDefinition().getName(), updateNode.right().value());
+			return Either.right(StorageOperationStatus.GENERAL_ERROR);
+		}
+		log.debug("Tosca resource name of VF {} was successfully updated",
+				resource.getMetadataDataDefinition().getName());
+		return Either.left(true);
+	}
+
+	public boolean testAddGroupUuids(String appConfigDir) {
+
+		if (!AddGroupUuid.addGroupUuids(titanGenericDao, log, false)) {
+			log.error("Failed to update group UUIDs");
+			return false;
+		}
+		return true;
+	}
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/VfcNamingAlignment.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/VfcNamingAlignment.java
new file mode 100644
index 0000000000..27b9351ebc
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1604/VfcNamingAlignment.java
@@ -0,0 +1,185 @@
+/*-
+ * ============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.asdctool.impl.migration.v1604;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
+import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
+import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.ResourceOperation;
+import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
+import org.openecomp.sdc.be.resources.data.TagData;
+import org.openecomp.sdc.be.utils.CommonBeUtils;
+import org.openecomp.sdc.common.api.Constants;
+import org.openecomp.sdc.common.util.ValidationUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import fj.data.Either;
+
+public class VfcNamingAlignment {
+
+	private static Logger log = LoggerFactory.getLogger(VfcNamingAlignment.class.getName());
+
+	@Autowired
+	protected TitanGenericDao titanGenericDao;
+	@Autowired
+	protected ResourceOperation resourceOperation;
+
+	public boolean alignVfcNames1604(String appConfigDir) {
+		log.debug("Started alignVfcNames1604 procedure..");
+		log.debug("Getting all resources with resourceType = VFC/CP/VL");
+		boolean result = false;
+		try {
+			Map<String, Object> notProperties = new HashMap<>();
+			notProperties.put(GraphPropertiesDictionary.RESOURCE_TYPE.getProperty(), ResourceTypeEnum.VF.name());
+			Either<List<ResourceMetadataData>, TitanOperationStatus> allVfcResources = titanGenericDao
+					.getByCriteria(NodeTypeEnum.Resource, null, notProperties, ResourceMetadataData.class);
+			if (allVfcResources.isRight()) {
+				log.error("Couldn't get VFC resources from DB, error: {}", allVfcResources.right().value());
+				result = false;
+				return result;
+			}
+			List<ResourceMetadataData> vfcList = allVfcResources.left().value();
+			if (vfcList == null) {
+				log.error("Couldn't get VFC/CP/VL resources from DB, no resources found");
+				result = false;
+				return result;
+			}
+			log.debug("Found {} VFC/CP/VL resources", vfcList.size());
+			for (ResourceMetadataData vfc : vfcList) {
+				log.debug("Checking resource {}", vfc.getMetadataDataDefinition().getName());
+				boolean wasChanged = false;
+
+				Either<Boolean, StorageOperationStatus> vfcEither = fixToscaNameEmpty(vfc);
+				if (vfcEither.isRight()) {
+					log.error("DB error during checkIsToscaNameEmpty - exiting...");
+					result = false;
+					return result;
+				}
+				wasChanged = wasChanged | vfcEither.left().value();
+
+				vfcEither = fixVfcToscaNameHasVf(vfc);
+				if (vfcEither.isRight()) {
+					log.error("DB error during checkIsVfcToscaNameHasVf - exiting...");
+					result = false;
+					return result;
+				}
+				wasChanged = wasChanged | vfcEither.left().value();
+
+				if (wasChanged) {
+					Either<ResourceMetadataData, TitanOperationStatus> updateVfc = updateVfc(vfc);
+					if (updateVfc.isRight()) {
+						log.error("DB error during while updating resource {}, error: {} - exiting...",
+								vfc.getMetadataDataDefinition().getName(), updateVfc.right().value());
+						result = false;
+						return result;
+					}
+					log.debug("Resource {} was successfully updated", vfc.getMetadataDataDefinition().getName());
+				}
+
+			}
+			result = true;
+		} finally {
+			if (!result) {
+				titanGenericDao.rollback();
+				log.debug("**********************************************");
+				log.debug("alignVfcNames1604 procedure FAILED!!");
+				log.debug("**********************************************");
+			} else {
+				titanGenericDao.commit();
+				log.debug("**********************************************");
+				log.debug("alignVfcNames1604 procedure ended successfully!");
+				log.debug("**********************************************");
+			}
+		}
+
+		return result;
+	}
+
+	private Either<ResourceMetadataData, TitanOperationStatus> updateVfc(ResourceMetadataData vfc) {
+		return titanGenericDao.updateNode(vfc, ResourceMetadataData.class);
+	}
+
+	private Either<Boolean, StorageOperationStatus> fixToscaNameEmpty(ResourceMetadataData vfc) {
+		String toscaResourceName = ((ResourceMetadataDataDefinition) vfc.getMetadataDataDefinition())
+				.getToscaResourceName();
+		if (toscaResourceName == null || toscaResourceName.trim().equals(Constants.EMPTY_STRING)) {
+			log.debug("Tosca resource name is empty - setting new tosca name...");
+			Either<Boolean, StorageOperationStatus> generateAndSetToscaResourceName = generateAndSetToscaResourceName(
+					vfc, null);
+			if (generateAndSetToscaResourceName.isRight()) {
+				return Either.right(generateAndSetToscaResourceName.right().value());
+			}
+			return Either.left(true);
+		}
+		return Either.left(false);
+	}
+
+	private Either<Boolean, StorageOperationStatus> fixVfcToscaNameHasVf(ResourceMetadataData vfc) {
+		String toscaResourceName = ((ResourceMetadataDataDefinition) vfc.getMetadataDataDefinition())
+				.getToscaResourceName();
+		if (toscaResourceName.contains(".vf.")) {
+			log.debug("Tosca resource name {} is VF-style - setting new tosca name...", toscaResourceName);
+			Either<Boolean, StorageOperationStatus> generateAndSetToscaResourceName = generateAndSetToscaResourceName(
+					vfc, null);
+			if (generateAndSetToscaResourceName.isRight()) {
+				return Either.right(generateAndSetToscaResourceName.right().value());
+			}
+			return Either.left(true);
+		}
+		return Either.left(false);
+	}
+
+
+	private Either<Boolean, StorageOperationStatus> generateAndSetToscaResourceName(ResourceMetadataData vfc,
+			String toscaResourceName) {
+		if (toscaResourceName == null) {
+			toscaResourceName = CommonBeUtils.generateToscaResourceName(
+					((ResourceMetadataDataDefinition) vfc.getMetadataDataDefinition()).getResourceType().name(),
+					vfc.getMetadataDataDefinition().getSystemName());
+		}
+		Either<Boolean, StorageOperationStatus> validateToscaResourceNameExists = resourceOperation
+				.validateToscaResourceNameExists(toscaResourceName);
+		if (validateToscaResourceNameExists.isRight()) {
+			StorageOperationStatus storageOperationStatus = validateToscaResourceNameExists.right().value();
+			log.error("Couldn't validate toscaResourceName uniqueness - error: {}", storageOperationStatus);
+			return Either.right(storageOperationStatus);
+		}
+		if (validateToscaResourceNameExists.left().value()) {
+			log.debug("Setting tosca resource name to be {}", toscaResourceName);
+			((ResourceMetadataDataDefinition) vfc.getMetadataDataDefinition()).setToscaResourceName(toscaResourceName);
+			return Either.left(true);
+		} else {
+			// As agreed with Renana - cannot be fixed automatically
+			log.warn("toscaResourceName {} is not unique! Cannot set it. Continuing...");
+			return Either.left(false);
+		}
+	}
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1607/CsarMigration.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1607/CsarMigration.java
new file mode 100644
index 0000000000..b141eecb87
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1607/CsarMigration.java
@@ -0,0 +1,93 @@
+/*-
+ * ============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.asdctool.impl.migration.v1607;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.structure.VertexProperty;
+import org.apache.tinkerpop.gremlin.structure.util.ElementHelper;
+import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
+import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
+import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
+import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import com.thinkaurelius.titan.core.TitanVertex;
+
+import fj.data.Either;
+
+public class CsarMigration {
+	private static Logger log = LoggerFactory.getLogger(CsarMigration.class.getName());
+
+	@Autowired
+	protected TitanGenericDao titanGenericDao;
+
+	public boolean removeCsarResources() {
+		Map<String, Object> props = new HashMap<>();
+		props.put(GraphPropertiesDictionary.RESOURCE_TYPE.getProperty(), ResourceTypeEnum.VF.name());
+
+		Either<List<ResourceMetadataData>, TitanOperationStatus> byCriteria = titanGenericDao
+				.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
+		if (byCriteria.isRight()) {
+			log.debug("Failed to fetch VF resources by criteria ", byCriteria.right().value());
+			return false;
+		}
+		List<ResourceMetadataData> resources = byCriteria.left().value();
+
+		try {
+			for (ResourceMetadataData data : resources) {
+				if (data.getMetadataDataDefinition().getCsarUUID() != null) {
+					log.debug("VF {} with CSAR {}", data.getUniqueId(), data.getMetadataDataDefinition().getCsarUUID());
+					Either<TitanVertex, TitanOperationStatus> vertexByProperty = titanGenericDao
+							.getVertexByProperty(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), data.getUniqueId());
+					if (vertexByProperty.isRight()) {
+						log.debug("Failed to fetch vertex with id {} . skip resource {} ", data.getUniqueId(),
+								data.getMetadataDataDefinition().getName());
+						continue;
+					}
+					Vertex vertex = vertexByProperty.left().value();
+					Iterator<VertexProperty<Object>> properties = vertex
+							.properties(GraphPropertiesDictionary.CSAR_UUID.getProperty());
+					while (properties.hasNext()) {
+						VertexProperty<Object> next = properties.next();
+						next.remove();
+					}
+
+				}
+			}
+			titanGenericDao.commit();
+		} catch (Exception e) {
+			log.debug("Failed to clean CSAR UUID. rollback");
+			titanGenericDao.rollback();
+		}
+
+		return true;
+	}
+
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1610/TitanFixUtils.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1610/TitanFixUtils.java
new file mode 100644
index 0000000000..36ac98e578
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1610/TitanFixUtils.java
@@ -0,0 +1,387 @@
+/*-
+ * ============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.asdctool.impl.migration.v1610;
+
+import com.google.gson.Gson;
+import com.thinkaurelius.titan.core.TitanGraph;
+import com.thinkaurelius.titan.core.TitanVertex;
+import fj.data.Either;
+
+import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
+import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
+import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.model.operations.impl.CacheMangerOperation;
+import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import java.util.*;
+
+/**
+ * Created by mlando on 8/17/2016.
+ */
+public class TitanFixUtils {
+	private static Logger log = LoggerFactory.getLogger(TitanFixUtils.class.getName());
+
+	@Autowired
+	protected TitanGenericDao titanGenericDao;
+	@Autowired
+	protected CacheMangerOperation cacheMangerOperation;
+
+	public boolean fixIconsInNormatives() {
+		log.info("starting fix");
+		String vlName = "VL";
+		String elineName = "VL_ELINE";
+		String elineFixedName = "VL ELINE";
+		Either<TitanGraph, TitanOperationStatus> graphResult = titanGenericDao.getGraph();
+		if (graphResult.isRight()) {
+			log.error("failed to get graph object.");
+			return false;
+		}
+
+		boolean operationFailed = false;
+		Map<String, Object> vlVerticeProperties = null;
+		Map<String, Object> elineVerticeProperties = null;
+
+		try {
+			TitanGraph titanGraph = graphResult.left().value();
+			log.info("look up vl :{}", vlName);
+
+			Iterable<TitanVertex> vertices = titanGraph.query()
+					.has(GraphPropertiesDictionary.LABEL.getProperty(), NodeTypeEnum.Resource.getName())
+					.has(GraphPropertiesDictionary.NAME.getProperty(), vlName)
+					.has(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true).vertices();
+
+			if (vertices == null) {
+				log.error("failed to get  vernice for resource name {}", vlName);
+				operationFailed = true;
+				return false;
+			}
+
+			Iterator<TitanVertex> iterator = vertices.iterator();
+			List<TitanVertex> vertexList = new ArrayList<>();
+
+			if (iterator == null) {
+				log.error("failed to get iterator over vertices object returned for resource id {}", vlName);
+				operationFailed = true;
+				return false;
+			}
+
+			while (iterator.hasNext()) {
+				TitanVertex vertex = iterator.next();
+				vertexList.add(vertex);
+			}
+
+			if (!(vertexList.size() == 1)) {
+				log.error("failed to get 1 vertex for resource {} with highest true. instead got {}", vlName,
+						vertexList.size());
+				operationFailed = true;
+				return false;
+			}
+
+			TitanVertex vlVertex = vertexList.get(0);
+
+			log.info("look up eline:{}", elineName);
+
+			boolean vl_eline_found = true;
+
+			vertices = titanGraph.query()
+					.has(GraphPropertiesDictionary.LABEL.getProperty(), NodeTypeEnum.Resource.getName())
+					.has(GraphPropertiesDictionary.NAME.getProperty(), elineName)
+					.has(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true).vertices();
+
+			if (vertices == null) {
+				log.error("failed to get  vertices object returned for resource {}", elineName);
+				operationFailed = true;
+
+				vl_eline_found = false;
+			}
+
+			if (vl_eline_found) {
+				iterator = vertices.iterator();
+				vertexList = new ArrayList<>();
+				if (iterator == null) {
+					log.error("failed to get iterator over vertices object returned for resource id {}", elineName);
+					operationFailed = true;
+
+					vl_eline_found = false;
+				}
+
+				if (vl_eline_found) {
+					while (iterator.hasNext()) {
+						TitanVertex vertex = iterator.next();
+						vertexList.add(vertex);
+					}
+
+					if (!(vertexList.size() == 1)) {
+						log.error("failed to get 1 vertex for resource  {} with highest true. instead got {}",
+								elineName, vertexList.size());
+						operationFailed = true;
+
+						vl_eline_found = false;
+					}
+				}
+			}
+
+			if (!vl_eline_found) {
+				log.info("look up eline:{}", elineFixedName);
+				vl_eline_found = true;
+				operationFailed = false;
+
+				vertices = titanGraph.query()
+						.has(GraphPropertiesDictionary.LABEL.getProperty(), NodeTypeEnum.Resource.getName())
+						.has(GraphPropertiesDictionary.NAME.getProperty(), elineFixedName)
+						.has(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true).vertices();
+
+				if (vertices == null) {
+					log.error("failed to get  vertices object returned for resource {}", elineFixedName);
+					operationFailed = true;
+
+					vl_eline_found = false;
+				}
+
+				if (vl_eline_found) {
+					iterator = vertices.iterator();
+					vertexList = new ArrayList<>();
+					if (iterator == null) {
+						log.error("failed to get iterator over vertices object returned for resource id {}",
+								elineFixedName);
+						operationFailed = true;
+
+						vl_eline_found = false;
+					}
+
+					if (vl_eline_found) {
+						while (iterator.hasNext()) {
+							TitanVertex vertex = iterator.next();
+							vertexList.add(vertex);
+						}
+
+						if (!(vertexList.size() == 1)) {
+							log.error("failed to get 1 vertex for resource  {} with highest true. instead got {}",
+									elineFixedName, vertexList.size());
+							operationFailed = true;
+
+							vl_eline_found = false;
+						}
+					}
+				}
+			}
+
+			if (!vl_eline_found) {
+				return false;
+			} else {
+				TitanVertex elineVertex = vertexList.get(0);
+
+				vlVerticeProperties = titanGenericDao.getProperties(vlVertex);
+
+				log.info("VL Vertice  Properties {}", vlVerticeProperties);
+				if ("network".equals(vlVerticeProperties.get(GraphPropertiesDictionary.ICON.getProperty()))) {
+					log.info("nothing to update in vl");
+				} else {
+					log.info("updating property icon of vl");
+					vlVertex.property(GraphPropertiesDictionary.ICON.getProperty(), "network");
+				}
+
+				elineVerticeProperties = titanGenericDao.getProperties(elineVertex);
+
+				log.info("eline vertice  Properties {}", elineVerticeProperties);
+				if ("network".equals(elineVerticeProperties.get(GraphPropertiesDictionary.ICON.getProperty()))) {
+					log.info("nothing to update in eline");
+				} else {
+					log.info("updating property icon of eline");
+					elineVertex.property(GraphPropertiesDictionary.ICON.getProperty(), "network");
+				}
+
+				if ("VL ELINE".equals(elineVerticeProperties.get(GraphPropertiesDictionary.NAME.getProperty()))) {
+					log.info("nothing to update in eline");
+				} else {
+					log.info("updating property name and tag of eline");
+					elineVertex.property(GraphPropertiesDictionary.NAME.getProperty(), elineFixedName);
+					List<String> tags = new ArrayList<>();
+					tags.add("VL ELINE");
+					elineVertex.property(GraphPropertiesDictionary.TAGS.getProperty(), new Gson().toJson(tags));
+				}
+
+				log.info("print current properties state");
+
+				vlVerticeProperties = titanGenericDao.getProperties(vlVertex);
+
+				log.info("vertice vl Properties {}", vlVerticeProperties);
+				elineVerticeProperties = titanGenericDao.getProperties(elineVertex);
+
+				log.info("vertice eline Properties {}", elineVerticeProperties);
+			}
+
+			try {
+				Thread.sleep(30 * 1000);
+			} catch (InterruptedException e) {
+				log.error("exception", e);
+			}
+			return true;
+		} finally {
+			if (operationFailed) {
+				titanGenericDao.rollback();
+			} else {
+				titanGenericDao.commit();
+				long time = System.currentTimeMillis();
+				if (vlVerticeProperties != null) {
+					cacheMangerOperation.updateComponentInCache(
+							(String) vlVerticeProperties.get(GraphPropertiesDictionary.UNIQUE_ID.getProperty()), time,
+							NodeTypeEnum.Resource);
+				}
+				if (elineVerticeProperties != null) {
+					cacheMangerOperation.updateComponentInCache(
+							(String) elineVerticeProperties.get(GraphPropertiesDictionary.UNIQUE_ID.getProperty()),
+							time, NodeTypeEnum.Resource);
+				}
+			}
+		}
+	}
+
+	/**
+	 * in 1610 we encounter an issue that if a capability property overrides a
+	 * property of a derived capability then it was created with out a property
+	 * type when it was first imported as part of the capability types. this
+	 * will add property type to the properties missing it.
+	 */
+	public boolean fixCapabiltyPropertyTypes() {
+
+		String propertyIdSecure = "tosca.capabilities.Endpoint.Admin.secure";
+		String propertyIdNetworkName = "tosca.capabilities.Endpoint.Public.network_name";
+		Either<TitanGraph, TitanOperationStatus> graphResult = titanGenericDao.getGraph();
+
+		if (graphResult.isRight()) {
+			log.error("failed to get graph object.");
+			return false;
+		}
+
+		boolean operationFailed = false;
+		try {
+			TitanGraph titanGraph = graphResult.left().value();
+			log.info("look up propertyIdSecure:{}", propertyIdSecure);
+			Iterable<TitanVertex> vertices = titanGraph.query()
+					.has(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Property), propertyIdSecure).vertices();
+			if (vertices == null) {
+				log.error("failed to get  vertices object returned for resource id {}", propertyIdSecure);
+				operationFailed = true;
+				return false;
+			}
+			Iterator<TitanVertex> iterator = vertices.iterator();
+			List<TitanVertex> vertexList = new ArrayList<>();
+
+			if (iterator == null) {
+				log.error("failed to get iterator over vertices object returned for resource id " + propertyIdSecure);
+				operationFailed = true;
+				return false;
+			}
+
+			while (iterator.hasNext()) {
+				TitanVertex vertex = iterator.next();
+				vertexList.add(vertex);
+			}
+
+			if (!(vertexList.size() == 1)) {
+				log.error("failed to get 1 vertex for resource id {} instead got {}", propertyIdSecure,
+						vertexList.size());
+				operationFailed = true;
+				return false;
+			}
+
+			TitanVertex propertyVerticeSecure = vertexList.get(0);
+
+			log.info("look up propertyIdNetworkName:{}", propertyIdNetworkName);
+			vertices = titanGraph.query()
+					.has(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Property), propertyIdNetworkName).vertices();
+			if (vertices == null) {
+				log.error("failed to get  vertices object returned for resource id {}", propertyIdNetworkName);
+				operationFailed = true;
+				return false;
+			}
+
+			iterator = vertices.iterator();
+			vertexList = new ArrayList<>();
+
+			if (iterator == null) {
+				log.error("failed to get iterator over vertices object returned for resource id {}",
+						propertyIdNetworkName);
+				operationFailed = true;
+				return false;
+			}
+
+			while (iterator.hasNext()) {
+				TitanVertex vertex = iterator.next();
+				vertexList.add(vertex);
+			}
+
+			if (!(vertexList.size() == 1)) {
+				log.error("failed to get 1 vertex for resource id {} instead got {}", propertyIdNetworkName,
+						vertexList.size());
+				operationFailed = true;
+				return false;
+			}
+
+			TitanVertex propertyVerticeNetworkName = vertexList.get(0);
+
+			Map<String, Object> verticeNetworkNameProperties = titanGenericDao
+					.getProperties(propertyVerticeNetworkName);
+
+			log.info("vertice NetworkName Properties {}", verticeNetworkNameProperties);
+			Object type = verticeNetworkNameProperties.get(GraphPropertiesDictionary.TYPE.getProperty());
+			if (type == null || "".equals(type)) {
+				log.info("updating property Vertice Network Name");
+				propertyVerticeNetworkName.property(GraphPropertiesDictionary.TYPE.getProperty(), "string");
+			}
+
+			Map<String, Object> verticeSecureProperties = titanGenericDao.getProperties(propertyVerticeSecure);
+
+			log.info("vertice Secure Properties {}", verticeSecureProperties);
+
+			type = verticeSecureProperties.get(GraphPropertiesDictionary.TYPE.getProperty());
+
+			if (type == null || "".equals(type)) {
+				log.info("updating property Vertice Secure");
+				propertyVerticeSecure.property(GraphPropertiesDictionary.TYPE.getProperty(), "boolean");
+			}
+
+			log.info("print current properties state");
+
+			verticeNetworkNameProperties = titanGenericDao.getProperties(propertyVerticeNetworkName);
+
+			log.info("vertice NetworkName Properties {}", verticeNetworkNameProperties);
+
+			verticeSecureProperties = titanGenericDao.getProperties(propertyVerticeSecure);
+
+			log.info("vertice Secure Properties {}", verticeSecureProperties);
+
+			return true;
+		} finally {
+			if (operationFailed) {
+				titanGenericDao.rollback();
+			} else {
+				titanGenericDao.commit();
+			}
+		}
+	}
+
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1610/ToscaArtifactsAlignment.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1610/ToscaArtifactsAlignment.java
new file mode 100644
index 0000000000..347a5705b7
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1610/ToscaArtifactsAlignment.java
@@ -0,0 +1,461 @@
+/*-
+ * ============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.asdctool.impl.migration.v1610;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.collections.MapUtils;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.openecomp.sdc.be.components.impl.ServiceBusinessLogic;
+import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
+import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
+import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
+import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
+import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
+import org.openecomp.sdc.be.model.ArtifactDefinition;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.openecomp.sdc.be.model.Operation;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.be.model.Service;
+import org.openecomp.sdc.be.model.User;
+import org.openecomp.sdc.be.model.operations.api.IArtifactOperation;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.AbstractOperation;
+import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
+import org.openecomp.sdc.be.resources.data.ArtifactData;
+import org.openecomp.sdc.be.resources.data.ComponentMetadataData;
+import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
+import org.openecomp.sdc.be.resources.data.ServiceMetadataData;
+import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
+import org.openecomp.sdc.common.api.ArtifactTypeEnum;
+import org.openecomp.sdc.common.datastructure.Wrapper;
+import org.openecomp.sdc.common.util.StreamUtils;
+import org.openecomp.sdc.exception.ResponseFormat;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import fj.data.Either;
+
+/**
+ * This Class holds the logic to add Tosca Artifacts placeholder and payload.<br>
+ * This addition is done for old version of Services and Resources (pre 1610) that weren't created with them.<br>
+ * 
+ * @author mshitrit <br>
+ * 
+ *
+ */
+public class ToscaArtifactsAlignment extends AbstractOperation {
+	@Autowired
+	private IArtifactOperation artifactOperation;
+
+	@Autowired
+	private ServiceBusinessLogic serviceBusinessLogic;
+
+	private static Logger log = LoggerFactory.getLogger(ToscaArtifactsAlignment.class.getName());
+
+	private static final String ERROR_PREFIX = "Tosca Artifact Alignment Error: ";
+
+	// API that Fetches Resource
+	private final Function<ComponentMetadataData, Resource> resourceFetcher = componentMD -> getComponent(componentMD, ComponentTypeEnum.RESOURCE);
+	// API that Fetches Service
+	private final Function<ComponentMetadataData, Service> serviceFetcher = componentMD -> getComponent(componentMD, ComponentTypeEnum.SERVICE);
+	// Class Getters
+	private final Supplier<Class<ResourceMetadataData>> resourceClassGetter = () -> ResourceMetadataData.class;
+	private final Supplier<Class<ServiceMetadataData>> serviceClassGetter = () -> ServiceMetadataData.class;
+
+	/**
+	 * This method holds the logic to add Tosca Artifacts placeholder and payload.<br>
+	 * 
+	 * @return true if succeed otherwise returns false
+	 */
+	public boolean alignToscaArtifacts() {
+		Wrapper<TitanOperationStatus> errorWrapper = new Wrapper<>();
+		List<ResourceMetadataData> allResources = new ArrayList<>();
+		List<ResourceMetadataData> resourcesWithoutToscaPlaceHolder = new ArrayList<>();
+		List<ServiceMetadataData> allServices = new ArrayList<>();
+		List<ServiceMetadataData> servicesWithoutToscaPlaceHolder = new ArrayList<>();
+		log.debug("alignToscaArtifacts Start");
+		try {
+
+			if (errorWrapper.isEmpty()) {
+				log.info("Fetching all resources");
+				fillAllComponetOfSpecificType(allResources, NodeTypeEnum.Resource, resourceClassGetter, errorWrapper);
+			}
+
+			if (errorWrapper.isEmpty()) {
+				// Filter Resources Without Tosca Artifacts
+				log.info("filtering resources to add tosca placeholder");
+				Either<List<ResourceMetadataData>, TitanOperationStatus> eitherRelevantResources = getComponentsWithMissingToscaArtifacts(resourceClassGetter, NodeTypeEnum.Resource, allResources);
+				fillListOrWrapper(errorWrapper, resourcesWithoutToscaPlaceHolder, eitherRelevantResources);
+			}
+
+			if (errorWrapper.isEmpty()) {
+				// Add PlaceHolders To Resources
+				log.info("adding tosca placeholders artifacts to resources");
+				addToscaArtifactToComponents(resourcesWithoutToscaPlaceHolder, resourceFetcher, NodeTypeEnum.Resource, errorWrapper);
+			}
+			if (errorWrapper.isEmpty()) {
+				// Add payload to Resources
+				log.info("generating payload to tosca artifacts on resources");
+				fillResourcesPayload(allResources, errorWrapper);
+			}
+
+			if (errorWrapper.isEmpty()) {
+				log.info("Fetching all services");
+				fillAllComponetOfSpecificType(allServices, NodeTypeEnum.Service, serviceClassGetter, errorWrapper);
+			}
+			if (errorWrapper.isEmpty()) {
+				// Filter Services Without Tosca Artifacts
+				log.info("filtering services to add tosca placeholder");
+				Either<List<ServiceMetadataData>, TitanOperationStatus> eitherRelevantServices = getComponentsWithMissingToscaArtifacts(serviceClassGetter, NodeTypeEnum.Service, allServices);
+				fillListOrWrapper(errorWrapper, servicesWithoutToscaPlaceHolder, eitherRelevantServices);
+			}
+
+			if (errorWrapper.isEmpty()) {
+				// Add PlaceHolders To Services
+				log.info("adding tosca placeholders artifacts to services");
+				addToscaArtifactToComponents(servicesWithoutToscaPlaceHolder, serviceFetcher, NodeTypeEnum.Service, errorWrapper);
+			}
+
+			if (errorWrapper.isEmpty()) {
+				// Filter Services for Payload Add
+				// Add payload to Services
+				log.info("generating payload to tosca artifacts on services");
+				fillToscaArtifactPayload(allServices, serviceFetcher, errorWrapper);
+			}
+		} finally {
+			titanGenericDao.commit();
+		}
+		return errorWrapper.isEmpty();
+
+	}
+
+	private void fillResourcesPayload(List<ResourceMetadataData> allResources, Wrapper<TitanOperationStatus> errorWrapper) {
+		if (errorWrapper.isEmpty()) {
+			// First Only Non VF (CP, VL & VFC)
+			List<ResourceMetadataData> basicResources = allResources.stream().filter(e -> isBasicResource((ResourceMetadataDataDefinition) e.getMetadataDataDefinition())).collect(Collectors.toList());
+			// Filter resources for Payload Add
+			// Add payload to resources
+			fillToscaArtifactPayload(basicResources, resourceFetcher, errorWrapper);
+		}
+		if (errorWrapper.isEmpty()) {
+			// VFs
+			List<ResourceMetadataData> complexResource = allResources.stream().filter(e -> ((ResourceMetadataDataDefinition) e.getMetadataDataDefinition()).getResourceType() == ResourceTypeEnum.VF).collect(Collectors.toList());
+			// Filter resources for Payload Add
+			// Add payload to resources
+			fillToscaArtifactPayload(complexResource, resourceFetcher, errorWrapper);
+		}
+	}
+
+	private boolean isBasicResource(ResourceMetadataDataDefinition resourceMetadataDataDefinition) {
+		final ResourceTypeEnum resourceType = resourceMetadataDataDefinition.getResourceType();
+		boolean isBasicResource = resourceType == ResourceTypeEnum.CP || resourceType == ResourceTypeEnum.VL || resourceType == ResourceTypeEnum.VFC;
+		return isBasicResource;
+	}
+
+	private <T extends ComponentMetadataData> void fillAllComponetOfSpecificType(List<T> components, NodeTypeEnum nodeType, Supplier<Class<T>> classGetter, Wrapper<TitanOperationStatus> errorWrapper) {
+
+		Map<String, Object> props = new HashMap<String, Object>();
+		props.put(GraphPropertiesDictionary.IS_DELETED.getProperty(), true);
+		Either<List<T>, TitanOperationStatus> eitherComponentMD = titanGenericDao.getByCriteria(nodeType, null, props, classGetter.get());
+		if (eitherComponentMD.isLeft()) {
+			components.addAll(eitherComponentMD.left().value());
+		} else {
+			final TitanOperationStatus errorType = eitherComponentMD.right().value();
+			if (errorType != TitanOperationStatus.NOT_FOUND) {
+				log.error("{} When fetching all components of type:{} a titan error occured:{}", ERROR_PREFIX, nodeType.getName(), errorType.name());
+				errorWrapper.setInnerElement(errorType);
+			}
+		}
+
+	}
+
+	private <T extends ComponentMetadataData, R extends Component> void addToscaArtifactToComponents(List<T> relevantResources, Function<ComponentMetadataData, R> componentConvertor, NodeTypeEnum nodeType,
+			Wrapper<TitanOperationStatus> errorWrapper) {
+
+		// This Stream contains all create tosca placeholder results
+		Stream<StorageOperationStatus> addToscaToComponentsResultsStream = relevantResources.stream().map(e -> addToscaArtifacts(e, nodeType, componentConvertor));
+		// Execute the stream, and collect error
+		Optional<StorageOperationStatus> optionalError = addToscaToComponentsResultsStream.filter(e -> e != StorageOperationStatus.OK).findFirst();
+
+		// Handle error
+		if (optionalError.isPresent()) {
+			errorWrapper.setInnerElement(TitanOperationStatus.NOT_CREATED);
+		}
+	}
+
+	private <R extends Component> R getComponent(ComponentMetadataData md, ComponentTypeEnum componentTypeEnum) {
+		R result = null;
+		Either<R, StorageOperationStatus> eitherComponent = serviceBusinessLogic.getComponent(md.getMetadataDataDefinition().getUniqueId(), componentTypeEnum);
+		if (eitherComponent.isRight()) {
+			log.error("{} When fetching component {} of type:{} with uniqueId:{}", ERROR_PREFIX, md.getMetadataDataDefinition().getName(), componentTypeEnum.getValue(), md.getMetadataDataDefinition().getUniqueId());
+		} else {
+			result = eitherComponent.left().value();
+		}
+		return result;
+	}
+
+	private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> populateToscaArtifactsWithLog(Component component, User user, boolean isInCertificationRequest, boolean inTransaction, boolean shouldLock) {
+		Either<Either<ArtifactDefinition, Operation>, ResponseFormat> ret;
+		try {
+			ret = serviceBusinessLogic.populateToscaArtifacts(component, user, isInCertificationRequest, inTransaction, shouldLock);
+			if (ret.isLeft()) {
+				log.debug("Added payload to tosca artifacts of component {} of type:{} with uniqueId:{}", component.getName(), component.getComponentType().getValue(), component.getUniqueId());
+			}
+			return ret;
+		} catch (Exception e) {
+			log.error("{} Exception Occured When filling tosca artifact payload for component {} of type:{} with uniqueId:{}", ERROR_PREFIX, component.getName(), component.getComponentType().name(), component.getUniqueId(), e);
+			throw e;
+		}
+	}
+
+	private <R extends Component, T extends ComponentMetadataData> void fillToscaArtifactPayload(List<T> relevantComponents, Function<ComponentMetadataData, R> componentCreator, Wrapper<TitanOperationStatus> errorWrapper) {
+
+		final User dummyUser = buildDummyUser();
+		// Stream for all fill payload results
+		Stream<ImmutablePair<Component, Either<Either<ArtifactDefinition, Operation>, ResponseFormat>>>
+		// Filter elements that needs generation of tosca payload
+		fillToscaPayloadResultsStream = relevantComponents.stream().filter(e -> isGenerateToscaPayload(e))
+				// Converts ComponentMetadataData to Component
+				.map(e -> componentCreator.apply(e))
+				// For each component generate payload for tosca
+				// artifacts
+				.map(component -> {
+					return new ImmutablePair<Component, Either<Either<ArtifactDefinition, Operation>, ResponseFormat>>(component, populateToscaArtifactsWithLog(component, dummyUser, true, true, false));
+				});
+
+		try {
+			// execute and the stream
+			Optional<Component> optionalError = fillToscaPayloadResultsStream.
+			// filter in error
+					filter(e -> e.getRight().isRight())
+					// convert the result to error and execute the stream
+					.map(e -> e.getLeft()).findFirst();
+
+			// Check if error occurred
+			if (optionalError.isPresent()) {
+				Component component = optionalError.get();
+				log.error("{} When filling tosca artifact payload for component {} of type:{} with uniqueId:{}", ERROR_PREFIX, component.getName(), component.getComponentType().name(), component.getUniqueId());
+
+				errorWrapper.setInnerElement(TitanOperationStatus.GENERAL_ERROR);
+			}
+		} catch (Exception e) {
+			log.error("{} When filling tosca artifact payload for components : {}", ERROR_PREFIX, e.getMessage(), e);
+			errorWrapper.setInnerElement(TitanOperationStatus.GENERAL_ERROR);
+		}
+	}
+
+	private <R extends Component> StorageOperationStatus addToscaArtifacts(ComponentMetadataData component, NodeTypeEnum nodeType, Function<ComponentMetadataData, R> componentCreator) {
+
+		StorageOperationStatus result = StorageOperationStatus.OK;
+		R componentDefinition = componentCreator.apply(component);
+
+		// Fetch artifacts to be Added
+		Either<List<ArtifactDefinition>, StorageOperationStatus> eitherToscaArtifacts = getToscaArtifactsToAdd(componentDefinition);
+		if (eitherToscaArtifacts.isRight()) {
+			result = eitherToscaArtifacts.right().value();
+		} else {
+			List<ArtifactDefinition> toscaArtifactsToAdd = eitherToscaArtifacts.left().value();
+			if (!CollectionUtils.isEmpty(eitherToscaArtifacts.left().value())) {
+				final Stream<ImmutablePair<ArtifactDefinition, Either<ArtifactDefinition, StorageOperationStatus>>> createdToscaPlaceHolderStream = toscaArtifactsToAdd.stream()
+						// creates the artifact in the graph
+						.map(artifactDef -> new ImmutablePair<ArtifactDefinition, Either<ArtifactDefinition, StorageOperationStatus>>(artifactDef,
+								artifactOperation.addArifactToComponent(artifactDef, componentDefinition.getUniqueId(), nodeType, false, true)));
+
+				// Execute the stream, and collect error
+				Optional<ImmutablePair<ArtifactDefinition, StorageOperationStatus>> optionalError = createdToscaPlaceHolderStream.filter(e -> e.getRight().isRight()).map(e -> new ImmutablePair<>(e.getLeft(), e.getRight().right().value()))
+						.findFirst();
+
+				// In case error occurred
+				if (optionalError.isPresent()) {
+					ArtifactDefinition toscaArtifact = optionalError.get().getLeft();
+					StorageOperationStatus storageError = optionalError.get().getRight();
+					log.error("{} When adding tosca artifact of type {} to component {} of type:{} " + "with uniqueId:{} a storageError occurred:{}", ERROR_PREFIX, toscaArtifact.getArtifactType(), component.getMetadataDataDefinition().getName(),
+							nodeType.getName(), component.getMetadataDataDefinition().getUniqueId(), storageError.name());
+
+					result = storageError;
+				} else {
+					log.debug("Added tosca artifacts to component {} of type:{} with uniqueId:{}", component.getMetadataDataDefinition().getName(), nodeType.getName(), component.getMetadataDataDefinition().getUniqueId());
+				}
+
+			}
+		}
+
+		return result;
+	}
+
+	private <R extends Component> Either<List<ArtifactDefinition>, StorageOperationStatus> getToscaArtifactsToAdd(R componentDefinition) {
+
+		Either<List<ArtifactDefinition>, StorageOperationStatus> result;
+		List<ArtifactDefinition> toscaArtifactsAlreadyExist = new ArrayList<>();
+		if (!MapUtils.isEmpty(componentDefinition.getToscaArtifacts())) {
+			toscaArtifactsAlreadyExist.addAll(componentDefinition.getToscaArtifacts().values());
+		}
+
+		// Set Tosca Artifacts on component
+		serviceBusinessLogic.setToscaArtifactsPlaceHolders(componentDefinition, buildDummyUser());
+
+		List<ArtifactDefinition> toscaArtifactsToAdd = new ArrayList<>();
+		if (!MapUtils.isEmpty(componentDefinition.getToscaArtifacts())) {
+			final Collection<ArtifactDefinition> allToscaArtifacts = componentDefinition.getToscaArtifacts().values();
+			Set<String> artifactTypesExist = toscaArtifactsAlreadyExist.stream().map(e -> e.getArtifactType()).collect(Collectors.toSet());
+			toscaArtifactsToAdd = allToscaArtifacts.stream().filter(e -> !artifactTypesExist.contains(e.getArtifactType())).collect(Collectors.toList());
+			result = Either.left(toscaArtifactsToAdd);
+		} else {
+			log.error("{} failed to add tosca artifacts in bussiness logic to component {} of type:{} with uniqueId:{}", ERROR_PREFIX, componentDefinition.getName(), componentDefinition.getComponentType().getValue(),
+					componentDefinition.getUniqueId());
+			result = Either.right(StorageOperationStatus.ARTIFACT_NOT_FOUND);
+		}
+		return result;
+	}
+
+	private User buildDummyUser() {
+		User user = new User();
+		user.setUserId("migrationTask");
+		return user;
+	}
+
+	private boolean isGenerateToscaPayload(ComponentMetadataData component) {
+		final String state = component.getMetadataDataDefinition().getState();
+		boolean componentLifeCycleStateIsValid = LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.name().equals(state) || LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name().equals(state);
+
+		return !componentLifeCycleStateIsValid;
+
+	}
+
+	private <T> void fillListOrWrapper(Wrapper<TitanOperationStatus> wrapper, List<T> listToFill, Either<List<T>, TitanOperationStatus> either) {
+		if (either.isRight()) {
+			final TitanOperationStatus errorType = either.right().value();
+			if (errorType != TitanOperationStatus.NOT_FOUND) {
+				wrapper.setInnerElement(errorType);
+			}
+		} else {
+			listToFill.addAll(either.left().value());
+		}
+	}
+
+	private <T extends ComponentMetadataData> Either<List<T>, TitanOperationStatus> getComponentsWithMissingToscaArtifacts(Supplier<Class<T>> classGetter, NodeTypeEnum nodeType, List<T> allComponents) {
+
+		Either<List<T>, TitanOperationStatus> result;
+		Stream<ImmutablePair<T, Either<List<ArtifactData>, TitanOperationStatus>>> componentsWithToscaStream =
+				// Create a Stream of pairs : component and its Tosca Artifacts
+				allComponents.stream().map(e -> new ImmutablePair<>(e, getToscaArtifatcs(e, nodeType)));
+
+		List<ImmutablePair<T, Either<List<ArtifactData>, TitanOperationStatus>>> componentsWithToscaArtifacts =
+				// Collect the stream to list.
+				// in case getToscaArtifatcs failed, the first failure is
+				// added to the list
+				// (the collection stops after first failure)
+				StreamUtils.takeWhilePlusOneNoEval(componentsWithToscaStream, e -> e.getRight().isLeft()).collect(Collectors.toList());
+
+		// retrieve the failure optional (it may or may not exist)
+		Optional<TitanOperationStatus> isErrorOccured = componentsWithToscaArtifacts.stream()
+				// convert to the right side of the pair of type Either
+				.map(e -> e.getRight())
+				// Filter in only the errors
+				.filter(e -> e.isRight()).
+				// map the error from Either to TitanOperationStatus
+				map(e -> e.right().value()).findFirst();
+
+		// In case failure occurred
+		if (isErrorOccured.isPresent()) {
+			result = Either.right(isErrorOccured.get());
+			// In case NO failure occurred
+		} else {
+			List<T> filteredComponents = componentsWithToscaArtifacts.stream()
+					// Filter in only elements that does NOT have tosca
+					// artifacts
+					.filter(e -> isNotContainAllToscaArtifacts(e))
+					// Convert back to Components List & collect
+					.map(e -> e.getLeft()).collect(Collectors.toList());
+
+			result = Either.left(filteredComponents);
+		}
+
+		return result;
+	}
+
+	private <T extends ComponentMetadataData> boolean isNotContainAllToscaArtifacts(ImmutablePair<T, Either<List<ArtifactData>, TitanOperationStatus>> pair) {
+
+		final List<ArtifactData> artifactList = pair.getRight().left().value();
+
+		Set<ArtifactTypeEnum> filteredToscaList = artifactList.stream().
+		// Convert to ArtifactDataDefinition
+				map(e -> e.getArtifactDataDefinition()).
+				// Filter in Only Tosca Artifacts
+				filter(e -> e.getArtifactGroupType() == ArtifactGroupTypeEnum.TOSCA).
+				// Convert To ArtifactTypeEnum
+				map(e -> ArtifactTypeEnum.findType(e.getArtifactType())).
+				// Filter Out nulls in case of Type not found
+				filter(e -> e != null).collect(Collectors.toSet());
+
+		boolean toscaArifactContained = filteredToscaList.contains(ArtifactTypeEnum.TOSCA_CSAR) && filteredToscaList.contains(ArtifactTypeEnum.TOSCA_TEMPLATE);
+		return !toscaArifactContained;
+	}
+
+	private <T extends ComponentMetadataData> Either<List<ArtifactData>, TitanOperationStatus> getToscaArtifatcs(T component, NodeTypeEnum nodeType) {
+
+		Either<List<ArtifactData>, TitanOperationStatus> result;
+		// All The Artifacts of the Component
+		Either<List<ImmutablePair<ArtifactData, GraphEdge>>, TitanOperationStatus> eitherComponentArtifacts = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(nodeType), component.getMetadataDataDefinition().getUniqueId(),
+				GraphEdgeLabels.ARTIFACT_REF, NodeTypeEnum.ArtifactRef, ArtifactData.class);
+
+		if (eitherComponentArtifacts.isLeft()) {
+			// Convert Artifact Edge Pair to Artifact
+			List<ArtifactData> toscaArtifacts = eitherComponentArtifacts.left().value().stream()
+					// map ImmutablePair<ArtifactData, GraphEdge> to
+					// ArtifactData
+					.map(e -> e.getLeft())
+					// Filter in only Tosca Artifacts
+					.filter(artifact -> artifact.getArtifactDataDefinition().getArtifactGroupType() == ArtifactGroupTypeEnum.TOSCA)
+					// Collect
+					.collect(Collectors.toList());
+			result = Either.left(toscaArtifacts);
+		} else if (eitherComponentArtifacts.right().value() == TitanOperationStatus.NOT_FOUND) {
+			result = Either.left(new ArrayList<>());
+		} else {
+			final TitanOperationStatus titanError = eitherComponentArtifacts.right().value();
+			log.error("{} When fetching artifacts for component {} of type:{} with uniqueId:{} a titanError occurred:{}", ERROR_PREFIX, component.getMetadataDataDefinition().getName(), nodeType.getName(),
+					component.getMetadataDataDefinition().getUniqueId(), titanError.name());
+
+			result = Either.right(titanError);
+		}
+
+		return result;
+	}
+
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/main/DataSchemaMenu.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/main/DataSchemaMenu.java
new file mode 100644
index 0000000000..e29cd7eb75
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/main/DataSchemaMenu.java
@@ -0,0 +1,97 @@
+/*-
+ * ============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.asdctool.main;
+
+import org.openecomp.sdc.be.config.ConfigurationManager;
+import org.openecomp.sdc.be.dao.cassandra.schema.SdcSchemaBuilder;
+import org.openecomp.sdc.common.api.ConfigurationSource;
+import org.openecomp.sdc.common.impl.ExternalConfiguration;
+import org.openecomp.sdc.common.impl.FSConfigurationSource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class DataSchemaMenu {
+
+	private static Logger log = LoggerFactory.getLogger(DataSchemaMenu.class.getName());
+
+	public static void main(String[] args) throws Exception {
+
+		String operation = args[0];
+
+		String appConfigDir = args[1];
+
+		if (args == null || args.length < 2) {
+			usageAndExit();
+		}
+
+		ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(),
+				appConfigDir);
+		ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
+
+		try {
+
+			switch (operation.toLowerCase()) {
+			case "create-cassandra-structures":
+				log.debug("Start create cassandra keyspace, tables and indexes");
+				if (SdcSchemaBuilder.createSchema()) {
+					log.debug("create cassandra keyspace, tables and indexes successfull");
+					System.exit(0);
+				} else {
+					log.debug("create cassandra keyspace, tables and indexes failed");
+					System.exit(2);
+				}
+			case "create-titan-structures":
+				log.debug("Start create titan keyspace, tables and indexes");
+				if (SdcSchemaBuilder.createSchema()) {
+					log.debug("create cassandra keyspace, tables and indexes successfull");
+					System.exit(0);
+				} else {
+					log.debug("create cassandra keyspace, tables and indexes failed");
+					System.exit(2);
+				}
+			case "clean-cassndra":
+				log.debug("Start clean keyspace, tables");
+				if (SdcSchemaBuilder.deleteSchema()) {
+					log.debug(" successfull");
+					System.exit(0);
+				} else {
+					log.debug(" failed");
+					System.exit(2);
+				}
+			default:
+				usageAndExit();
+			}
+		} catch (Throwable t) {
+			t.printStackTrace();
+			log.debug("create cassandra keyspace, tables and indexes failed");
+			System.exit(3);
+		}
+	}
+
+	private static void usageAndExit() {
+		DataSchemeUsage();
+		System.exit(1);
+	}
+
+	private static void DataSchemeUsage() {
+		System.out.println("Usage: create-cassandra-structures <configuration dir> ");
+	}
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/main/EsToCassandraDataMigrationMenu.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/main/EsToCassandraDataMigrationMenu.java
new file mode 100644
index 0000000000..17008b31a4
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/main/EsToCassandraDataMigrationMenu.java
@@ -0,0 +1,109 @@
+/*-
+ * ============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.asdctool.main;
+
+import org.openecomp.sdc.asdctool.impl.DataMigration;
+import org.openecomp.sdc.asdctool.impl.EsToCassandraDataMigrationConfig;
+import org.openecomp.sdc.asdctool.impl.migration.v1604.AppConfig;
+import org.openecomp.sdc.asdctool.impl.migration.v1604.ServiceMigration;
+import org.openecomp.sdc.be.config.ConfigurationManager;
+import org.openecomp.sdc.be.dao.cassandra.schema.SdcSchemaBuilder;
+import org.openecomp.sdc.common.api.ConfigurationSource;
+import org.openecomp.sdc.common.impl.ExternalConfiguration;
+import org.openecomp.sdc.common.impl.FSConfigurationSource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+
+public class EsToCassandraDataMigrationMenu {
+
+	private static Logger log = LoggerFactory.getLogger(MigrationMenu.class.getName());
+
+	public static void main(String[] args) throws Exception {
+
+		if (args == null || args.length < 2) {
+			usageAndExit();
+		}
+		String operation = args[0];
+
+		String appConfigDir = args[1];
+		System.setProperty("config.home", appConfigDir);
+		ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(),
+				appConfigDir);
+		ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
+
+		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
+				EsToCassandraDataMigrationConfig.class);
+		DataMigration dataMigration = null;
+		try {
+			switch (operation.toLowerCase()) {
+			case "es-to-cassndra-migration":
+				dataMigration = (DataMigration) context.getBean("DataMigrationBean");
+				log.debug("Start migration from ES to C* ");
+				if (dataMigration.migrateDataESToCassndra(appConfigDir, true, true)) {
+					log.debug("migration from ES to C* was finished successfull");
+					System.exit(0);
+				} else {
+					log.debug("migration from ES to C* failed");
+					System.exit(2);
+				}
+				break;
+			case "es-to-cassndra-migration-export-only":
+				dataMigration = (DataMigration) context.getBean("DataMigrationBean");
+				log.debug("Start migration export only from ES to C* ");
+				if (dataMigration.migrateDataESToCassndra(appConfigDir, true, false)) {
+					log.debug("migration export only from ES to C* was finished successfull");
+					System.exit(0);
+				} else {
+					log.debug("migration export only from ES to C* failed");
+					System.exit(2);
+				}
+				break;
+			case "es-to-cassndra-migration-import-only":
+				dataMigration = (DataMigration) context.getBean("DataMigrationBean");
+				log.debug("Start migration import only from ES to C* ");
+				if (dataMigration.migrateDataESToCassndra(appConfigDir, false, true)) {
+					log.debug("migration import only from ES to C* was finished successfull");
+					System.exit(0);
+				} else {
+					log.debug("migration import only from ES to C* failed");
+					System.exit(2);
+				}
+				break;
+			default:
+				usageAndExit();
+			}
+		} catch (Throwable t) {
+			t.printStackTrace();
+			System.exit(3);
+		}
+	}
+
+	private static void usageAndExit() {
+		MigrationUsage();
+		System.exit(1);
+	}
+
+	private static void MigrationUsage() {
+		System.out.println(
+				"Usage: es-to-cassndra-migration/es-to-cassndra-migration-import-only/es-to-cassndra-migration-export-only <configuration dir>");
+	}
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/main/ExportImportMenu.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/main/ExportImportMenu.java
new file mode 100644
index 0000000000..6b6f11c5a6
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/main/ExportImportMenu.java
@@ -0,0 +1,169 @@
+/*-
+ * ============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.asdctool.main;
+
+import org.openecomp.sdc.asdctool.impl.GraphMLConverter;
+import org.openecomp.sdc.asdctool.impl.GraphMLDataAnalyzer;
+
+public class ExportImportMenu {
+
+	private static void usageAndExit() {
+		exportUsage();
+		importUsage();
+		exportUsersUsage();
+
+		System.exit(1);
+	}
+
+	private static void importUsage() {
+		System.out.println("Usage: import <titan.properties> <graph file location>");
+	}
+
+	private static void exportUsage() {
+		System.out.println("Usage: export <titan.properties> <output directory>");
+	}
+
+	private static void dataReportUsage() {
+		System.out.println("Usage: get-data-report-from-graph-ml <full path of .graphml file>");
+	}
+
+	private static void exportUsersUsage() {
+		System.out.println("Usage: exportusers <titan.properties> <output directory>");
+	}
+
+	public static void main(String[] args) throws Exception {
+
+		if (args == null || args.length < 1) {
+			usageAndExit();
+		}
+
+		String operation = args[0];
+		GraphMLConverter graphMLConverter = new GraphMLConverter();
+		switch (operation.toLowerCase()) {
+
+		case "export":
+			boolean isValid = verifyParamsLength(args, 3);
+			if (false == isValid) {
+				exportUsage();
+				System.exit(1);
+			}
+
+			boolean result = graphMLConverter.exportGraph(args);
+			if (result == false) {
+				System.exit(2);
+			}
+
+			break;
+		case "import":
+			isValid = verifyParamsLength(args, 3);
+			if (false == isValid) {
+				importUsage();
+				System.exit(1);
+			}
+			result = graphMLConverter.importGraph(args);
+			if (result == false) {
+				System.exit(2);
+			}
+			break;
+
+		case "exportusers":
+			isValid = verifyParamsLength(args, 3);
+			if (false == isValid) {
+				importUsage();
+				System.exit(1);
+			}
+			result = graphMLConverter.exportUsers(args);
+			if (result == false) {
+				System.exit(2);
+			}
+			break;
+
+		case "findproblem":
+			isValid = verifyParamsLength(args, 3);
+			if (false == isValid) {
+				importUsage();
+				System.exit(1);
+			}
+			result = graphMLConverter.findErrorInJsonGraph(args);
+			if (result == false) {
+				System.exit(2);
+			}
+			break;
+		case "export-as-graph-ml":
+			isValid = verifyParamsLength(args, 3);
+			if (false == isValid) {
+				exportUsage();
+				System.exit(1);
+			}
+			String mlFile = graphMLConverter.exportGraphMl(args);
+			if (mlFile == null) {
+				System.exit(2);
+			}
+			break;
+		case "export-as-graph-ml-with-data-report":
+			isValid = verifyParamsLength(args, 3);
+			if (false == isValid) {
+				exportUsage();
+				System.exit(1);
+			}
+			mlFile = graphMLConverter.exportGraphMl(args);
+			if (mlFile == null) {
+				System.exit(2);
+			}
+			String[] dataArgs = new String[] { mlFile };
+			mlFile = new GraphMLDataAnalyzer().analyzeGraphMLData(dataArgs);
+			if (mlFile == null) {
+				System.exit(2);
+			}
+			break;
+		case "get-data-report-from-graph-ml":
+			isValid = verifyParamsLength(args, 2);
+			if (false == isValid) {
+				dataReportUsage();
+				System.exit(1);
+			}
+			dataArgs = new String[] { args[1] };
+			mlFile = new GraphMLDataAnalyzer().analyzeGraphMLData(dataArgs);
+			if (mlFile == null) {
+				System.exit(2);
+			}
+			break;
+		default:
+			usageAndExit();
+		}
+
+	}
+
+	private static boolean verifyParamsLength(String[] args, int i) {
+		if (args == null) {
+			if (i > 0) {
+				return false;
+			}
+			return true;
+		}
+
+		if (args.length >= i) {
+			return true;
+		}
+		return false;
+	}
+
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/main/MigrationMenu.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/main/MigrationMenu.java
new file mode 100644
index 0000000000..d7ed4600dd
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/main/MigrationMenu.java
@@ -0,0 +1,251 @@
+/*-
+ * ============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.asdctool.main;
+
+import java.util.Arrays;
+import java.util.Optional;
+
+import org.openecomp.sdc.asdctool.impl.PopulateComponentCache;
+import org.openecomp.sdc.asdctool.impl.migration.v1604.AppConfig;
+import org.openecomp.sdc.asdctool.impl.migration.v1604.DerivedFromAlignment;
+import org.openecomp.sdc.asdctool.impl.migration.v1604.GroupsAlignment;
+import org.openecomp.sdc.asdctool.impl.migration.v1604.ServiceMigration;
+import org.openecomp.sdc.asdctool.impl.migration.v1604.VfcNamingAlignment;
+import org.openecomp.sdc.asdctool.impl.migration.v1607.CsarMigration;
+import org.openecomp.sdc.asdctool.impl.migration.v1610.TitanFixUtils;
+import org.openecomp.sdc.asdctool.impl.migration.v1610.ToscaArtifactsAlignment;
+import org.openecomp.sdc.be.config.ConfigurationManager;
+import org.openecomp.sdc.common.api.ConfigurationSource;
+import org.openecomp.sdc.common.impl.ExternalConfiguration;
+import org.openecomp.sdc.common.impl.FSConfigurationSource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+
+public class MigrationMenu {
+
+	private static Logger log = LoggerFactory.getLogger(MigrationMenu.class.getName());
+	private static final String SERVICE_MIGARTION_BEAN = "serviceMigrationBean";
+
+	private static enum MigrationOperationEnum {
+		MIGRATION_1602_1604("migrate-1602-1604", SERVICE_MIGARTION_BEAN), 
+		ALIGN_DERIVED_FROM_1604("align-derived-from-1604", "derivedFromAlignment"), 
+		MIGRATE_1604_1607("migrate-1604-1607", SERVICE_MIGARTION_BEAN), 
+		ALIGN_VFC_NAMES_1604("align-vfc-names-1604", "vfcNamingAlignmentBean"), 
+		TEST_REMOVE_HEAT_PLACEHOLDERS("testremoveheatplaceholders",	SERVICE_MIGARTION_BEAN), 
+		TEST_ADD_GROUP_UUIDS("testaddgroupuuids", SERVICE_MIGARTION_BEAN), 
+		ALIGN_GROUPS("align-groups", "groupsAlignment"), 
+		CLEAN_CSAR("clean-csar", "csarMigration"), 
+		POPULATE_COMPONENT_CACHE("populate-component-cache", "populateComponentCache"), 
+		FIX_PROPERTIES("fix-properties", "titanFixUtils"), 
+		ALIGN_TOSCA_ARTIFACTS("align-tosca-artifacts", "toscaArtifactsAlignment"), 
+		FIX_ICONS("fix-icons", "titanFixUtils");
+
+		private String value, beanName;
+
+		public static MigrationOperationEnum findByValue(String value) {
+			Optional<MigrationOperationEnum> optionalFound = Arrays.asList(MigrationOperationEnum.values()).stream().filter(e -> e.getValue().equalsIgnoreCase(value)).findAny();
+			return optionalFound.isPresent() ? optionalFound.get() : null;
+		}
+
+		MigrationOperationEnum(String value, String beanName) {
+			this.value = value;
+			this.beanName = beanName;
+		}
+
+		public String getValue() {
+			return value;
+		}
+
+		public String getBeanName() {
+			return beanName;
+		}
+	};
+
+	public static void main(String[] args) throws Exception {
+
+		if (args == null || args.length < 2) {
+			usageAndExit();
+		}
+		MigrationOperationEnum operationEnum = MigrationOperationEnum.findByValue(args[0]);
+		String appConfigDir = args[1];
+		String dataInputFileDir = null;
+		if (operationEnum == MigrationOperationEnum.ALIGN_DERIVED_FROM_1604) {
+			dataInputFileDir = args[2];
+		}
+		AnnotationConfigApplicationContext context = initContext(appConfigDir);
+		try {
+			ServiceMigration serviceMigration = (ServiceMigration) context.getBean(SERVICE_MIGARTION_BEAN);
+			switch (operationEnum) {
+			case MIGRATION_1602_1604:
+				log.debug("Start Titan migration from 1602 version to 1604");
+				if (serviceMigration.migrate1602to1604(appConfigDir)) {
+					log.debug("Titan migration from 1602 version to 1604 was finished successfull");
+					System.exit(0);
+				} else {
+					log.debug("Titan migration from 1602 version to 1604 was failed");
+					System.exit(2);
+				}
+			case MIGRATE_1604_1607:
+				log.debug("Start Titan migration from 1604 version to 1607");
+				if (serviceMigration.migrate1604to1607(appConfigDir)) {
+					log.debug("Titan migration from 1604 version to 1607 was finished successfull");
+					System.exit(0);
+				} else {
+					log.debug("Titan migration from 1604 version to 1607 was failed");
+					System.exit(2);
+				}
+				break;
+			case ALIGN_VFC_NAMES_1604:
+				VfcNamingAlignment vfcNamingAlignment = (VfcNamingAlignment) context.getBean(operationEnum.getBeanName());
+				log.debug("Start VFC naming alignment on 1604");
+				if (vfcNamingAlignment.alignVfcNames1604(appConfigDir)) {
+					log.debug("VFC naming alignment on 1604 was finished successfull");
+					System.exit(0);
+				} else {
+					log.debug("VFC naming alignment on 1604 was failed");
+					System.exit(2);
+				}
+				break;
+			case TEST_REMOVE_HEAT_PLACEHOLDERS:
+				boolean check = serviceMigration.testRemoveHeatPlaceHolders(appConfigDir);
+				if (check == true) {
+					System.exit(0);
+				} else {
+					System.exit(2);
+				}
+				break;
+			case TEST_ADD_GROUP_UUIDS:
+				check = serviceMigration.testAddGroupUuids(appConfigDir);
+				if (check == true) {
+					System.exit(0);
+				} else {
+					System.exit(2);
+				}
+				break;
+			case ALIGN_DERIVED_FROM_1604:
+				DerivedFromAlignment derivedFromAlignment = (DerivedFromAlignment) context.getBean(operationEnum.getBeanName());
+				log.debug("Start derived from alignment on 1604");
+				if (derivedFromAlignment.alignDerivedFrom1604(appConfigDir, dataInputFileDir)) {
+					log.debug("Derived from alignment on 1604 was finished successfull");
+					System.exit(0);
+				} else {
+					log.debug("Derived from alignment on 1604 was failed");
+					System.exit(2);
+				}
+				break;
+			case ALIGN_GROUPS:
+				GroupsAlignment groupsAlignment = (GroupsAlignment) context.getBean(operationEnum.getBeanName());
+				log.debug("Start derived from alignment on 1604");
+				if (groupsAlignment.alignGroups(appConfigDir)) {
+					log.debug("Groups alignment was finished successfull");
+					System.exit(0);
+				} else {
+					log.debug("Groups alignment was failed");
+					System.exit(2);
+				}
+				break;
+			case CLEAN_CSAR:
+				log.debug("Start remove CSAR resources");
+				CsarMigration csarMigration = (CsarMigration) context.getBean(operationEnum.getBeanName());
+				// TODO Show to Michael L fixed return value
+				if (csarMigration.removeCsarResources()) {
+					log.debug("Remove CSAR resources finished successfully");
+					System.exit(0);
+				} else {
+					log.debug("Remove CSAR resources failed");
+					System.exit(2);
+				}
+				break;
+			case POPULATE_COMPONENT_CACHE:
+				PopulateComponentCache populateComponentCache = (PopulateComponentCache) context.getBean(operationEnum.getBeanName());
+				// TODO Show to Michael L No return value always returns 0
+				populateComponentCache.populateCache();
+				System.exit(0);
+				break;
+			case FIX_PROPERTIES:
+				log.debug("Start fix capability properties types");
+				TitanFixUtils titanFixUtils = (TitanFixUtils) context.getBean(operationEnum.getBeanName());
+				// TODO Show to Michael L fixed return value
+				if (titanFixUtils.fixCapabiltyPropertyTypes()) {
+					log.debug("Fix capability properties types finished successfully");
+					System.exit(0);
+				} else {
+					log.debug("Fix capability properties types failed");
+					System.exit(2);
+				}
+				break;
+			case FIX_ICONS:
+				log.debug("Start fix icons of vl and eline");
+				titanFixUtils = (TitanFixUtils) context.getBean(operationEnum.getBeanName());
+				// TODO Show to Michael L fixed return value
+				if (titanFixUtils.fixIconsInNormatives()) {
+					log.debug("Fix icons of vl and eline finished successfully");
+					System.exit(0);
+				} else {
+					log.debug("Fix icons of vl and eline failed");
+					System.exit(2);
+				}
+				break;
+			case ALIGN_TOSCA_ARTIFACTS:
+				log.debug("Start align tosca artifacts");
+				ToscaArtifactsAlignment toscaArtifactsAlignment = (ToscaArtifactsAlignment) context.getBean(operationEnum.getBeanName());
+				boolean isSuccessful = toscaArtifactsAlignment.alignToscaArtifacts();
+				if (isSuccessful) {
+					log.debug("Tosca Artifacts alignment was finished successfull");
+					System.exit(0);
+				} else {
+					log.debug("Tosca Artifacts alignment has failed");
+					System.exit(2);
+				}
+				break;
+			default:
+				usageAndExit();
+			}
+		} catch (Throwable t) {
+			t.printStackTrace();
+			System.exit(3);
+		} finally {
+			context.close();
+		}
+	}
+
+	private static AnnotationConfigApplicationContext initContext(String appConfigDir) {
+		ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
+		ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
+		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
+		return context;
+	}
+
+	private static void usageAndExit() {
+		MigrationUsage();
+		System.exit(1);
+	}
+
+	private static void MigrationUsage() {
+		System.out.println("Usage: migrate-1602-1604 <configuration dir>");
+		System.out.println("Usage: migrate-1604-1607 <configuration dir>");
+		System.out.println("Usage: align-vfc-names-1604 <configuration dir>");
+		System.out.println("Usage: align-derived-from-1604 <configuration dir> <data_input_file dir>");
+		System.out.println("Usage: align-groups <configuration dir>");
+		System.out.println("Usage: fix-properties <configuration dir>");
+	}
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/main/RemoveUtils.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/main/RemoveUtils.java
new file mode 100644
index 0000000000..ddece759c0
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/main/RemoveUtils.java
@@ -0,0 +1,78 @@
+/*-
+ * ============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.asdctool.main;
+
+import org.openecomp.sdc.asdctool.impl.ProductLogic;
+
+/**
+ * Created by mlando on 2/23/2016.
+ */
+public class RemoveUtils {
+
+	public static void main(String[] args) throws Exception {
+
+		if (args == null || args.length < 1) {
+			removeUsage();
+		}
+
+		String operation = args[0];
+
+		switch (operation.toLowerCase()) {
+
+		case "remove-products":
+
+			boolean isValid = verifyParamsLength(args, 5);
+			if (false == isValid) {
+				removeUsage();
+				System.exit(1);
+			}
+
+			ProductLogic productLogic = new ProductLogic();
+			boolean result = productLogic.deleteAllProducts(args[1], args[2], args[3], args[4]);
+
+			if (result == false) {
+				System.exit(2);
+			}
+			break;
+		default:
+			removeUsage();
+		}
+
+	}
+
+	private static void removeUsage() {
+		System.out.println("Usage: remove-products <titan.properties> <BE host> <BE port> <admin user>");
+	}
+
+	private static boolean verifyParamsLength(String[] args, int i) {
+		if (args == null) {
+			if (i > 0) {
+				return false;
+			}
+			return true;
+		}
+
+		if (args.length >= i) {
+			return true;
+		}
+		return false;
+	}
+}
diff --git a/asdctool/src/main/java/org/openecomp/sdc/asdctool/main/UpdateIsVnfMenu.java b/asdctool/src/main/java/org/openecomp/sdc/asdctool/main/UpdateIsVnfMenu.java
new file mode 100644
index 0000000000..e620510916
--- /dev/null
+++ b/asdctool/src/main/java/org/openecomp/sdc/asdctool/main/UpdateIsVnfMenu.java
@@ -0,0 +1,122 @@
+/*-
+ * ============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.asdctool.main;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.openecomp.sdc.asdctool.impl.UpdatePropertyOnVertex;
+import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class UpdateIsVnfMenu {
+
+	private static Logger log = LoggerFactory.getLogger(UpdateIsVnfMenu.class.getName());
+
+	private static void usageAndExit() {
+		updateIsVnfTrueUsage();
+		System.exit(1);
+	}
+
+	private static void updateIsVnfTrueUsage() {
+		System.out.println(
+				"Usage: updateIsVnfTrue <titan.properties> <systemServiceName1,systemServiceName2,...,systemServiceNameN>");
+	}
+
+	public static void main(String[] args) throws Exception {
+
+		if (args == null || args.length < 1) {
+			usageAndExit();
+		}
+
+		UpdatePropertyOnVertex updatePropertyOnVertex = new UpdatePropertyOnVertex();
+		String operation = args[0];
+
+		switch (operation.toLowerCase()) {
+
+		case "updateisvnftrue":
+			boolean isValid = verifyParamsLength(args, 3);
+			if (false == isValid) {
+				updateIsVnfTrueUsage();
+				System.exit(1);
+			}
+
+			Map<String, Object> keyValueToSet = new HashMap<>();
+			keyValueToSet.put(GraphPropertiesDictionary.IS_VNF.getProperty(), true);
+
+			List<Map<String, Object>> orCriteria = buildCriteriaFromSystemServiceNames(args[2]);
+			Integer updatePropertyOnServiceAtLeastCertified = updatePropertyOnVertex
+					.updatePropertyOnServiceAtLeastCertified(args[1], keyValueToSet, orCriteria);
+
+			if (updatePropertyOnServiceAtLeastCertified == null) {
+				System.exit(2);
+			} else if (updatePropertyOnServiceAtLeastCertified.intValue() >= 0) {
+				log.debug("Number of updated services is {}", updatePropertyOnServiceAtLeastCertified.intValue());
+				System.exit(0);
+			}
+
+			break;
+		default:
+			usageAndExit();
+		}
+
+	}
+
+	private static List<Map<String, Object>> buildCriteriaFromSystemServiceNames(String systemList) {
+
+		List<Map<String, Object>> systemNames = new ArrayList<>();
+
+		String[] split = systemList.split(",");
+		if (split != null) {
+			for (String systemName : split) {
+				systemName = systemName.trim();
+
+				Map<String, Object> map = new HashMap();
+				map.put(GraphPropertiesDictionary.SYSTEM_NAME.getProperty(), systemName);
+				map.put(GraphPropertiesDictionary.LABEL.getProperty(), NodeTypeEnum.Service.getName());
+
+				systemNames.add(map);
+			}
+		}
+
+		return systemNames;
+	}
+
+	private static boolean verifyParamsLength(String[] args, int i) {
+		if (args == null) {
+			if (i > 0) {
+				return false;
+			}
+			return true;
+		}
+
+		if (args.length >= i) {
+			return true;
+		}
+		return false;
+	}
+
+}