2014-04-10 14:20:58 -04:00
// Copyright 2014 The Gogs Authors. All rights reserved.
2019-01-23 17:30:19 -05:00
// Copyright 2019 The Gitea Authors. All rights reserved.
2014-04-10 14:20:58 -04:00
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
package models
import (
2019-12-15 04:51:28 -05:00
"context"
2014-04-10 14:20:58 -04:00
"crypto/sha256"
2016-12-03 00:49:17 -05:00
"crypto/subtle"
2014-04-10 14:20:58 -04:00
"encoding/hex"
"errors"
"fmt"
2021-11-16 13:18:25 -05:00
"net/url"
2014-04-10 14:20:58 -04:00
"os"
"path/filepath"
2020-02-23 14:52:05 -05:00
"regexp"
2014-04-10 14:20:58 -04:00
"strings"
"time"
2016-07-23 06:58:18 -04:00
"unicode/utf8"
2014-04-10 14:20:58 -04:00
2021-11-17 07:34:35 -05:00
_ "image/jpeg" // Needed for jpeg support
2021-09-19 07:49:59 -04:00
"code.gitea.io/gitea/models/db"
2021-09-24 07:32:56 -04:00
"code.gitea.io/gitea/models/login"
2021-11-09 14:57:58 -05:00
"code.gitea.io/gitea/models/unit"
2021-11-11 02:03:30 -05:00
user_model "code.gitea.io/gitea/models/user"
2021-11-17 04:58:31 -05:00
"code.gitea.io/gitea/modules/auth/openid"
2016-11-10 11:24:48 -05:00
"code.gitea.io/gitea/modules/base"
2019-03-27 05:33:00 -04:00
"code.gitea.io/gitea/modules/git"
2016-11-10 11:24:48 -05:00
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/setting"
2019-02-18 11:00:27 -05:00
"code.gitea.io/gitea/modules/structs"
2019-08-15 10:46:21 -04:00
"code.gitea.io/gitea/modules/timeutil"
2017-10-24 13:36:19 -04:00
"code.gitea.io/gitea/modules/util"
2019-02-18 11:00:27 -05:00
2019-07-07 02:01:01 -04:00
"golang.org/x/crypto/argon2"
"golang.org/x/crypto/bcrypt"
2019-02-18 11:00:27 -05:00
"golang.org/x/crypto/pbkdf2"
2019-07-07 02:01:01 -04:00
"golang.org/x/crypto/scrypt"
2019-06-23 11:22:43 -04:00
"xorm.io/builder"
2021-10-12 14:11:35 -04:00
"xorm.io/xorm"
2014-04-10 14:20:58 -04:00
)
2016-11-28 11:47:46 -05:00
// UserType defines the user type
2014-06-25 00:44:48 -04:00
type UserType int
2014-04-10 14:20:58 -04:00
const (
2016-11-28 11:47:46 -05:00
// UserTypeIndividual defines an individual user
2016-11-07 11:53:22 -05:00
UserTypeIndividual UserType = iota // Historic reason to make it starts at 0.
2016-11-28 11:47:46 -05:00
// UserTypeOrganization defines an organization
2016-11-07 11:53:22 -05:00
UserTypeOrganization
2014-04-10 14:20:58 -04:00
)
2019-07-07 02:01:01 -04:00
const (
algoBcrypt = "bcrypt"
algoScrypt = "scrypt"
algoArgon2 = "argon2"
algoPbkdf2 = "pbkdf2"
2021-02-16 17:37:20 -05:00
)
// AvailableHashAlgorithms represents the available password hashing algorithms
var AvailableHashAlgorithms = [ ] string {
algoPbkdf2 ,
algoArgon2 ,
algoScrypt ,
algoBcrypt ,
}
2019-08-29 10:05:42 -04:00
2021-02-16 17:37:20 -05:00
const (
2019-08-29 10:05:42 -04:00
// EmailNotificationsEnabled indicates that the user would like to receive all email notifications
EmailNotificationsEnabled = "enabled"
// EmailNotificationsOnMention indicates that the user would like to be notified via email when mentioned.
EmailNotificationsOnMention = "onmention"
// EmailNotificationsDisabled indicates that the user would not like to be notified via email.
EmailNotificationsDisabled = "disabled"
2019-07-07 02:01:01 -04:00
)
2014-04-10 14:20:58 -04:00
var (
2016-11-28 11:47:46 -05:00
// ErrUserNameIllegal user name contains illegal characters error
ErrUserNameIllegal = errors . New ( "User name contains illegal characters" )
// ErrLoginSourceNotActived login source is not actived error
2014-05-11 02:12:45 -04:00
ErrLoginSourceNotActived = errors . New ( "Login source is not actived" )
2016-11-28 11:47:46 -05:00
// ErrUnsupportedLoginType login source is unknown error
ErrUnsupportedLoginType = errors . New ( "Login source is unknown" )
2020-02-23 14:52:05 -05:00
// Characters prohibited in a user name (anything except A-Za-z0-9_.-)
alphaDashDotPattern = regexp . MustCompile ( ` [^\w-\.] ` )
2014-04-10 14:20:58 -04:00
)
// User represents the object of individual and member of organization.
type User struct {
2016-07-23 13:08:22 -04:00
ID int64 ` xorm:"pk autoincr" `
2014-12-17 03:26:19 -05:00
LowerName string ` xorm:"UNIQUE NOT NULL" `
Name string ` xorm:"UNIQUE NOT NULL" `
FullName string
2015-12-21 07:24:11 -05:00
// Email is the primary email address (to be used for communication)
2019-08-29 10:05:42 -04:00
Email string ` xorm:"NOT NULL" `
KeepEmailPrivate bool
EmailNotificationsPreference string ` xorm:"VARCHAR(20) NOT NULL DEFAULT 'enabled'" `
Passwd string ` xorm:"NOT NULL" `
2020-09-03 14:58:31 -04:00
PasswdHashAlgo string ` xorm:"NOT NULL DEFAULT 'argon2'" `
2018-09-13 08:04:25 -04:00
// MustChangePassword is an attribute that determines if a user
// is to change his/her password after registration.
MustChangePassword bool ` xorm:"NOT NULL DEFAULT false" `
2021-09-24 07:32:56 -04:00
LoginType login . Type
2018-09-13 08:04:25 -04:00
LoginSource int64 ` xorm:"NOT NULL DEFAULT 0" `
LoginName string
Type UserType
OwnedOrgs [ ] * User ` xorm:"-" `
Repos [ ] * Repository ` xorm:"-" `
Location string
Website string
Rands string ` xorm:"VARCHAR(10)" `
Salt string ` xorm:"VARCHAR(10)" `
Language string ` xorm:"VARCHAR(5)" `
2019-03-18 22:28:10 -04:00
Description string
2016-03-09 19:53:30 -05:00
2019-08-15 10:46:21 -04:00
CreatedUnix timeutil . TimeStamp ` xorm:"INDEX created" `
UpdatedUnix timeutil . TimeStamp ` xorm:"INDEX updated" `
LastLoginUnix timeutil . TimeStamp ` xorm:"INDEX" `
2014-11-21 10:58:08 -05:00
2015-10-25 04:26:26 -04:00
// Remember visibility choice for convenience, true for private
2015-08-28 04:44:04 -04:00
LastRepoVisibility bool
2016-11-27 06:59:12 -05:00
// Maximum repository creation limit, -1 means use global default
2015-12-10 12:48:45 -05:00
MaxRepoCreation int ` xorm:"NOT NULL DEFAULT -1" `
2015-08-28 04:44:04 -04:00
2021-11-09 05:42:58 -05:00
// IsActive true: primary email is activated, user can access Web UI and Git SSH.
// false: an inactive user can only log in Web UI for account operations (ex: activate the account by email), no other access.
IsActive bool ` xorm:"INDEX" `
// the user is a Gitea admin, who can access all repositories and the admin pages.
IsAdmin bool
// true: the user is only allowed to see organizations/repositories that they has explicit rights to.
// (ex: in private Gitea instances user won't be allowed to see even organizations/repositories that are set as public)
IsRestricted bool ` xorm:"NOT NULL DEFAULT false" `
2016-12-30 21:33:30 -05:00
AllowGitHook bool
AllowImportLocal bool // Allow migrate repository by local path
AllowCreateOrganization bool ` xorm:"DEFAULT true" `
2021-11-09 05:42:58 -05:00
// true: the user is not allowed to log in Web UI. Git/SSH access could still be allowed (please refer to Git/SSH access related code/documents)
ProhibitLogin bool ` xorm:"NOT NULL DEFAULT false" `
2014-11-21 10:58:08 -05:00
2015-12-21 07:24:11 -05:00
// Avatar
2014-11-21 10:58:08 -05:00
Avatar string ` xorm:"VARCHAR(2048) NOT NULL" `
AvatarEmail string ` xorm:"NOT NULL" `
UseCustomAvatar bool
2015-12-21 07:24:11 -05:00
// Counters
NumFollowers int
2015-12-21 19:09:28 -05:00
NumFollowing int ` xorm:"NOT NULL DEFAULT 0" `
2015-12-21 07:24:11 -05:00
NumStars int
NumRepos int
2014-06-25 00:44:48 -04:00
2015-12-21 07:24:11 -05:00
// For organization
2019-09-23 16:08:03 -04:00
NumTeams int
NumMembers int
Visibility structs . VisibleType ` xorm:"NOT NULL DEFAULT 0" `
RepoAdminChangeTeamAccess bool ` xorm:"NOT NULL DEFAULT false" `
2016-11-12 21:54:04 -05:00
// Preferences
2020-06-05 16:01:53 -04:00
DiffViewStyle string ` xorm:"NOT NULL DEFAULT ''" `
Theme string ` xorm:"NOT NULL DEFAULT ''" `
KeepActivityPrivate bool ` xorm:"NOT NULL DEFAULT false" `
2014-04-10 14:20:58 -04:00
}
2021-09-19 07:49:59 -04:00
func init ( ) {
db . RegisterModel ( new ( User ) )
}
2020-01-24 14:00:29 -05:00
// SearchOrganizationsOptions options to filter organizations
type SearchOrganizationsOptions struct {
2021-09-24 07:32:56 -04:00
db . ListOptions
2020-01-24 14:00:29 -05:00
All bool
}
2019-04-22 16:40:51 -04:00
// ColorFormat writes a colored string to identify this struct
func ( u * User ) ColorFormat ( s fmt . State ) {
log . ColorFprintf ( s , "%d:%s" ,
log . NewColoredIDValue ( u . ID ) ,
log . NewColoredValue ( u . Name ) )
}
2016-11-28 11:47:46 -05:00
// BeforeUpdate is invoked from XORM before updating this object.
2015-12-10 12:37:53 -05:00
func ( u * User ) BeforeUpdate ( ) {
2015-12-10 12:46:05 -05:00
if u . MaxRepoCreation < - 1 {
u . MaxRepoCreation = - 1
2015-12-10 12:37:53 -05:00
}
2018-01-13 04:45:16 -05:00
// Organization does not need email
u . Email = strings . ToLower ( u . Email )
if ! u . IsOrganization ( ) {
if len ( u . AvatarEmail ) == 0 {
u . AvatarEmail = u . Email
}
}
u . LowerName = strings . ToLower ( u . Name )
u . Location = base . TruncateString ( u . Location , 255 )
u . Website = base . TruncateString ( u . Website , 255 )
u . Description = base . TruncateString ( u . Description , 255 )
2015-12-10 12:37:53 -05:00
}
2019-01-09 12:22:57 -05:00
// AfterLoad is invoked from XORM after filling all the fields of this object.
func ( u * User ) AfterLoad ( ) {
if u . Theme == "" {
u . Theme = setting . UI . DefaultTheme
}
}
2016-11-28 11:47:46 -05:00
// SetLastLogin set time to last login
2016-11-09 05:53:45 -05:00
func ( u * User ) SetLastLogin ( ) {
2019-08-15 10:46:21 -04:00
u . LastLoginUnix = timeutil . TimeStampNow ( )
2016-11-09 05:53:45 -05:00
}
2016-11-28 11:47:46 -05:00
// UpdateDiffViewStyle updates the users diff view style
2016-11-12 21:54:04 -05:00
func ( u * User ) UpdateDiffViewStyle ( style string ) error {
u . DiffViewStyle = style
2017-08-12 10:18:44 -04:00
return UpdateUserCols ( u , "diff_view_style" )
2016-11-12 21:54:04 -05:00
}
2019-01-09 12:22:57 -05:00
// UpdateTheme updates a users' theme irrespective of the site wide theme
func ( u * User ) UpdateTheme ( themeName string ) error {
u . Theme = themeName
return UpdateUserCols ( u , "theme" )
}
2019-07-27 09:15:30 -04:00
// GetEmail returns an noreply email, if the user has set to keep his
2017-01-07 22:12:03 -05:00
// email address private, otherwise the primary email address.
2019-07-27 09:15:30 -04:00
func ( u * User ) GetEmail ( ) string {
2017-01-07 22:12:03 -05:00
if u . KeepEmailPrivate {
return fmt . Sprintf ( "%s@%s" , u . LowerName , setting . Service . NoReplyAddress )
}
return u . Email
}
2021-04-09 04:16:10 -04:00
// GetAllUsers returns a slice of all individual users found in DB.
2020-10-15 22:48:38 -04:00
func GetAllUsers ( ) ( [ ] * User , error ) {
users := make ( [ ] * User , 0 )
2021-09-23 11:45:36 -04:00
return users , db . GetEngine ( db . DefaultContext ) . OrderBy ( "id" ) . Where ( "type = ?" , UserTypeIndividual ) . Find ( & users )
2020-10-15 22:48:38 -04:00
}
2016-11-28 11:47:46 -05:00
// IsLocal returns true if user login type is LoginPlain.
2015-12-10 19:02:57 -05:00
func ( u * User ) IsLocal ( ) bool {
2021-09-24 07:32:56 -04:00
return u . LoginType <= login . Plain
2015-12-10 19:02:57 -05:00
}
2017-02-22 02:14:37 -05:00
// IsOAuth2 returns true if user login type is LoginOAuth2.
func ( u * User ) IsOAuth2 ( ) bool {
2021-09-24 07:32:56 -04:00
return u . LoginType == login . OAuth2
2017-02-22 02:14:37 -05:00
}
2015-11-16 10:14:12 -05:00
// HasForkedRepo checks if user has already forked a repository with given ID.
func ( u * User ) HasForkedRepo ( repoID int64 ) bool {
2016-07-23 13:08:22 -04:00
_ , has := HasForkedRepo ( u . ID , repoID )
2015-11-16 10:14:12 -05:00
return has
}
2017-05-23 20:27:08 -04:00
// MaxCreationLimit returns the number of repositories a user is allowed to create
func ( u * User ) MaxCreationLimit ( ) int {
2015-12-10 12:46:05 -05:00
if u . MaxRepoCreation <= - 1 {
2015-12-10 12:37:53 -05:00
return setting . Repository . MaxCreationLimit
}
return u . MaxRepoCreation
}
2016-11-28 11:47:46 -05:00
// CanCreateRepo returns if user login can create a repository
2020-04-30 11:11:56 -04:00
// NOTE: functions calling this assume a failure due to repository count limit; if new checks are added, those functions should be revised
2015-12-10 12:37:53 -05:00
func ( u * User ) CanCreateRepo ( ) bool {
2017-05-19 23:51:19 -04:00
if u . IsAdmin {
return true
}
2015-12-10 12:46:05 -05:00
if u . MaxRepoCreation <= - 1 {
2015-12-11 15:11:13 -05:00
if setting . Repository . MaxCreationLimit <= - 1 {
2015-12-10 16:27:47 -05:00
return true
}
2015-12-10 12:37:53 -05:00
return u . NumRepos < setting . Repository . MaxCreationLimit
}
return u . NumRepos < u . MaxRepoCreation
}
2016-12-30 21:33:30 -05:00
// CanCreateOrganization returns true if user can create organisation.
func ( u * User ) CanCreateOrganization ( ) bool {
2017-02-14 07:16:00 -05:00
return u . IsAdmin || ( u . AllowCreateOrganization && ! setting . Admin . DisableRegularOrgCreation )
2016-12-30 21:33:30 -05:00
}
2015-11-03 18:40:52 -05:00
// CanEditGitHook returns true if user can edit Git hooks.
func ( u * User ) CanEditGitHook ( ) bool {
2017-09-12 05:25:42 -04:00
return ! setting . DisableGitHooks && ( u . IsAdmin || u . AllowGitHook )
2015-11-03 18:40:52 -05:00
}
// CanImportLocal returns true if user can migrate repository by local path.
func ( u * User ) CanImportLocal ( ) bool {
2021-03-15 17:52:11 -04:00
if ! setting . ImportLocalPaths || u == nil {
2017-01-22 20:19:50 -05:00
return false
}
2015-11-03 18:40:52 -05:00
return u . IsAdmin || u . AllowImportLocal
}
2014-07-26 00:24:27 -04:00
// DashboardLink returns the user dashboard page link.
func ( u * User ) DashboardLink ( ) string {
if u . IsOrganization ( ) {
2021-10-07 14:27:38 -04:00
return u . OrganisationLink ( ) + "/dashboard"
2014-07-26 00:24:27 -04:00
}
2016-11-27 05:14:25 -05:00
return setting . AppSubURL + "/"
2014-07-26 00:24:27 -04:00
}
2015-08-26 09:45:51 -04:00
// HomeLink returns the user or organization home page link.
2014-06-25 00:44:48 -04:00
func ( u * User ) HomeLink ( ) string {
2021-11-16 13:18:25 -05:00
return setting . AppSubURL + "/" + url . PathEscape ( u . Name )
2014-04-10 14:20:58 -04:00
}
2015-09-17 01:54:12 -04:00
2017-02-11 07:57:33 -05:00
// HTMLURL returns the user or organization's full link.
func ( u * User ) HTMLURL ( ) string {
2021-11-16 13:18:25 -05:00
return setting . AppURL + url . PathEscape ( u . Name )
2017-02-11 07:57:33 -05:00
}
2021-04-30 13:25:13 -04:00
// OrganisationLink returns the organization sub page link.
func ( u * User ) OrganisationLink ( ) string {
2021-11-16 13:18:25 -05:00
return setting . AppSubURL + "/org/" + url . PathEscape ( u . Name )
2021-04-30 13:25:13 -04:00
}
2015-09-17 01:54:12 -04:00
// GenerateEmailActivateCode generates an activate code based on user information and given e-mail.
func ( u * User ) GenerateEmailActivateCode ( email string ) string {
code := base . CreateTimeLimitCode (
2020-12-25 04:59:32 -05:00
fmt . Sprintf ( "%d%s%s%s%s" , u . ID , email , u . LowerName , u . Passwd , u . Rands ) ,
2015-09-17 01:54:12 -04:00
setting . Service . ActiveCodeLives , nil )
// Add tail hex username
code += hex . EncodeToString ( [ ] byte ( u . LowerName ) )
return code
}
2016-11-28 11:47:46 -05:00
// GetFollowers returns range of user's followers.
2021-09-24 07:32:56 -04:00
func ( u * User ) GetFollowers ( listOptions db . ListOptions ) ( [ ] * User , error ) {
2021-09-23 11:45:36 -04:00
sess := db . GetEngine ( db . DefaultContext ) .
2018-10-19 12:49:36 -04:00
Where ( "follow.follow_id=?" , u . ID ) .
Join ( "LEFT" , "follow" , "`user`.id=follow.user_id" )
2020-01-24 14:00:29 -05:00
if listOptions . Page != 0 {
2021-09-24 07:32:56 -04:00
sess = db . SetSessionPagination ( sess , & listOptions )
2020-01-24 14:00:29 -05:00
users := make ( [ ] * User , 0 , listOptions . PageSize )
return users , sess . Find ( & users )
}
users := make ( [ ] * User , 0 , 8 )
2015-12-21 07:24:11 -05:00
return users , sess . Find ( & users )
}
2016-11-28 11:47:46 -05:00
// IsFollowing returns true if user is following followID.
2015-12-21 07:24:11 -05:00
func ( u * User ) IsFollowing ( followID int64 ) bool {
2021-11-17 04:58:31 -05:00
return user_model . IsFollowing ( u . ID , followID )
2015-12-21 07:24:11 -05:00
}
// GetFollowing returns range of user's following.
2021-09-24 07:32:56 -04:00
func ( u * User ) GetFollowing ( listOptions db . ListOptions ) ( [ ] * User , error ) {
2021-09-23 11:45:36 -04:00
sess := db . GetEngine ( db . DefaultContext ) .
2018-10-19 12:49:36 -04:00
Where ( "follow.user_id=?" , u . ID ) .
Join ( "LEFT" , "follow" , "`user`.id=follow.follow_id" )
2020-01-24 14:00:29 -05:00
if listOptions . Page != 0 {
2021-09-24 07:32:56 -04:00
sess = db . SetSessionPagination ( sess , & listOptions )
2020-01-24 14:00:29 -05:00
users := make ( [ ] * User , 0 , listOptions . PageSize )
return users , sess . Find ( & users )
}
users := make ( [ ] * User , 0 , 8 )
2015-12-21 07:24:11 -05:00
return users , sess . Find ( & users )
}
2014-04-10 14:20:58 -04:00
// NewGitSig generates and returns the signature of given user.
2014-06-25 00:44:48 -04:00
func ( u * User ) NewGitSig ( ) * git . Signature {
2014-04-10 14:20:58 -04:00
return & git . Signature {
2019-01-24 09:12:17 -05:00
Name : u . GitName ( ) ,
2019-07-27 09:15:30 -04:00
Email : u . GetEmail ( ) ,
2014-04-10 14:20:58 -04:00
When : time . Now ( ) ,
}
}
2019-07-07 02:01:01 -04:00
func hashPassword ( passwd , salt , algo string ) string {
var tempPasswd [ ] byte
switch algo {
case algoBcrypt :
tempPasswd , _ = bcrypt . GenerateFromPassword ( [ ] byte ( passwd ) , bcrypt . DefaultCost )
return string ( tempPasswd )
case algoScrypt :
tempPasswd , _ = scrypt . Key ( [ ] byte ( passwd ) , [ ] byte ( salt ) , 65536 , 16 , 2 , 50 )
case algoArgon2 :
tempPasswd = argon2 . IDKey ( [ ] byte ( passwd ) , [ ] byte ( salt ) , 2 , 65536 , 8 , 50 )
case algoPbkdf2 :
fallthrough
default :
tempPasswd = pbkdf2 . Key ( [ ] byte ( passwd ) , [ ] byte ( salt ) , 10000 , 50 , sha256 . New )
}
2018-01-11 17:19:38 -05:00
return fmt . Sprintf ( "%x" , tempPasswd )
}
2021-01-10 13:05:18 -05:00
// SetPassword hashes a password using the algorithm defined in the config value of PASSWORD_HASH_ALGO
// change passwd, salt and passwd_hash_algo fields
func ( u * User ) SetPassword ( passwd string ) ( err error ) {
if len ( passwd ) == 0 {
u . Passwd = ""
u . Salt = ""
u . PasswdHashAlgo = ""
return nil
}
if u . Salt , err = GetUserSalt ( ) ; err != nil {
return err
}
2019-07-07 02:01:01 -04:00
u . PasswdHashAlgo = setting . PasswordHashAlgo
u . Passwd = hashPassword ( passwd , u . Salt , setting . PasswordHashAlgo )
2021-01-10 13:05:18 -05:00
return nil
2014-06-25 00:44:48 -04:00
}
2015-04-16 14:40:39 -04:00
// ValidatePassword checks if given password matches the one belongs to the user.
2015-04-16 14:36:32 -04:00
func ( u * User ) ValidatePassword ( passwd string ) bool {
2019-07-07 02:01:01 -04:00
tempHash := hashPassword ( passwd , u . Salt , u . PasswdHashAlgo )
if u . PasswdHashAlgo != algoBcrypt && subtle . ConstantTimeCompare ( [ ] byte ( u . Passwd ) , [ ] byte ( tempHash ) ) == 1 {
return true
}
if u . PasswdHashAlgo == algoBcrypt && bcrypt . CompareHashAndPassword ( [ ] byte ( u . Passwd ) , [ ] byte ( passwd ) ) == nil {
return true
}
return false
2014-08-02 13:47:33 -04:00
}
2017-02-22 02:14:37 -05:00
// IsPasswordSet checks if the password is set or left empty
func ( u * User ) IsPasswordSet ( ) bool {
2021-01-10 13:05:18 -05:00
return len ( u . Passwd ) != 0
2017-02-22 02:14:37 -05:00
}
2021-06-26 15:53:14 -04:00
// IsVisibleToUser check if viewer is able to see user profile
func ( u * User ) IsVisibleToUser ( viewer * User ) bool {
2021-09-23 11:45:36 -04:00
return u . isVisibleToUser ( db . GetEngine ( db . DefaultContext ) , viewer )
2021-06-26 15:53:14 -04:00
}
2021-09-19 07:49:59 -04:00
func ( u * User ) isVisibleToUser ( e db . Engine , viewer * User ) bool {
2021-06-26 15:53:14 -04:00
if viewer != nil && viewer . IsAdmin {
return true
}
switch u . Visibility {
case structs . VisibleTypePublic :
return true
case structs . VisibleTypeLimited :
if viewer == nil || viewer . IsRestricted {
return false
}
return true
case structs . VisibleTypePrivate :
if viewer == nil || viewer . IsRestricted {
return false
}
// If they follow - they see each over
2021-11-17 04:58:31 -05:00
follower := user_model . IsFollowing ( u . ID , viewer . ID )
2021-06-26 15:53:14 -04:00
if follower {
return true
}
// Now we need to check if they in some organization together
2021-11-09 03:54:46 -05:00
count , err := e . Table ( "team_user" ) .
2021-06-26 15:53:14 -04:00
Where (
builder . And (
builder . Eq { "uid" : viewer . ID } ,
builder . Or (
builder . Eq { "org_id" : u . ID } ,
builder . In ( "org_id" ,
builder . Select ( "org_id" ) .
From ( "team_user" , "t2" ) .
Where ( builder . Eq { "uid" : u . ID } ) ) ) ) ) .
Count ( new ( TeamUser ) )
if err != nil {
return false
}
if count < 0 {
// No common organization
return false
}
// they are in an organization together
return true
}
return false
}
2014-06-28 00:40:07 -04:00
// IsOrganization returns true if user is actually a organization.
2014-06-25 00:44:48 -04:00
func ( u * User ) IsOrganization ( ) bool {
2016-11-07 11:53:22 -05:00
return u . Type == UserTypeOrganization
2014-06-25 00:44:48 -04:00
}
2014-08-15 06:29:41 -04:00
// IsUserOrgOwner returns true if user is in the owner team of given organization.
2016-11-28 11:47:46 -05:00
func ( u * User ) IsUserOrgOwner ( orgID int64 ) bool {
2017-12-21 02:43:26 -05:00
isOwner , err := IsOrganizationOwner ( orgID , u . ID )
if err != nil {
2019-04-02 03:48:31 -04:00
log . Error ( "IsOrganizationOwner: %v" , err )
2017-12-21 02:43:26 -05:00
return false
}
return isOwner
2014-08-15 06:29:41 -04:00
}
2017-01-20 00:16:10 -05:00
// IsPublicMember returns true if user public his/her membership in given organization.
2016-11-28 11:47:46 -05:00
func ( u * User ) IsPublicMember ( orgID int64 ) bool {
2017-12-21 02:43:26 -05:00
isMember , err := IsPublicMembership ( orgID , u . ID )
if err != nil {
2019-04-02 03:48:31 -04:00
log . Error ( "IsPublicMembership: %v" , err )
2017-12-21 02:43:26 -05:00
return false
}
return isMember
2014-08-15 06:29:41 -04:00
}
2021-11-18 12:42:27 -05:00
// GetOrganizationCount returns count of membership of organization of the user.
func GetOrganizationCount ( ctx context . Context , u * User ) ( int64 , error ) {
return db . GetEngine ( ctx ) .
2016-11-10 10:16:32 -05:00
Where ( "uid=?" , u . ID ) .
Count ( new ( OrgUser ) )
2015-09-06 08:54:08 -04:00
}
2014-06-28 15:43:25 -04:00
// GetOrganizationCount returns count of membership of organization of user.
func ( u * User ) GetOrganizationCount ( ) ( int64 , error ) {
2021-11-18 12:42:27 -05:00
return GetOrganizationCount ( db . DefaultContext , u )
2014-06-28 15:43:25 -04:00
}
2016-07-24 02:32:46 -04:00
// GetRepositories returns repositories that user owns, including private repositories.
2021-09-24 07:32:56 -04:00
func ( u * User ) GetRepositories ( listOpts db . ListOptions , names ... string ) ( err error ) {
2020-09-25 00:09:23 -04:00
u . Repos , _ , err = GetUserRepositories ( & SearchRepoOptions { Actor : u , Private : true , ListOptions : listOpts , LowerNames : names } )
2014-08-24 09:09:05 -04:00
return err
}
2019-10-08 13:55:16 -04:00
// GetRepositoryIDs returns repositories IDs where user owned and has unittypes
2020-01-17 02:34:37 -05:00
// Caller shall check that units is not globally disabled
2021-11-09 14:57:58 -05:00
func ( u * User ) GetRepositoryIDs ( units ... unit . Type ) ( [ ] int64 , error ) {
2019-10-08 13:55:16 -04:00
var ids [ ] int64
2021-09-23 11:45:36 -04:00
sess := db . GetEngine ( db . DefaultContext ) . Table ( "repository" ) . Cols ( "repository.id" )
2018-06-21 12:00:13 -04:00
if len ( units ) > 0 {
2019-10-08 13:55:16 -04:00
sess = sess . Join ( "INNER" , "repo_unit" , "repository.id = repo_unit.repo_id" )
sess = sess . In ( "repo_unit.type" , units )
2018-06-21 12:00:13 -04:00
}
2019-10-08 13:55:16 -04:00
return ids , sess . Where ( "owner_id = ?" , u . ID ) . Find ( & ids )
2017-02-16 19:58:19 -05:00
}
2021-01-12 23:19:17 -05:00
// GetActiveRepositoryIDs returns non-archived repositories IDs where user owned and has unittypes
// Caller shall check that units is not globally disabled
2021-11-09 14:57:58 -05:00
func ( u * User ) GetActiveRepositoryIDs ( units ... unit . Type ) ( [ ] int64 , error ) {
2021-01-12 23:19:17 -05:00
var ids [ ] int64
2021-09-23 11:45:36 -04:00
sess := db . GetEngine ( db . DefaultContext ) . Table ( "repository" ) . Cols ( "repository.id" )
2021-01-12 23:19:17 -05:00
if len ( units ) > 0 {
sess = sess . Join ( "INNER" , "repo_unit" , "repository.id = repo_unit.repo_id" )
sess = sess . In ( "repo_unit.type" , units )
}
sess . Where ( builder . Eq { "is_archived" : false } )
return ids , sess . Where ( "owner_id = ?" , u . ID ) . GroupBy ( "repository.id" ) . Find ( & ids )
}
2019-10-08 13:55:16 -04:00
// GetOrgRepositoryIDs returns repositories IDs where user's team owned and has unittypes
2020-01-17 02:34:37 -05:00
// Caller shall check that units is not globally disabled
2021-11-09 14:57:58 -05:00
func ( u * User ) GetOrgRepositoryIDs ( units ... unit . Type ) ( [ ] int64 , error ) {
2019-10-08 13:55:16 -04:00
var ids [ ] int64
2021-09-23 11:45:36 -04:00
if err := db . GetEngine ( db . DefaultContext ) . Table ( "repository" ) .
2019-10-08 13:55:16 -04:00
Cols ( "repository.id" ) .
Join ( "INNER" , "team_user" , "repository.owner_id = team_user.org_id" ) .
2020-01-13 12:33:46 -05:00
Join ( "INNER" , "team_repo" , "(? != ? and repository.is_private != ?) OR (team_user.team_id = team_repo.team_id AND repository.id = team_repo.repo_id)" , true , u . IsRestricted , true ) .
2020-01-04 20:23:29 -05:00
Where ( "team_user.uid = ?" , u . ID ) .
GroupBy ( "repository.id" ) . Find ( & ids ) ; err != nil {
return nil , err
}
2019-10-08 13:55:16 -04:00
2018-06-21 12:00:13 -04:00
if len ( units ) > 0 {
2020-01-04 20:23:29 -05:00
return FilterOutRepoIdsWithoutUnitAccess ( u , ids , units ... )
2019-10-08 13:55:16 -04:00
}
2020-01-04 20:23:29 -05:00
return ids , nil
2019-10-08 13:55:16 -04:00
}
2021-01-12 23:19:17 -05:00
// GetActiveOrgRepositoryIDs returns non-archived repositories IDs where user's team owned and has unittypes
// Caller shall check that units is not globally disabled
2021-11-09 14:57:58 -05:00
func ( u * User ) GetActiveOrgRepositoryIDs ( units ... unit . Type ) ( [ ] int64 , error ) {
2021-01-12 23:19:17 -05:00
var ids [ ] int64
2021-09-23 11:45:36 -04:00
if err := db . GetEngine ( db . DefaultContext ) . Table ( "repository" ) .
2021-01-12 23:19:17 -05:00
Cols ( "repository.id" ) .
Join ( "INNER" , "team_user" , "repository.owner_id = team_user.org_id" ) .
Join ( "INNER" , "team_repo" , "(? != ? and repository.is_private != ?) OR (team_user.team_id = team_repo.team_id AND repository.id = team_repo.repo_id)" , true , u . IsRestricted , true ) .
Where ( "team_user.uid = ?" , u . ID ) .
Where ( builder . Eq { "is_archived" : false } ) .
GroupBy ( "repository.id" ) . Find ( & ids ) ; err != nil {
return nil , err
}
if len ( units ) > 0 {
return FilterOutRepoIdsWithoutUnitAccess ( u , ids , units ... )
}
return ids , nil
}
2019-10-08 13:55:16 -04:00
// GetAccessRepoIDs returns all repositories IDs where user's or user is a team member organizations
2020-01-17 02:34:37 -05:00
// Caller shall check that units is not globally disabled
2021-11-09 14:57:58 -05:00
func ( u * User ) GetAccessRepoIDs ( units ... unit . Type ) ( [ ] int64 , error ) {
2019-10-08 13:55:16 -04:00
ids , err := u . GetRepositoryIDs ( units ... )
if err != nil {
return nil , err
}
ids2 , err := u . GetOrgRepositoryIDs ( units ... )
if err != nil {
return nil , err
}
return append ( ids , ids2 ... ) , nil
2017-02-16 19:58:19 -05:00
}
2021-01-12 23:19:17 -05:00
// GetActiveAccessRepoIDs returns all non-archived repositories IDs where user's or user is a team member organizations
// Caller shall check that units is not globally disabled
2021-11-09 14:57:58 -05:00
func ( u * User ) GetActiveAccessRepoIDs ( units ... unit . Type ) ( [ ] int64 , error ) {
2021-01-12 23:19:17 -05:00
ids , err := u . GetActiveRepositoryIDs ( units ... )
if err != nil {
return nil , err
}
ids2 , err := u . GetActiveOrgRepositoryIDs ( units ... )
if err != nil {
return nil , err
}
return append ( ids , ids2 ... ) , nil
}
2016-11-28 11:47:46 -05:00
// GetMirrorRepositories returns mirror repositories that user owns, including private repositories.
2016-07-24 02:32:46 -04:00
func ( u * User ) GetMirrorRepositories ( ) ( [ ] * Repository , error ) {
return GetUserMirrorRepositories ( u . ID )
}
2015-09-07 13:58:23 -04:00
// GetOwnedOrganizations returns all organizations that user owns.
func ( u * User ) GetOwnedOrganizations ( ) ( err error ) {
2016-07-23 13:08:22 -04:00
u . OwnedOrgs , err = GetOwnedOrgsByUserID ( u . ID )
2015-09-07 13:58:23 -04:00
return err
}
2015-08-27 01:26:38 -04:00
// DisplayName returns full name if it's not empty,
// returns username otherwise.
func ( u * User ) DisplayName ( ) string {
2019-01-24 09:12:17 -05:00
trimmed := strings . TrimSpace ( u . FullName )
if len ( trimmed ) > 0 {
return trimmed
2014-09-17 09:11:51 -04:00
}
2015-08-27 01:26:38 -04:00
return u . Name
2014-09-17 09:11:51 -04:00
}
2019-05-08 04:41:35 -04:00
// GetDisplayName returns full name if it's not empty and DEFAULT_SHOW_FULL_NAME is set,
// returns username otherwise.
func ( u * User ) GetDisplayName ( ) string {
2020-02-26 17:08:24 -05:00
if setting . UI . DefaultShowFullName {
trimmed := strings . TrimSpace ( u . FullName )
if len ( trimmed ) > 0 {
return trimmed
}
2019-05-08 04:41:35 -04:00
}
return u . Name
}
2019-01-24 09:12:17 -05:00
func gitSafeName ( name string ) string {
return strings . TrimSpace ( strings . NewReplacer ( "\n" , "" , "<" , "" , ">" , "" ) . Replace ( name ) )
}
// GitName returns a git safe name
func ( u * User ) GitName ( ) string {
gitName := gitSafeName ( u . FullName )
if len ( gitName ) > 0 {
return gitName
}
// Although u.Name should be safe if created in our system
// LDAP users may have bad names
gitName = gitSafeName ( u . Name )
if len ( gitName ) > 0 {
return gitName
}
// Totally pathological name so it's got to be:
return fmt . Sprintf ( "user-%d" , u . ID )
}
2016-11-28 11:47:46 -05:00
// ShortName ellipses username to length
2015-11-18 17:42:20 -05:00
func ( u * User ) ShortName ( length int ) string {
2016-01-11 07:41:43 -05:00
return base . EllipsisString ( u . Name , length )
2015-11-18 17:42:20 -05:00
}
2017-03-14 20:52:01 -04:00
// IsMailable checks if a user is eligible
2017-02-02 07:33:36 -05:00
// to receive emails.
func ( u * User ) IsMailable ( ) bool {
return u . IsActive
}
2019-08-29 10:05:42 -04:00
// EmailNotifications returns the User's email notification preference
func ( u * User ) EmailNotifications ( ) string {
return u . EmailNotificationsPreference
}
// SetEmailNotifications sets the user's email notification preference
func ( u * User ) SetEmailNotifications ( set string ) error {
u . EmailNotificationsPreference = set
if err := UpdateUserCols ( u , "email_notifications_preference" ) ; err != nil {
log . Error ( "SetEmailNotifications: %v" , err )
return err
}
return nil
}
2021-09-19 07:49:59 -04:00
func isUserExist ( e db . Engine , uid int64 , name string ) ( bool , error ) {
2014-04-10 14:20:58 -04:00
if len ( name ) == 0 {
return false , nil
}
2017-10-03 02:29:26 -04:00
return e .
2016-11-10 10:16:32 -05:00
Where ( "id!=?" , uid ) .
Get ( & User { LowerName : strings . ToLower ( name ) } )
2014-04-10 14:20:58 -04:00
}
2017-10-03 02:29:26 -04:00
// IsUserExist checks if given user name exist,
// the user name should be noncased unique.
// If uid is presented, then check will rule out that one,
// it is used when update a user name in settings page.
func IsUserExist ( uid int64 , name string ) ( bool , error ) {
2021-09-23 11:45:36 -04:00
return isUserExist ( db . GetEngine ( db . DefaultContext ) , uid , name )
2017-10-03 02:29:26 -04:00
}
2017-03-14 20:52:01 -04:00
// GetUserSalt returns a random user salt token.
2016-12-20 07:32:02 -05:00
func GetUserSalt ( ) ( string , error ) {
2021-05-10 02:45:17 -04:00
return util . RandomString ( 10 )
2014-04-10 14:20:58 -04:00
}
2016-08-14 06:32:24 -04:00
// NewGhostUser creates and returns a fake user for someone has deleted his/her account.
func NewGhostUser ( ) * User {
2015-08-14 14:48:05 -04:00
return & User {
2016-07-23 13:08:22 -04:00
ID : - 1 ,
2016-08-14 06:32:24 -04:00
Name : "Ghost" ,
LowerName : "ghost" ,
2015-08-14 14:48:05 -04:00
}
}
2020-01-15 06:14:07 -05:00
// NewReplaceUser creates and returns a fake user for external user
func NewReplaceUser ( name string ) * User {
return & User {
ID : - 1 ,
Name : name ,
LowerName : strings . ToLower ( name ) ,
}
}
2020-01-01 17:51:10 -05:00
// IsGhost check if user is fake user for a deleted account
func ( u * User ) IsGhost ( ) bool {
if u == nil {
return false
}
return u . ID == - 1 && u . Name == "Ghost"
}
2016-07-23 06:58:18 -04:00
var (
2021-04-28 08:35:06 -04:00
reservedUsernames = [ ] string {
2020-04-18 17:01:06 -04:00
"." ,
".." ,
".well-known" ,
2018-08-13 01:02:18 -04:00
"admin" ,
"api" ,
"assets" ,
2020-04-18 17:01:06 -04:00
"attachments" ,
2018-08-13 01:02:18 -04:00
"avatars" ,
2021-03-08 11:49:29 -05:00
"captcha" ,
2018-08-13 01:02:18 -04:00
"commits" ,
"debug" ,
"error" ,
"explore" ,
2021-05-12 14:36:53 -04:00
"favicon.ico" ,
2019-02-27 19:04:44 -05:00
"ghost" ,
2018-08-13 01:02:18 -04:00
"help" ,
"install" ,
"issues" ,
"less" ,
2020-04-18 17:01:06 -04:00
"login" ,
2020-02-16 02:56:49 -05:00
"manifest.json" ,
2018-11-04 22:20:00 -05:00
"metrics" ,
2020-02-16 02:56:49 -05:00
"milestones" ,
2018-08-13 01:02:18 -04:00
"new" ,
2019-02-27 19:04:44 -05:00
"notifications" ,
2018-08-13 01:02:18 -04:00
"org" ,
"plugins" ,
"pulls" ,
"raw" ,
"repo" ,
2020-04-18 17:01:06 -04:00
"robots.txt" ,
"search" ,
2021-05-12 14:36:53 -04:00
"serviceworker.js" ,
2018-08-13 01:02:18 -04:00
"stars" ,
"template" ,
"user" ,
2021-04-28 08:35:06 -04:00
}
2020-06-20 09:20:25 -04:00
2021-07-01 11:13:20 -04:00
reservedUserPatterns = [ ] string { "*.keys" , "*.gpg" , "*.rss" , "*.atom" }
2016-07-23 06:58:18 -04:00
)
// isUsableName checks if name is reserved or pattern of name is not allowed
2016-11-12 07:26:45 -05:00
// based on given reserved names and patterns.
2016-07-23 06:58:18 -04:00
// Names are exact match, patterns can be prefix or suffix match with placeholder '*'.
func isUsableName ( names , patterns [ ] string , name string ) error {
name = strings . TrimSpace ( strings . ToLower ( name ) )
if utf8 . RuneCountInString ( name ) == 0 {
return ErrNameEmpty
}
for i := range names {
if name == names [ i ] {
return ErrNameReserved { name }
}
}
for _ , pat := range patterns {
if pat [ 0 ] == '*' && strings . HasSuffix ( name , pat [ 1 : ] ) ||
( pat [ len ( pat ) - 1 ] == '*' && strings . HasPrefix ( name , pat [ : len ( pat ) - 1 ] ) ) {
return ErrNamePatternNotAllowed { pat }
}
}
return nil
}
2016-11-28 11:47:46 -05:00
// IsUsableUsername returns an error when a username is reserved
2016-07-23 06:58:18 -04:00
func IsUsableUsername ( name string ) error {
2020-02-23 14:52:05 -05:00
// Validate username make sure it satisfies requirement.
if alphaDashDotPattern . MatchString ( name ) {
// Note: usually this error is normally caught up earlier in the UI
return ErrNameCharsNotAllowed { Name : name }
}
2016-11-12 07:26:45 -05:00
return isUsableName ( reservedUsernames , reservedUserPatterns , name )
2016-07-23 06:58:18 -04:00
}
2021-06-26 15:53:14 -04:00
// CreateUserOverwriteOptions are an optional options who overwrite system defaults on user creation
type CreateUserOverwriteOptions struct {
Visibility structs . VisibleType
}
2014-06-25 00:44:48 -04:00
// CreateUser creates record of a new user.
2021-06-26 15:53:14 -04:00
func CreateUser ( u * User , overwriteDefault ... * CreateUserOverwriteOptions ) ( err error ) {
2016-07-23 06:58:18 -04:00
if err = IsUsableUsername ( u . Name ) ; err != nil {
2015-03-26 17:11:47 -04:00
return err
2014-06-25 00:44:48 -04:00
}
2021-06-27 14:47:35 -04:00
// set system defaults
u . KeepEmailPrivate = setting . Service . DefaultKeepEmailPrivate
u . Visibility = setting . Service . DefaultUserVisibilityMode
u . AllowCreateOrganization = setting . Service . DefaultAllowCreateOrganization && ! setting . Admin . DisableRegularOrgCreation
u . EmailNotificationsPreference = setting . Admin . DefaultEmailNotification
u . MaxRepoCreation = - 1
u . Theme = setting . UI . DefaultTheme
// overwrite defaults if set
if len ( overwriteDefault ) != 0 && overwriteDefault [ 0 ] != nil {
u . Visibility = overwriteDefault [ 0 ] . Visibility
}
2021-11-11 02:03:30 -05:00
ctx , committer , err := db . TxContext ( )
if err != nil {
2017-10-03 02:29:26 -04:00
return err
}
2021-11-11 02:03:30 -05:00
defer committer . Close ( )
2017-10-03 02:29:26 -04:00
2021-11-11 02:03:30 -05:00
sess := db . GetEngine ( ctx )
2014-06-25 00:44:48 -04:00
2021-11-11 02:03:30 -05:00
// validate data
2021-06-27 14:47:35 -04:00
if err := validateUser ( u ) ; err != nil {
2021-01-24 10:23:05 -05:00
return err
}
2021-06-27 14:47:35 -04:00
isExist , err := isUserExist ( sess , 0 , u . Name )
if err != nil {
2020-11-20 16:45:55 -05:00
return err
2021-06-27 14:47:35 -04:00
} else if isExist {
return ErrUserAlreadyExist { u . Name }
2020-11-14 11:53:43 -05:00
}
2021-11-11 02:03:30 -05:00
isExist , err = user_model . IsEmailUsed ( ctx , u . Email )
2014-06-25 00:44:48 -04:00
if err != nil {
2014-07-26 00:24:27 -04:00
return err
2014-06-25 00:44:48 -04:00
} else if isExist {
2021-11-11 02:03:30 -05:00
return user_model . ErrEmailAlreadyUsed {
Email : u . Email ,
}
2014-06-25 00:44:48 -04:00
}
2021-06-27 14:47:35 -04:00
// prepare for database
2014-06-25 00:44:48 -04:00
u . LowerName = strings . ToLower ( u . Name )
u . AvatarEmail = u . Email
2016-12-20 07:32:02 -05:00
if u . Rands , err = GetUserSalt ( ) ; err != nil {
return err
}
2021-01-10 13:05:18 -05:00
if err = u . SetPassword ( u . Passwd ) ; err != nil {
2016-12-20 07:32:02 -05:00
return err
}
2021-06-26 15:53:14 -04:00
2021-06-27 14:47:35 -04:00
// save changes to database
2021-11-11 02:03:30 -05:00
if err = user_model . DeleteUserRedirect ( ctx , u . Name ) ; err != nil {
2021-06-27 14:47:35 -04:00
return err
2021-06-26 15:53:14 -04:00
}
2014-06-25 00:44:48 -04:00
2021-11-11 02:03:30 -05:00
if err = db . Insert ( ctx , u ) ; err != nil {
2014-07-26 00:24:27 -04:00
return err
2014-06-25 00:44:48 -04:00
}
2014-04-22 12:55:27 -04:00
2021-06-07 23:52:51 -04:00
// insert email address
2021-11-11 02:03:30 -05:00
if err := db . Insert ( ctx , & user_model . EmailAddress {
2021-06-07 23:52:51 -04:00
UID : u . ID ,
Email : u . Email ,
LowerEmail : strings . ToLower ( u . Email ) ,
IsActivated : u . IsActive ,
IsPrimary : true ,
} ) ; err != nil {
return err
}
2021-11-11 02:03:30 -05:00
return committer . Commit ( )
2014-06-25 00:44:48 -04:00
}
2021-09-19 07:49:59 -04:00
func countUsers ( e db . Engine ) int64 {
2016-11-10 10:16:32 -05:00
count , _ := e .
Where ( "type=0" ) .
Count ( new ( User ) )
2015-08-06 12:00:11 -04:00
return count
}
2014-07-07 04:15:08 -04:00
// CountUsers returns number of users.
func CountUsers ( ) int64 {
2021-09-23 11:45:36 -04:00
return countUsers ( db . GetEngine ( db . DefaultContext ) )
2014-07-07 04:15:08 -04:00
}
2017-01-04 19:50:34 -05:00
// get user by verify code
2014-04-10 14:20:58 -04:00
func getVerifyUser ( code string ) ( user * User ) {
if len ( code ) <= base . TimeLimitCodeLength {
return nil
}
// use tail hex username query user
hexStr := code [ base . TimeLimitCodeLength : ]
if b , err := hex . DecodeString ( hexStr ) ; err == nil {
if user , err = GetUserByName ( string ( b ) ) ; user != nil {
return user
}
2019-04-02 03:48:31 -04:00
log . Error ( "user.getVerifyUser: %v" , err )
2014-04-10 14:20:58 -04:00
}
return nil
}
2016-11-28 11:47:46 -05:00
// VerifyUserActiveCode verifies active code when active account
2014-04-10 14:20:58 -04:00
func VerifyUserActiveCode ( code string ) ( user * User ) {
2014-05-25 20:11:25 -04:00
minutes := setting . Service . ActiveCodeLives
2014-04-10 14:20:58 -04:00
if user = getVerifyUser ( code ) ; user != nil {
// time limit code
prefix := code [ : base . TimeLimitCodeLength ]
2020-12-25 04:59:32 -05:00
data := fmt . Sprintf ( "%d%s%s%s%s" , user . ID , user . Email , user . LowerName , user . Passwd , user . Rands )
2014-04-10 14:20:58 -04:00
if base . VerifyTimeLimitCode ( data , minutes , prefix ) {
return user
}
}
return nil
}
2016-11-28 11:47:46 -05:00
// VerifyActiveEmailCode verifies active email code when active account
2021-11-11 02:03:30 -05:00
func VerifyActiveEmailCode ( code , email string ) * user_model . EmailAddress {
2014-12-17 10:40:10 -05:00
minutes := setting . Service . ActiveCodeLives
if user := getVerifyUser ( code ) ; user != nil {
// time limit code
prefix := code [ : base . TimeLimitCodeLength ]
2020-12-25 04:59:32 -05:00
data := fmt . Sprintf ( "%d%s%s%s%s" , user . ID , email , user . LowerName , user . Passwd , user . Rands )
2014-12-17 10:40:10 -05:00
if base . VerifyTimeLimitCode ( data , minutes , prefix ) {
2021-11-11 02:03:30 -05:00
emailAddress := & user_model . EmailAddress { UID : user . ID , Email : email }
2021-09-23 11:45:36 -04:00
if has , _ := db . GetEngine ( db . DefaultContext ) . Get ( emailAddress ) ; has {
2014-12-17 10:40:10 -05:00
return emailAddress
}
}
}
return nil
}
2014-04-10 14:20:58 -04:00
// ChangeUserName changes all corresponding setting from old user name to new one.
2014-07-26 00:24:27 -04:00
func ChangeUserName ( u * User , newUserName string ) ( err error ) {
2021-01-24 10:23:05 -05:00
oldUserName := u . Name
2016-07-23 06:58:18 -04:00
if err = IsUsableUsername ( newUserName ) ; err != nil {
2015-03-26 17:11:47 -04:00
return err
}
2021-11-11 02:03:30 -05:00
ctx , committer , err := db . TxContext ( )
if err != nil {
2020-02-08 09:59:40 -05:00
return err
}
2021-11-11 02:03:30 -05:00
defer committer . Close ( )
sess := db . GetEngine ( ctx )
2020-02-08 09:59:40 -05:00
2021-01-10 07:14:02 -05:00
isExist , err := isUserExist ( sess , 0 , newUserName )
if err != nil {
return err
} else if isExist {
return ErrUserAlreadyExist { newUserName }
}
2021-01-24 10:23:05 -05:00
if _ , err = sess . Exec ( "UPDATE `repository` SET owner_name=? WHERE owner_name=?" , newUserName , oldUserName ) ; err != nil {
2020-02-08 09:59:40 -05:00
return fmt . Errorf ( "Change repo owner name: %v" , err )
}
2016-01-27 16:45:03 -05:00
2018-09-06 20:40:58 -04:00
// Do not fail if directory does not exist
2021-07-15 11:46:07 -04:00
if err = util . Rename ( UserPath ( oldUserName ) , UserPath ( newUserName ) ) ; err != nil && ! os . IsNotExist ( err ) {
2018-09-06 20:40:58 -04:00
return fmt . Errorf ( "Rename user directory: %v" , err )
}
2021-11-11 02:03:30 -05:00
if err = user_model . NewUserRedirect ( ctx , u . ID , oldUserName , newUserName ) ; err != nil {
2021-01-24 10:23:05 -05:00
return err
}
2021-11-11 02:03:30 -05:00
if err = committer . Commit ( ) ; err != nil {
2021-07-15 11:46:07 -04:00
if err2 := util . Rename ( UserPath ( newUserName ) , UserPath ( oldUserName ) ) ; err2 != nil && ! os . IsNotExist ( err2 ) {
2021-01-24 10:23:05 -05:00
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
2014-04-10 14:20:58 -04:00
}
2017-02-25 09:53:57 -05:00
// checkDupEmail checks whether there are the same email with the user
2021-09-19 07:49:59 -04:00
func checkDupEmail ( e db . Engine , u * User ) error {
2017-02-25 09:53:57 -05:00
u . Email = strings . ToLower ( u . Email )
has , err := e .
Where ( "id!=?" , u . ID ) .
And ( "type=?" , u . Type ) .
And ( "email=?" , u . Email ) .
Get ( new ( User ) )
if err != nil {
return err
} else if has {
2021-11-11 02:03:30 -05:00
return user_model . ErrEmailAlreadyUsed {
Email : u . Email ,
}
2017-02-25 09:53:57 -05:00
}
return nil
}
2021-09-08 11:47:49 -04:00
// validateUser check if user is valid to insert / update into database
2021-06-27 14:47:35 -04:00
func validateUser ( u * User ) error {
2021-09-08 11:47:49 -04:00
if ! setting . Service . AllowedUserVisibilityModesSlice . IsAllowedVisibility ( u . Visibility ) && ! u . IsOrganization ( ) {
2021-06-27 14:47:35 -04:00
return fmt . Errorf ( "visibility Mode not allowed: %s" , u . Visibility . String ( ) )
}
2020-11-14 11:53:43 -05:00
u . Email = strings . ToLower ( u . Email )
2021-11-11 02:03:30 -05:00
return user_model . ValidateEmail ( u . Email )
2021-06-27 14:47:35 -04:00
}
2021-09-19 07:49:59 -04:00
func updateUser ( e db . Engine , u * User ) error {
2021-06-27 14:47:35 -04:00
if err := validateUser ( u ) ; err != nil {
2020-11-20 16:45:55 -05:00
return err
2020-11-14 11:53:43 -05:00
}
2021-06-27 14:47:35 -04:00
_ , err := e . ID ( u . ID ) . AllCols ( ) . Update ( u )
2014-04-10 14:20:58 -04:00
return err
}
2015-08-29 13:13:24 -04:00
// UpdateUser updates user's information.
func UpdateUser ( u * User ) error {
2021-09-23 11:45:36 -04:00
return updateUser ( db . GetEngine ( db . DefaultContext ) , u )
2017-02-25 09:53:57 -05:00
}
2017-08-12 10:18:44 -04:00
// UpdateUserCols update user according special columns
func UpdateUserCols ( u * User , cols ... string ) error {
2021-09-23 11:45:36 -04:00
return updateUserCols ( db . GetEngine ( db . DefaultContext ) , u , cols ... )
2017-09-25 00:59:27 -04:00
}
2021-09-19 07:49:59 -04:00
func updateUserCols ( e db . Engine , u * User , cols ... string ) error {
2021-06-27 14:47:35 -04:00
if err := validateUser ( u ) ; err != nil {
return err
}
2017-10-05 00:43:04 -04:00
_ , err := e . ID ( u . ID ) . Cols ( cols ... ) . Update ( u )
2017-08-12 10:18:44 -04:00
return err
}
2017-02-25 09:53:57 -05:00
// UpdateUserSetting updates user's settings.
2020-11-20 16:45:55 -05:00
func UpdateUserSetting ( u * User ) ( err error ) {
2021-09-23 11:45:36 -04:00
sess := db . NewSession ( db . DefaultContext )
2020-11-20 16:45:55 -05:00
defer sess . Close ( )
if err = sess . Begin ( ) ; err != nil {
return err
}
2017-02-25 09:53:57 -05:00
if ! u . IsOrganization ( ) {
2020-11-20 16:45:55 -05:00
if err = checkDupEmail ( sess , u ) ; err != nil {
2017-02-25 09:53:57 -05:00
return err
}
}
2020-11-20 16:45:55 -05:00
if err = updateUser ( sess , u ) ; err != nil {
return err
}
return sess . Commit ( )
2015-08-29 13:13:24 -04:00
}
2015-09-06 08:54:08 -04:00
// deleteBeans deletes all given beans, beans should contain delete conditions.
2021-09-19 07:49:59 -04:00
func deleteBeans ( e db . Engine , beans ... interface { } ) ( err error ) {
2015-03-17 21:51:39 -04:00
for i := range beans {
if _ , err = e . Delete ( beans [ i ] ) ; err != nil {
return err
}
}
return nil
}
2021-11-18 12:42:27 -05:00
// DeleteUser deletes models associated to an user.
func DeleteUser ( ctx context . Context , u * User ) ( err error ) {
2021-11-18 00:58:42 -05:00
e := db . GetEngine ( ctx )
2014-06-27 03:37:01 -04:00
2015-08-17 05:05:37 -04:00
// ***** START: Watch *****
2017-05-20 04:48:22 -04:00
watchedRepoIDs := make ( [ ] int64 , 0 , 10 )
if err = e . Table ( "watch" ) . Cols ( "watch.repo_id" ) .
2019-11-10 04:22:19 -05:00
Where ( "watch.user_id = ?" , u . ID ) . And ( "watch.mode <>?" , RepoWatchModeDont ) . Find ( & watchedRepoIDs ) ; err != nil {
2015-03-17 21:51:39 -04:00
return fmt . Errorf ( "get all watches: %v" , err )
2014-04-10 14:20:58 -04:00
}
2018-07-04 17:47:05 -04:00
if _ , err = e . Decr ( "num_watches" ) . In ( "id" , watchedRepoIDs ) . NoAutoTime ( ) . Update ( new ( Repository ) ) ; err != nil {
2017-05-20 04:48:22 -04:00
return fmt . Errorf ( "decrease repository num_watches: %v" , err )
2014-04-11 21:47:39 -04:00
}
2015-08-17 05:05:37 -04:00
// ***** END: Watch *****
2015-03-17 21:51:39 -04:00
2015-08-17 05:05:37 -04:00
// ***** START: Star *****
2017-05-20 04:48:22 -04:00
starredRepoIDs := make ( [ ] int64 , 0 , 10 )
if err = e . Table ( "star" ) . Cols ( "star.repo_id" ) .
Where ( "star.uid = ?" , u . ID ) . Find ( & starredRepoIDs ) ; err != nil {
2015-08-17 05:05:37 -04:00
return fmt . Errorf ( "get all stars: %v" , err )
2018-07-04 17:47:05 -04:00
} else if _ , err = e . Decr ( "num_stars" ) . In ( "id" , starredRepoIDs ) . NoAutoTime ( ) . Update ( new ( Repository ) ) ; err != nil {
2017-05-20 04:48:22 -04:00
return fmt . Errorf ( "decrease repository num_stars: %v" , err )
2015-08-17 05:05:37 -04:00
}
// ***** END: Star *****
2015-03-17 21:51:39 -04:00
2015-08-17 05:05:37 -04:00
// ***** START: Follow *****
2017-05-20 04:48:22 -04:00
followeeIDs := make ( [ ] int64 , 0 , 10 )
if err = e . Table ( "follow" ) . Cols ( "follow.follow_id" ) .
Where ( "follow.user_id = ?" , u . ID ) . Find ( & followeeIDs ) ; err != nil {
return fmt . Errorf ( "get all followees: %v" , err )
} else if _ , err = e . Decr ( "num_followers" ) . In ( "id" , followeeIDs ) . Update ( new ( User ) ) ; err != nil {
return fmt . Errorf ( "decrease user num_followers: %v" , err )
2015-08-17 05:05:37 -04:00
}
2017-05-20 04:48:22 -04:00
followerIDs := make ( [ ] int64 , 0 , 10 )
if err = e . Table ( "follow" ) . Cols ( "follow.user_id" ) .
Where ( "follow.follow_id = ?" , u . ID ) . Find ( & followerIDs ) ; err != nil {
return fmt . Errorf ( "get all followers: %v" , err )
} else if _ , err = e . Decr ( "num_following" ) . In ( "id" , followerIDs ) . Update ( new ( User ) ) ; err != nil {
return fmt . Errorf ( "decrease user num_following: %v" , err )
2014-04-10 14:20:58 -04:00
}
2015-08-17 05:05:37 -04:00
// ***** END: Follow *****
2015-03-17 21:51:39 -04:00
2015-09-06 08:54:08 -04:00
if err = deleteBeans ( e ,
2016-07-23 13:08:22 -04:00
& AccessToken { UID : u . ID } ,
& Collaboration { UserID : u . ID } ,
& Access { UserID : u . ID } ,
& Watch { UserID : u . ID } ,
& Star { UID : u . ID } ,
2021-11-17 04:58:31 -05:00
& user_model . Follow { UserID : u . ID } ,
& user_model . Follow { FollowID : u . ID } ,
2016-07-23 13:08:22 -04:00
& Action { UserID : u . ID } ,
& IssueUser { UID : u . ID } ,
2021-11-11 02:03:30 -05:00
& user_model . EmailAddress { UID : u . ID } ,
2021-11-17 04:58:31 -05:00
& user_model . UserOpenID { UID : u . ID } ,
2017-12-03 18:14:26 -05:00
& Reaction { UserID : u . ID } ,
2018-12-18 11:26:26 -05:00
& TeamUser { UID : u . ID } ,
& Collaboration { UserID : u . ID } ,
& Stopwatch { UserID : u . ID } ,
2015-03-17 21:51:39 -04:00
) ; err != nil {
2015-11-30 20:45:55 -05:00
return fmt . Errorf ( "deleteBeans: %v" , err )
2014-04-10 14:20:58 -04:00
}
2015-03-17 21:51:39 -04:00
2021-01-21 21:56:19 -05:00
if setting . Service . UserDeleteWithCommentsMaxTime != 0 &&
u . CreatedUnix . AsTime ( ) . Add ( setting . Service . UserDeleteWithCommentsMaxTime ) . After ( time . Now ( ) ) {
// Delete Comments
const batchSize = 50
for start := 0 ; ; start += batchSize {
comments := make ( [ ] * Comment , 0 , batchSize )
if err = e . Where ( "type=? AND poster_id=?" , CommentTypeComment , u . ID ) . Limit ( batchSize , start ) . Find ( & comments ) ; err != nil {
return err
}
if len ( comments ) == 0 {
break
}
for _ , comment := range comments {
if err = deleteComment ( e , comment ) ; err != nil {
return err
}
}
}
// Delete Reactions
if err = deleteReaction ( e , & ReactionOptions { Doer : u } ) ; err != nil {
return err
2021-01-17 15:48:38 -05:00
}
}
2015-08-17 05:05:37 -04:00
// ***** START: PublicKey *****
2018-12-18 11:26:26 -05:00
if _ , err = e . Delete ( & PublicKey { OwnerID : u . ID } ) ; err != nil {
2016-07-26 05:26:48 -04:00
return fmt . Errorf ( "deletePublicKeys: %v" , err )
2014-04-10 14:20:58 -04:00
}
2019-06-12 15:41:28 -04:00
err = rewriteAllPublicKeys ( e )
if err != nil {
return err
}
2020-10-10 20:38:09 -04:00
err = rewriteAllPrincipalKeys ( e )
if err != nil {
return err
}
2015-08-17 05:05:37 -04:00
// ***** END: PublicKey *****
2014-04-10 14:20:58 -04:00
2018-12-18 11:26:26 -05:00
// ***** START: GPGPublicKey *****
2021-09-24 07:32:56 -04:00
keys , err := listGPGKeys ( e , u . ID , db . ListOptions { } )
2021-02-04 04:16:21 -05:00
if err != nil {
return fmt . Errorf ( "ListGPGKeys: %v" , err )
}
// Delete GPGKeyImport(s).
for _ , key := range keys {
if _ , err = e . Delete ( & GPGKeyImport { KeyID : key . KeyID } ) ; err != nil {
return fmt . Errorf ( "deleteGPGKeyImports: %v" , err )
}
}
2018-12-18 11:26:26 -05:00
if _ , err = e . Delete ( & GPGKey { OwnerID : u . ID } ) ; err != nil {
return fmt . Errorf ( "deleteGPGKeys: %v" , err )
}
// ***** END: GPGPublicKey *****
2015-08-14 14:48:05 -04:00
// Clear assignee.
2018-05-09 12:29:04 -04:00
if err = clearAssigneeByUserID ( e , u . ID ) ; err != nil {
2015-08-17 05:05:37 -04:00
return fmt . Errorf ( "clear assignee: %v" , err )
2015-08-14 14:48:05 -04:00
}
2017-02-22 02:14:37 -05:00
// ***** START: ExternalLoginUser *****
2017-03-20 10:13:52 -04:00
if err = removeAllAccountLinks ( e , u ) ; err != nil {
2017-02-22 02:14:37 -05:00
return fmt . Errorf ( "ExternalLoginUser: %v" , err )
}
// ***** END: ExternalLoginUser *****
2017-10-05 00:43:04 -04:00
if _ , err = e . ID ( u . ID ) . Delete ( new ( User ) ) ; err != nil {
2015-08-17 05:05:37 -04:00
return fmt . Errorf ( "Delete: %v" , err )
2015-03-17 21:51:39 -04:00
}
2015-08-17 05:05:37 -04:00
return nil
2014-06-21 00:51:41 -04:00
}
2021-11-18 12:42:27 -05:00
// GetInactiveUsers gets all inactive users
func GetInactiveUsers ( ctx context . Context , olderThan time . Duration ) ( [ ] * User , error ) {
var cond builder . Cond = builder . Eq { "is_active" : false }
2015-09-06 08:54:08 -04:00
2020-05-16 19:31:38 -04:00
if olderThan > 0 {
2021-11-18 12:42:27 -05:00
cond = cond . And ( builder . Lt { "created_unix" : time . Now ( ) . Add ( - olderThan ) . Unix ( ) } )
2014-12-17 03:26:19 -05:00
}
2015-08-17 05:05:37 -04:00
2021-11-18 12:42:27 -05:00
users := make ( [ ] * User , 0 , 10 )
return users , db . GetEngine ( ctx ) .
Where ( cond ) .
Find ( & users )
2014-04-10 14:20:58 -04:00
}
// UserPath returns the path absolute path of user repositories.
func UserPath ( userName string ) string {
2014-05-25 20:11:25 -04:00
return filepath . Join ( setting . RepoRootPath , strings . ToLower ( userName ) )
2014-04-10 14:20:58 -04:00
}
2021-09-19 07:49:59 -04:00
func getUserByID ( e db . Engine , id int64 ) ( * User , error ) {
2014-06-05 22:07:35 -04:00
u := new ( User )
2017-10-05 00:43:04 -04:00
has , err := e . ID ( id ) . Get ( u )
2014-04-10 14:20:58 -04:00
if err != nil {
return nil , err
2014-06-05 22:07:35 -04:00
} else if ! has {
2016-11-11 18:01:09 -05:00
return nil , ErrUserNotExist { id , "" , 0 }
2014-04-10 14:20:58 -04:00
}
2014-06-05 22:07:35 -04:00
return u , nil
2014-04-10 14:20:58 -04:00
}
2015-08-08 10:43:14 -04:00
// GetUserByID returns the user object by given ID if exists.
func GetUserByID ( id int64 ) ( * User , error ) {
2021-11-09 22:21:01 -05:00
return GetUserByIDCtx ( db . DefaultContext , id )
}
// GetUserByIDCtx returns the user object by given ID if exists.
func GetUserByIDCtx ( ctx context . Context , id int64 ) ( * User , error ) {
return getUserByID ( db . GetEngine ( ctx ) , id )
2015-02-13 00:58:46 -05:00
}
2014-10-24 18:43:17 -04:00
// GetUserByName returns user by given name.
2014-04-10 14:20:58 -04:00
func GetUserByName ( name string ) ( * User , error ) {
2021-09-23 11:45:36 -04:00
return getUserByName ( db . GetEngine ( db . DefaultContext ) , name )
2017-08-30 00:31:33 -04:00
}
2021-09-19 07:49:59 -04:00
func getUserByName ( e db . Engine , name string ) ( * User , error ) {
2014-04-10 14:20:58 -04:00
if len ( name ) == 0 {
2016-11-11 18:01:09 -05:00
return nil , ErrUserNotExist { 0 , name , 0 }
2014-04-10 14:20:58 -04:00
}
2014-10-24 18:43:17 -04:00
u := & User { LowerName : strings . ToLower ( name ) }
2017-08-30 00:31:33 -04:00
has , err := e . Get ( u )
2014-04-10 14:20:58 -04:00
if err != nil {
return nil , err
} else if ! has {
2016-11-11 18:01:09 -05:00
return nil , ErrUserNotExist { 0 , name , 0 }
2014-04-10 14:20:58 -04:00
}
2014-10-24 18:43:17 -04:00
return u , nil
2014-04-10 14:20:58 -04:00
}
2019-08-29 10:05:42 -04:00
// GetUserEmailsByNames returns a list of e-mails corresponds to names of users
// that have their email notifications set to enabled or onmention.
2014-04-10 14:20:58 -04:00
func GetUserEmailsByNames ( names [ ] string ) [ ] string {
2021-09-23 11:45:36 -04:00
return getUserEmailsByNames ( db . GetEngine ( db . DefaultContext ) , names )
2017-08-30 00:31:33 -04:00
}
2021-09-19 07:49:59 -04:00
func getUserEmailsByNames ( e db . Engine , names [ ] string ) [ ] string {
2014-04-10 14:20:58 -04:00
mails := make ( [ ] string , 0 , len ( names ) )
for _ , name := range names {
2017-08-30 00:31:33 -04:00
u , err := getUserByName ( e , name )
2014-04-10 14:20:58 -04:00
if err != nil {
continue
}
2019-08-29 10:05:42 -04:00
if u . IsMailable ( ) && u . EmailNotifications ( ) != EmailNotificationsDisabled {
2017-02-02 07:33:36 -05:00
mails = append ( mails , u . Email )
}
2014-04-10 14:20:58 -04:00
}
return mails
}
2019-11-18 03:08:20 -05:00
// GetMaileableUsersByIDs gets users from ids, but only if they can receive mails
2020-09-09 15:08:55 -04:00
func GetMaileableUsersByIDs ( ids [ ] int64 , isMention bool ) ( [ ] * User , error ) {
2019-11-18 03:08:20 -05:00
if len ( ids ) == 0 {
return nil , nil
}
ous := make ( [ ] * User , 0 , len ( ids ) )
2020-09-09 15:08:55 -04:00
if isMention {
2021-09-23 11:45:36 -04:00
return ous , db . GetEngine ( db . DefaultContext ) . In ( "id" , ids ) .
2020-09-09 15:08:55 -04:00
Where ( "`type` = ?" , UserTypeIndividual ) .
And ( "`prohibit_login` = ?" , false ) .
And ( "`is_active` = ?" , true ) .
And ( "`email_notifications_preference` IN ( ?, ?)" , EmailNotificationsEnabled , EmailNotificationsOnMention ) .
Find ( & ous )
}
2021-09-23 11:45:36 -04:00
return ous , db . GetEngine ( db . DefaultContext ) . In ( "id" , ids ) .
2019-11-18 03:08:20 -05:00
Where ( "`type` = ?" , UserTypeIndividual ) .
And ( "`prohibit_login` = ?" , false ) .
And ( "`is_active` = ?" , true ) .
And ( "`email_notifications_preference` = ?" , EmailNotificationsEnabled ) .
Find ( & ous )
}
2020-02-12 18:19:35 -05:00
// GetUserNamesByIDs returns usernames for all resolved users from a list of Ids.
func GetUserNamesByIDs ( ids [ ] int64 ) ( [ ] string , error ) {
unames := make ( [ ] string , 0 , len ( ids ) )
2021-09-23 11:45:36 -04:00
err := db . GetEngine ( db . DefaultContext ) . In ( "id" , ids ) .
2020-02-12 18:19:35 -05:00
Table ( "user" ) .
Asc ( "name" ) .
Cols ( "name" ) .
Find ( & unames )
return unames , err
}
2016-11-10 03:10:35 -05:00
// GetUsersByIDs returns all resolved users from a list of Ids.
2020-02-26 01:32:22 -05:00
func GetUsersByIDs ( ids [ ] int64 ) ( UserList , error ) {
2016-11-10 03:10:35 -05:00
ous := make ( [ ] * User , 0 , len ( ids ) )
2017-01-19 21:31:46 -05:00
if len ( ids ) == 0 {
return ous , nil
}
2021-09-23 11:45:36 -04:00
err := db . GetEngine ( db . DefaultContext ) . In ( "id" , ids ) .
2016-11-10 10:16:32 -05:00
Asc ( "name" ) .
Find ( & ous )
2016-11-10 03:10:35 -05:00
return ous , err
}
2016-07-15 22:08:04 -04:00
// GetUserIDsByNames returns a slice of ids corresponds to names.
2019-10-25 10:46:37 -04:00
func GetUserIDsByNames ( names [ ] string , ignoreNonExistent bool ) ( [ ] int64 , error ) {
2014-05-07 16:51:14 -04:00
ids := make ( [ ] int64 , 0 , len ( names ) )
for _ , name := range names {
u , err := GetUserByName ( name )
if err != nil {
2019-10-25 10:46:37 -04:00
if ignoreNonExistent {
continue
} else {
return nil , err
}
2014-05-07 16:51:14 -04:00
}
2016-07-23 13:08:22 -04:00
ids = append ( ids , u . ID )
2014-05-07 16:51:14 -04:00
}
2019-10-25 10:46:37 -04:00
return ids , nil
2014-05-07 16:51:14 -04:00
}
2021-07-24 06:16:34 -04:00
// GetUsersBySource returns a list of Users for a login source
2021-09-24 07:32:56 -04:00
func GetUsersBySource ( s * login . Source ) ( [ ] * User , error ) {
2021-07-24 06:16:34 -04:00
var users [ ] * User
2021-09-23 11:45:36 -04:00
err := db . GetEngine ( db . DefaultContext ) . Where ( "login_type = ? AND login_source = ?" , s . Type , s . ID ) . Find ( & users )
2021-07-24 06:16:34 -04:00
return users , err
}
2014-12-06 20:22:48 -05:00
// UserCommit represents a commit with validation of user.
2014-09-23 15:30:04 -04:00
type UserCommit struct {
2014-11-21 10:58:08 -05:00
User * User
2015-12-09 20:46:05 -05:00
* git . Commit
2014-09-23 15:30:04 -04:00
}
2017-01-04 19:50:34 -05:00
// ValidateCommitWithEmail check if author's e-mail of commit is corresponding to a user.
2015-12-09 20:46:05 -05:00
func ValidateCommitWithEmail ( c * git . Commit ) * User {
2017-10-26 03:45:14 -04:00
if c . Author == nil {
return nil
}
2014-09-26 08:55:13 -04:00
u , err := GetUserByEmail ( c . Author . Email )
2014-11-21 10:58:08 -05:00
if err != nil {
return nil
2014-09-26 08:55:13 -04:00
}
2014-11-21 10:58:08 -05:00
return u
2014-09-26 08:55:13 -04:00
}
// ValidateCommitsWithEmails checks if authors' e-mails of commits are corresponding to users.
2021-08-09 14:08:51 -04:00
func ValidateCommitsWithEmails ( oldCommits [ ] * git . Commit ) [ ] * UserCommit {
2015-08-05 05:36:22 -04:00
var (
2021-08-09 14:08:51 -04:00
emails = make ( map [ string ] * User )
newCommits = make ( [ ] * UserCommit , 0 , len ( oldCommits ) )
2015-08-05 05:36:22 -04:00
)
2021-08-09 14:08:51 -04:00
for _ , c := range oldCommits {
var u * User
2017-10-26 03:45:14 -04:00
if c . Author != nil {
if v , ok := emails [ c . Author . Email ] ; ! ok {
u , _ = GetUserByEmail ( c . Author . Email )
emails [ c . Author . Email ] = u
} else {
u = v
}
2014-09-23 15:30:04 -04:00
}
2021-08-09 14:08:51 -04:00
newCommits = append ( newCommits , & UserCommit {
2014-11-21 10:58:08 -05:00
User : u ,
Commit : c ,
2014-09-23 15:30:04 -04:00
} )
}
return newCommits
}
2014-04-10 14:20:58 -04:00
// GetUserByEmail returns the user object by given e-mail if exists.
func GetUserByEmail ( email string ) ( * User , error ) {
2021-09-23 11:45:36 -04:00
return GetUserByEmailContext ( db . DefaultContext , email )
2020-02-03 03:47:04 -05:00
}
// GetUserByEmailContext returns the user object by given e-mail if exists with db context
2021-09-23 11:45:36 -04:00
func GetUserByEmailContext ( ctx context . Context , email string ) ( * User , error ) {
2014-04-10 14:20:58 -04:00
if len ( email ) == 0 {
2016-11-11 18:01:09 -05:00
return nil , ErrUserNotExist { 0 , email , 0 }
2014-04-10 14:20:58 -04:00
}
2015-08-05 05:36:22 -04:00
email = strings . ToLower ( email )
2014-12-17 03:26:19 -05:00
// First try to find the user by primary email
2015-08-05 05:36:22 -04:00
user := & User { Email : email }
2021-09-23 11:45:36 -04:00
has , err := db . GetEngine ( ctx ) . Get ( user )
2014-04-10 14:20:58 -04:00
if err != nil {
return nil , err
}
2014-12-17 03:26:19 -05:00
if has {
return user , nil
}
// Otherwise, check in alternative list for activated email addresses
2021-11-11 02:03:30 -05:00
emailAddress := & user_model . EmailAddress { Email : email , IsActivated : true }
2021-09-23 11:45:36 -04:00
has , err = db . GetEngine ( ctx ) . Get ( emailAddress )
2014-12-17 03:26:19 -05:00
if err != nil {
return nil , err
}
if has {
2021-11-09 22:21:01 -05:00
return GetUserByIDCtx ( ctx , emailAddress . UID )
2014-12-17 03:26:19 -05:00
}
2019-06-06 01:54:25 -04:00
// Finally, if email address is the protected email address:
if strings . HasSuffix ( email , fmt . Sprintf ( "@%s" , setting . Service . NoReplyAddress ) ) {
username := strings . TrimSuffix ( email , fmt . Sprintf ( "@%s" , setting . Service . NoReplyAddress ) )
2020-06-17 13:50:11 -04:00
user := & User { }
2021-09-23 11:45:36 -04:00
has , err := db . GetEngine ( ctx ) . Where ( "lower_name=?" , username ) . Get ( user )
2019-06-06 01:54:25 -04:00
if err != nil {
return nil , err
}
if has {
return user , nil
}
}
2016-11-11 18:01:09 -05:00
return nil , ErrUserNotExist { 0 , email , 0 }
2014-04-10 14:20:58 -04:00
}
2017-02-22 02:14:37 -05:00
// GetUser checks if a user already exists
func GetUser ( user * User ) ( bool , error ) {
2021-09-23 11:45:36 -04:00
return db . GetEngine ( db . DefaultContext ) . Get ( user )
2017-02-22 02:14:37 -05:00
}
2016-11-28 11:47:46 -05:00
// SearchUserOptions contains the options for searching
2016-03-11 15:33:12 -05:00
type SearchUserOptions struct {
2021-09-24 07:32:56 -04:00
db . ListOptions
2017-11-26 03:40:38 -05:00
Keyword string
Type UserType
2018-10-18 04:44:51 -04:00
UID int64
2018-05-23 21:03:42 -04:00
OrderBy SearchOrderBy
2020-01-12 10:43:44 -05:00
Visible [ ] structs . VisibleType
2020-01-13 12:33:46 -05:00
Actor * User // The user doing the search
2021-10-12 14:11:35 -04:00
SearchByEmail bool // Search by email as well as username/full name
IsActive util . OptionalBool
IsAdmin util . OptionalBool
IsRestricted util . OptionalBool
IsTwoFactorEnabled util . OptionalBool
IsProhibitLogin util . OptionalBool
2016-03-11 15:33:12 -05:00
}
2021-10-12 14:11:35 -04:00
func ( opts * SearchUserOptions ) toSearchQueryBase ( ) ( sess * xorm . Session ) {
2019-08-04 14:33:36 -04:00
var cond builder . Cond = builder . Eq { "type" : opts . Type }
2017-10-24 13:36:19 -04:00
if len ( opts . Keyword ) > 0 {
lowerKeyword := strings . ToLower ( opts . Keyword )
2017-11-26 03:40:38 -05:00
keywordCond := builder . Or (
2017-10-24 13:36:19 -04:00
builder . Like { "lower_name" , lowerKeyword } ,
builder . Like { "LOWER(full_name)" , lowerKeyword } ,
2017-11-26 03:40:38 -05:00
)
if opts . SearchByEmail {
keywordCond = keywordCond . Or ( builder . Like { "LOWER(email)" , lowerKeyword } )
}
2018-10-18 04:44:51 -04:00
2017-11-26 03:40:38 -05:00
cond = cond . And ( keywordCond )
2016-03-11 15:33:12 -05:00
}
2021-06-26 15:53:14 -04:00
// If visibility filtered
2020-01-12 10:43:44 -05:00
if len ( opts . Visible ) > 0 {
cond = cond . And ( builder . In ( "visibility" , opts . Visible ) )
2019-02-18 11:00:27 -05:00
}
2020-01-13 12:33:46 -05:00
if opts . Actor != nil {
2021-08-25 08:23:34 -04:00
var exprCond builder . Cond = builder . Expr ( "org_user.org_id = `user`.id" )
2021-03-14 14:52:12 -04:00
2021-06-26 15:53:14 -04:00
// If Admin - they see all users!
if ! opts . Actor . IsAdmin {
2021-07-08 07:38:13 -04:00
// Force visibility for privacy
2021-06-26 15:53:14 -04:00
var accessCond builder . Cond
if ! opts . Actor . IsRestricted {
accessCond = builder . Or (
builder . In ( "id" , builder . Select ( "org_id" ) . From ( "org_user" ) . LeftJoin ( "`user`" , exprCond ) . Where ( builder . And ( builder . Eq { "uid" : opts . Actor . ID } , builder . Eq { "visibility" : structs . VisibleTypePrivate } ) ) ) ,
builder . In ( "visibility" , structs . VisibleTypePublic , structs . VisibleTypeLimited ) )
} else {
// restricted users only see orgs they are a member of
accessCond = builder . In ( "id" , builder . Select ( "org_id" ) . From ( "org_user" ) . LeftJoin ( "`user`" , exprCond ) . Where ( builder . And ( builder . Eq { "uid" : opts . Actor . ID } ) ) )
}
// Don't forget about self
accessCond = accessCond . Or ( builder . Eq { "id" : opts . Actor . ID } )
cond = cond . And ( accessCond )
2020-01-13 12:33:46 -05:00
}
2021-06-26 15:53:14 -04:00
} else {
2021-07-08 07:38:13 -04:00
// Force visibility for privacy
2021-06-26 15:53:14 -04:00
// Not logged in - only public users
cond = cond . And ( builder . In ( "visibility" , structs . VisibleTypePublic ) )
2019-02-18 11:00:27 -05:00
}
2018-10-18 04:44:51 -04:00
if opts . UID > 0 {
cond = cond . And ( builder . Eq { "id" : opts . UID } )
}
2017-10-24 13:36:19 -04:00
if ! opts . IsActive . IsNone ( ) {
cond = cond . And ( builder . Eq { "is_active" : opts . IsActive . IsTrue ( ) } )
2016-03-11 15:33:12 -05:00
}
2021-10-12 14:11:35 -04:00
if ! opts . IsAdmin . IsNone ( ) {
cond = cond . And ( builder . Eq { "is_admin" : opts . IsAdmin . IsTrue ( ) } )
}
if ! opts . IsRestricted . IsNone ( ) {
cond = cond . And ( builder . Eq { "is_restricted" : opts . IsRestricted . IsTrue ( ) } )
}
if ! opts . IsProhibitLogin . IsNone ( ) {
cond = cond . And ( builder . Eq { "prohibit_login" : opts . IsProhibitLogin . IsTrue ( ) } )
}
sess = db . NewSession ( db . DefaultContext )
if ! opts . IsTwoFactorEnabled . IsNone ( ) {
// 2fa filter uses LEFT JOIN to check whether a user has a 2fa record
// TODO: bad performance here, maybe there will be a column "is_2fa_enabled" in the future
if opts . IsTwoFactorEnabled . IsTrue ( ) {
cond = cond . And ( builder . Expr ( "two_factor.uid IS NOT NULL" ) )
} else {
cond = cond . And ( builder . Expr ( "two_factor.uid IS NULL" ) )
}
sess = sess . Join ( "LEFT OUTER" , "two_factor" , "two_factor.uid = `user`.id" )
}
sess = sess . Where ( cond )
return sess
2017-10-24 13:36:19 -04:00
}
2016-03-11 15:33:12 -05:00
2017-10-24 13:36:19 -04:00
// SearchUsers takes options i.e. keyword and part of user name to search,
// it returns results in given range and number of total results.
func SearchUsers ( opts * SearchUserOptions ) ( users [ ] * User , _ int64 , _ error ) {
2021-10-12 14:11:35 -04:00
sessCount := opts . toSearchQueryBase ( )
defer sessCount . Close ( )
count , err := sessCount . Count ( new ( User ) )
2016-03-11 15:33:12 -05:00
if err != nil {
return nil , 0 , fmt . Errorf ( "Count: %v" , err )
2014-04-30 23:48:01 -04:00
}
2017-10-24 13:36:19 -04:00
if len ( opts . OrderBy ) == 0 {
2018-10-19 22:25:38 -04:00
opts . OrderBy = SearchOrderByAlphabetically
2017-10-24 13:36:19 -04:00
}
2021-10-12 14:11:35 -04:00
sessQuery := opts . toSearchQueryBase ( ) . OrderBy ( opts . OrderBy . String ( ) )
defer sessQuery . Close ( )
2020-01-24 14:00:29 -05:00
if opts . Page != 0 {
2021-10-12 14:11:35 -04:00
sessQuery = db . SetSessionPagination ( sessQuery , opts )
2019-02-21 15:42:54 -05:00
}
2019-01-23 17:30:19 -05:00
2021-10-12 14:11:35 -04:00
// the sql may contain JOIN, so we must only select User related columns
sessQuery = sessQuery . Select ( "`user`.*" )
2017-10-24 13:36:19 -04:00
users = make ( [ ] * User , 0 , opts . PageSize )
2021-10-12 14:11:35 -04:00
return users , count , sessQuery . Find ( & users )
2014-04-30 23:48:01 -04:00
}
2016-11-14 17:33:58 -05:00
// GetStarredRepos returns the repos starred by a particular user
2021-09-24 07:32:56 -04:00
func GetStarredRepos ( userID int64 , private bool , listOptions db . ListOptions ) ( [ ] * Repository , error ) {
2021-09-23 11:45:36 -04:00
sess := db . GetEngine ( db . DefaultContext ) . Where ( "star.uid=?" , userID ) .
2016-11-14 17:33:58 -05:00
Join ( "LEFT" , "star" , "`repository`.id=`star`.repo_id" )
if ! private {
sess = sess . And ( "is_private=?" , false )
}
2020-01-24 14:00:29 -05:00
if listOptions . Page != 0 {
2021-09-24 07:32:56 -04:00
sess = db . SetSessionPagination ( sess , & listOptions )
2020-01-24 14:00:29 -05:00
repos := make ( [ ] * Repository , 0 , listOptions . PageSize )
return repos , sess . Find ( & repos )
2016-11-14 17:33:58 -05:00
}
2020-01-24 14:00:29 -05:00
repos := make ( [ ] * Repository , 0 , 10 )
return repos , sess . Find ( & repos )
2016-11-14 17:33:58 -05:00
}
2016-12-23 20:53:11 -05:00
// GetWatchedRepos returns the repos watched by a particular user
2021-09-24 07:32:56 -04:00
func GetWatchedRepos ( userID int64 , private bool , listOptions db . ListOptions ) ( [ ] * Repository , int64 , error ) {
2021-09-23 11:45:36 -04:00
sess := db . GetEngine ( db . DefaultContext ) . Where ( "watch.user_id=?" , userID ) .
2019-11-10 04:22:19 -05:00
And ( "`watch`.mode<>?" , RepoWatchModeDont ) .
2016-12-23 20:53:11 -05:00
Join ( "LEFT" , "watch" , "`repository`.id=`watch`.repo_id" )
if ! private {
sess = sess . And ( "is_private=?" , false )
}
2020-01-24 14:00:29 -05:00
if listOptions . Page != 0 {
2021-09-24 07:32:56 -04:00
sess = db . SetSessionPagination ( sess , & listOptions )
2020-01-24 14:00:29 -05:00
repos := make ( [ ] * Repository , 0 , listOptions . PageSize )
2021-08-12 08:43:08 -04:00
total , err := sess . FindAndCount ( & repos )
return repos , total , err
2016-12-23 20:53:11 -05:00
}
2020-01-24 14:00:29 -05:00
repos := make ( [ ] * Repository , 0 , 10 )
2021-08-12 08:43:08 -04:00
total , err := sess . FindAndCount ( & repos )
return repos , total , err
2016-12-23 20:53:11 -05:00
}
2017-05-10 09:10:18 -04:00
2020-10-14 09:07:51 -04:00
// IterateUser iterate users
func IterateUser ( f func ( user * User ) error ) error {
var start int
2021-03-14 14:52:12 -04:00
batchSize := setting . Database . IterateBufferSize
2020-10-14 09:07:51 -04:00
for {
2021-03-14 14:52:12 -04:00
users := make ( [ ] * User , 0 , batchSize )
2021-09-23 11:45:36 -04:00
if err := db . GetEngine ( db . DefaultContext ) . Limit ( batchSize , start ) . Find ( & users ) ; err != nil {
2020-10-14 09:07:51 -04:00
return err
}
if len ( users ) == 0 {
return nil
}
start += len ( users )
for _ , user := range users {
if err := f ( user ) ; err != nil {
return err
}
}
}
}
2021-11-17 04:58:31 -05:00
// GetUserByOpenID returns the user object by given OpenID if exists.
func GetUserByOpenID ( uri string ) ( * User , error ) {
if len ( uri ) == 0 {
return nil , ErrUserNotExist { 0 , uri , 0 }
}
uri , err := openid . Normalize ( uri )
if err != nil {
return nil , err
}
log . Trace ( "Normalized OpenID URI: " + uri )
// Otherwise, check in openid table
oid := & user_model . UserOpenID { }
has , err := db . GetEngine ( db . DefaultContext ) . Where ( "uri=?" , uri ) . Get ( oid )
if err != nil {
return nil , err
}
if has {
return GetUserByID ( oid . UID )
}
return nil , ErrUserNotExist { 0 , uri , 0 }
}
2021-11-18 00:58:42 -05:00
// GetAdminUser returns the first administrator
func GetAdminUser ( ) ( * User , error ) {
var admin User
has , err := db . GetEngine ( db . DefaultContext ) . Where ( "is_admin=?" , true ) . Get ( & admin )
if err != nil {
return nil , err
} else if ! has {
return nil , ErrUserNotExist { }
}
return & admin , nil
}