Java DbxEntry类代码示例

import com.dropbox.core.DbxEntry; //导入依赖的package包/类
private DbxEntry.File putSingleFile(File inputFile, String dropboxPath, DropboxUploadMode mode) throws Exception {
    FileInputStream inputStream = new FileInputStream(inputFile);
    DbxEntry.File uploadedFile = null;
    try {
        DbxWriteMode uploadMode = null;
        if (mode == DropboxUploadMode.force) {
            uploadMode = DbxWriteMode.force();
        } else {
            uploadMode = DbxWriteMode.add();
        }
        uploadedFile =
            DropboxAPIFacade.client.uploadFile(dropboxPath,
                        uploadMode, inputFile.length(), inputStream);
        return uploadedFile;
    } finally {
        inputStream.close();
    }
}
 

import com.dropbox.core.DbxEntry; //导入依赖的package包/类
@Override
public boolean isFolder(String child) throws IOException {
    boolean isfolder = false;

    try {
        DbxEntry entry = this.dbClient.getMetadata(child);

        if (entry.isFolder()) {
            isfolder = true;
        }
    } catch (DbxException ex) {
        throw new IOException("Error in folder checking");
    }

    return isfolder;
}
 

import com.dropbox.core.DbxEntry; //导入依赖的package包/类
@Override
public synchronized boolean isLocked(String path) throws CSPApiException {
	try {
		DbxEntry lockFile = client.getMetadata(path
				+ DropboxConstants.LOCK_SUFFIX);
		DbxEntry tempLockFile = client.getMetadata(path
				+ DropboxConstants.TEMP_LOCK_SUFFIX);
		if (lockFile != null) {
			return true;
		} else if (tempLockFile != null) {
			if (new Date().compareTo(tempLockFile.asFile().lastModified) < DropboxConstants.TEMP_LOCK_DURATION) {
				return true;
			} else {
				releaseTemporaryLock(path);
				return false;
			}
		} else {
			return false;
		}
	} catch (DbxException e) {
		throw new CSPApiException(e);
	}
}
 

import com.dropbox.core.DbxEntry; //导入依赖的package包/类
public String upload(File fileToUpload) throws UploadException {
    DbxRequestConfig dconfig = new DbxRequestConfig("sc-java", Locale
            .getDefault().toString());
    DbxClient client = new DbxClient(dconfig, config.getDropboxConfig()
            .getAccessToken());

    DbxEntry.File uploadedFile = null;
    String shareLink = null;
    try (InputStream inputStream = new FileInputStream(fileToUpload);) {
        uploadedFile = client.uploadFile("/" + fileToUpload.getName(),
                DbxWriteMode.add(), fileToUpload.length(), inputStream);
        shareLink = client.createShareableUrl(uploadedFile.path);

    } catch (DbxException | IOException e) {
        throw new UploadException(e);
    }
    return shareLink;
}
 

import com.dropbox.core.DbxEntry; //导入依赖的package包/类
/**
 * Permite subir el fichero de log a una cuenta de Dropbox
 * @throws DbxException
 * @throws IOException
 */

public void subirArchivo() throws DbxException, IOException{
       DbxRequestConfig config = new DbxRequestConfig(
               "JavaTutorial/1.0", Locale.getDefault().toString());
       
       String accessToken = "cGF10uurG7MAAAAAAAAFGGi0UJD9H-TpMKBgESMHV5kDy5jTeF7ou8It1HY8ZFC7";
       
       DbxClient client = new DbxClient(config, accessToken);
       System.out.println("Linked account: " + client.getAccountInfo().displayName);

       FileInputStream inputStream = new FileInputStream(archivoLog);
       try {
           DbxEntry.File uploadedFile = client.uploadFile(
           		"/ArchivoLog_ " + TheHouseOfCrimes.getUsuario() + "_" + TheHouseOfCrimes.getFecha(),
               DbxWriteMode.add(), archivoLog.length(), inputStream);
           System.out.println("Uploaded: " + uploadedFile.toString());
       } finally {
           inputStream.close();
       }
}
 

import com.dropbox.core.DbxEntry; //导入依赖的package包/类
/**
 * @return List with user's files or empty List if error occurs
 */
public List<DbxEntryDto> getDbxTexEntries(DbxClient client) {
    List<DbxEntryDto> dbxEntries = new ArrayList<>();

    if (client == null) {
        return dbxEntries;
    }

    try {
        for (DbxEntry entry : client.searchFileAndFolderNames("/", TEX_EXTENSION)) {
            dbxEntries.add(new DbxEntryDto(entry));
        }
    } catch (DbxException ex) {
        DbxUtil.showDbxAccessDeniedPrompt();
        dbxEntries = new ArrayList<>(); //Empty list
    } finally {
        return dbxEntries;
    }
}
 

import com.dropbox.core.DbxEntry; //导入依赖的package包/类
@Override
public URI[] listFiles(URI uri) {
    DbxEntry.WithChildren dirents = null;
    try {
	dirents = client.getMetadataWithChildren(clean_path(uri));
    } catch(DbxException de) {
	return null;
    }

    if(dirents == null || dirents.children.size() == 0)
	return new URI[]{};
    
    URI[] retval = new URI[dirents.children.size()];
    Iterator<DbxEntry> dirent = dirents.children.iterator();
    int idx = 0;
    while(dirent.hasNext()) {
	DbxEntry entry = dirent.next();
	try {
	    retval[idx++] = new URI("dbx:" + entry.path);
	} catch(URISyntaxException urise) {
	    return null;
	}
    }
    return retval;
}
 

import com.dropbox.core.DbxEntry; //导入依赖的package包/类
public static DbxEntry[] ls(String query, DbxClient client) throws DbxException {
	DbxEntry.WithChildren listing = client.getMetadataWithChildren(query);
       if(listing == null) {
       	return new DbxEntry[]{};
       }
	if(listing.entry.isFile()) {
       	return new DbxEntry[]{listing.entry};
       }
	
	DbxEntry[] dirents = new DbxEntry[listing.children.size()];
	int idx = 0;
	for (DbxEntry child : listing.children) {
           dirents[idx++] = child;
       }
	return dirents;
}
 

import com.dropbox.core.DbxEntry; //导入依赖的package包/类
private DropboxConsumerOperation getConsumerSearch() {
    return new DropboxConsumerOperation() {
        @Override
        public List<Exchange> execute() throws DbxException {
            final List<Exchange> exchanges = new ArrayList<Exchange>();

            final Exchange exchange = endpoint.createExchange();
            final List<DbxEntry> listOfFilesFolders = client.searchFileAndFolderNames(endpoint.getPath(), endpoint.getQuery());
            exchange.getIn().setHeader("searchResult", "List<DbxEntry>");
            exchange.getIn().setBody(listOfFilesFolders);

            exchanges.add(exchange);
            return exchanges;
        }
    };
}
 

import com.dropbox.core.DbxEntry; //导入依赖的package包/类
private DropboxProducerOperation getProducerGet() {
    return new DropboxProducerOperation() {
        @Override
        public void execute(final Exchange exchange) throws DbxException, IOException {
            final List<DbxEntry> body = (List<DbxEntry>) exchange.getIn().getBody();

            String path = null;
            if (body != null) {
                final DbxEntry dbxEntry = body.get(0);
                endpoint.setPath(dbxEntry.path);
                path = dbxEntry.path;
            } else {
                path = endpoint.getPath();
            }
            final ByteArrayOutputStream baos = new ByteArrayOutputStream();
            client.getFile(path, null, baos);
            
            final String[] pathArray = path.split("/");
            exchange.getIn().setHeader(Exchange.FILE_NAME, pathArray[pathArray.length - 1]);
            exchange.getIn().setBody(baos);
        }
    };
}
 

import com.dropbox.core.DbxEntry; //导入依赖的package包/类
@Override
public FileInstanceAbstract[] listFilesAndDirectories() throws URISyntaxException, IOException {
	try {
		DbxClient dbxClient = connect();
		DbxEntry.WithChildren entries;
		entries = dbxClient.getMetadataWithChildren(getPath());
		if (entries == null || entries.children == null)
			return null;
		FileInstanceAbstract[] fileInstances = new FileInstanceAbstract[entries.children.size()];
		int i = 0;
		for (DbxEntry entry : entries.children)
			fileInstances[i++] = new DropboxFileInstance(filePathItem, this, entry);
		return fileInstances;
	} catch (DbxException e) {
		throw new IOException(e);
	}
}
 

import com.dropbox.core.DbxEntry; //导入依赖的package包/类
private void importFilesFromDropbox(DbxEntry entry, String bcIdentifier, DbxClient client) throws Exception {
	String fileName = entry.name;
	if (null != fileName) {
		int indexOfDot = fileName.indexOf('.');
		if (-1 != indexOfDot) {
			BatchClass batchClass = batchClassService.getBatchClassByIdentifier(bcIdentifier);

			if (batchClass != null) {
				String uncFolder = batchClassService.getBatchClassByIdentifier(bcIdentifier).getUncFolder();
				String destinationFolder = EphesoftStringUtil.concatenate(new Object[] { uncFolder, File.separator, fileName.substring(0, indexOfDot), Character.valueOf('_'),
						Long.valueOf(System.currentTimeMillis()) });
				String destinationFile = EphesoftStringUtil.concatenate(new String[] { destinationFolder, File.separator, fileName });

				File folder = new File(destinationFolder);
				if (!folder.exists())
					folder.mkdir();

				FileOutputStream outputStream = new FileOutputStream(destinationFile);
				client.getFile(entry.path, null, outputStream);
			} else
				LOGGER.debug(bcIdentifier + " doesn't exist.");
		}
	}
}
 

import com.dropbox.core.DbxEntry; //导入依赖的package包/类
@Override
protected final void call(final DbxClient client, final ProgressMonitor pm) throws DbxException {
    final Iterable<DbxEntry> entries;
    pm.begin(1);
    if (list) {
        if (hash == null) {
            entries = from(client.getMetadataWithChildren(path));
        } else {
            final Maybe<WithChildren> metadata = client.getMetadataWithChildrenIfChanged(path, hash);
            entries = metadata.isNothing() ? Collections.<DbxEntry> emptyList() : from(metadata.getJust());
        }
    } else {
        entries = singletonList(client.getMetadata(path));
    }
    for (final DbxEntry entry : entries) {
        getLog().info(entry.toString());
    }
}
 

import com.dropbox.core.DbxEntry; //导入依赖的package包/类
/**
 * Object payload contained in Exchange
 * Exchange Header is populated with the remote paths found.
 * Exchange Body is populated with the list of DbxEntry found.
 * @param exchange
 */
@Override
public void populateExchange(Exchange exchange) {
    StringBuffer fileExtracted = new StringBuffer();
    List<DbxEntry> entries = null;
    if (resultEntries != null) {
        entries = (List<DbxEntry>) resultEntries;
        for (DbxEntry entry : entries) {
            fileExtracted.append(entry.name + "-" + entry.path + "\n");
        }
    }
    exchange.getIn().setHeader(DropboxResultHeader.FOUNDED_FILES.name(), fileExtracted.toString());
    exchange.getIn().setBody(entries);
}
 

import com.dropbox.core.DbxEntry; //导入依赖的package包/类
private void collectDropboxEntries(DbxClient client, Map<String, Long> dropboxEntries, String path) throws DbxException {
	WithChildren entries = client.getMetadataWithChildren(path);
	for (DbxEntry entry : entries.children) {
		if (entry.isFolder()) {
			collectDropboxEntries(client, dropboxEntries, entry.path);
		} else {
			dropboxEntries.put(entry.path, entry.asFile().lastModified.getTime());
		}
	}
}