com.yandex.disk.rest.RestClient Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of disk-restapi-sdk Show documentation
The Java SDK for Yandex.Disk REST API is intended for applications that work with the files of Yandex.Disk users or store their own files and settings on Yandex.Disk.
The newest version!
/*
* (C) 2015 Yandex LLC (https://yandex.com/)
*
* The source code of Java SDK for Yandex.Disk REST API
* is available to use under terms of Apache License,
* Version 2.0. See the file LICENSE for the details.
*/

package com.yandex.disk.rest;

import com.squareup.okhttp.OkHttpClient;
import com.yandex.disk.rest.exceptions.ServerException;
import com.yandex.disk.rest.exceptions.ServerIOException;
import com.yandex.disk.rest.exceptions.WrongMethodException;
import com.yandex.disk.rest.exceptions.http.HttpCodeException;
import com.yandex.disk.rest.json.ApiVersion;
import com.yandex.disk.rest.json.DiskInfo;
import com.yandex.disk.rest.json.Link;
import com.yandex.disk.rest.json.Operation;
import com.yandex.disk.rest.json.Resource;
import com.yandex.disk.rest.json.ResourceList;
import com.yandex.disk.rest.retrofit.CloudApi;
import com.yandex.disk.rest.retrofit.ErrorHandlerImpl;
import com.yandex.disk.rest.retrofit.RequestInterceptorImpl;
import com.yandex.disk.rest.util.Hash;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import retrofit.RestAdapter;
import retrofit.client.OkClient;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.List;

public class RestClient {

    private static final Logger logger = LoggerFactory.getLogger(RestClient.class);

    private static final RestAdapter.LogLevel LOG_LEVEL = logger.isDebugEnabled()
            ? RestAdapter.LogLevel.FULL
            : RestAdapter.LogLevel.NONE;

    private final Credentials credentials;
    private final OkHttpClient client;
    private final String serverURL;
    private final CloudApi cloudApi;
    protected final RestAdapter.Builder builder;

    public RestClient(final Credentials credentials) {
        this(credentials, OkHttpClientFactory.makeClient());
    }

    public RestClient(final Credentials credentials, final OkHttpClient client) {
        this(credentials, client, "https://cloud-api.yandex.net");
    }

    public RestClient(final Credentials credentials, final OkHttpClient client, final String serverUrl) {
        this.credentials = credentials;
        this.client = client;
        try {
            this.serverURL = new URL(serverUrl).toExternalForm();
        } catch (MalformedURLException ex) {
            throw new RuntimeException(ex);
        }

        this.builder = new RestAdapter.Builder()
                .setClient(new OkClient(client))
                .setEndpoint(getUrl())
                .setRequestInterceptor(new RequestInterceptorImpl(credentials.getHeaders()))
                .setErrorHandler(new ErrorHandlerImpl())
                .setLogLevel(LOG_LEVEL);

        this.cloudApi = builder
                .build()
                .create(CloudApi.class);
    }

    /* package */ String getUrl() {
        return serverURL;
    }

    /* package */ OkHttpClient getClient() {
        return client;
    }

    /**
     * Server API version and build
     */
    public ApiVersion getApiVersion()
            throws IOException, ServerIOException {
        return cloudApi.getApiVersion();
    }

    /**
     * Operation status
     *
     * @see API reference english,
     * russian
     */
    public Operation getOperation(final String operationId)
            throws IOException, ServerIOException {
        return cloudApi.getOperation(operationId);
    }

    /**
     * Operation status
     *
     * @see API reference english,
     * russian
     */
    public Operation getOperation(final Link link)
            throws IOException, WrongMethodException, HttpCodeException {
        if (!"GET".equalsIgnoreCase(link.getMethod())) {
            throw new WrongMethodException("Method in Link object is not GET");
        }
        Operation operation = new RestClientIO(client, credentials.getHeaders())
                .getOperation(link.getHref());
        logger.debug("getOperation: " + operation);
        return operation;
    }

    /**
     * Waiting operation to stop
     *
     * @see API reference english,
     * russian
     */
    public Operation waitProgress(final Link link, final Runnable waiting)
            throws IOException, WrongMethodException, HttpCodeException {
        while (true) {
            Operation operation = getOperation(link);
            if (!operation.isInProgress()) {
                return operation;
            }
            waiting.run();
        }
    }

    /**
     * Data about a user's Disk
     *
     * @see API reference english,
     * russian
     */
    public DiskInfo getDiskInfo()
            throws IOException, ServerIOException {
        return getDiskInfo(null);
    }

    /**
     * Data about a user's Disk
     *
     * @see API reference english,
     * russian
     */
    public DiskInfo getDiskInfo(final String fields)
            throws IOException, ServerIOException {
        return cloudApi.getDiskInfo(fields);
    }

    /**
     * Metainformation about a file or folder
     *
     * @see API reference english,
     * russian
     */
    public Resource getResources(final ResourcesArgs args)
            throws IOException, ServerIOException {
        final Resource resource = cloudApi.getResources(args.getPath(), args.getFields(),
                args.getLimit(), args.getOffset(), args.getSort(), args.getPreviewSize(),
                args.getPreviewCrop());
        if (args.getParsingHandler() != null) {
            parseListResponse(resource, args.getParsingHandler());
        }
        return resource;
    }

    /**
     * Flat list of all files
     *
     * @see API reference english,
     * russian
     */
    public ResourceList getFlatResourceList(final ResourcesArgs args)
            throws IOException, ServerIOException {
        final ResourceList resourceList = cloudApi.getFlatResourceList(args.getLimit(), args.getMediaType(),
                args.getOffset(), args.getFields(), args.getPreviewSize(), args.getPreviewCrop());
        if (args.getParsingHandler() != null) {
            parseListResponse(resourceList, args.getParsingHandler());
        }
        return resourceList;
    }

    /**
     * Latest uploaded files
     *
     * @see API reference english,
     * russian
     */
    public ResourceList getLastUploadedResources(final ResourcesArgs args)
            throws IOException, ServerIOException {
        final ResourceList resourceList = cloudApi.getLastUploadedResources(args.getLimit(), args.getMediaType(),
                args.getOffset(), args.getFields(), args.getPreviewSize(), args.getPreviewCrop());
        if (args.getParsingHandler() != null) {
            parseListResponse(resourceList, args.getParsingHandler());
        }
        return resourceList;
    }

    /**
     * Latest uploaded files
     *
     * @see API reference english,
     * russian
     */
    public Resource patchResource(final ResourcesArgs args)
            throws ServerIOException, IOException {
        final Resource resource = cloudApi.patchResource(args.getPath(), args.getFields(), args.getBody());
        if (args.getParsingHandler() != null) {
            parseListResponse(resource, args.getParsingHandler());
        }
        return resource;
    }

    /**
     * Metainformation about a public resource
     *
     * @see API reference english,
     * russian
     */
    public Resource listPublicResources(final ResourcesArgs args)
            throws IOException, ServerIOException {
        final Resource resource = cloudApi.listPublicResources(args.getPublicKey(), args.getPath(),
                args.getFields(), args.getLimit(), args.getOffset(), args.getSort(),
                args.getPreviewSize(), args.getPreviewCrop());
        if (args.getParsingHandler() != null) {
            parseListResponse(resource, args.getParsingHandler());
        }
        return resource;
    }

    /**
     * Metainformation about a file or folder in the Trash
     *
     * @see API reference english,
     * russian
     */
    public Resource getTrashResources(final ResourcesArgs args)
            throws IOException, ServerIOException {
        final Resource resource = cloudApi.getTrashResources(args.getPath(), args.getFields(),
                args.getLimit(), args.getOffset(), args.getSort(), args.getPreviewSize(),
                args.getPreviewCrop());
        if (args.getParsingHandler() != null) {
            parseListResponse(resource, args.getParsingHandler());
        }
        return resource;
    }

    /**
     * Cleaning the Trash
     *
     * @see API reference english,
     * russian
     */
    public Link deleteFromTrash(final String path)
            throws IOException, ServerIOException {
        return new RestClientIO(client, credentials.getHeaders())
                .delete(new QueryBuilder(getUrl() + "/v1/disk/trash/resources")
                        .add("path", path)
                        .build());
    }

    /**
     * Restoring a file or folder from the Trash
     *
     * @see API reference english,
     * russian
     */
    public Link restoreFromTrash(final String path, final String name, final Boolean overwrite)
            throws IOException, ServerIOException {
        return new RestClientIO(client, credentials.getHeaders())
                .put(new QueryBuilder(getUrl() + "/v1/disk/trash/resources/restore")
                        .add("path", path)
                        .add("name", name)
                        .add("overwrite", overwrite)
                        .build());
    }

    private void parseListResponse(final Resource resource, final ResourcesHandler handler) {
        handler.handleSelf(resource);
        ResourceList items = resource.getResourceList();
        int size = 0;
        if (items != null) {
            size = items.getItems().size();
            for (Resource item : items.getItems()) {
                handler.handleItem(item);
            }
        }
        handler.onFinished(size);
    }

    private void parseListResponse(final ResourceList resourceList, final ResourcesHandler handler) {
        List items = resourceList.getItems();
        int size = 0;
        if (items != null) {
            size = items.size();
            for (Resource item : items) {
                handler.handleItem(item);
            }
        }
        handler.onFinished(size);
    }

    /**
     * Downloading a file from Disk
     *
     * @see API reference english,
     * russian
     */
    public void downloadFile(final String path, final File saveTo, final ProgressListener progressListener)
            throws IOException, ServerException {
        Link link = cloudApi.getDownloadLink(path);
        new RestClientIO(client, credentials.getHeaders())
                .downloadUrl(link.getHref(), new FileDownloadListener(saveTo, progressListener));
    }

    /**
     * Downloading a file from Disk
     *
     * @see API reference english,
     * russian
     */
    public void downloadFile(final String path, final DownloadListener downloadListener)
            throws IOException, ServerException {
        Link link = cloudApi.getDownloadLink(path);
        new RestClientIO(client, credentials.getHeaders())
                .downloadUrl(link.getHref(), downloadListener);
    }

    /**
     * Uploading a file to Disk from external resource
     *
     * @see API reference english,
     * russian
     */
    public Link saveFromUrl(final String url, final String serverPath)
            throws ServerIOException, IOException {
        return cloudApi.saveFromUrl(url, serverPath);
    }

    /**
     * Uploading a file to Disk: get Link to upload
     *
     * @see API reference english,
     * russian
     */
    public Link getUploadLink(final String serverPath, final boolean overwrite)
            throws ServerIOException, WrongMethodException, IOException {
        Link link = cloudApi.getUploadLink(serverPath, overwrite);
        if (!"PUT".equalsIgnoreCase(link.getMethod())) {
            throw new WrongMethodException("Method in Link object is not PUT");
        }
        return link;
    }

    /**
     * Uploading a file to Disk: upload a file
     *
     * @see API reference english,
     * russian
     */
    public void uploadFile(final Link link, final boolean resumeUpload, final File localSource,
                           final ProgressListener progressListener)
            throws IOException, ServerException {
        RestClientIO clientIO = new RestClientIO(client, credentials.getHeaders());
        long startOffset = 0;
        if (resumeUpload) {
            Hash hash = Hash.getHash(localSource);
            startOffset = clientIO.getUploadedSize(link.getHref(), hash);
            logger.debug("head: startOffset=" + startOffset);
        }
        clientIO.uploadFile(link.getHref(), localSource, startOffset, progressListener);
    }

    /**
     * Deleting a file or folder
     *
     * @see API reference english,
     * russian
     */
    public Link delete(final String path, final boolean permanently)
            throws ServerIOException, IOException {
        return new RestClientIO(client, credentials.getHeaders())
                .delete(new QueryBuilder(getUrl() + "/v1/disk/resources")
                        .add("path", path)
                        .add("permanently", permanently)
                        .build());
    }

    /**
     * Creating a folder
     *
     * @see API reference english,
     * russian
     */
    public Link makeFolder(final String path)
            throws ServerIOException, IOException {
        return cloudApi.makeFolder(path);
    }

    /**
     * Copying a file or folder
     *
     * @see API reference english,
     * russian
     */
    public Link copy(final String from, final String path, final boolean overwrite)
            throws ServerIOException, IOException {
        return cloudApi.copy(from, path, overwrite);
    }

    /**
     * Moving a file or folder
     *
     * @see API reference english,
     * russian
     */
    public Link move(final String from, final String path, final boolean overwrite)
            throws ServerIOException, IOException {
        return cloudApi.move(from, path, overwrite);
    }

    /**
     * Publishing a file or folder
     *
     * @see API reference english,
     * russian
     */
    public Link publish(final String path)
            throws ServerIOException, IOException {
        return cloudApi.publish(path);
    }

    /**
     * Closing access to a resource
     *
     * @see API reference english,
     * russian
     */
    public Link unpublish(final String path)
            throws ServerIOException, IOException {
        return cloudApi.unpublish(path);
    }

    /**
     * Downloading a public file or folder
     *
     * @see API reference english,
     * russian
     */
    public void downloadPublicResource(final String publicKey, final String path, final File saveTo,
                                       final ProgressListener progressListener)
            throws IOException, ServerException {
        Link link = cloudApi.getPublicResourceDownloadLink(publicKey, path);
        new RestClientIO(client, credentials.getHeaders())
                .downloadUrl(link.getHref(), new FileDownloadListener(saveTo, progressListener));
    }

    /**
     * Saving a public file in "Downloads"
     *
     * @see API reference english,
     * russian
     */
    public Link savePublicResource(final String publicKey, final String path, final String name)
            throws IOException, ServerException {
        return cloudApi.savePublicResource(publicKey, path, name);
    }
}