def get_user_repos(user):
"""
Get all repos that user can access, including owns, shared, public, and
repo in groups.
NOTE: collumn names in shared_repo struct are not same as owned or group
repos.
"""
email = user.username
shared_repos = list_share_repos(email, 'to_email', -1, -1)
if CLOUD_MODE:
if user.org:
org_id = user.org['org_id']
owned_repos = list_org_repos_by_owner(org_id, email)
groups_repos = []
for group in get_org_groups_by_user(org_id, email):
groups_repos += get_org_group_repos(org_id, group.id, email)
public_repos = list_org_inner_pub_repos(org_id, email, -1, -1)
else:
owned_repos = list_personal_repos_by_owner(email)
groups_repos = []
for group in get_personal_groups_by_user(email):
groups_repos += get_group_repos(group.id, email)
public_repos = []
else:
owned_repos = list_personal_repos_by_owner(email)
groups_repos = []
for group in get_personal_groups_by_user(email):
groups_repos += get_group_repos(group.id, email)
public_repos = list_inner_pub_repos(email)
return (owned_repos, shared_repos, groups_repos, public_repos)
def personal_wiki_pages(request):
"""
List personal wiki pages.
"""
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()))
try:
repo = get_personal_wiki_repo(username)
pages = get_wiki_pages(repo)
except SearpcError:
return render_error(request, _('Internal Server Error'))
except WikiDoesNotExist:
return render_error(request, _('Wiki does not exists.'))
return render_to_response("wiki/personal_wiki_pages.html", {
"pages": pages,
"repo_id": repo.id,
"search_repo_id": repo.id,
"search_wiki": True,
"grps": joined_groups,
}, context_instance=RequestContext(request))
def get_groups_by_user(username, org_id):
"""List user groups.
"""
if org_id:
return seaserv.get_org_groups_by_user(org_id, username)
else:
return seaserv.get_personal_groups_by_user(username)
def rename_group_with_new_name(request, group_id, new_group_name):
"""Rename a group with new name.
Arguments:
- `request`:
- `group_id`:
- `new_group_name`:
Raises:
BadGroupNameError: New group name format is not valid.
ConflictGroupNameError: New group name confilicts with existing name.
"""
if not validate_group_name(new_group_name):
raise BadGroupNameError
# Check whether group name is duplicated.
username = request.user.username
org_id = -1
if is_org_context(request):
org_id = request.user.org.org_id
checked_groups = seaserv.get_org_groups_by_user(org_id, username)
else:
if request.cloud_mode:
checked_groups = seaserv.get_personal_groups_by_user(username)
else:
checked_groups = get_all_groups(-1, -1)
for g in checked_groups:
if g.group_name == new_group_name:
raise ConflictGroupNameError
ccnet_threaded_rpc.set_group_name(group_id, new_group_name)
def get_user_repos(user):
"""
Get all repos that user can access, including owns, shared, and repo in
groups.
NOTE: collumn names in shared_repo struct are not same as owned or group
repos.
"""
email = user.username
if user.org:
# org context
org_id = user.org['org_id']
owned_repos = list_org_repos_by_owner(org_id, email)
shared_repos = list_personal_shared_repos(email, 'to_email', -1, -1)
groups_repos = []
for group in get_org_groups_by_user(org_id, email):
groups_repos += get_org_group_repos(org_id, group.id, email)
else:
# personal context
owned_repos = list_personal_repos_by_owner(email)
shared_repos = list_personal_shared_repos(email, 'to_email', -1, -1)
groups_repos = []
for group in get_personal_groups_by_user(email):
groups_repos += get_group_repos(group.id, email)
return (owned_repos, shared_repos, groups_repos)
def get(self, request, format=None):
username = request.user.username
shared_repos = []
shared_repos += seafile_api.get_share_in_repo_list(username, -1, -1)
joined_groups = get_personal_groups_by_user(username)
for grp in joined_groups:
# Get group repos, and for each group repos...
for r_id in get_group_repoids(grp.id):
# No need to list my own repo
if seafile_api.is_repo_owner(username, r_id):
continue
# Convert repo properties due to the different collumns in Repo
# and SharedRepo
r = get_repo(r_id)
if not r:
continue
r.repo_id = r.id
r.repo_name = r.name
r.repo_desc = r.desc
cmmts = get_commits(r_id, 0, 1)
last_commit = cmmts[0] if cmmts else None
r.last_modified = last_commit.ctime if last_commit else 0
r.share_type = 'group'
r.user = seafile_api.get_repo_owner(r_id)
r.user_perm = check_permission(r_id, username)
shared_repos.append(r)
if not CLOUD_MODE:
shared_repos += list_inner_pub_repos(username)
return HttpResponse(json.dumps(shared_repos, cls=SearpcObjEncoder),
status=200, content_type=json_content_type)
def group_list(request):
username = request.user.username
if request.method == "POST":
"""
Add a new group.
"""
result = {}
content_type = "application/json; charset=utf-8"
form = GroupAddForm(request.POST)
if form.is_valid():
group_name = form.cleaned_data["group_name"]
# Check whether group name is duplicated.
if request.cloud_mode:
checked_groups = get_personal_groups_by_user(username)
else:
checked_groups = get_personal_groups(-1, -1)
for g in checked_groups:
if g.group_name == group_name:
result["error"] = _(u"There is already a group with that name.")
return HttpResponse(json.dumps(result), status=400, content_type=content_type)
# Group name is valid, create that group.
try:
ccnet_threaded_rpc.create_group(group_name.encode("utf-8"), username)
return HttpResponse(json.dumps({"success": True}), content_type=content_type)
except SearpcError, e:
result["error"] = _(e.msg)
return HttpResponse(json.dumps(result), status=500, content_type=content_type)
else:
return HttpResponseBadRequest(json.dumps(form.errors), content_type=content_type)
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 get(self, request):
""" List all groups.
"""
org_id = None
username = request.user.username
if is_org_context(request):
org_id = request.user.org.org_id
user_groups = seaserv.get_org_groups_by_user(org_id, username)
else:
user_groups = seaserv.get_personal_groups_by_user(username)
try:
size = int(request.GET.get('avatar_size', GROUP_AVATAR_DEFAULT_SIZE))
except ValueError:
size = GROUP_AVATAR_DEFAULT_SIZE
try:
with_repos = int(request.GET.get('with_repos', 0))
except ValueError:
with_repos = 0
if with_repos not in (0, 1):
error_msg = _(u'Argument can only be 0 or 1')
return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
groups = []
for g in user_groups:
group_info = get_group_info(request, g.id , size)
if with_repos:
if org_id:
group_repos = seafile_api.get_org_group_repos(org_id, g.id)
else:
group_repos = seafile_api.get_repos_by_group(g.id)
repos = []
for r in group_repos:
repo = {
"id": r.id,
"name": r.name,
"desc": r.desc,
"size": r.size,
"size_formatted": filesizeformat(r.size),
"mtime": r.last_modified,
"mtime_relative": translate_seahub_time(r.last_modified),
"encrypted": r.encrypted,
"permission": r.permission,
"owner": r.user,
"owner_nickname": email2nickname(r.user),
"share_from_me": True if username == r.user else False,
}
repos.append(repo)
group_info['repos'] = repos
groups.append(group_info)
return Response(groups)
def remove_user(self, email=None):
if not email:
email = self.user.username
try:
User.objects.get(email).delete()
except User.DoesNotExist:
pass
for g in seaserv.get_personal_groups_by_user(email):
ccnet_threaded_rpc.remove_group(g.id, email)
def group_add(request):
"""Add a new group"""
if request.method != 'POST':
raise Http404
username = request.user.username
result = {}
content_type = 'application/json; charset=utf-8'
user_can_add_group = request.user.permissions.can_add_group()
if not user_can_add_group:
result['error'] = _(u'You do not have permission to create group.')
return HttpResponse(json.dumps(result), status=403,
content_type=content_type)
# check plan
num_of_groups = getattr(request.user, 'num_of_groups', -1)
if num_of_groups > 0:
current_groups = len(request.user.joined_groups)
if current_groups > num_of_groups:
result['error'] = _(u'You can only create %d groups.<a href="http://seafile.com/">Upgrade account.</a>') % num_of_groups
return HttpResponse(json.dumps(result), status=403,
content_type=content_type)
form = GroupAddForm(request.POST)
if form.is_valid():
group_name = form.cleaned_data['group_name']
# Check whether group name is duplicated.
org_id = -1
if is_org_context(request):
org_id = request.user.org.org_id
checked_groups = seaserv.get_org_groups_by_user(org_id, username)
else:
if request.cloud_mode:
checked_groups = seaserv.get_personal_groups_by_user(username)
else:
checked_groups = get_all_groups(-1, -1)
for g in checked_groups:
if g.group_name == group_name:
result['error'] = _(u'There is already a group with that name.')
return HttpResponse(json.dumps(result), status=400,
content_type=content_type)
# Group name is valid, create that group.
try:
if org_id > 0:
create_org_group(org_id, group_name, username)
else:
create_group(group_name, username)
return HttpResponse(json.dumps({'success': True}),
content_type=content_type)
except SearpcError, e:
result['error'] = _(e.msg)
return HttpResponse(json.dumps(result), status=500,
content_type=content_type)
def libraries(request):
"""
New URL to replace myhome
"""
username = request.user.username
# options
if request.cloud_mode and request.user.org is None:
allow_public_share = False
else:
allow_public_share = True
sub_lib_enabled = UserOptions.objects.is_sub_lib_enabled(username)
max_upload_file_size = get_max_upload_file_size()
guide_enabled = UserOptions.objects.is_user_guide_enabled(username)
if guide_enabled:
create_default_library(request)
folder_perm_enabled = True if is_pro_version() and ENABLE_FOLDER_PERM else False
can_add_pub_repo = True if is_org_repo_creation_allowed(request) else False
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()))
return render_to_response('libraries.html', {
"allow_public_share": allow_public_share,
"guide_enabled": guide_enabled,
"sub_lib_enabled": sub_lib_enabled,
'enable_upload_folder': settings.ENABLE_UPLOAD_FOLDER,
'enable_resumable_fileupload': settings.ENABLE_RESUMABLE_FILEUPLOAD,
'max_number_of_files_for_fileupload': settings.MAX_NUMBER_OF_FILES_FOR_FILEUPLOAD,
'enable_thumbnail': settings.ENABLE_THUMBNAIL,
'thumbnail_default_size': settings.THUMBNAIL_DEFAULT_SIZE,
'thumbnail_size_for_grid': settings.THUMBNAIL_SIZE_FOR_GRID,
'enable_encrypted_library': config.ENABLE_ENCRYPTED_LIBRARY,
'enable_repo_history_setting': config.ENABLE_REPO_HISTORY_SETTING,
'max_upload_file_size': max_upload_file_size,
'folder_perm_enabled': folder_perm_enabled,
'is_pro': True if is_pro_version() else False,
'file_audit_enabled': FILE_AUDIT_ENABLED,
'can_add_pub_repo': can_add_pub_repo,
'joined_groups': joined_groups,
'library_templates': LIBRARY_TEMPLATES.keys() if \
isinstance(LIBRARY_TEMPLATES, dict) else []
}, context_instance=RequestContext(request))
def user_info(request, email):
"""Show user info, libraries and groups.
"""
owned_repos = mute_seafile_api.get_owned_repo_list(email,
ret_corrupted=True)
owned_repos = filter(lambda r: not r.is_virtual, owned_repos)
in_repos = mute_seafile_api.get_share_in_repo_list(email, -1, -1)
space_usage = mute_seafile_api.get_user_self_usage(email)
space_quota = mute_seafile_api.get_user_quota(email)
# get user profile
profile = Profile.objects.get_profile_by_user(email)
d_profile = DetailedProfile.objects.get_detailed_profile_by_user(email)
try:
personal_groups = seaserv.get_personal_groups_by_user(email)
except SearpcError as e:
logger.error(e)
personal_groups = []
for g in personal_groups:
try:
is_group_staff = seaserv.check_group_staff(g.id, email)
except SearpcError as e:
logger.error(e)
is_group_staff = False
if email == g.creator_name:
g.role = _('Owner')
elif is_group_staff:
g.role = _('Admin')
else:
g.role = _('Member')
return render_to_response(
'institutions/user_info.html', {
'owned_repos': owned_repos,
'space_quota': space_quota,
'space_usage': space_usage,
'in_repos': in_repos,
'email': email,
'profile': profile,
'd_profile': d_profile,
'personal_groups': personal_groups,
}, context_instance=RequestContext(request))
def process_request(self, request):
if CLOUD_MODE:
request.cloud_mode = True
# Get all orgs user created.
# orgs = get_orgs_by_user(request.user.username)
# request.user.orgs = orgs
else:
request.cloud_mode = False
request.user.org = None
request.user.orgs = None
username = request.user.username
request.user.joined_groups = seaserv.get_personal_groups_by_user(username)
return None
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 = seaserv.list_personal_repos_by_owner(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 get_contacts_and_groups(request):
if not request.is_ajax():
raise Http404
content_type = 'application/json; charset=utf-8'
username = request.user.username
contacts = Contact.objects.get_contacts_by_user(username)
contact_list = []
from seahub.avatar.templatetags.avatar_tags import avatar
for c in contacts:
contact_list.append({"email": c.contact_email, "avatar": avatar(c.contact_email, 16)})
joined_groups = get_personal_groups_by_user(username)
group_list = []
from seahub.avatar.templatetags.group_avatar_tags import grp_avatar
for g in joined_groups:
group_list.append({"id": g.id, "name": g.group_name, "avatar": grp_avatar(g.id, 16)})
return HttpResponse(json.dumps({"contacts":contact_list, "groups":group_list}), content_type=content_type)
def message_list(request):
"""List and group messages related to the user, including he/she send to
others and others send to he/she.
"""
username = request.user.username
related_user_msgs = UserMessage.objects.get_messages_related_to_user(username)
user_msgs = user_msg_info_list(related_user_msgs, username)
total_unread = 0
for msg in user_msgs.items():
total_unread += msg[1]['not_read']
joined_groups = get_personal_groups_by_user(username)
group_msgs = group_msg_info_list(joined_groups, username)
msgs = sorted(user_msgs.items() + group_msgs.items(), key=lambda x: x[1]['last_time'], reverse=True)
return render_to_response('message/all_msg_list.html', {
'msgs': msgs,
'total_unread': total_unread,
}, context_instance=RequestContext(request))
def get(self, request, format=None):
""" Search group.
Permission checking:
1. default(NOT guest) user;
"""
# argument check
q = request.GET.get('q', None)
if not q:
error_msg = 'q invalid.'
return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
# permission check
if not self._can_use_global_address_book(request):
error_msg = 'Permission denied.'
return api_error(status.HTTP_403_FORBIDDEN, error_msg)
if CLOUD_MODE:
if is_org_context(request):
org_id = request.user.org.org_id
groups = ccnet_api.get_org_groups(org_id, -1, -1)
elif settings.ENABLE_GLOBAL_ADDRESSBOOK:
groups = ccnet_api.get_all_groups(-1, -1)
else:
username = request.user.username
groups = seaserv.get_personal_groups_by_user(username)
else:
groups = ccnet_api.get_all_groups(-1, -1)
result = []
for group in groups:
group_name = group.group_name
if not group_name:
continue
if q.lower() in group_name.lower():
group_info = get_group_info(group.id)
result.append(group_info)
return Response(result)
def process_request(self, request):
username = request.user.username
request.user.org = None
if CLOUD_MODE:
request.cloud_mode = True
if MULTI_TENANCY:
orgs = seaserv.get_orgs_by_user(username)
if orgs:
request.user.org = orgs[0]
else:
request.cloud_mode = False
if CLOUD_MODE and request.user.org is not None:
org_id = request.user.org.org_id
request.user.joined_groups = seaserv.get_org_groups_by_user(org_id, username)
else:
request.user.joined_groups = seaserv.get_personal_groups_by_user(username)
return None
def get_user_repos(username):
"""
Get all repos that user can access, including owns, shared, public, and
repo in groups.
NOTE: collumn names in shared_repo struct are not same as owned or group
repos.
"""
email = username
shared_repos = seafile_api.get_share_in_repo_list(email, -1, -1)
owned_repos = list_personal_repos_by_owner(email)
groups_repos = []
for group in get_personal_groups_by_user(email):
groups_repos += get_group_repos(group.id, email)
if CLOUD_MODE:
public_repos = []
else:
public_repos = list_inner_pub_repos(email)
return (owned_repos, shared_repos, groups_repos, public_repos)
def check_group_name_conflict(request, new_group_name):
"""Check if new group name conflict with existed group.
return "True" if conflicted else "False"
"""
org_id = -1
username = request.user.username
if is_org_context(request):
org_id = request.user.org.org_id
checked_groups = seaserv.get_org_groups_by_user(org_id, username)
else:
if request.cloud_mode:
checked_groups = seaserv.get_personal_groups_by_user(username)
else:
checked_groups = seaserv.ccnet_threaded_rpc.get_all_groups(-1, -1)
for g in checked_groups:
if g.group_name == new_group_name:
return True
return False
def get_groups(email):
group_json = []
joined_groups = get_personal_groups_by_user(email)
grpmsgs = {}
for g in joined_groups:
grpmsgs[g.id] = 0
notes = UserNotification.objects.get_user_notifications(email, seen=False)
replynum = 0
for n in notes:
if n.is_group_msg():
try:
gid = n.group_message_detail_to_dict().get('group_id')
except UserNotification.InvalidDetailError:
continue
if gid not in grpmsgs:
continue
grpmsgs[gid] = grpmsgs[gid] + 1
elif n.is_grpmsg_reply():
replynum = replynum + 1
for g in joined_groups:
msg = GroupMessage.objects.filter(
group_id=g.id).order_by('-timestamp')[:1]
mtime = 0
if len(msg) >= 1:
mtime = get_timestamp(msg[0].timestamp)
group = {
"id": g.id,
"name": g.group_name,
"creator": g.creator_name,
"ctime": g.timestamp,
"mtime": mtime,
"msgnum": grpmsgs[g.id],
}
group_json.append(group)
return group_json, replynum
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': True})
else:
return api_error(status.HTTP_400_BAD_REQUEST,
'op can only be migrate.')
def get_groups(email):
group_json = []
joined_groups = get_personal_groups_by_user(email)
grpmsgs = {}
for g in joined_groups:
grpmsgs[g.id] = 0
notes = UserNotification.objects.get_user_notifications(email, seen=False)
replynum = 0
for n in notes:
if n.is_group_msg():
try:
gid = n.group_message_detail_to_dict().get('group_id')
except UserNotification.InvalidDetailError:
continue
if gid not in grpmsgs:
continue
grpmsgs[gid] = grpmsgs[gid] + 1
elif n.is_grpmsg_reply():
replynum = replynum + 1
for g in joined_groups:
msg = GroupMessage.objects.filter(group_id=g.id).order_by('-timestamp')[:1]
mtime = 0
if len(msg) >= 1:
mtime = get_timestamp(msg[0].timestamp)
group = {
"id":g.id,
"name":g.group_name,
"creator":g.creator_name,
"ctime":g.timestamp,
"mtime":mtime,
"msgnum":grpmsgs[g.id],
}
group_json.append(group)
return group_json, replynum
def process_request(self, request):
username = request.user.username
request.user.org = None
if CLOUD_MODE:
request.cloud_mode = True
if MULTI_TENANCY:
orgs = seaserv.get_orgs_by_user(username)
if orgs:
request.user.org = orgs[0]
else:
request.cloud_mode = False
if CLOUD_MODE and request.user.org is not None:
org_id = request.user.org.org_id
request.user.joined_groups = seaserv.get_org_groups_by_user(
org_id, username)
else:
request.user.joined_groups = seaserv.get_personal_groups_by_user(
username)
return 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)
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 libraries(request):
"""
New URL to replace myhome
"""
username = request.user.username
# options
if request.cloud_mode and request.user.org is None:
allow_public_share = False
else:
allow_public_share = True
sub_lib_enabled = UserOptions.objects.is_sub_lib_enabled(username)
max_upload_file_size = get_max_upload_file_size()
guide_enabled = UserOptions.objects.is_user_guide_enabled(username)
if guide_enabled:
create_default_library(request)
folder_perm_enabled = True if is_pro_version() and ENABLE_FOLDER_PERM else False
can_add_pub_repo = True if is_org_repo_creation_allowed(request) else False
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:
try:
joined_groups.sort(lambda x, y: cmp(x.group_name.lower(), y.group_name.lower()))
except Exception as e:
logger.error(e)
joined_groups = []
storages = []
if is_pro_version() and ENABLE_STORAGE_CLASSES:
storages = get_library_storages(request)
return render(request, 'libraries.html', {
"allow_public_share": allow_public_share,
"guide_enabled": guide_enabled,
"sub_lib_enabled": sub_lib_enabled,
'enable_wiki': settings.ENABLE_WIKI,
'enable_upload_folder': settings.ENABLE_UPLOAD_FOLDER,
'enable_resumable_fileupload': settings.ENABLE_RESUMABLE_FILEUPLOAD,
'max_number_of_files_for_fileupload': settings.MAX_NUMBER_OF_FILES_FOR_FILEUPLOAD,
'enable_thumbnail': settings.ENABLE_THUMBNAIL,
'enable_repo_snapshot_label': settings.ENABLE_REPO_SNAPSHOT_LABEL,
'thumbnail_default_size': settings.THUMBNAIL_DEFAULT_SIZE,
'thumbnail_size_for_grid': settings.THUMBNAIL_SIZE_FOR_GRID,
'enable_encrypted_library': config.ENABLE_ENCRYPTED_LIBRARY,
'enable_repo_history_setting': config.ENABLE_REPO_HISTORY_SETTING,
'max_upload_file_size': max_upload_file_size,
'folder_perm_enabled': folder_perm_enabled,
'is_pro': True if is_pro_version() else False,
'file_audit_enabled': FILE_AUDIT_ENABLED,
'can_add_pub_repo': can_add_pub_repo,
'joined_groups': joined_groups,
'storages': storages,
'enable_storage_classes': ENABLE_STORAGE_CLASSES,
'unread_notifications_request_interval': UNREAD_NOTIFICATIONS_REQUEST_INTERVAL,
'library_templates': LIBRARY_TEMPLATES.keys() if \
isinstance(LIBRARY_TEMPLATES, dict) else [],
'enable_share_to_all_groups': config.ENABLE_SHARE_TO_ALL_GROUPS
})
def get_group_and_contacts(email):
group_json = []
contacts_json = []
replies_json = []
gmsgnums = {}
umsgnums = {}
replies = {}
gmsgnum = umsgnum = replynum = 0
contacts = [c.contact_email for c in Contact.objects.filter(user_email=email)]
joined_groups = get_personal_groups_by_user(email)
notes = UserNotification.objects.get_user_notifications(email, seen=False)
for n in notes:
if n.is_group_msg():
try:
gid = n.group_message_detail_to_dict().get('group_id')
except UserNotification.InvalidDetailError:
continue
gmsgnums[gid] = gmsgnums.get(gid, 0) + 1
elif n.is_user_message():
msg_from = n.user_message_detail_to_dict()['msg_from']
if msg_from not in contacts:
contacts.append(msg_from)
umsgnums[n.detail] = umsgnums.get(msg_from, 0) + 1
for r in replies_json:
r['msgnum'] = replies[r['msg_id']]
for g in joined_groups:
msg = GroupMessage.objects.filter(group_id=g.id).order_by('-timestamp')[:1]
mtime = 0
lastmsg = None
if len(msg) >= 1:
mtime = get_timestamp(msg[0].timestamp)
lastmsg = msg[0].message
group = {
"id":g.id,
"name":g.group_name,
"creator":g.creator_name,
"ctime":g.timestamp,
"mtime":mtime,
"lastmsg":lastmsg,
"msgnum":gmsgnums.get(g.id, 0),
}
gmsgnum = gmsgnum + gmsgnums.get(g.id, 0)
group_json.append(group)
for contact in contacts:
msg = UserMessage.objects.get_messages_between_users(
contact, email).order_by('-timestamp')[:1]
mtime = 0
lastmsg = None
if len(msg) >= 1:
mtime = get_timestamp(msg[0].timestamp)
lastmsg = msg[0].message
c = {
'email' : contact,
'name' : email2nickname(contact),
"mtime" : mtime,
"lastmsg":lastmsg,
"msgnum" : umsgnums.get(contact, 0),
}
umsgnum = umsgnum + umsgnums.get(contact, 0)
contacts_json.append(c)
contacts_json.sort(key=lambda x: x["mtime"], reverse=True)
return contacts_json, umsgnum, group_json, gmsgnum, replies_json, replynum
def group_add(request):
"""Add a new group"""
if request.method != 'POST':
raise Http404
username = request.user.username
result = {}
content_type = 'application/json; charset=utf-8'
user_can_add_group = request.user.permissions.can_add_group()
if not user_can_add_group:
result['error'] = _(u'You do not have permission to create group.')
return HttpResponse(json.dumps(result),
status=403,
content_type=content_type)
# check plan
num_of_groups = getattr(request.user, 'num_of_groups', -1)
if num_of_groups > 0:
current_groups = len(request.user.joined_groups)
if current_groups > num_of_groups:
result['error'] = _(
u'You can only create %d groups.<a href="http://seafile.com/">Upgrade account.</a>'
) % num_of_groups
return HttpResponse(json.dumps(result),
status=403,
content_type=content_type)
form = GroupAddForm(request.POST)
if form.is_valid():
group_name = form.cleaned_data['group_name']
# Check whether group name is duplicated.
org_id = -1
if is_org_context(request):
org_id = request.user.org.org_id
checked_groups = seaserv.get_org_groups_by_user(org_id, username)
else:
if request.cloud_mode:
checked_groups = seaserv.get_personal_groups_by_user(username)
else:
checked_groups = get_all_groups(-1, -1)
for g in checked_groups:
if g.group_name == group_name:
result['error'] = _(
u'There is already a group with that name.')
return HttpResponse(json.dumps(result),
status=400,
content_type=content_type)
# Group name is valid, create that group.
try:
if org_id > 0:
create_org_group(org_id, group_name, username)
else:
create_group(group_name, username)
return HttpResponse(json.dumps({'success': True}),
content_type=content_type)
except SearpcError, e:
result['error'] = _(e.msg)
return HttpResponse(json.dumps(result),
status=500,
content_type=content_type)
def render_repo(request, repo):
"""Steps to show repo page:
If user has permission to view repo
If repo is encrypt and password is not set on server
return decrypt repo page
If repo is not encrypt or password is set on server
Show repo direntries based on requested path
If user does not have permission to view repo
return permission deny page
"""
username = request.user.username
path = get_path_from_request(request)
user_perm = check_repo_access_permission(repo.id, username)
if user_perm is None:
return render_to_response('repo_access_deny.html', {
'repo': repo,
},
context_instance=RequestContext(request))
server_crypto = False
if repo.encrypted:
try:
server_crypto = UserOptions.objects.is_server_crypto(username)
except CryptoOptionNotSetError:
return render_to_response('options/set_user_options.html', {},
context_instance=RequestContext(request))
if (repo.enc_version == 1 or (repo.enc_version == 2 and server_crypto)) \
and not is_password_set(repo.id, username):
return render_to_response('decrypt_repo_form.html', {
'repo': repo,
'next': get_next_url_from_request(request) or \
reverse('repo', args=[repo.id])
}, context_instance=RequestContext(request))
# query context args
applet_root = get_ccnetapplet_root()
httpserver_root = get_httpserver_root()
max_upload_file_size = MAX_UPLOAD_FILE_SIZE
protocol = request.is_secure() and 'https' or 'http'
domain = RequestSite(request).domain
contacts = Contact.objects.get_contacts_by_user(username)
accessible_repos = [
repo
] if repo.encrypted else get_unencry_rw_repos_by_user(username)
head_commit = get_commit(repo.head_cmmt_id)
if not head_commit:
raise Http404
repo_size = get_repo_size(repo.id)
no_quota = is_no_quota(repo.id)
search_repo_id = None if repo.encrypted else repo.id
repo_owner = seafile_api.get_repo_owner(repo.id)
is_repo_owner = True if repo_owner == username else False
more_start = None
file_list, dir_list, dirent_more = get_repo_dirents(request,
repo.id,
head_commit,
path,
offset=0,
limit=100)
if dirent_more:
more_start = 100
zipped = get_nav_path(path, repo.name)
repo_groups = get_shared_groups_by_repo_and_user(repo.id, username)
if len(repo_groups) > 1:
repo_group_str = render_to_string("snippets/repo_group_list.html",
{'groups': repo_groups})
else:
repo_group_str = ''
upload_url = get_upload_url(request, repo.id)
if repo.encrypted and repo.enc_version == 2 and not server_crypto:
ajax_upload_url = get_blks_upload_url(request, repo.id)
ajax_update_url = get_blks_update_url(request, repo.id)
else:
ajax_upload_url = get_ajax_upload_url(request, repo.id)
ajax_update_url = get_ajax_update_url(request, repo.id)
fileshare = get_fileshare(repo.id, username, path)
dir_shared_link = get_dir_share_link(fileshare)
joined_groups = get_personal_groups_by_user(request.user.username)
return render_to_response('repo.html', {
'repo': repo,
'user_perm': user_perm,
'repo_owner': repo_owner,
'is_repo_owner': is_repo_owner,
'current_commit': head_commit,
'password_set': True,
'repo_size': repo_size,
'dir_list': dir_list,
'file_list': file_list,
'dirent_more': dirent_more,
'more_start': more_start,
'path': path,
'zipped': zipped,
'accessible_repos': accessible_repos,
'applet_root': applet_root,
'groups': repo_groups,
'joined_groups': joined_groups,
'repo_group_str': repo_group_str,
'no_quota': no_quota,
'max_upload_file_size': max_upload_file_size,
'upload_url': upload_url,
'ajax_upload_url': ajax_upload_url,
'ajax_update_url': ajax_update_url,
'httpserver_root': httpserver_root,
'protocol': protocol,
'domain': domain,
'contacts': contacts,
'fileshare': fileshare,
'dir_shared_link': dir_shared_link,
'search_repo_id': search_repo_id,
'ENABLE_SUB_LIBRARY': ENABLE_SUB_LIBRARY,
'server_crypto': server_crypto,
},
context_instance=RequestContext(request))
def share_repo(request):
"""
Handle POST method to share a repo to public/groups/users based on form
data. Return to ``myhome`` page and notify user whether success or failure.
"""
next = request.META.get('HTTP_REFERER', None)
if not next:
next = SITE_ROOT
form = RepoShareForm(request.POST)
if not form.is_valid():
# TODO: may display error msg on form
raise Http404
email_or_group = form.cleaned_data['email_or_group']
repo_id = form.cleaned_data['repo_id']
permission = form.cleaned_data['permission']
from_email = request.user.username
repo = seafile_api.get_repo(repo_id)
if not repo:
raise Http404
# Test whether user is the repo owner.
if not validate_owner(request, repo_id):
msg = _(u'Only the owner of the library has permission to share it.')
messages.error(request, msg)
return HttpResponseRedirect(next)
# Parsing input values.
share_to_list = string2list(email_or_group)
share_to_all, share_to_group_names, share_to_users = False, [], []
for share_to in share_to_list:
if share_to == 'all':
share_to_all = True
elif share_to.find('@') == -1:
share_to_group_names.append(share_to)
else:
share_to_users.append(share_to.lower())
share_to_groups = []
# get all personal groups
for group in seaserv.get_personal_groups_by_user(from_email):
# for every group that user joined, if group name matchs,
# then has find the group
if group.group_name in share_to_group_names:
share_to_groups.append(group)
if share_to_all and not CLOUD_MODE:
share_to_public(request, repo, permission)
if not check_user_share_quota(from_email, repo, users=share_to_users,
groups=share_to_groups):
messages.error(request, _('Failed to share "%s", no enough quota. <a href="http://seafile.com/">Upgrade account.</a>') % repo.name)
return HttpResponseRedirect(next)
for group in share_to_groups:
share_to_group(request, repo, from_email, group, permission)
for email in share_to_users:
# Add email to contacts.
mail_sended.send(sender=None, user=request.user.username, email=email)
share_to_user(request, repo, from_email, email, permission)
return HttpResponseRedirect(next)
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:
joined_groups = seaserv.get_personal_groups_by_user(username)
except SearpcError, e:
util.warn("Failed to get groups for %s" % username)
for g in joined_groups:
try:
group_repos = seafile_api.get_group_repo_list(g.id)
for repo in group_repos:
if all_repos.has_key(repo.id):
continue
all_repos[repo.id] = repo
except SearpcError, e:
util.warn("Failed to list repos in group %d" % g.id)
# Don't include encrypted repos
ret = []
for repo in all_repos.values():
def get(self, request, format=None):
email = request.user.username
repos_json = []
owned_repos = list_personal_repos_by_owner(email)
calculate_repo_info(owned_repos, email)
owned_repos.sort(lambda x, y: cmp(y.latest_modify, x.latest_modify))
for r in owned_repos:
repo = {
"type":"repo",
"id":r.id,
"owner":email,
"name":r.name,
"desc":r.desc,
"mtime":r.latest_modify,
"root":r.root,
"size":r.size,
"encrypted":r.encrypted,
"permission": 'rw', # Always have read-write permission to owned repo
}
repos_json.append(repo)
shared_repos = seafile_api.get_share_in_repo_list(email, -1, -1)
for r in shared_repos:
commit = get_commits(r.repo_id, 0, 1)[0]
if not commit:
continue
r.latest_modify = commit.ctime
r.root = commit.root_id
r.size = server_repo_size(r.repo_id)
r.password_need = is_passwd_set(r.repo_id, email)
r.permission = check_permission(r.repo_id, email)
repo = {
"type":"srepo",
"id":r.repo_id,
"owner":r.user,
"name":r.repo_name,
"desc":r.repo_desc,
"mtime":r.latest_modify,
"root":r.root,
"size":r.size,
"encrypted":r.encrypted,
"permission": r.permission,
}
repos_json.append(repo)
groups = get_personal_groups_by_user(email)
for group in groups:
g_repos = get_group_repos(group.id, email)
calculate_repo_info (g_repos, email)
g_repos.sort(lambda x, y: cmp(y.latest_modify, x.latest_modify))
for r in g_repos:
repo = {
"type":"grepo",
"id":r.id,
"owner":group.group_name,
"name":r.name,
"desc":r.desc,
"mtime":r.latest_modify,
"root":r.root,
"size":r.size,
"encrypted":r.encrypted,
"permission": check_permission(r.id, email),
}
repos_json.append(repo)
return Response(repos_json)
def get(self, request):
""" List all groups.
"""
org_id = None
username = request.user.username
if is_org_context(request):
org_id = request.user.org.org_id
user_groups = seaserv.get_org_groups_by_user(org_id, username)
else:
user_groups = seaserv.get_personal_groups_by_user(username)
try:
size = int(
request.GET.get('avatar_size', GROUP_AVATAR_DEFAULT_SIZE))
except ValueError:
size = GROUP_AVATAR_DEFAULT_SIZE
try:
with_repos = int(request.GET.get('with_repos', 0))
except ValueError:
with_repos = 0
if with_repos not in (0, 1):
error_msg = _(u'Argument can only be 0 or 1')
return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
groups = []
for g in user_groups:
group_info = get_group_info(request, g.id, size)
if with_repos:
if org_id:
group_repos = seafile_api.get_org_group_repos(org_id, g.id)
else:
group_repos = seafile_api.get_repos_by_group(g.id)
repos = []
for r in group_repos:
repo = {
"id": r.id,
"name": r.name,
"desc": r.desc,
"size": r.size,
"size_formatted": filesizeformat(r.size),
"mtime": r.last_modified,
"mtime_relative":
translate_seahub_time(r.last_modified),
"encrypted": r.encrypted,
"permission": r.permission,
"owner": r.user,
"owner_nickname": email2nickname(r.user),
"share_from_me": True if username == r.user else False,
}
repos.append(repo)
group_info['repos'] = repos
groups.append(group_info)
return Response(groups)
def render_repo(request, repo):
"""Steps to show repo page:
If user has permission to view repo
If repo is encrypt and password is not set on server
return decrypt repo page
If repo is not encrypt or password is set on server
Show repo direntries based on requested path
If user does not have permission to view repo
return permission deny page
"""
username = request.user.username
path = get_path_from_request(request)
user_perm = check_repo_access_permission(repo.id, username)
if user_perm is None:
return render_to_response("repo_access_deny.html", {"repo": repo}, context_instance=RequestContext(request))
if (
repo.encrypted
and (repo.enc_version == 1 or (repo.enc_version == 2 and SERVER_CRYPTO))
and not is_password_set(repo.id, username)
):
return render_to_response(
"decrypt_repo_form.html",
{"repo": repo, "next": get_next_url_from_request(request) or reverse("repo", args=[repo.id])},
context_instance=RequestContext(request),
)
# query context args
applet_root = get_ccnetapplet_root()
httpserver_root = get_httpserver_root()
max_upload_file_size = MAX_UPLOAD_FILE_SIZE
protocol = request.is_secure() and "https" or "http"
domain = RequestSite(request).domain
contacts = Contact.objects.get_contacts_by_user(username)
accessible_repos = [repo] if repo.encrypted else get_unencry_rw_repos_by_user(username)
head_commit = get_commit(repo.head_cmmt_id)
if not head_commit:
raise Http404
repo_size = get_repo_size(repo.id)
no_quota = is_no_quota(repo.id)
search_repo_id = None if repo.encrypted else repo.id
repo_owner = seafile_api.get_repo_owner(repo.id)
is_repo_owner = True if repo_owner == username else False
more_start = None
file_list, dir_list, dirent_more = get_repo_dirents(request, repo.id, head_commit, path, offset=0, limit=100)
if dirent_more:
more_start = 100
zipped = get_nav_path(path, repo.name)
repo_groups = get_shared_groups_by_repo_and_user(repo.id, username)
if len(repo_groups) > 1:
repo_group_str = render_to_string("snippets/repo_group_list.html", {"groups": repo_groups})
else:
repo_group_str = ""
upload_url = get_upload_url(request, repo.id)
if repo.encrypted and repo.enc_version == 2 and not SERVER_CRYPTO:
ajax_upload_url = get_blks_upload_url(request, repo.id)
ajax_update_url = get_blks_update_url(request, repo.id)
else:
ajax_upload_url = get_ajax_upload_url(request, repo.id)
ajax_update_url = get_ajax_update_url(request, repo.id)
fileshare = get_fileshare(repo.id, username, path)
dir_shared_link = get_dir_share_link(fileshare)
joined_groups = get_personal_groups_by_user(request.user.username)
return render_to_response(
"repo.html",
{
"repo": repo,
"user_perm": user_perm,
"repo_owner": repo_owner,
"is_repo_owner": is_repo_owner,
"current_commit": head_commit,
"password_set": True,
"repo_size": repo_size,
"dir_list": dir_list,
"file_list": file_list,
"dirent_more": dirent_more,
"more_start": more_start,
"path": path,
"zipped": zipped,
"accessible_repos": accessible_repos,
"applet_root": applet_root,
"groups": repo_groups,
"joined_groups": joined_groups,
"repo_group_str": repo_group_str,
"no_quota": no_quota,
"max_upload_file_size": max_upload_file_size,
"upload_url": upload_url,
"ajax_upload_url": ajax_upload_url,
"ajax_update_url": ajax_update_url,
"httpserver_root": httpserver_root,
"protocol": protocol,
"domain": domain,
"contacts": contacts,
"fileshare": fileshare,
"dir_shared_link": dir_shared_link,
"search_repo_id": search_repo_id,
"ENABLE_SUB_LIBRARY": ENABLE_SUB_LIBRARY,
},
context_instance=RequestContext(request),
)
def share_repo(request):
"""
Handle POST method to share a repo to public/groups/users based on form
data. Return to ``myhome`` page and notify user whether success or failure.
"""
next = request.META.get('HTTP_REFERER', None)
if not next:
next = SITE_ROOT
form = RepoShareForm(request.POST)
if not form.is_valid():
# TODO: may display error msg on form
raise Http404
email_or_group = form.cleaned_data['email_or_group']
repo_id = form.cleaned_data['repo_id']
permission = form.cleaned_data['permission']
from_email = request.user.username
repo = seafile_api.get_repo(repo_id)
if not repo:
raise Http404
# Test whether user is the repo owner.
if not validate_owner(request, repo_id):
msg = _(u'Only the owner of the library has permission to share it.')
messages.error(request, msg)
return HttpResponseRedirect(next)
# Parsing input values.
share_to_list = string2list(email_or_group)
share_to_all, share_to_group_names, share_to_users = False, [], []
for share_to in share_to_list:
if share_to == 'all':
share_to_all = True
elif share_to.find('@') == -1:
share_to_group_names.append(share_to)
else:
share_to_users.append(share_to.lower())
share_to_groups = []
# get all personal groups
for group in seaserv.get_personal_groups_by_user(from_email):
# for every group that user joined, if group name matchs,
# then has find the group
if group.group_name in share_to_group_names:
share_to_groups.append(group)
if share_to_all and not CLOUD_MODE:
share_to_public(request, repo, permission)
if not check_user_share_quota(
from_email, repo, users=share_to_users, groups=share_to_groups):
messages.error(
request,
_('Failed to share "%s", no enough quota. <a href="http://seafile.com/">Upgrade account.</a>'
) % repo.name)
return HttpResponseRedirect(next)
for group in share_to_groups:
share_to_group(request, repo, from_email, group, permission)
for email in share_to_users:
# Add email to contacts.
mail_sended.send(sender=None, user=request.user.username, email=email)
share_to_user(request, repo, from_email, email, permission)
return HttpResponseRedirect(next)
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:
joined_groups = seaserv.get_personal_groups_by_user(username)
except SearpcError, e:
util.warn("Failed to get groups for %s" % username)
for g in joined_groups:
try:
group_repos = seafile_api.get_group_repo_list(g.id)
for repo in group_repos:
if all_repos.has_key(repo.id):
continue
all_repos[repo.id] = repo
except SearpcError, e:
util.warn("Failed to list repos in group %d" % g.id)
# Don't include encrypted repos
ret = []
for repo in all_repos.values():
def get(self, request):
email = request.user.username
owned_repos = seafserv_threaded_rpc.list_owned_repos(email)
calculate_repo_info (owned_repos, email)
owned_repos.sort(lambda x, y: cmp(y.latest_modify, x.latest_modify))
n_repos = seafserv_threaded_rpc.list_share_repos(email,
'to_email', -1, -1)
calculate_repo_info (n_repos, email)
owned_repos.sort(lambda x, y: cmp(y.latest_modify, x.latest_modify))
repos_json = []
for r in owned_repos:
repo = {
"type":"repo",
"id":r.id,
"owner":email,
"name":r.name,
"desc":r.desc,
"mtime":r.latest_modify,
"root":r.root,
"size":r.size,
"encrypted":r.encrypted,
"password_need":r.password_need,
}
repos_json.append(repo)
for r in n_repos:
repo = {
"type":"srepo",
"id":r.id,
"owner":r.shared_email,
"name":r.name,
"desc":r.desc,
"mtime":r.latest_modify,
"root":r.root,
"size":r.size,
"encrypted":r.encrypted,
"password_need":r.password_need,
}
repos_json.append(repo)
groups = get_personal_groups_by_user(email)
for group in groups:
g_repos = get_group_repos(group.id, email)
calculate_repo_info (g_repos, email)
owned_repos.sort(lambda x, y: cmp(y.latest_modify, x.latest_modify))
for r in g_repos:
repo = {
"type":"grepo",
"id":r.id,
"owner":group.group_name,
"name":r.name,
"desc":r.desc,
"mtime":r.latest_modify,
"root":r.root,
"size":r.size,
"encrypted":r.encrypted,
"password_need":r.password_need,
}
repos_json.append(repo)
response = Response(200, repos_json)
return self.render(response)
def get(self, request, format=None):
email = request.user.username
repos_json = []
owned_repos = list_personal_repos_by_owner(email)
calculate_repo_info(owned_repos, email)
owned_repos.sort(lambda x, y: cmp(y.latest_modify, x.latest_modify))
for r in owned_repos:
repo = {
"type": "repo",
"id": r.id,
"owner": email,
"name": r.name,
"desc": r.desc,
"mtime": r.latest_modify,
"root": r.root,
"size": r.size,
"encrypted": r.encrypted,
"permission":
'rw', # Always have read-write permission to owned repo
}
repos_json.append(repo)
shared_repos = seafile_api.get_share_in_repo_list(email, -1, -1)
for r in shared_repos:
commit = get_commits(r.repo_id, 0, 1)[0]
if not commit:
continue
r.latest_modify = commit.ctime
r.root = commit.root_id
r.size = server_repo_size(r.repo_id)
r.password_need = is_passwd_set(r.repo_id, email)
r.permission = check_permission(r.repo_id, email)
repo = {
"type": "srepo",
"id": r.repo_id,
"owner": r.user,
"name": r.repo_name,
"desc": r.repo_desc,
"mtime": r.latest_modify,
"root": r.root,
"size": r.size,
"encrypted": r.encrypted,
"permission": r.permission,
}
repos_json.append(repo)
groups = get_personal_groups_by_user(email)
for group in groups:
g_repos = get_group_repos(group.id, email)
calculate_repo_info(g_repos, email)
g_repos.sort(lambda x, y: cmp(y.latest_modify, x.latest_modify))
for r in g_repos:
repo = {
"type": "grepo",
"id": r.id,
"owner": group.group_name,
"name": r.name,
"desc": r.desc,
"mtime": r.latest_modify,
"root": r.root,
"size": r.size,
"encrypted": r.encrypted,
"permission": check_permission(r.id, email),
}
repos_json.append(repo)
return Response(repos_json)
# Group name is valid, create that group.
try:
ccnet_threaded_rpc.create_group(group_name.encode('utf-8'),
username)
return HttpResponse(json.dumps({'success': True}),
content_type=content_type)
except SearpcError, e:
result['error'] = _(e.msg)
return HttpResponse(json.dumps(result), status=500,
content_type=content_type)
else:
return HttpResponseBadRequest(json.dumps(form.errors),
content_type=content_type)
### GET ###
joined_groups = get_personal_groups_by_user(username)
return render_to_response('group/groups.html', {
'joined_groups': joined_groups,
}, context_instance=RequestContext(request))
@login_required
def group_remove(request, group_id):
"""
Remove group from groupadmin page. Only system admin can perform this
operation.
"""
# Check whether user is system admin.
if not request.user.is_staff:
return render_permission_error(request, _(u'Only administrators can delete the group.'))
def get(self, request):
""" List all groups.
"""
org_id = None
username = request.user.username
if is_org_context(request):
org_id = request.user.org.org_id
user_groups = seaserv.get_org_groups_by_user(org_id, username)
else:
user_groups = seaserv.get_personal_groups_by_user(username)
try:
avatar_size = int(request.GET.get('avatar_size', GROUP_AVATAR_DEFAULT_SIZE))
except ValueError:
avatar_size = GROUP_AVATAR_DEFAULT_SIZE
try:
with_repos = int(request.GET.get('with_repos', 0))
except ValueError:
with_repos = 0
if with_repos not in (0, 1):
error_msg = 'with_repos invalid.'
return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
groups = []
if with_repos:
gids = [g.id for g in user_groups]
admin_info = ExtraGroupsSharePermission.objects.batch_get_repos_with_admin_permission(gids)
for g in user_groups:
group_info = get_group_info(request, g.id, avatar_size)
if with_repos:
if org_id:
group_repos = seafile_api.get_org_group_repos(org_id, g.id)
else:
group_repos = seafile_api.get_repos_by_group(g.id)
repos = []
for r in group_repos:
repo = {
"id": r.id,
"name": r.name,
"size": r.size,
"size_formatted": filesizeformat(r.size),
"mtime": r.last_modified,
"mtime_relative": translate_seahub_time(r.last_modified),
"encrypted": r.encrypted,
"permission": r.permission,
"owner": r.user,
"owner_name": email2nickname(r.user),
"is_admin": (r.id, g.id) in admin_info
}
repos.append(repo)
group_info['repos'] = repos
groups.append(group_info)
return Response(groups)
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))
