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