gitea/models/user.go

1111 lines
29 KiB
Go
Raw Normal View History

2014-04-10 18:20:58 +00:00
// Copyright 2014 The Gogs Authors. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
package models
import (
2014-11-21 15:58:08 +00:00
"bytes"
2014-09-23 19:30:04 +00:00
"container/list"
2014-04-10 18:20:58 +00:00
"crypto/sha256"
"encoding/hex"
"errors"
"fmt"
2014-11-21 15:58:08 +00:00
"image"
_ "image/jpeg"
2015-11-13 21:43:43 +00:00
"image/png"
2014-04-10 18:20:58 +00:00
"os"
"path/filepath"
"strings"
"time"
"unicode/utf8"
2014-04-10 18:20:58 +00:00
2014-07-26 04:24:27 +00:00
"github.com/Unknwon/com"
2015-09-01 16:19:52 +00:00
"github.com/go-xorm/xorm"
2014-11-21 15:58:08 +00:00
"github.com/nfnt/resize"
2014-04-10 18:20:58 +00:00
2015-12-15 22:25:45 +00:00
"github.com/gogits/git-module"
2015-11-27 05:24:24 +00:00
"github.com/gogits/gogs/modules/avatar"
2014-04-10 18:20:58 +00:00
"github.com/gogits/gogs/modules/base"
"github.com/gogits/gogs/modules/log"
2016-02-20 22:10:05 +00:00
"github.com/gogits/gogs/modules/markdown"
2014-05-26 00:11:25 +00:00
"github.com/gogits/gogs/modules/setting"
2014-04-10 18:20:58 +00:00
)
2014-06-25 04:44:48 +00:00
type UserType int
2014-04-10 18:20:58 +00:00
const (
USER_TYPE_INDIVIDUAL UserType = iota // Historic reason to make it starts at 0.
USER_TYPE_ORGANIZATION
2014-04-10 18:20:58 +00:00
)
var (
2014-05-22 01:37:13 +00:00
ErrUserNotKeyOwner = errors.New("User does not the owner of public key")
ErrEmailNotExist = errors.New("E-mail does not exist")
ErrEmailNotActivated = errors.New("E-mail address has not been activated")
2014-05-11 06:12:45 +00:00
ErrUserNameIllegal = errors.New("User name contains illegal characters")
ErrLoginSourceNotExist = errors.New("Login source does not exist")
ErrLoginSourceNotActived = errors.New("Login source is not actived")
2014-05-15 18:46:04 +00:00
ErrUnsupportedLoginType = errors.New("Login source is unknown")
2014-04-10 18:20:58 +00:00
)
// User represents the object of individual and member of organization.
type User struct {
2016-07-23 17:08:22 +00:00
ID int64 `xorm:"pk autoincr"`
LowerName string `xorm:"UNIQUE NOT NULL"`
Name string `xorm:"UNIQUE NOT NULL"`
FullName string
// Email is the primary email address (to be used for communication)
Email string `xorm:"NOT NULL"`
2014-11-21 15:58:08 +00:00
Passwd string `xorm:"NOT NULL"`
LoginType LoginType
LoginSource int64 `xorm:"NOT NULL DEFAULT 0"`
LoginName string
Type UserType
OwnedOrgs []*User `xorm:"-"`
2014-11-21 15:58:08 +00:00
Orgs []*User `xorm:"-"`
Repos []*Repository `xorm:"-"`
Location string
Website string
Rands string `xorm:"VARCHAR(10)"`
Salt string `xorm:"VARCHAR(10)"`
Created time.Time `xorm:"-"`
CreatedUnix int64
Updated time.Time `xorm:"-"`
UpdatedUnix int64
2014-11-21 15:58:08 +00:00
2015-10-25 08:26:26 +00:00
// Remember visibility choice for convenience, true for private
LastRepoVisibility bool
// Maximum repository creation limit, -1 means use gloabl default
2015-12-10 17:48:45 +00:00
MaxRepoCreation int `xorm:"NOT NULL DEFAULT -1"`
// Permissions
IsActive bool // Activate primary email
IsAdmin bool
AllowGitHook bool
AllowImportLocal bool // Allow migrate repository by local path
2016-07-16 02:22:16 +00:00
ProhibitLogin bool
2014-11-21 15:58:08 +00:00
// Avatar
2014-11-21 15:58:08 +00:00
Avatar string `xorm:"VARCHAR(2048) NOT NULL"`
AvatarEmail string `xorm:"NOT NULL"`
UseCustomAvatar bool
// Counters
NumFollowers int
NumFollowing int `xorm:"NOT NULL DEFAULT 0"`
NumStars int
NumRepos int
2014-06-25 04:44:48 +00:00
// For organization
2014-06-27 07:37:01 +00:00
Description string
NumTeams int
NumMembers int
2014-06-28 19:43:25 +00:00
Teams []*Team `xorm:"-"`
Members []*User `xorm:"-"`
2014-04-10 18:20:58 +00:00
}
func (u *User) BeforeInsert() {
u.CreatedUnix = time.Now().Unix()
u.UpdatedUnix = u.CreatedUnix
}
2015-12-10 17:37:53 +00:00
func (u *User) BeforeUpdate() {
2015-12-10 17:46:05 +00:00
if u.MaxRepoCreation < -1 {
u.MaxRepoCreation = -1
2015-12-10 17:37:53 +00:00
}
u.UpdatedUnix = time.Now().Unix()
2015-12-10 17:37:53 +00:00
}
2015-09-01 16:19:52 +00:00
func (u *User) AfterSet(colName string, _ xorm.Cell) {
switch colName {
case "full_name":
2016-02-20 22:10:05 +00:00
u.FullName = markdown.Sanitizer.Sanitize(u.FullName)
case "created_unix":
u.Created = time.Unix(u.CreatedUnix, 0).Local()
case "updated_unix":
u.Updated = time.Unix(u.UpdatedUnix, 0).Local()
2015-09-01 16:19:52 +00:00
}
}
// returns true if user login type is LOGIN_PLAIN.
func (u *User) IsLocal() bool {
return u.LoginType <= LOGIN_PLAIN
}
2015-11-16 15:14:12 +00:00
// HasForkedRepo checks if user has already forked a repository with given ID.
func (u *User) HasForkedRepo(repoID int64) bool {
2016-07-23 17:08:22 +00:00
_, has := HasForkedRepo(u.ID, repoID)
2015-11-16 15:14:12 +00:00
return has
}
2015-12-10 17:37:53 +00:00
func (u *User) RepoCreationNum() int {
2015-12-10 17:46:05 +00:00
if u.MaxRepoCreation <= -1 {
2015-12-10 17:37:53 +00:00
return setting.Repository.MaxCreationLimit
}
return u.MaxRepoCreation
}
func (u *User) CanCreateRepo() bool {
2015-12-10 17:46:05 +00:00
if u.MaxRepoCreation <= -1 {
if setting.Repository.MaxCreationLimit <= -1 {
return true
}
2015-12-10 17:37:53 +00:00
return u.NumRepos < setting.Repository.MaxCreationLimit
}
return u.NumRepos < u.MaxRepoCreation
}
// CanEditGitHook returns true if user can edit Git hooks.
func (u *User) CanEditGitHook() bool {
return u.IsAdmin || u.AllowGitHook
}
// CanImportLocal returns true if user can migrate repository by local path.
func (u *User) CanImportLocal() bool {
return u.IsAdmin || u.AllowImportLocal
}
2014-07-26 04:24:27 +00:00
// DashboardLink returns the user dashboard page link.
func (u *User) DashboardLink() string {
if u.IsOrganization() {
2014-09-20 00:11:34 +00:00
return setting.AppSubUrl + "/org/" + u.Name + "/dashboard/"
2014-07-26 04:24:27 +00:00
}
2014-09-20 00:11:34 +00:00
return setting.AppSubUrl + "/"
2014-07-26 04:24:27 +00:00
}
2015-08-26 13:45:51 +00:00
// HomeLink returns the user or organization home page link.
2014-06-25 04:44:48 +00:00
func (u *User) HomeLink() string {
2014-09-28 11:55:58 +00:00
return setting.AppSubUrl + "/" + u.Name
2014-04-10 18:20:58 +00:00
}
// GenerateEmailActivateCode generates an activate code based on user information and given e-mail.
func (u *User) GenerateEmailActivateCode(email string) string {
code := base.CreateTimeLimitCode(
2016-07-23 17:08:22 +00:00
com.ToStr(u.ID)+email+u.LowerName+u.Passwd+u.Rands,
setting.Service.ActiveCodeLives, nil)
// Add tail hex username
code += hex.EncodeToString([]byte(u.LowerName))
return code
}
// GenerateActivateCode generates an activate code based on user information.
func (u *User) GenerateActivateCode() string {
return u.GenerateEmailActivateCode(u.Email)
}
2014-04-10 18:20:58 +00:00
// CustomAvatarPath returns user custom avatar file path.
func (u *User) CustomAvatarPath() string {
2016-07-23 17:08:22 +00:00
return filepath.Join(setting.AvatarUploadPath, com.ToStr(u.ID))
}
// GenerateRandomAvatar generates a random avatar for user.
func (u *User) GenerateRandomAvatar() error {
seed := u.Email
if len(seed) == 0 {
seed = u.Name
}
img, err := avatar.RandomImage([]byte(seed))
if err != nil {
return fmt.Errorf("RandomImage: %v", err)
}
if err = os.MkdirAll(filepath.Dir(u.CustomAvatarPath()), os.ModePerm); err != nil {
return fmt.Errorf("MkdirAll: %v", err)
}
fw, err := os.Create(u.CustomAvatarPath())
if err != nil {
return fmt.Errorf("Create: %v", err)
}
defer fw.Close()
if err = png.Encode(fw, img); err != nil {
return fmt.Errorf("Encode: %v", err)
}
2016-07-23 17:08:22 +00:00
log.Info("New random avatar created: %d", u.ID)
return nil
}
2015-08-28 15:36:13 +00:00
func (u *User) RelAvatarLink() string {
defaultImgUrl := "/img/avatar_default.png"
2016-07-23 17:08:22 +00:00
if u.ID == -1 {
return defaultImgUrl
}
2014-11-21 15:58:08 +00:00
switch {
case u.UseCustomAvatar:
if !com.IsExist(u.CustomAvatarPath()) {
return defaultImgUrl
}
2016-07-23 17:08:22 +00:00
return "/avatars/" + com.ToStr(u.ID)
case setting.DisableGravatar, setting.OfflineMode:
if !com.IsExist(u.CustomAvatarPath()) {
if err := u.GenerateRandomAvatar(); err != nil {
log.Error(3, "GenerateRandomAvatar: %v", err)
}
}
2016-07-23 17:08:22 +00:00
return "/avatars/" + com.ToStr(u.ID)
2014-04-10 18:20:58 +00:00
}
2014-11-17 01:27:04 +00:00
return setting.GravatarSource + u.Avatar
2014-04-10 18:20:58 +00:00
}
// AvatarLink returns user avatar absolute link.
2015-08-28 15:36:13 +00:00
func (u *User) AvatarLink() string {
link := u.RelAvatarLink()
2015-09-02 09:16:30 +00:00
if link[0] == '/' && link[1] != '/' {
return setting.AppUrl + link[1:]
2015-08-28 15:36:13 +00:00
}
return link
}
// User.GetFollwoers returns range of user's followers.
func (u *User) GetFollowers(page int) ([]*User, error) {
users := make([]*User, 0, ItemsPerPage)
2016-07-23 17:08:22 +00:00
sess := x.Limit(ItemsPerPage, (page-1)*ItemsPerPage).Where("follow.follow_id=?", u.ID)
if setting.UsePostgreSQL {
sess = sess.Join("LEFT", "follow", `"user".id=follow.user_id`)
} else {
sess = sess.Join("LEFT", "follow", "user.id=follow.user_id")
}
return users, sess.Find(&users)
}
func (u *User) IsFollowing(followID int64) bool {
2016-07-23 17:08:22 +00:00
return IsFollowing(u.ID, followID)
}
// GetFollowing returns range of user's following.
func (u *User) GetFollowing(page int) ([]*User, error) {
users := make([]*User, 0, ItemsPerPage)
2016-07-23 17:08:22 +00:00
sess := x.Limit(ItemsPerPage, (page-1)*ItemsPerPage).Where("follow.user_id=?", u.ID)
if setting.UsePostgreSQL {
sess = sess.Join("LEFT", "follow", `"user".id=follow.follow_id`)
} else {
sess = sess.Join("LEFT", "follow", "user.id=follow.follow_id")
}
return users, sess.Find(&users)
}
2014-04-10 18:20:58 +00:00
// NewGitSig generates and returns the signature of given user.
2014-06-25 04:44:48 +00:00
func (u *User) NewGitSig() *git.Signature {
2014-04-10 18:20:58 +00:00
return &git.Signature{
2014-06-25 04:44:48 +00:00
Name: u.Name,
Email: u.Email,
2014-04-10 18:20:58 +00:00
When: time.Now(),
}
}
// EncodePasswd encodes password to safe format.
2014-06-25 04:44:48 +00:00
func (u *User) EncodePasswd() {
newPasswd := base.PBKDF2([]byte(u.Passwd), []byte(u.Salt), 10000, 50, sha256.New)
u.Passwd = fmt.Sprintf("%x", newPasswd)
}
2015-04-16 18:40:39 +00:00
// ValidatePassword checks if given password matches the one belongs to the user.
2015-04-16 18:36:32 +00:00
func (u *User) ValidatePassword(passwd string) bool {
2014-08-02 17:47:33 +00:00
newUser := &User{Passwd: passwd, Salt: u.Salt}
newUser.EncodePasswd()
return u.Passwd == newUser.Passwd
}
2014-11-21 15:58:08 +00:00
// UploadAvatar saves custom avatar for user.
2014-12-07 01:22:48 +00:00
// FIXME: split uploads to different subdirs in case we have massive users.
2014-11-21 15:58:08 +00:00
func (u *User) UploadAvatar(data []byte) error {
img, _, err := image.Decode(bytes.NewReader(data))
if err != nil {
2015-11-13 21:43:43 +00:00
return fmt.Errorf("Decode: %v", err)
2014-11-21 15:58:08 +00:00
}
m := resize.Resize(avatar.AVATAR_SIZE, avatar.AVATAR_SIZE, img, resize.NearestNeighbor)
2014-11-21 15:58:08 +00:00
sess := x.NewSession()
defer sessionRelease(sess)
2014-11-21 15:58:08 +00:00
if err = sess.Begin(); err != nil {
return err
}
2015-11-13 21:43:43 +00:00
u.UseCustomAvatar = true
if err = updateUser(sess, u); err != nil {
return fmt.Errorf("updateUser: %v", err)
2014-11-21 15:58:08 +00:00
}
2014-11-21 17:51:36 +00:00
os.MkdirAll(setting.AvatarUploadPath, os.ModePerm)
2014-11-22 15:22:53 +00:00
fw, err := os.Create(u.CustomAvatarPath())
2014-11-21 15:58:08 +00:00
if err != nil {
2015-11-13 21:43:43 +00:00
return fmt.Errorf("Create: %v", err)
2014-11-21 15:58:08 +00:00
}
defer fw.Close()
2015-11-13 21:43:43 +00:00
if err = png.Encode(fw, m); err != nil {
return fmt.Errorf("Encode: %v", err)
2014-11-21 15:58:08 +00:00
}
return sess.Commit()
}
2016-03-06 16:36:30 +00:00
// DeleteAvatar deletes the user's custom avatar.
func (u *User) DeleteAvatar() error {
2016-07-23 17:08:22 +00:00
log.Trace("DeleteAvatar[%d]: %s", u.ID, u.CustomAvatarPath())
2016-03-06 16:36:30 +00:00
os.Remove(u.CustomAvatarPath())
u.UseCustomAvatar = false
if err := UpdateUser(u); err != nil {
2016-03-06 18:24:42 +00:00
return fmt.Errorf("UpdateUser: %v", err)
2016-03-06 16:36:30 +00:00
}
return nil
}
// IsAdminOfRepo returns true if user has admin or higher access of repository.
func (u *User) IsAdminOfRepo(repo *Repository) bool {
has, err := HasAccess(u, repo, ACCESS_MODE_ADMIN)
if err != nil {
log.Error(3, "HasAccess: %v", err)
}
return has
}
// IsWriterOfRepo returns true if user has write access to given repository.
func (u *User) IsWriterOfRepo(repo *Repository) bool {
has, err := HasAccess(u, repo, ACCESS_MODE_WRITE)
if err != nil {
log.Error(3, "HasAccess: %v", err)
}
return has
}
2014-06-28 04:40:07 +00:00
// IsOrganization returns true if user is actually a organization.
2014-06-25 04:44:48 +00:00
func (u *User) IsOrganization() bool {
return u.Type == USER_TYPE_ORGANIZATION
2014-06-25 04:44:48 +00:00
}
// IsUserOrgOwner returns true if user is in the owner team of given organization.
func (u *User) IsUserOrgOwner(orgId int64) bool {
2016-07-23 17:08:22 +00:00
return IsOrganizationOwner(orgId, u.ID)
}
// IsPublicMember returns true if user public his/her membership in give organization.
func (u *User) IsPublicMember(orgId int64) bool {
2016-07-23 17:08:22 +00:00
return IsPublicMembership(orgId, u.ID)
}
2015-09-06 12:54:08 +00:00
func (u *User) getOrganizationCount(e Engine) (int64, error) {
2016-07-23 17:08:22 +00:00
return e.Where("uid=?", u.ID).Count(new(OrgUser))
2015-09-06 12:54:08 +00:00
}
2014-06-28 19:43:25 +00:00
// GetOrganizationCount returns count of membership of organization of user.
func (u *User) GetOrganizationCount() (int64, error) {
2015-09-06 12:54:08 +00:00
return u.getOrganizationCount(x)
2014-06-28 19:43:25 +00:00
}
2016-07-24 06:32:46 +00:00
// GetRepositories returns repositories that user owns, including private repositories.
func (u *User) GetRepositories(page, pageSize int) (err error) {
u.Repos, err = GetUserRepositories(u.ID, true, page, pageSize)
return err
}
2016-07-24 06:32:46 +00:00
// GetRepositories returns mirror repositories that user owns, including private repositories.
func (u *User) GetMirrorRepositories() ([]*Repository, error) {
return GetUserMirrorRepositories(u.ID)
}
// GetOwnedOrganizations returns all organizations that user owns.
func (u *User) GetOwnedOrganizations() (err error) {
2016-07-23 17:08:22 +00:00
u.OwnedOrgs, err = GetOwnedOrgsByUserID(u.ID)
return err
}
2014-06-28 04:40:07 +00:00
// GetOrganizations returns all organizations that user belongs to.
2015-12-17 07:28:47 +00:00
func (u *User) GetOrganizations(all bool) error {
2016-07-23 17:08:22 +00:00
ous, err := GetOrgUsersByUserID(u.ID, all)
2014-06-25 04:44:48 +00:00
if err != nil {
return err
}
u.Orgs = make([]*User, len(ous))
for i, ou := range ous {
2015-08-08 14:43:14 +00:00
u.Orgs[i], err = GetUserByID(ou.OrgID)
2014-06-25 04:44:48 +00:00
if err != nil {
return err
}
}
return nil
2014-04-10 18:20:58 +00:00
}
2015-08-27 05:26:38 +00:00
// DisplayName returns full name if it's not empty,
// returns username otherwise.
func (u *User) DisplayName() string {
if len(u.FullName) > 0 {
return u.FullName
}
2015-08-27 05:26:38 +00:00
return u.Name
}
func (u *User) ShortName(length int) string {
return base.EllipsisString(u.Name, length)
}
2014-04-10 18:20:58 +00: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) {
2014-04-10 18:20:58 +00:00
if len(name) == 0 {
return false, nil
}
return x.Where("id!=?", uid).Get(&User{LowerName: strings.ToLower(name)})
2014-04-10 18:20:58 +00:00
}
2014-10-24 22:43:17 +00:00
// GetUserSalt returns a ramdom user salt token.
2014-04-10 18:20:58 +00:00
func GetUserSalt() string {
return base.GetRandomString(10)
}
// NewFakeUser creates and returns a fake user for someone has deleted his/her account.
func NewFakeUser() *User {
return &User{
2016-07-23 17:08:22 +00:00
ID: -1,
Name: "Someone",
LowerName: "someone",
}
}
var (
reversedUsernames = []string{"debug", "raw", "install", "api", "avatar", "user", "org", "help", "stars", "issues", "pulls", "commits", "repo", "template", "admin", "new", ".", ".."}
reversedUserPatterns = []string{"*.keys"}
)
// isUsableName checks if name is reserved or pattern of name is not allowed
// based on given reversed names and patterns.
// 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
}
func IsUsableUsername(name string) error {
return isUsableName(reversedUsernames, reversedUserPatterns, name)
}
2014-06-25 04:44:48 +00:00
// CreateUser creates record of a new user.
func CreateUser(u *User) (err error) {
if err = IsUsableUsername(u.Name); err != nil {
return err
2014-06-25 04:44:48 +00:00
}
isExist, err := IsUserExist(0, u.Name)
2014-06-25 04:44:48 +00:00
if err != nil {
2014-07-26 04:24:27 +00:00
return err
2014-06-25 04:44:48 +00:00
} else if isExist {
return ErrUserAlreadyExist{u.Name}
2014-06-25 04:44:48 +00:00
}
2015-11-24 01:43:04 +00:00
u.Email = strings.ToLower(u.Email)
2014-06-25 04:44:48 +00:00
isExist, err = IsEmailUsed(u.Email)
if err != nil {
2014-07-26 04:24:27 +00:00
return err
2014-06-25 04:44:48 +00:00
} else if isExist {
return ErrEmailAlreadyUsed{u.Email}
2014-06-25 04:44:48 +00:00
}
u.LowerName = strings.ToLower(u.Name)
u.AvatarEmail = u.Email
u.Avatar = base.HashEmail(u.AvatarEmail)
2014-06-25 04:44:48 +00:00
u.Rands = GetUserSalt()
u.Salt = GetUserSalt()
u.EncodePasswd()
u.MaxRepoCreation = -1
2014-06-25 04:44:48 +00:00
sess := x.NewSession()
defer sessionRelease(sess)
2014-06-25 04:44:48 +00:00
if err = sess.Begin(); err != nil {
2014-07-26 04:24:27 +00:00
return err
2014-06-25 04:44:48 +00:00
}
if _, err = sess.Insert(u); err != nil {
2014-07-26 04:24:27 +00:00
return err
} else if err = os.MkdirAll(UserPath(u.Name), os.ModePerm); err != nil {
return err
2014-06-25 04:44:48 +00:00
}
return sess.Commit()
2014-06-25 04:44:48 +00:00
}
func countUsers(e Engine) int64 {
count, _ := e.Where("type=0").Count(new(User))
return count
}
// CountUsers returns number of users.
func CountUsers() int64 {
return countUsers(x)
}
2015-09-12 00:42:26 +00:00
// Users returns number of users in given page.
func Users(page, pageSize int) ([]*User, error) {
users := make([]*User, 0, pageSize)
return users, x.Limit(pageSize, (page-1)*pageSize).Where("type=0").Asc("id").Find(&users)
2014-04-10 18:20:58 +00:00
}
// get user by erify code
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
}
2014-07-26 04:24:27 +00:00
log.Error(4, "user.getVerifyUser: %v", err)
2014-04-10 18:20:58 +00:00
}
return nil
}
// verify active code when active account
func VerifyUserActiveCode(code string) (user *User) {
2014-05-26 00:11:25 +00:00
minutes := setting.Service.ActiveCodeLives
2014-04-10 18:20:58 +00:00
if user = getVerifyUser(code); user != nil {
// time limit code
prefix := code[:base.TimeLimitCodeLength]
2016-07-23 17:08:22 +00:00
data := com.ToStr(user.ID) + user.Email + user.LowerName + user.Passwd + user.Rands
2014-04-10 18:20:58 +00:00
if base.VerifyTimeLimitCode(data, minutes, prefix) {
return user
}
}
return nil
}
// verify active code when active account
func VerifyActiveEmailCode(code, email string) *EmailAddress {
minutes := setting.Service.ActiveCodeLives
if user := getVerifyUser(code); user != nil {
// time limit code
prefix := code[:base.TimeLimitCodeLength]
2016-07-23 17:08:22 +00:00
data := com.ToStr(user.ID) + email + user.LowerName + user.Passwd + user.Rands
if base.VerifyTimeLimitCode(data, minutes, prefix) {
emailAddress := &EmailAddress{Email: email}
if has, _ := x.Get(emailAddress); has {
return emailAddress
}
}
}
return nil
}
2014-04-10 18:20:58 +00:00
// ChangeUserName changes all corresponding setting from old user name to new one.
2014-07-26 04:24:27 +00:00
func ChangeUserName(u *User, newUserName string) (err error) {
if err = IsUsableUsername(newUserName); err != nil {
return err
}
isExist, err := IsUserExist(0, newUserName)
if err != nil {
return err
} else if isExist {
return ErrUserAlreadyExist{newUserName}
2014-07-26 04:24:27 +00:00
}
if err = ChangeUsernameInPullRequests(u.Name, newUserName); err != nil {
return fmt.Errorf("ChangeUsernameInPullRequests: %v", err)
2016-01-27 21:45:03 +00:00
}
// Delete all local copies of repository wiki that user owns.
2016-07-23 17:08:22 +00:00
if err = x.Where("owner_id=?", u.ID).Iterate(new(Repository), func(idx int, bean interface{}) error {
repo := bean.(*Repository)
RemoveAllWithNotice("Delete repository wiki local copy", repo.LocalWikiPath())
return nil
}); err != nil {
return fmt.Errorf("Delete repository wiki local copy: %v", err)
}
return os.Rename(UserPath(u.Name), UserPath(newUserName))
2014-04-10 18:20:58 +00:00
}
func updateUser(e Engine, u *User) error {
// Organization does not need email
if !u.IsOrganization() {
u.Email = strings.ToLower(u.Email)
2016-07-23 17:08:22 +00:00
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 {
return ErrEmailAlreadyUsed{u.Email}
}
if len(u.AvatarEmail) == 0 {
u.AvatarEmail = u.Email
}
u.Avatar = base.HashEmail(u.AvatarEmail)
2014-11-30 23:29:16 +00:00
}
2014-06-06 02:07:35 +00:00
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)
2014-04-10 18:20:58 +00:00
2016-02-20 22:10:05 +00:00
u.FullName = markdown.Sanitizer.Sanitize(u.FullName)
2016-07-23 17:08:22 +00:00
_, err := e.Id(u.ID).AllCols().Update(u)
2014-04-10 18:20:58 +00:00
return err
}
// UpdateUser updates user's information.
func UpdateUser(u *User) error {
return updateUser(x, u)
}
2015-09-06 12:54:08 +00:00
// deleteBeans deletes all given beans, beans should contain delete conditions.
func deleteBeans(e Engine, beans ...interface{}) (err error) {
for i := range beans {
if _, err = e.Delete(beans[i]); err != nil {
return err
}
}
return nil
}
2014-11-13 10:27:01 +00:00
// FIXME: need some kind of mechanism to record failure. HINT: system notice
2015-09-06 12:54:08 +00:00
func deleteUser(e *xorm.Session, u *User) error {
2015-08-17 09:05:37 +00:00
// Note: A user owns any repository or belongs to any organization
// cannot perform delete operation.
2014-04-10 18:20:58 +00:00
// Check ownership of repository.
2015-09-06 12:54:08 +00:00
count, err := getRepositoryCount(e, u)
2014-04-10 18:20:58 +00:00
if err != nil {
return fmt.Errorf("GetRepositoryCount: %v", err)
2014-04-10 18:20:58 +00:00
} else if count > 0 {
2016-07-23 17:08:22 +00:00
return ErrUserOwnRepos{UID: u.ID}
2014-04-10 18:20:58 +00:00
}
2014-06-27 07:37:01 +00:00
// Check membership of organization.
2015-09-06 12:54:08 +00:00
count, err = u.getOrganizationCount(e)
2014-06-27 07:37:01 +00:00
if err != nil {
return fmt.Errorf("GetOrganizationCount: %v", err)
2014-06-27 07:37:01 +00:00
} else if count > 0 {
2016-07-23 17:08:22 +00:00
return ErrUserHasOrgs{UID: u.ID}
2014-06-27 07:37:01 +00:00
}
2015-08-17 09:05:37 +00:00
// ***** START: Watch *****
watches := make([]*Watch, 0, 10)
2016-07-23 17:08:22 +00:00
if err = e.Find(&watches, &Watch{UserID: u.ID}); err != nil {
return fmt.Errorf("get all watches: %v", err)
2014-04-10 18:20:58 +00:00
}
for i := range watches {
2015-09-06 12:54:08 +00:00
if _, err = e.Exec("UPDATE `repository` SET num_watches=num_watches-1 WHERE id=?", watches[i].RepoID); err != nil {
2015-08-17 09:05:37 +00:00
return fmt.Errorf("decrease repository watch number[%d]: %v", watches[i].RepoID, err)
}
2014-04-12 01:47:39 +00:00
}
2015-08-17 09:05:37 +00:00
// ***** END: Watch *****
2015-08-17 09:05:37 +00:00
// ***** START: Star *****
stars := make([]*Star, 0, 10)
2016-07-23 17:08:22 +00:00
if err = e.Find(&stars, &Star{UID: u.ID}); err != nil {
2015-08-17 09:05:37 +00:00
return fmt.Errorf("get all stars: %v", err)
}
for i := range stars {
2015-09-06 12:54:08 +00:00
if _, err = e.Exec("UPDATE `repository` SET num_stars=num_stars-1 WHERE id=?", stars[i].RepoID); err != nil {
2015-08-17 09:05:37 +00:00
return fmt.Errorf("decrease repository star number[%d]: %v", stars[i].RepoID, err)
}
}
// ***** END: Star *****
2015-08-17 09:05:37 +00:00
// ***** START: Follow *****
followers := make([]*Follow, 0, 10)
2016-07-23 17:08:22 +00:00
if err = e.Find(&followers, &Follow{UserID: u.ID}); err != nil {
2015-08-17 09:05:37 +00:00
return fmt.Errorf("get all followers: %v", err)
}
for i := range followers {
2015-09-06 12:54:08 +00:00
if _, err = e.Exec("UPDATE `user` SET num_followers=num_followers-1 WHERE id=?", followers[i].UserID); err != nil {
2015-08-17 09:05:37 +00:00
return fmt.Errorf("decrease user follower number[%d]: %v", followers[i].UserID, err)
}
2014-04-10 18:20:58 +00:00
}
2015-08-17 09:05:37 +00:00
// ***** END: Follow *****
2015-09-06 12:54:08 +00:00
if err = deleteBeans(e,
2016-07-23 17:08:22 +00:00
&AccessToken{UID: u.ID},
&Collaboration{UserID: u.ID},
&Access{UserID: u.ID},
&Watch{UserID: u.ID},
&Star{UID: u.ID},
&Follow{FollowID: u.ID},
&Action{UserID: u.ID},
&IssueUser{UID: u.ID},
&EmailAddress{UID: u.ID},
); err != nil {
2015-12-01 01:45:55 +00:00
return fmt.Errorf("deleteBeans: %v", err)
2014-04-10 18:20:58 +00:00
}
2015-08-17 09:05:37 +00:00
// ***** START: PublicKey *****
2014-05-06 20:28:52 +00:00
keys := make([]*PublicKey, 0, 10)
2016-07-23 17:08:22 +00:00
if err = e.Find(&keys, &PublicKey{OwnerID: u.ID}); err != nil {
2015-08-17 09:05:37 +00:00
return fmt.Errorf("get all public keys: %v", err)
2014-04-10 18:20:58 +00:00
}
keyIDs := make([]int64, len(keys))
for i := range keys {
keyIDs[i] = keys[i].ID
}
if err = deletePublicKeys(e, keyIDs...); err != nil {
return fmt.Errorf("deletePublicKeys: %v", err)
2014-04-10 18:20:58 +00:00
}
2015-08-17 09:05:37 +00:00
// ***** END: PublicKey *****
2014-04-10 18:20:58 +00:00
// Clear assignee.
2016-07-23 17:08:22 +00:00
if _, err = e.Exec("UPDATE `issue` SET assignee_id=0 WHERE assignee_id=?", u.ID); err != nil {
2015-08-17 09:05:37 +00:00
return fmt.Errorf("clear assignee: %v", err)
}
2016-07-23 17:08:22 +00:00
if _, err = e.Id(u.ID).Delete(new(User)); err != nil {
2015-08-17 09:05:37 +00:00
return fmt.Errorf("Delete: %v", err)
}
2015-08-17 09:05:37 +00:00
// FIXME: system notice
// Note: There are something just cannot be roll back,
// so just keep error logs of those operations.
os.RemoveAll(UserPath(u.Name))
2015-08-11 19:46:08 +00:00
os.Remove(u.CustomAvatarPath())
2014-04-10 18:20:58 +00:00
2015-08-17 09:05:37 +00:00
return nil
2014-06-21 04:51:41 +00:00
}
2015-09-06 12:54:08 +00:00
// DeleteUser completely and permanently deletes everything of a user,
// but issues/comments/pulls will be kept and shown as someone has been deleted.
func DeleteUser(u *User) (err error) {
sess := x.NewSession()
defer sessionRelease(sess)
if err = sess.Begin(); err != nil {
return err
}
if err = deleteUser(sess, u); err != nil {
2015-09-13 17:26:20 +00:00
// Note: don't wrapper error here.
return err
2015-09-06 12:54:08 +00:00
}
if err = sess.Commit(); err != nil {
return err
}
return RewriteAllPublicKeys()
2015-09-06 12:54:08 +00:00
}
// DeleteInactivateUsers deletes all inactivate users and email addresses.
2015-08-17 09:05:37 +00:00
func DeleteInactivateUsers() (err error) {
users := make([]*User, 0, 10)
if err = x.Where("is_active = ?", false).Find(&users); err != nil {
2015-08-17 09:05:37 +00:00
return fmt.Errorf("get all inactive users: %v", err)
}
// FIXME: should only update authorized_keys file once after all deletions.
2015-08-17 09:05:37 +00:00
for _, u := range users {
if err = DeleteUser(u); err != nil {
// Ignore users that were set inactive by admin.
if IsErrUserOwnRepos(err) || IsErrUserHasOrgs(err) {
continue
}
return err
}
}
2015-08-17 09:05:37 +00:00
_, err = x.Where("is_activated = ?", false).Delete(new(EmailAddress))
2014-04-10 18:20:58 +00:00
return err
}
// UserPath returns the path absolute path of user repositories.
func UserPath(userName string) string {
2014-05-26 00:11:25 +00:00
return filepath.Join(setting.RepoRootPath, strings.ToLower(userName))
2014-04-10 18:20:58 +00:00
}
2015-11-05 02:57:10 +00:00
func GetUserByKeyID(keyID int64) (*User, error) {
2014-04-10 18:20:58 +00:00
user := new(User)
2015-11-05 02:57:10 +00:00
has, err := x.Sql("SELECT a.* FROM `user` AS a, public_key AS b WHERE a.id = b.owner_id AND b.id=?", keyID).Get(user)
2014-04-10 18:20:58 +00:00
if err != nil {
return nil, err
} else if !has {
2014-05-22 01:37:13 +00:00
return nil, ErrUserNotKeyOwner
2014-04-10 18:20:58 +00:00
}
return user, nil
}
2015-08-08 14:43:14 +00:00
func getUserByID(e Engine, id int64) (*User, error) {
2014-06-06 02:07:35 +00:00
u := new(User)
2015-02-13 05:58:46 +00:00
has, err := e.Id(id).Get(u)
2014-04-10 18:20:58 +00:00
if err != nil {
return nil, err
2014-06-06 02:07:35 +00:00
} else if !has {
2015-08-05 03:14:17 +00:00
return nil, ErrUserNotExist{id, ""}
2014-04-10 18:20:58 +00:00
}
2014-06-06 02:07:35 +00:00
return u, nil
2014-04-10 18:20:58 +00:00
}
2015-08-08 14:43:14 +00:00
// GetUserByID returns the user object by given ID if exists.
func GetUserByID(id int64) (*User, error) {
return getUserByID(x, id)
2015-02-13 05:58:46 +00:00
}
// GetAssigneeByID returns the user with write access of repository by given ID.
func GetAssigneeByID(repo *Repository, userID int64) (*User, error) {
2016-07-23 17:08:22 +00:00
has, err := HasAccess(&User{ID: userID}, repo, ACCESS_MODE_WRITE)
if err != nil {
return nil, err
} else if !has {
return nil, ErrUserNotExist{userID, ""}
}
return GetUserByID(userID)
}
2014-10-24 22:43:17 +00:00
// GetUserByName returns user by given name.
2014-04-10 18:20:58 +00:00
func GetUserByName(name string) (*User, error) {
if len(name) == 0 {
2015-08-05 03:14:17 +00:00
return nil, ErrUserNotExist{0, name}
2014-04-10 18:20:58 +00:00
}
2014-10-24 22:43:17 +00:00
u := &User{LowerName: strings.ToLower(name)}
has, err := x.Get(u)
2014-04-10 18:20:58 +00:00
if err != nil {
return nil, err
} else if !has {
2015-08-05 03:14:17 +00:00
return nil, ErrUserNotExist{0, name}
2014-04-10 18:20:58 +00:00
}
2014-10-24 22:43:17 +00:00
return u, nil
2014-04-10 18:20:58 +00:00
}
// GetUserEmailsByNames returns a list of e-mails corresponds to names.
2014-04-10 18:20:58 +00:00
func GetUserEmailsByNames(names []string) []string {
mails := make([]string, 0, len(names))
for _, name := range names {
u, err := GetUserByName(name)
if err != nil {
continue
}
mails = append(mails, u.Email)
}
return mails
}
// GetUserIDsByNames returns a slice of ids corresponds to names.
func GetUserIDsByNames(names []string) []int64 {
ids := make([]int64, 0, len(names))
for _, name := range names {
u, err := GetUserByName(name)
if err != nil {
continue
}
2016-07-23 17:08:22 +00:00
ids = append(ids, u.ID)
}
return ids
}
2014-12-07 01:22:48 +00:00
// UserCommit represents a commit with validation of user.
2014-09-23 19:30:04 +00:00
type UserCommit struct {
2014-11-21 15:58:08 +00:00
User *User
*git.Commit
2014-09-23 19:30:04 +00:00
}
2014-09-26 12:55:13 +00:00
// ValidateCommitWithEmail chceck if author's e-mail of commit is corresponsind to a user.
func ValidateCommitWithEmail(c *git.Commit) *User {
2014-09-26 12:55:13 +00:00
u, err := GetUserByEmail(c.Author.Email)
2014-11-21 15:58:08 +00:00
if err != nil {
return nil
2014-09-26 12:55:13 +00:00
}
2014-11-21 15:58:08 +00:00
return u
2014-09-26 12:55:13 +00:00
}
// ValidateCommitsWithEmails checks if authors' e-mails of commits are corresponding to users.
func ValidateCommitsWithEmails(oldCommits *list.List) *list.List {
2015-08-05 09:36:22 +00:00
var (
u *User
emails = map[string]*User{}
newCommits = list.New()
e = oldCommits.Front()
)
2014-09-23 19:30:04 +00:00
for e != nil {
c := e.Value.(*git.Commit)
2014-09-23 19:30:04 +00:00
2014-09-24 03:18:14 +00:00
if v, ok := emails[c.Author.Email]; !ok {
2014-11-21 15:58:08 +00:00
u, _ = GetUserByEmail(c.Author.Email)
emails[c.Author.Email] = u
2014-09-24 03:18:14 +00:00
} else {
2014-11-21 15:58:08 +00:00
u = v
2014-09-23 19:30:04 +00:00
}
newCommits.PushBack(UserCommit{
2014-11-21 15:58:08 +00:00
User: u,
Commit: c,
2014-09-23 19:30:04 +00:00
})
e = e.Next()
}
return newCommits
}
2014-04-10 18:20:58 +00:00
// GetUserByEmail returns the user object by given e-mail if exists.
func GetUserByEmail(email string) (*User, error) {
if len(email) == 0 {
2015-08-05 03:14:17 +00:00
return nil, ErrUserNotExist{0, "email"}
2014-04-10 18:20:58 +00:00
}
2015-08-05 09:36:22 +00:00
email = strings.ToLower(email)
// First try to find the user by primary email
2015-08-05 09:36:22 +00:00
user := &User{Email: email}
2014-06-21 04:51:41 +00:00
has, err := x.Get(user)
2014-04-10 18:20:58 +00:00
if err != nil {
return nil, err
}
if has {
return user, nil
}
// Otherwise, check in alternative list for activated email addresses
2015-08-05 09:36:22 +00:00
emailAddress := &EmailAddress{Email: email, IsActivated: true}
has, err = x.Get(emailAddress)
if err != nil {
return nil, err
}
if has {
2015-09-10 15:40:34 +00:00
return GetUserByID(emailAddress.UID)
}
2015-11-13 22:10:25 +00:00
return nil, ErrUserNotExist{0, email}
2014-04-10 18:20:58 +00:00
}
type SearchUserOptions struct {
Keyword string
Type UserType
OrderBy string
Page int
2016-07-23 16:23:54 +00:00
PageSize int // Can be smaller than or equal to setting.UI.ExplorePagingNum
}
// SearchUserByName takes keyword and part of user name to search,
// it returns results in given range and number of total results.
func SearchUserByName(opts *SearchUserOptions) (users []*User, _ int64, _ error) {
if len(opts.Keyword) == 0 {
return users, 0, nil
}
opts.Keyword = strings.ToLower(opts.Keyword)
2016-07-23 16:23:54 +00:00
if opts.PageSize <= 0 || opts.PageSize > setting.UI.ExplorePagingNum {
opts.PageSize = setting.UI.ExplorePagingNum
}
if opts.Page <= 0 {
opts.Page = 1
}
searchQuery := "%" + opts.Keyword + "%"
users = make([]*User, 0, opts.PageSize)
// Append conditions
sess := x.Where("LOWER(lower_name) LIKE ?", searchQuery).
Or("LOWER(full_name) LIKE ?", searchQuery).
And("type = ?", opts.Type)
var countSess xorm.Session
countSess = *sess
count, err := countSess.Count(new(User))
if err != nil {
return nil, 0, fmt.Errorf("Count: %v", err)
2014-05-01 03:48:01 +00:00
}
2016-03-11 21:11:33 +00:00
if len(opts.OrderBy) > 0 {
sess.OrderBy(opts.OrderBy)
}
return users, count, sess.Limit(opts.PageSize, (opts.Page-1)*opts.PageSize).Find(&users)
2014-05-01 03:48:01 +00:00
}
// ___________ .__ .__
// \_ _____/___ | | | | ______ _ __
// | __)/ _ \| | | | / _ \ \/ \/ /
// | \( <_> ) |_| |_( <_> ) /
// \___ / \____/|____/____/\____/ \/\_/
// \/
// Follow represents relations of user and his/her followers.
2014-04-10 18:20:58 +00:00
type Follow struct {
2015-08-17 09:05:37 +00:00
ID int64 `xorm:"pk autoincr"`
UserID int64 `xorm:"UNIQUE(follow)"`
FollowID int64 `xorm:"UNIQUE(follow)"`
2014-04-10 18:20:58 +00:00
}
func IsFollowing(userID, followID int64) bool {
has, _ := x.Get(&Follow{UserID: userID, FollowID: followID})
return has
}
2014-04-10 18:20:58 +00:00
// FollowUser marks someone be another's follower.
func FollowUser(userID, followID int64) (err error) {
if userID == followID || IsFollowing(userID, followID) {
return nil
}
2014-10-03 17:12:54 +00:00
sess := x.NewSession()
defer sessionRelease(sess)
if err = sess.Begin(); err != nil {
return err
}
2014-04-10 18:20:58 +00:00
if _, err = sess.Insert(&Follow{UserID: userID, FollowID: followID}); err != nil {
2014-04-10 18:20:58 +00:00
return err
}
if _, err = sess.Exec("UPDATE `user` SET num_followers = num_followers + 1 WHERE id = ?", followID); err != nil {
2014-04-10 18:20:58 +00:00
return err
}
if _, err = sess.Exec("UPDATE `user` SET num_following = num_following + 1 WHERE id = ?", userID); err != nil {
2014-04-10 18:20:58 +00:00
return err
}
2014-10-03 17:12:54 +00:00
return sess.Commit()
2014-04-10 18:20:58 +00:00
}
// UnfollowUser unmarks someone be another's follower.
func UnfollowUser(userID, followID int64) (err error) {
if userID == followID || !IsFollowing(userID, followID) {
return nil
2014-04-10 18:20:58 +00:00
}
sess := x.NewSession()
defer sessionRelease(sess)
if err = sess.Begin(); err != nil {
2014-04-10 18:20:58 +00:00
return err
}
if _, err = sess.Delete(&Follow{UserID: userID, FollowID: followID}); err != nil {
2014-04-10 18:20:58 +00:00
return err
}
if _, err = sess.Exec("UPDATE `user` SET num_followers = num_followers - 1 WHERE id = ?", followID); err != nil {
return err
}
if _, err = sess.Exec("UPDATE `user` SET num_following = num_following - 1 WHERE id = ?", userID); err != nil {
return err
}
return sess.Commit()
}