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)
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
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)
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)
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
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])
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)
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
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
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)
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
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
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)
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)
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)
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)
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)
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
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)
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
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
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)
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)
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)
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)
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))
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)
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 create_and_get_repo(*a, **kw): repo_id = seafile_api.create_repo(*a, **kw) repo = seafile_api.get_repo(repo_id) return repo
def create_repo(self, **kwargs): repo_id = seafile_api.create_repo('test-repo', '', '*****@*****.**', None) return repo_id
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)
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
def create_repo(self, **kwargs): repo_id = seafile_api.create_repo(**kwargs) return repo_id
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)
def create_repo(self, **kwargs): repo_id = seafile_api.create_repo("test-repo", "", self.user.username, None) return repo_id
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