def share_dir_to_group(repo, path, owner, share_from, gid, permission, org_id=None):
    # Share  repo or subdir to group with permission(r, rw, admin).
    extra_share_permission = ''
    if permission == PERMISSION_ADMIN:
        extra_share_permission = permission
        permission = PERMISSION_READ_WRITE

    if is_valid_org_id(org_id):
        if path == '/':
            seafile_api.add_org_group_repo(repo.repo_id, org_id, gid, 
                                           owner, permission)
        else:
            seafile_api.org_share_subdir_to_group(org_id, repo.repo_id,
                                                                path, owner, 
                                                                gid, permission)
    else:
        if path == '/':
            seafile_api.set_group_repo(repo.repo_id, gid, owner, 
                                       permission)
        else:
            seafile_api.share_subdir_to_group(repo.repo_id, path,
                                                            owner, gid,
                                                            permission)

    # add share permission if between is admin and is extra permission.
    if path == '/' and extra_share_permission == PERMISSION_ADMIN:
        ExtraGroupsSharePermission.objects.create_share_permission(repo.repo_id, gid, extra_share_permission)

def share_to_group(request, repo, group, permission):
    """Share repo to group with given permission.
    """
    repo_id = repo.id
    group_id = group.id
    group_name = group.group_name
    from_user = request.user.username

    if is_org_context(request):
        org_id = request.user.org.org_id
        group_repo_ids = seafile_api.get_org_group_repoids(org_id, group.id)
    else:
        group_repo_ids = seafile_api.get_group_repoids(group.id)
    if repo.id in group_repo_ids:
        msg = _(u'"%(repo)s" is already in group %(group)s. <a href="%(href)s">View</a>') % {
            'repo': repo.name, 'group': group.group_name,
            'href': reverse('group_info', args=[group.id])}
        messages.error(request, msg)
        return

    try:
        if is_org_context(request):
            org_id = request.user.org.org_id
            seafile_api.add_org_group_repo(repo_id, org_id, group_id,
                                           from_user, permission)
        else:
            seafile_api.set_group_repo(repo_id, group_id, from_user,
                                       permission)
    except Exception, e:
        logger.error(e)
        msg = _(u'Failed to share %(repo)s to %(group)s, please try again later.') % \
            {'repo': repo.name, 'group': group_name}
        messages.error(request, msg)

    def test_reshare_to_user_group_after_transfer_repo(self):

        tmp_user = '[email protected]'
        User.objects.create_user(tmp_user)

        # add admin user to group
        ccnet_api.group_add_member(self.group_id, self.user_name, self.admin.username)

        # share user's repo to tmp_user with 'rw' permission
        seafile_api.share_repo(self.user_repo_id, self.user.username,
                tmp_user, 'rw')

        # share user's repo to group with 'r' permission
        seafile_api.set_group_repo(self.user_repo_id, self.group_id,
                self.user_name, 'r')
        group_repos = seafile_api.get_repos_by_group(self.group_id)

        assert group_repos[0].permission == 'r'
        assert seafile_api.check_permission_by_path(self.user_repo_id,
                '/', tmp_user) == 'rw'

        self.login_as(self.user)

        url = reverse("api2-repo-owner", args=[self.user_repo_id])
        data = 'owner=%s' % self.admin.email

        # transfer repo to admin
        resp = self.client.put(url, data, 'application/x-www-form-urlencoded')
        self.assertEqual(200, resp.status_code)

        group_repos = seafile_api.get_repos_by_group(self.group_id)
        assert group_repos[0].permission == 'r'
        assert seafile_api.check_permission_by_path(self.user_repo_id,
                '/', tmp_user) == 'rw'

    def _add_shared_items(self):
        # create repo for user
        sub_repo_id = seafile_api.create_virtual_repo(self.repo.id,
                                                      self.folder,
                                                      self.repo.name, '',
                                                      self.user.username)

        self.sub_repo_id = sub_repo_id


        # create group for admin
        admin_group_id = seaserv.ccnet_threaded_rpc.create_group('admin-group',
                self.admin.email)
        self.admin_group_id = admin_group_id

        # A user shares a folder to admin with permission 'rw'.
        seafile_api.share_repo(sub_repo_id, self.user.username,
                               self.admin.username, 'rw')

        # A user shares a folder to admin group with permission 'rw'.
        seafile_api.set_group_repo(sub_repo_id, admin_group_id,
                                   self.user.username, 'rw')

        # A user shares a folder to public with permission 'rw'.
        seafile_api.add_inner_pub_repo(sub_repo_id, 'rw')

def share_to_group(request, repo, group, permission):
    """Share repo to group with given permission.
    """
    repo_id = repo.id
    group_id = group.id
    from_user = request.user.username

    if is_org_context(request):
        org_id = request.user.org.org_id
        group_repo_ids = seafile_api.get_org_group_repoids(org_id, group.id)
    else:
        group_repo_ids = seafile_api.get_group_repoids(group.id)

    if repo.id in group_repo_ids:
        return False

    try:
        if is_org_context(request):
            org_id = request.user.org.org_id
            seafile_api.add_org_group_repo(repo_id, org_id, group_id,
                                           from_user, permission)
        else:
            seafile_api.set_group_repo(repo_id, group_id, from_user,
                                       permission)
        return True
    except Exception, e:
        logger.error(e)
        return False

    def setUp(self):
        self.user_name = self.user.username
        self.admin_name = self.admin.username
        self.group_id = self.group.id
        self.repo_id = self.repo.id

        seafile_api.set_group_repo(self.repo_id, self.group_id,
                self.admin.username, 'r')

    def share_repo_to_user_and_group(self):

        # share repo to user
        seafile_api.share_repo(self.repo_id,
                self.user_name, self.admin_name, 'rw')

        # share repo to group
        seafile_api.set_group_repo(self.repo_id,
                self.group_id, self.user_name, 'rw')

    def setUp(self):
        self.login_as(self.user)
        self.group_id = self.group.id
        self.group_name = self.group.group_name
        self.repo_id = self.repo.id

        self.url = reverse("api-v2.1-groups")

        # share repo to group
        seafile_api.set_group_repo(self.repo_id, self.group_id, self.user.email, "rw")

 def _add_shared_items(self):
     sub_repo_id = seafile_api.create_virtual_repo(self.repo.id,
                                                   self.folder,
                                                   self.repo.name, '',
                                                   self.user.username)
     # A user shares a folder to admin with permission 'rw'.
     seafile_api.share_repo(sub_repo_id, self.user.username,
                            self.admin.username, 'rw')
     # A user shares a folder to group with permission 'rw'.
     seafile_api.set_group_repo(sub_repo_id, self.group.id,
                                self.user.username, 'rw')

    def test_can_list_group_repo(self):
        self._prepare_repo_and_group()

        # A user shares a folder to admin group with permission 'rw'.
        seafile_api.set_group_repo(self.sub_repo_id,
                                   self.admin_group_id,
                                   self.user.username,
                                   'rw')


        resp = self.client.get('/api2/beshared-repos/')
        self.assertEqual(200, resp.status_code)
        json_resp = json.loads(resp.content)
        assert json_resp[0]['repo_id'] == self.sub_repo_id
        assert json_resp[0]['share_type'] == 'group'

    def test_can_get(self):
        username = self.user.username

        owner = get_repo_owner(self.fake_request, self.repo.id)
        assert owner == username
        assert get_repo_shared_users(self.repo.id, owner) == []

        # user share a repo to admin
        seafile_api.share_repo(self.repo.id, username,
                               self.admin.username, 'rw')
        assert get_repo_shared_users(self.repo.id, owner) == [self.admin.username]

        # user share a repo to group
        seafile_api.set_group_repo(self.repo.id, self.group.id,
                                   username, 'rw')
        assert get_repo_shared_users(self.repo.id, owner) == [self.admin.username, self.user2.username]

def group_wiki_create(request, group):
    if group.view_perm == "pub":
        raise Http404

    if request.method != 'POST':
        raise Http404

    content_type = 'application/json; charset=utf-8'

    def json_error(err_msg, status=400):
        result = {'error': err_msg}
        return HttpResponse(json.dumps(result), status=status,
                            content_type=content_type)

    form = WikiCreateForm(request.POST)
    if not form.is_valid():
        return json_error(str(form.errors.values()[0]))

    # create group repo in user context
    repo_name = form.cleaned_data['repo_name']
    repo_desc = form.cleaned_data['repo_desc']
    user = request.user.username
    passwd = None
    permission = "rw"

    repo_id = create_repo(repo_name, repo_desc, user, passwd)
    if not repo_id:
        return json_error(_(u'Failed to create'), 500)

    try:
        seafile_api.set_group_repo(repo_id, group.id, user, permission)
    except SearpcError as e:
        remove_repo(repo_id)
        return json_error(_(u'Failed to create: internal error.'), 500)

    GroupWiki.objects.save_group_wiki(group_id=group.id, repo_id=repo_id)

    # create home page
    page_name = "home.md"
    if not post_empty_file(repo_id, "/", page_name, user):
        return json_error(_(u'Failed to create home page. Please retry later'), 500)

    next = reverse('group_wiki', args=[group.id])
    return HttpResponse(json.dumps({'href': next}), content_type=content_type)

    def test_not_reshare_to_group_after_transfer_repo(self):
        # If new owner NOT in group repo shared to, NOT reshare to group

        # share user's repo to group with 'r' permission
        seafile_api.set_group_repo(self.user_repo_id, self.group_id,
                self.user_name, 'r')

        group_repos = seafile_api.get_repos_by_group(self.group_id)
        assert group_repos[0].permission == 'r'

        self.login_as(self.user)

        url = reverse("api2-repo-owner", args=[self.user_repo_id])
        data = 'owner=%s' % self.admin.email

        # transfer repo to admin
        resp = self.client.put(url, data, 'application/x-www-form-urlencoded')
        self.assertEqual(200, resp.status_code)

        group_repos = seafile_api.get_repos_by_group(self.group_id)
        assert len(group_repos) == 0

    def test_can_notify_others_including_group(self):
        self.logout()
        self.login_as(self.tmp_user)

        assert len(UserNotification.objects.all()) == 0

        # share repo to tmp_user
        username = self.user.username
        seafile_api.share_repo(self.repo.id, username,
                               self.tmp_user.username, 'rw')

        # share repo to group(owner, admin)
        ccnet_api.group_add_member(self.group.id, username,
                                   self.admin.username)
        seafile_api.set_group_repo(self.repo.id, self.group.id,
                                   username, 'rw')

        # tmp_user comment a file
        resp = self.client.post(self.endpoint, {
            'comment': 'new comment'
        })
        self.assertEqual(201, resp.status_code)

        assert len(UserNotification.objects.all()) == 2

        else:
            return HttpResponse(json.dumps({"success": True}), content_type=content_type)
    else:
        try:
            if encryption:
                repo_id = seafile_api.create_enc_repo(
                    uuid, repo_name, repo_desc, username, magic_str, encrypted_file_key, enc_version=2
                )
            else:
                repo_id = seafile_api.create_repo(repo_name, repo_desc, username, None)
        except SearpcError, e:
            logger.error(e)
            return json_error(_(u"Failed to create"))

        try:
            seafile_api.set_group_repo(repo_id, group.id, username, permission)
        except SearpcError, e:
            logger.error(e)
            return json_error(_(u"Failed to create: internal error."))
        else:
            return HttpResponse(json.dumps({"success": True}), content_type=content_type)


@login_required_ajax
def attention(request):
    """
    Handle ajax request to query group members used in autocomplete.
    """
    user = request.user.username
    name_str = request.GET.get("name_startsWith")
    gids = request.GET.get("gids", "")

    def put(self, request, repo_id, format=None):
        username = request.user.username
        repo = seafile_api.get_repo(repo_id)
        if not repo:
            return api_error(status.HTTP_404_NOT_FOUND, "Library %s not found." % repo_id)

        path = request.GET.get("p", "/")
        if seafile_api.get_dir_id_by_path(repo.id, path) is None:
            return api_error(status.HTTP_404_NOT_FOUND, "Folder %s not found." % path)

        if username != self.get_repo_owner(request, repo_id):
            return api_error(status.HTTP_403_FORBIDDEN, "Permission denied.")

        if path != "/":
            try:
                sub_repo = self.get_or_create_sub_repo_by_path(request, repo, path)
            except SearpcError as e:
                logger.error(e)
                return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, "Failed to get sub repo.")
        else:
            sub_repo = None

        share_type = request.data.get("share_type")
        if share_type != "user" and share_type != "group":
            return api_error(status.HTTP_400_BAD_REQUEST, "share_type invalid.")

        permission = request.data.get("permission", "r")
        if permission not in ["r", "rw"]:
            return api_error(status.HTTP_400_BAD_REQUEST, "permission invalid.")

        shared_repo = repo if path == "/" else sub_repo
        success, failed = [], []
        if share_type == "user":
            share_to_users = request.data.getlist("username")
            for to_user in share_to_users:
                if not is_valid_username(to_user):
                    failed.append(to_user)
                    continue

                try:
                    User.objects.get(email=to_user)
                except User.DoesNotExist:
                    failed.append(to_user)
                    continue

                if not check_user_share_quota(username, shared_repo, users=[to_user]):
                    return api_error(status.HTTP_403_FORBIDDEN, "Not enough quota.")

                try:
                    if is_org_context(request):
                        org_id = request.user.org.org_id
                        seaserv.seafserv_threaded_rpc.org_add_share(
                            org_id, shared_repo.id, username, to_user, permission
                        )
                    else:
                        seafile_api.share_repo(shared_repo.id, username, to_user, permission)

                    # send a signal when sharing repo successful
                    share_repo_to_user_successful.send(
                        sender=None, from_user=username, to_user=to_user, repo=shared_repo
                    )
                    success.append(
                        {
                            "share_type": "user",
                            "user_info": {"name": to_user, "nickname": email2nickname(to_user)},
                            "permission": permission,
                        }
                    )

                    send_perm_audit_msg("add-repo-perm", username, to_user, repo_id, path, permission)
                except SearpcError as e:
                    logger.error(e)
                    failed.append(to_user)
                    continue

        if share_type == "group":
            group_ids = request.data.getlist("group_id")
            for gid in group_ids:
                try:
                    gid = int(gid)
                except ValueError:
                    return api_error(status.HTTP_400_BAD_REQUEST, "group_id %s invalid." % gid)
                group = seaserv.get_group(gid)
                if not group:
                    return api_error(status.HTTP_404_NOT_FOUND, "Group %s not found" % gid)

                if not check_user_share_quota(username, shared_repo, groups=[group]):
                    return api_error(status.HTTP_403_FORBIDDEN, "Not enough quota.")

                try:
                    if is_org_context(request):
                        org_id = request.user.org.org_id
                        seafile_api.add_org_group_repo(shared_repo.repo_id, org_id, gid, username, permission)
                    else:
                        seafile_api.set_group_repo(shared_repo.repo_id, gid, username, permission)

                    success.append(
                        {
                            "share_type": "group",
                            "group_info": {"id": gid, "name": group.group_name},
#.........这里部分代码省略.........

 def share_repo_to_group_with_rw_permission(self):
     seafile_api.set_group_repo(
             self.repo.id, self.group.id, self.user.username, 'rw')

    def put(self, request, repo_id, format=None):
        username = request.user.username
        repo = seafile_api.get_repo(repo_id)
        if not repo:
            return api_error(status.HTTP_400_BAD_REQUEST, 'Repo not found.')

        path = request.GET.get('p', '/')
        if seafile_api.get_dir_id_by_path(repo.id, path) is None:
            return api_error(status.HTTP_400_BAD_REQUEST, 'Directory not found.')

        if path != '/':
            try:
                sub_repo = self.get_or_create_sub_repo_by_path(request, repo, path)
            except SearpcError as e:
                logger.error(e)
                return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, 'Failed to get sub repo')
        else:
            sub_repo = None

        share_type = request.DATA.get('share_type')
        if share_type != 'user' and share_type != 'group':
            return api_error(status.HTTP_400_BAD_REQUEST, 'Bad share type')

        permission = request.DATA.get('permission', 'r')
        if permission not in ['r', 'rw']:
            return api_error(status.HTTP_400_BAD_REQUEST, 'Bad permission')

        shared_repo = repo if path == '/' else sub_repo
        success, failed = [], []
        if share_type == 'user':
            share_to_users = request.DATA.getlist('username')
            for to_user in share_to_users:
                if not is_valid_username(to_user):
                    return api_error(status.HTTP_400_BAD_REQUEST,
                                     'Username must be a valid email address.')

                if not check_user_share_quota(username, shared_repo, users=[to_user]):
                    return api_error(status.HTTP_403_FORBIDDEN,
                                     'Failed to share: No enough quota.')

                try:
                    if is_org_context(request):
                        org_id = request.user.org.org_id
                        seaserv.seafserv_threaded_rpc.org_add_share(
                            org_id, shared_repo.id, username, to_user,
                            permission)
                    else:
                        seafile_api.share_repo(shared_repo.id, username,
                                               to_user, permission)

                    # send a signal when sharing repo successful
                    share_repo_to_user_successful.send(sender=None,
                                                       from_user=username,
                                                       to_user=to_user,
                                                       repo=shared_repo)
                    success.append({
                        "share_type": "user",
                        "user_info": {
                            "name": to_user,
                            "nickname": email2nickname(to_user),
                        },
                        "permission": permission
                    })

                    send_perm_audit_msg('add-repo-perm', username, to_user,
                                        repo_id, path, permission)
                except SearpcError as e:
                    logger.error(e)
                    failed.append(to_user)
                    continue

        if share_type == 'group':
            group_ids = request.DATA.getlist('group_id')
            for gid in group_ids:
                try:
                    gid = int(gid)
                except ValueError:
                    return api_error(status.HTTP_400_BAD_REQUEST, 'Bad group id: %s' % gid)
                group = seaserv.get_group(gid)
                if not group:
                    return api_error(status.HTTP_400_BAD_REQUEST, 'Group not found: %s' % gid)

                if not check_user_share_quota(username, shared_repo, groups=[group]):
                    return api_error(status.HTTP_403_FORBIDDEN,
                                     'Failed to share: No enough quota.')

                try:
                    if is_org_context(request):
                        org_id = request.user.org.org_id
                        seafile_api.add_org_group_repo(shared_repo.repo_id,
                                                       org_id, gid, username,
                                                       permission)
                    else:
                        seafile_api.set_group_repo(shared_repo.repo_id, gid,
                                                   username, permission)

                    success.append({
                        "share_type": "group",
                        "group_info": {
                            "id": gid,
#.........这里部分代码省略.........

 def share_repo_to_group_with_admin_permission(self):
     seafile_api.set_group_repo(
             self.repo.id, self.group.id, self.user.username, 'rw')
     ExtraGroupsSharePermission.objects.create_share_permission(self.repo.id, self.group.id, 'admin')

 def share_repo_to_group(self, repo_id):
     seafile_api.set_group_repo(
             repo_id, self.group.id,
             self.user.username, 'rw')