com.github.davidmoten.odata.client.EntityRequestOptionsBuilder Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of odata-client-runtime Show documentation
OData client runtime for use with generated code
The newest version!
package com.github.davidmoten.odata.client;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.TimeUnit;

import com.github.davidmoten.guavamini.Preconditions;

public final class EntityRequestOptionsBuilder {

    private final EntityRequest request;
    private final List requestHeaders = new ArrayList<>();
    private final Map queries = new HashMap<>();
    private final boolean isMediaEntityOrHasStreamProperty;
    private Optional select = Optional.empty();
    private Optional expand = Optional.empty();
    private boolean useCaches = false;
    private String metadata = null; // set this later if not present
    private Optional connectTimeoutMs = Optional.empty();
    private Optional readTimeoutMs = Optional.empty();

    EntityRequestOptionsBuilder(EntityRequest request, boolean isMediaEntityOrHasStreamProperty) {
        this.request = request;
        this.isMediaEntityOrHasStreamProperty = isMediaEntityOrHasStreamProperty;
    }

    public EntityRequestOptionsBuilder requestHeader(String key, String value) {
        requestHeaders.add(new RequestHeader(key, value));
        return this;
    }

    public EntityRequestOptionsBuilder query(String name, String value) {
        queries.put(name,  value);
        return this;
    }
    
    public EntityRequestOptionsBuilder select(String clause) {
        Preconditions.checkNotNull(clause);
        this.select = Optional.of(clause);
        return this;
    }

    public EntityRequestOptionsBuilder expand(String clause) {
        Preconditions.checkNotNull(clause);
        this.expand = Optional.of(clause);
        return this;
    }

    public EntityRequestOptionsBuilder useCaches(boolean value) {
        // TODO implement useCaches
        this.useCaches = value;
        return this;
    }

    public EntityRequestOptionsBuilder ifMatch(String eTag) {
        return requestHeader("If-Match", eTag);
    }

    public EntityRequestOptionsBuilder useCaches() {
        return useCaches(true);
    }

    public EntityRequestOptionsBuilder metadataNone() {
        this.metadata = "none";
        return this;
    }

    public EntityRequestOptionsBuilder metadataMinimal() {
        this.metadata = "minimal";
        return this;
    }

    public EntityRequestOptionsBuilder metadataFull() {
        this.metadata = "full";
        return this;
    }
    
    public EntityRequestOptionsBuilder connectTimeout(long duration, TimeUnit unit) {
        this.connectTimeoutMs = Optional.of(unit.toMillis(duration));
        return this;
    }

    public EntityRequestOptionsBuilder readTimeout(long duration, TimeUnit unit) {
        this.readTimeoutMs = Optional.of(unit.toMillis(duration));
        return this;
    }
    
    public T get() {
        updateMetadataForReturningObject();
        return request.get(build());
    }

    public T patch(T entity) {
        updateMetadataForReturningObject();
        return request.patch(build(), entity);
    }

    public T put(T entity) {
        updateMetadataForReturningObject();
        return request.put(build(), entity);
    }

    public void delete() {
        request.delete(build());
    }
    
    private void updateMetadataForReturningObject() {
        if (metadata == null && isMediaEntityOrHasStreamProperty) {
            // ensure the stream url is returned in the metadata so users don't get nasty surprises
            // about the need to specify full metadata
            metadata = "full";
        }
    }

    private EntityRequestOptions build() {
        if (metadata == null) {
            metadata = "minimal";
        }
        requestHeaders.add(RequestHeader.acceptJsonWithMetadata(metadata));
        return new EntityRequestOptions(requestHeaders, select, expand, useCaches, //
        		connectTimeoutMs, readTimeoutMs, queries);
    }

}