2024-05-24 13:28:15 +02:00
// Copyright 2024 The Forgejo Authors. All rights reserved.
2021-11-18 18:42:27 +01:00
// Copyright 2021 The Gitea Authors. All rights reserved.
2022-11-27 19:20:29 +01:00
// SPDX-License-Identifier: MIT
2021-11-18 18:42:27 +01:00
package user
import (
"context"
"fmt"
2023-05-21 17:13:47 +02:00
"os"
"strings"
2021-11-18 18:42:27 +01:00
"time"
"code.gitea.io/gitea/models"
2021-12-10 09:14:24 +01:00
asymkey_model "code.gitea.io/gitea/models/asymkey"
2021-11-18 18:42:27 +01:00
"code.gitea.io/gitea/models/db"
2022-03-29 08:29:02 +02:00
"code.gitea.io/gitea/models/organization"
2022-03-30 10:42:47 +02:00
packages_model "code.gitea.io/gitea/models/packages"
2021-12-10 02:27:50 +01:00
repo_model "code.gitea.io/gitea/models/repo"
2022-10-17 01:29:26 +02:00
system_model "code.gitea.io/gitea/models/system"
2021-11-18 18:42:27 +01:00
user_model "code.gitea.io/gitea/models/user"
2022-07-14 09:22:09 +02:00
"code.gitea.io/gitea/modules/eventsource"
2021-11-22 16:21:55 +01:00
"code.gitea.io/gitea/modules/log"
2022-07-14 09:22:09 +02:00
"code.gitea.io/gitea/modules/setting"
2021-11-18 18:42:27 +01:00
"code.gitea.io/gitea/modules/storage"
"code.gitea.io/gitea/modules/util"
2023-05-21 17:13:47 +02:00
"code.gitea.io/gitea/services/agit"
2023-10-19 15:16:11 +02:00
org_service "code.gitea.io/gitea/services/org"
2022-07-14 09:22:09 +02:00
"code.gitea.io/gitea/services/packages"
2023-05-21 17:13:47 +02:00
container_service "code.gitea.io/gitea/services/packages/container"
2023-09-08 06:51:15 +02:00
repo_service "code.gitea.io/gitea/services/repository"
2021-11-18 18:42:27 +01:00
)
2023-03-14 08:45:21 +01:00
// RenameUser renames a user
func RenameUser ( ctx context . Context , u * user_model . User , newUserName string ) error {
2023-05-21 17:13:47 +02:00
// Non-local users are not allowed to change their username.
if ! u . IsOrganization ( ) && ! u . IsLocal ( ) {
return user_model . ErrUserIsNotLocal {
UID : u . ID ,
Name : u . Name ,
}
}
if newUserName == u . Name {
2024-02-04 14:29:09 +01:00
return nil
2023-05-21 17:13:47 +02:00
}
if err := user_model . IsUsableUsername ( newUserName ) ; err != nil {
return err
}
onlyCapitalization := strings . EqualFold ( newUserName , u . Name )
oldUserName := u . Name
if onlyCapitalization {
u . Name = newUserName
if err := user_model . UpdateUserCols ( ctx , u , "name" ) ; err != nil {
u . Name = oldUserName
return err
}
2023-09-16 16:39:12 +02:00
return repo_model . UpdateRepositoryOwnerNames ( ctx , u . ID , newUserName )
2023-05-21 17:13:47 +02:00
}
2023-03-14 08:45:21 +01:00
ctx , committer , err := db . TxContext ( ctx )
if err != nil {
return err
}
defer committer . Close ( )
2023-05-21 17:13:47 +02:00
isExist , err := user_model . IsUserExist ( ctx , u . ID , newUserName )
if err != nil {
2023-03-14 08:45:21 +01:00
return err
}
2023-05-21 17:13:47 +02:00
if isExist {
return user_model . ErrUserAlreadyExist {
Name : newUserName ,
}
}
if err = repo_model . UpdateRepositoryOwnerName ( ctx , oldUserName , newUserName ) ; err != nil {
return err
}
if err = user_model . NewUserRedirect ( ctx , u . ID , oldUserName , newUserName ) ; err != nil {
return err
}
if err := agit . UserNameChanged ( ctx , u , n ewUserName ) ; err != nil {
return err
}
if err := container_service . UpdateRepositoryNames ( ctx , u , newUserName ) ; err != nil {
return err
}
u . Name = newUserName
u . LowerName = strings . ToLower ( newUserName )
if err := user_model . UpdateUserCols ( ctx , u , "name" , "lower_name" ) ; err != nil {
u . Name = oldUserName
u . LowerName = strings . ToLower ( oldUserName )
2023-03-14 08:45:21 +01:00
return err
}
2023-05-21 17:13:47 +02:00
// Do not fail if directory does not exist
if err = util . Rename ( user_model . UserPath ( oldUserName ) , user_model . UserPath ( newUserName ) ) ; err != nil && ! os . IsNotExist ( err ) {
u . Name = oldUserName
u . LowerName = strings . ToLower ( oldUserName )
return fmt . Errorf ( "rename user directory: %w" , err )
}
if err = committer . Commit ( ) ; err != nil {
u . Name = oldUserName
u . LowerName = strings . ToLower ( oldUserName )
if err2 := util . Rename ( user_model . UserPath ( newUserName ) , user_model . UserPath ( oldUserName ) ) ; err2 != nil && ! os . IsNotExist ( err2 ) {
log . Critical ( "Unable to rollback directory change during failed username change from: %s to: %s. DB Error: %v. Filesystem Error: %v" , oldUserName , newUserName , err , err2 )
return fmt . Errorf ( "failed to rollback directory change during failed username change from: %s to: %s. DB Error: %w. Filesystem Error: %v" , oldUserName , newUserName , err , err2 )
}
return err
}
return nil
2023-03-14 08:45:21 +01:00
}
2021-11-18 18:42:27 +01:00
// 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.
2022-07-14 09:22:09 +02:00
func DeleteUser ( ctx context . Context , u * user_model . User , purge bool ) error {
2021-11-18 18:42:27 +01:00
if u . IsOrganization ( ) {
return fmt . Errorf ( "%s is an organization not a user" , u . Name )
}
2024-01-15 07:51:43 +01:00
if user_model . IsLastAdminUser ( ctx , u ) {
return models . ErrDeleteLastAdminUser { UID : u . ID }
}
2022-07-14 09:22:09 +02:00
if purge {
// Disable the user first
// NOTE: This is deliberately not within a transaction as it must disable the user immediately to prevent any further action by the user to be purged.
if err := user_model . UpdateUserCols ( ctx , & user_model . User {
ID : u . ID ,
IsActive : false ,
IsRestricted : true ,
IsAdmin : false ,
ProhibitLogin : true ,
Passwd : "" ,
Salt : "" ,
PasswdHashAlgo : "" ,
MaxRepoCreation : 0 ,
} , "is_active" , "is_restricted" , "is_admin" , "prohibit_login" , "max_repo_creation" , "passwd" , "salt" , "passwd_hash_algo" ) ; err != nil {
return fmt . Errorf ( "unable to disable user: %s[%d] prior to purge. UpdateUserCols: %w" , u . Name , u . ID , err )
}
// Force any logged in sessions to log out
// FIXME: We also need to tell the session manager to log them out too.
eventsource . GetManager ( ) . SendMessage ( u . ID , & eventsource . Event {
Name : "logout" ,
} )
// Delete all repos belonging to this user
// Now this is not within a transaction because there are internal transactions within the DeleteRepository
// BUT: the db will still be consistent even if a number of repos have already been deleted.
// And in fact we want to capture any repositories that are being created in other transactions in the meantime
//
// 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
2023-10-19 15:16:11 +02:00
err := repo_service . DeleteOwnerRepositoriesDirectly ( ctx , u )
if err != nil {
return err
2022-07-14 09:22:09 +02:00
}
// Remove from Organizations and delete last owner organizations
// Now this is not within a transaction because there are internal transactions within the DeleteOrganization
// BUT: the db will still be consistent even if a number of organizations memberships and organizations have already been deleted
// And in fact we want to capture any organization additions that are being created in other transactions in the meantime
//
// An alternative option here would be write a function which would delete all organizations but it seems
// but such a function would likely get out of date
for {
2023-11-24 04:49:41 +01:00
orgs , err := db . Find [ organization . Organization ] ( ctx , organization . FindOrgOptions {
2022-07-14 09:22:09 +02:00
ListOptions : db . ListOptions {
PageSize : repo_model . RepositoryListDefaultPageSize ,
Page : 1 ,
} ,
UserID : u . ID ,
IncludePrivate : true ,
} )
if err != nil {
2022-10-24 21:29:17 +02:00
return fmt . Errorf ( "unable to find org list for %s[%d]. Error: %w" , u . Name , u . ID , err )
2022-07-14 09:22:09 +02:00
}
if len ( orgs ) == 0 {
break
}
for _ , org := range orgs {
2023-10-15 17:46:06 +02:00
if err := models . RemoveOrgUser ( ctx , org . ID , u . ID ) ; err != nil {
2022-07-14 09:22:09 +02:00
if organization . IsErrLastOrgOwner ( err ) {
2023-10-19 15:16:11 +02:00
err = org_service . DeleteOrganization ( ctx , org , true )
if err != nil {
return fmt . Errorf ( "unable to delete organization %d: %w" , org . ID , err )
}
2022-07-14 09:22:09 +02:00
}
if err != nil {
2022-10-24 21:29:17 +02:00
return fmt . Errorf ( "unable to remove user %s[%d] from org %s[%d]. Error: %w" , u . Name , u . ID , org . Name , org . ID , err )
2022-07-14 09:22:09 +02:00
}
}
}
}
// Delete Packages
if setting . Packages . Enabled {
if _ , err := packages . RemoveAllPackages ( ctx , u . ID ) ; err != nil {
return err
}
}
2024-05-24 13:28:15 +02:00
// Delete Federated Users
if setting . Federation . Enabled {
if err := user_model . DeleteFederatedUser ( ctx , u . ID ) ; err != nil {
return err
}
}
2022-07-14 09:22:09 +02:00
}
2023-10-11 06:24:07 +02:00
ctx , committer , err := db . TxContext ( ctx )
2021-11-18 18:42:27 +01:00
if err != nil {
return err
}
2021-12-10 09:14:24 +01:00
defer committer . Close ( )
2021-11-18 18:42:27 +01:00
// Note: A user owns any repository or belongs to any organization
2022-07-14 09:22:09 +02:00
// cannot perform delete operation. This causes a race with the purge above
// however consistency requires that we ensure that this is the case
2021-11-18 18:42:27 +01:00
// Check ownership of repository.
2022-05-20 16:08:52 +02:00
count , err := repo_model . CountRepositories ( ctx , repo_model . CountRepositoryOptions { OwnerID : u . ID } )
2021-11-18 18:42:27 +01:00
if err != nil {
2022-10-24 21:29:17 +02:00
return fmt . Errorf ( "GetRepositoryCount: %w" , err )
2021-11-18 18:42:27 +01:00
} else if count > 0 {
return models . ErrUserOwnRepos { UID : u . ID }
}
// Check membership of organization.
2022-03-29 08:29:02 +02:00
count , err = organization . GetOrganizationCount ( ctx , u )
2021-11-18 18:42:27 +01:00
if err != nil {
2022-10-24 21:29:17 +02:00
return fmt . Errorf ( "GetOrganizationCount: %w" , err )
2021-11-18 18:42:27 +01:00
} else if count > 0 {
return models . ErrUserHasOrgs { UID : u . ID }
}
2022-03-30 10:42:47 +02:00
// Check ownership of packages.
if ownsPackages , err := packages_model . HasOwnerPackages ( ctx , u . ID ) ; err != nil {
2022-10-24 21:29:17 +02:00
return fmt . Errorf ( "HasOwnerPackages: %w" , err )
2022-03-30 10:42:47 +02:00
} else if ownsPackages {
return models . ErrUserOwnPackages { UID : u . ID }
}
2023-02-13 06:11:41 +01:00
if err := deleteUser ( ctx , u , purge ) ; err != nil {
2022-10-24 21:29:17 +02:00
return fmt . Errorf ( "DeleteUser: %w" , err )
2021-11-18 18:42:27 +01:00
}
2021-12-10 09:14:24 +01:00
if err := committer . Commit ( ) ; err != nil {
2021-11-18 18:42:27 +01:00
return err
}
2021-12-10 09:14:24 +01:00
committer . Close ( )
2021-11-18 18:42:27 +01:00
2023-09-25 15:17:37 +02:00
if err = asymkey_model . RewriteAllPublicKeys ( ctx ) ; err != nil {
2021-11-22 16:21:55 +01:00
return err
}
2023-09-25 15:17:37 +02:00
if err = asymkey_model . RewriteAllPrincipalKeys ( ctx ) ; err != nil {
2021-11-22 16:21:55 +01:00
return err
}
2021-11-18 18:42:27 +01:00
// Note: There are something just cannot be roll back,
// so just keep error logs of those operations.
2021-11-24 10:49:20 +01:00
path := user_model . UserPath ( u . Name )
2021-11-18 18:42:27 +01:00
if err := util . RemoveAll ( path ) ; err != nil {
2022-10-24 21:29:17 +02:00
err = fmt . Errorf ( "Failed to RemoveAll %s: %w" , path , err )
2022-10-17 01:29:26 +02:00
_ = system_model . CreateNotice ( ctx , system_model . NoticeTask , fmt . Sprintf ( "delete user '%s': %v" , u . Name , err ) )
2021-11-18 18:42:27 +01:00
return err
}
if u . Avatar != "" {
avatarPath := u . CustomAvatarRelativePath ( )
if err := storage . Avatars . Delete ( avatarPath ) ; err != nil {
2022-10-24 21:29:17 +02:00
err = fmt . Errorf ( "Failed to remove %s: %w" , avatarPath , err )
2022-10-17 01:29:26 +02:00
_ = system_model . CreateNotice ( ctx , system_model . NoticeTask , fmt . Sprintf ( "delete user '%s': %v" , u . Name , err ) )
2021-11-18 18:42:27 +01:00
return err
}
}
return nil
}
// DeleteInactiveUsers deletes all inactive users and email addresses.
func DeleteInactiveUsers ( ctx context . Context , olderThan time . Duration ) error {
2021-11-24 10:49:20 +01:00
users , err := user_model . GetInactiveUsers ( ctx , olderThan )
2021-11-18 18:42:27 +01:00
if err != nil {
return err
}
// FIXME: should only update authorized_keys file once after all deletions.
for _ , u := range users {
select {
case <- ctx . Done ( ) :
return db . ErrCancelledf ( "Before delete inactive user %s" , u . Name )
default :
}
2022-07-14 09:22:09 +02:00
if err := DeleteUser ( ctx , u , false ) ; err != nil {
2021-11-18 18:42:27 +01:00
// Ignore users that were set inactive by admin.
2024-01-15 07:51:43 +01:00
if models . IsErrUserOwnRepos ( err ) || models . IsErrUserHasOrgs ( err ) ||
models . IsErrUserOwnPackages ( err ) || models . IsErrDeleteLastAdminUser ( err ) {
2021-11-18 18:42:27 +01:00
continue
}
return err
}
}
2024-03-29 14:53:56 +01:00
return nil
2021-11-18 18:42:27 +01:00
}