下面列出了org.springframework.util.MultiValueMap#remove ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
private void updateTaskQueryWithWorkbasketKey(
TaskQuery taskQuery, MultiValueMap<String, String> params) throws InvalidArgumentException {
String[] domains = null;
if (params.get(DOMAIN) != null) {
domains = extractCommaSeparatedFields(params.get(DOMAIN));
}
if (domains == null || domains.length != 1) {
throw new InvalidArgumentException(
"workbasket-key requires excactly one domain as second parameter.");
}
String[] workbasketKeys = extractCommaSeparatedFields(params.get(WORKBASKET_KEY));
KeyDomain[] keyDomains = new KeyDomain[workbasketKeys.length];
for (int i = 0; i < workbasketKeys.length; i++) {
keyDomains[i] = new KeyDomain(workbasketKeys[i], domains[0]);
}
taskQuery.workbasketKeyDomainIn(keyDomains);
params.remove(WORKBASKET_KEY);
params.remove(DOMAIN);
}
@Test
public void testFieldDefaultPreemptsFieldMarker() throws Exception {
MultiValueMap<String, String> formData = new LinkedMultiValueMap<>();
formData.add("!postProcessed", "on");
formData.add("_postProcessed", "visible");
formData.add("postProcessed", "on");
this.binder.bind(exchange(formData)).block(Duration.ofMillis(5000));
assertTrue(this.testBean.isPostProcessed());
formData.remove("postProcessed");
this.binder.bind(exchange(formData)).block(Duration.ofMillis(5000));
assertTrue(this.testBean.isPostProcessed());
formData.remove("!postProcessed");
this.binder.bind(exchange(formData)).block(Duration.ofMillis(5000));
assertFalse(this.testBean.isPostProcessed());
}
private void bindIndexed(ConfigurationPropertySource source,
ConfigurationPropertyName root, AggregateElementBinder elementBinder,
IndexedCollectionSupplier collection, ResolvableType elementType) {
MultiValueMap<String, ConfigurationProperty> knownIndexedChildren = getKnownIndexedChildren(
source, root);
for (int i = 0; i < Integer.MAX_VALUE; i++) {
ConfigurationPropertyName name = root
.append((i != 0) ? "[" + i + "]" : INDEX_ZERO);
Object value = elementBinder.bind(name, Bindable.of(elementType), source);
if (value == null) {
break;
}
knownIndexedChildren.remove(name.getLastElement(Form.UNIFORM));
collection.get().add(value);
}
assertNoUnboundChildren(knownIndexedChildren);
}
@Test
public void testFieldPrefixCausesFieldResetWithIgnoreUnknownFields() throws Exception {
this.binder.setIgnoreUnknownFields(false);
MultiValueMap<String, String> formData = new LinkedMultiValueMap<>();
formData.add("_postProcessed", "visible");
formData.add("postProcessed", "on");
this.binder.bind(exchange(formData)).block(Duration.ofMillis(5000));
assertTrue(this.testBean.isPostProcessed());
formData.remove("postProcessed");
this.binder.bind(exchange(formData)).block(Duration.ofMillis(5000));
assertFalse(this.testBean.isPostProcessed());
}
@Test
public void testFieldDefault() throws Exception {
MultiValueMap<String, String> formData = new LinkedMultiValueMap<>();
formData.add("!postProcessed", "off");
formData.add("postProcessed", "on");
this.binder.bind(exchange(formData)).block(Duration.ofMillis(5000));
assertTrue(this.testBean.isPostProcessed());
formData.remove("postProcessed");
this.binder.bind(exchange(formData)).block(Duration.ofMillis(5000));
assertFalse(this.testBean.isPostProcessed());
}
private void updateTaskQueryWithIndefiniteTimeInterval(
TaskQuery taskQuery,
MultiValueMap<String, String> params,
String param,
TimeInterval timeInterval) {
if (param.equals(PLANNED_FROM) || param.equals(PLANNED_UNTIL)) {
taskQuery.plannedWithin(timeInterval);
} else {
taskQuery.dueWithin(timeInterval);
}
params.remove(param);
}
@Override
public GatewayFilter apply(NameConfig config) {
return new GatewayFilter() {
@Override
public Mono<Void> filter(ServerWebExchange exchange,
GatewayFilterChain chain) {
ServerHttpRequest request = exchange.getRequest();
MultiValueMap<String, String> queryParams = new LinkedMultiValueMap<>(
request.getQueryParams());
queryParams.remove(config.getName());
URI newUri = UriComponentsBuilder.fromUri(request.getURI())
.replaceQueryParams(unmodifiableMultiValueMap(queryParams))
.build().toUri();
ServerHttpRequest updatedRequest = exchange.getRequest().mutate()
.uri(newUri).build();
return chain.filter(exchange.mutate().request(updatedRequest).build());
}
@Override
public String toString() {
return filterToStringCreator(
RemoveRequestParameterGatewayFilterFactory.this)
.append("name", config.getName()).toString();
}
};
}
@Test
public void testFieldPrefixCausesFieldReset() throws Exception {
MultiValueMap<String, String> formData = new LinkedMultiValueMap<>();
formData.add("_postProcessed", "visible");
formData.add("postProcessed", "on");
this.binder.bind(exchange(formData)).block(Duration.ofMillis(5000));
assertTrue(this.testBean.isPostProcessed());
formData.remove("postProcessed");
this.binder.bind(exchange(formData)).block(Duration.ofMillis(5000));
assertFalse(this.testBean.isPostProcessed());
}
@Test
public void testFieldPrefixCausesFieldResetWithIgnoreUnknownFields() throws Exception {
this.binder.setIgnoreUnknownFields(false);
MultiValueMap<String, String> formData = new LinkedMultiValueMap<>();
formData.add("_postProcessed", "visible");
formData.add("postProcessed", "on");
this.binder.bind(exchange(formData)).block(Duration.ofMillis(5000));
assertTrue(this.testBean.isPostProcessed());
formData.remove("postProcessed");
this.binder.bind(exchange(formData)).block(Duration.ofMillis(5000));
assertFalse(this.testBean.isPostProcessed());
}
@Test
public void testFieldDefaultNonBoolean() throws Exception {
MultiValueMap<String, String> formData = new LinkedMultiValueMap<>();
formData.add("!name", "anonymous");
formData.add("name", "Scott");
this.binder.bind(exchange(formData)).block(Duration.ofMillis(5000));
assertEquals("Scott", this.testBean.getName());
formData.remove("name");
this.binder.bind(exchange(formData)).block(Duration.ofMillis(5000));
assertEquals("anonymous", this.testBean.getName());
}
@Override
protected AccessGrant postForAccessGrant(String accessTokenUrl, MultiValueMap<String, String> parameters) {
if ("authorization_code".equals(parameters.getFirst("grant_type"))) {
parameters.set("appid", parameters.getFirst("client_id"));
parameters.remove("client_id");
parameters.set("secret", parameters.getFirst("client_secret"));
parameters.remove("client_secret");
}
return super.postForAccessGrant(accessTokenUrl, parameters);
}
private void getAccessIds(WorkbasketAccessItemQuery query, MultiValueMap<String, String> params) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Entry to getAccessIds(query= {}, params= {})", query, params);
}
if (params.containsKey(ACCESS_IDS)) {
String[] accessIds = extractVerticalBarSeparatedFields(params.get(ACCESS_IDS));
query.accessIdIn(accessIds);
params.remove(ACCESS_IDS);
}
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Exit from getAccessIds(), returning {}", query);
}
}
private void applyFilterParams(
WorkbasketAccessItemQuery query, MultiValueMap<String, String> params) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Entry to applyFilterParams(query= {}, params= {})", query, params);
}
if (params.containsKey(WORKBASKET_KEY)) {
String[] keys = extractCommaSeparatedFields(params.get(WORKBASKET_KEY));
query.workbasketKeyIn(keys);
params.remove(WORKBASKET_KEY);
}
if (params.containsKey(WORKBASKET_KEY_LIKE)) {
query.workbasketKeyLike(LIKE + params.get(WORKBASKET_KEY_LIKE).get(0) + LIKE);
params.remove(WORKBASKET_KEY_LIKE);
}
if (params.containsKey(ACCESS_ID)) {
String[] accessId = extractCommaSeparatedFields(params.get(ACCESS_ID));
query.accessIdIn(accessId);
params.remove(ACCESS_ID);
}
if (params.containsKey(ACCESS_ID_LIKE)) {
query.accessIdLike(LIKE + params.get(ACCESS_ID_LIKE).get(0) + LIKE);
params.remove(ACCESS_ID_LIKE);
}
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Exit from applyFilterParams(), returning {}", query);
}
}
private WorkbasketAccessItemQuery applySortingParams(
WorkbasketAccessItemQuery query, MultiValueMap<String, String> params)
throws InvalidArgumentException {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Entry to applySortingParams(query= {}, params= {})", query, params);
}
// sorting
String sortBy = params.getFirst(SORT_BY);
if (sortBy != null) {
BaseQuery.SortDirection sortDirection;
if (params.getFirst(SORT_DIRECTION) != null
&& "desc".equals(params.getFirst(SORT_DIRECTION))) {
sortDirection = BaseQuery.SortDirection.DESCENDING;
} else {
sortDirection = BaseQuery.SortDirection.ASCENDING;
}
switch (sortBy) {
case (WORKBASKET_KEY):
query = query.orderByWorkbasketKey(sortDirection);
break;
case (ACCESS_ID):
query = query.orderByAccessId(sortDirection);
break;
default:
throw new InvalidArgumentException("Unknown order '" + sortBy + "'");
}
}
params.remove(SORT_BY);
params.remove(SORT_DIRECTION);
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Exit from applySortingParams(), returning {}", query);
}
return query;
}
private long getPageSize(MultiValueMap<String, String> params) throws InvalidArgumentException {
String param = params.getFirst(PAGING_PAGE_SIZE);
params.remove(PAGING_PAGE_SIZE);
try {
return param != null ? Long.parseLong(param) : Integer.MAX_VALUE;
} catch (NumberFormatException e) {
throw new InvalidArgumentException("page-size must be a integer value.", e.getCause());
}
}
private long getPage(MultiValueMap<String, String> params) throws InvalidArgumentException {
String param = params.getFirst(PAGING_PAGE);
params.remove(PAGING_PAGE);
try {
return Long.parseLong(param != null ? param : "1");
} catch (NumberFormatException e) {
throw new InvalidArgumentException("page must be a integer value.", e.getCause());
}
}
@GetMapping
@Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<TaskHistoryEventListResource> getTaskHistoryEvents(
@RequestParam MultiValueMap<String, String> params) throws InvalidArgumentException {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Entry to getTaskHistoryEvents(params= {})", params);
}
HistoryQuery query = simpleHistoryService.createHistoryQuery();
query = applySortingParams(query, params);
applyFilterParams(query, params);
PageMetadata pageMetadata = null;
List<HistoryEventImpl> historyEvents;
final String page = params.getFirst(PAGING_PAGE);
final String pageSize = params.getFirst(PAGING_PAGE_SIZE);
params.remove(PAGING_PAGE);
params.remove(PAGING_PAGE_SIZE);
validateNoInvalidParameterIsLeft(params);
if (page != null && pageSize != null) {
long totalElements = query.count();
pageMetadata = initPageMetadata(pageSize, page, totalElements);
historyEvents = query.listPage((int) pageMetadata.getNumber(), (int) pageMetadata.getSize());
} else if (page == null && pageSize == null) {
historyEvents = query.list();
} else {
throw new InvalidArgumentException("Paging information is incomplete.");
}
TaskHistoryEventListResourceAssembler assembler = new TaskHistoryEventListResourceAssembler();
TaskHistoryEventListResource pagedResources =
assembler.toResources(historyEvents, pageMetadata);
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(
"Exit from getTaskHistoryEvents(), returning {}",
new ResponseEntity<>(pagedResources, HttpStatus.OK));
}
return new ResponseEntity<>(pagedResources, HttpStatus.OK);
}
private HistoryQuery applySortingParams(HistoryQuery query, MultiValueMap<String, String> params)
throws InvalidArgumentException {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Entry to applySortingParams(params= {})", params);
}
String sortBy = params.getFirst(SORT_BY);
if (sortBy != null) {
BaseQuery.SortDirection sortDirection;
if (params.getFirst(SORT_DIRECTION) != null
&& "desc".equals(params.getFirst(SORT_DIRECTION))) {
sortDirection = BaseQuery.SortDirection.DESCENDING;
} else {
sortDirection = BaseQuery.SortDirection.ASCENDING;
}
switch (sortBy) {
case (BUSINESS_PROCESS_ID):
query = query.orderByBusinessProcessId(sortDirection);
break;
case (PARENT_BUSINESS_PROCESS_ID):
query = query.orderByParentBusinessProcessId(sortDirection);
break;
case (TASK_ID):
query = query.orderByTaskId(sortDirection);
break;
case (EVENT_TYPE):
query = query.orderByEventType(sortDirection);
break;
case (CREATED):
query = query.orderByCreated(sortDirection);
break;
case (USER_ID):
query = query.orderByUserId(sortDirection);
break;
case (DOMAIN):
query = query.orderByDomain(sortDirection);
break;
case (WORKBASKET_KEY):
query = query.orderByWorkbasketKey(sortDirection);
break;
case (POR_COMPANY):
query = query.orderByPorCompany(sortDirection);
break;
case (POR_SYSTEM):
query = query.orderByPorSystem(sortDirection);
break;
case (POR_INSTANCE):
query = query.orderByPorInstance(sortDirection);
break;
case (POR_TYPE):
query = query.orderByPorType(sortDirection);
break;
case (POR_VALUE):
query = query.orderByPorValue(sortDirection);
break;
case (TASK_CLASSIFICATION_KEY):
query = query.orderByTaskClassificationKey(sortDirection);
break;
case (TASK_CLASSIFICATION_CATEGORY):
query = query.orderByTaskClassificationCategory(sortDirection);
break;
case (ATTACHMENT_CLASSIFICATION_KEY):
query = query.orderByAttachmentClassificationKey(sortDirection);
break;
case (CUSTOM_1):
query = query.orderByCustomAttribute(1, sortDirection);
break;
case (CUSTOM_2):
query = query.orderByCustomAttribute(2, sortDirection);
break;
case (CUSTOM_3):
query = query.orderByCustomAttribute(3, sortDirection);
break;
case (CUSTOM_4):
query = query.orderByCustomAttribute(4, sortDirection);
break;
default:
throw new IllegalArgumentException("Unknown order '" + sortBy + "'");
}
}
params.remove(SORT_BY);
params.remove(SORT_DIRECTION);
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Exit from applySortingParams(), returning {}", query);
}
return query;
}
private WorkbasketQuery applySortingParams(
WorkbasketQuery query, MultiValueMap<String, String> params) throws InvalidArgumentException {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Entry to applySortingParams(query= {}, params={})", query, params);
}
// sorting
String sortBy = params.getFirst(SORT_BY);
if (sortBy != null) {
SortDirection sortDirection;
if (params.getFirst(SORT_DIRECTION) != null
&& "desc".equals(params.getFirst(SORT_DIRECTION))) {
sortDirection = SortDirection.DESCENDING;
} else {
sortDirection = SortDirection.ASCENDING;
}
switch (sortBy) {
case (NAME):
query = query.orderByName(sortDirection);
break;
case (KEY):
query = query.orderByKey(sortDirection);
break;
case (OWNER):
query = query.orderByOwner(sortDirection);
break;
case (TYPE):
query = query.orderByType(sortDirection);
break;
case (DESCRIPTION):
query = query.orderByDescription(sortDirection);
break;
default:
throw new InvalidArgumentException("Unknown order '" + sortBy + "'");
}
}
params.remove(SORT_BY);
params.remove(SORT_DIRECTION);
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Exit from applySortingParams(), returning {}", query);
}
return query;
}
private void updateTaskQueryWithPlannedOrDueTimeIntervals(
TaskQuery taskQuery, MultiValueMap<String, String> params, String plannedOrDue) {
String[] instants = extractCommaSeparatedFields(params.get(plannedOrDue));
TimeInterval[] timeIntervals = extractTimeIntervals(instants);
taskQuery.plannedWithin(timeIntervals);
params.remove(plannedOrDue);
}