Replaced old implementation at root

Old project files and directories has been moved
under 'deprecated-workflow-designer'. The old project
is not built by the CI anymore, but can be still built manually.
New modules/directories have been moved up and integrated with
the CI system.

Change-Id: I1528c792bcbcce9e50bfc294a1328a20e72c91cf
Issue-ID: SDC-1559
Signed-off-by: vempo <vitaliy.emporopulo@amdocs.com>

58 files changed, 4072 insertions, 0 deletions

diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/RestUtils.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/RestUtils.java
new file mode 100644
index 00000000..b6259ccc
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/RestUtils.java
@@ -0,0 +1,31 @@
+package org.onap.sdc.workflow;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Set;
+import java.util.stream.Collectors;
+import org.onap.sdc.workflow.persistence.types.WorkflowVersionState;
+import org.openecomp.sdc.logging.api.Logger;
+import org.openecomp.sdc.logging.api.LoggerFactory;
+
+public class RestUtils {
+
+    private RestUtils() {
+    }
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(RestUtils.class);
+
+    public static Set<WorkflowVersionState> mapVersionStateFilter(String versionStateFilter) {
+        Set<WorkflowVersionState> filter;
+        try {
+            filter = versionStateFilter == null ? null :
+                             Arrays.stream(versionStateFilter.split(",")).map(WorkflowVersionState::valueOf)
+                                   .collect(Collectors.toSet());
+        } catch (Exception e) {
+            LOGGER.info(
+                    "version state filter value is invalid and cannot be mapped to a set of version states, therefore it is set to empty set");
+            filter = Collections.emptySet();
+        }
+        return filter;
+    }
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/SpringBootWebApplication.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/SpringBootWebApplication.java
new file mode 100644
index 00000000..0feafd2a
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/SpringBootWebApplication.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.web.embedded.jetty.JettyServletWebServerFactory;
+import org.springframework.boot.web.servlet.server.ConfigurableServletWebServerFactory;
+import org.springframework.context.annotation.Bean;
+
+@SpringBootApplication
+public class SpringBootWebApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(SpringBootWebApplication.class, args);
+    }
+
+    @Bean
+    public ConfigurableServletWebServerFactory webServerFactory() {
+        return new JettyServletWebServerFactory();
+    }
+
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/RestConstants.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/RestConstants.java
new file mode 100644
index 00000000..817bebe1
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/RestConstants.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.api;
+
+public class RestConstants {
+
+    private RestConstants() {
+    }
+
+    public static final String USER_ID_HEADER_PARAM = "USER_ID";
+    public static final String SIZE_PARAM = "size";
+    public static final String PAGE_PARAM = "page";
+    public static final String SORT_PARAM = "sort";
+    public static final String SORT_FIELD_NAME = "name";
+    public static final int SIZE_DEFAULT = 20;
+    public static final int PAGE_DEFAULT = 0;
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/WorkflowController.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/WorkflowController.java
new file mode 100644
index 00000000..7027985f
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/WorkflowController.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.api;
+
+import static org.onap.sdc.workflow.RestUtils.mapVersionStateFilter;
+import static org.onap.sdc.workflow.api.RestConstants.SIZE_DEFAULT;
+import static org.onap.sdc.workflow.api.RestConstants.SORT_FIELD_NAME;
+import static org.onap.sdc.workflow.api.RestConstants.SORT_PARAM;
+import static org.onap.sdc.workflow.api.RestConstants.USER_ID_HEADER_PARAM;
+
+import com.google.common.collect.ImmutableSet;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+import java.util.Arrays;
+import java.util.Set;
+import org.onap.sdc.workflow.api.types.CollectionWrapper;
+import org.onap.sdc.workflow.persistence.types.Workflow;
+import org.onap.sdc.workflow.services.WorkflowManager;
+import org.onap.sdc.workflow.services.exceptions.InvalidPaginationParameterException;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.web.PageableDefault;
+import org.springframework.data.web.SortDefault;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestHeader;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+@RequestMapping("/workflows")
+@Api("Workflows")
+@RestController("workflowController")
+public class WorkflowController {
+
+    private final WorkflowManager workflowManager;
+
+    @Autowired
+    public WorkflowController(@Qualifier("workflowManager") WorkflowManager workflowManager) {
+        this.workflowManager = workflowManager;
+    }
+
+    @GetMapping(produces = MediaType.APPLICATION_JSON_VALUE)
+    @ApiOperation("List workflows")
+    public CollectionWrapper<Workflow> list(
+            @ApiParam(value = "Filter by version state", allowableValues = "DRAFT,CERTIFIED")
+            @RequestParam(value = "versionState", required = false) String versionStateFilter,
+            @PageableDefault(size = SIZE_DEFAULT)
+            @SortDefault.SortDefaults({@SortDefault(sort = SORT_FIELD_NAME, direction = Sort.Direction.ASC)})
+                    Pageable pageable, @RequestHeader(USER_ID_HEADER_PARAM) String user) {
+        PageRequest pageRequest = createPageRequest(pageable);
+        return new CollectionWrapper<>(pageRequest.getPageSize(), pageRequest.getPageNumber(),
+                workflowManager.list(mapVersionStateFilter(versionStateFilter), pageRequest));
+    }
+
+    @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE)
+    @ApiOperation("Create workflow")
+    public ResponseEntity<Workflow> create(@Validated @RequestBody Workflow workflow,
+            @RequestHeader(USER_ID_HEADER_PARAM) String user) {
+        return new ResponseEntity<>(workflowManager.create(workflow), HttpStatus.CREATED);
+    }
+
+    @GetMapping(path = "/{workflowId}")
+    @ApiOperation("Get workflow")
+    public Workflow get(@PathVariable("workflowId") String workflowId,
+            @RequestHeader(USER_ID_HEADER_PARAM) String user) {
+        Workflow workflow = new Workflow();
+        workflow.setId(workflowId);
+        return workflowManager.get(workflow);
+    }
+
+    @PutMapping(path = "/{workflowId}", consumes = MediaType.APPLICATION_JSON_VALUE)
+    @ApiOperation("Update workflow")
+    public Workflow update(@RequestBody Workflow workflow, @PathVariable("workflowId") String workflowId,
+            @RequestHeader(USER_ID_HEADER_PARAM) String user) {
+        workflow.setId(workflowId);
+        workflowManager.update(workflow);
+        return workflow;
+    }
+
+
+    private PageRequest createPageRequest(Pageable pageable) {
+        Set<String> validSortFields = ImmutableSet.of(SORT_FIELD_NAME);
+        Sort sort = pageable.getSort();
+        for (Sort.Order order : sort) {
+            String sortFieldName = order.getProperty();
+            if (!sortFieldName.equalsIgnoreCase(SORT_FIELD_NAME)) {
+                throw new InvalidPaginationParameterException(SORT_PARAM, sortFieldName,
+                        "is not supported. Supported values are: " + Arrays.toString(validSortFields.toArray()));
+            }
+        }
+        return PageRequest.of(pageable.getPageNumber(), pageable.getPageSize(), sort);
+    }
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/WorkflowVersionController.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/WorkflowVersionController.java
new file mode 100644
index 00000000..91995bd0
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/WorkflowVersionController.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.api;
+
+import static org.onap.sdc.workflow.RestUtils.mapVersionStateFilter;
+import static org.onap.sdc.workflow.api.RestConstants.USER_ID_HEADER_PARAM;
+
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+import org.onap.sdc.workflow.api.types.CollectionWrapper;
+import org.onap.sdc.workflow.api.types.VersionStateDto;
+import org.onap.sdc.workflow.persistence.types.ArtifactEntity;
+import org.onap.sdc.workflow.persistence.types.WorkflowVersion;
+import org.onap.sdc.workflow.services.WorkflowVersionManager;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.core.io.InputStreamResource;
+import org.springframework.core.io.Resource;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.Validator;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.WebDataBinder;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.InitBinder;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestHeader;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.multipart.MultipartFile;
+
+@RequestMapping("/workflows/{workflowId}/versions")
+@Api("Workflow versions")
+@RestController("workflowsVersionController")
+public class WorkflowVersionController {
+
+    private final WorkflowVersionManager workflowVersionManager;
+    private Validator validator;
+
+    @InitBinder
+    private void initBinder(WebDataBinder binder) {
+        binder.addValidators(validator);
+    }
+
+    @Autowired
+    public WorkflowVersionController(
+            @Qualifier("workflowVersionManager") WorkflowVersionManager workflowVersionManager,
+            @Qualifier("workflowVersionValidator") Validator validator ) {
+        this.workflowVersionManager = workflowVersionManager;
+        this.validator = validator;
+    }
+
+    @GetMapping
+    @ApiOperation("List workflow versions")
+    public CollectionWrapper<WorkflowVersion> list(@PathVariable("workflowId") String workflowId,
+            @ApiParam(value = "Filter by state", allowableValues = "DRAFT,CERTIFIED")
+            @RequestParam(value = "state", required = false) String stateFilter,
+            @RequestHeader(USER_ID_HEADER_PARAM) String user) {
+        return new CollectionWrapper<>(workflowVersionManager.list(workflowId, mapVersionStateFilter(stateFilter)));
+    }
+
+    @PostMapping
+    @ApiOperation("Create workflow version")
+    public ResponseEntity<WorkflowVersion> create(@RequestBody @Validated WorkflowVersion version,
+            @PathVariable("workflowId") String workflowId,
+            @RequestParam(value = "baseVersionId", required = false) String baseVersionId,
+            @RequestHeader(USER_ID_HEADER_PARAM) String user) {
+        WorkflowVersion createdVersion = workflowVersionManager.create(workflowId, baseVersionId, version);
+        return new ResponseEntity<>(createdVersion, HttpStatus.CREATED);
+    }
+
+    @GetMapping("/{versionId}")
+    @ApiOperation("Get workflow version")
+    public WorkflowVersion get(@PathVariable("workflowId") String workflowId,
+            @PathVariable("versionId") String versionId, @RequestHeader(USER_ID_HEADER_PARAM) String user) {
+        return workflowVersionManager.get(workflowId, versionId);
+    }
+
+    @PutMapping("/{versionId}")
+    @ApiOperation("Update workflow version")
+    public void update(@RequestBody @Validated WorkflowVersion version, @PathVariable("workflowId") String workflowId,
+            @PathVariable("versionId") String versionId, @RequestHeader(USER_ID_HEADER_PARAM) String user) {
+        version.setId(versionId);
+        workflowVersionManager.update(workflowId, version);
+    }
+
+    @GetMapping("/{versionId}/state")
+    @ApiOperation("Get workflow version state")
+    public VersionStateDto getState(@PathVariable("workflowId") String workflowId,
+            @PathVariable("versionId") String versionId, @RequestHeader(USER_ID_HEADER_PARAM) String user) {
+        return new VersionStateDto(workflowVersionManager.getState(workflowId, versionId));
+    }
+
+    @PostMapping("/{versionId}/state")
+    @ApiOperation("Update workflow version state")
+    public VersionStateDto updateState(@RequestBody VersionStateDto state,
+            @PathVariable("workflowId") String workflowId, @PathVariable("versionId") String versionId,
+            @RequestHeader(USER_ID_HEADER_PARAM) String user) {
+        workflowVersionManager.updateState(workflowId, versionId, state.getName());
+        return new VersionStateDto(state.getName());
+    }
+
+    @PutMapping("/{versionId}/artifact")
+    @ApiOperation("Create/update artifact of a version")
+    public void uploadArtifact(@RequestBody MultipartFile fileToUpload, @PathVariable("workflowId") String workflowId,
+            @PathVariable("versionId") String versionId, @RequestHeader(USER_ID_HEADER_PARAM) String user) {
+        workflowVersionManager.uploadArtifact(workflowId, versionId, fileToUpload);
+    }
+
+    @GetMapping("/{versionId}/artifact")
+    @ApiOperation("Download workflow version artifact")
+    public ResponseEntity<Resource> getArtifact(@PathVariable("workflowId") String workflowId,
+            @PathVariable("versionId") String versionId, @RequestHeader(USER_ID_HEADER_PARAM) String user) {
+        ArtifactEntity artifact = workflowVersionManager.getArtifact(workflowId, versionId);
+
+        return ResponseEntity.ok()
+                             .header(HttpHeaders.CONTENT_DISPOSITION, "attachment;filename=" + artifact.getFileName())
+                             .contentType(MediaType.APPLICATION_OCTET_STREAM)
+                             .body(new InputStreamResource(artifact.getArtifactData()));
+    }
+
+    @DeleteMapping("/{versionId}/artifact")
+    @ApiOperation("Delete workflow version artifact")
+    public void deleteArtifact(@PathVariable("workflowId") String workflowId,
+            @PathVariable("versionId") String versionId, @RequestHeader(USER_ID_HEADER_PARAM) String user) {
+        workflowVersionManager.deleteArtifact(workflowId, versionId);
+    }
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/exceptionshandlers/CustomizedResponseEntityExceptionHandler.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/exceptionshandlers/CustomizedResponseEntityExceptionHandler.java
new file mode 100644
index 00000000..ca6111df
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/exceptionshandlers/CustomizedResponseEntityExceptionHandler.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.api.exceptionshandlers;
+
+import static org.springframework.http.HttpStatus.BAD_REQUEST;
+import static org.springframework.http.HttpStatus.FORBIDDEN;
+import static org.springframework.http.HttpStatus.NOT_FOUND;
+import static org.springframework.http.HttpStatus.UNPROCESSABLE_ENTITY;
+
+import org.onap.sdc.workflow.services.exceptions.EntityNotFoundException;
+import org.onap.sdc.workflow.services.exceptions.InvalidArtifactException;
+import org.onap.sdc.workflow.services.exceptions.InvalidPaginationParameterException;
+import org.onap.sdc.workflow.services.exceptions.UniqueValueViolationException;
+import org.onap.sdc.workflow.services.exceptions.VersionCreationException;
+import org.onap.sdc.workflow.services.exceptions.VersionModificationException;
+import org.onap.sdc.workflow.services.exceptions.VersionStateModificationException;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.FieldError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.ServletRequestBindingException;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.context.request.WebRequest;
+import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;
+
+@ControllerAdvice
+@RestController
+public class CustomizedResponseEntityExceptionHandler extends ResponseEntityExceptionHandler {
+
+    @ExceptionHandler(UniqueValueViolationException.class)
+    public final ResponseEntity<String> handleUniqueValueViolationException(
+            UniqueValueViolationException exception) {
+        return new ResponseEntity<>(exception.getMessage(), UNPROCESSABLE_ENTITY);
+    }
+
+    @ExceptionHandler(EntityNotFoundException.class)
+    public final ResponseEntity<String> handleWorkflowNotFoundException(
+            Exception exception) {
+        return new ResponseEntity<>(exception.getMessage(), NOT_FOUND);
+    }
+
+    @ExceptionHandler({InvalidPaginationParameterException.class})
+    public final ResponseEntity<String> handlePaginationException(InvalidPaginationParameterException exception) {
+        return new ResponseEntity<>(exception.getMessage(), BAD_REQUEST);
+    }
+
+    //For workflowVersionValidator exception
+    @Override
+    protected final ResponseEntity<Object> handleMethodArgumentNotValid(final MethodArgumentNotValidException e,
+            final HttpHeaders headers,
+            final HttpStatus status,
+            final WebRequest request) {
+
+        FieldError result = e.getBindingResult().getFieldError();
+       return new ResponseEntity<>(result.getDefaultMessage(), BAD_REQUEST);
+    }
+
+    //For missing header exceptions
+    @Override
+    public ResponseEntity<Object> handleServletRequestBindingException(ServletRequestBindingException ex,
+                                                                       HttpHeaders headers, HttpStatus status,
+                                                                       WebRequest request) {
+        return new ResponseEntity<>(ex.getMessage(), BAD_REQUEST);
+    }
+
+
+    @ExceptionHandler({InvalidArtifactException.class, VersionModificationException.class,
+            VersionStateModificationException.class})
+    public final ResponseEntity<String> handleInvalidArtifactException(
+            Exception exception) {
+        return new ResponseEntity<>(exception.getMessage(), UNPROCESSABLE_ENTITY);
+    }
+
+
+    @ExceptionHandler(VersionCreationException.class)
+    public final ResponseEntity<String> handleVersioningErrorException(
+            VersionCreationException exception) {
+        return new ResponseEntity<>(exception.getMessage(), FORBIDDEN);
+    }
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/types/CollectionWrapper.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/types/CollectionWrapper.java
new file mode 100644
index 00000000..1e11bc90
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/types/CollectionWrapper.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.api.types;
+
+import java.util.Collection;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+public class CollectionWrapper<T> {
+
+    private int total;
+    private int size;
+    private int page;
+    private Collection<T> results;
+
+    public CollectionWrapper(int size, int page, Collection<T> results) {
+        this.results = results;
+        this.size = size;
+        this.page = page;
+        this.total = results.size();
+    }
+
+    public CollectionWrapper(Collection<T> results) {
+        this.results = results;
+        this.total = results.size();
+    }
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/types/VersionStateDto.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/types/VersionStateDto.java
new file mode 100644
index 00000000..a7f43cdd
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/types/VersionStateDto.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.api.types;
+
+import java.util.List;
+import lombok.Data;
+import org.onap.sdc.workflow.persistence.types.WorkflowVersionState;
+
+@Data
+public class VersionStateDto {
+
+    private WorkflowVersionState name;
+    private List<WorkflowVersionState> nextStates;
+
+    public VersionStateDto() {
+    }
+
+    public VersionStateDto(WorkflowVersionState state) {
+        name = state;
+        nextStates = state.getNextStates();
+    }
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/validator/WorkflowVersionValidator.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/validator/WorkflowVersionValidator.java
new file mode 100644
index 00000000..03101042
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/validator/WorkflowVersionValidator.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.api.validator;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Objects;
+import java.util.Set;
+import org.onap.sdc.workflow.persistence.types.ParameterEntity;
+import org.onap.sdc.workflow.persistence.types.WorkflowVersion;
+import org.springframework.stereotype.Component;
+import org.springframework.validation.Errors;
+import org.springframework.validation.Validator;
+
+
+@Component("workflowVersionValidator")
+public class WorkflowVersionValidator implements Validator{
+
+    @Override
+    public boolean supports(Class<?> aClass) {
+        return WorkflowVersion.class.equals(aClass);
+    }
+
+    @Override
+    public void validate(Object o, Errors errors) {
+
+        WorkflowVersion workflowVersion = (WorkflowVersion) o;
+        Collection<ParameterEntity> inputs = workflowVersion.getInputs();
+        Collection<ParameterEntity> outputs = workflowVersion.getOutputs();
+
+        if(containsDuplicates(inputs)){
+            errors.rejectValue("inputs", "duplicateName", new Object[] {inputs}, "Input name must be unique");
+        }
+
+        if(containsDuplicates(outputs)){
+            errors.rejectValue("outputs", "duplicateName", new Object[] {outputs}, "Output name must be unique");
+        }
+    }
+
+    private boolean containsDuplicates(Collection<ParameterEntity> parameters){
+        if(Objects.isNull(parameters) ||  parameters.size() < 2 ) {
+            return false;
+        }
+        Set<String> testSet = new HashSet<>();
+      return parameters.stream().anyMatch(s -> !testSet.add(s.getName()));
+    }
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/ArtifactRepository.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/ArtifactRepository.java
new file mode 100644
index 00000000..ed9371e6
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/ArtifactRepository.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.persistence;
+
+
+import java.util.Optional;
+import org.onap.sdc.workflow.persistence.types.ArtifactEntity;
+
+
+public interface ArtifactRepository {
+
+    void update(String id, String versionId,ArtifactEntity artifactEntity);
+
+    Optional<ArtifactEntity> get(String id, String versionId);
+
+    void createStructure(String id, String versionId);
+
+    void delete(String id, String versionId);
+
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/ParameterRepository.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/ParameterRepository.java
new file mode 100644
index 00000000..9f7fb1ad
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/ParameterRepository.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.persistence;
+
+import java.util.Collection;
+import org.onap.sdc.workflow.persistence.types.ParameterEntity;
+import org.onap.sdc.workflow.persistence.types.ParameterRole;
+
+
+public interface ParameterRepository {
+
+    void createStructure(String id, String versionId);
+
+    Collection<ParameterEntity> list(String id, String versionId, ParameterRole role);
+
+    void deleteAll(String id, String versionId, ParameterRole role);
+
+    ParameterEntity get(String id, String versionId, String parameterId);
+
+    void delete(String id, String versionId, String parameterId);
+
+    ParameterEntity create(String id, String versionId , ParameterRole role, ParameterEntity parameter);
+
+    void update(String id, String versionId, ParameterRole role, ParameterEntity parameter);
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/UniqueValueRepository.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/UniqueValueRepository.java
new file mode 100644
index 00000000..cf7b0633
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/UniqueValueRepository.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.persistence;
+
+import org.onap.sdc.workflow.persistence.types.UniqueValueEntity;
+import org.springframework.data.cassandra.repository.CassandraRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface UniqueValueRepository extends CassandraRepository<UniqueValueEntity, UniqueValueEntity> {
+
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/impl/ArtifactRepositoryImpl.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/impl/ArtifactRepositoryImpl.java
new file mode 100644
index 00000000..3c528db1
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/impl/ArtifactRepositoryImpl.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.persistence.impl;
+
+import static org.openecomp.core.zusammen.api.ZusammenUtil.buildStructuralElement;
+import static org.openecomp.core.zusammen.api.ZusammenUtil.createSessionContext;
+
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.Element;
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.ZusammenElement;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.item.Action;
+import com.amdocs.zusammen.datatypes.item.ElementContext;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
+import java.util.Optional;
+import org.apache.commons.io.IOUtils;
+import org.onap.sdc.workflow.persistence.ArtifactRepository;
+import org.onap.sdc.workflow.persistence.types.ArtifactEntity;
+import org.onap.sdc.workflow.persistence.types.WorkflowElementType;
+import org.openecomp.core.zusammen.api.ZusammenAdaptor;
+import org.openecomp.core.zusammen.api.ZusammenAdaptorFactory;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public class ArtifactRepositoryImpl implements ArtifactRepository {
+
+    private static final String FILE_NAME_PROPERTY = "fileName";
+    private static final String EMPTY_DATA = "{}";
+    private ZusammenAdaptor zusammenAdaptor = ZusammenAdaptorFactory.getInstance().createInterface();
+
+
+    @Override
+    public void update(String id, String versionId, ArtifactEntity artifactEntity) {
+
+        ZusammenElement artifactElement = buildStructuralElement(WorkflowElementType.ARTIFACT.name(), Action.UPDATE);
+        artifactElement.setData(artifactEntity.getArtifactData());
+        artifactElement.getInfo().addProperty(FILE_NAME_PROPERTY, artifactEntity.getFileName());
+
+        SessionContext context = createSessionContext();
+        ElementContext elementContext = new ElementContext(id, versionId);
+
+        zusammenAdaptor
+                .saveElement(context, elementContext, artifactElement, "Update WorkflowVersion Artifact Element");
+    }
+
+    @Override
+    public Optional<ArtifactEntity> get(String id, String versionId) {
+        SessionContext context = createSessionContext();
+        ElementContext elementContext = new ElementContext(id, versionId);
+
+        Optional<Element> elementOptional =
+                zusammenAdaptor.getElementByName(context, elementContext, null, WorkflowElementType.ARTIFACT.name());
+
+        if (!elementOptional.isPresent() || hasEmptyData(elementOptional.get().getData())) {
+            return Optional.empty();
+        }
+
+        Element artifactElement = elementOptional.get();
+
+        ArtifactEntity artifact = new ArtifactEntity(artifactElement.getInfo().getProperty(FILE_NAME_PROPERTY),
+                artifactElement.getData());
+
+        return Optional.of(artifact);
+    }
+
+    @Override
+    public void createStructure(String id, String versionId) {
+        SessionContext context = createSessionContext();
+        ElementContext elementContext = new ElementContext(id, versionId);
+
+        ZusammenElement artifactElement = buildStructuralElement(WorkflowElementType.ARTIFACT.name(), Action.CREATE);
+        artifactElement.setData(new ByteArrayInputStream(EMPTY_DATA.getBytes()));
+
+        zusammenAdaptor
+                .saveElement(context, elementContext, artifactElement, "Create WorkflowVersion Artifact Element");
+
+    }
+
+    @Override
+    public void delete(String id, String versionId) {
+        SessionContext context = createSessionContext();
+        ElementContext elementContext = new ElementContext(id, versionId);
+
+        ZusammenElement artifactElement = buildStructuralElement(WorkflowElementType.ARTIFACT.name(), Action.UPDATE);
+        artifactElement.setData(new ByteArrayInputStream(EMPTY_DATA.getBytes()));
+        artifactElement.getInfo().getProperties().remove(FILE_NAME_PROPERTY);
+
+        zusammenAdaptor
+                .saveElement(context, elementContext, artifactElement, "Delete WorkflowVersion Artifact Data");
+
+    }
+
+    private boolean hasEmptyData(InputStream elementData) {
+
+        byte[] byteElementData;
+        try {
+            byteElementData = IOUtils.toByteArray(elementData);
+        } catch (IOException ex) {
+            return false;
+        }
+        return Arrays.equals(EMPTY_DATA.getBytes(), byteElementData);
+    }
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/impl/ParameterRepositoryImpl.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/impl/ParameterRepositoryImpl.java
new file mode 100644
index 00000000..468e93fe
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/impl/ParameterRepositoryImpl.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.persistence.impl;
+
+import static org.openecomp.core.zusammen.api.ZusammenUtil.buildElement;
+import static org.openecomp.core.zusammen.api.ZusammenUtil.buildStructuralElement;
+import static org.openecomp.core.zusammen.api.ZusammenUtil.createSessionContext;
+
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.Element;
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementInfo;
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.ZusammenElement;
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.item.Action;
+import com.amdocs.zusammen.datatypes.item.ElementContext;
+import com.amdocs.zusammen.datatypes.item.Info;
+import java.util.Collection;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import org.onap.sdc.workflow.persistence.ParameterRepository;
+import org.onap.sdc.workflow.persistence.types.ParameterEntity;
+import org.onap.sdc.workflow.persistence.types.ParameterPropertyName;
+import org.onap.sdc.workflow.persistence.types.ParameterRole;
+import org.onap.sdc.workflow.persistence.types.ParameterType;
+import org.onap.sdc.workflow.persistence.types.WorkflowElementType;
+import org.openecomp.core.zusammen.api.ZusammenAdaptor;
+import org.openecomp.core.zusammen.api.ZusammenAdaptorFactory;
+import org.openecomp.types.ElementPropertyName;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public class ParameterRepositoryImpl implements ParameterRepository {
+
+    private ZusammenAdaptor zusammenAdaptor = ZusammenAdaptorFactory.getInstance().createInterface();
+
+    @Override
+    public void createStructure(String id, String versionId) {
+
+        SessionContext context = createSessionContext();
+        ElementContext elementContext = new ElementContext(id, versionId);
+
+        ZusammenElement inputsElement = buildStructuralElement(WorkflowElementType.INPUTS.name(), Action.CREATE);
+        ZusammenElement outputsElement = buildStructuralElement(WorkflowElementType.OUTPUTS.name(), Action.CREATE);
+
+        zusammenAdaptor.saveElement(context, elementContext, inputsElement, "Create WorkflowVersion INPUTS Element");
+        zusammenAdaptor.saveElement(context, elementContext, outputsElement, "Create WorkflowVersion OUTPUTS Element");
+    }
+
+    @Override
+    public Collection<ParameterEntity> list(String id, String versionId, ParameterRole role) {
+
+        SessionContext context = createSessionContext();
+        ElementContext elementContext = new ElementContext(id, versionId);
+
+        return zusammenAdaptor.listElementsByName(context, elementContext, null, getParentElementType(role)).stream()
+                              .map(this::mapElementInfoToParameter).collect(Collectors.toList());
+
+    }
+
+    @Override
+    public void deleteAll(String id, String versionId, ParameterRole role) {
+
+        SessionContext context = createSessionContext();
+        ElementContext elementContext = new ElementContext(id, versionId);
+
+        Optional<ElementInfo> optionalParentElement =
+                zusammenAdaptor.getElementInfoByName(context, elementContext, null, getParentElementType(role));
+
+        if (!optionalParentElement.isPresent()) {
+            return;
+        }
+        ZusammenElement parentElement = buildElement(optionalParentElement.get().getId(), Action.IGNORE);
+        parentElement.setSubElements(optionalParentElement.get().getSubElements().stream()
+                                                          .map(parameter -> buildElement(parameter.getId(),
+                                                                  Action.DELETE)).collect(Collectors.toList()));
+
+        zusammenAdaptor.saveElement(context, elementContext, parentElement, "Delete all " + role);
+    }
+
+    @Override
+    public ParameterEntity get(String id, String versionId, String parameterId) {
+
+        SessionContext context = createSessionContext();
+        ElementContext elementContext = new ElementContext(id, versionId);
+
+        Optional<ElementInfo> element = zusammenAdaptor.getElementInfo(context, elementContext, new Id(parameterId));
+
+        return element.map(this::mapElementInfoToParameter).orElse(null);
+    }
+
+    @Override
+    public void delete(String id, String versionId, String parameterId) {
+        SessionContext context = createSessionContext();
+        ElementContext elementContext = new ElementContext(id, versionId);
+
+        ZusammenElement parameterElement = buildElement(new Id(parameterId), Action.DELETE);
+
+        zusammenAdaptor.saveElement(context, elementContext, parameterElement,
+                String.format("Delete Parameter with id %s", parameterId));
+
+    }
+
+    @Override
+    public ParameterEntity create(String id, String versionId, ParameterRole role, ParameterEntity parameter) {
+
+        ZusammenElement parameterElement = parameterToZusammenElement(parameter, role, Action.CREATE);
+        ZusammenElement parentElement = buildStructuralElement(getParentElementType(role), Action.IGNORE);
+        parentElement.addSubElement(parameterElement);
+
+        SessionContext context = createSessionContext();
+        ElementContext elementContext = new ElementContext(id, versionId);
+
+        Element savedElement = zusammenAdaptor.saveElement(context, elementContext, parentElement,
+                "Create WorkflowVersion Parameter Element");
+
+        parameter.setId(savedElement.getSubElements().iterator().next().getElementId().getValue());
+        return parameter;
+    }
+
+    @Override
+    public void update(String id, String versionId, ParameterRole role, ParameterEntity parameter) {
+
+        SessionContext context = createSessionContext();
+        ElementContext elementContext = new ElementContext(id, versionId);
+
+        ZusammenElement parameterElement = parameterToZusammenElement(parameter, role, Action.UPDATE);
+
+        zusammenAdaptor.saveElement(context, elementContext, parameterElement, "Update WorkflowVersion Parameter");
+    }
+
+    private ZusammenElement parameterToZusammenElement(ParameterEntity parameter, ParameterRole role, Action action) {
+
+        ZusammenElement parameterElement =
+                buildElement(parameter.getId() == null ? null : new Id(parameter.getId()), action);
+        Info info = new Info();
+        info.setName(parameter.getName());
+        info.addProperty(ElementPropertyName.elementType.name(), WorkflowElementType.valueOf(role.name()));
+        info.addProperty(ParameterPropertyName.TYPE.name(), parameter.getType());
+        info.addProperty(ParameterPropertyName.mandatory.name(), parameter.isMandatory());
+        parameterElement.setInfo(info);
+
+        return parameterElement;
+    }
+
+    private ParameterEntity mapElementInfoToParameter(ElementInfo elementInfo) {
+        ParameterEntity parameterEntity = new ParameterEntity();
+        parameterEntity.setId(elementInfo.getId().getValue());
+        parameterEntity.setName(elementInfo.getInfo().getName());
+        parameterEntity
+                .setType(ParameterType.valueOf(elementInfo.getInfo().getProperty(ParameterPropertyName.TYPE.name())));
+        parameterEntity.setMandatory(elementInfo.getInfo().getProperty(ParameterPropertyName.mandatory.name()));
+        return parameterEntity;
+    }
+
+    private static String getParentElementType(ParameterRole role) {
+        switch (role) {
+            case INPUT:
+                return WorkflowElementType.INPUTS.name();
+            case OUTPUT:
+                return WorkflowElementType.OUTPUTS.name();
+            default:
+                throw new IllegalArgumentException("Wrong Element Type");
+        }
+    }
+
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ArtifactEntity.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ArtifactEntity.java
new file mode 100644
index 00000000..287acb45
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ArtifactEntity.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.persistence.types;
+
+import java.io.InputStream;
+import lombok.Data;
+
+@Data
+public class ArtifactEntity {
+
+    private String fileName;
+    private InputStream artifactData;
+
+    public ArtifactEntity(String fileName, InputStream artifactData) {
+        this.fileName = fileName;
+        this.artifactData = artifactData;
+    }
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterEntity.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterEntity.java
new file mode 100644
index 00000000..7c957d85
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterEntity.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.persistence.types;
+
+import javax.validation.constraints.Pattern;
+import lombok.Data;
+import javax.validation.constraints.NotNull;
+
+@Data
+public class ParameterEntity {
+
+    private String id;
+    @NotNull(message = "Parameter name may not be null")
+    @Pattern(regexp = "[A-Za-z0-9_]*", message = "The field must contain only letters, digits and underscores")
+    private String name;
+    @NotNull
+    private ParameterType type;
+    @NotNull
+    private boolean mandatory;
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterPropertyName.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterPropertyName.java
new file mode 100644
index 00000000..fa17bf69
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterPropertyName.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.persistence.types;
+
+public enum ParameterPropertyName {
+
+    TYPE,
+    mandatory
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterRole.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterRole.java
new file mode 100644
index 00000000..9f5aacfe
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterRole.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.persistence.types;
+
+public enum ParameterRole {
+
+    INPUT,
+    OUTPUT
+
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterType.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterType.java
new file mode 100644
index 00000000..04d09c01
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterType.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.persistence.types;
+
+public enum ParameterType {
+    STRING,
+    INTEGER,
+    FLOAT,
+    BOOLEAN,
+    TIMESTAMP
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/UniqueValueEntity.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/UniqueValueEntity.java
new file mode 100644
index 00000000..ee7172b6
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/UniqueValueEntity.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.persistence.types;
+
+import static org.springframework.data.cassandra.core.cql.PrimaryKeyType.PARTITIONED;
+
+import lombok.Data;
+import org.springframework.data.cassandra.core.mapping.PrimaryKeyColumn;
+import org.springframework.data.cassandra.core.mapping.Table;
+
+@Table("unique_value")
+@Data
+public class UniqueValueEntity {
+
+    @PrimaryKeyColumn(ordinal = 0, type = PARTITIONED)
+    private String type;
+
+    @PrimaryKeyColumn(ordinal = 1, type = PARTITIONED)
+    private String value;
+
+    public UniqueValueEntity(String type, String value) {
+        this.type = type;
+        this.value = value;
+    }
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/Workflow.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/Workflow.java
new file mode 100644
index 00000000..72e62778
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/Workflow.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.persistence.types;
+
+
+import java.util.Collection;
+import java.util.Set;
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.Pattern;
+import javax.validation.constraints.Size;
+import lombok.Data;
+
+
+@Data
+public class Workflow {
+
+    private String id;
+    @NotNull(message = "Workflow name may not be null")
+    @Size(min = 6, max = 30, message = "The field must be at least 6 characters, and less than 30 characters")
+    @Pattern(regexp = "[A-Za-z0-9_]*", message = "The field must contain only letters, digits and underscores")
+    private String name;
+    private String description;
+    private Set<WorkflowVersionState> versionStates;
+    private Collection<WorkflowVersion> versions;
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowElementType.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowElementType.java
new file mode 100644
index 00000000..10de37e0
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowElementType.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.persistence.types;
+
+public enum WorkflowElementType {
+
+    ARTIFACT,
+    INPUTS,
+    OUTPUTS,
+    INPUT,
+    OUTPUT
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowProperty.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowProperty.java
new file mode 100644
index 00000000..90fb3085
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowProperty.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.persistence.types;
+
+public final class WorkflowProperty {
+
+    private WorkflowProperty() {
+    }
+
+    public static final String CATEGORY = "category";
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowVersion.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowVersion.java
new file mode 100644
index 00000000..1c828d43
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowVersion.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.persistence.types;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Date;
+import lombok.Data;
+
+
+@Data
+public class WorkflowVersion {
+
+    private String id;
+    private String name;
+    private String description;
+    private String baseId;
+    private WorkflowVersionState state;
+    private Collection<ParameterEntity> inputs = Collections.emptyList();
+    private Collection<ParameterEntity> outputs = Collections.emptyList();
+    private Date creationTime;
+    private Date modificationTime;
+
+
+    public WorkflowVersion(String id) {
+        this.id = id;
+        this.state = WorkflowVersionState.DRAFT;
+    }
+
+    public WorkflowVersion() {
+    }
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowVersionState.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowVersionState.java
new file mode 100644
index 00000000..2be1d4da
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowVersionState.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.persistence.types;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public enum WorkflowVersionState {
+
+    CERTIFIED, DRAFT(CERTIFIED);
+
+    private final List<WorkflowVersionState> nextStates;
+
+    WorkflowVersionState(WorkflowVersionState... nextStates) {
+        this.nextStates = Collections.unmodifiableList(Arrays.asList(nextStates));
+    }
+
+    public List<WorkflowVersionState> getNextStates() {
+        return nextStates;
+    }
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/server/config/SwaggerConfig.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/server/config/SwaggerConfig.java
new file mode 100644
index 00000000..5105114f
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/server/config/SwaggerConfig.java
@@ -0,0 +1,24 @@
+package org.onap.sdc.workflow.server.config;
+
+import static springfox.documentation.builders.PathSelectors.regex;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import springfox.documentation.builders.RequestHandlerSelectors;
+import springfox.documentation.spi.DocumentationType;
+import springfox.documentation.spring.web.plugins.Docket;
+import springfox.documentation.swagger2.annotations.EnableSwagger2;
+
+@Configuration
+@EnableSwagger2
+public class SwaggerConfig {
+
+    @Bean
+    public Docket api() {
+        return new Docket(DocumentationType.SWAGGER_2)
+                       .select()
+                       .apis(RequestHandlerSelectors.basePackage("org.onap.sdc.workflow.api"))
+                       .paths(regex("/workflows.*"))
+                       .build();
+    }
+}
\ No newline at end of file
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/server/config/ZusammenConfig.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/server/config/ZusammenConfig.java
new file mode 100644
index 00000000..092c3464
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/server/config/ZusammenConfig.java
@@ -0,0 +1,32 @@
+package org.onap.sdc.workflow.server.config;
+
+import javax.annotation.PostConstruct;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class ZusammenConfig {
+
+    @Value("${zusammen-tenant:workflow}")
+    private String tenant;
+    @Value("${spring.data.cassandra.contact-points:localhost}")
+    private String cassandraAddress;
+    @Value("${spring.data.cassandra.username:}")
+    private String cassandraUser;
+    @Value("${spring.data.cassandra.password:}")
+    private String cassandraPassword;
+    @Value("${zusammen.cassandra.isAuthenticate:false}")
+    private String cassandraAuth;
+
+    @PostConstruct
+    public void init(){
+        System.setProperty("cassandra.nodes", cassandraAddress);
+        System.setProperty("cassandra.user", cassandraUser);
+        System.setProperty("cassandra.password", cassandraPassword);
+        System.setProperty("cassandra.authenticate", Boolean.toString(Boolean.valueOf(cassandraAuth)));
+    }
+
+    public String getTenant() {
+        return tenant;
+    }
+}
\ No newline at end of file
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/server/filters/SessionContextFilter.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/server/filters/SessionContextFilter.java
new file mode 100644
index 00000000..07d8eee7
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/server/filters/SessionContextFilter.java
@@ -0,0 +1,64 @@
+package org.onap.sdc.workflow.server.filters;
+
+import static org.onap.sdc.workflow.api.RestConstants.USER_ID_HEADER_PARAM;
+
+import java.io.IOException;
+import javax.servlet.Filter;
+import javax.servlet.FilterChain;
+import javax.servlet.FilterConfig;
+import javax.servlet.ServletException;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+import javax.servlet.http.HttpServletRequest;
+import org.onap.sdc.workflow.server.config.ZusammenConfig;
+import org.openecomp.sdc.common.session.SessionContextProvider;
+import org.openecomp.sdc.common.session.SessionContextProviderFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+public class SessionContextFilter implements Filter {
+
+    private ZusammenConfig zusammenConfig;
+
+    @Autowired
+    public SessionContextFilter(ZusammenConfig zusammenConfig) {
+        this.zusammenConfig = zusammenConfig;
+    }
+
+    @Override
+    public void init(FilterConfig filterConfig) {
+        // not implemented
+    }
+
+    @Override
+    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
+            throws IOException, ServletException {
+        SessionContextProvider contextProvider = SessionContextProviderFactory.getInstance().createInterface();
+
+        try {
+            if (servletRequest instanceof HttpServletRequest) {
+                contextProvider.create(getUser(servletRequest), getTenant());
+            }
+
+            filterChain.doFilter(servletRequest, servletResponse);
+        } finally {
+            contextProvider.close();
+        }
+    }
+
+    @Override
+    public void destroy() {
+        // not implemented
+    }
+
+    private String getUser(ServletRequest servletRequest) {
+        return "GLOBAL_USER";
+        // TODO: 7/11/2018 get user from header when collaboration will be supported
+                //((HttpServletRequest) servletRequest).getHeader(USER_ID_HEADER_PARAM);
+    }
+
+    private String getTenant() {
+        return zusammenConfig.getTenant();
+    }
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/UniqueValueService.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/UniqueValueService.java
new file mode 100644
index 00000000..0a8b640a
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/UniqueValueService.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.services;
+
+import java.util.Optional;
+import org.apache.commons.lang.ArrayUtils;
+import org.onap.sdc.workflow.persistence.UniqueValueRepository;
+import org.onap.sdc.workflow.persistence.types.UniqueValueEntity;
+import org.onap.sdc.workflow.services.exceptions.UniqueValueViolationException;
+import org.openecomp.core.utilities.CommonMethods; // todo get rid of
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service("uniqueValueService")
+public class UniqueValueService {
+
+    private static final char FORMATTED_UNIQUE_VALUE_SEPARATOR = '_';
+
+    private final UniqueValueRepository uniqueValueRepository;
+
+    @Autowired
+    public UniqueValueService(UniqueValueRepository uniqueValueRepository) {
+        this.uniqueValueRepository = uniqueValueRepository;
+    }
+
+    /**
+     * Create unique value.
+     *
+     * @param type              the type
+     * @param uniqueCombination the unique combination
+     */
+    public void createUniqueValue(String type, String[] uniqueCombination) {
+        formatValue(uniqueCombination).ifPresent(formattedValue -> {
+            validateUniqueValue(type, formattedValue, uniqueCombination);
+            uniqueValueRepository.insert(new UniqueValueEntity(type, formattedValue));
+        });
+    }
+
+    /**
+     * Delete unique value.
+     *
+     * @param type              the type
+     * @param uniqueCombination the unique combination
+     */
+    public void deleteUniqueValue(String type, String[] uniqueCombination) {
+        formatValue(uniqueCombination)
+                .ifPresent(formattedValue -> uniqueValueRepository.delete(new UniqueValueEntity(type, formattedValue)));
+
+    }
+
+    /**
+     * Update unique value.
+     *
+     * @param type          the type
+     * @param oldValue      the old value
+     * @param newValue      the new value
+     * @param uniqueContext the unique context
+     */
+    public void updateUniqueValue(String type, String oldValue, String newValue, String ... uniqueContext) {
+        if (newValue == null || !newValue.equalsIgnoreCase(oldValue)) {
+            createUniqueValue(type, CommonMethods.concat(uniqueContext, new String[] {newValue}));
+            deleteUniqueValue(type, CommonMethods.concat(uniqueContext, new String[] {oldValue}));
+        }
+    }
+
+    /**
+     * Validate unique value.
+     *
+     * @param type              the type
+     * @param uniqueCombination the unique combination
+     */
+    public void validateUniqueValue(String type, String[] uniqueCombination) {
+        formatValue(uniqueCombination)
+                .ifPresent(formattedValue -> validateUniqueValue(type, formattedValue, uniqueCombination));
+    }
+
+    /**
+     * Checks if a unique value is taken.
+     *
+     * @return true if the unique value is occupied, false otherwise
+     */
+    public boolean isUniqueValueOccupied(String type, String[] uniqueCombination) {
+        return formatValue(uniqueCombination).map(formattedValue -> isUniqueValueOccupied(type, formattedValue))
+                                             .orElse(false);
+    }
+
+    private void validateUniqueValue(String type, String formattedValue, String[] uniqueCombination) {
+        if (isUniqueValueOccupied(type, formattedValue)) {
+            throw new UniqueValueViolationException(type, getValueWithoutContext(uniqueCombination));
+        }
+    }
+
+    private boolean isUniqueValueOccupied(String type, String formattedValue) {
+        return uniqueValueRepository.findById(new UniqueValueEntity(type, formattedValue)).isPresent();
+    }
+
+    private Optional<String> formatValue(String[] uniqueCombination) {
+        if (ArrayUtils.isEmpty(uniqueCombination) || getValueWithoutContext(uniqueCombination) == null) {
+            return Optional.empty();
+        }
+
+        uniqueCombination[uniqueCombination.length - 1] = getValueWithoutContext(uniqueCombination).toLowerCase();
+        return Optional.of(CommonMethods.arrayToSeparatedString(uniqueCombination, FORMATTED_UNIQUE_VALUE_SEPARATOR));
+    }
+
+    private String getValueWithoutContext(String[] uniqueCombination) {
+        return uniqueCombination[uniqueCombination.length - 1];
+    }
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/WorkflowManager.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/WorkflowManager.java
new file mode 100644
index 00000000..ca079d42
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/WorkflowManager.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.services;
+
+import java.util.Collection;
+import java.util.Set;
+import org.onap.sdc.workflow.persistence.types.Workflow;
+import org.onap.sdc.workflow.persistence.types.WorkflowVersionState;
+import org.springframework.data.domain.Pageable;
+
+public interface WorkflowManager {
+
+    Collection<Workflow> list(Set<WorkflowVersionState> versionStatesFilter, Pageable pageable);
+
+    Workflow get(Workflow workflow);
+
+    Workflow create(Workflow workflow);
+
+    void update(Workflow workflow);
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/WorkflowNameComparator.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/WorkflowNameComparator.java
new file mode 100644
index 00000000..1cb6cb1d
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/WorkflowNameComparator.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.services;
+
+import java.util.Comparator;
+
+import org.onap.sdc.workflow.persistence.types.Workflow;
+
+public class WorkflowNameComparator implements Comparator<Workflow>{
+
+    @Override
+    public int compare(Workflow workflow1, Workflow workflow2) {
+        String workflowName1 = workflow1.getName().toLowerCase();
+        String workflowName2 = workflow2.getName().toLowerCase();
+        //ascending order
+        return workflowName1.compareTo(workflowName2);
+    }
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/WorkflowVersionManager.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/WorkflowVersionManager.java
new file mode 100644
index 00000000..8effb647
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/WorkflowVersionManager.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.services;
+
+import java.util.Collection;
+import java.util.Set;
+import org.onap.sdc.workflow.persistence.types.ArtifactEntity;
+import org.onap.sdc.workflow.persistence.types.WorkflowVersion;
+import org.onap.sdc.workflow.persistence.types.WorkflowVersionState;
+import org.springframework.web.multipart.MultipartFile;
+
+
+public interface WorkflowVersionManager {
+
+    Collection<WorkflowVersion> list(String workflowId, Set<WorkflowVersionState> stateFilter);
+
+    WorkflowVersion create(String workflowId, String baseVersionId, WorkflowVersion version);
+
+    void update(String workflowId, WorkflowVersion version);
+
+    WorkflowVersion get(String workflowId, String versionId);
+
+    WorkflowVersionState getState(String workflowId, String versionId);
+
+    void updateState(String workflowId, String versionId, WorkflowVersionState state);
+
+    ArtifactEntity getArtifact(String workflowId, String versionId);
+
+    void deleteArtifact(String workflowId, String versionId);
+
+    void uploadArtifact(String workflowId, String versionId, MultipartFile artifact);
+}
\ No newline at end of file
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/EntityNotFoundException.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/EntityNotFoundException.java
new file mode 100644
index 00000000..7fc3e81c
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/EntityNotFoundException.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.services.exceptions;
+
+public class EntityNotFoundException extends RuntimeException  {
+
+    public EntityNotFoundException(String message) {
+        super(message);
+    }
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/InvalidArtifactException.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/InvalidArtifactException.java
new file mode 100644
index 00000000..c4584179
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/InvalidArtifactException.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.services.exceptions;
+
+public class InvalidArtifactException extends RuntimeException  {
+
+    public InvalidArtifactException(String message) {
+        super("Invalid artifact file can not be processed. Error: " + message);
+    }
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/InvalidPaginationParameterException.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/InvalidPaginationParameterException.java
new file mode 100644
index 00000000..a4d4a5d6
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/InvalidPaginationParameterException.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.services.exceptions;
+
+public class InvalidPaginationParameterException extends RuntimeException {
+
+    public InvalidPaginationParameterException(String parameterName, String parameterValue, String message) {
+        super(String.format("Requested %s: %s %s", parameterName, parameterValue, message));
+    }
+}
\ No newline at end of file
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/UniqueValueViolationException.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/UniqueValueViolationException.java
new file mode 100644
index 00000000..a3046a77
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/UniqueValueViolationException.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.services.exceptions;
+
+
+public class UniqueValueViolationException extends RuntimeException {
+
+    private static final String UNIQUE_VALUE_VIOLATION_MSG = "%s with the value '%s' already exists.";
+
+    public UniqueValueViolationException(String uniqueType, String value) {
+        super(String.format(UNIQUE_VALUE_VIOLATION_MSG, uniqueType, value));
+    }
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/VersionCreationException.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/VersionCreationException.java
new file mode 100644
index 00000000..31c88923
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/VersionCreationException.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.services.exceptions;
+
+public class VersionCreationException extends RuntimeException {
+
+    private static final String MSG = "Error creating a new version for workflow with id %s";
+    private static final String MSG_WITH_BASE_ID = MSG + " based on version %s: %s";
+
+    public VersionCreationException(String workflowId, String baseVersionId, String detailedMessage) {
+        super(String.format(MSG_WITH_BASE_ID, workflowId, baseVersionId, detailedMessage));
+    }
+
+    public VersionCreationException(String workflowId) {
+        super(String.format(MSG, workflowId));
+    }
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/VersionModificationException.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/VersionModificationException.java
new file mode 100644
index 00000000..752d6bce
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/VersionModificationException.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.services.exceptions;
+
+public class VersionModificationException extends RuntimeException {
+
+    public VersionModificationException(String workflowId, String versionId) {
+        super(String.format(
+            "Error while trying to modify version %s of workflow %s: Version is CERTIFIED and can not be edited",
+            versionId, workflowId));
+    }
+}
\ No newline at end of file
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/VersionStateModificationException.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/VersionStateModificationException.java
new file mode 100644
index 00000000..87027a58
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/VersionStateModificationException.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.services.exceptions;
+
+import org.onap.sdc.workflow.persistence.types.WorkflowVersionState;
+
+public class VersionStateModificationException extends RuntimeException {
+
+    public VersionStateModificationException(String workflowId, String versionId, WorkflowVersionState sourceState,
+            WorkflowVersionState targetState) {
+        super(String.format("Workflow %s, version %s: state can not be changed from %s to %s", workflowId, versionId,
+                sourceState.name(), targetState.name()));
+    }
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/CollaborationConfiguration.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/CollaborationConfiguration.java
new file mode 100644
index 00000000..80b969cf
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/CollaborationConfiguration.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.services.impl;
+
+import org.openecomp.sdc.versioning.ItemManager;
+import org.openecomp.sdc.versioning.ItemManagerFactory;
+import org.openecomp.sdc.versioning.VersioningManager;
+import org.openecomp.sdc.versioning.VersioningManagerFactory;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class CollaborationConfiguration {
+
+    @Bean
+    public ItemManager itemManager() {
+        return ItemManagerFactory.getInstance().createInterface();
+    }
+
+    @Bean
+    public VersioningManager versioningManager() {
+        return VersioningManagerFactory.getInstance().createInterface();
+    }
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/WorkflowManagerImpl.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/WorkflowManagerImpl.java
new file mode 100644
index 00000000..52dd8f17
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/WorkflowManagerImpl.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.onap.sdc.workflow.services.impl;
+
+import static org.onap.sdc.workflow.api.RestConstants.SORT_FIELD_NAME;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import org.onap.sdc.workflow.persistence.types.Workflow;
+import org.onap.sdc.workflow.persistence.types.WorkflowVersionState;
+import org.onap.sdc.workflow.services.UniqueValueService;
+import org.onap.sdc.workflow.services.WorkflowManager;
+import org.onap.sdc.workflow.services.WorkflowNameComparator;
+import org.onap.sdc.workflow.services.exceptions.EntityNotFoundException;
+import org.onap.sdc.workflow.services.impl.mappers.VersionStateMapper;
+import org.onap.sdc.workflow.services.impl.mappers.WorkflowMapper;
+import org.openecomp.sdc.logging.api.Logger;
+import org.openecomp.sdc.logging.api.LoggerFactory;
+import org.openecomp.sdc.versioning.ItemManager;
+import org.openecomp.sdc.versioning.dao.types.VersionStatus;
+import org.openecomp.sdc.versioning.types.Item;
+import org.openecomp.sdc.versioning.types.ItemStatus;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.stereotype.Service;
+
+@Service("workflowManager")
+public class WorkflowManagerImpl implements WorkflowManager {
+
+    public static final String WORKFLOW_TYPE = "WORKFLOW";
+    private static final String WORKFLOW_NOT_FOUND_ERROR_MSG = "Workflow with id '%s' does not exist";
+    private static final String WORKFLOW_NAME_UNIQUE_TYPE = "WORKFLOW_NAME";
+    private static final Predicate<Item> WORKFLOW_ITEM_FILTER = item -> WORKFLOW_TYPE.equals(item.getType());
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(WorkflowManagerImpl.class);
+    private final ItemManager itemManager;
+    private final UniqueValueService uniqueValueService;
+    private final WorkflowMapper workflowMapper;
+    private final VersionStateMapper versionStateMapper;
+
+    @Autowired
+    public WorkflowManagerImpl(ItemManager itemManager,
+            @Qualifier("uniqueValueService") UniqueValueService uniqueValueService, WorkflowMapper workflowMapper,
+            VersionStateMapper versionStateMapper) {
+        this.itemManager = itemManager;
+        this.uniqueValueService = uniqueValueService;
+        this.workflowMapper = workflowMapper;
+        this.versionStateMapper = versionStateMapper;
+    }
+
+    @Override
+    public Collection<Workflow> list(Set<WorkflowVersionState> versionStatesFilter, Pageable pageRequest) {
+        Set<VersionStatus> versionStatusesFilter =
+                versionStatesFilter == null ? null :
+                        versionStatesFilter.stream().map(versionStateMapper::workflowVersionStateToVersionStatus)
+                                           .collect(Collectors.toSet());
+
+
+        List<Workflow> workflows = itemManager.list(getFilter(versionStatusesFilter)).stream()
+                                              .map(workflowMapper::itemToWorkflow)
+                                              .sorted(pageRequest.getSort().getOrderFor(SORT_FIELD_NAME).getDirection()
+                                                              == Sort.Direction.ASC ? getWorkflowsComparator() :
+                                                              Collections.reverseOrder(getWorkflowsComparator()))
+                                              .collect(Collectors.toList());
+        return applyLimitAndOffset(workflows, pageRequest);
+    }
+
+    @Override
+    public Workflow get(Workflow workflow) {
+        Item retrievedItem = itemManager.get(workflow.getId());
+        if (retrievedItem == null) {
+            LOGGER.error(String.format("Workflow with id %s was not found",workflow.getId()));
+            throw new EntityNotFoundException(String.format(WORKFLOW_NOT_FOUND_ERROR_MSG, workflow.getId()));
+        }
+        return this.workflowMapper.itemToWorkflow(retrievedItem);
+    }
+
+    @Override
+    public Workflow create(Workflow workflow) {
+        Item item = workflowMapper.workflowToItem(workflow);
+        item.setStatus(ItemStatus.ACTIVE);
+
+        uniqueValueService.validateUniqueValue(WORKFLOW_NAME_UNIQUE_TYPE, new String[] {workflow.getName()});
+        Item createdItem = itemManager.create(item);
+        uniqueValueService.createUniqueValue(WORKFLOW_NAME_UNIQUE_TYPE, new String[] {workflow.getName()});
+
+        return workflowMapper.itemToWorkflow(createdItem);
+    }
+
+    @Override
+    public void update(Workflow workflow) {
+        Item retrievedItem = itemManager.get(workflow.getId());
+        if (retrievedItem == null) {
+            LOGGER.error(String.format("Workflow with id %s was not found",workflow.getId()));
+            throw new EntityNotFoundException(String.format(WORKFLOW_NOT_FOUND_ERROR_MSG, workflow.getId()));
+        }
+
+        uniqueValueService.updateUniqueValue(WORKFLOW_NAME_UNIQUE_TYPE, retrievedItem.getName(), workflow.getName());
+
+        Item item = workflowMapper.workflowToItem(workflow);
+        item.setId(workflow.getId());
+        item.setStatus(retrievedItem.getStatus());
+        item.setVersionStatusCounters(retrievedItem.getVersionStatusCounters());
+        itemManager.update(item);
+    }
+
+    private List<Workflow> applyLimitAndOffset(List<Workflow> workflowList, Pageable pageRequest) {
+        int limit = pageRequest.getPageSize();
+        int offset = pageRequest.getPageNumber();
+        int totalNumOfWorkflows = workflowList.size();
+        List<Workflow> selectedWorkflows;
+        try {
+            if (limit > totalNumOfWorkflows) {
+                limit = totalNumOfWorkflows;
+            }
+            int startIndex = offset * limit;
+            int endIndex = startIndex + limit;
+            if (endIndex > totalNumOfWorkflows) {
+                endIndex = totalNumOfWorkflows;
+            }
+            selectedWorkflows = workflowList.subList(startIndex, endIndex);
+        } catch (IndexOutOfBoundsException | IllegalArgumentException ex) {
+            selectedWorkflows = new ArrayList<>();
+        }
+        return selectedWorkflows;
+    }
+
+    private Comparator<Workflow> getWorkflowsComparator() {
+        //More comparators can be added if required based on sort field name
+        return new WorkflowNameComparator();
+    }
+
+    private static Predicate<Item> getFilter(Set<VersionStatus> versionStatuses) {
+        return WORKFLOW_ITEM_FILTER.and(item -> versionStatuses == null
+                                            || item.getVersionStatusCounters().keySet().stream()
+                                                   .anyMatch(versionStatuses::contains));
+    }
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/WorkflowVersionManagerImpl.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/WorkflowVersionManagerImpl.java
new file mode 100644
index 00000000..484c598a
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/WorkflowVersionManagerImpl.java
@@ -0,0 +1,277 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.services.impl;
+
+import static org.onap.sdc.workflow.persistence.types.WorkflowVersionState.CERTIFIED;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import org.onap.sdc.workflow.persistence.ArtifactRepository;
+import org.onap.sdc.workflow.persistence.ParameterRepository;
+import org.onap.sdc.workflow.persistence.types.ArtifactEntity;
+import org.onap.sdc.workflow.persistence.types.ParameterEntity;
+import org.onap.sdc.workflow.persistence.types.ParameterRole;
+import org.onap.sdc.workflow.persistence.types.WorkflowVersion;
+import org.onap.sdc.workflow.persistence.types.WorkflowVersionState;
+import org.onap.sdc.workflow.services.WorkflowVersionManager;
+import org.onap.sdc.workflow.services.exceptions.EntityNotFoundException;
+import org.onap.sdc.workflow.services.exceptions.InvalidArtifactException;
+import org.onap.sdc.workflow.services.exceptions.VersionCreationException;
+import org.onap.sdc.workflow.services.exceptions.VersionModificationException;
+import org.onap.sdc.workflow.services.exceptions.VersionStateModificationException;
+import org.onap.sdc.workflow.services.impl.mappers.VersionMapper;
+import org.onap.sdc.workflow.services.impl.mappers.VersionStateMapper;
+import org.openecomp.sdc.logging.api.Logger;
+import org.openecomp.sdc.logging.api.LoggerFactory;
+import org.openecomp.sdc.versioning.VersioningManager;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.dao.types.VersionStatus;
+import org.openecomp.sdc.versioning.types.VersionCreationMethod;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+import org.springframework.web.multipart.MultipartFile;
+
+@Service("workflowVersionManager")
+public class WorkflowVersionManagerImpl implements WorkflowVersionManager {
+
+    private static final String VERSION_NOT_EXIST_MSG = "version with id '%s' does not exist for workflow with id '%s'";
+    private final VersioningManager versioningManager;
+    private final ArtifactRepository artifactRepository;
+    private final ParameterRepository parameterRepository;
+    private final VersionMapper versionMapper;
+    private final VersionStateMapper versionStateMapper;
+    private static final Logger LOGGER = LoggerFactory.getLogger(WorkflowVersionManagerImpl.class);
+
+    @Autowired
+    public WorkflowVersionManagerImpl(VersioningManager versioningManager, ArtifactRepository artifactRepository,
+            VersionMapper versionMapper, VersionStateMapper versionStateMapper,
+            ParameterRepository parameterRepository) {
+        this.versioningManager = versioningManager;
+        this.artifactRepository = artifactRepository;
+        this.parameterRepository = parameterRepository;
+        this.versionMapper = versionMapper;
+        this.versionStateMapper = versionStateMapper;
+    }
+
+    @Override
+    public Collection<WorkflowVersion> list(String workflowId, Set<WorkflowVersionState> stateFilter) {
+        Set<VersionStatus> versionStatusFilter =
+                stateFilter == null ? null :
+                        stateFilter.stream().map(versionStateMapper::workflowVersionStateToVersionStatus)
+                                           .collect(Collectors.toSet());
+
+        return versioningManager.list(workflowId).stream()
+                                .filter(version -> versionStatusFilter == null || versionStatusFilter.contains(
+                                        version.getStatus()))
+                                .map(versionMapper::versionToWorkflowVersion)
+                                .peek(workflowVersion -> loadAndAddParameters(workflowId, workflowVersion))
+                                .collect(Collectors.toList());
+    }
+
+    @Override
+    public WorkflowVersion get(String workflowId, String versionId) {
+        WorkflowVersion workflowVersion = versionMapper.versionToWorkflowVersion(getVersion(workflowId, versionId));
+        loadAndAddParameters(workflowId, workflowVersion);
+        return workflowVersion;
+    }
+
+    @Override
+    public WorkflowVersion create(String workflowId, String baseVersionId, WorkflowVersion workflowVersion) {
+        List<Version> versions = versioningManager.list(workflowId);
+
+        if (baseVersionId != null) {
+            if (!workflowVersion.getInputs().isEmpty() || !workflowVersion.getOutputs().isEmpty()) {
+                throw new VersionCreationException(workflowId, baseVersionId, "Inputs/Outputs should not be supplied");
+            }
+            validateVersionExistAndCertified(workflowId, versions, baseVersionId);
+        } else if (!versions.isEmpty()) {
+            throw new VersionCreationException(workflowId);
+        }
+
+        Version version = new Version();
+        version.setDescription(workflowVersion.getDescription());
+        version.setBaseId(baseVersionId);
+        Version createdVersion = versioningManager.create(workflowId, version, VersionCreationMethod.major);
+
+        if (versions.isEmpty()) { // only for first version
+            artifactRepository.createStructure(workflowId, createdVersion.getId());
+            parameterRepository.createStructure(workflowId, createdVersion.getId());
+            updateParameters(workflowId, createdVersion.getId(), workflowVersion.getInputs(), workflowVersion.getOutputs());
+            versioningManager.publish(workflowId, createdVersion, "Add initial data");
+        }
+
+        return get(workflowId, createdVersion.getId());
+    }
+
+    @Override
+    public void update(String workflowId, WorkflowVersion workflowVersion) {
+        Version retrievedVersion = getVersion(workflowId, workflowVersion.getId());
+        if (CERTIFIED.equals(versionStateMapper.versionStatusToWorkflowVersionState(retrievedVersion.getStatus()))) {
+            throw new VersionModificationException(workflowId, workflowVersion.getId());
+        }
+
+        Version version = versionMapper.workflowVersionToVersion(workflowVersion);
+        version.setName(retrievedVersion.getName());
+        version.setStatus(retrievedVersion.getStatus());
+
+        updateParameters(workflowId, version.getId(), workflowVersion.getInputs(), workflowVersion.getOutputs());
+
+        versioningManager.updateVersion(workflowId, version);
+        versioningManager.publish(workflowId, version, "Update version");
+    }
+
+    @Override
+    public WorkflowVersionState getState(String workflowId, String versionId) {
+        return versionStateMapper.versionStatusToWorkflowVersionState(getVersion(workflowId, versionId).getStatus());
+    }
+
+    @Override
+    public void updateState(String workflowId, String versionId, WorkflowVersionState state) {
+        WorkflowVersionState retrievedState =
+                versionStateMapper.versionStatusToWorkflowVersionState(getVersion(workflowId, versionId).getStatus());
+
+        if (state == CERTIFIED) {
+            try {
+                versioningManager.submit(workflowId, new Version(versionId),
+                        String.format("Update version state to %s", state.name()));
+            } catch (Exception e) {
+                throw new VersionStateModificationException(workflowId, versionId, retrievedState, state);
+            }
+        } else {
+            throw new VersionStateModificationException(workflowId, versionId, retrievedState, state);
+        }
+    }
+
+    @Override
+    public void uploadArtifact(String workflowId, String versionId, MultipartFile artifact) {
+        Version retrievedVersion = getVersion(workflowId, versionId);
+        if (CERTIFIED.equals(versionStateMapper.versionStatusToWorkflowVersionState(retrievedVersion.getStatus()))) {
+            throw new VersionModificationException(workflowId, versionId);
+        }
+
+        try (InputStream artifactData = artifact.getInputStream()) {
+            ArtifactEntity artifactEntity =
+                    new ArtifactEntity(StringUtils.cleanPath(artifact.getOriginalFilename()), artifactData);
+            artifactRepository.update(workflowId, versionId, artifactEntity);
+            versioningManager.publish(workflowId, new Version(versionId), "Update Artifact");
+
+        } catch (IOException e) {
+            LOGGER.error(String.format("Upload Artifact failed for workflow id %s and version id %s",
+                    workflowId, versionId),e);
+            throw new InvalidArtifactException(e.getMessage());
+        }
+    }
+
+    @Override
+    public ArtifactEntity getArtifact(String workflowId, String versionId) {
+        getVersion(workflowId, versionId);
+        Optional<ArtifactEntity> artifactOptional = artifactRepository.get(workflowId, versionId);
+        if (!artifactOptional.isPresent()) {
+            LOGGER.error(String.format("Workflow Version Artifact was not found for workflow id %s and version id %s",
+                    workflowId, versionId));
+            throw new EntityNotFoundException(
+                    String.format("Artifact for workflow id %S version id %S was not found", workflowId, versionId));
+        }
+        return artifactOptional.get();
+    }
+
+    @Override
+    public void deleteArtifact(String workflowId, String versionId) {
+        WorkflowVersion retrievedVersion = get(workflowId, versionId);
+        if (CERTIFIED.equals(retrievedVersion.getState())) {
+            LOGGER.error(String.format(
+                    "Workflow Version is certified and can not be edited.Workflow id %s and version id %s", workflowId,
+                    versionId));
+            throw new VersionModificationException(workflowId, versionId);
+        }
+
+        artifactRepository.delete(workflowId, versionId);
+        versioningManager.publish(workflowId, new Version(versionId), "Delete Artifact");
+    }
+
+    private void validateVersionExistAndCertified(String workflowId, List<Version> versions, String versionId) {
+        Version baseVersion = findVersion(versions, versionId).orElseThrow(
+                () -> new EntityNotFoundException(String.format(VERSION_NOT_EXIST_MSG, versionId, workflowId)));
+
+        if (CERTIFIED != versionStateMapper.versionStatusToWorkflowVersionState(baseVersion.getStatus())) {
+            throw new VersionCreationException(workflowId, versionId, "base version must be CERTIFIED");
+        }
+    }
+
+    private Version getVersion(String workflowId, String versionId) {
+        try {
+            Version version = versioningManager.get(workflowId, new Version(versionId));
+            if (version == null) {
+                throw new EntityNotFoundException(String.format(VERSION_NOT_EXIST_MSG, versionId, workflowId));
+            }
+            return version;
+        } catch (Exception e) {
+            LOGGER.error(String.format(
+                    "Workflow Version was not found.Workflow id %s and version id %s", workflowId,
+                    versionId),e);
+            throw new EntityNotFoundException(String.format(VERSION_NOT_EXIST_MSG, versionId, workflowId));
+        }
+    }
+
+    private void updateParameters(String workflowId, String versionId, Collection<ParameterEntity> inputs,
+            Collection<ParameterEntity> outputs) {
+        updateVersionParameters(workflowId, versionId, ParameterRole.INPUT, inputs);
+        updateVersionParameters(workflowId, versionId, ParameterRole.OUTPUT, outputs);
+    }
+
+    private void updateVersionParameters(String workflowId, String versionId, ParameterRole role,
+            Collection<ParameterEntity> parameters) {
+
+        Collection<ParameterEntity> retrievedParams = parameterRepository.list(workflowId, versionId, role);
+        Map<String, ParameterEntity> retrievedParamsByName =
+                retrievedParams.stream().collect(Collectors.toMap(ParameterEntity::getName, Function.identity()));
+
+        Set<String> namesOfParamsToKeep = new HashSet<>();
+        for (ParameterEntity parameter : parameters) {
+
+            ParameterEntity retrievedParam = retrievedParamsByName.get(parameter.getName());
+            if (retrievedParam == null) {
+                parameterRepository.create(workflowId, versionId, role, parameter);
+            } else {
+                parameterRepository.update(workflowId, versionId, role, parameter);
+                namesOfParamsToKeep.add(parameter.getName());
+            }
+        }
+
+        retrievedParams.stream().filter(retrievedParam -> !namesOfParamsToKeep.contains(retrievedParam.getName()))
+                       .forEach(retrievedParam -> parameterRepository
+                                                          .delete(workflowId, versionId, retrievedParam.getId()));
+    }
+
+    private void loadAndAddParameters(String workflowId, WorkflowVersion workflowVersion) {
+        workflowVersion.setInputs(parameterRepository.list(workflowId, workflowVersion.getId(), ParameterRole.INPUT));
+        workflowVersion.setOutputs(parameterRepository.list(workflowId, workflowVersion.getId(), ParameterRole.OUTPUT));
+    }
+
+    private static Optional<Version> findVersion(List<Version> versions, String versionId) {
+        return versions.stream().filter(version -> versionId.equals(version.getId())).findFirst();
+    }
+}
\ No newline at end of file
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/mappers/VersionMapper.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/mappers/VersionMapper.java
new file mode 100644
index 00000000..a3a1cdcc
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/mappers/VersionMapper.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.services.impl.mappers;
+
+import org.mapstruct.InheritInverseConfiguration;
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+import org.onap.sdc.workflow.persistence.types.WorkflowVersion;
+import org.openecomp.sdc.versioning.dao.types.Version;
+
+@Mapper(componentModel = "spring", uses = VersionStateMapper.class)
+public interface VersionMapper {
+
+
+    @Mapping(source = "status", target = "state")
+    WorkflowVersion versionToWorkflowVersion(Version version);
+
+    @InheritInverseConfiguration
+    Version workflowVersionToVersion(WorkflowVersion workflowVersion);
+
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/mappers/VersionStateMapper.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/mappers/VersionStateMapper.java
new file mode 100644
index 00000000..45012b57
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/mappers/VersionStateMapper.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.services.impl.mappers;
+
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import org.mapstruct.InheritInverseConfiguration;
+import org.mapstruct.Mapper;
+import org.mapstruct.ValueMapping;
+import org.mapstruct.ValueMappings;
+import org.onap.sdc.workflow.persistence.types.WorkflowVersionState;
+import org.openecomp.sdc.versioning.dao.types.VersionStatus;
+
+@Mapper(componentModel = "spring")
+public interface VersionStateMapper {
+
+    @ValueMappings({@ValueMapping(source = "Certified", target = "CERTIFIED"),
+            @ValueMapping(source = "Draft", target = "DRAFT"),
+            @ValueMapping(source = "<ANY_REMAINING>", target = "DRAFT")})
+    WorkflowVersionState versionStatusToWorkflowVersionState(VersionStatus status);
+
+    @InheritInverseConfiguration
+    VersionStatus workflowVersionStateToVersionStatus(WorkflowVersionState status);
+
+    default Set<WorkflowVersionState> versionStatusCountersToWorkflowVersionStates(
+            Map<VersionStatus, Integer> versionStatusCounters) {
+        return versionStatusCounters.keySet().stream().map(this::versionStatusToWorkflowVersionState)
+                                    .collect(Collectors.toSet());
+    }
+
+
+}
diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/mappers/WorkflowMapper.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/mappers/WorkflowMapper.java
new file mode 100644
index 00000000..5cfcd7ed
--- /dev/null
+++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/mappers/WorkflowMapper.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.services.impl.mappers;
+
+import org.mapstruct.InheritInverseConfiguration;
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+import org.mapstruct.Mappings;
+import org.onap.sdc.workflow.persistence.types.Workflow;
+import org.onap.sdc.workflow.services.impl.WorkflowManagerImpl;
+import org.openecomp.sdc.versioning.types.Item;
+
+@Mapper(componentModel = "spring", imports = WorkflowManagerImpl.class, uses = VersionStateMapper.class)
+public interface WorkflowMapper {
+
+    @Mapping(source = "versionStatusCounters", target = "versionStates")
+    Workflow itemToWorkflow(Item item);
+
+    @InheritInverseConfiguration
+    @Mappings({@Mapping(expression = "java(WorkflowManagerImpl.WORKFLOW_TYPE)", target = "type"),
+            @Mapping(target = "versionStatusCounters", ignore = true)})
+    Item workflowToItem(Workflow workflow);
+
+}
diff --git a/workflow-designer-be/src/main/resources/application.properties b/workflow-designer-be/src/main/resources/application.properties
new file mode 100644
index 00000000..ab4930b5
--- /dev/null
+++ b/workflow-designer-be/src/main/resources/application.properties
@@ -0,0 +1,10 @@
+server.servlet.context-path=/wf
+server.port=${SERVER_PORT:8080}
+
+#CASSANDRA
+spring.data.cassandra.contact-points=${CS_HOSTS}
+spring.data.cassandra.keyspace-name=workflow
+spring.data.cassandra.port=${CS_PORT:9042}
+spring.data.cassandra.username=${CS_USER:}
+spring.data.cassandra.password=${CS_PASSWORD:}
+zusammen.cassandra.isAuthenticate=${CS_AUTHENTICATE:true}
\ No newline at end of file
diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/RestPath.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/RestPath.java
new file mode 100644
index 00000000..7a7e715e
--- /dev/null
+++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/RestPath.java
@@ -0,0 +1,66 @@
+package org.onap.sdc.workflow;
+
+import static org.onap.sdc.workflow.api.RestConstants.SIZE_PARAM;
+import static org.onap.sdc.workflow.api.RestConstants.PAGE_PARAM;
+import static org.onap.sdc.workflow.api.RestConstants.SORT_PARAM;
+
+public class RestPath {
+
+    private RestPath() {
+        //Hiding implicit constructor
+    }
+
+    private static final String WORKFLOWS_URL = "/workflows";
+    public static final String WORKFLOWS_WITH_VERSION_STATE_FILTER_URL = WORKFLOWS_URL + "?versionState=%s";
+    private static final String WORKFLOW_URL_FORMATTER = WORKFLOWS_URL + "/%s";
+    private static final String VERSIONS_URL_FORMATTER = WORKFLOWS_URL + "/%s/versions";
+    private static final String VERSION_URL_FORMATTER = WORKFLOWS_URL + "/%s/versions/%s";
+    private static final String SORT_QUERY_STRING_FORMATTER = SORT_PARAM + "=%s";
+    private static final String SIZE_QUERY_STRING_FORMATTER = SIZE_PARAM + "=%s";
+    private static final String OFFSET_QUERY_STRING_FORMATTER = PAGE_PARAM + "=%s";
+    private static final String WORKFLOW_URL_FORMATTER_QUERY_PARAMS_ALL =
+            WORKFLOWS_URL + "?" + SORT_QUERY_STRING_FORMATTER+ "&" +  SIZE_QUERY_STRING_FORMATTER + "&" +
+                    OFFSET_QUERY_STRING_FORMATTER;
+    private static final String WORKFLOW_URL_FORMATTER_QUERY_PARAMS_NO_SORT =
+            WORKFLOWS_URL + "?" + SIZE_QUERY_STRING_FORMATTER + "&" + OFFSET_QUERY_STRING_FORMATTER;
+    private static final String WORKFLOW_URL_FORMATTER_QUERY_PARAMS_NO_SORT_AND_SIZE =
+            WORKFLOWS_URL + "?" + OFFSET_QUERY_STRING_FORMATTER;
+    private static final String WORKFLOW_URL_FORMATTER_QUERY_PARAMS_NO_SORT_AND_OFFSET =
+            WORKFLOWS_URL + "?" + SIZE_QUERY_STRING_FORMATTER;
+
+    public static String getWorkflowsPathAllQueryParams(String sort, String size, String offset){
+        return String.format(WORKFLOW_URL_FORMATTER_QUERY_PARAMS_ALL, sort, size, offset);
+    }
+
+    public static String getWorkflowsPathNoSort(String size, String offset){
+        return String.format(WORKFLOW_URL_FORMATTER_QUERY_PARAMS_NO_SORT, size, offset);
+    }
+
+    public static String getWorkflowsPathNoSortAndSize(String offset){
+        return String.format(WORKFLOW_URL_FORMATTER_QUERY_PARAMS_NO_SORT_AND_SIZE, offset);
+    }
+
+    public static String getWorkflowsPathNoSortAndOffset(String size){
+        return String.format(WORKFLOW_URL_FORMATTER_QUERY_PARAMS_NO_SORT_AND_OFFSET, size);
+    }
+
+    public static String getWorkflowsPath() {
+        return WORKFLOWS_URL;
+    }
+
+    public static String getWorkflowsWithVersionStateFilterPath(String versionState) {
+        return String.format(WORKFLOWS_WITH_VERSION_STATE_FILTER_URL, versionState);
+    }
+
+    public static String getWorkflowPath(String workflowId) {
+        return String.format(WORKFLOW_URL_FORMATTER, workflowId);
+    }
+
+    public static String getWorkflowVersions(String workflowId) {
+        return String.format(VERSIONS_URL_FORMATTER, workflowId);
+    }
+
+    public static String getWorkflowVersion(String workflowId, String versionId) {
+        return String.format(VERSION_URL_FORMATTER, workflowId, versionId);
+    }
+}
diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/TestUtil.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/TestUtil.java
new file mode 100644
index 00000000..e2a566aa
--- /dev/null
+++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/TestUtil.java
@@ -0,0 +1,35 @@
+package org.onap.sdc.workflow;
+
+import org.onap.sdc.workflow.persistence.types.Workflow;
+import org.openecomp.sdc.versioning.types.Item;
+
+public class TestUtil {
+
+    private static final String WORKFLOW_TYPE = "WORKFLOW";
+
+    public static Workflow createWorkflow(int workflowNum, boolean createId) {
+        Workflow workflow = new Workflow();
+        if (createId) {
+            workflow.setId(String.valueOf(workflowNum));
+        }
+        workflow.setName("Workflow_" + workflowNum);
+        workflow.setDescription("Description_" + workflowNum);
+
+        return workflow;
+    }
+
+    public static Item createItem(int itemNum, boolean setType, boolean setId) {
+        Item item = new Item();
+        if (setId) {
+            item.setId(String.valueOf(itemNum));
+        }
+        item.setName("Workflow_" + itemNum);
+        item.setDescription("Description_" + itemNum);
+        if (setType) {
+            item.setType(WORKFLOW_TYPE);
+        }
+        return item;
+    }
+
+
+}
diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/api/WorkflowControllerTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/api/WorkflowControllerTest.java
new file mode 100644
index 00000000..5e7df483
--- /dev/null
+++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/api/WorkflowControllerTest.java
@@ -0,0 +1,287 @@
+package org.onap.sdc.workflow.api;
+
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.collection.IsCollectionWithSize.hasSize;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+import static org.onap.sdc.workflow.TestUtil.createWorkflow;
+import static org.onap.sdc.workflow.api.RestConstants.PAGE_DEFAULT;
+import static org.onap.sdc.workflow.api.RestConstants.SIZE_DEFAULT;
+import static org.onap.sdc.workflow.api.RestConstants.SORT_FIELD_NAME;
+import static org.onap.sdc.workflow.api.RestConstants.SORT_PARAM;
+import static org.onap.sdc.workflow.api.RestConstants.USER_ID_HEADER_PARAM;
+import static org.springframework.http.MediaType.APPLICATION_JSON;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.item.Item;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.collect.ImmutableSet;
+import com.google.gson.Gson;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.onap.sdc.workflow.RestPath;
+import org.onap.sdc.workflow.api.exceptionshandlers.CustomizedResponseEntityExceptionHandler;
+import org.onap.sdc.workflow.api.types.CollectionWrapper;
+import org.onap.sdc.workflow.persistence.types.Workflow;
+import org.onap.sdc.workflow.persistence.types.WorkflowVersionState;
+import org.onap.sdc.workflow.services.WorkflowManager;
+import org.springframework.data.web.PageableHandlerMethodArgumentResolver;
+import org.springframework.mock.web.MockHttpServletResponse;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+
+@RunWith(MockitoJUnitRunner.class)
+public class WorkflowControllerTest {
+
+    private static final String MISSING_REQUEST_HEADER_ERRROR_FORMAT =
+            "Missing request header '%s' for method parameter of type String";
+    private static final String USER_ID = "userId";
+    private static final Gson GSON = new Gson();
+    private static final String USER_ID_HEADER = "USER_ID";
+    private static final String INVALID_PAGINATION_PARAMETER_FORMAT = "Requested %s: %s %s";
+    private static final String PAGINATION_PARAMETER_INVALID_SORT_FIELD_SUFFIX =
+            "is not supported. Supported values are: ";
+    private static final String DEFAULT_SORT_VALUE = "name,asc";
+
+    private MockMvc mockMvc;
+
+
+    @InjectMocks
+    private WorkflowController workflowController;
+
+    @Mock
+    private WorkflowManager workflowManagerMock;
+
+    @Before
+    public void setUp() {
+        mockMvc = MockMvcBuilders.standaloneSetup(workflowController)
+                                 .setCustomArgumentResolvers(new PageableHandlerMethodArgumentResolver())
+                                 .setControllerAdvice(new CustomizedResponseEntityExceptionHandler()).build();
+    }
+
+    @Test
+    public void shouldReturnErrorWhenMissingUserIdInGetReqHeader() throws Exception {
+        Workflow workflowMock = createWorkflow(1, true);
+        MockHttpServletResponse response =
+                mockMvc.perform(get(RestPath.getWorkflowPath(workflowMock.getId())).contentType(APPLICATION_JSON))
+                       .andDo(print()).andExpect(status().isBadRequest()).andExpect(status().is(400)).andReturn()
+                       .getResponse();
+        assertEquals(String.format(MISSING_REQUEST_HEADER_ERRROR_FORMAT, USER_ID_HEADER),
+                response.getContentAsString());
+    }
+
+    @Test
+    public void shouldReturnWorkflowDataWhenRequestPathIsOk() throws Exception {
+        Workflow workflowMock = createWorkflow(1, true);
+        doReturn(workflowMock).when(workflowManagerMock).get(any(Workflow.class));
+        mockMvc.perform(get(RestPath.getWorkflowPath(workflowMock.getId())).header(USER_ID_HEADER_PARAM, USER_ID)
+                                                                           .contentType(APPLICATION_JSON))
+               .andDo(print()).andExpect(status().isOk()).andExpect(jsonPath("$.id", is(workflowMock.getId())))
+               .andExpect(jsonPath("$.name", is(workflowMock.getName())));
+    }
+
+    @Test
+    public void shouldReturnErrorWhenMissingUserIdInListReqHeader() throws Exception {
+        MockHttpServletResponse response =
+                mockMvc.perform(get(RestPath.getWorkflowsPath()).contentType(APPLICATION_JSON)).andDo(print())
+                       .andExpect(status().isBadRequest()).andExpect(status().is(400)).andReturn().getResponse();
+        assertEquals(String.format(MISSING_REQUEST_HEADER_ERRROR_FORMAT, USER_ID_HEADER_PARAM),
+                response.getContentAsString());
+    }
+
+    @Test
+    public void shouldReturn5WorkflowWhen5WorkflowsExists() throws Exception {
+        int numOfWorkflows = 5;
+        List<Workflow> workflowMocks = createWorkflows(numOfWorkflows);
+        doReturn(workflowMocks).when(workflowManagerMock).list(any(), any());
+        mockMvc.perform(
+                get(RestPath.getWorkflowsPath()).header(USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON))
+               .andDo(print()).andExpect(status().isOk()).andExpect(jsonPath("$.results", hasSize(numOfWorkflows)));
+    }
+
+    @Test
+    public void listWithValidVersionStateFilter() throws Exception {
+        int numOfWorkflows = 3;
+        List<Workflow> workflows = createWorkflows(numOfWorkflows);
+        doReturn(workflows).when(workflowManagerMock)
+                           .list(eq(Collections.singleton(WorkflowVersionState.CERTIFIED)), any());
+        mockMvc.perform(
+                get(RestPath.getWorkflowsWithVersionStateFilterPath("CERTIFIED")).header(USER_ID_HEADER_PARAM, USER_ID)
+                                                                                 .contentType(APPLICATION_JSON))
+               .andDo(print()).andExpect(status().isOk()).andExpect(jsonPath("$.total", is(numOfWorkflows)))
+               .andExpect(jsonPath("$.results", hasSize(numOfWorkflows)));
+    }
+
+    @Test
+    public void listWithInvalidVersionStateFilter() throws Exception {
+        mockMvc.perform(
+                get(RestPath.getWorkflowsWithVersionStateFilterPath("hasdhf")).header(USER_ID_HEADER_PARAM, USER_ID)
+                                                                              .contentType(APPLICATION_JSON))
+               .andDo(print()).andExpect(status().isOk()).andExpect(jsonPath("$.total", is(0)));
+    }
+
+    @Test
+    public void shouldReturnSortedSizeOffsetAppliedWorkflows() throws Exception {
+        List<Workflow> workflowMocks = createSize2AndOffset1For5WorkflowList();
+        doReturn(workflowMocks).when(workflowManagerMock).list(any(), any());
+        mockMvc.perform(get(RestPath.getWorkflowsPathAllQueryParams(DEFAULT_SORT_VALUE, "2", "1"))
+                                .header(RestConstants.USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON))
+               .andDo(print()).andExpect(status().isOk()).andExpect(jsonPath("$.results", hasSize(2)));
+    }
+
+    @Test
+    public void shouldReturnResultsWithDefaultWhenSizeIsNegative() throws Exception {
+        List<Workflow> workflowMocks = createSize2AndOffset1For5WorkflowList();
+        doReturn(workflowMocks).when(workflowManagerMock).list(any(), any());
+        MockHttpServletResponse response = mockMvc.perform(
+                get(RestPath.getWorkflowsPathAllQueryParams(DEFAULT_SORT_VALUE, "-2", "1"))
+                        .header(RestConstants.USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON))
+                                                  .andDo(print()).andExpect(status().isOk()).andExpect(status().is(200))
+                                                  .andReturn().getResponse();
+        CollectionWrapper workflowListResponse =
+                new ObjectMapper().readValue(response.getContentAsString(), CollectionWrapper.class);
+        assertEquals(SIZE_DEFAULT, workflowListResponse.getSize());
+        assertEquals(1, workflowListResponse.getPage());
+        assertEquals(2, workflowListResponse.getTotal());
+    }
+
+    @Test
+    public void shouldFallbackOnDefaultOffsetWhenOffsetIsNegative() throws Exception {
+        MockHttpServletResponse response = mockMvc.perform(
+                get(RestPath.getWorkflowsPathAllQueryParams(DEFAULT_SORT_VALUE, "2", "-1"))
+                        .header(RestConstants.USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON))
+                                                  .andDo(print()).andExpect(status().isOk()).andExpect(status().is(200))
+                                                  .andReturn().getResponse();
+        CollectionWrapper workflowListResponse =
+                new ObjectMapper().readValue(response.getContentAsString(), CollectionWrapper.class);
+        assertEquals(2, workflowListResponse.getSize());
+        assertEquals(PAGE_DEFAULT, workflowListResponse.getPage());
+        assertEquals(0, workflowListResponse.getTotal());
+    }
+
+    @Test
+    public void shouldFallbackOnDefaultSizeWhenSizeIsNotAnInteger() throws Exception {
+        MockHttpServletResponse response = mockMvc.perform(
+                get(RestPath.getWorkflowsPathAllQueryParams(DEFAULT_SORT_VALUE, "abc", "0"))
+                        .header(RestConstants.USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON))
+                                                  .andDo(print()).andExpect(status().isOk()).andExpect(status().is(200))
+                                                  .andReturn().getResponse();
+        CollectionWrapper workflowListResponse =
+                new ObjectMapper().readValue(response.getContentAsString(), CollectionWrapper.class);
+        assertEquals(SIZE_DEFAULT, workflowListResponse.getSize());
+        assertEquals(0, workflowListResponse.getPage());
+        assertEquals(0, workflowListResponse.getTotal());
+    }
+
+    @Test
+    public void shouldFallbackOnDefaultOffsetWhenOffsetIsNotAnInteger() throws Exception {
+        MockHttpServletResponse response = mockMvc.perform(
+                get(RestPath.getWorkflowsPathAllQueryParams(DEFAULT_SORT_VALUE, "2", "abc"))
+                        .header(RestConstants.USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON))
+                                                  .andDo(print()).andExpect(status().isOk()).andExpect(status().is(200))
+                                                  .andReturn().getResponse();
+        CollectionWrapper workflowListResponse =
+                new ObjectMapper().readValue(response.getContentAsString(), CollectionWrapper.class);
+        assertEquals(2, workflowListResponse.getSize());
+        assertEquals(PAGE_DEFAULT, workflowListResponse.getPage());
+        assertEquals(0, workflowListResponse.getTotal());
+    }
+
+    @Test
+    public void shouldThrowExceptionWhenSortFieldIsInvalid() throws Exception {
+        MockHttpServletResponse response = mockMvc.perform(
+                get(RestPath.getWorkflowsPathAllQueryParams("invalidSortField,asc", "2", "1"))
+                        .header(RestConstants.USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON))
+                                                  .andDo(print()).andExpect(status().isBadRequest())
+                                                  .andExpect(status().is(400)).andReturn().getResponse();
+        assertEquals(String.format(INVALID_PAGINATION_PARAMETER_FORMAT, SORT_PARAM, "invalidSortField",
+                PAGINATION_PARAMETER_INVALID_SORT_FIELD_SUFFIX + getSupportedSortFields()),
+                response.getContentAsString());
+    }
+
+    @Test
+    public void shouldReturnAscSortedSizeOffsetAppliedWorkflowsWhenSortIsNotSpecified() throws Exception {
+        List<Workflow> workflowMocks = createSize2AndOffset1For5WorkflowList();
+        doReturn(workflowMocks).when(workflowManagerMock).list(any(), any());
+        mockMvc.perform(
+                get(RestPath.getWorkflowsPathNoSort("2", "1")).header(RestConstants.USER_ID_HEADER_PARAM, USER_ID)
+                                                              .contentType(APPLICATION_JSON)).andDo(print())
+               .andExpect(status().isOk()).andExpect(jsonPath("$.results", hasSize(2)));
+    }
+
+    @Test
+    public void shouldReturnDefaultSizeOffsetAppliedWorkflowsWhenSizeIsNotSpecified() throws Exception {
+        List<Workflow> workflowMocks = createSize2AndOffset1For5WorkflowList();
+        doReturn(workflowMocks).when(workflowManagerMock).list(any(), any());
+        mockMvc.perform(
+                get(RestPath.getWorkflowsPathNoSortAndSize("1")).header(RestConstants.USER_ID_HEADER_PARAM, USER_ID)
+                                                                .contentType(APPLICATION_JSON)).andDo(print())
+               .andExpect(status().isOk()).andExpect(jsonPath("$.results", hasSize(2)));
+    }
+
+    @Test
+    public void shouldReturnDefaultOffsetAppliedWorkflowsWhenOffsetIsNotSpecified() throws Exception {
+        List<Workflow> workflowMocks = createSize1WorkflowList();
+        doReturn(workflowMocks).when(workflowManagerMock).list(any(), any());
+        mockMvc.perform(
+                get(RestPath.getWorkflowsPathNoSortAndOffset("1")).header(RestConstants.USER_ID_HEADER_PARAM, USER_ID)
+                                                                  .contentType(APPLICATION_JSON)).andDo(print())
+               .andExpect(status().isOk()).andExpect(jsonPath("$.results", hasSize(1)));
+    }
+
+    @Test
+    public void shouldCreateWorkflowWhenCallingPostRESTRequest() throws Exception {
+        Item item = new Item();
+        item.setId(new Id("abc"));
+        Workflow reqWorkflow = createWorkflow(1, false);
+        mockMvc.perform(
+                post(RestPath.getWorkflowsPath()).header(USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON)
+                                                 .content(GSON.toJson(reqWorkflow))).andDo(print())
+               .andExpect(status().isCreated());
+        verify(workflowManagerMock).create(reqWorkflow);
+    }
+
+    private List<Workflow> createWorkflows(int numOfWorkflows) {
+        List<Workflow> workflowList = new ArrayList<>(numOfWorkflows);
+        for (int i = 0; i < numOfWorkflows; i++) {
+            workflowList.add(createWorkflow(i, true));
+        }
+
+        return workflowList;
+    }
+
+    private List<Workflow> createSize2AndOffset1For5WorkflowList() {
+        List<Workflow> workflowList = new ArrayList<>();
+        workflowList.add(createWorkflow(2, true));
+        workflowList.add(createWorkflow(3, true));
+        return workflowList;
+    }
+
+    private List<Workflow> createSize1WorkflowList() {
+        List<Workflow> workflowList = new ArrayList<>();
+        workflowList.add(createWorkflow(0, true));
+        return workflowList;
+    }
+
+
+    private Set<String> getSupportedSortFields() {
+        return ImmutableSet.of(SORT_FIELD_NAME);
+    }
+
+}
\ No newline at end of file
diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/api/WorkflowVersionControllerTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/api/WorkflowVersionControllerTest.java
new file mode 100644
index 00000000..ee9a56c8
--- /dev/null
+++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/api/WorkflowVersionControllerTest.java
@@ -0,0 +1,117 @@
+package org.onap.sdc.workflow.api;
+
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.collection.IsCollectionWithSize.hasSize;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.springframework.http.MediaType.APPLICATION_JSON;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
+import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+import com.google.gson.Gson;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.onap.sdc.workflow.RestPath;
+import org.onap.sdc.workflow.persistence.types.WorkflowVersion;
+import org.onap.sdc.workflow.services.WorkflowVersionManager;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.springframework.http.HttpStatus;
+import org.springframework.mock.web.MockHttpServletResponse;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+
+@RunWith(MockitoJUnitRunner.class)
+public class WorkflowVersionControllerTest {
+
+    private static final String USER_ID = "cs0008";
+    private static final String ITEM1_ID = "item_id_1";
+    private static final String VERSION1_ID = "version_id_1";
+    private static final String VERSION2_ID = "version_id_2";
+    private List<Version> versionList;
+
+    private static final Gson GSON = new Gson();
+
+    private MockMvc mockMvc;
+
+    @Mock
+    private WorkflowVersionManager workflowVersionManagerMock;
+
+    @InjectMocks
+    private WorkflowVersionController workflowVersionController;
+
+    @Before
+    public void setUp() {
+        versionList = Arrays.asList( new Version(VERSION1_ID),new Version(VERSION2_ID));
+        mockMvc = MockMvcBuilders.standaloneSetup(workflowVersionController).build();
+    }
+
+    @Test
+    public void shouldReturnWorkflowVersionListWhenCallingVersionGetREST() throws Exception {
+
+        doReturn(versionList).when(workflowVersionManagerMock).list(ITEM1_ID, null);
+        mockMvc.perform(get(RestPath.getWorkflowVersions(ITEM1_ID)).header(RestConstants.USER_ID_HEADER_PARAM, USER_ID)
+                                                                   .contentType(APPLICATION_JSON)).andExpect(status().isOk())
+               .andExpect(jsonPath("$.results", hasSize(2)))
+               .andExpect(jsonPath("$.results[0].id", equalTo(VERSION1_ID)))
+               .andExpect(jsonPath("$.results[1].id", equalTo(VERSION2_ID)));
+
+        verify(workflowVersionManagerMock, times(1)).list(ITEM1_ID, null);
+    }
+
+
+    @Test
+    public void shouldCreateWorkflowVersionWhenCallingVersionsPostREST() throws Exception {
+
+        WorkflowVersion version = new WorkflowVersion();
+        version.setDescription("VersionDescription");
+        mockMvc.perform(post(RestPath.getWorkflowVersions(ITEM1_ID)).header(RestConstants.USER_ID_HEADER_PARAM, USER_ID)
+                                                                    .contentType(APPLICATION_JSON)
+                                                                    .content(GSON.toJson(version)))
+               .andExpect(status().isCreated());
+
+        verify(workflowVersionManagerMock, times(1)).create(ITEM1_ID, null, version);
+    }
+
+
+    @Test
+    public void shouldReturnWorkflowVersionWhenExists() throws Exception {
+        WorkflowVersion version = new WorkflowVersion(VERSION1_ID);
+        doReturn(version).when(workflowVersionManagerMock).get(ITEM1_ID, VERSION1_ID);
+        mockMvc.perform(
+                get(RestPath.getWorkflowVersion(ITEM1_ID, VERSION1_ID)).header(RestConstants.USER_ID_HEADER_PARAM, USER_ID)
+                                                                       .contentType(APPLICATION_JSON)).andDo(print())
+               .andExpect(status().isOk()).andExpect(jsonPath("$.id", is(version.getId())));
+        verify(workflowVersionManagerMock, times(1)).get(ITEM1_ID, VERSION1_ID);
+    }
+
+    @Test
+    public void shouldUpdateWorkflowVersionWhenCallingPutREST() throws Exception {
+        WorkflowVersion version = new WorkflowVersion();
+        version.setDescription("Updated");
+
+        MockHttpServletResponse result = mockMvc.perform(
+                put(RestPath.getWorkflowVersion(ITEM1_ID, VERSION1_ID)).header(RestConstants.USER_ID_HEADER_PARAM, USER_ID)
+                                                                       .contentType(APPLICATION_JSON)
+                                                                       .content(GSON.toJson(version))).andReturn()
+                                                .getResponse();
+
+        assertEquals(HttpStatus.OK.value(), result.getStatus());
+        version.setId(VERSION1_ID);
+        verify(workflowVersionManagerMock, times(1)).update(ITEM1_ID, version);
+
+    }
+
+}
diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/persistence/impl/ArtifactRepositoryTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/persistence/impl/ArtifactRepositoryTest.java
new file mode 100644
index 00000000..b86b14b9
--- /dev/null
+++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/persistence/impl/ArtifactRepositoryTest.java
@@ -0,0 +1,99 @@
+package org.onap.sdc.workflow.persistence.impl;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.isNull;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+import static org.openecomp.core.zusammen.api.ZusammenUtil.buildStructuralElement;
+
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.Element;
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.ZusammenElement;
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.item.Action;
+import com.amdocs.zusammen.datatypes.item.ElementContext;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Optional;
+import org.apache.commons.io.IOUtils;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.onap.sdc.workflow.persistence.types.ArtifactEntity;
+import org.onap.sdc.workflow.persistence.types.WorkflowElementType;
+import org.openecomp.core.zusammen.api.ZusammenAdaptor;
+import org.openecomp.sdc.common.session.SessionContextProviderFactory;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ArtifactRepositoryTest {
+
+    private static final String FILE_NAME_PROPERTY = "fileName";
+    private static final String FILE_NAME = "fileName.txt";
+    private static final String ITEM1_ID = "item_id_1";
+    private static final String VERSION1_ID = "version_id_1";
+
+
+    @Mock
+    private ZusammenAdaptor zusammenAdaptorMock;
+
+    @InjectMocks
+    private ArtifactRepositoryImpl artifactRepository;
+
+    @Before
+    public void setUp() {
+        SessionContextProviderFactory.getInstance().createInterface().create("test_user", "workflow");
+    }
+
+    @Test
+    public void shouldUpdateArtifact() throws IOException {
+
+        InputStream inputStreamMock = IOUtils.toInputStream("some test data for my input stream", "UTF-8");
+        ArtifactEntity artifactMock = new ArtifactEntity(FILE_NAME, inputStreamMock);
+
+        artifactRepository.update(ITEM1_ID, VERSION1_ID, artifactMock);
+        verify(zusammenAdaptorMock)
+                .saveElement(any(SessionContext.class), any(ElementContext.class), any(ZusammenElement.class),
+                        eq("Update WorkflowVersion Artifact Element"));
+    }
+
+    @Test
+    public void shouldGetArtifactWhenExist() throws IOException {
+
+        ZusammenElement artifactElement = buildStructuralElement(WorkflowElementType.ARTIFACT.name(), Action.UPDATE);
+        artifactElement.setData(IOUtils.toInputStream("some test data for my input stream", "UTF-8"));
+        artifactElement.getInfo().addProperty(FILE_NAME_PROPERTY, FILE_NAME);
+        Optional<Element> elementOptional = Optional.of(artifactElement);
+
+        doReturn(elementOptional).when(zusammenAdaptorMock)
+                                 .getElementByName(any(SessionContext.class), any(ElementContext.class), isNull(Id.class),
+                                         eq(WorkflowElementType.ARTIFACT.name()));
+
+        Optional<ArtifactEntity> result = artifactRepository.get(ITEM1_ID, VERSION1_ID);
+        assertTrue(result.isPresent());
+        assertEquals(FILE_NAME,result.get().getFileName());
+        verify(zusammenAdaptorMock).getElementByName(any(SessionContext.class), any(ElementContext.class), isNull(Id.class),
+                eq(WorkflowElementType.ARTIFACT.name()));
+    }
+
+    @Test
+    public void shouldCreateArtifactStructure() {
+        artifactRepository.createStructure(ITEM1_ID, VERSION1_ID);
+        verify(zusammenAdaptorMock)
+                .saveElement(any(SessionContext.class), any(ElementContext.class), any(ZusammenElement.class),
+                        eq("Create WorkflowVersion Artifact Element"));
+    }
+
+    @Test
+    public void shouldDeleteArtifact(){
+        artifactRepository.delete(ITEM1_ID,VERSION1_ID);
+        verify(zusammenAdaptorMock).saveElement(any(SessionContext.class), any(ElementContext.class), any(ZusammenElement.class),
+                eq("Delete WorkflowVersion Artifact Data"));
+    }
+
+}
diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/persistence/impl/ParameterRepositoryTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/persistence/impl/ParameterRepositoryTest.java
new file mode 100644
index 00000000..07a42658
--- /dev/null
+++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/persistence/impl/ParameterRepositoryTest.java
@@ -0,0 +1,166 @@
+package org.onap.sdc.workflow.persistence.impl;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementInfo;
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.ZusammenElement;
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.item.ElementContext;
+import com.amdocs.zusammen.datatypes.item.Info;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Optional;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mapstruct.ap.internal.util.Collections;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Spy;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.onap.sdc.workflow.persistence.types.ParameterEntity;
+import org.onap.sdc.workflow.persistence.types.ParameterPropertyName;
+import org.onap.sdc.workflow.persistence.types.ParameterRole;
+import org.onap.sdc.workflow.persistence.types.ParameterType;
+import org.onap.sdc.workflow.persistence.types.WorkflowElementType;
+import org.openecomp.core.zusammen.api.ZusammenAdaptor;
+import org.openecomp.sdc.common.session.SessionContextProviderFactory;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ParameterRepositoryTest {
+
+    private static final String ITEM1_ID = "item_id_1";
+    private static final String VERSION1_ID = "version_id_1";
+    private static final String PARAMETER1_ID = "parameter_id_1";
+    private static final String PARAMETER2_ID = "parameter_id_2";
+    private static final String PARAMETERS_PARENT_ID = "parameters_id";
+
+
+    @Mock
+    private ZusammenAdaptor zusammenAdaptorMock;
+    @Spy
+    @InjectMocks
+    private ParameterRepositoryImpl parameterRepository;
+
+    @Before
+    public void setUp() {
+        SessionContextProviderFactory.getInstance().createInterface().create("test_user", "workflow");
+    }
+
+    @Test
+    public void shouldGetParameterById() {
+
+        ElementInfo element = new ElementInfo();
+        element.setId(new Id(PARAMETER1_ID));
+        Info info = new Info();
+        info.setName("testInput");
+        info.addProperty(ParameterPropertyName.TYPE.name(), ParameterType.FLOAT.name());
+        info.addProperty(ParameterPropertyName.mandatory.name(), true);
+        element.setInfo(info);
+        doReturn(Optional.of(element)).when(zusammenAdaptorMock)
+                                      .getElementInfo(any(SessionContext.class), any(ElementContext.class),
+                                              eq(new Id(PARAMETER1_ID)));
+        ParameterEntity result = parameterRepository.get(ITEM1_ID, VERSION1_ID, PARAMETER1_ID);
+        verify(zusammenAdaptorMock)
+                .getElementInfo(any(SessionContext.class), any(ElementContext.class), eq(new Id(PARAMETER1_ID)));
+        assertEquals("testInput", result.getName());
+
+    }
+
+
+    @Test
+    public void shouldUpdateParameter() {
+        ParameterEntity parameterEntityToUpdate = new ParameterEntity();
+        parameterEntityToUpdate.setId(PARAMETER1_ID);
+        parameterEntityToUpdate.setName("Input1");
+        parameterEntityToUpdate.setMandatory(true);
+        parameterEntityToUpdate.setType(ParameterType.STRING);
+
+        parameterRepository.update(ITEM1_ID, VERSION1_ID, ParameterRole.INPUT, parameterEntityToUpdate);
+        verify(zusammenAdaptorMock)
+                .saveElement(any(SessionContext.class), any(ElementContext.class), any(ZusammenElement.class),
+                        eq("Update WorkflowVersion Parameter"));
+
+    }
+
+    @Test
+    public void shouldCreateParameterStructure() {
+        parameterRepository.createStructure(ITEM1_ID, VERSION1_ID);
+        verify(zusammenAdaptorMock)
+                .saveElement(any(SessionContext.class), any(ElementContext.class), any(ZusammenElement.class),
+                        eq("Create WorkflowVersion INPUTS Element"));
+        verify(zusammenAdaptorMock)
+                .saveElement(any(SessionContext.class), any(ElementContext.class), any(ZusammenElement.class),
+                        eq("Create WorkflowVersion OUTPUTS Element"));
+    }
+
+    @Test
+    public void shouldDeleteParameter() {
+        parameterRepository.delete(ITEM1_ID, VERSION1_ID, PARAMETER1_ID);
+        verify(zusammenAdaptorMock)
+                .saveElement(any(SessionContext.class), any(ElementContext.class), any(ZusammenElement.class),
+                        eq("Delete Parameter with id parameter_id_1"));
+    }
+
+
+    @Test
+    public void shouldListParametersByType() {
+
+        ElementInfo parameter1 = new ElementInfo();
+        parameter1.setId(new Id(PARAMETER1_ID));
+        Info info1 = new Info();
+        info1.setName("input1");
+        info1.addProperty(ParameterPropertyName.TYPE.name(), "INTEGER");
+        info1.addProperty(ParameterPropertyName.mandatory.name(), true);
+        parameter1.setInfo(info1);
+        ElementInfo parameter2 = new ElementInfo();
+        parameter2.setId(new Id(PARAMETER2_ID));
+        Info info2 = new Info();
+        info2.setName("input2");
+        info2.addProperty(ParameterPropertyName.TYPE.name(), "STRING");
+        info2.addProperty(ParameterPropertyName.mandatory.name(), false);
+        parameter2.setInfo(info2);
+        Collection<ElementInfo> parameters = Collections.asSet(parameter1, parameter2);
+        doReturn(parameters).when(zusammenAdaptorMock)
+                            .listElementsByName(any(SessionContext.class), any(ElementContext.class), isNull(),
+                                    eq(WorkflowElementType.INPUTS.name()));
+        Collection<ParameterEntity> results = parameterRepository.list(ITEM1_ID, VERSION1_ID, ParameterRole.INPUT);
+
+        verify(zusammenAdaptorMock).listElementsByName(any(SessionContext.class), any(ElementContext.class), isNull(),
+                eq(WorkflowElementType.INPUTS.name()));
+        assertTrue(results.stream().anyMatch(parameterEntity -> parameterEntity.getId().equals(PARAMETER1_ID)));
+        assertTrue(results.stream().anyMatch(parameterEntity -> parameterEntity.getId().equals(PARAMETER2_ID)));
+    }
+
+    @Test
+    public void shouldDeleteAllParametersByType() {
+        ElementInfo parameterParentElement = new ElementInfo();
+        parameterParentElement.setId(new Id(PARAMETERS_PARENT_ID));
+        ElementInfo parameter1 = new ElementInfo();
+        parameter1.setId(new Id(PARAMETER1_ID));
+        ElementInfo parameter2 = new ElementInfo();
+        parameter2.setId(new Id(PARAMETER2_ID));
+        parameterParentElement.setSubElements(new ArrayList<>());
+        parameterParentElement.getSubElements().add(parameter1);
+        parameterParentElement.getSubElements().add(parameter2);
+
+        Optional<ElementInfo> elementOptional = Optional.of(parameterParentElement);
+
+        doReturn(elementOptional).when(zusammenAdaptorMock)
+                                 .getElementInfoByName(any(SessionContext.class), any(ElementContext.class), isNull(),
+                                         eq(WorkflowElementType.INPUTS.name()));
+
+        parameterRepository.deleteAll(ITEM1_ID, VERSION1_ID, ParameterRole.INPUT);
+        verify(zusammenAdaptorMock)
+                .saveElement(any(SessionContext.class), any(ElementContext.class), any(ZusammenElement.class),
+                        eq("Delete all INPUT"));
+    }
+
+}
diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/UniqueValueServiceTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/UniqueValueServiceTest.java
new file mode 100644
index 00000000..4911060a
--- /dev/null
+++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/UniqueValueServiceTest.java
@@ -0,0 +1,98 @@
+package org.onap.sdc.workflow.services;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import java.util.Optional;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+import org.onap.sdc.workflow.persistence.UniqueValueRepository;
+import org.onap.sdc.workflow.persistence.types.UniqueValueEntity;
+import org.onap.sdc.workflow.services.exceptions.UniqueValueViolationException;
+
+public class UniqueValueServiceTest {
+
+    private static final String TYPE = "ss";
+    private static final String DUMMY_COMBINATION = "dummy";
+
+    @Mock
+    private UniqueValueRepository uniqueValueRepositoryMock;
+
+    @Spy
+    @InjectMocks
+    private UniqueValueService uniqueValueService;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @Test
+    public void shouldCallRepositoryInsertIfValueUnique(){
+        doReturn(Optional.empty()).when(uniqueValueRepositoryMock).findById(any());
+        uniqueValueService.createUniqueValue(TYPE, new String[]{DUMMY_COMBINATION});
+        verify(uniqueValueRepositoryMock, times(1)).insert(any(UniqueValueEntity.class));
+    }
+
+    @Test
+    public void shouldNotCheckValueIfNoUniqueCombination(){
+        uniqueValueService.createUniqueValue(TYPE, null);
+        verify(uniqueValueRepositoryMock, never()).findById(any(UniqueValueEntity.class));
+    }
+
+    @Test(expected = UniqueValueViolationException.class)
+    public void shouldThrowExceptionIfValueIsNotUnique(){
+        doReturn(Optional.of("xxx")).when(uniqueValueRepositoryMock).findById(any());
+        uniqueValueService.createUniqueValue(TYPE, new String[]{DUMMY_COMBINATION});
+    }
+
+    @Test
+    public void shouldCallRepositoryDeleteIfValueValid(){
+        uniqueValueService.deleteUniqueValue(TYPE, new String[]{DUMMY_COMBINATION});
+        verify(uniqueValueRepositoryMock, times(1)).delete(any(UniqueValueEntity.class));
+    }
+
+    @Test
+    public void shouldNotCallRepositoryDeleteIfValueNouniqueCombination(){
+        uniqueValueService.deleteUniqueValue(TYPE, new String[]{});
+        verify(uniqueValueRepositoryMock, never()).delete(any(UniqueValueEntity.class));
+    }
+
+    @Test
+    public void shouldNotUpdateIfNewAndOldValueAreEqualsCaseIgnore(){
+        String value = "value";
+        uniqueValueService.updateUniqueValue(TYPE, value, value.toUpperCase());
+        verify(uniqueValueService, never()).createUniqueValue(anyString(), any());
+    }
+
+    @Test
+    public void shouldUpdateIfNewAndOldValueAreNotEqualsCaseIgnore(){
+        String oldValue = "oldValue";
+        String newValue = "newValue";
+        uniqueValueService.updateUniqueValue(TYPE, oldValue, newValue);
+        verify(uniqueValueService, times(1)).createUniqueValue(anyString(), any());
+        verify(uniqueValueService, times(1)).deleteUniqueValue(anyString(), any());
+    }
+
+    @Test
+    public void shouldReturnTrueIfValueExist() {
+        doReturn(Optional.of("xxx")).when(uniqueValueRepositoryMock).findById(any());
+        assertTrue(uniqueValueService.isUniqueValueOccupied(TYPE, new String[]{DUMMY_COMBINATION}));
+    }
+
+    @Test
+    public void shouldReturnFalseIfValueNotExist() {
+        doReturn(Optional.empty()).when(uniqueValueRepositoryMock).findById(any());
+        assertFalse(uniqueValueService.isUniqueValueOccupied(TYPE, new String[]{DUMMY_COMBINATION}));
+    }
+}
diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/WorkflowManagerImplTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/WorkflowManagerImplTest.java
new file mode 100644
index 00000000..0105fe83
--- /dev/null
+++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/WorkflowManagerImplTest.java
@@ -0,0 +1,240 @@
+package org.onap.sdc.workflow.services.impl;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.onap.sdc.workflow.TestUtil.createItem;
+import static org.onap.sdc.workflow.TestUtil.createWorkflow;
+import static org.onap.sdc.workflow.api.RestConstants.SORT_FIELD_NAME;
+import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Certified;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.onap.sdc.workflow.persistence.types.Workflow;
+import org.onap.sdc.workflow.persistence.types.WorkflowVersionState;
+import org.onap.sdc.workflow.services.UniqueValueService;
+import org.onap.sdc.workflow.services.exceptions.EntityNotFoundException;
+import org.onap.sdc.workflow.services.impl.mappers.VersionStateMapper;
+import org.onap.sdc.workflow.services.impl.mappers.WorkflowMapper;
+import org.openecomp.sdc.versioning.ItemManager;
+import org.openecomp.sdc.versioning.types.Item;
+import org.openecomp.sdc.versioning.types.ItemStatus;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+public class WorkflowManagerImplTest {
+
+    private static final String ITEM1_ID = "1";
+    private static final String WORKFLOW_TYPE = "WORKFLOW";
+    private static final String WORKFLOW_NAME_UNIQUE_TYPE = "WORKFLOW_NAME";
+    private static final List<Item> ITEMS;
+    private static final List<Workflow> MAPPED_WORKFLOWS;
+
+    static {
+        List<Item> items = new ArrayList<>();
+        List<Workflow> mappedWorkflows = new ArrayList<>();
+        for (int i = 1; i < 6; i++) {
+            items.add(createItem(i, true, true));
+            mappedWorkflows.add(createWorkflow(i, true));
+        }
+        ITEMS = Collections.unmodifiableList(items);
+        MAPPED_WORKFLOWS = Collections.unmodifiableList(mappedWorkflows);
+    }
+
+    @Mock
+    private ItemManager itemManagerMock;
+    @Mock
+    private UniqueValueService uniqueValueServiceMock;
+    @Mock
+    private WorkflowMapper workflowMapperMock;
+    @Mock
+    private VersionStateMapper versionStateMapperMock;
+    @InjectMocks
+    private WorkflowManagerImpl workflowManager;
+
+    @Test
+    public void shouldReturnWorkflowVersionList() {
+        doReturn(ITEMS).when(itemManagerMock).list(any());
+        for (int i = 0; i < ITEMS.size(); i++) {
+            doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i));
+        }
+        Collection<Workflow> workflows =
+                workflowManager.list(null, createPageRequest(20, 0, Sort.Direction.ASC, SORT_FIELD_NAME));
+
+        Map<String, Workflow> workflowById =
+                workflows.stream().collect(Collectors.toMap(Workflow::getId, Function.identity()));
+        assertEquals(ITEMS.size(), workflows.size());
+        for (int i = 1; i < ITEMS.size() + 1; i++) {
+            assertTrue(workflowById.containsKey(String.valueOf(i)));
+        }
+    }
+
+    @Test
+    public void listWithVersionStateFilter() {
+        doReturn(Certified).when(versionStateMapperMock)
+                           .workflowVersionStateToVersionStatus(WorkflowVersionState.CERTIFIED);
+        doReturn(Arrays.asList(ITEMS.get(0), ITEMS.get(2))).when(itemManagerMock).list(any());
+        doReturn(MAPPED_WORKFLOWS.get(0)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(0));
+        doReturn(MAPPED_WORKFLOWS.get(2)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(2));
+
+        Collection<Workflow> workflows = workflowManager.list(Collections.singleton(WorkflowVersionState.CERTIFIED),
+                createPageRequest(20, 0, Sort.Direction.ASC, SORT_FIELD_NAME));
+
+        Map<String, Workflow> workflowById =
+                workflows.stream().collect(Collectors.toMap(Workflow::getId, Function.identity()));
+        assertEquals(2, workflows.size());
+        assertTrue(workflowById.containsKey("1"));
+        assertTrue(workflowById.containsKey("3"));
+    }
+
+    @Test(expected = EntityNotFoundException.class)
+    public void shouldThrowExceptionWhenWorkflowDontExist() {
+        Workflow nonExistingWorkflow = new Workflow();
+        nonExistingWorkflow.setId(ITEM1_ID);
+        doReturn(null).when(itemManagerMock).get(ITEM1_ID);
+        workflowManager.get(nonExistingWorkflow);
+        verify(workflowMapperMock, times(3)).itemToWorkflow(any(Item.class));
+    }
+
+    @Test
+    public void shouldReturnWorkflow() {
+        Item retrievedItem = createItem(1, true, true);
+        doReturn(retrievedItem).when(itemManagerMock).get(ITEM1_ID);
+        Workflow workflow = createWorkflow(1, true);
+        workflowManager.get(workflow);
+        verify(itemManagerMock).get(ITEM1_ID);
+        verify(workflowMapperMock).itemToWorkflow(retrievedItem);
+    }
+
+    @Test
+    public void shouldCreateWorkflowItemFromWorkflow() {
+        Workflow workflowToBeCreated = createWorkflow(1, false);
+        Item createdWorkflowItem = createItem(1, false, true);
+        doReturn(createdWorkflowItem).when(workflowMapperMock).workflowToItem(workflowToBeCreated);
+        doReturn(createdWorkflowItem).when(itemManagerMock).create(createdWorkflowItem);
+        workflowManager.create(workflowToBeCreated);
+        verify(uniqueValueServiceMock)
+                .validateUniqueValue(WORKFLOW_NAME_UNIQUE_TYPE, new String[] {workflowToBeCreated.getName()});
+
+        createdWorkflowItem.setStatus(ItemStatus.ACTIVE);
+        createdWorkflowItem.setType(WORKFLOW_TYPE);
+        verify(itemManagerMock).create(createdWorkflowItem);
+        verify(uniqueValueServiceMock)
+                .createUniqueValue(WORKFLOW_NAME_UNIQUE_TYPE, new String[] {workflowToBeCreated.getName()});
+    }
+
+    @Test
+    public void shouldUpdateWorkflow() {
+        Item workflowItem = createItem(1, true, true);
+        doReturn(workflowItem).when(itemManagerMock).get(ITEM1_ID);
+        Workflow workflowToBeUpdated = createWorkflow(1, true);
+        doReturn(workflowItem).when(workflowMapperMock).workflowToItem(workflowToBeUpdated);
+        workflowManager.update(workflowToBeUpdated);
+        verify(itemManagerMock).update(workflowItem);
+        verify(uniqueValueServiceMock)
+                .updateUniqueValue(WORKFLOW_NAME_UNIQUE_TYPE, workflowItem.getName(), workflowToBeUpdated.getName());
+
+    }
+
+    @Test(expected = EntityNotFoundException.class)
+    public void shouldThrowExceptionWhenWorkflowToUpdateNotFound() {
+        doReturn(null).when(itemManagerMock).get(ITEM1_ID);
+        workflowManager.update(createWorkflow(1, true));
+    }
+
+    @Test
+    public void shouldListAllWorkflowsWhenLimitAndOffsetAreValid() {
+        PageRequest pageRequest = createPageRequest(5, 0, Sort.Direction.ASC, SORT_FIELD_NAME);
+        doReturn(ITEMS).when(itemManagerMock).list(any());
+        for (int i = 0; i < ITEMS.size(); i++) {
+            doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i));
+        }
+        Assert.assertEquals(5, workflowManager.list(null, pageRequest).size());
+    }
+
+    @Test
+    public void shouldListLimitFilteredWorkflowsInFirstOffsetRange() {
+        PageRequest pageRequest = createPageRequest(3, 0, Sort.Direction.ASC, SORT_FIELD_NAME);
+        doReturn(ITEMS).when(itemManagerMock).list(any());
+        for (int i = 0; i < ITEMS.size(); i++) {
+            doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i));
+        }
+        Assert.assertEquals(3, workflowManager.list(null, pageRequest).size());
+    }
+
+    @Test
+    public void shouldListLimitFilteredWorkflowsInSecondOffsetRange() {
+        PageRequest pageRequest = createPageRequest(3, 1, Sort.Direction.ASC, SORT_FIELD_NAME);
+        doReturn(ITEMS).when(itemManagerMock).list(any());
+        for (int i = 0; i < ITEMS.size(); i++) {
+            doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i));
+        }
+        Assert.assertEquals(2, workflowManager.list(null, pageRequest).size());
+    }
+
+    @Test
+    public void shouldListAllWorkflowsWhenLimitGreaterThanTotalRecordsAndOffsetInRange() {
+        PageRequest pageRequest = createPageRequest(10, 0, Sort.Direction.ASC, SORT_FIELD_NAME);
+        doReturn(ITEMS).when(itemManagerMock).list(any());
+        for (int i = 0; i < ITEMS.size(); i++) {
+            doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i));
+        }
+        Assert.assertEquals(5, workflowManager.list(null, pageRequest).size());
+    }
+
+    @Test
+    public void shouldNotListWorkflowsIfOffsetGreaterThanTotalRecords() {
+        PageRequest pageRequest = createPageRequest(3, 6, Sort.Direction.ASC, SORT_FIELD_NAME);
+        doReturn(ITEMS).when(itemManagerMock).list(any());
+        for (int i = 0; i < ITEMS.size(); i++) {
+            doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i));
+        }
+        Assert.assertEquals(0, workflowManager.list(null, pageRequest).size());
+    }
+
+    @Test
+    public void shouldNotListWorkflowsBothLimitAndOffsetGreaterThanTotalRecords() {
+        PageRequest pageRequest = createPageRequest(10, 10, Sort.Direction.ASC, SORT_FIELD_NAME);
+        doReturn(ITEMS).when(itemManagerMock).list(any());
+        for (int i = 0; i < ITEMS.size(); i++) {
+            doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i));
+        }
+        Assert.assertEquals(0, workflowManager.list(null, pageRequest).size());
+    }
+
+    @Test
+    public void shouldListLimitOffsetAppliedWorkflowsSortedInDescOrder() {
+        PageRequest pageRequest = createPageRequest(2, 1, Sort.Direction.DESC, SORT_FIELD_NAME);
+        doReturn(ITEMS).when(itemManagerMock).list(any());
+        for (int i = 0; i < ITEMS.size(); i++) {
+            doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i));
+        }
+        Collection<Workflow> workflows = workflowManager.list(null, pageRequest);
+        Assert.assertEquals(2, workflows.size());
+        Iterator<Workflow> workflowIterator = workflows.iterator();
+        Assert.assertEquals("Workflow_3", workflowIterator.next().getName());
+        Assert.assertEquals("Workflow_2", workflowIterator.next().getName());
+    }
+
+    private PageRequest createPageRequest(int limit, int offset, Sort.Direction sortOrder, String sortField) {
+        return PageRequest.of(offset, limit, sortOrder, sortField);
+    }
+
+}
\ No newline at end of file
diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/WorkflowVersionManagerImplTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/WorkflowVersionManagerImplTest.java
new file mode 100644
index 00000000..7dee5245
--- /dev/null
+++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/WorkflowVersionManagerImplTest.java
@@ -0,0 +1,264 @@
+package org.onap.sdc.workflow.services.impl;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.onap.sdc.workflow.persistence.types.WorkflowVersionState.CERTIFIED;
+import static org.onap.sdc.workflow.persistence.types.WorkflowVersionState.DRAFT;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import org.apache.commons.io.IOUtils;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatcher;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Spy;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.onap.sdc.workflow.persistence.ArtifactRepository;
+import org.onap.sdc.workflow.persistence.ParameterRepository;
+import org.onap.sdc.workflow.persistence.types.ArtifactEntity;
+import org.onap.sdc.workflow.persistence.types.ParameterRole;
+import org.onap.sdc.workflow.persistence.types.WorkflowVersion;
+import org.onap.sdc.workflow.persistence.types.WorkflowVersionState;
+import org.onap.sdc.workflow.services.exceptions.EntityNotFoundException;
+import org.onap.sdc.workflow.services.exceptions.VersionCreationException;
+import org.onap.sdc.workflow.services.exceptions.VersionStateModificationException;
+import org.onap.sdc.workflow.services.impl.mappers.VersionMapper;
+import org.onap.sdc.workflow.services.impl.mappers.VersionStateMapper;
+import org.openecomp.sdc.versioning.VersioningManager;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.dao.types.VersionStatus;
+import org.openecomp.sdc.versioning.types.VersionCreationMethod;
+import org.springframework.mock.web.MockMultipartFile;
+
+@RunWith(MockitoJUnitRunner.class)
+public class WorkflowVersionManagerImplTest {
+
+    private static final String ITEM1_ID = "item_id_1";
+    private static final String VERSION1_ID = "version_id_1";
+    private static final String VERSION2_ID = "version_id_2";
+
+    @Mock
+    private VersioningManager versioningManagerMock;
+    @Mock
+    private ParameterRepository parameterRepositoryMock;
+    @Mock
+    private ArtifactRepository artifactRepositoryMock;
+    @Mock
+    private VersionMapper versionMapperMock;
+    @Mock
+    private VersionStateMapper versionStateMapperMock;
+    @Spy
+    @InjectMocks
+    private WorkflowVersionManagerImpl workflowVersionManager;
+
+    @Test(expected = EntityNotFoundException.class)
+    public void shouldThrowExceptionWhenVersionDontExist() {
+        Version nonExistingVersion = new Version(VERSION1_ID);
+        doThrow(new RuntimeException()).when(versioningManagerMock).get(ITEM1_ID, nonExistingVersion);
+        workflowVersionManager.get(ITEM1_ID, VERSION1_ID);
+    }
+
+    @Test
+    public void shouldReturnWorkflowVersionWhenExist() {
+        Version version = new Version(VERSION1_ID);
+        WorkflowVersion workflowVersion = new WorkflowVersion(VERSION1_ID);
+        doReturn(workflowVersion).when(versionMapperMock).versionToWorkflowVersion(any(Version.class));
+        doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID),any(Version.class));
+        doReturn(new ArrayList()).when(parameterRepositoryMock).list(eq(ITEM1_ID), eq(VERSION1_ID), any(ParameterRole.class));
+        workflowVersionManager.get(ITEM1_ID,VERSION1_ID);
+        verify(versioningManagerMock).get(ITEM1_ID,version);
+    }
+
+    @Test
+    public void shouldReturnWorkflowVersionList() {
+        List<Version> versionList = Arrays.asList(new Version(VERSION1_ID), new Version(VERSION2_ID));
+        doReturn(versionList).when(versioningManagerMock).list(ITEM1_ID);
+        doReturn(new WorkflowVersion()).when(versionMapperMock).versionToWorkflowVersion(any(Version.class));
+        workflowVersionManager.list(ITEM1_ID, null);
+        verify(versioningManagerMock).list(ITEM1_ID);
+        verify(versionMapperMock, times(2)).versionToWorkflowVersion(any(Version.class));
+    }
+
+    @Test
+    public void shouldUpdateWorkflowVersion() {
+        String updatedDescription = "WorkflowVersion description updated";
+        Version retrievedVersion = new Version(VERSION1_ID);
+        retrievedVersion.setName("1.0");
+        retrievedVersion.setDescription("WorkflowVersion description");
+        retrievedVersion.setStatus(VersionStatus.Draft);
+        doReturn(retrievedVersion).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
+        doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(retrievedVersion.getStatus());
+
+        WorkflowVersion inputVersion = new WorkflowVersion(VERSION1_ID);
+        inputVersion.setName("1.0");
+        inputVersion.setDescription(updatedDescription);
+        inputVersion.setInputs(new ArrayList<>());
+        inputVersion.setOutputs(new ArrayList<>());
+
+        Version mappedInputVersion = new Version(VERSION1_ID);
+        mappedInputVersion.setName("1.0");
+        mappedInputVersion.setDescription(updatedDescription);
+        doReturn(mappedInputVersion).when(versionMapperMock).workflowVersionToVersion(inputVersion);
+
+        ArgumentCaptor<Version> versionArgCaptor = ArgumentCaptor.forClass(Version.class);
+        workflowVersionManager.update(ITEM1_ID, inputVersion);
+
+        verify(versioningManagerMock).updateVersion(eq(ITEM1_ID), versionArgCaptor.capture());
+        Version captorVersion = versionArgCaptor.getValue();
+        assertEquals("1.0", captorVersion.getName());
+        assertEquals(updatedDescription, captorVersion.getDescription());
+        assertEquals(VersionStatus.Draft, captorVersion.getStatus());
+        verify(versioningManagerMock).publish(ITEM1_ID, mappedInputVersion, "Update version");
+    }
+
+
+    @Test
+    public void shouldCreateWorkflowVersion(){
+        Version version = new Version(VERSION1_ID);
+        version.setDescription("version desc");
+        doReturn(version).when(versioningManagerMock).create(ITEM1_ID,version, VersionCreationMethod.major);
+        WorkflowVersion versionRequest = new WorkflowVersion();
+        versionRequest.setDescription("version desc");
+        versionRequest.setInputs(new ArrayList<>());
+        versionRequest.setOutputs(new ArrayList<>());
+        WorkflowVersion workflowVersion = new WorkflowVersion(VERSION1_ID);
+        doReturn(workflowVersion).when(workflowVersionManager).get(ITEM1_ID,VERSION1_ID);
+        workflowVersionManager.create(ITEM1_ID, null, versionRequest);
+        verify(versioningManagerMock).create(ITEM1_ID,version, VersionCreationMethod.major);
+    }
+
+    @Test(expected = VersionCreationException.class)
+    public void shouldTrowExceptionWhenDraftVersionExists() {
+        WorkflowVersion versionRequestDto = new WorkflowVersion();
+
+        Version baseVersion = new Version(VERSION2_ID);
+        baseVersion.setStatus(VersionStatus.Draft);
+        List<Version> versions = Collections.singletonList(baseVersion);
+        doReturn(versions).when(versioningManagerMock).list(ITEM1_ID);
+
+        workflowVersionManager.create(ITEM1_ID, VERSION2_ID, versionRequestDto);
+    }
+
+    @Test(expected = EntityNotFoundException.class)
+    public void getStateOfNonExisting() {
+        doThrow(new RuntimeException()).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
+        workflowVersionManager.getState(ITEM1_ID, VERSION1_ID);
+    }
+
+    @Test
+    public void getState() {
+        Version version = new Version(VERSION1_ID);
+        version.setStatus(VersionStatus.Certified);
+        doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
+        doReturn(CERTIFIED).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus());
+
+        WorkflowVersionState state = workflowVersionManager.getState(ITEM1_ID, VERSION1_ID);
+        assertEquals(CERTIFIED, state);
+    }
+
+    @Test(expected = EntityNotFoundException.class)
+    public void updateStateOfNonExisting() {
+        doThrow(new RuntimeException()).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
+        workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, CERTIFIED);
+    }
+
+    @Test(expected = VersionStateModificationException.class)
+    public void updateStateToCurrentState() {
+        Version version = new Version(VERSION1_ID);
+        version.setStatus(VersionStatus.Draft);
+        doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
+        doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus());
+
+        workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, DRAFT);
+    }
+
+    @Test(expected = VersionStateModificationException.class)
+    public void updateStateWhenCertified() {
+        Version version = new Version(VERSION1_ID);
+        version.setStatus(VersionStatus.Certified);
+        doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
+        doReturn(CERTIFIED).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus());
+        doThrow(new RuntimeException()).when(versioningManagerMock)
+                                       .submit(eq(ITEM1_ID), eqVersion(VERSION1_ID), anyString());
+
+        workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, CERTIFIED);
+    }
+
+    @Test
+    public void updateState() {
+        Version retrievedVersion = new Version(VERSION1_ID);
+        retrievedVersion.setStatus(VersionStatus.Draft);
+        doReturn(retrievedVersion).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
+        doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(VersionStatus.Draft);
+
+        workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, CERTIFIED);
+
+        verify(versioningManagerMock).submit(eq(ITEM1_ID), eqVersion(VERSION1_ID), anyString());
+    }
+
+    @Test
+    public void shouldUploadArtifact() {
+        Version version = new Version(VERSION1_ID);
+        version.setStatus(VersionStatus.Draft);
+        doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
+        doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus());
+
+        MockMultipartFile mockFile = new MockMultipartFile("data", "filename.txt", "text/plain", "some xml".getBytes());
+        workflowVersionManager.uploadArtifact(ITEM1_ID, VERSION1_ID, mockFile);
+
+        verify(artifactRepositoryMock).update(eq(ITEM1_ID), eq(VERSION1_ID), any(ArtifactEntity.class));
+    }
+
+    @Test(expected = EntityNotFoundException.class)
+    public void shouldThrowExceptionWhenArtifactNotFound() {
+        doReturn(new Version(VERSION1_ID)).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
+
+        doReturn(Optional.empty()).when(artifactRepositoryMock).get(ITEM1_ID, VERSION1_ID);
+        workflowVersionManager.getArtifact(ITEM1_ID, VERSION1_ID);
+    }
+
+    @Test
+    public void shouldReturnArtifact() throws IOException {
+        doReturn(new Version(VERSION1_ID)).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
+
+        InputStream inputStreamMock = IOUtils.toInputStream("some test data for my input stream", "UTF-8");
+        ArtifactEntity artifactMock = new ArtifactEntity("fileName.txt", inputStreamMock);
+        doReturn(Optional.of(artifactMock)).when(artifactRepositoryMock).get(ITEM1_ID, VERSION1_ID);
+        ArtifactEntity returnedArtifact = workflowVersionManager.getArtifact(ITEM1_ID, VERSION1_ID);
+        assertEquals(artifactMock, returnedArtifact);
+    }
+
+    private static Version eqVersion(String versionId) {
+        return argThat(new EqVersion(versionId));
+    }
+
+    private static class EqVersion implements ArgumentMatcher<Version> {
+
+        private final String versionId;
+
+        EqVersion(String versionId) {
+            this.versionId = versionId;
+        }
+
+        @Override
+        public boolean matches(Version version) {
+            return versionId.equals(version.getId());
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/mappers/VersionMapperTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/mappers/VersionMapperTest.java
new file mode 100644
index 00000000..d9790355
--- /dev/null
+++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/mappers/VersionMapperTest.java
@@ -0,0 +1,80 @@
+package org.onap.sdc.workflow.services.impl.mappers;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Date;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.onap.sdc.workflow.persistence.types.WorkflowVersion;
+import org.onap.sdc.workflow.persistence.types.WorkflowVersionState;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.dao.types.VersionStatus;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+@ContextConfiguration(classes = VersionMapperTest.VersionMapperSpringTestConfig.class)
+@RunWith(SpringJUnit4ClassRunner.class)
+public class VersionMapperTest {
+
+    @Configuration
+    @ComponentScan(basePackageClasses = {VersionMapper.class, VersionStateMapper.class})
+    public static class VersionMapperSpringTestConfig { }
+
+    @Autowired
+    VersionMapper versionMapper;
+
+
+    @Test
+    public void shouldMapVersionToWorkflowVersion() {
+        Version version = createVersion();
+        WorkflowVersion mappedWorkflowVersion = versionMapper.versionToWorkflowVersion(version);
+        assertEquals(mappedWorkflowVersion.getId(), version.getId());
+        assertEquals(mappedWorkflowVersion.getBaseId(), version.getBaseId());
+        assertEquals(mappedWorkflowVersion.getDescription(), version.getDescription());
+        assertEquals(mappedWorkflowVersion.getName(), version.getName());
+        assertEquals(mappedWorkflowVersion.getCreationTime(), version.getCreationTime());
+        assertEquals(mappedWorkflowVersion.getModificationTime(), version.getModificationTime());
+    }
+
+    @Test
+    public void shouldMapWorkflowVersionToVersion() {
+        WorkflowVersion workflowVersion = createWorkflowVersion();
+        Version mappedVersion = versionMapper.workflowVersionToVersion(workflowVersion);
+        assertEquals(mappedVersion.getId(), workflowVersion.getId());
+        assertEquals(mappedVersion.getBaseId(), workflowVersion.getBaseId());
+        assertEquals(mappedVersion.getDescription(), workflowVersion.getDescription());
+        assertEquals(mappedVersion.getName(), workflowVersion.getName());
+        assertEquals(mappedVersion.getCreationTime(), workflowVersion.getCreationTime());
+        assertEquals(mappedVersion.getModificationTime(), workflowVersion.getModificationTime());
+
+    }
+
+    private Version createVersion() {
+        Version version = new Version("version_id");
+        version.setBaseId("base_version_id");
+        version.setName("1.0");
+        version.setCreationTime(new Date());
+        version.setModificationTime(new Date());
+        version.setDescription("version_description");
+        version.setStatus(VersionStatus.Draft);
+
+        return version;
+
+    }
+
+    private WorkflowVersion createWorkflowVersion() {
+        WorkflowVersion workflowVersion = new WorkflowVersion();
+        workflowVersion.setId("wf_version_id");
+        workflowVersion.setBaseId("wf_base_version_id");
+        workflowVersion.setName("1.0");
+        workflowVersion.setCreationTime(new Date());
+        workflowVersion.setModificationTime(new Date());
+        workflowVersion.setDescription("version_description");
+        workflowVersion.setState(WorkflowVersionState.CERTIFIED);
+
+        return workflowVersion;
+    }
+}
\ No newline at end of file
diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/mappers/VersionStateMapperTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/mappers/VersionStateMapperTest.java
new file mode 100644
index 00000000..070c433e
--- /dev/null
+++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/mappers/VersionStateMapperTest.java
@@ -0,0 +1,75 @@
+package org.onap.sdc.workflow.services.impl.mappers;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.onap.sdc.workflow.persistence.types.WorkflowVersionState;
+import org.openecomp.sdc.versioning.dao.types.VersionStatus;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+@ContextConfiguration(classes = VersionStateMapperTest.VersionStatusMapperSpringTestConfig.class)
+@RunWith(SpringJUnit4ClassRunner.class)
+public class VersionStateMapperTest {
+
+    @Configuration
+    @ComponentScan(basePackageClasses = {VersionStateMapper.class})
+    public static class VersionStatusMapperSpringTestConfig { }
+
+
+    @Autowired
+    VersionStateMapper versionStateMapper;
+
+    @Test
+    public void shouldMapCertifiedVersionStatusToWorkflowVersionStatus() {
+        WorkflowVersionState mappedVersionStatus =
+                versionStateMapper.versionStatusToWorkflowVersionState(VersionStatus.Certified);
+        assertEquals(WorkflowVersionState.CERTIFIED, mappedVersionStatus);
+    }
+
+    @Test
+    public void shouldMapDraftVersionStatusToWorkflowVersionStatus() {
+        WorkflowVersionState mappedVersionStatus =
+                versionStateMapper.versionStatusToWorkflowVersionState(VersionStatus.Draft);
+        assertEquals(WorkflowVersionState.DRAFT, mappedVersionStatus);
+    }
+
+    @Test
+    public void shouldMapDeletedVersionStatusToWorkflowVersionStatus() {
+        WorkflowVersionState mappedVersionStatus =
+                versionStateMapper.versionStatusToWorkflowVersionState(VersionStatus.Deleted);
+        assertEquals(WorkflowVersionState.DRAFT, mappedVersionStatus);
+    }
+
+    @Test
+    public void shouldMapLockedVersionStatusToWorkflowVersionStatus() {
+        WorkflowVersionState mappedVersionStatus =
+                versionStateMapper.versionStatusToWorkflowVersionState(VersionStatus.Locked);
+        assertEquals(WorkflowVersionState.DRAFT, mappedVersionStatus);
+    }
+
+    @Test
+    public void shouldMapDeprecatedVersionStatusToWorkflowVersionStatus() {
+        WorkflowVersionState mappedVersionStatus =
+                versionStateMapper.versionStatusToWorkflowVersionState(VersionStatus.Deprecated);
+        assertEquals(WorkflowVersionState.DRAFT, mappedVersionStatus);
+    }
+
+    @Test
+    public void shouldMapCertifiedWorkflowVersionStatusToVersionStatus() {
+        VersionStatus mappedVersionStatus =
+                versionStateMapper.workflowVersionStateToVersionStatus(WorkflowVersionState.CERTIFIED);
+        assertEquals(VersionStatus.Certified, mappedVersionStatus);
+    }
+
+    @Test
+    public void shouldMapDraftWorkflowVersionStatusToVersionStatus() {
+        VersionStatus mappedVersionStatus =
+                versionStateMapper.workflowVersionStateToVersionStatus(WorkflowVersionState.DRAFT);
+        assertEquals(VersionStatus.Draft, mappedVersionStatus);
+    }
+}
\ No newline at end of file
diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/mappers/WorkflowMapperTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/mappers/WorkflowMapperTest.java
new file mode 100644
index 00000000..55802cc0
--- /dev/null
+++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/mappers/WorkflowMapperTest.java
@@ -0,0 +1,50 @@
+package org.onap.sdc.workflow.services.impl.mappers;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.onap.sdc.workflow.TestUtil.createItem;
+import static org.onap.sdc.workflow.TestUtil.createWorkflow;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.onap.sdc.workflow.persistence.types.Workflow;
+import org.openecomp.sdc.versioning.types.Item;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+@ContextConfiguration(classes = WorkflowMapperTest.WorkflowMapperSpringTestConfig.class)
+@RunWith(SpringJUnit4ClassRunner.class)
+public class WorkflowMapperTest {
+
+    @Configuration
+    @ComponentScan(basePackageClasses = {WorkflowMapper.class})
+    public static class WorkflowMapperSpringTestConfig { }
+
+    @Autowired
+    WorkflowMapper workflowMapper;
+
+    @Test
+    public void shouldMapItemToWorkflow() {
+
+        Item item = createItem(1,false,true);
+        Workflow mappedWorkflow = workflowMapper.itemToWorkflow(item);
+        assertEquals(mappedWorkflow.getId(), item.getId());
+        assertEquals(mappedWorkflow.getDescription(), item.getDescription());
+        assertEquals(mappedWorkflow.getName(), item.getName());
+    }
+
+    @Test
+    public void shouldMapWorkflowToItem(){
+
+       Workflow workflow = createWorkflow(1,true);
+       Item mappedItem = workflowMapper.workflowToItem(workflow);
+        assertEquals(mappedItem.getId(), workflow.getId());
+        assertEquals(mappedItem.getDescription(), workflow.getDescription());
+        assertEquals(mappedItem.getName(), workflow.getName());
+    }
+
+}
\ No newline at end of file