How to use dropbox - 10 common examples

function uploadPhoto(api: {dropboxAccessToken: string}, identityIndex: number,
  identityAddress: string, photoFile: any, photoIndex: number): Promise<*> {
  const dbx = new Dropbox({ accessToken: api.dropboxAccessToken })
  const path = getAvatarPath(identityIndex, identityAddress, photoIndex)
  return new Promise((resolve, reject) => dbx.filesUpload({ path, contents: photoFile })
  .then((response) => {
    dbx.sharingCreateSharedLinkWithSettings({ path: response.path_lower, settings: {} })
    .then((shareLinkResponse) => {
      /* Appending dropbox share url with ?dl=1 returns the actual file
      instead of dropbox sign up page */
      const avatarUrl = `${shareLinkResponse.url.split('=')[0]}=1`

      resolve(avatarUrl)
    })
    .catch((error) => {
      reject(error)
    })
  })
  .catch((error) => {

info(req, function(err, info, new_client){

        if (err) return next(err);

        var old_client = new Dropbox.Client(config.dropbox);

        old_client.setCredentials(req.session.old_credentials);

        // Remove the old credentials
        // This must happen before res.render
        // or the session will not be saved...
        req.session.old_credentials = null;

        res.addLocals({dropbox_email: info.email});

        res.title('Copy your files');
        res.renderDashboard('folder/copy-files');

        old_client.authenticate(function(err, old_client){

          if (err) console.log(err);

var FFTokenRejected = errorTypes.FFTokenRejected;
                    return new FFTokenRejected('User token has expired');

                case Dropbox.ApiError.NOT_FOUND:
                    // The file or folder you tried to access is not in the user's Dropbox.
                    // Handling this error is specific to your application.
                    var FFItemDoesNotExist = errorTypes.FFItemDoesNotExist;
                    return new FFItemDoesNotExist();

                case Dropbox.ApiError.OVER_QUOTA:
                    // The user is over their Dropbox quota.
                    // Tell them their Dropbox is full. Refreshing the page won't help.
                    var FFOverQuota = errorTypes.FFOverQuota
                    return new FFOverQuota();

                case Dropbox.ApiError.RATE_LIMITED:
                    // Too many API requests. Tell the user to try again later.
                    // Long-term, optimize your code to use fewer API calls.
                    var FFRateLimit = errorTypes.FFRateLimit;
                    return new FFRateLimit();

                case Dropbox.ApiError.NETWORK_ERROR:
                    // An error occurred at the XMLHttpRequest layer.
                    // Most likely, the user's network connection is down.
                    // API calls will not succeed until the user gets back online.
                    return error;

                case Dropbox.ApiError.INVALID_PARAM:
                    var FFParameterRejected = errorTypes.FFParameterRejected
                    return new FFParameterRejected();
                case Dropbox.ApiError.OAUTH_ERROR:
                    var FFTokenRejected = errorTypes.FFTokenRejected

export default ({ apiKey = null, client = null } = {}) => {
    if (!client && typeof apiKey === 'string') {
        client = new Dropbox({
            accessToken: apiKey
        });
    } else if (!client) {
        throw new Error('Dropbox client or apiKey should be provided.');
    }

    const api = {
        // fs adapter type (for downstream integrations)
        [TYPE_KEY]: 'dropbox-fs',

        /**
         * Read a directory and list all the files and folders inside
         *
         * @param {String} remotePath
         * @param {Object} options
         * @param {Function} callback

var router = require('express').Router();
var request = require('request');
var parser = require('body-parser');
var bcrypt = require('bcrypt-nodejs');
var moment = require('moment');
var Dropbox = require('dropbox');
var Twitter = require('twitter');

// Dropbox Setup for server-based Authentication
var dropboxOptions = process.env.dropbox || require('./config.js').dropbox;
var client = new Dropbox.Client({ key: "yhintvoqspu0w44", secret: dropboxOptions });

// Twitter Setup
var twitterOptions;
if(process.env.dropbox === undefined){
  twitterOptions = require('./config.js').twitter;
} else {
  twitterOptions = {
    consumer_key: process.env.twitter_consumer_key,
    consumer_secret: process.env.twitter_consumer_secret,
    access_token_key: process.env.twitter_access_token_key,
    access_token_secret: process.env.twitter_access_token_secret
  };
}
var twitterClient = new Twitter(twitterOptions);

// Database Requirements

function saveToDropBox (file, name, user) {
  log('actually saving it now');
  var client = new Dropbox.Client({
    key: options.id,
    secret: options.secret,
    token: user.dropbox_token // jshint ignore:line
  });

  client.writeFile(name, file, function (err) {
    if (err) {
      process.send({
        error: err,
        user: user
      });
    }
    log('saved!');
  });

}

}
            });
        });
        version = "v1";
    }

    // Upgrade from v1 to v2
    if(version == "v1") {
        var gdriveLastChangeId = localStorage["sync.gdrive.lastChangeId"];
        if(gdriveLastChangeId) {
            localStorage["gdrive.lastChangeId"] = gdriveLastChangeId;
            localStorage.removeItem("sync.gdrive.lastChangeId");
        }
        var dropboxLastChangeId = localStorage["sync.dropbox.lastChangeId"];
        if(dropboxLastChangeId) {
            localStorage["dropbox.lastChangeId"] = dropboxLastChangeId;
            localStorage.removeItem("sync.dropbox.lastChangeId");
        }

        var PROVIDER_GDRIVE = "gdrive";
        var PROVIDER_DROPBOX = "dropbox";
        var SYNC_PROVIDER_GDRIVE = "sync." + PROVIDER_GDRIVE + ".";
        var SYNC_PROVIDER_DROPBOX = "sync." + PROVIDER_DROPBOX + ".";
        _.each(fileIndexList, function(fileIndex) {
            var syncIndexList = utils.retrieveIndexArray(fileIndex + ".sync");
            _.each(syncIndexList, function(syncIndex) {
                var syncAttributes = {};
                if(syncIndex.indexOf(SYNC_PROVIDER_GDRIVE) === 0) {
                    syncAttributes.provider = PROVIDER_GDRIVE;
                    syncAttributes.id = syncIndex.substring(SYNC_PROVIDER_GDRIVE.length);
                    syncAttributes.etag = localStorage[syncIndex + ".etag"];
                    syncAttributes.contentCRC = localStorage[syncIndex + ".contentCRC"];

// Added : Kosso : log out of dropbox
// REQUIRES https://github.com/kosso/TiCookiejar v0.1
var cookiejar = require('com.kosso.cookiejar');
var logout = function() {
	cookiejar.clearWebViewCookies('.dropbox.com');
	Ti.App.Properties.setString('DROPBOX_TOKENS', null);
}


var dropbox = require('dropbox');


var client = dropbox.createClient({
	app_key : 'xxxxxxxxxxxxxxxxxxxx', // <--- you'll want to replace this
	app_secret : 'xxxxxxxxxxxxxxxxx', // <--- and this with your own keys!
	root : "dropbox"                  // optional (defaults to sandbox)
});

// see : https://www.dropbox.com/developers/apps

var getAccount = function() {

	var options = {
	};
	client.account(options, function(status, reply) {
		Ti.API.info(status);
		Ti.API.info(reply);
	});
};

downloadImages() {
    console.log('download\t', 'connecting to dropbox');
    new Dropbox({
        fetch: fetch,
        accessToken: this.dropBoxAccessToken
      })
      .filesListFolder({
        path: this.dropBoxPath,
      })
      .then((response) => {
        this._pending = response.entries.length;
        if (this.pending) {
          this.explode(response.entries);
        } else {
          this.emit('complete', {
            status: 'complete'
          });
        }
      })

}
  } else {
    returnedObject = {};
  }
  
  //Now, if there is an error with fetching localData we need to do a few things:
  //1: Grab the accessToken for the storage provider and use that to make the request.
  //2: If the token is expire, we need to provide a refreshToken and get a new access & refresh token.
  //3: If we got new tokens, we need to store those.
  //4: Fetch the appropriate file.
  //TODO: It would probably be smart to use IPFS as a fallback in case of file overwriting or something drastic.
  if (!returnedObject.data) {
    //Dropbox
    if (params.provider === "dropbox") {
      //Creating a Dropbox constructor with params from the method call.
      const dbx = new Dropbox({
        accessToken: params.token,
        fetch: fetch
      });
      //Make the Dropbox call here and return it to the file that's calling this function.
      return dbx
        .filesDownload({ path: params.filePath })
        .then(response => {
          console.log(response)
          return response;
        })
        .catch(error => {
          console.log(error);
          return "error fetching file";
        });
    } else if(params.provider === 'google') {
      //First we need to use the refreshToken to get a new access token.