class DropboxStorage(Storage):
def __init__(self):
flow = DropboxOAuth2FlowNoRedirect(settings.APP_KEY,
settings.APP_SECRET)
#authorize_url = flow.start()
#access_token, user_id = flow.finish(settings.ACCESS_TOKEN)
self.client = DropboxClient(settings.ACCESS_TOKEN)
def _open(self, name, mode='rb'):
return File(name, mode=mode)
def _save(self, name, content):
response = self.client.put_file(name, content, overwrite=True)
return response['path']
def delete(self, name):
self.client.file_delete(name)
def exists(self, name):
try:
self.client.metadata(name)
except ErrorResponse as e:
if e.status == 404:
return False
raise e
return True
def size(self, name):
return self.client.metadata(name)['bytes']
def url(self, name):
return self.client.metadata(name)
class DropBoxStorage(Storage):
"""DropBox Storage class for Django pluggable storage system."""
def generate_url(self, name):
url = self.client.share(name, name)
url = url['url']
f = request.urlopen(url)
path = f.geturl()
return re.sub('www.dropbox.com','dl.dropboxusercontent.com', path)
def url(self, name):
return name #
def __init__(self, oauth2_access_token=setting('DROPBOX_OAUTH2_TOKEN')):
if oauth2_access_token is None:
raise ImproperlyConfigured("You must configure a token auth at"
"'settings.DROPBOX_OAUTH2_TOKEN'.")
self.client = DropboxClient(oauth2_access_token)
def delete(self, name):
self.client.file_delete(name)
def exists(self, name):
response = self.client.search('/', name, file_limit=1)
return bool(response)
def listdir(self, path):
directories, files = [], []
metadata = self.client.metadata(path)
for entry in metadata['contents']:
if entry['is_dir']:
directories.append(entry['path'])
else:
files.append(entry['path'])
return directories, files
def size(self, name):
metadata = self.client.metadata(name)
return metadata['bytes']
def modified_time(self, name):
metadata = self.client.metadata(name)
mod_time = datetime.strptime(metadata['modified'], DATE_FORMAT)
return mod_time
def accessed_time(self, name):
metadata = self.client.metadata(name)
acc_time = datetime.strptime(metadata['client_mtime'], DATE_FORMAT)
return acc_time
def _open(self, name, mode='rb'):
remote_file = DropBoxFile(name, self)
return remote_file
def _save(self, name, content):
self.client.put_file(name, content)
return name
def _read(self, name, num_bytes=None):
data = self.client.get_file(name)
return data.read(num_bytes)
class DropBoxStorage(Storage):
"""DropBox Storage class for Django pluggable storage system."""
def __init__(self, oauth2_access_token=setting('DROPBOX_OAUTH2_TOKEN')):
if oauth2_access_token is None:
raise ImproperlyConfigured("You must configure a token auth at"
"'settings.DROPBOX_OAUTH2_TOKEN'.")
self.client = DropboxClient(oauth2_access_token)
def delete(self, name):
self.client.file_delete(name)
def exists(self, name):
try:
return bool(self.client.metadata(name))
except ErrorResponse:
return False
def listdir(self, path):
directories, files = [], []
metadata = self.client.metadata(path)
for entry in metadata['contents']:
if entry['is_dir']:
directories.append(entry['path'])
else:
files.append(entry['path'])
return directories, files
def size(self, name):
metadata = self.client.metadata(name)
return metadata['bytes']
def modified_time(self, name):
metadata = self.client.metadata(name)
mod_time = datetime.strptime(metadata['modified'], DATE_FORMAT)
return mod_time
def accessed_time(self, name):
metadata = self.client.metadata(name)
acc_time = datetime.strptime(metadata['client_mtime'], DATE_FORMAT)
return acc_time
def url(self, name):
media = self.client.media(name)
return media['url']
def _open(self, name, mode='rb'):
remote_file = DropBoxFile(name, self)
return remote_file
def _save(self, name, content):
self.client.put_file(name, content)
return name
def _read(self, name, num_bytes=None):
data = self.client.get_file(name)
return data.read(num_bytes)
def getAllRemoteFilesList(self, user_id):
files = []
cliente = DropboxClient(self.TOKEN)
respuesta = cliente.metadata("/" + str(user_id) + "/")
for anio in respuesta["contents"]:
meses = cliente.metadata(str(anio["path"]))
for mes in meses["contents"]:
backups = cliente.metadata(str(mes["path"]))
for file in backups["contents"]:
files.append(file["path"])
return files
def getAllBackupsByDate(self):
user = self.getData()
files = []
cliente = DropboxClient(self.TOKEN)
respuesta = cliente.metadata("/" + str(user['IdCustomer']) + "/")
for anio in respuesta["contents"]:
meses = cliente.metadata(str(anio["path"]))
for mes in meses["contents"]:
backups = cliente.metadata(str(mes["path"]))
for file in backups["contents"]:
files.append(file)
files = sorted(files, key=lambda file: file['client_mtime'], reverse=True)
return files
class DropboxStorage(Storage):
def __init__(self, *args, **kwargs):
self.client = DropboxClient(settings.DROPBOX_ACCESS_TOKEN)
self.location = kwargs.get('location', settings.MEDIA_ROOT)
def path(self, name):
return safe_join(self.location, name)
def created_time(self, name):
raise NotImplementedError
def exists(self, name):
try:
return isinstance(self.client.metadata(self.path(name)), dict)
except:
return False
def get_available_name(self, name):
raise NotImplementedError
def get_valid_name(self, name):
raise NotImplementedError
def listdir(self, path):
meta = self.client.metadata(self.path(path))
directories, files = [], []
for entry in meta['contents']:
name = os.path.basename(entry['path'])
if entry['is_dir']:
directories.append(name)
else:
files.append(name)
return (directories, files)
def modified_time(self, name):
raise NotImplementedError
def open(self, name, mode='rb'):
return self.client.get_file(self.path(name))
def save(self, name, content, max_length=None):
raise NotImplementedError
def size(self, name):
return self.client.metadata(self.path(name)).bytes
def url(self, name):
return self.client.media(self.path(name))['url']
def sync():
if 'user' not in session:
return redirect(url_for('login'))
access_token = get_access_token()
print(access_token)
real_name = ''
if access_token is not None:
client = DropboxClient(access_token)
gallery_items = client.metadata('/gallery')
for idx, item in enumerate(gallery_items['contents']):
if item['is_dir']:
pass
else:
name = get_image_name(item['path'], '/gallery/')
f, metadata = client.get_file_and_metadata(item['path'])
make_dir('%s/%s' % (GAL_PATH, name))
for lang in LANGUAGES:
make_dir('%s/%s/%s' % (GAL_PATH, name, lang))
create_file('%s/%s.jpg' % (GAL_PATH, name), f.read())
for lang in LANGUAGES:
create_file(
'%s/%s/%s/%s' % (GAL_PATH, name, lang, 'title.txt'),
'')
return redirect(url_for('admin.dashboard'))
def get_path(self, path):
client = DropboxClient(self.token)
files_list = client.metadata(path)['contents']
quota_info = client.account_info()['quota_info']
if path != '/':
path = '/' + path.replace("%20", " ")
path_regex = re.compile(path, re.IGNORECASE)
for item in files_list:
item['name'] = path_regex.split(item['path'], 1)[-1][1:]
item['path'] = '/' + item['name']
else:
for item in files_list:
item['path'] = item['path'][1:]
item['name'] = item['path']
parent_url = (SITE_URL + 'api/path/dropbox/%i' + path) %self.uid
upload_url = (SITE_URL + 'api/upload/dropbox/%i' + path) %self.uid
data = { 'bytes_total': quota_info['quota'],
'bytes_used': quota_info['normal'] + quota_info['shared'],
'contents': files_list,
'display_name': self.display_name,
'parent_path': parent_url,
'service_class': 'dropbox',
'service_name': 'dropbox',
'uid': self.uid,
'upload_path': upload_url,
'username': self.email
}
return data
class DropBox(BaseDrive):
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 ls(self, path):
folder_metadata = self.client.metadata(path)
contents = folder_metadata['contents']
files = []
for content in contents:
if content['is_dir']:
files.append(MyFile(content['path'], True))
else:
files.append(MyFile(content['path'], False))
return files
def get(self, myfile, temp_filename):
out = open(temp_filename, 'wb')
f = self.client.get_file(myfile.path)
out.write(f.read())
out.close()
def getRemoteFilesList(self, ruta):
self.creaFolder(ruta)
files = []
cliente = DropboxClient(self.TOKEN)
respuesta = cliente.metadata(ruta)
for file in respuesta["contents"]:
files.append(file["path"])
return files
def get_folders(self, **kwargs):
folder_id = kwargs.get('folder_id')
if folder_id is None:
return [{
'addon': 'dropbox',
'id': '/',
'path': '/',
'kind': 'folder',
'name': '/ (Full Dropbox)',
'urls': {
'folders':
api_v2_url('nodes/{}/addons/dropbox/folders/'.format(
self.owner._id),
params={'id': '/'})
}
}]
client = DropboxClient(self.external_account.oauth_key)
file_not_found = HTTPError(
http.NOT_FOUND,
data={
'message_short':
'File not found',
'message_long':
'The Dropbox file you requested could not be found.'
})
max_retry_error = HTTPError(
http.REQUEST_TIMEOUT,
data={
'message_short': 'Request Timeout',
'message_long': 'Dropbox could not be reached at this time.'
})
try:
metadata = client.metadata(folder_id)
except ErrorResponse:
raise file_not_found
except MaxRetryError:
raise max_retry_error
# Raise error if folder was deleted
if metadata.get('is_deleted'):
raise file_not_found
return [{
'addon': 'dropbox',
'kind': 'folder',
'id': item['path'],
'name': item['path'].split('/')[-1],
'path': item['path'],
'urls': {
'folders':
api_v2_url('nodes/{}/addons/box/folders/'.format(
self.owner._id),
params={'id': item['path']})
}
} for item in metadata['contents'] if item['is_dir']]
def tracks():
token = get_access_token()
client = DropboxClient(token)
files = client.metadata('iTunes/iTunes Media/Music/Jay-Z/Magna Carta... Holy Grail')['contents']
for f in files:
if f['is_dir']:
continue
f['media'] = client.media(f['path'])
return jsonify(data=files)
def getBackups(self, ruta):
self.creaFolder(ruta)
files = []
cliente = DropboxClient(self.TOKEN)
respuesta = cliente.metadata(ruta)
for file in respuesta["contents"]:
files.append(file)
files = sorted(files, key=lambda file: file['client_mtime'])
return files
def process():
# Save file metadata to DB for the first time
if 'accessToken' not in session:
session.clear()
return redirect(url_for('index'))
elif 'cached' not in session:
client = DropboxClient(session['accessToken'])
folderMetadata = client.metadata('/')
contents = folderMetadata["contents"]
names = []
types = []
sizes = []
paths = []
BFS(client, contents, names, types, sizes, paths)
saveToDB(session["userID"], names, types, sizes, paths)
session["cached"] = 1
# File Search from search page
if request.method == 'POST':
keyWord = request.form["keyword"]
paths = []
sizes = []
searchInDB(session["userID"], paths, sizes, keyWord)
data = sorted(zip(sizes, paths))
searchCount = len(paths)
return render_template("search.html",
data=data,
searchCount=searchCount)
# Button clicks from account page
if request.args.get('list') is not None:
names = []
types = []
sizes = []
retrieveFromDB(session["userID"], types, sizes, names)
data = sorted(zip(types, sizes, names))
return render_template("files.html", data=data)
elif request.args.get('filesearch') is not None:
return render_template("search.html")
elif request.args.get('analyze') is not None:
names = []
types = []
sizes = []
retrieveFromDB(session["userID"], types, sizes, names)
used, free = spaceUsage()
types, totalSizes = getFileTypeSizes(names, sizes)
colors = getColors(len(types))
data = sorted(zip(totalSizes, colors, types))
return render_template("analysis.html",
used=used,
free=free,
rows=data)
else:
session.clear()
return redirect(url_for('index'))
def get_folders(self, **kwargs):
folder_id = kwargs.get('folder_id')
if folder_id is None:
return [{
'addon': 'dropbox',
'id': '/',
'path': '/',
'kind': 'folder',
'name': '/ (Full Dropbox)',
'urls': {
'folders': api_v2_url('nodes/{}/addons/dropbox/folders/'.format(self.owner._id),
params={'id': '/'}
)
}
}]
client = DropboxClient(self.external_account.oauth_key)
file_not_found = HTTPError(http.NOT_FOUND, data={
'message_short': 'File not found',
'message_long': 'The Dropbox file you requested could not be found.'
})
max_retry_error = HTTPError(http.REQUEST_TIMEOUT, data={
'message_short': 'Request Timeout',
'message_long': 'Dropbox could not be reached at this time.'
})
try:
metadata = client.metadata(folder_id)
except ErrorResponse:
raise file_not_found
except MaxRetryError:
raise max_retry_error
# Raise error if folder was deleted
if metadata.get('is_deleted'):
raise file_not_found
return [
{
'addon': 'dropbox',
'kind': 'folder',
'id': item['path'],
'name': item['path'].split('/')[-1],
'path': item['path'],
'urls': {
'folders': api_v2_url('nodes/{}/addons/box/folders/'.format(self.owner._id),
params={'id': item['path']}
)
}
}
for item in metadata['contents']
if item['is_dir']
]
def main():
# ask for the user to enter their token
auth_token = raw_input("Please enter your Dropbox auth token: ")
client = DropboxClient(auth_token)
# see if there are any new .mp3 files
# currently the program sleeps for 5 minutes between checks - change it
# however you like
while True:
time.sleep(5 * 60)
possible_file = client.metadata('/new')
# check for errors
contents = possible_file.get('contents')
files = len(contents)
if files > 0:
print 'something here'
i = 0
while i < files:
path = contents[i].get('path')
# print path
# get the file
file, metadata = client.get_file_and_metadata(path)
# transfer the file to local
out = open('voice.mp3', 'wb')
out.write(file.read())
out.close()
# execute a bash command using mpg123 to play the .mp3
subprocess.call("mpg123 ./voice.mp3", shell=True)
# move the file to the save folder
# old_path = './new/' + path
# print old_path
# print path
new_path = path[4:]
# TODO add date to path name
new_path = '/save/' + new_path
# print new_path
print "moving from " + path + " to " + new_path
client.file_move(path, new_path)
i+=1
else:
print 'nothing here'
def lists():
access_token = get_access_token()
if not access_token:
return json_response(False, 'You are not currently logged in through Dropbox.')
client = DropboxClient(access_token)
folder_metadata = client.metadata('/')['contents']
note_titles = []
for file in folder_metadata:
note_titles.append({ 'Title': file['path'][1:] })
return json_response(True, '', note_titles=note_titles)
def _get_folders(node_addon, folder_id):
node = node_addon.owner
if folder_id is None:
return [{
'id': '/',
'path': '/',
'addon': 'dropbox',
'kind': 'folder',
'name': '/ (Full Dropbox)',
'urls': {
'folders': node.api_url_for('dropbox_folder_list',
folderId='/'),
}
}]
client = DropboxClient(node_addon.external_account.oauth_key)
file_not_found = HTTPError(
http.NOT_FOUND,
data={
'message_short': 'File not found',
'message_long':
'The Dropbox file you requested could not be found.'
})
max_retry_error = HTTPError(
http.REQUEST_TIMEOUT,
data={
'message_short': 'Request Timeout',
'message_long': 'Dropbox could not be reached at this time.'
})
try:
metadata = client.metadata(folder_id)
except ErrorResponse:
raise file_not_found
except MaxRetryError:
raise max_retry_error
# Raise error if folder was deleted
if metadata.get('is_deleted'):
raise file_not_found
return [{
'addon': 'dropbox',
'kind': 'folder',
'id': item['path'],
'name': item['path'].split('/')[-1],
'path': item['path'],
'urls': {
'folders':
node.api_url_for('dropbox_folder_list', folderId=item['path']),
}
} for item in metadata['contents'] if item['is_dir']]
def get_synced_files(cls, user_profile, parent_project):
api_client = DropboxClient(user_profile.dropbox_profile.access_token["key"])
current_path = settings.APP_NAME + "/" + parent_project.title + "/"
resp = api_client.metadata(current_path)
if "contents" in resp:
# Search for removed files on dropbox
files = parent_project.files
removed_files = filter(lambda n: n.path not in [file["path"] for file in resp["contents"]], files)
for f in removed_files:
parent_project.files.remove(f)
parent_project.save()
# Gets all the new or updated files
for f in resp["contents"]:
local_file = filter(lambda n: n.path == f["path"], files)
# If the a local file is not found then it is created, otherwise it is updatedfiles
if len(local_file) is not 1:
fileMetadata = FileMetadata()
fileMetadata.path = f["path"]
fileMetadata.modified = datetime.strptime(f["modified"], "%a, %d %b %Y %H:%M:%S +0000")
fileMetadata.is_dir = True if f["is_dir"] else False
fileMetadata.revision = int(f["revision"])
fileMetadata.mime_type = f["mime_type"] if f.has_key("mime_type") else ""
fileMetadata.rev = f["rev"]
fileMetadata.size = f["size"]
if f["thumb_exists"]:
fileMetadata.thumb_exists = True
fileMetadata.thumb_url = "/get-dropbox-thumbnail/?path=%s" % urllib.quote_plus(f["path"])
else:
fileMetadata.thumb_exists = False
parent_project.files.append(fileMetadata)
elif local_file[0].revision < f["revision"]:
fileMetadata = local_file[0]
fileMetadata.path = f["path"]
fileMetadata.modified = datetime.strptime(f["modified"], "%a, %d %b %Y %H:%M:%S +0000")
fileMetadata.is_dir = True if f["is_dir"] else False
fileMetadata.revision = int(f["revision"])
fileMetadata.mime_type = f["mime_type"] if f.has_key("mime_type") else ""
fileMetadata.rev = f["rev"]
fileMetadata.size = f["size"]
if f["thumb_exists"]:
fileMetadata.thumb_exists = True
fileMetadata.thumb_url = "/get-dropbox-thumbnail/?path=%s" % urllib.quote_plus(f["path"])
else:
fileMetadata.thumb_exists = False
parent_project.files.append(fileMetadata)
parent_project.save()
def init():
"""Generate the html and upload to S3
"""
client = DropboxClient(DROPBOX_TOKEN)
root = client.metadata(DROPBOX_ROOT)
for f in root["contents"]:
# Ignore deleted files, folders, and non-markdown files
if f["is_dir"] or not f["path"].endswith(".md"):
continue
# Convert to Markdown and store as <basename>.html
html = markdown(client.get_file(f["path"]).read())
s3_upload(html, f["path"])
def init():
"""Generate the html and upload to S3
"""
client = DropboxClient(DROPBOX_TOKEN)
root = client.metadata(DROPBOX_ROOT)
for f in root['contents']:
# Ignore deleted files, folders, and non-markdown files
if f['is_dir'] or not f['path'].endswith('.md'):
continue
# Convert to Markdown and store as <basename>.html
html = markdown(client.get_file(f['path']).read())
s3_upload(html, f['path'])
def put_chunk_data(self, chunk):
access_token = "JkT9Fsx17gQAAAAAAAAAs1DAbvAU3sQrP1pJ8WiTdnG7HzQHE70idZ9Ph-GBuA3s"
hash = hashlib.md5(chunk.data)
path = '/' + hash.hexdigest()
client = DropboxClient(access_token)
try:
response = client.metadata(path)
if 'is_deleted' in response and response['is_deleted']:
response = client.put_file('/' + path, base64.b64encode(chunk.data))
except rest.ErrorResponse as e:
if e.status == 404:
response = client.put_file('/' + path, base64.b64encode(chunk.data))
chunk.update_info('dropbox', response['path'] )
def getDropbox(path):
db_access_token = user.db_access_token
client = DropboxClient(str(db_access_token))
metadata = client.metadata(path)
for content in metadata['contents']:
title = content['path'][content['path'].rfind('/')+1:]
modified = content['modified'][:-6]
datetime_modified = datetime.strptime(modified, "%a, %d %b %Y %X")
name = File(current_user.id, title, content['path'], dropbox, content['is_dir'], datetime_modified, None)
db.session.add(name)
db.session.commit()
for f in current_user.files:
print f
def showFiles():
if request.method == 'POST':
try:
# get a chunked DropBox uploader
# Get the Dropbox client we stored earlier
access_token = config.get('Credentials','access_token')
dclient = DropboxClient(access_token)
contents = dclient.metadata("/")['contents']
flist = []
for i in contents:
flist.append(i['path'])
return render_template('viewfiles.html',filelist=flist)
except Exception as e:
print e
def _get_folders(node_addon, folder_id):
node = node_addon.owner
if folder_id is None:
return [{
'id': '/',
'path': '/',
'addon': 'dropbox',
'kind': 'folder',
'name': '/ (Full Dropbox)',
'urls': {
'folders': node.api_url_for('dropbox_folder_list', folderId='/'),
}
}]
client = DropboxClient(node_addon.external_account.oauth_key)
file_not_found = HTTPError(http.NOT_FOUND, data={
'message_short': 'File not found',
'message_long': 'The Dropbox file you requested could not be found.'
})
max_retry_error = HTTPError(http.REQUEST_TIMEOUT, data={
'message_short': 'Request Timeout',
'message_long': 'Dropbox could not be reached at this time.'
})
try:
metadata = client.metadata(folder_id)
except ErrorResponse:
raise file_not_found
except MaxRetryError:
raise max_retry_error
# Raise error if folder was deleted
if metadata.get('is_deleted'):
raise file_not_found
return [
{
'addon': 'dropbox',
'kind': 'folder',
'id': item['path'],
'name': item['path'].split('/')[-1],
'path': item['path'],
'urls': {
'folders': node.api_url_for('dropbox_folder_list', folderId=item['path']),
}
}
for item in metadata['contents']
if item['is_dir']
]
def _get(client: DropboxClient) -> list:
""" Get files from Dropbox.
"""
try:
metadata = client.metadata('/')
except (MaxRetryError, ErrorResponse):
return None
return [
{
'file': m['path'],
'modified': strptime(m['modified'], '%a, %d %b %Y %H:%M:%S %z'),
'size': m['bytes']
}
for m in metadata['contents']
if not m['is_dir']
]
def newfolder(uid):
#278097779
access_token = redis_client.hget('tokens', uid)
client = DropboxClient(access_token)
all_data = client.metadata('/')
contents = all_data['contents']
folders = []
for item in all_data['contents']:
for key in item:
if key == 'is_dir':
if item[key] == True:
for path, value in item.iteritems():
if path == 'path':
folders.append(value)
display_folders = "<br />".join(str(folder) for folder in folders)
return render_template('newfolder.html', display_folders=display_folders, uid=uid)
class DropboxProvider(DAVProvider):
def __init__(self, accessToken):
super(DropboxProvider, self).__init__()
self.client = DropboxClient(accessToken)
def getResourceInst(self, path, environ):
self._count_getResourceInst += 1
try:
metadata = self.client.metadata(path)
except ErrorResponse as err:
if err.status == 404:
return
raise
if metadata.get('is_deleted', False):
return None
return DropboxResource(path, metadata, environ)
def check_basket():
uid = session['uid']
token = redis_client.hget('tokens', uid)
client = DropboxClient(token)
# check if /Easter basket has all five eggs
basket_contents = set(
os.path.split(item['path'])[1] for item in
client.metadata('/Easter basket').get('contents'))
if basket_contents >= set(egg_refs.keys()):
elapsed = time.time() - float(redis_client.hget('start_times', uid))
return render_template('found_eggs.html', seconds=('%.2f' % elapsed))
else:
return render_template('done.html', notyet=True)
def newfolder(uid):
#278097779
access_token = redis_client.hget('tokens', uid)
client = DropboxClient(access_token)
all_data = client.metadata('/')
contents = all_data['contents']
folders = []
for item in all_data['contents']:
for key in item:
if key == 'is_dir':
if item[key] == True:
for path, value in item.iteritems():
if path == 'path':
folders.append(value)
display_folders = "<br />".join(str(folder) for folder in folders)
return render_template('newfolder.html',
display_folders=display_folders,
uid=uid)
class DropboxSyncClient:
def __init__(self, oauth2_access_token):
self.access_token = oauth2_access_token
self._client = DropboxClient(oauth2_access_token)
def upload_file(self, dropbox_file_path, local_file_path, replace=False):
f = open(local_file_path, 'rb')
response = self._client.put_file(dropbox_file_path, f, replace)
return 1, response['path']
def generate_public_url(self, dropbox_file_path):
return self._client.share(dropbox_file_path)['url']
def delete_file(self, dropbox_file_path):
self._client.file_delete(dropbox_file_path)
return 1, None
def update_local_to_cloud(self, dropbox_file_path, local_file_path):
return 1, self.upload_file(dropbox_file_path, local_file_path, replace=True)
def update_cloud_to_local(self, dropbox_file_path, local_file_path):
try:
try:
os.makedirs(os.path.dirname(local_file_path))
except Exception as e:
pass
open(local_file_path, 'wb').write(self._client.get_file(dropbox_file_path).read())
return 1, None
except Exception as e:
print e
return 1, None
def get_file_list(self, dropbox_folder_path):
folder_metadata = self._client.metadata(dropbox_folder_path)
return [content['path'] for content in folder_metadata['contents']]
def set_access_token(self, access_token):
self._client = DropboxClient(access_token)
def get_remaining_space(self):
quota_info = self._client.account_info()['quota_info']
return quota_info['total'] - (quota_info['shared'] + quota_info['normal'])
def user_detail(uid):
# NOTE: no login here, just sets the current user upon visiting the
# user page.
user = User.load(uid)
if not user:
abort(403)
session['user_id'] = user._primary_key
settings = get_dropbox_settings(user)
if settings:
dropbox_client = DropboxClient(settings.access_token)
account_info = dropbox_client.account_info()
metadata = dropbox_client.metadata('/')
else:
account_info = None
metadata = None
return render_template('user.html', user=user, settings=settings,
account_info=account_info, metadata=metadata
)
def dropboxFileTree(root, user_account):
try:
user_access_token = UserAccessToken.objects.get(user_account=user_account)
access_token = user_access_token.access_token
client = DropboxClient(access_token)
folder_metadata = client.metadata(root)
folder_contents = folder_metadata.get('contents')
file_list = []
for content in folder_contents:
name = content.get('path')
isDir = content.get('is_dir')
if isDir is True:
image = 'fileboard/images/folder1.png'
else:
mime_type = content.get('mime_type')
image = getImage(mime_type)
this_file = File('dropbox',name,image)
file_list.append(this_file)
return file_list
except UserAccessToken.DoesNotExist:
return None
class PydropboxFDW(ForeignDataWrapper):
_client = None
def __init__(self, options, columns):
super(PydropboxFDW, self).__init__(options, columns)
if 'token' not in options:
log_to_postgres('access token is not specified', ERROR)
self._path = options.get('path', '/')
self._metadata_params = {}
if 'file_limit' in options:
self._metadata_params['file_limit'] = int(options['file_limit'])
if 'include_deleted' in options:
self._metadata_params['include_deleted'] = bool(
options['include_deleted'])
try:
self._client = DropboxClient(options['token'])
except Exception as e:
log_to_postgres('could not connect to dropbox: %s' % str(e), ERROR)
def execute(self, quals, columns):
log_to_postgres('exec quals: %s' % quals, DEBUG)
log_to_postgres('exec columns: %s' % columns, DEBUG)
resp = {}
try:
resp = self._client.metadata(self._path, **self._metadata_params)
except Exception as e:
log_to_postgres(
'could not get metadata for path "%s": %s' %
(self._path, str(e)), ERROR)
for item in resp.get('contents', []):
yield item
class DropboxArchiver(ServiceArchiver):
ARCHIVES = 'dropbox'
REQUIRED_KEYS = ['access_token', 'folder']
def __init__(self, service):
try:
self.client = DropboxClient(service['access_token'])
self.folder_name = service['folder']
except KeyError as e:
raise DropboxArchiver('Missing argument "%s"' % e.message)
super(DropboxArchiver, self).__init__(service)
def clone(self):
header = self.build_header(self.folder_name, self.versions)
logging.info('Archiving {} items from "{}"'.format(len(header), self.folder_name))
return chord(header, clone_done.s(self.folder_name, self.cid))
def build_header(self, folder, versions=None):
header = []
for item in self.client.metadata(folder)['contents']:
if item['is_dir']:
header.extend(self.build_header(item['path'], versions=versions))
else:
header.append(self.build_file_chord(item, versions=versions))
return header
def build_file_chord(self, item, versions=None):
if not versions:
return fetch.si(self, item['path'], rev=None)
header = []
for rev in self.client.revisions(item['path'], versions):
header.append(fetch.si(self, item['path'], rev=rev['rev']))
return chord(header, file_done.s())
def list_beavlets(request):
user = request.user
try:
access_token = user.profile.access_token
except Profile.DoesNotExist:
messages.add_message(request, messages.ERROR,
"Your dropbox account needs to be linked!")
return redirect('/dropbox/')
import os
beavlet_root = u'/'
ls = {}
client = DropboxClient(access_token)
resp = client.metadata(beavlet_root)
if 'contents' in resp:
for f in resp['contents']:
path = f['path']
name = os.path.basename(path)
ls[name] = '/dropbox/render-beavlet/' + name
return render(request, 'dropbox/list-beavlets.html',
{'listing': ls})
def dropbox_file_view(request):
"""
The view for files/folders in a dropbox account
"""
try:
token = UserProfile.objects.get(user=request.user).dropbox_token
if not token: # Checks for existence of token
messages.add_message(request, messages.ERROR, 'You have not connected with a Dropbox account yet.')
return render(request, 'website/dashboard.html')
# Initiate a client session and get root contents of Dropbox
client = DropboxClient(token)
root_contents = client.metadata('/')['contents']
for data in root_contents:
if not data['is_dir']:
data['url'] = client.media(data['path'])['url']
context = {'root_contents': root_contents}
return render(request, 'website/dropbox/fileview.html', context)
except Exception, e:
messages.add_message(request, messages.ERROR, 'Error accessing Dropbox files')
print str(e)
return render(request, 'website/dropbox/fileview.html')
def dropbox_files(path):
if not session.get('user'):
abort(401)
user = get_user(session.get('user'))
if user.get('db_access_token') is None:
abort(401)
opening_file = get_file(path, user.get("username"))
if (not opening_file.get('last_updated') is None):
if (datetime.now()- datetime.strptime(str(opening_file['last_updated'])[:18], "%Y-%m-%dT%H:%M:%S")).seconds<3600:
cur2 = list(g.db.execute('SELECT * from file WHERE parent = ? and owner = ? and dropbox = ?', [path, user.get("username"), True]))
return json.dumps(cur2)
db_token = user['db_access_token']
client = DropboxClient(db_token)
print "DB API REQUEST"
metadata = client.metadata(path)
for contents in metadata['contents']:
title = contents['path'][contents['path'].rfind('/')+1:]
g.db.execute('INSERT or REPLACE into file (ID, owner, name, parent, content_path, dropbox, folder) values ((SELECT ID FROM file WHERE content_path = ?and owner = ?),?,?,?,?,?,?)', [ contents['path'], user.get("username"), user.get("username"), title, path, contents['path'], True, contents['is_dir']])
g.db.execute('UPDATE file SET last_updated = ? WHERE owner = ? and content_path = ?', [str(datetime.now().isoformat()), user.get("username"), path])
g.db.commit()
cur3 = list(g.db.execute('SELECT * from file WHERE owner = ? and parent = ? and dropbox = ?', [user.get("username"), path, True]))
return json.dumps(cur3)
def to_be_synced(file_path):
dc = DropboxClient(access_token)
# check if file exists on Dropbox
file_name = os.path.basename(file_path)
tmp_file = open(file_path + '.poom', 'wb+')
try:
with dc.get_file('/' + file_name) as f:
tmp_file.write(f.read())
f.close()
tmp_file.close()
logger.debug("Comparing files...")
# get dropbox file info
dr_file_data = dc.metadata('/' + file_name)
# get dropbox file last modified time in UTC
dr_time = parse(dr_file_data['modified'])
# get local file last modified time
file_localtime = parse(time.ctime(os.path.getmtime(file_path)))
# convert local time to utc
local_dt = get_localzone().localize(file_localtime, is_dst=None)
loc_time = local_dt.astimezone(pytz.utc)
# compare the last modified times
if dr_time > loc_time:
logger.debug("Newer version on dropbox")
os.remove(file_path)
logger.debug("Removed file from disk")
os.rename(file_path + '.poom', file_path)
else:
logger.debug("Newer version on local disk")
return False
return True
except dbrest.ErrorResponse as e:
if e.status == 404:
return False
class DBoxClient(object):
def __init__(self):
self._logger = logging.getLogger(config.dpbox['logger']['name'])
self.cache_file = config.dpbox['cachefile']
self._token = None
self._load()
key, secret = decode_dropbox_key(config.dpbox['app']['encoded'])
self.session = DBoxSession(config.dpbox['app']['key'],
config.dpbox['app']['secret'],
access_type=config.dpbox['app']['access'])
if (self._token):
self.session.set_token(self._token[0], self._token[1])
else:
self._token = self.session.link()
self._save()
self.client = DropboxClient(self.session)
def reset(self):
self._logger.debug('[dpbox v%s] resetting local state' % (VERSION))
self._save()
def download(self, source, directory=''):
if len(directory) > 0 and directory[len(directory) - 1] != '/':
directory += '/'
self._logger.info(u'[dpbox v%s] FETCH %s -> %s' %
(VERSION, unicode(source), unicode(directory)))
self._download(source, directory)
def _download(self, source, directory):
try:
metadata = self.client.metadata(source)
self._logger.debug(u'metadata for %s' % source)
self._logger.debug(metadata)
except Exception as e:
self._logger.error('[dpbox v%s] error fetching file' % (VERSION))
self._logger.exception(e)
return # Will check later if we've got everything.
segs = metadata['path'].split('/')
directory += segs[len(segs) - 1]
if metadata['is_dir']:
try:
os.stat(directory)
except:
os.mkdir(directory)
for item in metadata['contents']:
self._download(item['path'], directory + '/')
else:
f = self.client.get_file(source)
print 'writing file to disc...'
destination = open(os.path.expanduser(directory.encode('utf-8')),
'wb')
destination.write(f.read())
destination.close()
print u"[rev %s] %s - '%s' downloaded" % (
metadata['revision'], metadata['size'], directory)
def upload(self, source, directory):
if len(directory) > 0 and directory[len(directory) - 1] != '/':
directory += '/'
segs = source.split('/')
directory += segs[len(segs) - 1]
f = open(source, 'rb')
print u'uploading file %s -> %s' % (source, directory)
response = self.client.put_file(directory.encode('utf-8'), f)
print "[rev %s] %s - '%s' uploaded" % (
response['revision'], response['size'], response['path'])
self._logger.debug('[dpbox v%s] upload response: %s' %
(VERSION, response))
def list(self, directory):
path = unicode(directory).encode('utf-8')
metadata = self.client.metadata(path)
self._logger.debug('[dpbox v%s] metadata: %s' % (VERSION, metadata))
print 'display content of ', metadata['path'], ', ', metadata['size']
for item in metadata['contents']:
if item['is_dir']:
print 'd ', item['path']
else:
print 'f ', item['path']
def infos(self, item, filename=''):
path = unicode(item).encode('utf-8')
metadata = self.client.metadata(path)
if len(filename) > 0:
with open(filename, 'w') as outfile:
json.dump(metadata, outfile)
else:
print metadata
def user(self, item=''):
infos = self.client.account_info()
self._logger.debug(u'[dpbox v%s] %s' % (VERSION, infos))
if len(item) > 0:
print item, ' = ', infos[item]
return
for name in infos:
space = ' ' * (20 - len(name))
if isinstance(infos[name], types.DictType):
print name, ':'
for key in infos[name]:
print ' -> ', key, ': ', infos[name][key]
else:
print name, space, infos[name]
def disconnect(self):
cachefile = os.path.expanduser(self.cache_file)
if os.path.exists(cachefile):
os.unlink(cachefile)
self.session.unlink()
print 'disconnected from service'
def _save(self):
with open(os.path.expanduser(self.cache_file), 'w') as f:
f.write(''.join([json.dumps(self._token), '\n']))
# f.write(''.join([json.dumps(self.remote_dir), '\n']))
def _load(self):
cachefile = os.path.expanduser(self.cache_file)
if not os.path.exists(cachefile):
self._logger.warn('[dpbox v%s] Cache file not found: %s' %
(VERSION, cachefile))
self.reset()
return
try:
with open(cachefile, 'r') as f:
dir_changed = False
try:
line = f.readline() # Token.
self._token = json.loads(line)
self._logger.debug('[dpbox v%s] loaded token' % (VERSION))
except Exception as e:
self._logger.warn('[dpbox v%s] can\'t load cache state' %
(VERSION))
self._logger.exception(e)
# try:
# line = f.readline() # Dropbox directory.
# directory = json.loads(line)
# if directory != self.remote_dir: # Don't use state.
# self._logger.info(u'remote dir changed "%s" -> "%s"' %
# (directory, self.remote_dir))
# dir_changed = True
# except Exception as e:
# self._logger.warn('can\'t load cache state')
# self._logger.exception(e)
if dir_changed:
return
except Exception as e:
self._logger.error('[dpbox v%s] error opening cache file' %
(VERSION))
self._logger.exception(e)
'--token',
nargs='+',
help='Please enter token',
required=True)
args = parser.parse_args()
folder = args.list
auth_token = args.token[0]
src = args.upload[0]
dst = args.upload[1]
to_download = args.download
try:
dbx = dropbox.Dropbox(auth_token)
client = DropboxClient(auth_token)
folder_metadata = client.metadata('/')
except:
print('Invalid Token. Please check your token and try again...')
sys.exit(1)
def get_files(folder):
l = []
res = dbx.files_list_folder(folder)
for entry in res.entries:
l.append(entry.path_display)
return l
def upload():
# src = args.upload[0]
class DropBox(clouddrive.CloudDrive):
name = "DropBox"
def __init__(self, access_token):
self.client = DropboxClient(access_token)
self.access_token = access_token
clouddrive.CloudDrive.__init__(self, access_token)
@staticmethod
def auth():
#app_key = 'knbyx2adg14kkn5'
#app_secret = 'kh3ulgqry8jffqp'
app_key = 'eif0l7bgnpb06di'
app_secret = 'qa02jhdo4jrwaid'
global Auth_DROPMytoken
global Auth_Drop_Running_true
def keep_running():
global Auth_Drop_Running_true
return Auth_Drop_Running_true
class AuthHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_HEAD(s):
s.send_response(200)
s.send_header("Content-type", "text/html")
s.end_headers()
def do_GET(s):
s.send_response(200)
s.send_header("Content-type", "text/html")
s.end_headers()
if s.path.find("code=") != -1:
global Auth_DROPMytoken
global Auth_Drop_Running_true
Auth_DROPMytoken = s.path
Auth_Drop_Running_true = False
s.wfile.write("ok see command line")
return
class MYrequest:
def __init__(self, url):
self.url = url
def get(self, mystring):
if self.url.find(mystring) == -1:
return
item = self.url.split(mystring + "=")[1]
if item.find("&") != -1:
item = item.split("&")[0]
return urllib.unquote(item).decode()
redirect_url = "http://localhost:8787"
my_session = {}
Auth_Drop_Running_true = True
flow = DropboxOAuth2Flow(app_key, app_secret, redirect_url, my_session,
"dropbox-auth-csrf-token")
authorize_url = flow.start()
webbrowser.open(authorize_url)
try:
httpd = BaseHTTPServer.HTTPServer(("", 8787), AuthHandler)
while keep_running():
httpd.handle_request()
except KeyboardInterrupt:
pass
httpd.server_close()
token, user_id, url_state = flow.finish(MYrequest(Auth_DROPMytoken))
clouddrive.CloudDrive.access_token = token
return token
def read(self, filename):
try:
data = []
with self.client.get_file(filename) as f:
data += f.read()
except:
return -1
return ''.join(data)
def write(self, filename, data):
try:
response = self.client.put_file(filename, data, True)
except:
return -1
return 1
def mkdir(self, dirname):
try:
self.client.file_create_folder(dirname)
except:
return -1
return 1
def delete(self, filename):
try:
self.client.file_delete(filename)
except:
return -1
return 1
def capacity(self):
try:
a = self.client.account_info()["quota_info"]
except:
return -1
return a["quota"] - a["shared"] - a["normal"]
def listing(self, path="/"):
lists = self.client.metadata(path)
filelist = []
for x in lists["contents"]:
filelist.append((x['path'], x['is_dir']))
return filelist
class DropBoxStorage(Storage):
"""DropBox Storage class for Django pluggable storage system."""
def __init__(self, oauth2_access_token=None, root_path=None):
oauth2_access_token = oauth2_access_token or setting('DROPBOX_OAUTH2_TOKEN')
self.root_path = root_path or setting('DROPBOX_ROOT_PATH', '/')
if oauth2_access_token is None:
raise ImproperlyConfigured("You must configure a token auth at"
"'settings.DROPBOX_OAUTH2_TOKEN'.")
self.client = DropboxClient(oauth2_access_token)
def _full_path(self, name):
if name == '/':
name = ''
return safe_join(self.root_path, name).replace('\\', '/')
def delete(self, name):
self.client.file_delete(self._full_path(name))
def exists(self, name):
try:
return bool(self.client.metadata(self._full_path(name)))
except ErrorResponse:
return False
def listdir(self, path):
directories, files = [], []
full_path = self._full_path(path)
metadata = self.client.metadata(full_path)
for entry in metadata['contents']:
entry['path'] = entry['path'].replace(full_path, '', 1)
entry['path'] = entry['path'].replace('/', '', 1)
if entry['is_dir']:
directories.append(entry['path'])
else:
files.append(entry['path'])
return directories, files
def size(self, name):
metadata = self.client.metadata(self._full_path(name))
return metadata['bytes']
def modified_time(self, name):
metadata = self.client.metadata(self._full_path(name))
mod_time = datetime.strptime(metadata['modified'], DATE_FORMAT)
return mod_time
def accessed_time(self, name):
metadata = self.client.metadata(self._full_path(name))
acc_time = datetime.strptime(metadata['client_mtime'], DATE_FORMAT)
return acc_time
def url(self, name):
media = self.client.media(self._full_path(name))
return media['url']
def _open(self, name, mode='rb'):
remote_file = DropBoxFile(self._full_path(name), self)
return remote_file
def _save(self, name, content):
self.client.put_file(self._full_path(name), content)
return name
class DropboxAPI(StorageAPI, AppendOnlyLog):
"dropbox@auth : dropbox.com account with auth info"
def __init__(self):
from params import AUTH_DIR
authdir = AUTH_DIR
self.auth_file = os.path.join(authdir, 'dropbox.auth')
try:
with open(self.auth_file, 'r') as file:
ACCESS_TOKEN = file.readline().rstrip()
USER_ID = file.readline().rstrip()
except IOError:
ACCESS_TOKEN, USER_ID = self._authorize()
self.client = DropboxClient(ACCESS_TOKEN)
def sid(self):
return util.md5("dropbox") % 10000
def copy(self):
return DropboxAPI()
def _authorize(self):
dbg.info('Request access token from Dropbox')
flow = DropboxOAuth2FlowNoRedirect(APP_KEY, APP_SECRET)
authorize_url = flow.start()
# print 'Open auth url:', authorize_url
#browser = webdriver.PhantomJS(service_log_path=os.path.join(tempfile.gettempdir(), 'ghostdriver.log'))
#browser = webdriver.PhantomJS(service_log_path=os.path.join(tempfile.gettempdir(), 'ghostdriver.log'), service_args=['--ignore-ssl-errors=true', '--ssl-protocol=tlsv1'])
# Change to rely on browser
print(
"We need to authorize access to Dropbox. Please visit the following URL and authorize the access:"
)
print(authorize_url)
print("")
code = raw_input("Input the code you got: ").strip()
#code = #raw_input("Enter the authorization code here: ").strip()
access_token, user_id = flow.finish(code)
with open(self.auth_file, 'w') as file:
file.write(access_token + "\n")
file.write(user_id + "\n")
dbg.info('Authentication successful')
return (access_token, user_id)
# return: list of file paths
def listdir(self, path):
dic = self.client.metadata(path)
lst = map(lambda x: x["path"], dic["contents"])
lst = map(lambda x: x.split("/")[-1], lst)
return lst
def exists(self, path):
try:
dic = self.client.metadata(path)
if (dic.has_key("is_deleted") and dic["is_deleted"]): return False
return True
except:
return False
def get(self, path):
"""Get the file content
Args:
path: string
Returns:
content: string
"""
conn = self.client.get_file(path)
content = conn.read()
conn.close()
return content
def get_file_rev(self, path, rev):
# get file of a previous version with rev hash_id
content = None
try:
conn = self.client.get_file(path, rev=rev)
content = conn.read()
conn.close()
except ErrorResponse as detail:
#print "[get_file_rev] File doesn't exist", detail
return None
return content
def put(self, path, content):
"""Upload the file
Args:
path: string
content: string, size <= 4MB
Returns: None
"""
from dropbox.rest import ErrorResponse
strobj = StringIO(content)
try:
metadata = self.client.put_file(path,
strobj,
overwrite=False,
autorename=False)
except ErrorResponse as e:
if e.status == 409:
raise ItemAlreadyExists(e.status, e.reason)
else:
raise APIError(e.status, e.reason)
return True
def putdir(self, path):
self.client.file_create_folder(path)
def update(self, path, content):
"""Update the file
Args and returns same as put
"""
strobj = StringIO(content)
metadata = self.client.put_file(path, strobj, overwrite=True)
return True
def rm(self, path):
"""Delete the file
Args:
path: string
"""
self.client.file_delete(path)
def rmdir(self, path):
self.client.file_delete(path)
def metadata(self, path):
# only for file, not dir
_md = self.client.metadata(path)
md = {}
md['size'] = _md['bytes']
md['mtime'] = util.convert_time(_md['modified'])
return md
def delta(self, path=None, cursor=None):
resp = self.client.delta(cursor=cursor, path_prefix=path)
cursor = resp['cursor']
changes = []
for entry in resp['entries']:
event = {}
if entry[1]:
# we don't care about delete event
event['path'] = entry[0]
if entry[1]['is_dir']:
event['type'] = 'folder'
else:
event['type'] = 'file'
changes.append(event)
return cursor, changes
def poll(self, path=None, cursor=None, timeout=30):
# timeout max 480
import requests
import time
from error import PollError
beg_time = time.time()
end_time = beg_time + timeout
curr_time = beg_time
url = 'https://api-notify.dropbox.com/1/longpoll_delta'
params = {}
changes = []
if path:
path = util.format_path(path)
if not cursor:
cursor, _ = self.delta(path)
curr_time = time.time()
while True:
params['cursor'] = cursor
params['timeout'] = max(30, int(end_time -
curr_time)) # minimum 30 second
resp = requests.request('GET', url, params=params)
obj = resp.json()
if 'error' in obj:
raise PollError(resp.status_code, resp.text)
if obj['changes']:
cursor, _delta = self.delta(path, cursor)
changes.extend(_delta)
if changes:
break
curr_time = time.time()
if curr_time > end_time:
break
return cursor, changes
def init_log(self, path):
if not self.exists(path):
self.put(path, '')
def reset_log(self, path):
if self.exists(path):
self.rm(path)
def append(self, path, msg):
self.update(path, msg)
def get_logs(self, path, last_clock):
length = 5
# latest revision comes first
revisions = self.client.revisions(path, rev_limit=length)
if not revisions:
return [], None
new_logs = []
new_clock = revisions[0]['rev']
end = False # if reach to end
while True:
for metadata in revisions:
if last_clock and metadata['rev'] == last_clock:
end = True
break
if end: break
if len(revisions) < length: break
# still have logs unread, double the length
length *= 2
revisions = self.client.revisions(path, rev_limit=length)
# download the content of unseen rev
for metadata in revisions:
if last_clock and metadata['rev'] == last_clock:
break
if 'is_deleted' in metadata and metadata['is_deleted']: continue
msg = self.get_file_rev(path, metadata['rev'])
if len(msg) > 0:
new_logs.insert(0, msg)
return new_logs, new_clock
def __msg_index(self, fn):
return eval(fn[3:])
def init_log2(self, path):
if not self.exists(path):
self.putdir(path)
def append2(self, path, msg):
path = util.format_path(path)
lst = sorted(self.listdir(path))
if lst:
index = self.__msg_index(lst[-1]) + 1
else:
index = 0
while True:
fn = 'msg%d' % index
fpath = path + '/' + fn
try:
self.put(fpath, msg)
except ItemAlreadyExists:
index += 1
else:
break
def get_logs2(self, path, last_clock):
path = util.format_path(path)
lst = self.listdir(path)
if not lst:
return [], None
srt = {}
for fn in lst:
srt[self.__msg_index(fn)] = fn
lst = [srt[i] for i in sorted(srt.keys(), reverse=True)]
new_logs = []
new_clock = self.__msg_index(lst[0])
for fn in lst:
if last_clock == None and self.__msg_index(fn) == last_clock: break
msg = self.get(path + '/' + fn)
new_logs.insert(0, msg)
return new_logs, new_clock
def share(self, path, target_email):
url = "https://www.dropbox.com/"
print 'Get access token from Dropbox'
print 'Open auth url:', url
browser = webdriver.PhantomJS(
service_log_path=os.path.join(tempfile.gettempdir(),
'ghostdriver.log'),
service_args=['--ignore-ssl-errors=true', '--ssl-protocol=tlsv1'])
browser.get(url)
try:
wait = WebDriverWait(browser, 30)
btn = wait.until(
EC.element_to_be_clickable(
(By.XPATH, "//div[@id='sign-in']/a")))
btn.click()
email = wait.until(
EC.element_to_be_clickable(
(By.XPATH, "//input[@id='login_email']")))
email.send_keys(raw_input("Enter your Dropbox email:"))
pwd = browser.find_element_by_xpath(
"//input[@id='login_password']")
pwd.send_keys(getpass.getpass("Enter your Dropbox password:"******"//a[text()='%s']" % path)))
target_folder.click()
wait.until(EC.title_contains("%s" % path))
share_btn = browser.find_element_by_xpath(
"//a[@id='global_share_button']")
share_btn.click()
target = wait.until(
EC.element_to_be_clickable((
By.XPATH,
"//form[@class='invite-more-form']//input[@spellcheck][@type='text']"
)))
target.send_keys(target_email)
confirm_btn = browser.find_element_by_xpath(
"//form[@class='invite-more-form']//input[@type='button'][1]")
confirm_btn.click()
except:
print(browser.title)
assert False
# print(browser.current_url)
# print(browser.page_source)
pass
def __call__(self):
import pdb; pdb.set_trace()
metadata = DropboxClient.metadata('/bok')
files = [content['path'].split('/')[-1] for content in metadata['contents']]
return self.template(self.context)
def getDateFromBackup(self, backup):
from datetime import datetime
cliente = DropboxClient(self.TOKEN)
respuesta = cliente.metadata(backup)
m = re.search("(((\d{2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{4}))\s(\d{2}):(\d{2}):(\d{2}))", respuesta['client_mtime'])
return m.group(1)
class DropboxStorage(Storage):
"""
A storage class providing access to resources in a Dropbox Public folder.
"""
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 _get_abs_path(self, name):
return os.path.realpath(os.path.join(self.location, name))
def _open(self, name, mode='rb'):
name = self._get_abs_path(name)
remote_file = DropboxFile(name, self, mode=mode)
return remote_file
def _save(self, name, content):
name = self._get_abs_path(name)
directory = os.path.dirname(name)
if not self.exists(directory) and directory:
self.client.file_create_folder(directory)
response = self.client.metadata(directory)
if not response['is_dir']:
raise IOError("%s exists and is not a directory." % directory)
abs_name = os.path.realpath(os.path.join(self.location, name))
self.client.put_file(abs_name, content)
return name
def delete(self, name):
name = self._get_abs_path(name)
self.client.file_delete(name)
def exists(self, name):
name = self._get_abs_path(name)
try:
metadata = self.client.metadata(name)
if metadata.get('is_deleted'):
return False
except ErrorResponse as e:
if e.status == 404: # not found
return False
raise e
return True
def listdir(self, path):
path = self._get_abs_path(path)
response = self.client.metadata(path)
directories = []
files = []
for entry in response.get('contents', []):
if entry['is_dir']:
directories.append(os.path.basename(entry['path']))
else:
files.append(os.path.basename(entry['path']))
return directories, files
def size(self, name):
cache_key = 'django-dropbox-size:%s' % filepath_to_uri(name)
size = cache.get(cache_key)
if not size:
size = self.client.metadata(filepath_to_uri(name))['bytes']
cache.set(cache_key, size, CACHE_TIMEOUT)
return size
def url(self, name):
cache_key = 'django-dropbox-url:%s' % filepath_to_uri(name)
url = cache.get(cache_key)
if not url:
url = self.client.share(filepath_to_uri(name),
short_url=False)['url'] + '?dl=1'
cache.set(cache_key, url, CACHE_TIMEOUT)
return url
def get_available_name(self, name):
"""
Returns a filename that's free on the target storage system, and
available for new content to be written to.
"""
name = self._get_abs_path(name)
dir_name, file_name = os.path.split(name)
file_root, file_ext = os.path.splitext(file_name)
# If the filename already exists, add an underscore and a number (before
# the file extension, if one exists) to the filename until the generated
# filename doesn't exist.
count = itertools.count(1)
while self.exists(name):
# file_ext includes the dot.
name = os.path.join(
dir_name, "%s_%s%s" % (file_root, count.next(), file_ext))
return name
class cloudfiles_nb(object):
def __init__(self, api_type, keys):
self.api_type = api_type
if api_type == 'aws':
from boto.s3.connection import S3Connection
aws_key, aws_secret = keys
self.conn = S3Connection(aws_key, aws_secret)
elif api_type == 'dropbox':
from dropbox.client import DropboxClient
from dropbox.session import DropboxSession
access_token = keys
self.uploaded_files = {}
self.client = DropboxClient(access_token)
self.base_dir = 'workdocs-cloudfiles'
self.folders_list = [p['path'].replace('/%s/' %self.base_dir, '')\
for p in self.client.metadata(self.base_dir)['contents']]
self.upload_file_res = {}
def initialize_folder(self, folder_name):
if self.api_type == 'aws':
self.bucket = self.conn.create_bucket(folder_name)
self.folder_name = folder_name
elif self.api_type == 'dropbox':
self.thisfolder = '%s/%s' % (self.base_dir, folder_name)
if folder_name in self.folders_list:
print 'folder already exists'
res = None
else:
print 'creating folder'
res = self.client.file_create_folder(self.thisfolder)
# do something for error
return res
def upload_file(self, filepath):
if self.api_type == 'aws':
from boto.s3.key import Key
filename = filepath.split('/')[-1]
k = Key(self.bucket)
k.key = filename
k.set_contents_from_filename(filepath)
k.set_acl('public-read')
if '.png' in k.key: k.set_metadata('Contet-Type', 'image/png')
elif self.api_type == 'dropbox':
f = open(filepath, 'r')
filename = filepath.split('/')[-1]
newfile = '%s/%s' % (self.thisfolder, filename)
# if filename alread exists, delate and replace
#filecheck = self.client.search(self.thisfolder, filename)
#if filecheck: del_res = self.client.file_delete(newfile)
res = self.client.put_file(newfile, f, overwrite=True)
return res
def get_file_link(self, filename):
if self.api_type == 'aws':
thiskey = self.bucket.get_key(filename)
res = 'https://%s.s3.amazonaws.com/%s' % (self.bucket.name,
filename)
# something for error
return res
elif self.api_type == 'dropbox':
res = self.client.media('%s/%s' %
(self.thisfolder, filename))['url']
# something for error
return res
def get_nbviewer_link(self, filename):
file_link = self.get_file_link(filename)
nbv_pfx = 'http://nbviewer.ipython.org/urls'
res = nbv_pfx + '/' + file_link.replace('https://', '')
return res
def get_slideviewer_link(self, filename):
file_link = self.get_file_link(filename)
sv_pfx = 'https://slideviewer.herokuapp.com/urls'
res = sv_pfx + '/' + file_link.replace('https://', '')
return res
