def __init__(self):
session = DropboxSession(settings.DROPBOX_CONSUMER_KEY,
settings.DROPBOX_CONSUMER_SECRET,
settings.DROPBOX_ACCESS_TYPE, locale=None)
session.set_token(settings.DROPBOX_ACCESS_TOKEN,
settings.DROPBOX_ACCESS_TOKEN_SECRET)
self.client = DropboxClient(session)
def __init__(self, location='/Public'):
session = DropboxSession(CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TYPE, locale=None)
session.set_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
self.client = DropboxClient(session)
self.account_info = self.client.account_info()
self.location = location
self.base_url = 'http://dl.dropbox.com/u/{uid}/'.format(**self.account_info)
class DropboxAPIFacade(object): is_setup = False """Easy to use facade for the Dropbox API and database Provides full functionality to use the Dropbox API. It saves and retrieves access/request tokens automatically from the database. The API session gets fed with the right data from the database when it needs it. """ def __init__(self, autostart): """Creates the instance and sets up all data and session if autostart""" if autostart: self.setup() def setup(self): """Retrieves all startup data and creates a new DropboxClient with it""" (access_key, access_secret) = dropbox_access.get_access_token() self.session = DropboxSession(DROPBOX_APP_KEY, DROPBOX_APP_SECRET, DROPBOX_ACCESS_TYPE) self.session.obtain_request_token() self.session.set_token(access_key, access_secret) self.client = DropboxClient(self.session) self.is_setup = True def get_account(self): """Retrieves the account information from the Dropbox API""" try: return self.client.account_info() except ErrorResponse, e: return None
def __init__(self):
session = DropboxSession(settings.DROPBOX_CONSUMER_KEY,
settings.DROPBOX_CONSUMER_SECRET,
settings.DROPBOX_ACCESS_TYPE,
locale=None)
session.set_token(settings.DROPBOX_ACCESS_TOKEN,
settings.DROPBOX_ACCESS_TOKEN_SECRET)
self.client = DropboxClient(session)
def post(self, request):
try:
result = {}
path = request.POST["source_path"]
session_id = request.POST["session_id"]
user_id = get_user_from_session(session_id).id
dest_path = request.POST["dest_path"]
dest_path = dest_path.split("/")
dest_path.append(str(user_id))
dest_path[-1], dest_path[-2] = dest_path[-2], dest_path[-1]
dest_path = "/".join(dest_path)
print "dest_path at starting is ", dest_path
try:
# Increment the name of new directory by one
directories = map(int, os.listdir(dest_path))
dest_path += str(max(directories) + 1)
except:
# If no directory exists then give it name 1
dest_path += "/" + "1"
if dest_path[-1] != "/":
# Append forward slash to given url if not exists
dest_path += "/"
if not os.path.isdir(dest_path):
os.makedirs(dest_path)
if path.split(":")[0].lower() == "s3":
print "[DOWNLOAD API FOR S3]"
bucket = path.split(":")[1][2:]
source_path = str(path.split(":")[2])
result = get_data_from_s3(request, source_path, dest_path, bucket, user_id)
elif path.split(":")[0].lower() == "dropbox":
print "[DOWNLOAD API FOR DROPBOX]"
source_path = path.split(":")[1][1:]
access_token = SocialToken.objects.get(account__user__id=user_id, app__name="Dropbox")
session = DropboxSession(settings.DROPBOX_APP_KEY, settings.DROPBOX_APP_SECRET)
access_key, access_secret = (
access_token.token,
access_token.token_secret,
) # Previously obtained OAuth 1 credentials
session.set_token(access_key, access_secret)
client = DropboxClient(session)
token = client.create_oauth2_access_token()
print "########### ok ###########"
result = get_data_from_dropbox(request, source_path, dest_path, token, user_id)
elif path.split(":")[0].lower() == "gdrive":
# NON FUNCTIONAL
get_data_from_google(request, path, access_token)
else:
shutil.rmtree(dest_path[:-1])
result = {
"error": "Check if you have attached the type of cloud storage with your account or enter valid path"
}
except:
shutil.rmtree(dest_path[:-1])
result = {"error": "Invalid Input Provided"}
print result
return HttpResponse(json.dumps(result))
def obj_create(self, bundle, request=None, **kwargs):
response = super(ProjectResource, self).obj_create(bundle, request, **kwargs)
user_profile = UserProfile.objects.get(user=request.user)
if user_profile.is_dropbox_synced:
sess = DropboxSession(settings.DROPBOX_AUTH_KEY, settings.DROPBOX_AUTH_SECRET, access_type=settings.DROPBOX_ACCESS_TYPE)
sess.set_token(user_profile.dropbox_profile.access_token['key'], user_profile.dropbox_profile.access_token['secret'])
api_client = client.DropboxClient(sess)
api_client.file_create_folder(response.obj.title)
return response
def __init__(self, token, rootPath):
BaseDrive.__init__(self, token, rootPath)
APP_KEY = '5a91csqjtsujuw7'
APP_SECRET = 'x5wbkk2o273jqz7'
session = DropboxSession(APP_KEY, APP_SECRET)
print token
access_key, access_secret = token.split(',')
session.set_token(access_key, access_secret)
first_client = DropboxClient(session)
token1 = first_client.create_oauth2_access_token()
self.client = DropboxClient(token1)
def __init__(self, location='/Public'):
session = DropboxSession(CONSUMER_KEY,
CONSUMER_SECRET,
ACCESS_TYPE,
locale=None)
session.set_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
self.client = DropboxClient(session)
self.account_info = self.client.account_info()
self.location = location
self.base_url = 'http://dl.dropbox.com/u/{uid}/'.format(
**self.account_info)
def post(self, request):
source_path = request.POST["source_path"]
path = request.POST["dest_path"]
session_id = request.POST["session_id"]
user_id = get_user_from_session(session_id).id
try:
if path.split(":")[0].lower() == "s3":
print "[UPLOAD API FOR S3]"
bucket = path.split(":")[1][2:]
dest_path = str(path.split(":")[2])
result = post_data_on_s3(request, source_path, dest_path, bucket, user_id)
elif path.split(":")[0].lower() == "dropbox":
print "[UPLOAD API FOR DROPBOX]"
dest_path = path.split(":")[1][1:]
access_token = SocialToken.objects.get(account__user__id=user_id, app__name="Dropbox")
session = DropboxSession(settings.DROPBOX_APP_KEY, settings.DROPBOX_APP_SECRET)
access_key, access_secret = (
access_token.token,
access_token.token_secret,
) # Previously obtained OAuth 1 credentials
session.set_token(access_key, access_secret)
client = DropboxClient(session)
token = client.create_oauth2_access_token()
result = post_data_on_dropbox(request, source_path, dest_path, token, user_id)
elif path.split(":")[0].lower() == "gdrive":
"""*** NOT WORKING ***"""
print "[UPLOAD API FOR GOOGLE DRIVE]"
storage = Storage(SocialToken, "id", user_id, "token")
credential = storage.get()
# credentials = SocialToken.objects.get(account__user__id = request.user.id, app__name = storage)
# credentials = credentials.token
http = credential.authorize(httplib2.Http())
service = discovery.build("drive", "v2", http=http)
results = service.files().list(maxResults=10).execute()
items = results.get("items", [])
if not items:
# print 'No files found.'
pass
else:
# print 'Files:'
for item in items:
print "{0} ({1})".format(item["title"], item["id"])
result = put_data_on_google_drive(request, path, access_token.token)
else:
result = {
"error": "Check if you have attached the type of cloud storage with your account or enter valid path"
}
except:
result = {"error": "Incorrect Input"}
return HttpResponse(json.dumps(result))
def __init__(self, file, name=None):
self.dropbox_metadata = file
name = name or os.path.basename(self.dropbox_metadata["path"])
super(DropboxFile, self).__init__(file, name=name)
self._size = self.dropbox_metadata["size"]
access_type = getattr(settings, "DROPBOX_ACCESS_TYPE", "app_folder")
dropbox_session = DropboxSession(settings.DROPBOX_APP_KEY,
settings.DROPBOX_APP_SECRET_KEY,
access_type)
dropbox_session.set_token(settings.DROPBOX_APP_ACCESS_TOKEN,
settings.DROPBOX_APP_ACCESS_TOKEN_SECRET)
self.dropbox_client = DropboxClient(dropbox_session)
def __init__(self, *args, **kwargs):
super(DropboxFileUploadHandler, self).__init__(*args, **kwargs)
fallback_dropbox_folder = getattr(settings,
"DROPBOX_FILE_UPLOAD_FOLDER", "/")
self.dropbox_folder = kwargs.get("dropbox_folder",
fallback_dropbox_folder)
access_type = getattr(settings, "DROPBOX_ACCESS_TYPE", "app_folder")
dropbox_session = DropboxSession(settings.DROPBOX_APP_KEY,
settings.DROPBOX_APP_SECRET_KEY,
access_type)
dropbox_session.set_token(settings.DROPBOX_APP_ACCESS_TOKEN,
settings.DROPBOX_APP_ACCESS_TOKEN_SECRET)
self.dropbox_client = DropboxClient(dropbox_session)
def get_userinfo(self):
"""
{u'referral_link': u'https://db.tt/LbG4aSx1', u'display_name': u'waiting easilydo', u'uid': 330936854, u'country': u'HK', u'email': u'*****@*****.**', u'team': None, u'quota_info': {u'datastores': 0, u'shared': 0, u'quota': 2147483648, u'normal': 363213}}
"""
sess = DropboxSession(self.client_id, self.client_secret, self.ACCESS_TYPE)
sess.set_token(self.token['oauth_token'], self.token['oauth_token_secret'])
api = DropboxClient(sess)
try:
res = api.account_info()
return res
except Exception, e:
logging.warning("dropbox query info fail %s", e, exc_info=True)
return None
def _create_generic_session(rest_client,
consumer_key='a',
consumer_secret='b',
access_type='app_folder'):
return DropboxSession(consumer_key,
consumer_secret,
access_type,
rest_client=rest_client)
def connect(self, query):
sess = DropboxSession(self.app_key, self.app_secret, "app_folder")
# Access token is saved to memcache and the filesystem
s_token = self.cache.get("s_token") or read_file(".s_token")
s_secret = self.cache.get("s_secret") or read_file(".s_secret")
if s_token and s_secret:
sess.set_token(s_token, s_secret)
elif "oauth_token" in query: # callback from Dropbox
s_token = sess.obtain_access_token(
dropbox.session.OAuthToken(self.cache.get("r_token"),
self.cache.get("r_token_secret")))
self.cache.set("s_token", s_token.key)
self.cache.set("s_secret", s_token.secret)
with open(".s_token", "w") as f:
f.write(s_token.key)
with open(".s_secret", "w") as f:
f.write(s_token.secret)
self.cache.delete("r_token")
self.cache.delete("r_token_secret")
else: # start of Dropbox auth
req_token = sess.obtain_request_token()
self.cache.set("r_token", req_token.key)
self.cache.set("r_token_secret", req_token.secret)
url = sess.build_authorize_url(req_token, cherrypy.url())
raise cherrypy.HTTPRedirect(url)
self.client = DropboxClient(sess)
def __init__(self, connection_name='default', location='/Public'):
connection = settings.DROPBOXES.get(connection_name, None)
if not connection:
raise ImproperlyConfigured("Could not load Dropbox Config '%s'" % connection_name)
CONSUMER_KEY = connection.get('CONSUMER_KEY', None)
CONSUMER_SECRET = connection.get('CONSUMER_SECRET', None)
ACCESS_TOKEN = connection.get('ACCESS_TOKEN', None)
ACCESS_TOKEN_SECRET = connection.get('ACCESS_TOKEN_SECRET', None)
ACCESS_TYPE = connection.get('ACCESS_TYPE', None)
session = DropboxSession(CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TYPE, locale=None)
session.set_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
self.client = DropboxClient(session)
self.account_info = self.client.account_info()
self.location = location
self.base_url = 'http://dl.dropbox.com/u/{uid}/'.format(**self.account_info)
def session(self):
"""
Initialize or return already initialized ``DropboxSession`` instance.
"""
if not hasattr(self.cache_storage, SESSION_CACHE_KEY):
session = DropboxSession(self.DROPBOX_KEY, self.DROPBOX_SECRET,
self.DROPBOX_ACCESS_TYPE)
setattr(self.cache_storage, SESSION_CACHE_KEY, session)
return getattr(self.cache_storage, SESSION_CACHE_KEY)
def setup(self): """Retrieves all startup data and creates a new DropboxClient with it""" (access_key, access_secret) = dropbox_access.get_access_token() self.session = DropboxSession(DROPBOX_APP_KEY, DROPBOX_APP_SECRET, DROPBOX_ACCESS_TYPE) self.session.obtain_request_token() self.session.set_token(access_key, access_secret) self.client = DropboxClient(self.session) self.is_setup = True
def connectDropbox():
sess = DropboxSession(APP_KEY, APP_SECRET, ACCESS_TYPE)
if os.path.exists(TOKENS):
token_file = open(TOKENS)
token_key, token_secret = token_file.read().split('|')
token_file.close()
sess.set_token(token_key, token_secret)
else:
request_token = sess.obtain_request_token()
url = sess.build_authorize_url(request_token)
# Make the user sign in and authorize this token
print "url:", url
print "Please visit this website and press the 'Allow' button, then hit 'Enter' here."
raw_input()
# This will fail if the user didn't visit the above URL and hit 'Allow'
access_token = sess.obtain_access_token(request_token)
# Save the key to the file so we don't need to do this again
token_file = open(TOKENS, 'w')
token_key = access_token.key
token_secret = access_token.secret
token_file.write("%s|%s" % (token_key, token_secret))
token_file.close()
client = DropboxClient(sess)
print "Linked account: %s" % client.account_info()
return client
def connect(self, query):
sess = DropboxSession(self.app_key, self.app_secret, "app_folder")
# Access token is saved to memcache and the filesystem
s_token = self.cache.get("s_token") or read_file(".s_token")
s_secret = self.cache.get("s_secret") or read_file(".s_secret")
if s_token and s_secret:
sess.set_token(s_token, s_secret)
elif "oauth_token" in query: # callback from Dropbox
s_token = sess.obtain_access_token(dropbox.session.OAuthToken(
self.cache.get("r_token"), self.cache.get("r_token_secret")))
self.cache.set("s_token", s_token.key)
self.cache.set("s_secret", s_token.secret)
with open(".s_token", "w") as f:
f.write(s_token.key)
with open(".s_secret", "w") as f:
f.write(s_token.secret)
self.cache.delete("r_token")
self.cache.delete("r_token_secret")
else: # start of Dropbox auth
req_token = sess.obtain_request_token()
self.cache.set("r_token", req_token.key)
self.cache.set("r_token_secret", req_token.secret)
url = sess.build_authorize_url(req_token, cherrypy.url())
raise cherrypy.HTTPRedirect(url)
self.client = DropboxClient(sess)
def __init__(self, in_user_mode=True):
"""Connect to the Dropbox servers so that files can be uploaded"""
self.m = Message(in_user_mode=in_user_mode)
session = DropboxSession(API_KEY, API_SECRET, self.ACCESS_TYPE)
token_file = PyJson(TOKEN_PATH)
token = token_file.doc
# If there is a token saved, that can be used to connect with Dropbox
if 'key' in token and 'secret' in token:
# Read the token and authenticate the session with it
session.set_token(token['key'], token['secret'])
# Otherwise it is necessary to authenticate for the first time
else:
# Request an access token
request_token = session.obtain_request_token()
url = session.build_authorize_url(request_token)
# Open the authentication page in the user's browser and wait for them to accept
webbrowser.open(url, new=2)
print("Press enter once you have authorised the app in your browser")
input()
# Get a new access token from the authenticated session
# This will fail if the user didn't visit the above URL and press 'Allow'
try:
access_token = session.obtain_access_token(request_token)
except Exception as error:
if DEBUG:
print(error)
print("You didn't authorise the app, or something else went wrong")
exit(1)
# Save the access token to a file so that authentication is not needed next time the app is run
token_file.add('key', access_token.key)
token_file.add('secret', access_token.secret)
token_file.save()
# Create a Dropbox client from the session
client = DropboxClient(session)
self.client = client
def __init__(self, in_user_mode=True):
"""Connect to the Dropbox servers so that files can be uploaded"""
self.m = Message(in_user_mode=in_user_mode)
session = DropboxSession(API_KEY, API_SECRET, self.ACCESS_TYPE)
token_file = PyJson(TOKEN_PATH)
token = token_file.doc
# If there is a token saved, that can be used to connect with Dropbox
if 'key' in token and 'secret' in token:
# Read the token and authenticate the session with it
session.set_token(token['key'], token['secret'])
# Otherwise it is necessary to authenticate for the first time
else:
# Request an access token
request_token = session.obtain_request_token()
url = session.build_authorize_url(request_token)
# Open the authentication page in the user's browser and wait for them to accept
webbrowser.open(url, new=2)
print "Press enter once you have authorised the app in your browser"
raw_input()
# Get a new access token from the authenticated session
# This will fail if the user didn't visit the above URL and press 'Allow'
try:
access_token = session.obtain_access_token(request_token)
except Exception as error:
if DEBUG:
print error
print "You didn't authorise the app, or something else went wrong"
exit(1)
# Save the access token to a file so that authentication is not needed next time the app is run
token_file.add('key', access_token.key)
token_file.add('secret', access_token.secret)
token_file.save()
# Create a Dropbox client from the session
client = DropboxClient(session)
self.client = client
def unlink(self):
self.delete_creds()
DropboxSession.unlink(self)
def unlink(self):
DropboxSession.unlink(self)
import sys
import os.path
from dropbox.session import DropboxSession
if len(sys.argv) < 2:
print("usage: %s <dropbox-api-key> <dropbox-api-secret> <output-file-name>\n" % os.path.basename(__file__))
exit('not enough arguments')
app_key = sys.argv[1]
app_secret = sys.argv[2]
# should be 'dropbox' or 'app_folder' as configured for your app
access_type = 'app_folder'
file_name = sys.argv[3]
session = DropboxSession(app_key, app_secret, access_type)
request_token = session.obtain_request_token()
url = session.build_authorize_url(request_token)
print "url:", url
print "Please visit this website and press the 'Allow' button, then hit 'Enter' here."
raw_input()
access_token = session.obtain_access_token(request_token)
lines = [app_key, app_secret, access_token.key, access_token.secret]
with open(file_name, 'w') as f:
f.write("\n".join(lines))
print('done')
def unlink(self):
DropboxSession.unlink(self)
def connect_services():
g.dropbox = DropboxSession(app.config['DROPBOX_APP_KEY'],
app.config['DROPBOX_SECRET'], 'app_folder')
def __init__(self, location=None): session = DropboxSession(DROPBOX.app_key, DROPBOX.app_secret, DROPBOX.access_type, locale=None) session.set_token(DROPBOX.access_key, DROPBOX.access_secret) self.client = DropboxClient(session) self.overwrite_mode = DROPBOX.overwrite_mode self._location = location
