public JsonResponse<ApiResult> post$setting(final EditBody body) {
        validateApi(body, messages -> {});
        validateAttributes(body.attributes, this::throwValidationErrorApi);
        body.crudMode = CrudMode.EDIT;
        final User entity = getUser(body).orElseGet(() -> {
            throwValidationErrorApi(messages -> {
                messages.addErrorsCrudCouldNotFindCrudTable(GLOBAL, body.id);
            });
            return null;

    open fun head(): Builder = commonHead()

    open fun post(body: RequestBody): Builder = commonPost(body)

    @JvmOverloads
    open fun delete(body: RequestBody? = commonEmptyRequestBody): Builder = commonDelete(body)

    open fun put(body: RequestBody): Builder = commonPut(body)

    open fun patch(body: RequestBody): Builder = commonPatch(body)

    open fun method(
      method: String,

    assertThat(body.contentLength()).isEqualTo(3)
    assertThat(bodyToHex(body)).isEqualTo("616263")
    assertThat(bodyToHex(body), "Retransmit body").isEqualTo("616263")
  }

  @Test
  fun byteArrayRange() {
    val contentType = "text/plain".toMediaType()
    val body: RequestBody = ".abcd".toByteArray().toRequestBody(contentType, 1, 3)
    assertThat(body.contentType()).isEqualTo(contentType)

    }

    // PUT /api/admin/relatedquery/setting
    @Execute
    public JsonResponse<ApiResult> put$setting(final CreateBody body) {
        validateApi(body, messages -> {});
        body.crudMode = CrudMode.CREATE;
        final RelatedQuery relatedQuery = getRelatedQuery(body).map(entity -> {
            try {
                relatedQueryService.store(entity);
            } catch (final Exception e) {

    public JsonResponse<ApiResult> get$settings(final String dictId, final SearchBody body) {
        body.dictId = dictId;
        validateApi(body, messages -> {});
        final StopwordsPager pager = copyBeanToNewBean(body, StopwordsPager.class);
        return asJson(new ApiResult.ApiConfigsResponse<EditBody>()
                .settings(stopwordsService.getStopwordsList(body.dictId, pager).stream()

        "abc",
      ),
    )
    assertThat(partAbc.body.readUtf8()).isEqualTo("abcd\r\nefgh")

    val partIjk = parts.nextPart()!!
    assertThat(partIjk.headers).isEqualTo(
      headersOf(
        "Content-Type",
        "text/plain; charset=utf-8",
        "Content-ID",
        "ijk",
      ),
    )
    assertThat(partIjk.body.readUtf8()).isEqualTo("ijkl\r\nmnop\r\n")

  ): Sink {
    return when {
      request.body?.isDuplex() == true -> throw ProtocolException(
        "Duplex connections are not supported for HTTP/1",
      )
      request.isChunked -> newChunkedSink() // Stream a request body of unknown length.
      contentLength != -1L -> newKnownLengthSink() // Stream a request body of a known length.
      else -> // Stream a request body of a known length.
        throw IllegalStateException(

            "detail": [
                {
                    "type": "missing",
                    "loc": ["body", "item"],
                    "msg": "Field required",
                    "input": None,
                },
                {
                    "type": "missing",
                    "loc": ["body", "user"],
                    "msg": "Field required",
                    "input": None,
                },

            "detail": [
                {
                    "type": "missing",
                    "loc": ["body", "item"],
                    "msg": "Field required",
                    "input": None,
                },
                {
                    "type": "missing",
                    "loc": ["body", "user"],
                    "msg": "Field required",
                    "input": None,
                },

            "detail": [
                {
                    "type": "missing",
                    "loc": ["body", "item"],
                    "msg": "Field required",
                    "input": None,
                },
                {
                    "type": "missing",
                    "loc": ["body", "user"],
                    "msg": "Field required",
                    "input": None,
                },