Beispiel #1
0
    def test_create_in_encrypted_lib_with_invalid_password(self):

        password = randstring(8)
        encrypted_repo_id = seafile_api.create_repo('encrypted_repo_name', '',
                                                    self.user_name, password)

        dirname = randstring(8)
        seafile_api.post_dir(repo_id=encrypted_repo_id,
                             parent_dir='/',
                             dirname=dirname,
                             username=self.user_name)

        self.login_as(self.user)

        url = reverse("api2-dir-sub-repo", args=[encrypted_repo_id])

        # test invalid password argument
        args = "?p=/%s&name=%s&invalid_password=%s" % (dirname, dirname,
                                                       password)
        resp = self.client.get(url + args)
        self.assertEqual(400, resp.status_code)

        # test wrong password
        args = "?p=/%s&name=%s&password=%s" % (dirname, dirname,
                                               'invalid_password')
        resp = self.client.get(url + args)
        self.assertEqual(400, resp.status_code)
        json_resp = json.loads(resp.content)
        assert json_resp['error_msg'] == 'Wrong password'

        self.remove_repo(encrypted_repo_id)
Beispiel #2
0
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, org_id)
    else:
        repo_id = seafile_api.create_repo(repo_name, '', username)
    return repo_id
Beispiel #3
0
    def post(self, request):
        """ Admin create library

        Permission checking:
        1. only admin can perform this action.
        """

        repo_name = request.data.get('name', None)
        if not repo_name:
            error_msg = 'name invalid.'
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

        username = request.user.username
        repo_owner = request.data.get('owner', None)
        if repo_owner:
            try:
                User.objects.get(email=repo_owner)
            except User.DoesNotExist:
                error_msg = 'User %s not found.' % repo_owner
                return api_error(status.HTTP_404_NOT_FOUND, error_msg)
        else:
            repo_owner = username

        try:
            repo_id = seafile_api.create_repo(repo_name, '', repo_owner)
        except Exception as e:
            logger.error(e)
            error_msg = 'Internal Server Error'
            return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)

        repo = seafile_api.get_repo(repo_id)
        repo_info = get_repo_info(repo)
        return Response(repo_info)
Beispiel #4
0
    def test_can_get_be_shared_repo_info(self):

        # create admin repo
        admin_repo_id = seafile_api.create_repo(name='test-repo', desc='',
            username=self.admin_name, passwd=None)
        admin_repo = seafile_api.get_repo(admin_repo_id)

        # share admin repo to current user
        permission = 'r'
        seafile_api.share_repo(admin_repo_id, self.admin_name,
                self.user_name, permission)

        self.login_as(self.user)

        url = reverse('api-v2.1-repo-view', args=[admin_repo_id])
        resp = self.client.get(url)
        self.assertEqual(200, resp.status_code)
        json_resp = json.loads(resp.content)

        assert json_resp['repo_id'] == admin_repo.id
        assert json_resp['repo_name'] == admin_repo.name

        assert json_resp['owner_email'] == self.admin_name
        assert json_resp['owner_name'] == email2nickname(self.admin_name)
        assert json_resp['owner_contact_email'] == email2contact_email(self.admin_name)

        assert json_resp['permission'] == permission
        assert json_resp['status'] == 'normal'

        self.assertFalse(json_resp['encrypted'])
        self.assertIsNotNone(json_resp['file_count'])
        self.assertIsNotNone(json_resp['size'])

        self.remove_repo(admin_repo_id)
    def test_create_in_encrypted_lib_with_invalid_password(self):

        password = randstring(8)
        encrypted_repo_id = seafile_api.create_repo(
                'encrypted_repo_name', '', self.user_name, password)

        dirname = randstring(8)
        seafile_api.post_dir(repo_id=encrypted_repo_id,
                parent_dir='/', dirname=dirname, username=self.user_name)

        self.login_as(self.user)

        url = reverse("api2-dir-sub-repo", args=[encrypted_repo_id])

        # test invalid password argument
        args = "?p=/%s&name=%s&invalid_password=%s" % (dirname, dirname, password)
        resp = self.client.get(url + args)
        self.assertEqual(400, resp.status_code)

        # test wrong password
        args = "?p=/%s&name=%s&password=%s" % (dirname, dirname, 'invalid_password')
        resp = self.client.get(url + args)
        self.assertEqual(400, resp.status_code)
        json_resp = json.loads(resp.content)
        assert json_resp['error_msg'] == 'Wrong password'

        self.remove_repo(encrypted_repo_id)
Beispiel #6
0
def create_keeper_default_library():
    """ create keeper default library
        and put CDC files into it
    """
    # create repo
    repo_id = seafile_api.create_repo(
        KEEPER_DEFAULT_LIBRARY,
        "The library is used for keeper CDC generation",
        SERVER_EMAIL,
        passwd=None)
    if repo_id:
        # add CDC files
        dir_path = os.path.join(SEAFILE_DIR, 'seafile-server-latest', 'seahub',
                                'keeper', 'cdc')
        for fn in (ARCHIVE_METADATA_TARGET,
                   'Cared-Data-Certificate-HowTo.pdf'):
            path = os.path.join(dir_path, fn)
            if os.path.isfile(path):
                seafile_api.post_file(repo_id, path, "/", fn, SERVER_EMAIL)
            else:
                logging.error("File {} does not exist.".format(path))
                return None
        return repo_id
    else:
        return None
Beispiel #7
0
    def add(self, wiki_name, username, permission='private', repo_id=None,
            org_id=-1):
        if not permission:
            permission = 'private'

        from .utils import slugfy_wiki_name
        slug = slugfy_wiki_name(wiki_name)
        if self.filter(slug=slug).count() > 0:
            raise DuplicateWikiNameError

        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,
                                                      passwd=None, org_id=org_id)
            else:
                repo_id = seafile_api.create_repo(wiki_name, '', username,
                                                  passwd=None)

        repo = seafile_api.get_repo(repo_id)
        assert repo is not None

        wiki = self.model(username=username, name=wiki_name, slug=slug,
                          repo_id=repo.id, permission=permission,
                          created_at=now)
        wiki.save(using=self._db)
        return wiki
    def setUp(self):
        # add user to group
        self.login_as(self.user)
        self.group_id = self.group.id
        self.endpoint = reverse('api-v2.1-group-members', args=[self.group_id])
        self.client.post(self.endpoint, {'email': self.user.username})
        self.logout()

        # create group workspace
        group_repo_id = seafile_api.create_repo(_("My Workspace"),
                                                _("My Workspace"),
                                                "dtable@seafile")
        self.group_workspace = Workspaces.objects.create_workspace(
            str(self.group_id) + GROUP_DOMAIN, group_repo_id, -1)
        assert Workspaces.objects.all().count() == 1

        # create group dtable
        seafile_api.post_empty_file(group_repo_id, '/', 'group.dtable',
                                    self.user.username)
        self.group_dtable = DTables.objects.create_dtable(
            self.user.username, self.group_workspace, 'group')
        assert DTables.objects.all().count() == 1

        # share group dtable to admin
        DTableShare.objects.add(self.group_dtable,
                                str(self.group_id) + GROUP_DOMAIN,
                                self.admin.username, 'rw')
        assert DTableShare.objects.all().count() == 1

        self.url = reverse(
            'api-v2.1-dtable-related-users',
            args=[self.group_workspace.id, self.group_dtable.name])
Beispiel #9
0
    def setUp(self):
        self.login_as(self.user)

        self.password = randstring(6)
        self.repo_id = seafile_api.create_repo('test-repo', '',
                                               self.user.username,
                                               self.password)
Beispiel #10
0
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, None)
        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
Beispiel #11
0
    def create_new_repo(self, username):
        new_repo_id = seafile_api.create_repo(name=randstring(10),
                                              desc='',
                                              username=username,
                                              passwd=None)

        return new_repo_id
Beispiel #12
0
def test_file_operation():
    t_repo_version = 1
    t_repo_id1 = api.create_repo('test_file_operation1', '', USER, passwd=None)

    create_the_file()

    assert api.post_file(t_repo_id1, file_path, '/', file_name, USER) == 0
    assert api.post_dir(t_repo_id1, '/', dir_name, USER) == 0

    #test search files
    file_list = api.search_files(t_repo_id1, "test")
    assert len(file_list) == 2
    assert file_list[0].path == "/test.txt"
    assert file_list[0].is_dir == False
    assert file_list[1].path == "/test_dir"
    assert file_list[1].is_dir == True

    file_list = api.search_files(t_repo_id1, "dir")
    assert len(file_list) == 1
    assert file_list[0].path == "/test_dir"
    assert file_list[0].is_dir == True

    file_list = api.search_files(t_repo_id1, "DiR")
    assert len(file_list) == 1
    assert file_list[0].path == "/test_dir"
    assert file_list[0].is_dir == True

    api.remove_repo(t_repo_id1)
Beispiel #13
0
    def create_new_repo(self):
        new_repo_id = seafile_api.create_repo(name='test-repo-2',
                                              desc='',
                                              username=self.user.username,
                                              passwd=None)

        return new_repo_id
Beispiel #14
0
    def add(self, wiki_name, username, permission='private', repo_id=None,
            org_id=-1):
        if not permission:
            permission = 'private'

        from .utils import slugfy_wiki_name
        slug = slugfy_wiki_name(wiki_name)
        if self.filter(slug=slug).count() > 0:
            raise DuplicateWikiNameError

        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,
                                                      passwd=None, org_id=org_id)
            else:
                repo_id = seafile_api.create_repo(wiki_name, '', username,
                                                  passwd=None)

        repo = seafile_api.get_repo(repo_id)
        assert repo is not None

        wiki = self.model(username=username, name=wiki_name, slug=slug,
                          repo_id=repo.id, permission=permission,
                          created_at=now)
        wiki.save(using=self._db)
        return wiki
Beispiel #15
0
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,
                                              passwd=None, org_id=org_id)
    else:
        repo_id = seafile_api.create_repo(repo_name, '', username,
                                          passwd=None)
    return repo_id
Beispiel #16
0
    def setUp(self):

        self.file_size = 1
        self.exceeded_file_size = FILE_PREVIEW_MAX_SIZE + 1

        self.office_file_size = 1
        self.exceeded_office_file_size = OFFICE_PREVIEW_MAX_SIZE + 1

        self.encrypted_repo_id = seafile_api.create_repo(
            'encrypted-repo', '', self.user.username, 'password')
        self.encrypted_repo = seafile_api.get_repo(self.encrypted_repo_id)
Beispiel #17
0
    def test_get_with_invalid_permission(self):

        admin_repo_id = seafile_api.create_repo(name='test-repo', desc='',
            username=self.admin_name, passwd=None)

        self.login_as(self.user)

        url = reverse('api-v2.1-repo-view', args=[admin_repo_id])
        resp = self.client.get(url)
        self.assertEqual(403, resp.status_code)

        self.remove_repo(admin_repo_id)
Beispiel #18
0
def create_tmp_repo(create_tmp_user):
    """Create new random library"""
    REPO_NAME = "TEST_TMP_REPO-" + uuid4().hex
    repo_id = seafile_api.create_repo(REPO_NAME,
                                      "Tmp description",
                                      create_tmp_user,
                                      passwd=None)
    repo = seafile_api.get_repo(repo_id)
    yield repo
    # teardown code
    print("remove repo: " + repo_id)
    if repo and repo.id:
        seafile_api.remove_repo(repo.id)
        # clean up Catalog table, repo_deleted_cb is not called for tests!!!
        CDC.objects.delete_by_repo_id(repo.id)
        Catalog.objects.delete_by_repo_id(repo.id)
Beispiel #19
0
    def post(self, request):
        """ Admin create library

        Permission checking:
        1. only admin can perform this action.
        """
        if not request.user.admin_permissions.can_manage_library():
            return api_error(status.HTTP_403_FORBIDDEN, 'Permission denied.')

        repo_name = request.data.get('name', None)
        if not repo_name:
            error_msg = 'name invalid.'
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

        username = request.user.username
        repo_owner = request.data.get('owner', None)
        if repo_owner:
            try:
                User.objects.get(email=repo_owner)
            except User.DoesNotExist:
                error_msg = 'User %s not found.' % repo_owner
                return api_error(status.HTTP_404_NOT_FOUND, error_msg)
        else:
            repo_owner = username

        try:
            repo_id = seafile_api.create_repo(repo_name, '', repo_owner)
        except Exception as e:
            logger.error(e)
            error_msg = 'Internal Server Error'
            return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)

        # send admin operation log signal
        admin_op_detail = {
            "id": repo_id,
            "name": repo_name,
            "owner": repo_owner,
        }
        admin_operation.send(sender=None,
                             admin_name=request.user.username,
                             operation=REPO_CREATE,
                             detail=admin_op_detail)

        repo = seafile_api.get_repo(repo_id)
        repo_info = get_repo_info(repo)
        return Response(repo_info)
Beispiel #20
0
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 = seafile_api.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)
Beispiel #21
0
def tmp_repo(name=None, desc=None):
    """Create a temporary repo for test before the function exectutes, and delete
    the repo after that.

    Usage:

        with tmp_repo() as repo:
            ... do things with repo ...
    """
    name = name or randstring()
    desc = desc or randstring()
    repo_id = api.create_repo(name, desc, USER, enc_version=None)
    repo = {"id": repo_id, "name": name}
    try:
        yield repo
    finally:
        pass
Beispiel #22
0
def test_encrypted_repo(rpc, enc_version):
    test_repo_name = 'test_enc_repo'
    test_repo_desc = 'test_enc_repo'
    test_repo_passwd = 'test_enc_repo'
    if rpc == 'create_repo':
        repo_id = api.create_repo(test_repo_name, test_repo_desc, USER,
                                  test_repo_passwd, enc_version)
        assert repo_id
    else:
        if enc_version == 2:
            repo_id = 'd17bf8ca-3019-40ee-8fdb-0258c89fb762'
        elif enc_version == 3:
            repo_id = 'd17bf8ca-3019-40ee-8fdb-0258c89fb763'
        else:
            repo_id = 'd17bf8ca-3019-40ee-8fdb-0258c89fb764'
        enc_info = api.generate_magic_and_random_key(enc_version, repo_id,
                                                     test_repo_passwd)
        assert enc_info
        ret_repo_id = api.create_enc_repo(repo_id, test_repo_name,
                                          test_repo_desc, USER, enc_info.magic,
                                          enc_info.random_key, enc_info.salt,
                                          enc_version)
        assert ret_repo_id == repo_id

    repo = api.get_repo(repo_id)
    assert repo
    assert repo.enc_version == enc_version
    assert len(repo.magic) == 64
    assert len(repo.random_key) == 96
    if enc_version == 3 or enc_version == 4:
        assert len(repo.salt) == 64

    new_passwd = 'new password'

    assert api.set_passwd(repo.id, USER, test_repo_passwd) == 0
    assert api.get_decrypt_key(repo.id, USER)
    api.change_repo_passwd(repo.repo_id, test_repo_passwd, new_passwd,
                           USER) == 0
    assert api.set_passwd(repo.id, USER, new_passwd) == 0

    assert api.is_password_set(repo.id, USER)
    assert api.unset_passwd(repo.id, USER) == 0
    assert api.is_password_set(repo.id, USER) == 0

    api.remove_repo(repo_id)
    def test_can_copy_file_folder_with_dst(self, mock_can_view_sys_admin_repo):

        mock_can_view_sys_admin_repo.return_value = True

        dst_repo_id = seafile_api.create_repo(name='test-repo',
                                              desc='',
                                              username=self.user_name,
                                              passwd=None)

        dst_dir_name = randstring(6)
        dst_dir = '/' + dst_dir_name
        seafile_api.post_dir(dst_repo_id, '/', dst_dir_name, self.user_name)

        dst_init_num = self.get_file_folder_num(self.user_name, dst_repo_id,
                                                dst_dir)

        self.login_as(self.admin)

        dst_url = reverse('api-v2.1-admin-library-dirents',
                          args=[dst_repo_id]) + '?parent_dir=%s' % dst_dir

        ## copy file
        data = {'dst_repo_id': dst_repo_id, 'dst_dir': dst_dir}
        resp = self.client.put(self.url + '?path=%s' % (self.file_path),
                               json.dumps(data), 'application/json')

        self.assertEqual(200, resp.status_code)

        # length of dst library's dirent list will be dst_init_num + 1
        resp = self.client.get(dst_url)
        json_resp = json.loads(resp.content)
        assert len(json_resp['dirent_list']) == dst_init_num + 1

        ## copy folder
        resp = self.client.put(self.url + '?path=%s' % (self.folder_path),
                               json.dumps(data), 'application/json')

        self.assertEqual(200, resp.status_code)

        # length of dst library's dirent list will be dst_init_num + 2
        resp = self.client.get(dst_url)
        json_resp = json.loads(resp.content)
        assert len(json_resp['dirent_list']) == dst_init_num + 2

        self.remove_repo(dst_repo_id)
Beispiel #24
0
    def create_default_repo(self, username):

        default_repo_id = seafile_api.create_repo(name=_("My Library"),
                desc=_("My Library"), username=username, passwd=None)

        sys_repo_id = get_system_default_repo_id()
        if not sys_repo_id or not seafile_api.get_repo(sys_repo_id):
            return None

        dirents = seafile_api.list_dir_by_path(sys_repo_id, '/')
        for dirent in dirents:
            obj_name = dirent.obj_name
            seafile_api.copy_file(sys_repo_id, '/', obj_name,
                    default_repo_id, '/', obj_name, username, 0)

        UserOptions.objects.set_default_repo(username, default_repo_id)

        return default_repo_id
Beispiel #25
0
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 = seafile_api.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)
Beispiel #26
0
    def create_default_repo(self, username):

        default_repo_id = seafile_api.create_repo(name=_("My Library"),
                                                  desc=_("My Library"),
                                                  username=username)

        sys_repo_id = get_system_default_repo_id()
        if not sys_repo_id or not seafile_api.get_repo(sys_repo_id):
            return None

        dirents = seafile_api.list_dir_by_path(sys_repo_id, '/')
        for dirent in dirents:
            obj_name = dirent.obj_name
            seafile_api.copy_file(sys_repo_id, '/', obj_name, default_repo_id,
                                  '/', obj_name, username, 0)

        UserOptions.objects.set_default_repo(username, default_repo_id)

        return default_repo_id
Beispiel #27
0
def create_default_library(request):
    """Create a default library for user.

    Arguments:
    - `username`:
    """
    username = request.user.username

    # Disable user guide no matter user permission error or creation error,
    # so that the guide popup only show once.
    UserOptions.objects.disable_user_guide(username)

    if not request.user.permissions.can_add_repo():
        return

    if is_org_context(request):
        org_id = request.user.org.org_id
        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"),
                                               desc=_("My Library"),
                                               username=username,
                                               passwd=None)
    sys_repo_id = get_system_default_repo_id()
    if sys_repo_id is None:
        return

    try:
        dirents = seafile_api.list_dir_by_path(sys_repo_id, '/')
        for e in dirents:
            obj_name = e.obj_name
            seafile_api.copy_file(sys_repo_id, '/', obj_name, default_repo,
                                  '/', obj_name, username, 0)
    except SearpcError as e:
        logger.error(e)
        return

    UserOptions.objects.set_default_repo(username, default_repo)
    return default_repo
Beispiel #28
0
def create_default_library(request):
    """Create a default library for user.

    Arguments:
    - `username`:
    """
    username = request.user.username

    # Disable user guide no matter user permission error or creation error,
    # so that the guide popup only show once.
    UserOptions.objects.disable_user_guide(username)

    if not request.user.permissions.can_add_repo():
        return

    if is_org_context(request):
        org_id = request.user.org.org_id
        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"),
                                               desc=_("My Library"),
                                               username=username,
                                               passwd=None)
    sys_repo_id = get_system_default_repo_id()
    if sys_repo_id is None:
        return

    try:
        dirents = seafile_api.list_dir_by_path(sys_repo_id, '/')
        for e in dirents:
            obj_name = e.obj_name
            seafile_api.copy_file(sys_repo_id, '/', obj_name,
                                  default_repo, '/', obj_name, username, 0)
    except SearpcError as e:
        logger.error(e)
        return

    UserOptions.objects.set_default_repo(username, default_repo)
    return default_repo
    def test_can_create_in_encrypted_lib(self):

        password = randstring(8)
        encrypted_repo_id = seafile_api.create_repo(
                'encrypted_repo_name', '', self.user_name, password)

        dirname = randstring(8)
        seafile_api.post_dir(repo_id=encrypted_repo_id,
                parent_dir='/', dirname=dirname, username=self.user_name)

        self.login_as(self.user)

        url = reverse("api2-dir-sub-repo", args=[encrypted_repo_id])
        args = "?p=/%s&name=%s&password=%s" % (dirname, dirname, password)
        resp = self.client.get(url + args)
        json_resp = json.loads(resp.content)
        assert len(json_resp['sub_repo_id']) == 36

        self.remove_repo(encrypted_repo_id)
Beispiel #30
0
    def post(self, request):
        """ Admin create library

        Permission checking:
        1. only admin can perform this action.
        """

        repo_name = request.data.get('name', None)
        if not repo_name:
            error_msg = 'name invalid.'
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

        username = request.user.username
        repo_owner = request.data.get('owner', None)
        if repo_owner:
            try:
                User.objects.get(email=repo_owner)
            except User.DoesNotExist:
                error_msg = 'User %s not found.' % repo_owner
                return api_error(status.HTTP_404_NOT_FOUND, error_msg)
        else:
            repo_owner = username

        try:
            repo_id = seafile_api.create_repo(repo_name, '', repo_owner, None)
        except Exception as e:
            logger.error(e)
            error_msg = 'Internal Server Error'
            return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)

        # send admin operation log signal
        admin_op_detail = {
            "id": repo_id,
            "name": repo_name,
            "owner": repo_owner,
        }
        admin_operation.send(sender=None, admin_name=request.user.username,
                operation=REPO_CREATE, detail=admin_op_detail)

        repo = seafile_api.get_repo(repo_id)
        repo_info = get_repo_info(repo)
        return Response(repo_info)
Beispiel #31
0
    def test_can_create_in_encrypted_lib(self):

        password = randstring(8)
        encrypted_repo_id = seafile_api.create_repo('encrypted_repo_name', '',
                                                    self.user_name, password)

        dirname = randstring(8)
        seafile_api.post_dir(repo_id=encrypted_repo_id,
                             parent_dir='/',
                             dirname=dirname,
                             username=self.user_name)

        self.login_as(self.user)

        url = reverse("api2-dir-sub-repo", args=[encrypted_repo_id])
        args = "?p=/%s&name=%s&password=%s" % (dirname, dirname, password)
        resp = self.client.get(url + args)
        json_resp = json.loads(resp.content)
        assert len(json_resp['sub_repo_id']) == 36

        self.remove_repo(encrypted_repo_id)
Beispiel #32
0
def personal_wiki_create(request):
    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)

    if not request.user.permissions.can_add_repo():
        return json_error(_('You do not have permission to create wiki'), 403)

    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']
    username = request.user.username
    passwd = None
    permission = "rw"

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

    PersonalWiki.objects.save_personal_wiki(username=username, repo_id=repo_id)

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

    next = reverse('personal_wiki', args=[])
    return HttpResponse(json.dumps({'href': next}), content_type=content_type)
Beispiel #33
0
def personal_wiki_create(request):
    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)

    if not request.user.permissions.can_add_repo():
        return json_error(_('You do not have permission to create wiki'), 403)

    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']
    username = request.user.username
    passwd = None
    permission = "rw"

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

    PersonalWiki.objects.save_personal_wiki(username=username, repo_id=repo_id)

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

    next = reverse('personal_wiki', args=[])
    return HttpResponse(json.dumps({'href': next}), content_type=content_type)
Beispiel #34
0
                                               os.path.join(path, e.obj_name))
        else:
            num_files += 1
    return num_files

#Get library ID from input
origin_repo_id = repo_id

#Get origin_repo object
origin_repo = seafile_api.get_repo(origin_repo_id)
username = seafile_api.get_repo_owner(origin_repo_id)

# print vars(origin_repo)
#Create a new library, set name, desc and owner
new_repo_id = seafile_api.create_repo(name=origin_repo.name,
                                      desc=origin_repo.desc,
                                      username=username, passwd=None)

#Copy stuffs from old library to new library
# dirents = seafile_api.list_dir_by_path(origin_repo_id, '/')
# for e in dirents:
#     print "copying: " + e.obj_name
#     obj_name = e.obj_name
#     seafile_api.copy_file(origin_repo_id, '/', obj_name, new_repo_id, '/',
#                           obj_name, username, 0, 1)

print "*" * 60
print "OK, verifying..."
print "Origin library(%s): %d files. New Library(%s): %d files." % (
    origin_repo_id[:8], count_files_recursive(origin_repo_id),
    new_repo_id[:8], count_files_recursive(new_repo_id))
Beispiel #35
0
    def post(self, request, group_id):
        """ Add a group library.

        Permission checking:
        1. role permission, can_add_repo;
        1. is group member;
        """

        # argument check
        repo_name = request.data.get("repo_name", None)
        if not repo_name or \
                not is_valid_dirent_name(repo_name):
            error_msg = "repo_name invalid."
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

        password = request.data.get("password", None)
        if password and not config.ENABLE_ENCRYPTED_LIBRARY:
            error_msg = 'NOT allow to create encrypted library.'
            return api_error(status.HTTP_403_FORBIDDEN, error_msg)

        permission = request.data.get('permission', PERMISSION_READ)
        if permission not in get_available_repo_perms():
            error_msg = 'permission invalid.'
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

        # permission check
        if not request.user.permissions.can_add_repo():
            error_msg = 'Permission denied.'
            return api_error(status.HTTP_403_FORBIDDEN, error_msg)

        if not is_group_member(group_id, request.user.username):
            error_msg = 'Permission denied.'
            return api_error(status.HTTP_403_FORBIDDEN, error_msg)

        # create group repo
        org_id = -1
        group_id = int(group_id)
        username = request.user.username

        is_org = False
        if is_org_context(request):
            is_org = True
            org_id = request.user.org.org_id
            repo_id = seafile_api.create_org_repo(repo_name, '', username,
                                                  password, org_id)
        else:
            repo_id = seafile_api.create_repo(repo_name, '', username,
                                              password)

        repo = seafile_api.get_repo(repo_id)
        share_dir_to_group(repo, '/', username, username, group_id, permission,
                           org_id if is_org else None)

        # for activities
        library_template = request.data.get("library_template", '')
        repo_created.send(sender=None,
                          org_id=org_id,
                          creator=username,
                          repo_id=repo_id,
                          repo_name=repo_name,
                          library_template=library_template)

        # for notification
        share_repo_to_group_successful.send(sender=None,
                                            from_user=username,
                                            group_id=group_id,
                                            repo=repo,
                                            path='/',
                                            org_id=org_id)

        # for perm audit
        send_perm_audit_msg('add-repo-perm', username, group_id, repo_id, '/',
                            permission)

        group_repo = seafile_api.get_group_shared_repo_by_path(
            repo_id, None, group_id, is_org)
        group_repo_info = get_group_repo_info(request, group_repo)

        group_repo_info['owner_email'] = username
        group_repo_info['owner_name'] = email2nickname(username)
        group_repo_info['owner_contact_email'] = email2contact_email(username)

        modifier = group_repo.last_modifier
        group_repo_info['modifier_email'] = modifier
        group_repo_info['modifier_name'] = email2nickname(modifier)
        group_repo_info['modifier_contact_email'] = email2contact_email(
            modifier)

        return Response(group_repo_info)
Beispiel #36
0
        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, 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):
    def setUp(self):
        self.login_as(self.user)

        self.password = randstring(6)
        self.repo_id = seafile_api.create_repo('test-repo',
            '', self.user.username, self.password)
Beispiel #38
0
def create_and_get_repo(*a, **kw):
    repo_id = seafile_api.create_repo(*a, **kw)
    repo = seafile_api.get_repo(repo_id)
    return repo
Beispiel #39
0
 def create_repo(self, **kwargs):
     repo_id = seafile_api.create_repo('test-repo', '',
                                       '*****@*****.**', None)
     return repo_id
Beispiel #40
0
def test_zip_download():
    create_test_files()
    t_repo_id = api.create_repo('test_zip_download', '', USER)
    base_url = 'http://127.0.0.1:8082/'

    #test zip download dir
    dir_name = 'dir'
    api.post_dir(t_repo_id, '/', dir_name, USER)
    api.post_file(t_repo_id, file1_path, '/dir', file1_name, USER)
    api.post_file(t_repo_id, file2_path, '/dir', file2_name, USER)

    dir_id = api.get_dir_id_by_path(t_repo_id, '/dir')
    obj_id = {'obj_id': dir_id, 'dir_name': dir_name, 'is_windows': 0}
    obj_id_json_str = json.dumps(obj_id)
    token = api.get_fileserver_access_token(t_repo_id, obj_id_json_str,
                                            'download-dir', USER)

    time.sleep(1)
    download_url = base_url + 'zip/' + token
    response = requests.get(download_url)
    assert response.status_code == 200

    download_zipfile_path = download_dir_path + '/dir.zip'
    with open(download_zipfile_path, 'wb') as fp:
        fp.write(response.content)
    zipFile = zipfile.ZipFile(download_zipfile_path)
    for name in zipFile.namelist():
        zipFile.extract(name, download_dir_path)
    zipFile.close()
    assert os.path.exists(download_dir_path + '/dir.zip')
    assert os.path.exists(download_dir_path + '/dir')
    assert os.path.exists(download_dir_path + '/dir' + '/file1.txt')
    assert os.path.exists(download_dir_path + '/dir' + '/file2.txt')
    with open(download_dir_path + '/dir' + '/file1.txt', 'r') as fp1:
        line = fp1.read()
    assert line == file1_content
    with open(download_dir_path + '/dir' + '/file2.txt', 'r') as fp2:
        line = fp2.read()
    assert line == file2_content

    os.remove(download_dir_path + '/dir' + '/file1.txt')
    os.remove(download_dir_path + '/dir' + '/file2.txt')
    os.rmdir(download_dir_path + '/dir')
    os.remove(download_dir_path + '/dir.zip')

    #test zip download empty dir
    empty_dir_name = 'empty_dir'
    api.post_dir(t_repo_id, '/', empty_dir_name, USER)

    dir_id = api.get_dir_id_by_path(t_repo_id, '/empty_dir')
    obj_id = {'obj_id': dir_id, 'dir_name': empty_dir_name, 'is_windows': 0}
    obj_id_json_str = json.dumps(obj_id)
    token = api.get_fileserver_access_token(t_repo_id, obj_id_json_str,
                                            'download-dir', USER)
    time.sleep(1)
    download_url = base_url + 'zip/' + token
    response = requests.get(download_url)
    assert response.status_code == 200

    download_zipfile_path = download_dir_path + '/empty_dir.zip'
    with open(download_zipfile_path, 'wb') as fp:
        fp.write(response.content)
    zipFile = zipfile.ZipFile(download_zipfile_path)
    for name in zipFile.namelist():
        zipFile.extract(name, download_dir_path)
    zipFile.close()
    assert os.path.exists(download_dir_path + '/empty_dir')
    assert not os.listdir(download_dir_path + '/empty_dir')

    os.rmdir(download_dir_path + '/empty_dir')
    os.remove(download_dir_path + '/empty_dir.zip')

    #test zip download mutliple files
    api.post_file(t_repo_id, file1_path, '/', file1_name, USER)
    api.post_file(t_repo_id, file2_path, '/', file2_name, USER)
    obj_id = {
        'parent_dir': '/',
        'file_list': [file1_name, file2_name],
        'is_windows': 0
    }
    obj_id_json_str = json.dumps(obj_id)
    token = api.get_fileserver_access_token(t_repo_id, obj_id_json_str,
                                            'download-multi', USER)

    time.sleep(1)
    download_url = base_url + 'zip/' + token
    response = requests.get(download_url)
    assert response.status_code == 200

    download_zipfile_path = download_dir_path + '/multi_files.zip'
    with open(download_zipfile_path, 'wb') as fp:
        fp.write(response.content)
    zipFile = zipfile.ZipFile(download_zipfile_path)
    for name in zipFile.namelist():
        zipFile.extract(name, download_dir_path)
    zipFile.close()
    assert os.path.exists(download_dir_path + '/file1.txt')
    assert os.path.exists(download_dir_path + '/file2.txt')
    with open(download_dir_path + '/file1.txt', 'r') as fp1:
        line = fp1.read()
    assert line == file1_content
    with open(download_dir_path + '/file2.txt', 'r') as fp2:
        line = fp2.read()
    assert line == file2_content
    os.remove(download_dir_path + '/file1.txt')
    os.remove(download_dir_path + '/file2.txt')
    os.remove(download_dir_path + '/multi_files.zip')

    remove_test_files()
    api.remove_repo(t_repo_id)
Beispiel #41
0
            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, 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)


########## wiki
Beispiel #42
0
 def create_repo(self, **kwargs):
     repo_id = seafile_api.create_repo(**kwargs)
     return repo_id
Beispiel #43
0
 def create_repo(self, **kwargs):
     repo_id = seafile_api.create_repo(**kwargs)
     return repo_id
Beispiel #44
0
    def post(self, request, group_id):
        """ Add a group library.

        Permission checking:
        1. role permission, can_add_repo;
        1. is group member;
        """

        # argument check
        repo_name = request.data.get("repo_name", None)
        if not repo_name or \
                not is_valid_dirent_name(repo_name):
            error_msg = "repo_name invalid."
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

        password = request.data.get("password", None)
        if password and not config.ENABLE_ENCRYPTED_LIBRARY:
            error_msg = 'NOT allow to create encrypted library.'
            return api_error(status.HTTP_403_FORBIDDEN, error_msg)

        permission = request.data.get('permission', PERMISSION_READ)
        if permission not in get_available_repo_perms():
            error_msg = 'permission invalid.'
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

        # permission check
        if not request.user.permissions.can_add_repo():
            error_msg = 'Permission denied.'
            return api_error(status.HTTP_403_FORBIDDEN, error_msg)

        if not is_group_member(group_id, request.user.username):
            error_msg = 'Permission denied.'
            return api_error(status.HTTP_403_FORBIDDEN, error_msg)

        # create group repo
        org_id = -1
        group_id = int(group_id)
        username = request.user.username

        is_org = False
        if is_org_context(request):
            is_org = True
            org_id = request.user.org.org_id
            repo_id = seafile_api.create_org_repo(repo_name,
                    '', username, password, org_id)
        else:
            repo_id = seafile_api.create_repo(repo_name,
                    '', username, password)

        repo = seafile_api.get_repo(repo_id)
        share_dir_to_group(repo, '/', username, username, group_id,
                permission, org_id if is_org else None)

        # for activities
        library_template = request.data.get("library_template", '')
        repo_created.send(sender=None, org_id=org_id, creator=username,
                repo_id=repo_id, repo_name=repo_name,
                library_template=library_template)

        # for notification
        share_repo_to_group_successful.send(sender=None, from_user=username,
                group_id=group_id, repo=repo, path='/', org_id=org_id)

        # for perm audit
        send_perm_audit_msg('add-repo-perm', username, group_id,
                repo_id, '/', permission)

        group_repo = seafile_api.get_group_shared_repo_by_path(repo_id,
                None, group_id, is_org)
        group_repo_info = get_group_repo_info(request, group_repo)

        group_repo_info['owner_email'] = username
        group_repo_info['owner_name'] = email2nickname(username)
        group_repo_info['owner_contact_email'] = email2contact_email(username)

        modifier = group_repo.last_modifier
        group_repo_info['modifier_email'] = modifier
        group_repo_info['modifier_name'] = email2nickname(modifier)
        group_repo_info['modifier_contact_email'] = email2contact_email(modifier)

        return Response(group_repo_info)
Beispiel #45
0
 def create_repo(self, **kwargs):
     repo_id = seafile_api.create_repo("test-repo", "", self.user.username, None)
     return repo_id
Beispiel #46
0
def create_repo_and_workspace(owner, org_id):
    repo_id = seafile_api.create_repo("My Workspace", "My Workspace",
                                      "dtable@seafile")

    workspace = Workspaces.objects.create_workspace(owner, repo_id, org_id)
    return workspace
Beispiel #47
0
    def create_new_repo(self):
        new_repo_id = seafile_api.create_repo(name='test-repo-2', desc='',
            username=self.user.username, passwd=None)

        return new_repo_id