reshare repo to user/group/pub when admin transfer a repo

seahub/api2/endpoints/admin/libraries.py

@@ -9,10 +9,10 @@ from rest_framework import status
 from django.template.defaultfilters import filesizeformat
 from django.utils.translation import ugettext as _
 
+import seaserv
 from seaserv import ccnet_api, seafile_api, seafserv_threaded_rpc
 
 from seahub.views import get_system_default_repo_id
-from seahub.utils import is_org_context
 from seahub.base.accounts import User
 from seahub.api2.authentication import TokenAuthentication
 from seahub.api2.throttling import UserRateThrottle
@@ -170,21 +170,66 @@ class AdminLibrary(APIView):
             error_msg = 'User %s not found.' % new_owner
             return api_error(status.HTTP_404_NOT_FOUND, error_msg)
 
-        if is_org_context(request):
+        try:
-            try:
+            if seafserv_threaded_rpc.get_org_id_by_repo_id(repo_id) > 0:
-                if seafserv_threaded_rpc.get_org_id_by_repo_id(repo_id) > 0:
+                error_msg = 'Can not transfer organization library.'
-                    error_msg = 'Can not transfer organization library.'
+                return api_error(status.HTTP_403_FORBIDDEN, error_msg)
-                    return api_error(status.HTTP_403_FORBIDDEN, error_msg)
 
-                if ccnet_api.get_orgs_by_user(new_owner):
+            if ccnet_api.get_orgs_by_user(new_owner):
-                    error_msg = 'Can not transfer library to organization user %s' % new_owner
+                error_msg = 'Can not transfer library to organization user %s' % new_owner
-                    return api_error(status.HTTP_403_FORBIDDEN, error_msg)
+                return api_error(status.HTTP_403_FORBIDDEN, error_msg)
-            except Exception as e:
+        except Exception as e:
-                logger.error(e)
+            logger.error(e)
-                error_msg = 'Internal Server Error'
+            error_msg = 'Internal Server Error'
-                return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
+            return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
 
+        repo_owner = seafile_api.get_repo_owner(repo_id)
+
+        # get repo shared to user/group list
+        shared_users = seafile_api.list_repo_shared_to(
+                repo_owner, repo_id)
+        shared_groups = seafile_api.list_repo_shared_group_by_user(
+                repo_owner, repo_id)
+
+        # get all pub repos
+        pub_repos = []
+        if not request.cloud_mode:
+            pub_repos = seafile_api.list_inner_pub_repos_by_owner(repo_owner)
+
+        # transfer repo
         seafile_api.set_repo_owner(repo_id, new_owner)
+
+        # reshare repo to user
+        for shared_user in shared_users:
+            shared_username = shared_user.user
+
+            if new_owner == shared_username:
+                continue
+
+            seafile_api.share_repo(repo_id, new_owner,
+                    shared_username, shared_user.perm)
+
+        # reshare repo to group
+        for shared_group in shared_groups:
+            shared_group_id = shared_group.group_id
+
+            if not ccnet_api.is_group_user(shared_group_id, new_owner):
+                continue
+
+            seafile_api.set_group_repo(repo_id, shared_group_id,
+                    new_owner, shared_group.perm)
+
+        # check if current repo is pub-repo
+        # if YES, reshare current repo to public
+        for pub_repo in pub_repos:
+            if repo_id != pub_repo.id:
+                continue
+
+            seaserv.seafserv_threaded_rpc.set_inner_pub_repo(
+                    repo_id, pub_repo.permission)
+
+            break
+
         repo = seafile_api.get_repo(repo_id)
         repo_info = get_repo_info(repo)
 

seahub/api2/endpoints/shared_folders.py

@@ -40,12 +40,9 @@ class SharedFolders(APIView):
                 org_id = request.user.org.org_id
                 shared_repos += seafile_api.get_org_share_out_repo_list(org_id, username, -1, -1)
                 shared_repos += seaserv.seafserv_threaded_rpc.get_org_group_repos_by_owner(org_id, username)
-                #shared_repos += seaserv.seafserv_threaded_rpc.list_org_inner_pub_repos_by_owner(org_id, username)
             else:
                 shared_repos += seafile_api.get_share_out_repo_list(username, -1, -1)
                 shared_repos += seafile_api.get_group_repos_by_owner(username)
-                #if not request.cloud_mode:
-                    #shared_repos += seaserv.list_inner_pub_repos_by_owner(username)
         except Exception as e:
             logger.error(e)
             error_msg = 'Internal Server Error'

seahub/api2/endpoints/shared_repos.py

@@ -44,7 +44,7 @@ class SharedRepos(APIView):
                 shared_repos += seafile_api.get_share_out_repo_list(username, -1, -1)
                 shared_repos += seafile_api.get_group_repos_by_owner(username)
                 if not request.cloud_mode:
-                    shared_repos += seaserv.list_inner_pub_repos_by_owner(username)
+                    shared_repos += seafile_api.list_inner_pub_repos_by_owner(username)
         except Exception as e:
             logger.error(e)
             error_msg = 'Internal Server Error'

seahub/api2/views.py

@@ -118,8 +118,7 @@ from seaserv import seafserv_threaded_rpc, \
     get_personal_groups_by_user, get_session_info, is_personal_repo, \
     get_repo, check_permission, get_commits, is_passwd_set,\
     check_quota, list_share_repos, get_group_repos_by_owner, get_group_repoids, \
-    list_inner_pub_repos_by_owner, is_group_user, \
+    is_group_user, remove_share, unset_inner_pub_repo, get_group, \
-    remove_share, unset_inner_pub_repo, get_group, \
     get_commit, get_file_id_by_path, MAX_DOWNLOAD_DIR_SIZE, edit_repo, \
     ccnet_threaded_rpc, get_personal_groups, seafile_api, \
     create_org, ccnet_api
@@ -1123,6 +1122,7 @@ class RepoOwner(APIView):
             error_msg = 'Permission denied.'
             return api_error(status.HTTP_403_FORBIDDEN, error_msg)
 
+        pub_repos = []
         if org_id:
             # get repo shared to user/group list
             shared_users = seafile_api.list_org_repo_shared_to(org_id,
@@ -1130,7 +1130,7 @@ class RepoOwner(APIView):
             shared_groups = seafile_api.list_org_repo_shared_group(org_id,
                     repo_owner, repo_id)
 
-            # get all pub repos
+            # get all org pub repos
             pub_repos = seaserv.seafserv_threaded_rpc.list_org_inner_pub_repos_by_owner(
                     org_id, repo_owner)
         else:
@@ -1141,8 +1141,8 @@ class RepoOwner(APIView):
                     repo_owner, repo_id)
 
             # get all pub repos
-            pub_repos = seaserv.seafserv_threaded_rpc.list_inner_pub_repos_by_owner(
+            if not request.cloud_mode:
-                    repo_owner)
+                pub_repos = seafile_api.list_inner_pub_repos_by_owner(repo_owner)
 
         # transfer repo
         try:
@@ -1195,8 +1195,8 @@ class RepoOwner(APIView):
                 continue
 
             if org_id:
-                seaserv.seafserv_threaded_rpc.set_org_inner_pub_repo(
+                seafile_api.set_org_inner_pub_repo(org_id, repo_id,
-                        org_id, repo_id, pub_repo.permission)
+                        pub_repo.permission)
             else:
                 seaserv.seafserv_threaded_rpc.set_inner_pub_repo(
                         repo_id, pub_repo.permission)
@@ -2495,6 +2495,7 @@ class DirView(APIView):
                                             content_type=json_content_type)
                     response["oid"] = dir_id
                     response["dir_perm"] = seafile_api.check_permission_by_path(repo_id, path, username)
+
                     return response
 
             return get_dir_entrys_by_id(request, repo, path, dir_id, request_type)
@@ -2839,7 +2840,7 @@ class SharedRepos(APIView):
         shared_repos += list_share_repos(username, 'from_email', -1, -1)
         shared_repos += get_group_repos_by_owner(username)
         if not CLOUD_MODE:
-            shared_repos += list_inner_pub_repos_by_owner(username)
+            shared_repos += seafile_api.list_inner_pub_repos_by_owner(username)
 
         return HttpResponse(json.dumps(shared_repos, cls=SearpcObjEncoder),
                             status=200, content_type=json_content_type)

seahub/views/sysadmin.py

@@ -1528,11 +1528,13 @@ def sys_repo_transfer(request):
             messages.error(request, _(u'Can not transfer organization library'))
             return HttpResponseRedirect(next)
 
-        if ccnet_threaded_rpc.get_orgs_by_user(new_owner):
+        if ccnet_api.get_orgs_by_user(new_owner):
             messages.error(request, _(u'Can not transfer library to organization user %s') % new_owner)
             return HttpResponseRedirect(next)
-    except SearpcError:    # XXX: ignore rpc not found error
+    except Exception as e:
-        pass
+        logger.error(e)
+        messages.error(request, 'Internal Server Error')
+        return HttpResponseRedirect(next)
 
     repo_owner = seafile_api.get_repo_owner(repo_id)
 
@@ -1543,8 +1545,9 @@ def sys_repo_transfer(request):
             repo_owner, repo_id)
 
     # get all pub repos
-    pub_repos = seaserv.seafserv_threaded_rpc.list_inner_pub_repos_by_owner(
+    pub_repos = []
-            repo_owner)
+    if not request.cloud_mode:
+        pub_repos = seafile_api.list_inner_pub_repos_by_owner(repo_owner)
 
     # transfer repo
     seafile_api.set_repo_owner(repo_id, new_owner)

tests/api/endpoints/test_shared_repos.py

@@ -101,8 +101,7 @@ class SharedReposTest(BaseTestCase):
 
         self.share_repo_to_public()
 
-        repos = seaserv.seafserv_threaded_rpc.list_inner_pub_repos_by_owner(
+        repos = seafile_api.list_inner_pub_repos_by_owner(self.user_name)
-                self.user_name)
         assert repos[0].permission == 'rw'
 
         self.login_as(self.user)
@@ -113,8 +112,7 @@ class SharedReposTest(BaseTestCase):
 
         self.assertEqual(200, resp.status_code)
 
-        repos = seaserv.seafserv_threaded_rpc.list_inner_pub_repos_by_owner(
+        repos = seafile_api.list_inner_pub_repos_by_owner(self.user_name)
-                self.user_name)
         assert repos[0].permission == 'r'
 
     def test_delete_user_share(self):
@@ -162,7 +160,7 @@ class SharedReposTest(BaseTestCase):
         self.share_repo_to_public()
 
         # repo in public
-        repos = seaserv.seafserv_threaded_rpc.list_inner_pub_repos_by_owner(
+        repos = seafile_api.list_inner_pub_repos_by_owner(
                 self.user_name)
         assert repos[0].permission == 'rw'
 
@@ -175,7 +173,7 @@ class SharedReposTest(BaseTestCase):
         self.assertEqual(200, resp.status_code)
 
         # repo NOT in public
-        repos = seaserv.seafserv_threaded_rpc.list_inner_pub_repos_by_owner(
+        repos = seafile_api.list_inner_pub_repos_by_owner(
                 self.user_name)
         assert len(repos) == 0