Examples with DbxException com.dropbox.core.DbxException used on opensource projects

Example 16 with DbxException

use of com.dropbox.core.DbxException in project dropbox-sdk-java by dropbox.

the class UploadFileTask method doInBackground.

@Override
protected FileMetadata doInBackground(String... params) {
    String localUri = params[0];
    File localFile = UriHelpers.getFileForUri(mContext, Uri.parse(localUri));
    if (localFile != null) {
        String remoteFolderPath = params[1];
        // Note - this is not ensuring the name is a valid dropbox file name
        String remoteFileName = localFile.getName();
        try (InputStream inputStream = new FileInputStream(localFile)) {
            return mDbxClient.files().uploadBuilder(remoteFolderPath + "/" + remoteFileName).withMode(WriteMode.OVERWRITE).uploadAndFinish(inputStream);
        } catch (DbxException | IOException e) {
            mException = e;
        }
    }
    return null;
}

Example 17 with DbxException

use of com.dropbox.core.DbxException in project openhab1-addons by openhab.

the class DropboxSynchronizer method downloadFile.

private void downloadFile(DbxClient client, Entry<DbxEntry> entry) throws DbxException, IOException {
    String fqPath = contentDir + entry.metadata.path;
    File newLocalFile = new File(fqPath);
    if (entry.metadata.isFolder()) {
        // create intermediary directories
        boolean success = newLocalFile.mkdirs();
        if (!success) {
            logger.debug("Didn't create any intermediary directories for '{}'", fqPath);
        }
    } else {
        // directorys ...
        if (!newLocalFile.getParentFile().exists()) {
            newLocalFile.getParentFile().mkdirs();
        }
        try {
            FileOutputStream os = new FileOutputStream(newLocalFile);
            if (!fakeMode) {
                client.getFile(entry.metadata.path, null, os);
            }
            logger.debug("Successfully downloaded file '{}'", fqPath);
        } catch (FileNotFoundException fnfe) {
            throw new DbxException("Couldn't write file '" + fqPath + "'", fnfe);
        }
        long lastModified = entry.metadata.asFile().lastModified.getTime();
        boolean success = newLocalFile.setLastModified(lastModified);
        if (!success) {
            logger.debug("Couldn't change attribute 'lastModified' of file '{}'", fqPath);
        }
    }
}

Example 18 with DbxException

use of com.dropbox.core.DbxException in project camel by apache.

the class DropboxAPIFacade method downloadFilesInFolder.

private Map<String, Object> downloadFilesInFolder(String path) throws DropboxException {
    try {
        DbxEntry.WithChildren listing = client.getMetadataWithChildren(path);
        if (listing == null) {
            return Collections.emptyMap();
        } else if (listing.children == null) {
            LOG.debug("downloading a single file...");
            Map.Entry<String, Object> entry = downloadSingleFile(path);
            return Collections.singletonMap(entry.getKey(), entry.getValue());
        }
        Map<String, Object> result = new HashMap<>();
        for (DbxEntry entry : listing.children) {
            if (entry.isFile()) {
                try {
                    Map.Entry<String, Object> singleFile = downloadSingleFile(entry.path);
                    result.put(singleFile.getKey(), singleFile.getValue());
                } catch (DropboxException e) {
                    LOG.warn("Cannot download from path={}, reason={}. This exception is ignored.", entry.path, e.getMessage());
                }
            } else {
                Map<String, Object> filesInFolder = downloadFilesInFolder(entry.path);
                result.putAll(filesInFolder);
            }
        }
        return result;
    } catch (DbxException e) {
        throw new DropboxException(e);
    }
}

Example 19 with DbxException

use of com.dropbox.core.DbxException in project camel by apache.

the class DropboxAPIFacade method downloadSingleFile.

private Map.Entry<String, Object> downloadSingleFile(String path) throws DropboxException {
    try {
        OutputStreamBuilder target = OutputStreamBuilder.withExchange(exchange);
        DbxEntry.File downloadedFile = client.getFile(path, null, target);
        if (downloadedFile != null) {
            LOG.debug("downloaded path={}", path);
            return new AbstractMap.SimpleEntry<>(path, target.build());
        } else {
            return null;
        }
    } catch (DbxException e) {
        throw new DropboxException(path + " does not exist or can't obtain metadata");
    } catch (IOException e) {
        throw new DropboxException(path + " can't obtain a stream");
    }
}

Example 20 with DbxException

use of com.dropbox.core.DbxException in project camel by apache.

the class DropboxAPIFacade method put.

/**
     * Put or upload a new file or an entire directory to dropbox
     * @param localPath  the file path or the dir path on the local filesystem
     * @param remotePath the remote path destination on dropbox
     * @param mode how a file should be saved on dropbox;
     *             in case of "add" the new file will be renamed in case
     *             a file with the same name already exists on dropbox.
     *             in case of "force" the file already existing with the same name will be overridden.
     * @return a result object reporting for each remote path the result of the operation.
     * @throws DropboxException
     */
public DropboxFileUploadResult put(String localPath, String remotePath, DropboxUploadMode mode) throws DropboxException {
    //in case the remote path is not specified, the remotePath = localPath
    String dropboxPath = remotePath == null ? localPath : remotePath;
    DbxEntry entry;
    try {
        entry = client.getMetadata(dropboxPath);
    } catch (DbxException e) {
        throw new DropboxException(dropboxPath + " does not exist or can't obtain metadata");
    }
    File fileLocalPath = new File(localPath);
    //verify uploading of a single file
    if (fileLocalPath.isFile()) {
        //check if dropbox file exists
        if (entry != null && !entry.isFile()) {
            throw new DropboxException(dropboxPath + " exists on dropbox and is not a file!");
        }
        //in case the entry not exists on dropbox check if the filename should be appended
        if (entry == null) {
            if (dropboxPath.endsWith(DROPBOX_FILE_SEPARATOR)) {
                dropboxPath = dropboxPath + fileLocalPath.getName();
            }
        }
        DropboxFileUploadResult result;
        try {
            DbxEntry.File uploadedFile = putSingleFile(fileLocalPath, dropboxPath, mode);
            if (uploadedFile == null) {
                result = new DropboxFileUploadResult(dropboxPath, DropboxResultCode.KO);
            } else {
                result = new DropboxFileUploadResult(dropboxPath, DropboxResultCode.OK);
            }
        } catch (Exception ex) {
            result = new DropboxFileUploadResult(dropboxPath, DropboxResultCode.KO);
        }
        return result;
    } else {
        //verify uploading of a list of files inside a dir
        LOG.debug("Uploading a dir...");
        //check if dropbox folder exists
        if (entry != null && !entry.isFolder()) {
            throw new DropboxException(dropboxPath + " exists on dropbox and is not a folder!");
        }
        if (!dropboxPath.endsWith(DROPBOX_FILE_SEPARATOR)) {
            dropboxPath = dropboxPath + DROPBOX_FILE_SEPARATOR;
        }
        //revert to old path
        String oldDropboxPath = dropboxPath;
        //list all files in a dir
        Collection<File> listFiles = FileUtils.listFiles(fileLocalPath, null, true);
        if (listFiles.isEmpty()) {
            throw new DropboxException(localPath + " doesn't contain any files");
        }
        HashMap<String, DropboxResultCode> resultMap = new HashMap<>(listFiles.size());
        for (File file : listFiles) {
            String absPath = file.getAbsolutePath();
            int indexRemainingPath = localPath.length();
            if (!localPath.endsWith("/")) {
                indexRemainingPath += 1;
            }
            String remainingPath = absPath.substring(indexRemainingPath);
            dropboxPath = dropboxPath + remainingPath;
            try {
                LOG.debug("Uploading: {},{}", fileLocalPath, dropboxPath);
                DbxEntry.File uploadedFile = putSingleFile(file, dropboxPath, mode);
                if (uploadedFile == null) {
                    resultMap.put(dropboxPath, DropboxResultCode.KO);
                } else {
                    resultMap.put(dropboxPath, DropboxResultCode.OK);
                }
            } catch (Exception ex) {
                resultMap.put(dropboxPath, DropboxResultCode.KO);
            }
            dropboxPath = oldDropboxPath;
        }
        return new DropboxFileUploadResult(resultMap);
    }
}