update parameter call of seafile api

create_org_repo(self, name, desc, username, org_id, passwd=None, enc_version=2)
create_org_enc_repo(self, repo_id, name, desc, username, magic, random_key, salt, enc_version, org_id)
add_group_owned_repo (self, group_id, name, permission, passwd=None, enc_version=2, storage_id = None)
org_add_group_owned_repo (self, org_id, group_id, name, permission, passwd=None, enc_version=2)

seahub/api2/endpoints/admin/group_owned_libraries.py

@@ -23,7 +23,8 @@ from seahub.utils.timeutils import timestamp_to_isoformat_timestr
 from seahub.share.signals import share_repo_to_group_successful
 from seahub.constants import PERMISSION_READ, PERMISSION_READ_WRITE
 
-from seahub.settings import ENABLE_STORAGE_CLASSES, STORAGE_CLASS_MAPPING_POLICY
+from seahub.settings import ENABLE_STORAGE_CLASSES, STORAGE_CLASS_MAPPING_POLICY, \
+        ENCRYPTED_LIBRARY_VERSION
 
 logger = logging.getLogger(__name__)
 
@@ -95,22 +96,26 @@ class AdminGroupOwnedLibraries(APIView):
                     return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
 
                 repo_id = seafile_api.add_group_owned_repo(group_id, repo_name,
-                        password, permission, storage_id)
+                        permission, password, ENCRYPTED_LIBRARY_VERSION, storage_id)
             else:
                 # STORAGE_CLASS_MAPPING_POLICY == 'REPO_ID_MAPPING'
                 if org_id > 0:
                     repo_id = seafile_api.org_add_group_owned_repo(
-                        org_id, group_id, repo_name, password, permission)
+                        org_id, group_id, repo_name, permission, password,
+                        ENCRYPTED_LIBRARY_VERSION)
                 else:
                     repo_id = seafile_api.add_group_owned_repo(
-                        group_id, repo_name, password, permission)
+                        group_id, repo_name, permission, password,
+                        ENCRYPTED_LIBRARY_VERSION)
         else:
             if org_id > 0:
                 repo_id = seafile_api.org_add_group_owned_repo(
-                    org_id, group_id, repo_name, password, permission)
+                    org_id, group_id, repo_name, permission, password,
+                    ENCRYPTED_LIBRARY_VERSION)
             else:
                 repo_id = seafile_api.add_group_owned_repo(group_id, repo_name,
-                                                           password, permission)
+                                                           permission, password,
+                                                           ENCRYPTED_LIBRARY_VERSION)
 
         # for activities
         username = request.user.username

seahub/api2/endpoints/group_libraries.py

@@ -188,7 +188,7 @@ class GroupLibraries(APIView):
             is_org = True
             org_id = request.user.org.org_id
             repo_id = seafile_api.create_org_repo(repo_name,
-                    '', username, password, org_id)
+                    '', username, org_id, password, enc_version=settings.ENCRYPTED_LIBRARY_VERSION)
         else:
             repo_id = seafile_api.create_repo(repo_name,
                     '', username, password, enc_version=settings.ENCRYPTED_LIBRARY_VERSION)

seahub/api2/endpoints/group_owned_libraries.py

@@ -41,7 +41,8 @@ from seahub.share.utils import share_dir_to_user, share_dir_to_group, update_use
 from seahub.constants import PERMISSION_READ, PERMISSION_READ_WRITE
 from seahub.views import check_folder_permission
 
-from seahub.settings import ENABLE_STORAGE_CLASSES, STORAGE_CLASS_MAPPING_POLICY
+from seahub.settings import ENABLE_STORAGE_CLASSES, STORAGE_CLASS_MAPPING_POLICY, \
+        ENCRYPTED_LIBRARY_VERSION
 
 logger = logging.getLogger(__name__)
 
@@ -131,7 +132,7 @@ class GroupOwnedLibraries(APIView):
                     return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
 
                 repo_id = seafile_api.add_group_owned_repo(group_id, repo_name,
-                        password, permission, storage_id)
+                        permission, password, ENCRYPTED_LIBRARY_VERSION, storage_id)
             else:
                 # STORAGE_CLASS_MAPPING_POLICY == 'REPO_ID_MAPPING'
                 repo_id = SeafileAPI.add_group_owned_repo(

seahub/api2/views.py

@@ -983,7 +983,8 @@ class Repos(APIView):
 
         if org_id > 0:
             repo_id = seafile_api.create_org_repo(repo_name,
-                    repo_desc, username, passwd, org_id)
+                    repo_desc, username, org_id, passwd,
+                    enc_version=settings.ENCRYPTED_LIBRARY_VERSION)
         else:
             if is_pro_version() and ENABLE_STORAGE_CLASSES:
 
@@ -1045,7 +1046,8 @@ class Repos(APIView):
 
         if org_id > 0:
             repo_id = seafile_api.create_org_enc_repo(repo_id, repo_name, repo_desc,
-                                                      username, magic, random_key, enc_version, org_id)
+                                                      username, magic, random_key,
+                                                      salt, enc_version, org_id)
         else:
             repo_id = seafile_api.create_enc_repo(
                 repo_id, repo_name, repo_desc, username,
@@ -1115,7 +1117,8 @@ class PubRepos(APIView):
         if is_org_context(request):
             org_id = request.user.org.org_id
             repo_id = seafile_api.create_org_repo(repo_name, repo_desc,
-                                                  username, passwd, org_id)
+                                                  username, org_id, passwd,
+                                                  enc_version=settings.ENCRYPTED_LIBRARY_VERSION)
             repo = seafile_api.get_repo(repo_id)
             seafile_api.set_org_inner_pub_repo(org_id, repo.id, permission)
         else:
@@ -4657,7 +4660,8 @@ class GroupRepos(APIView):
         if is_org_context(request):
             org_id = request.user.org.org_id
             repo_id = seafile_api.create_org_repo(repo_name, repo_desc,
-                                                  username, passwd, org_id)
+                                                  username, org_id, passwd,
+                                                  enc_version=settings.ENCRYPTED_LIBRARY_VERSION)
             repo = seafile_api.get_repo(repo_id)
             seafile_api.add_org_group_repo(repo_id, org_id, group.id,
                                            username, permission)

seahub/drafts/utils.py

@@ -16,8 +16,7 @@ logger = logging.getLogger(__name__)
 def create_user_draft_repo(username, org_id=-1):
     repo_name = 'Drafts'
     if org_id > 0:
-        repo_id = seafile_api.create_org_repo(repo_name, '', username,
+        repo_id = seafile_api.create_org_repo(repo_name, '', username, org_id)
-                                              passwd=None, org_id=org_id)
     else:
         repo_id = seafile_api.create_repo(repo_name, '', username)
     return repo_id

seahub/group/views.py

@@ -193,84 +193,6 @@ def send_group_member_add_mail(request, group, from_user, to_user):
     subject = _(u'You are invited to join a group on %s') % get_site_name()
     send_html_email(subject, 'group/add_member_email.html', c, None, [to_user])
 
-@login_required_ajax
-def create_group_repo(request, group_id):
-    """Create a repo and share it to current group"""
-
-    content_type = 'application/json; charset=utf-8'
-
-    def json_error(err_msg):
-        result = {'error': err_msg}
-        return HttpResponseBadRequest(json.dumps(result),
-                                      content_type=content_type)
-    group_id = int(group_id)
-    group = get_group(group_id)
-    if not group:
-        return json_error(_(u'Failed to create: the group does not exist.'))
-
-    # Check whether user belongs to the group.
-    username = request.user.username
-    if not is_group_member(group_id, username):
-        return json_error(_(u'Failed to create: you are not in the group.'))
-
-    form = SharedRepoCreateForm(request.POST)
-    if not form.is_valid():
-        return json_error(str(form.errors.values()[0]))
-
-    # Form is valid, create group repo
-    repo_name = form.cleaned_data['repo_name']
-    repo_desc = form.cleaned_data['repo_desc']
-    permission = form.cleaned_data['permission']
-    encryption = int(form.cleaned_data['encryption'])
-
-    uuid = form.cleaned_data['uuid']
-    magic_str = form.cleaned_data['magic_str']
-    encrypted_file_key = form.cleaned_data['encrypted_file_key']
-
-    if is_org_context(request):
-        org_id = request.user.org.org_id
-        try:
-            if encryption:
-                repo_id = seafile_api.create_org_enc_repo(
-                    uuid, repo_name, repo_desc, username, magic_str,
-                    encrypted_file_key, enc_version=2, org_id=org_id)
-            else:
-                repo_id = seafile_api.create_org_repo(repo_name, repo_desc,
-                                                      username, None, org_id)
-        except SearpcError, e:
-            logger.error(e)
-            return json_error(_(u'Failed to create'))
-
-        try:
-            seafile_api.add_org_group_repo(repo_id, org_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)
-    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)
-        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)
-
 ########## wiki
 @group_check
 def group_wiki(request, group, page_name="home"):

seahub/utils/rpc.py

@@ -10,6 +10,7 @@ import logging
 from seaserv import seafile_api
 from pysearpc import SearpcError
 from seahub.utils import is_valid_org_id
+from seahub.settings import ENCRYPTED_LIBRARY_VERSION
 
 # Get an instance of a logger
 logger = logging.getLogger(__name__)
@@ -50,10 +51,12 @@ class RPCWrapper(object):
                              storage_id=None, org_id=None):
         if is_valid_org_id(org_id):
             return seafile_api.org_add_group_owned_repo(
-                org_id, group_id, repo_name, password, permission)
+                org_id, group_id, repo_name, permission, password,
+                ENCRYPTED_LIBRARY_VERSION)
         else:
             return seafile_api.add_group_owned_repo(
-                group_id, repo_name, password, permission,
+                group_id, repo_name, permission, password,
+                enc_version=ENCRYPTED_LIBRARY_VERSION,
                 storage_id=storage_id)
 
     def delete_group_owned_repo(self, group_id, repo_id, org_id=None):

seahub/views/__init__.py

@@ -629,7 +629,6 @@ def create_default_library(request):
         default_repo = seafile_api.create_org_repo(name=_("My Library"),
                                                    desc=_("My Library"),
                                                    username=username,
-                                                   passwd=None,
                                                    org_id=org_id)
     else:
         default_repo = seafile_api.create_repo(name=_("My Library"),

seahub/views/ajax.py

@@ -1244,38 +1244,6 @@ def repo_history_changes(request, repo_id):
 
     return HttpResponse(json.dumps(changes), content_type=content_type)
 
-def _create_repo_common(request, repo_name, repo_desc, encryption,
-                        uuid, magic_str, encrypted_file_key):
-    """Common logic for creating repo.
-
-    Returns:
-        newly created repo id. Or ``None`` if error raised.
-    """
-    username = request.user.username
-    try:
-        if not encryption:
-            if is_org_context(request):
-                org_id = request.user.org.org_id
-                repo_id = seafile_api.create_org_repo(repo_name, repo_desc,
-                                                      username, None, org_id)
-            else:
-                repo_id = seafile_api.create_repo(repo_name, repo_desc, username)
-        else:
-            if is_org_context(request):
-                org_id = request.user.org.org_id
-                repo_id = seafile_api.create_org_enc_repo(
-                    uuid, repo_name, repo_desc, username, magic_str,
-                    encrypted_file_key, enc_version=2, org_id=org_id)
-            else:
-                repo_id = seafile_api.create_enc_repo(
-                    uuid, repo_name, repo_desc, username,
-                    magic_str, encrypted_file_key, enc_version=2)
-    except SearpcError as e:
-        logger.error(e)
-        repo_id = None
-
-    return repo_id
-
 @login_required_ajax
 def ajax_group_members_import(request, group_id):
     """Import users to group.

seahub/wiki/models.py

@@ -72,8 +72,7 @@ class WikiManager(models.Manager):
         now = timezone.now()
         if repo_id is None:     # create new repo to store the wiki pages
             if org_id > 0:
-                repo_id = seafile_api.create_org_repo(wiki_name, '', username,
+                repo_id = seafile_api.create_org_repo(wiki_name, '', username, org_id)
-                                                      passwd=None, org_id=org_id)
             else:
                 repo_id = seafile_api.create_repo(wiki_name, '', username)