Example #1
0
    def create_exist_file_draft(self, repo, username, file_uuid, file_path):
        # create drafts dir if any
        draft_dir_id = seafile_api.get_dir_id_by_path(repo.id, '/Drafts')
        if draft_dir_id is None:
            seafile_api.post_dir(repo.id, '/', 'Drafts', username)

        # check draft file does not exists and copy origin file content to
        # draft file
        draft_file_name = get_draft_file_name(repo.id, file_path)
        draft_file_path = '/Drafts/' + draft_file_name

        if seafile_api.get_file_id_by_path(repo.id, draft_file_path):
            raise DraftFileExist

        # copy file to draft dir
        seafile_api.copy_file(repo.id,
                              file_uuid.parent_path,
                              file_uuid.filename,
                              repo.id,
                              '/Drafts',
                              draft_file_name,
                              username=username,
                              need_progress=0,
                              synchronous=1)

        return draft_file_path
def test_subdir_permission_in_virtual_repo(repo, group, permission):
    api.post_dir(repo.id, '/dir1', 'subdir1', USER)
    api.post_dir(repo.id, '/dir2', 'subdir2', USER)

    v_repo_id_1 = api.share_subdir_to_user(repo.id, '/dir1', USER, USER2,
                                           permission)
    v_subdir_repo_id_1 = api.create_virtual_repo(v_repo_id_1,
                                                 '/subdir1',
                                                 'subdir1',
                                                 'test_desc',
                                                 USER,
                                                 passwd='')
    assert api.check_permission(v_subdir_repo_id_1, USER2) == permission

    assert ccnet_api.group_add_member(group.id, USER, USER2) == 0
    v_repo_id_2 = api.share_subdir_to_group(repo.id, '/dir2', USER, group.id,
                                            permission)
    v_subdir_repo_id_2 = api.create_virtual_repo(v_repo_id_2,
                                                 '/subdir2',
                                                 'subdir2',
                                                 'test_desc',
                                                 USER,
                                                 passwd='')
    assert api.check_permission(v_subdir_repo_id_2, USER2) == permission

    assert api.unshare_subdir_for_user(repo.id, '/dir1', USER, USER2) == 0
    assert api.unshare_subdir_for_group(repo.id, '/dir2', USER, group.id) == 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)
Example #4
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)
Example #5
0
    def test_get_dirents(self):

        username = self.user.username
        dir_name = randstring(6)
        file_name = randstring(6)

        seafile_api.post_dir(self.repo_id,
                self.folder_path, dir_name, username)

        seafile_api.post_empty_file(self.repo_id,
                self.folder_path, file_name, username)

        self.login_as(self.admin)
        token = self._add_dir_share_link()
        url = reverse('api-v2.1-admin-share-link-dirents', args=[token])
        resp = self.client.get(url)
        self.assertEqual(200, resp.status_code)

        json_resp = json.loads(resp.content)

        assert json_resp[0]['is_dir'] == True
        assert dir_name in json_resp[0]['obj_name']
        assert json_resp[1]['is_dir'] == False
        assert file_name in json_resp[1]['obj_name']

        self._remove_share_link(token)
Example #6
0
def repo():
    repo = create_and_get_repo(
        'test_repo_{}'.format(randstring(10)), '', USER, passwd=None
    )
    try:
        seafile_api.post_dir(repo.id, '/', 'dir1', USER)
        seafile_api.post_dir(repo.id, '/', 'dir2', USER)
        yield repo
    finally:
        if seafile_api.get_repo(repo.id):
            # The repo may be deleted in the test case
            seafile_api.remove_repo(repo.id)
Example #7
0
    def test_can_get_dir_detail(self):

        seafile_api.post_dir(self.repo_id, self.folder_path, randstring(3),
                             self.user_name)
        seafile_api.post_empty_file(self.repo_id, self.folder_path,
                                    randstring(3), self.user_name)

        self.login_as(self.user)
        resp = self.client.get(self.url + '?path=%s' % self.folder_path)
        self.assertEqual(200, resp.status_code)
        json_resp = json.loads(resp.content)

        assert json_resp['name'] == self.folder_name
Example #8
0
def new_dir(repo_id, parent_dir, dirent_name, username):
    """
    Create a new dir with ajax.    
    """
    result = {}
    content_type = 'application/json; charset=utf-8'

    # create new dirent
    try:
        seafile_api.post_dir(repo_id, parent_dir, dirent_name, username)
    except SearpcError, e:
        result['error'] = str(e)
        return HttpResponse(json.dumps(result), status=500,
                            content_type=content_type)
Example #9
0
    def post(self, request, org_id, format=None):
        """Create a file draft if the user has read-write permission to the origin file
        """

        # argument check
        repo_id = request.data.get('repo_id', '')
        if not repo_id:
            error_msg = 'repo_id invalid.'
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

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

        # resource check
        repo = seafile_api.get_repo(repo_id)
        if not repo:
            error_msg = 'Library %s not found.' % repo_id
            return api_error(status.HTTP_404_NOT_FOUND, error_msg)

        file_id = seafile_api.get_file_id_by_path(repo_id, file_path)
        if not file_id:
            error_msg = 'File %s not found.' % file_path
            return api_error(status.HTTP_404_NOT_FOUND, error_msg)

        # permission check
        perm = check_folder_permission(request, repo_id, file_path)
        if perm != PERMISSION_READ_WRITE:
            error_msg = 'Permission denied.'
            return api_error(status.HTTP_403_FORBIDDEN, error_msg)

        username = request.user.username

        # create drafts dir if does not exist
        draft_dir_id = seafile_api.get_dir_id_by_path(repo_id, '/Drafts')
        if draft_dir_id is None:
            seafile_api.post_dir(repo_id, '/', 'Drafts', username)

        # create draft
        try:
            d = Draft.objects.add(username, repo, file_path, file_id=file_id)
            return Response(d.to_dict())
        except DraftFileExist:
            return api_error(status.HTTP_409_CONFLICT, 'Draft already exists.')
        except Exception as e:
            logger.error(e)
            error_msg = 'Internal Server Error'
            return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
Example #10
0
def new_dir(repo_id, parent_dir, dirent_name, username):
    """
    Create a new dir with ajax.    
    """
    result = {}
    content_type = 'application/json; charset=utf-8'

    # create new dirent
    try:
        seafile_api.post_dir(repo_id, parent_dir, dirent_name, username)
    except SearpcError, e:
        result['error'] = str(e)
        return HttpResponse(json.dumps(result),
                            status=500,
                            content_type=content_type)
Example #11
0
    def test_can_get_with_recursive_and_file_type_parameter(self):

        # create a sub folder
        new_dir_name = randstring(6)
        seafile_api.post_dir(self.repo_id, self.folder_path, new_dir_name,
                             self.user_name)

        self.login_as(self.user)
        resp = self.client.get(self.url + '?recursive=1&t=f')
        self.assertEqual(200, resp.status_code)
        json_resp = json.loads(resp.content)

        assert len(json_resp['dirent_list']) == 1
        assert json_resp['dirent_list'][0]['type'] == 'file'
        assert json_resp['dirent_list'][0]['name'] == self.file_name
Example #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)
Example #13
0
    def create_collection(self, name):
        """Create a new collection as member of self.

        See DAVResource.createCollection()
        """
        assert not "/" in name
        if self.provider.readonly:
            raise DAVError(HTTP_FORBIDDEN)

        if seafile_api.check_permission_by_path(self.repo.id, self.rel_path, self.username) != "rw":
            raise DAVError(HTTP_FORBIDDEN)

        if not seafile_api.is_valid_filename(self.repo.id, name):
            raise DAVError(HTTP_BAD_REQUEST)

        seafile_api.post_dir(self.repo.id, self.rel_path, name, self.username)
    def createCollection(self, name):
        """Create a new collection as member of self.

        See DAVResource.createCollection()
        """
        assert not "/" in name
        if self.provider.readonly:
            raise DAVError(HTTP_FORBIDDEN)

        if seafile_api.check_permission_by_path(self.repo.id, self.rel_path, self.username) != "rw":
            raise DAVError(HTTP_FORBIDDEN)

        if not seafile_api.is_valid_filename(self.repo.id, name):
            raise DAVError(HTTP_BAD_REQUEST)

        seafile_api.post_dir(self.repo.id, self.rel_path, name, self.username)
Example #15
0
    def post(self, request, repo_id, format=None):
        """ create file/folder in a library
        """

        repo = seafile_api.get_repo(repo_id)
        if not repo:
            error_msg = 'Library %s not found.' % repo_id
            return api_error(status.HTTP_404_NOT_FOUND, error_msg)

        if not can_view_sys_admin_repo(repo):
            error_msg = 'Feature disabled.'
            return api_error(status.HTTP_403_FORBIDDEN, error_msg)

        parent_dir = request.GET.get('parent_dir', '/')
        if not parent_dir:
            error_msg = 'parent_dir invalid.'
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

        if parent_dir[-1] != '/':
            parent_dir = parent_dir + '/'

        dir_id = seafile_api.get_dir_id_by_path(repo_id, parent_dir)
        if not dir_id:
            error_msg = 'Folder %s not found.' % parent_dir
            return api_error(status.HTTP_404_NOT_FOUND, error_msg)

        obj_name = request.data.get('obj_name', None)
        if not obj_name or not seafile_api.is_valid_filename(
                repo_id, obj_name):
            error_msg = 'obj_name invalid.'
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

        obj_name = check_filename_with_rename(repo_id, parent_dir, obj_name)

        username = request.user.username
        try:
            seafile_api.post_dir(repo_id, parent_dir, obj_name, username)
        except SearpcError as e:
            logger.error(e)
            error_msg = 'Internal Server Error'
            return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)

        dirent_path = posixpath.join(parent_dir, obj_name)
        dirent = seafile_api.get_dirent_by_path(repo_id, dirent_path)
        dirent_info = get_dirent_info(dirent)

        return Response(dirent_info)
Example #16
0
    def create_exist_file_draft(self, repo, username, file_uuid, file_path):
        # create drafts dir if does not exist
        draft_dir_id = seafile_api.get_dir_id_by_path(repo.id, '/Drafts')
        if draft_dir_id is None:
            seafile_api.post_dir(repo.id, '/', 'Drafts', username)

        # check draft file does not exists and copy origin file content to
        # draft file
        draft_file_name = get_draft_file_name(repo.id, file_path)
        draft_file_path = '/Drafts/' + draft_file_name

        try:
            # Determine if there is a draft of the file
            d = self.get(origin_file_uuid=file_uuid.uuid)
        except Draft.DoesNotExist:
            try:
                # Determine if there is a draft with the same name as
                # the generated draft file path
                d_2 = self.get(origin_repo_id=repo.id, draft_file_path=draft_file_path)
                d_2.delete(operator=username)
            except Draft.DoesNotExist:
                pass

            # copy file to draft dir
            seafile_api.copy_file(repo.id, file_uuid.parent_path, file_uuid.filename,
                                  repo.id, '/Drafts', draft_file_name,
                                  username=username, need_progress=0, synchronous=1)

            return draft_file_path

        if d:
            file_id = seafile_api.get_file_id_by_path(repo.id, d.draft_file_path)
            # If the database entry exists and the draft file exists,
            # then raise DraftFileExist
            if file_id:
                raise DraftFileExist
            # If the database entry exists and the draft file does not exist,
            # delete the database entry
            else:
                d.delete(operator=username)

                # copy file to draft dir
                seafile_api.copy_file(repo.id, file_uuid.parent_path, file_uuid.filename,
                                      repo.id, '/Drafts', draft_file_name,
                                      username=username, need_progress=0, synchronous=1)

                return draft_file_path
Example #17
0
    def post(self, request, repo_id, format=None):
        """ create file/folder in a library
        """

        repo = seafile_api.get_repo(repo_id)
        if not repo:
            error_msg = 'Library %s not found.' % repo_id
            return api_error(status.HTTP_404_NOT_FOUND, error_msg)

        if not can_view_sys_admin_repo(repo):
            error_msg = 'Feature disabled.'
            return api_error(status.HTTP_403_FORBIDDEN, error_msg)

        parent_dir = request.GET.get('parent_dir', '/')
        if not parent_dir:
            error_msg = 'parent_dir invalid.'
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

        if parent_dir[-1] != '/':
            parent_dir = parent_dir + '/'

        dir_id = seafile_api.get_dir_id_by_path(repo_id, parent_dir)
        if not dir_id:
            error_msg = 'Folder %s not found.' % parent_dir
            return api_error(status.HTTP_404_NOT_FOUND, error_msg)

        obj_name = request.data.get('obj_name', None)
        if not obj_name or not seafile_api.is_valid_filename(repo_id, obj_name):
            error_msg = 'obj_name invalid.'
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

        obj_name = check_filename_with_rename(repo_id, parent_dir, obj_name)

        username = request.user.username
        try:
            seafile_api.post_dir(repo_id, parent_dir, obj_name, username)
        except SearpcError as e:
            logger.error(e)
            error_msg = 'Internal Server Error'
            return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)

        dirent_path = posixpath.join(parent_dir, obj_name)
        dirent = seafile_api.get_dirent_by_path(repo_id, dirent_path)
        dirent_info = get_dirent_info(dirent)

        return Response(dirent_info)
    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)
Example #19
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)
Example #20
0
    def post(self, request, repo_id, format=None):
        """ create file/folder in a library
        """

        if not request.user.admin_permissions.can_manage_library():
            return api_error(status.HTTP_403_FORBIDDEN, 'Permission denied.')

        parent_dir = request.GET.get('parent_dir', '/')
        parent_dir = normalize_dir_path(parent_dir)
        dir_id = seafile_api.get_dir_id_by_path(repo_id, parent_dir)
        if not dir_id:
            error_msg = 'Folder %s not found.' % parent_dir
            return api_error(status.HTTP_404_NOT_FOUND, error_msg)

        obj_name = request.data.get('obj_name', None)
        if not obj_name or not is_valid_dirent_name(obj_name):
            error_msg = 'obj_name invalid.'
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

        is_file = request.data.get('is_file', 'false')
        is_file = is_file.lower()
        if is_file not in ('true', 'false'):
            error_msg = 'is_file invalid.'

        username = request.user.username
        obj_name = check_filename_with_rename(repo_id, parent_dir, obj_name)
        try:
            if is_file == 'true':
                seafile_api.post_empty_file(repo_id, parent_dir, obj_name,
                                            username)
            else:
                seafile_api.post_dir(repo_id, parent_dir, obj_name, username)
        except SearpcError as e:
            logger.error(e)
            error_msg = 'Internal Server Error'
            return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)

        dirent_path = posixpath.join(parent_dir, obj_name)
        dirent = seafile_api.get_dirent_by_path(repo_id, dirent_path)
        dirent_info = get_dirent_info(dirent)

        return Response(dirent_info)
Example #21
0
    def test_download_sub_dir_in_shared_dir(self):

        username = self.user.username
        dir_name = randstring(6)
        seafile_api.post_dir(self.repo_id,
                self.folder_path, dir_name, username)

        self.login_as(self.admin)
        token = self._add_dir_share_link()

        url = reverse('api-v2.1-admin-share-link-download', args=[token])
        resp = self.client.get(url + '?path=/%s&type=folder' % dir_name)
        self.assertEqual(200, resp.status_code)

        json_resp = json.loads(resp.content)

        assert '8082' in json_resp['download_link']
        assert 'zip' in json_resp['download_link']

        self._remove_share_link(token)
Example #22
0
    def test_can_get_download_multi_zip_token(self):

        # create another folder for download multi
        another_folder_name = 'another_folder_name'
        seafile_api.post_dir(repo_id=self.repo.id,
                parent_dir='/', dirname=another_folder_name,
                username=self.user.username)

        self.login_as(self.user)

        parent_dir = '/'
        folder_name = self.folder_name
        url = self.url + '?parent_dir=%s&dirents=%s&dirents=%s' % (parent_dir,
                folder_name, another_folder_name)

        resp = self.client.get(url)
        self.assertEqual(200, resp.status_code)

        json_resp = json.loads(resp.content)
        assert len(json_resp['zip_token']) == 36
Example #23
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)
Example #24
0
    def test_can_get_download_multi_zip_token(self):

        # create another folder for download multi
        another_folder_name = 'another_folder_name'
        seafile_api.post_dir(repo_id=self.repo.id,
                             parent_dir='/',
                             dirname=another_folder_name,
                             username=self.user.username)

        self.login_as(self.user)

        parent_dir = '/'
        folder_name = self.folder_name
        url = self.url + '?parent_dir=%s&dirents=%s&dirents=%s' % (
            parent_dir, folder_name, another_folder_name)

        resp = self.client.get(url)
        self.assertEqual(200, resp.status_code)

        json_resp = json.loads(resp.content)
        assert len(json_resp['zip_token']) == 36
Example #25
0
    def post(self, request, repo_id, format=None):
        """ create file/folder in a library
        """

        parent_dir = request.GET.get('parent_dir', '/')
        parent_dir = normalize_dir_path(parent_dir)
        dir_id = seafile_api.get_dir_id_by_path(repo_id, parent_dir)
        if not dir_id:
            error_msg = 'Folder %s not found.' % parent_dir
            return api_error(status.HTTP_404_NOT_FOUND, error_msg)

        obj_name = request.data.get('obj_name', None)
        if not obj_name or not is_valid_dirent_name(obj_name):
            error_msg = 'obj_name invalid.'
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

        is_file = request.data.get('is_file', 'false')
        is_file = is_file.lower()
        if is_file not in ('true', 'false'):
            error_msg = 'is_file invalid.'

        username = request.user.username
        obj_name = check_filename_with_rename(repo_id, parent_dir, obj_name)
        try:
            if is_file == 'true':
                seafile_api.post_empty_file(repo_id, parent_dir, obj_name, username)
            else:
                seafile_api.post_dir(repo_id, parent_dir, obj_name, username)
        except SearpcError as e:
            logger.error(e)
            error_msg = 'Internal Server Error'
            return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)

        dirent_path = posixpath.join(parent_dir, obj_name)
        dirent = seafile_api.get_dirent_by_path(repo_id, dirent_path)
        dirent_info = get_dirent_info(dirent)

        return Response(dirent_info)
Example #26
0
File: dir.py Project: dolevu/seahub
    def post(self, request, repo_id, format=None):
        """ Create, rename, revert dir.

        Permission checking:
        1. create: user with 'rw' permission for current dir's parent dir;
        2. rename: user with 'rw' permission for current dir;
        3. revert: user with 'rw' permission for current dir's parent dir;
        """

        # argument check
        path = request.GET.get('p', None)
        if not path or path[0] != '/':
            error_msg = 'p invalid.'
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

        if path == '/':
            error_msg = 'Can not operate root dir.'
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

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

        operation = operation.lower()
        if operation not in ('mkdir', 'rename', 'revert'):
            error_msg = "operation can only be 'mkdir', 'rename' or 'revert'."
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

        # resource check
        repo = seafile_api.get_repo(repo_id)
        if not repo:
            error_msg = 'Library %s not found.' % repo_id
            return api_error(status.HTTP_404_NOT_FOUND, error_msg)

        path = path.rstrip('/')
        username = request.user.username
        parent_dir = os.path.dirname(path)
        if operation == 'mkdir':
            # permission check
            if check_folder_permission(request, repo_id, parent_dir) != 'rw':
                error_msg = 'Permission denied.'
                return api_error(status.HTTP_403_FORBIDDEN, error_msg)

            # resource check
            parent_dir_id = seafile_api.get_dir_id_by_path(repo_id, parent_dir)
            if not parent_dir_id:
                error_msg = 'Folder %s not found.' % parent_dir
                return api_error(status.HTTP_404_NOT_FOUND, error_msg)

            new_dir_name = os.path.basename(path)

            if not is_valid_dirent_name(new_dir_name):
                return api_error(status.HTTP_400_BAD_REQUEST, 'name invalid.')

            new_dir_name = check_filename_with_rename(repo_id, parent_dir,
                                                      new_dir_name)
            try:
                seafile_api.post_dir(repo_id, parent_dir, new_dir_name,
                                     username)
            except SearpcError as e:
                logger.error(e)
                error_msg = 'Internal Server Error'
                return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR,
                                 error_msg)

            new_dir_path = posixpath.join(parent_dir, new_dir_name)
            dir_info = self.get_dir_info(repo_id, new_dir_path)
            resp = Response(dir_info)

            return resp

        if operation == 'rename':
            # resource check
            dir_id = seafile_api.get_dir_id_by_path(repo_id, path)
            if not dir_id:
                error_msg = 'Folder %s not found.' % path
                return api_error(status.HTTP_404_NOT_FOUND, error_msg)

            # permission check
            if check_folder_permission(request, repo_id, path) != 'rw':
                error_msg = 'Permission denied.'
                return api_error(status.HTTP_403_FORBIDDEN, error_msg)

            old_dir_name = os.path.basename(path)
            new_dir_name = request.data.get('newname', None)

            if not new_dir_name:
                error_msg = 'newname invalid.'
                return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

            if not is_valid_dirent_name(new_dir_name):
                return api_error(status.HTTP_400_BAD_REQUEST, 'name invalid.')

            if new_dir_name == old_dir_name:
                dir_info = self.get_dir_info(repo_id, path)
                resp = Response(dir_info)
                return resp

            try:
                # rename duplicate name
                new_dir_name = check_filename_with_rename(
                    repo_id, parent_dir, new_dir_name)
                # rename dir
                seafile_api.rename_file(repo_id, parent_dir, old_dir_name,
                                        new_dir_name, username)

                new_dir_path = posixpath.join(parent_dir, new_dir_name)
                dir_info = self.get_dir_info(repo_id, new_dir_path)
                resp = Response(dir_info)
                return resp
            except SearpcError, e:
                logger.error(e)
                error_msg = 'Internal Server Error'
                return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR,
                                 error_msg)
def test_file_operation():
    t_repo_version = 1
    t_repo_id1 = api.create_repo('test_file_operation1', '', USER, passwd=None)

    create_the_file()

    # test post_file
    assert api.post_file(t_repo_id1, file_path, '/', file_name, USER) == 0
    t_file_id = api.get_file_id_by_path(t_repo_id1, '/' + file_name)
    t_file_size = len(file_content)
    assert t_file_size == api.get_file_size(t_repo_id1, t_repo_version,
                                            t_file_id)

    # test post_dir
    assert api.post_dir(t_repo_id1, '/', dir_name, USER) == 0

    # test copy_file (synchronize)
    t_copy_file_result1 = api.copy_file(t_repo_id1, '/', file_name, t_repo_id1,
                                        '/', new_file_name, USER, 0, 1)
    assert t_copy_file_result1
    assert t_copy_file_result1.task_id is None
    assert not t_copy_file_result1.background
    t_file_id = api.get_file_id_by_path(t_repo_id1, '/' + new_file_name)
    assert t_file_size == api.get_file_size(t_repo_id1, t_repo_version,
                                            t_file_id)

    # test copy_file (asynchronous)
    t_repo_id2 = api.create_repo('test_file_operation2', '', USER, passwd=None)
    usage = api.get_user_self_usage(USER)
    api.set_user_quota(USER, usage + 1)
    t_copy_file_result2 = api.copy_file(t_repo_id1, '/', file_name, t_repo_id2,
                                        '/', file_name, USER, 1, 0)
    assert t_copy_file_result2
    assert t_copy_file_result2.background
    while True:
        time.sleep(0.1)
        t_copy_task = api.get_copy_task(t_copy_file_result2.task_id)
        assert t_copy_task.failed
        assert t_copy_task.failed_reason == 'Quota is full'
        if t_copy_task.failed:
            break

    api.set_user_quota(USER, -1)
    t_copy_file_result2 = api.copy_file(t_repo_id1, '/', file_name, t_repo_id2,
                                        '/', file_name, USER, 1, 0)
    assert t_copy_file_result2
    assert t_copy_file_result2.task_id
    assert t_copy_file_result2.background
    while True:
        time.sleep(0.1)
        t_copy_task = api.get_copy_task(t_copy_file_result2.task_id)
        if t_copy_task.successful:
            break
    t_file_id = api.get_file_id_by_path(t_repo_id2, '/' + file_name)
    assert t_file_size == api.get_file_size(t_repo_id2, t_repo_version,
                                            t_file_id)

    # test move_file (synchronize)
    t_move_file_info1 = api.get_dirent_by_path(t_repo_id1, '/' + new_file_name)
    t_move_file_result1 = api.move_file(t_repo_id1, '/', new_file_name,
                                        t_repo_id1, '/' + dir_name,
                                        new_file_name, 1, USER, 0, 1)
    assert t_move_file_result1
    t_move_file_info2 = api.get_dirent_by_path(
        t_repo_id1, '/' + dir_name + '/' + new_file_name)
    assert t_move_file_info1.mtime == t_move_file_info2.mtime
    t_file_id = api.get_file_id_by_path(t_repo_id1, '/' + new_file_name)
    assert t_file_id is None

    # test move_file (synchronize)
    t_move_file_result1 = api.move_file(t_repo_id1, '/' + dir_name,
                                        new_file_name, t_repo_id1, '/',
                                        new_file_name_2, 1, USER, 0, 1)
    assert t_move_file_result1
    t_file_id = api.get_file_id_by_path(t_repo_id1,
                                        '/' + dir_name + '/' + new_file_name)
    assert t_file_id is None

    # test move_file (asynchronous)
    usage = api.get_user_self_usage(USER)
    api.set_user_quota(USER, usage + 1)
    t_move_file_result2 = api.move_file(t_repo_id1, '/', file_name, t_repo_id2,
                                        '/', new_file_name, 1, USER, 1, 0)
    assert t_move_file_result2
    assert t_move_file_result2.task_id
    assert t_move_file_result2.background
    while True:
        time.sleep(0.1)
        t_move_task = api.get_copy_task(t_move_file_result2.task_id)
        assert t_move_task.failed
        assert t_move_task.failed_reason == 'Quota is full'
        if t_move_task.failed:
            break

    api.set_user_quota(USER, -1)
    t_move_file_result2 = api.move_file(t_repo_id1, '/', file_name, t_repo_id2,
                                        '/', new_file_name, 1, USER, 1, 0)
    assert t_move_file_result2
    assert t_move_file_result2.task_id
    assert t_move_file_result2.background
    while True:
        time.sleep(0.1)
        t_move_task = api.get_copy_task(t_move_file_result2.task_id)
        if t_move_task.successful:
            break
    t_file_id = api.get_file_id_by_path(t_repo_id2, '/' + new_file_name)
    assert t_file_size == api.get_file_size(t_repo_id2, t_repo_version,
                                            t_file_id)

    # test post_empty_file
    assert api.post_empty_file(t_repo_id1, '/' + dir_name, empty_file_name,
                               USER) == 0
    t_file_id = api.get_file_id_by_path(t_repo_id1,
                                        '/' + dir_name + '/' + empty_file_name)
    assert api.get_file_size(t_repo_id1, t_repo_version, t_file_id) == 0

    # test rename_file
    assert api.rename_file(t_repo_id1, '/' + dir_name, empty_file_name,
                           new_empty_file_name, USER) == 0

    #test put_file
    t_new_file_id = api.put_file(t_repo_id1, file_path, '/' + dir_name,
                                 new_empty_file_name, USER, None)
    assert t_new_file_id

    # test get_file_revisions
    t_commit_list = api.get_file_revisions(t_repo_id2, None, '/' + file_name,
                                           2)
    assert t_commit_list
    assert len(t_commit_list) == 2
    assert t_commit_list[0].creator_name == USER

    # test del_file
    assert api.del_file(t_repo_id2, '/', file_name, USER) == 0

    # test get_deleted
    t_deleted_file_list = api.get_deleted(t_repo_id2, 1)
    assert t_deleted_file_list
    assert len(t_deleted_file_list) == 2
    assert t_deleted_file_list[0].obj_name == file_name
    assert t_deleted_file_list[0].basedir == '/'

    # test del a non-exist file. should return 0.
    assert api.del_file(t_repo_id2, '/', file_name, USER) == 0

    assert api.del_file(t_repo_id1, '/' + dir_name, new_empty_file_name,
                        USER) == 0
    assert api.del_file(t_repo_id1, '/' + dir_name, new_file_name, USER) == 0
    assert api.del_file(t_repo_id2, '/', new_file_name, USER) == 0
    assert api.del_file(t_repo_id1, '/', new_file_name_2, USER) == 0

    time.sleep(1)
    api.remove_repo(t_repo_id1)
def create_test_dir(repo, dir_name):
    parent_dir = '/'
    api.post_dir(repo.id,parent_dir,dir_name,USER)
Example #29
0
 def create_folder(self, **kwargs):
     seafile_api.post_dir(**kwargs)
     return kwargs['parent_dir'] + kwargs['dirname']
Example #30
0
 def create_folder(self, **kwargs):
     seafile_api.post_dir(**kwargs)
     return kwargs['parent_dir'] + kwargs['dirname']
Example #31
0
        def _test_under_path(path):
            repo = TEST_REPO
            path = path.rstrip('/')
            #sdir = repo.get_dir('/')
            parent_dir = '/'
            if path:
                dirs = [p for p in path.split('/') if p]
                for d in dirs:
                    api.post_dir(repo.get('id'), parent_dir, d, USER)
                    parent_dir = parent_dir + d + '/'
            entries = davclient.repo_listdir(repo, path)
            self.assertEmpty(entries)

            # create a folder from webapi and list it in webdav
            dirname = 'folder-%s' % randstring()
            api.post_dir(repo.get('id'), parent_dir, dirname, USER)

            entries = davclient.repo_listdir(repo, parent_dir)
            self.assertHasLen(entries, 1)
            sfolder = entries[0]
            self.assertEqual(dav_basename(sfolder), dirname)

            # create a file from webapi and list it in webdav
            testfpath = os.path.join(os.path.dirname(__file__), 'data',
                                     'test.txt')
            with open(testfpath, 'rb') as fp:
                testfcontent = fp.read()
            fname = 'uploaded-file-%s.txt' % randstring()
            api.post_file(repo.get('id'), testfpath, parent_dir, fname, USER)
            entries = davclient.repo_listdir(repo, parent_dir)
            self.assertHasLen(entries, 2)
            downloaded_file = davclient.repo_getfile(
                repo, posixpath.join(parent_dir, fname))
            assert downloaded_file == testfcontent

            # create a folder through webdav, and check it in webapi
            dirname = 'another-level1-folder-%s' % randstring(10)
            davclient.repo_mkdir(repo, parent_dir, dirname)
            entries = api.list_dir_by_path(repo.get('id'), parent_dir)
            self.assertHasLen(entries, 3)
            davdir = [e for e in entries if e.obj_name == dirname][0]
            self.assertEqual(davdir.obj_name, dirname)

            # upload a file through webdav, and check it in webapi
            fname = 'uploaded-file-%s' % randstring()
            repo_fpath = posixpath.join(parent_dir, fname)
            davclient.repo_uploadfile(repo, testfpath, repo_fpath)
            entries = api.list_dir_by_path(repo.get('id'), parent_dir)
            self.assertHasLen(entries, 4)

            # remove a dir through webdav
            self.assertIn(dirname, [dirent.obj_name for dirent in \
                                    api.list_dir_by_path(repo.get('id'), parent_dir)])
            davclient.repo_removedir(repo, os.path.join(parent_dir, dirname))
            entries = api.list_dir_by_path(repo.get('id'), parent_dir)
            self.assertHasLen(entries, 3)
            self.assertNotIn(dirname, [dirent.obj_name for dirent in entries])

            # remove a file through webdav
            self.assertIn(fname, [dirent.obj_name for dirent in \
                                  api.list_dir_by_path(repo.get('id'), parent_dir)])
            davclient.repo_removefile(repo, os.path.join(parent_dir, fname))
            entries = api.list_dir_by_path(repo.get('id'), parent_dir)
            self.assertHasLen(entries, 2)
            self.assertNotIn(fname, [dirent.obj_name for dirent in entries])
Example #32
0
 def create_folder(self, **kwargs):
     seafile_api.post_dir(**kwargs)
     return kwargs["parent_dir"] + kwargs["dirname"]
Example #33
0
    def post(self, request, format=None):
        repo_id = request.repo_api_token_obj.repo_id
        # argument check
        path = request.GET.get('path', None)
        if not path or path[0] != '/':
            error_msg = 'path invalid.'
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

        if path == '/':
            error_msg = 'Can not operate root dir.'
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

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

        operation = operation.lower()
        if operation not in ('mkdir', 'rename', 'revert'):
            error_msg = "operation can only be 'mkdir', 'rename' or 'revert'."
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

        # resource check
        repo = seafile_api.get_repo(repo_id)
        if not repo:
            error_msg = 'Library %s not found.' % repo_id
            return api_error(status.HTTP_404_NOT_FOUND, error_msg)

        path = path.rstrip('/')
        username = request.user.username
        parent_dir = os.path.dirname(path)
        if operation == 'mkdir':
            # resource check
            parent_dir_id = seafile_api.get_dir_id_by_path(repo_id, parent_dir)
            if not parent_dir_id:
                error_msg = 'Folder %s not found.' % parent_dir
                return api_error(status.HTTP_404_NOT_FOUND, error_msg)

            # permission check
            if check_folder_permission_by_repo_api(request, repo_id,
                                                   parent_dir) != 'rw':
                error_msg = 'Permission denied.'
                return api_error(status.HTTP_403_FORBIDDEN, error_msg)

            new_dir_name = os.path.basename(path)

            if not is_valid_dirent_name(new_dir_name):
                return api_error(status.HTTP_400_BAD_REQUEST, 'name invalid.')

            retry_count = 0
            while retry_count < 10:
                new_dir_name = check_filename_with_rename(
                    repo_id, parent_dir, new_dir_name)
                try:
                    seafile_api.post_dir(repo_id, parent_dir, new_dir_name,
                                         username)
                    break
                except SearpcError as e:
                    if str(e) == 'file already exists':
                        retry_count += 1
                    else:
                        logger.error(e)
                        error_msg = 'Internal Server Error'
                        return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR,
                                         error_msg)

            new_dir_path = posixpath.join(parent_dir, new_dir_name)
            dir_info = self.get_dir_info(repo_id, new_dir_path)
            resp = Response(dir_info)

            return resp

        if operation == 'rename':
            # resource check
            dir_id = seafile_api.get_dir_id_by_path(repo_id, path)
            if not dir_id:
                error_msg = 'Folder %s not found.' % path
                return api_error(status.HTTP_404_NOT_FOUND, error_msg)

            # permission check
            if check_folder_permission_by_repo_api(request, repo_id,
                                                   path) != 'rw':
                error_msg = 'Permission denied.'
                return api_error(status.HTTP_403_FORBIDDEN, error_msg)

            old_dir_name = os.path.basename(path)
            new_dir_name = request.data.get('newname', None)

            if not new_dir_name:
                error_msg = 'newname invalid.'
                return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

            if not is_valid_dirent_name(new_dir_name):
                return api_error(status.HTTP_400_BAD_REQUEST, 'name invalid.')

            if new_dir_name == old_dir_name:
                dir_info = self.get_dir_info(repo_id, path)
                resp = Response(dir_info)
                return resp

            try:
                # rename duplicate name
                new_dir_name = check_filename_with_rename(
                    repo_id, parent_dir, new_dir_name)
                # rename dir
                seafile_api.rename_file(repo_id, parent_dir, old_dir_name,
                                        new_dir_name, username)

                new_dir_path = posixpath.join(parent_dir, new_dir_name)
                dir_info = self.get_dir_info(repo_id, new_dir_path)
                resp = Response(dir_info)
                return resp
            except SearpcError as e:
                logger.error(e)
                error_msg = 'Internal Server Error'
                return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR,
                                 error_msg)

        if operation == 'revert':
            commit_id = request.data.get('commit_id', None)
            if not commit_id:
                error_msg = 'commit_id invalid.'
                return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

            if seafile_api.get_dir_id_by_path(repo_id, path):
                # dir exists in repo
                if check_folder_permission_by_repo_api(request, repo_id,
                                                       path) != 'rw':
                    error_msg = 'Permission denied.'
                    return api_error(status.HTTP_403_FORBIDDEN, error_msg)
            else:
                # dir NOT exists in repo
                if check_folder_permission_by_repo_api(request, repo_id,
                                                       '/') != 'rw':
                    error_msg = 'Permission denied.'
                    return api_error(status.HTTP_403_FORBIDDEN, error_msg)

            try:
                seafile_api.revert_dir(repo_id, commit_id, path, username)
            except Exception as e:
                logger.error(e)
                error_msg = 'Internal Server Error'
                return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR,
                                 error_msg)

            return Response({'success': True})
Example #34
0
def test_merge_virtual_repo(repo):
    api.post_dir(repo.id, '/dir1', 'subdir1', USER)
    api.post_dir(repo.id, '/dir2', 'subdir2', USER)
    v_repo_id = api.share_subdir_to_user(repo.id, '/dir1', USER, USER2, 'rw')

    create_test_file()
    params = {'ret-json': '1'}
    obj_id = '{"parent_dir":"/"}'
    create_test_dir(repo, 'test')

    #test upload file to vritual repo root dir.
    token = api.get_fileserver_access_token(v_repo_id, obj_id, 'upload', USER2,
                                            False)
    upload_url_base = 'http://127.0.0.1:8082/upload-api/' + token
    m = MultipartEncoder(
        fields={
            'parent_dir': '/',
            'file': (file_name, open(file_path, 'rb'),
                     'application/octet-stream')
        })
    response = requests.post(upload_url_base,
                             params=params,
                             data=m,
                             headers={'Content-Type': m.content_type})
    assert_upload_response(response, False, False)

    time.sleep(1.5)
    repo_size = api.get_repo_size(v_repo_id)
    assert repo_size == 0

    time.sleep(1.5)
    repo_size = api.get_repo_size(repo.id)
    assert repo_size == 0

    #test resumable upload file to virtual repo root dir
    parent_dir = '/'
    headers = {
        'Content-Range':
        'bytes 0-{}/{}'.format(str(len(chunked_part1_content) - 1),
                               str(total_size)),
        'Content-Disposition':
        'attachment; filename=\"{}\"'.format(resumable_file_name)
    }
    response = request_resumable_upload(chunked_part1_path, headers,
                                        upload_url_base, parent_dir, False)
    assert_resumable_upload_response(response, v_repo_id, resumable_file_name,
                                     False)

    time.sleep(1.5)
    v_repo_size = api.get_repo_size(v_repo_id)
    assert v_repo_size == 0
    time.sleep(1.5)
    repo_size = api.get_repo_size(repo.id)
    assert repo_size == 0

    headers = {
        'Content-Range':
        'bytes {}-{}/{}'.format(str(len(chunked_part1_content)),
                                str(total_size - 1), str(total_size)),
        'Content-Disposition':
        'attachment; filename=\"{}\"'.format(resumable_file_name)
    }
    response = request_resumable_upload(chunked_part2_path, headers,
                                        upload_url_base, parent_dir, False)
    assert_resumable_upload_response(response, v_repo_id, resumable_file_name,
                                     True)

    time.sleep(2.5)
    v_repo_size = api.get_repo_size(v_repo_id)
    assert v_repo_size == total_size
    time.sleep(1.5)
    repo_size = api.get_repo_size(repo.id)
    assert repo_size == total_size

    #test update file to virtual repo.
    write_file(file_path, file_content)
    token = api.get_fileserver_access_token(v_repo_id, obj_id, 'update', USER2,
                                            False)
    update_url_base = 'http://127.0.0.1:8082/update-api/' + token
    m = MultipartEncoder(
        fields={
            'target_file': '/' + file_name,
            'file': (file_name, open(file_path, 'rb'),
                     'application/octet-stream')
        })
    response = requests.post(update_url_base,
                             data=m,
                             headers={'Content-Type': m.content_type})
    assert_update_response(response, False)

    time.sleep(1.5)
    v_repo_size = api.get_repo_size(v_repo_id)
    assert v_repo_size == total_size + file_size
    time.sleep(1.5)
    repo_size = api.get_repo_size(repo.id)
    assert repo_size == total_size + file_size

    api.del_file(v_repo_id, '/', file_name, USER2)

    time.sleep(1.5)
    v_repo_size = api.get_repo_size(v_repo_id)
    assert v_repo_size == total_size
    time.sleep(1.5)
    repo_size = api.get_repo_size(repo.id)
    assert repo_size == total_size

    api.del_file(v_repo_id, '/', resumable_file_name, USER2)

    time.sleep(1.5)
    v_repo_size = api.get_repo_size(v_repo_id)
    assert v_repo_size == 0
    time.sleep(1.5)
    repo_size = api.get_repo_size(repo.id)
    assert repo_size == 0

    api.del_file(repo.id, '/dir1', 'subdir1', USER)
    api.del_file(repo.id, '/dir2', 'subdir1', USER)
    assert api.unshare_subdir_for_user(repo.id, '/dir1', USER, USER2) == 0
    del_local_files()
def test_repo_manipulation():

    #test get_system_default_repo_id
    t_default_repo_id = api.get_system_default_repo_id()
    assert t_default_repo_id

    #test create_repo
    t_repo_id = api.create_repo('test_repo_manipulation',
                                '',
                                USER,
                                passwd=None)
    assert t_repo_id

    #test counts_repo
    t_repo_count = 0
    t_repo_count = api.count_repos()
    assert t_repo_count != 0

    #test get_repo ,edit_repo
    t_new_name = 'n_name'
    t_new_desc = 'n_desc'
    t_repo_version = 1
    t_repo = api.get_repo(t_repo_id)
    assert t_repo

    api.edit_repo(t_repo_id, t_new_name, t_new_desc, USER)
    t_repo = api.get_repo(t_repo_id)
    assert t_repo.name == t_new_name and t_repo.desc == t_new_desc

    #test revert_repo and get_commit
    t_commit_id_before_changing = t_repo.head_cmmt_id

    api.post_dir(t_repo_id, '/', 'dir1', USER)
    t_repo = api.get_repo(t_repo_id)

    api.revert_repo(t_repo_id, t_commit_id_before_changing, USER)

    t_repo = api.get_repo(t_repo_id)
    t_commit_id_after_revert = t_repo.head_cmmt_id

    t_commit_before_changing = api.get_commit(t_repo_id, t_repo_version,
                                              t_commit_id_before_changing)
    t_commit_after_revert = api.get_commit(t_repo_id, t_repo_version,
                                           t_commit_id_after_revert)
    assert t_commit_before_changing.root_id == t_commit_after_revert.root_id

    #test is_repo_owner
    assert api.is_repo_owner(USER, t_repo_id)
    assert api.is_repo_owner(USER2, t_repo_id) == 0

    #test get_repo_owner
    owner_get = api.get_repo_owner(t_repo_id)
    assert owner_get == USER

    #test set_repo_owner
    api.set_repo_owner(t_repo_id, USER2)
    assert api.is_repo_owner(USER2, t_repo_id)

    #test create_enc_repo
    t_enc_repo_id = '826d1b7b-f110-46f2-8d5e-7b5ac3e11f4d'
    t_enc_version = 2
    t_passwd = '123'
    magic_and_random_key = api.generate_magic_and_random_key(
        t_enc_version, t_enc_repo_id, t_passwd)
    t_magic = magic_and_random_key.magic
    t_random_key = magic_and_random_key.random_key
    t_enc_repo_id = api.create_enc_repo(t_enc_repo_id, 'test_encrypted_repo',
                                        '', USER, t_magic, t_random_key,
                                        t_enc_version)
    assert t_enc_repo_id == '826d1b7b-f110-46f2-8d5e-7b5ac3e11f4d'

    #test get_repo_list
    t_start = -1
    t_limit = -1
    t_repo_list = api.get_repo_list(t_start, t_limit)
    assert t_repo_list and len(t_repo_list)

    t_start = 1
    t_limit = 1
    t_repo_list = api.get_repo_list(t_start, t_limit)
    assert t_repo_list and len(t_repo_list) == 1

    #test get_owned_repo_list
    t_repo_list = api.get_owned_repo_list(USER2)
    assert t_repo_list and len(t_repo_list)

    #test get_commit_list
    t_offset = 0
    t_limit = 0
    t_commit_list = api.get_commit_list(t_repo_id, t_offset, t_limit)
    assert t_commit_list and len(t_commit_list) == 4

    t_offset = 1
    t_limit = 1
    t_commit_list = api.get_commit_list(t_repo_id, t_offset, t_limit)
    assert t_commit_list and len(t_commit_list) == 1

    #test remove_repo
    api.remove_repo(t_repo_id)
    t_repo = api.get_repo(t_repo_id)
    assert t_repo == None
Example #36
0
    def post(self, request, repo_id, format=None):
        repo = seafile_api.get_repo(repo_id)
        if not repo:
            return api_error(status.HTTP_404_NOT_FOUND, 'Library not found.')

        path = request.GET.get('p', '')
        if not path or path[0] != '/':
            error_msg = 'p invalid.'
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

        if path == '/':
            error_msg = 'Can not make or rename root dir.'
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

        if path[-1] == '/':
            path = path[:-1]

        username = request.user.username
        parent_dir = os.path.dirname(path)
        operation = request.POST.get('operation', '')
        if operation.lower() == 'mkdir':
            parent_dir = os.path.dirname(path)
            if check_folder_permission(request, repo_id, parent_dir) != 'rw':
                error_msg = 'Permission denied.'
                return api_error(status.HTTP_403_FORBIDDEN, error_msg)

            create_parents = request.POST.get('create_parents', '').lower() in ('true', '1')
            if not create_parents:
                parent_dir_id = seafile_api.get_dir_id_by_path(repo_id, parent_dir)
                if not parent_dir_id:
                    error_msg = 'Folder %s not found.' % parent_dir
                    return api_error(status.HTTP_404_NOT_FOUND, error_msg)

                new_dir_name = os.path.basename(path)
                new_dir_name = check_filename_with_rename(repo_id, parent_dir, new_dir_name)
                try:
                    seafile_api.post_dir(repo_id, parent_dir, new_dir_name, username)
                except SearpcError as e:
                    logger.error(e)
                    error_msg = 'Internal Server Error'
                    return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
            else:
                if not is_pro_version():
                    error_msg = 'Feature not supported.'
                    return api_error(status.HTTP_403_FORBIDDEN, error_msg)

                try:
                    seafile_api.mkdir_with_parents(repo_id, '/', path[1:], username)
                except SearpcError as e:
                    logger.error(e)
                    error_msg = 'Internal Server Error'
                    return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)

            if request.GET.get('reloaddir', '').lower() == 'true':
                resp = reloaddir(request, repo, parent_dir)
            else:
                resp = Response({'success': True})

            return resp

        elif operation.lower() == 'rename':
            dir_id = seafile_api.get_dir_id_by_path(repo_id, path)
            if not dir_id:
                error_msg = 'Folder %s not found.' % path
                return api_error(status.HTTP_404_NOT_FOUND, error_msg)

            if check_folder_permission(request, repo.id, path) != 'rw':
                error_msg = 'Permission denied.'
                return api_error(status.HTTP_403_FORBIDDEN, error_msg)

            parent_dir = os.path.dirname(path)
            old_dir_name = os.path.basename(path)
            newname = request.POST.get('newname', '')
            if not newname:
                error_msg = 'newname invalid.'
                return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

            if newname == old_dir_name:
                return Response({'success': True})

            try:
                # rename duplicate name
                checked_newname = check_filename_with_rename(repo_id, parent_dir, newname)
                # rename dir
                seafile_api.rename_file(repo_id, parent_dir, old_dir_name,
                                        checked_newname, username)
                return Response({'success': True})
            except SearpcError, e:
                logger.error(e)
                error_msg = 'Internal Server Error'
                return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
Example #37
0
    def post(self, request, repo_id, format=None):
        """ Create, rename, revert dir.

        Permission checking:
        1. create: user with 'rw' permission for current dir's parent dir;
        2. rename: user with 'rw' permission for current dir;
        3. revert: user with 'rw' permission for current dir's parent dir;
        """

        # argument check
        path = request.GET.get('p', None)
        if not path or path[0] != '/':
            error_msg = 'p invalid.'
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

        if path == '/':
            error_msg = 'Can not operate root dir.'
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

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

        operation = operation.lower()
        if operation not in ('mkdir', 'rename', 'revert'):
            error_msg = "operation can only be 'mkdir', 'rename' or 'revert'."
            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

        # resource check
        repo = seafile_api.get_repo(repo_id)
        if not repo:
            error_msg = 'Library %s not found.' % repo_id
            return api_error(status.HTTP_404_NOT_FOUND, error_msg)

        path = path.rstrip('/')
        username = request.user.username
        parent_dir = os.path.dirname(path)
        if operation == 'mkdir':
            # permission check
            if check_folder_permission(request, repo_id, parent_dir) != 'rw':
                error_msg = 'Permission denied.'
                return api_error(status.HTTP_403_FORBIDDEN, error_msg)

            # resource check
            parent_dir_id = seafile_api.get_dir_id_by_path(repo_id, parent_dir)
            if not parent_dir_id:
                error_msg = 'Folder %s not found.' % parent_dir
                return api_error(status.HTTP_404_NOT_FOUND, error_msg)

            new_dir_name = os.path.basename(path)
            new_dir_name = check_filename_with_rename(repo_id, parent_dir, new_dir_name)
            try:
                seafile_api.post_dir(repo_id, parent_dir, new_dir_name, username)
            except SearpcError as e:
                logger.error(e)
                error_msg = 'Internal Server Error'
                return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)

            new_dir_path = posixpath.join(parent_dir, new_dir_name)
            dir_info = self.get_dir_info(repo_id, new_dir_path)
            resp = Response(dir_info)

            return resp

        if operation == 'rename':
            # resource check
            dir_id = seafile_api.get_dir_id_by_path(repo_id, path)
            if not dir_id:
                error_msg = 'Folder %s not found.' % path
                return api_error(status.HTTP_404_NOT_FOUND, error_msg)

            # permission check
            if check_folder_permission(request, repo_id, path) != 'rw':
                error_msg = 'Permission denied.'
                return api_error(status.HTTP_403_FORBIDDEN, error_msg)

            old_dir_name = os.path.basename(path)
            new_dir_name = request.data.get('newname', None)
            if not new_dir_name:
                error_msg = 'newname invalid.'
                return api_error(status.HTTP_400_BAD_REQUEST, error_msg)

            if new_dir_name == old_dir_name:
                dir_info = self.get_dir_info(repo_id, path)
                resp = Response(dir_info)
                return resp

            try:
                # rename duplicate name
                new_dir_name = check_filename_with_rename(repo_id, parent_dir, new_dir_name)
                # rename dir
                seafile_api.rename_file(repo_id, parent_dir, old_dir_name,
                                        new_dir_name, username)

                new_dir_path = posixpath.join(parent_dir, new_dir_name)
                dir_info = self.get_dir_info(repo_id, new_dir_path)
                resp = Response(dir_info)
                return resp
            except SearpcError, e:
                logger.error(e)
                error_msg = 'Internal Server Error'
                return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
Example #38
0
 def setUp(self):
     seafile_api.post_dir(self.repo.id, '/', 'Drafts', self.user.username)
Example #39
0
def test_file_property_and_dir_listing():

    t_repo_version = 1
    t_repo_id = api.create_repo('test_file_property_and_dir_listing',
                                '',
                                USER,
                                passwd=None)

    create_the_file()

    api.post_file(t_repo_id, file_path, '/', file_name, USER)
    api.post_dir(t_repo_id, '/', dir_name, USER)
    api.post_file(t_repo_id, file_path, '/' + dir_name, file_name, USER)

    #test is_valid_filename
    t_valid_file_name = 'valid_filename'
    t_invalid_file_name = '/invalid_filename'
    assert api.is_valid_filename(t_repo_id, t_valid_file_name)
    assert api.is_valid_filename(t_repo_id, t_invalid_file_name) == 0

    #test get_file_id_by_path
    t_file_id = api.get_file_id_by_path(t_repo_id, '/test.txt')
    assert t_file_id

    #test get_dir_id_by_path
    t_dir_id = api.get_dir_id_by_path(t_repo_id, '/test_dir')
    assert t_dir_id

    #test get_file_size
    t_file_size = len(file_content)
    assert t_file_size == api.get_file_size(t_repo_id, t_repo_version,
                                            t_file_id)

    #test get_dir_size
    t_dir_size = len(file_content)
    assert t_dir_size == api.get_dir_size(t_repo_id, t_repo_version, t_dir_id)

    #test get_file_count_info_by_path
    t_file_count_info = api.get_file_count_info_by_path(t_repo_id, '/')
    assert t_file_count_info.file_count == 2
    assert t_file_count_info.dir_count == 1
    assert t_file_count_info.size == t_file_size + t_dir_size

    #test get_file_id_by_commit_and_path
    t_file_id_tmp = t_file_id
    t_repo = api.get_repo(t_repo_id)
    assert t_repo
    t_commit_id = t_repo.head_cmmt_id
    t_file_id = api.get_file_id_by_commit_and_path(t_repo_id, t_commit_id,
                                                   '/test.txt')

    assert t_file_id == t_file_id_tmp

    #test get_dirent_by_path
    std_file_mode = 0100000 | 0644
    t_dirent_obj = api.get_dirent_by_path(t_repo_id, '/test.txt')
    assert t_dirent_obj
    assert t_dirent_obj.obj_id == t_file_id
    assert t_dirent_obj.obj_name == 'test.txt'
    assert t_dirent_obj.mode == std_file_mode
    assert t_dirent_obj.version == t_repo_version
    assert t_dirent_obj.size == t_file_size
    assert t_dirent_obj.modifier == USER

    #test list_file_by_file_id
    t_block_list = api.list_file_by_file_id(t_repo_id, t_file_id)
    assert t_block_list

    #test list_blocks_by_file_id
    t_block_list = api.list_blocks_by_file_id(t_repo_id, t_file_id)
    assert t_block_list

    #test list_dir_by_dir_id
    t_dir_list = api.list_dir_by_dir_id(t_repo_id, t_dir_id)
    assert len(t_dir_list) == 1

    #test list_dir_by_path
    t_dir_list = api.list_dir_by_path(t_repo_id, '/test_dir')
    assert len(t_dir_list) == 1

    #test get_dir_id_by_commit_and_path
    t_dir_id = api.get_dir_id_by_commit_and_path(t_repo_id, t_commit_id,
                                                 '/test_dir')
    assert t_dir_id

    #test list_dir_by_commit_and_path
    t_dir_list = api.list_dir_by_commit_and_path(t_repo_id, t_commit_id,
                                                 '/test_dir')
    assert len(t_dir_list) == 1

    #test list_dir_with_perm
    t_dir_list = api.list_dir_with_perm(t_repo_id, '/test_dir', t_dir_id, USER)
    assert len(t_dir_list) == 1

    #test mkdir_with_parent
    api.mkdir_with_parents(t_repo_id, '/test_dir', 'test_subdir', USER)
    t_dir_id = api.get_dir_id_by_path(t_repo_id, '/test_dir/test_subdir')
    assert t_dir_id

    #test get_total_storage
    t_total_size = api.get_total_storage()
    t_repo_size = api.get_repo_size(t_repo_id)
    assert t_total_size == t_repo_size

    #get_total_file_number
    time.sleep(1)
    assert api.get_total_file_number() == 2

    api.remove_repo(t_repo_id)
Example #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)