hawkBit rest docs (management & DDI API) (#688)

* hawkBit REST docs.

Signed-off-by: kaizimmerm <kai.zimmermann@bosch-si.com>

* Fiy gitignore.

Signed-off-by: kaizimmerm <kai.zimmermann@bosch-si.com>

* Add to website.

Signed-off-by: kaizimmerm <kai.zimmermann@bosch-si.com>

* Switch to generated docs.

Signed-off-by: kaizimmerm <kai.zimmermann@bosch-si.com>

* Fix typos.

Signed-off-by: kaizimmerm <kai.zimmermann@bosch-si.com>

* Review findings.

Signed-off-by: kaizimmerm <kai.zimmermann@bosch-si.com>

* Otimizations.

Signed-off-by: kaizimmerm <kai.zimmermann@bosch-si.com>

* Revert accidental checkin.

Signed-off-by: kaizimmerm <kai.zimmermann@bosch-si.com>

* Add security link.

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtApiConfiguration.java

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import org.eclipse.hawkbit.rest.RestConfiguration;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.stereotype.Controller;
+
+/**
+ * Enable {@link ComponentScan} in the resource package to setup all
+ * {@link Controller} annotated classes and setup the REST-Resources for the
+ * Management API.
+ */
+@Configuration
+@ComponentScan
+@Import(RestConfiguration.class)
+public class MgmtApiConfiguration {
+
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtDistributionSetMapper.java

@@ -0,0 +1,178 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import static org.springframework.hateoas.mvc.ControllerLinkBuilder.linkTo;
+import static org.springframework.hateoas.mvc.ControllerLinkBuilder.methodOn;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.eclipse.hawkbit.mgmt.json.model.MgmtMetadata;
+import org.eclipse.hawkbit.mgmt.json.model.distributionset.MgmtDistributionSet;
+import org.eclipse.hawkbit.mgmt.json.model.distributionset.MgmtDistributionSetRequestBodyPost;
+import org.eclipse.hawkbit.mgmt.json.model.distributionset.MgmtTargetAssignmentResponseBody;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtDistributionSetRestApi;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtDistributionSetTypeRestApi;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.repository.EntityFactory;
+import org.eclipse.hawkbit.repository.builder.DistributionSetCreate;
+import org.eclipse.hawkbit.repository.model.DistributionSet;
+import org.eclipse.hawkbit.repository.model.DistributionSetAssignmentResult;
+import org.eclipse.hawkbit.repository.model.DistributionSetMetadata;
+import org.eclipse.hawkbit.repository.model.MetaData;
+import org.eclipse.hawkbit.rest.data.ResponseList;
+
+/**
+ * A mapper which maps repository model to RESTful model representation and
+ * back.
+ */
+public final class MgmtDistributionSetMapper {
+    private MgmtDistributionSetMapper() {
+        // Utility class
+    }
+
+    /**
+     * {@link MgmtDistributionSetRequestBodyPost}s to {@link DistributionSet}s.
+     *
+     * @param sets
+     *            to convert
+     * @return converted list of {@link DistributionSet}s
+     */
+    static List<DistributionSetCreate> dsFromRequest(final Collection<MgmtDistributionSetRequestBodyPost> sets,
+            final EntityFactory entityFactory) {
+
+        return sets.stream().map(dsRest -> fromRequest(dsRest, entityFactory)).collect(Collectors.toList());
+    }
+
+    /**
+     * {@link MgmtDistributionSetRequestBodyPost} to {@link DistributionSet}.
+     *
+     * @param dsRest
+     *            to convert
+     * @return converted {@link DistributionSet}
+     */
+    private static DistributionSetCreate fromRequest(final MgmtDistributionSetRequestBodyPost dsRest,
+            final EntityFactory entityFactory) {
+
+        final List<Long> modules = new ArrayList<>();
+
+        if (dsRest.getOs() != null) {
+            modules.add(dsRest.getOs().getId());
+        }
+
+        if (dsRest.getApplication() != null) {
+            modules.add(dsRest.getApplication().getId());
+        }
+
+        if (dsRest.getRuntime() != null) {
+            modules.add(dsRest.getRuntime().getId());
+        }
+
+        if (dsRest.getModules() != null) {
+            dsRest.getModules().forEach(module -> modules.add(module.getId()));
+        }
+
+        return entityFactory.distributionSet().create().name(dsRest.getName()).version(dsRest.getVersion())
+                .description(dsRest.getDescription()).type(dsRest.getType()).modules(modules)
+                .requiredMigrationStep(dsRest.isRequiredMigrationStep());
+    }
+
+    static List<MetaData> fromRequestDsMetadata(final List<MgmtMetadata> metadata, final EntityFactory entityFactory) {
+        if (metadata == null) {
+            return Collections.emptyList();
+        }
+
+        return metadata.stream()
+                .map(metadataRest -> entityFactory.generateMetadata(metadataRest.getKey(), metadataRest.getValue()))
+                .collect(Collectors.toList());
+    }
+
+    static MgmtDistributionSet toResponse(final DistributionSet distributionSet) {
+        if (distributionSet == null) {
+            return null;
+        }
+        final MgmtDistributionSet response = new MgmtDistributionSet();
+        MgmtRestModelMapper.mapNamedToNamed(response, distributionSet);
+
+        response.setDsId(distributionSet.getId());
+        response.setVersion(distributionSet.getVersion());
+        response.setComplete(distributionSet.isComplete());
+        response.setType(distributionSet.getType().getKey());
+        response.setDeleted(distributionSet.isDeleted());
+
+        distributionSet.getModules()
+                .forEach(module -> response.getModules().add(MgmtSoftwareModuleMapper.toResponse(module)));
+
+        response.setRequiredMigrationStep(distributionSet.isRequiredMigrationStep());
+
+        response.add(linkTo(methodOn(MgmtDistributionSetRestApi.class).getDistributionSet(response.getDsId()))
+                .withSelfRel());
+
+        return response;
+    }
+
+    static void addLinks(final DistributionSet distributionSet, final MgmtDistributionSet response) {
+        response.add(linkTo(methodOn(MgmtDistributionSetRestApi.class).getAssignedSoftwareModules(response.getDsId(),
+                MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET_VALUE,
+                MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT_VALUE, null))
+                        .withRel(MgmtRestConstants.DISTRIBUTIONSET_V1_MODULE));
+
+        response.add(linkTo(methodOn(MgmtDistributionSetTypeRestApi.class)
+                .getDistributionSetType(distributionSet.getType().getId())).withRel("type"));
+
+        response.add(linkTo(methodOn(MgmtDistributionSetRestApi.class).getMetadata(response.getDsId(),
+                MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET_VALUE,
+                MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT_VALUE, null, null)).withRel("metadata"));
+    }
+
+    static MgmtTargetAssignmentResponseBody toResponse(final DistributionSetAssignmentResult dsAssignmentResult) {
+        final MgmtTargetAssignmentResponseBody result = new MgmtTargetAssignmentResponseBody();
+        result.setAssigned(dsAssignmentResult.getAssigned());
+        result.setAlreadyAssigned(dsAssignmentResult.getAlreadyAssigned());
+        result.setTotal(dsAssignmentResult.getTotal());
+        return result;
+    }
+
+    static List<MgmtDistributionSet> toResponseDistributionSets(final Collection<DistributionSet> sets) {
+        if (sets == null) {
+            return Collections.emptyList();
+        }
+
+        return new ResponseList<>(
+                sets.stream().map(MgmtDistributionSetMapper::toResponse).collect(Collectors.toList()));
+    }
+
+    static MgmtMetadata toResponseDsMetadata(final DistributionSetMetadata metadata) {
+        final MgmtMetadata metadataRest = new MgmtMetadata();
+        metadataRest.setKey(metadata.getKey());
+        metadataRest.setValue(metadata.getValue());
+        return metadataRest;
+    }
+
+    static List<MgmtMetadata> toResponseDsMetadata(final List<DistributionSetMetadata> metadata) {
+
+        final List<MgmtMetadata> mappedList = new ArrayList<>(metadata.size());
+        for (final DistributionSetMetadata distributionSetMetadata : metadata) {
+            mappedList.add(toResponseDsMetadata(distributionSetMetadata));
+        }
+        return mappedList;
+    }
+
+    static List<MgmtDistributionSet> toResponseFromDsList(final List<DistributionSet> sets) {
+        if (sets == null) {
+            return Collections.emptyList();
+        }
+
+        return sets.stream().map(MgmtDistributionSetMapper::toResponse).collect(Collectors.toList());
+    }
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtDistributionSetResource.java

@@ -0,0 +1,387 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.eclipse.hawkbit.mgmt.json.model.MgmtMaintenanceWindowRequestBody;
+import org.eclipse.hawkbit.mgmt.json.model.MgmtMetadata;
+import org.eclipse.hawkbit.mgmt.json.model.MgmtMetadataBodyPut;
+import org.eclipse.hawkbit.mgmt.json.model.PagedList;
+import org.eclipse.hawkbit.mgmt.json.model.distributionset.MgmtDistributionSet;
+import org.eclipse.hawkbit.mgmt.json.model.distributionset.MgmtDistributionSetRequestBodyPost;
+import org.eclipse.hawkbit.mgmt.json.model.distributionset.MgmtDistributionSetRequestBodyPut;
+import org.eclipse.hawkbit.mgmt.json.model.distributionset.MgmtTargetAssignmentRequestBody;
+import org.eclipse.hawkbit.mgmt.json.model.distributionset.MgmtTargetAssignmentResponseBody;
+import org.eclipse.hawkbit.mgmt.json.model.softwaremodule.MgmtSoftwareModule;
+import org.eclipse.hawkbit.mgmt.json.model.softwaremodule.MgmtSoftwareModuleAssigment;
+import org.eclipse.hawkbit.mgmt.json.model.target.MgmtTarget;
+import org.eclipse.hawkbit.mgmt.json.model.targetfilter.MgmtTargetFilterQuery;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtDistributionSetRestApi;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.repository.DeploymentManagement;
+import org.eclipse.hawkbit.repository.DistributionSetManagement;
+import org.eclipse.hawkbit.repository.EntityFactory;
+import org.eclipse.hawkbit.repository.MaintenanceScheduleHelper;
+import org.eclipse.hawkbit.repository.OffsetBasedPageRequest;
+import org.eclipse.hawkbit.repository.SoftwareModuleManagement;
+import org.eclipse.hawkbit.repository.SystemManagement;
+import org.eclipse.hawkbit.repository.TargetFilterQueryManagement;
+import org.eclipse.hawkbit.repository.TargetManagement;
+import org.eclipse.hawkbit.repository.exception.EntityNotFoundException;
+import org.eclipse.hawkbit.repository.model.DistributionSet;
+import org.eclipse.hawkbit.repository.model.DistributionSetAssignmentResult;
+import org.eclipse.hawkbit.repository.model.DistributionSetMetadata;
+import org.eclipse.hawkbit.repository.model.SoftwareModule;
+import org.eclipse.hawkbit.repository.model.Target;
+import org.eclipse.hawkbit.repository.model.TargetFilterQuery;
+import org.eclipse.hawkbit.repository.model.TargetWithActionType;
+import org.eclipse.hawkbit.security.SystemSecurityContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Slice;
+import org.springframework.data.domain.Sort;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * REST Resource handling for {@link DistributionSet} CRUD operations.
+ */
+@RestController
+public class MgmtDistributionSetResource implements MgmtDistributionSetRestApi {
+    private static final Logger LOG = LoggerFactory.getLogger(MgmtDistributionSetResource.class);
+
+    @Autowired
+    private SoftwareModuleManagement softwareModuleManagement;
+
+    @Autowired
+    private TargetManagement targetManagement;
+
+    @Autowired
+    private TargetFilterQueryManagement targetFilterQueryManagement;
+
+    @Autowired
+    private DeploymentManagement deployManagament;
+
+    @Autowired
+    private SystemManagement systemManagement;
+
+    @Autowired
+    private EntityFactory entityFactory;
+
+    @Autowired
+    private DistributionSetManagement distributionSetManagement;
+
+    @Autowired
+    private SystemSecurityContext systemSecurityContext;
+
+    @Override
+    public ResponseEntity<PagedList<MgmtDistributionSet>> getDistributionSets(
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {
+
+        final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
+        final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
+        final Sort sorting = PagingUtility.sanitizeDistributionSetSortParam(sortParam);
+
+        final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);
+        final Slice<DistributionSet> findDsPage;
+        final long countModulesAll;
+        if (rsqlParam != null) {
+            findDsPage = distributionSetManagement.findByRsql(pageable, rsqlParam);
+            countModulesAll = ((Page<DistributionSet>) findDsPage).getTotalElements();
+        } else {
+            findDsPage = distributionSetManagement.findAll(pageable);
+            countModulesAll = distributionSetManagement.count();
+        }
+
+        final List<MgmtDistributionSet> rest = MgmtDistributionSetMapper.toResponseFromDsList(findDsPage.getContent());
+        return ResponseEntity.ok(new PagedList<>(rest, countModulesAll));
+    }
+
+    @Override
+    public ResponseEntity<MgmtDistributionSet> getDistributionSet(
+            @PathVariable("distributionSetId") final Long distributionSetId) {
+        final DistributionSet foundDs = findDistributionSetWithExceptionIfNotFound(distributionSetId);
+
+        final MgmtDistributionSet response = MgmtDistributionSetMapper.toResponse(foundDs);
+        MgmtDistributionSetMapper.addLinks(foundDs, response);
+
+        return ResponseEntity.ok(response);
+    }
+
+    @Override
+    public ResponseEntity<List<MgmtDistributionSet>> createDistributionSets(
+            @RequestBody final List<MgmtDistributionSetRequestBodyPost> sets) {
+
+        LOG.debug("creating {} distribution sets", sets.size());
+        // set default Ds type if ds type is null
+        final String defaultDsKey = systemSecurityContext
+                .runAsSystem(systemManagement.getTenantMetadata().getDefaultDsType()::getKey);
+        sets.stream().filter(ds -> ds.getType() == null).forEach(ds -> ds.setType(defaultDsKey));
+
+        final Collection<DistributionSet> createdDSets = distributionSetManagement
+                .create(MgmtDistributionSetMapper.dsFromRequest(sets, entityFactory));
+
+        LOG.debug("{} distribution sets created, return status {}", sets.size(), HttpStatus.CREATED);
+        return new ResponseEntity<>(MgmtDistributionSetMapper.toResponseDistributionSets(createdDSets),
+                HttpStatus.CREATED);
+    }
+
+    @Override
+    public ResponseEntity<Void> deleteDistributionSet(@PathVariable("distributionSetId") final Long distributionSetId) {
+        distributionSetManagement.delete(distributionSetId);
+        return ResponseEntity.ok().build();
+    }
+
+    @Override
+    public ResponseEntity<MgmtDistributionSet> updateDistributionSet(
+            @PathVariable("distributionSetId") final Long distributionSetId,
+            @RequestBody final MgmtDistributionSetRequestBodyPut toUpdate) {
+
+        final DistributionSet updated = distributionSetManagement.update(entityFactory.distributionSet()
+                .update(distributionSetId).name(toUpdate.getName()).description(toUpdate.getDescription())
+                .version(toUpdate.getVersion()).requiredMigrationStep(toUpdate.isRequiredMigrationStep()));
+
+        final MgmtDistributionSet response = MgmtDistributionSetMapper.toResponse(updated);
+        MgmtDistributionSetMapper.addLinks(updated, response);
+
+        return ResponseEntity.ok(response);
+    }
+
+    @Override
+    public ResponseEntity<PagedList<MgmtTarget>> getAssignedTargets(
+            @PathVariable("distributionSetId") final Long distributionSetId,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {
+
+        final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
+        final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
+        final Sort sorting = PagingUtility.sanitizeTargetSortParam(sortParam);
+
+        final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);
+        final Page<Target> targetsAssignedDS;
+        if (rsqlParam != null) {
+            targetsAssignedDS = this.targetManagement.findByAssignedDistributionSetAndRsql(pageable, distributionSetId,
+                    rsqlParam);
+        } else {
+            targetsAssignedDS = this.targetManagement.findByAssignedDistributionSet(pageable, distributionSetId);
+        }
+
+        return ResponseEntity.ok(new PagedList<>(MgmtTargetMapper.toResponse(targetsAssignedDS.getContent()),
+                targetsAssignedDS.getTotalElements()));
+    }
+
+    @Override
+    public ResponseEntity<PagedList<MgmtTarget>> getInstalledTargets(
+            @PathVariable("distributionSetId") final Long distributionSetId,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {
+        // check if distribution set exists otherwise throw exception
+        // immediately
+        findDistributionSetWithExceptionIfNotFound(distributionSetId);
+
+        final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
+        final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
+        final Sort sorting = PagingUtility.sanitizeTargetSortParam(sortParam);
+
+        final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);
+        final Page<Target> targetsInstalledDS;
+        if (rsqlParam != null) {
+            targetsInstalledDS = this.targetManagement.findByInstalledDistributionSetAndRsql(pageable,
+                    distributionSetId, rsqlParam);
+        } else {
+            targetsInstalledDS = this.targetManagement.findByInstalledDistributionSet(pageable, distributionSetId);
+        }
+
+        return ResponseEntity.ok(new PagedList<>(MgmtTargetMapper.toResponse(targetsInstalledDS.getContent()),
+                targetsInstalledDS.getTotalElements()));
+    }
+
+    @Override
+    public ResponseEntity<PagedList<MgmtTargetFilterQuery>> getAutoAssignTargetFilterQueries(
+            @PathVariable("distributionSetId") final Long distributionSetId,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {
+        final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
+        final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
+        final Sort sorting = PagingUtility.sanitizeTargetFilterQuerySortParam(sortParam);
+
+        final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);
+        final Page<TargetFilterQuery> targetFilterQueries = targetFilterQueryManagement
+                .findByAutoAssignDSAndRsql(pageable, distributionSetId, rsqlParam);
+
+        return ResponseEntity
+                .ok(new PagedList<>(MgmtTargetFilterQueryMapper.toResponse(targetFilterQueries.getContent()),
+                        targetFilterQueries.getTotalElements()));
+    }
+
+    @Override
+    public ResponseEntity<MgmtTargetAssignmentResponseBody> createAssignedTarget(
+            @PathVariable("distributionSetId") final Long distributionSetId,
+            @RequestBody final List<MgmtTargetAssignmentRequestBody> assignments,
+            @RequestParam(value = "offline", required = false) final boolean offline) {
+
+        if (offline) {
+            return ResponseEntity.ok(MgmtDistributionSetMapper
+                    .toResponse(this.deployManagament.offlineAssignedDistributionSet(distributionSetId, assignments
+                            .stream().map(MgmtTargetAssignmentRequestBody::getId).collect(Collectors.toList()))));
+        }
+
+        final DistributionSetAssignmentResult assignDistributionSet = this.deployManagament
+                .assignDistributionSet(distributionSetId, assignments.stream().map(t -> {
+                    final MgmtMaintenanceWindowRequestBody maintenanceWindow = t.getMaintenanceWindow();
+
+                    if (maintenanceWindow == null) {
+                        return new TargetWithActionType(t.getId(), MgmtRestModelMapper.convertActionType(t.getType()),
+                                t.getForcetime());
+                    }
+
+                    final String cronSchedule = maintenanceWindow.getSchedule();
+                    final String duration = maintenanceWindow.getDuration();
+                    final String timezone = maintenanceWindow.getTimezone();
+
+                    MaintenanceScheduleHelper.validateMaintenanceSchedule(cronSchedule, duration, timezone);
+
+                    return new TargetWithActionType(t.getId(), MgmtRestModelMapper.convertActionType(t.getType()),
+                            t.getForcetime(), cronSchedule, duration, timezone);
+                }).collect(Collectors.toList()));
+
+        return ResponseEntity.ok(MgmtDistributionSetMapper.toResponse(assignDistributionSet));
+
+    }
+
+    @Override
+    public ResponseEntity<PagedList<MgmtMetadata>> getMetadata(
+            @PathVariable("distributionSetId") final Long distributionSetId,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {
+
+        final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
+        final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
+        final Sort sorting = PagingUtility.sanitizeDistributionSetMetadataSortParam(sortParam);
+
+        final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);
+        final Page<DistributionSetMetadata> metaDataPage;
+
+        if (rsqlParam != null) {
+            metaDataPage = distributionSetManagement.findMetaDataByDistributionSetIdAndRsql(pageable, distributionSetId,
+                    rsqlParam);
+        } else {
+            metaDataPage = distributionSetManagement.findMetaDataByDistributionSetId(pageable, distributionSetId);
+        }
+
+        return ResponseEntity
+                .ok(new PagedList<>(MgmtDistributionSetMapper.toResponseDsMetadata(metaDataPage.getContent()),
+                        metaDataPage.getTotalElements()));
+
+    }
+
+    @Override
+    public ResponseEntity<MgmtMetadata> getMetadataValue(
+            @PathVariable("distributionSetId") final Long distributionSetId,
+            @PathVariable("metadataKey") final String metadataKey) {
+        // check if distribution set exists otherwise throw exception
+        // immediately
+        final DistributionSetMetadata findOne = distributionSetManagement
+                .getMetaDataByDistributionSetId(distributionSetId, metadataKey)
+                .orElseThrow(() -> new EntityNotFoundException(DistributionSetMetadata.class, distributionSetId,
+                        metadataKey));
+        return ResponseEntity.ok(MgmtDistributionSetMapper.toResponseDsMetadata(findOne));
+    }
+
+    @Override
+    public ResponseEntity<MgmtMetadata> updateMetadata(@PathVariable("distributionSetId") final Long distributionSetId,
+            @PathVariable("metadataKey") final String metadataKey, @RequestBody final MgmtMetadataBodyPut metadata) {
+        // check if distribution set exists otherwise throw exception
+        // immediately
+        final DistributionSetMetadata updated = distributionSetManagement.updateMetaData(distributionSetId,
+                entityFactory.generateMetadata(metadataKey, metadata.getValue()));
+        return ResponseEntity.ok(MgmtDistributionSetMapper.toResponseDsMetadata(updated));
+    }
+
+    @Override
+    public ResponseEntity<Void> deleteMetadata(@PathVariable("distributionSetId") final Long distributionSetId,
+            @PathVariable("metadataKey") final String metadataKey) {
+        // check if distribution set exists otherwise throw exception
+        // immediately
+        distributionSetManagement.deleteMetaData(distributionSetId, metadataKey);
+        return ResponseEntity.ok().build();
+    }
+
+    @Override
+    public ResponseEntity<List<MgmtMetadata>> createMetadata(
+            @PathVariable("distributionSetId") final Long distributionSetId,
+            @RequestBody final List<MgmtMetadata> metadataRest) {
+        // check if distribution set exists otherwise throw exception
+        // immediately
+        final List<DistributionSetMetadata> created = distributionSetManagement.createMetaData(distributionSetId,
+                MgmtDistributionSetMapper.fromRequestDsMetadata(metadataRest, entityFactory));
+        return new ResponseEntity<>(MgmtDistributionSetMapper.toResponseDsMetadata(created), HttpStatus.CREATED);
+
+    }
+
+    @Override
+    public ResponseEntity<Void> assignSoftwareModules(@PathVariable("distributionSetId") final Long distributionSetId,
+            @RequestBody final List<MgmtSoftwareModuleAssigment> softwareModuleIDs) {
+
+        distributionSetManagement.assignSoftwareModules(distributionSetId,
+                softwareModuleIDs.stream().map(MgmtSoftwareModuleAssigment::getId).collect(Collectors.toList()));
+        return ResponseEntity.ok().build();
+    }
+
+    @Override
+    public ResponseEntity<Void> deleteAssignSoftwareModules(
+            @PathVariable("distributionSetId") final Long distributionSetId,
+            @PathVariable("softwareModuleId") final Long softwareModuleId) {
+        distributionSetManagement.unassignSoftwareModule(distributionSetId, softwareModuleId);
+        return ResponseEntity.ok().build();
+    }
+
+    @Override
+    public ResponseEntity<PagedList<MgmtSoftwareModule>> getAssignedSoftwareModules(
+            @PathVariable("distributionSetId") final Long distributionSetId,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam) {
+
+        final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
+        final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
+        final Sort sorting = PagingUtility.sanitizeSoftwareModuleSortParam(sortParam);
+        final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);
+        final Page<SoftwareModule> softwaremodules = softwareModuleManagement.findByAssignedTo(pageable,
+                distributionSetId);
+        return ResponseEntity.ok(new PagedList<>(MgmtSoftwareModuleMapper.toResponse(softwaremodules.getContent()),
+                softwaremodules.getTotalElements()));
+    }
+
+    private DistributionSet findDistributionSetWithExceptionIfNotFound(final Long distributionSetId) {
+        return distributionSetManagement.get(distributionSetId)
+                .orElseThrow(() -> new EntityNotFoundException(DistributionSet.class, distributionSetId));
+    }
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtDistributionSetTagResource.java

@@ -0,0 +1,249 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.eclipse.hawkbit.mgmt.json.model.PagedList;
+import org.eclipse.hawkbit.mgmt.json.model.distributionset.MgmtDistributionSet;
+import org.eclipse.hawkbit.mgmt.json.model.tag.MgmtAssignedDistributionSetRequestBody;
+import org.eclipse.hawkbit.mgmt.json.model.tag.MgmtDistributionSetTagAssigmentResult;
+import org.eclipse.hawkbit.mgmt.json.model.tag.MgmtTag;
+import org.eclipse.hawkbit.mgmt.json.model.tag.MgmtTagRequestBodyPut;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtDistributionSetTagRestApi;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.repository.DistributionSetManagement;
+import org.eclipse.hawkbit.repository.DistributionSetTagManagement;
+import org.eclipse.hawkbit.repository.EntityFactory;
+import org.eclipse.hawkbit.repository.OffsetBasedPageRequest;
+import org.eclipse.hawkbit.repository.exception.EntityNotFoundException;
+import org.eclipse.hawkbit.repository.model.DistributionSet;
+import org.eclipse.hawkbit.repository.model.DistributionSetTag;
+import org.eclipse.hawkbit.repository.model.DistributionSetTagAssignmentResult;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Slice;
+import org.springframework.data.domain.Sort;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * REST Resource handling for {@link DistributionSetTag} CRUD operations.
+ *
+ */
+@RestController
+public class MgmtDistributionSetTagResource implements MgmtDistributionSetTagRestApi {
+    private static final Logger LOG = LoggerFactory.getLogger(MgmtDistributionSetTagResource.class);
+
+    @Autowired
+    private DistributionSetTagManagement distributionSetTagManagement;
+
+    @Autowired
+    private DistributionSetManagement distributionSetManagement;
+
+    @Autowired
+    private EntityFactory entityFactory;
+
+    @Override
+    public ResponseEntity<PagedList<MgmtTag>> getDistributionSetTags(
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {
+
+        final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
+        final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
+        final Sort sorting = PagingUtility.sanitizeTagSortParam(sortParam);
+
+        final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);
+        final Slice<DistributionSetTag> distributionSetTags;
+        final long count;
+        if (rsqlParam == null) {
+            distributionSetTags = distributionSetTagManagement.findAll(pageable);
+            count = distributionSetTagManagement.count();
+
+        } else {
+            final Page<DistributionSetTag> page = distributionSetTagManagement.findByRsql(pageable, rsqlParam);
+            distributionSetTags = page;
+            count = page.getTotalElements();
+
+        }
+
+        final List<MgmtTag> rest = MgmtTagMapper.toResponseDistributionSetTag(distributionSetTags.getContent());
+        return ResponseEntity.ok(new PagedList<>(rest, count));
+    }
+
+    @Override
+    public ResponseEntity<MgmtTag> getDistributionSetTag(
+            @PathVariable("distributionsetTagId") final Long distributionsetTagId) {
+        final DistributionSetTag distributionSetTag = findDistributionTagById(distributionsetTagId);
+
+        final MgmtTag response = MgmtTagMapper.toResponse(distributionSetTag);
+        MgmtTagMapper.addLinks(distributionSetTag, response);
+
+        return ResponseEntity.ok(response);
+    }
+
+    @Override
+    public ResponseEntity<List<MgmtTag>> createDistributionSetTags(
+            @RequestBody final List<MgmtTagRequestBodyPut> tags) {
+        LOG.debug("creating {} ds tags", tags.size());
+
+        final List<DistributionSetTag> createdTags = distributionSetTagManagement
+                .create(MgmtTagMapper.mapTagFromRequest(entityFactory, tags));
+
+        return new ResponseEntity<>(MgmtTagMapper.toResponseDistributionSetTag(createdTags), HttpStatus.CREATED);
+    }
+
+    @Override
+    public ResponseEntity<MgmtTag> updateDistributionSetTag(
+            @PathVariable("distributionsetTagId") final Long distributionsetTagId,
+            @RequestBody final MgmtTagRequestBodyPut restDSTagRest) {
+
+        final DistributionSetTag distributionSetTag = distributionSetTagManagement
+                .update(entityFactory.tag().update(distributionsetTagId).name(restDSTagRest.getName())
+                        .description(restDSTagRest.getDescription()).colour(restDSTagRest.getColour()));
+
+        final MgmtTag response = MgmtTagMapper.toResponse(distributionSetTag);
+        MgmtTagMapper.addLinks(distributionSetTag, response);
+
+        return ResponseEntity.ok(response);
+    }
+
+    @Override
+    public ResponseEntity<Void> deleteDistributionSetTag(
+            @PathVariable("distributionsetTagId") final Long distributionsetTagId) {
+        LOG.debug("Delete {} distribution set tag", distributionsetTagId);
+        final DistributionSetTag tag = findDistributionTagById(distributionsetTagId);
+
+        distributionSetTagManagement.delete(tag.getName());
+
+        return ResponseEntity.ok().build();
+    }
+
+    @Override
+    public ResponseEntity<List<MgmtDistributionSet>> getAssignedDistributionSets(
+            @PathVariable("distributionsetTagId") final Long distributionsetTagId) {
+        return ResponseEntity.ok(MgmtDistributionSetMapper.toResponseDistributionSets(distributionSetManagement
+                .findByTag(new PageRequest(0, MgmtRestConstants.REQUEST_PARAMETER_PAGING_MAX_LIMIT),
+                        distributionsetTagId)
+                .getContent()));
+    }
+
+    @Override
+    public ResponseEntity<PagedList<MgmtDistributionSet>> getAssignedDistributionSets(
+            @PathVariable("distributionsetTagId") final Long distributionsetTagId,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {
+        final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
+        final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
+        final Sort sorting = PagingUtility.sanitizeTagSortParam(sortParam);
+
+        final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);
+        Page<DistributionSet> findDistrAll;
+        if (rsqlParam == null) {
+            findDistrAll = distributionSetManagement.findByTag(pageable, distributionsetTagId);
+
+        } else {
+            findDistrAll = distributionSetManagement.findByRsqlAndTag(pageable, rsqlParam, distributionsetTagId);
+        }
+
+        final List<MgmtDistributionSet> rest = MgmtDistributionSetMapper
+                .toResponseFromDsList(findDistrAll.getContent());
+        return ResponseEntity.ok(new PagedList<>(rest, findDistrAll.getTotalElements()));
+    }
+
+    @Override
+    public ResponseEntity<MgmtDistributionSetTagAssigmentResult> toggleTagAssignment(
+            @PathVariable("distributionsetTagId") final Long distributionsetTagId,
+            @RequestBody final List<MgmtAssignedDistributionSetRequestBody> assignedDSRequestBodies) {
+        LOG.debug("Toggle distribution set assignment {} for ds tag {}", assignedDSRequestBodies.size(),
+                distributionsetTagId);
+
+        final DistributionSetTag tag = findDistributionTagById(distributionsetTagId);
+
+        final DistributionSetTagAssignmentResult assigmentResult = this.distributionSetManagement
+                .toggleTagAssignment(findDistributionSetIds(assignedDSRequestBodies), tag.getName());
+
+        final MgmtDistributionSetTagAssigmentResult tagAssigmentResultRest = new MgmtDistributionSetTagAssigmentResult();
+        tagAssigmentResultRest.setAssignedDistributionSets(
+                MgmtDistributionSetMapper.toResponseDistributionSets(assigmentResult.getAssignedEntity()));
+        tagAssigmentResultRest.setUnassignedDistributionSets(
+                MgmtDistributionSetMapper.toResponseDistributionSets(assigmentResult.getUnassignedEntity()));
+
+        LOG.debug("Toggled assignedDS {} and unassignedDS{}", assigmentResult.getAssigned(),
+                assigmentResult.getUnassigned());
+
+        return ResponseEntity.ok(tagAssigmentResultRest);
+    }
+
+    @Override
+    public ResponseEntity<List<MgmtDistributionSet>> assignDistributionSets(
+            @PathVariable("distributionsetTagId") final Long distributionsetTagId,
+            @RequestBody final List<MgmtAssignedDistributionSetRequestBody> assignedDSRequestBodies) {
+        LOG.debug("Assign DistributionSet {} for ds tag {}", assignedDSRequestBodies.size(), distributionsetTagId);
+        final List<DistributionSet> assignedDs = this.distributionSetManagement
+                .assignTag(findDistributionSetIds(assignedDSRequestBodies), distributionsetTagId);
+        LOG.debug("Assignd DistributionSet {}", assignedDs.size());
+        return ResponseEntity.ok(MgmtDistributionSetMapper.toResponseDistributionSets(assignedDs));
+    }
+
+    @Override
+    public ResponseEntity<Void> unassignDistributionSet(
+            @PathVariable("distributionsetTagId") final Long distributionsetTagId,
+            @PathVariable("distributionsetId") final Long distributionsetId) {
+        LOG.debug("Unassign ds {} for ds tag {}", distributionsetId, distributionsetTagId);
+        this.distributionSetManagement.unAssignTag(distributionsetId, distributionsetTagId);
+        return ResponseEntity.ok().build();
+    }
+
+    private DistributionSetTag findDistributionTagById(final Long distributionsetTagId) {
+        return distributionSetTagManagement.get(distributionsetTagId)
+                .orElseThrow(() -> new EntityNotFoundException(DistributionSetTag.class, distributionsetTagId));
+    }
+
+    private static List<Long> findDistributionSetIds(
+            final List<MgmtAssignedDistributionSetRequestBody> assignedDistributionSetRequestBodies) {
+        return assignedDistributionSetRequestBodies.stream()
+                .map(MgmtAssignedDistributionSetRequestBody::getDistributionSetId).collect(Collectors.toList());
+    }
+
+    @Override
+    public ResponseEntity<MgmtDistributionSetTagAssigmentResult> toggleTagAssignmentUnpaged(
+            @PathVariable("distributionsetTagId") final Long distributionsetTagId,
+            @RequestBody final List<MgmtAssignedDistributionSetRequestBody> assignedDSRequestBodies) {
+        return toggleTagAssignment(distributionsetTagId, assignedDSRequestBodies);
+    }
+
+    @Override
+    public ResponseEntity<List<MgmtDistributionSet>> assignDistributionSetsUnpaged(
+            @PathVariable("distributionsetTagId") final Long distributionsetTagId,
+            @RequestBody final List<MgmtAssignedDistributionSetRequestBody> assignedDSRequestBodies) {
+        return assignDistributionSets(distributionsetTagId, assignedDSRequestBodies);
+    }
+
+    @Override
+    public ResponseEntity<Void> unassignDistributionSetUnpaged(
+            @PathVariable("distributionsetTagId") final Long distributionsetTagId,
+            @PathVariable("distributionsetId") final Long distributionsetId) {
+        return unassignDistributionSet(distributionsetTagId, distributionsetId);
+    }
+
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtDistributionSetTypeMapper.java

@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import static org.springframework.hateoas.mvc.ControllerLinkBuilder.linkTo;
+import static org.springframework.hateoas.mvc.ControllerLinkBuilder.methodOn;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+import org.eclipse.hawkbit.mgmt.json.model.distributionsettype.MgmtDistributionSetType;
+import org.eclipse.hawkbit.mgmt.json.model.distributionsettype.MgmtDistributionSetTypeRequestBodyPost;
+import org.eclipse.hawkbit.mgmt.json.model.softwaremoduletype.MgmtSoftwareModuleTypeAssigment;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtDistributionSetTypeRestApi;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.repository.EntityFactory;
+import org.eclipse.hawkbit.repository.builder.DistributionSetTypeCreate;
+import org.eclipse.hawkbit.repository.model.DistributionSetType;
+
+/**
+ * A mapper which maps repository model to RESTful model representation and
+ * back.
+ *
+ */
+final class MgmtDistributionSetTypeMapper {
+
+    // private constructor, utility class
+    private MgmtDistributionSetTypeMapper() {
+
+    }
+
+    static List<DistributionSetTypeCreate> smFromRequest(final EntityFactory entityFactory,
+            final Collection<MgmtDistributionSetTypeRequestBodyPost> smTypesRest) {
+        if (smTypesRest == null) {
+            return Collections.emptyList();
+        }
+
+        return smTypesRest.stream().map(smRest -> fromRequest(entityFactory, smRest)).collect(Collectors.toList());
+    }
+
+    private static DistributionSetTypeCreate fromRequest(final EntityFactory entityFactory,
+            final MgmtDistributionSetTypeRequestBodyPost smsRest) {
+        return entityFactory.distributionSetType().create().key(smsRest.getKey()).name(smsRest.getName())
+                .description(smsRest.getDescription()).colour(smsRest.getColour())
+                .mandatory(getMandatoryModules(smsRest)).optional(getOptionalmodules(smsRest));
+    }
+
+    private static Collection<Long> getMandatoryModules(final MgmtDistributionSetTypeRequestBodyPost smsRest) {
+        return Optional.ofNullable(smsRest.getMandatorymodules()).map(
+                modules -> modules.stream().map(MgmtSoftwareModuleTypeAssigment::getId).collect(Collectors.toList()))
+                .orElse(Collections.emptyList());
+    }
+
+    private static Collection<Long> getOptionalmodules(final MgmtDistributionSetTypeRequestBodyPost smsRest) {
+        return Optional.ofNullable(smsRest.getOptionalmodules()).map(
+                modules -> modules.stream().map(MgmtSoftwareModuleTypeAssigment::getId).collect(Collectors.toList()))
+                .orElse(Collections.emptyList());
+    }
+
+    static List<MgmtDistributionSetType> toTypesResponse(final List<DistributionSetType> types) {
+        if (types == null) {
+            return Collections.emptyList();
+        }
+
+        return types.stream().map(MgmtDistributionSetTypeMapper::toResponse).collect(Collectors.toList());
+    }
+
+    static List<MgmtDistributionSetType> toListResponse(final List<DistributionSetType> types) {
+        if (types == null) {
+            return Collections.emptyList();
+        }
+
+        return types.stream().map(MgmtDistributionSetTypeMapper::toResponse).collect(Collectors.toList());
+    }
+
+    static MgmtDistributionSetType toResponse(final DistributionSetType type) {
+        final MgmtDistributionSetType result = new MgmtDistributionSetType();
+
+        MgmtRestModelMapper.mapNamedToNamed(result, type);
+        result.setKey(type.getKey());
+        result.setModuleId(type.getId());
+        result.setDeleted(type.isDeleted());
+
+        result.add(linkTo(methodOn(MgmtDistributionSetTypeRestApi.class).getDistributionSetType(result.getModuleId()))
+                .withSelfRel());
+
+        return result;
+    }
+
+    static void addLinks(final MgmtDistributionSetType result) {
+
+        result.add(linkTo(methodOn(MgmtDistributionSetTypeRestApi.class).getMandatoryModules(result.getModuleId()))
+                .withRel(MgmtRestConstants.DISTRIBUTIONSETTYPE_V1_MANDATORY_MODULES));
+
+        result.add(linkTo(methodOn(MgmtDistributionSetTypeRestApi.class).getOptionalModules(result.getModuleId()))
+                .withRel(MgmtRestConstants.DISTRIBUTIONSETTYPE_V1_OPTIONAL_MODULES));
+    }
+
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtDistributionSetTypeResource.java

@@ -0,0 +1,226 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.eclipse.hawkbit.mgmt.json.model.MgmtId;
+import org.eclipse.hawkbit.mgmt.json.model.PagedList;
+import org.eclipse.hawkbit.mgmt.json.model.distributionsettype.MgmtDistributionSetType;
+import org.eclipse.hawkbit.mgmt.json.model.distributionsettype.MgmtDistributionSetTypeRequestBodyPost;
+import org.eclipse.hawkbit.mgmt.json.model.distributionsettype.MgmtDistributionSetTypeRequestBodyPut;
+import org.eclipse.hawkbit.mgmt.json.model.softwaremoduletype.MgmtSoftwareModuleType;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtDistributionSetTypeRestApi;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.repository.DistributionSetTypeManagement;
+import org.eclipse.hawkbit.repository.EntityFactory;
+import org.eclipse.hawkbit.repository.OffsetBasedPageRequest;
+import org.eclipse.hawkbit.repository.SoftwareModuleTypeManagement;
+import org.eclipse.hawkbit.repository.exception.EntityNotFoundException;
+import org.eclipse.hawkbit.repository.exception.SoftwareModuleTypeNotInDistributionSetTypeException;
+import org.eclipse.hawkbit.repository.model.Artifact;
+import org.eclipse.hawkbit.repository.model.DistributionSetType;
+import org.eclipse.hawkbit.repository.model.SoftwareModule;
+import org.eclipse.hawkbit.repository.model.SoftwareModuleType;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Slice;
+import org.springframework.data.domain.Sort;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * REST Resource handling for {@link SoftwareModule} and related
+ * {@link Artifact} CRUD operations.
+ */
+@RestController
+public class MgmtDistributionSetTypeResource implements MgmtDistributionSetTypeRestApi {
+
+    @Autowired
+    private SoftwareModuleTypeManagement softwareModuleTypeManagement;
+
+    @Autowired
+    private DistributionSetTypeManagement distributionSetTypeManagement;
+
+    @Autowired
+    private EntityFactory entityFactory;
+
+    @Override
+    public ResponseEntity<PagedList<MgmtDistributionSetType>> getDistributionSetTypes(
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {
+
+        final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
+        final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
+        final Sort sorting = PagingUtility.sanitizeDistributionSetTypeSortParam(sortParam);
+        final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);
+
+        final Slice<DistributionSetType> findModuleTypessAll;
+        long countModulesAll;
+        if (rsqlParam != null) {
+            findModuleTypessAll = distributionSetTypeManagement.findByRsql(pageable, rsqlParam);
+            countModulesAll = ((Page<DistributionSetType>) findModuleTypessAll).getTotalElements();
+        } else {
+            findModuleTypessAll = distributionSetTypeManagement.findAll(pageable);
+            countModulesAll = distributionSetTypeManagement.count();
+        }
+
+        final List<MgmtDistributionSetType> rest = MgmtDistributionSetTypeMapper
+                .toListResponse(findModuleTypessAll.getContent());
+        return ResponseEntity.ok(new PagedList<>(rest, countModulesAll));
+    }
+
+    @Override
+    public ResponseEntity<MgmtDistributionSetType> getDistributionSetType(
+            @PathVariable("distributionSetTypeId") final Long distributionSetTypeId) {
+
+        final DistributionSetType foundType = findDistributionSetTypeWithExceptionIfNotFound(distributionSetTypeId);
+
+        final MgmtDistributionSetType reponse = MgmtDistributionSetTypeMapper.toResponse(foundType);
+        MgmtDistributionSetTypeMapper.addLinks(reponse);
+
+        return ResponseEntity.ok(reponse);
+    }
+
+    @Override
+    public ResponseEntity<Void> deleteDistributionSetType(
+            @PathVariable("distributionSetTypeId") final Long distributionSetTypeId) {
+        distributionSetTypeManagement.delete(distributionSetTypeId);
+
+        return ResponseEntity.ok().build();
+    }
+
+    @Override
+    public ResponseEntity<MgmtDistributionSetType> updateDistributionSetType(
+            @PathVariable("distributionSetTypeId") final Long distributionSetTypeId,
+            @RequestBody final MgmtDistributionSetTypeRequestBodyPut restDistributionSetType) {
+
+        final DistributionSetType updated = distributionSetTypeManagement.update(entityFactory.distributionSetType()
+                .update(distributionSetTypeId).description(restDistributionSetType.getDescription())
+                .colour(restDistributionSetType.getColour()));
+
+        final MgmtDistributionSetType reponse = MgmtDistributionSetTypeMapper.toResponse(updated);
+        MgmtDistributionSetTypeMapper.addLinks(reponse);
+
+        return ResponseEntity.ok(reponse);
+    }
+
+    @Override
+    public ResponseEntity<List<MgmtDistributionSetType>> createDistributionSetTypes(
+            @RequestBody final List<MgmtDistributionSetTypeRequestBodyPost> distributionSetTypes) {
+
+        final List<DistributionSetType> createdSoftwareModules = distributionSetTypeManagement
+                .create(MgmtDistributionSetTypeMapper.smFromRequest(entityFactory, distributionSetTypes));
+
+        return ResponseEntity.status(HttpStatus.CREATED)
+                .body(MgmtDistributionSetTypeMapper.toTypesResponse(createdSoftwareModules));
+    }
+
+    private DistributionSetType findDistributionSetTypeWithExceptionIfNotFound(final Long distributionSetTypeId) {
+        return distributionSetTypeManagement.get(distributionSetTypeId)
+                .orElseThrow(() -> new EntityNotFoundException(DistributionSetType.class, distributionSetTypeId));
+    }
+
+    @Override
+    public ResponseEntity<List<MgmtSoftwareModuleType>> getMandatoryModules(
+            @PathVariable("distributionSetTypeId") final Long distributionSetTypeId) {
+
+        final DistributionSetType foundType = findDistributionSetTypeWithExceptionIfNotFound(distributionSetTypeId);
+        return ResponseEntity.ok(MgmtSoftwareModuleTypeMapper.toTypesResponse(foundType.getMandatoryModuleTypes()));
+    }
+
+    @Override
+    public ResponseEntity<MgmtSoftwareModuleType> getMandatoryModule(
+            @PathVariable("distributionSetTypeId") final Long distributionSetTypeId,
+            @PathVariable("softwareModuleTypeId") final Long softwareModuleTypeId) {
+
+        final DistributionSetType foundType = findDistributionSetTypeWithExceptionIfNotFound(distributionSetTypeId);
+        final SoftwareModuleType foundSmType = findSoftwareModuleTypeWithExceptionIfNotFound(softwareModuleTypeId);
+
+        if (!foundType.containsMandatoryModuleType(foundSmType)) {
+            throw new SoftwareModuleTypeNotInDistributionSetTypeException(softwareModuleTypeId, distributionSetTypeId);
+        }
+
+        return ResponseEntity.ok(MgmtSoftwareModuleTypeMapper.toResponse(foundSmType));
+    }
+
+    @Override
+    public ResponseEntity<MgmtSoftwareModuleType> getOptionalModule(
+            @PathVariable("distributionSetTypeId") final Long distributionSetTypeId,
+            @PathVariable("softwareModuleTypeId") final Long softwareModuleTypeId) {
+
+        final DistributionSetType foundType = findDistributionSetTypeWithExceptionIfNotFound(distributionSetTypeId);
+        final SoftwareModuleType foundSmType = findSoftwareModuleTypeWithExceptionIfNotFound(softwareModuleTypeId);
+
+        if (!foundType.containsOptionalModuleType(foundSmType)) {
+            throw new SoftwareModuleTypeNotInDistributionSetTypeException(softwareModuleTypeId, distributionSetTypeId);
+        }
+
+        return ResponseEntity.ok(MgmtSoftwareModuleTypeMapper.toResponse(foundSmType));
+    }
+
+    @Override
+    public ResponseEntity<List<MgmtSoftwareModuleType>> getOptionalModules(
+            @PathVariable("distributionSetTypeId") final Long distributionSetTypeId) {
+
+        final DistributionSetType foundType = findDistributionSetTypeWithExceptionIfNotFound(distributionSetTypeId);
+        return ResponseEntity.ok(MgmtSoftwareModuleTypeMapper.toTypesResponse(foundType.getOptionalModuleTypes()));
+    }
+
+    @Override
+    public ResponseEntity<Void> removeMandatoryModule(
+            @PathVariable("distributionSetTypeId") final Long distributionSetTypeId,
+            @PathVariable("softwareModuleTypeId") final Long softwareModuleTypeId) {
+        distributionSetTypeManagement.unassignSoftwareModuleType(distributionSetTypeId, softwareModuleTypeId);
+
+        return ResponseEntity.ok().build();
+    }
+
+    @Override
+    public ResponseEntity<Void> removeOptionalModule(
+            @PathVariable("distributionSetTypeId") final Long distributionSetTypeId,
+            @PathVariable("softwareModuleTypeId") final Long softwareModuleTypeId) {
+
+        return removeMandatoryModule(distributionSetTypeId, softwareModuleTypeId);
+    }
+
+    @Override
+    public ResponseEntity<Void> addMandatoryModule(
+            @PathVariable("distributionSetTypeId") final Long distributionSetTypeId, @RequestBody final MgmtId smtId) {
+
+        distributionSetTypeManagement.assignMandatorySoftwareModuleTypes(distributionSetTypeId,
+                Arrays.asList(smtId.getId()));
+
+        return ResponseEntity.ok().build();
+    }
+
+    @Override
+    public ResponseEntity<Void> addOptionalModule(
+            @PathVariable("distributionSetTypeId") final Long distributionSetTypeId, @RequestBody final MgmtId smtId) {
+
+        distributionSetTypeManagement.assignOptionalSoftwareModuleTypes(distributionSetTypeId,
+                Arrays.asList(smtId.getId()));
+
+        return ResponseEntity.ok().build();
+    }
+
+    private SoftwareModuleType findSoftwareModuleTypeWithExceptionIfNotFound(final Long softwareModuleTypeId) {
+
+        return softwareModuleTypeManagement.get(softwareModuleTypeId)
+                .orElseThrow(() -> new EntityNotFoundException(SoftwareModuleType.class, softwareModuleTypeId));
+    }
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtDownloadArtifactResource.java

@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import java.io.InputStream;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.eclipse.hawkbit.artifact.repository.model.AbstractDbArtifact;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtDownloadArtifactRestApi;
+import org.eclipse.hawkbit.repository.ArtifactManagement;
+import org.eclipse.hawkbit.repository.SoftwareModuleManagement;
+import org.eclipse.hawkbit.repository.exception.ArtifactBinaryNotFoundException;
+import org.eclipse.hawkbit.repository.exception.EntityNotFoundException;
+import org.eclipse.hawkbit.repository.model.Artifact;
+import org.eclipse.hawkbit.repository.model.SoftwareModule;
+import org.eclipse.hawkbit.rest.util.FileStreamingUtil;
+import org.eclipse.hawkbit.rest.util.HttpUtil;
+import org.eclipse.hawkbit.rest.util.RequestResponseContextHolder;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Scope;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.context.WebApplicationContext;
+
+/**
+ *
+ */
+@RestController
+@Scope(value = WebApplicationContext.SCOPE_REQUEST)
+public class MgmtDownloadArtifactResource implements MgmtDownloadArtifactRestApi {
+    @Autowired
+    private SoftwareModuleManagement softwareModuleManagement;
+
+    @Autowired
+    private ArtifactManagement artifactManagement;
+
+    @Autowired
+    private RequestResponseContextHolder requestResponseContextHolder;
+
+    /**
+     * Handles the GET request for downloading an artifact.
+     *
+     * @param softwareModuleId
+     *            of the parent SoftwareModule
+     * @param artifactId
+     *            of the related Artifact
+     *
+     * @return responseEntity with status ok if successful
+     */
+    @Override
+    public ResponseEntity<InputStream> downloadArtifact(@PathVariable("softwareModuleId") final Long softwareModuleId,
+            @PathVariable("artifactId") final Long artifactId) {
+
+        final SoftwareModule module = softwareModuleManagement.get(softwareModuleId)
+                .orElseThrow(() -> new EntityNotFoundException(SoftwareModule.class, softwareModuleId));
+        final Artifact artifact = module.getArtifact(artifactId)
+                .orElseThrow(() -> new EntityNotFoundException(Artifact.class, artifactId));
+
+        final AbstractDbArtifact file = artifactManagement.loadArtifactBinary(artifact.getSha1Hash())
+                .orElseThrow(() -> new ArtifactBinaryNotFoundException(artifact.getSha1Hash()));
+        final HttpServletRequest request = requestResponseContextHolder.getHttpServletRequest();
+        final String ifMatch = request.getHeader(HttpHeaders.IF_MATCH);
+        if (ifMatch != null && !HttpUtil.matchesHttpHeader(ifMatch, artifact.getSha1Hash())) {
+            return new ResponseEntity<>(HttpStatus.PRECONDITION_FAILED);
+        }
+
+        return FileStreamingUtil.writeFileResponse(file, artifact.getFilename(), artifact.getCreatedAt(),
+                requestResponseContextHolder.getHttpServletResponse(), request, null);
+    }
+
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtDownloadResource.java

@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import java.io.InputStream;
+
+import org.eclipse.hawkbit.artifact.repository.ArtifactRepository;
+import org.eclipse.hawkbit.artifact.repository.model.AbstractDbArtifact;
+import org.eclipse.hawkbit.cache.DownloadArtifactCache;
+import org.eclipse.hawkbit.cache.DownloadIdCache;
+import org.eclipse.hawkbit.cache.DownloadType;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtDownloadRestApi;
+import org.eclipse.hawkbit.rest.util.FileStreamingUtil;
+import org.eclipse.hawkbit.rest.util.RequestResponseContextHolder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Scope;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.context.WebApplicationContext;
+
+/**
+ * A resource for download artifacts.
+ */
+@RestController
+@Scope(value = WebApplicationContext.SCOPE_REQUEST)
+public class MgmtDownloadResource implements MgmtDownloadRestApi {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(MgmtDownloadResource.class);
+
+    @Autowired
+    private ArtifactRepository artifactRepository;
+
+    @Autowired
+    private DownloadIdCache downloadIdCache;
+
+    @Autowired
+    private RequestResponseContextHolder requestResponseContextHolder;
+
+    @Override
+    @ResponseBody
+    public ResponseEntity<InputStream> downloadArtifactByDownloadId(@PathVariable("tenant") final String tenant,
+            @PathVariable("downloadId") final String downloadId) {
+
+        try {
+            final DownloadArtifactCache artifactCache = downloadIdCache.get(downloadId);
+            if (artifactCache == null) {
+                LOGGER.warn("Download Id {} could not be found", downloadId);
+                return ResponseEntity.notFound().build();
+            }
+
+            AbstractDbArtifact artifact = null;
+
+            if (DownloadType.BY_SHA1.equals(artifactCache.getDownloadType())) {
+                artifact = artifactRepository.getArtifactBySha1(tenant, artifactCache.getId());
+            } else {
+                LOGGER.warn("Download Type {} not supported", artifactCache.getDownloadType());
+            }
+
+            if (artifact == null) {
+                LOGGER.warn("Artifact with cached id {} and download type {} could not be found.",
+                        artifactCache.getId(), artifactCache.getDownloadType());
+                return ResponseEntity.notFound().build();
+            }
+
+            return FileStreamingUtil.writeFileResponse(artifact, downloadId, 0L,
+                    requestResponseContextHolder.getHttpServletResponse(),
+                    requestResponseContextHolder.getHttpServletRequest(), null);
+
+        } finally {
+            downloadIdCache.evict(downloadId);
+        }
+    }
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtRestModelMapper.java

@@ -0,0 +1,99 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import org.eclipse.hawkbit.mgmt.json.model.MgmtBaseEntity;
+import org.eclipse.hawkbit.mgmt.json.model.MgmtNamedEntity;
+import org.eclipse.hawkbit.mgmt.json.model.distributionset.MgmtActionType;
+import org.eclipse.hawkbit.repository.model.Action.ActionType;
+import org.eclipse.hawkbit.repository.model.NamedEntity;
+import org.eclipse.hawkbit.repository.model.TenantAwareBaseEntity;
+
+/**
+ * A mapper which maps repository model to RESTful model representation and
+ * back.
+ *
+ */
+final class MgmtRestModelMapper {
+
+    // private constructor, utility class
+    private MgmtRestModelMapper() {
+
+    }
+
+    static void mapBaseToBase(final MgmtBaseEntity response, final TenantAwareBaseEntity base) {
+        response.setCreatedBy(base.getCreatedBy());
+        response.setLastModifiedBy(base.getLastModifiedBy());
+        if (base.getCreatedAt() > 0) {
+            response.setCreatedAt(base.getCreatedAt());
+        }
+        if (base.getLastModifiedAt() > 0) {
+            response.setLastModifiedAt(base.getLastModifiedAt());
+        }
+    }
+
+    static void mapNamedToNamed(final MgmtNamedEntity response, final NamedEntity base) {
+        mapBaseToBase(response, base);
+
+        response.setName(base.getName());
+        response.setDescription(base.getDescription());
+    }
+
+    /**
+     * Convert the given {@link MgmtActionType} into a corresponding repository
+     * {@link ActionType}.
+     * 
+     * @param actionTypeRest
+     *            the REST representation of the action type
+     * 
+     * @return <null> or the repository action type
+     */
+    public static ActionType convertActionType(final MgmtActionType actionTypeRest) {
+        if (actionTypeRest == null) {
+            return null;
+        }
+
+        switch (actionTypeRest) {
+        case SOFT:
+            return ActionType.SOFT;
+        case FORCED:
+            return ActionType.FORCED;
+        case TIMEFORCED:
+            return ActionType.TIMEFORCED;
+        default:
+            throw new IllegalStateException("Action Type is not supported");
+        }
+    }
+
+    /**
+     * Converts the given repository {@link ActionType} into a corresponding
+     * {@link MgmtActionType}.
+     * 
+     * @param actionType
+     *            the repository representation of the action type
+     * 
+     * @return <null> or the REST action type
+     */
+    public static MgmtActionType convertActionType(final ActionType actionType) {
+        if (actionType == null) {
+            return null;
+        }
+
+        switch (actionType) {
+        case SOFT:
+            return MgmtActionType.SOFT;
+        case FORCED:
+            return MgmtActionType.FORCED;
+        case TIMEFORCED:
+            return MgmtActionType.TIMEFORCED;
+        default:
+            throw new IllegalStateException("Action Type is not supported");
+        }
+    }
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtRolloutMapper.java

@@ -0,0 +1,250 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import static org.springframework.hateoas.mvc.ControllerLinkBuilder.linkTo;
+import static org.springframework.hateoas.mvc.ControllerLinkBuilder.methodOn;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.eclipse.hawkbit.mgmt.json.model.rollout.AbstractMgmtRolloutConditionsEntity;
+import org.eclipse.hawkbit.mgmt.json.model.rollout.MgmtRolloutCondition;
+import org.eclipse.hawkbit.mgmt.json.model.rollout.MgmtRolloutCondition.Condition;
+import org.eclipse.hawkbit.mgmt.json.model.rollout.MgmtRolloutErrorAction;
+import org.eclipse.hawkbit.mgmt.json.model.rollout.MgmtRolloutErrorAction.ErrorAction;
+import org.eclipse.hawkbit.mgmt.json.model.rollout.MgmtRolloutResponseBody;
+import org.eclipse.hawkbit.mgmt.json.model.rollout.MgmtRolloutRestRequestBody;
+import org.eclipse.hawkbit.mgmt.json.model.rollout.MgmtRolloutSuccessAction;
+import org.eclipse.hawkbit.mgmt.json.model.rollout.MgmtRolloutSuccessAction.SuccessAction;
+import org.eclipse.hawkbit.mgmt.json.model.rolloutgroup.MgmtRolloutGroup;
+import org.eclipse.hawkbit.mgmt.json.model.rolloutgroup.MgmtRolloutGroupResponseBody;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRolloutRestApi;
+import org.eclipse.hawkbit.repository.EntityFactory;
+import org.eclipse.hawkbit.repository.builder.RolloutCreate;
+import org.eclipse.hawkbit.repository.builder.RolloutGroupCreate;
+import org.eclipse.hawkbit.repository.model.DistributionSet;
+import org.eclipse.hawkbit.repository.model.Rollout;
+import org.eclipse.hawkbit.repository.model.RolloutGroup;
+import org.eclipse.hawkbit.repository.model.RolloutGroup.RolloutGroupErrorAction;
+import org.eclipse.hawkbit.repository.model.RolloutGroup.RolloutGroupErrorCondition;
+import org.eclipse.hawkbit.repository.model.RolloutGroup.RolloutGroupSuccessAction;
+import org.eclipse.hawkbit.repository.model.RolloutGroup.RolloutGroupSuccessCondition;
+import org.eclipse.hawkbit.repository.model.RolloutGroupConditionBuilder;
+import org.eclipse.hawkbit.repository.model.RolloutGroupConditions;
+import org.eclipse.hawkbit.repository.model.TotalTargetCountStatus;
+
+/**
+ * A mapper which maps repository model to RESTful model representation and
+ * back.
+ *
+ *
+ */
+final class MgmtRolloutMapper {
+
+    private static final String NOT_SUPPORTED = " is not supported";
+
+    private MgmtRolloutMapper() {
+        // Utility class
+    }
+
+    static List<MgmtRolloutResponseBody> toResponseRollout(final List<Rollout> rollouts) {
+        if (rollouts == null) {
+            return Collections.emptyList();
+        }
+
+        return rollouts.stream().map(rollout -> toResponseRollout(rollout, false)).collect(Collectors.toList());
+    }
+
+    static MgmtRolloutResponseBody toResponseRollout(final Rollout rollout, final boolean withDetails) {
+        final MgmtRolloutResponseBody body = new MgmtRolloutResponseBody();
+        body.setCreatedAt(rollout.getCreatedAt());
+        body.setCreatedBy(rollout.getCreatedBy());
+        body.setDescription(rollout.getDescription());
+        body.setLastModifiedAt(rollout.getLastModifiedAt());
+        body.setLastModifiedBy(rollout.getLastModifiedBy());
+        body.setName(rollout.getName());
+        body.setRolloutId(rollout.getId());
+        body.setTargetFilterQuery(rollout.getTargetFilterQuery());
+        body.setDistributionSetId(rollout.getDistributionSet().getId());
+        body.setStatus(rollout.getStatus().toString().toLowerCase());
+        body.setTotalTargets(rollout.getTotalTargets());
+        body.setDeleted(rollout.isDeleted());
+
+        if (withDetails) {
+            for (final TotalTargetCountStatus.Status status : TotalTargetCountStatus.Status.values()) {
+                body.addTotalTargetsPerStatus(status.name().toLowerCase(),
+                        rollout.getTotalTargetCountStatus().getTotalTargetCountByStatus(status));
+            }
+
+            body.add(linkTo(methodOn(MgmtRolloutRestApi.class).start(rollout.getId())).withRel("start"));
+            body.add(linkTo(methodOn(MgmtRolloutRestApi.class).pause(rollout.getId())).withRel("pause"));
+            body.add(linkTo(methodOn(MgmtRolloutRestApi.class).resume(rollout.getId())).withRel("resume"));
+            body.add(linkTo(methodOn(MgmtRolloutRestApi.class).getRolloutGroups(rollout.getId(),
+                    MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET_VALUE,
+                    MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT_VALUE, null, null)).withRel("groups"));
+        }
+
+        body.add(linkTo(methodOn(MgmtRolloutRestApi.class).getRollout(rollout.getId())).withSelfRel());
+        return body;
+    }
+
+    static RolloutCreate fromRequest(final EntityFactory entityFactory, final MgmtRolloutRestRequestBody restRequest,
+            final DistributionSet distributionSet) {
+
+        return entityFactory.rollout().create().name(restRequest.getName()).description(restRequest.getDescription())
+                .set(distributionSet).targetFilterQuery(restRequest.getTargetFilterQuery())
+                .actionType(MgmtRestModelMapper.convertActionType(restRequest.getType()))
+                .forcedTime(restRequest.getForcetime()).startAt(restRequest.getStartAt());
+    }
+
+    static RolloutGroupCreate fromRequest(final EntityFactory entityFactory, final MgmtRolloutGroup restRequest) {
+
+        return entityFactory.rolloutGroup().create().name(restRequest.getName())
+                .description(restRequest.getDescription()).targetFilterQuery(restRequest.getTargetFilterQuery())
+                .targetPercentage(restRequest.getTargetPercentage()).conditions(fromRequest(restRequest, false));
+    }
+
+    static RolloutGroupConditions fromRequest(final AbstractMgmtRolloutConditionsEntity restRequest,
+            final boolean withDefaults) {
+        final RolloutGroupConditionBuilder conditions = new RolloutGroupConditionBuilder();
+
+        if (withDefaults) {
+            conditions.withDefaults();
+        }
+
+        if (restRequest.getSuccessCondition() != null) {
+            conditions.successCondition(mapFinishCondition(restRequest.getSuccessCondition().getCondition()),
+                    restRequest.getSuccessCondition().getExpression());
+        }
+        if (restRequest.getSuccessAction() != null) {
+            conditions.successAction(map(restRequest.getSuccessAction().getAction()),
+                    restRequest.getSuccessAction().getExpression());
+        }
+
+        if (restRequest.getErrorCondition() != null) {
+            conditions.errorCondition(mapErrorCondition(restRequest.getErrorCondition().getCondition()),
+                    restRequest.getErrorCondition().getExpression());
+        }
+        if (restRequest.getErrorAction() != null) {
+            conditions.errorAction(map(restRequest.getErrorAction().getAction()),
+                    restRequest.getErrorAction().getExpression());
+        }
+
+        return conditions.build();
+    }
+
+    static List<MgmtRolloutGroupResponseBody> toResponseRolloutGroup(final List<RolloutGroup> rollouts) {
+        if (rollouts == null) {
+            return Collections.emptyList();
+        }
+
+        return rollouts.stream().map(group -> toResponseRolloutGroup(group, false)).collect(Collectors.toList());
+    }
+
+    static MgmtRolloutGroupResponseBody toResponseRolloutGroup(final RolloutGroup rolloutGroup,
+            final boolean withDetailedStatus) {
+        final MgmtRolloutGroupResponseBody body = new MgmtRolloutGroupResponseBody();
+        body.setCreatedAt(rolloutGroup.getCreatedAt());
+        body.setCreatedBy(rolloutGroup.getCreatedBy());
+        body.setDescription(rolloutGroup.getDescription());
+        body.setLastModifiedAt(rolloutGroup.getLastModifiedAt());
+        body.setLastModifiedBy(rolloutGroup.getLastModifiedBy());
+        body.setName(rolloutGroup.getName());
+        body.setRolloutGroupId(rolloutGroup.getId());
+        body.setStatus(rolloutGroup.getStatus().toString().toLowerCase());
+        body.setTargetPercentage(rolloutGroup.getTargetPercentage());
+        body.setTargetFilterQuery(rolloutGroup.getTargetFilterQuery());
+        body.setTotalTargets(rolloutGroup.getTotalTargets());
+
+        body.setSuccessCondition(new MgmtRolloutCondition(map(rolloutGroup.getSuccessCondition()),
+                rolloutGroup.getSuccessConditionExp()));
+        body.setSuccessAction(
+                new MgmtRolloutSuccessAction(map(rolloutGroup.getSuccessAction()), rolloutGroup.getSuccessActionExp()));
+
+        body.setErrorCondition(
+                new MgmtRolloutCondition(map(rolloutGroup.getErrorCondition()), rolloutGroup.getErrorConditionExp()));
+        body.setErrorAction(
+                new MgmtRolloutErrorAction(map(rolloutGroup.getErrorAction()), rolloutGroup.getErrorActionExp()));
+
+        if (withDetailedStatus) {
+            for (final TotalTargetCountStatus.Status status : TotalTargetCountStatus.Status.values()) {
+                body.addTotalTargetsPerStatus(status.name().toLowerCase(),
+                        rolloutGroup.getTotalTargetCountStatus().getTotalTargetCountByStatus(status));
+            }
+        }
+
+        body.add(linkTo(methodOn(MgmtRolloutRestApi.class).getRolloutGroup(rolloutGroup.getRollout().getId(),
+                rolloutGroup.getId())).withSelfRel());
+        return body;
+    }
+
+    private static RolloutGroupErrorCondition mapErrorCondition(final Condition condition) {
+        if (Condition.THRESHOLD.equals(condition)) {
+            return RolloutGroupErrorCondition.THRESHOLD;
+        }
+        throw new IllegalArgumentException(createIllegalArgumentLiteral(condition));
+    }
+
+    private static RolloutGroupSuccessCondition mapFinishCondition(final Condition condition) {
+        if (Condition.THRESHOLD.equals(condition)) {
+            return RolloutGroupSuccessCondition.THRESHOLD;
+        }
+        throw new IllegalArgumentException(createIllegalArgumentLiteral(condition));
+    }
+
+    private static Condition map(final RolloutGroupSuccessCondition rolloutCondition) {
+        if (RolloutGroupSuccessCondition.THRESHOLD.equals(rolloutCondition)) {
+            return Condition.THRESHOLD;
+        }
+        throw new IllegalArgumentException("Rollout group condition " + rolloutCondition + NOT_SUPPORTED);
+    }
+
+    private static Condition map(final RolloutGroupErrorCondition rolloutCondition) {
+        if (RolloutGroupErrorCondition.THRESHOLD.equals(rolloutCondition)) {
+            return Condition.THRESHOLD;
+        }
+        throw new IllegalArgumentException("Rollout group condition " + rolloutCondition + NOT_SUPPORTED);
+    }
+
+    private static RolloutGroupErrorAction map(final ErrorAction action) {
+        if (ErrorAction.PAUSE.equals(action)) {
+            return RolloutGroupErrorAction.PAUSE;
+        }
+        throw new IllegalArgumentException("Error Action " + action + NOT_SUPPORTED);
+    }
+
+    private static RolloutGroupSuccessAction map(final SuccessAction action) {
+        if (SuccessAction.NEXTGROUP.equals(action)) {
+            return RolloutGroupSuccessAction.NEXTGROUP;
+        }
+        throw new IllegalArgumentException("Success Action " + action + NOT_SUPPORTED);
+    }
+
+    private static SuccessAction map(final RolloutGroupSuccessAction successAction) {
+        if (RolloutGroupSuccessAction.NEXTGROUP.equals(successAction)) {
+            return SuccessAction.NEXTGROUP;
+        }
+        throw new IllegalArgumentException("Rollout group success action " + successAction + NOT_SUPPORTED);
+    }
+
+    private static ErrorAction map(final RolloutGroupErrorAction errorAction) {
+        if (RolloutGroupErrorAction.PAUSE.equals(errorAction)) {
+            return ErrorAction.PAUSE;
+        }
+        throw new IllegalArgumentException("Rollout group error action " + errorAction + NOT_SUPPORTED);
+    }
+
+    private static String createIllegalArgumentLiteral(final Condition condition) {
+        return "Condition " + condition + NOT_SUPPORTED;
+    }
+
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtRolloutResource.java

@@ -0,0 +1,228 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import javax.validation.ValidationException;
+
+import org.eclipse.hawkbit.mgmt.json.model.PagedList;
+import org.eclipse.hawkbit.mgmt.json.model.rollout.MgmtRolloutResponseBody;
+import org.eclipse.hawkbit.mgmt.json.model.rollout.MgmtRolloutRestRequestBody;
+import org.eclipse.hawkbit.mgmt.json.model.rolloutgroup.MgmtRolloutGroupResponseBody;
+import org.eclipse.hawkbit.mgmt.json.model.target.MgmtTarget;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRolloutRestApi;
+import org.eclipse.hawkbit.repository.DistributionSetManagement;
+import org.eclipse.hawkbit.repository.EntityFactory;
+import org.eclipse.hawkbit.repository.OffsetBasedPageRequest;
+import org.eclipse.hawkbit.repository.RolloutGroupManagement;
+import org.eclipse.hawkbit.repository.RolloutManagement;
+import org.eclipse.hawkbit.repository.TargetFilterQueryManagement;
+import org.eclipse.hawkbit.repository.builder.RolloutCreate;
+import org.eclipse.hawkbit.repository.builder.RolloutGroupCreate;
+import org.eclipse.hawkbit.repository.exception.EntityNotFoundException;
+import org.eclipse.hawkbit.repository.model.DistributionSet;
+import org.eclipse.hawkbit.repository.model.Rollout;
+import org.eclipse.hawkbit.repository.model.RolloutGroup;
+import org.eclipse.hawkbit.repository.model.RolloutGroupConditions;
+import org.eclipse.hawkbit.repository.model.Target;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * REST Resource handling rollout CRUD operations.
+ *
+ */
+@RestController
+public class MgmtRolloutResource implements MgmtRolloutRestApi {
+    @Autowired
+    private RolloutManagement rolloutManagement;
+
+    @Autowired
+    private RolloutGroupManagement rolloutGroupManagement;
+
+    @Autowired
+    private DistributionSetManagement distributionSetManagement;
+
+    @Autowired
+    private TargetFilterQueryManagement targetFilterQueryManagement;
+
+    @Autowired
+    private EntityFactory entityFactory;
+
+    @Override
+    public ResponseEntity<PagedList<MgmtRolloutResponseBody>> getRollouts(
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {
+
+        final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
+        final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
+        final Sort sorting = PagingUtility.sanitizeRolloutSortParam(sortParam);
+
+        final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);
+
+        final Page<Rollout> findModulesAll;
+        if (rsqlParam != null) {
+            findModulesAll = this.rolloutManagement.findByRsql(pageable, rsqlParam, false);
+        } else {
+            findModulesAll = this.rolloutManagement.findAll(pageable, false);
+        }
+
+        final List<MgmtRolloutResponseBody> rest = MgmtRolloutMapper.toResponseRollout(findModulesAll.getContent());
+        return ResponseEntity.ok(new PagedList<>(rest, findModulesAll.getTotalElements()));
+    }
+
+    @Override
+    public ResponseEntity<MgmtRolloutResponseBody> getRollout(@PathVariable("rolloutId") final Long rolloutId) {
+        final Rollout findRolloutById = rolloutManagement.getWithDetailedStatus(rolloutId)
+                .orElseThrow(() -> new EntityNotFoundException(Rollout.class, rolloutId));
+
+        return ResponseEntity.ok(MgmtRolloutMapper.toResponseRollout(findRolloutById, true));
+    }
+
+    @Override
+    public ResponseEntity<MgmtRolloutResponseBody> create(
+            @RequestBody final MgmtRolloutRestRequestBody rolloutRequestBody) {
+
+        // first check the given RSQL query if it's well formed, otherwise and
+        // exception is thrown
+        targetFilterQueryManagement.verifyTargetFilterQuerySyntax(rolloutRequestBody.getTargetFilterQuery());
+
+        final DistributionSet distributionSet = findDistributionSetOrThrowException(rolloutRequestBody);
+        final RolloutGroupConditions rolloutGroupConditions = MgmtRolloutMapper.fromRequest(rolloutRequestBody, true);
+
+        final RolloutCreate create = MgmtRolloutMapper.fromRequest(entityFactory, rolloutRequestBody, distributionSet);
+
+        Rollout rollout;
+        if (rolloutRequestBody.getGroups() != null) {
+            final List<RolloutGroupCreate> rolloutGroups = rolloutRequestBody.getGroups().stream()
+                    .map(mgmtRolloutGroup -> MgmtRolloutMapper.fromRequest(entityFactory, mgmtRolloutGroup))
+                    .collect(Collectors.toList());
+            rollout = rolloutManagement.create(create, rolloutGroups, rolloutGroupConditions);
+
+        } else if (rolloutRequestBody.getAmountGroups() != null) {
+            rollout = rolloutManagement.create(create, rolloutRequestBody.getAmountGroups(),
+                    rolloutGroupConditions);
+
+        } else {
+            throw new ValidationException("Either 'amountGroups' or 'groups' must be defined in the request");
+        }
+
+        return ResponseEntity.status(HttpStatus.CREATED).body(MgmtRolloutMapper.toResponseRollout(rollout, true));
+    }
+
+    @Override
+    public ResponseEntity<Void> start(@PathVariable("rolloutId") final Long rolloutId) {
+        this.rolloutManagement.start(rolloutId);
+        return ResponseEntity.ok().build();
+    }
+
+    @Override
+    public ResponseEntity<Void> pause(@PathVariable("rolloutId") final Long rolloutId) {
+        this.rolloutManagement.pauseRollout(rolloutId);
+        return ResponseEntity.ok().build();
+    }
+
+    @Override
+    public ResponseEntity<Void> delete(@PathVariable("rolloutId") final Long rolloutId) {
+        this.rolloutManagement.delete(rolloutId);
+        return ResponseEntity.ok().build();
+    }
+
+    @Override
+    public ResponseEntity<Void> resume(@PathVariable("rolloutId") final Long rolloutId) {
+        this.rolloutManagement.resumeRollout(rolloutId);
+        return ResponseEntity.ok().build();
+    }
+
+    @Override
+    public ResponseEntity<PagedList<MgmtRolloutGroupResponseBody>> getRolloutGroups(
+            @PathVariable("rolloutId") final Long rolloutId,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {
+        final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
+        final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
+        final Sort sorting = PagingUtility.sanitizeRolloutGroupSortParam(sortParam);
+
+        final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);
+
+        final Page<RolloutGroup> findRolloutGroupsAll;
+        if (rsqlParam != null) {
+            findRolloutGroupsAll = this.rolloutGroupManagement.findByRolloutAndRsql(pageable, rolloutId, rsqlParam);
+        } else {
+            findRolloutGroupsAll = this.rolloutGroupManagement.findByRollout(pageable, rolloutId);
+        }
+
+        final List<MgmtRolloutGroupResponseBody> rest = MgmtRolloutMapper
+                .toResponseRolloutGroup(findRolloutGroupsAll.getContent());
+        return ResponseEntity.ok(new PagedList<>(rest, findRolloutGroupsAll.getTotalElements()));
+    }
+
+    @Override
+    public ResponseEntity<MgmtRolloutGroupResponseBody> getRolloutGroup(@PathVariable("rolloutId") final Long rolloutId,
+            @PathVariable("groupId") final Long groupId) {
+        findRolloutOrThrowException(rolloutId);
+
+        final RolloutGroup rolloutGroup = rolloutGroupManagement.getWithDetailedStatus(groupId)
+                .orElseThrow(() -> new EntityNotFoundException(RolloutGroup.class, rolloutId));
+        return ResponseEntity.ok(MgmtRolloutMapper.toResponseRolloutGroup(rolloutGroup, true));
+    }
+
+    private void findRolloutOrThrowException(final Long rolloutId) {
+        if (!rolloutManagement.exists(rolloutId)) {
+            throw new EntityNotFoundException(Rollout.class, rolloutId);
+        }
+    }
+
+    @Override
+    public ResponseEntity<PagedList<MgmtTarget>> getRolloutGroupTargets(@PathVariable("rolloutId") final Long rolloutId,
+            @PathVariable("groupId") final Long groupId,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {
+        findRolloutOrThrowException(rolloutId);
+        final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
+        final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
+        final Sort sorting = PagingUtility.sanitizeTargetSortParam(sortParam);
+
+        final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);
+
+        final Page<Target> rolloutGroupTargets;
+        if (rsqlParam != null) {
+            rolloutGroupTargets = this.rolloutGroupManagement.findTargetsOfRolloutGroupByRsql(pageable, groupId, rsqlParam);
+        } else {
+            final Page<Target> pageTargets = this.rolloutGroupManagement.findTargetsOfRolloutGroup(pageable, groupId);
+            rolloutGroupTargets = pageTargets;
+        }
+        final List<MgmtTarget> rest = MgmtTargetMapper.toResponse(rolloutGroupTargets.getContent());
+        return ResponseEntity.ok(new PagedList<>(rest, rolloutGroupTargets.getTotalElements()));
+    }
+
+    private DistributionSet findDistributionSetOrThrowException(final MgmtRolloutRestRequestBody rolloutRequestBody) {
+        return this.distributionSetManagement.get(rolloutRequestBody.getDistributionSetId())
+                .orElseThrow(() -> new EntityNotFoundException(DistributionSet.class,
+                        rolloutRequestBody.getDistributionSetId()));
+
+    }
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtSoftwareModuleMapper.java

@@ -0,0 +1,161 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import static org.springframework.hateoas.mvc.ControllerLinkBuilder.linkTo;
+import static org.springframework.hateoas.mvc.ControllerLinkBuilder.methodOn;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.eclipse.hawkbit.mgmt.json.model.artifact.MgmtArtifact;
+import org.eclipse.hawkbit.mgmt.json.model.artifact.MgmtArtifactHash;
+import org.eclipse.hawkbit.mgmt.json.model.softwaremodule.MgmtSoftwareModule;
+import org.eclipse.hawkbit.mgmt.json.model.softwaremodule.MgmtSoftwareModuleMetadata;
+import org.eclipse.hawkbit.mgmt.json.model.softwaremodule.MgmtSoftwareModuleRequestBodyPost;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtSoftwareModuleRestApi;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtSoftwareModuleTypeRestApi;
+import org.eclipse.hawkbit.repository.EntityFactory;
+import org.eclipse.hawkbit.repository.builder.SoftwareModuleCreate;
+import org.eclipse.hawkbit.repository.builder.SoftwareModuleMetadataCreate;
+import org.eclipse.hawkbit.repository.model.Artifact;
+import org.eclipse.hawkbit.repository.model.SoftwareModule;
+import org.eclipse.hawkbit.repository.model.SoftwareModuleMetadata;
+import org.eclipse.hawkbit.rest.data.ResponseList;
+
+/**
+ * A mapper which maps repository model to RESTful model representation and
+ * back.
+ *
+ */
+public final class MgmtSoftwareModuleMapper {
+    private MgmtSoftwareModuleMapper() {
+        // Utility class
+    }
+
+    private static SoftwareModuleCreate fromRequest(final EntityFactory entityFactory,
+            final MgmtSoftwareModuleRequestBodyPost smsRest) {
+        return entityFactory.softwareModule().create().type(smsRest.getType()).name(smsRest.getName())
+                .version(smsRest.getVersion()).description(smsRest.getDescription()).vendor(smsRest.getVendor());
+    }
+
+    static List<SoftwareModuleMetadataCreate> fromRequestSwMetadata(final EntityFactory entityFactory,
+            final Long softwareModuleId, final Collection<MgmtSoftwareModuleMetadata> metadata) {
+        if (metadata == null) {
+            return Collections.emptyList();
+        }
+
+        return metadata.stream()
+                .map(metadataRest -> entityFactory.softwareModuleMetadata().create(softwareModuleId)
+                        .key(metadataRest.getKey()).value(metadataRest.getValue())
+                        .targetVisible(metadataRest.isTargetVisible()))
+                .collect(Collectors.toList());
+    }
+
+    static List<SoftwareModuleCreate> smFromRequest(final EntityFactory entityFactory,
+            final Collection<MgmtSoftwareModuleRequestBodyPost> smsRest) {
+        if (smsRest == null) {
+            return Collections.emptyList();
+        }
+
+        return smsRest.stream().map(smRest -> fromRequest(entityFactory, smRest)).collect(Collectors.toList());
+    }
+
+    static List<MgmtSoftwareModule> toResponse(final Collection<SoftwareModule> softwareModules) {
+        if (softwareModules == null) {
+            return Collections.emptyList();
+        }
+
+        return new ResponseList<>(
+                softwareModules.stream().map(MgmtSoftwareModuleMapper::toResponse).collect(Collectors.toList()));
+    }
+
+    static List<MgmtSoftwareModuleMetadata> toResponseSwMetadata(final Collection<SoftwareModuleMetadata> metadata) {
+        if (metadata == null) {
+            return Collections.emptyList();
+        }
+
+        return metadata.stream().map(MgmtSoftwareModuleMapper::toResponseSwMetadata).collect(Collectors.toList());
+    }
+
+    static MgmtSoftwareModuleMetadata toResponseSwMetadata(final SoftwareModuleMetadata metadata) {
+        final MgmtSoftwareModuleMetadata metadataRest = new MgmtSoftwareModuleMetadata();
+        metadataRest.setKey(metadata.getKey());
+        metadataRest.setValue(metadata.getValue());
+        metadataRest.setTargetVisible(metadata.isTargetVisible());
+        return metadataRest;
+    }
+
+    static MgmtSoftwareModule toResponse(final SoftwareModule softwareModule) {
+        if (softwareModule == null) {
+            return null;
+        }
+
+        final MgmtSoftwareModule response = new MgmtSoftwareModule();
+        MgmtRestModelMapper.mapNamedToNamed(response, softwareModule);
+        response.setModuleId(softwareModule.getId());
+        response.setVersion(softwareModule.getVersion());
+        response.setType(softwareModule.getType().getKey());
+        response.setVendor(softwareModule.getVendor());
+        response.setDeleted(softwareModule.isDeleted());
+
+        response.add(linkTo(methodOn(MgmtSoftwareModuleRestApi.class).getSoftwareModule(response.getModuleId()))
+                .withSelfRel());
+
+        return response;
+    }
+
+    static void addLinks(final SoftwareModule softwareModule, final MgmtSoftwareModule response) {
+        response.add(linkTo(methodOn(MgmtSoftwareModuleRestApi.class).getArtifacts(response.getModuleId()))
+                .withRel(MgmtRestConstants.SOFTWAREMODULE_V1_ARTIFACT));
+
+        response.add(linkTo(
+                methodOn(MgmtSoftwareModuleTypeRestApi.class).getSoftwareModuleType(softwareModule.getType().getId()))
+                        .withRel(MgmtRestConstants.SOFTWAREMODULE_V1_TYPE));
+
+        response.add(linkTo(methodOn(MgmtSoftwareModuleResource.class).getMetadata(response.getModuleId(),
+                MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET_VALUE,
+                MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT_VALUE, null, null)).withRel("metadata")
+                        .expand());
+    }
+
+    static MgmtArtifact toResponse(final Artifact artifact) {
+        final MgmtArtifact artifactRest = new MgmtArtifact();
+        artifactRest.setArtifactId(artifact.getId());
+        artifactRest.setSize(artifact.getSize());
+        artifactRest.setHashes(new MgmtArtifactHash(artifact.getSha1Hash(), artifact.getMd5Hash()));
+
+        artifactRest.setProvidedFilename(artifact.getFilename());
+
+        MgmtRestModelMapper.mapBaseToBase(artifactRest, artifact);
+
+        artifactRest.add(linkTo(methodOn(MgmtSoftwareModuleRestApi.class)
+                .getArtifact(artifact.getSoftwareModule().getId(), artifact.getId())).withSelfRel());
+
+        return artifactRest;
+    }
+
+    static void addLinks(final Artifact artifact, final MgmtArtifact response) {
+
+        response.add(linkTo(methodOn(MgmtDownloadArtifactResource.class)
+                .downloadArtifact(artifact.getSoftwareModule().getId(), artifact.getId())).withRel("download"));
+    }
+
+    static List<MgmtArtifact> artifactsToResponse(final Collection<Artifact> artifacts) {
+        if (artifacts == null) {
+            return Collections.emptyList();
+        }
+
+        return new ResponseList<>(
+                artifacts.stream().map(MgmtSoftwareModuleMapper::toResponse).collect(Collectors.toList()));
+    }
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtSoftwareModuleResource.java

@@ -0,0 +1,293 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.hawkbit.mgmt.json.model.PagedList;
+import org.eclipse.hawkbit.mgmt.json.model.artifact.MgmtArtifact;
+import org.eclipse.hawkbit.mgmt.json.model.softwaremodule.MgmtSoftwareModule;
+import org.eclipse.hawkbit.mgmt.json.model.softwaremodule.MgmtSoftwareModuleMetadata;
+import org.eclipse.hawkbit.mgmt.json.model.softwaremodule.MgmtSoftwareModuleMetadataBodyPut;
+import org.eclipse.hawkbit.mgmt.json.model.softwaremodule.MgmtSoftwareModuleRequestBodyPost;
+import org.eclipse.hawkbit.mgmt.json.model.softwaremodule.MgmtSoftwareModuleRequestBodyPut;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtSoftwareModuleRestApi;
+import org.eclipse.hawkbit.repository.ArtifactManagement;
+import org.eclipse.hawkbit.repository.EntityFactory;
+import org.eclipse.hawkbit.repository.OffsetBasedPageRequest;
+import org.eclipse.hawkbit.repository.SoftwareModuleManagement;
+import org.eclipse.hawkbit.repository.exception.EntityNotFoundException;
+import org.eclipse.hawkbit.repository.model.Artifact;
+import org.eclipse.hawkbit.repository.model.SoftwareModule;
+import org.eclipse.hawkbit.repository.model.SoftwareModuleMetadata;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Slice;
+import org.springframework.data.domain.Sort;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.multipart.MultipartFile;
+
+/**
+ * REST Resource handling for {@link SoftwareModule} and related
+ * {@link Artifact} CRUD operations.
+ */
+@RestController
+public class MgmtSoftwareModuleResource implements MgmtSoftwareModuleRestApi {
+
+    private static final Logger LOG = LoggerFactory.getLogger(MgmtSoftwareModuleResource.class);
+
+    @Autowired
+    private ArtifactManagement artifactManagement;
+
+    @Autowired
+    private SoftwareModuleManagement softwareModuleManagement;
+
+    @Autowired
+    private EntityFactory entityFactory;
+
+    @Override
+    public ResponseEntity<MgmtArtifact> uploadArtifact(@PathVariable("softwareModuleId") final Long softwareModuleId,
+            @RequestParam("file") final MultipartFile file,
+            @RequestParam(value = "filename", required = false) final String optionalFileName,
+            @RequestParam(value = "md5sum", required = false) final String md5Sum,
+            @RequestParam(value = "sha1sum", required = false) final String sha1Sum) {
+
+        if (file.isEmpty()) {
+            return ResponseEntity.badRequest().build();
+        }
+        String fileName = optionalFileName;
+
+        if (fileName == null) {
+            fileName = file.getOriginalFilename();
+        }
+
+        try (InputStream in = file.getInputStream()) {
+            final Artifact result = artifactManagement.create(in, softwareModuleId, fileName,
+                    md5Sum == null ? null : md5Sum.toLowerCase(), sha1Sum == null ? null : sha1Sum.toLowerCase(), false,
+                    file.getContentType(), file.getSize());
+
+            final MgmtArtifact reponse = MgmtSoftwareModuleMapper.toResponse(result);
+            MgmtSoftwareModuleMapper.addLinks(result, reponse);
+
+            return ResponseEntity.status(HttpStatus.CREATED).body(reponse);
+        } catch (final IOException e) {
+            LOG.error("Failed to store artifact", e);
+            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
+        }
+    }
+
+    @Override
+    public ResponseEntity<List<MgmtArtifact>> getArtifacts(
+            @PathVariable("softwareModuleId") final Long softwareModuleId) {
+
+        final SoftwareModule module = findSoftwareModuleWithExceptionIfNotFound(softwareModuleId, null);
+        return ResponseEntity.ok(MgmtSoftwareModuleMapper.artifactsToResponse(module.getArtifacts()));
+    }
+
+    @Override
+    @ResponseBody
+    // Exception squid:S3655 - Optional access is checked in
+    // findSoftwareModuleWithExceptionIfNotFound
+    // subroutine
+    @SuppressWarnings("squid:S3655")
+    public ResponseEntity<MgmtArtifact> getArtifact(@PathVariable("softwareModuleId") final Long softwareModuleId,
+            @PathVariable("artifactId") final Long artifactId) {
+
+        final SoftwareModule module = findSoftwareModuleWithExceptionIfNotFound(softwareModuleId, artifactId);
+
+        final MgmtArtifact reponse = MgmtSoftwareModuleMapper.toResponse(module.getArtifact(artifactId).get());
+        MgmtSoftwareModuleMapper.addLinks(module.getArtifact(artifactId).get(), reponse);
+
+        return ResponseEntity.ok(reponse);
+    }
+
+    @Override
+    @ResponseBody
+    public ResponseEntity<Void> deleteArtifact(@PathVariable("softwareModuleId") final Long softwareModuleId,
+            @PathVariable("artifactId") final Long artifactId) {
+
+        findSoftwareModuleWithExceptionIfNotFound(softwareModuleId, artifactId);
+        artifactManagement.delete(artifactId);
+
+        return ResponseEntity.ok().build();
+    }
+
+    @Override
+    public ResponseEntity<PagedList<MgmtSoftwareModule>> getSoftwareModules(
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {
+
+        final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
+        final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
+        final Sort sorting = PagingUtility.sanitizeSoftwareModuleSortParam(sortParam);
+
+        final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);
+
+        final Slice<SoftwareModule> findModulesAll;
+        long countModulesAll;
+        if (rsqlParam != null) {
+            findModulesAll = softwareModuleManagement.findByRsql(pageable, rsqlParam);
+            countModulesAll = ((Page<SoftwareModule>) findModulesAll).getTotalElements();
+        } else {
+            findModulesAll = softwareModuleManagement.findAll(pageable);
+            countModulesAll = softwareModuleManagement.count();
+        }
+
+        final List<MgmtSoftwareModule> rest = MgmtSoftwareModuleMapper.toResponse(findModulesAll.getContent());
+        return ResponseEntity.ok(new PagedList<>(rest, countModulesAll));
+    }
+
+    @Override
+    public ResponseEntity<MgmtSoftwareModule> getSoftwareModule(
+            @PathVariable("softwareModuleId") final Long softwareModuleId) {
+
+        final SoftwareModule module = findSoftwareModuleWithExceptionIfNotFound(softwareModuleId, null);
+
+        final MgmtSoftwareModule response = MgmtSoftwareModuleMapper.toResponse(module);
+        MgmtSoftwareModuleMapper.addLinks(module, response);
+
+        return ResponseEntity.ok(response);
+    }
+
+    @Override
+    public ResponseEntity<List<MgmtSoftwareModule>> createSoftwareModules(
+            @RequestBody final List<MgmtSoftwareModuleRequestBodyPost> softwareModules) {
+
+        LOG.debug("creating {} softwareModules", softwareModules.size());
+        final Collection<SoftwareModule> createdSoftwareModules = softwareModuleManagement
+                .create(MgmtSoftwareModuleMapper.smFromRequest(entityFactory, softwareModules));
+        LOG.debug("{} softwareModules created, return status {}", softwareModules.size(), HttpStatus.CREATED);
+
+        return ResponseEntity.status(HttpStatus.CREATED)
+                .body(MgmtSoftwareModuleMapper.toResponse(createdSoftwareModules));
+    }
+
+    @Override
+    public ResponseEntity<MgmtSoftwareModule> updateSoftwareModule(
+            @PathVariable("softwareModuleId") final Long softwareModuleId,
+            @RequestBody final MgmtSoftwareModuleRequestBodyPut restSoftwareModule) {
+        final SoftwareModule module = softwareModuleManagement
+                .update(entityFactory.softwareModule().update(softwareModuleId)
+                        .description(restSoftwareModule.getDescription()).vendor(restSoftwareModule.getVendor()));
+
+        final MgmtSoftwareModule response = MgmtSoftwareModuleMapper.toResponse(module);
+        MgmtSoftwareModuleMapper.addLinks(module, response);
+
+        return ResponseEntity.ok(response);
+    }
+
+    @Override
+    public ResponseEntity<Void> deleteSoftwareModule(@PathVariable("softwareModuleId") final Long softwareModuleId) {
+
+        final SoftwareModule module = findSoftwareModuleWithExceptionIfNotFound(softwareModuleId, null);
+        softwareModuleManagement.delete(module.getId());
+
+        return ResponseEntity.ok().build();
+    }
+
+    @Override
+    public ResponseEntity<PagedList<MgmtSoftwareModuleMetadata>> getMetadata(
+            @PathVariable("softwareModuleId") final Long softwareModuleId,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {
+
+        // check if software module exists otherwise throw exception immediately
+        findSoftwareModuleWithExceptionIfNotFound(softwareModuleId, null);
+
+        final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
+        final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
+        final Sort sorting = PagingUtility.sanitizeSoftwareModuleMetadataSortParam(sortParam);
+
+        final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);
+        final Page<SoftwareModuleMetadata> metaDataPage;
+
+        if (rsqlParam != null) {
+            metaDataPage = softwareModuleManagement.findMetaDataByRsql(pageable, softwareModuleId, rsqlParam);
+        } else {
+            metaDataPage = softwareModuleManagement.findMetaDataBySoftwareModuleId(pageable, softwareModuleId);
+        }
+
+        return ResponseEntity
+                .ok(new PagedList<>(MgmtSoftwareModuleMapper.toResponseSwMetadata(metaDataPage.getContent()),
+                        metaDataPage.getTotalElements()));
+    }
+
+    @Override
+    public ResponseEntity<MgmtSoftwareModuleMetadata> getMetadataValue(
+            @PathVariable("softwareModuleId") final Long softwareModuleId,
+            @PathVariable("metadataKey") final String metadataKey) {
+
+        final SoftwareModuleMetadata findOne = softwareModuleManagement
+                .getMetaDataBySoftwareModuleId(softwareModuleId, metadataKey).orElseThrow(
+                        () -> new EntityNotFoundException(SoftwareModuleMetadata.class, softwareModuleId, metadataKey));
+
+        return ResponseEntity.ok(MgmtSoftwareModuleMapper.toResponseSwMetadata(findOne));
+    }
+
+    @Override
+    public ResponseEntity<MgmtSoftwareModuleMetadata> updateMetadata(
+            @PathVariable("softwareModuleId") final Long softwareModuleId,
+            @PathVariable("metadataKey") final String metadataKey,
+            @RequestBody final MgmtSoftwareModuleMetadataBodyPut metadata) {
+        final SoftwareModuleMetadata updated = softwareModuleManagement
+                .updateMetaData(entityFactory.softwareModuleMetadata().update(softwareModuleId, metadataKey)
+                        .value(metadata.getValue()).targetVisible(metadata.isTargetVisible()));
+
+        return ResponseEntity.ok(MgmtSoftwareModuleMapper.toResponseSwMetadata(updated));
+    }
+
+    @Override
+    public ResponseEntity<Void> deleteMetadata(@PathVariable("softwareModuleId") final Long softwareModuleId,
+            @PathVariable("metadataKey") final String metadataKey) {
+        softwareModuleManagement.deleteMetaData(softwareModuleId, metadataKey);
+
+        return ResponseEntity.ok().build();
+    }
+
+    @Override
+    public ResponseEntity<List<MgmtSoftwareModuleMetadata>> createMetadata(
+            @PathVariable("softwareModuleId") final Long softwareModuleId,
+            @RequestBody final List<MgmtSoftwareModuleMetadata> metadataRest) {
+
+        final List<SoftwareModuleMetadata> created = softwareModuleManagement.createMetaData(
+                MgmtSoftwareModuleMapper.fromRequestSwMetadata(entityFactory, softwareModuleId, metadataRest));
+
+        return ResponseEntity.status(HttpStatus.CREATED).body(MgmtSoftwareModuleMapper.toResponseSwMetadata(created));
+    }
+
+    private SoftwareModule findSoftwareModuleWithExceptionIfNotFound(final Long softwareModuleId,
+            final Long artifactId) {
+
+        final SoftwareModule module = softwareModuleManagement.get(softwareModuleId)
+                .orElseThrow(() -> new EntityNotFoundException(SoftwareModule.class, softwareModuleId));
+
+        if (artifactId != null && !module.getArtifact(artifactId).isPresent()) {
+            throw new EntityNotFoundException(Artifact.class, artifactId);
+        }
+
+        return module;
+    }
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtSoftwareModuleTypeMapper.java

@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import static org.springframework.hateoas.mvc.ControllerLinkBuilder.linkTo;
+import static org.springframework.hateoas.mvc.ControllerLinkBuilder.methodOn;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.eclipse.hawkbit.mgmt.json.model.softwaremoduletype.MgmtSoftwareModuleType;
+import org.eclipse.hawkbit.mgmt.json.model.softwaremoduletype.MgmtSoftwareModuleTypeRequestBodyPost;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtSoftwareModuleTypeRestApi;
+import org.eclipse.hawkbit.repository.EntityFactory;
+import org.eclipse.hawkbit.repository.builder.SoftwareModuleTypeCreate;
+import org.eclipse.hawkbit.repository.model.SoftwareModuleType;
+import org.eclipse.hawkbit.rest.data.ResponseList;
+
+/**
+ * A mapper which maps repository model to RESTful model representation and
+ * back.
+ *
+ */
+final class MgmtSoftwareModuleTypeMapper {
+
+    // private constructor, utility class
+    private MgmtSoftwareModuleTypeMapper() {
+
+    }
+
+    static List<SoftwareModuleTypeCreate> smFromRequest(final EntityFactory entityFactory,
+            final Collection<MgmtSoftwareModuleTypeRequestBodyPost> smTypesRest) {
+        if (smTypesRest == null) {
+            return Collections.emptyList();
+        }
+
+        return smTypesRest.stream().map(smRest -> fromRequest(entityFactory, smRest)).collect(Collectors.toList());
+    }
+
+    private static SoftwareModuleTypeCreate fromRequest(final EntityFactory entityFactory,
+            final MgmtSoftwareModuleTypeRequestBodyPost smsRest) {
+        return entityFactory.softwareModuleType().create().key(smsRest.getKey()).name(smsRest.getName())
+                .description(smsRest.getDescription()).colour(smsRest.getColour())
+                .maxAssignments(smsRest.getMaxAssignments());
+    }
+
+    static List<MgmtSoftwareModuleType> toTypesResponse(final Collection<SoftwareModuleType> types) {
+        if (types == null) {
+            return Collections.emptyList();
+        }
+
+        return new ResponseList<>(
+                types.stream().map(MgmtSoftwareModuleTypeMapper::toResponse).collect(Collectors.toList()));
+    }
+
+    static MgmtSoftwareModuleType toResponse(final SoftwareModuleType type) {
+        final MgmtSoftwareModuleType result = new MgmtSoftwareModuleType();
+
+        MgmtRestModelMapper.mapNamedToNamed(result, type);
+        result.setKey(type.getKey());
+        result.setMaxAssignments(type.getMaxAssignments());
+        result.setModuleId(type.getId());
+        result.setDeleted(type.isDeleted());
+
+        result.add(linkTo(methodOn(MgmtSoftwareModuleTypeRestApi.class).getSoftwareModuleType(result.getModuleId()))
+                .withSelfRel());
+
+        return result;
+    }
+
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtSoftwareModuleTypeResource.java

@@ -0,0 +1,123 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import java.util.List;
+
+import org.eclipse.hawkbit.mgmt.json.model.PagedList;
+import org.eclipse.hawkbit.mgmt.json.model.softwaremoduletype.MgmtSoftwareModuleType;
+import org.eclipse.hawkbit.mgmt.json.model.softwaremoduletype.MgmtSoftwareModuleTypeRequestBodyPost;
+import org.eclipse.hawkbit.mgmt.json.model.softwaremoduletype.MgmtSoftwareModuleTypeRequestBodyPut;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtSoftwareModuleTypeRestApi;
+import org.eclipse.hawkbit.repository.EntityFactory;
+import org.eclipse.hawkbit.repository.OffsetBasedPageRequest;
+import org.eclipse.hawkbit.repository.SoftwareModuleTypeManagement;
+import org.eclipse.hawkbit.repository.exception.EntityNotFoundException;
+import org.eclipse.hawkbit.repository.model.Artifact;
+import org.eclipse.hawkbit.repository.model.SoftwareModule;
+import org.eclipse.hawkbit.repository.model.SoftwareModuleType;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Slice;
+import org.springframework.data.domain.Sort;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * REST Resource handling for {@link SoftwareModule} and related
+ * {@link Artifact} CRUD operations.
+ *
+ */
+@RestController
+public class MgmtSoftwareModuleTypeResource implements MgmtSoftwareModuleTypeRestApi {
+    @Autowired
+    private SoftwareModuleTypeManagement softwareModuleTypeManagement;
+
+    @Autowired
+    private EntityFactory entityFactory;
+
+    @Override
+    public ResponseEntity<PagedList<MgmtSoftwareModuleType>> getTypes(
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {
+
+        final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
+        final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
+        final Sort sorting = PagingUtility.sanitizeSoftwareModuleTypeSortParam(sortParam);
+
+        final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);
+
+        final Slice<SoftwareModuleType> findModuleTypessAll;
+        Long countModulesAll;
+        if (rsqlParam != null) {
+            findModuleTypessAll = softwareModuleTypeManagement.findByRsql(pageable, rsqlParam);
+            countModulesAll = ((Page<SoftwareModuleType>) findModuleTypessAll).getTotalElements();
+        } else {
+            findModuleTypessAll = softwareModuleTypeManagement.findAll(pageable);
+            countModulesAll = softwareModuleTypeManagement.count();
+        }
+
+        final List<MgmtSoftwareModuleType> rest = MgmtSoftwareModuleTypeMapper
+                .toTypesResponse(findModuleTypessAll.getContent());
+        return ResponseEntity.ok(new PagedList<>(rest, countModulesAll));
+    }
+
+    @Override
+    public ResponseEntity<MgmtSoftwareModuleType> getSoftwareModuleType(
+            @PathVariable("softwareModuleTypeId") final Long softwareModuleTypeId) {
+        final SoftwareModuleType foundType = findSoftwareModuleTypeWithExceptionIfNotFound(softwareModuleTypeId);
+
+        return ResponseEntity.ok(MgmtSoftwareModuleTypeMapper.toResponse(foundType));
+    }
+
+    @Override
+    public ResponseEntity<Void> deleteSoftwareModuleType(
+            @PathVariable("softwareModuleTypeId") final Long softwareModuleTypeId) {
+        softwareModuleTypeManagement.delete(softwareModuleTypeId);
+        return ResponseEntity.ok().build();
+    }
+
+    @Override
+    public ResponseEntity<MgmtSoftwareModuleType> updateSoftwareModuleType(
+            @PathVariable("softwareModuleTypeId") final Long softwareModuleTypeId,
+            @RequestBody final MgmtSoftwareModuleTypeRequestBodyPut restSoftwareModuleType) {
+
+        final SoftwareModuleType updatedSoftwareModuleType = softwareModuleTypeManagement
+                .update(entityFactory.softwareModuleType().update(softwareModuleTypeId)
+                        .description(restSoftwareModuleType.getDescription())
+                        .colour(restSoftwareModuleType.getColour()));
+
+        return ResponseEntity.ok(MgmtSoftwareModuleTypeMapper.toResponse(updatedSoftwareModuleType));
+    }
+
+    @Override
+    public ResponseEntity<List<MgmtSoftwareModuleType>> createSoftwareModuleTypes(
+            @RequestBody final List<MgmtSoftwareModuleTypeRequestBodyPost> softwareModuleTypes) {
+
+        final List<SoftwareModuleType> createdSoftwareModules = softwareModuleTypeManagement.create(
+                MgmtSoftwareModuleTypeMapper.smFromRequest(entityFactory, softwareModuleTypes));
+
+        return new ResponseEntity<>(MgmtSoftwareModuleTypeMapper.toTypesResponse(createdSoftwareModules),
+                HttpStatus.CREATED);
+    }
+
+    private SoftwareModuleType findSoftwareModuleTypeWithExceptionIfNotFound(final Long softwareModuleTypeId) {
+        return softwareModuleTypeManagement.get(softwareModuleTypeId)
+                .orElseThrow(() -> new EntityNotFoundException(SoftwareModuleType.class, softwareModuleTypeId));
+    }
+
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtSystemManagementResource.java

@@ -0,0 +1,139 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.eclipse.hawkbit.im.authentication.SpPermission.SpringEvalExpressions;
+import org.eclipse.hawkbit.mgmt.json.model.systemmanagement.MgmtSystemCache;
+import org.eclipse.hawkbit.mgmt.json.model.systemmanagement.MgmtSystemStatisticsRest;
+import org.eclipse.hawkbit.mgmt.json.model.systemmanagement.MgmtSystemTenantServiceUsage;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtSystemManagementRestApi;
+import org.eclipse.hawkbit.repository.SystemManagement;
+import org.eclipse.hawkbit.repository.report.model.SystemUsageReportWithTenants;
+import org.eclipse.hawkbit.repository.report.model.TenantUsage;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * {@link SystemManagement} capabilities by REST.
+ *
+ */
+@RestController
+public class MgmtSystemManagementResource implements MgmtSystemManagementRestApi {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(MgmtSystemManagementResource.class);
+
+    @Autowired
+    private SystemManagement systemManagement;
+
+    @Autowired
+    private CacheManager cacheManager;
+
+    /**
+     * Deletes the tenant data of a given tenant. USE WITH CARE!
+     *
+     * @param tenant
+     *            to delete
+     * @return HttpStatus.OK
+     */
+    @Override
+    public ResponseEntity<Void> deleteTenant(@PathVariable("tenant") final String tenant) {
+        systemManagement.deleteTenant(tenant);
+        return ResponseEntity.ok().build();
+    }
+
+    /**
+     * Collects and returns system usage statistics. It provides a system wide
+     * overview and tenant based stats.
+     *
+     * @return system usage statistics
+     */
+    @Override
+    public ResponseEntity<MgmtSystemStatisticsRest> getSystemUsageStats() {
+        final SystemUsageReportWithTenants report = systemManagement.getSystemUsageStatisticsWithTenants();
+
+        final MgmtSystemStatisticsRest result = new MgmtSystemStatisticsRest()
+                .setOverallActions(report.getOverallActions()).setOverallArtifacts(report.getOverallArtifacts())
+                .setOverallArtifactVolumeInBytes(report.getOverallArtifactVolumeInBytes())
+                .setOverallTargets(report.getOverallTargets()).setOverallTenants(report.getTenants().size());
+
+        result.setTenantStats(report.getTenants().stream().map(MgmtSystemManagementResource::convertTenant)
+                .collect(Collectors.toList()));
+
+        return ResponseEntity.ok(result);
+    }
+
+    private static MgmtSystemTenantServiceUsage convertTenant(final TenantUsage tenant) {
+        final MgmtSystemTenantServiceUsage result = new MgmtSystemTenantServiceUsage();
+        result.setTenantName(tenant.getTenantName());
+        result.setActions(tenant.getActions());
+        result.setArtifacts(tenant.getArtifacts());
+        result.setOverallArtifactVolumeInBytes(tenant.getOverallArtifactVolumeInBytes());
+        result.setTargets(tenant.getTargets());
+        if (!tenant.getUsageData().isEmpty()) {
+            result.setUsageData(tenant.getUsageData());
+        }
+        return result;
+    }
+
+    /**
+     * Returns a list of all caches.
+     *
+     * @return a list of caches for all tenants
+     */
+    @Override
+    @PreAuthorize(SpringEvalExpressions.HAS_AUTH_SYSTEM_ADMIN)
+    public ResponseEntity<Collection<MgmtSystemCache>> getCaches() {
+        final Collection<String> cacheNames = cacheManager.getCacheNames();
+        return ResponseEntity
+                .ok(cacheNames.stream().map(cacheManager::getCache).map(this::cacheRest).collect(Collectors.toList()));
+    }
+
+    /**
+     * Invalidates all caches for all tenants.
+     *
+     * @return a list of cache names which has been invalidated
+     */
+    @PreAuthorize(SpringEvalExpressions.HAS_AUTH_SYSTEM_ADMIN)
+    @Override
+    public ResponseEntity<Collection<String>> invalidateCaches() {
+        final Collection<String> cacheNames = cacheManager.getCacheNames();
+        LOGGER.info("Invalidating caches {}", cacheNames);
+        cacheNames.forEach(cacheName -> cacheManager.getCache(cacheName).clear());
+        return ResponseEntity.ok(cacheNames);
+    }
+
+    private MgmtSystemCache cacheRest(final Cache cache) {
+        final Object nativeCache = cache.getNativeCache();
+        if (nativeCache instanceof com.google.common.cache.Cache) {
+            return guavaCache(cache, nativeCache);
+        } else {
+            return new MgmtSystemCache(cache.getName(), Collections.emptyList());
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private MgmtSystemCache guavaCache(final Cache cache, final Object nativeCache) {
+        final com.google.common.cache.Cache<Object, Object> guavaCache = (com.google.common.cache.Cache<Object, Object>) nativeCache;
+        final List<String> keys = guavaCache.asMap().keySet().stream().map(key -> key.toString())
+                .collect(Collectors.toList());
+        return new MgmtSystemCache(cache.getName(), keys);
+    }
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtTagMapper.java

@@ -0,0 +1,125 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import static org.springframework.hateoas.mvc.ControllerLinkBuilder.linkTo;
+import static org.springframework.hateoas.mvc.ControllerLinkBuilder.methodOn;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.eclipse.hawkbit.mgmt.json.model.tag.MgmtTag;
+import org.eclipse.hawkbit.mgmt.json.model.tag.MgmtTagRequestBodyPut;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtDistributionSetTagRestApi;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtTargetTagRestApi;
+import org.eclipse.hawkbit.repository.EntityFactory;
+import org.eclipse.hawkbit.repository.builder.TagCreate;
+import org.eclipse.hawkbit.repository.model.DistributionSetTag;
+import org.eclipse.hawkbit.repository.model.Tag;
+import org.eclipse.hawkbit.repository.model.TargetTag;
+import org.eclipse.hawkbit.rest.data.ResponseList;
+
+/**
+ * A mapper which maps repository model to RESTful model representation and
+ * back.
+ *
+ */
+final class MgmtTagMapper {
+    private MgmtTagMapper() {
+        // Utility class
+    }
+
+    static List<MgmtTag> toResponse(final List<TargetTag> targetTags) {
+        final List<MgmtTag> tagsRest = new ArrayList<>();
+        if (targetTags == null) {
+            return tagsRest;
+        }
+
+        for (final TargetTag target : targetTags) {
+            final MgmtTag response = toResponse(target);
+
+            tagsRest.add(response);
+        }
+        return new ResponseList<>(tagsRest);
+    }
+
+    static MgmtTag toResponse(final TargetTag targetTag) {
+        final MgmtTag response = new MgmtTag();
+        if (targetTag == null) {
+            return response;
+        }
+
+        mapTag(response, targetTag);
+
+        response.add(linkTo(methodOn(MgmtTargetTagRestApi.class).getTargetTag(targetTag.getId())).withSelfRel());
+
+        return response;
+    }
+
+    static void addLinks(final TargetTag targetTag, final MgmtTag response) {
+        response.add(linkTo(methodOn(MgmtTargetTagRestApi.class).getAssignedTargets(targetTag.getId(),
+                MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET_VALUE,
+                MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT_VALUE, null, null))
+                        .withRel("assignedTargets"));
+
+    }
+
+    static List<MgmtTag> toResponseDistributionSetTag(final List<DistributionSetTag> distributionSetTags) {
+        final List<MgmtTag> tagsRest = new ArrayList<>();
+        if (distributionSetTags == null) {
+            return tagsRest;
+        }
+
+        for (final DistributionSetTag distributionSetTag : distributionSetTags) {
+            final MgmtTag response = toResponse(distributionSetTag);
+
+            tagsRest.add(response);
+        }
+        return new ResponseList<>(tagsRest);
+    }
+
+    static MgmtTag toResponse(final DistributionSetTag distributionSetTag) {
+        final MgmtTag response = new MgmtTag();
+        if (distributionSetTag == null) {
+            return null;
+        }
+
+        mapTag(response, distributionSetTag);
+
+        response.add(
+                linkTo(methodOn(MgmtDistributionSetTagRestApi.class).getDistributionSetTag(distributionSetTag.getId()))
+                        .withSelfRel());
+
+        return response;
+    }
+
+    static void addLinks(final DistributionSetTag distributionSetTag, final MgmtTag response) {
+        response.add(linkTo(methodOn(MgmtDistributionSetTagRestApi.class).getAssignedDistributionSets(
+                distributionSetTag.getId(), MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET_VALUE,
+                MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT_VALUE, null, null))
+                        .withRel("assignedDistributionSets"));
+    }
+
+    static List<TagCreate> mapTagFromRequest(final EntityFactory entityFactory,
+            final Collection<MgmtTagRequestBodyPut> tags) {
+        return tags.stream()
+                .map(tagRest -> entityFactory.tag().create().name(tagRest.getName())
+                        .description(tagRest.getDescription()).colour(tagRest.getColour()))
+                .collect(Collectors.toList());
+    }
+
+    private static void mapTag(final MgmtTag response, final Tag tag) {
+        MgmtRestModelMapper.mapNamedToNamed(response, tag);
+        response.setTagId(tag.getId());
+        response.setColour(tag.getColour());
+    }
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtTargetFilterQueryMapper.java

@@ -0,0 +1,78 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import static org.springframework.hateoas.mvc.ControllerLinkBuilder.linkTo;
+import static org.springframework.hateoas.mvc.ControllerLinkBuilder.methodOn;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.eclipse.hawkbit.mgmt.json.model.targetfilter.MgmtTargetFilterQuery;
+import org.eclipse.hawkbit.mgmt.json.model.targetfilter.MgmtTargetFilterQueryRequestBody;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtTargetFilterQueryRestApi;
+import org.eclipse.hawkbit.repository.EntityFactory;
+import org.eclipse.hawkbit.repository.builder.TargetFilterQueryCreate;
+import org.eclipse.hawkbit.repository.model.DistributionSet;
+import org.eclipse.hawkbit.repository.model.TargetFilterQuery;
+import org.springframework.util.CollectionUtils;
+
+/**
+ * A mapper which maps repository model to RESTful model representation and
+ * back.
+ *
+ */
+public final class MgmtTargetFilterQueryMapper {
+
+    private MgmtTargetFilterQueryMapper() {
+        // Utility class
+    }
+
+    static List<MgmtTargetFilterQuery> toResponse(final List<TargetFilterQuery> filters) {
+        if (CollectionUtils.isEmpty(filters)) {
+            return Collections.emptyList();
+        }
+        return filters.stream().map(MgmtTargetFilterQueryMapper::toResponse).collect(Collectors.toList());
+    }
+
+    static MgmtTargetFilterQuery toResponse(final TargetFilterQuery filter) {
+        final MgmtTargetFilterQuery targetRest = new MgmtTargetFilterQuery();
+        targetRest.setFilterId(filter.getId());
+        targetRest.setName(filter.getName());
+        targetRest.setQuery(filter.getQuery());
+
+        targetRest.setCreatedBy(filter.getCreatedBy());
+        targetRest.setLastModifiedBy(filter.getLastModifiedBy());
+
+        targetRest.setCreatedAt(filter.getCreatedAt());
+        targetRest.setLastModifiedAt(filter.getLastModifiedAt());
+
+        final DistributionSet distributionSet = filter.getAutoAssignDistributionSet();
+        if (distributionSet != null) {
+            targetRest.setAutoAssignDistributionSet(distributionSet.getId());
+        }
+
+        targetRest.add(linkTo(methodOn(MgmtTargetFilterQueryRestApi.class).getFilter(filter.getId())).withSelfRel());
+
+        return targetRest;
+    }
+
+    static void addLinks(final MgmtTargetFilterQuery targetRest) {
+        targetRest.add(linkTo(methodOn(MgmtTargetFilterQueryRestApi.class)
+                .postAssignedDistributionSet(targetRest.getFilterId(), null)).withRel("autoAssignDS"));
+    }
+
+    static TargetFilterQueryCreate fromRequest(final EntityFactory entityFactory,
+            final MgmtTargetFilterQueryRequestBody filterRest) {
+
+        return entityFactory.targetFilterQuery().create().name(filterRest.getName()).query(filterRest.getQuery());
+    }
+
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtTargetFilterQueryResource.java

@@ -0,0 +1,164 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import java.util.List;
+
+import org.eclipse.hawkbit.mgmt.json.model.MgmtId;
+import org.eclipse.hawkbit.mgmt.json.model.PagedList;
+import org.eclipse.hawkbit.mgmt.json.model.distributionset.MgmtDistributionSet;
+import org.eclipse.hawkbit.mgmt.json.model.targetfilter.MgmtTargetFilterQuery;
+import org.eclipse.hawkbit.mgmt.json.model.targetfilter.MgmtTargetFilterQueryRequestBody;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtTargetFilterQueryRestApi;
+import org.eclipse.hawkbit.repository.EntityFactory;
+import org.eclipse.hawkbit.repository.OffsetBasedPageRequest;
+import org.eclipse.hawkbit.repository.TargetFilterQueryManagement;
+import org.eclipse.hawkbit.repository.exception.EntityNotFoundException;
+import org.eclipse.hawkbit.repository.model.DistributionSet;
+import org.eclipse.hawkbit.repository.model.TargetFilterQuery;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Slice;
+import org.springframework.data.domain.Sort;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * REST Resource handling target CRUD operations.
+ */
+@RestController
+public class MgmtTargetFilterQueryResource implements MgmtTargetFilterQueryRestApi {
+    private static final Logger LOG = LoggerFactory.getLogger(MgmtTargetFilterQueryResource.class);
+
+    @Autowired
+    private TargetFilterQueryManagement filterManagement;
+
+    @Autowired
+    private EntityFactory entityFactory;
+
+    @Override
+    public ResponseEntity<MgmtTargetFilterQuery> getFilter(@PathVariable("filterId") final Long filterId) {
+        final TargetFilterQuery findTarget = findFilterWithExceptionIfNotFound(filterId);
+        // to single response include poll status
+        final MgmtTargetFilterQuery response = MgmtTargetFilterQueryMapper.toResponse(findTarget);
+        MgmtTargetFilterQueryMapper.addLinks(response);
+
+        return ResponseEntity.ok(response);
+    }
+
+    @Override
+    public ResponseEntity<PagedList<MgmtTargetFilterQuery>> getFilters(
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {
+
+        final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
+        final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
+        final Sort sorting = PagingUtility.sanitizeTargetFilterQuerySortParam(sortParam);
+
+        final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);
+        final Slice<TargetFilterQuery> findTargetFiltersAll;
+        final Long countTargetsAll;
+        if (rsqlParam != null) {
+            final Page<TargetFilterQuery> findFilterPage = filterManagement.findByRsql(pageable, rsqlParam);
+            countTargetsAll = findFilterPage.getTotalElements();
+            findTargetFiltersAll = findFilterPage;
+        } else {
+            findTargetFiltersAll = filterManagement.findAll(pageable);
+            countTargetsAll = filterManagement.count();
+        }
+
+        final List<MgmtTargetFilterQuery> rest = MgmtTargetFilterQueryMapper
+                .toResponse(findTargetFiltersAll.getContent());
+        return ResponseEntity.ok(new PagedList<>(rest, countTargetsAll));
+    }
+
+    @Override
+    public ResponseEntity<MgmtTargetFilterQuery> createFilter(
+            @RequestBody final MgmtTargetFilterQueryRequestBody filter) {
+        final TargetFilterQuery createdTarget = filterManagement
+                .create(MgmtTargetFilterQueryMapper.fromRequest(entityFactory, filter));
+
+        final MgmtTargetFilterQuery response = MgmtTargetFilterQueryMapper.toResponse(createdTarget);
+        MgmtTargetFilterQueryMapper.addLinks(response);
+
+        return new ResponseEntity<>(response, HttpStatus.CREATED);
+    }
+
+    @Override
+    public ResponseEntity<MgmtTargetFilterQuery> updateFilter(@PathVariable("filterId") final Long filterId,
+            @RequestBody final MgmtTargetFilterQueryRequestBody targetFilterRest) {
+        LOG.debug("updating target filter query {}", filterId);
+
+        final TargetFilterQuery updateFilter = filterManagement.update(entityFactory.targetFilterQuery()
+                .update(filterId).name(targetFilterRest.getName()).query(targetFilterRest.getQuery()));
+
+        final MgmtTargetFilterQuery response = MgmtTargetFilterQueryMapper.toResponse(updateFilter);
+        MgmtTargetFilterQueryMapper.addLinks(response);
+
+        return ResponseEntity.ok(response);
+    }
+
+    @Override
+    public ResponseEntity<Void> deleteFilter(@PathVariable("filterId") final Long filterId) {
+        filterManagement.delete(filterId);
+        LOG.debug("{} target filter query deleted, return status {}", filterId, HttpStatus.OK);
+        return ResponseEntity.ok().build();
+    }
+
+    @Override
+    public ResponseEntity<MgmtTargetFilterQuery> postAssignedDistributionSet(
+            @PathVariable("filterId") final Long filterId, @RequestBody final MgmtId dsId) {
+
+        final TargetFilterQuery updateFilter = filterManagement.updateAutoAssignDS(filterId, dsId.getId());
+
+        final MgmtTargetFilterQuery response = MgmtTargetFilterQueryMapper.toResponse(updateFilter);
+        MgmtTargetFilterQueryMapper.addLinks(response);
+
+        return ResponseEntity.ok(response);
+    }
+
+    @Override
+    public ResponseEntity<MgmtDistributionSet> getAssignedDistributionSet(
+            @PathVariable("filterId") final Long filterId) {
+        final TargetFilterQuery filter = findFilterWithExceptionIfNotFound(filterId);
+        final DistributionSet autoAssignDistributionSet = filter.getAutoAssignDistributionSet();
+
+        if (autoAssignDistributionSet == null) {
+            return ResponseEntity.noContent().build();
+        }
+
+        final MgmtDistributionSet response = MgmtDistributionSetMapper.toResponse(autoAssignDistributionSet);
+        MgmtDistributionSetMapper.addLinks(autoAssignDistributionSet, response);
+
+        return ResponseEntity.ok(response);
+    }
+
+    @Override
+    public ResponseEntity<Void> deleteAssignedDistributionSet(@PathVariable("filterId") final Long filterId) {
+        filterManagement.updateAutoAssignDS(filterId, null);
+
+        return ResponseEntity.noContent().build();
+    }
+
+    private TargetFilterQuery findFilterWithExceptionIfNotFound(final Long filterId) {
+        return filterManagement.get(filterId)
+                .orElseThrow(() -> new EntityNotFoundException(TargetFilterQuery.class, filterId));
+    }
+
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtTargetMapper.java

@@ -0,0 +1,264 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import static org.springframework.hateoas.mvc.ControllerLinkBuilder.linkTo;
+import static org.springframework.hateoas.mvc.ControllerLinkBuilder.methodOn;
+
+import java.net.URI;
+import java.time.ZoneId;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.eclipse.hawkbit.mgmt.json.model.MgmtMaintenanceWindow;
+import org.eclipse.hawkbit.mgmt.json.model.MgmtPollStatus;
+import org.eclipse.hawkbit.mgmt.json.model.action.MgmtAction;
+import org.eclipse.hawkbit.mgmt.json.model.action.MgmtActionStatus;
+import org.eclipse.hawkbit.mgmt.json.model.target.MgmtTarget;
+import org.eclipse.hawkbit.mgmt.json.model.target.MgmtTargetRequestBody;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtDistributionSetRestApi;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtTargetRestApi;
+import org.eclipse.hawkbit.repository.ActionFields;
+import org.eclipse.hawkbit.repository.ActionStatusFields;
+import org.eclipse.hawkbit.repository.DeploymentManagement;
+import org.eclipse.hawkbit.repository.EntityFactory;
+import org.eclipse.hawkbit.repository.builder.TargetCreate;
+import org.eclipse.hawkbit.repository.model.Action;
+import org.eclipse.hawkbit.repository.model.Action.ActionType;
+import org.eclipse.hawkbit.repository.model.ActionStatus;
+import org.eclipse.hawkbit.repository.model.PollStatus;
+import org.eclipse.hawkbit.repository.model.Target;
+import org.eclipse.hawkbit.rest.data.ResponseList;
+import org.eclipse.hawkbit.rest.data.SortDirection;
+import org.eclipse.hawkbit.util.IpUtil;
+import org.springframework.data.domain.PageRequest;
+
+/**
+ * A mapper which maps repository model to RESTful model representation and
+ * back.
+ *
+ */
+public final class MgmtTargetMapper {
+
+    private MgmtTargetMapper() {
+        // Utility class
+    }
+
+    /**
+     * Add links to a target response.
+     *
+     * @param response
+     *            the target response
+     */
+    public static void addTargetLinks(final MgmtTarget response) {
+        response.add(linkTo(methodOn(MgmtTargetRestApi.class).getAssignedDistributionSet(response.getControllerId()))
+                .withRel(MgmtRestConstants.TARGET_V1_ASSIGNED_DISTRIBUTION_SET));
+        response.add(linkTo(methodOn(MgmtTargetRestApi.class).getInstalledDistributionSet(response.getControllerId()))
+                .withRel(MgmtRestConstants.TARGET_V1_INSTALLED_DISTRIBUTION_SET));
+        response.add(linkTo(methodOn(MgmtTargetRestApi.class).getAttributes(response.getControllerId()))
+                .withRel(MgmtRestConstants.TARGET_V1_ATTRIBUTES));
+        response.add(linkTo(methodOn(MgmtTargetRestApi.class).getActionHistory(response.getControllerId(), 0,
+                MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT_VALUE,
+                ActionFields.ID.getFieldName() + ":" + SortDirection.DESC, null))
+                        .withRel(MgmtRestConstants.TARGET_V1_ACTIONS).expand());
+    }
+
+    static void addPollStatus(final Target target, final MgmtTarget targetRest) {
+        final PollStatus pollStatus = target.getPollStatus();
+        if (pollStatus != null) {
+            final MgmtPollStatus pollStatusRest = new MgmtPollStatus();
+            pollStatusRest.setLastRequestAt(
+                    Date.from(pollStatus.getLastPollDate().atZone(ZoneId.systemDefault()).toInstant()).getTime());
+            pollStatusRest.setNextExpectedRequestAt(
+                    Date.from(pollStatus.getNextPollDate().atZone(ZoneId.systemDefault()).toInstant()).getTime());
+            pollStatusRest.setOverdue(pollStatus.isOverdue());
+            targetRest.setPollStatus(pollStatusRest);
+        }
+    }
+
+    /**
+     * Create a response for targets.
+     *
+     * @param targets
+     *            list of targets
+     * @return the response
+     */
+    public static List<MgmtTarget> toResponse(final Collection<Target> targets) {
+        if (targets == null) {
+            return Collections.emptyList();
+        }
+
+        return new ResponseList<>(targets.stream().map(MgmtTargetMapper::toResponse).collect(Collectors.toList()));
+    }
+
+    /**
+     * Create a response for target.
+     *
+     * @param target
+     *            the target
+     * @return the response
+     */
+    public static MgmtTarget toResponse(final Target target) {
+        if (target == null) {
+            return null;
+        }
+        final MgmtTarget targetRest = new MgmtTarget();
+        targetRest.setControllerId(target.getControllerId());
+        targetRest.setDescription(target.getDescription());
+        targetRest.setName(target.getName());
+        targetRest.setUpdateStatus(target.getUpdateStatus().name().toLowerCase());
+
+        final URI address = target.getAddress();
+        if (address != null) {
+            if (IpUtil.isIpAddresKnown(address)) {
+                targetRest.setIpAddress(address.getHost());
+            }
+            targetRest.setAddress(address.toString());
+        }
+
+        targetRest.setCreatedBy(target.getCreatedBy());
+        targetRest.setLastModifiedBy(target.getLastModifiedBy());
+
+        targetRest.setCreatedAt(target.getCreatedAt());
+        targetRest.setLastModifiedAt(target.getLastModifiedAt());
+
+        targetRest.setSecurityToken(target.getSecurityToken());
+
+        // last target query is the last controller request date
+        final Long lastTargetQuery = target.getLastTargetQuery();
+        final Long installationDate = target.getInstallationDate();
+
+        if (lastTargetQuery != null) {
+            targetRest.setLastControllerRequestAt(lastTargetQuery);
+        }
+        if (installationDate != null) {
+            targetRest.setInstalledAt(installationDate);
+        }
+
+        targetRest.add(linkTo(methodOn(MgmtTargetRestApi.class).getTarget(target.getControllerId())).withSelfRel());
+
+        return targetRest;
+    }
+
+    static List<TargetCreate> fromRequest(final EntityFactory entityFactory,
+            final Collection<MgmtTargetRequestBody> targetsRest) {
+        if (targetsRest == null) {
+            return Collections.emptyList();
+        }
+
+        return targetsRest.stream().map(targetRest -> fromRequest(entityFactory, targetRest))
+                .collect(Collectors.toList());
+    }
+
+    private static TargetCreate fromRequest(final EntityFactory entityFactory, final MgmtTargetRequestBody targetRest) {
+        return entityFactory.target().create().controllerId(targetRest.getControllerId()).name(targetRest.getName())
+                .description(targetRest.getDescription()).securityToken(targetRest.getSecurityToken())
+                .address(targetRest.getAddress());
+    }
+
+    static List<MgmtActionStatus> toActionStatusRestResponse(final Collection<ActionStatus> actionStatus,
+            final DeploymentManagement deploymentManagement) {
+        if (actionStatus == null) {
+            return Collections.emptyList();
+        }
+
+        return actionStatus.stream().map(status -> toResponse(status,
+                deploymentManagement.findMessagesByActionStatusId(
+                        new PageRequest(0, MgmtRestConstants.REQUEST_PARAMETER_PAGING_MAX_LIMIT), status.getId())
+                        .getContent()))
+                .collect(Collectors.toList());
+    }
+
+    static MgmtAction toResponse(final String targetId, final Action action) {
+        final MgmtAction result = new MgmtAction();
+
+        result.setActionId(action.getId());
+        result.setType(getType(action));
+        if (ActionType.TIMEFORCED.equals(action.getActionType())) {
+            result.setForceTime(action.getForcedTime());
+        }
+        result.setForceType(MgmtRestModelMapper.convertActionType(action.getActionType()));
+
+        if (action.isActive()) {
+            result.setStatus(MgmtAction.ACTION_PENDING);
+        } else {
+            result.setStatus(MgmtAction.ACTION_FINISHED);
+        }
+
+        if (action.hasMaintenanceSchedule()) {
+            final MgmtMaintenanceWindow maintenanceWindow = new MgmtMaintenanceWindow();
+            maintenanceWindow.setSchedule(action.getMaintenanceWindowSchedule());
+            maintenanceWindow.setDuration(action.getMaintenanceWindowDuration());
+            maintenanceWindow.setTimezone(action.getMaintenanceWindowTimeZone());
+            action.getMaintenanceWindowStartTime()
+                    .ifPresent(nextStart -> maintenanceWindow.setNextStartAt(nextStart.toInstant().toEpochMilli()));
+            result.setMaintenanceWindow(maintenanceWindow);
+        }
+
+        MgmtRestModelMapper.mapBaseToBase(result, action);
+
+        result.add(linkTo(methodOn(MgmtTargetRestApi.class).getAction(targetId, action.getId())).withSelfRel());
+
+        return result;
+    }
+
+    static MgmtAction toResponseWithLinks(final String controllerId, final Action action) {
+        final MgmtAction result = toResponse(controllerId, action);
+
+        if (action.isCancelingOrCanceled()) {
+            result.add(linkTo(methodOn(MgmtTargetRestApi.class).getAction(controllerId, action.getId()))
+                    .withRel(MgmtRestConstants.TARGET_V1_CANCELED_ACTION));
+        } else {
+            result.add(linkTo(
+                    methodOn(MgmtDistributionSetRestApi.class).getDistributionSet(action.getDistributionSet().getId()))
+                            .withRel("distributionset"));
+        }
+
+        result.add(linkTo(methodOn(MgmtTargetRestApi.class).getActionStatusList(controllerId, action.getId(), 0,
+                MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT_VALUE,
+                ActionStatusFields.ID.getFieldName() + ":" + SortDirection.DESC))
+                        .withRel(MgmtRestConstants.TARGET_V1_ACTION_STATUS));
+
+        return result;
+    }
+
+    static List<MgmtAction> toResponse(final String targetId, final Collection<Action> actions) {
+        if (actions == null) {
+            return Collections.emptyList();
+        }
+
+        return actions.stream().map(action -> toResponse(targetId, action)).collect(Collectors.toList());
+    }
+
+    private static String getType(final Action action) {
+        if (!action.isCancelingOrCanceled()) {
+            return MgmtAction.ACTION_UPDATE;
+        } else if (action.isCancelingOrCanceled()) {
+            return MgmtAction.ACTION_CANCEL;
+        }
+
+        return null;
+    }
+
+    private static MgmtActionStatus toResponse(final ActionStatus actionStatus, final List<String> messages) {
+        final MgmtActionStatus result = new MgmtActionStatus();
+
+        result.setMessages(messages);
+        result.setReportedAt(actionStatus.getCreatedAt());
+        result.setStatusId(actionStatus.getId());
+        result.setType(actionStatus.getStatus().name().toLowerCase());
+
+        return result;
+    }
+
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtTargetResource.java

@@ -0,0 +1,344 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import javax.validation.ValidationException;
+
+import org.eclipse.hawkbit.mgmt.json.model.MgmtMaintenanceWindowRequestBody;
+import org.eclipse.hawkbit.mgmt.json.model.PagedList;
+import org.eclipse.hawkbit.mgmt.json.model.action.MgmtAction;
+import org.eclipse.hawkbit.mgmt.json.model.action.MgmtActionRequestBodyPut;
+import org.eclipse.hawkbit.mgmt.json.model.action.MgmtActionStatus;
+import org.eclipse.hawkbit.mgmt.json.model.distributionset.MgmtActionType;
+import org.eclipse.hawkbit.mgmt.json.model.distributionset.MgmtDistributionSet;
+import org.eclipse.hawkbit.mgmt.json.model.distributionset.MgmtTargetAssignmentResponseBody;
+import org.eclipse.hawkbit.mgmt.json.model.target.MgmtDistributionSetAssignment;
+import org.eclipse.hawkbit.mgmt.json.model.target.MgmtTarget;
+import org.eclipse.hawkbit.mgmt.json.model.target.MgmtTargetAttributes;
+import org.eclipse.hawkbit.mgmt.json.model.target.MgmtTargetRequestBody;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtTargetRestApi;
+import org.eclipse.hawkbit.repository.DeploymentManagement;
+import org.eclipse.hawkbit.repository.EntityFactory;
+import org.eclipse.hawkbit.repository.MaintenanceScheduleHelper;
+import org.eclipse.hawkbit.repository.OffsetBasedPageRequest;
+import org.eclipse.hawkbit.repository.TargetManagement;
+import org.eclipse.hawkbit.repository.exception.EntityNotFoundException;
+import org.eclipse.hawkbit.repository.model.Action;
+import org.eclipse.hawkbit.repository.model.ActionStatus;
+import org.eclipse.hawkbit.repository.model.Target;
+import org.eclipse.hawkbit.repository.model.TargetWithActionType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Slice;
+import org.springframework.data.domain.Sort;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * REST Resource handling target CRUD operations.
+ */
+@RestController
+public class MgmtTargetResource implements MgmtTargetRestApi {
+    private static final Logger LOG = LoggerFactory.getLogger(MgmtTargetResource.class);
+
+    @Autowired
+    private TargetManagement targetManagement;
+
+    @Autowired
+    private DeploymentManagement deploymentManagement;
+
+    @Autowired
+    private EntityFactory entityFactory;
+
+    @Override
+    public ResponseEntity<MgmtTarget> getTarget(@PathVariable("controllerId") final String controllerId) {
+        final Target findTarget = findTargetWithExceptionIfNotFound(controllerId);
+        // to single response include poll status
+        final MgmtTarget response = MgmtTargetMapper.toResponse(findTarget);
+        MgmtTargetMapper.addPollStatus(findTarget, response);
+        MgmtTargetMapper.addTargetLinks(response);
+
+        return ResponseEntity.ok(response);
+    }
+
+    @Override
+    public ResponseEntity<PagedList<MgmtTarget>> getTargets(
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {
+
+        final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
+        final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
+        final Sort sorting = PagingUtility.sanitizeTargetSortParam(sortParam);
+
+        final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);
+        final Slice<Target> findTargetsAll;
+        final long countTargetsAll;
+        if (rsqlParam != null) {
+            final Page<Target> findTargetPage = this.targetManagement.findByRsql(pageable, rsqlParam);
+            countTargetsAll = findTargetPage.getTotalElements();
+            findTargetsAll = findTargetPage;
+        } else {
+            findTargetsAll = this.targetManagement.findAll(pageable);
+            countTargetsAll = this.targetManagement.count();
+        }
+
+        final List<MgmtTarget> rest = MgmtTargetMapper.toResponse(findTargetsAll.getContent());
+        return ResponseEntity.ok(new PagedList<>(rest, countTargetsAll));
+    }
+
+    @Override
+    public ResponseEntity<List<MgmtTarget>> createTargets(@RequestBody final List<MgmtTargetRequestBody> targets) {
+        LOG.debug("creating {} targets", targets.size());
+        final Collection<Target> createdTargets = this.targetManagement
+                .create(MgmtTargetMapper.fromRequest(entityFactory, targets));
+        LOG.debug("{} targets created, return status {}", targets.size(), HttpStatus.CREATED);
+        return new ResponseEntity<>(MgmtTargetMapper.toResponse(createdTargets), HttpStatus.CREATED);
+    }
+
+    @Override
+    public ResponseEntity<MgmtTarget> updateTarget(@PathVariable("controllerId") final String controllerId,
+            @RequestBody final MgmtTargetRequestBody targetRest) {
+
+        final Target updateTarget = this.targetManagement.update(entityFactory.target().update(controllerId)
+                .name(targetRest.getName()).description(targetRest.getDescription()).address(targetRest.getAddress())
+                .securityToken(targetRest.getSecurityToken()));
+
+        final MgmtTarget response = MgmtTargetMapper.toResponse(updateTarget);
+        MgmtTargetMapper.addPollStatus(updateTarget, response);
+        MgmtTargetMapper.addTargetLinks(response);
+
+        return ResponseEntity.ok(response);
+    }
+
+    @Override
+    public ResponseEntity<Void> deleteTarget(@PathVariable("controllerId") final String controllerId) {
+        this.targetManagement.deleteByControllerID(controllerId);
+        LOG.debug("{} target deleted, return status {}", controllerId, HttpStatus.OK);
+        return ResponseEntity.ok().build();
+    }
+
+    @Override
+    public ResponseEntity<MgmtTargetAttributes> getAttributes(@PathVariable("controllerId") final String controllerId) {
+        final Map<String, String> controllerAttributes = targetManagement.getControllerAttributes(controllerId);
+        if (controllerAttributes.isEmpty()) {
+            return ResponseEntity.noContent().build();
+        }
+
+        final MgmtTargetAttributes result = new MgmtTargetAttributes();
+        result.putAll(controllerAttributes);
+
+        return ResponseEntity.ok(result);
+    }
+
+    @Override
+    public ResponseEntity<PagedList<MgmtAction>> getActionHistory(
+            @PathVariable("controllerId") final String controllerId,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {
+
+        findTargetWithExceptionIfNotFound(controllerId);
+
+        final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
+        final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
+        final Sort sorting = PagingUtility.sanitizeActionSortParam(sortParam);
+        final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);
+
+        final Slice<Action> activeActions;
+        final Long totalActionCount;
+        if (rsqlParam != null) {
+            activeActions = this.deploymentManagement.findActionsByTarget(rsqlParam, controllerId, pageable);
+            totalActionCount = this.deploymentManagement.countActionsByTarget(rsqlParam, controllerId);
+        } else {
+            activeActions = this.deploymentManagement.findActionsByTarget(controllerId, pageable);
+            totalActionCount = this.deploymentManagement.countActionsByTarget(controllerId);
+        }
+
+        return ResponseEntity.ok(new PagedList<>(MgmtTargetMapper.toResponse(controllerId, activeActions.getContent()),
+                totalActionCount));
+    }
+
+    @Override
+    public ResponseEntity<MgmtAction> getAction(@PathVariable("controllerId") final String controllerId,
+            @PathVariable("actionId") final Long actionId) {
+
+        final Action action = deploymentManagement.findAction(actionId)
+                .orElseThrow(() -> new EntityNotFoundException(Action.class, actionId));
+        if (!action.getTarget().getControllerId().equals(controllerId)) {
+            LOG.warn("given action ({}) is not assigned to given target ({}).", action.getId(), controllerId);
+            return ResponseEntity.notFound().build();
+        }
+
+        return ResponseEntity.ok(MgmtTargetMapper.toResponseWithLinks(controllerId, action));
+    }
+
+    @Override
+    public ResponseEntity<Void> cancelAction(@PathVariable("controllerId") final String controllerId,
+            @PathVariable("actionId") final Long actionId,
+            @RequestParam(value = "force", required = false, defaultValue = "false") final boolean force) {
+        final Action action = deploymentManagement.findAction(actionId)
+                .orElseThrow(() -> new EntityNotFoundException(Action.class, actionId));
+
+        if (!action.getTarget().getControllerId().equals(controllerId)) {
+            LOG.warn("given action ({}) is not assigned to given target ({}).", actionId, controllerId);
+            return ResponseEntity.notFound().build();
+        }
+
+        if (force) {
+            this.deploymentManagement.forceQuitAction(actionId);
+        } else {
+            this.deploymentManagement.cancelAction(actionId);
+        }
+        // both functions will throw an exception, when action is in wrong
+        // state, which is mapped by MgmtResponseExceptionHandler.
+
+        return ResponseEntity.noContent().build();
+    }
+
+    @Override
+    public ResponseEntity<PagedList<MgmtActionStatus>> getActionStatusList(
+            @PathVariable("controllerId") final String controllerId, @PathVariable("actionId") final Long actionId,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam) {
+
+        final Target target = findTargetWithExceptionIfNotFound(controllerId);
+
+        final Action action = deploymentManagement.findAction(actionId)
+                .orElseThrow(() -> new EntityNotFoundException(Action.class, actionId));
+
+        if (!action.getTarget().getId().equals(target.getId())) {
+            LOG.warn("given action ({}) is not assigned to given target ({}).", action.getId(), target.getId());
+            return ResponseEntity.notFound().build();
+        }
+
+        final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
+        final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
+        final Sort sorting = PagingUtility.sanitizeActionStatusSortParam(sortParam);
+
+        final Page<ActionStatus> statusList = this.deploymentManagement.findActionStatusByAction(
+                new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting), action.getId());
+
+        return ResponseEntity.ok(new PagedList<>(
+                MgmtTargetMapper.toActionStatusRestResponse(statusList.getContent(), deploymentManagement),
+                statusList.getTotalElements()));
+
+    }
+
+    @Override
+    public ResponseEntity<MgmtDistributionSet> getAssignedDistributionSet(
+            @PathVariable("controllerId") final String controllerId) {
+        final MgmtDistributionSet distributionSetRest = deploymentManagement.getAssignedDistributionSet(controllerId)
+                .map(ds -> {
+                    final MgmtDistributionSet response = MgmtDistributionSetMapper.toResponse(ds);
+                    MgmtDistributionSetMapper.addLinks(ds, response);
+
+                    return response;
+                }).orElse(null);
+
+        if (distributionSetRest == null) {
+            return ResponseEntity.noContent().build();
+        }
+        return ResponseEntity.ok(distributionSetRest);
+    }
+
+    @Override
+    public ResponseEntity<MgmtTargetAssignmentResponseBody> postAssignedDistributionSet(
+            @PathVariable("controllerId") final String controllerId,
+            @RequestBody final MgmtDistributionSetAssignment dsId,
+            @RequestParam(value = "offline", required = false) final boolean offline) {
+
+        if (offline) {
+            return ResponseEntity.ok(MgmtDistributionSetMapper.toResponse(
+                    deploymentManagement.offlineAssignedDistributionSet(dsId.getId(), Arrays.asList(controllerId))));
+        }
+
+        findTargetWithExceptionIfNotFound(controllerId);
+        final MgmtMaintenanceWindowRequestBody maintenanceWindow = dsId.getMaintenanceWindow();
+
+        if (maintenanceWindow == null) {
+            return ResponseEntity.ok(MgmtDistributionSetMapper.toResponse(this.deploymentManagement
+                    .assignDistributionSet(dsId.getId(), Arrays.asList(new TargetWithActionType(controllerId,
+                            MgmtRestModelMapper.convertActionType(dsId.getType()), dsId.getForcetime())))));
+        }
+
+        final String cronSchedule = maintenanceWindow.getSchedule();
+        final String duration = maintenanceWindow.getDuration();
+        final String timezone = maintenanceWindow.getTimezone();
+
+        MaintenanceScheduleHelper.validateMaintenanceSchedule(cronSchedule, duration, timezone);
+
+        return ResponseEntity
+                .ok(MgmtDistributionSetMapper.toResponse(this.deploymentManagement.assignDistributionSet(dsId.getId(),
+                        Arrays.asList(new TargetWithActionType(controllerId,
+                                MgmtRestModelMapper.convertActionType(dsId.getType()), dsId.getForcetime(),
+                                cronSchedule, duration, timezone)))));
+
+    }
+
+    @Override
+    public ResponseEntity<MgmtDistributionSet> getInstalledDistributionSet(
+            @PathVariable("controllerId") final String controllerId) {
+        final MgmtDistributionSet distributionSetRest = deploymentManagement.getInstalledDistributionSet(controllerId)
+                .map(set -> {
+                    final MgmtDistributionSet response = MgmtDistributionSetMapper.toResponse(set);
+                    MgmtDistributionSetMapper.addLinks(set, response);
+
+                    return response;
+                }).orElse(null);
+
+        if (distributionSetRest == null) {
+            return ResponseEntity.noContent().build();
+        }
+
+        return ResponseEntity.ok(distributionSetRest);
+    }
+
+    private Target findTargetWithExceptionIfNotFound(final String controllerId) {
+        return targetManagement.getByControllerID(controllerId)
+                .orElseThrow(() -> new EntityNotFoundException(Target.class, controllerId));
+    }
+
+    @Override
+    public ResponseEntity<MgmtAction> updateAction(@PathVariable("controllerId") final String controllerId,
+            @PathVariable("actionId") final Long actionId, @RequestBody final MgmtActionRequestBodyPut actionUpdate) {
+
+        Action action = deploymentManagement.findAction(actionId)
+                .orElseThrow(() -> new EntityNotFoundException(Action.class, actionId));
+        if (!action.getTarget().getControllerId().equals(controllerId)) {
+            LOG.warn("given action ({}) is not assigned to given target ({}).", action.getId(), controllerId);
+            return ResponseEntity.notFound().build();
+        }
+
+        if (!MgmtActionType.FORCED.equals(actionUpdate.getForceType())) {
+            throw new ValidationException("Resource supports only switch to FORCED.");
+        }
+
+        action = deploymentManagement.forceTargetAction(actionId);
+
+        return ResponseEntity.ok(MgmtTargetMapper.toResponseWithLinks(controllerId, action));
+    }
+
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtTargetTagResource.java

@@ -0,0 +1,227 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.eclipse.hawkbit.mgmt.json.model.PagedList;
+import org.eclipse.hawkbit.mgmt.json.model.tag.MgmtAssignedTargetRequestBody;
+import org.eclipse.hawkbit.mgmt.json.model.tag.MgmtTag;
+import org.eclipse.hawkbit.mgmt.json.model.tag.MgmtTagRequestBodyPut;
+import org.eclipse.hawkbit.mgmt.json.model.tag.MgmtTargetTagAssigmentResult;
+import org.eclipse.hawkbit.mgmt.json.model.target.MgmtTarget;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtTargetTagRestApi;
+import org.eclipse.hawkbit.repository.EntityFactory;
+import org.eclipse.hawkbit.repository.OffsetBasedPageRequest;
+import org.eclipse.hawkbit.repository.TargetManagement;
+import org.eclipse.hawkbit.repository.TargetTagManagement;
+import org.eclipse.hawkbit.repository.exception.EntityNotFoundException;
+import org.eclipse.hawkbit.repository.model.Target;
+import org.eclipse.hawkbit.repository.model.TargetTag;
+import org.eclipse.hawkbit.repository.model.TargetTagAssignmentResult;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * REST Resource handling for tag CRUD operations.
+ *
+ */
+@RestController
+public class MgmtTargetTagResource implements MgmtTargetTagRestApi {
+    private static final Logger LOG = LoggerFactory.getLogger(MgmtTargetTagResource.class);
+
+    @Autowired
+    private TargetTagManagement tagManagement;
+
+    @Autowired
+    private TargetManagement targetManagement;
+
+    @Autowired
+    private EntityFactory entityFactory;
+
+    @Override
+    public ResponseEntity<PagedList<MgmtTag>> getTargetTags(
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {
+
+        final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
+        final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
+        final Sort sorting = PagingUtility.sanitizeTagSortParam(sortParam);
+
+        final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);
+        Page<TargetTag> findTargetsAll;
+        if (rsqlParam == null) {
+            findTargetsAll = this.tagManagement.findAll(pageable);
+
+        } else {
+            findTargetsAll = this.tagManagement.findByRsql(pageable, rsqlParam);
+        }
+
+        final List<MgmtTag> rest = MgmtTagMapper.toResponse(findTargetsAll.getContent());
+        return ResponseEntity.ok(new PagedList<>(rest, findTargetsAll.getTotalElements()));
+    }
+
+    @Override
+    public ResponseEntity<MgmtTag> getTargetTag(@PathVariable("targetTagId") final Long targetTagId) {
+        final TargetTag tag = findTargetTagById(targetTagId);
+
+        final MgmtTag response = MgmtTagMapper.toResponse(tag);
+        MgmtTagMapper.addLinks(tag, response);
+
+        return ResponseEntity.ok(response);
+    }
+
+    @Override
+    public ResponseEntity<List<MgmtTag>> createTargetTags(@RequestBody final List<MgmtTagRequestBodyPut> tags) {
+        LOG.debug("creating {} target tags", tags.size());
+        final List<TargetTag> createdTargetTags = this.tagManagement
+                .create(MgmtTagMapper.mapTagFromRequest(entityFactory, tags));
+        return new ResponseEntity<>(MgmtTagMapper.toResponse(createdTargetTags), HttpStatus.CREATED);
+    }
+
+    @Override
+    public ResponseEntity<MgmtTag> updateTargetTag(@PathVariable("targetTagId") final Long targetTagId,
+            @RequestBody final MgmtTagRequestBodyPut restTargetTagRest) {
+        LOG.debug("update {} target tag", restTargetTagRest);
+
+        final TargetTag updateTargetTag = tagManagement
+                .update(entityFactory.tag().update(targetTagId).name(restTargetTagRest.getName())
+                        .description(restTargetTagRest.getDescription()).colour(restTargetTagRest.getColour()));
+
+        LOG.debug("target tag updated");
+
+        final MgmtTag response = MgmtTagMapper.toResponse(updateTargetTag);
+        MgmtTagMapper.addLinks(updateTargetTag, response);
+
+        return ResponseEntity.ok(response);
+    }
+
+    @Override
+    public ResponseEntity<Void> deleteTargetTag(@PathVariable("targetTagId") final Long targetTagId) {
+        LOG.debug("Delete {} target tag", targetTagId);
+        final TargetTag targetTag = findTargetTagById(targetTagId);
+
+        this.tagManagement.delete(targetTag.getName());
+
+        return ResponseEntity.ok().build();
+    }
+
+    @Override
+    public ResponseEntity<List<MgmtTarget>> getAssignedTargets(@PathVariable("targetTagId") final Long targetTagId) {
+
+        return ResponseEntity.ok(MgmtTargetMapper.toResponse(targetManagement
+                .findByTag(new PageRequest(0, MgmtRestConstants.REQUEST_PARAMETER_PAGING_MAX_LIMIT), targetTagId)
+                .getContent()));
+    }
+
+    @Override
+    public ResponseEntity<PagedList<MgmtTarget>> getAssignedTargets(@PathVariable("targetTagId") final Long targetTagId,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
+            @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {
+
+        final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
+        final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
+        final Sort sorting = PagingUtility.sanitizeTargetSortParam(sortParam);
+
+        final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);
+        Page<Target> findTargetsAll;
+        if (rsqlParam == null) {
+            findTargetsAll = targetManagement.findByTag(pageable, targetTagId);
+
+        } else {
+            findTargetsAll = targetManagement.findByRsqlAndTag(pageable, rsqlParam, targetTagId);
+        }
+
+        final Long countTargetsAll = findTargetsAll.getTotalElements();
+
+        final List<MgmtTarget> rest = MgmtTargetMapper.toResponse(findTargetsAll.getContent());
+        return ResponseEntity.ok(new PagedList<>(rest, countTargetsAll));
+    }
+
+    @Override
+    public ResponseEntity<MgmtTargetTagAssigmentResult> toggleTagAssignment(
+            @PathVariable("targetTagId") final Long targetTagId,
+            @RequestBody final List<MgmtAssignedTargetRequestBody> assignedTargetRequestBodies) {
+        LOG.debug("Toggle Target assignment {} for target tag {}", assignedTargetRequestBodies.size(), targetTagId);
+
+        final TargetTag targetTag = findTargetTagById(targetTagId);
+        final TargetTagAssignmentResult assigmentResult = this.targetManagement
+                .toggleTagAssignment(findTargetControllerIds(assignedTargetRequestBodies), targetTag.getName());
+
+        final MgmtTargetTagAssigmentResult tagAssigmentResultRest = new MgmtTargetTagAssigmentResult();
+        tagAssigmentResultRest.setAssignedTargets(MgmtTargetMapper.toResponse(assigmentResult.getAssignedEntity()));
+        tagAssigmentResultRest.setUnassignedTargets(MgmtTargetMapper.toResponse(assigmentResult.getUnassignedEntity()));
+        return ResponseEntity.ok(tagAssigmentResultRest);
+    }
+
+    @Override
+    public ResponseEntity<List<MgmtTarget>> assignTargets(@PathVariable("targetTagId") final Long targetTagId,
+            @RequestBody final List<MgmtAssignedTargetRequestBody> assignedTargetRequestBodies) {
+        LOG.debug("Assign Targets {} for target tag {}", assignedTargetRequestBodies.size(), targetTagId);
+        final List<Target> assignedTarget = this.targetManagement
+                .assignTag(findTargetControllerIds(assignedTargetRequestBodies), targetTagId);
+        return ResponseEntity.ok(MgmtTargetMapper.toResponse(assignedTarget));
+    }
+
+    @Override
+    public ResponseEntity<Void> unassignTarget(@PathVariable("targetTagId") final Long targetTagId,
+            @PathVariable("controllerId") final String controllerId) {
+        LOG.debug("Unassign target {} for target tag {}", controllerId, targetTagId);
+        this.targetManagement.unAssignTag(controllerId, targetTagId);
+        return ResponseEntity.ok().build();
+    }
+
+    private TargetTag findTargetTagById(final Long targetTagId) {
+        return tagManagement.get(targetTagId)
+                .orElseThrow(() -> new EntityNotFoundException(TargetTag.class, targetTagId));
+    }
+
+    private List<String> findTargetControllerIds(
+            final List<MgmtAssignedTargetRequestBody> assignedTargetRequestBodies) {
+        return assignedTargetRequestBodies.stream().map(MgmtAssignedTargetRequestBody::getControllerId)
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public ResponseEntity<MgmtTargetTagAssigmentResult> toggleTagAssignmentUnpaged(
+            @PathVariable("targetTagId") final Long targetTagId,
+            @RequestBody final List<MgmtAssignedTargetRequestBody> assignedTargetRequestBodies) {
+        return toggleTagAssignment(targetTagId, assignedTargetRequestBodies);
+    }
+
+    @Override
+    public ResponseEntity<List<MgmtTarget>> assignTargetsUnpaged(@PathVariable("targetTagId") final Long targetTagId,
+            @RequestBody final List<MgmtAssignedTargetRequestBody> assignedTargetRequestBodies) {
+        return assignTargets(targetTagId, assignedTargetRequestBodies);
+    }
+
+    @Override
+    public ResponseEntity<Void> unassignTargetUnpaged(@PathVariable("targetTagId") final Long targetTagId,
+            @PathVariable("controllerId") final String controllerId) {
+        return unassignTarget(targetTagId, controllerId);
+    }
+
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtTenantManagementMapper.java

@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import static org.springframework.hateoas.mvc.ControllerLinkBuilder.linkTo;
+import static org.springframework.hateoas.mvc.ControllerLinkBuilder.methodOn;
+
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import org.eclipse.hawkbit.mgmt.json.model.system.MgmtSystemTenantConfigurationValue;
+import org.eclipse.hawkbit.repository.TenantConfigurationManagement;
+import org.eclipse.hawkbit.repository.model.TenantConfigurationValue;
+import org.eclipse.hawkbit.tenancy.configuration.TenantConfigurationProperties;
+import org.eclipse.hawkbit.tenancy.configuration.TenantConfigurationProperties.TenantConfigurationKey;
+
+/**
+ * A mapper which maps repository model to RESTful model representation and
+ * back.
+ */
+public final class MgmtTenantManagementMapper {
+
+    private MgmtTenantManagementMapper() {
+        // Utility class
+    }
+
+    static Map<String, MgmtSystemTenantConfigurationValue> toResponse(
+            final TenantConfigurationManagement tenantConfigurationManagement,
+            final TenantConfigurationProperties tenantConfigurationProperties) {
+
+        return tenantConfigurationProperties.getConfigurationKeys().stream()
+                .collect(Collectors.toMap(TenantConfigurationKey::getKeyName, key -> toResponse(key.getKeyName(),
+                        tenantConfigurationManagement.getConfigurationValue(key.getKeyName()))));
+    }
+
+    static MgmtSystemTenantConfigurationValue toResponse(final String key,
+            final TenantConfigurationValue<?> repoConfValue) {
+        final MgmtSystemTenantConfigurationValue restConfValue = new MgmtSystemTenantConfigurationValue();
+
+        restConfValue.setValue(repoConfValue.getValue());
+        restConfValue.setGlobal(repoConfValue.isGlobal());
+        restConfValue.setCreatedAt(repoConfValue.getCreatedAt());
+        restConfValue.setCreatedBy(repoConfValue.getCreatedBy());
+        restConfValue.setLastModifiedAt(repoConfValue.getLastModifiedAt());
+        restConfValue.setLastModifiedBy(repoConfValue.getLastModifiedBy());
+
+        restConfValue.add(
+                linkTo(methodOn(MgmtTenantManagementResource.class).getTenantConfigurationValue(key)).withSelfRel());
+
+        return restConfValue;
+    }
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtTenantManagementResource.java

@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import java.io.Serializable;
+import java.util.Map;
+
+import org.eclipse.hawkbit.mgmt.json.model.system.MgmtSystemTenantConfigurationValue;
+import org.eclipse.hawkbit.mgmt.json.model.system.MgmtSystemTenantConfigurationValueRequest;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtTenantManagementRestApi;
+import org.eclipse.hawkbit.repository.TenantConfigurationManagement;
+import org.eclipse.hawkbit.repository.model.TenantConfigurationValue;
+import org.eclipse.hawkbit.tenancy.configuration.TenantConfigurationProperties;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * REST Resource for handling tenant specific configuration operations.
+ */
+@RestController
+public class MgmtTenantManagementResource implements MgmtTenantManagementRestApi {
+
+    private static final Logger LOG = LoggerFactory.getLogger(MgmtTenantManagementResource.class);
+
+    private final TenantConfigurationManagement tenantConfigurationManagement;
+    private final TenantConfigurationProperties tenantConfigurationProperties;
+
+    @Autowired
+    MgmtTenantManagementResource(final TenantConfigurationManagement tenantConfigurationManagement,
+            final TenantConfigurationProperties tenantConfigurationProperties) {
+        this.tenantConfigurationManagement = tenantConfigurationManagement;
+        this.tenantConfigurationProperties = tenantConfigurationProperties;
+    }
+
+    @Override
+    public ResponseEntity<Map<String, MgmtSystemTenantConfigurationValue>> getTenantConfiguration() {
+        return ResponseEntity.ok(
+                MgmtTenantManagementMapper.toResponse(tenantConfigurationManagement, tenantConfigurationProperties));
+    }
+
+    @Override
+    public ResponseEntity<Void> deleteTenantConfigurationValue(@PathVariable("keyName") final String keyName) {
+
+        tenantConfigurationManagement.deleteConfiguration(keyName);
+
+        LOG.debug("{} config value deleted, return status {}", keyName, HttpStatus.OK);
+        return ResponseEntity.ok().build();
+    }
+
+    @Override
+    public ResponseEntity<MgmtSystemTenantConfigurationValue> getTenantConfigurationValue(
+            @PathVariable("keyName") final String keyName) {
+
+        LOG.debug("{} config value getted, return status {}", keyName, HttpStatus.OK);
+        return ResponseEntity.ok(MgmtTenantManagementMapper.toResponse(keyName,
+                tenantConfigurationManagement.getConfigurationValue(keyName)));
+    }
+
+    @Override
+    public ResponseEntity<MgmtSystemTenantConfigurationValue> updateTenantConfigurationValue(
+            @PathVariable("keyName") final String keyName,
+            @RequestBody final MgmtSystemTenantConfigurationValueRequest configurationValueRest) {
+
+        final TenantConfigurationValue<? extends Serializable> updatedValue = tenantConfigurationManagement
+                .addOrUpdateConfiguration(keyName, configurationValueRest.getValue());
+        return ResponseEntity.ok(MgmtTenantManagementMapper.toResponse(keyName, updatedValue));
+    }
+
+}

hawkbit-rest/hawkbit-mgmt-resource/src/main/java/org/eclipse/hawkbit/mgmt/rest/resource/PagingUtility.java

@@ -0,0 +1,161 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.repository.ActionFields;
+import org.eclipse.hawkbit.repository.ActionStatusFields;
+import org.eclipse.hawkbit.repository.DistributionSetFields;
+import org.eclipse.hawkbit.repository.DistributionSetMetadataFields;
+import org.eclipse.hawkbit.repository.DistributionSetTypeFields;
+import org.eclipse.hawkbit.repository.RolloutFields;
+import org.eclipse.hawkbit.repository.RolloutGroupFields;
+import org.eclipse.hawkbit.repository.SoftwareModuleFields;
+import org.eclipse.hawkbit.repository.SoftwareModuleMetadataFields;
+import org.eclipse.hawkbit.repository.SoftwareModuleTypeFields;
+import org.eclipse.hawkbit.repository.TagFields;
+import org.eclipse.hawkbit.repository.TargetFields;
+import org.eclipse.hawkbit.repository.TargetFilterQueryFields;
+import org.eclipse.hawkbit.rest.util.SortUtility;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.domain.Sort.Direction;
+
+/**
+ * Utility class for for paged body generation.
+ *
+ */
+public final class PagingUtility {
+    /*
+     * utility constructor private.
+     */
+    private PagingUtility() {
+    }
+
+    static int sanitizeOffsetParam(final int offset) {
+        if (offset < 0) {
+            return MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET_VALUE;
+        }
+        return offset;
+    }
+
+    static int sanitizePageLimitParam(final int pageLimit) {
+        if (pageLimit < 1) {
+            return MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT_VALUE;
+        } else if (pageLimit > MgmtRestConstants.REQUEST_PARAMETER_PAGING_MAX_LIMIT) {
+            return MgmtRestConstants.REQUEST_PARAMETER_PAGING_MAX_LIMIT;
+        }
+        return pageLimit;
+    }
+
+    static Sort sanitizeTargetSortParam(final String sortParam) {
+        if (sortParam == null) {
+            // default
+            return new Sort(Direction.ASC, TargetFields.CONTROLLERID.getFieldName());
+        }
+        return new Sort(SortUtility.parse(TargetFields.class, sortParam));
+    }
+
+    static Sort sanitizeTagSortParam(final String sortParam) {
+        if (sortParam == null) {
+            // default
+            return new Sort(Direction.ASC, TagFields.ID.getFieldName());
+        }
+        return new Sort(SortUtility.parse(TagFields.class, sortParam));
+    }
+
+    static Sort sanitizeTargetFilterQuerySortParam(final String sortParam) {
+        if (sortParam == null) {
+            // default
+            return new Sort(Direction.ASC, TargetFilterQueryFields.ID.getFieldName());
+        }
+        return new Sort(SortUtility.parse(TargetFilterQueryFields.class, sortParam));
+    }
+
+    static Sort sanitizeSoftwareModuleSortParam(final String sortParam) {
+        if (sortParam == null) {
+            // default
+            return new Sort(Direction.ASC, SoftwareModuleFields.ID.getFieldName());
+        }
+        return new Sort(SortUtility.parse(SoftwareModuleFields.class, sortParam));
+    }
+
+    static Sort sanitizeSoftwareModuleTypeSortParam(final String sortParam) {
+        if (sortParam == null) {
+            // default
+            return new Sort(Direction.ASC, SoftwareModuleTypeFields.ID.getFieldName());
+        }
+        return new Sort(SortUtility.parse(SoftwareModuleTypeFields.class, sortParam));
+    }
+
+    static Sort sanitizeDistributionSetSortParam(final String sortParam) {
+        if (sortParam == null) {
+            // default
+            return new Sort(Direction.ASC, DistributionSetFields.ID.getFieldName());
+        }
+        return new Sort(SortUtility.parse(DistributionSetFields.class, sortParam));
+    }
+
+    static Sort sanitizeDistributionSetTypeSortParam(final String sortParam) {
+        if (sortParam == null) {
+            // default
+            return new Sort(Direction.ASC, DistributionSetTypeFields.ID.getFieldName());
+        }
+        return new Sort(SortUtility.parse(DistributionSetTypeFields.class, sortParam));
+    }
+
+    static Sort sanitizeActionSortParam(final String sortParam) {
+        if (sortParam == null) {
+            // default sort is DESC in case of action to match behavior
+            // of management UI (last entry on top)
+            return new Sort(Direction.DESC, ActionFields.ID.getFieldName());
+        }
+        return new Sort(SortUtility.parse(ActionFields.class, sortParam));
+    }
+
+    static Sort sanitizeActionStatusSortParam(final String sortParam) {
+        if (sortParam == null) {
+            // default sort is DESC in case of action status to match behavior
+            // of management UI (last entry on top)
+            return new Sort(Direction.DESC, ActionStatusFields.ID.getFieldName());
+        }
+        return new Sort(SortUtility.parse(ActionStatusFields.class, sortParam));
+    }
+
+    static Sort sanitizeDistributionSetMetadataSortParam(final String sortParam) {
+        if (sortParam == null) {
+            // default
+            return new Sort(Direction.ASC, DistributionSetMetadataFields.KEY.getFieldName());
+        }
+        return new Sort(SortUtility.parse(DistributionSetMetadataFields.class, sortParam));
+    }
+
+    static Sort sanitizeSoftwareModuleMetadataSortParam(final String sortParam) {
+        if (sortParam == null) {
+            // default
+            return new Sort(Direction.ASC, SoftwareModuleMetadataFields.KEY.getFieldName());
+        }
+        return new Sort(SortUtility.parse(SoftwareModuleMetadataFields.class, sortParam));
+    }
+
+    static Sort sanitizeRolloutSortParam(final String sortParam) {
+        if (sortParam == null) {
+            // default
+            return new Sort(Direction.ASC, RolloutFields.ID.getFieldName());
+        }
+        return new Sort(SortUtility.parse(RolloutFields.class, sortParam));
+    }
+
+    static Sort sanitizeRolloutGroupSortParam(final String sortParam) {
+        if (sortParam == null) {
+            // default
+            return new Sort(Direction.ASC, RolloutGroupFields.ID.getFieldName());
+        }
+        return new Sort(SortUtility.parse(RolloutGroupFields.class, sortParam));
+    }
+}

hawkbit-rest/hawkbit-mgmt-resource/src/test/java/org/eclipse/hawkbit/mgmt/rest/resource/AbstractManagementApiIntegrationTest.java

@@ -0,0 +1,193 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.Matchers.equalTo;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+
+import org.eclipse.hawkbit.repository.model.BaseEntity;
+import org.eclipse.hawkbit.repository.model.NamedEntity;
+import org.eclipse.hawkbit.repository.model.NamedVersionedEntity;
+import org.eclipse.hawkbit.repository.model.Tag;
+import org.eclipse.hawkbit.repository.model.Target;
+import org.eclipse.hawkbit.rest.AbstractRestIntegrationTest;
+import org.springframework.boot.test.SpringApplicationConfiguration;
+import org.springframework.test.web.servlet.ResultMatcher;
+
+@SpringApplicationConfiguration(classes = { MgmtApiConfiguration.class })
+public abstract class AbstractManagementApiIntegrationTest extends AbstractRestIntegrationTest {
+
+    protected static ResultMatcher applyBaseEntityMatcherOnArrayResult(final BaseEntity entity,
+            final String arrayElement) throws Exception {
+        return mvcResult -> {
+            jsonPath("$." + arrayElement + ".[?(@.id==" + entity.getId() + ")].createdBy",
+                    contains(entity.getCreatedBy())).match(mvcResult);
+            jsonPath("$." + arrayElement + ".[?(@.id==" + entity.getId() + ")].createdAt",
+                    contains(entity.getCreatedAt())).match(mvcResult);
+            jsonPath("$." + arrayElement + ".[?(@.id==" + entity.getId() + ")].lastModifiedBy",
+                    contains(entity.getLastModifiedBy())).match(mvcResult);
+            jsonPath("$." + arrayElement + ".[?(@.id==" + entity.getId() + ")].lastModifiedAt",
+                    contains(entity.getLastModifiedAt())).match(mvcResult);
+        };
+    }
+
+    protected static ResultMatcher applyTargetEntityMatcherOnArrayResult(final Target entity, final String arrayElement)
+            throws Exception {
+        return mvcResult -> {
+            jsonPath("$." + arrayElement + ".[?(@.controllerId==" + entity.getControllerId() + ")].createdBy",
+                    contains(entity.getCreatedBy())).match(mvcResult);
+            jsonPath("$." + arrayElement + ".[?(@.controllerId==" + entity.getControllerId() + ")].createdAt",
+                    contains(entity.getCreatedAt())).match(mvcResult);
+            jsonPath("$." + arrayElement + ".[?(@.controllerId==" + entity.getControllerId() + ")].lastModifiedBy",
+                    contains(entity.getLastModifiedBy())).match(mvcResult);
+            jsonPath("$." + arrayElement + ".[?(@.controllerId==" + entity.getControllerId() + ")].lastModifiedAt",
+                    contains(entity.getLastModifiedAt())).match(mvcResult);
+        };
+    }
+
+    protected static ResultMatcher applyBaseEntityMatcherOnPagedResult(final BaseEntity entity) throws Exception {
+        return applyBaseEntityMatcherOnArrayResult(entity, "content");
+    }
+
+    protected static ResultMatcher applyNamedEntityMatcherOnPagedResult(final NamedEntity entity) throws Exception {
+        return mvcResult -> {
+            applyBaseEntityMatcherOnPagedResult(entity).match(mvcResult);
+            jsonPath("$.content.[?(@.id==" + entity.getId() + ")].name", contains(entity.getName())).match(mvcResult);
+            jsonPath("$.content.[?(@.id==" + entity.getId() + ")].description", contains(entity.getDescription()))
+                    .match(mvcResult);
+        };
+
+    }
+
+    protected static ResultMatcher applyNamedVersionedEntityMatcherOnPagedResult(final NamedVersionedEntity entity)
+            throws Exception {
+        return mvcResult -> {
+            applyNamedEntityMatcherOnPagedResult(entity).match(mvcResult);
+            jsonPath("$.content.[?(@.id==" + entity.getId() + ")].version", contains(entity.getVersion()))
+                    .match(mvcResult);
+        };
+    }
+
+    protected static ResultMatcher applyTagMatcherOnPagedResult(final Tag entity) throws Exception {
+        return mvcResult -> {
+            applyNamedEntityMatcherOnPagedResult(entity).match(mvcResult);
+            jsonPath("$.content.[?(@.id==" + entity.getId() + ")].colour", contains(entity.getColour()))
+                    .match(mvcResult);
+        };
+    }
+
+    protected static ResultMatcher applySelfLinkMatcherOnPagedResult(final BaseEntity entity, final String link)
+            throws Exception {
+
+        return mvcResult -> {
+            jsonPath("$.content.[?(@.id==" + entity.getId() + ")]._links.self.href", contains(link)).match(mvcResult);
+        };
+    }
+
+    protected static ResultMatcher applyBaseEntityMatcherOnArrayResult(final BaseEntity entity) throws Exception {
+        return mvcResult -> {
+            jsonPath("$.[?(@.id==" + entity.getId() + ")].createdBy", contains(entity.getCreatedBy())).match(mvcResult);
+            jsonPath("$.[?(@.id==" + entity.getId() + ")].createdAt", contains(entity.getCreatedAt())).match(mvcResult);
+            jsonPath("$.[?(@.id==" + entity.getId() + ")].lastModifiedBy", contains(entity.getLastModifiedBy()))
+                    .match(mvcResult);
+            jsonPath("$.[?(@.id==" + entity.getId() + ")].lastModifiedAt", contains(entity.getLastModifiedAt()))
+                    .match(mvcResult);
+        };
+    }
+
+    protected static ResultMatcher applyTargetEntityMatcherOnArrayResult(final Target entity) throws Exception {
+        return mvcResult -> {
+            jsonPath("$.[?(@.controllerId==" + entity.getControllerId() + ")].createdBy",
+                    contains(entity.getCreatedBy())).match(mvcResult);
+            jsonPath("$.[?(@.controllerId==" + entity.getControllerId() + ")].createdAt",
+                    contains(entity.getCreatedAt())).match(mvcResult);
+            jsonPath("$.[?(@.controllerId==" + entity.getControllerId() + ")].lastModifiedBy",
+                    contains(entity.getLastModifiedBy())).match(mvcResult);
+            jsonPath("$.[?(@.controllerId==" + entity.getControllerId() + ")].lastModifiedAt",
+                    contains(entity.getLastModifiedAt())).match(mvcResult);
+        };
+    }
+
+    protected static ResultMatcher applyNamedEntityMatcherOnArrayResult(final NamedEntity entity) throws Exception {
+        return mvcResult -> {
+            applyBaseEntityMatcherOnPagedResult(entity);
+
+            jsonPath("$.[?(@.id==" + entity.getId() + ")].name", contains(entity.getName())).match(mvcResult);
+            jsonPath("$.[?(@.id==" + entity.getId() + ")].description", contains(entity.getDescription()))
+                    .match(mvcResult);
+        };
+    }
+
+    protected static ResultMatcher applyNamedVersionedEntityMatcherOnArrayResult(final NamedVersionedEntity entity)
+            throws Exception {
+        return mvcResult -> {
+            applyNamedEntityMatcherOnPagedResult(entity);
+
+            jsonPath("$.[?(@.id==" + entity.getId() + ")].version", contains(entity.getVersion())).match(mvcResult);
+        };
+    }
+
+    protected static ResultMatcher applyTagMatcherOnArrayResult(final Tag entity) throws Exception {
+        return mvcResult -> {
+            applyNamedEntityMatcherOnPagedResult(entity);
+
+            jsonPath("$.[?(@.id==" + entity.getId() + ")].colour", contains(entity.getColour())).match(mvcResult);
+        };
+    }
+
+    protected static ResultMatcher applySelfLinkMatcherOnArrayResult(final BaseEntity entity, final String link)
+            throws Exception {
+        return mvcResult -> {
+            jsonPath("$.[?(@.id==" + entity.getId() + ")]._links.self.href", contains(link)).match(mvcResult);
+        };
+    }
+
+    protected static ResultMatcher applyBaseEntityMatcherOnSingleResult(final BaseEntity entity) throws Exception {
+        return mvcResult -> {
+            jsonPath("createdBy", equalTo(entity.getCreatedBy())).match(mvcResult);
+            jsonPath("createdAt", equalTo(entity.getCreatedAt())).match(mvcResult);
+            jsonPath("lastModifiedBy", equalTo(entity.getLastModifiedBy())).match(mvcResult);
+            jsonPath("lastModifiedAt", equalTo(entity.getLastModifiedAt())).match(mvcResult);
+        };
+    }
+
+    protected static ResultMatcher applyNamedEntityMatcherOnSingleResult(final NamedEntity entity) throws Exception {
+        return mvcResult -> {
+            applyBaseEntityMatcherOnSingleResult(entity);
+
+            jsonPath("name", equalTo(entity.getName())).match(mvcResult);
+            jsonPath("description", equalTo(entity.getDescription())).match(mvcResult);
+        };
+    }
+
+    protected static ResultMatcher applyNamedVersionedEntityMatcherOnSingleResult(final NamedVersionedEntity entity)
+            throws Exception {
+        return mvcResult -> {
+            applyNamedEntityMatcherOnSingleResult(entity);
+
+            jsonPath("version", equalTo(entity.getVersion())).match(mvcResult);
+        };
+    }
+
+    protected static ResultMatcher applyTagMatcherOnSingleResult(final Tag entity) throws Exception {
+        return mvcResult -> {
+            applyNamedEntityMatcherOnSingleResult(entity);
+
+            jsonPath("colour", equalTo(entity.getColour())).match(mvcResult);
+        };
+    }
+
+    protected static ResultMatcher applySelfLinkMatcherOnSingleResult(final String link) throws Exception {
+        return mvcResult -> {
+            jsonPath("_links.self.href", equalTo(link)).match(mvcResult);
+        };
+    }
+
+}

hawkbit-rest/hawkbit-mgmt-resource/src/test/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtDistributionSetTagResourceTest.java

@@ -0,0 +1,317 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.Matchers.hasSize;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
+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.MockMvcResultMatchers.content;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.repository.event.remote.DistributionSetTagDeletedEvent;
+import org.eclipse.hawkbit.repository.event.remote.entity.DistributionSetCreatedEvent;
+import org.eclipse.hawkbit.repository.event.remote.entity.DistributionSetTagCreatedEvent;
+import org.eclipse.hawkbit.repository.event.remote.entity.DistributionSetTagUpdatedEvent;
+import org.eclipse.hawkbit.repository.event.remote.entity.DistributionSetUpdatedEvent;
+import org.eclipse.hawkbit.repository.model.BaseEntity;
+import org.eclipse.hawkbit.repository.model.DistributionSet;
+import org.eclipse.hawkbit.repository.model.DistributionSetTag;
+import org.eclipse.hawkbit.repository.model.Tag;
+import org.eclipse.hawkbit.repository.test.matcher.Expect;
+import org.eclipse.hawkbit.repository.test.matcher.ExpectEvents;
+import org.eclipse.hawkbit.rest.util.JsonBuilder;
+import org.eclipse.hawkbit.rest.util.MockMvcResultPrinter;
+import org.json.JSONException;
+import org.junit.Test;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.ResultActions;
+
+import ru.yandex.qatools.allure.annotations.Description;
+import ru.yandex.qatools.allure.annotations.Features;
+import ru.yandex.qatools.allure.annotations.Stories;
+
+@Features("Component Tests - Management API")
+@Stories("Distribution Set Tag Resource")
+public class MgmtDistributionSetTagResourceTest extends AbstractManagementApiIntegrationTest {
+
+    private static final String DISTRIBUTIONSETTAGS_ROOT = "http://localhost"
+            + MgmtRestConstants.DISTRIBUTIONSET_TAG_V1_REQUEST_MAPPING + "/";
+
+    @Test
+    @Description("Verfies that a paged result list of DS tags reflects the content on the repository side.")
+    @ExpectEvents({ @Expect(type = DistributionSetTagCreatedEvent.class, count = 2) })
+    public void getDistributionSetTags() throws Exception {
+        final List<DistributionSetTag> tags = testdataFactory.createDistributionSetTags(2);
+        final DistributionSetTag assigned = tags.get(0);
+        final DistributionSetTag unassigned = tags.get(1);
+
+        mvc.perform(get(MgmtRestConstants.DISTRIBUTIONSET_TAG_V1_REQUEST_MAPPING).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(applyBaseEntityMatcherOnPagedResult(assigned))
+                .andExpect(applyBaseEntityMatcherOnPagedResult(unassigned))
+                .andExpect(applySelfLinkMatcherOnPagedResult(assigned, DISTRIBUTIONSETTAGS_ROOT + assigned.getId()))
+                .andExpect(applySelfLinkMatcherOnPagedResult(unassigned, DISTRIBUTIONSETTAGS_ROOT + unassigned.getId()))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_TOTAL, equalTo(2)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_SIZE, equalTo(2)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_CONTENT, hasSize(2)));
+    }
+
+    @Test
+    @Description("Verfies that a single result of a DS tag reflects the content on the repository side.")
+    @ExpectEvents({ @Expect(type = DistributionSetTagCreatedEvent.class, count = 2) })
+    public void getDistributionSetTag() throws Exception {
+        final List<DistributionSetTag> tags = testdataFactory.createDistributionSetTags(2);
+        final DistributionSetTag assigned = tags.get(0);
+
+        mvc.perform(get(MgmtRestConstants.DISTRIBUTIONSET_TAG_V1_REQUEST_MAPPING + "/" + assigned.getId())
+                .accept(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(applyTagMatcherOnSingleResult(assigned))
+                .andExpect(applySelfLinkMatcherOnSingleResult(DISTRIBUTIONSETTAGS_ROOT + assigned.getId()))
+                .andExpect(jsonPath("_links.assignedDistributionSets.href",
+                        equalTo(DISTRIBUTIONSETTAGS_ROOT + assigned.getId() + "/assigned?offset=0&limit=50{&sort,q}")));
+    }
+
+    @Test
+    @Description("Verifies that created DS tags are stored in the repository as send to the API.")
+    @ExpectEvents({ @Expect(type = DistributionSetTagCreatedEvent.class, count = 2) })
+    public void createDistributionSetTags() throws JSONException, Exception {
+        final Tag tagOne = entityFactory.tag().create().colour("testcol1").description("its a test1").name("thetest1")
+                .build();
+        final Tag tagTwo = entityFactory.tag().create().colour("testcol2").description("its a test2").name("thetest2")
+                .build();
+
+        final ResultActions result = mvc
+                .perform(post(MgmtRestConstants.DISTRIBUTIONSET_TAG_V1_REQUEST_MAPPING)
+                        .content(JsonBuilder.tags(Arrays.asList(tagOne, tagTwo)))
+                        .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isCreated())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE));
+
+        final Tag createdOne = distributionSetTagManagement.findByRsql(PAGE, "name==thetest1").getContent().get(0);
+        assertThat(createdOne.getName()).isEqualTo(tagOne.getName());
+        assertThat(createdOne.getDescription()).isEqualTo(tagOne.getDescription());
+        assertThat(createdOne.getColour()).isEqualTo(tagOne.getColour());
+        final Tag createdTwo = distributionSetTagManagement.findByRsql(PAGE, "name==thetest2").getContent().get(0);
+        assertThat(createdTwo.getName()).isEqualTo(tagTwo.getName());
+        assertThat(createdTwo.getDescription()).isEqualTo(tagTwo.getDescription());
+        assertThat(createdTwo.getColour()).isEqualTo(tagTwo.getColour());
+
+        result.andExpect(applyTagMatcherOnArrayResult(createdOne)).andExpect(applyTagMatcherOnArrayResult(createdTwo));
+    }
+
+    @Test
+    @Description("Verifies that an updated DS tag is stored in the repository as send to the API.")
+    @ExpectEvents({ @Expect(type = DistributionSetTagCreatedEvent.class, count = 1),
+            @Expect(type = DistributionSetTagUpdatedEvent.class, count = 1) })
+    public void updateDistributionSetTag() throws Exception {
+        final List<DistributionSetTag> tags = testdataFactory.createDistributionSetTags(1);
+        final DistributionSetTag original = tags.get(0);
+
+        final Tag update = entityFactory.tag().create().name("updatedName").colour("updatedCol")
+                .description("updatedDesc").build();
+
+        final ResultActions result = mvc
+                .perform(put(MgmtRestConstants.DISTRIBUTIONSET_TAG_V1_REQUEST_MAPPING + "/" + original.getId())
+                        .content(JsonBuilder.tag(update)).contentType(MediaType.APPLICATION_JSON)
+                        .accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE));
+
+        final Tag updated = distributionSetTagManagement.findByRsql(PAGE, "name==updatedName").getContent().get(0);
+        assertThat(updated.getName()).isEqualTo(update.getName());
+        assertThat(updated.getDescription()).isEqualTo(update.getDescription());
+        assertThat(updated.getColour()).isEqualTo(update.getColour());
+
+        result.andExpect(applyTagMatcherOnArrayResult(updated)).andExpect(applyTagMatcherOnArrayResult(updated));
+    }
+
+    @Test
+    @Description("Verfies that the delete call is reflected by the repository.")
+    @ExpectEvents({ @Expect(type = DistributionSetTagCreatedEvent.class, count = 1),
+            @Expect(type = DistributionSetTagDeletedEvent.class, count = 1) })
+    public void deleteDistributionSetTag() throws Exception {
+        final List<DistributionSetTag> tags = testdataFactory.createDistributionSetTags(1);
+        final DistributionSetTag original = tags.get(0);
+
+        mvc.perform(delete(MgmtRestConstants.DISTRIBUTIONSET_TAG_V1_REQUEST_MAPPING + "/" + original.getId()))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk());
+
+        assertThat(distributionSetTagManagement.get(original.getId())).isNotPresent();
+    }
+
+    @Test
+    @Description("Ensures that assigned DS to tag in repository are listed with proper paging results.")
+    @ExpectEvents({ @Expect(type = DistributionSetTagCreatedEvent.class, count = 1),
+            @Expect(type = DistributionSetCreatedEvent.class, count = 5),
+            @Expect(type = DistributionSetUpdatedEvent.class, count = 5) })
+    public void getAssignedDistributionSets() throws Exception {
+        final DistributionSetTag tag = testdataFactory.createDistributionSetTags(1).get(0);
+        final int setsAssigned = 5;
+        final List<DistributionSet> sets = testdataFactory.createDistributionSetsWithoutModules(setsAssigned);
+        distributionSetManagement.toggleTagAssignment(sets.stream().map(BaseEntity::getId).collect(Collectors.toList()),
+                tag.getName());
+
+        mvc.perform(get(MgmtRestConstants.DISTRIBUTIONSET_TAG_V1_REQUEST_MAPPING + "/" + tag.getId() + "/assigned"))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_TOTAL, equalTo(setsAssigned)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_SIZE, equalTo(setsAssigned)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_CONTENT, hasSize(setsAssigned)));
+    }
+
+    @Test
+    @Description("Ensures that assigned DS to tag in repository are listed with proper paging results with paging limit parameter.")
+    @ExpectEvents({ @Expect(type = DistributionSetTagCreatedEvent.class, count = 1),
+            @Expect(type = DistributionSetCreatedEvent.class, count = 5),
+            @Expect(type = DistributionSetUpdatedEvent.class, count = 5) })
+    public void getAssignedDistributionSetsWithPagingLimitRequestParameter() throws Exception {
+        final DistributionSetTag tag = testdataFactory.createDistributionSetTags(1).get(0);
+        final int setsAssigned = 5;
+        final int limitSize = 1;
+        final List<DistributionSet> sets = testdataFactory.createDistributionSetsWithoutModules(setsAssigned);
+        distributionSetManagement.toggleTagAssignment(sets.stream().map(BaseEntity::getId).collect(Collectors.toList()),
+                tag.getName());
+
+        mvc.perform(get(MgmtRestConstants.DISTRIBUTIONSET_TAG_V1_REQUEST_MAPPING + "/" + tag.getId() + "/assigned")
+                .param(MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, String.valueOf(limitSize)))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_TOTAL, equalTo(setsAssigned)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_SIZE, equalTo(limitSize)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_CONTENT, hasSize(limitSize)));
+    }
+
+    @Test
+    @Description("Ensures that assigned DS to tag in repository are listed with proper paging results with paging limit and offset parameter.")
+    @ExpectEvents({ @Expect(type = DistributionSetTagCreatedEvent.class, count = 1),
+            @Expect(type = DistributionSetCreatedEvent.class, count = 5),
+            @Expect(type = DistributionSetUpdatedEvent.class, count = 5) })
+    public void getAssignedDistributionSetsWithPagingLimitAndOffsetRequestParameter() throws Exception {
+        final DistributionSetTag tag = testdataFactory.createDistributionSetTags(1).get(0);
+        final int setsAssigned = 5;
+        final int offsetParam = 2;
+        final int expectedSize = setsAssigned - offsetParam;
+
+        final List<DistributionSet> sets = testdataFactory.createDistributionSetsWithoutModules(setsAssigned);
+        distributionSetManagement.toggleTagAssignment(sets.stream().map(BaseEntity::getId).collect(Collectors.toList()),
+                tag.getName());
+
+        mvc.perform(get(MgmtRestConstants.DISTRIBUTIONSET_TAG_V1_REQUEST_MAPPING + "/" + tag.getId() + "/assigned")
+                .param(MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, String.valueOf(offsetParam))
+                .param(MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, String.valueOf(setsAssigned)))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_TOTAL, equalTo(setsAssigned)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_SIZE, equalTo(expectedSize)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_CONTENT, hasSize(expectedSize)));
+    }
+
+    @Test
+    @Description("Verfies that tag assignments done through toggle API command are correctly assigned or unassigned.")
+    @ExpectEvents({ @Expect(type = DistributionSetTagCreatedEvent.class, count = 1),
+            @Expect(type = DistributionSetCreatedEvent.class, count = 2),
+            @Expect(type = DistributionSetUpdatedEvent.class, count = 4) })
+    public void toggleTagAssignment() throws Exception {
+        final DistributionSetTag tag = testdataFactory.createDistributionSetTags(1).get(0);
+        final int setsAssigned = 2;
+        final List<DistributionSet> sets = testdataFactory.createDistributionSetsWithoutModules(setsAssigned);
+
+        // 2 DistributionSetUpdateEvent
+        ResultActions result = toggle(tag, sets);
+
+        List<DistributionSet> updated = distributionSetManagement.findByTag(PAGE, tag.getId()).getContent();
+
+        assertThat(updated.stream().map(DistributionSet::getId).collect(Collectors.toList()))
+                .containsAll(sets.stream().map(DistributionSet::getId).collect(Collectors.toList()));
+
+        result.andExpect(applyBaseEntityMatcherOnArrayResult(updated.get(0), "assignedDistributionSets"))
+                .andExpect(applyBaseEntityMatcherOnArrayResult(updated.get(1), "assignedDistributionSets"));
+
+        // 2 DistributionSetUpdateEvent
+        result = toggle(tag, sets);
+
+        updated = distributionSetManagement.findAll(PAGE).getContent();
+
+        result.andExpect(applyBaseEntityMatcherOnArrayResult(updated.get(0), "unassignedDistributionSets"))
+                .andExpect(applyBaseEntityMatcherOnArrayResult(updated.get(1), "unassignedDistributionSets"));
+
+        assertThat(distributionSetManagement.findByTag(PAGE, tag.getId())).isEmpty();
+    }
+
+    private ResultActions toggle(final DistributionSetTag tag, final List<DistributionSet> sets) throws Exception {
+        return mvc
+                .perform(post(MgmtRestConstants.DISTRIBUTIONSET_TAG_V1_REQUEST_MAPPING + "/" + tag.getId()
+                        + "/assigned/toggleTagAssignment").content(
+                                JsonBuilder.ids(sets.stream().map(DistributionSet::getId).collect(Collectors.toList())))
+                                .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE));
+    }
+
+    @Test
+    @Description("Verfies that tag assignments done through tag API command are correctly stored in the repository.")
+    @ExpectEvents({ @Expect(type = DistributionSetTagCreatedEvent.class, count = 1),
+            @Expect(type = DistributionSetCreatedEvent.class, count = 2),
+            @Expect(type = DistributionSetUpdatedEvent.class, count = 2) })
+    public void assignDistributionSets() throws Exception {
+        final DistributionSetTag tag = testdataFactory.createDistributionSetTags(1).get(0);
+        final int setsAssigned = 2;
+        final List<DistributionSet> sets = testdataFactory.createDistributionSetsWithoutModules(setsAssigned);
+
+        final ResultActions result = mvc
+                .perform(
+                        post(MgmtRestConstants.DISTRIBUTIONSET_TAG_V1_REQUEST_MAPPING + "/" + tag.getId() + "/assigned")
+                                .content(JsonBuilder
+                                        .ids(sets.stream().map(DistributionSet::getId).collect(Collectors.toList())))
+                                .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE));
+
+        final List<DistributionSet> updated = distributionSetManagement.findByTag(PAGE, tag.getId()).getContent();
+
+        assertThat(updated.stream().map(DistributionSet::getId).collect(Collectors.toList()))
+                .containsAll(sets.stream().map(DistributionSet::getId).collect(Collectors.toList()));
+
+        result.andExpect(applyBaseEntityMatcherOnArrayResult(updated.get(0)))
+                .andExpect(applyBaseEntityMatcherOnArrayResult(updated.get(1)));
+    }
+
+    @Test
+    @Description("Verfies that tag unassignments done through tag API command are correctly stored in the repository.")
+    @ExpectEvents({ @Expect(type = DistributionSetTagCreatedEvent.class, count = 1),
+            @Expect(type = DistributionSetCreatedEvent.class, count = 2),
+            @Expect(type = DistributionSetUpdatedEvent.class, count = 3) })
+    public void unassignDistributionSet() throws Exception {
+        final DistributionSetTag tag = testdataFactory.createDistributionSetTags(1).get(0);
+        final int setsAssigned = 2;
+        final List<DistributionSet> sets = testdataFactory.createDistributionSetsWithoutModules(setsAssigned);
+        final DistributionSet assigned = sets.get(0);
+        final DistributionSet unassigned = sets.get(1);
+
+        distributionSetManagement.toggleTagAssignment(sets.stream().map(BaseEntity::getId).collect(Collectors.toList()),
+                tag.getName());
+
+        mvc.perform(delete(MgmtRestConstants.DISTRIBUTIONSET_TAG_V1_REQUEST_MAPPING + "/" + tag.getId() + "/assigned/"
+                + unassigned.getId())).andDo(MockMvcResultPrinter.print()).andExpect(status().isOk());
+
+        final List<DistributionSet> updated = distributionSetManagement.findByTag(PAGE, tag.getId()).getContent();
+
+        assertThat(updated.stream().map(DistributionSet::getId).collect(Collectors.toList()))
+                .containsOnly(assigned.getId());
+    }
+}

hawkbit-rest/hawkbit-mgmt-resource/src/test/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtDistributionSetTypeResourceTest.java

@@ -0,0 +1,667 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.Matchers.hasSize;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
+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.MockMvcResultMatchers.content;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+import java.io.UnsupportedEncodingException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import org.apache.commons.lang3.RandomStringUtils;
+import org.assertj.core.util.Lists;
+import org.eclipse.hawkbit.exception.SpServerError;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.repository.builder.SoftwareModuleTypeCreate;
+import org.eclipse.hawkbit.repository.exception.QuotaExceededException;
+import org.eclipse.hawkbit.repository.model.DistributionSetType;
+import org.eclipse.hawkbit.repository.model.SoftwareModuleType;
+import org.eclipse.hawkbit.repository.test.util.WithUser;
+import org.eclipse.hawkbit.rest.util.JsonBuilder;
+import org.eclipse.hawkbit.rest.util.MockMvcResultPrinter;
+import org.json.JSONObject;
+import org.junit.Test;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MvcResult;
+
+import com.jayway.jsonpath.JsonPath;
+
+import ru.yandex.qatools.allure.annotations.Description;
+import ru.yandex.qatools.allure.annotations.Features;
+import ru.yandex.qatools.allure.annotations.Step;
+import ru.yandex.qatools.allure.annotations.Stories;
+
+/**
+ * Test for {@link MgmtDistributionSetTypeResource}.
+ *
+ */
+@Features("Component Tests - Management API")
+@Stories("Distribution Set Type Resource")
+public class MgmtDistributionSetTypeResourceTest extends AbstractManagementApiIntegrationTest {
+
+    @Test
+    @WithUser(principal = "uploadTester", allSpPermissions = true)
+    @Description("Checks the correct behaviour of /rest/v1/distributionsettypes GET requests.")
+    public void getDistributionSetTypes() throws Exception {
+
+        DistributionSetType testType = distributionSetTypeManagement.create(entityFactory.distributionSetType().create()
+                .key("test123").name("TestName123").description("Desc123").colour("col12"));
+        testType = distributionSetTypeManagement
+                .update(entityFactory.distributionSetType().update(testType.getId()).description("Desc1234"));
+
+        // 4 types overall (2 hawkbit tenant default, 1 test default and 1
+        // generated in this test)
+        mvc.perform(get("/rest/v1/distributionsettypes").accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.content.[?(@.key==" + standardDsType.getKey() + ")]$..name",
+                        contains(standardDsType.getName())))
+                .andExpect(jsonPath("$.content.[?(@.key==" + standardDsType.getKey() + ")]$..description",
+                        contains(standardDsType.getDescription())))
+                .andExpect(jsonPath("$.content.[?(@.key==" + standardDsType.getKey() + ")]$..key",
+                        contains(standardDsType.getKey())))
+                .andExpect(jsonPath("$.content.[?(@.key==test123)]$..id", contains(testType.getId().intValue())))
+                .andExpect(jsonPath("$.content.[?(@.key==test123)]$..name", contains("TestName123")))
+                .andExpect(jsonPath("$.content.[?(@.key==test123)]$..description", contains("Desc1234")))
+                .andExpect(jsonPath("$.content.[?(@.key==test123)]$..createdBy", contains("uploadTester")))
+                .andExpect(jsonPath("$.content.[?(@.key==test123)]$..createdAt", contains(testType.getCreatedAt())))
+                .andExpect(jsonPath("$.content.[?(@.key==test123)]$..lastModifiedBy", contains("uploadTester")))
+                .andExpect(jsonPath("$.content.[?(@.key==test123)]$..lastModifiedAt",
+                        contains(testType.getLastModifiedAt())))
+                .andExpect(jsonPath("$.content.[?(@.key==test123)]$..key", contains("test123")))
+                .andExpect(jsonPath("$.content.[?(@.key==test123)]$.._links.self.href",
+                        contains("http://localhost/rest/v1/distributionsettypes/" + testType.getId())))
+                .andExpect(jsonPath("$.total", equalTo(5)));
+    }
+
+    @Test
+    @WithUser(principal = "uploadTester", allSpPermissions = true)
+    @Description("Checks the correct behaviour of /rest/v1/distributionsettypes GET requests with sorting by KEY.")
+    public void getDistributionSetTypesSortedByKey() throws Exception {
+
+        DistributionSetType testType = distributionSetTypeManagement.create(entityFactory.distributionSetType().create()
+                .key("zzzzz").name("TestName123").description("Desc123").colour("col12"));
+        testType = distributionSetTypeManagement
+                .update(entityFactory.distributionSetType().update(testType.getId()).description("Desc1234"));
+
+        // descending
+        mvc.perform(get("/rest/v1/distributionsettypes").accept(MediaType.APPLICATION_JSON)
+                .param(MgmtRestConstants.REQUEST_PARAMETER_SORTING, "KEY:DESC")).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk()).andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.content.[0].id", equalTo(testType.getId().intValue())))
+                .andExpect(jsonPath("$.content.[0].name", equalTo("TestName123")))
+                .andExpect(jsonPath("$.content.[0].description", equalTo("Desc1234")))
+                .andExpect(jsonPath("$.content.[0].createdBy", equalTo("uploadTester")))
+                .andExpect(jsonPath("$.content.[0].createdAt", equalTo(testType.getCreatedAt())))
+                .andExpect(jsonPath("$.content.[0].lastModifiedBy", equalTo("uploadTester")))
+                .andExpect(jsonPath("$.content.[0].lastModifiedAt", equalTo(testType.getLastModifiedAt())))
+                .andExpect(jsonPath("$.content.[0].key", equalTo("zzzzz")))
+                .andExpect(jsonPath("$.total", equalTo(DEFAULT_DS_TYPES + 1)));
+
+        // ascending
+        mvc.perform(get("/rest/v1/distributionsettypes").accept(MediaType.APPLICATION_JSON)
+                .param(MgmtRestConstants.REQUEST_PARAMETER_SORTING, "KEY:ASC")).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk()).andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.content.[4].id", equalTo(testType.getId().intValue())))
+                .andExpect(jsonPath("$.content.[4].name", equalTo("TestName123")))
+                .andExpect(jsonPath("$.content.[4].description", equalTo("Desc1234")))
+                .andExpect(jsonPath("$.content.[4].createdBy", equalTo("uploadTester")))
+                .andExpect(jsonPath("$.content.[4].createdAt", equalTo(testType.getCreatedAt())))
+                .andExpect(jsonPath("$.content.[4].lastModifiedBy", equalTo("uploadTester")))
+                .andExpect(jsonPath("$.content.[4].lastModifiedAt", equalTo(testType.getLastModifiedAt())))
+                .andExpect(jsonPath("$.content.[4].key", equalTo("zzzzz")))
+                .andExpect(jsonPath("$.total", equalTo(DEFAULT_DS_TYPES + 1)));
+    }
+
+    @Test
+    @WithUser(principal = "uploadTester", allSpPermissions = true)
+    @Description("Checks the correct behaviour of /rest/v1/distributionsettypes POST requests.")
+    public void createDistributionSetTypes() throws Exception {
+
+        final List<DistributionSetType> types = createTestDistributionSetTestTypes();
+
+        final MvcResult mvcResult = runPostDistributionSetType(types);
+
+        verifyCreatedDistributionSetTypes(mvcResult);
+    }
+
+    @Step
+    private void verifyCreatedDistributionSetTypes(final MvcResult mvcResult) throws UnsupportedEncodingException {
+        final DistributionSetType created1 = distributionSetTypeManagement.getByKey("testKey1").get();
+        final DistributionSetType created2 = distributionSetTypeManagement.getByKey("testKey2").get();
+        final DistributionSetType created3 = distributionSetTypeManagement.getByKey("testKey3").get();
+
+        assertThat(created1.getMandatoryModuleTypes()).containsOnly(osType);
+        assertThat(created1.getOptionalModuleTypes()).containsOnly(runtimeType);
+        assertThat(created2.getOptionalModuleTypes()).containsOnly(osType, runtimeType, appType);
+        assertThat(created3.getMandatoryModuleTypes()).containsOnly(osType, runtimeType);
+
+        assertThat(
+                JsonPath.compile("[0]_links.self.href").read(mvcResult.getResponse().getContentAsString()).toString())
+                        .isEqualTo("http://localhost/rest/v1/distributionsettypes/" + created1.getId());
+        assertThat(
+                JsonPath.compile("[1]_links.self.href").read(mvcResult.getResponse().getContentAsString()).toString())
+                        .isEqualTo("http://localhost/rest/v1/distributionsettypes/" + created2.getId());
+        assertThat(
+                JsonPath.compile("[2]_links.self.href").read(mvcResult.getResponse().getContentAsString()).toString())
+                        .isEqualTo("http://localhost/rest/v1/distributionsettypes/" + created3.getId());
+
+        assertThat(distributionSetTypeManagement.count()).isEqualTo(7);
+    }
+
+    @Step
+    private MvcResult runPostDistributionSetType(final List<DistributionSetType> types) throws Exception {
+        return mvc
+                .perform(post("/rest/v1/distributionsettypes/").content(JsonBuilder.distributionSetTypes(types))
+                        .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isCreated())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("[0].name", equalTo("TestName1")))
+                .andExpect(jsonPath("[0].key", equalTo("testKey1")))
+                .andExpect(jsonPath("[0].description", equalTo("Desc1")))
+                .andExpect(jsonPath("[0].createdBy", equalTo("uploadTester")))
+                .andExpect(jsonPath("[1].name", equalTo("TestName2")))
+                .andExpect(jsonPath("[1].key", equalTo("testKey2")))
+                .andExpect(jsonPath("[1].description", equalTo("Desc2")))
+                .andExpect(jsonPath("[1].createdBy", equalTo("uploadTester")))
+                .andExpect(jsonPath("[2].name", equalTo("TestName3")))
+                .andExpect(jsonPath("[2].key", equalTo("testKey3")))
+                .andExpect(jsonPath("[2].description", equalTo("Desc3")))
+                .andExpect(jsonPath("[2].createdBy", equalTo("uploadTester")))
+                .andExpect(jsonPath("[2].createdAt", not(equalTo(0)))).andReturn();
+    }
+
+    @Step
+    private List<DistributionSetType> createTestDistributionSetTestTypes() {
+        assertThat(distributionSetTypeManagement.count()).isEqualTo(DEFAULT_DS_TYPES);
+
+        return Arrays.asList(
+                entityFactory.distributionSetType().create().key("testKey1").name("TestName1").description("Desc1")
+                        .colour("col").mandatory(Arrays.asList(osType.getId()))
+                        .optional(Arrays.asList(runtimeType.getId())).build(),
+                entityFactory.distributionSetType().create().key("testKey2").name("TestName2").description("Desc2")
+                        .colour("col").optional(Arrays.asList(runtimeType.getId(), osType.getId(), appType.getId()))
+                        .build(),
+                entityFactory.distributionSetType().create().key("testKey3").name("TestName3").description("Desc3")
+                        .colour("col").mandatory(Arrays.asList(runtimeType.getId(), osType.getId())).build());
+    }
+
+    @Test
+    @WithUser(principal = "uploadTester", allSpPermissions = true)
+    @Description("Checks the correct behaviour of /rest/v1/distributionsettypes/{ID}/mandatorymoduletypes POST requests.")
+    public void addMandatoryModuleToDistributionSetType() throws Exception {
+        DistributionSetType testType = distributionSetTypeManagement.create(entityFactory.distributionSetType().create()
+                .key("test123").name("TestName123").description("Desc123").colour("col12"));
+        assertThat(testType.getOptLockRevision()).isEqualTo(1);
+
+        mvc.perform(post("/rest/v1/distributionsettypes/{dstID}/mandatorymoduletypes", testType.getId())
+                .content("{\"id\":" + osType.getId() + "}").contentType(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk());
+
+        testType = distributionSetTypeManagement.get(testType.getId()).get();
+        assertThat(testType.getLastModifiedBy()).isEqualTo("uploadTester");
+        assertThat(testType.getOptLockRevision()).isEqualTo(2);
+        assertThat(testType.getMandatoryModuleTypes()).containsExactly(osType);
+        assertThat(testType.getOptionalModuleTypes()).isEmpty();
+    }
+
+    @Test
+    @WithUser(principal = "uploadTester", allSpPermissions = true)
+    @Description("Checks the correct behaviour of /rest/v1/distributionsettypes/{ID}/optionalmoduletypes POST requests.")
+    public void addOptionalModuleToDistributionSetType() throws Exception {
+        DistributionSetType testType = distributionSetTypeManagement.create(entityFactory.distributionSetType().create()
+                .key("test123").name("TestName123").description("Desc123").colour("col12"));
+        assertThat(testType.getOptLockRevision()).isEqualTo(1);
+
+        mvc.perform(post("/rest/v1/distributionsettypes/{dstID}/optionalmoduletypes", testType.getId())
+                .content("{\"id\":" + osType.getId() + "}").contentType(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk());
+
+        testType = distributionSetTypeManagement.get(testType.getId()).get();
+        assertThat(testType.getLastModifiedBy()).isEqualTo("uploadTester");
+        assertThat(testType.getOptLockRevision()).isEqualTo(2);
+        assertThat(testType.getOptionalModuleTypes()).containsExactly(osType);
+        assertThat(testType.getMandatoryModuleTypes()).isEmpty();
+
+    }
+
+    @Test
+    @WithUser(principal = "uploadTester", allSpPermissions = true)
+    @Description("Verifies quota enforcement for /rest/v1/distributionsettypes/{ID}/optionalmoduletypes POST requests.")
+    public void assignModuleTypesToDistributionSetTypeUntilQuotaExceeded() throws Exception {
+
+        // create software module types
+        final int maxSoftwareModuleTypes = quotaManagement.getMaxSoftwareModuleTypesPerDistributionSetType();
+        final List<Long> moduleTypeIds = Lists.newArrayList();
+        for (int i = 0; i < maxSoftwareModuleTypes + 1; ++i) {
+            final SoftwareModuleTypeCreate smCreate = entityFactory.softwareModuleType().create().name("smType_" + i)
+                    .description("smType_" + i).maxAssignments(1).colour("blue").key("smType_" + i);
+            moduleTypeIds.add(softwareModuleTypeManagement.create(smCreate).getId());
+        }
+
+        // verify quota enforcement for optional module types
+
+        final DistributionSetType testType = distributionSetTypeManagement.create(entityFactory.distributionSetType()
+                .create().key("testType").name("testType").description("testType").colour("col12"));
+        assertThat(testType.getOptLockRevision()).isEqualTo(1);
+
+        for (int i = 0; i < moduleTypeIds.size() - 1; ++i) {
+            mvc.perform(post("/rest/v1/distributionsettypes/{dstID}/optionalmoduletypes", testType.getId())
+                    .content("{\"id\":" + moduleTypeIds.get(i) + "}").contentType(MediaType.APPLICATION_JSON))
+                    .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk());
+        }
+
+        mvc.perform(post("/rest/v1/distributionsettypes/{dstID}/optionalmoduletypes", testType.getId())
+                .content("{\"id\":" + moduleTypeIds.get(moduleTypeIds.size() - 1) + "}")
+                .contentType(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isForbidden())
+                .andExpect(jsonPath("$.exceptionClass", equalTo(QuotaExceededException.class.getName())))
+                .andExpect(jsonPath("$.errorCode", equalTo(SpServerError.SP_QUOTA_EXCEEDED.getKey())));
+
+        // verify quota enforcement for mandatory module types
+
+        final DistributionSetType testType2 = distributionSetTypeManagement.create(entityFactory.distributionSetType()
+                .create().key("testType2").name("testType2").description("testType2").colour("col12"));
+        assertThat(testType2.getOptLockRevision()).isEqualTo(1);
+
+        for (int i = 0; i < moduleTypeIds.size() - 1; ++i) {
+            mvc.perform(post("/rest/v1/distributionsettypes/{dstID}/mandatorymoduletypes", testType2.getId())
+                    .content("{\"id\":" + moduleTypeIds.get(i) + "}").contentType(MediaType.APPLICATION_JSON))
+                    .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk());
+        }
+
+        mvc.perform(post("/rest/v1/distributionsettypes/{dstID}/mandatorymoduletypes", testType2.getId())
+                .content("{\"id\":" + moduleTypeIds.get(moduleTypeIds.size() - 1) + "}")
+                .contentType(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isForbidden())
+                .andExpect(jsonPath("$.exceptionClass", equalTo(QuotaExceededException.class.getName())))
+                .andExpect(jsonPath("$.errorCode", equalTo(SpServerError.SP_QUOTA_EXCEEDED.getKey())));
+
+    }
+
+    @Test
+    @WithUser(principal = "uploadTester", allSpPermissions = true)
+    @Description("Checks the correct behaviour of /rest/v1/distributionsettypes/{ID}/mandatorymoduletypes GET requests.")
+    public void getMandatoryModulesOfDistributionSetType() throws Exception {
+        final DistributionSetType testType = generateTestType();
+
+        mvc.perform(get("/rest/v1/distributionsettypes/{dstID}/mandatorymoduletypes", testType.getId())
+                .accept(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("[0].name", equalTo(osType.getName())))
+                .andExpect(jsonPath("[0].description", equalTo(osType.getDescription())))
+                .andExpect(jsonPath("[0].maxAssignments", equalTo(1))).andExpect(jsonPath("[0].key", equalTo("os")));
+    }
+
+    @Test
+    @WithUser(principal = "uploadTester", allSpPermissions = true)
+    @Description("Checks the correct behaviour of /rest/v1/distributionsettypes/{ID}/optionalmoduletypes GET requests.")
+    public void getOptionalModulesOfDistributionSetType() throws Exception {
+        final DistributionSetType testType = generateTestType();
+
+        mvc.perform(get("/rest/v1/distributionsettypes/{dstID}/optionalmoduletypes", testType.getId())
+                .accept(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("[0].name", equalTo(appType.getName())))
+                .andExpect(jsonPath("[0].description", equalTo(appType.getDescription())))
+                .andExpect(jsonPath("[0].maxAssignments", equalTo(Integer.MAX_VALUE)))
+                .andExpect(jsonPath("[0].key", equalTo("application")));
+    }
+
+    @Test
+    @WithUser(principal = "uploadTester", allSpPermissions = true)
+    @Description("Checks the correct behaviour of /rest/v1/distributionsettypes/{ID}/mandatorymoduletypes/{ID} GET requests.")
+    public void getMandatoryModuleOfDistributionSetType() throws Exception {
+        final DistributionSetType testType = generateTestType();
+
+        mvc.perform(get("/rest/v1/distributionsettypes/{dstID}/mandatorymoduletypes/{smtId}", testType.getId(),
+                osType.getId()).contentType(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk()).andExpect(jsonPath("$.id", equalTo(osType.getId().intValue())))
+                .andExpect(jsonPath("$.name", equalTo(osType.getName())))
+                .andExpect(jsonPath("$.description", equalTo(osType.getDescription())))
+                .andExpect(jsonPath("$.createdBy", equalTo(osType.getCreatedBy())))
+                .andExpect(jsonPath("$.createdAt", equalTo(osType.getCreatedAt())))
+                .andExpect(jsonPath("$.lastModifiedBy", equalTo(osType.getLastModifiedBy())))
+                .andExpect(jsonPath("$.lastModifiedAt", equalTo(osType.getLastModifiedAt())));
+    }
+
+    private DistributionSetType generateTestType() {
+        final DistributionSetType testType = distributionSetTypeManagement.create(entityFactory.distributionSetType()
+                .create().key("test123").name("TestName123").description("Desc123").colour("col")
+                .mandatory(Arrays.asList(osType.getId())).optional(Arrays.asList(appType.getId())));
+        assertThat(testType.getOptLockRevision()).isEqualTo(1);
+        assertThat(testType.getOptionalModuleTypes()).containsExactly(appType);
+        assertThat(testType.getMandatoryModuleTypes()).containsExactly(osType);
+        return testType;
+    }
+
+    @Test
+    @WithUser(principal = "uploadTester", allSpPermissions = true)
+    @Description("Checks the correct behaviour of /rest/v1/distributionsettypes/{ID}/optionalmoduletypes/{ID} GET requests.")
+    public void getOptionalModuleOfDistributionSetType() throws Exception {
+        final DistributionSetType testType = generateTestType();
+
+        mvc.perform(get("/rest/v1/distributionsettypes/{dstID}/optionalmoduletypes/{smtId}", testType.getId(),
+                appType.getId()).contentType(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk()).andExpect(jsonPath("$.id", equalTo(appType.getId().intValue())))
+                .andExpect(jsonPath("$.name", equalTo(appType.getName())))
+                .andExpect(jsonPath("$.description", equalTo(appType.getDescription())))
+                .andExpect(jsonPath("$.createdBy", equalTo(appType.getCreatedBy())))
+                .andExpect(jsonPath("$.createdAt", equalTo(appType.getCreatedAt())))
+                .andExpect(jsonPath("$.lastModifiedBy", equalTo(appType.getLastModifiedBy())))
+                .andExpect(jsonPath("$.lastModifiedAt", equalTo(appType.getLastModifiedAt())));
+    }
+
+    @Test
+    @WithUser(principal = "uploadTester", allSpPermissions = true)
+    @Description("Checks the correct behaviour of /rest/v1/distributionsettypes/{ID}/mandatorymoduletypes/{ID} DELETE requests.")
+    public void removeMandatoryModuleToDistributionSetType() throws Exception {
+        DistributionSetType testType = generateTestType();
+
+        mvc.perform(delete("/rest/v1/distributionsettypes/{dstID}/mandatorymoduletypes/{smtId}", testType.getId(),
+                osType.getId()).contentType(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk());
+
+        testType = distributionSetTypeManagement.get(testType.getId()).get();
+        assertThat(testType.getLastModifiedBy()).isEqualTo("uploadTester");
+        assertThat(testType.getOptLockRevision()).isEqualTo(2);
+        assertThat(testType.getOptionalModuleTypes()).containsExactly(appType);
+        assertThat(testType.getMandatoryModuleTypes()).isEmpty();
+    }
+
+    @Test
+    @WithUser(principal = "uploadTester", allSpPermissions = true)
+    @Description("Checks the correct behaviour of /rest/v1/distributionsettypes/{ID}/optionalmoduletypes/{ID} DELETE requests.")
+    public void removeOptionalModuleToDistributionSetType() throws Exception {
+        DistributionSetType testType = generateTestType();
+
+        mvc.perform(delete("/rest/v1/distributionsettypes/{dstID}/optionalmoduletypes/{smtId}", testType.getId(),
+                appType.getId()).contentType(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk());
+
+        testType = distributionSetTypeManagement.get(testType.getId()).get();
+        assertThat(testType.getLastModifiedBy()).isEqualTo("uploadTester");
+        assertThat(testType.getOptLockRevision()).isEqualTo(2);
+        assertThat(testType.getOptionalModuleTypes()).isEmpty();
+        assertThat(testType.getMandatoryModuleTypes()).containsExactly(osType);
+    }
+
+    @Test
+    @WithUser(principal = "uploadTester", allSpPermissions = true)
+    @Description("Checks the correct behaviour of /rest/v1/distributionsettypes/{ID} GET requests.")
+    public void getDistributionSetType() throws Exception {
+
+        DistributionSetType testType = distributionSetTypeManagement.create(entityFactory.distributionSetType().create()
+                .key("test123").name("TestName123").description("Desc123").colour("col12"));
+        testType = distributionSetTypeManagement
+                .update(entityFactory.distributionSetType().update(testType.getId()).description("Desc1234"));
+
+        mvc.perform(get("/rest/v1/distributionsettypes/{dstId}", testType.getId()).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.name", equalTo("TestName123")))
+                .andExpect(jsonPath("$.description", equalTo("Desc1234")))
+                .andExpect(jsonPath("$.createdBy", equalTo("uploadTester")))
+                .andExpect(jsonPath("$.createdAt", equalTo(testType.getCreatedAt())))
+                .andExpect(jsonPath("$.lastModifiedBy", equalTo("uploadTester")))
+                .andExpect(jsonPath("$.deleted", equalTo(testType.isDeleted())));
+    }
+
+    @Test
+    @WithUser(principal = "uploadTester", allSpPermissions = true)
+    @Description("Checks the correct behaviour of /rest/v1/DistributionSetTypes/{ID} DELETE requests (hard delete scenario).")
+    public void deleteDistributionSetTypeUnused() throws Exception {
+        final DistributionSetType testType = distributionSetTypeManagement.create(entityFactory.distributionSetType()
+                .create().key("test123").name("TestName123").description("Desc123").colour("col12"));
+
+        assertThat(distributionSetTypeManagement.count()).isEqualTo(DEFAULT_DS_TYPES + 1);
+
+        mvc.perform(delete("/rest/v1/distributionsettypes/{dsId}", testType.getId()))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk());
+
+        assertThat(distributionSetTypeManagement.count()).isEqualTo(DEFAULT_DS_TYPES);
+    }
+
+    @Test
+    @Description("Ensures that DS type deletion request to API on an entity that does not exist results in NOT_FOUND.")
+    public void deleteDistributionSetTypeThatDoesNotExistLeadsToNotFound() throws Exception {
+        mvc.perform(delete("/rest/v1/distributionsettypes/1234")).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isNotFound());
+    }
+
+    @Test
+    @WithUser(principal = "uploadTester", allSpPermissions = true)
+    @Description("Checks the correct behaviour of /rest/v1/DistributionSetTypes/{ID} DELETE requests (soft delete scenario).")
+    public void deleteDistributionSetTypeUsed() throws Exception {
+        final DistributionSetType testType = distributionSetTypeManagement.create(entityFactory.distributionSetType()
+                .create().key("test123").name("TestName123").description("Desc123").colour("col12"));
+
+        distributionSetManagement.create(entityFactory.distributionSet().create().name("sdfsd").description("dsfsdf")
+                .version("1").type(testType));
+
+        assertThat(distributionSetTypeManagement.count()).isEqualTo(DEFAULT_DS_TYPES + 1);
+        assertThat(distributionSetManagement.count()).isEqualTo(1);
+
+        mvc.perform(get("/rest/v1/distributionsettypes/{dstId}", testType.getId())).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk()).andExpect(jsonPath("$.deleted", equalTo(false)));
+
+        mvc.perform(delete("/rest/v1/distributionsettypes/{dstId}", testType.getId()))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk());
+
+        mvc.perform(get("/rest/v1/distributionsettypes/{dstId}", testType.getId())).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk()).andExpect(jsonPath("$.deleted", equalTo(true)));
+
+        assertThat(distributionSetManagement.count()).isEqualTo(1);
+        assertThat(distributionSetTypeManagement.count()).isEqualTo(DEFAULT_DS_TYPES);
+    }
+
+    @Test
+    @Description("Checks the correct behaviour of /rest/v1/distributionsettypes/{ID} PUT requests.")
+    public void updateDistributionSetTypeOnlyDescriptionAndNameUntouched() throws Exception {
+        final DistributionSetType testType = distributionSetTypeManagement.create(entityFactory.distributionSetType()
+                .create().key("test123").name("TestName123").description("Desc123").colour("col"));
+
+        final String body = new JSONObject().put("id", testType.getId()).put("description", "foobardesc")
+                .put("name", "nameShouldNotBeChanged").toString();
+
+        mvc.perform(put("/rest/v1/distributionsettypes/{smId}", testType.getId()).content(body)
+                .contentType(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(jsonPath("$.id", equalTo(testType.getId().intValue())))
+                .andExpect(jsonPath("$.description", equalTo("foobardesc")))
+                .andExpect(jsonPath("$.name", equalTo("TestName123"))).andReturn();
+    }
+
+    @Test
+    @Description("Tests the update of the deletion flag. It is verfied that the distribution set type can't be marked as deleted through update operation.")
+    public void updateDistributionSetTypeDeletedFlag() throws Exception {
+        final DistributionSetType testType = distributionSetTypeManagement
+                .create(entityFactory.distributionSetType().create().key("test123").name("TestName123").colour("col"));
+
+        final String body = new JSONObject().put("id", testType.getId()).put("deleted", true).toString();
+
+        mvc.perform(put("/rest/v1/distributionsettypes/{dstId}", testType.getId()).content(body)
+                .contentType(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(jsonPath("$.id", equalTo(testType.getId().intValue())))
+                .andExpect(jsonPath("$.deleted", equalTo(false)));
+    }
+
+    @Test
+    @Description("Checks the correct behaviour of /rest/v1/distributionsettypes GET requests with paging.")
+    public void getDistributionSetTypesWithoutAddtionalRequestParameters() throws Exception {
+
+        // 4 types overall (3 hawkbit tenant default, 1 test default
+        final int types = 4;
+        mvc.perform(get(MgmtRestConstants.DISTRIBUTIONSETTYPE_V1_REQUEST_MAPPING)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk())
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_TOTAL, equalTo(types)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_SIZE, equalTo(types)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_CONTENT, hasSize(types)));
+    }
+
+    @Test
+    @Description("Checks the correct behaviour of /rest/v1/distributionsettypes GET requests with paging.")
+    public void getDistributionSetTypesWithPagingLimitRequestParameter() throws Exception {
+
+        final int types = DEFAULT_DS_TYPES;
+        final int limitSize = 1;
+        mvc.perform(get(MgmtRestConstants.DISTRIBUTIONSETTYPE_V1_REQUEST_MAPPING)
+                .param(MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, String.valueOf(limitSize)))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_TOTAL, equalTo(types)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_SIZE, equalTo(limitSize)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_CONTENT, hasSize(limitSize)));
+    }
+
+    @Test
+    @Description("Checks the correct behaviour of /rest/v1/distributionsettypes GET requests with paging.")
+    public void getDistributionSetTypesWithPagingLimitAndOffsetRequestParameter() throws Exception {
+
+        final int types = DEFAULT_DS_TYPES;
+        final int offsetParam = 2;
+        final int expectedSize = types - offsetParam;
+        mvc.perform(get(MgmtRestConstants.DISTRIBUTIONSETTYPE_V1_REQUEST_MAPPING)
+                .param(MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, String.valueOf(offsetParam))
+                .param(MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, String.valueOf(types)))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_TOTAL, equalTo(types)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_SIZE, equalTo(expectedSize)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_CONTENT, hasSize(expectedSize)));
+    }
+
+    @Test
+    @Description("Ensures that the server is behaving as expected on invalid requests (wrong media type, wrong ID etc.).")
+    public void invalidRequestsOnDistributionSetTypesResource() throws Exception {
+        // final DistributionSetType testDsType = distributionSetManagement
+        // .createDistributionSetType(entityFactory.distributionSetType().create().key("test123")
+        // .name("TestName123").description("Desc123").colour("col"));
+
+        final SoftwareModuleType testSmType = softwareModuleTypeManagement
+                .create(entityFactory.softwareModuleType().create().key("test123").name("TestName123"));
+
+        // DST does not exist
+        mvc.perform(get("/rest/v1/distributionsettypes/12345678")).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isNotFound());
+        mvc.perform(get("/rest/v1/distributionsettypes/12345678/mandatorymoduletypes"))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isNotFound());
+        mvc.perform(get("/rest/v1/distributionsettypes/12345678/optionalmoduletypes"))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isNotFound());
+
+        mvc.perform(delete("/rest/v1/distributionsettypes/12345678")).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isNotFound());
+
+        // Module types incorrect
+        mvc.perform(get("/rest/v1/distributionsettypes/" + standardDsType.getId() + "/mandatorymoduletypes"))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk());
+        mvc.perform(get("/rest/v1/distributionsettypes/" + standardDsType.getId() + "/mandatorymoduletypes/565765656"))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isNotFound());
+        mvc.perform(get("/rest/v1/distributionsettypes/" + standardDsType.getId() + "/optionalmoduletypes/565765656"))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isNotFound());
+
+        mvc.perform(get(
+                "/rest/v1/distributionsettypes/" + standardDsType.getId() + "/mandatorymoduletypes/" + osType.getId()))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk());
+        mvc.perform(get("/rest/v1/distributionsettypes/" + standardDsType.getId() + "/mandatorymoduletypes/"
+                + testSmType.getId())).andDo(MockMvcResultPrinter.print()).andExpect(status().isNotFound());
+
+        mvc.perform(get(
+                "/rest/v1/distributionsettypes/" + standardDsType.getId() + "/optionalmoduletypes/" + osType.getId()))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isNotFound());
+
+        mvc.perform(get(
+                "/rest/v1/distributionsettypes/" + standardDsType.getId() + "/optionalmoduletypes/" + appType.getId()))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk());
+
+        mvc.perform(get("/rest/v1/distributionsettypes/" + standardDsType.getId() + "/optionalmoduletypes/"
+                + testSmType.getId())).andDo(MockMvcResultPrinter.print()).andExpect(status().isNotFound());
+
+        // Modules types at creation time invalid
+
+        final DistributionSetType testNewType = entityFactory.distributionSetType().create().key("test123")
+                .name("TestName123").description("Desc123").colour("col").mandatory(Arrays.asList(osType.getId()))
+                .optional(Collections.emptyList()).build();
+
+        mvc.perform(post("/rest/v1/distributionsettypes")
+                .content(JsonBuilder.distributionSetTypes(Arrays.asList(testNewType)))
+                .contentType(MediaType.APPLICATION_OCTET_STREAM)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isUnsupportedMediaType());
+
+        // bad request - no content
+        mvc.perform(post("/rest/v1/distributionsettypes").contentType(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isBadRequest());
+
+        // bad request - bad content
+        mvc.perform(post("/rest/v1/distributionsettypes").content("sdfjsdlkjfskdjf".getBytes())
+                .contentType(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isBadRequest());
+
+        // Missing mandatory field name
+        mvc.perform(post("/rest/v1/distributionsettypes").content("[{\"description\":\"Desc123\",\"key\":\"test123\"}]")
+                .contentType(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isBadRequest());
+
+        final DistributionSetType toLongName = entityFactory.distributionSetType().create().key("test123")
+                .name(RandomStringUtils.randomAlphanumeric(80)).build();
+        mvc.perform(post("/rest/v1/distributionsettypes")
+                .content(JsonBuilder.distributionSetTypes(Arrays.asList(toLongName)))
+                .contentType(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isBadRequest());
+
+        // not allowed methods
+        mvc.perform(put("/rest/v1/distributionsettypes")).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isMethodNotAllowed());
+
+        mvc.perform(delete("/rest/v1/distributionsettypes")).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isMethodNotAllowed());
+
+        mvc.perform(put("/rest/v1/distributionsettypes/" + standardDsType.getId() + "/mandatorymoduletypes"))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isMethodNotAllowed());
+        mvc.perform(put(
+                "/rest/v1/distributionsettypes/" + standardDsType.getId() + "/optionalmoduletypes/" + osType.getId()))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isMethodNotAllowed());
+    }
+
+    @Test
+    @Description("Search erquest of software module types.")
+    public void searchDistributionSetTypeRsql() throws Exception {
+        distributionSetTypeManagement
+                .create(entityFactory.distributionSetType().create().key("test123").name("TestName123"));
+        distributionSetTypeManagement
+                .create(entityFactory.distributionSetType().create().key("test1234").name("TestName1234"));
+
+        final String rsqlFindLikeDs1OrDs2 = "name==TestName123,name==TestName1234";
+
+        mvc.perform(get("/rest/v1/distributionsettypes?q=" + rsqlFindLikeDs1OrDs2)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk()).andExpect(jsonPath("size", equalTo(2)))
+                .andExpect(jsonPath("total", equalTo(2))).andExpect(jsonPath("content[0].name", equalTo("TestName123")))
+                .andExpect(jsonPath("content[1].name", equalTo("TestName1234")));
+    }
+
+    private void createSoftwareModulesAlphabetical(final int amount) {
+        char character = 'a';
+        for (int index = 0; index < amount; index++) {
+            final String str = String.valueOf(character);
+            softwareModuleManagement.create(
+                    entityFactory.softwareModule().create().name(str).description(str).vendor(str).version(str));
+            character++;
+        }
+    }
+
+}

hawkbit-rest/hawkbit-mgmt-resource/src/test/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtDownloadResourceTest.java

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+import org.eclipse.hawkbit.cache.DownloadArtifactCache;
+import org.eclipse.hawkbit.cache.DownloadIdCache;
+import org.eclipse.hawkbit.cache.DownloadType;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.repository.model.Artifact;
+import org.eclipse.hawkbit.repository.model.DistributionSet;
+import org.eclipse.hawkbit.repository.model.SoftwareModule;
+import org.eclipse.hawkbit.rest.util.MockMvcResultPrinter;
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import ru.yandex.qatools.allure.annotations.Description;
+import ru.yandex.qatools.allure.annotations.Features;
+import ru.yandex.qatools.allure.annotations.Stories;
+
+@Features("Component Tests - Management API")
+@Stories("Download Resource")
+public class MgmtDownloadResourceTest extends AbstractManagementApiIntegrationTest {
+
+    @Autowired
+    private DownloadIdCache downloadIdCache;
+
+    private static final String DOWNLOAD_ID_SHA1 = "downloadIdSha1";
+
+    private static final String DOWNLOAD_ID_NOT_AVAILABLE = "downloadIdNotAvailable";
+
+    @Before
+    public void setupCache() {
+
+        final DistributionSet distributionSet = testdataFactory.createDistributionSet("Test");
+        final SoftwareModule softwareModule = distributionSet.getModules().stream().findAny().get();
+        final Artifact artifact = testdataFactory.createArtifacts(softwareModule.getId()).stream().findAny().get();
+
+        downloadIdCache.put(DOWNLOAD_ID_SHA1, new DownloadArtifactCache(DownloadType.BY_SHA1, artifact.getSha1Hash()));
+    }
+
+    @Test
+    @Description("This test verifies the call of download artifact without a valid download id fails.")
+    public void testNoDownloadIdAvailable() throws Exception {
+        mvc.perform(get(
+                MgmtRestConstants.DOWNLOAD_ID_V1_REQUEST_MAPPING_BASE
+                        + MgmtRestConstants.DOWNLOAD_ID_V1_REQUEST_MAPPING,
+                tenantAware.getCurrentTenant(), DOWNLOAD_ID_NOT_AVAILABLE)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isNotFound());
+
+    }
+
+    @Test
+    @Description("This test verifies the call of download artifact works and the download id will be removed.")
+    public void testDownload() throws Exception {
+        mvc.perform(get(
+                MgmtRestConstants.DOWNLOAD_ID_V1_REQUEST_MAPPING_BASE
+                        + MgmtRestConstants.DOWNLOAD_ID_V1_REQUEST_MAPPING,
+                tenantAware.getCurrentTenant(), DOWNLOAD_ID_SHA1)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk());
+
+        // because cache is empty
+        mvc.perform(get(
+                MgmtRestConstants.DOWNLOAD_ID_V1_REQUEST_MAPPING_BASE
+                        + MgmtRestConstants.DOWNLOAD_ID_V1_REQUEST_MAPPING,
+                tenantAware.getCurrentTenant(), DOWNLOAD_ID_SHA1)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isNotFound());
+
+    }
+
+}

hawkbit-rest/hawkbit-mgmt-resource/src/test/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtRolloutResourceTest.java

@@ -0,0 +1,998 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.hamcrest.CoreMatchers.allOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.endsWith;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.CoreMatchers.startsWith;
+import static org.hamcrest.Matchers.hasSize;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
+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.MockMvcResultMatchers.content;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.Callable;
+
+import org.eclipse.hawkbit.exception.SpServerError;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.repository.RolloutGroupManagement;
+import org.eclipse.hawkbit.repository.RolloutManagement;
+import org.eclipse.hawkbit.repository.exception.QuotaExceededException;
+import org.eclipse.hawkbit.repository.model.DistributionSet;
+import org.eclipse.hawkbit.repository.model.Rollout;
+import org.eclipse.hawkbit.repository.model.Rollout.RolloutStatus;
+import org.eclipse.hawkbit.repository.model.RolloutGroup;
+import org.eclipse.hawkbit.repository.model.RolloutGroup.RolloutGroupSuccessCondition;
+import org.eclipse.hawkbit.repository.model.RolloutGroupConditionBuilder;
+import org.eclipse.hawkbit.repository.model.RolloutGroupConditions;
+import org.eclipse.hawkbit.repository.test.util.WithUser;
+import org.eclipse.hawkbit.rest.util.JsonBuilder;
+import org.eclipse.hawkbit.rest.util.MockMvcResultPrinter;
+import org.eclipse.hawkbit.rest.util.SuccessCondition;
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort.Direction;
+import org.springframework.http.MediaType;
+
+import ru.yandex.qatools.allure.annotations.Description;
+import ru.yandex.qatools.allure.annotations.Features;
+import ru.yandex.qatools.allure.annotations.Step;
+import ru.yandex.qatools.allure.annotations.Stories;
+
+/**
+ * Tests for covering the {@link MgmtRolloutResource}.
+ */
+@Features("Component Tests - Management API")
+@Stories("Rollout Resource")
+public class MgmtRolloutResourceTest extends AbstractManagementApiIntegrationTest {
+
+    private static final String HREF_ROLLOUT_PREFIX = "http://localhost/rest/v1/rollouts/";
+
+    @Autowired
+    private RolloutManagement rolloutManagement;
+
+    @Autowired
+    private RolloutGroupManagement rolloutGroupManagement;
+
+    @Test
+    @Description("Testing that creating rollout with wrong body returns bad request")
+    public void createRolloutWithInvalidBodyReturnsBadRequest() throws Exception {
+        mvc.perform(post("/rest/v1/rollouts").content("invalid body").contentType(MediaType.APPLICATION_JSON)
+                .accept(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("errorCode", equalTo("hawkbit.server.error.rest.body.notReadable")));
+    }
+
+    @Test
+    @Description("Testing that creating rollout with insufficient permission returns forbidden")
+    @WithUser(allSpPermissions = true, removeFromAllPermission = "CREATE_ROLLOUT")
+    public void createRolloutWithInsufficientPermissionReturnsForbidden() throws Exception {
+        final DistributionSet dsA = testdataFactory.createDistributionSet("");
+        mvc.perform(post("/rest/v1/rollouts")
+                .content(JsonBuilder.rollout("name", "desc", 10, dsA.getId(), "name==test", null))
+                .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().is(403)).andReturn();
+    }
+
+    @Test
+    @Description("Testing that creating rollout with not exisiting distribution set returns not found")
+    public void createRolloutWithNotExistingDistributionSetReturnsNotFound() throws Exception {
+        mvc.perform(post("/rest/v1/rollouts").content(JsonBuilder.rollout("name", "desc", 10, 1234, "name==test", null))
+                .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isNotFound()).andReturn();
+    }
+
+    @Test
+    @Description("Testing that creating rollout with not valid formed target filter query returns bad request")
+    public void createRolloutWithNotWellFormedFilterReturnsBadRequest() throws Exception {
+        final DistributionSet dsA = testdataFactory.createDistributionSet("");
+        mvc.perform(post("/rest/v1/rollouts")
+                .content(JsonBuilder.rollout("name", "desc", 10, dsA.getId(), "name=test", null))
+                .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isBadRequest())
+                .andExpect(jsonPath("errorCode", equalTo("hawkbit.server.error.rest.param.rsqlParamSyntax")))
+                .andReturn();
+    }
+
+    @Description("Ensures that the repository refuses to create rollout without a defined target filter set.")
+    public void missingTargetFilterQueryInRollout() throws Exception {
+
+        final String targetFilterQuery = null;
+
+        final DistributionSet dsA = testdataFactory.createDistributionSet("");
+        mvc.perform(post("/rest/v1/rollouts")
+                .content(JsonBuilder.rollout("rollout1", "desc", 10, dsA.getId(), targetFilterQuery, null))
+                .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isBadRequest())
+                .andExpect(jsonPath("errorCode", equalTo("hawkbit.server.error.rest.param.rsqlParamSyntax")))
+                .andReturn();
+
+    }
+
+    @Test
+    @Description("Testing that rollout can be created")
+    public void createRollout() throws Exception {
+        testdataFactory.createTargets(20, "target", "rollout");
+
+        final DistributionSet dsA = testdataFactory.createDistributionSet("");
+        postRollout("rollout1", 10, dsA.getId(), "id==target*", 20);
+    }
+
+    @Test
+    @Description("Verifies that rollout cannot be created if too many rollout groups are specified.")
+    public void createRolloutWithTooManyRolloutGroups() throws Exception {
+
+        final int maxGroups = quotaManagement.getMaxRolloutGroupsPerRollout();
+        testdataFactory.createTargets(20, "target", "rollout");
+
+        mvc.perform(post("/rest/v1/rollouts")
+                .content(JsonBuilder.rollout("rollout1", "rollout1Desc", maxGroups + 1,
+                        testdataFactory.createDistributionSet("ds").getId(), "id==target*",
+                        new RolloutGroupConditionBuilder().withDefaults().build()))
+                .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isForbidden())
+                .andExpect(jsonPath("$.exceptionClass", equalTo(QuotaExceededException.class.getName())))
+                .andExpect(jsonPath("$.errorCode", equalTo(SpServerError.SP_QUOTA_EXCEEDED.getKey())));
+
+    }
+
+    @Test
+    @Description("Verifies that rollout cannot be created if the 'max targets per rollout group' quota would be violated for one of the groups.")
+    public void createRolloutFailsIfRolloutGroupQuotaIsViolated() throws Exception {
+
+        final int maxTargets = quotaManagement.getMaxTargetsPerRolloutGroup();
+        testdataFactory.createTargets(maxTargets + 1, "target", "rollout");
+
+        mvc.perform(post("/rest/v1/rollouts")
+                .content(JsonBuilder.rollout("rollout1", "rollout1Desc", 1,
+                        testdataFactory.createDistributionSet("ds").getId(), "id==target*",
+                        new RolloutGroupConditionBuilder().withDefaults().build()))
+                .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isForbidden())
+                .andExpect(jsonPath("$.exceptionClass", equalTo(QuotaExceededException.class.getName())))
+                .andExpect(jsonPath("$.errorCode", equalTo(SpServerError.SP_QUOTA_EXCEEDED.getKey())));
+
+    }
+
+    @Test
+    @Description("Testing that rollout can be created with groups")
+    public void createRolloutWithGroupDefinitions() throws Exception {
+        final DistributionSet dsA = testdataFactory.createDistributionSet("ro");
+
+        final int amountTargets = 10;
+        testdataFactory.createTargets(amountTargets, "ro-target", "rollout");
+
+        final float percentTargetsInGroup1 = 20;
+        final float percentTargetsInGroup2 = 100;
+
+        final List<RolloutGroup> rolloutGroups = Arrays.asList(
+                entityFactory.rolloutGroup().create().name("Group1").description("Group1desc")
+                        .targetPercentage(percentTargetsInGroup1).build(),
+                entityFactory.rolloutGroup().create().name("Group2").description("Group2desc")
+                        .targetPercentage(percentTargetsInGroup2).build());
+
+        final RolloutGroupConditions rolloutGroupConditions = new RolloutGroupConditionBuilder().withDefaults().build();
+
+        mvc.perform(post("/rest/v1/rollouts")
+                .content(JsonBuilder.rollout("rollout2", "desc", null, dsA.getId(), "id==ro-target*",
+                        rolloutGroupConditions, rolloutGroups))
+                .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isCreated()).andReturn();
+
+    }
+
+    @Test
+    @Description("Testing that no rollout with groups that have illegal percentages can be created")
+    public void createRolloutWithTooLowPercentage() throws Exception {
+        final DistributionSet dsA = testdataFactory.createDistributionSet("ro2");
+
+        final int amountTargets = 10;
+        testdataFactory.createTargets(amountTargets, "ro-target", "rollout");
+
+        final List<RolloutGroup> rolloutGroups = Arrays.asList(
+                entityFactory.rolloutGroup().create().name("Group1").description("Group1desc").targetPercentage(0F)
+                        .build(),
+                entityFactory.rolloutGroup().create().name("Group2").description("Group2desc").targetPercentage(100F)
+                        .build());
+
+        final RolloutGroupConditions rolloutGroupConditions = new RolloutGroupConditionBuilder().withDefaults().build();
+
+        mvc.perform(post("/rest/v1/rollouts")
+                .content(JsonBuilder.rollout("rollout4", "desc", null, dsA.getId(), "id==ro-target*",
+                        rolloutGroupConditions, rolloutGroups))
+                .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.errorCode", equalTo("hawkbit.server.error.repo.constraintViolation")));
+
+    }
+
+    @Test
+    @Description("Testing that no rollout with groups that have illegal percentages can be created")
+    public void createRolloutWithTooHighPercentage() throws Exception {
+        final DistributionSet dsA = testdataFactory.createDistributionSet("ro2");
+
+        final int amountTargets = 10;
+        testdataFactory.createTargets(amountTargets, "ro-target", "rollout");
+
+        final List<RolloutGroup> rolloutGroups = Arrays.asList(
+                entityFactory.rolloutGroup().create().name("Group1").description("Group1desc").targetPercentage(1F)
+                        .build(),
+                entityFactory.rolloutGroup().create().name("Group2").description("Group2desc").targetPercentage(101F)
+                        .build());
+
+        final RolloutGroupConditions rolloutGroupConditions = new RolloutGroupConditionBuilder().withDefaults().build();
+
+        mvc.perform(post("/rest/v1/rollouts")
+                .content(JsonBuilder.rollout("rollout4", "desc", null, dsA.getId(), "id==ro-target*",
+                        rolloutGroupConditions, rolloutGroups))
+                .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.errorCode", equalTo("hawkbit.server.error.repo.constraintViolation")));
+
+    }
+
+    @Test
+    @Description("Testing the empty list is returned if no rollout exists")
+    public void noRolloutReturnsEmptyList() throws Exception {
+        mvc.perform(get("/rest/v1/rollouts").accept(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk()).andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.content", hasSize(0))).andExpect(jsonPath("$.total", equalTo(0)));
+    }
+
+    @Test
+    @Description("Retrieves single rollout from management API including extra data that is delivered only for single rollout access.")
+    public void retrieveSingleRollout() throws Exception {
+        testdataFactory.createTargets(20, "rollout", "rollout");
+        final DistributionSet dsA = testdataFactory.createDistributionSet("");
+
+        // create rollout including the created targets with prefix 'rollout'
+        final Rollout rollout = rolloutManagement.create(
+                entityFactory.rollout().create().name("rollout1").set(dsA.getId())
+                        .targetFilterQuery("controllerId==rollout*"),
+                4, new RolloutGroupConditionBuilder().withDefaults()
+                        .successCondition(RolloutGroupSuccessCondition.THRESHOLD, "100").build());
+
+        retrieveAndVerifyRolloutInCreating(dsA, rollout);
+        retrieveAndVerifyRolloutInReady(rollout);
+        retrieveAndVerifyRolloutInStarting(rollout);
+        retrieveAndVerifyRolloutInRunning(rollout);
+    }
+
+    @Step
+    private void retrieveAndVerifyRolloutInRunning(final Rollout rollout) throws Exception {
+        rolloutManagement.handleRollouts();
+
+        mvc.perform(get("/rest/v1/rollouts/" + rollout.getId()).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.id", equalTo(rollout.getId().intValue())))
+                .andExpect(jsonPath("$.name", equalTo("rollout1"))).andExpect(jsonPath("$.status", equalTo("running")))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.running", equalTo(5)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.notstarted", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.scheduled", equalTo(15)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.cancelled", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.finished", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.error", equalTo(0)))
+                .andExpect(jsonPath("$.deleted", equalTo(false)));
+    }
+
+    @Step
+    private void retrieveAndVerifyRolloutInStarting(final Rollout rollout) throws Exception {
+        rolloutManagement.start(rollout.getId());
+
+        mvc.perform(get("/rest/v1/rollouts/" + rollout.getId()).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.id", equalTo(rollout.getId().intValue())))
+                .andExpect(jsonPath("$.name", equalTo("rollout1"))).andExpect(jsonPath("$.status", equalTo("starting")))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.running", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.notstarted", equalTo(20)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.scheduled", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.cancelled", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.finished", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.error", equalTo(0)))
+                .andExpect(jsonPath("$.deleted", equalTo(false)));
+    }
+
+    @Step
+    private void retrieveAndVerifyRolloutInReady(final Rollout rollout) throws Exception {
+        rolloutManagement.handleRollouts();
+
+        mvc.perform(get("/rest/v1/rollouts/" + rollout.getId()).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.id", equalTo(rollout.getId().intValue())))
+                .andExpect(jsonPath("$.name", equalTo("rollout1"))).andExpect(jsonPath("$.status", equalTo("ready")))
+                .andExpect(jsonPath("$.lastModifiedBy", equalTo("bumlux")))
+                .andExpect(jsonPath("$.lastModifiedAt", not(equalTo(0))))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.running", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.notstarted", equalTo(20)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.scheduled", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.cancelled", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.finished", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.error", equalTo(0)))
+                .andExpect(jsonPath("$.deleted", equalTo(false)));
+    }
+
+    @Step
+    private void retrieveAndVerifyRolloutInCreating(final DistributionSet dsA, final Rollout rollout) throws Exception {
+        mvc.perform(get("/rest/v1/rollouts/" + rollout.getId()).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.id", equalTo(rollout.getId().intValue())))
+                .andExpect(jsonPath("$.name", equalTo("rollout1"))).andExpect(jsonPath("$.status", equalTo("creating")))
+                .andExpect(jsonPath("$.targetFilterQuery", equalTo("controllerId==rollout*")))
+                .andExpect(jsonPath("$.distributionSetId", equalTo(dsA.getId().intValue())))
+                .andExpect(jsonPath("$.createdBy", equalTo("bumlux")))
+                .andExpect(jsonPath("$.createdAt", not(equalTo(0))))
+                .andExpect(jsonPath("$.lastModifiedBy", equalTo("bumlux")))
+                .andExpect(jsonPath("$.lastModifiedAt", not(equalTo(0))))
+                .andExpect(jsonPath("$.totalTargets", equalTo(20)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.running", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.notstarted", equalTo(20)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.scheduled", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.cancelled", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.finished", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.error", equalTo(0)))
+                .andExpect(jsonPath("$._links.self.href", startsWith(HREF_ROLLOUT_PREFIX)))
+                .andExpect(jsonPath("$._links.start.href", allOf(startsWith(HREF_ROLLOUT_PREFIX), endsWith("/start"))))
+                .andExpect(jsonPath("$._links.pause.href", allOf(startsWith(HREF_ROLLOUT_PREFIX), endsWith("/pause"))))
+                .andExpect(
+                        jsonPath("$._links.resume.href", allOf(startsWith(HREF_ROLLOUT_PREFIX), endsWith("/resume"))))
+                .andExpect(jsonPath("$._links.groups.href",
+                        allOf(startsWith(HREF_ROLLOUT_PREFIX), containsString("/deploygroups"))))
+                .andExpect(jsonPath("$.deleted", equalTo(false)));
+    }
+
+    @Test
+    @Description("Testing that rollout paged list contains rollouts")
+    public void rolloutPagedListContainsAllRollouts() throws Exception {
+        final DistributionSet dsA = testdataFactory.createDistributionSet("");
+
+        testdataFactory.createTargets(20, "target", "rollout");
+
+        // setup - create 2 rollouts
+        postRollout("rollout1", 10, dsA.getId(), "id==target*", 20);
+        postRollout("rollout2", 5, dsA.getId(), "id==target-0001*", 10);
+
+        // Run here, because Scheduler is disabled during tests
+        rolloutManagement.handleRollouts();
+
+        mvc.perform(get("/rest/v1/rollouts").accept(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk()).andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.content", hasSize(2))).andExpect(jsonPath("$.total", equalTo(2)))
+                .andExpect(jsonPath("content[0].name", equalTo("rollout1")))
+                .andExpect(jsonPath("content[0].status", equalTo("ready")))
+                .andExpect(jsonPath("content[0].targetFilterQuery", equalTo("id==target*")))
+                .andExpect(jsonPath("content[0].distributionSetId", equalTo(dsA.getId().intValue())))
+                .andExpect(jsonPath("content[0].createdBy", equalTo("bumlux")))
+                .andExpect(jsonPath("content[0].createdAt", not(equalTo(0))))
+                .andExpect(jsonPath("content[0].lastModifiedBy", equalTo("bumlux")))
+                .andExpect(jsonPath("content[0].lastModifiedAt", not(equalTo(0))))
+                .andExpect(jsonPath("content[0].totalTargets", equalTo(20)))
+                .andExpect(jsonPath("content[0].totalTargetsPerStatus").doesNotExist())
+                .andExpect(jsonPath("content[0]._links.self.href", startsWith(HREF_ROLLOUT_PREFIX)))
+                .andExpect(jsonPath("content[1].name", equalTo("rollout2")))
+                .andExpect(jsonPath("content[1].status", equalTo("ready")))
+                .andExpect(jsonPath("content[1].targetFilterQuery", equalTo("id==target-0001*")))
+                .andExpect(jsonPath("content[1].distributionSetId", equalTo(dsA.getId().intValue())))
+                .andExpect(jsonPath("content[1].createdBy", equalTo("bumlux")))
+                .andExpect(jsonPath("content[1].createdAt", not(equalTo(0))))
+                .andExpect(jsonPath("content[1].lastModifiedBy", equalTo("bumlux")))
+                .andExpect(jsonPath("content[1].lastModifiedAt", not(equalTo(0))))
+                .andExpect(jsonPath("content[1].totalTargets", equalTo(10)))
+                .andExpect(jsonPath("content[1].totalTargetsPerStatus").doesNotExist())
+                .andExpect(jsonPath("content[1]._links.self.href", startsWith(HREF_ROLLOUT_PREFIX)));
+    }
+
+    @Test
+    @Description("Testing that rollout paged list is limited by the query param limit")
+    public void rolloutPagedListIsLimitedToQueryParam() throws Exception {
+        final DistributionSet dsA = testdataFactory.createDistributionSet("");
+
+        testdataFactory.createTargets(20, "target", "rollout");
+
+        // setup - create 2 rollouts
+        postRollout("rollout1", 10, dsA.getId(), "id==target*", 20);
+        postRollout("rollout2", 5, dsA.getId(), "id==target*", 20);
+
+        // Run here, because Scheduler is disabled during tests
+        rolloutManagement.handleRollouts();
+
+        mvc.perform(get("/rest/v1/rollouts?limit=1").accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.content", hasSize(1))).andExpect(jsonPath("$.total", equalTo(2)));
+    }
+
+    @Test
+    @Description("Testing that rollout paged list is limited by the query param limit")
+    public void retrieveRolloutGroupsForSpecificRollout() throws Exception {
+        // setup
+        final int amountTargets = 20;
+        testdataFactory.createTargets(amountTargets, "rollout", "rollout");
+        final DistributionSet dsA = testdataFactory.createDistributionSet("");
+
+        // create rollout including the created targets with prefix 'rollout'
+        final Rollout rollout = createRollout("rollout1", 4, dsA.getId(), "controllerId==rollout*");
+
+        // retrieve rollout groups from created rollout
+        mvc.perform(
+                get("/rest/v1/rollouts/{rolloutId}/deploygroups", rollout.getId()).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.content", hasSize(4))).andExpect(jsonPath("$.total", equalTo(4)))
+                .andExpect(jsonPath("$.content[0].status", equalTo("ready")))
+                .andExpect(jsonPath("$.content[1].status", equalTo("ready")))
+                .andExpect(jsonPath("$.content[2].status", equalTo("ready")))
+                .andExpect(jsonPath("$.content[3].status", equalTo("ready")));
+    }
+
+    @Test
+    @Description("Testing that starting the rollout switches the state to starting and then to running")
+    public void startingRolloutSwitchesIntoRunningState() throws Exception {
+        // setup
+        final int amountTargets = 20;
+        testdataFactory.createTargets(amountTargets, "rollout", "rollout");
+        final DistributionSet dsA = testdataFactory.createDistributionSet("");
+
+        // create rollout including the created targets with prefix 'rollout'
+        final Rollout rollout = createRollout("rollout1", 4, dsA.getId(), "controllerId==rollout*");
+
+        // starting rollout
+        mvc.perform(post("/rest/v1/rollouts/{rolloutId}/start", rollout.getId())).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk());
+
+        // check rollout is in starting state
+        mvc.perform(get("/rest/v1/rollouts/{rolloutId}", rollout.getId()).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("id", equalTo(rollout.getId().intValue())))
+                .andExpect(jsonPath("status", equalTo("starting")));
+
+        // Run here, because scheduler is disabled during tests
+        rolloutManagement.handleRollouts();
+
+        // check rollout is in running state
+        mvc.perform(get("/rest/v1/rollouts/{rolloutId}", rollout.getId()).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("id", equalTo(rollout.getId().intValue())))
+                .andExpect(jsonPath("status", equalTo("running")));
+    }
+
+    @Test
+    @Description("Testing that pausing the rollout switches the state to paused")
+    public void pausingRolloutSwitchesIntoPausedState() throws Exception {
+        // setup
+        final int amountTargets = 20;
+        testdataFactory.createTargets(amountTargets, "rollout", "rollout");
+        final DistributionSet dsA = testdataFactory.createDistributionSet("");
+
+        // create rollout including the created targets with prefix 'rollout'
+        final Rollout rollout = createRollout("rollout1", 4, dsA.getId(), "controllerId==rollout*");
+
+        // starting rollout
+        mvc.perform(post("/rest/v1/rollouts/{rolloutId}/start", rollout.getId())).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk());
+
+        // Run here, because scheduler is disabled during tests
+        rolloutManagement.handleRollouts();
+
+        // pausing rollout
+        mvc.perform(post("/rest/v1/rollouts/{rolloutId}/pause", rollout.getId())).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk());
+
+        // check rollout is in running state
+        mvc.perform(get("/rest/v1/rollouts/{rolloutId}", rollout.getId()).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("id", equalTo(rollout.getId().intValue())))
+                .andExpect(jsonPath("status", equalTo("paused")));
+    }
+
+    @Test
+    @Description("Testing that resuming the rollout switches the state to running")
+    public void resumingRolloutSwitchesIntoRunningState() throws Exception {
+        // setup
+        final int amountTargets = 20;
+        testdataFactory.createTargets(amountTargets, "rollout", "rollout");
+        final DistributionSet dsA = testdataFactory.createDistributionSet("");
+
+        // create rollout including the created targets with prefix 'rollout'
+        final Rollout rollout = createRollout("rollout1", 4, dsA.getId(), "controllerId==rollout*");
+
+        // starting rollout
+        mvc.perform(post("/rest/v1/rollouts/{rolloutId}/start", rollout.getId())).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk());
+
+        // Run here, because scheduler is disabled during tests
+        rolloutManagement.handleRollouts();
+
+        // pausing rollout
+        mvc.perform(post("/rest/v1/rollouts/{rolloutId}/pause", rollout.getId())).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk());
+
+        // resume rollout
+        mvc.perform(post("/rest/v1/rollouts/{rolloutId}/resume", rollout.getId())).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk());
+
+        // check rollout is in running state
+        mvc.perform(get("/rest/v1/rollouts/{rolloutId}", rollout.getId()).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("id", equalTo(rollout.getId().intValue())))
+                .andExpect(jsonPath("status", equalTo("running")));
+    }
+
+    @Test
+    @Description("Testing that an already started rollout cannot be started again and returns bad request")
+    public void startingAlreadyStartedRolloutReturnsBadRequest() throws Exception {
+        // setup
+        final int amountTargets = 20;
+        testdataFactory.createTargets(amountTargets, "rollout", "rollout");
+        final DistributionSet dsA = testdataFactory.createDistributionSet("");
+
+        // create rollout including the created targets with prefix 'rollout'
+        final Rollout rollout = createRollout("rollout1", 4, dsA.getId(), "controllerId==rollout*");
+
+        // starting rollout
+        mvc.perform(post("/rest/v1/rollouts/{rolloutId}/start", rollout.getId())).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk());
+
+        // Run here, because scheduler is disabled during tests
+        rolloutManagement.handleRollouts();
+
+        // starting rollout - already started should lead into bad request
+        mvc.perform(post("/rest/v1/rollouts/{rolloutId}/start", rollout.getId())).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("errorCode", equalTo("hawkbit.server.error.rollout.illegalstate")));
+    }
+
+    @Test
+    @Description("Testing that resuming a rollout which is not started leads to bad request")
+    public void resumingNotStartedRolloutReturnsBadRequest() throws Exception {
+        // setup
+        final int amountTargets = 20;
+        testdataFactory.createTargets(amountTargets, "rollout", "rollout");
+        final DistributionSet dsA = testdataFactory.createDistributionSet("");
+
+        // create rollout including the created targets with prefix 'rollout'
+        final Rollout rollout = createRollout("rollout1", 4, dsA.getId(), "controllerId==rollout*");
+
+        // resume not yet started rollout
+        mvc.perform(post("/rest/v1/rollouts/{rolloutId}/resume", rollout.getId())).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("errorCode", equalTo("hawkbit.server.error.rollout.illegalstate")));
+    }
+
+    @Test
+    @Description("Testing that starting rollout the first rollout group is in running state")
+    public void startingRolloutFirstRolloutGroupIsInRunningState() throws Exception {
+        // setup
+        final int amountTargets = 10;
+        testdataFactory.createTargets(amountTargets, "rollout", "rollout");
+        final DistributionSet dsA = testdataFactory.createDistributionSet("");
+
+        // create rollout including the created targets with prefix 'rollout'
+        final Rollout rollout = createRollout("rollout1", 2, dsA.getId(), "controllerId==rollout*");
+
+        // starting rollout
+        mvc.perform(post("/rest/v1/rollouts/{rolloutId}/start", rollout.getId())).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk());
+
+        // Run here, because scheduler is disabled during tests
+        rolloutManagement.handleRollouts();
+
+        // retrieve rollout groups from created rollout - 2 groups exists
+        // (amountTargets / groupSize = 2)
+        mvc.perform(get("/rest/v1/rollouts/{rolloutId}/deploygroups?sort=ID:ASC", rollout.getId())
+                .accept(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.content", hasSize(2))).andExpect(jsonPath("$.total", equalTo(2)))
+                .andExpect(jsonPath("$.content[0].status", equalTo("running")))
+                .andExpect(jsonPath("$.content[1].status", equalTo("scheduled")));
+    }
+
+    @Test
+    @Description("Testing that a single rollout group can be retrieved")
+    public void retrieveSingleRolloutGroup() throws Exception {
+        // setup
+        final int amountTargets = 20;
+        testdataFactory.createTargets(amountTargets, "rollout", "rollout");
+        final DistributionSet dsA = testdataFactory.createDistributionSet("");
+
+        // create rollout including the created targets with prefix 'rollout'
+        final Rollout rollout = rolloutManagement.create(
+                entityFactory.rollout().create().name("rollout1").set(dsA.getId())
+                        .targetFilterQuery("controllerId==rollout*"),
+                4, new RolloutGroupConditionBuilder().withDefaults()
+                        .successCondition(RolloutGroupSuccessCondition.THRESHOLD, "100").build());
+
+        final RolloutGroup firstGroup = rolloutGroupManagement
+                .findByRollout(new PageRequest(0, 1, Direction.ASC, "id"), rollout.getId()).getContent().get(0);
+        final RolloutGroup secondGroup = rolloutGroupManagement
+                .findByRollout(new PageRequest(1, 1, Direction.ASC, "id"), rollout.getId()).getContent().get(0);
+
+        retrieveAndVerifyRolloutGroupInCreating(rollout, firstGroup);
+        retrieveAndVerifyRolloutGroupInReady(rollout, firstGroup);
+        retrieveAndVerifyRolloutGroupInRunningAndScheduled(rollout, firstGroup, secondGroup);
+    }
+
+    @Step
+    private void retrieveAndVerifyRolloutGroupInRunningAndScheduled(final Rollout rollout,
+            final RolloutGroup firstGroup, final RolloutGroup secondGroup) throws Exception {
+        rolloutManagement.start(rollout.getId());
+        rolloutManagement.handleRollouts();
+        mvc.perform(get("/rest/v1/rollouts/{rolloutId}/deploygroups/{groupId}", rollout.getId(), firstGroup.getId())
+                .accept(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("status", equalTo("running")))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.running", equalTo(5)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.notstarted", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.scheduled", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.cancelled", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.finished", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.error", equalTo(0)));
+
+        mvc.perform(get("/rest/v1/rollouts/{rolloutId}/deploygroups/{groupId}", rollout.getId(), secondGroup.getId())
+                .accept(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("status", equalTo("scheduled")))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.running", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.notstarted", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.scheduled", equalTo(5)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.cancelled", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.finished", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.error", equalTo(0)));
+    }
+
+    @Step
+    private void retrieveAndVerifyRolloutGroupInReady(final Rollout rollout, final RolloutGroup firstGroup)
+            throws Exception {
+        rolloutManagement.handleRollouts();
+        mvc.perform(get("/rest/v1/rollouts/{rolloutId}/deploygroups/{groupId}", rollout.getId(), firstGroup.getId())
+                .accept(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("status", equalTo("ready")))
+                .andExpect(jsonPath("$.lastModifiedBy", equalTo("bumlux")))
+                .andExpect(jsonPath("$.lastModifiedAt", not(equalTo(0))))
+                .andExpect(jsonPath("$.totalTargets", equalTo(5)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.running", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.notstarted", equalTo(5)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.scheduled", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.cancelled", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.finished", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.error", equalTo(0)));
+    }
+
+    @Step
+    private void retrieveAndVerifyRolloutGroupInCreating(final Rollout rollout, final RolloutGroup firstGroup)
+            throws Exception {
+        mvc.perform(get("/rest/v1/rollouts/{rolloutId}/deploygroups/{groupId}", rollout.getId(), firstGroup.getId())
+                .accept(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("id", equalTo(firstGroup.getId().intValue())))
+                .andExpect(jsonPath("status", equalTo("creating"))).andExpect(jsonPath("name", endsWith("1")))
+                .andExpect(jsonPath("description", endsWith("1")))
+                .andExpect(jsonPath("$.targetFilterQuery", equalTo("")))
+                .andExpect(jsonPath("$.targetPercentage", equalTo(25.0)))
+                .andExpect(jsonPath("$.createdBy", equalTo("bumlux")))
+                .andExpect(jsonPath("$.createdAt", not(equalTo(0))))
+                .andExpect(jsonPath("$.lastModifiedBy", equalTo("bumlux")))
+                .andExpect(jsonPath("$.lastModifiedAt", not(equalTo(0))))
+                .andExpect(jsonPath("$.totalTargets", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.running", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.notstarted", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.scheduled", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.cancelled", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.finished", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.error", equalTo(0)))
+                .andExpect(jsonPath("$._links.self.href", equalTo(
+                        HREF_ROLLOUT_PREFIX + rollout.getId() + "/deploygroups/" + firstGroup.getId().intValue())));
+    }
+
+    @Test
+    @Description("Testing that the targets of rollout group can be retrieved")
+    public void retrieveTargetsFromRolloutGroup() throws Exception {
+        // setup
+        final int amountTargets = 10;
+        testdataFactory.createTargets(amountTargets, "rollout", "rollout");
+        final DistributionSet dsA = testdataFactory.createDistributionSet("");
+
+        // create rollout including the created targets with prefix 'rollout'
+        final Rollout rollout = createRollout("rollout1", 2, dsA.getId(), "controllerId==rollout*");
+
+        final RolloutGroup firstGroup = rolloutGroupManagement
+                .findByRollout(new PageRequest(0, 1, Direction.ASC, "id"), rollout.getId()).getContent().get(0);
+
+        // retrieve targets from the first rollout group with known ID
+        mvc.perform(
+                get("/rest/v1/rollouts/{rolloutId}/deploygroups/{groupId}/targets", rollout.getId(), firstGroup.getId())
+                        .accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.content", hasSize(5))).andExpect(jsonPath("$.total", equalTo(5)));
+    }
+
+    @Test
+    @Description("Testing that the targets of rollout group can be retrieved with rsql query param")
+    public void retrieveTargetsFromRolloutGroupWithQuery() throws Exception {
+        // setup
+        final int amountTargets = 10;
+        testdataFactory.createTargets(amountTargets, "rollout", "rollout");
+        final DistributionSet dsA = testdataFactory.createDistributionSet("");
+
+        // create rollout including the created targets with prefix 'rollout'
+        final Rollout rollout = createRollout("rollout1", 2, dsA.getId(), "controllerId==rollout*");
+
+        final RolloutGroup firstGroup = rolloutGroupManagement
+                .findByRollout(new PageRequest(0, 1, Direction.ASC, "id"), rollout.getId()).getContent().get(0);
+
+        final String targetInGroup = rolloutGroupManagement.findTargetsOfRolloutGroup(PAGE, firstGroup.getId())
+                .getContent().get(0).getControllerId();
+
+        // retrieve targets from the first rollout group with known ID
+        mvc.perform(
+                get("/rest/v1/rollouts/{rolloutId}/deploygroups/{groupId}/targets", rollout.getId(), firstGroup.getId())
+                        .accept(MediaType.APPLICATION_JSON).param("q", "controllerId==" + targetInGroup))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.content", hasSize(1))).andExpect(jsonPath("$.total", equalTo(1)));
+    }
+
+    @Test
+    @Description("Testing that the targets of rollout group can be retrieved after the rollout has been started")
+    public void retrieveTargetsFromRolloutGroupAfterRolloutIsStarted() throws Exception {
+        // setup
+        final int amountTargets = 10;
+        testdataFactory.createTargets(amountTargets, "rollout", "rollout");
+        final DistributionSet dsA = testdataFactory.createDistributionSet("");
+
+        // create rollout including the created targets with prefix 'rollout'
+        final Rollout rollout = createRollout("rollout1", 2, dsA.getId(), "controllerId==rollout*");
+
+        rolloutManagement.start(rollout.getId());
+
+        // Run here, because scheduler is disabled during tests
+        rolloutManagement.handleRollouts();
+
+        final RolloutGroup firstGroup = rolloutGroupManagement
+                .findByRollout(new PageRequest(0, 1, Direction.ASC, "id"), rollout.getId()).getContent().get(0);
+
+        // retrieve targets from the first rollout group with known ID
+        mvc.perform(
+                get("/rest/v1/rollouts/{rolloutId}/deploygroups/{groupId}/targets", rollout.getId(), firstGroup.getId())
+                        .accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.content", hasSize(5))).andExpect(jsonPath("$.total", equalTo(5)));
+    }
+
+    @Test
+    @Description("Start the rollout in async mode")
+    public void startingRolloutSwitchesIntoRunningStateAsync() throws Exception {
+
+        final int amountTargets = 1000;
+        testdataFactory.createTargets(amountTargets, "rollout", "rollout");
+        final DistributionSet dsA = testdataFactory.createDistributionSet("");
+
+        // create rollout including the created targets with prefix 'rollout'
+        final Rollout rollout = createRollout("rollout1", 4, dsA.getId(), "controllerId==rollout*");
+
+        // starting rollout
+        mvc.perform(post("/rest/v1/rollouts/{rolloutId}/start", rollout.getId())).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk());
+
+        // Run here, because scheduler is disabled during tests
+        rolloutManagement.handleRollouts();
+
+        // check if running
+        assertThat(doWithTimeout(() -> getRollout(rollout.getId()), this::success, 60_000, 100)).isNotNull();
+    }
+
+    @Test
+    @Description("Deletion of a rollout")
+    public void deleteRollout() throws Exception {
+        final int amountTargets = 10;
+        testdataFactory.createTargets(amountTargets, "rolloutDelete", "rolloutDelete");
+        final DistributionSet dsA = testdataFactory.createDistributionSet("");
+
+        // create rollout including the created targets with prefix 'rollout'
+        final Rollout rollout = createRollout("rolloutDelete", 4, dsA.getId(), "controllerId==rolloutDelete*");
+
+        // delete rollout
+        mvc.perform(delete("/rest/v1/rollouts/{rolloutid}", rollout.getId())).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk());
+
+        assertThat(getRollout(rollout.getId()).getStatus()).isEqualTo(RolloutStatus.DELETING);
+    }
+
+    @Test
+    @Description("Soft deletion of a rollout: soft deletion appears when already running rollout is being deleted")
+    public void deleteRunningRollout() throws Exception {
+        final Rollout rollout = testdataFactory.createSoftDeletedRollout("softDeletedRollout");
+
+        mvc.perform(get("/rest/v1/rollouts/{rolloutid}", rollout.getId())).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk()).andExpect(jsonPath("$.deleted", equalTo(true)));
+        assertThat(getRollout(rollout.getId()).getStatus()).isEqualTo(RolloutStatus.DELETED);
+    }
+
+    @Test
+    @Description("Testing that rollout paged list with rsql parameter")
+    public void getRolloutWithRSQLParam() throws Exception {
+
+        final int amountTargetsRollout1 = 25;
+        final int amountTargetsRollout2 = 25;
+        final int amountTargetsRollout3 = 25;
+        final int amountTargetsOther = 25;
+        testdataFactory.createTargets(amountTargetsRollout1, "rollout1", "rollout1");
+        testdataFactory.createTargets(amountTargetsRollout2, "rollout2", "rollout2");
+        testdataFactory.createTargets(amountTargetsRollout3, "rollout3", "rollout3");
+        testdataFactory.createTargets(amountTargetsOther, "other1", "other1");
+        final DistributionSet dsA = testdataFactory.createDistributionSet("");
+
+        createRollout("rollout1", 5, dsA.getId(), "controllerId==rollout1*");
+        final Rollout rollout2 = createRollout("rollout2", 5, dsA.getId(), "controllerId==rollout2*");
+        createRollout("rollout3", 5, dsA.getId(), "controllerId==rollout3*");
+        createRollout("other1", 5, dsA.getId(), "controllerId==other1*");
+
+        mvc.perform(get("/rest/v1/rollouts").param(MgmtRestConstants.REQUEST_PARAMETER_SEARCH, "name==*2")
+                .accept(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.content", hasSize(1))).andExpect(jsonPath("$.total", equalTo(1)))
+                .andExpect(jsonPath("$.content[0].name", equalTo(rollout2.getName())));
+
+        mvc.perform(get("/rest/v1/rollouts").accept(MediaType.APPLICATION_JSON)
+                .param(MgmtRestConstants.REQUEST_PARAMETER_SEARCH, "name==rollout*"))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.content", hasSize(3))).andExpect(jsonPath("$.total", equalTo(3)));
+
+        mvc.perform(get("/rest/v1/rollouts").accept(MediaType.APPLICATION_JSON)
+                .param(MgmtRestConstants.REQUEST_PARAMETER_SEARCH, "name==*1")).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk()).andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.content", hasSize(2))).andExpect(jsonPath("$.total", equalTo(2)));
+
+    }
+
+    @Test
+    @Description("Testing that rolloutgroup paged list with rsql parameter")
+    public void retrieveRolloutGroupsForSpecificRolloutWithRSQLParam() throws Exception {
+        // setup
+        final int amountTargets = 20;
+        testdataFactory.createTargets(amountTargets, "rollout", "rollout");
+        final DistributionSet dsA = testdataFactory.createDistributionSet("");
+
+        // create rollout including the created targets with prefix 'rollout'
+        final Rollout rollout = createRollout("rollout1", 4, dsA.getId(), "controllerId==rollout*");
+
+        // retrieve rollout groups from created rollout
+        mvc.perform(get("/rest/v1/rollouts/{rolloutId}/deploygroups", rollout.getId())
+                .accept(MediaType.APPLICATION_JSON).param(MgmtRestConstants.REQUEST_PARAMETER_SEARCH, "name==group-1"))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.content", hasSize(1))).andExpect(jsonPath("$.total", equalTo(1)))
+                .andExpect(jsonPath("$.content[0].name", equalTo("group-1")));
+
+        mvc.perform(get("/rest/v1/rollouts/{rolloutId}/deploygroups", rollout.getId())
+                .accept(MediaType.APPLICATION_JSON).param(MgmtRestConstants.REQUEST_PARAMETER_SEARCH, "name==group*"))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.content", hasSize(4))).andExpect(jsonPath("$.total", equalTo(4)));
+
+        mvc.perform(
+                get("/rest/v1/rollouts/{rolloutId}/deploygroups", rollout.getId()).accept(MediaType.APPLICATION_JSON)
+                        .param(MgmtRestConstants.REQUEST_PARAMETER_SEARCH, "name==group-1,name==group-2"))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.content", hasSize(2))).andExpect(jsonPath("$.total", equalTo(2)));
+
+    }
+
+    protected <T> T doWithTimeout(final Callable<T> callable, final SuccessCondition<T> successCondition,
+            final long timeout, final long pollInterval) throws Exception // NOPMD
+    {
+
+        if (pollInterval < 0) {
+            throw new IllegalArgumentException("pollInterval must non negative");
+        }
+
+        long duration = 0;
+        Exception exception = null;
+        T returnValue = null;
+        while (untilTimeoutReached(timeout, duration)) {
+            try {
+                returnValue = callable.call();
+                // clear exception
+                exception = null;
+            } catch (final Exception ex) {
+                exception = ex;
+            }
+            Thread.sleep(pollInterval);
+            duration += pollInterval > 0 ? pollInterval : 1;
+            if (exception == null && successCondition.success(returnValue)) {
+                return returnValue;
+            } else {
+                returnValue = null;
+            }
+        }
+        if (exception != null) {
+            throw exception;
+        }
+        return returnValue;
+    }
+
+    protected boolean untilTimeoutReached(final long timeout, final long duration) {
+        return duration <= timeout || timeout < 0;
+    }
+
+    private void postRollout(final String name, final int groupSize, final Long distributionSetId,
+            final String targetFilterQuery, final int targets) throws Exception {
+        mvc.perform(post("/rest/v1/rollouts")
+                .content(JsonBuilder.rollout(name, "desc", groupSize, distributionSetId, targetFilterQuery,
+                        new RolloutGroupConditionBuilder().withDefaults().build()))
+                .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isCreated())
+                .andExpect(jsonPath("$.name", equalTo(name))).andExpect(jsonPath("$.status", equalTo("creating")))
+                .andExpect(jsonPath("$.targetFilterQuery", equalTo(targetFilterQuery)))
+                .andExpect(jsonPath("$.description", equalTo("desc")))
+                .andExpect(jsonPath("$.distributionSetId", equalTo(distributionSetId.intValue())))
+                .andExpect(jsonPath("$.createdBy", equalTo("bumlux")))
+                .andExpect(jsonPath("$.createdAt", not(equalTo(0))))
+                .andExpect(jsonPath("$.lastModifiedBy", equalTo("bumlux")))
+                .andExpect(jsonPath("$.lastModifiedAt", not(equalTo(0))))
+                .andExpect(jsonPath("$.totalTargets", equalTo(targets)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.running", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.notstarted", equalTo(targets)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.scheduled", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.cancelled", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.finished", equalTo(0)))
+                .andExpect(jsonPath("$.totalTargetsPerStatus.error", equalTo(0)))
+                .andExpect(jsonPath("$._links.self.href", startsWith(HREF_ROLLOUT_PREFIX)))
+                .andExpect(jsonPath("$._links.start.href", allOf(startsWith(HREF_ROLLOUT_PREFIX), endsWith("/start"))))
+                .andExpect(jsonPath("$._links.pause.href", allOf(startsWith(HREF_ROLLOUT_PREFIX), endsWith("/pause"))))
+                .andExpect(
+                        jsonPath("$._links.resume.href", allOf(startsWith(HREF_ROLLOUT_PREFIX), endsWith("/resume"))))
+                .andExpect(jsonPath("$._links.groups.href",
+                        allOf(startsWith(HREF_ROLLOUT_PREFIX), containsString("/deploygroups"))));
+    }
+
+    private Rollout createRollout(final String name, final int amountGroups, final long distributionSetId,
+            final String targetFilterQuery) {
+        final Rollout rollout = rolloutManagement.create(
+                entityFactory.rollout().create().name(name).set(distributionSetId).targetFilterQuery(targetFilterQuery),
+                amountGroups, new RolloutGroupConditionBuilder().withDefaults()
+                        .successCondition(RolloutGroupSuccessCondition.THRESHOLD, "100").build());
+
+        // Run here, because Scheduler is disabled during tests
+        rolloutManagement.handleRollouts();
+
+        return rolloutManagement.get(rollout.getId()).get();
+    }
+
+    protected boolean success(final Rollout result) {
+        return result != null && result.getStatus() == RolloutStatus.RUNNING;
+    }
+
+    public Rollout getRollout(final Long rolloutId) throws Exception {
+        return rolloutManagement.get(rolloutId).get();
+    }
+
+}

hawkbit-rest/hawkbit-mgmt-resource/src/test/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtSoftwareModuleTypeResourceTest.java

@@ -0,0 +1,420 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.Matchers.hasSize;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
+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.MockMvcResultMatchers.content;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.apache.commons.lang3.RandomStringUtils;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.repository.model.SoftwareModuleType;
+import org.eclipse.hawkbit.repository.test.util.WithUser;
+import org.eclipse.hawkbit.rest.util.JsonBuilder;
+import org.eclipse.hawkbit.rest.util.MockMvcResultPrinter;
+import org.json.JSONObject;
+import org.junit.Test;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MvcResult;
+
+import com.jayway.jsonpath.JsonPath;
+
+import ru.yandex.qatools.allure.annotations.Description;
+import ru.yandex.qatools.allure.annotations.Features;
+import ru.yandex.qatools.allure.annotations.Stories;
+
+/**
+ * Test for {@link MgmtSoftwareModuleTypeResource}.
+ *
+ */
+@Features("Component Tests - Management API")
+@Stories("Software Module Type Resource")
+public class MgmtSoftwareModuleTypeResourceTest extends AbstractManagementApiIntegrationTest {
+
+    @Test
+    @WithUser(principal = "uploadTester", allSpPermissions = true)
+    @Description("Checks the correct behaviour of /rest/v1/softwaremoduletypes GET requests.")
+    public void getSoftwareModuleTypes() throws Exception {
+        final SoftwareModuleType testType = createTestType();
+
+        mvc.perform(get("/rest/v1/softwaremoduletypes").accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.content.[?(@.key==" + osType.getKey() + ")].name", contains(osType.getName())))
+                .andExpect(jsonPath("$.content.[?(@.key==" + osType.getKey() + ")].description",
+                        contains(osType.getDescription())))
+                .andExpect(jsonPath("$.content.[?(@.key==" + osType.getKey() + ")].maxAssignments", contains(1)))
+                .andExpect(jsonPath("$.content.[?(@.key==" + osType.getKey() + ")].key", contains("os")))
+                .andExpect(jsonPath("$.content.[?(@.key==" + runtimeType.getKey() + ")].name",
+                        contains(runtimeType.getName())))
+                .andExpect(jsonPath("$.content.[?(@.key==" + runtimeType.getKey() + ")].description",
+                        contains(runtimeType.getDescription())))
+                .andExpect(jsonPath("$.content.[?(@.key==" + runtimeType.getKey() + ")].maxAssignments", contains(1)))
+                .andExpect(jsonPath("$.content.[?(@.key==" + runtimeType.getKey() + ")].key", contains("runtime")))
+                .andExpect(jsonPath("$.content.[?(@.key==" + appType.getKey() + ")].name", contains(appType.getName())))
+                .andExpect(jsonPath("$.content.[?(@.key==" + appType.getKey() + ")].description",
+                        contains(appType.getDescription())))
+                .andExpect(jsonPath("$.content.[?(@.key==" + appType.getKey() + ")].maxAssignments",
+                        contains(Integer.MAX_VALUE)))
+                .andExpect(jsonPath("$.content.[?(@.key==" + appType.getKey() + ")].key", contains("application")))
+                .andExpect(jsonPath("$.content.[?(@.key==test123)].id", contains(testType.getId().intValue())))
+                .andExpect(jsonPath("$.content.[?(@.key==test123)].name", contains("TestName123")))
+                .andExpect(jsonPath("$.content.[?(@.key==test123)].description", contains("Desc1234")))
+                .andExpect(jsonPath("$.content.[?(@.key==test123)].createdBy", contains("uploadTester")))
+                .andExpect(jsonPath("$.content.[?(@.key==test123)].createdAt", contains(testType.getCreatedAt())))
+                .andExpect(jsonPath("$.content.[?(@.key==test123)].lastModifiedBy", contains("uploadTester")))
+                .andExpect(jsonPath("$.content.[?(@.key==test123)].lastModifiedAt",
+                        contains(testType.getLastModifiedAt())))
+                .andExpect(jsonPath("$.content.[?(@.key==test123)].maxAssignments", contains(5)))
+                .andExpect(jsonPath("$.content.[?(@.key==test123)].key", contains("test123")))
+                .andExpect(jsonPath("$.total", equalTo(4)));
+    }
+
+    private SoftwareModuleType createTestType() {
+        SoftwareModuleType testType = softwareModuleTypeManagement.create(entityFactory.softwareModuleType().create()
+                .key("test123").name("TestName123").description("Desc123").maxAssignments(5));
+        testType = softwareModuleTypeManagement
+                .update(entityFactory.softwareModuleType().update(testType.getId()).description("Desc1234"));
+        return testType;
+    }
+
+    @Test
+    @WithUser(principal = "uploadTester", allSpPermissions = true)
+    @Description("Checks the correct behaviour of /rest/v1/softwaremoduletypes GET requests with sorting by MAXASSIGNMENTS field.")
+    public void getSoftwareModuleTypesSortedByMaxAssignments() throws Exception {
+        final SoftwareModuleType testType = createTestType();
+
+        // descending
+        mvc.perform(get("/rest/v1/softwaremoduletypes").accept(MediaType.APPLICATION_JSON)
+                .param(MgmtRestConstants.REQUEST_PARAMETER_SORTING, "MAXASSIGNMENTS:DESC"))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.content.[1].id", equalTo(testType.getId().intValue())))
+                .andExpect(jsonPath("$.content.[1].name", equalTo("TestName123")))
+                .andExpect(jsonPath("$.content.[1].description", equalTo("Desc1234")))
+                .andExpect(jsonPath("$.content.[1].createdBy", equalTo("uploadTester")))
+                .andExpect(jsonPath("$.content.[1].createdAt", equalTo(testType.getCreatedAt())))
+                .andExpect(jsonPath("$.content.[1].lastModifiedBy", equalTo("uploadTester")))
+                .andExpect(jsonPath("$.content.[1].lastModifiedAt", equalTo(testType.getLastModifiedAt())))
+                .andExpect(jsonPath("$.content.[1].maxAssignments", equalTo(5)))
+                .andExpect(jsonPath("$.content.[1].key", equalTo("test123")))
+                .andExpect(jsonPath("$.total", equalTo(4)));
+
+        // ascending
+        mvc.perform(get("/rest/v1/softwaremoduletypes").accept(MediaType.APPLICATION_JSON)
+                .param(MgmtRestConstants.REQUEST_PARAMETER_SORTING, "MAXASSIGNMENTS:ASC"))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.content.[2].id", equalTo(testType.getId().intValue())))
+                .andExpect(jsonPath("$.content.[2].name", equalTo("TestName123")))
+                .andExpect(jsonPath("$.content.[2].description", equalTo("Desc1234")))
+                .andExpect(jsonPath("$.content.[2].createdBy", equalTo("uploadTester")))
+                .andExpect(jsonPath("$.content.[2].createdAt", equalTo(testType.getCreatedAt())))
+                .andExpect(jsonPath("$.content.[2].lastModifiedBy", equalTo("uploadTester")))
+                .andExpect(jsonPath("$.content.[2].lastModifiedAt", equalTo(testType.getLastModifiedAt())))
+                .andExpect(jsonPath("$.content.[2].maxAssignments", equalTo(5)))
+                .andExpect(jsonPath("$.content.[2].key", equalTo("test123")))
+                .andExpect(jsonPath("$.total", equalTo(4)));
+    }
+
+    @Test
+    @WithUser(principal = "uploadTester", allSpPermissions = true)
+    @Description("Checks the correct behaviour of /rest/v1/softwaremoduletypes POST requests when max assignment is smaller than 1")
+    public void createSoftwareModuleTypesInvalidAssignmentBadRequest() throws Exception {
+
+        final List<SoftwareModuleType> types = new ArrayList<>();
+        types.add(entityFactory.softwareModuleType().create().key("test-1").name("TestName-1").maxAssignments(-1)
+                .build());
+
+        mvc.perform(post("/rest/v1/softwaremoduletypes/").content(JsonBuilder.softwareModuleTypes(types))
+                .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isBadRequest());
+
+        types.clear();
+        types.add(entityFactory.softwareModuleType().create().key("test0").name("TestName0").maxAssignments(0).build());
+
+        mvc.perform(post("/rest/v1/softwaremoduletypes/").content(JsonBuilder.softwareModuleTypes(types))
+                .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isBadRequest());
+    }
+
+    @Test
+    @WithUser(principal = "uploadTester", allSpPermissions = true)
+    @Description("Checks the correct behaviour of /rest/v1/softwaremoduletypes POST requests.")
+    public void createSoftwareModuleTypes() throws Exception {
+
+        final List<SoftwareModuleType> types = Arrays.asList(
+                entityFactory.softwareModuleType().create().key("test1").name("TestName1").description("Desc1")
+                        .colour("col1‚").maxAssignments(1).build(),
+                entityFactory.softwareModuleType().create().key("test2").name("TestName2").description("Desc2")
+                        .colour("col2‚").maxAssignments(2).build(),
+                entityFactory.softwareModuleType().create().key("test3").name("TestName3").description("Desc3")
+                        .colour("col3‚").maxAssignments(3).build());
+
+        final MvcResult mvcResult = mvc
+                .perform(post("/rest/v1/softwaremoduletypes/").content(JsonBuilder.softwareModuleTypes(types))
+                        .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isCreated())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("[0].name", equalTo("TestName1"))).andExpect(jsonPath("[0].key", equalTo("test1")))
+                .andExpect(jsonPath("[0].description", equalTo("Desc1")))
+                .andExpect(jsonPath("[0].createdBy", equalTo("uploadTester")))
+                .andExpect(jsonPath("[0].maxAssignments", equalTo(1)))
+                .andExpect(jsonPath("[1].name", equalTo("TestName2"))).andExpect(jsonPath("[1].key", equalTo("test2")))
+                .andExpect(jsonPath("[1].description", equalTo("Desc2")))
+                .andExpect(jsonPath("[1].createdBy", equalTo("uploadTester")))
+                .andExpect(jsonPath("[1].maxAssignments", equalTo(2)))
+                .andExpect(jsonPath("[2].name", equalTo("TestName3"))).andExpect(jsonPath("[2].key", equalTo("test3")))
+                .andExpect(jsonPath("[2].description", equalTo("Desc3")))
+                .andExpect(jsonPath("[2].createdBy", equalTo("uploadTester")))
+                .andExpect(jsonPath("[2].createdAt", not(equalTo(0))))
+                .andExpect(jsonPath("[2].maxAssignments", equalTo(3))).andReturn();
+
+        final SoftwareModuleType created1 = softwareModuleTypeManagement.getByKey("test1").get();
+        final SoftwareModuleType created2 = softwareModuleTypeManagement.getByKey("test2").get();
+        final SoftwareModuleType created3 = softwareModuleTypeManagement.getByKey("test3").get();
+
+        assertThat(
+                JsonPath.compile("[0]_links.self.href").read(mvcResult.getResponse().getContentAsString()).toString())
+                        .isEqualTo("http://localhost/rest/v1/softwaremoduletypes/" + created1.getId());
+        assertThat(
+                JsonPath.compile("[1]_links.self.href").read(mvcResult.getResponse().getContentAsString()).toString())
+                        .isEqualTo("http://localhost/rest/v1/softwaremoduletypes/" + created2.getId());
+        assertThat(
+                JsonPath.compile("[2]_links.self.href").read(mvcResult.getResponse().getContentAsString()).toString())
+                        .isEqualTo("http://localhost/rest/v1/softwaremoduletypes/" + created3.getId());
+
+        assertThat(softwareModuleTypeManagement.count()).isEqualTo(6);
+    }
+
+    @Test
+    @WithUser(principal = "uploadTester", allSpPermissions = true)
+    @Description("Checks the correct behaviour of /rest/v1/softwaremoduletypes/{ID} GET requests.")
+    public void getSoftwareModuleType() throws Exception {
+        final SoftwareModuleType testType = createTestType();
+
+        mvc.perform(get("/rest/v1/softwaremoduletypes/{smtId}", testType.getId()).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.name", equalTo("TestName123")))
+                .andExpect(jsonPath("$.description", equalTo("Desc1234")))
+                .andExpect(jsonPath("$.maxAssignments", equalTo(5)))
+                .andExpect(jsonPath("$.createdBy", equalTo("uploadTester")))
+                .andExpect(jsonPath("$.createdAt", equalTo(testType.getCreatedAt())))
+                .andExpect(jsonPath("$.lastModifiedBy", equalTo("uploadTester")))
+                .andExpect(jsonPath("$.lastModifiedAt", equalTo(testType.getLastModifiedAt())))
+                .andExpect(jsonPath("$.deleted", equalTo(testType.isDeleted())));
+    }
+
+    @Test
+    @WithUser(principal = "uploadTester", allSpPermissions = true)
+    @Description("Checks the correct behaviour of /rest/v1/softwaremoduletypes/{ID} DELETE requests (hard delete scenario).")
+    public void deleteSoftwareModuleTypeUnused() throws Exception {
+        final SoftwareModuleType testType = createTestType();
+
+        assertThat(softwareModuleTypeManagement.count()).isEqualTo(4);
+
+        mvc.perform(delete("/rest/v1/softwaremoduletypes/{smId}", testType.getId())).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk());
+
+        assertThat(softwareModuleTypeManagement.count()).isEqualTo(3);
+    }
+
+    @Test
+    @Description("Ensures that module type deletion request to API on an entity that does not exist results in NOT_FOUND.")
+    public void deleteSoftwareModuleTypeThatDoesNotExistLeadsToNotFound() throws Exception {
+        mvc.perform(delete("/rest/v1/softwaremoduletypes/1234")).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isNotFound());
+    }
+
+    @Test
+    @WithUser(principal = "uploadTester", allSpPermissions = true)
+    @Description("Checks the correct behaviour of /rest/v1/softwaremoduletypes/{ID} DELETE requests (soft delete scenario).")
+    public void deleteSoftwareModuleTypeUsed() throws Exception {
+        final SoftwareModuleType testType = createTestType();
+        softwareModuleManagement
+                .create(entityFactory.softwareModule().create().type(testType).name("name").version("version"));
+
+        assertThat(softwareModuleTypeManagement.count()).isEqualTo(4);
+
+        mvc.perform(get("/rest/v1/softwaremoduletypes/{smtId}", testType.getId())).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk()).andExpect(jsonPath("$.deleted", equalTo(false)));
+
+        mvc.perform(delete("/rest/v1/softwaremoduletypes/{smtId}", testType.getId()))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk());
+
+        mvc.perform(get("/rest/v1/softwaremoduletypes/{smtId}", testType.getId())).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk()).andExpect(jsonPath("$.deleted", equalTo(true)));
+
+        assertThat(softwareModuleTypeManagement.count()).isEqualTo(3);
+    }
+
+    @Test
+    @Description("Checks the correct behaviour of /rest/v1/softwaremoduletypes/{ID} PUT requests.")
+    public void updateSoftwareModuleTypeOnlyDescriptionAndNameUntouched() throws Exception {
+        final SoftwareModuleType testType = createTestType();
+
+        final String body = new JSONObject().put("id", testType.getId()).put("description", "foobardesc")
+                .put("name", "nameShouldNotBeChanged").toString();
+
+        mvc.perform(put("/rest/v1/softwaremoduletypes/{smId}", testType.getId()).content(body)
+                .contentType(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(jsonPath("$.id", equalTo(testType.getId().intValue())))
+                .andExpect(jsonPath("$.description", equalTo("foobardesc")))
+                .andExpect(jsonPath("$.name", equalTo("TestName123"))).andReturn();
+
+    }
+
+    @Test
+    @Description("Tests the update of the deletion flag. It is verfied that the software module type can't be marked as deleted through update operation.")
+    public void updateSoftwareModuleTypeDeletedFlag() throws Exception {
+        SoftwareModuleType testType = createTestType();
+
+        final String body = new JSONObject().put("id", testType.getId()).put("deleted", true).toString();
+
+        mvc.perform(put("/rest/v1/softwaremoduletypes/{smtId}", testType.getId()).content(body)
+                .contentType(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(jsonPath("$.id", equalTo(testType.getId().intValue())))
+                .andExpect(jsonPath("$.lastModifiedAt", equalTo(testType.getLastModifiedAt())))
+                .andExpect(jsonPath("$.deleted", equalTo(false)));
+
+        testType = softwareModuleTypeManagement.get(testType.getId()).get();
+        assertThat(testType.getLastModifiedAt()).isEqualTo(testType.getLastModifiedAt());
+        assertThat(testType.isDeleted()).isEqualTo(false);
+    }
+
+    @Test
+    @Description("Checks the correct behaviour of /rest/v1/softwaremoduletypes GET requests with paging.")
+    public void getSoftwareModuleTypesWithoutAddtionalRequestParameters() throws Exception {
+        final int types = 3;
+        mvc.perform(get(MgmtRestConstants.SOFTWAREMODULETYPE_V1_REQUEST_MAPPING)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk())
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_TOTAL, equalTo(types)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_SIZE, equalTo(types)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_CONTENT, hasSize(types)));
+    }
+
+    @Test
+    @Description("Checks the correct behaviour of /rest/v1/softwaremoduletypes GET requests with paging.")
+    public void getSoftwareModuleTypesWithPagingLimitRequestParameter() throws Exception {
+        final int types = 3;
+        final int limitSize = 1;
+        mvc.perform(get(MgmtRestConstants.SOFTWAREMODULETYPE_V1_REQUEST_MAPPING)
+                .param(MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, String.valueOf(limitSize)))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_TOTAL, equalTo(types)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_SIZE, equalTo(limitSize)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_CONTENT, hasSize(limitSize)));
+    }
+
+    @Test
+    @Description("Checks the correct behaviour of /rest/v1/softwaremoduletypes GET requests with paging.")
+    public void getSoftwareModuleTypesWithPagingLimitAndOffsetRequestParameter() throws Exception {
+        final int types = 3;
+        final int offsetParam = 2;
+        final int expectedSize = types - offsetParam;
+        mvc.perform(get(MgmtRestConstants.SOFTWAREMODULETYPE_V1_REQUEST_MAPPING)
+                .param(MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, String.valueOf(offsetParam))
+                .param(MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, String.valueOf(types)))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_TOTAL, equalTo(types)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_SIZE, equalTo(expectedSize)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_CONTENT, hasSize(expectedSize)));
+    }
+
+    @Test
+    @Description("Ensures that the server is behaving as expected on invalid requests (wrong media type, wrong ID etc.).")
+    public void invalidRequestsOnSoftwaremoduleTypesResource() throws Exception {
+        final SoftwareModuleType testType = createTestType();
+
+        final List<SoftwareModuleType> types = Arrays.asList(testType);
+
+        // SM does not exist
+        mvc.perform(get("/rest/v1/softwaremoduletypes/12345678")).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isNotFound());
+
+        mvc.perform(delete("/rest/v1/softwaremoduletypes/12345678")).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isNotFound());
+
+        // bad request - no content
+        mvc.perform(post("/rest/v1/softwaremoduletypes").contentType(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isBadRequest());
+
+        // bad request - bad content
+        mvc.perform(post("/rest/v1/softwaremoduletypes").content("sdfjsdlkjfskdjf".getBytes())
+                .contentType(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isBadRequest());
+
+        mvc.perform(post("/rest/v1/softwaremoduletypes").content(
+                "[{\"description\":\"Desc123\",\"id\":9223372036854775807,\"key\":\"test123\",\"maxAssignments\":5}]")
+                .contentType(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isBadRequest());
+
+        final SoftwareModuleType toLongName = entityFactory.softwareModuleType().create().key("test123")
+                .name(RandomStringUtils.randomAlphanumeric(80)).build();
+        mvc.perform(
+                post("/rest/v1/softwaremoduletypes").content(JsonBuilder.softwareModuleTypes(Arrays.asList(toLongName)))
+                        .contentType(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isBadRequest());
+
+        // unsupported media type
+        mvc.perform(post("/rest/v1/softwaremoduletypes").content(JsonBuilder.softwareModuleTypes(types))
+                .contentType(MediaType.APPLICATION_OCTET_STREAM)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isUnsupportedMediaType());
+
+        // not allowed methods
+        mvc.perform(put("/rest/v1/softwaremoduletypes")).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isMethodNotAllowed());
+
+        mvc.perform(delete("/rest/v1/softwaremoduletypes")).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isMethodNotAllowed());
+
+    }
+
+    @Test
+    @Description("Search erquest of software module types.")
+    public void searchSoftwareModuleTypeRsql() throws Exception {
+        softwareModuleTypeManagement.create(entityFactory.softwareModuleType().create().key("test123")
+                .name("TestName123").description("Desc123").maxAssignments(5));
+        softwareModuleTypeManagement.create(entityFactory.softwareModuleType().create().key("test1234")
+                .name("TestName1234").description("Desc1234").maxAssignments(5));
+
+        final String rsqlFindLikeDs1OrDs2 = "name==TestName123,name==TestName1234";
+
+        mvc.perform(get("/rest/v1/softwaremoduletypes?q=" + rsqlFindLikeDs1OrDs2)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isOk()).andExpect(jsonPath("size", equalTo(2)))
+                .andExpect(jsonPath("total", equalTo(2))).andExpect(jsonPath("content[0].name", equalTo("TestName123")))
+                .andExpect(jsonPath("content[1].name", equalTo("TestName1234")));
+
+    }
+
+    private void createSoftwareModulesAlphabetical(final int amount) {
+        char character = 'a';
+        for (int index = 0; index < amount; index++) {
+            final String str = String.valueOf(character);
+            softwareModuleManagement.create(entityFactory.softwareModule().create().type(osType).name(str)
+                    .description(str).vendor(str).version(str));
+            character++;
+        }
+    }
+
+}

hawkbit-rest/hawkbit-mgmt-resource/src/test/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtTargetFilterQueryResourceTest.java

@@ -0,0 +1,399 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.Matchers.hasSize;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
+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.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+import org.eclipse.hawkbit.exception.SpServerError;
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.repository.exception.QuotaExceededException;
+import org.eclipse.hawkbit.repository.model.DistributionSet;
+import org.eclipse.hawkbit.repository.model.TargetFilterQuery;
+import org.eclipse.hawkbit.rest.exception.MessageNotReadableException;
+import org.eclipse.hawkbit.rest.json.model.ExceptionInfo;
+import org.eclipse.hawkbit.rest.util.MockMvcResultPrinter;
+import org.json.JSONObject;
+import org.junit.Test;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MvcResult;
+
+import ru.yandex.qatools.allure.annotations.Description;
+import ru.yandex.qatools.allure.annotations.Features;
+import ru.yandex.qatools.allure.annotations.Stories;
+
+/**
+ * Spring MVC Tests against the MgmtTargetResource.
+ *
+ */
+@Features("Component Tests - Management API")
+@Stories("Target Filter Query Resource")
+public class MgmtTargetFilterQueryResourceTest extends AbstractManagementApiIntegrationTest {
+
+    private static final String JSON_PATH_ROOT = "$";
+
+    // fields, attributes
+    private static final String JSON_PATH_FIELD_ID = ".id";
+    private static final String JSON_PATH_FIELD_NAME = ".name";
+    private static final String JSON_PATH_FIELD_QUERY = ".query";
+    private static final String JSON_PATH_FIELD_CONTENT = ".content";
+    private static final String JSON_PATH_FIELD_SIZE = ".size";
+    private static final String JSON_PATH_FIELD_TOTAL = ".total";
+    private static final String JSON_PATH_FIELD_AUTO_ASSIGN_DS = ".autoAssignDistributionSet";
+    private static final String JSON_PATH_FIELD_EXCEPTION_CLASS = ".exceptionClass";
+    private static final String JSON_PATH_FIELD_ERROR_CODE = ".errorCode";
+
+    // target
+    // $.field
+    static final String JSON_PATH_PAGED_LIST_CONTENT = JSON_PATH_ROOT + JSON_PATH_FIELD_CONTENT;
+    static final String JSON_PATH_PAGED_LIST_SIZE = JSON_PATH_ROOT + JSON_PATH_FIELD_SIZE;
+    static final String JSON_PATH_PAGED_LIST_TOTAL = JSON_PATH_ROOT + JSON_PATH_FIELD_TOTAL;
+
+    private static final String JSON_PATH_NAME = JSON_PATH_ROOT + JSON_PATH_FIELD_NAME;
+    private static final String JSON_PATH_ID = JSON_PATH_ROOT + JSON_PATH_FIELD_ID;
+    private static final String JSON_PATH_QUERY = JSON_PATH_ROOT + JSON_PATH_FIELD_QUERY;
+    private static final String JSON_PATH_AUTO_ASSIGN_DS = JSON_PATH_ROOT + JSON_PATH_FIELD_AUTO_ASSIGN_DS;
+    private static final String JSON_PATH_EXCEPTION_CLASS = JSON_PATH_ROOT + JSON_PATH_FIELD_EXCEPTION_CLASS;
+    private static final String JSON_PATH_ERROR_CODE = JSON_PATH_ROOT + JSON_PATH_FIELD_ERROR_CODE;
+
+    @Test
+    @Description("Ensures that deletion is executed if permitted.")
+    public void deleteTargetFilterQueryReturnsOK() throws Exception {
+        final String filterName = "filter_01";
+        final TargetFilterQuery filterQuery = createSingleTargetFilterQuery(filterName, "name=test_01");
+
+        mvc.perform(delete(MgmtRestConstants.TARGET_FILTER_V1_REQUEST_MAPPING + "/" + filterQuery.getId()))
+                .andExpect(status().isOk());
+
+        assertThat(targetFilterQueryManagement.get(filterQuery.getId())).isNotPresent();
+    }
+
+    @Test
+    @Description("Ensures that deletion is refused with not found if target does not exist.")
+    public void deleteTargetWhichDoesNotExistsLeadsToEntityNotFound() throws Exception {
+        final String notExistingId = "4395";
+
+        mvc.perform(delete(MgmtRestConstants.TARGET_FILTER_V1_REQUEST_MAPPING + "/" + notExistingId))
+                .andExpect(status().isNotFound());
+    }
+
+    @Test
+    @Description("Ensures that update is refused with not found if target does not exist.")
+    public void updateTargetWhichDoesNotExistsLeadsToEntityNotFound() throws Exception {
+        final String notExistingId = "4395";
+        mvc.perform(put(MgmtRestConstants.TARGET_FILTER_V1_REQUEST_MAPPING + "/" + notExistingId).content("{}")
+                .contentType(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print())
+                .andExpect(status().isNotFound());
+    }
+
+    @Test
+    @Description("Ensures that update request is reflected by repository.")
+    public void updateTargetFilterQueryQuery() throws Exception {
+        final String filterName = "filter_02";
+        final String filterQuery = "name=test_02";
+        final String filterQuery2 = "name=test_02_changed";
+        final String body = new JSONObject().put("query", filterQuery2).toString();
+
+        // prepare
+        final TargetFilterQuery tfq = createSingleTargetFilterQuery(filterName, filterQuery);
+
+        mvc.perform(put(MgmtRestConstants.TARGET_FILTER_V1_REQUEST_MAPPING + "/" + tfq.getId()).content(body)
+                .contentType(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(jsonPath("$.id", equalTo(tfq.getId().intValue())))
+                .andExpect(jsonPath("$.query", equalTo(filterQuery2)))
+                .andExpect(jsonPath("$.name", equalTo(filterName)));
+
+        final TargetFilterQuery tfqCheck = targetFilterQueryManagement.get(tfq.getId()).get();
+        assertThat(tfqCheck.getQuery()).isEqualTo(filterQuery2);
+        assertThat(tfqCheck.getName()).isEqualTo(filterName);
+    }
+
+    @Test
+    @Description("Ensures that update request is reflected by repository.")
+    public void updateTargetFilterQueryName() throws Exception {
+        final String filterName = "filter_03";
+        final String filterName2 = "filter_03_changed";
+        final String filterQuery = "name=test_03";
+        final String body = new JSONObject().put("name", filterName2).toString();
+
+        // prepare
+        final TargetFilterQuery tfq = targetFilterQueryManagement
+                .create(entityFactory.targetFilterQuery().create().name(filterName).query(filterQuery));
+
+        mvc.perform(put(MgmtRestConstants.TARGET_FILTER_V1_REQUEST_MAPPING + "/" + tfq.getId()).content(body)
+                .contentType(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(jsonPath("$.id", equalTo(tfq.getId().intValue())))
+                .andExpect(jsonPath("$.query", equalTo(filterQuery)))
+                .andExpect(jsonPath("$.name", equalTo(filterName2)));
+
+        final TargetFilterQuery tfqCheck = targetFilterQueryManagement.get(tfq.getId()).get();
+        assertThat(tfqCheck.getQuery()).isEqualTo(filterQuery);
+        assertThat(tfqCheck.getName()).isEqualTo(filterName2);
+    }
+
+    @Test
+    @Description("Ensures that request returns list of filters in defined format.")
+    public void getTargetFilterQueryWithoutAdditionalRequestParameters() throws Exception {
+        final int knownTargetAmount = 3;
+        final String idA = "a";
+        final String idB = "b";
+        final String idC = "c";
+        final String testQuery = "name=test";
+
+        createSingleTargetFilterQuery(idA, testQuery);
+        createSingleTargetFilterQuery(idB, testQuery);
+        createSingleTargetFilterQuery(idC, testQuery);
+
+        mvc.perform(get(MgmtRestConstants.TARGET_FILTER_V1_REQUEST_MAPPING)).andExpect(status().isOk())
+                .andDo(MockMvcResultPrinter.print())
+                .andExpect(jsonPath(JSON_PATH_PAGED_LIST_TOTAL, equalTo(knownTargetAmount)))
+                .andExpect(jsonPath(JSON_PATH_PAGED_LIST_SIZE, equalTo(knownTargetAmount)))
+                .andExpect(jsonPath(JSON_PATH_PAGED_LIST_CONTENT, hasSize(knownTargetAmount)))
+                // idA
+                .andExpect(jsonPath("$.content.[?(@.name==" + idA + ")].name", contains(idA)))
+                .andExpect(jsonPath("$.content.[?(@.name==" + idA + ")].query", contains(testQuery)))
+                // idB
+                .andExpect(jsonPath("$.content.[?(@.name==" + idB + ")].name", contains(idB)))
+                .andExpect(jsonPath("$.content.[?(@.name==" + idB + ")].query", contains(testQuery)))
+                // idC
+                .andExpect(jsonPath("$.content.[?(@.name==" + idC + ")].name", contains(idC)))
+                .andExpect(jsonPath("$.content.[?(@.name==" + idC + ")].query", contains(testQuery)));
+    }
+
+    @Test
+    @Description("Ensures that request returns list of filters in defined format in size reduced by given limit parameter.")
+    public void getTargetWithPagingLimitRequestParameter() throws Exception {
+        final int limitSize = 1;
+        final int knownTargetAmount = 3;
+        final String idA = "a";
+        final String idB = "b";
+        final String idC = "c";
+        final String testQuery = "name=test";
+
+        createSingleTargetFilterQuery(idA, testQuery);
+        createSingleTargetFilterQuery(idB, testQuery);
+        createSingleTargetFilterQuery(idC, testQuery);
+
+        mvc.perform(get(MgmtRestConstants.TARGET_FILTER_V1_REQUEST_MAPPING)
+                .param(MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, String.valueOf(limitSize)))
+                .andExpect(status().isOk()).andDo(MockMvcResultPrinter.print())
+                .andExpect(jsonPath(JSON_PATH_PAGED_LIST_TOTAL, equalTo(knownTargetAmount)))
+                .andExpect(jsonPath(JSON_PATH_PAGED_LIST_SIZE, equalTo(limitSize)))
+                .andExpect(jsonPath(JSON_PATH_PAGED_LIST_CONTENT, hasSize(limitSize)))
+                // idA
+                .andExpect(jsonPath("$.content.[?(@.name==" + idA + ")].name", contains(idA)))
+                .andExpect(jsonPath("$.content.[?(@.name==" + idA + ")].query", contains(testQuery)));
+    }
+
+    @Test
+    @Description("Ensures that request returns list of filters in defined format in size reduced by given limit and offset parameter.")
+    public void getTargetWithPagingLimitAndOffsetRequestParameter() throws Exception {
+        final int knownTargetAmount = 5;
+        final int offsetParam = 2;
+        final int expectedSize = knownTargetAmount - offsetParam;
+        final String idC = "c";
+        final String idD = "d";
+        final String idE = "e";
+        final String testQuery = "name=test";
+
+        createSingleTargetFilterQuery("a", testQuery);
+        createSingleTargetFilterQuery("b", testQuery);
+        createSingleTargetFilterQuery(idC, testQuery);
+        createSingleTargetFilterQuery(idD, testQuery);
+        createSingleTargetFilterQuery(idE, testQuery);
+
+        mvc.perform(get(MgmtRestConstants.TARGET_FILTER_V1_REQUEST_MAPPING)
+                .param(MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, String.valueOf(offsetParam))
+                .param(MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, String.valueOf(knownTargetAmount)))
+                .andExpect(status().isOk()).andDo(MockMvcResultPrinter.print())
+                .andExpect(jsonPath(JSON_PATH_PAGED_LIST_TOTAL, equalTo(knownTargetAmount)))
+                .andExpect(jsonPath(JSON_PATH_PAGED_LIST_SIZE, equalTo(expectedSize)))
+                .andExpect(jsonPath(JSON_PATH_PAGED_LIST_CONTENT, hasSize(expectedSize)))
+                // idA
+                .andExpect(jsonPath("$.content.[?(@.name==" + idC + ")].name", contains(idC)))
+                .andExpect(jsonPath("$.content.[?(@.name==" + idC + ")].query", contains(testQuery)))
+                // idB
+                .andExpect(jsonPath("$.content.[?(@.name==" + idD + ")].name", contains(idD)))
+                .andExpect(jsonPath("$.content.[?(@.name==" + idD + ")].query", contains(testQuery)))
+                // idC
+                .andExpect(jsonPath("$.content.[?(@.name==" + idE + ")].name", contains(idE)))
+                .andExpect(jsonPath("$.content.[?(@.name==" + idE + ")].query", contains(testQuery)));
+    }
+
+    @Test
+    @Description("Ensures that a single target filter query can be retrieved via its id.")
+    public void getSingleTarget() throws Exception {
+        // create first a target which can be retrieved by rest interface
+        final String knownQuery = "name=test01";
+        final String knownName = "someName";
+        final TargetFilterQuery tfq = createSingleTargetFilterQuery(knownName, knownQuery);
+        final String hrefPrefix = "http://localhost" + MgmtRestConstants.TARGET_FILTER_V1_REQUEST_MAPPING + "/"
+                + tfq.getId();
+        // test
+        mvc.perform(get(MgmtRestConstants.TARGET_FILTER_V1_REQUEST_MAPPING + "/" + tfq.getId()))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(jsonPath(JSON_PATH_NAME, equalTo(knownName)))
+                .andExpect(jsonPath(JSON_PATH_QUERY, equalTo(knownQuery)))
+                .andExpect(jsonPath("$._links.self.href", equalTo(hrefPrefix)))
+                .andExpect(jsonPath("$._links.autoAssignDS.href", equalTo(hrefPrefix + "/autoAssignDS")));
+    }
+
+    @Test
+    @Description("Ensures that the retrieval of a non-existing target filter query results in a HTTP Not found error (404).")
+    public void getSingleTargetNoExistsResponseNotFound() throws Exception {
+        final String targetIdNotExists = "546546";
+        // test
+
+        final MvcResult mvcResult = mvc
+                .perform(get(MgmtRestConstants.TARGET_FILTER_V1_REQUEST_MAPPING + "/" + targetIdNotExists))
+                .andExpect(status().isNotFound()).andReturn();
+
+        // verify response json exception message
+        final ExceptionInfo exceptionInfo = ResourceUtility
+                .convertException(mvcResult.getResponse().getContentAsString());
+        assertThat(exceptionInfo.getErrorCode()).isEqualTo(SpServerError.SP_REPO_ENTITY_NOT_EXISTS.getKey());
+    }
+
+    @Test
+    @Description("Ensures that the creation of a target filter query based on an invalid request payload results in a HTTP Bad Request error (400).")
+    public void createTargetFilterQueryWithBadPayloadBadRequest() throws Exception {
+        final String notJson = "abc";
+
+        final MvcResult mvcResult = mvc
+                .perform(post(MgmtRestConstants.TARGET_FILTER_V1_REQUEST_MAPPING).content(notJson)
+                        .contentType(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isBadRequest()).andReturn();
+
+        assertThat(targetFilterQueryManagement.count()).isEqualTo(0);
+
+        // verify response json exception message
+        final ExceptionInfo exceptionInfo = ResourceUtility
+                .convertException(mvcResult.getResponse().getContentAsString());
+        assertThat(exceptionInfo.getExceptionClass()).isEqualTo(MessageNotReadableException.class.getName());
+        assertThat(exceptionInfo.getErrorCode()).isEqualTo(SpServerError.SP_REST_BODY_NOT_READABLE.getKey());
+    }
+
+    @Test
+    @Description("Ensures that the assignment of an auto-assign distribution set results in a HTTP Forbidden error (403) "
+            + "if the (existing) query addresses too many targets.")
+    public void setAutoAssignDistributionSetOnFilterQueryThatExceedsQuota() throws Exception {
+
+        // create targets
+        final int maxTargets = quotaManagement.getMaxTargetsPerAutoAssignment();
+        testdataFactory.createTargets(maxTargets + 1, "target%s");
+
+        // create the filter query and the distribution set
+        final DistributionSet set = testdataFactory.createDistributionSet();
+        final TargetFilterQuery filterQuery = createSingleTargetFilterQuery("1", "controllerId==target*");
+
+        mvc.perform(
+                post(MgmtRestConstants.TARGET_FILTER_V1_REQUEST_MAPPING + "/" + filterQuery.getId() + "/autoAssignDS")
+                        .content("{\"id\":" + set.getId() + "}").contentType(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isForbidden())
+                .andExpect(jsonPath(JSON_PATH_EXCEPTION_CLASS, equalTo(QuotaExceededException.class.getName())))
+                .andExpect(jsonPath(JSON_PATH_ERROR_CODE, equalTo(SpServerError.SP_QUOTA_EXCEEDED.getKey())));
+    }
+
+    @Test
+    @Description("Ensures that the update of a target filter query results in a HTTP Forbidden error (403) "
+            + "if the updated query addresses too many targets.")
+    public void updateTargetFilterQueryWithQueryThatExceedsQuota() throws Exception {
+
+        // create targets
+        final int maxTargets = quotaManagement.getMaxTargetsPerAutoAssignment();
+        testdataFactory.createTargets(maxTargets + 1, "target%s");
+
+        // create the filter query and the distribution set
+        final DistributionSet set = testdataFactory.createDistributionSet();
+        final TargetFilterQuery filterQuery = createSingleTargetFilterQuery("1", "controllerId==target1");
+
+        // assign the auto-assign distribution set, this should work
+        mvc.perform(
+                post(MgmtRestConstants.TARGET_FILTER_V1_REQUEST_MAPPING + "/" + filterQuery.getId() + "/autoAssignDS")
+                        .content("{\"id\":" + set.getId() + "}").contentType(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk());
+
+        assertThat(targetFilterQueryManagement.get(filterQuery.getId()).get().getAutoAssignDistributionSet())
+                .isEqualTo(set);
+
+        // update the query of the filter query to trigger a quota hit
+        mvc.perform(put(MgmtRestConstants.TARGET_FILTER_V1_REQUEST_MAPPING + "/" + filterQuery.getId())
+                .content("{\"query\":\"controllerId==target*\"}").contentType(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isForbidden())
+                .andExpect(jsonPath(JSON_PATH_EXCEPTION_CLASS, equalTo(QuotaExceededException.class.getName())))
+                .andExpect(jsonPath(JSON_PATH_ERROR_CODE, equalTo(SpServerError.SP_QUOTA_EXCEEDED.getKey())));
+
+    }
+
+    @Test
+    public void setAutoAssignDistributionSetToTargetFilterQuery() throws Exception {
+
+        final String knownQuery = "name==test05";
+        final String knownName = "filter05";
+
+        final DistributionSet set = testdataFactory.createDistributionSet();
+        final TargetFilterQuery tfq = createSingleTargetFilterQuery(knownName, knownQuery);
+
+        mvc.perform(post(MgmtRestConstants.TARGET_FILTER_V1_REQUEST_MAPPING + "/" + tfq.getId() + "/autoAssignDS")
+                .content("{\"id\":" + set.getId() + "}").contentType(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk());
+
+        assertThat(targetFilterQueryManagement.get(tfq.getId()).get().getAutoAssignDistributionSet()).isEqualTo(set);
+
+        final String hrefPrefix = "http://localhost" + MgmtRestConstants.TARGET_FILTER_V1_REQUEST_MAPPING + "/"
+                + tfq.getId();
+
+        mvc.perform(get(MgmtRestConstants.TARGET_FILTER_V1_REQUEST_MAPPING + "/" + tfq.getId()))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(jsonPath(JSON_PATH_NAME, equalTo(knownName)))
+                .andExpect(jsonPath(JSON_PATH_QUERY, equalTo(knownQuery)))
+                .andExpect(jsonPath(JSON_PATH_AUTO_ASSIGN_DS, equalTo(set.getId().intValue())))
+                .andExpect(jsonPath("$._links.self.href", equalTo(hrefPrefix)))
+                .andExpect(jsonPath("$._links.autoAssignDS.href", equalTo(hrefPrefix + "/autoAssignDS")));
+    }
+
+    @Test
+    public void deleteAutoAssignDistributionSetOfTargetFilterQuery() throws Exception {
+
+        final String knownQuery = "name==test06";
+        final String knownName = "filter06";
+        final String dsName = "testDS";
+
+        final DistributionSet set = testdataFactory.createDistributionSet(dsName);
+        final TargetFilterQuery tfq = createSingleTargetFilterQuery(knownName, knownQuery);
+        targetFilterQueryManagement.updateAutoAssignDS(tfq.getId(), set.getId());
+
+        assertThat(targetFilterQueryManagement.get(tfq.getId()).get().getAutoAssignDistributionSet()).isEqualTo(set);
+
+        mvc.perform(get(MgmtRestConstants.TARGET_FILTER_V1_REQUEST_MAPPING + "/" + tfq.getId() + "/autoAssignDS"))
+                .andExpect(status().isOk()).andExpect(jsonPath(JSON_PATH_NAME, equalTo(dsName)));
+
+        mvc.perform(delete(MgmtRestConstants.TARGET_FILTER_V1_REQUEST_MAPPING + "/" + tfq.getId() + "/autoAssignDS"))
+                .andExpect(status().isNoContent());
+
+        assertThat(targetFilterQueryManagement.get(tfq.getId()).get().getAutoAssignDistributionSet()).isNull();
+
+        mvc.perform(get(MgmtRestConstants.TARGET_FILTER_V1_REQUEST_MAPPING + "/" + tfq.getId() + "/autoAssignDS"))
+                .andExpect(status().isNoContent());
+
+    }
+
+    private TargetFilterQuery createSingleTargetFilterQuery(final String name, final String query) {
+        return targetFilterQueryManagement.create(entityFactory.targetFilterQuery().create().name(name).query(query));
+    }
+
+}

hawkbit-rest/hawkbit-mgmt-resource/src/test/java/org/eclipse/hawkbit/mgmt/rest/resource/MgmtTargetTagResourceTest.java

@@ -0,0 +1,313 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.Matchers.hasSize;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
+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.MockMvcResultMatchers.content;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.eclipse.hawkbit.mgmt.rest.api.MgmtRestConstants;
+import org.eclipse.hawkbit.repository.event.remote.TargetTagDeletedEvent;
+import org.eclipse.hawkbit.repository.event.remote.entity.TargetCreatedEvent;
+import org.eclipse.hawkbit.repository.event.remote.entity.TargetTagCreatedEvent;
+import org.eclipse.hawkbit.repository.event.remote.entity.TargetTagUpdatedEvent;
+import org.eclipse.hawkbit.repository.event.remote.entity.TargetUpdatedEvent;
+import org.eclipse.hawkbit.repository.model.Tag;
+import org.eclipse.hawkbit.repository.model.Target;
+import org.eclipse.hawkbit.repository.model.TargetTag;
+import org.eclipse.hawkbit.repository.test.matcher.Expect;
+import org.eclipse.hawkbit.repository.test.matcher.ExpectEvents;
+import org.eclipse.hawkbit.rest.util.JsonBuilder;
+import org.eclipse.hawkbit.rest.util.MockMvcResultPrinter;
+import org.junit.Test;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.ResultActions;
+
+import ru.yandex.qatools.allure.annotations.Description;
+import ru.yandex.qatools.allure.annotations.Features;
+import ru.yandex.qatools.allure.annotations.Stories;
+
+/**
+ * Spring MVC Tests against the MgmtTargetTagResource.
+ *
+ */
+@Features("Component Tests - Management API")
+@Stories("Target Tag Resource")
+public class MgmtTargetTagResourceTest extends AbstractManagementApiIntegrationTest {
+
+    private static final String TARGETTAGS_ROOT = "http://localhost" + MgmtRestConstants.TARGET_TAG_V1_REQUEST_MAPPING
+            + "/";
+
+    @Test
+    @Description("Verfies that a paged result list of target tags reflects the content on the repository side.")
+    @ExpectEvents({ @Expect(type = TargetTagCreatedEvent.class, count = 2) })
+    public void getTargetTags() throws Exception {
+        final List<TargetTag> tags = testdataFactory.createTargetTags(2, "");
+        final TargetTag assigned = tags.get(0);
+        final TargetTag unassigned = tags.get(1);
+
+        mvc.perform(get(MgmtRestConstants.TARGET_TAG_V1_REQUEST_MAPPING).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(applyTagMatcherOnPagedResult(assigned)).andExpect(applyTagMatcherOnPagedResult(unassigned))
+                .andExpect(applySelfLinkMatcherOnPagedResult(assigned, TARGETTAGS_ROOT + assigned.getId()))
+                .andExpect(applySelfLinkMatcherOnPagedResult(unassigned, TARGETTAGS_ROOT + unassigned.getId()))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_TOTAL, equalTo(2)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_SIZE, equalTo(2)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_CONTENT, hasSize(2)));
+
+    }
+
+    @Test
+    @Description("Verfies that a single result of a target tag reflects the content on the repository side.")
+    @ExpectEvents({ @Expect(type = TargetTagCreatedEvent.class, count = 2) })
+    public void getTargetTag() throws Exception {
+        final List<TargetTag> tags = testdataFactory.createTargetTags(2, "");
+        final TargetTag assigned = tags.get(0);
+
+        mvc.perform(get(MgmtRestConstants.TARGET_TAG_V1_REQUEST_MAPPING + "/" + assigned.getId())
+                .accept(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(applyTagMatcherOnSingleResult(assigned))
+                .andExpect(applySelfLinkMatcherOnSingleResult(TARGETTAGS_ROOT + assigned.getId()))
+                .andExpect(jsonPath("_links.assignedTargets.href",
+                        equalTo(TARGETTAGS_ROOT + assigned.getId() + "/assigned?offset=0&limit=50{&sort,q}")));
+
+    }
+
+    @Test
+    @Description("Verifies that created target tags are stored in the repository as send to the API.")
+    @ExpectEvents({ @Expect(type = TargetTagCreatedEvent.class, count = 2) })
+    public void createTargetTags() throws Exception {
+        final Tag tagOne = entityFactory.tag().create().colour("testcol1").description("its a test1").name("thetest1")
+                .build();
+        final Tag tagTwo = entityFactory.tag().create().colour("testcol2").description("its a test2").name("thetest2")
+                .build();
+
+        final ResultActions result = mvc
+                .perform(post(MgmtRestConstants.TARGET_TAG_V1_REQUEST_MAPPING)
+                        .content(JsonBuilder.tags(Arrays.asList(tagOne, tagTwo)))
+                        .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isCreated())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE));
+
+        final Tag createdOne = targetTagManagement.findByRsql(PAGE, "name==thetest1").getContent().get(0);
+        assertThat(createdOne.getName()).isEqualTo(tagOne.getName());
+        assertThat(createdOne.getDescription()).isEqualTo(tagOne.getDescription());
+        assertThat(createdOne.getColour()).isEqualTo(tagOne.getColour());
+        final Tag createdTwo = targetTagManagement.findByRsql(PAGE, "name==thetest2").getContent().get(0);
+        assertThat(createdTwo.getName()).isEqualTo(tagTwo.getName());
+        assertThat(createdTwo.getDescription()).isEqualTo(tagTwo.getDescription());
+        assertThat(createdTwo.getColour()).isEqualTo(tagTwo.getColour());
+
+        result.andExpect(applyTagMatcherOnArrayResult(createdOne)).andExpect(applyTagMatcherOnArrayResult(createdTwo));
+    }
+
+    @Test
+    @Description("Verifies that an updated target tag is stored in the repository as send to the API.")
+    @ExpectEvents({ @Expect(type = TargetTagCreatedEvent.class, count = 1),
+            @Expect(type = TargetTagUpdatedEvent.class, count = 1) })
+    public void updateTargetTag() throws Exception {
+        final List<TargetTag> tags = testdataFactory.createTargetTags(1, "");
+        final TargetTag original = tags.get(0);
+
+        final Tag update = entityFactory.tag().create().name("updatedName").colour("updatedCol")
+                .description("updatedDesc").build();
+
+        final ResultActions result = mvc
+                .perform(put(MgmtRestConstants.TARGET_TAG_V1_REQUEST_MAPPING + "/" + original.getId())
+                        .content(JsonBuilder.tag(update)).contentType(MediaType.APPLICATION_JSON)
+                        .accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE));
+
+        final Tag updated = targetTagManagement.findByRsql(PAGE, "name==updatedName").getContent().get(0);
+        assertThat(updated.getName()).isEqualTo(update.getName());
+        assertThat(updated.getDescription()).isEqualTo(update.getDescription());
+        assertThat(updated.getColour()).isEqualTo(update.getColour());
+
+        result.andExpect(applyTagMatcherOnArrayResult(updated)).andExpect(applyTagMatcherOnArrayResult(updated));
+    }
+
+    @Test
+    @Description("Verfies that the delete call is reflected by the repository.")
+    @ExpectEvents({ @Expect(type = TargetTagCreatedEvent.class, count = 1),
+            @Expect(type = TargetTagDeletedEvent.class, count = 1) })
+    public void deleteTargetTag() throws Exception {
+        final List<TargetTag> tags = testdataFactory.createTargetTags(1, "");
+        final TargetTag original = tags.get(0);
+
+        mvc.perform(delete(MgmtRestConstants.TARGET_TAG_V1_REQUEST_MAPPING + "/" + original.getId()))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk());
+
+        assertThat(targetTagManagement.get(original.getId())).isNotPresent();
+    }
+
+    @Test
+    @Description("Ensures that assigned targets to tag in repository are listed with proper paging results.")
+    @ExpectEvents({ @Expect(type = TargetTagCreatedEvent.class, count = 1),
+            @Expect(type = TargetCreatedEvent.class, count = 5), @Expect(type = TargetUpdatedEvent.class, count = 5) })
+    public void getAssignedTargets() throws Exception {
+        final TargetTag tag = testdataFactory.createTargetTags(1, "").get(0);
+        final int targetsAssigned = 5;
+        final List<Target> targets = testdataFactory.createTargets(targetsAssigned);
+        targetManagement.toggleTagAssignment(targets.stream().map(Target::getControllerId).collect(Collectors.toList()),
+                tag.getName());
+
+        mvc.perform(get(MgmtRestConstants.TARGET_TAG_V1_REQUEST_MAPPING + "/" + tag.getId() + "/assigned"))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_TOTAL, equalTo(targetsAssigned)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_SIZE, equalTo(targetsAssigned)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_CONTENT, hasSize(targetsAssigned)));
+    }
+
+    @Test
+    @Description("Ensures that assigned DS to tag in repository are listed with proper paging results with paging limit parameter.")
+    @ExpectEvents({ @Expect(type = TargetTagCreatedEvent.class, count = 1),
+            @Expect(type = TargetCreatedEvent.class, count = 5), @Expect(type = TargetUpdatedEvent.class, count = 5) })
+    public void getAssignedTargetsWithPagingLimitRequestParameter() throws Exception {
+        final TargetTag tag = testdataFactory.createTargetTags(1, "").get(0);
+        final int targetsAssigned = 5;
+        final int limitSize = 1;
+        final List<Target> targets = testdataFactory.createTargets(targetsAssigned);
+        targetManagement.toggleTagAssignment(targets.stream().map(Target::getControllerId).collect(Collectors.toList()),
+                tag.getName());
+
+        mvc.perform(get(MgmtRestConstants.TARGET_TAG_V1_REQUEST_MAPPING + "/" + tag.getId() + "/assigned")
+                .param(MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, String.valueOf(limitSize)))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_TOTAL, equalTo(targetsAssigned)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_SIZE, equalTo(limitSize)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_CONTENT, hasSize(limitSize)));
+    }
+
+    @Test
+    @Description("Ensures that assigned targets to tag in repository are listed with proper paging results with paging limit and offset parameter.")
+    @ExpectEvents({ @Expect(type = TargetTagCreatedEvent.class, count = 1),
+            @Expect(type = TargetCreatedEvent.class, count = 5), @Expect(type = TargetUpdatedEvent.class, count = 5) })
+    public void getAssignedTargetsWithPagingLimitAndOffsetRequestParameter() throws Exception {
+        final TargetTag tag = testdataFactory.createTargetTags(1, "").get(0);
+        final int targetsAssigned = 5;
+        final int offsetParam = 2;
+        final int expectedSize = targetsAssigned - offsetParam;
+
+        final List<Target> targets = testdataFactory.createTargets(targetsAssigned);
+        targetManagement.toggleTagAssignment(targets.stream().map(Target::getControllerId).collect(Collectors.toList()),
+                tag.getName());
+
+        mvc.perform(get(MgmtRestConstants.TARGET_TAG_V1_REQUEST_MAPPING + "/" + tag.getId() + "/assigned")
+                .param(MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, String.valueOf(offsetParam))
+                .param(MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, String.valueOf(targetsAssigned)))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_TOTAL, equalTo(targetsAssigned)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_SIZE, equalTo(expectedSize)))
+                .andExpect(jsonPath(MgmtTargetResourceTest.JSON_PATH_PAGED_LIST_CONTENT, hasSize(expectedSize)));
+    }
+
+    @Test
+    @Description("verfies that tag assignments done through toggle API command are correctly assigned or unassigned.")
+    @ExpectEvents({ @Expect(type = TargetTagCreatedEvent.class, count = 1),
+            @Expect(type = TargetCreatedEvent.class, count = 2), @Expect(type = TargetUpdatedEvent.class, count = 4) })
+    public void toggleTagAssignment() throws Exception {
+        final TargetTag tag = testdataFactory.createTargetTags(1, "").get(0);
+        final int targetsAssigned = 2;
+        final List<Target> targets = testdataFactory.createTargets(targetsAssigned);
+
+        ResultActions result = toggle(tag, targets);
+
+        List<Target> updated = targetManagement.findByTag(PAGE, tag.getId()).getContent();
+
+        assertThat(updated.stream().map(Target::getControllerId).collect(Collectors.toList()))
+                .containsAll(targets.stream().map(Target::getControllerId).collect(Collectors.toList()));
+
+        result.andExpect(applyTargetEntityMatcherOnArrayResult(updated.get(0), "assignedTargets"))
+                .andExpect(applyTargetEntityMatcherOnArrayResult(updated.get(1), "assignedTargets"));
+
+        result = toggle(tag, targets);
+
+        updated = targetManagement.findAll(PAGE).getContent();
+
+        result.andExpect(applyTargetEntityMatcherOnArrayResult(updated.get(0), "unassignedTargets"))
+                .andExpect(applyTargetEntityMatcherOnArrayResult(updated.get(1), "unassignedTargets"));
+
+        assertThat(targetManagement.findByTag(PAGE, tag.getId())).isEmpty();
+    }
+
+    private ResultActions toggle(final TargetTag tag, final List<Target> targets) throws Exception {
+        return mvc
+                .perform(post(MgmtRestConstants.TARGET_TAG_V1_REQUEST_MAPPING + "/" + tag.getId()
+                        + "/assigned/toggleTagAssignment")
+                                .content(JsonBuilder.controllerIds(
+                                        targets.stream().map(Target::getControllerId).collect(Collectors.toList())))
+                                .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE));
+    }
+
+    @Test
+    @Description("Verfies that tag assignments done through tag API command are correctly stored in the repository.")
+    @ExpectEvents({ @Expect(type = TargetTagCreatedEvent.class, count = 1),
+            @Expect(type = TargetCreatedEvent.class, count = 2), @Expect(type = TargetUpdatedEvent.class, count = 2) })
+    public void assignTargets() throws Exception {
+        final TargetTag tag = testdataFactory.createTargetTags(1, "").get(0);
+        final int targetsAssigned = 2;
+        final List<Target> targets = testdataFactory.createTargets(targetsAssigned);
+
+        final ResultActions result = mvc
+                .perform(post(MgmtRestConstants.TARGET_TAG_V1_REQUEST_MAPPING + "/" + tag.getId() + "/assigned")
+                        .content(JsonBuilder.controllerIds(
+                                targets.stream().map(Target::getControllerId).collect(Collectors.toList())))
+                        .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON))
+                .andDo(MockMvcResultPrinter.print()).andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE));
+
+        final List<Target> updated = targetManagement.findByTag(PAGE, tag.getId()).getContent();
+
+        assertThat(updated.stream().map(Target::getControllerId).collect(Collectors.toList()))
+                .containsAll(targets.stream().map(Target::getControllerId).collect(Collectors.toList()));
+
+        result.andExpect(applyTargetEntityMatcherOnArrayResult(updated.get(0)))
+                .andExpect(applyTargetEntityMatcherOnArrayResult(updated.get(1)));
+    }
+
+    @Test
+    @Description("Verfies that tag unassignments done through tag API command are correctly stored in the repository.")
+    @ExpectEvents({ @Expect(type = TargetTagCreatedEvent.class, count = 1),
+            @Expect(type = TargetCreatedEvent.class, count = 2), @Expect(type = TargetUpdatedEvent.class, count = 3) })
+    public void unassignTarget() throws Exception {
+        final TargetTag tag = testdataFactory.createTargetTags(1, "").get(0);
+        final int targetsAssigned = 2;
+        final List<Target> targets = testdataFactory.createTargets(targetsAssigned);
+        final Target assigned = targets.get(0);
+        final Target unassigned = targets.get(1);
+
+        targetManagement.toggleTagAssignment(targets.stream().map(Target::getControllerId).collect(Collectors.toList()),
+                tag.getName());
+
+        mvc.perform(delete(MgmtRestConstants.TARGET_TAG_V1_REQUEST_MAPPING + "/" + tag.getId() + "/assigned/"
+                + unassigned.getControllerId())).andDo(MockMvcResultPrinter.print()).andExpect(status().isOk());
+
+        final List<Target> updated = targetManagement.findByTag(PAGE, tag.getId()).getContent();
+
+        assertThat(updated.stream().map(Target::getControllerId).collect(Collectors.toList()))
+                .containsOnly(assigned.getControllerId());
+    }
+
+}

hawkbit-rest/hawkbit-mgmt-resource/src/test/java/org/eclipse/hawkbit/mgmt/rest/resource/ResourceUtility.java

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2015 Bosch Software Innovations GmbH and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.hawkbit.mgmt.rest.resource;
+
+import java.io.IOException;
+
+import org.eclipse.hawkbit.mgmt.json.model.PagedList;
+import org.eclipse.hawkbit.mgmt.json.model.artifact.MgmtArtifact;
+import org.eclipse.hawkbit.rest.json.model.ExceptionInfo;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+/**
+ * Utility additions for the REST API tests.
+ *
+ *
+ *
+ *
+ */
+public final class ResourceUtility {
+    private static final ObjectMapper mapper = new ObjectMapper();
+
+    static ExceptionInfo convertException(final String jsonExceptionResponse)
+            throws JsonParseException, JsonMappingException, IOException {
+        return mapper.readValue(jsonExceptionResponse, ExceptionInfo.class);
+    }
+
+    static MgmtArtifact convertArtifactResponse(final String jsonResponse)
+            throws JsonParseException, JsonMappingException, IOException {
+        return mapper.readValue(jsonResponse, MgmtArtifact.class);
+
+    }
+
+    static <T> PagedList<T> mapResponse(final Class<T> clazz, final String responseBody)
+            throws JsonParseException, JsonMappingException, IOException {
+        return mapper.readValue(responseBody, PagedList.class);
+    }
+
+}