Java 类org.springframework.web.bind.annotation.PatchMapping 实例源码

@Override
public void process(Object annotation, OperationGenerator operationGenerator) {
  PatchMapping mappingAnnotation = (PatchMapping) annotation;
  Operation operation = operationGenerator.getOperation();

  // path/value是等同的
  this.processPath(mappingAnnotation.path(), operationGenerator);
  this.processPath(mappingAnnotation.value(), operationGenerator);
  this.processMethod(RequestMethod.PATCH, operationGenerator);
  this.processConsumes(mappingAnnotation.consumes(), operation);
  this.processProduces(mappingAnnotation.produces(), operation);

  if (StringUtils.isEmpty(operationGenerator.getHttpMethod())
      && StringUtils.isEmpty(operationGenerator.getSwaggerGenerator().getHttpMethod())) {
    throw new Error("HttpMethod must not both be empty in class and method");
  }
}

@ApiOperation(value = "Start an existing workspace. Stop all other workspaces (only one workspace can be running at a time)")
@PatchMapping("/workspace/{name}")
public Workspace startExisting(@PathVariable String name, @RequestParam String masterUrl,
        @RequestParam String namespace,
        @ApiParam(value = "Keycloak token", required = true) @RequestHeader("Authorization") String keycloakToken)
        throws IOException, URISyntaxException, RouteNotFoundException, StackNotFoundException,
        GitHubOAthTokenException, ProjectCreationException, KeycloakException, WorkspaceNotFound {

    KeycloakTokenValidator.validate(keycloakToken);

    String openShiftToken = keycloakClient.getOpenShiftToken(keycloakToken);
    String gitHubToken = keycloakClient.getGitHubToken(keycloakToken);
    String cheServerURL = openShiftClientWrapper.getCheServerUrl(masterUrl, namespace, openShiftToken, keycloakToken);

    Workspace workspace = workspaceClient.startWorkspace(cheServerURL, name, masterUrl, namespace, openShiftToken, keycloakToken);
    setGitHubOAthTokenAndCommitterInfo(cheServerURL, gitHubToken, keycloakToken);
    return workspace;
}

/**
 * @api {patch} /credentials/:name Update
 * @apiParam {String} name Credential name to update
 *
 * @apiParamExample {multipart} RSA-Multipart-Body:
 *  the same as create
 *
 * @apiGroup Credenital
 */
@PatchMapping(path = "/{name}", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
@WebSecurity(action = Actions.ADMIN_UPDATE)
public Credential update(@PathVariable String name,
                         @RequestParam(name = "detail") String detailJson,
                         @RequestPart(name = "android-file", required = false) MultipartFile androidFile,
                         @RequestPart(name = "p12-files", required = false) MultipartFile[] p12Files,
                         @RequestPart(name = "pp-files", required = false) MultipartFile[] ppFiles) {

    // check name is existed
    if (!credentialService.existed(name)) {
        throw new IllegalParameterException("Credential name does not existed");
    }

    CredentialDetail detail = jsonConverter.getGsonForReader().fromJson(detailJson, CredentialDetail.class);
    return createOrUpdate(name, detail, androidFile, p12Files, ppFiles);
}

@PatchMapping
public List<JSONDocument> processChanges(
        @PathVariable(PARAM_WindowId) final String windowIdStr //
        , @PathVariable(PARAM_ViewId) final String viewIdStr //
        , @PathVariable(PARAM_RowId) final String rowIdStr //
        , @RequestBody final List<JSONDocumentChangedEvent> events //
)
{
    userSession.assertLoggedIn();

    final ViewId viewId = ViewId.of(windowIdStr, viewIdStr);
    final DocumentId rowId = DocumentId.of(rowIdStr);
    return Execution.callInNewExecution("processChanges", () -> {
        viewsRepo.getView(viewId)
                .getById(rowId)
                .getAttributes()
                .processChanges(events);
        return JSONDocument.ofEvents(Execution.getCurrentDocumentChangesCollectorOrNull(), newJSONOptions());
    });
}

@PatchMapping
public JSONViewRow patchRow(
        @PathVariable(PARAM_WindowId) final String windowIdStr,
        @PathVariable(PARAM_ViewId) final String viewIdStr,
        @PathVariable(PARAM_RowId) final String rowIdStr,
        @RequestBody final List<JSONDocumentChangedEvent> fieldChangeRequests)
{
    userSession.assertLoggedIn();

    final ViewId viewId = ViewId.of(windowIdStr, viewIdStr);
    final DocumentId rowId = DocumentId.of(rowIdStr);

    final IEditableView view = getEditableView(viewId);
    final RowEditingContext editingCtx = createRowEditingContext(rowId);
    view.patchViewRow(editingCtx, fieldChangeRequests);

    final IViewRow row = view.getById(rowId);
    final IViewRowOverrides rowOverrides = ViewRowOverridesHelper.getViewRowOverrides(view);
    return JSONViewRow.ofRow(row, rowOverrides, userSession.getAD_Language());
}

/**
 * 
 * @param windowIdStr
 * @param documentIdStr the string to identify the document to be returned. May also be {@link DocumentId#NEW_ID_STRING}, if a new record shall be created.
 * @param advanced
 * @param events
 * @return
 */
@PatchMapping("/{windowId}/{documentId}")
public List<JSONDocument> patchRootDocument(
        @PathVariable("windowId") final String windowIdStr //
        , @PathVariable("documentId") final String documentIdStr //
        , @RequestParam(name = PARAM_Advanced, required = false, defaultValue = PARAM_Advanced_DefaultValue) final boolean advanced //
        , @RequestBody final List<JSONDocumentChangedEvent> events)
{
    final DocumentPath documentPath = DocumentPath.builder()
            .setDocumentType(WindowId.fromJson(windowIdStr))
            .setDocumentId(documentIdStr)
            .allowNewDocumentId()
            .build();

    return patchDocument(documentPath, advanced, events);
}

@PatchMapping("/{windowId}/{documentId}/{tabId}/{rowId}")
public List<JSONDocument> patchIncludedDocument(
        @PathVariable("windowId") final String windowIdStr //
        , @PathVariable("documentId") final String documentIdStr //
        , @PathVariable("tabId") final String detailIdStr //
        , @PathVariable("rowId") final String rowIdStr //
        , @RequestParam(name = PARAM_Advanced, required = false, defaultValue = PARAM_Advanced_DefaultValue) final boolean advanced //
        , @RequestBody final List<JSONDocumentChangedEvent> events)
{
    final DocumentPath documentPath = DocumentPath.builder()
            .setDocumentType(WindowId.fromJson(windowIdStr))
            .setDocumentId(documentIdStr)
            .setDetailId(detailIdStr)
            .setRowId(rowIdStr)
            .allowNewRowId()
            .build();

    return patchDocument(documentPath, advanced, events);
}

@PatchMapping("/{asiDocId}")
public List<JSONDocument> processChanges(
        @PathVariable("asiDocId") final String asiDocIdStr //
        , @RequestBody final List<JSONDocumentChangedEvent> events //
)
{
    userSession.assertLoggedIn();

    final DocumentId asiDocId = DocumentId.of(asiDocIdStr);

    return Execution.callInNewExecution("processChanges", () -> {
        final IDocumentChangesCollector changesCollector = Execution.getCurrentDocumentChangesCollectorOrNull();
        asiRepo.processASIDocumentChanges(asiDocId, events, changesCollector);
        return JSONDocument.ofEvents(changesCollector, newJsonOpts());
    });
}

@PatchMapping("/node/{nodeId}")
public List<JSONMenuNode> patchNode(@PathVariable(PARAM_NodeId) final String nodeId, @RequestBody List<JSONDocumentChangedEvent> events)
{
    userSession.assertLoggedIn();

    final JSONPatchMenuNodeRequest request = JSONPatchMenuNodeRequest.ofChangeEvents(events);

    final MenuTree menuTree = getMenuTree();
    final MenuNode node = menuTree.getNodeById(nodeId);

    final LinkedHashMap<String, MenuNode> changedMenuNodesById = new LinkedHashMap<>();

    if (request.getFavorite() != null)
    {
        menuTreeRepository.setFavorite(node, request.getFavorite());
        menuTree.streamNodesByAD_Menu_ID(node.getAD_Menu_ID())
                .forEach(changedNode -> changedMenuNodesById.put(changedNode.getId(), changedNode));
    }

    return JSONMenuNode.ofList(changedMenuNodesById.values(), menuTreeRepository);
}

@PatchMapping(value = {
        "/{cfInstanceId}/v2/service_instances/{instanceId}",
        "/v2/service_instances/{instanceId}"
})
public ResponseEntity<?> updateServiceInstance(@PathVariable Map<String, String> pathVariables,
                                               @PathVariable("instanceId") String serviceInstanceId,
                                               @RequestParam(value = ASYNC_REQUEST_PARAMETER, required = false) boolean acceptsIncomplete,
                                               @RequestHeader(value = API_INFO_LOCATION_HEADER, required = false) String apiInfoLocation,
                                               @RequestHeader(value = ORIGINATING_IDENTITY_HEADER, required = false) String originatingIdentityString,
                                               @Valid @RequestBody UpdateServiceInstanceRequest request) {
    ServiceDefinition serviceDefinition = getServiceDefinition(request.getServiceDefinitionId());

    request.setServiceInstanceId(serviceInstanceId);
    request.setServiceDefinition(serviceDefinition);
    setCommonRequestFields(request, pathVariables.get("cfInstanceId"), apiInfoLocation,
            originatingIdentityString, acceptsIncomplete);

    log.debug("Updating a service instance: request={}", request);

    UpdateServiceInstanceResponse response = service.updateServiceInstance(request);

    log.debug("Updating a service instance succeeded: serviceInstanceId={}, response={}",
            serviceInstanceId, response);

    return new ResponseEntity<>(response, response.isAsync() ? HttpStatus.ACCEPTED : HttpStatus.OK);
}

Annotation findMappingAnnotation(AnnotatedElement element) {
  Annotation mappingAnnotation = element.getAnnotation(RequestMapping.class);

  if (mappingAnnotation == null) {
    mappingAnnotation = element.getAnnotation(GetMapping.class);

    if (mappingAnnotation == null) {
      mappingAnnotation = element.getAnnotation(PostMapping.class);

      if (mappingAnnotation == null) {
        mappingAnnotation = element.getAnnotation(PutMapping.class);

        if (mappingAnnotation == null) {
          mappingAnnotation = element.getAnnotation(DeleteMapping.class);

          if (mappingAnnotation == null) {
            mappingAnnotation = element.getAnnotation(PatchMapping.class);
          }
        }
      }
    }
  }

  if (mappingAnnotation == null) {
    if (element instanceof Method) {
      Method method = (Method) element;
      mappingAnnotation = AnnotationUtils.findAnnotation(method, RequestMapping.class);
    } else {
      Class<?> clazz = (Class<?>) element;
      mappingAnnotation = AnnotationUtils.findAnnotation(clazz, RequestMapping.class);
    }
  }

  return mappingAnnotation;
}

@Override
public boolean canProcess(Method method) {
  return method.getAnnotation(RequestMapping.class) != null ||
      method.getAnnotation(GetMapping.class) != null ||
      method.getAnnotation(PutMapping.class) != null ||
      method.getAnnotation(PostMapping.class) != null ||
      method.getAnnotation(PatchMapping.class) != null ||
      method.getAnnotation(DeleteMapping.class) != null;
}

@Override
protected void initMethodAnnotationMgr() {
  super.initMethodAnnotationMgr();

  methodAnnotationMgr.register(RequestMapping.class, new RequestMappingMethodAnnotationProcessor());
  methodAnnotationMgr.register(GetMapping.class, new GetMappingMethodAnnotationProcessor());
  methodAnnotationMgr.register(PutMapping.class, new PutMappingMethodAnnotationProcessor());
  methodAnnotationMgr.register(PostMapping.class, new PostMappingMethodAnnotationProcessor());
  methodAnnotationMgr.register(PatchMapping.class, new PatchMappingMethodAnnotationProcessor());
  methodAnnotationMgr.register(DeleteMapping.class, new DeleteMappingMethodAnnotationProcessor());
}

@PatchMapping(
    path = "usingPatchMapping/{targetName}",
    consumes = {"text/plain", "application/*"},
    produces = {"text/plain", "application/*"})
public String usingPatchMapping(@RequestBody User srcUser, @RequestHeader String header,
    @PathVariable String targetName, @RequestParam(name = "word") String word, @RequestAttribute String form) {
  return String.format("%s %s %s %s %s", srcUser.name, header, targetName, word, form);
}

@ApiOperation(value = "Start Che Server")
@PatchMapping("/server")
public CheServerInfo startCheServer(@RequestParam String masterUrl, @RequestParam String namespace,
        @ApiParam(value = "Keycloak token", required = true) @RequestHeader("Authorization") String keycloakToken, HttpServletResponse response, HttpServletRequest request) throws Exception {

    KeycloakTokenValidator.validate(keycloakToken);
    String openShiftToken = keycloakClient.getOpenShiftToken(keycloakToken);
    CheServerInfo info = startServer(masterUrl, openShiftToken, keycloakToken, namespace, response, request);
    return info;
}

@ApiOperation(value = "Start Che Server")
@PatchMapping("/server/oso")
public CheServerInfo startCheServerOnOpenShift(@RequestParam String masterUrl, @RequestParam String namespace,
        @ApiParam(value = "OpenShift token", required = true) @RequestHeader("Authorization") String openShiftToken, HttpServletResponse response, HttpServletRequest request) throws Exception {

    CheServerInfo info = startServer(masterUrl, openShiftToken, null, namespace, response, request);
    return info;
}

@ApiOperation(value = "Start an existing workspace. Stop all other workspaces (only one workspace can be running at a time)")
@PatchMapping("/workspace/oso/{name}")
public Workspace startExistingOnOpenShift(@PathVariable String name, @RequestParam String masterUrl,
        @RequestParam String namespace,
        @ApiParam(value = "OpenShift token", required = true) @RequestHeader("Authorization") String openShiftToken)
        throws IOException, URISyntaxException, RouteNotFoundException, StackNotFoundException,
        GitHubOAthTokenException, ProjectCreationException, WorkspaceNotFound {

    String cheServerURL = openShiftClientWrapper.getCheServerUrl(masterUrl, namespace, openShiftToken, null);
    return workspaceClient.startWorkspace(cheServerURL, name, masterUrl, namespace, openShiftToken, null);
}

@PatchMapping(path = "/{name}", consumes = MediaType.APPLICATION_JSON_VALUE)
@WebSecurity(action = Actions.ADMIN_UPDATE)
public Credential update(@PathVariable String name,
                         @RequestBody CredentialDetail detail) {
    // check name is existed
    if (!credentialService.existed(name)) {
        throw new IllegalParameterException("Credential name does not existed");
    }

    Credential credential = credentialService.createOrUpdate(name, detail);
    return credential;
}

@Authorize(action = {Permission.ACTION_UPDATE, Permission.ACTION_ADD}, logical = Logical.AND)
@PatchMapping
@ApiOperation("新增或者修改")
default ResponseMessage<PK> saveOrUpdate(@RequestBody M data) {
    E entity = getService().createEntity();
    return ResponseMessage.ok(getService().saveOrUpdate(modelToEntity(data, entity)));
}

@PatchMapping("/{boardId}/card/{cardId}")
public JSONBoardCard patchCard(@PathVariable("boardId") final int boardId, @PathVariable("cardId") final int cardId, @RequestBody final List<JSONDocumentChangedEvent> changes)
{
    userSession.assertLoggedIn();

    final BoardCard card = boardsRepo.changeCard(boardId, cardId, createBoardCardChangeRequest(changes));
    return JSONBoardCard.of(card, userSession.getAD_Language());
}

@PatchMapping("/{letterId}")
@ApiOperation("Changes the letter")
public JSONLetter changeLetter(@PathVariable("letterId") final String letterId, @RequestBody final List<JSONDocumentChangedEvent> events)
{
    userSession.assertLoggedIn();

    final WebuiLetterChangeResult result = changeLetter(letterId, letterOld -> changeLetter(letterOld, events));
    return JSONLetter.of(result.getLetter());
}

@PatchMapping("/{emailId}")
@ApiOperation("Changes the email")
public JSONEmail changeEmail(@PathVariable("emailId") final String emailId, @RequestBody final List<JSONDocumentChangedEvent> events)
{
    userSession.assertLoggedIn();

    final WebuiEmailChangeResult result = changeEmail(emailId, emailOld -> changeEmail(emailOld, events));
    return JSONEmail.of(result.getEmail());
}

@PatchMapping("/{quickInputId}")
public List<JSONDocument> processChanges(
        @PathVariable("windowId") final String windowIdStr //
        , @PathVariable("documentId") final String documentIdStr //
        , @PathVariable("tabId") final String tabIdStr //
        , @PathVariable("quickInputId") final String quickInputIdStr //
        , @RequestBody final List<JSONDocumentChangedEvent> events)
{
    userSession.assertLoggedIn();

    final QuickInputPath quickInputPath = QuickInputPath.of(windowIdStr, documentIdStr, tabIdStr, quickInputIdStr);
    return Execution.callInNewExecution("quickInput-writable-" + quickInputPath, () -> {
        final IDocumentChangesCollector changesCollector = Execution.getCurrentDocumentChangesCollectorOrNull();

        forQuickInputWritable(quickInputPath, changesCollector, quickInput -> {
            quickInput.processValueChanges(events);

            changesCollector.setPrimaryChange(quickInput.getDocumentPath());
            return null; // void
        });

        // Extract and send websocket events
        final List<JSONDocument> jsonDocumentEvents = JSONDocument.ofEvents(changesCollector, newJSONOptions());
        websocketPublisher.convertAndPublish(jsonDocumentEvents);

        return jsonDocumentEvents;
    });
}

@PatchMapping("/{id}")
public ResponseEntity patchUser(@PathVariable Long id, @RequestBody JsonPatch jsonPatch) {
  return this.userService
      .getUserByID(id)
      .map(existing -> {
        try {
          JsonNode patched = jsonPatch.apply(objectMapper.convertValue(existing, JsonNode.class));

          UserDTO patchedUser = objectMapper.treeToValue(patched, UserDTO.class);
          // TODO add patched operations
          return ResponseEntity.ok(this.userService.update(patchedUser));
        } catch (JsonPatchException | JsonProcessingException e) {
          return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(e.getMessage());
        }
      })
      .orElse(ResponseEntity.notFound().build());
}

@Override
public JAnnotationUse apply(ApiActionMetadata endpointMetadata, JMethod generatableType) {
    JAnnotationUse requestMappingAnnotation;
    switch (RequestMethod.valueOf(endpointMetadata.getActionType().name())) {
        case GET:
            requestMappingAnnotation = generatableType.annotate(GetMapping.class);
            break;
        case POST:
            requestMappingAnnotation = generatableType.annotate(PostMapping.class);
            break;
        case PUT:
            requestMappingAnnotation = generatableType.annotate(PutMapping.class);
            break;
        case PATCH:
            requestMappingAnnotation = generatableType.annotate(PatchMapping.class);
            break;
        case DELETE:
            requestMappingAnnotation = generatableType.annotate(DeleteMapping.class);
            break;
        default:
            requestMappingAnnotation = generatableType.annotate(RequestMapping.class);
            requestMappingAnnotation.param("method", RequestMethod.valueOf(endpointMetadata.getActionType().name()));
    }

    if (StringUtils.isNotBlank(endpointMetadata.getUrl())) {
        requestMappingAnnotation.param("value", endpointMetadata.getUrl());
    }
    return requestMappingAnnotation;
}

/**
 * Searches {@link org.springframework.web.bind.annotation.RequestMapping RequestMapping}
 * annotation on the given method argument and extracts
 * If RequestMapping annotation is not found, NoRequestMappingFoundException is thrown.
 * {@link org.springframework.http.HttpMethod HttpMethod} type equivalent to
 * {@link org.springframework.web.bind.annotation.RequestMethod RequestMethod} type
 *
 * @param element AnnotatedElement object to be examined.
 * @return Mapping object
 */
Mapping extractMapping(AnnotatedElement element) {
  Annotation annotation = findMappingAnnotation(element);
  String[] urls;
  RequestMethod requestMethod;
  String consumes;

  if (annotation instanceof RequestMapping) {
    RequestMapping requestMapping = (RequestMapping) annotation;
    requestMethod = requestMapping.method().length == 0
        ? RequestMethod.GET : requestMapping.method()[0];
    urls = requestMapping.value();
    consumes = StringHelper.getFirstOrEmpty(requestMapping.consumes());

  } else if (annotation instanceof GetMapping) {

    requestMethod = RequestMethod.GET;
    urls = ((GetMapping) annotation).value();
    consumes = StringHelper.getFirstOrEmpty(((GetMapping) annotation).consumes());

  } else if (annotation instanceof PostMapping) {

    requestMethod = RequestMethod.POST;
    urls = ((PostMapping) annotation).value();
    consumes = StringHelper.getFirstOrEmpty(((PostMapping) annotation).consumes());

  } else if (annotation instanceof PutMapping) {

    requestMethod = RequestMethod.PUT;
    urls = ((PutMapping) annotation).value();
    consumes = StringHelper.getFirstOrEmpty(((PutMapping) annotation).consumes());

  } else if (annotation instanceof DeleteMapping) {

    requestMethod = RequestMethod.DELETE;
    urls = ((DeleteMapping) annotation).value();
    consumes = StringHelper.getFirstOrEmpty(((DeleteMapping) annotation).consumes());

  } else if (annotation instanceof PatchMapping) {

    requestMethod = RequestMethod.PATCH;
    urls = ((PatchMapping) annotation).value();
    consumes = StringHelper.getFirstOrEmpty(((PatchMapping) annotation).consumes());

  } else {
    throw new NoRequestMappingFoundException(element);
  }

  HttpMethod httpMethod = HttpMethod.resolve(requestMethod.name());
  String url = StringHelper.getFirstOrEmpty(urls);

  MediaType mediaType;
  try {
    mediaType =  MediaType.valueOf(consumes);
  } catch (InvalidMediaTypeException exception) {
    mediaType = MediaType.APPLICATION_JSON_UTF8;
  }

  return new Mapping(httpMethod, url, mediaType);

}

@PatchMapping
ResponseEntity patchMapping();

@PatchMapping(path = "usingPatchMapping")
public ResponseEntity<List<User>> usingPatchMapping() {
  return null;
}

@PatchMapping(path = "usingPatchMapping")
public void usingPatchMapping(int query) {
}

@PatchMapping(path = "/groups/{group}/jobs/{name}/pause")
public ResponseEntity<Void> pauseJob(@PathVariable String group, @PathVariable String name) {
    emailService.pauseJob(group, name);
    return ResponseEntity.noContent().build();
}

@PatchMapping(path = "/groups/{group}/jobs/{name}/resume")
public ResponseEntity<Void> resumeJob(@PathVariable String group, @PathVariable String name) {
    emailService.resumeJob(group, name);
    return ResponseEntity.noContent().build();
}

@PatchMapping("/patch-mapping")
public void patchMapping() {
}

@PatchMapping(value = "/hello-patch")
public void helloPatch() {
    logger.fine("hello PATCH");
}

@PatchMapping("{id}")
@ResponseStatus(HttpStatus.NO_CONTENT)
public void update(@PathVariable("id") long problemId, @RequestBody Problem p,
        @RequestParam(value = "locale", required = false) String requestLocale) {
    problemService.updateSelective(problemId, p, requestLocale);
}

@PatchMapping("{userId}")
@ResponseStatus(HttpStatus.NO_CONTENT)
public void update(@PathVariable("userId") String userId, @RequestBody User user) {
    accountService.updateSelective(userId, user.toBuilder().password(null).build());
}

@PatchMapping("{userId}/password")
@ResponseStatus(HttpStatus.NO_CONTENT)
public void updatePassword(@PathVariable("userId") String userId, @RequestBody UserPasswordForm user) {
    accountService.updatePassword(userId, user.getPassword());
}

@PatchMapping("{id}")
@ResponseStatus(HttpStatus.NO_CONTENT)
public void update(@PathVariable("id") long id, @RequestBody Contest contest) {
    contestService.updateSelective(id, contest);
}

@PatchMapping("")
void methodWithPatchMappingAnnotation() throws ExceptionWithThrowableConstructorException;

@PatchMapping("/kpis/{itemId}")
public JSONDashboardItem changeKPIItem(@PathVariable("itemId") final int itemId, @RequestBody final List<JSONPatchEvent<DashboardItemPatchPath>> events)
{
    return changeDashboardItem(DashboardWidgetType.KPI, itemId, events);
}

@PatchMapping("/targetIndicators/{itemId}")
public JSONDashboardItem changeTargetIndicatorItem(@PathVariable("itemId") final int itemId, @RequestBody final List<JSONPatchEvent<DashboardItemPatchPath>> events)
{
    return changeDashboardItem(DashboardWidgetType.TargetIndicator, itemId, events);
}