Java Slice类代码示例

import org.springframework.data.domain.Slice; //导入依赖的package包/类
private void deleteScheduledActions(final JpaRollout rollout, final Slice<JpaAction> scheduledActions) {
    final boolean hasScheduledActions = scheduledActions.getNumberOfElements() > 0;

    if (hasScheduledActions) {
        try {
            final Iterable<JpaAction> iterable = scheduledActions::iterator;
            final List<Long> actionIds = StreamSupport.stream(iterable.spliterator(), false).map(Action::getId)
                    .collect(Collectors.toList());
            actionRepository.deleteByIdIn(actionIds);
            afterCommit.afterCommit(() -> eventPublisher.publishEvent(
                    new RolloutUpdatedEvent(rollout, EventPublisherHolder.getInstance().getApplicationId())));
        } catch (final RuntimeException e) {
            LOGGER.error("Exception during deletion of actions of rollout {}", rollout, e);
        }
    }
}
 

import org.springframework.data.domain.Slice; //导入依赖的package包/类
@Test
public void useSliceToLoadContent() {

	repository.deleteAll();

	// int repository with some values that can be ordered
	int totalNumberUsers = 11;
	List<User> source = new ArrayList<User>(totalNumberUsers);

	for (int i = 1; i <= totalNumberUsers; i++) {

		User user = new User();
		user.setLastname(this.user.getLastname());
		user.setUsername(user.getLastname() + "-" + String.format("%03d", i));
		source.add(user);
	}

	repository.save(source);

	Slice<User> users = repository.findByLastnameOrderByUsernameAsc(this.user.getLastname(), new PageRequest(1, 5));

	assertThat(users, contains(source.subList(5, 10).toArray()));
}
 

import org.springframework.data.domain.Slice; //导入依赖的package包/类
@RequestMapping(value = "/", method = GET)
public String home(Model model) {
    String springVersion = webUI.parameterizedMessage("home.spring.version", SpringBootVersion.getVersion());
    model.addAttribute("springVersion", springVersion);

    GitHubStats gitHubStats = webUI.getCurrentGitHubStats();
    if (gitHubStats != null) {
        model.addAttribute("showGitHubStats", true);
        model.addAttribute("gitHubStats", gitHubStats);
    }

    if (webUI.isNixMash()) {
        SiteImage siteImage = siteService.getHomeBanner();
        model.addAttribute("siteImage", siteImage);
    }

    Slice<Post> posts = postService.getPublishedPosts(0, 10);
    if (posts.getContent().size() > 0)
        model.addAttribute("posts", posts);

    return HOME_VIEW;
}
 

import org.springframework.data.domain.Slice; //导入依赖的package包/类
@RequestMapping(value = "/quicksearch/page/{pageNumber}",
        produces = "text/html;charset=UTF-8")
public String getQuickSearchPosts(@PathVariable int pageNumber,
                                  HttpServletRequest request,
                                  CurrentUser currentUser) {
    String search = (String) WebUtils.getSessionAttribute(request, SESSION_QUICKSEARCH_QUERY);
    String result;
    List<PostDoc> postDocs = postDocService.doQuickSearch(search);
    if (postDocs.size() == 0) {
        result = fmService.getNoResultsMessage(search);
    } else {
        Slice<PostDoc> posts = postDocService.doPagedQuickSearch(search, pageNumber, POST_PAGING_SIZE);
        result = populatePostDocStream(posts.getContent(), currentUser);
        WebUtils.setSessionAttribute(request, SESSION_ATTRIBUTE_QUICKSEARCH_POSTS, posts.getContent());
    }
    return result;
}
 

import org.springframework.data.domain.Slice; //导入依赖的package包/类
@Transactional(readOnly = true)
public Slice<ListAnnouncementDTO> list(final ListAnnouncementRequest request, final Pageable pageRequest) {
    final ListAnnouncementFilter filter = new ListAnnouncementFilter(occupationRepository);

    if (!activeUserService.isModeratorOrAdmin()) {
        filter.withSubscriberPerson(activeUserService.requireActivePerson());
    }

    final Optional<Organisation> maybeOrganisation = resolveOrganisation(request);

    switch (request.getDirection()) {
        case SENT:
            maybeOrganisation.ifPresent(filter::withFromOrganisation);
            break;
        case RECEIVED:
            maybeOrganisation.ifPresent(filter::withSubscriberOrganisation);
            break;
        default:
            throw new IllegalArgumentException("Invalid direction");
    }

    return filter.buildPredicate()
            .map(predicate -> announcementRepository.findAllAsSlice(predicate, pageRequest))
            .map(slice -> transform(pageRequest, slice))
            .orElseGet(() -> new SliceImpl<>(emptyList()));
}
 

import org.springframework.data.domain.Slice; //导入依赖的package包/类
@Override
public Slice<SoftwareModule> findAll(final Pageable pageable) {

    final List<Specification<JpaSoftwareModule>> specList = new ArrayList<>(2);

    Specification<JpaSoftwareModule> spec = SoftwareModuleSpecification.isDeletedFalse();
    specList.add(spec);

    spec = (root, query, cb) -> {
        if (!query.getResultType().isAssignableFrom(Long.class)) {
            root.fetch(JpaSoftwareModule_.type);
        }
        return cb.conjunction();
    };

    specList.add(spec);

    return convertSmPage(findByCriteriaAPI(pageable, specList), pageable);
}
 

import org.springframework.data.domain.Slice; //导入依赖的package包/类
@Test
@Description("Test verifies that action-states of an action are found by using id-based search.")
public void findActionStatusByActionId() {
    final DistributionSet testDs = testdataFactory.createDistributionSet("TestDs", "1.0",
            new ArrayList<DistributionSetTag>());
    final List<Target> testTarget = testdataFactory.createTargets(1);
    // one action with one action status is generated
    final Long actionId = assignDistributionSet(testDs, testTarget).getActions().get(0);
    final Slice<Action> actions = deploymentManagement.findActionsByTarget(testTarget.get(0).getControllerId(),
            PAGE);
    final ActionStatus expectedActionStatus = ((JpaAction) actions.getContent().get(0)).getActionStatus().get(0);

    // act
    final Page<ActionStatus> actionStates = deploymentManagement.findActionStatusByAction(PAGE, actionId);

    assertThat(actionStates.getContent()).hasSize(1);
    assertThat(actionStates.getContent().get(0)).as("Action-status of action").isEqualTo(expectedActionStatus);
}
 

import org.springframework.data.domain.Slice; //导入依赖的package包/类
/**
 * @param set
 *            the expected distribution set
 * @param targets
 *            the targets that should have it
 */
@Step
private void verifyThatTargetsHaveDistributionSetAssignment(final DistributionSet set, final List<Target> targets,
        final int count) {
    final List<Long> targetIds = targets.stream().map(Target::getId).collect(Collectors.toList());

    final Slice<Target> targetsAll = targetManagement.findAll(PAGE);
    assertThat(targetsAll).as("Count of targets").hasSize(count);

    for (final Target target : targetsAll) {
        if (targetIds.contains(target.getId())) {
            assertThat(deploymentManagement.getAssignedDistributionSet(target.getControllerId()).get())
                    .as("assigned DS").isEqualTo(set);
        }
    }

}
 

import org.springframework.data.domain.Slice; //导入依赖的package包/类
@Test
@Description(value = "Ensures that multiple targets with same controller-ID can be created for different tenants.")
public void createMultipleTargetsWithSameIdForDifferentTenant() throws Exception {
    // known controller ID for overall tenants same
    final String knownControllerId = "controllerId";

    // known tenant names
    final String tenant = "aTenant";
    final String anotherTenant = "anotherTenant";
    // create targets
    createTargetForTenant(knownControllerId, tenant);
    createTargetForTenant(knownControllerId, anotherTenant);

    // ensure both tenants see their target
    final Slice<Target> findTargetsForTenant = findTargetsForTenant(tenant);
    assertThat(findTargetsForTenant).hasSize(1);
    assertThat(findTargetsForTenant.getContent().get(0).getTenant().toUpperCase()).isEqualTo(tenant.toUpperCase());
    final Slice<Target> findTargetsForAnotherTenant = findTargetsForTenant(anotherTenant);
    assertThat(findTargetsForAnotherTenant).hasSize(1);
    assertThat(findTargetsForAnotherTenant.getContent().get(0).getTenant().toUpperCase())
            .isEqualTo(anotherTenant.toUpperCase());

}
 

import org.springframework.data.domain.Slice; //导入依赖的package包/类
@Test
@Description(value = "Ensures that targtes created by a tenant are not visible by another tenant.")
@WithUser(tenantId = "mytenant", allSpPermissions = true)
public void queryTargetFromDifferentTenantIsNotVisible() throws Exception {
    // create target for another tenant
    final String anotherTenant = "anotherTenant";
    final String controllerAnotherTenant = "anotherController";
    createTargetForTenant(controllerAnotherTenant, anotherTenant);

    // find all targets for current tenant "mytenant"
    final Slice<Target> findTargetsAll = targetManagement.findAll(PAGE);
    // no target has been created for "mytenant"
    assertThat(findTargetsAll).hasSize(0);

    // find all targets for anotherTenant
    final Slice<Target> findTargetsForTenant = findTargetsForTenant(anotherTenant);
    // another tenant should have targets
    assertThat(findTargetsForTenant).hasSize(1);
}
 

import org.springframework.data.domain.Slice; //导入依赖的package包/类
@Test
@Description(value = "Ensures that targets created from a different tenant cannot be deleted from other tenants")
@WithUser(tenantId = "mytenant", allSpPermissions = true)
public void deleteTargetFromOtherTenantIsNotPossible() throws Exception {
    // create target for another tenant
    final String anotherTenant = "anotherTenant";
    final String controllerAnotherTenant = "anotherController";
    final Target createTargetForTenant = createTargetForTenant(controllerAnotherTenant, anotherTenant);

    // ensure target cannot be deleted by 'mytenant'
    try {
        targetManagement.delete(Arrays.asList(createTargetForTenant.getId()));
        fail("mytenant should not have been able to delete target of anotherTenant");
    } catch (final EntityNotFoundException ex) {
        // ok
    }

    Slice<Target> targetsForAnotherTenant = findTargetsForTenant(anotherTenant);
    assertThat(targetsForAnotherTenant).hasSize(1);

    // ensure another tenant can delete the target
    deleteTargetsForTenant(anotherTenant, Arrays.asList(createTargetForTenant.getId()));
    targetsForAnotherTenant = findTargetsForTenant(anotherTenant);
    assertThat(targetsForAnotherTenant).hasSize(0);
}
 

import org.springframework.data.domain.Slice; //导入依赖的package包/类
@Override
protected List<ProxyTag> loadBeans(final int startIndex, final int count) {
    final Slice<DistributionSetTag> dsTagBeans = getTagManagement()
            .findAll(new OffsetBasedPageRequest(startIndex, count, sort));

    return dsTagBeans.getContent().stream().map(tag -> {
        final ProxyTag proxyTargetTag = new ProxyTag();
        proxyTargetTag.setColour(tag.getColour());
        proxyTargetTag.setDescription(tag.getDescription());
        proxyTargetTag.setName(tag.getName());
        proxyTargetTag.setId(tag.getId());
        final TagIdName tagIdName = new TagIdName(tag.getName(), tag.getId());
        proxyTargetTag.setTagIdName(tagIdName);

        return proxyTargetTag;

    }).collect(Collectors.toList());
}
 

import org.springframework.data.domain.Slice; //导入依赖的package包/类
/**
 * Creates a list of {@link ProxyAction}s for presentation layer from slice
 * of {@link Action}s.
 *
 * @param actionBeans
 *            slice of {@link Action}s
 * @return list of {@link ProxyAction}s
 */
private static List<ProxyAction> createProxyActions(final Slice<Action> actionBeans) {
    final List<ProxyAction> proxyActions = new ArrayList<>();
    for (final Action action : actionBeans) {
        final ProxyAction proxyAction = new ProxyAction();
        final String dsNameVersion = action.getDistributionSet().getName() + ":"
                + action.getDistributionSet().getVersion();
        proxyAction.setActive(action.isActive());
        proxyAction.setIsActiveDecoration(buildIsActiveDecoration(action));
        proxyAction.setDsNameVersion(dsNameVersion);
        proxyAction.setAction(action);
        proxyAction.setId(action.getId());
        proxyAction.setLastModifiedAt(action.getLastModifiedAt());
        proxyAction.setRolloutName(action.getRollout() != null ? action.getRollout().getName() : "");
        proxyAction.setStatus(action.getStatus());

        proxyActions.add(proxyAction);
    }
    return proxyActions;
}
 

import org.springframework.data.domain.Slice; //导入依赖的package包/类
@Override
public ResponseEntity<PagedList<MgmtDistributionSetType>> getDistributionSetTypes(
        @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
        @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
        @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
        @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {

    final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
    final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
    final Sort sorting = PagingUtility.sanitizeDistributionSetTypeSortParam(sortParam);
    final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);

    final Slice<DistributionSetType> findModuleTypessAll;
    long countModulesAll;
    if (rsqlParam != null) {
        findModuleTypessAll = distributionSetTypeManagement.findByRsql(pageable, rsqlParam);
        countModulesAll = ((Page<DistributionSetType>) findModuleTypessAll).getTotalElements();
    } else {
        findModuleTypessAll = distributionSetTypeManagement.findAll(pageable);
        countModulesAll = distributionSetTypeManagement.count();
    }

    final List<MgmtDistributionSetType> rest = MgmtDistributionSetTypeMapper
            .toListResponse(findModuleTypessAll.getContent());
    return ResponseEntity.ok(new PagedList<>(rest, countModulesAll));
}
 

import org.springframework.data.domain.Slice; //导入依赖的package包/类
@Override
public ResponseEntity<PagedList<MgmtSoftwareModule>> getSoftwareModules(
        @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
        @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
        @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
        @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {

    final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
    final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
    final Sort sorting = PagingUtility.sanitizeSoftwareModuleSortParam(sortParam);

    final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);

    final Slice<SoftwareModule> findModulesAll;
    long countModulesAll;
    if (rsqlParam != null) {
        findModulesAll = softwareModuleManagement.findByRsql(pageable, rsqlParam);
        countModulesAll = ((Page<SoftwareModule>) findModulesAll).getTotalElements();
    } else {
        findModulesAll = softwareModuleManagement.findAll(pageable);
        countModulesAll = softwareModuleManagement.count();
    }

    final List<MgmtSoftwareModule> rest = MgmtSoftwareModuleMapper.toResponse(findModulesAll.getContent());
    return ResponseEntity.ok(new PagedList<>(rest, countModulesAll));
}