def put(self, request, repo_id): """ Copy a single file/folder to other place. """ # check parameter for src path = request.GET.get('path', None) if not path: error_msg = 'path invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) try: dirent = seafile_api.get_dirent_by_path(repo_id, path) except Exception as e: logger.error(e) error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) if not dirent: error_msg = 'File or folder %s not found.' % path return api_error(status.HTTP_404_NOT_FOUND, error_msg) if path == '/': error_msg = 'path invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) # normalize path to '/1/2/3' format # NOT ends with '/' path = normalize_file_path(path) # now get `src_dir` and `obj_name` according to normalized path src_repo_id = repo_id src_dir = os.path.dirname(path) src_obj_name = os.path.basename(path) # check parameter for dst dst_repo_id = request.data.get('dst_repo_id', src_repo_id) if dst_repo_id != src_repo_id and not seafile_api.get_repo(dst_repo_id): error_msg = 'Library %s not found.' % dst_repo_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) dst_dir = request.data.get('dst_dir', '/') if dst_dir != '/': dst_dir = normalize_dir_path(dst_dir) if not seafile_api.get_dir_id_by_path(dst_repo_id, dst_dir): error_msg = 'Folder %s not found.' % dst_dir return api_error(status.HTTP_404_NOT_FOUND, error_msg) # copy file username = request.user.username dst_obj_name = check_filename_with_rename(dst_repo_id, dst_dir, src_obj_name) try: seafile_api.copy_file(src_repo_id, src_dir, src_obj_name, dst_repo_id, dst_dir, dst_obj_name, username, need_progress=0, synchronous=1) except SearpcError as e: logger.error(e) error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) return Response({'success': True, 'dst_item_name': dst_obj_name})
def personal_wiki(request, page_name="home"): username = request.user.username wiki_exists = True try: content, repo, dirent = get_personal_wiki_page(username, page_name) except WikiDoesNotExist: wiki_exists = False owned_repos = seafile_api.get_owned_repo_list(username) owned_repos = [r for r in owned_repos if not r.encrypted] return render_to_response("wiki/personal_wiki.html", { "wiki_exists": wiki_exists, "owned_repos": owned_repos, }, context_instance=RequestContext(request)) except WikiPageMissing: repo = get_personal_wiki_repo(username) filename = page_name_to_file_name(clean_page_name(page_name)) if not seaserv.post_empty_file(repo.id, "/", filename, username): return render_error( request, _("Failed to create wiki page. Please retry later.")) return HttpResponseRedirect(reverse('personal_wiki', args=[page_name])) else: url_prefix = reverse('personal_wiki', args=[]) # fetch file modified time and modifier path = '/' + dirent.obj_name try: dirent = seafile_api.get_dirent_by_path(repo.id, path) if dirent: latest_contributor, last_modified = dirent.modifier, dirent.mtime else: latest_contributor, last_modified = None, 0 except SearpcError as e: logger.error(e) latest_contributor, last_modified = None, 0 wiki_index_exists = True index_pagename = 'index' index_content = None try: index_content, index_repo, index_dirent = get_personal_wiki_page( username, index_pagename) except (WikiDoesNotExist, WikiPageMissing) as e: wiki_index_exists = False return render_to_response( "wiki/personal_wiki.html", { "wiki_exists": wiki_exists, "content": content, "page": os.path.splitext(dirent.obj_name)[0], "last_modified": last_modified, "latest_contributor": latest_contributor or _("Unknown"), "path": path, "repo_id": repo.id, "search_repo_id": repo.id, "search_wiki": True, "wiki_index_exists": wiki_index_exists, "index_content": index_content, }, context_instance=RequestContext(request))
def get_tagged_files(repo, repo_tag_id): # get tagged files tagged_file_objs = FileTags.objects.filter( repo_tag__id=repo_tag_id).select_related('repo_tag', 'file_uuid') tagged_files = defaultdict(list) for tagged_file_obj in tagged_file_objs: parent_path = tagged_file_obj.file_uuid.parent_path filename = tagged_file_obj.file_uuid.filename file_path = posixpath.join(parent_path, filename) tagged_file = dict() file_obj = seafile_api.get_dirent_by_path(repo.store_id, file_path) tagged_file["parent_path"] = parent_path tagged_file["filename"] = filename tagged_file["size"] = file_obj.size tagged_file["last_modified"] = timestamp_to_isoformat_timestr( file_obj.mtime) tagged_file["modifier_email"] = file_obj.modifier tagged_file["modifier_contact_email"] = email2contact_email( file_obj.modifier) tagged_file["modifier_name"] = email2nickname(file_obj.modifier) tagged_files["tagged_files"].append(tagged_file) return tagged_files
def get_file_info(self, username, repo_id, file_path): repo = seafile_api.get_repo(repo_id) file_obj = seafile_api.get_dirent_by_path(repo_id, file_path) file_name = file_obj.obj_name file_size = file_obj.size can_preview, error_msg = can_preview_file(file_name, file_size, repo) can_edit, error_msg = can_edit_file(file_name, file_size, repo) try: is_locked, locked_by_me = check_file_lock(repo_id, file_path, username) except Exception as e: logger.error(e) is_locked = False file_info = { 'type': 'file', 'repo_id': repo_id, 'parent_dir': os.path.dirname(file_path), 'obj_name': file_name, 'obj_id': file_obj.obj_id, 'size': file_size, 'mtime': timestamp_to_isoformat_timestr(file_obj.mtime), 'is_locked': is_locked, 'can_preview': can_preview, 'can_edit': can_edit, } return file_info
def search_files(repos_map, search_path, keyword, obj_desc, start, size, org_id=None): # search file if len(repos_map) > 1: search_path = None files_found, total = es_search(repos_map, search_path, keyword, obj_desc, start, size) result = [] for f in files_found: repo = repos_map.get(f['repo_id'].encode('UTF-8'), None) if not repo: continue if repo.origin_path: if not f['fullpath'].startswith(repo.origin_path): # this operation will reduce the result items, but it will not happen now continue else: f['repo_id'] = repo.repo_id f['fullpath'] = f['fullpath'].split(repo.origin_path)[-1] if not repo.owner: if org_id: repo.owner = seafile_api.get_org_repo_owner(repo.id) else: repo.owner = seafile_api.get_repo_owner(repo.id) # if match multiple files, keep the lookup only once. if not hasattr(repo, 'owner_nickname') or not repo.owner_nickname: repo.owner_nickname = email2nickname(repo.owner) if not hasattr(repo, 'owner_contact_email') or not repo.owner_contact_email: repo.owner_contact_email = email2contact_email(repo.owner) if f['fullpath'] == '/': f['last_modified_by'] = repo.last_modifier f['last_modified'] = repo.last_modify f['size'] = repo.size else: try: dirent = seafile_api.get_dirent_by_path(f['repo_id'], f['fullpath']) except Exception as e: logger.error(e) continue if not dirent: continue f['last_modified_by'] = dirent.modifier f['last_modified'] = dirent.mtime f['size'] = dirent.size f['repo'] = repo f['repo_name'] = repo.name f['repo_owner_email'] = repo.owner f['repo_owner_name'] = repo.owner_nickname f['repo_owner_contact_email'] = repo.owner_contact_email result.append(f) return result, total
def get_tagged_files(repo, repo_tag_id): # get tagged files tagged_file_objs = FileTags.objects.filter( repo_tag__id=repo_tag_id).select_related('repo_tag', 'file_uuid') tagged_files = defaultdict(list) for tagged_file_obj in tagged_file_objs: file_tag_id = tagged_file_obj.pk parent_path = tagged_file_obj.file_uuid.parent_path filename = tagged_file_obj.file_uuid.filename file_path = posixpath.join(parent_path, filename) tagged_file = dict() file_obj = seafile_api.get_dirent_by_path(repo.store_id, file_path) if not file_obj: exception = "Can't find tagged file. Repo_id: %s, Path: %s." % (repo.id, file_path) logger.warning(exception) tagged_file["file_deleted"] = True tagged_file["file_tag_id"] = file_tag_id tagged_file["filename"] = filename tagged_files["tagged_files"].append(tagged_file) continue tagged_file["parent_path"] = parent_path tagged_file["filename"] = filename tagged_file["size"] = file_obj.size tagged_file["mtime"] = file_obj.mtime tagged_file["last_modified"] = timestamp_to_isoformat_timestr(file_obj.mtime) tagged_file["modifier_email"] = file_obj.modifier tagged_file["modifier_contact_email"] = email2contact_email(file_obj.modifier) tagged_file["modifier_name"] = email2nickname(file_obj.modifier) tagged_files["tagged_files"].append(tagged_file) return tagged_files
def get(self, request, repo_id): """ get info of a single file/folder in a library """ repo = seafile_api.get_repo(repo_id) if not repo: error_msg = 'Library %s not found.' % repo_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) if not can_view_sys_admin_repo(repo): error_msg = 'Feature disabled.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) path = request.GET.get('path', None) if not path: error_msg = 'path invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) if path[0] != '/': path = '/' + path try: dirent = seafile_api.get_dirent_by_path(repo_id, path) except SearpcError as e: logger.error(e) error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) if not dirent: error_msg = 'file/folder %s not found.' % path return api_error(status.HTTP_404_NOT_FOUND, error_msg) if stat.S_ISDIR(dirent.mode): is_file = False else: is_file = True username = request.user.username if is_file and request.GET.get('dl', '0') == '1': token = seafile_api.get_fileserver_access_token(repo_id, dirent.obj_id, 'download', username, use_onetime=True) if not token: error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) dl_url = gen_file_get_url(token, dirent.obj_name) send_file_access_msg(request, repo, path, 'web') return Response({'download_url': dl_url}) dirent_info = get_dirent_info(dirent) return Response(dirent_info)
def personal_wiki(request, page_name="home"): username = request.user.username wiki_exists = True try: content, repo, dirent = get_personal_wiki_page(username, page_name) except WikiDoesNotExist: wiki_exists = False owned_repos = seafile_api.get_owned_repo_list(username) owned_repos = [r for r in owned_repos if not r.encrypted] return render_to_response("wiki/personal_wiki.html", { "wiki_exists": wiki_exists, "owned_repos": owned_repos, }, context_instance=RequestContext(request)) except WikiPageMissing: repo = get_personal_wiki_repo(username) filename = clean_page_name(page_name) + '.md' if not seaserv.post_empty_file(repo.id, "/", filename, username): return render_error(request, _("Failed to create wiki page. Please retry later.")) return HttpResponseRedirect(reverse('personal_wiki', args=[page_name])) else: url_prefix = reverse('personal_wiki', args=[]) content = convert_wiki_link(content, url_prefix, repo.id, username) # fetch file modified time and modifier path = '/' + dirent.obj_name try: dirent = seafile_api.get_dirent_by_path(repo.id, path) if dirent: latest_contributor, last_modified = dirent.modifier, dirent.mtime else: latest_contributor, last_modified = None, 0 except SearpcError as e: logger.error(e) latest_contributor, last_modified = None, 0 wiki_index_exists = True index_pagename = 'index' index_content = None try: index_content, index_repo, index_dirent = get_personal_wiki_page(username, index_pagename) except (WikiDoesNotExist, WikiPageMissing) as e: wiki_index_exists = False else: index_content = convert_wiki_link(index_content, url_prefix, index_repo.id, username) return render_to_response("wiki/personal_wiki.html", { "wiki_exists": wiki_exists, "content": content, "page": os.path.splitext(dirent.obj_name)[0], "last_modified": last_modified, "latest_contributor": latest_contributor or _("Unknown"), "path": path, "repo_id": repo.id, "search_repo_id": repo.id, "search_wiki": True, "wiki_index_exists": wiki_index_exists, "index_content": index_content, }, context_instance=RequestContext(request))
def get_share_link_info(fileshare): data = {} token = fileshare.token repo_id = fileshare.repo_id try: repo = seafile_api.get_repo(repo_id) except Exception as e: logger.error(e) repo = None path = fileshare.path if path: obj_name = '/' if path == '/' else os.path.basename(path.rstrip('/')) else: obj_name = '' if fileshare.expire_date: expire_date = datetime_to_isoformat_timestr(fileshare.expire_date) else: expire_date = '' if fileshare.ctime: ctime = datetime_to_isoformat_timestr(fileshare.ctime) else: ctime = '' data['username'] = fileshare.username data['repo_id'] = repo_id data['repo_name'] = repo.repo_name if repo else '' data['path'] = path data['obj_name'] = obj_name data['is_dir'] = True if fileshare.s_type == 'd' else False data['token'] = token data['link'] = gen_shared_link(token, fileshare.s_type) data['view_cnt'] = fileshare.view_cnt data['ctime'] = ctime data['expire_date'] = expire_date data['is_expired'] = fileshare.is_expired() data['permissions'] = fileshare.get_permissions() data['can_edit'] = False if repo and path != '/' and not data['is_dir']: dirent = seafile_api.get_dirent_by_path(repo_id, path) if dirent: try: can_edit, error_msg = can_edit_file(obj_name, dirent.size, repo) data['can_edit'] = can_edit except Exception as e: logger.error(e) else: data['can_edit'] = False return data
def get(self, request, repo_id): """ get info of a single file/folder in a library """ if not request.user.admin_permissions.can_manage_library(): return api_error(status.HTTP_403_FORBIDDEN, 'Permission denied.') repo = seafile_api.get_repo(repo_id) path = request.GET.get('path', None) if not path: error_msg = 'path invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) path = normalize_file_path(path) try: dirent = seafile_api.get_dirent_by_path(repo_id, path) except SearpcError as e: logger.error(e) error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) if not dirent: error_msg = 'File or folder %s not found.' % path return api_error(status.HTTP_404_NOT_FOUND, error_msg) if stat.S_ISDIR(dirent.mode): is_file = False else: is_file = True username = request.user.username if is_file and request.GET.get('dl', '0') == '1': token = seafile_api.get_fileserver_access_token( repo_id, dirent.obj_id, 'download', username, use_onetime=settings.FILESERVER_TOKEN_ONCE_ONLY) if not token: error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) dl_url = gen_file_get_url(token, dirent.obj_name) send_file_access_msg(request, repo, path, 'web') return Response({'download_url': dl_url}) dirent_info = get_dirent_info(dirent) return Response(dirent_info)
def get(self, request, repo_id): """ Get dir info. Permission checking: 1. user with either 'r' or 'rw' permission. """ # parameter check path = request.GET.get('path', None) if not path: error_msg = 'path invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) path = normalize_dir_path(path) if path == '/': error_msg = 'path invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) # resource check repo = seafile_api.get_repo(repo_id) if not repo: error_msg = 'Library %s not found.' % repo_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) dir_id = seafile_api.get_dir_id_by_path(repo_id, path) if not dir_id: error_msg = 'Folder %s not found.' % path return api_error(status.HTTP_404_NOT_FOUND, error_msg) # permission check if not check_folder_permission(request, repo_id, path): error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) try: dir_obj = seafile_api.get_dirent_by_path(repo_id, path) count_info = seafile_api.get_file_count_info_by_path(repo_id, path) except SearpcError as e: logger.error(e) error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) dir_info = { 'repo_id': repo_id, 'path': path, 'name': dir_obj.obj_name, 'file_count': count_info.file_count, 'dir_count': count_info.dir_count, 'size': count_info.size, 'mtime': timestamp_to_isoformat_timestr(dir_obj.mtime), } return Response(dir_info)
def get_related_file(self, r_repo_id, r_file_path, r_uuid): related_file = dict() related_file["name"] = r_uuid.filename related_file["repo_id"] = r_repo_id r_repo = seafile_api.get_repo(r_repo_id) if not r_repo: related_file["repo_name"] = "" related_file["repo_name"] = r_repo.name related_file["path"] = r_file_path file_obj = seafile_api.get_dirent_by_path(r_repo_id, r_file_path) related_file["size"] = file_obj.size related_file["last_modified"] = timestamp_to_isoformat_timestr(file_obj.mtime) return related_file
def get_dir_info(self, repo_id, dir_path): dir_obj = seafile_api.get_dirent_by_path(repo_id, dir_path) dir_info = { 'type': 'dir', 'repo_id': repo_id, 'parent_dir': os.path.dirname(dir_path.rstrip('/')), 'obj_name': dir_obj.obj_name, 'obj_id': dir_obj.obj_id, 'mtime': timestamp_to_isoformat_timestr(dir_obj.mtime), } return dir_info
def get(self, request, repo_id): """ Get dir info. Permission checking: 1. user with either 'r' or 'rw' permission. """ # parameter check path = request.GET.get('path', None) if not path: error_msg = 'path invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) path = normalize_dir_path(path) if path == '/': error_msg = 'path invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) # resource check repo = seafile_api.get_repo(repo_id) if not repo: error_msg = 'Library %s not found.' % repo_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) dir_id = seafile_api.get_dir_id_by_path(repo_id, path) if not dir_id: error_msg = 'Folder %s not found.' % path return api_error(status.HTTP_404_NOT_FOUND, error_msg) # permission check if not check_folder_permission(request, repo_id, path): error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) try: dir_obj = seafile_api.get_dirent_by_path(repo_id, path) except SearpcError as e: logger.error(e) error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) dir_info = { 'repo_id': repo_id, 'path': path, 'name': dir_obj.obj_name, 'mtime': timestamp_to_isoformat_timestr(dir_obj.mtime), } return Response(dir_info)
def get(self, request, repo_id): """ get info of a single file/folder in a library """ repo = seafile_api.get_repo(repo_id) if not repo: error_msg = 'Library %s not found.' % repo_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) if not can_view_sys_admin_repo(repo): error_msg = 'Feature disabled.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) path = request.GET.get('path', None) if not path: error_msg = 'path invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) if path[0] != '/': path = '/' + path try: dirent = seafile_api.get_dirent_by_path(repo_id, path) except SearpcError as e: logger.error(e) error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) if not dirent: error_msg = 'file/folder %s not found.' % path return api_error(status.HTTP_404_NOT_FOUND, error_msg) if stat.S_ISDIR(dirent.mode): is_file = False else: is_file = True username = request.user.username if is_file and request.GET.get('dl', '0') == '1': token = seafile_api.get_fileserver_access_token(repo_id, dirent.obj_id, 'download', username, use_onetime=True) dl_url = gen_file_get_url(token, dirent.obj_name) send_file_access_msg(request, repo, path, 'web') return Response({'download_url': dl_url}) dirent_info = get_dirent_info(dirent) return Response(dirent_info)
def get_file_info(self, username, repo_id, file_path): file_obj = seafile_api.get_dirent_by_path(repo_id, file_path) is_locked, locked_by_me = check_file_lock(repo_id, file_path, username) file_info = { 'type': 'file', 'repo_id': repo_id, 'parent_dir': os.path.dirname(file_path), 'obj_name': file_obj.obj_name, 'obj_id': file_obj.obj_id, 'size': file_obj.size, 'mtime': timestamp_to_isoformat_timestr(file_obj.mtime), 'is_locked': is_locked, } return file_info
def post(self, request, repo_id, format=None): """ create file/folder in a library """ repo = seafile_api.get_repo(repo_id) if not repo: error_msg = 'Library %s not found.' % repo_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) if not can_view_sys_admin_repo(repo): error_msg = 'Feature disabled.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) parent_dir = request.GET.get('parent_dir', '/') if not parent_dir: error_msg = 'parent_dir invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) if parent_dir[-1] != '/': parent_dir = parent_dir + '/' dir_id = seafile_api.get_dir_id_by_path(repo_id, parent_dir) if not dir_id: error_msg = 'Folder %s not found.' % parent_dir return api_error(status.HTTP_404_NOT_FOUND, error_msg) obj_name = request.data.get('obj_name', None) if not obj_name or not seafile_api.is_valid_filename( repo_id, obj_name): error_msg = 'obj_name invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) obj_name = check_filename_with_rename(repo_id, parent_dir, obj_name) username = request.user.username try: seafile_api.post_dir(repo_id, parent_dir, obj_name, username) except SearpcError as e: logger.error(e) error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) dirent_path = posixpath.join(parent_dir, obj_name) dirent = seafile_api.get_dirent_by_path(repo_id, dirent_path) dirent_info = get_dirent_info(dirent) return Response(dirent_info)
def get(self, request, repo_id): """ get info of a single file/folder in a library """ repo = seafile_api.get_repo(repo_id) path = request.GET.get('path', None) if not path: error_msg = 'path invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) path = normalize_file_path(path) try: dirent = seafile_api.get_dirent_by_path(repo_id, path) except SearpcError as e: logger.error(e) error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) if not dirent: error_msg = 'File or folder %s not found.' % path return api_error(status.HTTP_404_NOT_FOUND, error_msg) if stat.S_ISDIR(dirent.mode): is_file = False else: is_file = True username = request.user.username if is_file and request.GET.get('dl', '0') == '1': token = seafile_api.get_fileserver_access_token( repo_id, dirent.obj_id, 'download', username, use_onetime=settings.FILESERVER_TOKEN_ONCE_ONLY) if not token: error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) dl_url = gen_file_get_url(token, dirent.obj_name) send_file_access_msg(request, repo, path, 'web') return Response({'download_url': dl_url}) dirent_info = get_dirent_info(dirent) return Response(dirent_info)
def post(self, request, repo_id, format=None): """ create file/folder in a library """ repo = seafile_api.get_repo(repo_id) if not repo: error_msg = 'Library %s not found.' % repo_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) if not can_view_sys_admin_repo(repo): error_msg = 'Feature disabled.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) parent_dir = request.GET.get('parent_dir', '/') if not parent_dir: error_msg = 'parent_dir invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) if parent_dir[-1] != '/': parent_dir = parent_dir + '/' dir_id = seafile_api.get_dir_id_by_path(repo_id, parent_dir) if not dir_id: error_msg = 'Folder %s not found.' % parent_dir return api_error(status.HTTP_404_NOT_FOUND, error_msg) obj_name = request.data.get('obj_name', None) if not obj_name or not seafile_api.is_valid_filename(repo_id, obj_name): error_msg = 'obj_name invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) obj_name = check_filename_with_rename(repo_id, parent_dir, obj_name) username = request.user.username try: seafile_api.post_dir(repo_id, parent_dir, obj_name, username) except SearpcError as e: logger.error(e) error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) dirent_path = posixpath.join(parent_dir, obj_name) dirent = seafile_api.get_dirent_by_path(repo_id, dirent_path) dirent_info = get_dirent_info(dirent) return Response(dirent_info)
def get(self, request, repo_id): """ Get dir info. Permission checking: 1. user with either 'r' or 'rw' permission. """ # parameter check path = request.GET.get('path', None) if not path: error_msg = 'path invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) path = normalize_dir_path(path) if path == '/': error_msg = 'path invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) # resource check repo = seafile_api.get_repo(repo_id) if not repo: error_msg = 'Library %s not found.' % repo_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) dir_id = seafile_api.get_dir_id_by_path(repo_id, path) if not dir_id: error_msg = 'Folder %s not found.' % path return api_error(status.HTTP_404_NOT_FOUND, error_msg) # permission check permission = check_folder_permission(request, repo_id, path) if not permission: error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) dir_obj = seafile_api.get_dirent_by_path(repo_id, path) dir_info = { 'repo_id': repo_id, 'path': path, 'name': dir_obj.obj_name if dir_obj else '', 'mtime': timestamp_to_isoformat_timestr(dir_obj.mtime) if dir_obj else '', 'permission': permission, } return Response(dir_info)
def get_wiki_page_object(wiki_object, page_name): page_name = clean_page_name(page_name) filepath = "/" + page_name + ".md" repo_id = wiki_object.repo_id try: dirent = seafile_api.get_dirent_by_path(repo_id, filepath) if dirent: latest_contributor, last_modified = dirent.modifier, dirent.mtime else: latest_contributor, last_modified = None, 0 except SearpcError as e: logger.error(e) latest_contributor, last_modified = None, 0 try: repo = seafile_api.get_repo(wiki_object.repo_id) except SearpcError as e: logger.error(e) file_url = get_inner_file_url(repo, dirent.obj_id, dirent.obj_name) edit_url = get_site_scheme_and_netloc().rstrip('/') + "%s?p=%s" % ( reverse('file_edit', args=[repo_id]), urlquote(filepath.encode('utf-8'))) slug = wiki_object.slug page_url = get_site_scheme_and_netloc().rstrip('/') + reverse('wiki:slug', args=[slug, page_name]) # FIX ME: move to top after wiki code refactor from seahub.base.templatetags.seahub_tags import email2nickname, \ email2contact_email return {"name": page_name, "link": page_url, "file_link": file_url, "file_edit_link": edit_url, "updated_at": timestamp_to_isoformat_timestr(last_modified), "last_modifier": latest_contributor, "last_modifier_contact_email": email2contact_email(latest_contributor), "last_modifier_name": email2nickname(latest_contributor), }
def get_wiki_page_object(wiki_object, page_name): page_name = clean_page_name(page_name) filepath = "/" + page_name + ".md" repo_id = wiki_object.repo_id try: dirent = seafile_api.get_dirent_by_path(repo_id, filepath) if dirent: latest_contributor, last_modified = dirent.modifier, dirent.mtime else: latest_contributor, last_modified = None, 0 except SearpcError as e: logger.error(e) latest_contributor, last_modified = None, 0 try: repo = seafile_api.get_repo(wiki_object.repo_id) except SearpcError as e: logger.error(e) file_url = get_inner_file_url(repo, dirent.obj_id, dirent.obj_name) edit_url = get_site_scheme_and_netloc().rstrip('/') + "%s?p=%s" % (reverse( 'file_edit', args=[repo_id]), urlquote(filepath.encode('utf-8'))) slug = wiki_object.slug page_url = get_site_scheme_and_netloc().rstrip('/') + reverse( 'wiki:slug', args=[slug, page_name]) # FIX ME: move to top after wiki code refactor from seahub.base.templatetags.seahub_tags import email2nickname, \ email2contact_email return { "name": page_name, "link": page_url, "file_link": file_url, "file_edit_link": edit_url, "updated_at": timestamp_to_isoformat_timestr(last_modified), "last_modifier": latest_contributor, "last_modifier_contact_email": email2contact_email(latest_contributor), "last_modifier_name": email2nickname(latest_contributor), }
def post(self, request, repo_id, format=None): """ create file/folder in a library """ if not request.user.admin_permissions.can_manage_library(): return api_error(status.HTTP_403_FORBIDDEN, 'Permission denied.') parent_dir = request.GET.get('parent_dir', '/') parent_dir = normalize_dir_path(parent_dir) dir_id = seafile_api.get_dir_id_by_path(repo_id, parent_dir) if not dir_id: error_msg = 'Folder %s not found.' % parent_dir return api_error(status.HTTP_404_NOT_FOUND, error_msg) obj_name = request.data.get('obj_name', None) if not obj_name or not is_valid_dirent_name(obj_name): error_msg = 'obj_name invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) is_file = request.data.get('is_file', 'false') is_file = is_file.lower() if is_file not in ('true', 'false'): error_msg = 'is_file invalid.' username = request.user.username obj_name = check_filename_with_rename(repo_id, parent_dir, obj_name) try: if is_file == 'true': seafile_api.post_empty_file(repo_id, parent_dir, obj_name, username) else: seafile_api.post_dir(repo_id, parent_dir, obj_name, username) except SearpcError as e: logger.error(e) error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) dirent_path = posixpath.join(parent_dir, obj_name) dirent = seafile_api.get_dirent_by_path(repo_id, dirent_path) dirent_info = get_dirent_info(dirent) return Response(dirent_info)
def post(self, request): repo_id = request.POST.get('repo_id', '') file_path = request.POST.get('file_path', '') # new draft repo = seafile_api.get_repo(repo_id) if not repo: error_msg = 'Library %s not found.' % repo_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) # perm check perm = check_folder_permission(request, repo.id, file_path) if perm is None: error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) file_id = seafile_api.get_file_id_by_path(repo.id, file_path) if not file_id: return api_error(status.HTTP_404_NOT_FOUND, "File %s not found" % file_path) username = request.user.username dirent = seafile_api.get_dirent_by_path(repo_id, file_path) try: d = Draft.objects.add(dirent.modifier, repo, file_path, file_id) except (DraftFileExist, IntegrityError): return api_error(status.HTTP_409_CONFLICT, 'Draft already exists.') # new review try: r = DraftReview.objects.add(creator=dirent.modifier, draft=d) except (DraftReviewExist): return api_error(status.HTTP_409_CONFLICT, 'Draft review already exists.') # new reviewer if username != d.username: ReviewReviewer.objects.add(username, r) return Response(r.to_dict())
def get(self, request, workspace_id, name): """ check wether an asset exists by path """ table_name = name path = request.query_params.get('path', '').lstrip('/') if not path: error_msg = 'path invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) # resource check workspace = Workspaces.objects.get_workspace_by_id(workspace_id) if not workspace: error_msg = 'Workspace %s not found.' % workspace_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) repo_id = workspace.repo_id repo = seafile_api.get_repo(repo_id) if not repo: error_msg = 'Library %s not found.' % repo_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) dtable = DTables.objects.get_dtable(workspace, table_name) if not dtable: error_msg = 'dtable %s not found.' % table_name return api_error(status.HTTP_404_NOT_FOUND, error_msg) asset_path = os.path.join('/asset', str(dtable.uuid), path) try: dir = seafile_api.get_dirent_by_path(repo_id, asset_path) except Exception as e: logger.error(e) return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, 'Internal Server Error') res = {} res['is_exist'] = True if dir else False return Response(res)
def post(self, request, repo_id, format=None): """ create file/folder in a library """ parent_dir = request.GET.get('parent_dir', '/') parent_dir = normalize_dir_path(parent_dir) dir_id = seafile_api.get_dir_id_by_path(repo_id, parent_dir) if not dir_id: error_msg = 'Folder %s not found.' % parent_dir return api_error(status.HTTP_404_NOT_FOUND, error_msg) obj_name = request.data.get('obj_name', None) if not obj_name or not is_valid_dirent_name(obj_name): error_msg = 'obj_name invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) is_file = request.data.get('is_file', 'false') is_file = is_file.lower() if is_file not in ('true', 'false'): error_msg = 'is_file invalid.' username = request.user.username obj_name = check_filename_with_rename(repo_id, parent_dir, obj_name) try: if is_file == 'true': seafile_api.post_empty_file(repo_id, parent_dir, obj_name, username) else: seafile_api.post_dir(repo_id, parent_dir, obj_name, username) except SearpcError as e: logger.error(e) error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) dirent_path = posixpath.join(parent_dir, obj_name) dirent = seafile_api.get_dirent_by_path(repo_id, dirent_path) dirent_info = get_dirent_info(dirent) return Response(dirent_info)
def get_tagged_files(repo, repo_tag_id): # get tagged files tagged_file_objs = FileTags.objects.filter( repo_tag__id=repo_tag_id).select_related('repo_tag', 'file_uuid') tagged_files = defaultdict(list) for tagged_file_obj in tagged_file_objs: file_tag_id = tagged_file_obj.pk parent_path = tagged_file_obj.file_uuid.parent_path filename = tagged_file_obj.file_uuid.filename file_path = posixpath.join(parent_path, filename) tagged_file = dict() file_obj = seafile_api.get_dirent_by_path(repo.store_id, file_path) if not file_obj: exception = "Can't find tagged file. Repo_id: %s, Path: %s." % (repo.id, file_path) logger.warning(exception) tagged_file["file_deleted"] = True tagged_file["file_tag_id"] = file_tag_id tagged_file["filename"] = filename tagged_files["tagged_files"].append(tagged_file) continue tagged_file["file_tag_id"] = file_tag_id tagged_file["parent_path"] = parent_path tagged_file["filename"] = filename tagged_file["size"] = file_obj.size tagged_file["mtime"] = file_obj.mtime tagged_file["last_modified"] = timestamp_to_isoformat_timestr(file_obj.mtime) tagged_file["modifier_email"] = file_obj.modifier tagged_file["modifier_contact_email"] = email2contact_email(file_obj.modifier) tagged_file["modifier_name"] = email2nickname(file_obj.modifier) tagged_files["tagged_files"].append(tagged_file) return tagged_files
def get_starred_item_info(self, repo, starred_item): item_info = {} repo_id = starred_item.repo_id item_info['repo_id'] = repo_id item_info['repo_name'] = repo.repo_name if repo else '' item_info['repo_encrypted'] = repo.encrypted item_info['is_dir'] = starred_item.is_dir path = starred_item.path item_info['path'] = path if path == '/': item_info['obj_name'] = repo.repo_name if repo else '' item_info['mtime'] = timestamp_to_isoformat_timestr(repo.last_modified) if \ repo else '' else: item_info['obj_name'] = os.path.basename(path.rstrip('/')) dirent = seafile_api.get_dirent_by_path(repo_id, path) item_info['mtime'] = timestamp_to_isoformat_timestr(dirent.mtime) if \ dirent else '' return item_info
def get_starred_item_info(self, repo, starred_item): item_info = {} repo_id = starred_item.repo_id item_info['repo_id'] = repo_id item_info['repo_name'] = repo.repo_name if repo else '' item_info['repo_encrypted'] = repo.encrypted item_info['is_dir'] = starred_item.is_dir path = starred_item.path item_info['path'] = path if path == '/': item_info['obj_name'] = repo.repo_name if repo else '' item_info['mtime'] = timestamp_to_isoformat_timestr(repo.last_modified) if \ repo else '' else: item_info['obj_name'] = os.path.basename(path.rstrip('/')) dirent = seafile_api.get_dirent_by_path(repo_id, path) item_info['mtime'] = timestamp_to_isoformat_timestr(dirent.mtime) if \ dirent else '' if not starred_item.is_dir: file_type, file_ext = get_file_type_and_ext( item_info['obj_name']) if file_type in (IMAGE, XMIND) or \ (file_type == VIDEO and ENABLE_VIDEO_THUMBNAIL): thumbnail_size = THUMBNAIL_DEFAULT_SIZE thumbnail_file_path = os.path.join(THUMBNAIL_ROOT, str(thumbnail_size), dirent.obj_id) if os.path.exists(thumbnail_file_path): src = get_thumbnail_src(repo_id, thumbnail_size, path) item_info['encoded_thumbnail_src'] = urlquote(src) return item_info
def get(self, request, file_id, format=None): """ WOPI endpoint for check file info """ token = request.GET.get('access_token', None) info_dict = get_file_info_by_token(token) request_user = info_dict['request_user'] repo_id = info_dict['repo_id'] file_path = info_dict['file_path'] obj_id = info_dict['obj_id'] can_edit = info_dict['can_edit'] can_download = info_dict['can_download'] repo = seafile_api.get_repo(repo_id) if not obj_id: # if not cache file obj_id, then get it from seafile_api obj_id = seafile_api.get_file_id_by_path(repo_id, file_path) try: file_size = seafile_api.get_file_size(repo.store_id, repo.version, obj_id) except SearpcError as e: logger.error(e) return HttpResponse(json.dumps({}), status=500, content_type=json_content_type) if file_size == -1: logger.error('File %s not found.' % file_path) return HttpResponse(json.dumps({}), status=401, content_type=json_content_type) result = {} # necessary result['BaseFileName'] = os.path.basename(file_path) result['Size'] = file_size result['UserId'] = request_user result['Version'] = obj_id result['LastModifiedTime'] = '' try: if is_pro_version(): result['OwnerId'] = seafile_api.get_repo_owner(repo_id) or \ seafile_api.get_org_repo_owner(repo_id) else: result['OwnerId'] = seafile_api.get_repo_owner(repo_id) dirent = seafile_api.get_dirent_by_path(repo_id, file_path) if dirent: last_modified = datetime.datetime.utcfromtimestamp( dirent.mtime) result['LastModifiedTime'] = last_modified.isoformat() except Exception as e: logger.error(e) return HttpResponse(json.dumps({}), status=500, content_type=json_content_type) # optional if request_user != ANONYMOUS_EMAIL: result['UserFriendlyName'] = email2nickname(request_user) result['IsAnonymousUser'] = False else: result['IsAnonymousUser'] = True absolute_uri = request.build_absolute_uri('/') result['PostMessageOrigin'] = urllib.parse.urljoin( absolute_uri, SITE_ROOT).strip('/') result['HideSaveOption'] = True result['HideExportOption'] = True result['EnableOwnerTermination'] = True result['SupportsLocks'] = True result['SupportsGetLock'] = True result['DisablePrint'] = True if not can_download else False result['HidePrintOption'] = True if not can_download else False result['SupportsUpdate'] = True if can_edit else False result['UserCanWrite'] = True if can_edit else False result['ReadOnly'] = True if not can_edit else False # new file creation feature is not implemented on wopi host(seahub) # hide save as button on view/edit file page result['UserCanNotWriteRelative'] = True return HttpResponse(json.dumps(result), status=200, content_type=json_content_type)
def get(self, request, name=None): username = request.user.username org_id = request.user.org.org_id if is_org_context(request) else None owned_repos, shared_repos, groups_repos, public_repos = get_user_repos( username, org_id=org_id) repo_id_list =\ [repo.id for repo in owned_repos] + \ [repo.id for repo in shared_repos] + \ [repo.id for repo in groups_repos] + \ [repo.id for repo in public_repos] if name is None: def with_quotes(s): return "'" + s + "'" # sql = """ # SELECT DISTINCT t.* FROM tags_tags t # LEFT JOIN tags_filetag f ON t.id = f.tag_id # LEFT JOIN tags_fileuuidmap m ON f.uuid_id = m.uuid # WHERE m.repo_id IN (%(repo_id_list)s) # """ # tag_list = Tags.objects.raw(sql, {'repo_id_list': repo_id_list}) repo_id_text = ', '.join(map(with_quotes, repo_id_list)) sql = """ SELECT DISTINCT t.* FROM tags_tags t LEFT JOIN tags_filetag f ON t.id = f.tag_id LEFT JOIN tags_fileuuidmap m ON f.uuid_id = m.uuid WHERE m.repo_id IN ({}) """.format(repo_id_text) tag_list = Tags.objects.raw(sql) tag_list = [tag.to_dict() for tag in tag_list] return Response(tag_list, status=status.HTTP_200_OK) else: tag = get_object_or_404(Tags, name=name) fileuuidmap_list = tag.fileuuidmap_set.all() repo = None dir_list = [] file_list = [] for fileuuidmap in fileuuidmap_list: if repo is None or repo.id != fileuuidmap.repo_id: repo = seafile_api.get_repo(fileuuidmap.repo_id) fullpath = posixpath.join(fileuuidmap.parent_path, fileuuidmap.filename) dirent = seafile_api.get_dirent_by_path( fileuuidmap.repo_id, fullpath) dirent.repo_id = repo.id dirent.parent_path = fileuuidmap.parent_path dirent.fullpath = fullpath dirent.last_modified = dirent.mtime if stat.S_ISDIR(dirent.mode): dir_list.append(dirent) else: if repo.version == 0: file_size = seafile_api.get_file_size( repo.store_id, repo.version, dirent.obj_id) else: file_size = dirent.size dirent.file_size = file_size if file_size else 0 can_preview, err_msg = can_preview_file( dirent.obj_name, file_size, repo) dirent.can_preview = can_preview file_list.append(dirent) dirent_list = [] for d in dir_list: d_ = { 'is_dir': True, 'obj_name': d.obj_name, 'last_modified': d.last_modified, 'last_update': translate_seahub_time(d.last_modified), 'p_dpath': d.fullpath, 'perm': d.permission, 'repo_id': d.repo_id, 'parent_path': d.parent_path, } dirent_list.append(d_) size = int( request.GET.get('thumbnail_size', THUMBNAIL_DEFAULT_SIZE)) for f in file_list: f_ = { 'is_file': True, 'obj_name': f.obj_name, 'last_modified': f.last_modified, 'last_update': translate_seahub_time(f.last_modified), 'file_size': filesizeformat(f.file_size), 'obj_id': f.obj_id, 'perm': f.permission, 'can_preview': f.can_preview, 'repo_id': f.repo_id, 'parent_path': f.parent_path, } if not repo.encrypted and ENABLE_THUMBNAIL: file_ext = os.path.splitext(f.obj_name)[1][1:].lower() file_type = FILEEXT_TYPE_MAP.get(file_ext) if file_type == IMAGE: f_['is_img'] = True if file_type == VIDEO and ENABLE_VIDEO_THUMBNAIL: f_['is_video'] = True if file_type == IMAGE or file_type == VIDEO and ENABLE_VIDEO_THUMBNAIL: thumbnail_file_path = os.path.join( THUMBNAIL_ROOT, str(size), f.obj_id) thumbnail_exist = os.path.exists(thumbnail_file_path) if thumbnail_exist: src = get_thumbnail_src(f.repo_id, size, f.fullpath) f_['encoded_thumbnail_src'] = urlquote(src) dirent_list.append(f_) return Response(dirent_list, status=status.HTTP_200_OK)
def put(self, request, token): """ Update share link, currently only available for permission. Permission checking: share link creater """ # argument check try: perm = check_permissions_arg(request) except Exception: error_msg = 'permissions invalud.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) # resource check try: fs = FileShare.objects.get(token=token) except FileShare.DoesNotExist: error_msg = 'token %s not found.' % token return api_error(status.HTTP_404_NOT_FOUND, error_msg) repo_id = fs.repo_id repo = seafile_api.get_repo(repo_id) if not repo_id: error_msg = 'Library %s not found.' % repo_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) if fs.path != '/': dirent = seafile_api.get_dirent_by_path(repo_id, fs.path) if not dirent: error_msg = 'Dirent %s not found.' % repo_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) # permission check username = request.user.username if not fs.is_owner(username): error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) # get permission of origin repo/folder if fs.s_type == 'd': folder_path = normalize_dir_path(fs.path) else: file_path = normalize_file_path(fs.path) folder_path = os.path.dirname(file_path) username = request.user.username repo_folder_permission = seafile_api.check_permission_by_path(repo_id, folder_path, username) if not repo_folder_permission: error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) if repo_folder_permission in (PERMISSION_PREVIEW_EDIT, PERMISSION_PREVIEW) \ and perm != FileShare.PERM_VIEW_ONLY: error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) if repo_folder_permission in (PERMISSION_READ) \ and perm not in (FileShare.PERM_VIEW_DL, FileShare.PERM_VIEW_ONLY): error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) if fs.s_type == 'f': file_name = os.path.basename(fs.path.rstrip('/')) can_edit, error_msg = can_edit_file(file_name, dirent.size, repo) if not can_edit and perm in (FileShare.PERM_EDIT_DL, FileShare.PERM_EDIT_ONLY): error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) # update share link permission fs.permission = perm fs.save() link_info = get_share_link_info(fs) return Response(link_info)
def post(self, request): """ Create share link. Permission checking: 1. default(NOT guest) user; """ # argument check repo_id = request.data.get('repo_id', None) if not repo_id: error_msg = 'repo_id invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) path = request.data.get('path', None) if not path: error_msg = 'path invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) password = request.data.get('password', None) if password and len(password) < config.SHARE_LINK_PASSWORD_MIN_LENGTH: error_msg = _('Password is too short.') return api_error(status.HTTP_400_BAD_REQUEST, error_msg) expire_days = request.data.get('expire_days', '') expiration_time = request.data.get('expiration_time', '') if expire_days and expiration_time: error_msg = 'Can not pass expire_days and expiration_time at the same time.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) expire_date = None if expire_days: try: expire_days = int(expire_days) except ValueError: error_msg = 'expire_days invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) if expire_days <= 0: error_msg = 'expire_days invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) if SHARE_LINK_EXPIRE_DAYS_MIN > 0: if expire_days < SHARE_LINK_EXPIRE_DAYS_MIN: error_msg = _('Expire days should be greater or equal to %s') % \ SHARE_LINK_EXPIRE_DAYS_MIN return api_error(status.HTTP_400_BAD_REQUEST, error_msg) if SHARE_LINK_EXPIRE_DAYS_MAX > 0: if expire_days > SHARE_LINK_EXPIRE_DAYS_MAX: error_msg = _('Expire days should be less than or equal to %s') % \ SHARE_LINK_EXPIRE_DAYS_MAX return api_error(status.HTTP_400_BAD_REQUEST, error_msg) expire_date = timezone.now() + relativedelta(days=expire_days) elif expiration_time: try: expire_date = dateutil.parser.isoparse(expiration_time) except Exception as e: logger.error(e) error_msg = 'expiration_time invalid, should be iso format, for example: 2020-05-17T10:26:22+08:00' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) expire_date = expire_date.astimezone(get_current_timezone()).replace(tzinfo=None) if SHARE_LINK_EXPIRE_DAYS_MIN > 0: expire_date_min_limit = timezone.now() + relativedelta(days=SHARE_LINK_EXPIRE_DAYS_MIN) expire_date_min_limit = expire_date_min_limit.replace(hour=0).replace(minute=0).replace(second=0) if expire_date < expire_date_min_limit: error_msg = _('Expiration time should be later than %s.') % \ expire_date_min_limit.strftime("%Y-%m-%d %H:%M:%S") return api_error(status.HTTP_400_BAD_REQUEST, error_msg) if SHARE_LINK_EXPIRE_DAYS_MAX > 0: expire_date_max_limit = timezone.now() + relativedelta(days=SHARE_LINK_EXPIRE_DAYS_MAX) expire_date_max_limit = expire_date_max_limit.replace(hour=23).replace(minute=59).replace(second=59) if expire_date > expire_date_max_limit: error_msg = _('Expiration time should be earlier than %s.') % \ expire_date_max_limit.strftime("%Y-%m-%d %H:%M:%S") return api_error(status.HTTP_400_BAD_REQUEST, error_msg) else: if SHARE_LINK_EXPIRE_DAYS_DEFAULT > 0: expire_date = timezone.now() + relativedelta(days=SHARE_LINK_EXPIRE_DAYS_DEFAULT) try: perm = check_permissions_arg(request) except Exception: error_msg = 'permissions invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) # resource check repo = seafile_api.get_repo(repo_id) if not repo: error_msg = 'Library %s not found.' % repo_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) if path != '/': dirent = seafile_api.get_dirent_by_path(repo_id, path) if not dirent: error_msg = 'Dirent %s not found.' % path return api_error(status.HTTP_404_NOT_FOUND, error_msg) # permission check if repo.encrypted: error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) username = request.user.username repo_folder_permission = seafile_api.check_permission_by_path(repo_id, path, username) if parse_repo_perm(repo_folder_permission).can_generate_share_link is False: error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) if repo_folder_permission in (PERMISSION_PREVIEW_EDIT, PERMISSION_PREVIEW) \ and perm != FileShare.PERM_VIEW_ONLY: error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) if repo_folder_permission in (PERMISSION_READ) \ and perm not in (FileShare.PERM_VIEW_DL, FileShare.PERM_VIEW_ONLY): error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) # can_upload requires rw repo permission if perm == FileShare.PERM_VIEW_DL_UPLOAD and \ repo_folder_permission != PERMISSION_READ_WRITE: error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) if path != '/': s_type = 'd' if stat.S_ISDIR(dirent.mode) else 'f' if s_type == 'f': file_name = os.path.basename(path.rstrip('/')) can_edit, error_msg = can_edit_file(file_name, dirent.size, repo) if not can_edit and perm in (FileShare.PERM_EDIT_DL, FileShare.PERM_EDIT_ONLY): error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) else: s_type = 'd' # create share link org_id = request.user.org.org_id if is_org_context(request) else None if s_type == 'f': fs = FileShare.objects.get_file_link_by_path(username, repo_id, path) if fs: error_msg = _('Share link %s already exists.' % fs.token) return api_error(status.HTTP_400_BAD_REQUEST, error_msg) fs = FileShare.objects.create_file_link(username, repo_id, path, password, expire_date, permission=perm, org_id=org_id) elif s_type == 'd': fs = FileShare.objects.get_dir_link_by_path(username, repo_id, path) if fs: error_msg = _('Share link %s already exists.' % fs.token) return api_error(status.HTTP_400_BAD_REQUEST, error_msg) fs = FileShare.objects.create_dir_link(username, repo_id, path, password, expire_date, permission=perm, org_id=org_id) link_info = get_share_link_info(fs) return Response(link_info)
def get(self, request): """ Get all share links of a user. Permission checking: 1. default(NOT guest) user; """ username = request.user.username repo_id = request.GET.get('repo_id', '') path = request.GET.get('path', '') fileshares = [] # get all share links of current user if not repo_id and not path: fileshares = FileShare.objects.filter(username=username) # share links in repo if repo_id and not path: repo = seafile_api.get_repo(repo_id) if not repo: error_msg = 'Library %s not found.' % repo_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) fileshares = FileShare.objects.filter(username=username) \ .filter(repo_id=repo_id) # share links by repo and path if repo_id and path: repo = seafile_api.get_repo(repo_id) if not repo: error_msg = 'Library %s not found.' % repo_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) if path != '/': dirent = seafile_api.get_dirent_by_path(repo_id, path) if not dirent: error_msg = 'Dirent %s not found.' % path return api_error(status.HTTP_404_NOT_FOUND, error_msg) if stat.S_ISDIR(dirent.mode): path = normalize_dir_path(path) else: path = normalize_file_path(path) fileshares = FileShare.objects.filter(username=username) \ .filter(repo_id=repo_id) \ .filter(path=path) repo_folder_permission_dict = {} for fileshare in fileshares: if fileshare.s_type == 'd': folder_path = normalize_dir_path(fileshare.path) else: file_path = normalize_file_path(fileshare.path) folder_path = os.path.dirname(file_path) repo_id = fileshare.repo_id if repo_id not in repo_folder_permission_dict: try: permission = seafile_api.check_permission_by_path(repo_id, folder_path, fileshare.username) except Exception as e: logger.error(e) permission = '' repo_folder_permission_dict[repo_id] = permission links_info = [] for fs in fileshares: link_info = get_share_link_info(fs) link_info['repo_folder_permission'] = \ repo_folder_permission_dict.get(link_info['repo_id'], '') links_info.append(link_info) if len(links_info) == 1: result = links_info else: dir_list = [x for x in links_info if x['is_dir']] file_list = [x for x in links_info if not x['is_dir']] dir_list.sort(key=lambda x: x['obj_name']) file_list.sort(key=lambda x: x['obj_name']) result = dir_list + file_list return Response(result)
def get_starred_files_by_username(self, username): """Get a user's starred files. Arguments: - `self`: - `username`: """ starred_files = super(UserStarredFilesManager, self).filter( email=username, org_id=-1) ret = [] repo_cache = {} for sfile in starred_files: # repo still exists? if repo_cache.has_key(sfile.repo_id): repo = repo_cache[sfile.repo_id] else: try: repo = seafile_api.get_repo(sfile.repo_id) except SearpcError: continue if repo is not None: repo_cache[sfile.repo_id] = repo else: sfile.delete() continue # file still exists? file_id = '' size = -1 if sfile.path != "/": try: file_id = seafile_api.get_file_id_by_path(sfile.repo_id, sfile.path) # size = seafile_api.get_file_size(file_id) except SearpcError: continue if not file_id: sfile.delete() continue f = StarredFile(sfile.org_id, repo, file_id, sfile.path, sfile.is_dir, 0) # TODO: remove ``size`` from StarredFile ret.append(f) '''Calculate files last modification time''' for sfile in ret: if sfile.is_dir: continue try: # get real path for sub repo real_path = sfile.repo.origin_path + sfile.path if sfile.repo.origin_path else sfile.path dirent = seafile_api.get_dirent_by_path(sfile.repo.store_id, real_path) if dirent: sfile.last_modified = dirent.mtime else: sfile.last_modified = 0 except SearpcError as e: logger.error(e) sfile.last_modified = 0 ret.sort(lambda x, y: cmp(y.last_modified, x.last_modified)) return ret
def react_fake_view(request, **kwargs): username = request.user.username if resolve(request.path).url_name == 'lib_view': repo_id = kwargs.get('repo_id', '') path = kwargs.get('path', '') if repo_id and path and \ not check_folder_permission(request, repo_id, path): converted_repo_path = seafile_api.convert_repo_path( repo_id, path, username) if not converted_repo_path: error_msg = 'Permission denied.' return render_error(request, error_msg) repo_path_dict = json.loads(converted_repo_path) converted_repo_id = repo_path_dict['repo_id'] converted_repo = seafile_api.get_repo(converted_repo_id) if not converted_repo: error_msg = 'Library %s not found.' % converted_repo_id return render_error(request, error_msg) converted_path = repo_path_dict['path'] if not seafile_api.get_dirent_by_path(converted_repo_id, converted_path): error_msg = 'Dirent %s not found.' % converted_path return render_error(request, error_msg) if not check_folder_permission(request, converted_repo_id, converted_path): error_msg = 'Permission denied.' return render_error(request, error_msg) next_url = reverse('lib_view', args=[ converted_repo_id, converted_repo.repo_name, converted_path.strip('/') ]) return HttpResponseRedirect(next_url) guide_enabled = UserOptions.objects.is_user_guide_enabled(username) if guide_enabled: create_default_library(request) try: expire_days = seafile_api.get_server_config_int( 'library_trash', 'expire_days') except Exception as e: logger.error(e) expire_days = -1 folder_perm_enabled = True if is_pro_version( ) and ENABLE_FOLDER_PERM else False try: max_upload_file_size = seafile_api.get_server_config_int( 'fileserver', 'max_upload_size') except Exception as e: logger.error(e) max_upload_file_size = -1 return render( request, "react_app.html", { "onlyoffice_desktop_editors_portal_login": ONLYOFFICE_DESKTOP_EDITORS_PORTAL_LOGIN, "guide_enabled": guide_enabled, 'trash_repos_expire_days': expire_days if expire_days > 0 else 30, 'dtable_web_server': DTABLE_WEB_SERVER, 'max_upload_file_size': max_upload_file_size, 'seafile_collab_server': SEAFILE_COLLAB_SERVER, 'storages': get_library_storages(request), 'library_templates': list(LIBRARY_TEMPLATES.keys()), 'enable_repo_snapshot_label': settings.ENABLE_REPO_SNAPSHOT_LABEL, 'resumable_upload_file_block_size': settings.RESUMABLE_UPLOAD_FILE_BLOCK_SIZE, 'max_number_of_files_for_fileupload': settings.MAX_NUMBER_OF_FILES_FOR_FILEUPLOAD, 'share_link_expire_days_default': SHARE_LINK_EXPIRE_DAYS_DEFAULT, 'share_link_expire_days_min': SHARE_LINK_EXPIRE_DAYS_MIN, 'share_link_expire_days_max': SHARE_LINK_EXPIRE_DAYS_MAX, 'upload_link_expire_days_default': UPLOAD_LINK_EXPIRE_DAYS_DEFAULT, 'upload_link_expire_days_min': UPLOAD_LINK_EXPIRE_DAYS_MIN, 'upload_link_expire_days_max': UPLOAD_LINK_EXPIRE_DAYS_MAX, 'enable_encrypted_library': config.ENABLE_ENCRYPTED_LIBRARY, 'enable_repo_history_setting': config.ENABLE_REPO_HISTORY_SETTING, 'enable_reset_encrypted_repo_password': ENABLE_RESET_ENCRYPTED_REPO_PASSWORD, 'enableFileComment': settings.ENABLE_FILE_COMMENT, 'is_email_configured': IS_EMAIL_CONFIGURED, 'can_add_public_repo': request.user.permissions.can_add_public_repo(), 'folder_perm_enabled': folder_perm_enabled, 'file_audit_enabled': FILE_AUDIT_ENABLED, 'custom_nav_items': json.dumps(CUSTOM_NAV_ITEMS), 'enable_show_contact_email_when_search_user': settings.ENABLE_SHOW_CONTACT_EMAIL_WHEN_SEARCH_USER, 'additional_share_dialog_note': ADDITIONAL_SHARE_DIALOG_NOTE, 'additional_app_bottom_links': ADDITIONAL_APP_BOTTOM_LINKS, 'additional_about_dialog_links': ADDITIONAL_ABOUT_DIALOG_LINKS, 'enable_ocm': ENABLE_OCM, 'ocm_remote_servers': OCM_REMOTE_SERVERS, 'enable_share_to_department': settings.ENABLE_SHARE_TO_DEPARTMENT, 'enable_video_thumbnail': settings.ENABLE_VIDEO_THUMBNAIL, 'group_import_members_extra_msg': GROUP_IMPORT_MEMBERS_EXTRA_MSG, })
def get(self, request, repo_id, format=None): """ Get file server token for download-dir and download-multi. Permission checking: 1. user with 'r' or 'rw' permission; """ # argument check parent_dir = request.GET.get('parent_dir', None) if not parent_dir: error_msg = 'parent_dir invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) dirent_name_list = request.GET.getlist('dirents', None) if not dirent_name_list: error_msg = 'dirents invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) if len(dirent_name_list) == 1: download_type = 'download-dir' elif len(dirent_name_list) > 1: download_type = 'download-multi' else: error_msg = 'dirents invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) # recourse check repo = seafile_api.get_repo(repo_id) if not repo: error_msg = 'Library %s not found.' % repo_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) if not seafile_api.get_dir_id_by_path(repo_id, parent_dir): error_msg = 'Folder %s not found.' % parent_dir return api_error(status.HTTP_404_NOT_FOUND, error_msg) # permission check if not check_folder_permission(request, repo_id, parent_dir): error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) # get file server access token is_windows = 0 if is_windows_operating_system(request): is_windows = 1 if download_type == 'download-dir': dir_name = dirent_name_list[0].strip('/') full_dir_path = posixpath.join(parent_dir, dir_name) dir_id = seafile_api.get_dir_id_by_path(repo_id, full_dir_path) if not dir_id: error_msg = 'Folder %s not found.' % full_dir_path return api_error(status.HTTP_404_NOT_FOUND, error_msg) dir_size = seafile_api.get_dir_size( repo.store_id, repo.version, dir_id) if dir_size > seaserv.MAX_DOWNLOAD_DIR_SIZE: error_msg = 'Unable to download directory "%s": size is too large.' % dir_name return api_error(status.HTTP_400_BAD_REQUEST, error_msg) fake_obj_id = { 'obj_id': dir_id, 'dir_name': dir_name, 'is_windows': is_windows } if download_type == 'download-multi': dirent_list = [] total_size = 0 for dirent_name in dirent_name_list: dirent_name = dirent_name.strip('/') dirent_list.append(dirent_name) full_dirent_path = posixpath.join(parent_dir, dirent_name) current_dirent = seafile_api.get_dirent_by_path(repo_id, full_dirent_path) if not current_dirent: continue if stat.S_ISDIR(current_dirent.mode): total_size += seafile_api.get_dir_size(repo.store_id, repo.version, current_dirent.obj_id) else: total_size += current_dirent.size if total_size > seaserv.MAX_DOWNLOAD_DIR_SIZE: error_msg = _('Total size exceeds limit.') return api_error(status.HTTP_400_BAD_REQUEST, error_msg) fake_obj_id = { 'parent_dir': parent_dir, 'file_list': dirent_list, 'is_windows': is_windows } username = request.user.username try: zip_token = seafile_api.get_fileserver_access_token( repo_id, json.dumps(fake_obj_id), download_type, username) except Exception as e: logger.error(e) error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) if len(dirent_name_list) > 10: send_file_access_msg(request, repo, parent_dir, 'web') else: for dirent_name in dirent_name_list: full_dirent_path = posixpath.join(parent_dir, dirent_name) send_file_access_msg(request, repo, full_dirent_path, 'web') return Response({'zip_token': zip_token})
def get(self, request, repo_id, format=None): repo = seafile_api.get_repo(repo_id) if not repo: error_msg = 'Library %s not found.' % repo_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) # argument checking parent_dir = request.GET.get('parent_dir', None) dirent_name_string = request.GET.get('dirents', None) if not parent_dir: error_msg = 'parent_dir invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) if not dirent_name_string: error_msg = 'dirents invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) # folder exist checking if not seafile_api.get_dir_id_by_path(repo_id, parent_dir): error_msg = 'Folder %s not found.' % parent_dir return api_error(status.HTTP_404_NOT_FOUND, error_msg) # permission checking if check_folder_permission(request, repo_id, parent_dir) is None: error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) dirent_name_list = string2list(dirent_name_string) dirent_list = [] total_size = 0 for dirent_name in dirent_name_list: dirent_name = dirent_name.strip('/') dirent_list.append(dirent_name) full_dirent_path = posixpath.join(parent_dir, dirent_name) current_dirent = seafile_api.get_dirent_by_path(repo_id, full_dirent_path) if stat.S_ISDIR(current_dirent.mode): total_size += seafile_api.get_dir_size(repo.store_id, repo.version, current_dirent.obj_id) else: total_size += current_dirent.size if total_size > seaserv.MAX_DOWNLOAD_DIR_SIZE: error_msg = _('Total size exceeds limit.') return api_error(status.HTTP_400_BAD_REQUEST, error_msg) fake_obj_id = {} fake_obj_id['file_list'] = dirent_list fake_obj_id['parent_dir'] = parent_dir username = request.user.username try: token = seafile_api.get_fileserver_access_token(repo_id, json.dumps(fake_obj_id), 'download-multi', username, False) except SearpcError as e: logger.error(e) error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) if len(dirent_list) > 10: send_file_access_msg(request, repo, parent_dir, 'web') else: for dirent_name in dirent_list: full_dirent_path = posixpath.join(parent_dir, dirent_name) send_file_access_msg(request, repo, full_dirent_path, 'web') download_url = '%s/files/%s' % (get_fileserver_root(), token) return Response({'url': download_url})
def get_starred_files_by_username(self, username): """Get a user's starred files. Arguments: - `self`: - `username`: """ starred_files = super(UserStarredFilesManager, self).filter(email=username, org_id=-1) ret = [] repo_cache = {} for sfile in starred_files: # repo still exists? if repo_cache.has_key(sfile.repo_id): repo = repo_cache[sfile.repo_id] else: try: repo = seafile_api.get_repo(sfile.repo_id) except SearpcError: continue if repo is not None: repo_cache[sfile.repo_id] = repo else: sfile.delete() continue # file still exists? file_id = '' size = -1 if sfile.path != "/": try: file_id = seafile_api.get_file_id_by_path( sfile.repo_id, sfile.path) # size = seafile_api.get_file_size(file_id) except SearpcError: continue if not file_id: sfile.delete() continue f = StarredFile(sfile.org_id, repo, file_id, sfile.path, sfile.is_dir, 0) # TODO: remove ``size`` from StarredFile ret.append(f) '''Calculate files last modification time''' for sfile in ret: if sfile.is_dir: continue try: # get real path for sub repo real_path = sfile.repo.origin_path + sfile.path if sfile.repo.origin_path else sfile.path dirent = seafile_api.get_dirent_by_path( sfile.repo.store_id, real_path) if dirent: sfile.last_modified = dirent.mtime else: sfile.last_modified = 0 except SearpcError as e: logger.error(e) sfile.last_modified = 0 ret.sort(lambda x, y: cmp(y.last_modified, x.last_modified)) return ret
def personal_wiki(request, page_name="home"): username = request.user.username if request.cloud_mode and request.user.org is not None: org_id = request.user.org.org_id joined_groups = seaserv.get_org_groups_by_user(org_id, username) else: joined_groups = seaserv.get_personal_groups_by_user(username) if joined_groups: joined_groups.sort(lambda x, y: cmp(x.group_name.lower(), y.group_name.lower())) wiki_exists = True try: content, repo, dirent = get_personal_wiki_page(username, page_name) except WikiDoesNotExist: wiki_exists = False owned_repos = seafile_api.get_owned_repo_list(username) owned_repos = [r for r in owned_repos if not r.encrypted] return render_to_response("wiki/personal_wiki.html", { "wiki_exists": wiki_exists, "owned_repos": owned_repos, "grps": joined_groups, }, context_instance=RequestContext(request)) except WikiPageMissing: repo = get_personal_wiki_repo(username) filename = page_name_to_file_name(clean_page_name(page_name)) if not seaserv.post_empty_file(repo.id, "/", filename, username): return render_error(request, _("Failed to create wiki page. Please retry later.")) return HttpResponseRedirect(reverse('personal_wiki', args=[page_name])) else: # fetch file modified time and modifier path = '/' + dirent.obj_name try: dirent = seafile_api.get_dirent_by_path(repo.id, path) if dirent: latest_contributor, last_modified = dirent.modifier, dirent.mtime else: latest_contributor, last_modified = None, 0 except SearpcError as e: logger.error(e) latest_contributor, last_modified = None, 0 wiki_index_exists = True index_pagename = 'index' index_content = None try: index_content, index_repo, index_dirent = get_personal_wiki_page(username, index_pagename) except (WikiDoesNotExist, WikiPageMissing) as e: wiki_index_exists = False return render_to_response("wiki/personal_wiki.html", { "wiki_exists": wiki_exists, "content": content, "page": os.path.splitext(dirent.obj_name)[0], "last_modified": last_modified, "latest_contributor": latest_contributor or _("Unknown"), "path": path, "repo_id": repo.id, "search_repo_id": repo.id, "search_wiki": True, "wiki_index_exists": wiki_index_exists, "index_content": index_content, "grps": joined_groups, }, context_instance=RequestContext(request))
def get(self, request, slug): """Get content of a wiki """ path = request.GET.get('p', '/') try: wiki = Wiki.objects.get(slug=slug) except Wiki.DoesNotExist: error_msg = "Wiki not found." return api_error(status.HTTP_404_NOT_FOUND, error_msg) # perm check if not wiki.check_access_wiki(request): error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) if request.user.username: parent_dir = os.path.dirname(path) permission = check_folder_permission(request, wiki.repo_id, parent_dir) else: permission = 'r' try: repo = seafile_api.get_repo(wiki.repo_id) if not repo: error_msg = "Wiki library not found." return api_error(status.HTTP_404_NOT_FOUND, error_msg) except SearpcError: error_msg = _("Internal Server Error") return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) file_id = None try: file_id = seafile_api.get_file_id_by_path(repo.repo_id, path) except SearpcError as e: logger.error(e) return api_error(HTTP_520_OPERATION_FAILED, "Failed to get file id by path.") if not file_id: return api_error(status.HTTP_404_NOT_FOUND, "File not found") # send stats message send_file_access_msg(request, repo, path, 'api') file_name = os.path.basename(path) token = seafile_api.get_fileserver_access_token( repo.repo_id, file_id, 'download', request.user.username, 'False') if not token: error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) url = gen_inner_file_get_url(token, file_name) file_response = urllib2.urlopen(url) content = file_response.read() try: dirent = seafile_api.get_dirent_by_path(repo.repo_id, path) if dirent: latest_contributor, last_modified = dirent.modifier, dirent.mtime else: latest_contributor, last_modified = None, 0 except SearpcError as e: logger.error(e) latest_contributor, last_modified = None, 0 return Response({ "content": content, "latest_contributor": email2nickname(latest_contributor), "last_modified": last_modified, "permission": permission, })
def group_wiki(request, group, page_name="home"): username = request.user.username # get available modules(wiki, etc) mods_available = get_available_mods_by_group(group.id) mods_enabled = get_enabled_mods_by_group(group.id) wiki_exists = True try: content, repo, dirent = get_group_wiki_page(username, group, page_name) except WikiDoesNotExist: wiki_exists = False group_repos = get_group_repos(group.id, username) group_repos = [r for r in group_repos if not r.encrypted] return render_to_response( "group/group_wiki.html", { "group": group, "is_staff": group.is_staff, "wiki_exists": wiki_exists, "mods_enabled": mods_enabled, "mods_available": mods_available, "group_repos": group_repos, }, context_instance=RequestContext(request), ) except WikiPageMissing: """create that page for user if he/she is a group member""" if not is_group_user(group.id, username): raise Http404 repo = get_group_wiki_repo(group, username) # No need to check whether repo is none, since repo is already created filename = page_name_to_file_name(clean_page_name(page_name)) if not post_empty_file(repo.id, "/", filename, username): return render_error(request, _("Failed to create wiki page. Please retry later.")) return HttpResponseRedirect(reverse("group_wiki", args=[group.id, page_name])) else: url_prefix = reverse("group_wiki", args=[group.id]) # fetch file modified time and modifier path = "/" + dirent.obj_name try: dirent = seafile_api.get_dirent_by_path(repo.id, path) if dirent: latest_contributor, last_modified = dirent.modifier, dirent.mtime else: latest_contributor, last_modified = None, 0 except SearpcError as e: logger.error(e) latest_contributor, last_modified = None, 0 repo_perm = seafile_api.check_repo_access_permission(repo.id, username) wiki_index_exists = True index_pagename = "index" index_content = None try: index_content, index_repo, index_dirent = get_group_wiki_page(username, group, index_pagename) except (WikiDoesNotExist, WikiPageMissing) as e: wiki_index_exists = False return render_to_response( "group/group_wiki.html", { "group": group, "is_staff": group.is_staff, "wiki_exists": wiki_exists, "content": content, "page": os.path.splitext(dirent.obj_name)[0], "last_modified": last_modified, "latest_contributor": latest_contributor or _("Unknown"), "path": path, "repo_id": repo.id, "search_repo_id": repo.id, "search_wiki": True, "mods_enabled": mods_enabled, "mods_available": mods_available, "repo_perm": repo_perm, "wiki_index_exists": wiki_index_exists, "index_content": index_content, }, context_instance=RequestContext(request), )
def group_wiki(request, group, page_name="home"): username = request.user.username # get available modules(wiki, etc) mods_available = get_available_mods_by_group(group.id) mods_enabled = get_enabled_mods_by_group(group.id) wiki_exists = True try: content, repo, dirent = get_group_wiki_page(username, group, page_name) except WikiDoesNotExist: wiki_exists = False group_repos = get_group_repos(group.id, username) group_repos = [r for r in group_repos if not r.encrypted] return render_to_response("group/group_wiki.html", { "group": group, "is_staff": group.is_staff, "wiki_exists": wiki_exists, "mods_enabled": mods_enabled, "mods_available": mods_available, "group_repos": group_repos, }, context_instance=RequestContext(request)) except WikiPageMissing: '''create that page for user if he/she is a group member''' if not is_group_user(group.id, username): raise Http404 repo = get_group_wiki_repo(group, username) # No need to check whether repo is none, since repo is already created filename = page_name_to_file_name(clean_page_name(page_name)) if not post_empty_file(repo.id, "/", filename, username): return render_error( request, _("Failed to create wiki page. Please retry later.")) return HttpResponseRedirect( reverse('group_wiki', args=[group.id, page_name])) else: # fetch file modified time and modifier path = '/' + dirent.obj_name try: dirent = seafile_api.get_dirent_by_path(repo.id, path) if dirent: latest_contributor, last_modified = dirent.modifier, dirent.mtime else: latest_contributor, last_modified = None, 0 except SearpcError as e: logger.error(e) latest_contributor, last_modified = None, 0 if is_registered_user(username): repo_perm = seafile_api.check_permission_by_path( repo.id, '/', username) else: # when anonymous user visit public group wiki, set permission as 'r' repo_perm = 'r' wiki_index_exists = True index_pagename = 'index' index_content = None try: index_content, index_repo, index_dirent = get_group_wiki_page( username, group, index_pagename) except (WikiDoesNotExist, WikiPageMissing) as e: wiki_index_exists = False return render_to_response( "group/group_wiki.html", { "group": group, "is_staff": group.is_staff, "wiki_exists": wiki_exists, "content": content, "page": os.path.splitext(dirent.obj_name)[0], "last_modified": last_modified, "latest_contributor": latest_contributor or _("Unknown"), "path": path, "repo_id": repo.id, "search_repo_id": repo.id, "search_wiki": True, "mods_enabled": mods_enabled, "mods_available": mods_available, "repo_perm": repo_perm, "wiki_index_exists": wiki_index_exists, "index_content": index_content, }, context_instance=RequestContext(request))
def get(self, request, slug): """Get content of a wiki """ path = request.GET.get('p', '/') try: wiki = Wiki.objects.get(slug=slug) except Wiki.DoesNotExist: error_msg = "Wiki not found." return api_error(status.HTTP_404_NOT_FOUND, error_msg) # perm check if not wiki.has_read_perm(request): error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) if request.user.username: parent_dir = os.path.dirname(path) permission = check_folder_permission(request, wiki.repo_id, parent_dir) else: permission = 'r' try: repo = seafile_api.get_repo(wiki.repo_id) if not repo: error_msg = "Wiki library not found." return api_error(status.HTTP_404_NOT_FOUND, error_msg) except SearpcError: error_msg = _("Internal Server Error") return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) file_id = None try: file_id = seafile_api.get_file_id_by_path(repo.repo_id, path) except SearpcError as e: logger.error(e) return api_error(HTTP_520_OPERATION_FAILED, "Failed to get file id by path.") if not file_id: return api_error(status.HTTP_404_NOT_FOUND, "File not found") # send stats message send_file_access_msg(request, repo, path, 'api') file_name = os.path.basename(path) token = seafile_api.get_fileserver_access_token(repo.repo_id, file_id, 'download', request.user.username, 'False') if not token: error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) url = gen_inner_file_get_url(token, file_name) file_response = urllib2.urlopen(url) content = file_response.read() try: dirent = seafile_api.get_dirent_by_path(repo.repo_id, path) if dirent: latest_contributor, last_modified = dirent.modifier, dirent.mtime else: latest_contributor, last_modified = None, 0 except SearpcError as e: logger.error(e) latest_contributor, last_modified = None, 0 return Response({ "content": content, "latest_contributor": email2nickname(latest_contributor), "last_modified": last_modified, "permission": permission, })