merge from ecomp a88f0072 - Modern UI

Issue-ID: VID-378
Change-Id: Ibcb23dd27f550cf32ce2fe0239f0f496ae014ff6
Signed-off-by: Ittay Stern <ittay.stern@att.com>

26 files changed, 3511 insertions, 0 deletions

diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/general/general.action.spec.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/general/general.action.spec.ts
new file mode 100644
index 000000000..a65249a3b
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/general/general.action.spec.ts
@@ -0,0 +1,157 @@
+import {
+  GeneralActions, UpdateAicZonesAction,
+  UpdateLcpRegionsAndTenantsAction,
+  UpdateProductFamiliesAction,
+  UpdateSubscribersAction, UpdateUserIdAction
+} from "./general.actions";
+import {SelectOption} from "../../../models/selectOption";
+
+
+describe('general actions', () => {
+  test('#UPDATE_LCP_REGIONS_AND_TENANTS : action', () => {
+    const action: UpdateLcpRegionsAndTenantsAction = <UpdateLcpRegionsAndTenantsAction>{
+      type: GeneralActions.UPDATE_LCP_REGIONS_AND_TENANTS,
+      lcpRegionsAndTenants: {
+        "lcpRegionList": [],
+        "lcpRegionsTenantsMap": {}
+      }
+    };
+
+    expect(action.type).toEqual(GeneralActions.UPDATE_LCP_REGIONS_AND_TENANTS);
+    expect(action.lcpRegionsAndTenants.lcpRegionList).toEqual([]);
+    expect(action.lcpRegionsAndTenants.lcpRegionsTenantsMap).toEqual({});
+  });
+
+  test('#UPDATE_SUBSCRIBERS : action', () => {
+    const action: UpdateSubscribersAction = <UpdateSubscribersAction>{
+      type: GeneralActions.UPDATE_SUBSCRIBERS,
+      subscribers: [
+        {
+          "id": "ERICA5779-Subscriber-2",
+          "name": "ERICA5779-Subscriber-2",
+          "isPermitted": false
+        },
+        {
+          "id": "ERICA5779-Subscriber-3",
+          "name": "ERICA5779-Subscriber-3",
+          "isPermitted": false
+        },
+        {
+          "id": "ERICA5779-Subscriber-4",
+          "name": "ERICA5779-Subscriber-5",
+          "isPermitted": false
+        },
+        {
+          "id": "ERICA5779-TestSub-PWT-101",
+          "name": "ERICA5779-TestSub-PWT-101",
+          "isPermitted": false
+        },
+        {
+          "id": "ERICA5779-TestSub-PWT-102",
+          "name": "ERICA5779-TestSub-PWT-102",
+          "isPermitted": false
+        },
+        {
+          "id": "ERICA5779-TestSub-PWT-103",
+          "name": "ERICA5779-TestSub-PWT-103",
+          "isPermitted": false
+        },
+        {
+          "id": "31739f3e-526b-11e6-beb8-9e71128cae77",
+          "name": "CRAIG/ROBERTS",
+          "isPermitted": false
+        },
+        {
+          "id": "DHV1707-TestSubscriber-2",
+          "name": "DALE BRIDGES",
+          "isPermitted": false
+        },
+        {
+          "id": "jimmy-example",
+          "name": "JimmyExampleCust-20161102",
+          "isPermitted": false
+        },
+        {
+          "id": "jimmy-example2",
+          "name": "JimmyExampleCust-20161103",
+          "isPermitted": false
+        },
+        {
+          "id": "CAR_2020_ER",
+          "name": "CAR_2020_ER",
+          "isPermitted": true
+        },
+        {
+          "id": "a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb",
+          "name": "Emanuel",
+          "isPermitted": false
+        },
+        {
+          "id": "21014aa2-526b-11e6-beb8-9e71128cae77",
+          "name": "JULIO ERICKSON",
+          "isPermitted": false
+        },
+        {
+          "id": "DHV1707-TestSubscriber-1",
+          "name": "LLOYD BRIDGES",
+          "isPermitted": false
+        },
+        {
+          "id": "e433710f-9217-458d-a79d-1c7aff376d89",
+          "name": "SILVIA ROBBINS",
+          "isPermitted": true
+        }
+      ]
+    };
+
+    expect(action.type).toEqual(GeneralActions.UPDATE_SUBSCRIBERS);
+    expect(action.subscribers).toHaveLength(15);
+  });
+
+  test('#UPDATE_PRODUCT_FAMILIES : action', () => {
+    const action: UpdateProductFamiliesAction = <UpdateProductFamiliesAction>{
+      type: GeneralActions.UPDATE_PRODUCT_FAMILIES,
+      productFamilies: [
+        new SelectOption({
+          id : 'id',
+          name : 'name',
+          isPermitted : false
+        })
+      ]
+    };
+
+    expect(action.type).toEqual(GeneralActions.UPDATE_PRODUCT_FAMILIES);
+    expect(action.productFamilies).toHaveLength(1);
+  });
+
+
+  test('#UpdateAicZonesAction : action', () => {
+    const action: UpdateAicZonesAction = <UpdateAicZonesAction>{
+      type: GeneralActions.UPDATE_AIC_ZONES,
+      aicZones: [
+        new SelectOption({
+          id : 'id',
+          name : 'name',
+          isPermitted : false
+        })
+      ]
+    };
+
+    expect(action.type).toEqual(GeneralActions.UPDATE_AIC_ZONES);
+    expect(action.aicZones).toHaveLength(1);
+  });
+
+  test('#UpdateUserIdAction : action', () => {
+    const action: UpdateUserIdAction = <UpdateUserIdAction>{
+      type: GeneralActions.UPDATE_USER_ID,
+      userId: "userId"
+    };
+
+    expect(action.type).toEqual(GeneralActions.UPDATE_USER_ID);
+    expect(action.userId).toBe("userId");
+  });
+
+});
+
+
+
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/general/general.actions.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/general/general.actions.ts
new file mode 100644
index 000000000..7a10eba0a
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/general/general.actions.ts
@@ -0,0 +1,150 @@
+import {Action, ActionCreator} from "redux";
+import {LcpRegionsAndTenants} from "../../../models/lcpRegionsAndTenants";
+import {SelectOptionInterface} from "../../../models/selectOption";
+import {ServiceType} from "../../../models/serviceType";
+import {ITreeNode} from "angular-tree-component/dist/defs/api";
+
+export enum GeneralActions {
+  UPDATE_LCP_REGIONS_AND_TENANTS = "UPDATE_LCP_REGIONS_AND_TENANTS",
+  UPDATE_SUBSCRIBERS = "UPDATE_SUBSCRIBERS",
+  UPDATE_PRODUCT_FAMILIES = "UPDATE_PRODUCT_FAMILIES",
+  UPDATE_SERVICE_TYPES = "UPDATE_SERVICE_TYPES",
+  UPDATE_AIC_ZONES = "UPDATE_AIC_ZONES",
+  UPDATE_USER_ID = "UPDATE_USER_ID",
+  UPDATE_NETWORK_FUNCTION = "UPDATE_NETWORK_FUNCTION",
+  UPDATE_CATEGORY_PARAMETERS = "UPDATE_CATEGORY_PARAMETERS",
+  REMOVE_INSTANCE = 'REMOVE_INSTANCE',
+  CHANGE_INSTANCE_COUNTER = 'CHANGE_INSTANCE_COUNTER',
+  DUPLICATE_BULK_INSTANCES = 'DUPLICATE_BULK_INSTANCES'
+}
+export interface UpdateLcpRegionsAndTenantsAction extends Action {
+  lcpRegionsAndTenants?: LcpRegionsAndTenants;
+}
+
+export interface RemoveInstanceAction extends Action {
+  modelName?: string;
+  serviceModelId: string;
+  storeKey : string;
+  node : ITreeNode;
+}
+
+export interface UpdateSubscribersAction extends Action {
+  subscribers?: SelectOptionInterface[];
+}
+
+export interface UpdateProductFamiliesAction extends Action {
+  productFamilies?: SelectOptionInterface[];
+}
+
+export interface UpdateAicZonesAction extends Action {
+  aicZones?: SelectOptionInterface[];
+}
+
+export interface UpdateServiceTypesAction extends Action {
+  serviceTypes?: ServiceType[];
+  subscriberId: string;
+}
+export interface UpdateUserIdAction extends Action {
+  userId: string;
+}
+
+export interface UpdateNetworkCollectionFunction extends Action {
+  networksAccordingToNetworkCollection: any;
+  network_function: any;
+}
+
+export interface UpdateCategoryParametersAction extends Action {
+  categoryParameters?: Object;
+}
+
+export interface ChangeInstanceCounterAction extends Action{
+  serviceUUID : string;
+  UUID : string;
+  changeBy : number;
+  node : ITreeNode;
+}
+
+export interface DuplicateBulkInstancesAction extends Action {
+  serviceId?: string;
+  modelName?: string;
+  originalName? : string;
+  objects? : {};
+  existingNames: {[key: string] : any};
+  node : ITreeNode;
+}
+
+export interface UpdateServiceTypesAction extends Action {
+  serviceTypes?: ServiceType[];
+  subscriberId: string;
+}
+
+export const updateLcpRegionsAndTenants: ActionCreator<UpdateLcpRegionsAndTenantsAction> = lcpRegionsAndTenants => ({
+  type: GeneralActions.UPDATE_LCP_REGIONS_AND_TENANTS,
+  lcpRegionsAndTenants: lcpRegionsAndTenants
+});
+
+export const updateSubscribers: ActionCreator<UpdateSubscribersAction> = subscribers => ({
+  type: GeneralActions.UPDATE_SUBSCRIBERS,
+  subscribers: subscribers
+});
+
+export const updateProductFamilies: ActionCreator<UpdateProductFamiliesAction> = productFamilies => ({
+  type: GeneralActions.UPDATE_PRODUCT_FAMILIES,
+  productFamilies: productFamilies
+});
+
+export const updateAicZones: ActionCreator<UpdateAicZonesAction> = aicZones => ({
+  type: GeneralActions.UPDATE_AIC_ZONES,
+  aicZones: aicZones
+});
+
+export const updateUserId: ActionCreator<UpdateUserIdAction> = userId => ({
+  type: GeneralActions.UPDATE_USER_ID,
+  userId: userId
+});
+
+export const updateNetworkCollectionFunction: ActionCreator<UpdateNetworkCollectionFunction> = (ncf, networksAccordingToNetworkCollection) => ({
+  type: GeneralActions.UPDATE_NETWORK_FUNCTION,
+  networksAccordingToNetworkCollection: networksAccordingToNetworkCollection["results"],
+  network_function: ncf
+});
+
+export const updateCategoryParameters: ActionCreator<UpdateCategoryParametersAction> = categoryParameters => ({
+  type: GeneralActions.UPDATE_CATEGORY_PARAMETERS,
+  categoryParameters: categoryParameters
+});
+
+export const removeInstance: ActionCreator<RemoveInstanceAction> = (modelName, serviceModelId, storeKey, node : ITreeNode) => ({
+  type: GeneralActions.REMOVE_INSTANCE,
+  modelName: modelName,
+  serviceModelId: serviceModelId,
+  storeKey: storeKey,
+  node : node
+});
+
+
+export const changeInstanceCounter: ActionCreator<ChangeInstanceCounterAction> = (UUID, serviceUUID , changeBy, node) => ({
+  type: GeneralActions.CHANGE_INSTANCE_COUNTER,
+  UUID: UUID,
+  serviceUUID: serviceUUID,
+  changeBy : changeBy || 1,
+  node : node
+});
+
+
+export const duplicateBulkInstances: ActionCreator<DuplicateBulkInstancesAction> = (serviceId, objects, existingNames, node) => ({
+  type: GeneralActions.DUPLICATE_BULK_INSTANCES,
+  serviceId: serviceId,
+  objects : objects,
+  existingNames: existingNames,
+  node : node
+});
+
+
+export const updateServiceTypes: ActionCreator<UpdateServiceTypesAction> = (serviceTypes, subscriberId) => ({
+  type: GeneralActions.UPDATE_SERVICE_TYPES,
+  serviceTypes: serviceTypes,
+  subscriberId: subscriberId
+});
+
+
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/general/general.reducers.spec.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/general/general.reducers.spec.ts
new file mode 100644
index 000000000..ed456314e
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/general/general.reducers.spec.ts
@@ -0,0 +1,376 @@
+import {LcpRegion} from "../../../models/lcpRegion";
+import {Tenant} from "../../../models/tenant";
+import {generalReducer} from "./general.reducers";
+import {
+  ChangeInstanceCounterAction,
+  RemoveInstanceAction,
+  DuplicateBulkInstancesAction,
+  GeneralActions,
+  UpdateAicZonesAction,
+  UpdateCategoryParametersAction,
+  UpdateProductFamiliesAction,
+  UpdateServiceTypesAction,
+  UpdateSubscribersAction,
+  UpdateUserIdAction, UpdateNetworkCollectionFunction,
+} from "./general.actions";
+import {SelectOption} from "../../../models/selectOption";
+import {ServiceType} from "../../../models/serviceType";
+import {ITreeNode} from "angular-tree-component/dist/defs/api";
+import {VnfInstance} from "../../../models/vnfInstance";
+
+describe('generalReducer', () => {
+  test('#UPDATE_LCP_REGIONS_AND_TENANTS : should update lcp region and tenants', () => {
+    let lcpRegionsAndTenantsObj = [
+      {
+        lcpRegionList : [
+          new LcpRegion(
+            'cloudRegionID',
+            'cloudRegionID (cloudOwner)',
+            true,
+            'cloudOwner'
+          )
+        ],
+        lcpRegionsTenantsMap : {
+          "lcpRegion" : [new Tenant({
+            "tenantID" : "tenantID",
+            "tenantName" : "tenantName",
+            "is-permitted" : true
+          })]
+        }
+      }
+    ];
+    let lcpRegionsAndTenantsState = generalReducer(<any>{serviceInstance : {}},
+      <any>{
+        type: GeneralActions.UPDATE_LCP_REGIONS_AND_TENANTS,
+        lcpRegionsAndTenants : lcpRegionsAndTenantsObj
+      })['lcpRegionsAndTenants'];
+
+    expect(lcpRegionsAndTenantsState).toBeDefined();
+  });
+
+  test('#UPDATE_SUBSCRIBERS : should update subscribers', () => {
+    let subscribersList = [
+      new SelectOption({
+        id : 'id',
+        name : 'name',
+        isPermitted : false
+      })
+    ];
+    let subscribersState = generalReducer(<any>
+        {
+          serviceInstance : {}
+        },
+      <UpdateSubscribersAction>{
+        type: GeneralActions.UPDATE_SUBSCRIBERS,
+        subscribers : subscribersList
+      })['subscribers'];
+
+    expect(subscribersState).toBeDefined();
+    expect(subscribersState[0].id).toEqual(subscribersList[0].id);
+    expect(subscribersState[0].isPermitted).toEqual(subscribersList[0].isPermitted);
+    expect(subscribersState[0].name).toEqual(subscribersList[0].name);
+  });
+
+  test('#UPDATE_PRODUCT_FAMILIES : should update product families', () => {
+    let productFamiliesObj = [
+      new SelectOption({
+        id : 'id',
+        name : 'name',
+        isPermitted : false
+      })
+    ];
+    let productFamiliesState = generalReducer(<any>{serviceInstance : {}},
+      <UpdateProductFamiliesAction>{
+        type: GeneralActions.UPDATE_PRODUCT_FAMILIES,
+        productFamilies : productFamiliesObj
+      })['productFamilies'];
+
+    expect(productFamiliesState).toBeDefined();
+    expect(productFamiliesState[0].id).toEqual(productFamiliesObj[0].id);
+    expect(productFamiliesState[0].isPermitted).toEqual(productFamiliesObj[0].isPermitted);
+    expect(productFamiliesState[0].name).toEqual(productFamiliesObj[0].name);
+  });
+
+  test('#UPDATE_AIC_ZONES : should update aic zones', () => {
+    let aicZonesObj = [
+      new SelectOption({
+        id : 'id',
+        name : 'name',
+        isPermitted : false
+      })
+    ];
+    let aicZonesState = generalReducer(<any>{serviceInstance : {}},
+      <UpdateAicZonesAction>{
+        type: GeneralActions.UPDATE_AIC_ZONES,
+        aicZones : aicZonesObj
+      })['aicZones'];
+
+    expect(aicZonesState).toBeDefined();
+    expect(aicZonesState[0].id).toEqual(aicZonesObj[0].id);
+    expect(aicZonesState[0].isPermitted).toEqual(aicZonesObj[0].isPermitted);
+    expect(aicZonesState[0].name).toEqual(aicZonesObj[0].name);
+  });
+
+  test('#UPDATE_SERVICE_TYPES : should update service types', () => {
+    const subscriberId = 'subscriberId';
+    let serviceTypesList : ServiceType[] = [
+      new ServiceType('id',{
+        'service-type' : 'name',
+        'is-permitted' : true
+      })
+    ];
+    let serviceTypesState = generalReducer(<any>
+        {
+          serviceTypes : {
+          }
+        },
+      <UpdateServiceTypesAction>{
+        type: GeneralActions.UPDATE_SERVICE_TYPES,
+        subscriberId : subscriberId,
+        serviceTypes : serviceTypesList
+      })['serviceTypes'][subscriberId];
+
+    expect(serviceTypesState).toBeDefined();
+    expect(serviceTypesState[0].id).toEqual(serviceTypesList[0].id);
+    expect(serviceTypesState[0].isPermitted).toEqual(serviceTypesList[0].isPermitted);
+    expect(serviceTypesState[0].name).toEqual(serviceTypesList[0].name);
+  });
+
+  test('#UPDATE_CATEGORY_PARAMETERS : should update category parameters', () => {
+    let list = [
+      new SelectOption({
+        id : 'id',
+        name : 'name',
+        isPermitted : false
+      })
+    ];
+
+    const categoryParametersObj = {
+      owningEntityList : list,
+      projectList : list,
+      lineOfBusinessList : list,
+      platformList : list
+    };
+
+    let categoryParametersState = generalReducer(<any>{serviceInstance : {}},
+      <UpdateCategoryParametersAction>{
+        type: GeneralActions.UPDATE_CATEGORY_PARAMETERS,
+        categoryParameters : categoryParametersObj
+      })['categoryParameters'];
+
+    expect(categoryParametersState).toBeDefined();
+    expect(categoryParametersState['owningEntityList'][0].id).toEqual(list[0].id);
+    expect(categoryParametersState['owningEntityList'][0].isPermitted).toEqual(list[0].isPermitted);
+    expect(categoryParametersState['owningEntityList'][0].name).toEqual(list[0].name);
+
+    expect(categoryParametersState['projectList'][0].id).toEqual(list[0].id);
+    expect(categoryParametersState['projectList'][0].isPermitted).toEqual(list[0].isPermitted);
+    expect(categoryParametersState['projectList'][0].name).toEqual(list[0].name);
+
+    expect(categoryParametersState['lineOfBusinessList'][0].id).toEqual(list[0].id);
+    expect(categoryParametersState['lineOfBusinessList'][0].isPermitted).toEqual(list[0].isPermitted);
+    expect(categoryParametersState['lineOfBusinessList'][0].name).toEqual(list[0].name);
+
+    expect(categoryParametersState['platformList'][0].id).toEqual(list[0].id);
+    expect(categoryParametersState['platformList'][0].isPermitted).toEqual(list[0].isPermitted);
+    expect(categoryParametersState['platformList'][0].name).toEqual(list[0].name);
+  });
+
+  test('#UPDATE_USER_ID : should update user id', () => {
+    const userId = 'userId';
+    let userState = generalReducer(<any>{serviceInstance : {}},
+      <UpdateUserIdAction>{
+        type: GeneralActions.UPDATE_USER_ID,
+        userId : userId
+      })['userId'];
+
+    expect(userState).toBeDefined();
+    expect(userState).toEqual(userId);
+  });
+
+  test('#DELETE_VNF_INSTANCE : should delete existing vnf', () => {
+    let state = generalReducer(<any>{serviceInstance : {
+          'serviceModelId' : {
+            vnfs : {
+              'modelName' : {}
+            }
+          }
+        }},
+      <RemoveInstanceAction>{
+        type: GeneralActions.REMOVE_INSTANCE,
+        modelName : 'modelName',
+        serviceModelId : 'serviceModelId',
+        storeKey : 'modelName',
+        node : {
+          data : {
+            type : 'VF'
+          }
+        }
+      });
+
+    expect(state).toBeDefined();
+    expect(state.serviceInstance[ 'serviceModelId'].vnfs['modelName']).not.toBeDefined();
+  });
+
+  test('#DELETE_VNF_INSTANCE : should delete existing network', () => {
+    let state = generalReducer(<any>{serviceInstance : {
+          'serviceModelId' : {
+            'networks' : {
+              'modelName' : {}
+            }
+          }
+        }},
+      <RemoveInstanceAction>{
+        type: GeneralActions.REMOVE_INSTANCE,
+        modelName : 'modelName',
+        serviceModelId : 'serviceModelId',
+        storeKey : 'modelName',
+        node : {
+          data : {
+            type : 'VL'
+          }
+        }
+      });
+
+    expect(state).toBeDefined();
+    expect(state.serviceInstance['serviceModelId'].networks['modelName']).not.toBeDefined();
+  });
+
+  test('#CHANGE_VNF_INSTANCE_COUNTER : should init existingVNFCounterMap to 1', () => {
+    let state = generalReducer(<any>{serviceInstance : {
+          'serviceModelId' : {
+            vnfs : {
+              'vnfName' : { }
+            },
+            existingVNFCounterMap : {
+
+            }
+          }
+        }},
+      <ChangeInstanceCounterAction>{
+        type: GeneralActions.CHANGE_INSTANCE_COUNTER,
+        serviceUUID : 'serviceModelId',
+        node : {data : {type : 'VF'}},
+        UUID : 'vnfUUID',
+        changeBy : 1
+      });
+
+    expect(state).toBeDefined();
+    expect(state.serviceInstance['serviceModelId'].existingVNFCounterMap['vnfUUID']).toEqual(1);
+  });
+
+  test('#CHANGE_VNF_INSTANCE_COUNTER : should increase existingVNFCounterMap to 2 if VNF exist', () => {
+    let state = generalReducer(<any>{serviceInstance : {
+          'serviceModelId' : {
+            vnfs : {
+              'vnfName' : { }
+            },
+            existingVNFCounterMap : {
+              'vnfUUID' : 1
+            }
+          }
+        }},
+      <ChangeInstanceCounterAction>{
+        type: GeneralActions.CHANGE_INSTANCE_COUNTER,
+        serviceUUID : 'serviceModelId',
+        UUID : 'vnfUUID',
+        node : {data : {type : 'VF'}},
+        changeBy : 1
+      });
+
+    expect(state).toBeDefined();
+    expect(state.serviceInstance['serviceModelId'].existingVNFCounterMap['vnfUUID']).toEqual(2);
+  });
+
+  test('#CHANGE_VNF_INSTANCE_COUNTER : should remove existingVNFCounterMap to 0 remove VNF', () => {
+
+    let state = generalReducer(<any>{serviceInstance : {
+          'serviceModelId' : {
+            vnfs : {
+              'vnfName' : { }
+            },
+            existingVNFCounterMap : {
+              'vnfUUID' : 1
+            }
+          }
+        }},
+      <ChangeInstanceCounterAction>{
+        type: GeneralActions.CHANGE_INSTANCE_COUNTER,
+        serviceUUID : 'serviceModelId',
+        UUID : 'vnfUUID',
+        node : {data : {type : 'VF'}},
+        changeBy : -1
+      });
+
+    expect(state).toBeDefined();
+    expect(state.serviceInstance['serviceModelId'].existingVNFCounterMap['vnfUUID']).toEqual(0);
+  });
+
+  test('#DUPLICATE_BULK_INSTANCES : should duplicate existing VNF/Network', ()=>{
+    let existingNames = {
+      'vnfOriginalName' : 1
+    };
+
+    let vnfInstance: VnfInstance = new VnfInstance();
+    vnfInstance.originalName = 'vnfOriginalName';
+    vnfInstance.vnfStoreKey = 'vnfStoreKey';
+
+    let cloneObjects = {
+      'vnfOriginalName' : vnfInstance,
+      'vnfOriginalName:0001' : vnfInstance,
+      'vnfOriginalName:0002' : vnfInstance,
+      'vnfOriginalName:0003' : vnfInstance
+    };
+
+    let node : ITreeNode = <any>{
+      data : {
+        serviceId : 'serviceModelId',
+        vnfStoreKey : 'vnfStoreKey',
+        type : 'VF'
+      }
+    };
+
+    let vnfsState = generalReducer(<any>{serviceInstance : {
+          'serviceModelId' : {
+            vnfs : {
+            },
+            existingVNFCounterMap : {}
+          }
+        }},
+      <DuplicateBulkInstancesAction>{
+        type: GeneralActions.DUPLICATE_BULK_INSTANCES,
+        serviceId: 'serviceModelId',
+        modelName: 'modelName',
+        originalName : 'modelName',
+        objects : cloneObjects,
+        existingNames: existingNames,
+        node : node
+      }).serviceInstance['serviceModelId'].vnfs;
+
+    expect(vnfsState).toBeDefined();
+    expect(Object.keys(vnfsState).length).toEqual(4);
+  });
+
+  test('#UPDATE_NETWORK_FUNCTION : should update network functions', ()=>{
+    let state = generalReducer(<any>{serviceInstance : {
+          'serviceModelId' : {
+            vnfs : {
+            },
+            existingVNFCounterMap : {}
+          }
+        }},
+      <UpdateNetworkCollectionFunction>{
+        type: GeneralActions.UPDATE_NETWORK_FUNCTION,
+        network_function : {
+          results : []
+        },
+        networksAccordingToNetworkCollection : "networksAccordingToNetworkCollection"
+      });
+
+    expect(state).toBeDefined();
+    expect(state['networkFunctions']).toBeDefined();
+  });
+});
+
+
+
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/general/general.reducers.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/general/general.reducers.ts
new file mode 100644
index 000000000..8ee47331f
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/general/general.reducers.ts
@@ -0,0 +1,147 @@
+import {Action} from "redux";
+import {
+  ChangeInstanceCounterAction, RemoveInstanceAction, DuplicateBulkInstancesAction,
+  GeneralActions,
+  UpdateAicZonesAction, UpdateCategoryParametersAction,
+  UpdateLcpRegionsAndTenantsAction, UpdateNetworkCollectionFunction,
+  UpdateProductFamiliesAction, UpdateServiceTypesAction,
+  UpdateSubscribersAction, UpdateUserIdAction
+} from "./general.actions";
+import {TypeNodeInformation} from "../../../../drawingBoard/service-planning/typeNodeInformation.model";
+import * as _ from "lodash";
+import {ITreeNode} from "angular-tree-component/dist/defs/api";
+import {ServiceInstance} from "../../../models/serviceInstance";
+import {ServiceState} from "../main.reducer";
+
+export function generalReducer(state: ServiceState, action: Action) : ServiceState {
+  switch (action.type) {
+    case GeneralActions.UPDATE_LCP_REGIONS_AND_TENANTS: {
+      Object.assign(state, (<UpdateLcpRegionsAndTenantsAction>action));
+      return Object.assign({}, state);
+    }
+    case GeneralActions.UPDATE_SUBSCRIBERS: {
+      Object.assign(state, (<UpdateSubscribersAction>action));
+      return Object.assign({}, state);
+    }
+    case GeneralActions.UPDATE_AIC_ZONES: {
+      Object.assign(state, (<UpdateAicZonesAction>action));
+      return Object.assign({}, state);
+    }
+    case GeneralActions.UPDATE_PRODUCT_FAMILIES: {
+      Object.assign(state, (<UpdateProductFamiliesAction>action));
+      return Object.assign({}, state);
+    }
+    case GeneralActions.UPDATE_NETWORK_FUNCTION: {
+      const networkFunctionReduxObj = state['networkFunctions'] == undefined ? {} : state['networkFunctions'];
+      networkFunctionReduxObj[(<UpdateNetworkCollectionFunction>action).network_function] = (<UpdateNetworkCollectionFunction>action).networksAccordingToNetworkCollection;
+      Object.assign(state, {'networkFunctions': networkFunctionReduxObj});
+      return Object.assign({}, state);
+    }
+    case GeneralActions.UPDATE_SERVICE_TYPES: {
+      state.serviceTypes[(<UpdateServiceTypesAction>action).subscriberId] = (<UpdateServiceTypesAction>action).serviceTypes;
+      return Object.assign({}, state);
+    }
+    case GeneralActions.UPDATE_CATEGORY_PARAMETERS: {
+      Object.assign(state, (<UpdateCategoryParametersAction>action));
+      return Object.assign({}, state);
+    }
+    case GeneralActions.UPDATE_USER_ID: {
+      const updateUserId: UpdateUserIdAction = <UpdateUserIdAction>action;
+      let newState = _.cloneDeep(state);
+      newState['userId'] = updateUserId.userId;
+      return newState;
+    }
+    case GeneralActions.REMOVE_INSTANCE: {
+      const actionData = (<RemoveInstanceAction>action);
+      if (state.serviceInstance[actionData.serviceModelId]) {
+        const typeNodeInformation : TypeNodeInformation = new TypeNodeInformation(actionData.node);
+        updateIsMissingDataOnDelete(state, actionData.serviceModelId, actionData.storeKey, actionData.node);
+        updateUniqueNames(state.serviceInstance[actionData.serviceModelId][typeNodeInformation.hierarchyName][actionData.storeKey].instanceName, null, state.serviceInstance[actionData.serviceModelId]);
+        if(actionData.node.data.type === 'VF'){
+          _.forOwn(state.serviceInstance[actionData.serviceModelId][typeNodeInformation.hierarchyName][actionData.storeKey].vfModules, (vfModuleMap) => {
+            _.forOwn(vfModuleMap, (vfModuleInstance) => {
+              updateUniqueNames(vfModuleInstance.instanceName, null, state.serviceInstance[actionData.serviceModelId]);
+            })
+          });
+        }
+        delete state.serviceInstance[actionData.serviceModelId][typeNodeInformation.hierarchyName][actionData.storeKey];
+      }
+      return Object.assign({}, state);
+    }
+
+    case GeneralActions.CHANGE_INSTANCE_COUNTER : {
+      const changeInstanceCounterAction = <ChangeInstanceCounterAction>action;
+      const typeNodeInformation : TypeNodeInformation =  new TypeNodeInformation(changeInstanceCounterAction.node);
+      let newState = _.cloneDeep(state);
+
+      let existing: number = getExistingCounter(newState, changeInstanceCounterAction.serviceUUID, changeInstanceCounterAction.UUID, typeNodeInformation);
+      newState.serviceInstance[changeInstanceCounterAction.serviceUUID][typeNodeInformation.existingMappingCounterName][changeInstanceCounterAction.UUID] = existing ? existing + changeInstanceCounterAction.changeBy : changeInstanceCounterAction.changeBy;
+      return newState;
+    }
+
+    case GeneralActions.DUPLICATE_BULK_INSTANCES : {
+      const createInstanceAction = <DuplicateBulkInstancesAction>action;
+      const typeNodeInformation : TypeNodeInformation =  new TypeNodeInformation(createInstanceAction.node);
+      const serviceId = createInstanceAction.serviceId;
+      const objects = createInstanceAction.objects;
+
+      let newState = _.cloneDeep(state);
+      newState.serviceInstance[serviceId].existingNames = createInstanceAction.existingNames;
+      newState.serviceInstance[serviceId][typeNodeInformation.hierarchyName] = Object.assign({}, newState.serviceInstance[serviceId][typeNodeInformation.hierarchyName], objects);
+      return newState;
+    }
+  }
+}
+
+const getExistingCounter = (state: any, serviceModelId: string, modelId: string, typeNodeInformation : TypeNodeInformation ) : number => {
+  const serviceExistingCounterMap = state.serviceInstance[serviceModelId][typeNodeInformation.existingMappingCounterName];
+  if(serviceExistingCounterMap && !_.isNil(serviceExistingCounterMap[modelId])){
+    return serviceExistingCounterMap[modelId];
+  }else {
+    return null;
+  }
+};
+
+const updateIsMissingDataOnDelete = (state: any, serviceModelId: string, storeKey: string, node: ITreeNode): void => {
+  const typeNodeInformation : TypeNodeInformation = new TypeNodeInformation(node);
+  let vnf = state.serviceInstance[serviceModelId][typeNodeInformation.hierarchyName][storeKey];
+  if(node.children){
+    _.forOwn(vnf.vfModules, (vfModules, vfModulesKey) => {
+      updateIsMissingDataOnDeleteVFModule(state, serviceModelId, storeKey, vfModulesKey);
+    });
+  }
+
+
+  let isMissingData: boolean = state.serviceInstance[serviceModelId][typeNodeInformation.hierarchyName][storeKey].isMissingData;
+  updateServiceValidationCounter(state, isMissingData, false, serviceModelId);
+};
+
+const updateUniqueNames = (oldName : string, newName : string, serviceInstance : ServiceInstance) : void => {
+  let existingNames = serviceInstance.existingNames;
+  if (!_.isNil(oldName) && oldName.toLowerCase() in existingNames) {
+    delete existingNames[oldName.toLowerCase()];
+  }
+  if(!_.isNil(newName)) {
+    existingNames[newName.toLowerCase()] = "";
+  }
+};
+
+const updateIsMissingDataOnDeleteVFModule = (state: any, serviceModelId: string, vnfStoreKey: string, vfModuleName): void => {
+  const vfModules = state.serviceInstance[serviceModelId].vnfs[vnfStoreKey].vfModules[vfModuleName];
+
+  _.forOwn(vfModules, (vfModuleInstance) => {
+    let isMissingData: boolean = vfModuleInstance.isMissingData;
+    updateServiceValidationCounter(state, isMissingData, false, serviceModelId);
+  });
+};
+
+const updateServiceValidationCounter = (newState: any, oldValidationState: boolean, newValidationState: boolean, serviceUuid: string) => {
+  if (oldValidationState && !newValidationState) {
+    newState.serviceInstance[serviceUuid].validationCounter--;
+  } else if (!oldValidationState && newValidationState) {
+    newState.serviceInstance[serviceUuid].validationCounter++;
+  }
+};
+
+
+
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/global/global.actions.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/global/global.actions.ts
new file mode 100644
index 000000000..609ec69f4
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/global/global.actions.ts
@@ -0,0 +1,37 @@
+import {Action, ActionCreator} from "redux";
+
+export enum GlobalActions {
+  UPDATE_NAME = 'UPDATE_NAME',
+  UPDATE_FLAGS = 'UPDATE_FLAGS',
+  UPDATE_DRAWING_BOARD_STATUS = 'UPDATE_DRAWING_BOARD_STATUS'
+}
+
+export interface UpdateGlobalAction extends Action {
+  name?: string;
+}
+
+export interface UpdateFlagsAction extends Action {
+  flags?: any;
+}
+
+export interface UpdateDrawingBoardStatusAction extends Action{
+  drawingBoardStatus?: any;
+}
+
+export const updateName: ActionCreator<UpdateGlobalAction> =
+  (name) => ({
+    type: GlobalActions.UPDATE_NAME,
+    name: name
+  });
+
+export const updateFlags: ActionCreator<UpdateFlagsAction> =
+  (flags) => ({
+    type: GlobalActions.UPDATE_FLAGS,
+    flags: flags
+  });
+
+export const updateDrawingBoardStatus: ActionCreator<UpdateDrawingBoardStatusAction> =
+  (drawingBoardStatus) => ({
+    type: GlobalActions.UPDATE_DRAWING_BOARD_STATUS,
+    drawingBoardStatus: drawingBoardStatus
+  });
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/global/global.reducers.spec.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/global/global.reducers.spec.ts
new file mode 100644
index 000000000..4fc80863a
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/global/global.reducers.spec.ts
@@ -0,0 +1,48 @@
+import {GlobalActions, UpdateFlagsAction, UpdateGlobalAction, UpdateDrawingBoardStatusAction} from "./global.actions";
+import {globalReducer} from "./global.reducers";
+
+
+describe('globalReducer', () => {
+
+  test('#UPDATE_FLAGS : should update global flags', () => {
+    const flags = {
+      'A' : 'A',
+      'B' : 'B',
+      'C' : 'C',
+      'D' : 'D'
+    };
+    let flagsState = globalReducer(<any>{global : {}},
+      <UpdateFlagsAction>{
+        type: GlobalActions.UPDATE_FLAGS,
+        flags : flags
+      }).flags;
+
+    expect(flagsState).toBeDefined();
+    expect(<any>flagsState).toEqual(<any>flags);
+  });
+
+  test('#UPDATE_NAME : should update global name', () => {
+    const name = 'name';
+    let globalState = globalReducer(<any>{global : {}},
+      <UpdateGlobalAction>{
+        type: GlobalActions.UPDATE_NAME,
+        name : name
+      });
+    expect(globalState).toBeDefined();
+    expect(globalState.name).toEqual(name);
+  });
+
+  test('#UPDATE_DRAWING_BOARD_STATUS : should update global drawing board status',  ()=> {
+    const drawingBoardStatus = 'EDIT';
+    let globalDrawingBoardState = globalReducer(<any>{global : {}},
+      <UpdateDrawingBoardStatusAction>{
+        type: GlobalActions.UPDATE_DRAWING_BOARD_STATUS,
+        drawingBoardStatus : drawingBoardStatus
+      });
+    expect(globalDrawingBoardState).toBeDefined();
+    expect(globalDrawingBoardState.drawingBoardStatus).toEqual(drawingBoardStatus);
+  });
+});
+
+
+
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/global/global.reducers.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/global/global.reducers.ts
new file mode 100644
index 000000000..f9e083414
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/global/global.reducers.ts
@@ -0,0 +1,29 @@
+import {Action} from 'redux';
+import {GlobalActions, UpdateFlagsAction, UpdateGlobalAction, UpdateDrawingBoardStatusAction} from "./global.actions";
+
+export interface GlobalState {
+  name : string;
+  flags : { [key: string]: boolean };
+  drawingBoardStatus : string;
+}
+
+const initialState: GlobalState = {
+  name : null,
+  flags : null,
+  drawingBoardStatus : null
+};
+
+export const globalReducer =
+  function (state: GlobalState = initialState, action: Action): GlobalState {
+    switch (action.type) {
+      case GlobalActions.UPDATE_NAME:
+        return Object.assign(state, state, (<UpdateGlobalAction>action));
+      case GlobalActions.UPDATE_FLAGS:
+        Object.assign(state, (<UpdateFlagsAction>action));
+        return Object.assign({}, state);
+      case GlobalActions.UPDATE_DRAWING_BOARD_STATUS:
+        return Object.assign(state, state, (<UpdateDrawingBoardStatusAction>action));
+      default:
+        return state;
+    }
+  };
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/main.reducer.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/main.reducer.ts
new file mode 100644
index 000000000..2166c81a0
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/main.reducer.ts
@@ -0,0 +1,67 @@
+import {LcpRegionsAndTenants} from "../../models/lcpRegionsAndTenants";
+import {CategoryParams} from "../../models/categoryParams";
+import {Action} from "redux";
+import {ServiceActions} from "./service/service.actions";
+import {GeneralActions} from "./general/general.actions";
+import {NetworkActions} from "./network/network.actions";
+import {VfModuleActions} from "./vfModule/vfModule.actions";
+import {VNFActions} from "./vnf/vnf.actions";
+import {vnfReducer} from "./vnf/vnf.reducers";
+import {generalReducer} from "./general/general.reducers";
+import {serviceReducer} from "./service/service.reducers";
+import {networkReducer} from "./network/network.reducers";
+import {vfModuleReducer} from "./vfModule/vfModule.reducers";
+import {ServiceInstance} from "../../models/serviceInstance";
+import {SelectOptionInterface} from "../../models/selectOption";
+import {ServiceType} from "../../models/serviceType";
+import {VnfGroupActions} from "./vnfGroup/vnfGroup.actions";
+import {vnfGroupReducer} from "./vnfGroup/vnfGroup.reducers";
+import {RelatedVnfActions} from "./relatedVnfMember/relatedVnfMember.actions";
+import {relatedVnfMemeberReducer} from "./relatedVnfMember/relatedVnfMember.reducers";
+
+export let initialState: ServiceState = {
+  serviceHierarchy: {},
+  serviceInstance: {},
+  lcpRegionsAndTenants: new LcpRegionsAndTenants(),
+  subscribers: null,
+  productFamilies: null,
+  serviceTypes: {},
+  aicZones: null,
+  categoryParameters: new CategoryParams()
+};
+
+
+export interface ServiceState {
+  serviceHierarchy: any;
+  serviceInstance: { [uuid: string]: ServiceInstance; };
+  lcpRegionsAndTenants: LcpRegionsAndTenants;
+  subscribers: SelectOptionInterface[];
+  productFamilies: any;
+  serviceTypes: { [subscriberId: string]: ServiceType[]; };
+  aicZones: SelectOptionInterface[];
+  categoryParameters: CategoryParams;
+}
+
+export const MainReducer = function (state: ServiceState = initialState, action: Action): ServiceState {
+  console.info("action name", action.type);
+  if(Object.values(ServiceActions).includes(action.type)){
+    return serviceReducer(state, action);
+  }else if (Object.values(GeneralActions).includes(action.type)){
+    return generalReducer(state, action);
+  }else if (Object.values(NetworkActions).includes(action.type)){
+    return networkReducer(state, action);
+  }else if (Object.values(VfModuleActions).includes(action.type)){
+    return vfModuleReducer(state, action);
+  }else if (Object.values(VNFActions).includes(action.type)){
+    return vnfReducer(state, action);
+  }else if (Object.values(VnfGroupActions).includes(action.type)){
+    return vnfGroupReducer(state, action);
+  }else if(Object.values(RelatedVnfActions).includes(action.type)){
+    return relatedVnfMemeberReducer(state, action);
+  } else {
+    return Object.assign({}, state);
+  }
+};
+
+
+
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/network/network.actions.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/network/network.actions.ts
new file mode 100644
index 000000000..c90d8eb3d
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/network/network.actions.ts
@@ -0,0 +1,94 @@
+import {Action, ActionCreator} from "redux";
+import {NetworkInstance} from "../../../models/networkInstance";
+
+export enum NetworkActions {
+  UPDATE_NETWORK_INSTANCE = "UPDATE_NETWORK_INSTANCE",
+  UPDATE_NETWORK_FUNCTION  = 'UPDATE_NETWORK_FUNCTION',
+  CREATE_NETWORK_INSTANCE = 'CREATE_NETWORK_INSTANCE',
+  DELETE_ACTION_NETWORK_INSTANCE = "DELETE_ACTION_NETWORK_INSTANCE",
+  UNDO_DELETE_ACTION_NETWORK_INSTANCE = "UNDO_DELETE_ACTION_NETWORK_INSTANCE",
+  UPDATE_NETWORK_POSITION = "UPDATE_NETWORK_POSITION"
+
+}
+
+
+export interface UpdateNetworkPosition extends Action {
+  node: any,
+  instanceId : string,
+  networkStoreKey?: string;
+}
+
+export interface UpdateNetworkInstanceAction extends Action {
+  networkInstance?: NetworkInstance;
+  networkModelName?: string;
+  serviceUuid?: string;
+  networkStoreKey?:string;
+}
+
+export interface UpdateNetworkCollectionFunction extends Action {
+  networksAccordingToNetworkCollection: any;
+  network_function: any;
+}
+
+export interface CreateNetworkInstanceAction extends Action {
+  networkInstance?: NetworkInstance;
+  networkModelName?: string;
+  serviceUuid?: string;
+  networkStoreKey?:string;
+}
+
+export interface DeleteActionNetworkInstanceAction extends Action {
+  networkStoreKey: string;
+  serviceId?: string;
+}
+
+export interface UndoDeleteActionNetworkInstanceAction extends Action {
+  networkStoreKey: string;
+  serviceId?: string;
+}
+
+export const updateNetworkInstance: ActionCreator<UpdateNetworkInstanceAction> = (networkInstance, networkfModelName, serviceUuid, networkStoreKey) => ({
+  type: NetworkActions.UPDATE_NETWORK_INSTANCE,
+  networkInstance: networkInstance,
+  networkModelName: networkfModelName,
+  serviceUuid: serviceUuid,
+  networkStoreKey : networkStoreKey
+});
+
+
+export const updateNetworkCollectionFunction: ActionCreator<UpdateNetworkCollectionFunction> = (ncf, networksAccordingToNetworkCollection) => ({
+  type: NetworkActions.UPDATE_NETWORK_FUNCTION,
+  networksAccordingToNetworkCollection: networksAccordingToNetworkCollection["results"],
+  network_function: ncf
+});
+
+export const createNetworkInstance: ActionCreator<CreateNetworkInstanceAction> = (networkInstance, networkModelName, serviceUuid, networkStoreKey) => ({
+  type: NetworkActions.CREATE_NETWORK_INSTANCE,
+  networkInstance: networkInstance,
+  networkModelName: networkModelName,
+  serviceUuid: serviceUuid,
+  networkStoreKey : networkStoreKey
+});
+
+
+export const deleteActionNetworkInstance: ActionCreator<DeleteActionNetworkInstanceAction> = (networkStoreKey, serviceId) => ({
+  type: NetworkActions.DELETE_ACTION_NETWORK_INSTANCE,
+  networkStoreKey: networkStoreKey,
+  serviceId: serviceId
+});
+
+export const undoDeleteActionNetworkInstance: ActionCreator<UndoDeleteActionNetworkInstanceAction> = (networkStoreKey, serviceId) => ({
+  type: NetworkActions.UNDO_DELETE_ACTION_NETWORK_INSTANCE,
+  networkStoreKey: networkStoreKey,
+  serviceId: serviceId
+});
+
+
+export const updateNetworkPosition: ActionCreator<UpdateNetworkPosition> = (node, instanceId, networkStoreKey) => ({
+  type: NetworkActions.UPDATE_NETWORK_POSITION,
+  node: node,
+  instanceId: instanceId,
+  networkStoreKey : networkStoreKey
+});
+
+
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/network/network.reducers.spec.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/network/network.reducers.spec.ts
new file mode 100644
index 000000000..ba41ad6e6
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/network/network.reducers.spec.ts
@@ -0,0 +1,114 @@
+import {networkReducer} from "./network.reducers";
+import {
+  CreateNetworkInstanceAction, DeleteActionNetworkInstanceAction,
+  NetworkActions, UndoDeleteActionNetworkInstanceAction,
+  UpdateNetworkCollectionFunction,
+  UpdateNetworkInstanceAction
+} from "./network.actions";
+import {NetworkInstance} from "../../../models/networkInstance";
+import {ServiceInstanceActions} from "../../../models/serviceInstanceActions";
+
+
+describe('networkReducer', () => {
+  test('#CREATE_SERVICE_INSTANCE', () => {
+    let networkInstance: NetworkInstance = new NetworkInstance();
+    networkInstance.isMissingData = false;
+    networkInstance.instanceName = 'instanceName';
+    let networkState = networkReducer(<any>{serviceInstance : {
+          'serviceModelId' : {
+            networks : {
+              'networkStoreKey' : {
+                isMissingData : true
+              }
+            }
+          }
+        }},
+      <UpdateNetworkInstanceAction>{
+        type: NetworkActions.UPDATE_NETWORK_INSTANCE,
+        networkInstance : new NetworkInstance(),
+        networkStoreKey : 'networkStoreKey',
+        networkModelName : 'networkModelName',
+        serviceUuid : 'serviceModelId'
+      }).serviceInstance['serviceModelId'].networks['networkStoreKey'];
+
+    expect(networkState).toBeDefined();
+    expect(networkState.isMissingData).toBeFalsy();
+  });
+
+  test('#CREATE_NETWORK_INSTANCE', () => {
+    let networkInstance: NetworkInstance = new NetworkInstance();
+    networkInstance.isMissingData = false;
+    networkInstance.instanceName = 'instanceName';
+    let networkState = networkReducer(<any>{serviceInstance : {
+          'serviceModelId' : {
+            networks : {}
+          }
+        }},
+      <CreateNetworkInstanceAction>{
+        type: NetworkActions.CREATE_NETWORK_INSTANCE,
+        networkInstance : new NetworkInstance(),
+        networkStoreKey : null,
+        networkModelName : 'networkModelName',
+        serviceUuid : 'serviceModelId'
+      }).serviceInstance['serviceModelId'].networks['networkModelName'];
+
+    expect(networkState).toBeDefined();
+    expect(networkState.isMissingData).toBeFalsy();
+  });
+
+  test('#UPDATE_NETWORK_FUNCTION', () => {
+    let state = networkReducer(<any>{serviceInstance : {}},
+      <UpdateNetworkCollectionFunction>{
+        type: NetworkActions.UPDATE_NETWORK_FUNCTION,
+        networksAccordingToNetworkCollection: 'networksAccordingToNetworkCollection',
+        network_function: 'network_function'
+      });
+
+    expect(state).toBeDefined();
+  });
+
+  test('#DELETE_ACTION_NETWORK_INSTANCE', () => {
+    let networkState = networkReducer(<any>{serviceInstance : {
+          'serviceModelId' : {
+            networks : {
+              'networkStoreKey' : {
+                isMissingData : true,
+                action : 'None'
+              }
+            }
+          }
+        }},
+      <DeleteActionNetworkInstanceAction>{
+        type: NetworkActions.DELETE_ACTION_NETWORK_INSTANCE,
+        networkStoreKey: 'networkStoreKey',
+        serviceId: 'serviceModelId'
+      }).serviceInstance['serviceModelId'].networks['networkStoreKey'];
+
+    expect(networkState).toBeDefined();
+    expect(networkState.action).toEqual(ServiceInstanceActions.None_Delete);
+  });
+
+  test('#UNDO_DELETE_ACTION_NETWORK_INSTANCE', () => {
+    let networkState = networkReducer(<any>{serviceInstance : {
+          'serviceModelId' : {
+            networks : {
+              'networkStoreKey' : {
+                isMissingData : true,
+                action : 'Update_Delete'
+              }
+            }
+          }
+        }},
+      <UndoDeleteActionNetworkInstanceAction>{
+        type: NetworkActions.UNDO_DELETE_ACTION_NETWORK_INSTANCE,
+        networkStoreKey: 'networkStoreKey',
+        serviceId: 'serviceModelId'
+      }).serviceInstance['serviceModelId'].networks['networkStoreKey'];
+
+    expect(networkState).toBeDefined();
+    expect(networkState.action).toEqual(ServiceInstanceActions.Update);
+  });
+});
+
+
+
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/network/network.reducers.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/network/network.reducers.ts
new file mode 100644
index 000000000..bcbbea57d
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/network/network.reducers.ts
@@ -0,0 +1,102 @@
+import {Action} from "redux";
+import * as _ from "lodash";
+import {NetworkInstance} from "../../../models/networkInstance";
+import {
+  CreateNetworkInstanceAction, DeleteActionNetworkInstanceAction,
+  NetworkActions, UndoDeleteActionNetworkInstanceAction,
+  UpdateNetworkCollectionFunction,
+  UpdateNetworkInstanceAction
+} from "./network.actions";
+import {ServiceInstance} from "../../../models/serviceInstance";
+import {calculateNextUniqueModelName} from "../vnf/vnf.reducers";
+import {ServiceState} from "../main.reducer";
+import {ServiceInstanceActions} from "../../../models/serviceInstanceActions";
+
+
+export function networkReducer(state: ServiceState , action: Action) : ServiceState {
+  switch (action.type) {
+    case NetworkActions.CREATE_NETWORK_INSTANCE: {
+      const updateNetworkInstanceAction = <CreateNetworkInstanceAction>action;
+      const serviceUuid = updateNetworkInstanceAction.serviceUuid;
+      let networkModelName = updateNetworkInstanceAction.networkModelName;
+
+
+      let newState = _.cloneDeep(state);
+
+      updateNetworkInstanceAction.networkInstance.originalName = networkModelName;
+      updateNetworkInstanceAction.networkModelName = calculateNextUniqueModelName(networkModelName, serviceUuid, newState, 'networks');
+
+      let networkInstance: NetworkInstance = newState.serviceInstance[serviceUuid].networks[networkModelName];
+      networkInstance = new NetworkInstance();
+      updateNetworkInstanceAction.networkInstance.networkStoreKey = updateNetworkInstanceAction.networkModelName;
+      updateNetworkInstanceAction.networkInstance.originalName = networkModelName;
+      networkInstance.originalName = updateNetworkInstanceAction.networkInstance.originalName;
+      networkInstance.networkStoreKey = updateNetworkInstanceAction.networkInstance.networkStoreKey;
+      updateServiceValidationCounter(newState, networkInstance['isMissingData'], updateNetworkInstanceAction.networkInstance['isMissingData'], serviceUuid);
+
+      newState.serviceInstance[serviceUuid].networks[updateNetworkInstanceAction.networkModelName] = Object.assign(networkInstance, updateNetworkInstanceAction.networkInstance);
+      return newState;
+    }
+    case NetworkActions.UPDATE_NETWORK_INSTANCE: {
+      const updateNetworkInstanceAction = <UpdateNetworkInstanceAction>action;
+      const serviceUuid = updateNetworkInstanceAction.serviceUuid;
+      let networkStoreKey = updateNetworkInstanceAction.networkStoreKey;
+
+      let newState = _.cloneDeep(state);
+      let networkInstance: NetworkInstance = newState.serviceInstance[serviceUuid].networks[networkStoreKey];
+      updateUniqueNames(networkInstance? networkInstance.instanceName : null, updateNetworkInstanceAction.networkInstance.instanceName, newState.serviceInstance[serviceUuid]);
+
+      networkInstance = networkInstance || new NetworkInstance();
+      updateServiceValidationCounter(newState, networkInstance['isMissingData'], updateNetworkInstanceAction.networkInstance['isMissingData'], serviceUuid);
+
+      newState.serviceInstance[serviceUuid].networks[networkStoreKey] = Object.assign(networkInstance, updateNetworkInstanceAction.networkInstance);
+      return newState;
+    }
+    case NetworkActions.UPDATE_NETWORK_FUNCTION: {
+      let networkFunctionReduxObj = state['networkFunctions'] == undefined ? {} : state['networkFunctions'];
+      networkFunctionReduxObj[(<UpdateNetworkCollectionFunction>action).network_function] = (<UpdateNetworkCollectionFunction>action).networksAccordingToNetworkCollection;
+      Object.assign(state, {'networkFunctions': networkFunctionReduxObj});
+      return Object.assign({}, state);
+    }
+    case NetworkActions.DELETE_ACTION_NETWORK_INSTANCE : {
+      let newState = _.cloneDeep(state);
+      let network = newState.serviceInstance[(<DeleteActionNetworkInstanceAction>action).serviceId].networks[(<DeleteActionNetworkInstanceAction>action).networkStoreKey];
+      let oldAction = network.action;
+      if(oldAction === ServiceInstanceActions.None_Delete || oldAction === ServiceInstanceActions.Update_Delete) return newState;
+      newState.serviceInstance[(<DeleteActionNetworkInstanceAction>action).serviceId].networks[(<DeleteActionNetworkInstanceAction>action).networkStoreKey].action = (oldAction + '_Delete') as ServiceInstanceActions;
+      updateServiceValidationCounter(newState, network['isMissingData'], false , (<DeleteActionNetworkInstanceAction>action).serviceId);
+
+      return newState;
+    }
+
+    case NetworkActions.UNDO_DELETE_ACTION_NETWORK_INSTANCE : {
+      let newState = _.cloneDeep(state);
+      let network = newState.serviceInstance[(<UndoDeleteActionNetworkInstanceAction>action).serviceId].networks[(<UndoDeleteActionNetworkInstanceAction>action).networkStoreKey];
+      let oldState = network.action;
+      newState.serviceInstance[(<UndoDeleteActionNetworkInstanceAction>action).serviceId].networks[(<UndoDeleteActionNetworkInstanceAction>action).networkStoreKey].action = (oldState.split('_')[0]) as ServiceInstanceActions;
+      updateServiceValidationCounter(newState, network['isMissingData'], false , (<DeleteActionNetworkInstanceAction>action).serviceId);
+      return newState;
+    }
+  }
+}
+
+const updateUniqueNames = (oldName : string, newName : string, serviceInstance : ServiceInstance) : void => {
+  let existingNames = serviceInstance.existingNames;
+  if (!_.isNil(oldName) && oldName.toLowerCase() in existingNames) {
+    delete existingNames[oldName.toLowerCase()];
+  }
+  if(!_.isNil(newName)) {
+    existingNames[newName.toLowerCase()] = "";
+  }
+};
+
+
+const updateServiceValidationCounter = (newState: any, oldValidationState: boolean, newValidationState: boolean, serviceUuid: string) => {
+  if (oldValidationState && !newValidationState) {
+    newState.serviceInstance[serviceUuid].validationCounter--;
+  } else if (!oldValidationState && newValidationState) {
+    newState.serviceInstance[serviceUuid].validationCounter++;
+  }
+};
+
+
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/relatedVnfMember/relatedVnfMember.actions.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/relatedVnfMember/relatedVnfMember.actions.ts
new file mode 100644
index 000000000..faa7a52d3
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/relatedVnfMember/relatedVnfMember.actions.ts
@@ -0,0 +1,68 @@
+import {Action, ActionCreator} from "redux";
+
+export enum RelatedVnfActions {
+  CREATE_RELATED_VNF_MEMBER_INSTANCE = "CREATE_RELATED_VNF_MEMBER_INSTANCE",
+  REMOVE_RELATED_VNF_MEMBER_INSTANCE = "REMOVE_RELATED_VNF_MEMBER_INSTANCE",
+  DELETE_ACTION_RELATED_VNF_MEMBER_INSTANCE = "DELETE_ACTION_RELATED_VNF_MEMBER_INSTANCE",
+  UNDO_DELETE_ACTION_RELATED_VNF_MEMBER_INSTANCE = "UNDO_DELETE_ACTION_RELATED_VNF_MEMBER_INSTANCE"
+}
+
+export interface RemoveRelatedVnfMemebrInstance extends Action {
+  vnfGroupStoreKey: string;
+  relatedVnfMemeberStoreKey: string;
+  serviceId?: string;
+}
+
+export interface DeleteRelatedVnfMemebrInstanceAction extends Action {
+  vnfGroupStoreKey: string;
+  relatedVnfMemeberStoreKey: string;
+  serviceId?: string;
+}
+
+export interface DeleteActionRelatedVnfMemeberInstanceAction extends Action {
+  vnfGroupStoreKey: string;
+  relatedVnfMemeberStoreKey: string;
+  serviceId?: string;
+}
+
+export interface UndoDeleteActionRelatedVnfMemeberInstanceAction extends Action {
+  vnfGroupStoreKey: string;
+  relatedVnfMemeberStoreKey: string;
+  serviceId?: string;
+}
+
+export interface CreateRelatedVnfMemeberInstanceAction extends Action {
+  relatedVnfMember: any;
+  vnfGroupStoreKey: string;
+  serviceId?: string;
+}
+
+
+export const removeRelatedVnfMemberInstance: ActionCreator<RemoveRelatedVnfMemebrInstance> = (vnfGroupStoreKey, relatedVnfMemeberStoreKey, serviceId) => ({
+  type: RelatedVnfActions.REMOVE_RELATED_VNF_MEMBER_INSTANCE,
+  vnfGroupStoreKey: vnfGroupStoreKey,
+  relatedVnfMemeberStoreKey: relatedVnfMemeberStoreKey,
+  serviceId: serviceId
+});
+
+export const deleteActionRelatedVnfMemberInstance: ActionCreator<DeleteActionRelatedVnfMemeberInstanceAction> = (vnfGroupStoreKey, relatedVnfMemeberStoreKey, serviceId) => ({
+  type: RelatedVnfActions.DELETE_ACTION_RELATED_VNF_MEMBER_INSTANCE,
+  vnfGroupStoreKey: vnfGroupStoreKey,
+  relatedVnfMemeberStoreKey: relatedVnfMemeberStoreKey,
+  serviceId: serviceId
+});
+
+export const undoDeleteActionRelatedVnfMemberInstance: ActionCreator<UndoDeleteActionRelatedVnfMemeberInstanceAction> = (vnfGroupStoreKey, relatedVnfMemeberStoreKey, serviceId) => ({
+  type: RelatedVnfActions.UNDO_DELETE_ACTION_RELATED_VNF_MEMBER_INSTANCE,
+  vnfGroupStoreKey: vnfGroupStoreKey,
+  relatedVnfMemeberStoreKey: relatedVnfMemeberStoreKey,
+  serviceId: serviceId
+});
+
+
+export const createRelatedVnfMemberInstance: ActionCreator<CreateRelatedVnfMemeberInstanceAction> = (vnfGroupStoreKey, serviceId, relatedVnfMember) => ({
+  type: RelatedVnfActions.CREATE_RELATED_VNF_MEMBER_INSTANCE,
+  relatedVnfMember: relatedVnfMember,
+  vnfGroupStoreKey: vnfGroupStoreKey,
+  serviceId: serviceId
+});
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/relatedVnfMember/relatedVnfMember.reducers.spec.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/relatedVnfMember/relatedVnfMember.reducers.spec.ts
new file mode 100644
index 000000000..347957480
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/relatedVnfMember/relatedVnfMember.reducers.spec.ts
@@ -0,0 +1,153 @@
+import {relatedVnfMemeberReducer} from "./relatedVnfMember.reducers";
+import {
+  CreateRelatedVnfMemeberInstanceAction,
+  DeleteActionRelatedVnfMemeberInstanceAction,
+  RelatedVnfActions,
+  UndoDeleteActionRelatedVnfMemeberInstanceAction
+} from "./relatedVnfMember.actions";
+import {ServiceInstanceActions} from "../../../models/serviceInstanceActions";
+
+
+describe('relatedVnfMemberReducer', () => {
+
+  test('#DELETE_ACTION_RELATED_VNF_MEMBER_INSTANCE should change action to delete',() => {
+    const serviceUuid: string = 'serviceUuid';
+    const actionName: ServiceInstanceActions = ServiceInstanceActions.None;
+
+    let service = relatedVnfMemeberReducer(<any>{
+      serviceInstance: {
+        'serviceUuid': {
+          'vnfGroups' : {
+            'vnfGroupStoreKey' : {
+              'vnfs' : {
+                'vnfStoreKey1' : {
+                  'action' : actionName
+                }
+              }
+            }
+
+          }
+        }
+      }
+    }, <DeleteActionRelatedVnfMemeberInstanceAction>{
+      type: RelatedVnfActions.DELETE_ACTION_RELATED_VNF_MEMBER_INSTANCE,
+      vnfGroupStoreKey: 'vnfGroupStoreKey',
+      relatedVnfMemeberStoreKey : 'vnfStoreKey1',
+      serviceId : 'serviceUuid'
+    });
+
+    expect(service.serviceInstance[serviceUuid].vnfGroups['vnfGroupStoreKey']['vnfs']['vnfStoreKey1'].action).toEqual('None_Delete');
+  });
+
+  test('#UNDO_DELETE_ACTION_RELATED_VNF_MEMBER_INSTANCE should undo change action to delete', () => {
+    const serviceUuid: string = 'serviceUuid';
+    const actionName: ServiceInstanceActions = ServiceInstanceActions.None_Delete;
+
+    let service = relatedVnfMemeberReducer(<any>{
+      serviceInstance: {
+        'serviceUuid': {
+          'vnfGroups' : {
+            'vnfGroupStoreKey' : {
+              'vnfs' : {
+                'vnfStoreKey1' : {
+                  'action' : actionName
+                }
+              }
+            }
+
+          }
+        }
+      }
+    }, <UndoDeleteActionRelatedVnfMemeberInstanceAction>{
+      type: RelatedVnfActions.UNDO_DELETE_ACTION_RELATED_VNF_MEMBER_INSTANCE,
+      vnfGroupStoreKey: 'vnfGroupStoreKey',
+      relatedVnfMemeberStoreKey : 'vnfStoreKey1',
+      serviceId : 'serviceUuid'
+    });
+
+    expect(service.serviceInstance[serviceUuid].vnfGroups['vnfGroupStoreKey']['vnfs']['vnfStoreKey1'].action).toEqual('None');
+  });
+
+  test('#REMOVE_RELATED_VNF_MEMBER_INSTANCE should remove instance', () => {
+    const serviceUuid: string = 'serviceUuid';
+    const actionName: ServiceInstanceActions = ServiceInstanceActions.None_Delete;
+
+    let service = relatedVnfMemeberReducer(<any>{
+      serviceInstance: {
+        'serviceUuid': {
+          'vnfGroups' : {
+            'vnfGroupStoreKey' : {
+              'vnfs' : {
+                'vnfStoreKey1' : {
+                  'action' : actionName
+                }
+              }
+            }
+
+          }
+        }
+      }
+    }, <UndoDeleteActionRelatedVnfMemeberInstanceAction>{
+      type: RelatedVnfActions.UNDO_DELETE_ACTION_RELATED_VNF_MEMBER_INSTANCE,
+      vnfGroupStoreKey: 'vnfGroupStoreKey',
+      relatedVnfMemeberStoreKey : 'vnfStoreKey1',
+      serviceId : 'serviceUuid'
+    });
+
+    expect(service.serviceInstance[serviceUuid].vnfGroups['vnfGroupStoreKey']['vnfs']['vnfStoreKey1'].action).toEqual('None');
+  });
+
+  test('#CREATE_RELATED_VNF_MEMBER_INSTANCE should add new relatedVNF instance', () => {
+    const serviceUuid: string = 'serviceUuid';
+    const actionName: ServiceInstanceActions = ServiceInstanceActions.None_Delete;
+    let relatedVnfMember =  {
+      "instanceName":"VNF1_INSTANCE_NAME",
+      "instanceId":"VNF1_INSTANCE_ID",
+      "orchStatus":null,
+      "productFamilyId":null,
+      "lcpCloudRegionId":"mtn23b",
+      "tenantId":"3e9a20a3e89e45f884e09df0cc2d2d2a",
+      "tenantName":"APPC-24595-T-IST-02C",
+      "modelInfo":{
+        "modelInvariantId":"vnf-instance-model-invariant-id",
+        "modelVersionId":"7a6ee536-f052-46fa-aa7e-2fca9d674c44",
+        "modelVersion":"2.0",
+        "modelName":"vf_vEPDG",
+        "modelType":"vnf"
+      },
+      "instanceType":"VNF1_INSTANCE_TYPE",
+      "provStatus":null,
+      "inMaint":false,
+      "uuid":"7a6ee536-f052-46fa-aa7e-2fca9d674c44",
+      "originalName":null,
+      "legacyRegion":null,
+      "lineOfBusiness":null,
+      "platformName":null,
+      "trackById":"7a6ee536-f052-46fa-aa7e-2fca9d674c44:002",
+      "serviceInstanceId":"service-instance-id1",
+      "serviceInstanceName":"service-instance-name"
+    };
+
+    let service = relatedVnfMemeberReducer(<any>{
+      serviceInstance: {
+        'serviceUuid': {
+          'vnfGroups' : {
+            'vnfGroupStoreKey' : { }
+          }
+        }
+      }
+    }, <CreateRelatedVnfMemeberInstanceAction>{
+      type: RelatedVnfActions.CREATE_RELATED_VNF_MEMBER_INSTANCE,
+      relatedVnfMember: relatedVnfMember,
+      vnfGroupStoreKey: 'vnfGroupStoreKey',
+      serviceId: serviceUuid
+    });
+
+    expect(service.serviceInstance[serviceUuid].vnfGroups['vnfGroupStoreKey']['vnfs']['VNF1_INSTANCE_ID'].action).toEqual('Create');
+    expect(service.serviceInstance[serviceUuid].vnfGroups['vnfGroupStoreKey']['vnfs']['VNF1_INSTANCE_ID'].instanceId).toEqual('VNF1_INSTANCE_ID');
+  });
+
+});
+
+
+
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/relatedVnfMember/relatedVnfMember.reducers.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/relatedVnfMember/relatedVnfMember.reducers.ts
new file mode 100644
index 000000000..250f934be
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/relatedVnfMember/relatedVnfMember.reducers.ts
@@ -0,0 +1,58 @@
+import {Action} from "redux";
+import * as _ from "lodash";
+import {ServiceState} from "../main.reducer";
+import {ServiceInstanceActions} from "../../../models/serviceInstanceActions";
+import {
+  CreateRelatedVnfMemeberInstanceAction,
+  DeleteActionRelatedVnfMemeberInstanceAction, DeleteRelatedVnfMemebrInstanceAction,
+  RelatedVnfActions,
+  UndoDeleteActionRelatedVnfMemeberInstanceAction
+} from "./relatedVnfMember.actions";
+
+export function relatedVnfMemeberReducer(state: ServiceState, action: Action): ServiceState {
+  switch (action.type) {
+
+    case RelatedVnfActions.DELETE_ACTION_RELATED_VNF_MEMBER_INSTANCE : {
+      let newState = _.cloneDeep(state);
+      let relatedVnfMember = newState.serviceInstance[(<DeleteActionRelatedVnfMemeberInstanceAction>action).serviceId].vnfGroups[(<DeleteActionRelatedVnfMemeberInstanceAction>action).vnfGroupStoreKey]['vnfs'][(<DeleteActionRelatedVnfMemeberInstanceAction>action).relatedVnfMemeberStoreKey];
+      let oldAction = relatedVnfMember.action;
+      if(oldAction === ServiceInstanceActions.None_Delete || oldAction === ServiceInstanceActions.Update_Delete) return newState;
+      newState.serviceInstance[(<DeleteActionRelatedVnfMemeberInstanceAction>action).serviceId].vnfGroups[(<DeleteActionRelatedVnfMemeberInstanceAction>action).vnfGroupStoreKey]['vnfs'][(<DeleteActionRelatedVnfMemeberInstanceAction>action).relatedVnfMemeberStoreKey].action = (oldAction + '_Delete') as ServiceInstanceActions;
+      return newState;
+    }
+
+    case RelatedVnfActions.UNDO_DELETE_ACTION_RELATED_VNF_MEMBER_INSTANCE : {
+      let newState = _.cloneDeep(state);
+      let relatedVnfMember = newState.serviceInstance[(<UndoDeleteActionRelatedVnfMemeberInstanceAction>action).serviceId].vnfGroups[(<UndoDeleteActionRelatedVnfMemeberInstanceAction>action).vnfGroupStoreKey]['vnfs'][(<UndoDeleteActionRelatedVnfMemeberInstanceAction>action).relatedVnfMemeberStoreKey];
+      let oldState = relatedVnfMember.action;
+      newState.serviceInstance[(<DeleteActionRelatedVnfMemeberInstanceAction>action).serviceId].vnfGroups[(<DeleteActionRelatedVnfMemeberInstanceAction>action).vnfGroupStoreKey]['vnfs'][(<DeleteActionRelatedVnfMemeberInstanceAction>action).relatedVnfMemeberStoreKey].action = (oldState.split('_')[0]) as ServiceInstanceActions;
+      return newState;
+    }
+
+    case RelatedVnfActions.REMOVE_RELATED_VNF_MEMBER_INSTANCE : {
+      let newState = _.cloneDeep(state);
+      delete newState.serviceInstance[(<DeleteRelatedVnfMemebrInstanceAction>action).serviceId].vnfGroups[(<DeleteRelatedVnfMemebrInstanceAction>action).vnfGroupStoreKey]['vnfs'][(<DeleteRelatedVnfMemebrInstanceAction>action).relatedVnfMemeberStoreKey];
+      return newState;
+    }
+
+    case RelatedVnfActions.CREATE_RELATED_VNF_MEMBER_INSTANCE : {
+      let newState = _.cloneDeep(state);
+      let relatedVnfMember = (<CreateRelatedVnfMemeberInstanceAction>action).relatedVnfMember;
+      relatedVnfMember['action'] = 'Create';
+      relatedVnfMember['vnfStoreKey'] = relatedVnfMember.instanceId;
+      relatedVnfMember['trackById'] = relatedVnfMember.instanceId;
+      relatedVnfMember['instanceName'] = relatedVnfMember.instanceName;
+      if(_.isNil(newState.serviceInstance[(<CreateRelatedVnfMemeberInstanceAction>action).serviceId].vnfGroups[(<CreateRelatedVnfMemeberInstanceAction>action).vnfGroupStoreKey]['vnfs'])){
+        newState.serviceInstance[(<CreateRelatedVnfMemeberInstanceAction>action).serviceId].vnfGroups[(<CreateRelatedVnfMemeberInstanceAction>action).vnfGroupStoreKey]['vnfs'] = {};
+      }
+      newState.serviceInstance[(<CreateRelatedVnfMemeberInstanceAction>action).serviceId].vnfGroups[(<CreateRelatedVnfMemeberInstanceAction>action).vnfGroupStoreKey]['vnfs'][(<CreateRelatedVnfMemeberInstanceAction>action).relatedVnfMember['instanceId']] = relatedVnfMember;
+      newState.serviceInstance[(<CreateRelatedVnfMemeberInstanceAction>action).serviceId].isDirty = true;
+      return newState;
+    }
+  }
+}
+
+
+
+
+
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/service/service.actions.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/service/service.actions.ts
new file mode 100644
index 000000000..e4e7e494e
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/service/service.actions.ts
@@ -0,0 +1,102 @@
+import {ServiceInstance} from "../../../models/serviceInstance";
+import {ServiceInstanceActions} from "../../../models/serviceInstanceActions";
+import {Action, ActionCreator} from "redux";
+
+export enum ServiceActions {
+  CREATE_SERVICE_INSTANCE = 'CREATE_SERVICE_INSTANCE',
+  UPDATE_SERVICE_INSTANCE = 'UPDATE_SERVICE_INSTANCE',
+  DELETE_ALL_SERVICE_INSTANCES = 'DELETE_ALL_SERVICE_INSTANCES',
+  UPDATE_MODEL  = 'UPDATE_MODEL',
+  ADD_SERVICE_ACTION = 'ADD_SERVICE_ACTION',
+  DELETE_ACTION_SERVICE_INSTANCE = "DELETE_ACTION_SERVICE_INSTANCE",
+  UNDO_DELETE_ACTION_SERVICE_INSTANCE = "UNDO_DELETE_ACTION_SERVICE_INSTANCE",
+  CHANGE_SERVICE_IS_DIRTY = "CHANGE_SERVICE_IS_DIRTY"
+}
+
+export interface CreateServiceInstanceAction extends Action {
+  serviceUuid?: string;
+  serviceInstance?: ServiceInstance;
+}
+
+export interface UpdateServiceInstanceAction extends Action {
+  serviceUuid?: string;
+  serviceInstance?: ServiceInstance;
+}
+
+export interface DeleteServiceInstanceAction extends Action {
+  serviceUuid?: string;
+}
+
+export interface DeleteServiceInstanceAction extends Action {
+  serviceUuid?: string;
+}
+
+export interface UpdateServiceModelAction extends Action {
+  serviceHierarchy?: any;
+}
+
+export interface AddServiceAction extends Action{
+  serviceUuid: string;
+  action: ServiceInstanceActions;
+}
+
+
+export interface DeleteActionServiceInstanceAction extends Action {
+  serviceId?: string;
+}
+
+export interface UndoDeleteActionServiceInstanceAction extends Action {
+  serviceId?: string;
+}
+
+export interface ChangeServiceDirty extends Action {
+  nodes: any[];
+  serviceId : string;
+}
+
+export const addServiceAction: ActionCreator<AddServiceAction> = (serviceUuid : string, actionName : ServiceInstanceActions) => ({
+  type: ServiceActions.ADD_SERVICE_ACTION,
+  serviceUuid: serviceUuid,
+  action : actionName
+});
+
+
+export const deleteAllServiceInstances: ActionCreator<DeleteServiceInstanceAction> = () => ({
+  type: ServiceActions.DELETE_ALL_SERVICE_INSTANCES
+});
+
+export const createServiceInstance: ActionCreator<CreateServiceInstanceAction> = (serviceInstance, serviceUuid) => ({
+  type: ServiceActions.CREATE_SERVICE_INSTANCE,
+  serviceInstance: serviceInstance,
+  serviceUuid: serviceUuid
+});
+
+export const updateServiceInstance: ActionCreator<UpdateServiceInstanceAction> = (serviceInstance, serviceUuid) => ({
+  type: ServiceActions.UPDATE_SERVICE_INSTANCE,
+  serviceInstance: serviceInstance,
+  serviceUuid: serviceUuid
+});
+
+export const updateModel: ActionCreator<UpdateServiceModelAction> = serviceHierarchy => ({
+  type: ServiceActions.UPDATE_MODEL,
+  serviceHierarchy: serviceHierarchy
+});
+
+
+export const deleteActionServiceInstance: ActionCreator<DeleteActionServiceInstanceAction> = (vnfStoreKey, serviceId) => ({
+  type: ServiceActions.DELETE_ACTION_SERVICE_INSTANCE,
+  serviceId: serviceId
+});
+
+export const undoDeleteActionServiceInstance: ActionCreator<UndoDeleteActionServiceInstanceAction> = (vnfStoreKey, serviceId) => ({
+  type: ServiceActions.UNDO_DELETE_ACTION_SERVICE_INSTANCE,
+  serviceId: serviceId
+});
+
+export const changeServiceIsDirty: ActionCreator<ChangeServiceDirty> = (nodes, serviceId) => ({
+  type: ServiceActions.CHANGE_SERVICE_IS_DIRTY,
+  nodes: nodes,
+  serviceId : serviceId
+});
+
+
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/service/service.reducers.spec.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/service/service.reducers.spec.ts
new file mode 100644
index 000000000..05fc008ad
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/service/service.reducers.spec.ts
@@ -0,0 +1,499 @@
+import {ServiceInstance} from "../../../models/serviceInstance";
+import {
+  AddServiceAction, ChangeServiceDirty,
+  DeleteServiceInstanceAction,
+  ServiceActions,
+  CreateServiceInstanceAction,
+  UpdateServiceModelAction, UpdateServiceInstanceAction
+} from "./service.actions";
+import {serviceReducer} from "./service.reducers";
+import {ServiceInstanceActions} from "../../../models/serviceInstanceActions";
+
+describe('serviceReducer', () => {
+
+  test('#UPDATE_SERVICE_INSTANCE should update exiting instance without change his child', () => {
+    const serviceUuid: string = 'serviceUuid';
+    const actionName: ServiceInstanceActions = ServiceInstanceActions.Create;
+
+    const elemntThatShouldNotOverideOnUpdateService = {
+      vnfs: {
+        "2017-388_ADIOD-vPE 0": {
+          "action": "Create",
+          "inMaint": false,
+          "rollbackOnFailure": "true",
+          "originalName": "2017-388_ADIOD-vPE 0",
+          "isMissingData": false,
+          "trackById": "eymgwlevh54",
+          "vfModules": {},
+          "vnfStoreKey": "2017-388_ADIOD-vPE 0",
+          "uuid": "afacccf6-397d-45d6-b5ae-94c39734b168",
+          "productFamilyId": "e433710f-9217-458d-a79d-1c7aff376d89",
+          "lcpCloudRegionId": "JANET25",
+          "tenantId": "092eb9e8e4b7412e8787dd091bc58e86",
+          "lineOfBusiness": "ONAP",
+          "platformName": "platform",
+          "modelInfo": {
+            "modelInvariantId": "72e465fe-71b1-4e7b-b5ed-9496118ff7a8",
+            "modelVersionId": "afacccf6-397d-45d6-b5ae-94c39734b168",
+            "modelName": "2017-388_ADIOD-vPE",
+            "modelVersion": "4.0",
+            "modelCustomizationId": "b3c76f73-eeb5-4fb6-9d31-72a889f1811c",
+            "modelCustomizationName": "2017-388_ADIOD-vPE 0",
+            "uuid": "afacccf6-397d-45d6-b5ae-94c39734b168",
+            "modelUniqueId": "b3c76f73-eeb5-4fb6-9d31-72a889f1811c"
+          },
+          "instanceName": "2017-388_ADIOD-vPEAjXzainstanceName",
+          "legacyRegion": "some legacy region",
+          "instanceParams": [
+            {
+              "vnf_config_template_version": "17.2",
+              "bandwidth_units": "Gbps",
+              "bandwidth": "10",
+              "AIC_CLLI": "ATLMY8GA",
+              "ASN": "AV_vPE",
+              "vnf_instance_name": "mtnj309me6"
+            }
+          ]
+        },
+        "2017-488_ADIOD-vPE 0": {
+          "action": "Create",
+          "inMaint": false,
+          "rollbackOnFailure": "true",
+          "originalName": "2017-488_ADIOD-vPE 0",
+          "isMissingData": false,
+          "trackById": "xr6o2782z7",
+          "vfModules": {
+            "2017488_adiodvpe0..2017488AdiodVpe..ADIOD_base_vPE_BV..module-0": {
+              "2017488_adiodvpe0..2017488AdiodVpe..ADIOD_base_vPE_BV..module-0wmkjw": {
+                "isMissingData": true,
+                "sdncPreReload": null,
+                "modelInfo": {
+                  "modelType": "VFmodule",
+                  "modelInvariantId": "b34833bb-6aa9-4ad6-a831-70b06367a091",
+                  "modelVersionId": "f8360508-3f17-4414-a2ed-6bc71161e8db",
+                  "modelName": "2017488AdiodVpe..ADIOD_base_vPE_BV..module-0",
+                  "modelVersion": "5",
+                  "modelCustomizationId": "a55961b2-2065-4ab0-a5b7-2fcee1c227e3",
+                  "modelCustomizationName": "2017488AdiodVpe..ADIOD_base_vPE_BV..module-0",
+                  "modelUniqueId": "a55961b2-2065-4ab0-a5b7-2fcee1c227e3"
+                },
+                "instanceParams": [
+                  {}
+                ],
+                "trackById": "a19sjb1ez2"
+              }
+            }
+          },
+          "vnfStoreKey": "2017-488_ADIOD-vPE 0",
+          "uuid": "69e09f68-8b63-4cc9-b9ff-860960b5db09",
+          "productFamilyId": "e433710f-9217-458d-a79d-1c7aff376d89",
+          "lcpCloudRegionId": "JANET25",
+          "tenantId": "092eb9e8e4b7412e8787dd091bc58e86",
+          "lineOfBusiness": "ONAP",
+          "platformName": "platform",
+          "modelInfo": {
+            "modelInvariantId": "72e465fe-71b1-4e7b-b5ed-9496118ff7a8",
+            "modelVersionId": "69e09f68-8b63-4cc9-b9ff-860960b5db09",
+            "modelName": "2017-488_ADIOD-vPE",
+            "modelVersion": "5.0",
+            "modelCustomizationId": "1da7b585-5e61-4993-b95e-8e6606c81e45",
+            "modelCustomizationName": "2017-488_ADIOD-vPE 0",
+            "uuid": "69e09f68-8b63-4cc9-b9ff-860960b5db09",
+            "modelUniqueId": "1da7b585-5e61-4993-b95e-8e6606c81e45"
+          },
+          "instanceName": "2017-488_ADIOD-vPEVNFinstancename",
+          "legacyRegion": "some legacy region",
+          "instanceParams": [
+            {
+              "vnf_config_template_version": "17.2",
+              "bandwidth_units": "Gbps",
+              "bandwidth": "10",
+              "AIC_CLLI": "ATLMY8GA",
+              "ASN": "AV_vPE",
+              "vnf_instance_name": "mtnj309me6"
+            }
+          ]
+        }
+      },
+      existingVNFCounterMap: {
+        "b3c76f73-eeb5-4fb6-9d31-72a889f1811c": 1,
+        "1da7b585-5e61-4993-b95e-8e6606c81e45": 1
+      },
+      existingVnfGroupCounterMap: {},
+      existingNetworksCounterMap: {},
+      optionalGroupMembersMap : {},
+      networks : {},
+      vnfGroups : {}
+    };
+
+
+    let service = serviceReducer(<any>{
+      "serviceInstance": {
+        "6b528779-44a3-4472-bdff-9cd15ec93450": {
+          "action": "Create",
+          "isDirty": true,
+          "vnfs": elemntThatShouldNotOverideOnUpdateService.vnfs,
+          "instanceParams": [
+            {
+              "2017488_adiodvpe0_ASN": "AV_vPE"
+            }
+          ],
+          "validationCounter": 1,
+          "existingNames": {
+            "ajxzainstancename": "",
+            "2017-488_adiod-vpevnfinstancename": "",
+            "2017-388_adiod-vpeajxzainstancename": ""
+          },
+          "existingVNFCounterMap": elemntThatShouldNotOverideOnUpdateService.existingVNFCounterMap,
+          "existingVnfGroupCounterMap": elemntThatShouldNotOverideOnUpdateService.existingVnfGroupCounterMap,
+          "existingNetworksCounterMap": elemntThatShouldNotOverideOnUpdateService.existingNetworksCounterMap,
+          "optionalGroupMembersMap":elemntThatShouldNotOverideOnUpdateService.optionalGroupMembersMap,
+          "networks": elemntThatShouldNotOverideOnUpdateService.networks,
+          "vnfGroups": elemntThatShouldNotOverideOnUpdateService.vnfGroups,
+          "bulkSize": "3",
+          "instanceName": "AjXzainstancename",
+          "globalSubscriberId": "e433710f-9217-458d-a79d-1c7aff376d89",
+          "subscriptionServiceType": "TYLER SILVIA",
+          "owningEntityId": "d61e6f2d-12fa-4cc2-91df-7c244011d6fc",
+          "productFamilyId": "e433710f-9217-458d-a79d-1c7aff376d89",
+          "lcpCloudRegionId": "hvf6",
+          "tenantId": "bae71557c5bb4d5aac6743a4e5f1d054",
+          "aicZoneId": "NFT1",
+          "projectName": "WATKINS",
+          "rollbackOnFailure": "true",
+          "aicZoneName": "NFTJSSSS-NFT1",
+          "owningEntityName": "WayneHolland",
+          "testApi": "VNF_API",
+          "tenantName": "AIN Web Tool-15-D-testalexandria",
+          "modelInfo": {
+            "modelInvariantId": "e49fbd11-e60c-4a8e-b4bf-30fbe8f4fcc0",
+            "modelVersionId": "6b528779-44a3-4472-bdff-9cd15ec93450",
+            "modelName": "action-data",
+            "modelVersion": "1.0",
+            "uuid": "6b528779-44a3-4472-bdff-9cd15ec93450",
+            "modelUniqueId": "6b528779-44a3-4472-bdff-9cd15ec93450"
+          },
+          "isALaCarte": false,
+          "name": "action-data",
+          "version": "1.0",
+          "description": "",
+          "category": "",
+          "uuid": "6b528779-44a3-4472-bdff-9cd15ec93450",
+          "invariantUuid": "e49fbd11-e60c-4a8e-b4bf-30fbe8f4fcc0",
+          "serviceType": "",
+          "serviceRole": "",
+          "vidNotions": {
+            "instantiationUI": "legacy",
+            "modelCategory": "other",
+            "viewEditUI": "legacy"
+          },
+          "isEcompGeneratedNaming": false,
+          "isMultiStepDesign": false
+        }
+      },
+    }, <UpdateServiceInstanceAction>{
+      type: ServiceActions.UPDATE_SERVICE_INSTANCE,
+      serviceUuid: "6b528779-44a3-4472-bdff-9cd15ec93450",
+      serviceInstance: <any>{
+        aicZoneId: "ATL53",
+        aicZoneName: "AAIATLTE-ATL53",
+        bulkSize: 1,
+        category: "",
+        description: "",
+        globalSubscriberId: "e433710f-9217-458d-a79d-1c7aff376d89",
+        instanceName: "yoav",
+        instanceParams: [{}],
+        invariantUuid: "e49fbd11-e60c-4a8e-b4bf-30fbe8f4fcc0",
+        isALaCarte: false,
+        isEcompGeneratedNaming: false,
+        isMultiStepDesign: false,
+        lcpCloudRegionId: "JANET25",
+        modelInfo: {
+          modelInvariantId: "e49fbd11-e60c-4a8e-b4bf-30fbe8f4fcc0",
+          modelVersionId: "6b528779-44a3-4472-bdff-9cd15ec93450",
+          modelName: "action-data",
+          modelVersion: "1.0"
+        },
+        name: "action-data",
+        owningEntityId: "d61e6f2d-12fa-4cc2-91df-7c244011d6fc",
+        owningEntityName: "WayneHolland",
+        productFamilyId: "d8a6ed93-251c-47ca-adc9-86671fd19f4c",
+        projectName: "WATKINS",
+        rollbackOnFailure: "true",
+        serviceRole: "",
+        serviceType: "",
+        subscriptionServiceType: "TYLER SILVIA",
+        tenantId: "092eb9e8e4b7412e8787dd091bc58e86",
+        tenantName: "USP-SIP-IC-24335-T-01",
+        testApi: "VNF_API",
+        uuid: "6b528779-44a3-4472-bdff-9cd15ec93450",
+        version: "1.0",
+        vidNotions: {instantiationUI: "legacy", modelCategory: "other", viewEditUI: "legacy"}
+      }
+    });
+    expect(service.serviceInstance["6b528779-44a3-4472-bdff-9cd15ec93450"]).toBeDefined();
+
+    for(const element in elemntThatShouldNotOverideOnUpdateService){
+      expect(service.serviceInstance["6b528779-44a3-4472-bdff-9cd15ec93450"][element]).toEqual(elemntThatShouldNotOverideOnUpdateService[element]);
+    }
+
+    expect(service.serviceInstance["6b528779-44a3-4472-bdff-9cd15ec93450"].aicZoneId).toEqual("ATL53");
+    expect(service.serviceInstance["6b528779-44a3-4472-bdff-9cd15ec93450"].owningEntityId).toEqual("d61e6f2d-12fa-4cc2-91df-7c244011d6fc");
+    expect(service.serviceInstance["6b528779-44a3-4472-bdff-9cd15ec93450"].owningEntityName).toEqual("WayneHolland");
+    expect(service.serviceInstance["6b528779-44a3-4472-bdff-9cd15ec93450"].productFamilyId).toEqual("d8a6ed93-251c-47ca-adc9-86671fd19f4c");
+    expect(service.serviceInstance["6b528779-44a3-4472-bdff-9cd15ec93450"].projectName).toEqual("WATKINS");
+    expect(service.serviceInstance["6b528779-44a3-4472-bdff-9cd15ec93450"].rollbackOnFailure).toEqual("true");
+    expect(service.serviceInstance["6b528779-44a3-4472-bdff-9cd15ec93450"].subscriptionServiceType).toEqual("TYLER SILVIA");
+    expect(service.serviceInstance["6b528779-44a3-4472-bdff-9cd15ec93450"].tenantId).toEqual("092eb9e8e4b7412e8787dd091bc58e86");
+
+  });
+
+  test('#ADD_SERVICE_ACTION should add action to the service', () => {
+    const serviceUuid: string = 'serviceUuid';
+    const actionName: ServiceInstanceActions = ServiceInstanceActions.Create;
+
+    let service = serviceReducer(<any>{
+      serviceInstance: {
+        'serviceUuid': {}
+      }
+    }, <AddServiceAction>{
+      type: ServiceActions.ADD_SERVICE_ACTION,
+      serviceUuid: 'serviceUuid',
+      action: actionName
+    });
+    expect(service.serviceInstance[serviceUuid]['action']).toEqual(actionName);
+  });
+
+  test('#UPDATE_SERVICE_INSTANCE', () => {
+    const serviceUuid: string = 'serviceUuid';
+
+    let serviceInstanceObject: ServiceInstance = <any>{
+      isDirty: false,
+      instanceName: 'instanceName',
+      isEcompGeneratedNaming: false,
+      globalSubscriberId: 'globalSubscriberId',
+      productFamilyId: 'productFamilyId',
+      subscriptionServiceType: 'subscriptionServiceType',
+      lcpCloudRegionId: 'lcpCloudRegionId',
+      tenantId: 'tenantId',
+      tenantName: 'tenantName',
+      aicZoneId: 'aicZoneId',
+      aicZoneName: 'aicZoneName',
+      projectName: 'projectName',
+      owningEntityId: 'owningEntityId',
+      owningEntityName: 'owningEntityName',
+      existingVnfGroupCounterMap: {},
+      existingVNFCounterMap: {},
+      existingNetworksCounterMap: {},
+      pause: false,
+      bulkSize: 1,
+      vnfs: {},
+      vnfGroups: {},
+      networks: {},
+      instanceParams: [],
+      rollbackOnFailure: false,
+      subscriberName: 'subscriberName',
+      validationCounter: 0,
+      existingNames: {},
+      action: ServiceInstanceActions.Create
+    };
+
+    let serviceState = serviceReducer(<any>{serviceInstance: {}},
+      <CreateServiceInstanceAction>{
+        type: ServiceActions.CREATE_SERVICE_INSTANCE,
+        serviceUuid: serviceUuid,
+        serviceInstance: serviceInstanceObject
+      }).serviceInstance[serviceUuid];
+
+    expect(serviceState.instanceName).toEqual(serviceInstanceObject.instanceName);
+    expect(serviceState.isEcompGeneratedNaming).toEqual(serviceInstanceObject.isEcompGeneratedNaming);
+    expect(serviceState.globalSubscriberId).toEqual(serviceInstanceObject.globalSubscriberId);
+    expect(serviceState.productFamilyId).toEqual(serviceInstanceObject.productFamilyId);
+    expect(serviceState.subscriptionServiceType).toEqual(serviceInstanceObject.subscriptionServiceType);
+    expect(serviceState.lcpCloudRegionId).toEqual(serviceInstanceObject.lcpCloudRegionId);
+    expect(serviceState.tenantId).toEqual(serviceInstanceObject.tenantId);
+    expect(serviceState.tenantName).toEqual(serviceInstanceObject.tenantName);
+    expect(serviceState.aicZoneId).toEqual(serviceInstanceObject.aicZoneId);
+    expect(serviceState.aicZoneName).toEqual(serviceInstanceObject.aicZoneName);
+    expect(serviceState.projectName).toEqual(serviceInstanceObject.projectName);
+    expect(serviceState.owningEntityId).toEqual(serviceInstanceObject.owningEntityId);
+    expect(serviceState.owningEntityName).toEqual(serviceInstanceObject.owningEntityName);
+    expect(serviceState.pause).toEqual(serviceInstanceObject.pause);
+    expect(serviceState.bulkSize).toEqual(serviceInstanceObject.bulkSize);
+    expect(serviceState.vnfs).toEqual(serviceInstanceObject.vnfs);
+    expect(serviceState.instanceParams).toEqual(serviceInstanceObject.instanceParams);
+    expect(serviceState.rollbackOnFailure).toEqual(serviceInstanceObject.rollbackOnFailure);
+    expect(serviceState.subscriberName).toEqual(serviceInstanceObject.subscriberName);
+  });
+
+
+  test('#DELETE_ALL_SERVICE_INSTANCES should delete all services', () => {
+    const state = serviceReducer(<any>{
+        serviceInstance: {
+          'service-1': {},
+          'service-2': {}
+        }
+      },
+      <CreateServiceInstanceAction>{
+        type: ServiceActions.DELETE_ALL_SERVICE_INSTANCES
+      });
+
+    expect(state.serviceInstance['service-1']).toBeUndefined();
+    expect(state.serviceInstance['service-2']).toBeUndefined();
+  });
+
+  test('#DELETE_SERVICE_INSTANCE should delete service', () => {
+    const state = serviceReducer(<any>{
+        serviceInstance: {
+          'service-1': {}
+        }
+      },
+      <DeleteServiceInstanceAction>{
+        type: ServiceActions.DELETE_ALL_SERVICE_INSTANCES
+      });
+
+    expect(state.serviceInstance['service-1']).toBeUndefined();
+  });
+
+  test('#UPDATE_MODEL should update service model ', () => {
+    const state = serviceReducer(<any>{
+        serviceHierarchy: {}
+      },
+      <UpdateServiceModelAction>{
+        type: ServiceActions.UPDATE_MODEL,
+        serviceHierarchy: {
+          service: {
+            uuid: 'uuid-1'
+          }
+        }
+      });
+
+    expect(state.serviceHierarchy['uuid-1'].service).toBeDefined();
+  });
+
+  test('#UPDATE_MODEL should update service model with vnfGroups ', () => {
+    const state = serviceReducer(<any>{
+        serviceHierarchy: {}
+      },
+      <UpdateServiceModelAction>{
+        type: ServiceActions.UPDATE_MODEL,
+        serviceHierarchy: {
+          service: {
+            uuid: 'uuid-1'
+          },
+          vnfs: {},
+          vnfGroups: {
+            'vnfGrouop_1': {
+              uuid: 'vnfGroup_uuid_1',
+              name: 'vnfGroup_name_1',
+              type: 'Group'
+            },
+            'vnfGrouop_2': {
+              uuid: 'vnfGroup_uuid_2',
+              name: 'vnfGroup_name_2',
+              type: 'Group'
+            }
+          }
+        }
+      });
+
+    expect(state.serviceHierarchy['uuid-1']).toBeDefined();
+    expect(state.serviceHierarchy['uuid-1'].vnfGroups['vnfGrouop_1']).toBeDefined();
+    expect(state.serviceHierarchy['uuid-1'].vnfGroups['vnfGrouop_2']).toBeDefined();
+  });
+
+  test('#CHANGE_SERVICE_IS_DIRTY should update service isDirty flag : service is not dirty ', () => {
+    const state = serviceReducer(<any>{
+        serviceInstance: {
+          'serviceId': {
+            action: ServiceInstanceActions.None,
+            'vnfs': {
+              'vnf1': {
+                action: ServiceInstanceActions.None
+              },
+              'vnf2': {
+                action: ServiceInstanceActions.None
+              }
+            }
+
+          }
+        }
+      },
+      <ChangeServiceDirty>{
+        type: ServiceActions.CHANGE_SERVICE_IS_DIRTY,
+        nodes: [
+          {
+            action: ServiceInstanceActions.None
+          },
+          {
+            action: ServiceInstanceActions.None
+          }],
+        serviceId: 'serviceId'
+
+      });
+
+    expect(state.serviceInstance['serviceId'].isDirty).toBeFalsy();
+  });
+
+  test('#CHANGE_SERVICE_IS_DIRTY should update service isDirty flag : service is dirty should return true', () => {
+    const state = serviceReducer(<any>{
+        serviceInstance: {
+          'serviceId': {
+            action: ServiceInstanceActions.Create
+
+          }
+        }
+      },
+      <ChangeServiceDirty>{
+        type: ServiceActions.CHANGE_SERVICE_IS_DIRTY,
+        nodes: [
+          {
+            action: ServiceInstanceActions.None
+          },
+          {
+            action: ServiceInstanceActions.None
+          }],
+        serviceId: 'serviceId'
+
+      });
+
+    expect(state.serviceInstance['serviceId'].isDirty).toBeTruthy();
+  });
+
+  test('#CHANGE_SERVICE_IS_DIRTY should update service isDirty flag : vnf is dirty ', () => {
+    const state = serviceReducer(<any>{
+        serviceInstance: {
+          'serviceId': {
+            action: ServiceInstanceActions.None,
+            'vnfs': {
+              'vnf1': {
+                action: ServiceInstanceActions.None
+              },
+              'vnf2': {
+                action: ServiceInstanceActions.Create
+              }
+            }
+
+          }
+        }
+      },
+      <ChangeServiceDirty>{
+        type: ServiceActions.CHANGE_SERVICE_IS_DIRTY,
+        nodes: [
+          {
+            action: ServiceInstanceActions.None
+          },
+          {
+            action: ServiceInstanceActions.Create
+          }],
+        serviceId: 'serviceId'
+
+      });
+
+    expect(state.serviceInstance['serviceId'].isDirty).toBeTruthy();
+  });
+
+});
+
+
+
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/service/service.reducers.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/service/service.reducers.ts
new file mode 100644
index 000000000..9d21d359c
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/service/service.reducers.ts
@@ -0,0 +1,107 @@
+import {Action} from "redux";
+import {
+  AddServiceAction,
+  ChangeServiceDirty,
+  ServiceActions,
+  CreateServiceInstanceAction,
+  UpdateServiceModelAction, UpdateServiceInstanceAction
+} from "./service.actions";
+import {ServiceInstance} from "../../../models/serviceInstance";
+import {ServiceState} from "../main.reducer";
+import {ServiceInstanceActions} from "../../../models/serviceInstanceActions";
+import * as _ from "lodash";
+
+export function serviceReducer(state: ServiceState, action: Action) : ServiceState{
+    switch (action.type) {
+      case ServiceActions.UPDATE_SERVICE_INSTANCE : {
+        let newState = _.cloneDeep(state);
+        const updateServiceInstanceAction = <UpdateServiceInstanceAction>action;
+        const uuid = updateServiceInstanceAction.serviceUuid;
+        const serviceInstance = updateServiceInstanceAction.serviceInstance;
+
+
+        updateUniqueNames(serviceInstance.instanceName, updateServiceInstanceAction.serviceInstance.instanceName, newState.serviceInstance[uuid]);
+
+        newState.serviceInstance[uuid] = _.merge(newState.serviceInstance[uuid], serviceInstance);
+        return newState;
+      }
+      case ServiceActions.CREATE_SERVICE_INSTANCE : {
+        const updateServiceInstanceAction = <CreateServiceInstanceAction>action;
+        const uuid = updateServiceInstanceAction.serviceUuid;
+        let newState = _.cloneDeep(state);
+
+        const serviceInstance: ServiceInstance =  new ServiceInstance();
+        const currentInstaceName = state.serviceInstance[uuid] ? serviceInstance.instanceName : null;
+
+        newState.serviceInstance[uuid] = Object.assign(serviceInstance, updateServiceInstanceAction.serviceInstance);
+        if (!_.isNil(updateServiceInstanceAction.serviceInstance)) {
+          updateUniqueNames(currentInstaceName, updateServiceInstanceAction.serviceInstance.instanceName, newState.serviceInstance[uuid]);
+        }
+        return newState;
+      }
+      case ServiceActions.DELETE_ALL_SERVICE_INSTANCES: {
+        if (state.serviceInstance) {
+          let newState = _.cloneDeep(state);
+          newState.serviceInstance = {};
+          return Object.assign({}, state, newState);
+        }
+        return Object.assign({}, state);
+      }
+      case ServiceActions.UPDATE_MODEL: {
+        let uuid = (<UpdateServiceModelAction>action).serviceHierarchy.service.uuid;
+        state.serviceHierarchy[uuid] = _.cloneDeep((<UpdateServiceModelAction>action).serviceHierarchy);
+        return Object.assign({}, state);
+      }
+      case ServiceActions.ADD_SERVICE_ACTION: {
+        const uuid: string = (<AddServiceAction>action).serviceUuid;
+        const actionToAdd: ServiceInstanceActions =  (<AddServiceAction>action).action;
+        state.serviceInstance[uuid].action =  actionToAdd;
+        return Object.assign({}, state);
+      }
+      case ServiceActions.CHANGE_SERVICE_IS_DIRTY : {
+        let newState = _.cloneDeep(state);
+        let serviceInstanceAction: ServiceInstanceActions = newState.serviceInstance[(<ChangeServiceDirty>action).serviceId].action;
+
+        if(serviceInstanceAction !== ServiceInstanceActions.None){
+          newState.serviceInstance[(<ChangeServiceDirty>action).serviceId].isDirty = true;
+          return newState;
+        }
+
+        const nodes =  (<ChangeServiceDirty>action).nodes;
+        for(let node of nodes){
+          const dirty = isDirty(node);
+          if(dirty) {
+            newState.serviceInstance[(<ChangeServiceDirty>action).serviceId].isDirty = true;
+            return newState;
+          }
+        }
+
+        newState.serviceInstance[(<ChangeServiceDirty>action).serviceId].isDirty = false;
+        return newState;
+      }
+    }
+}
+
+const isDirty = (node) : boolean => {
+  if(node.action !== ServiceInstanceActions.None) return true;
+  if(!_.isNil(node.children) && node.children.length > 0){
+      for(let child of node.children){
+        const dirty: boolean = isDirty(child);
+        if(dirty) return true;
+      }
+  }
+  return false;
+};
+
+const updateUniqueNames = (oldName : string, newName : string, serviceInstance : ServiceInstance) : void => {
+  let existingNames = serviceInstance.existingNames;
+  if (!_.isNil(oldName) && oldName.toLowerCase() in existingNames) {
+    delete existingNames[oldName.toLowerCase()];
+  }
+  if(!_.isNil(newName)) {
+    existingNames[newName.toLowerCase()] = "";
+  }
+};
+
+
+
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/vfModule/vfModule.actions.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/vfModule/vfModule.actions.ts
new file mode 100644
index 000000000..a3f0f4009
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/vfModule/vfModule.actions.ts
@@ -0,0 +1,105 @@
+import {Action, ActionCreator} from "redux";
+
+export enum VfModuleActions {
+  REMOVE_VNF_MODULE_INSTANCE = 'REMOVE_VNF_MODULE_INSTANCE',
+  CREATE_VF_MODULE = 'CREATE_VF_MODULE',
+  UPDATE_VF_MODULE = 'UPDATE_VF_MODULE',
+  DELETE_ACTION_VF_MODULE_INSTANCE = "DELETE_ACTION_VF_MODULE_INSTANCE",
+  UNDO_DELETE_ACTION_VF_MODULE_INSTANCE = "UNDO_DELETE_ACTION_VF_MODULE_INSTANCE",
+  UPDATE_VFMODULE_POSITION = "UPDATE_VFMODULE_POSITION"
+}
+
+
+export interface UpdateVFModluePosition extends Action {
+  node: any,
+  instanceId : string,
+  vnfStoreKey ?: string;
+}
+
+export interface DeleteVfModuleInstanceAction extends Action {
+  modelName?: string;
+  serviceModelId?: string;
+  vfName?: string;
+  vnfStoreKey?:string;
+  dynamicModelName?: string;
+}
+
+export interface CreateVFModuleInstanceAction extends Action {
+  vfInstance: any;
+  vfId: string;
+  serviceUuid: string;
+  index : number
+  vnfStoreKey : string;
+}
+
+export interface UpdateVFModuleInstanceAction extends Action {
+  vfInstance: any;
+  vfId: string;
+  serviceUuid: string;
+  dynamicModelName : string;
+  vnfStoreKey : string
+}
+
+
+export interface DeleteActionVfModuleInstanceAction extends Action {
+  dynamicModelName: string;
+  vnfStoreKey : string;
+  serviceId?: string;
+}
+
+export interface UndoDeleteActionVfModuleInstanceAction extends Action {
+  dynamicModelName: string;
+  vnfStoreKey : string;
+  serviceId?: string;
+}
+
+export const removeVfModuleInstance: ActionCreator<DeleteVfModuleInstanceAction> = (modelName, serviceModelId, vfName, vnfStoreKey, dynamicModelName) => ({
+  type: VfModuleActions.REMOVE_VNF_MODULE_INSTANCE,
+  modelName: modelName,
+  serviceModelId: serviceModelId,
+  vfName: vfName,
+  vnfStoreKey : vnfStoreKey,
+  dynamicModelName:dynamicModelName
+});
+
+
+export const createVFModuleInstance: ActionCreator<CreateVFModuleInstanceAction> = (vfInstance, vfId, serviceUuid, index, vnfStoreKey) => ({
+  type: VfModuleActions.CREATE_VF_MODULE,
+  vfInstance: vfInstance,
+  vfId: vfId,
+  serviceUuid: serviceUuid,
+  index : index,
+  vnfStoreKey : vnfStoreKey
+});
+
+export const updateVFModuleInstance: ActionCreator<UpdateVFModuleInstanceAction> = (vfInstance, vfId, serviceUuid, dynamicModelName, vnfStoreKey) => ({
+  type: VfModuleActions.UPDATE_VF_MODULE,
+  vfInstance: vfInstance,
+  vfId: vfId,
+  serviceUuid: serviceUuid,
+  dynamicModelName : dynamicModelName,
+  vnfStoreKey : vnfStoreKey
+});
+
+export const deleteActionVfModuleInstance: ActionCreator<DeleteActionVfModuleInstanceAction> = (dynamicModelName, vnfStoreKey, serviceId) => ({
+  type: VfModuleActions.DELETE_ACTION_VF_MODULE_INSTANCE,
+  dynamicModelName: dynamicModelName,
+  vnfStoreKey : vnfStoreKey,
+  serviceId: serviceId
+});
+
+export const undoDeleteVfModuleInstance: ActionCreator<UndoDeleteActionVfModuleInstanceAction> = (dynamicModelName, vnfStoreKey, serviceId) => ({
+  type: VfModuleActions.UNDO_DELETE_ACTION_VF_MODULE_INSTANCE,
+  dynamicModelName: dynamicModelName,
+  vnfStoreKey : vnfStoreKey,
+  serviceId: serviceId
+});
+
+
+export const updateVFModulePosition: ActionCreator<UpdateVFModluePosition> = (node, instanceId, vnfStoreKey) => ({
+  type: VfModuleActions.UPDATE_VFMODULE_POSITION,
+  node: node,
+  instanceId: instanceId,
+  vnfStoreKey : vnfStoreKey
+});
+
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/vfModule/vfModule.reducers.spec.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/vfModule/vfModule.reducers.spec.ts
new file mode 100644
index 000000000..de6d2142c
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/vfModule/vfModule.reducers.spec.ts
@@ -0,0 +1,248 @@
+import {
+  CreateVFModuleInstanceAction,
+  DeleteActionVfModuleInstanceAction,
+  DeleteVfModuleInstanceAction, UndoDeleteActionVfModuleInstanceAction, UpdateVFModluePosition,
+  VfModuleActions
+} from "./vfModule.actions";
+import {vfModuleReducer} from "./vfModule.reducers";
+import {VfModuleInstance} from "../../../models/vfModuleInstance";
+import {ServiceInstanceActions} from "../../../models/serviceInstanceActions";
+
+
+describe('vfModuleReducer', () => {
+  test('#REMOVE_VNF_MODULE_INSTANCE : should delete existing vnf module by dynamicModelName', () => {
+    let state = vfModuleReducer(<any>{serviceInstance : {
+          'serviceModelId' : {
+            vnfs : {
+              'vfName' : {
+                vfModules : {
+                  'modelName' : {
+                    'dynamicModelName1': {},
+                    'dynamicModelName2': {},
+                  }
+                }
+              }
+            }
+          }
+        }},
+      <DeleteVfModuleInstanceAction>{
+        type: VfModuleActions.REMOVE_VNF_MODULE_INSTANCE,
+        modelName : 'modelName',
+        vfName : 'vfName',
+        vnfStoreKey : 'vfName',
+        serviceModelId : 'serviceModelId',
+        dynamicModelName: 'dynamicModelName1'
+      });
+
+    expect(state).toBeDefined();
+    expect(state.serviceInstance['serviceModelId'].vnfs['vfName'].vfModules['modelName']['dynamicModelName2']).toBeDefined();
+    expect(state.serviceInstance['serviceModelId'].vnfs['vfName'].vfModules['modelName']['dynamicModelName1']).not.toBeDefined();
+  });
+
+  test('#DELETE_LAST_VNF_MODULE_INSTANCE : should delete existing vnf module', () => {
+    let state = vfModuleReducer(<any>{serviceInstance : {
+          'serviceModelId' : {
+            vnfs : {
+              'vfName' : {
+                vfModules : {
+                  'modelName' : {
+                    'dynamicModelName': {
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }},
+      <DeleteVfModuleInstanceAction>{
+        type: VfModuleActions.REMOVE_VNF_MODULE_INSTANCE,
+        modelName : 'modelName',
+        vfName : 'vfName',
+        vnfStoreKey : 'vfName',
+        serviceModelId : 'serviceModelId',
+        dynamicModelName: 'dynamicModelName'
+      });
+
+    expect(state).toBeDefined();
+    expect(state.serviceInstance['serviceModelId'].vnfs['vfName'].vfModules['modelName']).not.toBeDefined();
+  });
+
+  test('#CREATE_VF_MODULE: should create new vfModule to existing VNF', ()=>{
+    let vfModuleInstance : VfModuleInstance = new VfModuleInstance();
+    vfModuleInstance.instanceName = 'instanceName';
+    vfModuleInstance.isMissingData = false;
+    vfModuleInstance.volumeGroupName = 'volumeGroupName';
+    let vfModule = vfModuleReducer(<any>{serviceInstance : {
+          'serviceUuid' : {
+            vnfs : {
+              'vnfStoreKey' : {
+                'vfModules' : {
+                }
+              }
+            }
+          }
+        }},
+      <CreateVFModuleInstanceAction>{
+        type: VfModuleActions.CREATE_VF_MODULE,
+        vfId : 'vfId',
+        vfInstance : new VfModuleInstance(),
+        vnfStoreKey : 'vnfStoreKey',
+        serviceUuid : 'serviceUuid',
+        index : 1
+      }).serviceInstance['serviceUuid'].vnfs['vnfStoreKey'].vfModules;
+
+    let firstVfModuleName = Object.keys(vfModule)[0];
+    expect(vfModule[firstVfModuleName]).toBeDefined();
+    expect(vfModule[firstVfModuleName].isMissingData).toBeFalsy();
+  });
+
+  test('#UPDATE_VF_MODULE: should update existing VFModule', ()=>{
+    let vfModuleInstance : VfModuleInstance = new VfModuleInstance();
+    vfModuleInstance.instanceName = 'instanceName';
+    vfModuleInstance.isMissingData = false;
+    vfModuleInstance.volumeGroupName = 'volumeGroupName';
+    let vfModule = vfModuleReducer(<any>{
+      serviceHierarchy : {
+        'serviceModelId' : {}
+      },
+      serviceInstance : {
+          'serviceModelId' : {
+            vnfs : {
+              'vfName' : {
+                vfModules : {
+                  'modelName' : {
+                    'dynamicModelName1': {
+                      isMissingData : true
+                    },
+                    'dynamicModelName2': {},
+                  }
+                }
+              }
+            }
+          }
+        }},
+      <CreateVFModuleInstanceAction>{
+        type: VfModuleActions.UPDATE_VF_MODULE,
+        vfId : 'modelName',
+        vfInstance : new VfModuleInstance(),
+        vnfStoreKey : 'vfName',
+        dynamicModelName : 'dynamicModelName1',
+        serviceUuid : 'serviceModelId',
+        index : 1
+      }).serviceInstance['serviceModelId'].vnfs['vfName'].vfModules;
+
+    let firstVfModuleName = Object.keys(vfModule)[0];
+    expect(vfModule[firstVfModuleName]).toBeDefined();
+    expect(vfModule[firstVfModuleName].isMissingData).toBeFalsy();
+  });
+
+
+  test('#UPDATE_VFMODULE_POSITION: should update position', ()=>{
+    let vfModule = vfModuleReducer(<any>{
+        serviceHierarchy : {
+          'serviceModelId' : {}
+        },
+        serviceInstance : {
+          'serviceModelId' : {
+            vnfs : {
+              'vfName' : {
+                vfModules : {
+                  'modelName' : {
+                    'dynamicModelName': {
+                      isMissingData : true
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }},
+      <UpdateVFModluePosition>{
+        type: VfModuleActions.UPDATE_VFMODULE_POSITION,
+        node: {
+          position : 1,
+          dynamicModelName : "dynamicModelName",
+          modelName : "modelName"
+        },
+        instanceId : "serviceModelId",
+        vnfStoreKey : "vfName"
+
+      }).serviceInstance['serviceModelId'].vnfs['vfName'].vfModules["modelName"]["dynamicModelName"];
+
+      expect(vfModule.position).toEqual(1);
+  });
+
+
+  test('#DELETE_ACTION_VF_MODULE_INSTANCE', ()=>{
+    let vfModule = vfModuleReducer(<any>{
+      serviceHierarchy : {
+        'serviceModelId' : {}
+      },
+      serviceInstance : {
+          'serviceModelId' : {
+            vnfs : {
+              'vnfStoreKey' : {
+                vfModules : {
+                  'modelName' : {
+                    'dynamicModelName1': {
+                      isMissingData : true,
+                      action : 'None'
+                    },
+                    'dynamicModelName2': {},
+                  }
+                }
+              }
+            }
+          }
+        }},
+      <DeleteActionVfModuleInstanceAction>{
+        type: VfModuleActions.DELETE_ACTION_VF_MODULE_INSTANCE,
+        dynamicModelName: 'dynamicModelName1',
+        vnfStoreKey : 'vnfStoreKey',
+        serviceId: 'serviceModelId'
+      }).serviceInstance['serviceModelId'].vnfs['vnfStoreKey'].vfModules['modelName']['dynamicModelName1'];
+
+    console.log(vfModule.action);
+    expect(vfModule).toBeDefined();
+    expect(vfModule.isMissingData).toBeTruthy();
+    expect(vfModule.action).toEqual(ServiceInstanceActions.None_Delete);
+  });
+
+  test('#UNDO_DELETE_ACTION_VF_MODULE_INSTANCE', ()=>{
+    let vfModule = vfModuleReducer(<any>{
+        serviceHierarchy : {
+          'serviceModelId' : {}
+        },
+        serviceInstance : {
+          'serviceModelId' : {
+            vnfs : {
+              'vnfStoreKey' : {
+                vfModules : {
+                  'modelName' : {
+                    'dynamicModelName1': {
+                      isMissingData : true,
+                      action : 'None_Delete'
+                    },
+                    'dynamicModelName2': {},
+                  }
+                }
+              }
+            }
+          }
+        }},
+      <UndoDeleteActionVfModuleInstanceAction>{
+        type: VfModuleActions.UNDO_DELETE_ACTION_VF_MODULE_INSTANCE,
+        dynamicModelName: 'dynamicModelName1',
+        vnfStoreKey : 'vnfStoreKey',
+        serviceId: 'serviceModelId'
+      }).serviceInstance['serviceModelId'].vnfs['vnfStoreKey'].vfModules['modelName']['dynamicModelName1'];
+
+    console.log(vfModule.action);
+    expect(vfModule).toBeDefined();
+    expect(vfModule.action).toEqual(ServiceInstanceActions.None);
+  });
+
+});
+
+
+
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/vfModule/vfModule.reducers.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/vfModule/vfModule.reducers.ts
new file mode 100644
index 000000000..f3636ff41
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/vfModule/vfModule.reducers.ts
@@ -0,0 +1,165 @@
+import {Action} from "redux";
+import * as _ from "lodash";
+import {
+  CreateVFModuleInstanceAction, DeleteActionVfModuleInstanceAction,
+  DeleteVfModuleInstanceAction, UndoDeleteActionVfModuleInstanceAction, UpdateVFModluePosition,
+  UpdateVFModuleInstanceAction,
+  VfModuleActions
+} from "./vfModule.actions";
+import {ServiceInstance} from "../../../models/serviceInstance";
+import {VfModuleMap} from "../../../models/vfModulesMap";
+import {ServiceState} from "../main.reducer";
+import {ServiceInstanceActions} from "../../../models/serviceInstanceActions";
+
+
+export function vfModuleReducer(state: ServiceState , action: Action) : ServiceState{
+  switch (action.type) {
+    case VfModuleActions.CREATE_VF_MODULE: {
+      const updateVFModuleInstanceAction = <CreateVFModuleInstanceAction>action;
+      const vfInstance = updateVFModuleInstanceAction.vfInstance;
+      const serviceUuid = updateVFModuleInstanceAction.serviceUuid;
+      const vfModuleId = updateVFModuleInstanceAction.vfId;
+      const vnfStoreKey = updateVFModuleInstanceAction.vnfStoreKey;
+
+      let newState = Object.assign({}, state);
+
+      let vfModulesMap = newState.serviceInstance[serviceUuid].vnfs[vnfStoreKey].vfModules[vfModuleId] || new VfModuleMap();
+      let randomId = generateId();
+      vfModulesMap[vfModuleId + randomId] = vfInstance;
+      updateUniqueNames(null, vfInstance.instanceName, newState.serviceInstance[serviceUuid]);
+      updateUniqueNames(null, vfInstance.volumeGroupName, newState.serviceInstance[serviceUuid]);
+      updateServiceValidationCounter(newState, false, vfInstance['isMissingData'], serviceUuid);
+
+      newState.serviceInstance[serviceUuid].vnfs[vnfStoreKey].vfModules[vfModuleId] = vfModulesMap;
+      return newState;
+    }
+    case VfModuleActions.UPDATE_VF_MODULE: {
+      const updateVFModuleInstanceAction = <UpdateVFModuleInstanceAction>action;
+      const vfInstance = updateVFModuleInstanceAction.vfInstance;
+      const serviceUuid = updateVFModuleInstanceAction.serviceUuid;
+      const vfModuleId = updateVFModuleInstanceAction.vfId;
+      const newState = _.cloneDeep(state);
+      const vnfs = newState.serviceHierarchy[serviceUuid].vnfs;
+      let vnfId = getVfModuleParentVnfId(vnfs, vfModuleId);
+      const vnfStoreKey = updateVFModuleInstanceAction.vnfStoreKey;
+      if (!_.isNil(vnfStoreKey)) {
+        vnfId = vnfStoreKey;
+      }
+      let vfModulesMap = newState.serviceInstance[serviceUuid].vnfs[vnfId].vfModules[vfModuleId] || new VfModuleMap();
+      updateServiceValidationCounter(newState, vfModulesMap[updateVFModuleInstanceAction.dynamicModelName]['isMissingData'], vfInstance.isMissingData, serviceUuid);
+      updateUniqueNames(vfModulesMap[updateVFModuleInstanceAction.dynamicModelName].instanceName, vfInstance.instanceName, newState.serviceInstance[serviceUuid]);
+      updateUniqueNames(vfModulesMap[updateVFModuleInstanceAction.dynamicModelName].volumeGroupName, vfInstance.volumeGroupName, newState.serviceInstance[serviceUuid]);
+      vfModulesMap[updateVFModuleInstanceAction.dynamicModelName] = vfInstance;
+      newState.serviceInstance[serviceUuid].vnfs[vnfId].vfModules[vfModuleId] = vfModulesMap;
+      return newState;
+    }
+    case VfModuleActions.REMOVE_VNF_MODULE_INSTANCE: {
+      const actionData = (<DeleteVfModuleInstanceAction>action);
+      if (state.serviceInstance[actionData.serviceModelId]) {
+        let vfModulesMap = state.serviceInstance[actionData.serviceModelId].vnfs[actionData.vnfStoreKey].vfModules;
+        updateIsMissingDataOnDeleteVFModule(state, actionData.serviceModelId, actionData.vnfStoreKey, actionData.modelName);
+        updateUniqueNames(vfModulesMap[actionData.modelName][actionData.dynamicModelName].instanceName, null, state.serviceInstance[actionData.serviceModelId] );
+        updateUniqueNames(vfModulesMap[actionData.modelName][actionData.dynamicModelName].volumeGroupName, null, state.serviceInstance[actionData.serviceModelId] );
+        delete vfModulesMap[actionData.modelName][actionData.dynamicModelName];
+        if(_.isEmpty(vfModulesMap[actionData.modelName])){
+          delete vfModulesMap[actionData.modelName];
+        }
+      }
+      return Object.assign({}, state);
+    }
+    case VfModuleActions.DELETE_ACTION_VF_MODULE_INSTANCE : {
+      let newState = _.cloneDeep(state);
+      let vfModules = newState.serviceInstance[(<DeleteActionVfModuleInstanceAction>action).serviceId].vnfs[(<DeleteActionVfModuleInstanceAction>action).vnfStoreKey].vfModules;
+
+      for(let key in vfModules){
+        let firstKey = Object.keys(vfModules[key])[0];
+        if(firstKey === (<DeleteActionVfModuleInstanceAction>action).dynamicModelName){
+          let oldAction = newState.serviceInstance[(<DeleteActionVfModuleInstanceAction>action).serviceId].vnfs[(<DeleteActionVfModuleInstanceAction>action).vnfStoreKey].vfModules[key][firstKey].action;
+          if(oldAction === ServiceInstanceActions.None_Delete || oldAction === ServiceInstanceActions.Update_Delete) return newState;
+          newState.serviceInstance[(<DeleteActionVfModuleInstanceAction>action).serviceId].vnfs[(<DeleteActionVfModuleInstanceAction>action).vnfStoreKey].vfModules[key][firstKey].action = (oldAction + '_Delete') as ServiceInstanceActions;
+          updateIsMissingDataOnDeleteVFModule(newState, (<UndoDeleteActionVfModuleInstanceAction>action).serviceId, (<UndoDeleteActionVfModuleInstanceAction>action).vnfStoreKey, key);
+          return newState;
+        }
+      }
+      return newState;
+    }
+    case VfModuleActions.UNDO_DELETE_ACTION_VF_MODULE_INSTANCE : {
+      let newState = _.cloneDeep(state);
+      let vfModules = newState.serviceInstance[(<DeleteActionVfModuleInstanceAction>action).serviceId].vnfs[(<DeleteActionVfModuleInstanceAction>action).vnfStoreKey].vfModules;
+
+      for(let key in vfModules){
+        let firstKey = Object.keys(vfModules[key])[0];
+        if(firstKey === (<UndoDeleteActionVfModuleInstanceAction>action).dynamicModelName){
+          let oldAction = newState.serviceInstance[(<UndoDeleteActionVfModuleInstanceAction>action).serviceId].vnfs[(<UndoDeleteActionVfModuleInstanceAction>action).vnfStoreKey].vfModules[key][firstKey].action;
+          newState.serviceInstance[(<UndoDeleteActionVfModuleInstanceAction>action).serviceId].vnfs[(<UndoDeleteActionVfModuleInstanceAction>action).vnfStoreKey].vfModules[key][firstKey].action = (oldAction.split('_')[0]) as ServiceInstanceActions;
+          updateIsMissingDataOnDeleteVFModule(newState, (<UndoDeleteActionVfModuleInstanceAction>action).serviceId, (<UndoDeleteActionVfModuleInstanceAction>action).vnfStoreKey, key);
+          return newState;
+        }
+      }
+      return newState;
+    }
+
+    case VfModuleActions.UPDATE_VFMODULE_POSITION : {
+      const updateVFModluePosition = <UpdateVFModluePosition>action;
+      const serviceUuid = updateVFModluePosition.instanceId;
+      const dynamicModelName = updateVFModluePosition.node.dynamicModelName;
+      const modelName = updateVFModluePosition.node.modelName;
+      const newState = _.cloneDeep(state);
+
+      newState.serviceInstance[serviceUuid].vnfs[updateVFModluePosition.vnfStoreKey].vfModules[modelName][dynamicModelName].position = updateVFModluePosition.node.position;
+      return newState;
+    }
+  }
+}
+
+const updateIsMissingDataOnDeleteVFModule = (state: any, serviceModelId: string, vnfStoreKey: string, vfModuleName): void => {
+  const vfModules = state.serviceInstance[serviceModelId].vnfs[vnfStoreKey].vfModules[vfModuleName];
+
+  _.forOwn(vfModules, (vfModuleInstance) => {
+    let isMissingData: boolean = vfModuleInstance.isMissingData;
+    updateServiceValidationCounter(state, isMissingData, false, serviceModelId);
+  });
+};
+
+
+const updateUniqueNames = (oldName : string, newName : string, serviceInstance : ServiceInstance) : void => {
+  let existingNames = serviceInstance.existingNames;
+  if (!_.isNil(oldName) && oldName.toLowerCase() in existingNames) {
+    delete existingNames[oldName.toLowerCase()];
+  }
+  if(!_.isNil(newName)) {
+    existingNames[newName.toLowerCase()] = "";
+  }
+};
+
+const updateServiceValidationCounter = (newState: any, oldValidationState: boolean, newValidationState: boolean, serviceUuid: string) => {
+  if (oldValidationState && !newValidationState) {
+    newState.serviceInstance[serviceUuid].validationCounter--;
+  } else if (!oldValidationState && newValidationState) {
+    newState.serviceInstance[serviceUuid].validationCounter++;
+  }
+};
+
+const generateId = () => {
+  return Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 5);
+};
+const getVfModuleParentVnfId = (vnfs: object, vfModuleId: string) => {
+  let vnfId = undefined;
+  _.forOwn(vnfs, (value, key) => {
+    if (vnfs[key].vfModules && vnfs[key].vfModules[vfModuleId]) {
+      vnfId = vnfs[key].modelCustomizationName;
+      return false;
+    }
+  });
+  return vnfId;
+};
+
+
+
+
+
+
+
+
+
+
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/vnf/vnf.actions.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/vnf/vnf.actions.ts
new file mode 100644
index 000000000..b84284490
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/vnf/vnf.actions.ts
@@ -0,0 +1,99 @@
+import {Action, ActionCreator} from "redux";
+import {VnfInstance} from "../../../models/vnfInstance";
+
+export enum VNFActions {
+  CREATE_VNF_INSTANCE = "CREATE_VNF_INSTANCE",
+  UPDATE_VNF_INSTANCE = "UPDATE_VNF_INSTANCE",
+  REMOVE_VNF_INSTANCE = "REMOVE_VNF_INSTANCE",
+  DELETE_ACTION_VNF_INSTANCE = "DELETE_VNF_INSTANCE",
+  UNDO_DELETE_ACTION_VNF_INSTANCE = "UNDO_DELETE_VNF_INSTANCE",
+  UPDATE_VNF_POSITION = "UPDATE_VNF_POISTION"
+}
+
+
+export interface CreateVnfInstanceAction extends Action {
+  vnfInstance?: VnfInstance;
+  vnfModelName?: string;
+  serviceUuid?: string;
+  vnfStoreKey?:string;
+}
+
+export interface UpdateVnfPosition extends Action {
+  node: any,
+  instanceId : string,
+  vnfStoreKey?: string;
+}
+
+export interface UpdateVnfInstanceAction extends Action {
+  vnfInstance?: VnfInstance;
+  vnfModelName?: string;
+  serviceUuid?: string;
+  vnfStoreKey?:string;
+}
+
+
+
+export interface DeleteActionVnfInstanceAction extends Action {
+  vnfStoreKey: string;
+  serviceId?: string;
+}
+
+export interface UndoDeleteActionVnfInstanceAction extends Action {
+  vnfStoreKey: string;
+  serviceId?: string;
+}
+
+export interface RemoveVnfInstanceAction extends Action {
+  vnfStoreKey: string;
+  serviceId?: string;
+}
+
+export const createVNFInstance: ActionCreator<CreateVnfInstanceAction> = (vnfInstance, vnfModelName, serviceUuid, vnfStoreKey) => ({
+  type: VNFActions.CREATE_VNF_INSTANCE,
+  vnfInstance: vnfInstance,
+  vnfModelName: vnfModelName,
+  serviceUuid: serviceUuid,
+  vnfStoreKey : vnfStoreKey
+});
+
+
+export const updateVNFInstance: ActionCreator<UpdateVnfInstanceAction> = (vnfInstance, vnfModelName, serviceUuid, vnfStoreKey) => ({
+  type: VNFActions.UPDATE_VNF_INSTANCE,
+  vnfInstance: vnfInstance,
+  vnfModelName: vnfModelName,
+  serviceUuid: serviceUuid,
+  vnfStoreKey : vnfStoreKey
+});
+
+
+export const deleteActionVnfInstance: ActionCreator<DeleteActionVnfInstanceAction> = (vnfStoreKey, serviceId) => ({
+  type: VNFActions.DELETE_ACTION_VNF_INSTANCE,
+  vnfStoreKey: vnfStoreKey,
+  serviceId: serviceId
+});
+
+export const undoDeleteActionVnfInstance: ActionCreator<UndoDeleteActionVnfInstanceAction> = (vnfStoreKey, serviceId) => ({
+  type: VNFActions.UNDO_DELETE_ACTION_VNF_INSTANCE,
+  vnfStoreKey: vnfStoreKey,
+  serviceId: serviceId
+});
+
+export const removeVnfInstance: ActionCreator<RemoveVnfInstanceAction> = (vnfStoreKey, serviceId) => ({
+  type: VNFActions.REMOVE_VNF_INSTANCE,
+  vnfStoreKey: vnfStoreKey,
+  serviceId: serviceId
+});
+
+export const updateVnfPosition: ActionCreator<UpdateVnfPosition> = (node, instanceId, vnfStoreKey) => ({
+  type: VNFActions.UPDATE_VNF_POSITION,
+  node: node,
+  instanceId: instanceId,
+  vnfStoreKey : vnfStoreKey
+});
+
+
+
+
+
+
+
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/vnf/vnf.reducers.spec.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/vnf/vnf.reducers.spec.ts
new file mode 100644
index 000000000..3241f11d9
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/vnf/vnf.reducers.spec.ts
@@ -0,0 +1,132 @@
+import {VnfInstance} from "../../../models/vnfInstance";
+import {
+  CreateVnfInstanceAction,
+  DeleteActionVnfInstanceAction, RemoveVnfInstanceAction,
+  UndoDeleteActionVnfInstanceAction, UpdateVnfPosition,
+  VNFActions
+} from "./vnf.actions";
+import {vnfReducer} from "./vnf.reducers";
+import {ServiceInstanceActions} from "../../../models/serviceInstanceActions";
+
+describe('networkReducer', () => {
+  test('#UPDATE_VNF_POSITION', () => {
+    let vnfInstance: VnfInstance = new VnfInstance();
+    vnfInstance.isMissingData = false;
+    vnfInstance.instanceName = 'instanceName';
+    let vnfState = vnfReducer(<any>{
+      serviceInstance : {
+          'serviceModelId' : {
+            vnfs : {
+              "vnfStoreKey" : {
+
+              }
+            }
+          }
+        }},
+      <UpdateVnfPosition>{
+        type: VNFActions.UPDATE_VNF_POSITION,
+        node : <any>{
+          position : 1
+        },
+        vnfStoreKey : 'vnfStoreKey',
+        instanceId : 'serviceModelId'
+      }).serviceInstance['serviceModelId'].vnfs['vnfStoreKey'];
+
+    expect(vnfState).toBeDefined();
+    expect(vnfState.position).toEqual(1);
+  });
+
+  test('#CREATE_NETWORK_INSTANCE', () => {
+    let vnfInstance: VnfInstance = new VnfInstance();
+    vnfInstance.isMissingData = false;
+    vnfInstance.instanceName = 'instanceName';
+    let vnfState = vnfReducer(<any>{serviceInstance : {
+          'serviceModelId' : {
+            vnfs : {
+
+            }
+          }
+        }},
+      <CreateVnfInstanceAction>{
+        type: VNFActions.CREATE_VNF_INSTANCE,
+        vnfInstance : vnfInstance,
+        vnfStoreKey : null,
+        vnfModelName : 'vnfModelName',
+        serviceUuid : 'serviceModelId'
+      }).serviceInstance['serviceModelId'].vnfs['vnfModelName'];
+
+    expect(vnfState).toBeDefined();
+    expect(vnfState.isMissingData).toBeFalsy();
+  });
+
+  test('#DELETE_ACTION_VNF_INSTANCE', () => {
+    let vnfState = vnfReducer(<any>{serviceInstance : {
+          'serviceModelId' : {
+            vnfs : {
+              'vnfStoreKey' : {
+                isMissingData : true,
+                action : 'None'
+              }
+            }
+          }
+        }},
+      <DeleteActionVnfInstanceAction>{
+        type: VNFActions.DELETE_ACTION_VNF_INSTANCE,
+        vnfStoreKey: 'vnfStoreKey',
+        serviceId: 'serviceModelId'
+      }).serviceInstance['serviceModelId'].vnfs['vnfStoreKey'];
+
+    expect(vnfState).toBeDefined();
+    expect(vnfState.action).toEqual(ServiceInstanceActions.None_Delete);
+  });
+
+  test('#UNDO_DELETE_ACTION_VNF_INSTANCE', () => {
+    let vnfState = vnfReducer(<any>{serviceInstance : {
+          'serviceModelId' : {
+            vnfs : {
+              'vnfStoreKey' : {
+                isMissingData : true,
+                action : 'Update_Delete'
+              }
+            }
+          }
+        }},
+      <UndoDeleteActionVnfInstanceAction>{
+        type: VNFActions.UNDO_DELETE_ACTION_VNF_INSTANCE,
+        vnfStoreKey: 'vnfStoreKey',
+        serviceId: 'serviceModelId'
+      }).serviceInstance['serviceModelId'].vnfs['vnfStoreKey'];
+
+    expect(vnfState).toBeDefined();
+    expect(vnfState.action).toEqual(ServiceInstanceActions.Update);
+  });
+
+  test('#REMOVE_VNF_INSTANCE', () => {
+    let vnfs = vnfReducer(<any>{serviceInstance : {
+          'serviceModelId' : {
+            vnfs : {
+              'vnfStoreKey' : {
+                isMissingData : true,
+                action : 'Update_Delete'
+              },
+              'vnfStoreKey_1' : {
+                isMissingData : true,
+                action : 'Update_Delete'
+              }
+            }
+          }
+        }},
+      <RemoveVnfInstanceAction>{
+        type: VNFActions.REMOVE_VNF_INSTANCE,
+        vnfStoreKey: 'vnfStoreKey',
+        serviceId: 'serviceModelId'
+      }).serviceInstance['serviceModelId'].vnfs;
+
+    expect(vnfs).toBeDefined();
+    expect(vnfs['vnfStoreKey']).toBeUndefined();
+  });
+
+});
+
+
+
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/vnf/vnf.reducers.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/vnf/vnf.reducers.ts
new file mode 100644
index 000000000..cc24d8dc3
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/vnf/vnf.reducers.ts
@@ -0,0 +1,124 @@
+import {Action} from "redux";
+import {VnfInstance} from "../../../models/vnfInstance";
+import {
+  CreateVnfInstanceAction,
+  DeleteActionVnfInstanceAction, RemoveVnfInstanceAction, UndoDeleteActionVnfInstanceAction,
+  UpdateVnfInstanceAction, UpdateVnfPosition,
+  VNFActions
+} from "./vnf.actions";
+import * as _ from "lodash";
+import {ServiceInstance} from "../../../models/serviceInstance";
+import {ServiceState} from "../main.reducer";
+import {ServiceInstanceActions} from "../../../models/serviceInstanceActions";
+
+export function vnfReducer(state: ServiceState, action: Action): ServiceState {
+  switch (action.type) {
+    case VNFActions.CREATE_VNF_INSTANCE: {
+      const updateVnfInstanceAction = <CreateVnfInstanceAction>action;
+      const serviceUuid = updateVnfInstanceAction.serviceUuid;
+      let vnfModelName = updateVnfInstanceAction.vnfModelName;
+      let newState = _.cloneDeep(state);
+
+      updateVnfInstanceAction.vnfInstance.originalName = vnfModelName;
+      updateVnfInstanceAction.vnfModelName = calculateNextUniqueModelName(vnfModelName, serviceUuid, newState, 'vnfs');
+
+      let vnfInstance: VnfInstance = newState.serviceInstance[serviceUuid].vnfs[vnfModelName];
+      vnfInstance = new VnfInstance();
+      updateVnfInstanceAction.vnfInstance.vnfStoreKey = updateVnfInstanceAction.vnfModelName;
+      updateVnfInstanceAction.vnfInstance.originalName = vnfModelName;
+      vnfInstance.originalName = updateVnfInstanceAction.vnfInstance.originalName;
+      vnfInstance.vnfStoreKey = updateVnfInstanceAction.vnfInstance.vnfStoreKey;
+      updateServiceValidationCounter(newState, vnfInstance['isMissingData'], updateVnfInstanceAction.vnfInstance['isMissingData'], serviceUuid);
+
+      newState.serviceInstance[serviceUuid].vnfs[updateVnfInstanceAction.vnfModelName] = Object.assign(vnfInstance, updateVnfInstanceAction.vnfInstance);
+      return newState;
+    }
+
+    case VNFActions.UPDATE_VNF_INSTANCE: {
+      const updateVnfInstanceAction = <UpdateVnfInstanceAction>action;
+      const serviceUuid = updateVnfInstanceAction.serviceUuid;
+      let vnfStoreKey = updateVnfInstanceAction.vnfStoreKey;
+
+
+      let newState = _.cloneDeep(state);
+      let vnfInstance: VnfInstance = newState.serviceInstance[serviceUuid].vnfs[vnfStoreKey];
+      updateUniqueNames(vnfInstance ? vnfInstance.instanceName : null, updateVnfInstanceAction.vnfInstance.instanceName, newState.serviceInstance[serviceUuid]);
+
+      vnfInstance = vnfInstance || new VnfInstance();
+      updateServiceValidationCounter(newState, vnfInstance['isMissingData'], updateVnfInstanceAction.vnfInstance['isMissingData'], serviceUuid);
+
+      newState.serviceInstance[serviceUuid].vnfs[vnfStoreKey] = Object.assign(vnfInstance, updateVnfInstanceAction.vnfInstance);
+      return newState;
+    }
+
+    case VNFActions.DELETE_ACTION_VNF_INSTANCE : {
+      let newState = _.cloneDeep(state);
+      let vnf = newState.serviceInstance[(<DeleteActionVnfInstanceAction>action).serviceId].vnfs[(<DeleteActionVnfInstanceAction>action).vnfStoreKey];
+      let oldAction = vnf.action;
+      if(oldAction === ServiceInstanceActions.None_Delete || oldAction === ServiceInstanceActions.Update_Delete) return newState;
+      newState.serviceInstance[(<DeleteActionVnfInstanceAction>action).serviceId].vnfs[(<DeleteActionVnfInstanceAction>action).vnfStoreKey].action = (oldAction + '_Delete') as ServiceInstanceActions;
+      updateServiceValidationCounter(newState, vnf['isMissingData'], false,  (<RemoveVnfInstanceAction>action).serviceId);
+      return newState;
+    }
+
+    case VNFActions.UNDO_DELETE_ACTION_VNF_INSTANCE : {
+      let newState = _.cloneDeep(state);
+      let vnf = newState.serviceInstance[(<UndoDeleteActionVnfInstanceAction>action).serviceId].vnfs[(<UndoDeleteActionVnfInstanceAction>action).vnfStoreKey];
+      let oldState = vnf.action;
+      newState.serviceInstance[(<UndoDeleteActionVnfInstanceAction>action).serviceId].vnfs[(<UndoDeleteActionVnfInstanceAction>action).vnfStoreKey].action = (oldState.split('_')[0]) as ServiceInstanceActions;
+      updateServiceValidationCounter(newState, vnf['isMissingData'], false,  (<UndoDeleteActionVnfInstanceAction>action).serviceId);
+      return newState;
+    }
+
+    case VNFActions.REMOVE_VNF_INSTANCE : {
+      let newState = _.cloneDeep(state);
+      let vnfInstance = newState.serviceInstance[(<RemoveVnfInstanceAction>action).serviceId].vnfs[(<RemoveVnfInstanceAction>action).vnfStoreKey];
+      updateServiceValidationCounter(newState, vnfInstance['isMissingData'], false,  (<RemoveVnfInstanceAction>action).serviceId);
+      delete newState.serviceInstance[(<RemoveVnfInstanceAction>action).serviceId].vnfs[(<RemoveVnfInstanceAction>action).vnfStoreKey];
+      return newState;
+    }
+
+    case VNFActions.UPDATE_VNF_POSITION : {
+      let newState = _.cloneDeep(state);
+      newState.serviceInstance[(<UpdateVnfPosition>action).instanceId].vnfs[(<UpdateVnfPosition>action).vnfStoreKey].position = (<UpdateVnfPosition>action).node.position;
+      return newState;
+    }
+  }
+}
+
+const updateServiceValidationCounter = (newState: any, oldValidationState: boolean, newValidationState: boolean, serviceUuid: string) => {
+  if (oldValidationState && !newValidationState) {
+    newState.serviceInstance[serviceUuid].validationCounter--;
+  } else if (!oldValidationState && newValidationState) {
+    newState.serviceInstance[serviceUuid].validationCounter++;
+  }
+};
+
+
+const updateUniqueNames = (oldName: string, newName: string, serviceInstance: ServiceInstance): void => {
+  let existingNames = serviceInstance.existingNames;
+  if (!_.isNil(oldName) && oldName.toLowerCase() in existingNames) {
+    delete existingNames[oldName.toLowerCase()];
+  }
+  if (!_.isNil(newName)) {
+    existingNames[newName.toLowerCase()] = "";
+  }
+};
+
+
+export const calculateNextUniqueModelName = (vnfModelName: string, serviceId: string, state: any, levelName: string): string => {
+  let counter: number = null;
+  while (true) {
+    let pattern = !_.isNil(counter) ? ("_" + counter) : "";
+    if (!_.isNil(state.serviceInstance[serviceId][levelName][vnfModelName + pattern])) {
+      counter = counter ? (counter + 1) : 1;
+    } else {
+      return vnfModelName + pattern;
+    }
+  }
+};
+
+
+
+
+
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/vnfGroup/vnfGroup.actions.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/vnfGroup/vnfGroup.actions.ts
new file mode 100644
index 000000000..4ed377b7d
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/vnfGroup/vnfGroup.actions.ts
@@ -0,0 +1,82 @@
+import {Action, ActionCreator} from "redux";
+import {VnfGroupInstance} from "../../../models/vnfGroupInstance";
+import {VnfMember} from "../../../models/VnfMember";
+
+export enum VnfGroupActions {
+  CREATE_VNF_GROUP_INSTANCE = "CREATE_VNF_GROUP_INSTANCE",
+  UPDATE_VNF_GROUP_INSTANCE = "UPDATE_VNF_GROUP_INSTANCE",
+  DELETE_ACTION_VNF_GROUP_INSTANCE = "DELETE_VNF_GROUP_INSTANCE",
+  UNDO_DELETE_ACTION_VNF_GROUP_INSTANCE = "UNDO_DELETE_VNF_GROUP_INSTANCE",
+  SET_OPTIONAL_MEMBERS_VNF_GROUP_INSTANCE = "SET_OPTIONAL_MEMBERS_VNF_GROUP_INSTANCE"
+}
+
+
+export interface CreateVnfGroupInstanceAction extends Action {
+  vnfGroupInstance?: VnfGroupInstance;
+  vnfGroupModelName?: string;
+  serviceUuid?: string;
+  vnfGroupStoreKey?:string;
+}
+
+export interface UpdateVnfGroupInstanceAction extends Action {
+  vnfGroupInstance?: VnfGroupInstance;
+  vnfGroupModelName?: string;
+  serviceUuid?: string;
+  vnfGroupStoreKey?:string;
+}
+
+export interface DeleteActionVnfGroupInstanceAction extends Action {
+  vnfGroupStoreKey: string;
+  serviceId?: string;
+}
+
+export interface UndoDeleteActionVnfGroupInstanceAction extends Action {
+  vnfGroupStoreKey: string;
+  serviceId?: string;
+}
+
+export interface SetOptionalMembersVnfGroupInstanceAction extends Action{
+  path?: string;
+  serviceId?: string;
+  vnfMembers?: VnfMember[]
+}
+
+export const createVnfGroupInstance: ActionCreator<CreateVnfGroupInstanceAction> = (vnfGroupInstance, vnfGroupModelName, serviceUuid, vnfGroupStoreKey) => ({
+  type: VnfGroupActions.CREATE_VNF_GROUP_INSTANCE,
+  vnfGroupInstance: vnfGroupInstance,
+  vnfGroupModelName: vnfGroupModelName,
+  serviceUuid: serviceUuid,
+  vnfGroupStoreKey : vnfGroupStoreKey
+});
+
+
+export const updateVnfGroupInstance: ActionCreator<UpdateVnfGroupInstanceAction> = (vnfGroupInstance, vnfGroupModelName, serviceUuid, vnfGroupStoreKey) => ({
+  type: VnfGroupActions.UPDATE_VNF_GROUP_INSTANCE,
+  vnfGroupInstance: vnfGroupInstance,
+  vnfGroupModelName: vnfGroupModelName,
+  serviceUuid: serviceUuid,
+  vnfGroupStoreKey : vnfGroupStoreKey
+});
+
+export const deleteActionVnfGroupInstance: ActionCreator<DeleteActionVnfGroupInstanceAction> = (vnfGroupStoreKey, serviceId) => ({
+  type: VnfGroupActions.DELETE_ACTION_VNF_GROUP_INSTANCE,
+  vnfGroupStoreKey: vnfGroupStoreKey,
+  serviceId: serviceId
+});
+
+export const undoDeleteActionVnfGroupInstance: ActionCreator<UndoDeleteActionVnfGroupInstanceAction> = (vnfGroupStoreKey, serviceId) => ({
+  type: VnfGroupActions.UNDO_DELETE_ACTION_VNF_GROUP_INSTANCE,
+  vnfGroupStoreKey: vnfGroupStoreKey,
+  serviceId: serviceId
+});
+
+export const setOptionalMembersVnfGroupInstance: ActionCreator<SetOptionalMembersVnfGroupInstanceAction> = ( serviceId: string, path: string, vnfMembers: VnfMember[]) => ({
+  type: VnfGroupActions.SET_OPTIONAL_MEMBERS_VNF_GROUP_INSTANCE,
+  path: path,
+  serviceId: serviceId,
+  vnfMembers: vnfMembers
+});
+
+
+
+
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/vnfGroup/vnfGroup.reducers.spec.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/vnfGroup/vnfGroup.reducers.spec.ts
new file mode 100644
index 000000000..16c1c45cd
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/vnfGroup/vnfGroup.reducers.spec.ts
@@ -0,0 +1,140 @@
+import {VnfGroupInstance} from "../../../models/vnfGroupInstance";
+import {
+  CreateVnfGroupInstanceAction,
+  DeleteActionVnfGroupInstanceAction,
+  SetOptionalMembersVnfGroupInstanceAction,
+  UpdateVnfGroupInstanceAction,
+  VnfGroupActions
+} from "./vnfGroup.actions";
+import {vnfGroupReducer} from "./vnfGroup.reducers";
+import {ServiceInstanceActions} from "../../../models/serviceInstanceActions";
+import {VnfMember} from "../../../models/VnfMember";
+
+
+describe('vnfGroupReducer', () => {
+  test('#CREATE_VNF_GROUP_INSTANCE', () => {
+    let vnfGroupInstance: VnfGroupInstance = new VnfGroupInstance();
+    vnfGroupInstance.isMissingData = false;
+    vnfGroupInstance.instanceName = 'instanceName';
+    let vnfGroupState = vnfGroupReducer(<any>{serviceInstance : {
+          'serviceModelId' : {
+            vnfGroups : {
+
+            }
+          }
+        }},
+      <CreateVnfGroupInstanceAction>{
+        type: VnfGroupActions.CREATE_VNF_GROUP_INSTANCE,
+        vnfGroupInstance : vnfGroupInstance,
+        vnfGroupStoreKey : null,
+        vnfGroupModelName : 'vnfGroupModelName',
+        serviceUuid : 'serviceModelId'
+      }).serviceInstance['serviceModelId'].vnfGroups['vnfGroupModelName'];
+
+    expect(vnfGroupState).toBeDefined();
+    expect(vnfGroupState.isMissingData).toBeFalsy();
+  });
+
+  test('#UPDATE_VNF_GROUP_INSTANCE', () => {
+    let vnfGroupInstance: VnfGroupInstance = new VnfGroupInstance();
+    vnfGroupInstance.isMissingData = false;
+    vnfGroupInstance.instanceName = 'instanceName';
+    let vnfGroupState = vnfGroupReducer(<any>{serviceInstance : {
+        'serviceModelId' : {
+          vnfGroups : {
+            'vnfGroupStoreKey' : {
+              isMissingData : true
+            }
+          }
+        }
+      }},
+      <UpdateVnfGroupInstanceAction>{
+        type: VnfGroupActions.UPDATE_VNF_GROUP_INSTANCE,
+        vnfGroupInstance : new VnfGroupInstance(),
+        vnfGroupStoreKey : 'vnfGroupStoreKey',
+        vnfGroupModelName : 'vnfGroupModelName',
+        serviceUuid : 'serviceModelId'
+      }).serviceInstance['serviceModelId'].vnfGroups['vnfGroupStoreKey'];
+
+    expect(vnfGroupState).toBeDefined();
+    expect(vnfGroupState.isMissingData).toBeFalsy();
+  });
+
+  test('#DELETE_ACTION_VNF_GROUP_INSTANCE', () => {
+    let vnfGroupInstance: VnfGroupInstance = new VnfGroupInstance();
+    vnfGroupInstance.isMissingData = false;
+    vnfGroupInstance.instanceName = 'instanceName';
+    vnfGroupInstance.action = ServiceInstanceActions.None;
+    let vnfGroupState = vnfGroupReducer(<any>{serviceInstance : {
+        'serviceModelId' : {
+          vnfGroups : {
+            'vnfGroupStoreKey' : {
+              isMissingData : true,
+              action : 'None'
+            }
+          }
+        }
+      }},
+      <DeleteActionVnfGroupInstanceAction>{
+        type: VnfGroupActions.DELETE_ACTION_VNF_GROUP_INSTANCE,
+        vnfGroupStoreKey: 'vnfGroupStoreKey',
+        serviceId: 'serviceModelId'
+      }).serviceInstance['serviceModelId'].vnfGroups['vnfGroupStoreKey'];
+
+    expect(vnfGroupState).toBeDefined();
+    expect(vnfGroupState.action).toEqual(ServiceInstanceActions.None_Delete);
+  });
+
+  test('#UNDO_DELETE_ACTION_VNF_GROUP_INSTANCE', () => {
+    let vnfGroupInstance: VnfGroupInstance = new VnfGroupInstance();
+    vnfGroupInstance.isMissingData = false;
+    vnfGroupInstance.instanceName = 'instanceName';
+    vnfGroupInstance.action = ServiceInstanceActions.None_Delete;
+    let vnfGroupState = vnfGroupReducer(<any>{serviceInstance : {
+          'serviceModelId' : {
+            vnfGroups : {
+              'vnfGroupStoreKey' : {
+                isMissingData : true,
+                action : 'None_Delete'
+              }
+            }
+          }
+        }},
+      <DeleteActionVnfGroupInstanceAction>{
+        type: VnfGroupActions.UNDO_DELETE_ACTION_VNF_GROUP_INSTANCE,
+        vnfGroupStoreKey: 'vnfGroupStoreKey',
+        serviceId: 'serviceModelId'
+      }).serviceInstance['serviceModelId'].vnfGroups['vnfGroupStoreKey'];
+
+    expect(vnfGroupState).toBeDefined();
+    expect(vnfGroupState.action).toEqual(ServiceInstanceActions.None);
+  });
+
+  test('#SET_OPTIONAL_MEMBERS_VNF_GROUP_INSTANCE', () => {
+    let vnf1: VnfMember = new VnfMember();
+    vnf1.serviceInstanceId = 'aa';
+    vnf1.instanceId = 'aaa';
+    let vnf2: VnfMember = new VnfMember();
+    vnf2.serviceInstanceId = 'bb';
+    vnf2.instanceId = 'bbb';
+    let optionalGroupMembersMap = vnfGroupReducer(<any>{
+        serviceInstance: {
+          'serviceModelId': {
+            optionalGroupMembersMap : {}
+          }
+        }
+      },
+      <SetOptionalMembersVnfGroupInstanceAction>{
+        type: VnfGroupActions.SET_OPTIONAL_MEMBERS_VNF_GROUP_INSTANCE,
+        path: 'path1',
+        serviceId: 'serviceModelId',
+        vnfMembers: [vnf1, vnf2]
+      }).serviceInstance['serviceModelId'].optionalGroupMembersMap;
+
+    optionalGroupMembersMap['path1']= [vnf1, vnf2];
+    expect(optionalGroupMembersMap).toEqual({'path1':[vnf1, vnf2]});
+  });
+});
+
+
+
diff --git a/vid-webpack-master/src/app/shared/storeUtil/utils/vnfGroup/vnfGroup.reducers.ts b/vid-webpack-master/src/app/shared/storeUtil/utils/vnfGroup/vnfGroup.reducers.ts
new file mode 100644
index 000000000..2923c09b2
--- /dev/null
+++ b/vid-webpack-master/src/app/shared/storeUtil/utils/vnfGroup/vnfGroup.reducers.ts
@@ -0,0 +1,108 @@
+import {Action} from "redux";
+import {VnfGroupInstance} from "../../../models/vnfGroupInstance";
+import * as _ from "lodash";
+import {ServiceInstance} from "../../../models/serviceInstance";
+import {ServiceState} from "../main.reducer";
+import {
+  CreateVnfGroupInstanceAction,
+  DeleteActionVnfGroupInstanceAction, SetOptionalMembersVnfGroupInstanceAction,
+  UpdateVnfGroupInstanceAction,
+  VnfGroupActions
+} from "./vnfGroup.actions";
+import {ServiceInstanceActions} from "../../../models/serviceInstanceActions";
+
+export function vnfGroupReducer(state: ServiceState, action: Action): ServiceState {
+  switch (action.type) {
+    case VnfGroupActions.CREATE_VNF_GROUP_INSTANCE: {
+      const updateVnfGroupInstanceAction = <CreateVnfGroupInstanceAction>action;
+      const serviceUuid = updateVnfGroupInstanceAction.serviceUuid;
+      let vnfGroupModelName = updateVnfGroupInstanceAction.vnfGroupModelName;
+      let newState = _.cloneDeep(state);
+
+      updateVnfGroupInstanceAction.vnfGroupInstance.originalName = vnfGroupModelName;
+      updateVnfGroupInstanceAction.vnfGroupModelName = calculateNextUniqueModelName(vnfGroupModelName, serviceUuid, newState, 'vnfGroups');
+
+      let vnfGroupInstance: VnfGroupInstance = newState.serviceInstance[serviceUuid].vnfGroups[vnfGroupModelName];
+      vnfGroupInstance = new VnfGroupInstance();
+      updateVnfGroupInstanceAction.vnfGroupInstance.vnfGroupStoreKey = updateVnfGroupInstanceAction.vnfGroupModelName;
+      updateVnfGroupInstanceAction.vnfGroupInstance.originalName = vnfGroupModelName;
+      vnfGroupInstance.originalName = updateVnfGroupInstanceAction.vnfGroupInstance.originalName;
+      vnfGroupInstance.vnfGroupStoreKey = updateVnfGroupInstanceAction.vnfGroupInstance.vnfGroupStoreKey;
+      updateServiceValidationCounter(newState, vnfGroupInstance['isMissingData'], updateVnfGroupInstanceAction.vnfGroupInstance['isMissingData'], serviceUuid);
+
+      newState.serviceInstance[serviceUuid].vnfGroups[updateVnfGroupInstanceAction.vnfGroupModelName] = Object.assign(vnfGroupInstance, updateVnfGroupInstanceAction.vnfGroupInstance);
+      return newState;
+    }
+    case VnfGroupActions.UPDATE_VNF_GROUP_INSTANCE: {
+      const updateVnfInstanceAction = <UpdateVnfGroupInstanceAction>action;
+      const serviceUuid = updateVnfInstanceAction.serviceUuid;
+      let vnfGroupStoreKey = updateVnfInstanceAction.vnfGroupStoreKey;
+
+
+      let newState = _.cloneDeep(state);
+      let vnfGroupInstance: VnfGroupInstance = newState.serviceInstance[serviceUuid].vnfGroups[vnfGroupStoreKey];
+      updateUniqueNames(vnfGroupInstance ? vnfGroupInstance.instanceName : null, updateVnfInstanceAction.vnfGroupInstance.instanceName, newState.serviceInstance[serviceUuid]);
+
+      vnfGroupInstance = vnfGroupInstance || new VnfGroupInstance();
+      updateServiceValidationCounter(newState, vnfGroupInstance['isMissingData'], updateVnfInstanceAction.vnfGroupInstance['isMissingData'], serviceUuid);
+
+      newState.serviceInstance[serviceUuid].vnfGroups[vnfGroupStoreKey] = Object.assign(vnfGroupInstance, updateVnfInstanceAction.vnfGroupInstance);
+      return newState;
+    }
+    case VnfGroupActions.DELETE_ACTION_VNF_GROUP_INSTANCE : {
+      let newState = _.cloneDeep(state);
+      let oldAction = newState.serviceInstance[(<DeleteActionVnfGroupInstanceAction>action).serviceId].vnfGroups[(<DeleteActionVnfGroupInstanceAction>action).vnfGroupStoreKey].action;
+      if(oldAction === ServiceInstanceActions.None_Delete || oldAction === ServiceInstanceActions.Update_Delete) return newState;
+      newState.serviceInstance[(<DeleteActionVnfGroupInstanceAction>action).serviceId].vnfGroups[(<DeleteActionVnfGroupInstanceAction>action).vnfGroupStoreKey].action = (oldAction + '_Delete') as ServiceInstanceActions;
+      return newState;
+    }
+    case VnfGroupActions.UNDO_DELETE_ACTION_VNF_GROUP_INSTANCE : {
+      let newState = _.cloneDeep(state);
+      let oldState = newState.serviceInstance[(<DeleteActionVnfGroupInstanceAction>action).serviceId].vnfGroups[(<DeleteActionVnfGroupInstanceAction>action).vnfGroupStoreKey].action;
+      newState.serviceInstance[(<DeleteActionVnfGroupInstanceAction>action).serviceId].vnfGroups[(<DeleteActionVnfGroupInstanceAction>action).vnfGroupStoreKey].action = (oldState.split('_')[0]) as ServiceInstanceActions;
+      return newState;
+    }
+    case VnfGroupActions.SET_OPTIONAL_MEMBERS_VNF_GROUP_INSTANCE:{
+      let newState = _.cloneDeep(state);
+      newState.serviceInstance[(<SetOptionalMembersVnfGroupInstanceAction>action).serviceId].optionalGroupMembersMap[(<SetOptionalMembersVnfGroupInstanceAction>action).path] = (<SetOptionalMembersVnfGroupInstanceAction>action).vnfMembers;
+      return newState;
+    }
+  }
+}
+
+const updateServiceValidationCounter = (newState: any, oldValidationState: boolean, newValidationState: boolean, serviceUuid: string) => {
+  if (oldValidationState && !newValidationState) {
+    newState.serviceInstance[serviceUuid].validationCounter--;
+  } else if (!oldValidationState && newValidationState) {
+    newState.serviceInstance[serviceUuid].validationCounter++;
+  }
+};
+
+
+const updateUniqueNames = (oldName: string, newName: string, serviceInstance: ServiceInstance): void => {
+  let existingNames = serviceInstance.existingNames;
+  if (!_.isNil(oldName) && oldName.toLowerCase() in existingNames) {
+    delete existingNames[oldName.toLowerCase()];
+  }
+  if (!_.isNil(newName)) {
+    existingNames[newName.toLowerCase()] = "";
+  }
+};
+
+
+export const calculateNextUniqueModelName = (vnfGroupModelName: string, serviceId: string, state: any, levelName: string): string => {
+  let counter: number = null;
+  while (true) {
+    let pattern = !_.isNil(counter) ? ("_" + counter) : "";
+    if (!_.isNil(state.serviceInstance[serviceId][levelName][vnfGroupModelName + pattern])) {
+      counter = counter ? (counter + 1) : 1;
+    } else {
+      return vnfGroupModelName + pattern;
+    }
+  }
+};
+
+
+
+
+