def org_user_remove(request, user_id): """Remove an organization user""" referer = request.META.get('HTTP_REFERER', None) next = reverse('org_user_admin') if referer is None else referer try: user = User.objects.get(id=int(user_id)) except User.DoesNotExist: messages.error(request, _(u'Failed to delete: the user does not exist')) return HttpResponseRedirect(next) org = request.user.org if not org_user_exists(org.org_id, user.username): messages.error( request, 'Failed to delete: the user does not belong to the organization.') return HttpResponseRedirect(next) if org.creator == user.username: messages.error( request, 'Failed to delete: the user is an organization creator') return HttpResponseRedirect(next) org_repos = seafile_api.get_org_owned_repo_list(org.org_id, user.username) for repo in org_repos: seafile_api.remove_repo(repo.id) user.delete() unset_org_user(org.org_id, user.username) messages.success(request, _('Successfully deleted %s') % user.name) return HttpResponseRedirect(next)
def delete(self, request, repo_id, format=None): """ delete a library Permission checking: 1. only admin can perform this action. """ if get_system_default_repo_id() == repo_id: error_msg = _('System library can not be deleted.') return api_error(status.HTTP_400_BAD_REQUEST, error_msg) repo = seafile_api.get_repo(repo_id) if not repo: return api_error(status.HTTP_404_NOT_FOUND, 'Library %s not found.' % repo_id) repo_owner = seafile_api.get_repo_owner(repo_id) if not repo_owner: repo_owner = seafile_api.get_org_repo_owner(repo_id) related_usernames = seaserv.get_related_users_by_repo(repo_id) try: seafile_api.remove_repo(repo_id) repo_deleted.send(sender=None, org_id=-1, usernames=related_usernames, repo_owner=repo_owner, repo_id=repo_id, repo_name=repo.name) 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})
def delete(self): """ When delete user, we should also delete group relationships. """ if self.source == "DB": source = "DB" else: source = "LDAP" username = self.username orgs = [] if is_pro_version(): orgs = ccnet_api.get_orgs_by_user(username) # remove owned repos owned_repos = [] if orgs: for org in orgs: owned_repos += seafile_api.get_org_owned_repo_list( org.org_id, username) else: owned_repos += seafile_api.get_owned_repo_list(username) for r in owned_repos: seafile_api.remove_repo(r.id) # remove shared in repos shared_in_repos = [] if orgs: for org in orgs: org_id = org.org_id shared_in_repos = seafile_api.get_org_share_in_repo_list( org_id, username, -1, -1) for r in shared_in_repos: seafile_api.org_remove_share(org_id, r.repo_id, r.user, username) else: shared_in_repos = seafile_api.get_share_in_repo_list( username, -1, -1) for r in shared_in_repos: seafile_api.remove_share(r.repo_id, r.user, username) ExtraSharePermission.objects.filter(share_to=username).delete() # clear web api and repo sync token # when delete user try: clear_token(self.username) except Exception as e: logger.error(e) # remove current user from joined groups ccnet_api.remove_group_user(username) ccnet_api.remove_emailuser(source, username) Profile.objects.delete_profile_by_user(username) if settings.ENABLE_TERMS_AND_CONDITIONS: from termsandconditions.models import UserTermsAndConditions UserTermsAndConditions.objects.filter(username=username).delete()
def delete(self, request, repo_id): 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) # check permission username = request.user.username repo_owner = get_repo_owner(request, repo_id) if username != repo_owner: error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) # check repo status repo_status = repo.status if repo_status != 0: error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) org_id = None if is_org_context(request): org_id = request.user.org.org_id # remove repo seafile_api.remove_repo(repo_id) repo_deleted.send(sender=None, org_id=org_id, operator=username, repo_owner=repo_owner, repo_id=repo_id, repo_name=repo.name) return Response('success', status=status.HTTP_200_OK)
def sys_repo_delete(request, repo_id): """Delete a repo. """ next_page = request.META.get('HTTP_REFERER', None) if not next_page: next_page = HASH_URLS['SYS_REPO_ADMIN'] if get_system_default_repo_id() == repo_id: messages.error(request, _('System library can not be deleted.')) return HttpResponseRedirect(next_page) repo = seafile_api.get_repo(repo_id) if repo: # Handle the case that repo is `None`. repo_name = repo.name else: repo_name = '' repo_owner = get_repo_owner(request, repo_id) try: org_id = seafile_api.get_org_id_by_repo_id(repo_id) usernames = get_related_users_by_repo(repo_id, org_id if org_id and org_id > 0 else None) except Exception as e: logger.error(e) org_id = -1 usernames = [] seafile_api.remove_repo(repo_id) repo_deleted.send(sender=None, org_id=org_id, operator=request.user.username, usernames=usernames, repo_owner=repo_owner, repo_id=repo_id, repo_name=repo_name) messages.success(request, _('Successfully deleted.')) return HttpResponseRedirect(next_page)
def delete(self, request, repo_id, format=None): """ delete a library Permission checking: 1. only admin can perform this action. """ if get_system_default_repo_id() == repo_id: error_msg = _('System library can not be deleted.') return api_error(status.HTTP_400_BAD_REQUEST, error_msg) repo = seafile_api.get_repo(repo_id) if not repo: # for case of `seafile-data` has been damaged # no `repo object` will be returned from seafile api # delete the database record anyway try: seafile_api.remove_repo(repo_id) 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}) repo_name = repo.name repo_owner = seafile_api.get_repo_owner(repo_id) if not repo_owner: repo_owner = seafile_api.get_org_repo_owner(repo_id) try: related_usernames = seaserv.get_related_users_by_repo(repo_id) seafile_api.remove_repo(repo_id) # send signal for seafevents repo_deleted.send(sender=None, org_id=-1, operator=request.user.username, usernames=related_usernames, repo_owner=repo_owner, repo_id=repo_id, repo_name=repo.name) 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_DELETE, detail=admin_op_detail) return Response({'success': True})
def delete(self, request, org_id, repo_id): """Remove an organization library """ # resource check org_id = int(org_id) if not ccnet_api.get_org_by_id(org_id): error_msg = 'Organization %s not found.' % org_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) 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 is_org_repo(org_id, repo_id): error_msg = 'Library %s not in org %s.' % (repo_id, org_id) return api_error(status.HTTP_400_BAD_REQUEST, error_msg) usernames = seaserv.get_related_users_by_org_repo(org_id, repo_id) repo_owner = seafile_api.get_org_repo_owner(repo_id) seafile_api.remove_repo(repo_id) repo_deleted.send(sender=None, operator=request.user.username, org_id=org_id, usernames=usernames, repo_owner=repo_owner, repo_id=repo_id, repo_name=repo.name) return Response({'success': True})
def delete(self): """ When delete user, we should also delete group relationships. """ if self.source == "DB": source = "DB" else: source = "LDAP" owned_repos = [] orgs = ccnet_threaded_rpc.get_orgs_by_user(self.username) if orgs: for org in orgs: owned_repos += seafile_api.get_org_owned_repo_list(org.org_id, self.username) else: owned_repos += seafile_api.get_owned_repo_list(self.username) for r in owned_repos: seafile_api.remove_repo(r.id) clear_token(self.username) # remove current user from joined groups ccnet_api.remove_group_user(self.username) ccnet_api.remove_emailuser(source, self.username) Profile.objects.delete_profile_by_user(self.username)
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 repo_remove(request, repo_id): if not request.is_ajax(): raise Http404 content_type = 'application/json; charset=utf-8' result = {} repo = get_repo(repo_id) if not repo: result['error'] = _(u'Library does not exist') return HttpResponse(json.dumps(result), status=400, content_type=content_type) user = request.user.username org, base_template = check_and_get_org_by_repo(repo_id, user) if org: # Remove repo in org context, only repo owner or org staff can # perform this operation. if request.user.is_staff or org.is_staff or \ is_org_repo_owner(org.org_id, repo_id, user): # Must get related useres before remove the repo usernames = get_related_users_by_org_repo(org.org_id, repo_id) seafile_api.remove_repo(repo_id) repo_deleted.send( sender=None, org_id=org.org_id, usernames=usernames, repo_owner=user, repo_id=repo_id, repo_name=repo.name, ) result['success'] = True return HttpResponse(json.dumps(result), content_type=content_type) else: result['error'] = _(u'Permission denied.') return HttpResponse(json.dumps(result), status=400, content_type=content_type) else: # Remove repo in personal context, only repo owner or site staff can # perform this operation. if validate_owner(request, repo_id) or request.user.is_staff: usernames = get_related_users_by_repo(repo_id) seafile_api.remove_repo(repo_id) repo_deleted.send( sender=None, org_id=-1, usernames=usernames, repo_owner=user, repo_id=repo_id, repo_name=repo.name, ) result['success'] = True return HttpResponse(json.dumps(result), content_type=content_type) else: result['error'] = _(u'Permission denied.') return HttpResponse(json.dumps(result), status=400, content_type=content_type)
def user_remove(request, user_id): """Remove user""" referer = request.META.get('HTTP_REFERER', None) next = reverse('sys_useradmin') if referer is None else referer try: user = User.objects.get(id=int(user_id)) org = ccnet_threaded_rpc.get_orgs_by_user(user.email) if org: if org[0].creator == user.email: messages.error( request, _(u'Failed to delete: the user is an organization creator') ) return HttpResponseRedirect(next) org_id = org[0].org_id org_repos = seafile_api.get_org_owned_repo_list(org_id, user.email) for repo in org_repos: seafile_api.remove_repo(repo.id) user.delete() messages.success(request, _(u'Successfully deleted %s') % user.username) except User.DoesNotExist: messages.error(request, _(u'Failed to delete: the user does not exist')) return HttpResponseRedirect(next)
def delete(self): """ When delete user, we should also delete group relationships. """ if self.source == "DB": source = "DB" else: source = "LDAP" owned_repos = [] orgs = ccnet_threaded_rpc.get_orgs_by_user(self.username) if orgs: for org in orgs: owned_repos += seafile_api.get_org_owned_repo_list( org.org_id, self.username) else: owned_repos += seafile_api.get_owned_repo_list(self.username) for r in owned_repos: seafile_api.remove_repo(r.id) clear_token(self.username) # remove current user from joined groups ccnet_api.remove_group_user(self.username) ccnet_api.remove_emailuser(source, self.username) Profile.objects.delete_profile_by_user(self.username)
def org_repo_delete(request, repo_id): """Delete a repo. """ if request.method != 'POST': raise Http404 next = request.META.get('HTTP_REFERER', None) if not next: next = reverse("org_repo_admin") repo = seafile_api.get_repo(repo_id) if not repo: raise Http404 repo_name = repo.name org_id = request.user.org.org_id if not is_org_repo(org_id, repo_id): messages.error(request, 'Failed to delete, library does not exist.') return HttpResponseRedirect(next) usernames = seaserv.get_related_users_by_org_repo(org_id, repo_id) repo_owner = seafile_api.get_org_repo_owner(repo_id) seafile_api.remove_repo(repo_id) repo_deleted.send(sender=None, org_id=org_id, usernames=usernames, repo_owner=repo_owner, repo_id=repo_id, repo_name=repo_name) messages.success(request, _(u'Successfully deleted.')) return HttpResponseRedirect(next)
def delete(self, request, group_id): """ Delete an address book group. """ group_id = int(group_id) group = ccnet_api.get_group(group_id) if not group: return Response({'success': True}) try: has_repo = seafile_api.if_group_has_group_owned_repo(group_id) child_groups = ccnet_api.get_child_groups(group_id) except Exception as e: logger.error(e) error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) if has_repo: error_msg = _('There are libraries in this department.') return api_error(status.HTTP_403_FORBIDDEN, error_msg) if len(child_groups) > 0: error_msg = _('There are sub-departments in this department.') return api_error(status.HTTP_403_FORBIDDEN, error_msg) owner = '%s@seafile_group' % group_id workspace = Workspaces.objects.get_workspace_by_owner(owner) if workspace: try: seafile_api.remove_repo(workspace.repo_id) workspace.delete() except Exception as e: logger.error(e) error_msg = _('Internal Server Error') return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) try: ret_code = ccnet_api.remove_group(group_id) except Exception as e: logger.error(e) error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) if ret_code == -1: error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) # send admin operation log signal group_owner = group.creator_name group_name = group.group_name admin_op_detail = { "id": group_id, "name": group_name, "owner": group_owner, } admin_operation.send(sender=None, admin_name=request.user.username, operation=GROUP_DELETE, detail=admin_op_detail) return Response({'success': True})
def test_to_dict(self): wiki = Wiki.objects.add('new wiki', self.user.username) d = wiki.to_dict() assert 'published/new-wiki/' in d['link'] assert 'new-wiki' == d['slug'] assert 'T' in d['created_at'] assert 'T' in d['updated_at'] seafile_api.remove_repo(wiki.repo_id)
def repo_remove(request, repo_id): if not request.is_ajax(): raise Http404 content_type = 'application/json; charset=utf-8' result = {} if get_system_default_repo_id() == repo_id: result['error'] = _(u'System library can not be deleted.') return HttpResponse(json.dumps(result), status=403, content_type=content_type) repo = get_repo(repo_id) if not repo: result['error'] = _(u'Library does not exist') return HttpResponse(json.dumps(result), status=400, content_type=content_type) user = request.user.username org, base_template = check_and_get_org_by_repo(repo_id, user) if org: # Remove repo in org context, only repo owner or org staff can # perform this operation. if request.user.is_staff or org.is_staff or \ is_org_repo_owner(org.org_id, repo_id, user): # Must get related useres before remove the repo usernames = get_related_users_by_org_repo(org.org_id, repo_id) seafile_api.remove_repo(repo_id) repo_deleted.send(sender=None, org_id=org.org_id, usernames=usernames, repo_owner=user, repo_id=repo_id, repo_name=repo.name, ) result['success'] = True return HttpResponse(json.dumps(result), content_type=content_type) else: result['error'] = _(u'Permission denied.') return HttpResponse(json.dumps(result), status=400, content_type=content_type) else: # Remove repo in personal context, only repo owner or site staff can # perform this operation. if validate_owner(request, repo_id) or request.user.is_staff: usernames = get_related_users_by_repo(repo_id) seafile_api.remove_repo(repo_id) repo_deleted.send(sender=None, org_id=-1, usernames=usernames, repo_owner=user, repo_id=repo_id, repo_name=repo.name, ) result['success'] = True return HttpResponse(json.dumps(result), content_type=content_type) else: result['error'] = _(u'Permission denied.') return HttpResponse(json.dumps(result), status=400, content_type=content_type)
def test_get_all_tag_when_repo_deleted(self): resp = self.client.post(self.url_create, { "tag_names": self.tag_name, "repo_id": self.repo.id, "commit_id": "" }) assert resp.status_code in [200, 201] seafile_api.remove_repo(self.repo.id) resp = self.client.get(self.url) assert resp.status_code in [200, 201]
def repo(): repo = create_and_get_repo( 'testrepo测试-{}'.format(randstring(10)), '', USER, passwd=None ) try: 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)
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)
def delete(self, request, repo_id, format=None): username = request.user.username repo = seafile_api.get_repo(repo_id) if not repo: return api_error(status.HTTP_400_BAD_REQUEST, \ 'Library does not exist.') if not seafile_api.is_repo_owner(username, repo_id): return api_error(status.HTTP_403_FORBIDDEN, \ 'Only library owner can perform this operation.') seafile_api.remove_repo(repo_id) return Response('success', status=status.HTTP_200_OK)
def tearDown(self): # remove common user's repo and group self.remove_group() self.remove_repo() # remove admin user's group ccnet_threaded_rpc.remove_group(self.admin_group_1_id, self.admin.email) # remove admin user's another group ccnet_threaded_rpc.remove_group(self.admin_group_2_id, self.admin.email) # remove amdin user's repo seafile_api.remove_repo(self.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 delete(self): """ When delete user, we should also delete group relationships. """ if self.source == "DB": source = "DB" else: source = "LDAP" username = self.username orgs = ccnet_threaded_rpc.get_orgs_by_user(username) # remove owned repos owned_repos = [] if orgs: for org in orgs: owned_repos += seafile_api.get_org_owned_repo_list( org.org_id, username) else: owned_repos += seafile_api.get_owned_repo_list(username) for r in owned_repos: seafile_api.remove_repo(r.id) # remove shared in repos shared_in_repos = [] if orgs: for org in orgs: org_id = org.org_id shared_in_repos = seafile_api.get_org_share_in_repo_list( org_id, username, -1, -1) for r in shared_in_repos: seafile_api.org_remove_share(org_id, r.repo_id, r.user, username) else: shared_in_repos = seafile_api.get_share_in_repo_list( username, -1, -1) for r in shared_in_repos: seafile_api.remove_share(r.repo_id, r.user, username) clear_token(username) # remove current user from joined groups ccnet_api.remove_group_user(username) ccnet_api.remove_emailuser(source, username) Profile.objects.delete_profile_by_user(username)
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 delete(self, request, repo_id): repo = seafile_api.get_repo(repo_id) if not repo: # for case of `seafile-data` has been damaged # no `repo object` will be returned from seafile api # delete the database record anyway try: seafile_api.remove_repo(repo_id) 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}) # check permission username = request.user.username repo_owner = get_repo_owner(request, repo_id) if username != repo_owner: error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) # check repo status repo_status = repo.status if repo_status != 0: error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) org_id = None if is_org_context(request): org_id = request.user.org.org_id # remove repo seafile_api.remove_repo(repo_id) repo_deleted.send(sender=None, org_id=org_id, operator=username, repo_owner=repo_owner, repo_id=repo_id, repo_name=repo.name) return Response('success', status=status.HTTP_200_OK)
def delete(self, request, repo_id, format=None): """ delete a library Permission checking: 1. only admin can perform this action. """ if get_system_default_repo_id() == repo_id: error_msg = _('System library can not be deleted.') return api_error(status.HTTP_400_BAD_REQUEST, error_msg) try: seafile_api.remove_repo(repo_id) 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})
def delete(self, request, group_id): """ Dismiss a specific group """ group_id = int(group_id) group = ccnet_api.get_group(group_id) if not group: return Response({'success': True}) group_owner = group.creator_name group_name = group.group_name owner = '%s@seafile_group' % group_id workspace = Workspaces.objects.get_workspace_by_owner(owner) if workspace: try: seafile_api.remove_repo(workspace.repo_id) workspace.delete() except Exception as e: logger.error(e) error_msg = _('Internal Server Error') return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) try: ccnet_api.remove_group(group_id) seafile_api.remove_group_repos(group_id) 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": group_id, "name": group_name, "owner": group_owner, } admin_operation.send(sender=None, admin_name=request.user.username, operation=GROUP_DELETE, detail=admin_op_detail) return Response({'success': True})
def user_remove(request, user_id): """Remove user, also remove group relationship.""" try: user = User.objects.get(id=int(user_id)) org = ccnet_threaded_rpc.get_orgs_by_user(user.email) if org: org_id = org[0].org_id org_repos = seafile_api.get_org_owned_repo_list(org_id, user.email) for repo in org_repos: seafile_api.remove_repo(repo.id) user.delete() messages.success(request, _(u'Successfully deleted %s') % user.username) except User.DoesNotExist: messages.error(request, _(u'Failed to delete: the user does not exist')) referer = request.META.get('HTTP_REFERER', None) next = reverse('sys_useradmin') if referer is None else referer return HttpResponseRedirect(next)
def delete(self, request, repo_id, format=None): """ delete a library Permission checking: 1. only admin can perform this action. """ repo = seafile_api.get_repo(repo_id) if not repo: return Response({'success': True}) if get_system_default_repo_id() == repo_id: error_msg = _('System library can not be deleted.') return api_error(status.HTTP_400_BAD_REQUEST, error_msg) try: seafile_api.remove_repo(repo_id) 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})
def delete(self, request, group_id): """ Dismiss a specific group Permission: 1. group owner """ org_id = None if is_org_context(request): org_id = request.user.org.org_id username = request.user.username try: # only group owner can dismiss a group if not is_group_owner(group_id, username): error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) except SearpcError as e: logger.error(e) error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) # if there are dtables in this group, prohibit deletion of groups owner = '%s@seafile_group' % group_id workspace = Workspaces.objects.get_workspace_by_owner(owner) if DTables.objects.filter(workspace=workspace, deleted=False).exists(): error_msg = 'Disable group deletion before deleting table(s).' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) try: seafile_api.remove_repo(workspace.repo_id) workspace.delete() remove_group_common(group_id, username, org_id=org_id) 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})
def delete(self, request, repo_id): 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) # check permission username = request.user.username repo_owner = get_repo_owner(request, repo_id) if username != repo_owner: error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) org_id = None if is_org_context(request): org_id = request.user.org.org_id try: related_users = get_related_users_by_repo(repo_id, org_id) except Exception as e: logger.error(e) related_users = [] # remove repo seafile_api.remove_repo(repo_id) repo_deleted.send(sender=None, org_id=org_id, operator=username, usernames=related_users, repo_owner=repo_owner, repo_id=repo_id, repo_name=repo.name) return Response('success', status=status.HTTP_200_OK)
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 delete(self, request, repo_id, format=None): """ delete a library Permission checking: 1. only admin can perform this action. """ if get_system_default_repo_id() == repo_id: error_msg = _('System library can not be deleted.') return api_error(status.HTTP_400_BAD_REQUEST, error_msg) repo = seafile_api.get_repo(repo_id) if not repo: # for case of `seafile-data` has been damaged # no `repo object` will be returned from seafile api # delete the database record anyway try: seafile_api.remove_repo(repo_id) 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}) repo_name = repo.name repo_owner = seafile_api.get_repo_owner(repo_id) if not repo_owner: repo_owner = seafile_api.get_org_repo_owner(repo_id) try: seafile_api.remove_repo(repo_id) try: org_id = seafile_api.get_org_id_by_repo_id(repo_id) related_usernames = get_related_users_by_repo(repo_id, org_id if org_id > 0 else None) except Exception as e: logger.error(e) org_id = -1 related_usernames = [] # send signal for seafevents repo_deleted.send(sender=None, org_id=-1, operator=request.user.username, usernames=related_usernames, repo_owner=repo_owner, repo_id=repo_id, repo_name=repo.name) 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_DELETE, detail=admin_op_detail) return Response({'success': True})
def remove_repo(self, repo_id=None): if not repo_id: repo_id = self.repo.id return seafile_api.remove_repo(repo_id)
def tearDown(self): CDC.objects.delete_by_repo_id(self.repo.id) Catalog.objects.delete_by_repo_id(self.repo.id) Profile.objects.delete_profile_by_user(self.user) seafile_api.remove_repo(self.repo.id)
def remove_repo(self): return seafile_api.remove_repo(self.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)