Refactoring of RepostioryManagement and extending classes (#2174)

* createMetaData renamed to putMetaData
* getXXX methods returing Optional are renamed to findXXX
* unified method order (code cosmetics)

Signed-off-by: Avgustin Marinov <Avgustin.Marinov@bosch.com>

hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/JpaManagementHelper.java

@@ -44,7 +44,7 @@ public final class JpaManagementHelper {
     }
 
     public static <T, J extends T> Page<T> findAllWithCountBySpec(final JpaSpecificationExecutor<J> repository,
-            final Pageable pageable, final List<Specification<J>> specList) {
+            final List<Specification<J>> specList, final Pageable pageable) {
         if (CollectionUtils.isEmpty(specList)) {
             return convertPage(repository.findAll(Specification.where(null), pageable), pageable);
         }

hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/builder/JpaDistributionSetCreate.java

@@ -59,7 +59,7 @@ public class JpaDistributionSetCreate extends AbstractDistributionSetUpdateCreat
     }
 
     private DistributionSetType findDistributionSetTypeWithExceptionIfNotFound(final String distributionSetTypekey) {
-        return distributionSetTypeManagement.getByKey(distributionSetTypekey)
+        return distributionSetTypeManagement.findByKey(distributionSetTypekey)
                 .orElseThrow(() -> new EntityNotFoundException(DistributionSetType.class, distributionSetTypekey));
     }
 

hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/builder/JpaSoftwareModuleCreate.java

@@ -51,7 +51,7 @@ public class JpaSoftwareModuleCreate extends AbstractSoftwareModuleUpdateCreate<
             throw new ValidationException("type cannot be null");
         }
 
-        return softwareModuleTypeManagement.getByKey(type.trim())
+        return softwareModuleTypeManagement.findByKey(type.trim())
                 .orElseThrow(() -> new EntityNotFoundException(SoftwareModuleType.class, type.trim()));
     }
 }

hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/management/JpaControllerManagement.java

@@ -582,7 +582,7 @@ public class JpaControllerManagement extends JpaActionManagement implements Cont
     public boolean updateOfflineAssignedVersion(@NotEmpty final String controllerId, final String distributionName, final String version) {
         List<DistributionSetAssignmentResult> distributionSetAssignmentResults =
                 systemSecurityContext.runAsSystem(() ->
-                        distributionSetManagement.getByNameAndVersion(distributionName, version).map(
+                        distributionSetManagement.findByNameAndVersion(distributionName, version).map(
                                         distributionSet -> deploymentManagement.offlineAssignedDistributionSets(
                                                 List.of(Map.entry(controllerId, distributionSet.getId())), controllerId))
                                 .orElseThrow(() ->

hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/management/JpaDeploymentManagement.java

@@ -316,7 +316,7 @@ public class JpaDeploymentManagement extends JpaActionManagement implements Depl
                 RSQLUtility.buildRsqlSpecification(rsqlParam, ActionFields.class, virtualPropertyReplacer, database),
                 ActionSpecifications.byTargetControllerId(controllerId));
 
-        return JpaManagementHelper.findAllWithCountBySpec(actionRepository, pageable, specList);
+        return JpaManagementHelper.findAllWithCountBySpec(actionRepository, specList, pageable);
     }
 
     @Override

hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/management/JpaDistributionSetManagement.java

@@ -155,8 +155,9 @@ public class JpaDistributionSetManagement implements DistributionSetManagement {
             backoff = @Backoff(delay = Constants.TX_RT_DELAY))
     public List<DistributionSet> create(final Collection<DistributionSetCreate> creates) {
         final List<JpaDistributionSet> toCreate = creates.stream().map(JpaDistributionSetCreate.class::cast)
-                .map(this::setDefaultTypeIfMissing).map(JpaDistributionSetCreate::build).toList();
-
+                .map(this::setDefaultTypeIfMissing)
+                .map(JpaDistributionSetCreate::build)
+                .toList();
         return Collections.unmodifiableList(distributionSetRepository.saveAll(AccessController.Operation.CREATE, toCreate));
     }
 
@@ -168,7 +169,6 @@ public class JpaDistributionSetManagement implements DistributionSetManagement {
     public DistributionSet create(final DistributionSetCreate c) {
         final JpaDistributionSetCreate create = (JpaDistributionSetCreate) c;
         setDefaultTypeIfMissing(create);
-
         return distributionSetRepository.save(AccessController.Operation.CREATE, create.build());
     }
 
@@ -207,11 +207,6 @@ public class JpaDistributionSetManagement implements DistributionSetManagement {
         return distributionSetRepository.save(set);
     }
 
-    @Override
-    public long count() {
-        return distributionSetRepository.count(DistributionSetSpecification.isNotDeleted());
-    }
-
     @Override
     @Transactional
     @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
@@ -263,6 +258,11 @@ public class JpaDistributionSetManagement implements DistributionSetManagement {
         }
     }
 
+    @Override
+    public Optional<DistributionSet> get(final long id) {
+        return distributionSetRepository.findById(id).map(DistributionSet.class::cast);
+    }
+
     @Override
     public List<DistributionSet> get(final Collection<Long> ids) {
         return Collections.unmodifiableList(getDistributionSets(ids));
@@ -274,8 +274,8 @@ public class JpaDistributionSetManagement implements DistributionSetManagement {
     }
 
     @Override
-    public Optional<DistributionSet> get(final long id) {
-        return distributionSetRepository.findById(id).map(DistributionSet.class::cast);
+    public long count() {
+        return distributionSetRepository.count(DistributionSetSpecification.isNotDeleted());
     }
 
     @Override
@@ -285,11 +285,30 @@ public class JpaDistributionSetManagement implements DistributionSetManagement {
     }
 
     @Override
-    public Page<DistributionSet> findByRsql(final Pageable pageable, final String rsqlParam) {
-        return JpaManagementHelper.findAllWithCountBySpec(distributionSetRepository, pageable, List.of(
-                RSQLUtility.buildRsqlSpecification(rsqlParam, DistributionSetFields.class, virtualPropertyReplacer,
-                        database),
-                DistributionSetSpecification.isNotDeleted()));
+    public Page<DistributionSet> findByRsql(final String rsqlParam, final Pageable pageable) {
+        return JpaManagementHelper.findAllWithCountBySpec(distributionSetRepository, List.of(
+                RSQLUtility.buildRsqlSpecification(rsqlParam, DistributionSetFields.class, virtualPropertyReplacer, database),
+                DistributionSetSpecification.isNotDeleted()), pageable);
+    }
+
+    @Override
+    public Optional<DistributionSet> getWithDetails(final long id) {
+        return distributionSetRepository
+                .findOne(distributionSetRepository.byIdSpec(id), JpaDistributionSet_.GRAPH_DISTRIBUTION_SET_DETAIL)
+                .map(DistributionSet.class::cast);
+    }
+
+    @Override
+    @Transactional
+    public void invalidate(final DistributionSet distributionSet) {
+        final JpaDistributionSet jpaSet = (JpaDistributionSet) distributionSet;
+        jpaSet.invalidate();
+        distributionSetRepository.save(jpaSet);
+    }
+
+    @Override
+    public DistributionSet getOrElseThrowException(final long id) {
+        return getById(id);
     }
 
     @Override
@@ -312,6 +331,20 @@ public class JpaDistributionSetManagement implements DistributionSetManagement {
         return distributionSetRepository.save(set);
     }
 
+    @Override
+    @Transactional
+    @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
+            backoff = @Backoff(delay = Constants.TX_RT_DELAY))
+    public DistributionSet unassignSoftwareModule(final long id, final long moduleId) {
+        final JpaDistributionSet set = (JpaDistributionSet) getValid(id);
+        assertDistributionSetIsNotAssignedToTargets(id);
+
+        final JpaSoftwareModule module = findSoftwareModuleAndThrowExceptionIfNotFound(moduleId);
+        set.removeModule(module);
+
+        return distributionSetRepository.save(set);
+    }
+
     @Override
     @Transactional
     @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
@@ -327,6 +360,21 @@ public class JpaDistributionSetManagement implements DistributionSetManagement {
         });
     }
 
+    @Override
+    @Transactional
+    @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
+            backoff = @Backoff(delay = Constants.TX_RT_DELAY))
+    public DistributionSetMetadata updateMetaData(final long id, final MetaData md) {
+        // check if exists otherwise throw entity not found exception
+        final JpaDistributionSetMetadata toUpdate = (JpaDistributionSetMetadata) findMetaDataByDistributionSetId(id, md.getKey())
+                .orElseThrow(() -> new EntityNotFoundException(DistributionSetMetadata.class, id, md.getKey()));
+        toUpdate.setValue(md.getValue());
+
+        // touch it to update the lock revision because we are modifying the DS indirectly, it will, also check UPDATE access
+        JpaManagementHelper.touch(entityManager, distributionSetRepository, (JpaDistributionSet) getValid(id));
+        return distributionSetMetadataRepository.save(toUpdate);
+    }
+
     @Override
     @Transactional
     @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
@@ -346,7 +394,7 @@ public class JpaDistributionSetManagement implements DistributionSetManagement {
     @Transactional
     @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
             backoff = @Backoff(delay = Constants.TX_RT_DELAY))
-    public List<DistributionSetMetadata> createMetaData(final long id, final Collection<MetaData> md) {
+    public List<DistributionSetMetadata> putMetaData(final long id, final Collection<MetaData> md) {
         final JpaDistributionSet distributionSet = (JpaDistributionSet) getValid(id);
         assertMetaDataQuota(id, md.size());
 
@@ -366,7 +414,7 @@ public class JpaDistributionSetManagement implements DistributionSetManagement {
     @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
             backoff = @Backoff(delay = Constants.TX_RT_DELAY))
     public void deleteMetaData(final long id, final String key) {
-        final JpaDistributionSetMetadata metadata = (JpaDistributionSetMetadata) getMetaDataByDistributionSetId(
+        final JpaDistributionSetMetadata metadata = (JpaDistributionSetMetadata) findMetaDataByDistributionSetId(
                 id, key)
                 .orElseThrow(() -> new EntityNotFoundException(DistributionSetMetadata.class, id, key));
 
@@ -403,7 +451,7 @@ public class JpaDistributionSetManagement implements DistributionSetManagement {
     }
 
     @Override
-    public Optional<DistributionSet> getByAction(final long actionId) {
+    public Optional<DistributionSet> findByAction(final long actionId) {
         return actionRepository
                 .findById(actionId)
                 .map(action -> {
@@ -422,14 +470,7 @@ public class JpaDistributionSetManagement implements DistributionSetManagement {
     }
 
     @Override
-    public Optional<DistributionSet> getWithDetails(final long id) {
-        return distributionSetRepository
-                .findOne(distributionSetRepository.byIdSpec(id), JpaDistributionSet_.GRAPH_DISTRIBUTION_SET_DETAIL)
-                .map(DistributionSet.class::cast);
-    }
-
-    @Override
-    public Optional<DistributionSet> getByNameAndVersion(final String distributionName, final String version) {
+    public Optional<DistributionSet> findByNameAndVersion(final String distributionName, final String version) {
         return distributionSetRepository
                 .findOne(DistributionSetSpecification.equalsNameAndVersionIgnoreCase(distributionName, version))
                 .map(DistributionSet.class::cast);
@@ -465,17 +506,11 @@ public class JpaDistributionSetManagement implements DistributionSetManagement {
     }
 
     @Override
-    public DistributionSet getOrElseThrowException(final long id) {
-        return getById(id);
-    }
-
-    @Override
-    public Page<DistributionSetMetadata> findMetaDataByDistributionSetId(final Pageable pageable,
-            final long id) {
+    public Page<DistributionSetMetadata> findMetaDataByDistributionSetId(final long id, final Pageable pageable) {
         assertDistributionSetExists(id);
 
-        return JpaManagementHelper.findAllWithCountBySpec(distributionSetMetadataRepository, pageable,
-                Collections.singletonList(byDsIdSpec(id)));
+        return JpaManagementHelper.findAllWithCountBySpec(distributionSetMetadataRepository, Collections.singletonList(byDsIdSpec(id)), pageable
+        );
     }
 
     @Override
@@ -486,15 +521,15 @@ public class JpaDistributionSetManagement implements DistributionSetManagement {
     }
 
     @Override
-    public Page<DistributionSetMetadata> findMetaDataByDistributionSetIdAndRsql(final Pageable pageable,
-            final long id, final String rsqlParam) {
+    public Page<DistributionSetMetadata> findMetaDataByDistributionSetIdAndRsql(final long id, final String rsqlParam,
+            final Pageable pageable) {
         assertDistributionSetExists(id);
 
         final List<Specification<JpaDistributionSetMetadata>> specList = Arrays
                 .asList(RSQLUtility.buildRsqlSpecification(rsqlParam, DistributionSetMetadataFields.class,
                         virtualPropertyReplacer, database), byDsIdSpec(id));
 
-        return JpaManagementHelper.findAllWithCountBySpec(distributionSetMetadataRepository, pageable, specList);
+        return JpaManagementHelper.findAllWithCountBySpec(distributionSetMetadataRepository, specList, pageable);
     }
 
     @Override
@@ -512,8 +547,7 @@ public class JpaDistributionSetManagement implements DistributionSetManagement {
     }
 
     @Override
-    public Slice<DistributionSet> findByDistributionSetFilter(final Pageable pageable,
-            final DistributionSetFilter distributionSetFilter) {
+    public Slice<DistributionSet> findByDistributionSetFilter(final DistributionSetFilter distributionSetFilter, final Pageable pageable) {
         final List<Specification<JpaDistributionSet>> specList = buildDistributionSetSpecifications(
                 distributionSetFilter);
 
@@ -527,25 +561,25 @@ public class JpaDistributionSetManagement implements DistributionSetManagement {
     }
 
     @Override
-    public Page<DistributionSet> findByTag(final Pageable pageable, final long tagId) {
+    public Page<DistributionSet> findByTag(final long tagId, final Pageable pageable) {
         assertDsTagExists(tagId);
 
-        return JpaManagementHelper.findAllWithCountBySpec(distributionSetRepository, pageable, List.of(
-                DistributionSetSpecification.hasTag(tagId)));
+        return JpaManagementHelper.findAllWithCountBySpec(distributionSetRepository, List.of(
+                DistributionSetSpecification.hasTag(tagId)), pageable);
     }
 
     @Override
-    public Page<DistributionSet> findByRsqlAndTag(final Pageable pageable, final String rsqlParam, final long tagId) {
+    public Page<DistributionSet> findByRsqlAndTag(final String rsqlParam, final long tagId, final Pageable pageable) {
         assertDsTagExists(tagId);
 
-        return JpaManagementHelper.findAllWithCountBySpec(distributionSetRepository, pageable, List.of(
+        return JpaManagementHelper.findAllWithCountBySpec(distributionSetRepository, List.of(
                 RSQLUtility.buildRsqlSpecification(rsqlParam, DistributionSetFields.class, virtualPropertyReplacer,
                         database),
-                DistributionSetSpecification.hasTag(tagId), DistributionSetSpecification.isNotDeleted()));
+                DistributionSetSpecification.hasTag(tagId), DistributionSetSpecification.isNotDeleted()), pageable);
     }
 
     @Override
-    public Optional<DistributionSetMetadata> getMetaDataByDistributionSetId(final long id, final String key) {
+    public Optional<DistributionSetMetadata> findMetaDataByDistributionSetId(final long id, final String key) {
         assertDistributionSetExists(id);
 
         return distributionSetMetadataRepository
@@ -553,42 +587,6 @@ public class JpaDistributionSetManagement implements DistributionSetManagement {
                 .map(DistributionSetMetadata.class::cast);
     }
 
-    @Override
-    public boolean isInUse(final long id) {
-        assertDistributionSetExists(id);
-
-        return actionRepository.countByDistributionSetId(id) > 0;
-    }
-
-    @Override
-    @Transactional
-    @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
-            backoff = @Backoff(delay = Constants.TX_RT_DELAY))
-    public DistributionSet unassignSoftwareModule(final long id, final long moduleId) {
-        final JpaDistributionSet set = (JpaDistributionSet) getValid(id);
-        assertDistributionSetIsNotAssignedToTargets(id);
-
-        final JpaSoftwareModule module = findSoftwareModuleAndThrowExceptionIfNotFound(moduleId);
-        set.removeModule(module);
-
-        return distributionSetRepository.save(set);
-    }
-
-    @Override
-    @Transactional
-    @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
-            backoff = @Backoff(delay = Constants.TX_RT_DELAY))
-    public DistributionSetMetadata updateMetaData(final long id, final MetaData md) {
-        // check if exists otherwise throw entity not found exception
-        final JpaDistributionSetMetadata toUpdate = (JpaDistributionSetMetadata) getMetaDataByDistributionSetId(id, md.getKey())
-                .orElseThrow(() -> new EntityNotFoundException(DistributionSetMetadata.class, id, md.getKey()));
-        toUpdate.setValue(md.getValue());
-
-        // touch it to update the lock revision because we are modifying the DS indirectly, it will, also check UPDATE access
-        JpaManagementHelper.touch(entityManager, distributionSetRepository, (JpaDistributionSet) getValid(id));
-        return distributionSetMetadataRepository.save(toUpdate);
-    }
-
     @Override
     public long countByTypeId(final long typeId) {
         if (!distributionSetTypeManagement.exists(typeId)) {
@@ -598,9 +596,17 @@ public class JpaDistributionSetManagement implements DistributionSetManagement {
         return distributionSetRepository.count(DistributionSetSpecification.byType(typeId));
     }
 
+    @Override
+    public boolean isInUse(final long id) {
+        assertDistributionSetExists(id);
+
+        return actionRepository.countByDistributionSetId(id) > 0;
+    }
+
     @Override
     public List<Statistic> countRolloutsByStatusForDistributionSet(final Long id) {
         assertDistributionSetExists(id);
+
         return distributionSetRepository.countRolloutsByStatusForDistributionSet(id).stream().map(Statistic.class::cast).toList();
     }
 
@@ -619,14 +625,6 @@ public class JpaDistributionSetManagement implements DistributionSetManagement {
         return distributionSetRepository.countAutoAssignmentsForDistributionSet(id);
     }
 
-    @Override
-    @Transactional
-    public void invalidate(final DistributionSet distributionSet) {
-        final JpaDistributionSet jpaSet = (JpaDistributionSet) distributionSet;
-        jpaSet.invalidate();
-        distributionSetRepository.save(jpaSet);
-    }
-
     @Override
     @Transactional
     @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
@@ -635,7 +633,7 @@ public class JpaDistributionSetManagement implements DistributionSetManagement {
         return updateTag(
                 ids,
                 () -> distributionSetTagManagement
-                        .getByName(tagName)
+                        .findByName(tagName)
                         .orElseThrow(() -> new EntityNotFoundException(DistributionSetTag.class, tagName)),
                 (allDs, distributionSetTag) -> {
                     final List<JpaDistributionSet> toBeChangedDSs = allDs.stream().filter(set -> set.addTag(distributionSetTag))

hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/management/JpaDistributionSetTagManagement.java

@@ -75,10 +75,11 @@ public class JpaDistributionSetTagManagement implements DistributionSetTagManage
     @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
             backoff = @Backoff(delay = Constants.TX_RT_DELAY))
     public List<DistributionSetTag> create(final Collection<TagCreate> dst) {
-        final List<JpaDistributionSetTag> toCreate = dst.stream().map(JpaTagCreate.class::cast)
-                .map(JpaTagCreate::buildDistributionSetTag).toList();
-        return Collections
-                .unmodifiableList(distributionSetTagRepository.saveAll(AccessController.Operation.CREATE, toCreate));
+        final List<JpaDistributionSetTag> toCreate = dst.stream()
+                .map(JpaTagCreate.class::cast)
+                .map(JpaTagCreate::buildDistributionSetTag)
+                .toList();
+        return Collections.unmodifiableList(distributionSetTagRepository.saveAll(AccessController.Operation.CREATE, toCreate));
     }
 
     @Override
@@ -87,8 +88,7 @@ public class JpaDistributionSetTagManagement implements DistributionSetTagManage
             backoff = @Backoff(delay = Constants.TX_RT_DELAY))
     @PreAuthorize(SpPermission.SpringEvalExpressions.HAS_AUTH_CREATE_REPOSITORY)
     public DistributionSetTag create(final TagCreate c) {
-        final JpaTagCreate create = (JpaTagCreate) c;
-        return distributionSetTagRepository.save(AccessController.Operation.CREATE, create.buildDistributionSetTag());
+        return distributionSetTagRepository.save(AccessController.Operation.CREATE, ((JpaTagCreate) c).buildDistributionSetTag());
     }
 
     @Override
@@ -98,7 +98,6 @@ public class JpaDistributionSetTagManagement implements DistributionSetTagManage
     @PreAuthorize(SpPermission.SpringEvalExpressions.HAS_AUTH_UPDATE_REPOSITORY)
     public DistributionSetTag update(final TagUpdate u) {
         final GenericTagUpdate update = (GenericTagUpdate) u;
-
         final JpaDistributionSetTag tag = distributionSetTagRepository.findById(update.getId())
                 .orElseThrow(() -> new EntityNotFoundException(DistributionSetTag.class, update.getId()));
 
@@ -109,11 +108,6 @@ public class JpaDistributionSetTagManagement implements DistributionSetTagManage
         return distributionSetTagRepository.save(tag);
     }
 
-    @Override
-    public long count() {
-        return distributionSetTagRepository.count();
-    }
-
     @Override
     @Transactional
     @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
@@ -137,6 +131,11 @@ public class JpaDistributionSetTagManagement implements DistributionSetTagManage
         distributionSetTagRepository.deleteAll(setsFound);
     }
 
+    @Override
+    public Optional<DistributionSetTag> get(final long id) {
+        return distributionSetTagRepository.findById(id).map(DistributionSetTag.class::cast);
+    }
+
     @Override
     public List<DistributionSetTag> get(final Collection<Long> ids) {
         return Collections.unmodifiableList(distributionSetTagRepository.findAllById(ids));
@@ -148,22 +147,37 @@ public class JpaDistributionSetTagManagement implements DistributionSetTagManage
     }
 
     @Override
-    public Optional<DistributionSetTag> get(final long id) {
-        return distributionSetTagRepository.findById(id).map(DistributionSetTag.class::cast);
+    public long count() {
+        return distributionSetTagRepository.count();
     }
 
+
     @Override
     public Slice<DistributionSetTag> findAll(final Pageable pageable) {
         return JpaManagementHelper.findAllWithoutCountBySpec(distributionSetTagRepository, pageable, null);
     }
 
     @Override
-    public Page<DistributionSetTag> findByRsql(final Pageable pageable, final String rsqlParam) {
-        final Specification<JpaDistributionSetTag> spec = RSQLUtility.buildRsqlSpecification(rsqlParam, DistributionSetTagFields.class,
-                virtualPropertyReplacer, database);
+    public Page<DistributionSetTag> findByRsql(final String rsqlParam, final Pageable pageable) {
+        final Specification<JpaDistributionSetTag> spec = RSQLUtility.buildRsqlSpecification(
+                rsqlParam, DistributionSetTagFields.class, virtualPropertyReplacer, database);
+        return JpaManagementHelper.findAllWithCountBySpec(distributionSetTagRepository, Collections.singletonList(spec), pageable);
+    }
 
-        return JpaManagementHelper.findAllWithCountBySpec(distributionSetTagRepository, pageable,
-                Collections.singletonList(spec));
+    @Override
+    public Optional<DistributionSetTag> findByName(final String name) {
+        return distributionSetTagRepository.findByNameEquals(name);
+    }
+
+    @Override
+    public Page<DistributionSetTag> findByDistributionSet(final Pageable pageable, final long distributionSetId) {
+        if (!distributionSetRepository.existsById(distributionSetId)) {
+            throw new EntityNotFoundException(DistributionSet.class, distributionSetId);
+        }
+
+        return JpaManagementHelper.findAllWithCountBySpec(distributionSetTagRepository,
+                Collections.singletonList(TagSpecification.ofDistributionSet(distributionSetId)), pageable
+        );
     }
 
     @Override
@@ -174,22 +188,6 @@ public class JpaDistributionSetTagManagement implements DistributionSetTagManage
         final JpaDistributionSetTag dsTag = distributionSetTagRepository
                 .findOne(DistributionSetTagSpecifications.byName(tagName))
                 .orElseThrow(() -> new EntityNotFoundException(DistributionSetTag.class, tagName));
-
         distributionSetTagRepository.delete(dsTag);
     }
-
-    @Override
-    public Optional<DistributionSetTag> getByName(final String name) {
-        return distributionSetTagRepository.findByNameEquals(name);
-    }
-
-    @Override
-    public Page<DistributionSetTag> findByDistributionSet(final Pageable pageable, final long distributionSetId) {
-        if (!distributionSetRepository.existsById(distributionSetId)) {
-            throw new EntityNotFoundException(DistributionSet.class, distributionSetId);
-        }
-
-        return JpaManagementHelper.findAllWithCountBySpec(distributionSetTagRepository, pageable,
-                Collections.singletonList(TagSpecification.ofDistributionSet(distributionSetId)));
-    }
 }

hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/management/JpaDistributionSetTypeManagement.java

@@ -88,43 +88,6 @@ public class JpaDistributionSetTypeManagement implements DistributionSetTypeMana
         this.quotaManagement = quotaManagement;
     }
 
-    @Override
-    public Optional<DistributionSetType> getByKey(final String key) {
-        return distributionSetTypeRepository.findOne(DistributionSetTypeSpecification.byKey(key)).map(DistributionSetType.class::cast);
-    }
-
-    @Override
-    public Optional<DistributionSetType> getByName(final String name) {
-        return distributionSetTypeRepository.findOne(DistributionSetTypeSpecification.byName(name)).map(DistributionSetType.class::cast);
-    }
-
-    @Override
-    @Transactional
-    @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
-            backoff = @Backoff(delay = Constants.TX_RT_DELAY))
-    public DistributionSetType assignOptionalSoftwareModuleTypes(final long id, final Collection<Long> softwareModulesTypeIds) {
-        return assignSoftwareModuleTypes(id, softwareModulesTypeIds, false);
-    }
-
-    @Override
-    @Transactional
-    @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
-            backoff = @Backoff(delay = Constants.TX_RT_DELAY))
-    public DistributionSetType assignMandatorySoftwareModuleTypes(final long id, final Collection<Long> softwareModuleTypeIds) {
-        return assignSoftwareModuleTypes(id, softwareModuleTypeIds, true);
-    }
-
-    @Override
-    @Transactional
-    @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
-            backoff = @Backoff(delay = Constants.TX_RT_DELAY))
-    public DistributionSetType unassignSoftwareModuleType(final long id, final long softwareModuleTypeId) {
-        final JpaDistributionSetType type = findDistributionSetTypeAndThrowExceptionIfNotFound(id);
-        checkDistributionSetTypeNotAssigned(id);
-        type.removeModuleType(softwareModuleTypeId);
-        return distributionSetTypeRepository.save(type);
-    }
-
     @Override
     @Transactional
     @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
@@ -184,11 +147,6 @@ public class JpaDistributionSetTypeManagement implements DistributionSetTypeMana
         return distributionSetTypeRepository.save(type);
     }
 
-    @Override
-    public long count() {
-        return distributionSetTypeRepository.count(DistributionSetTypeSpecification.isNotDeleted());
-    }
-
     @Override
     @Transactional
     @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
@@ -215,6 +173,11 @@ public class JpaDistributionSetTypeManagement implements DistributionSetTypeMana
         distributionSetTypeRepository.deleteAllById(ids);
     }
 
+    @Override
+    public Optional<DistributionSetType> get(final long id) {
+        return distributionSetTypeRepository.findById(id).map(DistributionSetType.class::cast);
+    }
+
     @Override
     public List<DistributionSetType> get(final Collection<Long> ids) {
         return Collections.unmodifiableList(distributionSetTypeRepository.findAllById(ids));
@@ -226,8 +189,8 @@ public class JpaDistributionSetTypeManagement implements DistributionSetTypeMana
     }
 
     @Override
-    public Optional<DistributionSetType> get(final long id) {
-        return distributionSetTypeRepository.findById(id).map(DistributionSetType.class::cast);
+    public long count() {
+        return distributionSetTypeRepository.count(DistributionSetTypeSpecification.isNotDeleted());
     }
 
     @Override
@@ -237,10 +200,47 @@ public class JpaDistributionSetTypeManagement implements DistributionSetTypeMana
     }
 
     @Override
-    public Page<DistributionSetType> findByRsql(final Pageable pageable, final String rsqlParam) {
-        return JpaManagementHelper.findAllWithCountBySpec(distributionSetTypeRepository, pageable, List.of(
+    public Page<DistributionSetType> findByRsql(final String rsqlParam, final Pageable pageable) {
+        return JpaManagementHelper.findAllWithCountBySpec(distributionSetTypeRepository, List.of(
                 RSQLUtility.buildRsqlSpecification(rsqlParam, DistributionSetTypeFields.class, virtualPropertyReplacer, database),
-                DistributionSetTypeSpecification.isNotDeleted()));
+                DistributionSetTypeSpecification.isNotDeleted()), pageable);
+    }
+
+    @Override
+    public Optional<DistributionSetType> findByKey(final String key) {
+        return distributionSetTypeRepository.findOne(DistributionSetTypeSpecification.byKey(key)).map(DistributionSetType.class::cast);
+    }
+
+    @Override
+    public Optional<DistributionSetType> findByName(final String name) {
+        return distributionSetTypeRepository.findOne(DistributionSetTypeSpecification.byName(name)).map(DistributionSetType.class::cast);
+    }
+
+    @Override
+    @Transactional
+    @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
+            backoff = @Backoff(delay = Constants.TX_RT_DELAY))
+    public DistributionSetType assignOptionalSoftwareModuleTypes(final long id, final Collection<Long> softwareModulesTypeIds) {
+        return assignSoftwareModuleTypes(id, softwareModulesTypeIds, false);
+    }
+
+    @Override
+    @Transactional
+    @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
+            backoff = @Backoff(delay = Constants.TX_RT_DELAY))
+    public DistributionSetType assignMandatorySoftwareModuleTypes(final long id, final Collection<Long> softwareModuleTypeIds) {
+        return assignSoftwareModuleTypes(id, softwareModuleTypeIds, true);
+    }
+
+    @Override
+    @Transactional
+    @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
+            backoff = @Backoff(delay = Constants.TX_RT_DELAY))
+    public DistributionSetType unassignSoftwareModuleType(final long id, final long softwareModuleTypeId) {
+        final JpaDistributionSetType type = findDistributionSetTypeAndThrowExceptionIfNotFound(id);
+        checkDistributionSetTypeNotAssigned(id);
+        type.removeModuleType(softwareModuleTypeId);
+        return distributionSetTypeRepository.save(type);
     }
 
     private static void removeModuleTypes(

hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/management/JpaRolloutGroupManagement.java

@@ -132,7 +132,7 @@ public class JpaRolloutGroupManagement implements RolloutGroupManagement {
                         database),
                 (root, query, cb) -> cb.equal(root.get(JpaRolloutGroup_.rollout).get(JpaRollout_.id), rolloutId));
 
-        return JpaManagementHelper.findAllWithCountBySpec(rolloutGroupRepository, pageable, specList);
+        return JpaManagementHelper.findAllWithCountBySpec(rolloutGroupRepository, specList, pageable);
     }
 
     @Override
@@ -180,11 +180,13 @@ public class JpaRolloutGroupManagement implements RolloutGroupManagement {
             // in case of status ready the action has not been created yet and
             // the relation information between target and rollout-group is
             // stored in the #TargetRolloutGroup.
-            return JpaManagementHelper.findAllWithCountBySpec(targetRepository, page,
-                    Collections.singletonList(TargetSpecifications.isInRolloutGroup(rolloutGroupId)));
+            return JpaManagementHelper.findAllWithCountBySpec(targetRepository,
+                    Collections.singletonList(TargetSpecifications.isInRolloutGroup(rolloutGroupId)), page
+            );
         }
-        return JpaManagementHelper.findAllWithCountBySpec(targetRepository, page,
-                Collections.singletonList(TargetSpecifications.isInActionRolloutGroup(rolloutGroupId)));
+        return JpaManagementHelper.findAllWithCountBySpec(targetRepository,
+                Collections.singletonList(TargetSpecifications.isInActionRolloutGroup(rolloutGroupId)), page
+        );
     }
 
     @Override
@@ -201,7 +203,7 @@ public class JpaRolloutGroupManagement implements RolloutGroupManagement {
                             rolloutGroupId);
                 });
 
-        return JpaManagementHelper.findAllWithCountBySpec(targetRepository, pageable, specList);
+        return JpaManagementHelper.findAllWithCountBySpec(targetRepository, specList, pageable);
     }
 
     @Override

hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/management/JpaSoftwareModuleManagement.java

@@ -178,11 +178,6 @@ public class JpaSoftwareModuleManagement implements SoftwareModuleManagement {
         return softwareModuleRepository.save(module);
     }
 
-    @Override
-    public long count() {
-        return softwareModuleRepository.count(SoftwareModuleSpecification.isNotDeleted());
-    }
-
     @Override
     @Transactional
     @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
@@ -238,6 +233,11 @@ public class JpaSoftwareModuleManagement implements SoftwareModuleManagement {
         }
     }
 
+    @Override
+    public Optional<SoftwareModule> get(final long id) {
+        return softwareModuleRepository.findById(id).map(SoftwareModule.class::cast);
+    }
+
     @Override
     public List<SoftwareModule> get(final Collection<Long> ids) {
         return Collections.unmodifiableList(softwareModuleRepository.findAllById(ids));
@@ -249,8 +249,8 @@ public class JpaSoftwareModuleManagement implements SoftwareModuleManagement {
     }
 
     @Override
-    public Optional<SoftwareModule> get(final long id) {
-        return softwareModuleRepository.findById(id).map(SoftwareModule.class::cast);
+    public long count() {
+        return softwareModuleRepository.count(SoftwareModuleSpecification.isNotDeleted());
     }
 
     @Override
@@ -261,18 +261,18 @@ public class JpaSoftwareModuleManagement implements SoftwareModuleManagement {
     }
 
     @Override
-    public Page<SoftwareModule> findByRsql(final Pageable pageable, final String rsqlParam) {
-        return JpaManagementHelper.findAllWithCountBySpec(softwareModuleRepository, pageable, List.of(
+    public Page<SoftwareModule> findByRsql(final String rsqlParam, final Pageable pageable) {
+        return JpaManagementHelper.findAllWithCountBySpec(softwareModuleRepository, List.of(
                 RSQLUtility.buildRsqlSpecification(rsqlParam, SoftwareModuleFields.class, virtualPropertyReplacer,
                         database),
-                SoftwareModuleSpecification.isNotDeleted()));
+                SoftwareModuleSpecification.isNotDeleted()), pageable);
     }
 
     @Override
     @Transactional
     @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
             backoff = @Backoff(delay = Constants.TX_RT_DELAY))
-    public List<SoftwareModuleMetadata> createMetaData(final Collection<SoftwareModuleMetadataCreate> create) {
+    public List<SoftwareModuleMetadata> putMetaData(final Collection<SoftwareModuleMetadataCreate> create) {
         if (!create.isEmpty()) {
             // check if all metadata entries refer to the same software module
             final Long id = ((JpaSoftwareModuleMetadataCreate) create.iterator().next()).getSoftwareModuleId();
@@ -309,7 +309,7 @@ public class JpaSoftwareModuleManagement implements SoftwareModuleManagement {
     @Transactional
     @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
             backoff = @Backoff(delay = Constants.TX_RT_DELAY))
-    public SoftwareModuleMetadata createMetaData(final SoftwareModuleMetadataCreate c) {
+    public SoftwareModuleMetadata updateMetaData(final SoftwareModuleMetadataCreate c) {
         final JpaSoftwareModuleMetadataCreate create = (JpaSoftwareModuleMetadataCreate) c;
         final Long id = create.getSoftwareModuleId();
 
@@ -322,12 +322,31 @@ public class JpaSoftwareModuleManagement implements SoftwareModuleManagement {
         return saveMetadata(create);
     }
 
+    @Override
+    @Transactional
+    @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
+            backoff = @Backoff(delay = Constants.TX_RT_DELAY))
+    public SoftwareModuleMetadata updateMetaData(final SoftwareModuleMetadataUpdate u) {
+        final GenericSoftwareModuleMetadataUpdate update = (GenericSoftwareModuleMetadataUpdate) u;
+
+        // check if exists otherwise throw entity not found exception
+        final JpaSoftwareModuleMetadata metadata = (JpaSoftwareModuleMetadata) findMetaDataBySoftwareModuleId(
+                update.getSoftwareModuleId(), update.getKey())
+                .orElseThrow(() -> new EntityNotFoundException(SoftwareModuleMetadata.class, update.getSoftwareModuleId(), update.getKey()));
+
+        update.getValue().ifPresent(metadata::setValue);
+        update.isTargetVisible().ifPresent(metadata::setTargetVisible);
+
+        JpaManagementHelper.touch(entityManager, softwareModuleRepository, metadata.getSoftwareModule());
+        return softwareModuleMetadataRepository.save(metadata);
+    }
+
     @Override
     @Transactional
     @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
             backoff = @Backoff(delay = Constants.TX_RT_DELAY))
     public void deleteMetaData(final long id, final String key) {
-        final JpaSoftwareModuleMetadata metadata = (JpaSoftwareModuleMetadata) getMetaDataBySoftwareModuleId(id,
+        final JpaSoftwareModuleMetadata metadata = (JpaSoftwareModuleMetadata) findMetaDataBySoftwareModuleId(id,
                 key).orElseThrow(() -> new EntityNotFoundException(SoftwareModuleMetadata.class, id, key));
 
         JpaManagementHelper.touch(entityManager, softwareModuleRepository,
@@ -335,111 +354,6 @@ public class JpaSoftwareModuleManagement implements SoftwareModuleManagement {
         softwareModuleMetadataRepository.deleteById(metadata.getId());
     }
 
-    @Override
-    public Page<SoftwareModule> findByAssignedTo(final Pageable pageable, final long distributionSetId) {
-        assertDistributionSetExists(distributionSetId);
-
-        return JpaManagementHelper.findAllWithCountBySpec(softwareModuleRepository, pageable,
-                Collections.singletonList(SoftwareModuleSpecification.byAssignedToDs(distributionSetId)));
-    }
-
-    @Override
-    public long countByAssignedTo(final long distributionSetId) {
-        assertDistributionSetExists(distributionSetId);
-
-        return softwareModuleRepository.count(SoftwareModuleSpecification.byAssignedToDs(distributionSetId));
-    }
-
-    @Override
-    public Slice<SoftwareModule> findByTextAndType(final Pageable pageable, final String searchText,
-            final Long typeId) {
-        final List<Specification<JpaSoftwareModule>> specList = new ArrayList<>(3);
-        specList.add(SoftwareModuleSpecification.isNotDeleted());
-
-        if (!ObjectUtils.isEmpty(searchText)) {
-            specList.add(buildSmSearchQuerySpec(searchText));
-        }
-
-        if (null != typeId) {
-            assertSoftwareModuleTypeExists(typeId);
-            specList.add(SoftwareModuleSpecification.equalType(typeId));
-        }
-
-        specList.add(SoftwareModuleSpecification.fetchType());
-
-        return JpaManagementHelper.findAllWithoutCountBySpec(softwareModuleRepository, pageable, specList);
-    }
-
-    @Override
-    public Optional<SoftwareModule> getByNameAndVersionAndType(final String name, final String version,
-            final long typeId) {
-        assertSoftwareModuleTypeExists(typeId);
-
-        // TODO AC - Access is restricted. This could have problem with UI when access control is enabled.
-        // Vaadin UI use this for validation. May need to be called via elevated access
-        return JpaManagementHelper
-                .findOneBySpec(softwareModuleRepository, List.of(
-                        SoftwareModuleSpecification.likeNameAndVersion(name, version),
-                        SoftwareModuleSpecification.equalType(typeId),
-                        SoftwareModuleSpecification.fetchType()))
-                .map(SoftwareModule.class::cast);
-    }
-
-    @Override
-    public Optional<SoftwareModuleMetadata> getMetaDataBySoftwareModuleId(final long id, final String key) {
-        assertSoftwareModuleExists(id);
-
-        return softwareModuleMetadataRepository.findById(new SwMetadataCompositeKey(id, key))
-                .map(SoftwareModuleMetadata.class::cast);
-    }
-
-    @Override
-    public Page<SoftwareModuleMetadata> findMetaDataBySoftwareModuleId(final Pageable pageable, final long id) {
-        assertSoftwareModuleExists(id);
-
-        return JpaManagementHelper.findAllWithCountBySpec(softwareModuleMetadataRepository, pageable,
-                Collections.singletonList(metadataBySoftwareModuleIdSpec(id)));
-    }
-
-    @Override
-    public long countMetaDataBySoftwareModuleId(final long id) {
-        assertSoftwareModuleExists(id);
-
-        return softwareModuleMetadataRepository.countBySoftwareModuleId(id);
-    }
-
-    @Override
-    public Page<SoftwareModuleMetadata> findMetaDataBySoftwareModuleIdAndTargetVisible(final Pageable pageable,
-            final long id) {
-        assertSoftwareModuleExists(id);
-
-        return JpaManagementHelper.convertPage(softwareModuleMetadataRepository.findBySoftwareModuleIdAndTargetVisible(
-                id, true, PageRequest.of(0, RepositoryConstants.MAX_META_DATA_COUNT)), pageable);
-    }
-
-    @Override
-    public Page<SoftwareModuleMetadata> findMetaDataByRsql(final Pageable pageable, final long id,
-            final String rsqlParam) {
-        assertSoftwareModuleExists(id);
-
-        final List<Specification<JpaSoftwareModuleMetadata>> specList = Arrays
-                .asList(RSQLUtility.buildRsqlSpecification(rsqlParam, SoftwareModuleMetadataFields.class,
-                        virtualPropertyReplacer, database), metadataBySoftwareModuleIdSpec(id));
-        return JpaManagementHelper.findAllWithCountBySpec(softwareModuleMetadataRepository, pageable, specList);
-    }
-
-    @Override
-    public Slice<SoftwareModule> findByType(final Pageable pageable, final long typeId) {
-        assertSoftwareModuleTypeExists(typeId);
-
-        return JpaManagementHelper.findAllWithoutCountBySpec(
-                softwareModuleRepository,
-                pageable,
-                List.of(
-                        SoftwareModuleSpecification.equalType(typeId),
-                        SoftwareModuleSpecification.isNotDeleted()));
-    }
-
     @Override
     @Transactional
     @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
@@ -469,22 +383,94 @@ public class JpaSoftwareModuleManagement implements SoftwareModuleManagement {
     }
 
     @Override
-    @Transactional
-    @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
-            backoff = @Backoff(delay = Constants.TX_RT_DELAY))
-    public SoftwareModuleMetadata updateMetaData(final SoftwareModuleMetadataUpdate u) {
-        final GenericSoftwareModuleMetadataUpdate update = (GenericSoftwareModuleMetadataUpdate) u;
+    public Page<SoftwareModule> findByAssignedTo(final long distributionSetId, final Pageable pageable) {
+        assertDistributionSetExists(distributionSetId);
 
-        // check if exists otherwise throw entity not found exception
-        final JpaSoftwareModuleMetadata metadata = (JpaSoftwareModuleMetadata) getMetaDataBySoftwareModuleId(
-                update.getSoftwareModuleId(), update.getKey())
-                .orElseThrow(() -> new EntityNotFoundException(SoftwareModuleMetadata.class, update.getSoftwareModuleId(), update.getKey()));
+        return JpaManagementHelper.findAllWithCountBySpec(softwareModuleRepository,
+                Collections.singletonList(SoftwareModuleSpecification.byAssignedToDs(distributionSetId)), pageable
+        );
+    }
 
-        update.getValue().ifPresent(metadata::setValue);
-        update.isTargetVisible().ifPresent(metadata::setTargetVisible);
+    @Override
+    public Slice<SoftwareModule> findByTextAndType(final String searchText, final Long typeId, final Pageable pageable) {
+        final List<Specification<JpaSoftwareModule>> specList = new ArrayList<>(3);
+        specList.add(SoftwareModuleSpecification.isNotDeleted());
 
-        JpaManagementHelper.touch(entityManager, softwareModuleRepository, metadata.getSoftwareModule());
-        return softwareModuleMetadataRepository.save(metadata);
+        if (!ObjectUtils.isEmpty(searchText)) {
+            specList.add(buildSmSearchQuerySpec(searchText));
+        }
+
+        if (null != typeId) {
+            assertSoftwareModuleTypeExists(typeId);
+            specList.add(SoftwareModuleSpecification.equalType(typeId));
+        }
+
+        specList.add(SoftwareModuleSpecification.fetchType());
+
+        return JpaManagementHelper.findAllWithoutCountBySpec(softwareModuleRepository, pageable, specList);
+    }
+
+    @Override
+    public Optional<SoftwareModule> findByNameAndVersionAndType(final String name, final String version,
+            final long typeId) {
+        assertSoftwareModuleTypeExists(typeId);
+
+        // TODO AC - Access is restricted. This could have problem with UI when access control is enabled.
+        // Vaadin UI use this for validation. May need to be called via elevated access
+        return JpaManagementHelper
+                .findOneBySpec(softwareModuleRepository, List.of(
+                        SoftwareModuleSpecification.likeNameAndVersion(name, version),
+                        SoftwareModuleSpecification.equalType(typeId),
+                        SoftwareModuleSpecification.fetchType()))
+                .map(SoftwareModule.class::cast);
+    }
+
+    @Override
+    public Optional<SoftwareModuleMetadata> findMetaDataBySoftwareModuleId(final long id, final String key) {
+        assertSoftwareModuleExists(id);
+
+        return softwareModuleMetadataRepository.findById(new SwMetadataCompositeKey(id, key))
+                .map(SoftwareModuleMetadata.class::cast);
+    }
+
+    @Override
+    public Page<SoftwareModuleMetadata> findMetaDataBySoftwareModuleId(final Pageable pageable, final long id) {
+        assertSoftwareModuleExists(id);
+
+        return JpaManagementHelper.findAllWithCountBySpec(softwareModuleMetadataRepository,
+                Collections.singletonList(metadataBySoftwareModuleIdSpec(id)), pageable
+        );
+    }
+
+    @Override
+    public Page<SoftwareModuleMetadata> findMetaDataBySoftwareModuleIdAndTargetVisible(final Pageable pageable,
+            final long id) {
+        assertSoftwareModuleExists(id);
+
+        return JpaManagementHelper.convertPage(softwareModuleMetadataRepository.findBySoftwareModuleIdAndTargetVisible(
+                id, true, PageRequest.of(0, RepositoryConstants.MAX_META_DATA_COUNT)), pageable);
+    }
+
+    @Override
+    public Page<SoftwareModuleMetadata> findMetaDataByRsql(final long id, final String rsqlParam, final Pageable pageable) {
+        assertSoftwareModuleExists(id);
+
+        final List<Specification<JpaSoftwareModuleMetadata>> specList = Arrays
+                .asList(RSQLUtility.buildRsqlSpecification(rsqlParam, SoftwareModuleMetadataFields.class,
+                        virtualPropertyReplacer, database), metadataBySoftwareModuleIdSpec(id));
+        return JpaManagementHelper.findAllWithCountBySpec(softwareModuleMetadataRepository, specList, pageable);
+    }
+
+    @Override
+    public Slice<SoftwareModule> findByType(final long typeId, final Pageable pageable) {
+        assertSoftwareModuleTypeExists(typeId);
+
+        return JpaManagementHelper.findAllWithoutCountBySpec(
+                softwareModuleRepository,
+                pageable,
+                List.of(
+                        SoftwareModuleSpecification.equalType(typeId),
+                        SoftwareModuleSpecification.isNotDeleted()));
     }
 
     @Override
@@ -495,6 +481,20 @@ public class JpaSoftwareModuleManagement implements SoftwareModuleManagement {
                 .collect(Collectors.groupingBy(o -> (Long) o[0], Collectors.mapping(o -> (SoftwareModuleMetadata) o[1], Collectors.toList())));
     }
 
+    @Override
+    public long countByAssignedTo(final long distributionSetId) {
+        assertDistributionSetExists(distributionSetId);
+
+        return softwareModuleRepository.count(SoftwareModuleSpecification.byAssignedToDs(distributionSetId));
+    }
+
+    @Override
+    public long countMetaDataBySoftwareModuleId(final long id) {
+        assertSoftwareModuleExists(id);
+
+        return softwareModuleMetadataRepository.countBySoftwareModuleId(id);
+    }
+
     private static Stream<JpaSoftwareModuleMetadataCreate> createJpaMetadataCreateStream(
             final Collection<SoftwareModuleMetadataCreate> create) {
         return create.stream().map(JpaSoftwareModuleMetadataCreate.class::cast);

hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/management/JpaSoftwareModuleTypeManagement.java

@@ -69,27 +69,6 @@ public class JpaSoftwareModuleTypeManagement implements SoftwareModuleTypeManage
         this.database = database;
     }
 
-    @Override
-    public Optional<SoftwareModuleType> getByKey(final String key) {
-        return softwareModuleTypeRepository.findByKey(key);
-    }
-
-    @Override
-    public Optional<SoftwareModuleType> getByName(final String name) {
-        return softwareModuleTypeRepository.findByName(name);
-    }
-
-    @Override
-    @Transactional
-    @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
-            backoff = @Backoff(delay = Constants.TX_RT_DELAY))
-    public List<SoftwareModuleType> create(final Collection<SoftwareModuleTypeCreate> c) {
-        final List<JpaSoftwareModuleType> creates = c.stream().map(JpaSoftwareModuleTypeCreate.class::cast)
-                .map(JpaSoftwareModuleTypeCreate::build).toList();
-        return Collections.unmodifiableList(
-                softwareModuleTypeRepository.saveAll(AccessController.Operation.CREATE, creates));
-    }
-
     @Override
     @Transactional
     @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
@@ -118,11 +97,6 @@ public class JpaSoftwareModuleTypeManagement implements SoftwareModuleTypeManage
         return softwareModuleTypeRepository.save(type);
     }
 
-    @Override
-    public long count() {
-        return softwareModuleTypeRepository.count(SoftwareModuleTypeSpecification.isNotDeleted());
-    }
-
     @Override
     @Transactional
     @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
@@ -144,6 +118,11 @@ public class JpaSoftwareModuleTypeManagement implements SoftwareModuleTypeManage
                 .forEach(this::delete);
     }
 
+    @Override
+    public Optional<SoftwareModuleType> get(final long id) {
+        return softwareModuleTypeRepository.findById(id).map(SoftwareModuleType.class::cast);
+    }
+
     @Override
     public List<SoftwareModuleType> get(final Collection<Long> ids) {
         return Collections.unmodifiableList(softwareModuleTypeRepository.findAllById(ids));
@@ -155,8 +134,8 @@ public class JpaSoftwareModuleTypeManagement implements SoftwareModuleTypeManage
     }
 
     @Override
-    public Optional<SoftwareModuleType> get(final long id) {
-        return softwareModuleTypeRepository.findById(id).map(SoftwareModuleType.class::cast);
+    public long count() {
+        return softwareModuleTypeRepository.count(SoftwareModuleTypeSpecification.isNotDeleted());
     }
 
     @Override
@@ -166,12 +145,33 @@ public class JpaSoftwareModuleTypeManagement implements SoftwareModuleTypeManage
     }
 
     @Override
-    public Page<SoftwareModuleType> findByRsql(final Pageable pageable, final String rsqlParam) {
-        return JpaManagementHelper.findAllWithCountBySpec(softwareModuleTypeRepository, pageable,
-                List.of(
-                        RSQLUtility.buildRsqlSpecification(rsqlParam, SoftwareModuleTypeFields.class,
-                                virtualPropertyReplacer, database),
-                        SoftwareModuleTypeSpecification.isNotDeleted()));
+    public Page<SoftwareModuleType> findByRsql(final String rsqlParam, final Pageable pageable) {
+        return JpaManagementHelper.findAllWithCountBySpec(softwareModuleTypeRepository, List.of(
+                RSQLUtility.buildRsqlSpecification(rsqlParam, SoftwareModuleTypeFields.class,
+                        virtualPropertyReplacer, database),
+                SoftwareModuleTypeSpecification.isNotDeleted()), pageable
+        );
+    }
+
+    @Override
+    public Optional<SoftwareModuleType> findByKey(final String key) {
+        return softwareModuleTypeRepository.findByKey(key);
+    }
+
+    @Override
+    public Optional<SoftwareModuleType> findByName(final String name) {
+        return softwareModuleTypeRepository.findByName(name);
+    }
+
+    @Override
+    @Transactional
+    @Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
+            backoff = @Backoff(delay = Constants.TX_RT_DELAY))
+    public List<SoftwareModuleType> create(final Collection<SoftwareModuleTypeCreate> c) {
+        final List<JpaSoftwareModuleType> creates = c.stream().map(JpaSoftwareModuleTypeCreate.class::cast)
+                .map(JpaSoftwareModuleTypeCreate::build).toList();
+        return Collections.unmodifiableList(
+                softwareModuleTypeRepository.saveAll(AccessController.Operation.CREATE, creates));
     }
 
     private void delete(JpaSoftwareModuleType toDelete) {

hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/management/JpaTargetFilterQueryManagement.java

@@ -192,7 +192,7 @@ public class JpaTargetFilterQueryManagement implements TargetFilterQueryManageme
                 TargetFilterQueryFields.class, virtualPropertyReplacer, database))
                 : Collections.emptyList();
 
-        return JpaManagementHelper.findAllWithCountBySpec(targetFilterQueryRepository, pageable, specList);
+        return JpaManagementHelper.findAllWithCountBySpec(targetFilterQueryRepository, specList, pageable);
     }
 
     @Override
@@ -225,7 +225,7 @@ public class JpaTargetFilterQueryManagement implements TargetFilterQueryManageme
                     virtualPropertyReplacer, database));
         }
 
-        return JpaManagementHelper.findAllWithCountBySpec(targetFilterQueryRepository, pageable, specList);
+        return JpaManagementHelper.findAllWithCountBySpec(targetFilterQueryRepository, specList, pageable);
     }
 
     @Override

hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/management/JpaTargetManagement.java

@@ -345,7 +345,7 @@ public class JpaTargetManagement implements TargetManagement {
                 TargetSpecifications.failedActionsForRollout(rolloutId),
                 TargetSpecifications.isNotInRolloutGroups(groups));
 
-        return JpaManagementHelper.findAllWithCountBySpec(targetRepository, pageRequest, specList);
+        return JpaManagementHelper.findAllWithCountBySpec(targetRepository, specList, pageRequest);
     }
 
     @Override
@@ -382,8 +382,9 @@ public class JpaTargetManagement implements TargetManagement {
     public Page<Target> findByAssignedDistributionSet(final Pageable pageReq, final long distributionSetId) {
         final DistributionSet validDistSet = distributionSetManagement.getOrElseThrowException(distributionSetId);
 
-        return JpaManagementHelper.findAllWithCountBySpec(targetRepository, pageReq,
-                List.of(TargetSpecifications.hasAssignedDistributionSet(validDistSet.getId())));
+        return JpaManagementHelper.findAllWithCountBySpec(targetRepository,
+                List.of(TargetSpecifications.hasAssignedDistributionSet(validDistSet.getId())), pageReq
+        );
     }
 
     @Override
@@ -395,7 +396,7 @@ public class JpaTargetManagement implements TargetManagement {
                 RSQLUtility.buildRsqlSpecification(rsqlParam, TargetFields.class, virtualPropertyReplacer, database),
                 TargetSpecifications.hasAssignedDistributionSet(validDistSet.getId()));
 
-        return JpaManagementHelper.findAllWithCountBySpec(targetRepository, pageReq, specList);
+        return JpaManagementHelper.findAllWithCountBySpec(targetRepository, specList, pageReq);
     }
 
     @Override
@@ -419,8 +420,9 @@ public class JpaTargetManagement implements TargetManagement {
     public Page<Target> findByInstalledDistributionSet(final Pageable pageReq, final long distributionSetId) {
         final DistributionSet validDistSet = distributionSetManagement.getOrElseThrowException(distributionSetId);
 
-        return JpaManagementHelper.findAllWithCountBySpec(targetRepository, pageReq,
-                List.of(TargetSpecifications.hasInstalledDistributionSet(validDistSet.getId())));
+        return JpaManagementHelper.findAllWithCountBySpec(targetRepository,
+                List.of(TargetSpecifications.hasInstalledDistributionSet(validDistSet.getId())), pageReq
+        );
     }
 
     @Override
@@ -432,13 +434,14 @@ public class JpaTargetManagement implements TargetManagement {
                 RSQLUtility.buildRsqlSpecification(rsqlParam, TargetFields.class, virtualPropertyReplacer, database),
                 TargetSpecifications.hasInstalledDistributionSet(validDistSet.getId()));
 
-        return JpaManagementHelper.findAllWithCountBySpec(targetRepository, pageable, specList);
+        return JpaManagementHelper.findAllWithCountBySpec(targetRepository, specList, pageable);
     }
 
     @Override
     public Page<Target> findByUpdateStatus(final Pageable pageable, final TargetUpdateStatus status) {
-        return JpaManagementHelper.findAllWithCountBySpec(targetRepository, pageable,
-                List.of(TargetSpecifications.hasTargetUpdateStatus(status)));
+        return JpaManagementHelper.findAllWithCountBySpec(targetRepository, List.of(TargetSpecifications.hasTargetUpdateStatus(status)),
+                pageable
+        );
     }
 
     @Override
@@ -466,8 +469,8 @@ public class JpaTargetManagement implements TargetManagement {
     public Page<Target> findByTag(final Pageable pageable, final long tagId) {
         throwEntityNotFoundExceptionIfTagDoesNotExist(tagId);
 
-        return JpaManagementHelper.findAllWithCountBySpec(targetRepository, pageable,
-                List.of(TargetSpecifications.hasTag(tagId)));
+        return JpaManagementHelper.findAllWithCountBySpec(targetRepository, List.of(TargetSpecifications.hasTag(tagId)), pageable
+        );
     }
 
     @Override
@@ -478,7 +481,7 @@ public class JpaTargetManagement implements TargetManagement {
                 RSQLUtility.buildRsqlSpecification(rsqlParam, TargetFields.class, virtualPropertyReplacer, database),
                 TargetSpecifications.hasTag(tagId));
 
-        return JpaManagementHelper.findAllWithCountBySpec(targetRepository, pageable, specList);
+        return JpaManagementHelper.findAllWithCountBySpec(targetRepository, specList, pageable);
     }
 
     @Override
@@ -685,8 +688,9 @@ public class JpaTargetManagement implements TargetManagement {
 
     @Override
     public Page<Target> findByControllerAttributesRequested(final Pageable pageReq) {
-        return JpaManagementHelper.findAllWithCountBySpec(targetRepository, pageReq,
-                List.of(TargetSpecifications.hasRequestControllerAttributesTrue()));
+        return JpaManagementHelper.findAllWithCountBySpec(targetRepository, List.of(TargetSpecifications.hasRequestControllerAttributesTrue()),
+                pageReq
+        );
     }
 
     @Override
@@ -770,8 +774,9 @@ public class JpaTargetManagement implements TargetManagement {
     public Page<TargetMetadata> findMetaDataByControllerId(final Pageable pageable, final String controllerId) {
         final Long id = getByControllerIdAndThrowIfNotFound(controllerId).getId();
 
-        return JpaManagementHelper.findAllWithCountBySpec(targetMetadataRepository, pageable,
-                Collections.singletonList(metadataByTargetIdSpec(id)));
+        return JpaManagementHelper.findAllWithCountBySpec(targetMetadataRepository, Collections.singletonList(metadataByTargetIdSpec(id)),
+                pageable
+        );
     }
 
     @Override
@@ -791,7 +796,7 @@ public class JpaTargetManagement implements TargetManagement {
                         .buildRsqlSpecification(rsqlParam, TargetMetadataFields.class, virtualPropertyReplacer, database),
                 metadataByTargetIdSpec(targetId));
 
-        return JpaManagementHelper.findAllWithCountBySpec(targetMetadataRepository, pageable, specList);
+        return JpaManagementHelper.findAllWithCountBySpec(targetMetadataRepository, specList, pageable);
     }
 
     @Override

hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/management/JpaTargetTagManagement.java

@@ -99,13 +99,13 @@ public class JpaTargetTagManagement implements TargetTagManagement {
 
     @Override
     public Page<TargetTag> findAll(final Pageable pageable) {
-        return JpaManagementHelper.findAllWithCountBySpec(targetTagRepository, pageable, null);
+        return JpaManagementHelper.findAllWithCountBySpec(targetTagRepository, null, pageable);
     }
 
     @Override
     public Page<TargetTag> findByRsql(final Pageable pageable, final String rsqlParam) {
-        return JpaManagementHelper.findAllWithCountBySpec(targetTagRepository, pageable, Collections.singletonList(
-                RSQLUtility.buildRsqlSpecification(rsqlParam, TargetTagFields.class, virtualPropertyReplacer, database)));
+        return JpaManagementHelper.findAllWithCountBySpec(targetTagRepository, Collections.singletonList(
+                RSQLUtility.buildRsqlSpecification(rsqlParam, TargetTagFields.class, virtualPropertyReplacer, database)), pageable);
     }
 
     @Override

hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/management/JpaTargetTypeManagement.java

@@ -144,10 +144,10 @@ public class JpaTargetTypeManagement implements TargetTypeManagement {
 
     @Override
     public Page<TargetType> findByRsql(final Pageable pageable, final String rsqlParam) {
-        return JpaManagementHelper.findAllWithCountBySpec(targetTypeRepository, pageable,
-                List.of(
-                        RSQLUtility.buildRsqlSpecification(
-                                rsqlParam, TargetTypeFields.class, virtualPropertyReplacer, database)));
+        return JpaManagementHelper.findAllWithCountBySpec(targetTypeRepository, List.of(
+                RSQLUtility.buildRsqlSpecification(
+                        rsqlParam, TargetTypeFields.class, virtualPropertyReplacer, database)), pageable
+        );
     }
 
     @Override

hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/AbstractRepositoryManagementSecurityTest.java

@@ -14,7 +14,6 @@ import java.util.List;
 import io.qameta.allure.Description;
 import org.eclipse.hawkbit.im.authentication.SpPermission;
 import org.eclipse.hawkbit.repository.RepositoryManagement;
-import org.eclipse.hawkbit.repository.test.util.WithUser;
 import org.junit.jupiter.api.Test;
 import org.springframework.data.domain.Pageable;
 
@@ -105,7 +104,7 @@ public abstract class AbstractRepositoryManagementSecurityTest<T, C, U> extends
     @Test
     @Description("Tests RepositoryManagement PreAuthorized method with correct and insufficient permissions.")
     public void findByRsqlPermissionCheck() {
-        assertPermissions(() -> getRepositoryManagement().findByRsql(Pageable.ofSize(1), "(name==*)"), List.of(SpPermission.READ_REPOSITORY));
+        assertPermissions(() -> getRepositoryManagement().findByRsql("(name==*)", Pageable.ofSize(1)), List.of(SpPermission.READ_REPOSITORY));
     }
 
 }

hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/acm/controller/DistributionSetAccessControllerTest.java

@@ -73,7 +73,7 @@ class DistributionSetAccessControllerTest extends AbstractAccessControllerTest {
                 .containsOnly(permitted.getId());
 
         // verify distributionSetManagement#findByRsql
-        assertThat(distributionSetManagement.findByRsql(Pageable.unpaged(), "name==*").get().map(Identifiable::getId)
+        assertThat(distributionSetManagement.findByRsql("name==*", Pageable.unpaged()).get().map(Identifiable::getId)
                 .toList()).containsOnly(permitted.getId());
 
         // verify distributionSetManagement#findByCompleted
@@ -82,8 +82,8 @@ class DistributionSetAccessControllerTest extends AbstractAccessControllerTest {
 
         // verify distributionSetManagement#findByDistributionSetFilter
         assertThat(distributionSetManagement
-                .findByDistributionSetFilter(Pageable.unpaged(),
-                        DistributionSetFilter.builder().isDeleted(false).build())
+                .findByDistributionSetFilter(DistributionSetFilter.builder().isDeleted(false).build(), Pageable.unpaged()
+                )
                 .get().map(Identifiable::getId).toList()).containsOnly(permitted.getId());
 
         // verify distributionSetManagement#get
@@ -106,14 +106,14 @@ class DistributionSetAccessControllerTest extends AbstractAccessControllerTest {
         }).as("Fail if request hidden.").isInstanceOf(EntityNotFoundException.class);
 
         // verify distributionSetManagement#getByNameAndVersion
-        assertThat(distributionSetManagement.getByNameAndVersion(permitted.getName(), permitted.getVersion()))
+        assertThat(distributionSetManagement.findByNameAndVersion(permitted.getName(), permitted.getVersion()))
                 .isPresent();
-        assertThat(distributionSetManagement.getByNameAndVersion(hidden.getName(), hidden.getVersion())).isEmpty();
+        assertThat(distributionSetManagement.findByNameAndVersion(hidden.getName(), hidden.getVersion())).isEmpty();
 
         // verify distributionSetManagement#getByAction
-        assertThat(distributionSetManagement.getByAction(permittedAction.getId())).isPresent();
+        assertThat(distributionSetManagement.findByAction(permittedAction.getId())).isPresent();
         assertThatThrownBy(() -> {
-            distributionSetManagement.getByAction(hiddenAction.getId());
+            distributionSetManagement.findByAction(hiddenAction.getId());
         }).as("Action is hidden.").isInstanceOf(InsufficientPermissionException.class);
     }
 
@@ -152,11 +152,11 @@ class DistributionSetAccessControllerTest extends AbstractAccessControllerTest {
         final JpaDistributionSetMetadata metadata = new JpaDistributionSetMetadata("test", "test");
 
         // verify distributionSetManagement#createMetaData
-        distributionSetManagement.createMetaData(permitted.getId(), Collections.singletonList(metadata));
-        assertThatThrownBy(() -> distributionSetManagement.createMetaData(readOnly.getId(), Collections.singletonList(metadata)))
+        distributionSetManagement.putMetaData(permitted.getId(), Collections.singletonList(metadata));
+        assertThatThrownBy(() -> distributionSetManagement.putMetaData(readOnly.getId(), Collections.singletonList(metadata)))
                 .as("Distribution set not allowed to me modified.")
                 .isInstanceOf(EntityNotFoundException.class);
-        assertThatThrownBy(() -> distributionSetManagement.createMetaData(hidden.getId(), Collections.singletonList(metadata)))
+        assertThatThrownBy(() -> distributionSetManagement.putMetaData(hidden.getId(), Collections.singletonList(metadata)))
                 .as("Distribution set should not be visible.")
                 .isInstanceOf(EntityNotFoundException.class);
 
@@ -204,10 +204,10 @@ class DistributionSetAccessControllerTest extends AbstractAccessControllerTest {
         // allow updating the permitted distributionSet
         defineAccess(AccessController.Operation.UPDATE, permitted);
 
-        assertThat(distributionSetManagement.findByTag(Pageable.unpaged(), dsTag.getId()).get().map(Identifiable::getId)
+        assertThat(distributionSetManagement.findByTag(dsTag.getId(), Pageable.unpaged()).get().map(Identifiable::getId)
                 .toList()).containsOnly(permitted.getId(), readOnly.getId());
 
-        assertThat(distributionSetManagement.findByRsqlAndTag(Pageable.unpaged(), "name==*", dsTag.getId()).get()
+        assertThat(distributionSetManagement.findByRsqlAndTag("name==*", dsTag.getId(), Pageable.unpaged()).get()
                 .map(Identifiable::getId).toList()).containsOnly(permitted.getId(), readOnly.getId());
 
         // verify distributionSetManagement#unassignTag on permitted target

hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/management/DistributionSetManagementSecurityTest.java

@@ -10,7 +10,6 @@
 package org.eclipse.hawkbit.repository.jpa.management;
 
 import java.util.List;
-import java.util.Random;
 
 import io.qameta.allure.Description;
 import io.qameta.allure.Feature;
@@ -69,7 +68,7 @@ class DistributionSetManagementSecurityTest
     @Description("Tests ManagementAPI PreAuthorized method with correct and insufficient permissions.")
     void createMetaDataPermissionsCheck() {
         assertPermissions(
-                () -> distributionSetManagement.createMetaData(1L, List.of(entityFactory.generateTargetMetadata("key", "value"))),
+                () -> distributionSetManagement.putMetaData(1L, List.of(entityFactory.generateTargetMetadata("key", "value"))),
                 List.of(SpPermission.UPDATE_REPOSITORY));
     }
 
@@ -103,7 +102,7 @@ class DistributionSetManagementSecurityTest
     @Test
     @Description("Tests ManagementAPI PreAuthorized method with correct and insufficient permissions.")
     void getByActionPermissionsCheck() {
-        assertPermissions(() -> distributionSetManagement.getByAction(1L), List.of(SpPermission.READ_REPOSITORY));
+        assertPermissions(() -> distributionSetManagement.findByAction(1L), List.of(SpPermission.READ_REPOSITORY));
     }
 
     @Test
@@ -115,7 +114,7 @@ class DistributionSetManagementSecurityTest
     @Test
     @Description("Tests ManagementAPI PreAuthorized method with correct and insufficient permissions.")
     void getByNameAndVersionPermissionsCheck() {
-        assertPermissions(() -> distributionSetManagement.getByNameAndVersion("name", "version"), List.of(SpPermission.READ_REPOSITORY));
+        assertPermissions(() -> distributionSetManagement.findByNameAndVersion("name", "version"), List.of(SpPermission.READ_REPOSITORY));
     }
 
     @Test
@@ -139,7 +138,7 @@ class DistributionSetManagementSecurityTest
     @Test
     @Description("Tests ManagementAPI PreAuthorized method with correct and insufficient permissions.")
     void findMetaDataByDistributionSetIdPermissionsCheck() {
-        assertPermissions(() -> distributionSetManagement.findMetaDataByDistributionSetId(PAGE, 1L), List.of(SpPermission.READ_REPOSITORY));
+        assertPermissions(() -> distributionSetManagement.findMetaDataByDistributionSetId(1L, PAGE), List.of(SpPermission.READ_REPOSITORY));
     }
 
     @Test
@@ -151,7 +150,7 @@ class DistributionSetManagementSecurityTest
     @Test
     @Description("Tests ManagementAPI PreAuthorized method with correct and insufficient permissions.")
     void findMetaDataByDistributionSetIdAndRsqlPermissionsCheck() {
-        assertPermissions(() -> distributionSetManagement.findMetaDataByDistributionSetIdAndRsql(PAGE, 1L, "rsql"),
+        assertPermissions(() -> distributionSetManagement.findMetaDataByDistributionSetIdAndRsql(1L, "rsql", PAGE),
                 List.of(SpPermission.READ_REPOSITORY));
     }
 
@@ -170,7 +169,7 @@ class DistributionSetManagementSecurityTest
     @Test
     @Description("Tests ManagementAPI PreAuthorized method with correct and insufficient permissions.")
     void findByDistributionSetFilterPermissionsCheck() {
-        assertPermissions(() -> distributionSetManagement.findByDistributionSetFilter(PAGE, DistributionSetFilter.builder().build()),
+        assertPermissions(() -> distributionSetManagement.findByDistributionSetFilter(DistributionSetFilter.builder().build(), PAGE),
                 List.of(SpPermission.READ_REPOSITORY));
     }
 
@@ -184,19 +183,19 @@ class DistributionSetManagementSecurityTest
     @Test
     @Description("Tests ManagementAPI PreAuthorized method with correct and insufficient permissions.")
     void findByTagPermissionsCheck() {
-        assertPermissions(() -> distributionSetManagement.findByTag(PAGE, 1L), List.of(SpPermission.READ_REPOSITORY));
+        assertPermissions(() -> distributionSetManagement.findByTag(1L, PAGE), List.of(SpPermission.READ_REPOSITORY));
     }
 
     @Test
     @Description("Tests ManagementAPI PreAuthorized method with correct and insufficient permissions.")
     void findByRsqlAndTagPermissionsCheck() {
-        assertPermissions(() -> distributionSetManagement.findByRsqlAndTag(PAGE, "rsql", 1L), List.of(SpPermission.READ_REPOSITORY));
+        assertPermissions(() -> distributionSetManagement.findByRsqlAndTag("rsql", 1L, PAGE), List.of(SpPermission.READ_REPOSITORY));
     }
 
     @Test
     @Description("Tests ManagementAPI PreAuthorized method with correct and insufficient permissions.")
     void getMetaDataByDistributionSetIdPermissionsCheck() {
-        assertPermissions(() -> distributionSetManagement.getMetaDataByDistributionSetId(1L, "key"), List.of(SpPermission.READ_REPOSITORY));
+        assertPermissions(() -> distributionSetManagement.findMetaDataByDistributionSetId(1L, "key"), List.of(SpPermission.READ_REPOSITORY));
     }
 
     @Test

hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/management/DistributionSetManagementTest.java

@@ -96,8 +96,8 @@ class DistributionSetManagementTest extends AbstractJpaIntegrationTest {
         final DistributionSet set = testdataFactory.createDistributionSet();
         assertThat(distributionSetManagement.get(NOT_EXIST_IDL)).isNotPresent();
         assertThat(distributionSetManagement.getWithDetails(NOT_EXIST_IDL)).isNotPresent();
-        assertThat(distributionSetManagement.getByNameAndVersion(NOT_EXIST_ID, NOT_EXIST_ID)).isNotPresent();
-        assertThat(distributionSetManagement.getMetaDataByDistributionSetId(set.getId(), NOT_EXIST_ID)).isNotPresent();
+        assertThat(distributionSetManagement.findByNameAndVersion(NOT_EXIST_ID, NOT_EXIST_ID)).isNotPresent();
+        assertThat(distributionSetManagement.findMetaDataByDistributionSetId(set.getId(), NOT_EXIST_ID)).isNotPresent();
     }
 
     @Test
@@ -125,8 +125,8 @@ class DistributionSetManagementTest extends AbstractJpaIntegrationTest {
         verifyThrownExceptionBy(() -> distributionSetManagement.assignTag(singletonList(set.getId()), NOT_EXIST_IDL), "DistributionSetTag");
         verifyThrownExceptionBy(() -> distributionSetManagement.assignTag(singletonList(NOT_EXIST_IDL), dsTag.getId()), "DistributionSet");
 
-        verifyThrownExceptionBy(() -> distributionSetManagement.findByTag(PAGE, NOT_EXIST_IDL), "DistributionSetTag");
-        verifyThrownExceptionBy(() -> distributionSetManagement.findByRsqlAndTag(PAGE, "name==*", NOT_EXIST_IDL), "DistributionSetTag");
+        verifyThrownExceptionBy(() -> distributionSetManagement.findByTag(NOT_EXIST_IDL, PAGE), "DistributionSetTag");
+        verifyThrownExceptionBy(() -> distributionSetManagement.findByRsqlAndTag("name==*", NOT_EXIST_IDL, PAGE), "DistributionSetTag");
 
         verifyThrownExceptionBy(() -> distributionSetManagement.assignTag(singletonList(NOT_EXIST_IDL), dsTag.getId()), "DistributionSet");
         verifyThrownExceptionBy(() ->
@@ -139,7 +139,7 @@ class DistributionSetManagementTest extends AbstractJpaIntegrationTest {
         verifyThrownExceptionBy(() -> distributionSetManagement.create(
                 entityFactory.distributionSet().create().name("xxx").type(NOT_EXIST_ID)), "DistributionSetType");
 
-        verifyThrownExceptionBy(() -> distributionSetManagement.createMetaData(
+        verifyThrownExceptionBy(() -> distributionSetManagement.putMetaData(
                 NOT_EXIST_IDL, singletonList(entityFactory.generateDsMetadata("123", "123"))), "DistributionSet");
 
         verifyThrownExceptionBy(() -> distributionSetManagement.delete(singletonList(NOT_EXIST_IDL)), "DistributionSet");
@@ -149,16 +149,16 @@ class DistributionSetManagementTest extends AbstractJpaIntegrationTest {
         verifyThrownExceptionBy(() -> distributionSetManagement.deleteMetaData(set.getId(), NOT_EXIST_ID),
                 "DistributionSetMetadata");
 
-        verifyThrownExceptionBy(() -> distributionSetManagement.getByAction(NOT_EXIST_IDL), "Action");
+        verifyThrownExceptionBy(() -> distributionSetManagement.findByAction(NOT_EXIST_IDL), "Action");
 
-        verifyThrownExceptionBy(() -> distributionSetManagement.getMetaDataByDistributionSetId(NOT_EXIST_IDL, "xxx"),
+        verifyThrownExceptionBy(() -> distributionSetManagement.findMetaDataByDistributionSetId(NOT_EXIST_IDL, "xxx"),
                 "DistributionSet");
 
-        verifyThrownExceptionBy(() -> distributionSetManagement.findMetaDataByDistributionSetId(PAGE, NOT_EXIST_IDL),
+        verifyThrownExceptionBy(() -> distributionSetManagement.findMetaDataByDistributionSetId(NOT_EXIST_IDL, PAGE),
                 "DistributionSet");
 
         verifyThrownExceptionBy(
-                () -> distributionSetManagement.findMetaDataByDistributionSetIdAndRsql(PAGE, NOT_EXIST_IDL, "name==*"),
+                () -> distributionSetManagement.findMetaDataByDistributionSetIdAndRsql(NOT_EXIST_IDL, "name==*", PAGE),
                 "DistributionSet");
 
         assertThatThrownBy(() -> distributionSetManagement.isInUse(NOT_EXIST_IDL))
@@ -325,22 +325,22 @@ class DistributionSetManagementTest extends AbstractJpaIntegrationTest {
                 .as("ds has wrong tag size")
                 .isEqualTo(1));
 
-        final DistributionSetTag findDistributionSetTag = getOrThrow(distributionSetTagManagement.getByName(TAG1_NAME));
+        final DistributionSetTag findDistributionSetTag = getOrThrow(distributionSetTagManagement.findByName(TAG1_NAME));
 
         assertThat(assignedDS.size()).as("assigned ds has wrong size")
-                .isEqualTo(distributionSetManagement.findByTag(PAGE, tag.getId()).getNumberOfElements());
+                .isEqualTo(distributionSetManagement.findByTag(tag.getId(), PAGE).getNumberOfElements());
 
         final JpaDistributionSet unAssignDS = (JpaDistributionSet) distributionSetManagement
                 .unassignTag(assignDS.get(0), findDistributionSetTag.getId());
         assertThat(unAssignDS.getId()).as("unassigned ds is wrong").isEqualTo(assignDS.get(0));
         assertThat(unAssignDS.getTags().size()).as("unassigned ds has wrong tag size").isZero();
-        assertThat(distributionSetTagManagement.getByName(TAG1_NAME)).isPresent();
-        assertThat(distributionSetManagement.findByTag(PAGE, tag.getId()).getNumberOfElements())
+        assertThat(distributionSetTagManagement.findByName(TAG1_NAME)).isPresent();
+        assertThat(distributionSetManagement.findByTag(tag.getId(), PAGE).getNumberOfElements())
                 .as("ds tag ds has wrong ds size").isEqualTo(3);
 
-        assertThat(distributionSetManagement.findByRsqlAndTag(PAGE, "name==" + unAssignDS.getName(), tag.getId())
+        assertThat(distributionSetManagement.findByRsqlAndTag("name==" + unAssignDS.getName(), tag.getId(), PAGE)
                 .getNumberOfElements()).as("ds tag ds has wrong ds size").isZero();
-        assertThat(distributionSetManagement.findByRsqlAndTag(PAGE, "name!=" + unAssignDS.getName(), tag.getId())
+        assertThat(distributionSetManagement.findByRsqlAndTag("name!=" + unAssignDS.getName(), tag.getId(), PAGE)
                 .getNumberOfElements()).as("ds tag ds has wrong ds size").isEqualTo(3);
     }
 
@@ -791,10 +791,10 @@ class DistributionSetManagementTest extends AbstractJpaIntegrationTest {
         }
 
         final Page<DistributionSetMetadata> metadataOfDs1 = distributionSetManagement
-                .findMetaDataByDistributionSetId(PageRequest.of(0, 100), ds1.getId());
+                .findMetaDataByDistributionSetId(ds1.getId(), PageRequest.of(0, 100));
 
         final Page<DistributionSetMetadata> metadataOfDs2 = distributionSetManagement
-                .findMetaDataByDistributionSetId(PageRequest.of(0, 100), ds2.getId());
+                .findMetaDataByDistributionSetId(ds2.getId(), PageRequest.of(0, 100));
 
         assertThat(metadataOfDs1.getNumberOfElements())
                 .isEqualTo(quotaManagement.getMaxMetaDataEntriesPerDistributionSet());
@@ -831,7 +831,7 @@ class DistributionSetManagementTest extends AbstractJpaIntegrationTest {
         assertThat(distributionSetRepository.findAll()).hasSize(4);
         assertThat(distributionSetManagement.findByCompleted(PAGE, true)).hasSize(2);
         assertThat(distributionSetManagement.findAll(PAGE)).hasSize(2);
-        assertThat(distributionSetManagement.findByRsql(PAGE, "name==*")).hasSize(2);
+        assertThat(distributionSetManagement.findByRsql("name==*", PAGE)).hasSize(2);
         assertThat(distributionSetManagement.count()).isEqualTo(2);
     }
 
@@ -889,7 +889,7 @@ class DistributionSetManagementTest extends AbstractJpaIntegrationTest {
         final String knownUpdateValue = "knownUpdateValue";
 
         final DistributionSet ds = testdataFactory.createDistributionSet();
-        distributionSetManagement.createMetaData(ds.getId(),
+        distributionSetManagement.putMetaData(ds.getId(),
                 singletonList(entityFactory.generateDsMetadata(knownKey1, knownValue)));
 
         distributionSetInvalidationManagement.invalidateDistributionSet(
@@ -898,7 +898,7 @@ class DistributionSetManagementTest extends AbstractJpaIntegrationTest {
         // assert that no new metadata can be created
         assertThatExceptionOfType(InvalidDistributionSetException.class)
                 .as("Invalid distributionSet should throw an exception")
-                .isThrownBy(() -> distributionSetManagement.createMetaData(ds.getId(),
+                .isThrownBy(() -> distributionSetManagement.putMetaData(ds.getId(),
                         singletonList(entityFactory.generateDsMetadata(knownKey2, knownValue))));
 
         // assert that an existing metadata can not be updated
@@ -1251,18 +1251,18 @@ class DistributionSetManagementTest extends AbstractJpaIntegrationTest {
     private void assertThatFilterContainsOnlyGivenDistributionSets(final DistributionSetFilterBuilder filterBuilder,
             final List<DistributionSet> distributionSets) {
         final int expectedDsSize = distributionSets.size();
-        assertThat(distributionSetManagement.findByDistributionSetFilter(PAGE, filterBuilder.build()).getContent())
+        assertThat(distributionSetManagement.findByDistributionSetFilter(filterBuilder.build(), PAGE).getContent())
                 .hasSize(expectedDsSize).containsOnly(distributionSets.toArray(new DistributionSet[expectedDsSize]));
     }
 
     private void assertThatFilterDoesNotContainAnyDistributionSet(final DistributionSetFilterBuilder filterBuilder) {
-        assertThat(distributionSetManagement.findByDistributionSetFilter(PAGE, filterBuilder.build()).getContent())
+        assertThat(distributionSetManagement.findByDistributionSetFilter(filterBuilder.build(), PAGE).getContent())
                 .isEmpty();
     }
 
     private void assertThatFilterHasSizeAndDoesNotContainDistributionSet(
             final DistributionSetFilterBuilder filterBuilder, final int size, final DistributionSet ds) {
-        assertThat(distributionSetManagement.findByDistributionSetFilter(PAGE, filterBuilder.build()).getContent())
+        assertThat(distributionSetManagement.findByDistributionSetFilter(filterBuilder.build(), PAGE).getContent())
                 .hasSize(size).doesNotContain(ds);
     }
 

hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/management/DistributionSetTagManagementSecurityTest.java

@@ -47,7 +47,7 @@ public class DistributionSetTagManagementSecurityTest
     @Test
     @Description("Tests ManagementAPI PreAuthorized method with correct and insufficient permissions.")
     void getByNameWitPermissionWorks() {
-        assertPermissions(() -> distributionSetTagManagement.getByName("tagName"), List.of(SpPermission.READ_REPOSITORY));
+        assertPermissions(() -> distributionSetTagManagement.findByName("tagName"), List.of(SpPermission.READ_REPOSITORY));
     }
 
     @Test

hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/management/DistributionSetTagManagementTest.java

@@ -56,7 +56,7 @@ class DistributionSetTagManagementTest extends AbstractJpaIntegrationTest {
     @Description("Verifies that management get access reacts as specified on calls for non existing entities by means of Optional not present.")
     @ExpectEvents({ @Expect(type = TargetCreatedEvent.class, count = 0) })
     void nonExistingEntityAccessReturnsNotPresent() {
-        assertThat(distributionSetTagManagement.getByName(NOT_EXIST_ID)).isNotPresent();
+        assertThat(distributionSetTagManagement.findByName(NOT_EXIST_ID)).isNotPresent();
         assertThat(distributionSetTagManagement.get(NOT_EXIST_IDL)).isNotPresent();
     }
 
@@ -95,18 +95,18 @@ class DistributionSetTagManagementTest extends AbstractJpaIntegrationTest {
         assignTag(dsBs, tagB);
         assignTag(dsCs, tagC);
 
-        assignTag(dsABs, distributionSetTagManagement.getByName(tagA.getName()).get());
-        assignTag(dsABs, distributionSetTagManagement.getByName(tagB.getName()).get());
+        assignTag(dsABs, distributionSetTagManagement.findByName(tagA.getName()).get());
+        assignTag(dsABs, distributionSetTagManagement.findByName(tagB.getName()).get());
 
-        assignTag(dsACs, distributionSetTagManagement.getByName(tagA.getName()).get());
-        assignTag(dsACs, distributionSetTagManagement.getByName(tagC.getName()).get());
+        assignTag(dsACs, distributionSetTagManagement.findByName(tagA.getName()).get());
+        assignTag(dsACs, distributionSetTagManagement.findByName(tagC.getName()).get());
 
-        assignTag(dsBCs, distributionSetTagManagement.getByName(tagB.getName()).get());
-        assignTag(dsBCs, distributionSetTagManagement.getByName(tagC.getName()).get());
+        assignTag(dsBCs, distributionSetTagManagement.findByName(tagB.getName()).get());
+        assignTag(dsBCs, distributionSetTagManagement.findByName(tagC.getName()).get());
 
-        assignTag(dsABCs, distributionSetTagManagement.getByName(tagA.getName()).get());
-        assignTag(dsABCs, distributionSetTagManagement.getByName(tagB.getName()).get());
-        assignTag(dsABCs, distributionSetTagManagement.getByName(tagC.getName()).get());
+        assignTag(dsABCs, distributionSetTagManagement.findByName(tagA.getName()).get());
+        assignTag(dsABCs, distributionSetTagManagement.findByName(tagB.getName()).get());
+        assignTag(dsABCs, distributionSetTagManagement.findByName(tagC.getName()).get());
 
         // search for not deleted
         final DistributionSetFilter.DistributionSetFilterBuilder distributionSetFilterBuilder = getDistributionSetFilterBuilder()
@@ -150,7 +150,7 @@ class DistributionSetTagManagementTest extends AbstractJpaIntegrationTest {
         assertThat(result).size().isEqualTo(20);
         assertThat(result).containsAll(distributionSetManagement.get(groupA.stream().map(DistributionSet::getId).toList()));
         assertThat(
-                distributionSetManagement.findByTag(Pageable.unpaged(), tag.getId()).getContent().stream()
+                distributionSetManagement.findByTag(tag.getId(), Pageable.unpaged()).getContent().stream()
                         .map(DistributionSet::getId)
                         .sorted()
                         .toList())
@@ -163,7 +163,7 @@ class DistributionSetTagManagementTest extends AbstractJpaIntegrationTest {
         assertThat(result).containsAll(distributionSetManagement
                 .get(groupAB.stream().map(DistributionSet::getId).toList()));
         assertThat(
-                distributionSetManagement.findByTag(Pageable.unpaged(), tag.getId()).getContent().stream().map(DistributionSet::getId).sorted()
+                distributionSetManagement.findByTag(tag.getId(), Pageable.unpaged()).getContent().stream().map(DistributionSet::getId).sorted()
                         .toList())
                 .isEqualTo(groupAB.stream().map(DistributionSet::getId).sorted().toList());
 
@@ -171,7 +171,7 @@ class DistributionSetTagManagementTest extends AbstractJpaIntegrationTest {
         result = unassignTag(concat(groupA, groupB), tag);
         assertThat(result).size().isEqualTo(40);
         assertThat(result).containsAll(distributionSetManagement.get(concat(groupB, groupA).stream().map(DistributionSet::getId).toList()));
-        assertThat(distributionSetManagement.findByTag(Pageable.unpaged(), tag.getId()).getContent()).isEmpty();
+        assertThat(distributionSetManagement.findByTag(tag.getId(), Pageable.unpaged()).getContent()).isEmpty();
     }
 
     @Test
@@ -210,7 +210,7 @@ class DistributionSetTagManagementTest extends AbstractJpaIntegrationTest {
 
         assertThat(distributionSetTagRepository.findByNameEquals("kai1").get().getDescription()).as("wrong tag found")
                 .isEqualTo("kai2");
-        assertThat(distributionSetTagManagement.getByName("kai1").get().getColour()).as("wrong tag found")
+        assertThat(distributionSetTagManagement.findByName("kai1").get().getColour()).as("wrong tag found")
                 .isEqualTo("colour");
         assertThat(distributionSetTagManagement.get(tag.getId()).get().getColour()).as("wrong tag found")
                 .isEqualTo("colour");
@@ -302,7 +302,7 @@ class DistributionSetTagManagementTest extends AbstractJpaIntegrationTest {
     private void verifyExpectedFilteredDistributionSets(final DistributionSetFilter.DistributionSetFilterBuilder distributionSetFilterBuilder,
             final Stream<Collection<DistributionSet>> expectedFilteredDistributionSets) {
         final Collection<Long> retrievedFilteredDsIds = distributionSetManagement
-                .findByDistributionSetFilter(PAGE, distributionSetFilterBuilder.build()).stream()
+                .findByDistributionSetFilter(distributionSetFilterBuilder.build(), PAGE).stream()
                 .map(DistributionSet::getId).toList();
         final Collection<Long> expectedFilteredDsIds = expectedFilteredDistributionSets.flatMap(Collection::stream)
                 .map(DistributionSet::getId).toList();

hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/management/DistributionSetTypeManagementSecurityTest.java

@@ -46,13 +46,13 @@ public class DistributionSetTypeManagementSecurityTest
     @Test
     @Description("Tests ManagementAPI PreAuthorized method with correct and insufficient permissions.")
     void getByKeyPermissionsCheck() {
-        assertPermissions(() -> distributionSetTypeManagement.getByKey("key"), List.of(SpPermission.READ_REPOSITORY));
+        assertPermissions(() -> distributionSetTypeManagement.findByKey("key"), List.of(SpPermission.READ_REPOSITORY));
     }
 
     @Test
     @Description("Tests ManagementAPI PreAuthorized method with correct and insufficient permissions.")
     void getByNamePermissionsCheck() {
-        assertPermissions(() -> distributionSetTypeManagement.getByName("name"), List.of(SpPermission.READ_REPOSITORY));
+        assertPermissions(() -> distributionSetTypeManagement.findByName("name"), List.of(SpPermission.READ_REPOSITORY));
     }
 
     @Test

hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/management/DistributionSetTypeManagementTest.java

@@ -58,8 +58,8 @@ public class DistributionSetTypeManagementTest extends AbstractJpaIntegrationTes
     @ExpectEvents({ @Expect(type = DistributionSetCreatedEvent.class, count = 0) })
     public void nonExistingEntityAccessReturnsNotPresent() {
         assertThat(distributionSetTypeManagement.get(NOT_EXIST_IDL)).isNotPresent();
-        assertThat(distributionSetTypeManagement.getByKey(NOT_EXIST_ID)).isNotPresent();
-        assertThat(distributionSetTypeManagement.getByName(NOT_EXIST_ID)).isNotPresent();
+        assertThat(distributionSetTypeManagement.findByKey(NOT_EXIST_ID)).isNotPresent();
+        assertThat(distributionSetTypeManagement.findByName(NOT_EXIST_ID)).isNotPresent();
     }
 
     @Test
@@ -111,23 +111,23 @@ public class DistributionSetTypeManagementTest extends AbstractJpaIntegrationTes
     public void updateUnassignedDistributionSetTypeModules() {
         final DistributionSetType updatableType = distributionSetTypeManagement
                 .create(entityFactory.distributionSetType().create().key("updatableType").name("to be deleted"));
-        assertThat(distributionSetTypeManagement.getByKey("updatableType").get().getMandatoryModuleTypes()).isEmpty();
+        assertThat(distributionSetTypeManagement.findByKey("updatableType").get().getMandatoryModuleTypes()).isEmpty();
 
         // add OS
         distributionSetTypeManagement.assignMandatorySoftwareModuleTypes(updatableType.getId(),
                 Set.of(osType.getId()));
-        assertThat(distributionSetTypeManagement.getByKey("updatableType").get().getMandatoryModuleTypes())
+        assertThat(distributionSetTypeManagement.findByKey("updatableType").get().getMandatoryModuleTypes())
                 .containsOnly(osType);
 
         // add JVM
         distributionSetTypeManagement.assignMandatorySoftwareModuleTypes(updatableType.getId(),
                 Set.of(runtimeType.getId()));
-        assertThat(distributionSetTypeManagement.getByKey("updatableType").get().getMandatoryModuleTypes())
+        assertThat(distributionSetTypeManagement.findByKey("updatableType").get().getMandatoryModuleTypes())
                 .containsOnly(osType, runtimeType);
 
         // remove OS
         distributionSetTypeManagement.unassignSoftwareModuleType(updatableType.getId(), osType.getId());
-        assertThat(distributionSetTypeManagement.getByKey("updatableType").get().getMandatoryModuleTypes())
+        assertThat(distributionSetTypeManagement.findByKey("updatableType").get().getMandatoryModuleTypes())
                 .containsOnly(runtimeType);
     }
 
@@ -186,9 +186,9 @@ public class DistributionSetTypeManagementTest extends AbstractJpaIntegrationTes
         distributionSetTypeManagement.update(
                 entityFactory.distributionSetType().update(nonUpdatableType.getId()).description("a new description"));
 
-        assertThat(distributionSetTypeManagement.getByKey("updatableType").get().getDescription())
+        assertThat(distributionSetTypeManagement.findByKey("updatableType").get().getDescription())
                 .isEqualTo("a new description");
-        assertThat(distributionSetTypeManagement.getByKey("updatableType").get().getColour()).isEqualTo("test123");
+        assertThat(distributionSetTypeManagement.findByKey("updatableType").get().getColour()).isEqualTo("test123");
     }
 
     @Test
@@ -206,7 +206,7 @@ public class DistributionSetTypeManagementTest extends AbstractJpaIntegrationTes
     public void removeModuleToAssignedDistributionSetTypeFails() {
         DistributionSetType nonUpdatableType = distributionSetTypeManagement
                 .create(entityFactory.distributionSetType().create().key("updatableType").name("to be deleted"));
-        assertThat(distributionSetTypeManagement.getByKey("updatableType").get().getMandatoryModuleTypes()).isEmpty();
+        assertThat(distributionSetTypeManagement.findByKey("updatableType").get().getMandatoryModuleTypes()).isEmpty();
 
         nonUpdatableType = distributionSetTypeManagement.assignMandatorySoftwareModuleTypes(nonUpdatableType.getId(),
                 Set.of(osType.getId()));
@@ -242,11 +242,11 @@ public class DistributionSetTypeManagementTest extends AbstractJpaIntegrationTes
                 entityFactory.distributionSet().create().name("softdeleted").version("1").type(toBeDeleted.getKey()));
 
         distributionSetTypeManagement.delete(toBeDeleted.getId());
-        final Optional<DistributionSetType> softdeleted = distributionSetTypeManagement.getByKey("softdeleted");
+        final Optional<DistributionSetType> softdeleted = distributionSetTypeManagement.findByKey("softdeleted");
         assertThat(softdeleted).isPresent();
         assertThat(softdeleted.get().isDeleted()).isTrue();
         assertThat(distributionSetTypeManagement.findAll(PAGE)).hasSize(existing);
-        assertThat(distributionSetTypeManagement.findByRsql(PAGE, "name==*")).hasSize(existing);
+        assertThat(distributionSetTypeManagement.findByRsql("name==*", PAGE)).hasSize(existing);
         assertThat(distributionSetTypeManagement.count()).isEqualTo(existing);
     }
 
@@ -358,7 +358,7 @@ public class DistributionSetTypeManagementTest extends AbstractJpaIntegrationTes
     private DistributionSetType createDistributionSetTypeUsedByDs() {
         final DistributionSetType nonUpdatableType = distributionSetTypeManagement.create(entityFactory
                 .distributionSetType().create().key("updatableType").name("to be deleted").colour("test123"));
-        assertThat(distributionSetTypeManagement.getByKey("updatableType").get().getMandatoryModuleTypes()).isEmpty();
+        assertThat(distributionSetTypeManagement.findByKey("updatableType").get().getMandatoryModuleTypes()).isEmpty();
         distributionSetManagement.create(entityFactory.distributionSet().create().name("newtypesoft").version("1")
                 .type(nonUpdatableType.getKey()));
         return nonUpdatableType;

hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/management/SoftwareManagementSecurityTest.java

@@ -46,9 +46,9 @@ public class SoftwareManagementSecurityTest
     @Description("Tests ManagementAPI PreAuthorized method with correct and insufficient permissions.")
     void createMetaDataPermissionsCheck() {
         assertPermissions(
-                () -> softwareModuleManagement.createMetaData(entityFactory.softwareModuleMetadata().create(1L).key("key").value("value")),
+                () -> softwareModuleManagement.updateMetaData(entityFactory.softwareModuleMetadata().create(1L).key("key").value("value")),
                 List.of(SpPermission.UPDATE_REPOSITORY));
-        assertPermissions(() -> softwareModuleManagement.createMetaData(
+        assertPermissions(() -> softwareModuleManagement.putMetaData(
                 List.of(entityFactory.softwareModuleMetadata().create(1L).key("key").value("value"))), List.of(SpPermission.UPDATE_REPOSITORY));
     }
 
@@ -64,7 +64,7 @@ public class SoftwareManagementSecurityTest
     @Test
     @Description("Tests ManagementAPI PreAuthorized method with correct and insufficient permissions.")
     void findByAssignedToPermissionsCheck() {
-        assertPermissions(() -> softwareModuleManagement.findByAssignedTo(PAGE, 1L), List.of(SpPermission.READ_REPOSITORY));
+        assertPermissions(() -> softwareModuleManagement.findByAssignedTo(1L, PAGE), List.of(SpPermission.READ_REPOSITORY));
     }
 
     @Test
@@ -76,19 +76,19 @@ public class SoftwareManagementSecurityTest
     @Test
     @Description("Tests ManagementAPI PreAuthorized method with correct and insufficient permissions.")
     void findByTextAndTypePermissionsCheck() {
-        assertPermissions(() -> softwareModuleManagement.findByTextAndType(PAGE, "text", 1L), List.of(SpPermission.READ_REPOSITORY));
+        assertPermissions(() -> softwareModuleManagement.findByTextAndType("text", 1L, PAGE), List.of(SpPermission.READ_REPOSITORY));
     }
 
     @Test
     void getByNameAndVersionAndTypePermissionsCheck() {
-        assertPermissions(() -> softwareModuleManagement.getByNameAndVersionAndType("name", "version", 1L),
+        assertPermissions(() -> softwareModuleManagement.findByNameAndVersionAndType("name", "version", 1L),
                 List.of(SpPermission.READ_REPOSITORY));
     }
 
     @Test
     @Description("Tests ManagementAPI PreAuthorized method with correct and insufficient permissions.")
     void getMetaDataBySoftwareModuleIdPermissionsCheck() {
-        assertPermissions(() -> softwareModuleManagement.getMetaDataBySoftwareModuleId(1L, "key"), List.of(SpPermission.READ_REPOSITORY));
+        assertPermissions(() -> softwareModuleManagement.findMetaDataBySoftwareModuleId(1L, "key"), List.of(SpPermission.READ_REPOSITORY));
     }
 
     @Test
@@ -113,13 +113,13 @@ public class SoftwareManagementSecurityTest
     @Test
     @Description("Tests ManagementAPI PreAuthorized method with correct and insufficient permissions.")
     void findMetaDataByRsqlPermissionsCheck() {
-        assertPermissions(() -> softwareModuleManagement.findMetaDataByRsql(PAGE, 1L, "key==value"), List.of(SpPermission.READ_REPOSITORY));
+        assertPermissions(() -> softwareModuleManagement.findMetaDataByRsql(1L, "key==value", PAGE), List.of(SpPermission.READ_REPOSITORY));
     }
 
     @Test
     @Description("Tests ManagementAPI PreAuthorized method with correct and insufficient permissions.")
     void findByTypePermissionsCheck() {
-        assertPermissions(() -> softwareModuleManagement.findByType(PAGE, 1L), List.of(SpPermission.READ_REPOSITORY));
+        assertPermissions(() -> softwareModuleManagement.findByType(1L, PAGE), List.of(SpPermission.READ_REPOSITORY));
     }
 
     @Test

hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/management/SoftwareModuleManagementTest.java

@@ -68,10 +68,10 @@ class SoftwareModuleManagementTest extends AbstractJpaIntegrationTest {
 
         assertThat(softwareModuleManagement.get(1234L)).isNotPresent();
 
-        assertThat(softwareModuleManagement.getByNameAndVersionAndType(NOT_EXIST_ID, NOT_EXIST_ID, osType.getId()))
+        assertThat(softwareModuleManagement.findByNameAndVersionAndType(NOT_EXIST_ID, NOT_EXIST_ID, osType.getId()))
                 .isNotPresent();
 
-        assertThat(softwareModuleManagement.getMetaDataBySoftwareModuleId(module.getId(), NOT_EXIST_ID)).isNotPresent();
+        assertThat(softwareModuleManagement.findMetaDataBySoftwareModuleId(module.getId(), NOT_EXIST_ID)).isNotPresent();
     }
 
     @Test
@@ -91,11 +91,11 @@ class SoftwareModuleManagementTest extends AbstractJpaIntegrationTest {
                 "SoftwareModuleType");
 
         verifyThrownExceptionBy(
-                () -> softwareModuleManagement.createMetaData(
+                () -> softwareModuleManagement.updateMetaData(
                         entityFactory.softwareModuleMetadata().create(NOT_EXIST_IDL).key("xxx").value("xxx")),
                 "SoftwareModule");
         verifyThrownExceptionBy(
-                () -> softwareModuleManagement.createMetaData(Collections.singletonList(
+                () -> softwareModuleManagement.putMetaData(Collections.singletonList(
                         entityFactory.softwareModuleMetadata().create(NOT_EXIST_IDL).key("xxx").value("xxx"))),
                 "SoftwareModule");
 
@@ -115,21 +115,21 @@ class SoftwareModuleManagementTest extends AbstractJpaIntegrationTest {
                         entityFactory.softwareModuleMetadata().update(module.getId(), NOT_EXIST_ID).value("xxx")),
                 "SoftwareModuleMetadata");
 
-        verifyThrownExceptionBy(() -> softwareModuleManagement.findByAssignedTo(PAGE, NOT_EXIST_IDL),
+        verifyThrownExceptionBy(() -> softwareModuleManagement.findByAssignedTo(NOT_EXIST_IDL, PAGE),
                 "DistributionSet");
 
-        verifyThrownExceptionBy(() -> softwareModuleManagement.getByNameAndVersionAndType("xxx", "xxx", NOT_EXIST_IDL),
+        verifyThrownExceptionBy(() -> softwareModuleManagement.findByNameAndVersionAndType("xxx", "xxx", NOT_EXIST_IDL),
                 "SoftwareModuleType");
 
         verifyThrownExceptionBy(
-                () -> softwareModuleManagement.getMetaDataBySoftwareModuleId(NOT_EXIST_IDL, NOT_EXIST_ID),
+                () -> softwareModuleManagement.findMetaDataBySoftwareModuleId(NOT_EXIST_IDL, NOT_EXIST_ID),
                 "SoftwareModule");
 
         verifyThrownExceptionBy(() -> softwareModuleManagement.findMetaDataBySoftwareModuleId(PAGE, NOT_EXIST_IDL),
                 "SoftwareModule");
-        verifyThrownExceptionBy(() -> softwareModuleManagement.findMetaDataByRsql(PAGE, NOT_EXIST_IDL, "name==*"),
+        verifyThrownExceptionBy(() -> softwareModuleManagement.findMetaDataByRsql(NOT_EXIST_IDL, "name==*", PAGE),
                 "SoftwareModule");
-        verifyThrownExceptionBy(() -> softwareModuleManagement.findByType(PAGE, NOT_EXIST_IDL), "SoftwareModule");
+        verifyThrownExceptionBy(() -> softwareModuleManagement.findByType(NOT_EXIST_IDL, PAGE), "SoftwareModule");
 
         verifyThrownExceptionBy(
                 () -> softwareModuleManagement.update(entityFactory.softwareModule().update(NOT_EXIST_IDL)),
@@ -195,23 +195,23 @@ class SoftwareModuleManagementTest extends AbstractJpaIntegrationTest {
         implicitLock(jvm);
 
         // standard searches
-        assertThat(softwareModuleManagement.findByTextAndType(PAGE, "poky", osType.getId()).getContent()).hasSize(1);
-        assertThat(softwareModuleManagement.findByTextAndType(PAGE, "poky", osType.getId()).getContent().get(0))
+        assertThat(softwareModuleManagement.findByTextAndType("poky", osType.getId(), PAGE).getContent()).hasSize(1);
+        assertThat(softwareModuleManagement.findByTextAndType("poky", osType.getId(), PAGE).getContent().get(0))
                 .isEqualTo(os);
-        assertThat(softwareModuleManagement.findByTextAndType(PAGE, "oracle", runtimeType.getId()).getContent())
+        assertThat(softwareModuleManagement.findByTextAndType("oracle", runtimeType.getId(), PAGE).getContent())
                 .hasSize(1);
         assertThat(
-                softwareModuleManagement.findByTextAndType(PAGE, "oracle", runtimeType.getId()).getContent().get(0))
+                softwareModuleManagement.findByTextAndType("oracle", runtimeType.getId(), PAGE).getContent().get(0))
                 .isEqualTo(jvm);
-        assertThat(softwareModuleManagement.findByTextAndType(PAGE, ":1.0.1", appType.getId()).getContent()).hasSize(1)
+        assertThat(softwareModuleManagement.findByTextAndType(":1.0.1", appType.getId(), PAGE).getContent()).hasSize(1)
                 .first().isEqualTo(ah);
-        assertThat(softwareModuleManagement.findByTextAndType(PAGE, ":1.0", appType.getId()).getContent()).hasSize(2);
+        assertThat(softwareModuleManagement.findByTextAndType(":1.0", appType.getId(), PAGE).getContent()).hasSize(2);
 
         distributionSetManagement.unlock(ds.getId()); // otherwise delete will be rejected as a part of a locked DS
         softwareModuleManagement.delete(ah2.getId());
 
-        assertThat(softwareModuleManagement.findByTextAndType(PAGE, ":1.0", appType.getId()).getContent()).hasSize(1);
-        assertThat(softwareModuleManagement.findByTextAndType(PAGE, ":1.0", appType.getId()).getContent().get(0))
+        assertThat(softwareModuleManagement.findByTextAndType(":1.0", appType.getId(), PAGE).getContent()).hasSize(1);
+        assertThat(softwareModuleManagement.findByTextAndType(":1.0", appType.getId(), PAGE).getContent().get(0))
                 .isEqualTo(ah);
     }
 
@@ -235,7 +235,7 @@ class SoftwareModuleManagementTest extends AbstractJpaIntegrationTest {
         softwareModuleManagement.delete(testdataFactory.createSoftwareModuleOs("deleted").getId());
         testdataFactory.createSoftwareModuleApp();
 
-        assertThat(softwareModuleManagement.findByType(PAGE, osType.getId()).getContent())
+        assertThat(softwareModuleManagement.findByType(osType.getId(), PAGE).getContent())
                 .as("Expected to find the following number of modules:").hasSize(2).as("with the following elements")
                 .contains(two, one);
     }
@@ -297,7 +297,7 @@ class SoftwareModuleManagementTest extends AbstractJpaIntegrationTest {
         assignedModule = softwareModuleManagement.get(assignedModule.getId()).get();
         assertTrue(assignedModule.isDeleted(), "The module should be flagged as deleted");
         assertThat(softwareModuleManagement.findAll(PAGE)).isEmpty();
-        assertThat(softwareModuleManagement.findByRsql(PAGE, "name==*")).isEmpty();
+        assertThat(softwareModuleManagement.findByRsql("name==*", PAGE)).isEmpty();
         assertThat(softwareModuleManagement.count()).isZero();
         assertThat(softwareModuleRepository.findAll()).hasSize(1);
 
@@ -484,7 +484,7 @@ class SoftwareModuleManagementTest extends AbstractJpaIntegrationTest {
                 .name("set").version("1").modules(Arrays.asList(one.getId(), deleted.getId())));
         softwareModuleManagement.delete(deleted.getId());
 
-        assertThat(softwareModuleManagement.findByAssignedTo(PAGE, set.getId()).getContent())
+        assertThat(softwareModuleManagement.findByAssignedTo(set.getId(), PAGE).getContent())
                 .as("Found this number of modules").hasSize(2);
     }
 
@@ -508,7 +508,7 @@ class SoftwareModuleManagementTest extends AbstractJpaIntegrationTest {
                 .key(knownKey2).value(knownValue2);
 
         final List<SoftwareModuleMetadata> softwareModuleMetadata = softwareModuleManagement
-                .createMetaData(Arrays.asList(swMetadata1, swMetadata2));
+                .putMetaData(Arrays.asList(swMetadata1, swMetadata2));
 
         final SoftwareModule changedLockRevisionModule = softwareModuleManagement.get(ah.getId()).get();
         assertThat(changedLockRevisionModule.getOptLockRevision()).isEqualTo(2);
@@ -528,13 +528,13 @@ class SoftwareModuleManagementTest extends AbstractJpaIntegrationTest {
         final SoftwareModule module = testdataFactory.createSoftwareModuleApp("m1");
         final int maxMetaData = quotaManagement.getMaxMetaDataEntriesPerSoftwareModule();
         for (int i = 0; i < maxMetaData; ++i) {
-            softwareModuleManagement.createMetaData(
+            softwareModuleManagement.updateMetaData(
                     entityFactory.softwareModuleMetadata().create(module.getId()).key("k" + i).value("v" + i));
         }
 
         // quota exceeded
         assertThatExceptionOfType(AssignmentQuotaExceededException.class)
-                .isThrownBy(() -> softwareModuleManagement.createMetaData(entityFactory.softwareModuleMetadata()
+                .isThrownBy(() -> softwareModuleManagement.updateMetaData(entityFactory.softwareModuleMetadata()
                         .create(module.getId()).key("k" + maxMetaData).value("v" + maxMetaData)));
 
         // add multiple meta data entries at once
@@ -545,13 +545,13 @@ class SoftwareModuleManagementTest extends AbstractJpaIntegrationTest {
         }
         // quota exceeded
         assertThatExceptionOfType(AssignmentQuotaExceededException.class)
-                .isThrownBy(() -> softwareModuleManagement.createMetaData(create));
+                .isThrownBy(() -> softwareModuleManagement.putMetaData(create));
 
         // add some meta data entries
         final SoftwareModule module3 = testdataFactory.createSoftwareModuleApp("m3");
         final int firstHalf = Math.round((maxMetaData) / 2.f);
         for (int i = 0; i < firstHalf; ++i) {
-            softwareModuleManagement.createMetaData(
+            softwareModuleManagement.updateMetaData(
                     entityFactory.softwareModuleMetadata().create(module3.getId()).key("k" + i).value("v" + i));
         }
         // add too many data entries
@@ -562,7 +562,7 @@ class SoftwareModuleManagementTest extends AbstractJpaIntegrationTest {
         }
         // quota exceeded
         assertThatExceptionOfType(AssignmentQuotaExceededException.class)
-                .isThrownBy(() -> softwareModuleManagement.createMetaData(create2));
+                .isThrownBy(() -> softwareModuleManagement.putMetaData(create2));
 
     }
 
@@ -574,21 +574,21 @@ class SoftwareModuleManagementTest extends AbstractJpaIntegrationTest {
         final String knownValue1 = "myKnownValue1";
         final SoftwareModule ah = testdataFactory.createSoftwareModuleApp();
 
-        softwareModuleManagement.createMetaData(entityFactory.softwareModuleMetadata().create(ah.getId()).key(knownKey1)
+        softwareModuleManagement.updateMetaData(entityFactory.softwareModuleMetadata().create(ah.getId()).key(knownKey1)
                 .value(knownValue1).targetVisible(true));
 
         assertThatExceptionOfType(EntityAlreadyExistsException.class)
-                .isThrownBy(() -> softwareModuleManagement.createMetaData(entityFactory.softwareModuleMetadata()
+                .isThrownBy(() -> softwareModuleManagement.updateMetaData(entityFactory.softwareModuleMetadata()
                         .create(ah.getId()).key(knownKey1).value(knownValue1).targetVisible(true)))
                 .withMessageContaining("Metadata").withMessageContaining(knownKey1);
 
         final String knownKey2 = "myKnownKey2";
 
-        softwareModuleManagement.createMetaData(entityFactory.softwareModuleMetadata().create(ah.getId()).key(knownKey2)
+        softwareModuleManagement.updateMetaData(entityFactory.softwareModuleMetadata().create(ah.getId()).key(knownKey2)
                 .value(knownValue1).targetVisible(false));
 
         assertThatExceptionOfType(EntityAlreadyExistsException.class)
-                .isThrownBy(() -> softwareModuleManagement.createMetaData(entityFactory.softwareModuleMetadata()
+                .isThrownBy(() -> softwareModuleManagement.updateMetaData(entityFactory.softwareModuleMetadata()
                         .create(ah.getId()).key(knownKey2).value(knownValue1).targetVisible(true)))
                 .withMessageContaining("Metadata").withMessageContaining(knownKey2);
     }
@@ -607,7 +607,7 @@ class SoftwareModuleManagementTest extends AbstractJpaIntegrationTest {
         assertThat(ah.getOptLockRevision()).isEqualTo(1);
 
         // create an software module meta data entry
-        final SoftwareModuleMetadata softwareModuleMetadata = softwareModuleManagement.createMetaData(
+        final SoftwareModuleMetadata softwareModuleMetadata = softwareModuleManagement.updateMetaData(
                 entityFactory.softwareModuleMetadata().create(ah.getId()).key(knownKey).value(knownValue));
         assertThat(softwareModuleMetadata.isTargetVisible()).isFalse();
         assertThat(softwareModuleMetadata.getValue()).isEqualTo(knownValue);
@@ -642,7 +642,7 @@ class SoftwareModuleManagementTest extends AbstractJpaIntegrationTest {
 
         final SoftwareModule swModule = testdataFactory.createSoftwareModuleApp();
 
-        softwareModuleManagement.createMetaData(
+        softwareModuleManagement.updateMetaData(
                 entityFactory.softwareModuleMetadata().create(swModule.getId()).key(knownKey1).value(knownValue1));
 
         assertThat(softwareModuleManagement.findMetaDataBySoftwareModuleId(PageRequest.of(0, 10), swModule.getId())
@@ -665,10 +665,10 @@ class SoftwareModuleManagementTest extends AbstractJpaIntegrationTest {
 
         final SoftwareModule ah = testdataFactory.createSoftwareModuleApp();
 
-        softwareModuleManagement.createMetaData(
+        softwareModuleManagement.updateMetaData(
                 entityFactory.softwareModuleMetadata().create(ah.getId()).key(knownKey1).value(knownValue1));
 
-        assertThat(softwareModuleManagement.getMetaDataBySoftwareModuleId(ah.getId(), "doesnotexist")).isNotPresent();
+        assertThat(softwareModuleManagement.findMetaDataBySoftwareModuleId(ah.getId(), "doesnotexist")).isNotPresent();
     }
 
     @Test
@@ -682,12 +682,12 @@ class SoftwareModuleManagementTest extends AbstractJpaIntegrationTest {
         final int metadataCountSw2 = 10;
 
         for (int index = 0; index < metadataCountSw1; index++) {
-            softwareModuleManagement.createMetaData(entityFactory.softwareModuleMetadata().create(sw1.getId())
+            softwareModuleManagement.updateMetaData(entityFactory.softwareModuleMetadata().create(sw1.getId())
                     .key("key" + index).value("value" + index).targetVisible(true));
         }
 
         for (int index = 0; index < metadataCountSw2; index++) {
-            softwareModuleManagement.createMetaData(entityFactory.softwareModuleMetadata().create(sw2.getId())
+            softwareModuleManagement.updateMetaData(entityFactory.softwareModuleMetadata().create(sw2.getId())
                     .key("key" + index).value("value" + index).targetVisible(false));
         }
 

hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/management/SoftwareModuleTypeManagementSecurityTest.java

@@ -46,13 +46,13 @@ public class SoftwareModuleTypeManagementSecurityTest
     @Test
     @Description("Tests ManagementAPI PreAuthorized method with correct and insufficient permissions.")
     void getByKeyPermissionsCheck() {
-        assertPermissions(() -> softwareModuleTypeManagement.getByKey("key"), List.of(SpPermission.READ_REPOSITORY));
+        assertPermissions(() -> softwareModuleTypeManagement.findByKey("key"), List.of(SpPermission.READ_REPOSITORY));
     }
 
     @Test
     @Description("Tests ManagementAPI PreAuthorized method with correct and insufficient permissions.")
     void getByNamePermissionsCheck() {
-        assertPermissions(() -> softwareModuleTypeManagement.getByName("name"), List.of(SpPermission.READ_REPOSITORY));
+        assertPermissions(() -> softwareModuleTypeManagement.findByName("name"), List.of(SpPermission.READ_REPOSITORY));
     }
 
 }

hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/management/SoftwareModuleTypeManagementTest.java

@@ -41,8 +41,8 @@ public class SoftwareModuleTypeManagementTest extends AbstractJpaIntegrationTest
     public void nonExistingEntityAccessReturnsNotPresent() {
 
         assertThat(softwareModuleTypeManagement.get(NOT_EXIST_IDL)).isNotPresent();
-        assertThat(softwareModuleTypeManagement.getByKey(NOT_EXIST_ID)).isNotPresent();
-        assertThat(softwareModuleTypeManagement.getByName(NOT_EXIST_ID)).isNotPresent();
+        assertThat(softwareModuleTypeManagement.findByKey(NOT_EXIST_ID)).isNotPresent();
+        assertThat(softwareModuleTypeManagement.findByName(NOT_EXIST_ID)).isNotPresent();
     }
 
     @Test
@@ -129,7 +129,7 @@ public class SoftwareModuleTypeManagementTest extends AbstractJpaIntegrationTest
         // delete assigned
         softwareModuleTypeManagement.delete(type.getId());
         assertThat(softwareModuleTypeManagement.findAll(PAGE)).hasSize(3).contains(osType, runtimeType, appType);
-        assertThat(softwareModuleTypeManagement.findByRsql(PAGE, "name==*")).hasSize(3).contains(osType, runtimeType,
+        assertThat(softwareModuleTypeManagement.findByRsql("name==*", PAGE)).hasSize(3).contains(osType, runtimeType,
                 appType);
         assertThat(softwareModuleTypeManagement.count()).isEqualTo(3);
 
@@ -147,7 +147,7 @@ public class SoftwareModuleTypeManagementTest extends AbstractJpaIntegrationTest
         softwareModuleTypeManagement
                 .create(entityFactory.softwareModuleType().create().key("thetype2").name("anothername"));
 
-        assertThat(softwareModuleTypeManagement.getByName("thename").get()).as("Type with given name").isEqualTo(found);
+        assertThat(softwareModuleTypeManagement.findByName("thename").get()).as("Type with given name").isEqualTo(found);
     }
 
     @Test

hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/rsql/RSQLDistributionSetFieldTest.java

@@ -202,7 +202,7 @@ public class RSQLDistributionSetFieldTest extends AbstractJpaIntegrationTest {
     }
 
     private void assertRSQLQuery(final String rsqlParam, final long expectedEntity) {
-        final Page<DistributionSet> find = distributionSetManagement.findByRsql(PageRequest.of(0, 100), rsqlParam);
+        final Page<DistributionSet> find = distributionSetManagement.findByRsql(rsqlParam, PageRequest.of(0, 100));
         final long countAll = find.getTotalElements();
         assertThat(find).as("Found entity is should not be null").isNotNull();
         assertThat(countAll).as("Found entity size is wrong").isEqualTo(expectedEntity);

hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/rsql/RSQLDistributionSetMetadataFieldsTest.java

@@ -44,9 +44,9 @@ public class RSQLDistributionSetMetadataFieldsTest extends AbstractJpaIntegratio
             metadata.add(entityFactory.generateDsMetadata("" + i, "" + i));
         }
 
-        distributionSetManagement.createMetaData(distributionSetId, metadata);
+        distributionSetManagement.putMetaData(distributionSetId, metadata);
 
-        distributionSetManagement.createMetaData(distributionSetId,
+        distributionSetManagement.putMetaData(distributionSetId,
                 Arrays.asList(entityFactory.generateDsMetadata("emptyValueTest", null)));
     }
 
@@ -73,7 +73,7 @@ public class RSQLDistributionSetMetadataFieldsTest extends AbstractJpaIntegratio
     private void assertRSQLQuery(final String rsqlParam, final long expectedEntities) {
 
         final Page<DistributionSetMetadata> findEnitity = distributionSetManagement
-                .findMetaDataByDistributionSetIdAndRsql(PageRequest.of(0, 100), distributionSetId, rsqlParam);
+                .findMetaDataByDistributionSetIdAndRsql(distributionSetId, rsqlParam, PageRequest.of(0, 100));
         final long countAllEntities = findEnitity.getTotalElements();
         assertThat(findEnitity).isNotNull();
         assertThat(countAllEntities).isEqualTo(expectedEntities);

hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/rsql/RSQLSoftwareModuleFieldTest.java

@@ -51,11 +51,11 @@ public class RSQLSoftwareModuleFieldTest extends AbstractJpaIntegrationTest {
 
         final SoftwareModuleMetadataCreate softwareModuleMetadata = entityFactory.softwareModuleMetadata()
                 .create(ah.getId()).key("metaKey").value("metaValue");
-        softwareModuleManagement.createMetaData(softwareModuleMetadata);
+        softwareModuleManagement.updateMetaData(softwareModuleMetadata);
 
         final SoftwareModuleMetadataCreate softwareModuleMetadata2 = entityFactory.softwareModuleMetadata()
                 .create(ah2.getId()).key("metaKey").value("value");
-        softwareModuleManagement.createMetaData(softwareModuleMetadata2);
+        softwareModuleManagement.updateMetaData(softwareModuleMetadata2);
     }
 
     @Test
@@ -150,7 +150,7 @@ public class RSQLSoftwareModuleFieldTest extends AbstractJpaIntegrationTest {
     }
 
     private void assertRSQLQuery(final String rsqlParam, final long expectedEntity) {
-        final Page<SoftwareModule> find = softwareModuleManagement.findByRsql(PageRequest.of(0, 100), rsqlParam);
+        final Page<SoftwareModule> find = softwareModuleManagement.findByRsql(rsqlParam, PageRequest.of(0, 100));
         final long countAll = find.getTotalElements();
         assertThat(find).isNotNull();
         assertThat(countAll).isEqualTo(expectedEntity);

hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/rsql/RSQLSoftwareModuleMetadataFieldsTest.java

@@ -51,7 +51,7 @@ public class RSQLSoftwareModuleMetadataFieldsTest extends AbstractJpaIntegration
         metadata.add(entityFactory.softwareModuleMetadata().create(softwareModule.getId()).key("emptyMd")
                 .targetVisible(true));
 
-        softwareModuleManagement.createMetaData(metadata);
+        softwareModuleManagement.putMetaData(metadata);
 
     }
 
@@ -87,7 +87,7 @@ public class RSQLSoftwareModuleMetadataFieldsTest extends AbstractJpaIntegration
     private void assertRSQLQuery(final String rsqlParam, final long expectedEntities) {
 
         final Page<SoftwareModuleMetadata> findEnitity = softwareModuleManagement
-                .findMetaDataByRsql(PageRequest.of(0, 100), softwareModuleId, rsqlParam);
+                .findMetaDataByRsql(softwareModuleId, rsqlParam, PageRequest.of(0, 100));
         final long countAllEntities = findEnitity.getTotalElements();
         assertThat(findEnitity).isNotNull();
         assertThat(countAllEntities).isEqualTo(expectedEntities);

hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/rsql/RSQLSoftwareModuleTypeFieldsTest.java

@@ -78,8 +78,8 @@ public class RSQLSoftwareModuleTypeFieldsTest extends AbstractJpaIntegrationTest
     }
 
     private void assertRSQLQuery(final String rsqlParam, final long excpectedEntity) {
-        final Page<SoftwareModuleType> find = softwareModuleTypeManagement.findByRsql(PageRequest.of(0, 100),
-                rsqlParam);
+        final Page<SoftwareModuleType> find = softwareModuleTypeManagement.findByRsql(rsqlParam, PageRequest.of(0, 100)
+        );
         final long countAll = find.getTotalElements();
         assertThat(find).isNotNull();
         assertThat(countAll).isEqualTo(excpectedEntity);

hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/rsql/RSQLTagFieldsTest.java

@@ -119,8 +119,8 @@ public class RSQLTagFieldsTest extends AbstractJpaIntegrationTest {
 
     private void assertRSQLQueryDistributionSet(final String rsqlParam, final long expectedEntities) {
 
-        final Page<DistributionSetTag> findEnitity = distributionSetTagManagement.findByRsql(PageRequest.of(0, 100),
-                rsqlParam);
+        final Page<DistributionSetTag> findEnitity = distributionSetTagManagement.findByRsql(rsqlParam, PageRequest.of(0, 100)
+        );
         final long countAllEntities = findEnitity.getTotalElements();
         assertThat(findEnitity).isNotNull();
         assertThat(countAllEntities).isEqualTo(expectedEntities);