revert unnecessary change

lunny · lunny · commit f3d0e5166f06 · 2025-07-17T17:42:44.000-07:00
diff --git a/cmd/admin_user_delete.go b/cmd/admin_user_delete.go
@@ -80,10 +80,5 @@ func runDeleteUser(ctx context.Context, c *cli.Command) error {
 		return fmt.Errorf("the user %s does not match the provided id %d", user.Name, c.Int64("id"))
 	}
 
-	adminUser, err := user_model.GetAdminUser(ctx)
-	if err != nil {
-		return fmt.Errorf("failed to get admin user: %w", err)
-	}
-
-	return user_service.DeleteUser(ctx, adminUser, user, c.Bool("purge"))
+	return user_service.DeleteUser(ctx, user, c.Bool("purge"))
 }
diff --git a/models/issues/pull_list_test.go b/models/issues/pull_list_test.go
@@ -39,9 +39,8 @@ func TestPullRequestList_LoadReviewCommentsCounts(t *testing.T) {
 	reviewComments, err := prs.LoadReviewCommentsCounts(db.DefaultContext)
 	assert.NoError(t, err)
 	assert.Len(t, reviewComments, 2)
-	for _, pr := range prs {
-		assert.Equal(t, 1, reviewComments[pr.IssueID])
-	}
+	assert.Equal(t, 1, reviewComments[prs[0].IssueID])
+	assert.Equal(t, 2, reviewComments[prs[1].IssueID])
 }
 
 func TestPullRequestList_LoadReviews(t *testing.T) {
diff --git a/routers/api/v1/admin/user.go b/routers/api/v1/admin/user.go
@@ -300,7 +300,7 @@ func DeleteUser(ctx *context.APIContext) {
 		return
 	}
 
-	if err := user_service.DeleteUser(ctx, ctx.Doer, ctx.ContextUser, ctx.FormBool("purge")); err != nil {
+	if err := user_service.DeleteUser(ctx, ctx.ContextUser, ctx.FormBool("purge")); err != nil {
 		if repo_model.IsErrUserOwnRepos(err) ||
 			org_model.IsErrUserHasOrgs(err) ||
 			packages_model.IsErrUserOwnPackages(err) ||
diff --git a/routers/api/v1/org/org.go b/routers/api/v1/org/org.go
@@ -421,7 +421,7 @@ func Delete(ctx *context.APIContext) {
 	//   "404":
 	//     "$ref": "#/responses/notFound"
 
-	if err := org.DeleteOrganization(ctx, ctx.Doer, ctx.Org.Organization, false); err != nil {
+	if err := org.DeleteOrganization(ctx, ctx.Org.Organization, false); err != nil {
 		ctx.APIErrorInternal(err)
 		return
 	}
diff --git a/routers/api/v1/repo/migrate.go b/routers/api/v1/repo/migrate.go
@@ -203,7 +203,7 @@ func Migrate(ctx *context.APIContext) {
 		}
 
 		if repo != nil {
-			if errDelete := repo_service.DeleteRepositoryDirectly(ctx, ctx.Doer, repo.ID); errDelete != nil {
+			if errDelete := repo_service.DeleteRepositoryDirectly(ctx, repo.ID); errDelete != nil {
 				log.Error("DeleteRepository: %v", errDelete)
 			}
 		}
diff --git a/routers/web/admin/users.go b/routers/web/admin/users.go
@@ -496,7 +496,7 @@ func DeleteUser(ctx *context.Context) {
 		return
 	}
 
-	if err = user_service.DeleteUser(ctx, ctx.Doer, u, ctx.FormBool("purge")); err != nil {
+	if err = user_service.DeleteUser(ctx, u, ctx.FormBool("purge")); err != nil {
 		switch {
 		case repo_model.IsErrUserOwnRepos(err):
 			ctx.Flash.Error(ctx.Tr("admin.users.still_own_repo"))
diff --git a/routers/web/org/setting.go b/routers/web/org/setting.go
@@ -149,7 +149,7 @@ func SettingsDeleteOrgPost(ctx *context.Context) {
 		return
 	}
 
-	if err := org_service.DeleteOrganization(ctx, ctx.Doer, ctx.Org.Organization, false /* no purge */); err != nil {
+	if err := org_service.DeleteOrganization(ctx, ctx.Org.Organization, false /* no purge */); err != nil {
 		if repo_model.IsErrUserOwnRepos(err) {
 			ctx.JSONError(ctx.Tr("form.org_still_own_repo"))
 		} else if packages_model.IsErrUserOwnPackages(err) {
diff --git a/routers/web/user/setting/account.go b/routers/web/user/setting/account.go
@@ -272,7 +272,7 @@ func DeleteAccount(ctx *context.Context) {
 		return
 	}
 
-	if err := user.DeleteUser(ctx, ctx.Doer, ctx.Doer, false); err != nil {
+	if err := user.DeleteUser(ctx, ctx.Doer, false); err != nil {
 		switch {
 		case repo_model.IsErrUserOwnRepos(err):
 			ctx.Flash.Error(ctx.Tr("form.still_own_repo"))
diff --git a/services/cron/tasks_extended.go b/services/cron/tasks_extended.go
@@ -30,11 +30,7 @@ func registerDeleteInactiveUsers() {
 		OlderThan: time.Minute * time.Duration(setting.Service.ActiveCodeLives),
 	}, func(ctx context.Context, _ *user_model.User, config Config) error {
 		olderThanConfig := config.(*OlderThanConfig)
-		adminUser, err := user_model.GetAdminUser(ctx)
-		if err != nil {
-			return err
-		}
-		return user_service.DeleteInactiveUsers(ctx, adminUser, olderThanConfig.OlderThan)
+		return user_service.DeleteInactiveUsers(ctx, olderThanConfig.OlderThan)
 	})
 }
 
@@ -115,7 +111,7 @@ func registerDeleteMissingRepositories() {
 		RunAtStart: false,
 		Schedule:   "@every 72h",
 	}, func(ctx context.Context, user *user_model.User, _ Config) error {
-		return repo_service.DeleteMissingRepositories(ctx, user)
+		return repo_service.DeleteMissingRepositories(ctx)
 	})
 }
 
diff --git a/services/doctor/repository.go b/services/doctor/repository.go
@@ -7,7 +7,6 @@ import (
 	"context"
 
 	"code.gitea.io/gitea/models/db"
-	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/storage"
 	repo_service "code.gitea.io/gitea/services/repository"
@@ -38,10 +37,6 @@ func deleteOrphanedRepos(ctx context.Context) (int64, error) {
 
 	batchSize := db.MaxBatchInsertSize("repository")
 	var deleted int64
-	adminUser, err := user_model.GetAdminUser(ctx)
-	if err != nil {
-		return deleted, err
-	}
 
 	for {
 		select {
@@ -62,7 +57,7 @@ func deleteOrphanedRepos(ctx context.Context) (int64, error) {
 			}
 
 			for _, id := range ids {
-				if err := repo_service.DeleteRepositoryDirectly(ctx, adminUser, id, true); err != nil {
+				if err := repo_service.DeleteRepositoryDirectly(ctx, id, true); err != nil {
 					return deleted, err
 				}
 				deleted++
diff --git a/services/org/org.go b/services/org/org.go
@@ -47,15 +47,15 @@ func deleteOrganization(ctx context.Context, org *org_model.Organization) error
 }
 
 // DeleteOrganization completely and permanently deletes everything of organization.
-func DeleteOrganization(ctx context.Context, doer *user_model.User, org *org_model.Organization, purge bool) error {
+func DeleteOrganization(ctx context.Context, org *org_model.Organization, purge bool) error {
 	ctx, committer, err := db.TxContext(ctx)
 	if err != nil {
 		return err
 	}
 	defer committer.Close()
 
 	if purge {
-		err := repo_service.DeleteOwnerRepositoriesDirectly(ctx, doer, org.AsUser())
+		err := repo_service.DeleteOwnerRepositoriesDirectly(ctx, org.AsUser())
 		if err != nil {
 			return err
 		}
diff --git a/services/org/org_test.go b/services/org/org_test.go
@@ -22,18 +22,17 @@ func TestMain(m *testing.M) {
 func TestDeleteOrganization(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	org := unittest.AssertExistsAndLoadBean(t, &organization.Organization{ID: 6})
-	user1 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1})
-	assert.NoError(t, DeleteOrganization(db.DefaultContext, user1, org, false))
+	assert.NoError(t, DeleteOrganization(db.DefaultContext, org, false))
 	unittest.AssertNotExistsBean(t, &organization.Organization{ID: 6})
 	unittest.AssertNotExistsBean(t, &organization.OrgUser{OrgID: 6})
 	unittest.AssertNotExistsBean(t, &organization.Team{OrgID: 6})
 
 	org = unittest.AssertExistsAndLoadBean(t, &organization.Organization{ID: 3})
-	err := DeleteOrganization(db.DefaultContext, user1, org, false)
+	err := DeleteOrganization(db.DefaultContext, org, false)
 	assert.Error(t, err)
 	assert.True(t, repo_model.IsErrUserOwnRepos(err))
 
 	user := unittest.AssertExistsAndLoadBean(t, &organization.Organization{ID: 5})
-	assert.Error(t, DeleteOrganization(db.DefaultContext, user1, user, false))
+	assert.Error(t, DeleteOrganization(db.DefaultContext, user, false))
 	unittest.CheckConsistencyFor(t, &user_model.User{}, &organization.Team{})
 }
diff --git a/services/org/team_test.go b/services/org/team_test.go
@@ -280,10 +280,8 @@ func TestIncludesAllRepositoriesTeams(t *testing.T) {
 		testTeamRepositories(team.ID, teamRepos[i])
 	}
 
-	user1 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1})
-
 	// Remove repo and check teams repositories.
-	assert.NoError(t, repo_service.DeleteRepositoryDirectly(db.DefaultContext, user1, repoIDs[0]), "DeleteRepository")
+	assert.NoError(t, repo_service.DeleteRepositoryDirectly(db.DefaultContext, repoIDs[0]), "DeleteRepository")
 	teamRepos[0] = repoIDs[1:]
 	teamRepos[1] = repoIDs[1:]
 	teamRepos[3] = repoIDs[1:3]
@@ -295,8 +293,8 @@ func TestIncludesAllRepositoriesTeams(t *testing.T) {
 	// Wipe created items.
 	for i, rid := range repoIDs {
 		if i > 0 { // first repo already deleted.
-			assert.NoError(t, repo_service.DeleteRepositoryDirectly(db.DefaultContext, user1, rid), "DeleteRepository %d", i)
+			assert.NoError(t, repo_service.DeleteRepositoryDirectly(db.DefaultContext, rid), "DeleteRepository %d", i)
 		}
 	}
-	assert.NoError(t, DeleteOrganization(db.DefaultContext, user1, org, false), "DeleteOrganization")
+	assert.NoError(t, DeleteOrganization(db.DefaultContext, org, false), "DeleteOrganization")
 }
diff --git a/services/repository/check.go b/services/repository/check.go
@@ -12,7 +12,6 @@ import (
 	"code.gitea.io/gitea/models/db"
 	repo_model "code.gitea.io/gitea/models/repo"
 	system_model "code.gitea.io/gitea/models/system"
-	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/git"
 	"code.gitea.io/gitea/modules/log"
 	repo_module "code.gitea.io/gitea/modules/repository"
@@ -145,7 +144,7 @@ func gatherMissingRepoRecords(ctx context.Context) (repo_model.RepositoryList, e
 }
 
 // DeleteMissingRepositories deletes all repository records that lost Git files.
-func DeleteMissingRepositories(ctx context.Context, doer *user_model.User) error {
+func DeleteMissingRepositories(ctx context.Context) error {
 	repos, err := gatherMissingRepoRecords(ctx)
 	if err != nil {
 		return err
@@ -162,7 +161,7 @@ func DeleteMissingRepositories(ctx context.Context, doer *user_model.User) error
 		default:
 		}
 		log.Trace("Deleting %d/%d...", repo.OwnerID, repo.ID)
-		if err := DeleteRepositoryDirectly(ctx, doer, repo.ID); err != nil {
+		if err := DeleteRepositoryDirectly(ctx, repo.ID); err != nil {
 			log.Error("Failed to DeleteRepository %-v: Error: %v", repo, err)
 			if err2 := system_model.CreateRepositoryNotice("Failed to DeleteRepository %s [%d]: Error: %v", repo.FullName(), repo.ID, err); err2 != nil {
 				log.Error("CreateRepositoryNotice: %v", err)
diff --git a/services/repository/create.go b/services/repository/create.go
@@ -263,7 +263,7 @@ func CreateRepositoryDirectly(ctx context.Context, doer, owner *user_model.User,
 	defer func() {
 		if err != nil {
 			// we can not use the ctx because it maybe canceled or timeout
-			cleanupRepository(doer, repo.ID)
+			cleanupRepository(repo.ID)
 		}
 	}()
 
@@ -458,8 +458,8 @@ func createRepositoryInDB(ctx context.Context, doer, u *user_model.User, repo *r
 	return nil
 }
 
-func cleanupRepository(doer *user_model.User, repoID int64) {
-	if errDelete := DeleteRepositoryDirectly(db.DefaultContext, doer, repoID); errDelete != nil {
+func cleanupRepository(repoID int64) {
+	if errDelete := DeleteRepositoryDirectly(db.DefaultContext, repoID); errDelete != nil {
 		log.Error("cleanupRepository failed: %v", errDelete)
 		// add system notice
 		if err := system_model.CreateRepositoryNotice("DeleteRepositoryDirectly failed when cleanup repository: %v", errDelete); err != nil {
diff --git a/services/repository/create_test.go b/services/repository/create_test.go
@@ -35,7 +35,7 @@ func TestCreateRepositoryDirectly(t *testing.T) {
 
 	unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{OwnerName: user2.Name, Name: createdRepo.Name})
 
-	err = DeleteRepositoryDirectly(db.DefaultContext, user2, createdRepo.ID)
+	err = DeleteRepositoryDirectly(db.DefaultContext, createdRepo.ID)
 	assert.NoError(t, err)
 
 	// a failed creating because some mock data
diff --git a/services/repository/delete.go b/services/repository/delete.go
@@ -49,7 +49,7 @@ func deleteDBRepository(ctx context.Context, repoID int64) error {
 
 // DeleteRepository deletes a repository for a user or organization.
 // make sure if you call this func to close open sessions (sqlite will otherwise get a deadlock)
-func DeleteRepositoryDirectly(ctx context.Context, doer *user_model.User, repoID int64, ignoreOrgTeams ...bool) error {
+func DeleteRepositoryDirectly(ctx context.Context, repoID int64, ignoreOrgTeams ...bool) error {
 	ctx, committer, err := db.TxContext(ctx)
 	if err != nil {
 		return err
@@ -370,7 +370,7 @@ func DeleteRepositoryDirectly(ctx context.Context, doer *user_model.User, repoID
 }
 
 // DeleteOwnerRepositoriesDirectly calls DeleteRepositoryDirectly for all repos of the given owner
-func DeleteOwnerRepositoriesDirectly(ctx context.Context, doer, owner *user_model.User) error {
+func DeleteOwnerRepositoriesDirectly(ctx context.Context, owner *user_model.User) error {
 	for {
 		repos, _, err := repo_model.GetUserRepositories(ctx, repo_model.SearchRepoOptions{
 			ListOptions: db.ListOptions{
@@ -388,7 +388,7 @@ func DeleteOwnerRepositoriesDirectly(ctx context.Context, doer, owner *user_mode
 			break
 		}
 		for _, repo := range repos {
-			if err := DeleteRepositoryDirectly(ctx, doer, repo.ID); err != nil {
+			if err := DeleteRepositoryDirectly(ctx, repo.ID); err != nil {
 				return fmt.Errorf("unable to delete repository %s for %s[%d]. Error: %w", repo.Name, owner.Name, owner.ID, err)
 			}
 		}
diff --git a/services/repository/delete_test.go b/services/repository/delete_test.go
@@ -51,5 +51,5 @@ func TestDeleteOwnerRepositoriesDirectly(t *testing.T) {
 
 	user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
 
-	assert.NoError(t, repo_service.DeleteOwnerRepositoriesDirectly(db.DefaultContext, user, user))
+	assert.NoError(t, repo_service.DeleteOwnerRepositoriesDirectly(db.DefaultContext, user))
 }
diff --git a/services/repository/fork.go b/services/repository/fork.go
@@ -124,7 +124,7 @@ func ForkRepository(ctx context.Context, doer, owner *user_model.User, opts Fork
 	defer func() {
 		if err != nil {
 			// we can not use the ctx because it maybe canceled or timeout
-			cleanupRepository(doer, repo.ID)
+			cleanupRepository(repo.ID)
 		}
 	}()
 
diff --git a/services/repository/fork_test.go b/services/repository/fork_test.go
@@ -69,7 +69,7 @@ func TestForkRepositoryCleanup(t *testing.T) {
 	assert.NoError(t, err)
 	assert.True(t, exist)
 
-	err = DeleteRepositoryDirectly(db.DefaultContext, user2, fork.ID)
+	err = DeleteRepositoryDirectly(db.DefaultContext, fork.ID)
 	assert.NoError(t, err)
 
 	// a failed creating because some mock data
diff --git a/services/repository/repository.go b/services/repository/repository.go
@@ -69,7 +69,7 @@ func DeleteRepository(ctx context.Context, doer *user_model.User, repo *repo_mod
 		notify_service.DeleteRepository(ctx, doer, repo)
 	}
 
-	return DeleteRepositoryDirectly(ctx, doer, repo.ID)
+	return DeleteRepositoryDirectly(ctx, repo.ID)
 }
 
 // PushCreateRepo creates a repository when a new repository is pushed to an appropriate namespace
diff --git a/services/repository/template.go b/services/repository/template.go
@@ -102,7 +102,7 @@ func GenerateRepository(ctx context.Context, doer, owner *user_model.User, templ
 	defer func() {
 		if err != nil {
 			// we can not use the ctx because it maybe canceled or timeout
-			cleanupRepository(doer, generateRepo.ID)
+			cleanupRepository(generateRepo.ID)
 		}
 	}()
 
diff --git a/services/user/user.go b/services/user/user.go
@@ -121,7 +121,7 @@ func RenameUser(ctx context.Context, u *user_model.User, newUserName string) err
 // DeleteUser completely and permanently deletes everything of a user,
 // but issues/comments/pulls will be kept and shown as someone has been deleted,
 // unless the user is younger than USER_DELETE_WITH_COMMENTS_MAX_DAYS.
-func DeleteUser(ctx context.Context, doer, u *user_model.User, purge bool) error {
+func DeleteUser(ctx context.Context, u *user_model.User, purge bool) error {
 	if u.IsOrganization() {
 		return fmt.Errorf("%s is an organization not a user", u.Name)
 	}
@@ -160,7 +160,7 @@ func DeleteUser(ctx context.Context, doer, u *user_model.User, purge bool) error
 		//
 		// An alternative option here would be write a DeleteAllRepositoriesForUserID function which would delete all of the repos
 		// but such a function would likely get out of date
-		err := repo_service.DeleteOwnerRepositoriesDirectly(ctx, doer, u)
+		err := repo_service.DeleteOwnerRepositoriesDirectly(ctx, u)
 		if err != nil {
 			return err
 		}
@@ -190,7 +190,7 @@ func DeleteUser(ctx context.Context, doer, u *user_model.User, purge bool) error
 			for _, org := range orgs {
 				if err := org_service.RemoveOrgUser(ctx, org, u); err != nil {
 					if organization.IsErrLastOrgOwner(err) {
-						err = org_service.DeleteOrganization(ctx, doer, org, true)
+						err = org_service.DeleteOrganization(ctx, org, true)
 						if err != nil {
 							return fmt.Errorf("unable to delete organization %d: %w", org.ID, err)
 						}
@@ -281,15 +281,15 @@ func DeleteUser(ctx context.Context, doer, u *user_model.User, purge bool) error
 }
 
 // DeleteInactiveUsers deletes all inactive users and their email addresses.
-func DeleteInactiveUsers(ctx context.Context, doer *user_model.User, olderThan time.Duration) error {
+func DeleteInactiveUsers(ctx context.Context, olderThan time.Duration) error {
 	inactiveUsers, err := user_model.GetInactiveUsers(ctx, olderThan)
 	if err != nil {
 		return err
 	}
 
 	// FIXME: should only update authorized_keys file once after all deletions.
 	for _, u := range inactiveUsers {
-		if err = DeleteUser(ctx, doer, u, false); err != nil {
+		if err = DeleteUser(ctx, u, false); err != nil {
 			// Ignore inactive users that were ever active but then were set inactive by admin
 			if repo_model.IsErrUserOwnRepos(err) || organization.IsErrUserHasOrgs(err) || packages_model.IsErrUserOwnPackages(err) {
 				log.Warn("Inactive user %q has repositories, organizations or packages, skipping deletion: %v", u.Name, err)
diff --git a/services/user/user_test.go b/services/user/user_test.go
diff --git a/tests/integration/api_repo_test.go b/tests/integration/api_repo_test.go
diff --git a/tests/integration/ephemeral_actions_runner_deletion_test.go b/tests/integration/ephemeral_actions_runner_deletion_test.go
diff --git a/tests/integration/git_push_test.go b/tests/integration/git_push_test.go
diff --git a/tests/integration/pull_compare_test.go b/tests/integration/pull_compare_test.go
diff --git a/tests/integration/repo_test.go b/tests/integration/repo_test.go

Original file line number	Diff line number	Diff line change
`@@ -80,10 +80,5 @@ func runDeleteUser(ctx context.Context, c *cli.Command) error {`
`80`	`80`	`return fmt.Errorf("the user %s does not match the provided id %d", user.Name, c.Int64("id"))`
`81`	`81`	`}`
`82`	`82`
`83`		`- adminUser, err := user_model.GetAdminUser(ctx)`
`84`		`- if err != nil {`
`85`		`- return fmt.Errorf("failed to get admin user: %w", err)`
`86`		`- }`
`87`		`-`
`88`		`- return user_service.DeleteUser(ctx, adminUser, user, c.Bool("purge"))`
	`83`	`+ return user_service.DeleteUser(ctx, user, c.Bool("purge"))`
`89`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -300,7 +300,7 @@ func DeleteUser(ctx *context.APIContext) {`
`300`	`300`	`return`
`301`	`301`	`}`
`302`	`302`
`303`		`- if err := user_service.DeleteUser(ctx, ctx.Doer, ctx.ContextUser, ctx.FormBool("purge")); err != nil {`
	`303`	`+ if err := user_service.DeleteUser(ctx, ctx.ContextUser, ctx.FormBool("purge")); err != nil {`
`304`	`304`	`if repo_model.IsErrUserOwnRepos(err) \|\|`
`305`	`305`	`org_model.IsErrUserHasOrgs(err) \|\|`
`306`	`306`	`packages_model.IsErrUserOwnPackages(err) \|\|`
Original file line number	Diff line number	Diff line change
`@@ -421,7 +421,7 @@ func Delete(ctx *context.APIContext) {`
`421`	`421`	`// "404":`
`422`	`422`	`// "$ref": "#/responses/notFound"`
`423`	`423`
`424`		`- if err := org.DeleteOrganization(ctx, ctx.Doer, ctx.Org.Organization, false); err != nil {`
	`424`	`+ if err := org.DeleteOrganization(ctx, ctx.Org.Organization, false); err != nil {`
`425`	`425`	`ctx.APIErrorInternal(err)`
`426`	`426`	`return`
`427`	`427`	`}`
Original file line number	Diff line number	Diff line change
`@@ -203,7 +203,7 @@ func Migrate(ctx *context.APIContext) {`
`203`	`203`	`}`
`204`	`204`
`205`	`205`	`if repo != nil {`
`206`		`- if errDelete := repo_service.DeleteRepositoryDirectly(ctx, ctx.Doer, repo.ID); errDelete != nil {`
	`206`	`+ if errDelete := repo_service.DeleteRepositoryDirectly(ctx, repo.ID); errDelete != nil {`
`207`	`207`	`log.Error("DeleteRepository: %v", errDelete)`
`208`	`208`	`}`
`209`	`209`	`}`
Original file line number	Diff line number	Diff line change
`@@ -496,7 +496,7 @@ func DeleteUser(ctx *context.Context) {`
`496`	`496`	`return`
`497`	`497`	`}`
`498`	`498`
`499`		`- if err = user_service.DeleteUser(ctx, ctx.Doer, u, ctx.FormBool("purge")); err != nil {`
	`499`	`+ if err = user_service.DeleteUser(ctx, u, ctx.FormBool("purge")); err != nil {`
`500`	`500`	`switch {`
`501`	`501`	`case repo_model.IsErrUserOwnRepos(err):`
`502`	`502`	`ctx.Flash.Error(ctx.Tr("admin.users.still_own_repo"))`
Original file line number	Diff line number	Diff line change
`@@ -149,7 +149,7 @@ func SettingsDeleteOrgPost(ctx *context.Context) {`
`149`	`149`	`return`
`150`	`150`	`}`
`151`	`151`
`152`		`- if err := org_service.DeleteOrganization(ctx, ctx.Doer, ctx.Org.Organization, false /* no purge */); err != nil {`
	`152`	`+ if err := org_service.DeleteOrganization(ctx, ctx.Org.Organization, false /* no purge */); err != nil {`
`153`	`153`	`if repo_model.IsErrUserOwnRepos(err) {`
`154`	`154`	`ctx.JSONError(ctx.Tr("form.org_still_own_repo"))`
`155`	`155`	`} else if packages_model.IsErrUserOwnPackages(err) {`
Original file line number	Diff line number	Diff line change
`@@ -272,7 +272,7 @@ func DeleteAccount(ctx *context.Context) {`
`272`	`272`	`return`
`273`	`273`	`}`
`274`	`274`
`275`		`- if err := user.DeleteUser(ctx, ctx.Doer, ctx.Doer, false); err != nil {`
	`275`	`+ if err := user.DeleteUser(ctx, ctx.Doer, false); err != nil {`
`276`	`276`	`switch {`
`277`	`277`	`case repo_model.IsErrUserOwnRepos(err):`
`278`	`278`	`ctx.Flash.Error(ctx.Tr("form.still_own_repo"))`