io.higgs.http.client.POST Maven / Gradle / Ivy

Go to download
package io.higgs.http.client;

import io.higgs.core.StaticUtil;
import io.higgs.http.client.readers.Reader;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.handler.codec.http.HttpMethod;
import io.netty.handler.codec.http.HttpVersion;
import io.netty.handler.codec.http.multipart.DefaultHttpDataFactory;
import io.netty.handler.codec.http.multipart.HttpDataFactory;
import io.netty.handler.codec.http.multipart.HttpPostRequestEncoder;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.GenericFutureListener;

import java.net.URI;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author Courtney Robinson 
 */
public class POST extends Request {
    private final List files = new ArrayList<>();
    protected long minSize = DefaultHttpDataFactory.MINSIZE;
    private HttpPostRequestEncoder encoder;
    private Map form = new HashMap<>();
    private HttpDataFactory factory;

    public POST(HttpRequestBuilder builder, EventLoopGroup group, URI uri, HttpVersion version, Reader f) {
        super(builder, group, uri, HttpMethod.POST, version, f);
    }

    @Override
    protected void configure() throws Exception {
        super.configure();
        boolean multipart = files.size() > 0;
        newEncoder(multipart);
        addFormParams();
        if (multipart) {
            addFileParams();
        }
        // finalize request
        request = encoder.finalizeRequest();
    }

    protected ChannelFuture makeTheRequest() {
        return !encoder.isChunked() ? super.makeTheRequest() : doRequest();
    }

    private ChannelFuture doRequest() {
        StaticUtil.write(channel, request);
        return StaticUtil.write(channel, encoder).awaitUninterruptibly()
                .addListener(new GenericFutureListener>() {
                    @Override
                    public void operationComplete(Future future) throws Exception {
                        encoder.cleanFiles();
                    }
                });
    }

    /**
     * Create a new factory and post request encoder
     *
     * @param multipart if true then a multipart encoder is created
     * @throws HttpPostRequestEncoder.ErrorDataEncoderException
     */
    protected void newEncoder(boolean multipart) throws HttpPostRequestEncoder.ErrorDataEncoderException {
        factory = new DefaultHttpDataFactory(minSize);
        // Use the PostBody encoder
        encoder = new HttpPostRequestEncoder(factory, request, multipart);
    }

    private void addFormParams() throws HttpPostRequestEncoder.ErrorDataEncoderException {
        // add Form attribute
        for (Map.Entry e : form.entrySet()) {
            encoder.addBodyAttribute(e.getKey(), String.valueOf(e.getValue() == null ? "" : e.getValue()));
        }
    }

    private void addFileParams() throws HttpPostRequestEncoder.ErrorDataEncoderException {
        for (HttpFile file : files) {
            if (file.isSingle()) {
                encoder.addBodyFileUpload(file.name(), file.file(), file.contentType(), file.isText());
            } else {
                encoder.addBodyFileUploads(file.name(), file.fileSet(), file.contentTypes(), file.isTextSet());
            }
        }
    }

    public long getMinSize() {
        return minSize;
    }

    public POST setMinSize(long minSize) {
        this.minSize = minSize;
        return this;
    }

    public List getFiles() {
        return files;
    }

    public HttpPostRequestEncoder getEncoder() {
        return encoder;
    }

    public Map getForm() {
        return form;
    }

    public HttpDataFactory getFactory() {
        return factory;
    }

    public POST form(String name, Object value) {
        form.put(name, value);
        return this;
    }

    public POST file(HttpFile file) {
        if (file != null) {
            files.add(file);
        }
        return this;
    }

}