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)
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