def get_keeper_default_library(): try: from_repos = seafile_api.get_owned_repo_list(SERVER_EMAIL) from_repos = [ r for r in from_repos if r.name == KEEPER_DEFAULT_LIBRARY ] if from_repos: from_repo_id = from_repos[0].id else: logging.info( "Cannot find KEEPER_DEFAULT_LIBRARY repo in admin libraries, trying to create..." ) from_repo_id = create_keeper_default_library() if from_repo_id is None: raise Exception( "Cannot create KEEPER_DEFAULT_LIBRARY repo in admin libraries, please check!" ) else: logging.info( "KEEPER_DEFAULT_LIBRARY has been successfully created!") return { 'repo_id': from_repo_id, 'dirents': seafile_api.list_dir_by_path(from_repo_id, '/') } except Exception as err: logging.error("Cannot find KEEPER_DEFAULT_LIBRARY dirents, err: " + str(err)) return None
def delete(self): """ When delete user, we should also delete group relationships. """ if self.source == "DB": source = "DB" else: source = "LDAP" username = self.username orgs = [] if is_pro_version(): orgs = ccnet_api.get_orgs_by_user(username) # remove owned repos owned_repos = [] if orgs: for org in orgs: owned_repos += seafile_api.get_org_owned_repo_list( org.org_id, username) else: owned_repos += seafile_api.get_owned_repo_list(username) for r in owned_repos: seafile_api.remove_repo(r.id) # remove shared in repos shared_in_repos = [] if orgs: for org in orgs: org_id = org.org_id shared_in_repos = seafile_api.get_org_share_in_repo_list( org_id, username, -1, -1) for r in shared_in_repos: seafile_api.org_remove_share(org_id, r.repo_id, r.user, username) else: shared_in_repos = seafile_api.get_share_in_repo_list( username, -1, -1) for r in shared_in_repos: seafile_api.remove_share(r.repo_id, r.user, username) ExtraSharePermission.objects.filter(share_to=username).delete() # clear web api and repo sync token # when delete user try: clear_token(self.username) except Exception as e: logger.error(e) # remove current user from joined groups ccnet_api.remove_group_user(username) ccnet_api.remove_emailuser(source, username) Profile.objects.delete_profile_by_user(username) if settings.ENABLE_TERMS_AND_CONDITIONS: from termsandconditions.models import UserTermsAndConditions UserTermsAndConditions.objects.filter(username=username).delete()
def post(self, request, email, format=None): # migrate an account's repos and groups to an exist account if not is_valid_username(email): return api_error(status.HTTP_400_BAD_REQUEST, 'Email %s invalid.' % email) op = request.data.get('op', '').lower() if op == 'migrate': from_user = email to_user = request.data.get('to_user', '') if not is_valid_username(to_user): return api_error(status.HTTP_400_BAD_REQUEST, 'Email %s invalid.' % to_user) try: user2 = User.objects.get(email=to_user) except User.DoesNotExist: return api_error(status.HTTP_404_NOT_FOUND, 'User %s not found.' % to_user) # transfer owned repos to new user for r in seafile_api.get_owned_repo_list(from_user): seafile_api.set_repo_owner(r.id, user2.username) # transfer joined groups to new user for g in seaserv.get_personal_groups_by_user(from_user): if not seaserv.is_group_user(g.id, user2.username): # add new user to the group on behalf of the group creator ccnet_threaded_rpc.group_add_member(g.id, g.creator_name, to_user) if from_user == g.creator_name: ccnet_threaded_rpc.set_group_creator(g.id, to_user) return Response("success") else: return api_error(status.HTTP_400_BAD_REQUEST, 'op can only be migrate.')
def post(self, request, email, format=None): # migrate an account's repos and groups to an exist account if not is_valid_username(email): return api_error(status.HTTP_404_NOT_FOUND, 'User not found.') op = request.DATA.get('op', '').lower() if op == 'migrate': from_user = email to_user = request.DATA.get('to_user', '') if not is_valid_username(to_user): return api_error(status.HTTP_400_BAD_REQUEST, '%s is not valid email.' % to_user) try: user2 = User.objects.get(email=to_user) except User.DoesNotExist: return api_error(status.HTTP_400_BAD_REQUEST, '%s does not exist.' % to_user) # transfer owned repos to new user for r in seafile_api.get_owned_repo_list(from_user): seafile_api.set_repo_owner(r.id, user2.username) # transfer joined groups to new user for g in seaserv.get_personal_groups_by_user(from_user): if not seaserv.is_group_user(g.id, user2.username): # add new user to the group on behalf of the group creator ccnet_threaded_rpc.group_add_member(g.id, g.creator_name, to_user) if from_user == g.creator_name: ccnet_threaded_rpc.set_group_creator(g.id, to_user) return Response("success") else: return api_error(status.HTTP_400_BAD_REQUEST, 'Op can only be migrate')
def delete(self): """ When delete user, we should also delete group relationships. """ if self.source == "DB": source = "DB" else: source = "LDAP" owned_repos = [] orgs = ccnet_threaded_rpc.get_orgs_by_user(self.username) if orgs: for org in orgs: owned_repos += seafile_api.get_org_owned_repo_list( org.org_id, self.username) else: owned_repos += seafile_api.get_owned_repo_list(self.username) for r in owned_repos: seafile_api.remove_repo(r.id) clear_token(self.username) # remove current user from joined groups ccnet_api.remove_group_user(self.username) ccnet_api.remove_emailuser(source, self.username) Profile.objects.delete_profile_by_user(self.username)
def delete(self): """ When delete user, we should also delete group relationships. """ if self.source == "DB": source = "DB" else: source = "LDAP" owned_repos = [] orgs = ccnet_threaded_rpc.get_orgs_by_user(self.username) if orgs: for org in orgs: owned_repos += seafile_api.get_org_owned_repo_list(org.org_id, self.username) else: owned_repos += seafile_api.get_owned_repo_list(self.username) for r in owned_repos: seafile_api.remove_repo(r.id) clear_token(self.username) # remove current user from joined groups ccnet_api.remove_group_user(self.username) ccnet_api.remove_emailuser(source, self.username) Profile.objects.delete_profile_by_user(self.username)
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 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 latest contributor and last modified path = '/' + dirent.obj_name file_path_hash = hashlib.md5(urllib2.quote( path.encode('utf-8'))).hexdigest()[:12] contributors, last_modified, last_commit_id = \ FileContributors.objects.get_file_contributors( repo.id, path.encode('utf-8'), file_path_hash, dirent.obj_id) latest_contributor = contributors[0] if contributors else None 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, "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_owned_repos(username, org_id=None): if org_id is None: owned_repos = seafile_api.get_owned_repo_list(username) else: owned_repos = seafile_api.get_org_owned_repo_list(org_id, username) return owned_repos
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 latest contributor and last modified path = "/" + dirent.obj_name file_path_hash = hashlib.md5(urllib2.quote(path.encode("utf-8"))).hexdigest()[:12] contributors, last_modified, last_commit_id = FileContributors.objects.get_file_contributors( repo.id, path.encode("utf-8"), file_path_hash, dirent.obj_id ) latest_contributor = contributors[0] if contributors else None 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, "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 list_repos_by_name_and_owner(repo_name, owner): repos = [] owned_repos = seafile_api.get_owned_repo_list(owner) for repo in owned_repos: if repo_name in repo.name: repo.owner = owner repos.append(repo) return repos
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_owned_repo_list(request): """List owned repos. """ username = request.user.username if is_org_context(request): org_id = request.user.org.org_id return seafile_api.get_org_owned_repo_list(org_id, username) else: return seafile_api.get_owned_repo_list(username)
def edit_profile(request): """ Show and edit user profile. """ username = request.user.username form_class = DetailedProfileForm if request.method == 'POST': form = form_class(request.POST) if form.is_valid(): form.save(username=username) messages.success(request, _(u'Successfully edited profile.')) # refresh nickname cache refresh_cache(request.user.username) return HttpResponseRedirect(reverse('edit_profile')) else: messages.error(request, _(u'Failed to edit profile')) else: profile = Profile.objects.get_profile_by_user(username) d_profile = DetailedProfile.objects.get_detailed_profile_by_user( username) init_dict = {} if profile: init_dict['nickname'] = profile.nickname init_dict['intro'] = profile.intro if d_profile: init_dict['department'] = d_profile.department init_dict['telephone'] = d_profile.telephone form = form_class(init_dict) # common logic try: server_crypto = UserOptions.objects.is_server_crypto(username) except CryptoOptionNotSetError: # Assume server_crypto is ``False`` if this option is not set. server_crypto = False sub_lib_enabled = UserOptions.objects.is_sub_lib_enabled(username) default_repo_id = UserOptions.objects.get_default_repo(username) if default_repo_id: default_repo = seafile_api.get_repo(default_repo_id) else: default_repo = None owned_repos = seafile_api.get_owned_repo_list(username) return render_to_response('profile/set_profile.html', { 'form': form, 'server_crypto': server_crypto, "sub_lib_enabled": sub_lib_enabled, 'force_server_crypto': settings.FORCE_SERVER_CRYPTO, 'default_repo': default_repo, 'owned_repos': owned_repos, }, context_instance=RequestContext(request))
def get_keeper_default_library(): try: from_repos = seafile_api.get_owned_repo_list(SERVER_EMAIL) from_repos = [r for r in from_repos if r.name == KEEPER_DEFAULT_LIBRARY] if from_repos: from_repo_id = from_repos[0].id return { 'repo_id': from_repo_id, 'dirents': seafile_api.list_dir_by_path(from_repo_id, '/') } else: raise Exception("Cannot find KEEPER_DEFAULT_LIBRARY repo in admin libraries, please install!") except Exception as err: logging.error("Cannot find KEEPER_DEFAULT_LIBRARY dirents, err: " + str(err)) return None
def get_my_unenc_repos(request): """Get my owned and unencrypted repos. """ if not request.is_ajax(): raise Http404 content_type = 'application/json; charset=utf-8' repos = seafile_api.get_owned_repo_list(request.user.username) repo_list = [] for repo in repos: if repo.encrypted: continue repo_list.append({"name": repo.name, "id": repo.id}) return HttpResponse(json.dumps(repo_list), content_type=content_type)
def user_info(request, email): owned_repos = seafile_api.get_owned_repo_list(email) quota = seafile_api.get_user_quota(email) quota_usage = 0 share_usage = 0 my_usage = 0 my_usage = seafile_api.get_user_self_usage(email) if CALC_SHARE_USAGE: try: share_usage = seafile_api.get_user_share_usage(email) except SearpcError, e: logger.error(e) share_usage = 0 quota_usage = my_usage + share_usage
def delete(self): """ When delete user, we should also delete group relationships. """ if self.source == "DB": source = "DB" else: source = "LDAP" username = self.username orgs = ccnet_threaded_rpc.get_orgs_by_user(username) # remove owned repos owned_repos = [] if orgs: for org in orgs: owned_repos += seafile_api.get_org_owned_repo_list( org.org_id, username) else: owned_repos += seafile_api.get_owned_repo_list(username) for r in owned_repos: seafile_api.remove_repo(r.id) # remove shared in repos shared_in_repos = [] if orgs: for org in orgs: org_id = org.org_id shared_in_repos = seafile_api.get_org_share_in_repo_list( org_id, username, -1, -1) for r in shared_in_repos: seafile_api.org_remove_share(org_id, r.repo_id, r.user, username) else: shared_in_repos = seafile_api.get_share_in_repo_list( username, -1, -1) for r in shared_in_repos: seafile_api.remove_share(r.repo_id, r.user, username) clear_token(username) # remove current user from joined groups ccnet_api.remove_group_user(username) ccnet_api.remove_emailuser(source, username) Profile.objects.delete_profile_by_user(username)
def get_user_repos(username, org_id=None): """ Get all repos that user can access, including owns, shared, public, and repo in groups. If ``org_id`` is not None, get org repos that user can access. """ if org_id is None: owned_repos = seafile_api.get_owned_repo_list(username) shared_repos = seafile_api.get_share_in_repo_list(username, -1, -1) groups_repos = [] for group in seaserv.get_personal_groups_by_user(username): # TODO: use seafile_api.get_group_repos groups_repos += seaserv.get_group_repos(group.id, username) if CLOUD_MODE: public_repos = [] else: public_repos = seaserv.list_inner_pub_repos(username) for r in shared_repos + public_repos: # collumn names in shared_repo struct are not same as owned or group # repos. r.id = r.repo_id r.name = r.repo_name r.desc = r.repo_desc r.last_modify = r.last_modified else: owned_repos = seafile_api.get_org_owned_repo_list(org_id, username) shared_repos = seafile_api.get_org_share_in_repo_list( org_id, username, -1, -1) groups_repos = [] for group in seaserv.get_org_groups_by_user(org_id, username): groups_repos += seafile_api.get_org_group_repos(org_id, group.id) public_repos = seaserv.seafserv_threaded_rpc.list_org_inner_pub_repos( org_id) for r in shared_repos + groups_repos + public_repos: # collumn names in shared_repo struct are not same as owned # repos. r.id = r.repo_id r.name = r.repo_name r.desc = r.repo_desc r.last_modify = r.last_modified return (owned_repos, shared_repos, groups_repos, public_repos)
def post(self, request, email, format=None): # migrate an account's repos and groups to an exist account if not is_valid_username(email): return api_error(status.HTTP_400_BAD_REQUEST, 'Email %s invalid.' % email) op = request.data.get('op', '').lower() if op == 'migrate': from_user = email to_user = request.data.get('to_user', '') if not is_valid_username(to_user): return api_error(status.HTTP_400_BAD_REQUEST, 'Email %s invalid.' % to_user) try: user2 = User.objects.get(email=to_user) except User.DoesNotExist: return api_error(status.HTTP_404_NOT_FOUND, 'User %s not found.' % to_user) # transfer owned repos to new user for r in seafile_api.get_owned_repo_list(from_user): seafile_api.set_repo_owner(r.id, user2.username) # transfer shared repos to new user for r in seafile_api.get_share_in_repo_list(from_user, -1, -1): owner = seafile_api.get_repo_owner(r.repo_id) seafile_api.share_repo(r.repo_id, owner, to_user, r.permission) # transfer joined groups to new user for g in ccnet_api.get_groups(from_user): if not is_group_member(g.id, user2.username): # add new user to the group on behalf of the group creator ccnet_threaded_rpc.group_add_member( g.id, g.creator_name, to_user) if from_user == g.creator_name: ccnet_threaded_rpc.set_group_creator(g.id, to_user) return Response({'success': True}) else: return api_error(status.HTTP_400_BAD_REQUEST, 'op can only be migrate.')
def user_info(request, email): owned_repos = seafile_api.get_owned_repo_list(email) org = ccnet_threaded_rpc.get_orgs_by_user(email) if not org: my_usage = seafile_api.get_user_self_usage(email) quota = seafile_api.get_user_quota(email) else: org_id = org[0].org_id my_usage =seafserv_threaded_rpc. \ get_org_user_quota_usage(org_id, email) quota = seafserv_threaded_rpc. \ get_org_user_quota(org_id, email) if CALC_SHARE_USAGE: try: share_usage = seafile_api.get_user_share_usage(email) except SearpcError, e: logger.error(e) share_usage = 0 quota_usage = my_usage + share_usage
def user_info(request, email): if request.method == 'POST': result = {} content_type = 'application/json; charset=utf-8' f = SetUserQuotaForm(request.POST) if f.is_valid(): email = f.cleaned_data['email'] quota_mb = f.cleaned_data['quota'] quota = quota_mb * (1 << 20) try: seafile_api.set_user_quota(email, quota) except: result['error'] = _(u'Failed to set quota: internal error') return HttpResponse(json.dumps(result), content_type=content_type) result['success'] = True return HttpResponse(json.dumps(result), content_type=content_type) else: result['error'] = str(f.errors.values()[0]) return HttpResponse(json.dumps(result), content_type=content_type) owned_repos = [] owned_repos = seafile_api.get_owned_repo_list(email) quota = seafile_api.get_user_quota(email) quota_usage = 0 share_usage = 0 my_usage = 0 my_usage = seafile_api.get_user_self_usage(email) if CALC_SHARE_USAGE: try: share_usage = seafile_api.get_user_share_usage(email) except SearpcError, e: logger.error(e) share_usage = 0 quota_usage = my_usage + share_usage
def getAccessibleRepos(username): all_repos = {} def addRepo(repo_id): try: if all_repos.has_key(repo_id): return repo = seafile_api.get_repo(repo_id) if repo: all_repos[repo_id] = repo except SearpcError, e: util.warn("Failed to get repo %.8s: %s" % (repo_id, e.msg)) try: owned_repos = seafile_api.get_owned_repo_list(username) except SearpcError, e: util.warn("Failed to list owned repos: %s" % e.msg) for orepo in owned_repos: addRepo(orepo.id) try: shared_repos = seafile_api.get_share_in_repo_list(username, -1, -1) except SearpcError, e: util.warn("Failed to list shared repos: %s" % e.msg) for srepo in shared_repos: addRepo(srepo.repo_id) try:
def test_migrate(self): self.login_as(self.admin) # user1 created a repo user1_repo = self.create_repo(name='user1-repo', desc='', username=self.user1.username, passwd=None) user1_repos = seafile_api.get_owned_repo_list(self.user1.username) self.assertEqual(len(user1_repos), 1) self.assertEqual(user1_repos[0].id, user1_repo) # user1 created a group and joined a group created by the other user1_group = self.create_group(group_name='test_group', username=self.user1.username) other_group = self.create_group(group_name='other_group', username=self.user.username) seaserv.ccnet_threaded_rpc.group_add_member(other_group.id, self.user.username, self.user1.username) user1_groups = seaserv.get_personal_groups_by_user(self.user1.username) self.assertEqual(len(user1_groups), 2) real_creator = sorted([self.user1.username, self.user.username]) test_creator = sorted([x.creator_name for x in user1_groups]) self.assertEqual(real_creator, test_creator) real_id = sorted([user1_group.id, other_group.id]) test_id = sorted([x.id for x in user1_groups]) self.assertEqual(real_id, test_id) # user2 had no repos user2_repos = seafile_api.get_owned_repo_list(self.user2.username) self.assertEqual(len(user2_repos), 0) # user2 had no groups user2_groups = seaserv.get_personal_groups_by_user(self.user2.username) self.assertEqual(len(user2_groups), 0) # admin migrate account user1 to account user2 resp = self._do_migrate() self.assertEqual(200, resp.status_code) ### Verify ### # user1 should have no repos new_user1_repos = seafile_api.get_owned_repo_list(self.user1.username) self.assertEqual(len(new_user1_repos), 0) # user1 should still in two groups, except not the creator anymore in # the first group, but second group should remain the same user1_groups = seaserv.get_personal_groups_by_user(self.user1.username) self.assertEqual(len(user1_groups), 2) real_creator = sorted([self.user1.username, self.user.username]) test_creator = sorted([x.creator_name for x in user1_groups]) self.assertNotEqual(real_creator, test_creator) real_id = sorted([user1_group.id, other_group.id]) test_id = sorted([x.id for x in user1_groups]) self.assertEqual(real_id, test_id) # user2 should have the repo used to be user1's new_user2_repos = seafile_api.get_owned_repo_list(self.user2.username) self.assertEqual(len(new_user2_repos), 1) self.assertEqual(new_user2_repos[0].id, user1_repo) # user2 should be in two groups, and is the creator of first group, # but second group should remain the same user2_groups = seaserv.get_personal_groups_by_user(self.user2.username) self.assertEqual(len(user2_groups), 2) real_creator = sorted([self.user2.username, self.user.username]) test_creator = sorted([x.creator_name for x in user2_groups]) self.assertEqual(real_creator, test_creator) real_id = sorted([user1_group.id, other_group.id]) test_id = sorted([x.id for x in user2_groups]) self.assertEqual(real_id, test_id)
def get(self, request, format=None): """ List 'all' libraries (by name/owner/page) Permission checking: 1. only admin can perform this action. """ # search libraries (by name/owner) repo_name = request.GET.get('name', '') owner = request.GET.get('owner', '') repos = [] if repo_name and owner: # search by name and owner owned_repos = seafile_api.get_owned_repo_list(owner) for repo in owned_repos: if not repo.name or repo.is_virtual: continue if repo_name in repo.name: repo_info = get_repo_info(repo) repos.append(repo_info) return Response({"name": repo_name, "owner": owner, "repos": repos}) elif repo_name: # search by name(keyword in name) repos_all = seafile_api.get_repo_list(-1, -1) for repo in repos_all: if not repo.name or repo.is_virtual: continue if repo_name in repo.name: repo_info = get_repo_info(repo) repos.append(repo_info) return Response({"name": repo_name, "owner": '', "repos": repos}) elif owner: # search by owner owned_repos = seafile_api.get_owned_repo_list(owner) for repo in owned_repos: if repo.is_virtual: continue repo_info = get_repo_info(repo) repos.append(repo_info) return Response({"name": '', "owner": owner, "repos": repos}) # get libraries by page try: current_page = int(request.GET.get('page', '1')) per_page = int(request.GET.get('per_page', '100')) except ValueError: current_page = 1 per_page = 100 start = (current_page - 1) * per_page limit = per_page + 1 repos_all = seafile_api.get_repo_list(start, limit) if len(repos_all) > per_page: repos_all = repos_all[:per_page] has_next_page = True else: has_next_page = False default_repo_id = get_system_default_repo_id() repos_all = [r for r in repos_all if not r.is_virtual] repos_all = [r for r in repos_all if r.repo_id != default_repo_id] return_results = [] for repo in repos_all: repo_info = get_repo_info(repo) return_results.append(repo_info) page_info = { 'has_next_page': has_next_page, 'current_page': current_page } return Response({"page_info": page_info, "repos": return_results})
def test_repo_manipulation(): #test get_system_default_repo_id t_default_repo_id = api.get_system_default_repo_id() assert t_default_repo_id #test create_repo t_repo_id = api.create_repo('test_repo_manipulation', '', USER, passwd=None) assert t_repo_id #test counts_repo t_repo_count = 0 t_repo_count = api.count_repos() assert t_repo_count != 0 #test get_repo ,edit_repo t_new_name = 'n_name' t_new_desc = 'n_desc' t_repo_version = 1 t_repo = api.get_repo(t_repo_id) assert t_repo api.edit_repo(t_repo_id, t_new_name, t_new_desc, USER) t_repo = api.get_repo(t_repo_id) assert t_repo.name == t_new_name and t_repo.desc == t_new_desc #test revert_repo and get_commit t_commit_id_before_changing = t_repo.head_cmmt_id api.post_dir(t_repo_id, '/', 'dir1', USER) t_repo = api.get_repo(t_repo_id) api.revert_repo(t_repo_id, t_commit_id_before_changing, USER) t_repo = api.get_repo(t_repo_id) t_commit_id_after_revert = t_repo.head_cmmt_id t_commit_before_changing = api.get_commit(t_repo_id, t_repo_version, t_commit_id_before_changing) t_commit_after_revert = api.get_commit(t_repo_id, t_repo_version, t_commit_id_after_revert) assert t_commit_before_changing.root_id == t_commit_after_revert.root_id #test is_repo_owner assert api.is_repo_owner(USER, t_repo_id) assert api.is_repo_owner(USER2, t_repo_id) == 0 #test get_repo_owner owner_get = api.get_repo_owner(t_repo_id) assert owner_get == USER #test set_repo_owner api.set_repo_owner(t_repo_id, USER2) assert api.is_repo_owner(USER2, t_repo_id) #test create_enc_repo t_enc_repo_id = '826d1b7b-f110-46f2-8d5e-7b5ac3e11f4d' t_enc_version = 2 t_passwd = '123' magic_and_random_key = api.generate_magic_and_random_key( t_enc_version, t_enc_repo_id, t_passwd) t_magic = magic_and_random_key.magic t_random_key = magic_and_random_key.random_key t_enc_repo_id = api.create_enc_repo(t_enc_repo_id, 'test_encrypted_repo', '', USER, t_magic, t_random_key, t_enc_version) assert t_enc_repo_id == '826d1b7b-f110-46f2-8d5e-7b5ac3e11f4d' #test get_repo_list t_start = -1 t_limit = -1 t_repo_list = api.get_repo_list(t_start, t_limit) assert t_repo_list and len(t_repo_list) t_start = 1 t_limit = 1 t_repo_list = api.get_repo_list(t_start, t_limit) assert t_repo_list and len(t_repo_list) == 1 #test get_owned_repo_list t_repo_list = api.get_owned_repo_list(USER2) assert t_repo_list and len(t_repo_list) #test get_commit_list t_offset = 0 t_limit = 0 t_commit_list = api.get_commit_list(t_repo_id, t_offset, t_limit) assert t_commit_list and len(t_commit_list) == 4 t_offset = 1 t_limit = 1 t_commit_list = api.get_commit_list(t_repo_id, t_offset, t_limit) assert t_commit_list and len(t_commit_list) == 1 #test remove_repo api.remove_repo(t_repo_id) t_repo = api.get_repo(t_repo_id) assert t_repo == None
def test_migrate(self): self.login_as(self.admin) # user1 created a repo user1_repo = self.create_repo(name='user1-repo', desc='', username=self.user1.username, passwd=None) user1_repos = seafile_api.get_owned_repo_list(self.user1.username) self.assertEqual(len(user1_repos), 1) self.assertEqual(user1_repos[0].id, user1_repo) # user1 created a group and joined a group created by the other user1_group = self.create_group(group_name='test_group', username=self.user1.username) other_group = self.create_group(group_name='other_group', username=self.user.username) seaserv.ccnet_threaded_rpc.group_add_member(other_group.id, self.user.username, self.user1.username) user1_groups = seaserv.get_personal_groups_by_user(self.user1.username) self.assertEqual(len(user1_groups), 2) self.assertEqual(user1_groups[0].id, user1_group.id) self.assertEqual(user1_groups[0].creator_name, self.user1.username) self.assertEqual(user1_groups[1].id, other_group.id) self.assertEqual(user1_groups[1].creator_name, self.user.username) # user2 had no repos user2_repos = seafile_api.get_owned_repo_list(self.user2.username) self.assertEqual(len(user2_repos), 0) # user2 had no groups user2_groups = seaserv.get_personal_groups_by_user(self.user2.username) self.assertEqual(len(user2_groups), 0) # admin migrate account user1 to account user2 resp = self._do_migrate() self.assertEqual(200, resp.status_code) ### Verify ### # user1 should have no repos new_user1_repos = seafile_api.get_owned_repo_list(self.user1.username) self.assertEqual(len(new_user1_repos), 0) # user1 should still in two groups, except not the creator anymore in # the first group, but second group should remain the same user1_groups = seaserv.get_personal_groups_by_user(self.user1.username) self.assertEqual(len(user1_groups), 2) self.assertEqual(user1_groups[0].id, user1_group.id) self.assertNotEqual(user1_groups[0].creator_name, self.user1.username) self.assertEqual(user1_groups[1].id, other_group.id) self.assertEqual(user1_groups[1].creator_name, self.user.username) # user2 should have the repo used to be user1's new_user2_repos = seafile_api.get_owned_repo_list(self.user2.username) self.assertEqual(len(new_user2_repos), 1) self.assertEqual(new_user2_repos[0].id, user1_repo) # user2 should be in two groups, and is the creator of first group, # but second group should remain the same user2_groups = seaserv.get_personal_groups_by_user(self.user2.username) self.assertEqual(len(user2_groups), 2) self.assertEqual(user2_groups[0].id, user1_group.id) self.assertEqual(user2_groups[0].creator_name, self.user2.username) self.assertEqual(user2_groups[1].id, other_group.id) self.assertEqual(user2_groups[1].creator_name, self.user.username)
def get_owned_repos(username, org_id): if org_id: return seafile_api.get_org_owned_repo_list(org_id, username) else: return seafile_api.get_owned_repo_list(username)
def get(self, request, format=None): """ List 'all' libraries (by name/owner/page) Permission checking: 1. only admin can perform this action. """ # search libraries (by name/owner) repo_name = request.GET.get('name', '') owner = request.GET.get('owner', '') repos = [] if repo_name and owner: # search by name and owner owned_repos = seafile_api.get_owned_repo_list(owner) for repo in owned_repos: if not repo.name or repo.is_virtual: continue if repo_name in repo.name: repo_info = get_repo_info(repo) repos.append(repo_info) return Response({"name": repo_name, "owner": owner, "repos": repos}) elif repo_name: # search by name(keyword in name) repos_all = seafile_api.get_repo_list(-1, -1) for repo in repos_all: if not repo.name or repo.is_virtual: continue if repo_name in repo.name: repo_info = get_repo_info(repo) repos.append(repo_info) return Response({"name": repo_name, "owner": '', "repos": repos}) elif owner: # search by owner owned_repos = seafile_api.get_owned_repo_list(owner) for repo in owned_repos: if repo.is_virtual: continue repo_info = get_repo_info(repo) repos.append(repo_info) return Response({"name": '', "owner": owner, "repos": repos}) # get libraries by page try: current_page = int(request.GET.get('page', '1')) per_page = int(request.GET.get('per_page', '100')) except ValueError: current_page = 1 per_page = 100 start = (current_page - 1) * per_page limit = per_page + 1 repos_all = seafile_api.get_repo_list(start, limit) if len(repos_all) > per_page: repos_all = repos_all[:per_page] has_next_page = True else: has_next_page = False default_repo_id = get_system_default_repo_id() repos_all = filter(lambda r: not r.is_virtual, repos_all) repos_all = filter(lambda r: r.repo_id != default_repo_id, repos_all) return_results = [] for repo in repos_all: repo_info = get_repo_info(repo) return_results.append(repo_info) page_info = { 'has_next_page': has_next_page, 'current_page': current_page } return Response({"page_info": page_info, "repos": return_results})
def user_info(request, email): owned_repos = seafile_api.get_owned_repo_list(email) org = ccnet_threaded_rpc.get_orgs_by_user(email) org_name = None if not org: space_usage = seafile_api.get_user_self_usage(email) space_quota = seafile_api.get_user_quota(email) if CALC_SHARE_USAGE: share_usage = seafile_api.get_user_share_usage(email) share_quota = seafile_api.get_user_share_quota(email) else: share_quota = share_usage = 0 else: org_id = org[0].org_id org_name = org[0].org_name space_usage = seafserv_threaded_rpc.get_org_user_quota_usage(org_id, email) space_quota = seafserv_threaded_rpc.get_org_user_quota(org_id, email) share_usage = share_quota = 0 # Repos that are share to user in_repos = seafile_api.get_share_in_repo_list(email, -1, -1) # get user profile profile = Profile.objects.get_profile_by_user(email) d_profile = DetailedProfile.objects.get_detailed_profile_by_user(email) user_shared_links = [] # download links p_fileshares = [] fileshares = list(FileShare.objects.filter(username=email)) for fs in fileshares: r = seafile_api.get_repo(fs.repo_id) if not r: fs.delete() continue if fs.is_file_share_link(): if seafile_api.get_file_id_by_path(r.id, fs.path) is None: fs.delete() continue fs.filename = os.path.basename(fs.path) path = fs.path.rstrip('/') # Normalize file path obj_id = seafile_api.get_file_id_by_path(r.id, path) fs.file_size = seafile_api.get_file_size(r.store_id, r.version, obj_id) else: if seafile_api.get_dir_id_by_path(r.id, fs.path) is None: fs.delete() continue fs.filename = os.path.basename(fs.path.rstrip('/')) path = fs.path if path[-1] != '/': # Normalize dir path path += '/' # get dir size dir_id = seafserv_threaded_rpc.get_dirid_by_path(r.id, r.head_cmmt_id, path) fs.dir_size = seafserv_threaded_rpc.get_dir_size(r.store_id, r.version, dir_id) fs.is_download = True p_fileshares.append(fs) p_fileshares.sort(key=lambda x: x.view_cnt, reverse=True) user_shared_links += p_fileshares # upload links uploadlinks = list(UploadLinkShare.objects.filter(username=email)) p_uploadlinks = [] for link in uploadlinks: r = seafile_api.get_repo(link.repo_id) if not r: link.delete() continue if seafile_api.get_dir_id_by_path(r.id, link.path) is None: link.delete() continue link.dir_name = os.path.basename(link.path.rstrip('/')) link.is_upload = True p_uploadlinks.append(link) p_uploadlinks.sort(key=lambda x: x.view_cnt, reverse=True) user_shared_links += p_uploadlinks return render_to_response( 'sysadmin/userinfo.html', { 'owned_repos': owned_repos, 'space_quota': space_quota, 'space_usage': space_usage, 'share_quota': share_quota, 'share_usage': share_usage, 'CALC_SHARE_USAGE': CALC_SHARE_USAGE, 'in_repos': in_repos, 'email': email, 'profile': profile, 'd_profile': d_profile, 'org_name': org_name, 'user_shared_links': user_shared_links, }, context_instance=RequestContext(request))
def get(self, request): """ Return repos user can access. Permission checking: 1. all authenticated user can perform this action. """ filter_by = { 'mine': False, 'shared': False, 'group': False, 'public': False, } request_type_list = request.GET.getlist('type', "") if not request_type_list: # set all to True, no filter applied filter_by = filter_by.fromkeys(filter_by.iterkeys(), True) for request_type in request_type_list: request_type = request_type.strip() filter_by[request_type] = True email = request.user.username # Use dict to reduce memcache fetch cost in large for-loop. contact_email_dict = {} nickname_dict = {} org_id = None if is_org_context(request): org_id = request.user.org.org_id try: starred_repos = UserStarredFiles.objects.get_starred_repos_by_user( email) starred_repo_id_list = [item.repo_id for item in starred_repos] except Exception as e: logger.error(e) starred_repo_id_list = [] repo_info_list = [] if filter_by['mine']: if org_id: owned_repos = seafile_api.get_org_owned_repo_list( org_id, email, ret_corrupted=True) else: owned_repos = seafile_api.get_owned_repo_list( email, ret_corrupted=True) # Reduce memcache fetch ops. modifiers_set = set([x.last_modifier for x in owned_repos]) for e in modifiers_set: if e not in contact_email_dict: contact_email_dict[e] = email2contact_email(e) if e not in nickname_dict: nickname_dict[e] = email2nickname(e) owned_repos.sort(lambda x, y: cmp(y.last_modify, x.last_modify)) for r in owned_repos: # do not return virtual repos if r.is_virtual: continue repo_info = { "type": "mine", "repo_id": r.id, "repo_name": r.name, "owner_email": email, "owner_name": email2nickname(email), "owner_contact_email": email2contact_email(email), "last_modified": timestamp_to_isoformat_timestr(r.last_modify), "modifier_email": r.last_modifier, "modifier_name": nickname_dict.get(r.last_modifier, ''), "modifier_contact_email": contact_email_dict.get(r.last_modifier, ''), "size": r.size, "encrypted": r.encrypted, "permission": 'rw', # Always have read-write permission to owned repo "starred": r.repo_id in starred_repo_id_list, "status": normalize_repo_status_code(r.status), } if is_pro_version() and ENABLE_STORAGE_CLASSES: repo_info['storage_name'] = r.storage_name repo_info['storage_id'] = r.storage_id repo_info_list.append(repo_info) if filter_by['shared']: if org_id: shared_repos = seafile_api.get_org_share_in_repo_list( org_id, email, -1, -1) else: shared_repos = seafile_api.get_share_in_repo_list( email, -1, -1) repos_with_admin_share_to = ExtraSharePermission.objects.\ get_repos_with_admin_permission(email) # Reduce memcache fetch ops. owners_set = set([x.user for x in shared_repos]) modifiers_set = set([x.last_modifier for x in shared_repos]) for e in owners_set | modifiers_set: if e not in contact_email_dict: contact_email_dict[e] = email2contact_email(e) if e not in nickname_dict: nickname_dict[e] = email2nickname(e) shared_repos.sort(lambda x, y: cmp(y.last_modify, x.last_modify)) for r in shared_repos: owner_email = r.user group_name = '' is_group_owned_repo = False if '@seafile_group' in owner_email: is_group_owned_repo = True group_id = get_group_id_by_repo_owner(owner_email) group_name = group_id_to_name(group_id) owner_name = group_name if is_group_owned_repo else \ nickname_dict.get(owner_email, '') owner_contact_email = '' if is_group_owned_repo else \ contact_email_dict.get(owner_email, '') repo_info = { "type": "shared", "repo_id": r.repo_id, "repo_name": r.repo_name, "last_modified": timestamp_to_isoformat_timestr(r.last_modify), "modifier_email": r.last_modifier, "modifier_name": nickname_dict.get(r.last_modifier, ''), "modifier_contact_email": contact_email_dict.get(r.last_modifier, ''), "owner_email": owner_email, "owner_name": owner_name, "owner_contact_email": owner_contact_email, "size": r.size, "encrypted": r.encrypted, "permission": r.permission, "starred": r.repo_id in starred_repo_id_list, "status": normalize_repo_status_code(r.status), } if r.repo_id in repos_with_admin_share_to: repo_info['is_admin'] = True else: repo_info['is_admin'] = False repo_info_list.append(repo_info) if filter_by['group']: if org_id: group_repos = seafile_api.get_org_group_repos_by_user( email, org_id) else: group_repos = seafile_api.get_group_repos_by_user(email) group_repos.sort(lambda x, y: cmp(y.last_modify, x.last_modify)) # Reduce memcache fetch ops. share_from_set = set([x.user for x in group_repos]) modifiers_set = set([x.last_modifier for x in group_repos]) for e in modifiers_set | share_from_set: if e not in contact_email_dict: contact_email_dict[e] = email2contact_email(e) if e not in nickname_dict: nickname_dict[e] = email2nickname(e) for r in group_repos: repo_info = { "type": "group", "group_id": r.group_id, "group_name": r.group_name, "repo_id": r.repo_id, "repo_name": r.repo_name, "last_modified": timestamp_to_isoformat_timestr(r.last_modify), "modifier_email": r.last_modifier, "modifier_name": nickname_dict.get(r.last_modifier, ''), "modifier_contact_email": contact_email_dict.get(r.last_modifier, ''), "size": r.size, "encrypted": r.encrypted, "permission": r.permission, "starred": r.repo_id in starred_repo_id_list, "status": normalize_repo_status_code(r.status), } repo_info_list.append(repo_info) if filter_by['public'] and request.user.permissions.can_view_org(): public_repos = list_inner_pub_repos(request) # get repo id owner dict all_repo_owner = [] repo_id_owner_dict = {} for repo in public_repos: repo_id = repo.repo_id if repo_id not in repo_id_owner_dict: repo_owner = get_repo_owner(request, repo_id) all_repo_owner.append(repo_owner) repo_id_owner_dict[repo_id] = repo_owner # Reduce memcache fetch ops. owner_set = set(all_repo_owner) share_from_set = set([x.user for x in public_repos]) modifiers_set = set([x.last_modifier for x in public_repos]) for e in modifiers_set | share_from_set | owner_set: if e not in contact_email_dict: contact_email_dict[e] = email2contact_email(e) if e not in nickname_dict: nickname_dict[e] = email2nickname(e) for r in public_repos: repo_owner = repo_id_owner_dict[r.repo_id] repo_info = { "type": "public", "repo_id": r.repo_id, "repo_name": r.repo_name, "last_modified": timestamp_to_isoformat_timestr(r.last_modify), "modifier_email": r.last_modifier, "modifier_name": nickname_dict.get(r.last_modifier, ''), "modifier_contact_email": contact_email_dict.get(r.last_modifier, ''), "owner_email": repo_owner, "owner_name": nickname_dict.get(repo_owner, ''), "owner_contact_email": contact_email_dict.get(repo_owner, ''), "size": r.size, "encrypted": r.encrypted, "permission": r.permission, "starred": r.repo_id in starred_repo_id_list, "status": normalize_repo_status_code(r.status), } repo_info_list.append(repo_info) utc_dt = datetime.datetime.utcnow() timestamp = utc_dt.strftime('%Y-%m-%d %H:%M:%S') org_id = request.user.org.org_id if is_org_context(request) else -1 try: send_message('seahub.stats', 'user-login\t%s\t%s\t%s' % (email, timestamp, org_id)) except Exception as e: logger.error('Error when sending user-login message: %s' % str(e)) return Response({'repos': repo_info_list})
def user_info(request, email): owned_repos = seafile_api.get_owned_repo_list(email) org = ccnet_threaded_rpc.get_orgs_by_user(email) org_name = None if not org: space_usage = seafile_api.get_user_self_usage(email) space_quota = seafile_api.get_user_quota(email) if CALC_SHARE_USAGE: share_usage = seafile_api.get_user_share_usage(email) share_quota = seafile_api.get_user_share_quota(email) else: share_quota = share_usage = 0 else: org_id = org[0].org_id org_name = org[0].org_name space_usage = seafserv_threaded_rpc.get_org_user_quota_usage( org_id, email) space_quota = seafserv_threaded_rpc.get_org_user_quota(org_id, email) share_usage = share_quota = 0 # Repos that are share to user in_repos = seafile_api.get_share_in_repo_list(email, -1, -1) # get user profile profile = Profile.objects.get_profile_by_user(email) d_profile = DetailedProfile.objects.get_detailed_profile_by_user(email) user_shared_links = [] # download links p_fileshares = [] fileshares = list(FileShare.objects.filter(username=email)) for fs in fileshares: r = seafile_api.get_repo(fs.repo_id) if not r: fs.delete() continue if fs.is_file_share_link(): if seafile_api.get_file_id_by_path(r.id, fs.path) is None: fs.delete() continue fs.filename = os.path.basename(fs.path) path = fs.path.rstrip('/') # Normalize file path obj_id = seafile_api.get_file_id_by_path(r.id, path) fs.file_size = seafile_api.get_file_size(r.store_id, r.version, obj_id) else: if seafile_api.get_dir_id_by_path(r.id, fs.path) is None: fs.delete() continue fs.filename = os.path.basename(fs.path.rstrip('/')) path = fs.path if path[-1] != '/': # Normalize dir path path += '/' # get dir size dir_id = seafserv_threaded_rpc.get_dirid_by_path( r.id, r.head_cmmt_id, path) fs.dir_size = seafserv_threaded_rpc.get_dir_size( r.store_id, r.version, dir_id) fs.is_download = True p_fileshares.append(fs) p_fileshares.sort(key=lambda x: x.view_cnt, reverse=True) user_shared_links += p_fileshares # upload links uploadlinks = list(UploadLinkShare.objects.filter(username=email)) p_uploadlinks = [] for link in uploadlinks: r = seafile_api.get_repo(link.repo_id) if not r: link.delete() continue if seafile_api.get_dir_id_by_path(r.id, link.path) is None: link.delete() continue link.dir_name = os.path.basename(link.path.rstrip('/')) link.is_upload = True p_uploadlinks.append(link) p_uploadlinks.sort(key=lambda x: x.view_cnt, reverse=True) user_shared_links += p_uploadlinks return render_to_response('sysadmin/userinfo.html', { 'owned_repos': owned_repos, 'space_quota': space_quota, 'space_usage': space_usage, 'share_quota': share_quota, 'share_usage': share_usage, 'CALC_SHARE_USAGE': CALC_SHARE_USAGE, 'in_repos': in_repos, 'email': email, 'profile': profile, 'd_profile': d_profile, 'org_name': org_name, 'user_shared_links': user_shared_links, }, context_instance=RequestContext(request))
def get(self, request, format=None): """ List 'all' libraries (by name/owner/page) Permission checking: 1. only admin can perform this action. """ if not request.user.admin_permissions.can_manage_library(): return api_error(status.HTTP_403_FORBIDDEN, 'Permission denied.') order_by = request.GET.get('order_by', '').lower().strip() if order_by and order_by not in ('size', 'file_count'): error_msg = 'order_by invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) # search libraries (by name/owner) repo_name = request.GET.get('name', '') owner = request.GET.get('owner', '') repos = [] if repo_name and owner: # search by name and owner orgs = ccnet_api.get_orgs_by_user(owner) if orgs: org_id = orgs[0].org_id owned_repos = seafile_api.get_org_owned_repo_list( org_id, owner) else: owned_repos = seafile_api.get_owned_repo_list(owner) for repo in owned_repos: if not repo.name or repo.is_virtual: continue if repo_name in repo.name: repo_info = get_repo_info(repo) repos.append(repo_info) return Response({ "name": repo_name, "owner": owner, "repos": repos }) elif repo_name: # search by name(keyword in name) repos_all = seafile_api.get_repo_list(-1, -1) for repo in repos_all: if not repo.name or repo.is_virtual: continue if repo_name in repo.name: repo_info = get_repo_info(repo) repos.append(repo_info) return Response({"name": repo_name, "owner": '', "repos": repos}) elif owner: # search by owner orgs = ccnet_api.get_orgs_by_user(owner) if orgs: org_id = orgs[0].org_id owned_repos = seafile_api.get_org_owned_repo_list( org_id, owner) else: owned_repos = seafile_api.get_owned_repo_list(owner) for repo in owned_repos: if repo.is_virtual: continue repo_info = get_repo_info(repo) repos.append(repo_info) return Response({"name": '', "owner": owner, "repos": repos}) # get libraries by page try: current_page = int(request.GET.get('page', '1')) per_page = int(request.GET.get('per_page', '100')) except ValueError: current_page = 1 per_page = 100 start = (current_page - 1) * per_page limit = per_page + 1 if order_by: repos_all = seafile_api.get_repo_list(start, limit, order_by) else: repos_all = seafile_api.get_repo_list(start, limit) if len(repos_all) > per_page: repos_all = repos_all[:per_page] has_next_page = True else: has_next_page = False default_repo_id = get_system_default_repo_id() repos_all = [r for r in repos_all if not r.is_virtual] repos_all = [r for r in repos_all if r.repo_id != default_repo_id] return_results = [] for repo in repos_all: repo_info = get_repo_info(repo) return_results.append(repo_info) page_info = { 'has_next_page': has_next_page, 'current_page': current_page } return Response({"page_info": page_info, "repos": return_results})
def list_repos_by_owner(owner): repos = seafile_api.get_owned_repo_list(owner) for e in repos: e.owner = owner return repos
def get(self, request): """ Return repos user can access. Permission checking: 1. all authenticated user can perform this action. """ filter_by = { 'mine': False, 'shared': False, 'group': False, 'public': False, } request_type_list = request.GET.getlist('type', "") if not request_type_list: # set all to True, no filter applied filter_by = filter_by.fromkeys(filter_by.iterkeys(), True) for request_type in request_type_list: request_type = request_type.strip() filter_by[request_type] = True email = request.user.username # Use dict to reduce memcache fetch cost in large for-loop. contact_email_dict = {} nickname_dict = {} org_id = None if is_org_context(request): org_id = request.user.org.org_id repo_info_list = [] if filter_by['mine']: if org_id: owned_repos = seafile_api.get_org_owned_repo_list(org_id, email, ret_corrupted=True) else: owned_repos = seafile_api.get_owned_repo_list(email, ret_corrupted=True) # Reduce memcache fetch ops. modifiers_set = set([x.last_modifier for x in owned_repos]) for e in modifiers_set: if e not in contact_email_dict: contact_email_dict[e] = email2contact_email(e) if e not in nickname_dict: nickname_dict[e] = email2nickname(e) owned_repos.sort(lambda x, y: cmp(y.last_modify, x.last_modify)) for r in owned_repos: # do not return virtual repos if r.is_virtual: continue repo_info = { "type": "mine", "repo_id": r.id, "repo_name": r.name, "owner_email": email, "owner_name": email2nickname(email), "owner_contact_email": email2contact_email(email), "last_modified": timestamp_to_isoformat_timestr(r.last_modify), "modifier_email": r.last_modifier, "modifier_name": nickname_dict.get(r.last_modifier, ''), "modifier_contact_email": contact_email_dict.get(r.last_modifier, ''), "size": r.size, "encrypted": r.encrypted, "permission": 'rw', # Always have read-write permission to owned repo } repo_info_list.append(repo_info) if filter_by['shared']: if org_id: shared_repos = seafile_api.get_org_share_in_repo_list(org_id, email, -1, -1) else: shared_repos = seafile_api.get_share_in_repo_list( email, -1, -1) repos_with_admin_share_to = ExtraSharePermission.objects.\ get_repos_with_admin_permission(email) # Reduce memcache fetch ops. owners_set = set([x.user for x in shared_repos]) modifiers_set = set([x.last_modifier for x in shared_repos]) for e in owners_set | modifiers_set: if e not in contact_email_dict: contact_email_dict[e] = email2contact_email(e) if e not in nickname_dict: nickname_dict[e] = email2nickname(e) shared_repos.sort(lambda x, y: cmp(y.last_modify, x.last_modify)) for r in shared_repos: repo_info = { "type": "shared", "repo_id": r.repo_id, "repo_name": r.repo_name, "last_modified": timestamp_to_isoformat_timestr(r.last_modify), "modifier_email": r.last_modifier, "modifier_name": nickname_dict.get(r.last_modifier, ''), "modifier_contact_email": contact_email_dict.get(r.last_modifier, ''), "size": r.size, "encrypted": r.encrypted, "permission": r.permission, } if r.repo_id in repos_with_admin_share_to: repo_info['is_admin'] = True else: repo_info['is_admin'] = False repo_info_list.append(repo_info) if filter_by['group']: if org_id: group_repos = seafile_api.get_org_group_repos_by_user(email, org_id) else: group_repos = seafile_api.get_group_repos_by_user(email) group_repos.sort(lambda x, y: cmp(y.last_modify, x.last_modify)) # Reduce memcache fetch ops. share_from_set = set([x.user for x in group_repos]) modifiers_set = set([x.last_modifier for x in group_repos]) for e in modifiers_set | share_from_set: if e not in contact_email_dict: contact_email_dict[e] = email2contact_email(e) if e not in nickname_dict: nickname_dict[e] = email2nickname(e) for r in group_repos: repo_info = { "type": "group", "group_id": r.group_id, "group_name": r.group_name, "repo_id": r.repo_id, "repo_name": r.repo_name, "last_modified": timestamp_to_isoformat_timestr(r.last_modify), "modifier_email": r.last_modifier, "modifier_name": nickname_dict.get(r.last_modifier, ''), "modifier_contact_email": contact_email_dict.get(r.last_modifier, ''), "size": r.size, "encrypted": r.encrypted, "permission": r.permission, } repo_info_list.append(repo_info) if filter_by['public'] and request.user.permissions.can_view_org(): public_repos = list_inner_pub_repos(request) # Reduce memcache fetch ops. share_from_set = set([x.user for x in public_repos]) modifiers_set = set([x.last_modifier for x in public_repos]) for e in modifiers_set | share_from_set: if e not in contact_email_dict: contact_email_dict[e] = email2contact_email(e) if e not in nickname_dict: nickname_dict[e] = email2nickname(e) for r in public_repos: repo_info = { "type": "public", "repo_id": r.repo_id, "repo_name": r.repo_name, "last_modified": timestamp_to_isoformat_timestr(r.last_modify), "modifier_email": r.last_modifier, "modifier_name": nickname_dict.get(r.last_modifier, ''), "modifier_contact_email": contact_email_dict.get(r.last_modifier, ''), "size": r.size, "encrypted": r.encrypted, "permission": r.permission, } repo_info_list.append(repo_info) return Response({'repos': repo_info_list})
def edit_profile(request): """ Show and edit user profile. """ username = request.user.username if request.method == 'POST': form = ProfileForm(request.POST) if form.is_valid(): nickname = form.cleaned_data['nickname'] intro = form.cleaned_data['intro'] try: profile = Profile.objects.get(user=request.user.username) except Profile.DoesNotExist: profile = Profile() profile.user = username profile.nickname = nickname profile.intro = intro profile.save() messages.success(request, _(u'Successfully edited profile.')) # refresh nickname cache refresh_cache(request.user.username) return HttpResponseRedirect(reverse('edit_profile')) else: messages.error(request, _(u'Failed to edit profile')) else: try: profile = Profile.objects.get(user=request.user.username) form = ProfileForm({ 'nickname': profile.nickname, 'intro': profile.intro, }) except Profile.DoesNotExist: form = ProfileForm() # common logic try: server_crypto = UserOptions.objects.is_server_crypto(username) except CryptoOptionNotSetError: # Assume server_crypto is ``False`` if this option is not set. server_crypto = False sub_lib_enabled = UserOptions.objects.is_sub_lib_enabled(username) default_repo_id = UserOptions.objects.get_default_repo(username) if default_repo_id: default_repo = seafile_api.get_repo(default_repo_id) else: default_repo = None owned_repos = seafile_api.get_owned_repo_list(username) return render_to_response('profile/set_profile.html', { 'form': form, 'server_crypto': server_crypto, "sub_lib_enabled": sub_lib_enabled, 'force_server_crypto': settings.FORCE_SERVER_CRYPTO, 'default_repo': default_repo, 'owned_repos': owned_repos, }, context_instance=RequestContext(request))
def get(self, request): """ Return repos user can access. Permission checking: 1. all authenticated user can perform this action. """ filter_by = { 'mine': False, 'shared': False, 'group': False, 'public': False, } request_type_list = request.GET.getlist('type', "") if not request_type_list: # set all to True, no filter applied filter_by = filter_by.fromkeys(filter_by.iterkeys(), True) for request_type in request_type_list: request_type = request_type.strip() filter_by[request_type] = True email = request.user.username # Use dict to reduce memcache fetch cost in large for-loop. contact_email_dict = {} nickname_dict = {} org_id = None if is_org_context(request): org_id = request.user.org.org_id try: starred_repos = UserStarredFiles.objects.get_starred_repos_by_user(email) starred_repo_id_list = [item.repo_id for item in starred_repos] except Exception as e: logger.error(e) starred_repo_id_list = [] repo_info_list = [] if filter_by['mine']: if org_id: owned_repos = seafile_api.get_org_owned_repo_list(org_id, email, ret_corrupted=True) else: owned_repos = seafile_api.get_owned_repo_list(email, ret_corrupted=True) # Reduce memcache fetch ops. modifiers_set = set([x.last_modifier for x in owned_repos]) for e in modifiers_set: if e not in contact_email_dict: contact_email_dict[e] = email2contact_email(e) if e not in nickname_dict: nickname_dict[e] = email2nickname(e) owned_repos.sort(lambda x, y: cmp(y.last_modify, x.last_modify)) for r in owned_repos: # do not return virtual repos if r.is_virtual: continue repo_info = { "type": "mine", "repo_id": r.id, "repo_name": r.name, "owner_email": email, "owner_name": email2nickname(email), "owner_contact_email": email2contact_email(email), "last_modified": timestamp_to_isoformat_timestr(r.last_modify), "modifier_email": r.last_modifier, "modifier_name": nickname_dict.get(r.last_modifier, ''), "modifier_contact_email": contact_email_dict.get(r.last_modifier, ''), "size": r.size, "encrypted": r.encrypted, "permission": 'rw', # Always have read-write permission to owned repo "starred": r.repo_id in starred_repo_id_list, } if is_pro_version() and ENABLE_STORAGE_CLASSES: repo_info['storage_name'] = r.storage_name repo_info['storage_id'] = r.storage_id repo_info_list.append(repo_info) if filter_by['shared']: if org_id: shared_repos = seafile_api.get_org_share_in_repo_list(org_id, email, -1, -1) else: shared_repos = seafile_api.get_share_in_repo_list( email, -1, -1) repos_with_admin_share_to = ExtraSharePermission.objects.\ get_repos_with_admin_permission(email) # Reduce memcache fetch ops. owners_set = set([x.user for x in shared_repos]) modifiers_set = set([x.last_modifier for x in shared_repos]) for e in owners_set | modifiers_set: if e not in contact_email_dict: contact_email_dict[e] = email2contact_email(e) if e not in nickname_dict: nickname_dict[e] = email2nickname(e) shared_repos.sort(lambda x, y: cmp(y.last_modify, x.last_modify)) for r in shared_repos: owner_email = r.user group_name = '' is_group_owned_repo = False if '@seafile_group' in owner_email: is_group_owned_repo = True group_id = get_group_id_by_repo_owner(owner_email) group_name= group_id_to_name(group_id) owner_name = group_name if is_group_owned_repo else \ nickname_dict.get(owner_email, '') owner_contact_email = '' if is_group_owned_repo else \ contact_email_dict.get(owner_email, '') repo_info = { "type": "shared", "repo_id": r.repo_id, "repo_name": r.repo_name, "last_modified": timestamp_to_isoformat_timestr(r.last_modify), "modifier_email": r.last_modifier, "modifier_name": nickname_dict.get(r.last_modifier, ''), "modifier_contact_email": contact_email_dict.get(r.last_modifier, ''), "owner_email": owner_email, "owner_name": owner_name, "owner_contact_email": owner_contact_email, "size": r.size, "encrypted": r.encrypted, "permission": r.permission, "starred": r.repo_id in starred_repo_id_list, } if r.repo_id in repos_with_admin_share_to: repo_info['is_admin'] = True else: repo_info['is_admin'] = False repo_info_list.append(repo_info) if filter_by['group']: if org_id: group_repos = seafile_api.get_org_group_repos_by_user(email, org_id) else: group_repos = seafile_api.get_group_repos_by_user(email) group_repos.sort(lambda x, y: cmp(y.last_modify, x.last_modify)) # Reduce memcache fetch ops. share_from_set = set([x.user for x in group_repos]) modifiers_set = set([x.last_modifier for x in group_repos]) for e in modifiers_set | share_from_set: if e not in contact_email_dict: contact_email_dict[e] = email2contact_email(e) if e not in nickname_dict: nickname_dict[e] = email2nickname(e) for r in group_repos: repo_info = { "type": "group", "group_id": r.group_id, "group_name": r.group_name, "repo_id": r.repo_id, "repo_name": r.repo_name, "last_modified": timestamp_to_isoformat_timestr(r.last_modify), "modifier_email": r.last_modifier, "modifier_name": nickname_dict.get(r.last_modifier, ''), "modifier_contact_email": contact_email_dict.get(r.last_modifier, ''), "size": r.size, "encrypted": r.encrypted, "permission": r.permission, "starred": r.repo_id in starred_repo_id_list, } repo_info_list.append(repo_info) if filter_by['public'] and request.user.permissions.can_view_org(): public_repos = list_inner_pub_repos(request) # get repo id owner dict all_repo_owner = [] repo_id_owner_dict = {} for repo in public_repos: repo_id = repo.repo_id if repo_id not in repo_id_owner_dict: repo_owner = get_repo_owner(request, repo_id) all_repo_owner.append(repo_owner) repo_id_owner_dict[repo_id] = repo_owner # Reduce memcache fetch ops. owner_set = set(all_repo_owner) share_from_set = set([x.user for x in public_repos]) modifiers_set = set([x.last_modifier for x in public_repos]) for e in modifiers_set | share_from_set | owner_set: if e not in contact_email_dict: contact_email_dict[e] = email2contact_email(e) if e not in nickname_dict: nickname_dict[e] = email2nickname(e) for r in public_repos: repo_owner = repo_id_owner_dict[r.repo_id] repo_info = { "type": "public", "repo_id": r.repo_id, "repo_name": r.repo_name, "last_modified": timestamp_to_isoformat_timestr(r.last_modify), "modifier_email": r.last_modifier, "modifier_name": nickname_dict.get(r.last_modifier, ''), "modifier_contact_email": contact_email_dict.get(r.last_modifier, ''), "owner_email": repo_owner, "owner_name": nickname_dict.get(repo_owner, ''), "owner_contact_email": contact_email_dict.get(repo_owner, ''), "size": r.size, "encrypted": r.encrypted, "permission": r.permission, "starred": r.repo_id in starred_repo_id_list, } repo_info_list.append(repo_info) utc_dt = datetime.datetime.utcnow() timestamp = utc_dt.strftime('%Y-%m-%d %H:%M:%S') org_id = request.user.org.org_id if is_org_context(request) else -1 try: send_message('seahub.stats', 'user-login\t%s\t%s\t%s' % (email, timestamp, org_id)) except Exception as e: logger.error('Error when sending user-login message: %s' % str(e)) return Response({'repos': repo_info_list})
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( request, "wiki/personal_wiki.html", { "wiki_exists": wiki_exists, "owned_repos": owned_repos, "grps": joined_groups, }) 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( request, "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, })
def _teardown_new_user(self, username): # First delete all repos created by user for e in seafile_api.get_owned_repo_list(username): remove_repo(e.id) # Then remove user User.objects.get(email=username).delete()
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))