Source code

001
002package com.commercetools.api.client;
003
004import java.net.URI;
005import java.time.Duration;
006import java.util.ArrayList;
007import java.util.Collection;
008import java.util.List;
009import java.util.concurrent.CompletableFuture;
010import java.util.function.Function;
011import java.util.function.Supplier;
012import java.util.stream.Collectors;
013
014import io.vrap.rmf.base.client.*;
015import io.vrap.rmf.base.client.utils.Generated;
016
017import org.apache.commons.lang3.builder.EqualsBuilder;
018import org.apache.commons.lang3.builder.HashCodeBuilder;
019
020/**
021 *
022 *
023 * <hr>
024 * <div class=code-example>
025 * <pre><code class='java'>{@code
026 *   CompletableFuture<ApiHttpResponse<com.commercetools.api.models.cart.CartPagedQueryResponse>> result = apiRoot
027 *            .withProjectKey("{projectKey}")
028 *            .me()
029 *            .carts()
030 *            .get()
031 *            .execute()
032 * }</code></pre>
033 * </div>
034 */
035@Generated(value = "io.vrap.rmf.codegen.rendering.CoreCodeGenerator", comments = "https://github.com/commercetools/rmf-codegen")
036public class ByProjectKeyMeCartsGet
037        extends ApiMethod<ByProjectKeyMeCartsGet, com.commercetools.api.models.cart.CartPagedQueryResponse>
038        implements com.commercetools.api.client.ExpandableTrait<ByProjectKeyMeCartsGet>,
039        com.commercetools.api.client.SortableTrait<ByProjectKeyMeCartsGet>,
040        com.commercetools.api.client.PagingTrait<ByProjectKeyMeCartsGet>,
041        com.commercetools.api.client.QueryTrait<ByProjectKeyMeCartsGet>,
042        com.commercetools.api.client.ErrorableTrait<ByProjectKeyMeCartsGet>,
043        com.commercetools.api.client.Deprecatable200Trait<ByProjectKeyMeCartsGet> {
044
045    private String projectKey;
046
047    public ByProjectKeyMeCartsGet(final ApiHttpClient apiHttpClient, String projectKey) {
048        super(apiHttpClient);
049        this.projectKey = projectKey;
050    }
051
052    public ByProjectKeyMeCartsGet(ByProjectKeyMeCartsGet t) {
053        super(t);
054        this.projectKey = t.projectKey;
055    }
056
057    @Override
058    protected ApiHttpRequest buildHttpRequest() {
059        List<String> params = new ArrayList<>(getQueryParamUriStrings());
060        String httpRequestPath = String.format("%s/me/carts", this.projectKey);
061        if (!params.isEmpty()) {
062            httpRequestPath += "?" + String.join("&", params);
063        }
064        return new ApiHttpRequest(ApiHttpMethod.GET, URI.create(httpRequestPath), getHeaders(), null);
065    }
066
067    @Override
068    public ApiHttpResponse<com.commercetools.api.models.cart.CartPagedQueryResponse> executeBlocking(
069            final ApiHttpClient client, final Duration timeout) {
070        return executeBlocking(client, timeout, com.commercetools.api.models.cart.CartPagedQueryResponse.class);
071    }
072
073    @Override
074    public CompletableFuture<ApiHttpResponse<com.commercetools.api.models.cart.CartPagedQueryResponse>> execute(
075            final ApiHttpClient client) {
076        return execute(client, com.commercetools.api.models.cart.CartPagedQueryResponse.class);
077    }
078
079    public String getProjectKey() {
080        return this.projectKey;
081    }
082
083    public List<String> getExpand() {
084        return this.getQueryParam("expand");
085    }
086
087    public List<String> getSort() {
088        return this.getQueryParam("sort");
089    }
090
091    public List<String> getLimit() {
092        return this.getQueryParam("limit");
093    }
094
095    public List<String> getOffset() {
096        return this.getQueryParam("offset");
097    }
098
099    public List<String> getWithTotal() {
100        return this.getQueryParam("withTotal");
101    }
102
103    public List<String> getWhere() {
104        return this.getQueryParam("where");
105    }
106
107    public void setProjectKey(final String projectKey) {
108        this.projectKey = projectKey;
109    }
110
111    /**
112     * set expand with the specified value
113     * @param expand value to be set
114     * @param <TValue> value type
115     * @return ByProjectKeyMeCartsGet
116     */
117    public <TValue> ByProjectKeyMeCartsGet withExpand(final TValue expand) {
118        return copy().withQueryParam("expand", expand);
119    }
120
121    /**
122     * add additional expand query parameter
123     * @param expand value to be added
124     * @param <TValue> value type
125     * @return ByProjectKeyMeCartsGet
126     */
127    public <TValue> ByProjectKeyMeCartsGet addExpand(final TValue expand) {
128        return copy().addQueryParam("expand", expand);
129    }
130
131    /**
132     * set expand with the specified value
133     * @param supplier supplier for the value to be set
134     * @return ByProjectKeyMeCartsGet
135     */
136    public ByProjectKeyMeCartsGet withExpand(final Supplier<String> supplier) {
137        return copy().withQueryParam("expand", supplier.get());
138    }
139
140    /**
141     * add additional expand query parameter
142     * @param supplier supplier for the value to be added
143     * @return ByProjectKeyMeCartsGet
144     */
145    public ByProjectKeyMeCartsGet addExpand(final Supplier<String> supplier) {
146        return copy().addQueryParam("expand", supplier.get());
147    }
148
149    /**
150     * set expand with the specified value
151     * @param op builder for the value to be set
152     * @return ByProjectKeyMeCartsGet
153     */
154    public ByProjectKeyMeCartsGet withExpand(final Function<StringBuilder, StringBuilder> op) {
155        return copy().withQueryParam("expand", op.apply(new StringBuilder()));
156    }
157
158    /**
159     * add additional expand query parameter
160     * @param op builder for the value to be added
161     * @return ByProjectKeyMeCartsGet
162     */
163    public ByProjectKeyMeCartsGet addExpand(final Function<StringBuilder, StringBuilder> op) {
164        return copy().addQueryParam("expand", op.apply(new StringBuilder()));
165    }
166
167    /**
168     * set expand with the specified values
169     * @param expand values to be set
170     * @param <TValue> value type
171     * @return ByProjectKeyMeCartsGet
172     */
173    public <TValue> ByProjectKeyMeCartsGet withExpand(final Collection<TValue> expand) {
174        return copy().withoutQueryParam("expand")
175                .addQueryParams(
176                    expand.stream().map(s -> new ParamEntry<>("expand", s.toString())).collect(Collectors.toList()));
177    }
178
179    /**
180     * add additional expand query parameters
181     * @param expand values to be added
182     * @param <TValue> value type
183     * @return ByProjectKeyMeCartsGet
184     */
185    public <TValue> ByProjectKeyMeCartsGet addExpand(final Collection<TValue> expand) {
186        return copy().addQueryParams(
187            expand.stream().map(s -> new ParamEntry<>("expand", s.toString())).collect(Collectors.toList()));
188    }
189
190    /**
191     * set sort with the specified value
192     * @param sort value to be set
193     * @param <TValue> value type
194     * @return ByProjectKeyMeCartsGet
195     */
196    public <TValue> ByProjectKeyMeCartsGet withSort(final TValue sort) {
197        return copy().withQueryParam("sort", sort);
198    }
199
200    /**
201     * add additional sort query parameter
202     * @param sort value to be added
203     * @param <TValue> value type
204     * @return ByProjectKeyMeCartsGet
205     */
206    public <TValue> ByProjectKeyMeCartsGet addSort(final TValue sort) {
207        return copy().addQueryParam("sort", sort);
208    }
209
210    /**
211     * set sort with the specified value
212     * @param supplier supplier for the value to be set
213     * @return ByProjectKeyMeCartsGet
214     */
215    public ByProjectKeyMeCartsGet withSort(final Supplier<String> supplier) {
216        return copy().withQueryParam("sort", supplier.get());
217    }
218
219    /**
220     * add additional sort query parameter
221     * @param supplier supplier for the value to be added
222     * @return ByProjectKeyMeCartsGet
223     */
224    public ByProjectKeyMeCartsGet addSort(final Supplier<String> supplier) {
225        return copy().addQueryParam("sort", supplier.get());
226    }
227
228    /**
229     * set sort with the specified value
230     * @param op builder for the value to be set
231     * @return ByProjectKeyMeCartsGet
232     */
233    public ByProjectKeyMeCartsGet withSort(final Function<StringBuilder, StringBuilder> op) {
234        return copy().withQueryParam("sort", op.apply(new StringBuilder()));
235    }
236
237    /**
238     * add additional sort query parameter
239     * @param op builder for the value to be added
240     * @return ByProjectKeyMeCartsGet
241     */
242    public ByProjectKeyMeCartsGet addSort(final Function<StringBuilder, StringBuilder> op) {
243        return copy().addQueryParam("sort", op.apply(new StringBuilder()));
244    }
245
246    /**
247     * set sort with the specified values
248     * @param sort values to be set
249     * @param <TValue> value type
250     * @return ByProjectKeyMeCartsGet
251     */
252    public <TValue> ByProjectKeyMeCartsGet withSort(final Collection<TValue> sort) {
253        return copy().withoutQueryParam("sort")
254                .addQueryParams(
255                    sort.stream().map(s -> new ParamEntry<>("sort", s.toString())).collect(Collectors.toList()));
256    }
257
258    /**
259     * add additional sort query parameters
260     * @param sort values to be added
261     * @param <TValue> value type
262     * @return ByProjectKeyMeCartsGet
263     */
264    public <TValue> ByProjectKeyMeCartsGet addSort(final Collection<TValue> sort) {
265        return copy().addQueryParams(
266            sort.stream().map(s -> new ParamEntry<>("sort", s.toString())).collect(Collectors.toList()));
267    }
268
269    /**
270     * set limit with the specified value
271     * @param limit value to be set
272     * @param <TValue> value type
273     * @return ByProjectKeyMeCartsGet
274     */
275    public <TValue> ByProjectKeyMeCartsGet withLimit(final TValue limit) {
276        return copy().withQueryParam("limit", limit);
277    }
278
279    /**
280     * add additional limit query parameter
281     * @param limit value to be added
282     * @param <TValue> value type
283     * @return ByProjectKeyMeCartsGet
284     */
285    public <TValue> ByProjectKeyMeCartsGet addLimit(final TValue limit) {
286        return copy().addQueryParam("limit", limit);
287    }
288
289    /**
290     * set limit with the specified value
291     * @param supplier supplier for the value to be set
292     * @return ByProjectKeyMeCartsGet
293     */
294    public ByProjectKeyMeCartsGet withLimit(final Supplier<Integer> supplier) {
295        return copy().withQueryParam("limit", supplier.get());
296    }
297
298    /**
299     * add additional limit query parameter
300     * @param supplier supplier for the value to be added
301     * @return ByProjectKeyMeCartsGet
302     */
303    public ByProjectKeyMeCartsGet addLimit(final Supplier<Integer> supplier) {
304        return copy().addQueryParam("limit", supplier.get());
305    }
306
307    /**
308     * set limit with the specified value
309     * @param op builder for the value to be set
310     * @return ByProjectKeyMeCartsGet
311     */
312    public ByProjectKeyMeCartsGet withLimit(final Function<StringBuilder, StringBuilder> op) {
313        return copy().withQueryParam("limit", op.apply(new StringBuilder()));
314    }
315
316    /**
317     * add additional limit query parameter
318     * @param op builder for the value to be added
319     * @return ByProjectKeyMeCartsGet
320     */
321    public ByProjectKeyMeCartsGet addLimit(final Function<StringBuilder, StringBuilder> op) {
322        return copy().addQueryParam("limit", op.apply(new StringBuilder()));
323    }
324
325    /**
326     * set limit with the specified values
327     * @param limit values to be set
328     * @param <TValue> value type
329     * @return ByProjectKeyMeCartsGet
330     */
331    public <TValue> ByProjectKeyMeCartsGet withLimit(final Collection<TValue> limit) {
332        return copy().withoutQueryParam("limit")
333                .addQueryParams(
334                    limit.stream().map(s -> new ParamEntry<>("limit", s.toString())).collect(Collectors.toList()));
335    }
336
337    /**
338     * add additional limit query parameters
339     * @param limit values to be added
340     * @param <TValue> value type
341     * @return ByProjectKeyMeCartsGet
342     */
343    public <TValue> ByProjectKeyMeCartsGet addLimit(final Collection<TValue> limit) {
344        return copy().addQueryParams(
345            limit.stream().map(s -> new ParamEntry<>("limit", s.toString())).collect(Collectors.toList()));
346    }
347
348    /**
349     * set offset with the specified value
350     * @param offset value to be set
351     * @param <TValue> value type
352     * @return ByProjectKeyMeCartsGet
353     */
354    public <TValue> ByProjectKeyMeCartsGet withOffset(final TValue offset) {
355        return copy().withQueryParam("offset", offset);
356    }
357
358    /**
359     * add additional offset query parameter
360     * @param offset value to be added
361     * @param <TValue> value type
362     * @return ByProjectKeyMeCartsGet
363     */
364    public <TValue> ByProjectKeyMeCartsGet addOffset(final TValue offset) {
365        return copy().addQueryParam("offset", offset);
366    }
367
368    /**
369     * set offset with the specified value
370     * @param supplier supplier for the value to be set
371     * @return ByProjectKeyMeCartsGet
372     */
373    public ByProjectKeyMeCartsGet withOffset(final Supplier<Integer> supplier) {
374        return copy().withQueryParam("offset", supplier.get());
375    }
376
377    /**
378     * add additional offset query parameter
379     * @param supplier supplier for the value to be added
380     * @return ByProjectKeyMeCartsGet
381     */
382    public ByProjectKeyMeCartsGet addOffset(final Supplier<Integer> supplier) {
383        return copy().addQueryParam("offset", supplier.get());
384    }
385
386    /**
387     * set offset with the specified value
388     * @param op builder for the value to be set
389     * @return ByProjectKeyMeCartsGet
390     */
391    public ByProjectKeyMeCartsGet withOffset(final Function<StringBuilder, StringBuilder> op) {
392        return copy().withQueryParam("offset", op.apply(new StringBuilder()));
393    }
394
395    /**
396     * add additional offset query parameter
397     * @param op builder for the value to be added
398     * @return ByProjectKeyMeCartsGet
399     */
400    public ByProjectKeyMeCartsGet addOffset(final Function<StringBuilder, StringBuilder> op) {
401        return copy().addQueryParam("offset", op.apply(new StringBuilder()));
402    }
403
404    /**
405     * set offset with the specified values
406     * @param offset values to be set
407     * @param <TValue> value type
408     * @return ByProjectKeyMeCartsGet
409     */
410    public <TValue> ByProjectKeyMeCartsGet withOffset(final Collection<TValue> offset) {
411        return copy().withoutQueryParam("offset")
412                .addQueryParams(
413                    offset.stream().map(s -> new ParamEntry<>("offset", s.toString())).collect(Collectors.toList()));
414    }
415
416    /**
417     * add additional offset query parameters
418     * @param offset values to be added
419     * @param <TValue> value type
420     * @return ByProjectKeyMeCartsGet
421     */
422    public <TValue> ByProjectKeyMeCartsGet addOffset(final Collection<TValue> offset) {
423        return copy().addQueryParams(
424            offset.stream().map(s -> new ParamEntry<>("offset", s.toString())).collect(Collectors.toList()));
425    }
426
427    /**
428     * set withTotal with the specified value
429     * @param withTotal value to be set
430     * @param <TValue> value type
431     * @return ByProjectKeyMeCartsGet
432     */
433    public <TValue> ByProjectKeyMeCartsGet withWithTotal(final TValue withTotal) {
434        return copy().withQueryParam("withTotal", withTotal);
435    }
436
437    /**
438     * add additional withTotal query parameter
439     * @param withTotal value to be added
440     * @param <TValue> value type
441     * @return ByProjectKeyMeCartsGet
442     */
443    public <TValue> ByProjectKeyMeCartsGet addWithTotal(final TValue withTotal) {
444        return copy().addQueryParam("withTotal", withTotal);
445    }
446
447    /**
448     * set withTotal with the specified value
449     * @param supplier supplier for the value to be set
450     * @return ByProjectKeyMeCartsGet
451     */
452    public ByProjectKeyMeCartsGet withWithTotal(final Supplier<Boolean> supplier) {
453        return copy().withQueryParam("withTotal", supplier.get());
454    }
455
456    /**
457     * add additional withTotal query parameter
458     * @param supplier supplier for the value to be added
459     * @return ByProjectKeyMeCartsGet
460     */
461    public ByProjectKeyMeCartsGet addWithTotal(final Supplier<Boolean> supplier) {
462        return copy().addQueryParam("withTotal", supplier.get());
463    }
464
465    /**
466     * set withTotal with the specified value
467     * @param op builder for the value to be set
468     * @return ByProjectKeyMeCartsGet
469     */
470    public ByProjectKeyMeCartsGet withWithTotal(final Function<StringBuilder, StringBuilder> op) {
471        return copy().withQueryParam("withTotal", op.apply(new StringBuilder()));
472    }
473
474    /**
475     * add additional withTotal query parameter
476     * @param op builder for the value to be added
477     * @return ByProjectKeyMeCartsGet
478     */
479    public ByProjectKeyMeCartsGet addWithTotal(final Function<StringBuilder, StringBuilder> op) {
480        return copy().addQueryParam("withTotal", op.apply(new StringBuilder()));
481    }
482
483    /**
484     * set withTotal with the specified values
485     * @param withTotal values to be set
486     * @param <TValue> value type
487     * @return ByProjectKeyMeCartsGet
488     */
489    public <TValue> ByProjectKeyMeCartsGet withWithTotal(final Collection<TValue> withTotal) {
490        return copy().withoutQueryParam("withTotal")
491                .addQueryParams(withTotal.stream()
492                        .map(s -> new ParamEntry<>("withTotal", s.toString()))
493                        .collect(Collectors.toList()));
494    }
495
496    /**
497     * add additional withTotal query parameters
498     * @param withTotal values to be added
499     * @param <TValue> value type
500     * @return ByProjectKeyMeCartsGet
501     */
502    public <TValue> ByProjectKeyMeCartsGet addWithTotal(final Collection<TValue> withTotal) {
503        return copy().addQueryParams(
504            withTotal.stream().map(s -> new ParamEntry<>("withTotal", s.toString())).collect(Collectors.toList()));
505    }
506
507    /**
508     * set where with the specified value
509     * @param where value to be set
510     * @param <TValue> value type
511     * @return ByProjectKeyMeCartsGet
512     */
513    public <TValue> ByProjectKeyMeCartsGet withWhere(final TValue where) {
514        return copy().withQueryParam("where", where);
515    }
516
517    /**
518     * add additional where query parameter
519     * @param where value to be added
520     * @param <TValue> value type
521     * @return ByProjectKeyMeCartsGet
522     */
523    public <TValue> ByProjectKeyMeCartsGet addWhere(final TValue where) {
524        return copy().addQueryParam("where", where);
525    }
526
527    /**
528     * set where with the specified value
529     * @param supplier supplier for the value to be set
530     * @return ByProjectKeyMeCartsGet
531     */
532    public ByProjectKeyMeCartsGet withWhere(final Supplier<String> supplier) {
533        return copy().withQueryParam("where", supplier.get());
534    }
535
536    /**
537     * add additional where query parameter
538     * @param supplier supplier for the value to be added
539     * @return ByProjectKeyMeCartsGet
540     */
541    public ByProjectKeyMeCartsGet addWhere(final Supplier<String> supplier) {
542        return copy().addQueryParam("where", supplier.get());
543    }
544
545    /**
546     * set where with the specified value
547     * @param op builder for the value to be set
548     * @return ByProjectKeyMeCartsGet
549     */
550    public ByProjectKeyMeCartsGet withWhere(final Function<StringBuilder, StringBuilder> op) {
551        return copy().withQueryParam("where", op.apply(new StringBuilder()));
552    }
553
554    /**
555     * add additional where query parameter
556     * @param op builder for the value to be added
557     * @return ByProjectKeyMeCartsGet
558     */
559    public ByProjectKeyMeCartsGet addWhere(final Function<StringBuilder, StringBuilder> op) {
560        return copy().addQueryParam("where", op.apply(new StringBuilder()));
561    }
562
563    /**
564     * set where with the specified values
565     * @param where values to be set
566     * @param <TValue> value type
567     * @return ByProjectKeyMeCartsGet
568     */
569    public <TValue> ByProjectKeyMeCartsGet withWhere(final Collection<TValue> where) {
570        return copy().withoutQueryParam("where")
571                .addQueryParams(
572                    where.stream().map(s -> new ParamEntry<>("where", s.toString())).collect(Collectors.toList()));
573    }
574
575    /**
576     * add additional where query parameters
577     * @param where values to be added
578     * @param <TValue> value type
579     * @return ByProjectKeyMeCartsGet
580     */
581    public <TValue> ByProjectKeyMeCartsGet addWhere(final Collection<TValue> where) {
582        return copy().addQueryParams(
583            where.stream().map(s -> new ParamEntry<>("where", s.toString())).collect(Collectors.toList()));
584    }
585
586    /**
587     * set predicateVar with the specificied value
588     * @param <TValue> value type
589     * @param varName parameter name
590     * @param predicateVar parameter value
591     * @return ByProjectKeyMeCartsGet
592     */
593    public <TValue> ByProjectKeyMeCartsGet withPredicateVar(final String varName, final TValue predicateVar) {
594        return copy().withQueryParam(String.format("var.%s", varName), predicateVar);
595    }
596
597    /**
598     * add additional predicateVar query parameter
599     * @param <TValue> value type
600     * @param varName parameter name
601     * @param predicateVar parameter value
602     * @return ByProjectKeyMeCartsGet
603     */
604    public <TValue> ByProjectKeyMeCartsGet addPredicateVar(final String varName, final TValue predicateVar) {
605        return copy().addQueryParam(String.format("var.%s", varName), predicateVar);
606    }
607
608    /**
609     * set predicateVar with the specificied values
610     * @param <TValue> value type
611     * @param varName parameter name
612     * @param predicateVar parameter values
613     * @return ByProjectKeyMeCartsGet
614     */
615    public <TValue> ByProjectKeyMeCartsGet withPredicateVar(final String varName,
616            final Collection<TValue> predicateVar) {
617        final String placeholderName = String.format("var.%s", varName);
618        return copy().withoutQueryParam(placeholderName)
619                .addQueryParams(predicateVar.stream()
620                        .map(s -> new ParamEntry<>(placeholderName, s.toString()))
621                        .collect(Collectors.toList()));
622    }
623
624    /**
625     * add additional predicateVar query parameters
626     * @param <TValue> value type
627     * @param varName parameter name
628     * @param predicateVar parameter values
629     * @return ByProjectKeyMeCartsGet
630     */
631    public <TValue> ByProjectKeyMeCartsGet addPredicateVar(final String varName,
632            final Collection<TValue> predicateVar) {
633        final String placeholderName = String.format("var.%s", varName);
634        return copy().addQueryParams(predicateVar.stream()
635                .map(s -> new ParamEntry<>(placeholderName, s.toString()))
636                .collect(Collectors.toList()));
637    }
638
639    @Override
640    public boolean equals(Object o) {
641        if (this == o)
642            return true;
643
644        if (o == null || getClass() != o.getClass())
645            return false;
646
647        ByProjectKeyMeCartsGet that = (ByProjectKeyMeCartsGet) o;
648
649        return new EqualsBuilder().append(projectKey, that.projectKey).isEquals();
650    }
651
652    @Override
653    public int hashCode() {
654        return new HashCodeBuilder(17, 37).append(projectKey).toHashCode();
655    }
656
657    @Override
658    protected ByProjectKeyMeCartsGet copy() {
659        return new ByProjectKeyMeCartsGet(this);
660    }
661}