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 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_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 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):
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 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 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 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 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 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 list_repos_by_owner(owner):
repos = seafile_api.get_owned_repo_list(owner)
for e in repos:
e.owner = owner
return repos
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))