Template
1
0
Fork 0
mirror of https://codeberg.org/forgejo/forgejo synced 2024-12-05 02:54:46 +01:00
forgejo/models/user.go

480 lines
12 KiB
Go
Raw Normal View History

2014-02-15 00:16:54 +01: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.
2014-02-14 15:20:57 +01:00
package models
import (
2014-04-06 22:10:57 +02:00
"crypto/sha256"
2014-03-19 17:50:44 +01:00
"encoding/hex"
2014-02-14 15:20:57 +01:00
"errors"
"fmt"
2014-02-20 07:53:56 +01:00
"os"
"path/filepath"
2014-02-14 15:20:57 +01:00
"strings"
"time"
2014-03-17 16:56:50 +01:00
"github.com/gogits/git"
2014-03-07 23:22:15 +01:00
"github.com/gogits/gogs/modules/base"
2014-03-19 17:50:44 +01:00
"github.com/gogits/gogs/modules/log"
2014-02-15 00:16:54 +01:00
)
// User types.
2014-02-14 15:20:57 +01:00
const (
2014-02-15 00:16:54 +01:00
UT_INDIVIDUAL = iota + 1
UT_ORGANIZATION
2014-02-14 15:20:57 +01:00
)
2014-02-15 00:16:54 +01:00
// Login types.
2014-02-14 15:20:57 +01:00
const (
2014-02-15 00:16:54 +01:00
LT_PLAIN = iota + 1
LT_LDAP
2014-02-14 15:20:57 +01:00
)
2014-03-20 21:04:56 +01:00
var (
ErrUserOwnRepos = errors.New("User still have ownership of repositories")
ErrUserAlreadyExist = errors.New("User already exist")
ErrUserNotExist = errors.New("User does not exist")
ErrEmailAlreadyUsed = errors.New("E-mail already used")
ErrUserNameIllegal = errors.New("User name contains illegal characters")
2014-03-30 22:01:50 +02:00
ErrKeyNotExist = errors.New("Public key does not exist")
2014-03-20 21:04:56 +01:00
)
// User represents the object of individual and member of organization.
2014-02-14 15:20:57 +01:00
type User struct {
Id int64
LowerName string `xorm:"unique not null"`
2014-03-06 17:10:35 +01:00
Name string `xorm:"unique not null"`
Email string `xorm:"unique not null"`
Passwd string `xorm:"not null"`
2014-02-14 15:20:57 +01:00
LoginType int
Type int
NumFollowers int
NumFollowings int
NumStars int
NumRepos int
Avatar string `xorm:"varchar(2048) not null"`
2014-03-14 06:12:07 +01:00
AvatarEmail string `xorm:"not null"`
Location string
Website string
2014-03-19 12:21:23 +01:00
IsActive bool
2014-03-20 12:50:26 +01:00
IsAdmin bool
2014-03-20 02:05:48 +01:00
Rands string `xorm:"VARCHAR(10)"`
2014-04-06 22:10:57 +02:00
Salt string `xorm:"VARCHAR(10)"`
2014-02-14 15:20:57 +01:00
Created time.Time `xorm:"created"`
Updated time.Time `xorm:"updated"`
}
// HomeLink returns the user home page link.
func (user *User) HomeLink() string {
2014-03-30 11:03:00 +02:00
return "/user/" + user.Name
}
// AvatarLink returns the user gravatar link.
func (user *User) AvatarLink() string {
2014-03-23 17:16:17 +01:00
if base.Service.EnableCacheAvatar {
return "/avatar/" + user.Avatar
}
return "http://1.gravatar.com/avatar/" + user.Avatar
}
2014-03-20 21:04:56 +01:00
// NewGitSig generates and returns the signature of given user.
func (user *User) NewGitSig() *git.Signature {
return &git.Signature{
Name: user.Name,
Email: user.Email,
When: time.Now(),
}
2014-02-14 15:20:57 +01:00
}
2014-03-20 21:04:56 +01:00
// EncodePasswd encodes password to safe format.
2014-04-06 22:10:57 +02:00
func (user *User) EncodePasswd() {
newPasswd := base.PBKDF2([]byte(user.Passwd), []byte(user.Salt), 10000, 50, sha256.New)
2014-03-20 21:04:56 +01:00
user.Passwd = fmt.Sprintf("%x", newPasswd)
}
// Member represents user is member of organization.
type Member struct {
Id int64
OrgId int64 `xorm:"unique(member) index"`
UserId int64 `xorm:"unique(member)"`
}
2014-02-14 15:20:57 +01:00
2014-02-15 00:16:54 +01:00
// IsUserExist checks if given user name exist,
// the user name should be noncased unique.
2014-02-14 15:20:57 +01:00
func IsUserExist(name string) (bool, error) {
2014-04-05 00:31:09 +02:00
if len(name) == 0 {
return false, nil
}
2014-02-14 15:20:57 +01:00
return orm.Get(&User{LowerName: strings.ToLower(name)})
}
// IsEmailUsed returns true if the e-mail has been used.
2014-03-06 17:10:35 +01:00
func IsEmailUsed(email string) (bool, error) {
2014-04-05 00:31:09 +02:00
if len(email) == 0 {
return false, nil
}
2014-03-06 17:10:35 +01:00
return orm.Get(&User{Email: email})
}
2014-03-19 12:21:23 +01:00
// return a user salt token
func GetUserSalt() string {
return base.GetRandomString(10)
}
2014-02-18 23:31:16 +01:00
// RegisterUser creates record of a new user.
2014-03-19 13:27:27 +01:00
func RegisterUser(user *User) (*User, error) {
2014-03-20 16:41:24 +01:00
if !IsLegalName(user.Name) {
return nil, ErrUserNameIllegal
}
2014-02-18 23:31:16 +01:00
isExist, err := IsUserExist(user.Name)
2014-02-15 00:16:54 +01:00
if err != nil {
2014-03-19 13:27:27 +01:00
return nil, err
2014-02-15 00:16:54 +01:00
} else if isExist {
2014-03-19 13:27:27 +01:00
return nil, ErrUserAlreadyExist
2014-02-15 00:16:54 +01:00
}
2014-03-06 17:10:35 +01:00
isExist, err = IsEmailUsed(user.Email)
if err != nil {
2014-03-19 13:27:27 +01:00
return nil, err
2014-03-06 17:10:35 +01:00
} else if isExist {
2014-03-19 13:27:27 +01:00
return nil, ErrEmailAlreadyUsed
2014-03-06 17:10:35 +01:00
}
2014-02-18 00:38:50 +01:00
user.LowerName = strings.ToLower(user.Name)
2014-03-07 23:22:15 +01:00
user.Avatar = base.EncodeMd5(user.Email)
2014-03-14 06:12:07 +01:00
user.AvatarEmail = user.Email
2014-03-19 12:21:23 +01:00
user.Rands = GetUserSalt()
2014-04-06 22:10:57 +02:00
user.Salt = GetUserSalt()
user.EncodePasswd()
if _, err = orm.Insert(user); err != nil {
2014-03-19 13:27:27 +01:00
return nil, err
} else if err = os.MkdirAll(UserPath(user.Name), os.ModePerm); err != nil {
2014-03-06 08:21:44 +01:00
if _, err := orm.Id(user.Id).Delete(&User{}); err != nil {
2014-03-19 13:27:27 +01:00
return nil, errors.New(fmt.Sprintf(
"both create userpath %s and delete table record faild: %v", user.Name, err))
2014-02-20 07:53:56 +01:00
}
2014-03-19 13:27:27 +01:00
return nil, err
2014-03-19 12:21:23 +01:00
}
2014-03-20 13:02:14 +01:00
if user.Id == 1 {
user.IsAdmin = true
user.IsActive = true
_, err = orm.Id(user.Id).UseBool().Update(user)
}
return user, err
2014-02-14 15:20:57 +01:00
}
2014-03-20 21:04:56 +01:00
// GetUsers returns given number of user objects with offset.
func GetUsers(num, offset int) ([]User, error) {
users := make([]User, 0, num)
err := orm.Limit(num, offset).Asc("id").Find(&users)
return users, err
}
2014-03-19 17:50:44 +01: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
}
log.Error("user.getVerifyUser: %v", err)
}
return nil
}
// verify active code when active account
func VerifyUserActiveCode(code string) (user *User) {
minutes := base.Service.ActiveCodeLives
if user = getVerifyUser(code); user != nil {
// time limit code
prefix := code[:base.TimeLimitCodeLength]
data := base.ToStr(user.Id) + user.Email + user.LowerName + user.Passwd + user.Rands
if base.VerifyTimeLimitCode(data, minutes, prefix) {
return user
}
}
return nil
}
2014-04-03 22:33:27 +02:00
// ChangeUserName changes all corresponding setting from old user name to new one.
func ChangeUserName(user *User, newUserName string) (err error) {
newUserName = strings.ToLower(newUserName)
// Update accesses of user.
accesses := make([]Access, 0, 10)
if err = orm.Find(&accesses, &Access{UserName: user.LowerName}); err != nil {
return err
}
2014-04-05 00:55:17 +02:00
sess := orm.NewSession()
defer sess.Close()
if err = sess.Begin(); err != nil {
return err
}
2014-04-03 22:33:27 +02:00
for i := range accesses {
accesses[i].UserName = newUserName
if strings.HasPrefix(accesses[i].RepoName, user.LowerName+"/") {
accesses[i].RepoName = strings.Replace(accesses[i].RepoName, user.LowerName, newUserName, 1)
2014-04-05 00:55:17 +02:00
if err = UpdateAccessWithSession(sess, &accesses[i]); err != nil {
2014-04-03 22:33:27 +02:00
return err
}
}
}
repos, err := GetRepositories(user)
if err != nil {
return err
}
for i := range repos {
accesses = make([]Access, 0, 10)
// Update accesses of user repository.
if err = orm.Find(&accesses, &Access{RepoName: user.LowerName + "/" + repos[i].LowerName}); err != nil {
return err
}
for j := range accesses {
accesses[j].RepoName = newUserName + "/" + repos[i].LowerName
2014-04-05 00:55:17 +02:00
if err = UpdateAccessWithSession(sess, &accesses[j]); err != nil {
2014-04-03 22:33:27 +02:00
return err
}
}
}
// Change user directory name.
2014-04-05 00:55:17 +02:00
if err = os.Rename(UserPath(user.LowerName), UserPath(newUserName)); err != nil {
sess.Rollback()
return err
}
return sess.Commit()
2014-04-03 22:33:27 +02:00
}
2014-02-15 00:16:54 +01:00
// UpdateUser updates user's information.
func UpdateUser(user *User) (err error) {
2014-04-03 22:33:27 +02:00
user.LowerName = strings.ToLower(user.Name)
2014-03-22 21:00:46 +01:00
if len(user.Location) > 255 {
user.Location = user.Location[:255]
}
if len(user.Website) > 255 {
user.Website = user.Website[:255]
}
2014-03-24 14:01:25 +01:00
_, err = orm.Id(user.Id).AllCols().Update(user)
2014-02-14 15:20:57 +01:00
return err
}
2014-02-15 00:16:54 +01:00
// DeleteUser completely deletes everything of the user.
func DeleteUser(user *User) error {
2014-03-16 10:24:13 +01:00
// Check ownership of repository.
2014-03-11 16:40:47 +01:00
count, err := GetRepositoryCount(user)
2014-02-19 19:04:31 +01:00
if err != nil {
return errors.New("modesl.GetRepositories: " + err.Error())
2014-03-11 16:40:47 +01:00
} else if count > 0 {
2014-02-19 19:04:31 +01:00
return ErrUserOwnRepos
}
2014-03-11 07:17:05 +01:00
// TODO: check issues, other repos' commits
2014-04-10 03:42:25 +02:00
// Delete all followers.
if _, err = orm.Delete(&Follow{FollowId: user.Id}); err != nil {
return err
}
// Delete all feeds.
if _, err = orm.Delete(&Action{UserId: user.Id}); err != nil {
return err
}
2014-04-10 03:42:25 +02:00
// Delete all watches.
if _, err = orm.Delete(&Watch{UserId: user.Id}); err != nil {
return err
}
2014-04-03 22:33:27 +02:00
// Delete all accesses.
if _, err = orm.Delete(&Access{UserName: user.LowerName}); err != nil {
return err
}
// Delete all SSH keys.
2014-03-16 10:24:13 +01:00
keys := make([]PublicKey, 0, 10)
if err = orm.Find(&keys, &PublicKey{OwnerId: user.Id}); err != nil {
return err
}
for _, key := range keys {
if err = DeletePublicKey(&key); err != nil {
return err
}
}
2014-03-16 15:35:25 +01:00
// Delete user directory.
if err = os.RemoveAll(UserPath(user.Name)); err != nil {
return err
}
2014-02-19 19:04:31 +01:00
_, err = orm.Delete(user)
2014-02-15 00:16:54 +01:00
return err
}
// UserPath returns the path absolute path of user repositories.
2014-02-20 07:53:56 +01:00
func UserPath(userName string) string {
2014-03-20 21:04:56 +01:00
return filepath.Join(base.RepoRootPath, strings.ToLower(userName))
2014-02-20 07:53:56 +01:00
}
2014-02-19 10:50:53 +01:00
func GetUserByKeyId(keyId int64) (*User, error) {
user := new(User)
2014-03-20 21:04:56 +01:00
rawSql := "SELECT a.* FROM `user` AS a, public_key AS b WHERE a.id = b.owner_id AND b.id=?"
has, err := orm.Sql(rawSql, keyId).Get(user)
2014-02-19 10:50:53 +01:00
if err != nil {
return nil, err
} else if !has {
2014-02-19 10:50:53 +01:00
err = errors.New("not exist key owner")
return nil, err
}
return user, nil
}
// GetUserById returns the user object by given id if exists.
2014-02-25 08:11:54 +01:00
func GetUserById(id int64) (*User, error) {
user := new(User)
has, err := orm.Id(id).Get(user)
if err != nil {
return nil, err
}
if !has {
return nil, ErrUserNotExist
}
return user, nil
}
// GetUserByName returns the user object by given name if exists.
func GetUserByName(name string) (*User, error) {
if len(name) == 0 {
return nil, ErrUserNotExist
}
2014-03-22 09:44:57 +01:00
user := &User{LowerName: strings.ToLower(name)}
has, err := orm.Get(user)
2014-04-05 18:32:34 +02:00
if err != nil {
return nil, err
} else if !has {
return nil, ErrUserNotExist
}
return user, nil
}
// GetUserEmailsByNames returns a slice of e-mails corresponds to names.
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
}
2014-04-05 18:32:34 +02:00
// GetUserByEmail returns the user object by given e-mail if exists.
func GetUserByEmail(email string) (*User, error) {
if len(email) == 0 {
return nil, ErrUserNotExist
}
user := &User{Email: strings.ToLower(email)}
has, err := orm.Get(user)
if err != nil {
return nil, err
} else if !has {
return nil, ErrUserNotExist
}
return user, nil
}
2014-02-15 00:16:54 +01:00
// LoginUserPlain validates user by raw user name and password.
2014-02-14 15:20:57 +01:00
func LoginUserPlain(name, passwd string) (*User, error) {
2014-04-06 22:10:57 +02:00
user := User{LowerName: strings.ToLower(name)}
2014-02-14 15:20:57 +01:00
has, err := orm.Get(&user)
if err != nil {
return nil, err
} else if !has {
2014-04-06 22:10:57 +02:00
return nil, ErrUserNotExist
}
newUser := &User{Passwd: passwd, Salt: user.Salt}
newUser.EncodePasswd()
if user.Passwd != newUser.Passwd {
return nil, ErrUserNotExist
2014-02-14 15:20:57 +01:00
}
2014-04-06 22:10:57 +02:00
return &user, nil
2014-02-14 15:20:57 +01:00
}
2014-03-20 21:04:56 +01:00
// Follow is connection request for receiving user notifycation.
type Follow struct {
Id int64
UserId int64 `xorm:"unique(follow)"`
FollowId int64 `xorm:"unique(follow)"`
}
2014-02-15 00:16:54 +01:00
// FollowUser marks someone be another's follower.
func FollowUser(userId int64, followId int64) (err error) {
2014-02-14 15:20:57 +01:00
session := orm.NewSession()
defer session.Close()
session.Begin()
if _, err = session.Insert(&Follow{UserId: userId, FollowId: followId}); err != nil {
2014-02-14 15:20:57 +01:00
session.Rollback()
return err
}
2014-03-20 21:04:56 +01:00
rawSql := "UPDATE `user` SET num_followers = num_followers + 1 WHERE id = ?"
if _, err = session.Exec(rawSql, followId); err != nil {
2014-02-14 15:20:57 +01:00
session.Rollback()
return err
}
2014-03-20 21:04:56 +01:00
rawSql = "UPDATE `user` SET num_followings = num_followings + 1 WHERE id = ?"
if _, err = session.Exec(rawSql, userId); err != nil {
2014-02-14 15:20:57 +01:00
session.Rollback()
return err
}
return session.Commit()
}
2014-02-15 00:16:54 +01:00
// UnFollowUser unmarks someone be another's follower.
func UnFollowUser(userId int64, unFollowId int64) (err error) {
2014-02-14 15:20:57 +01:00
session := orm.NewSession()
defer session.Close()
session.Begin()
if _, err = session.Delete(&Follow{UserId: userId, FollowId: unFollowId}); err != nil {
2014-02-14 15:20:57 +01:00
session.Rollback()
return err
}
2014-03-20 21:04:56 +01:00
rawSql := "UPDATE `user` SET num_followers = num_followers - 1 WHERE id = ?"
if _, err = session.Exec(rawSql, unFollowId); err != nil {
2014-02-14 15:20:57 +01:00
session.Rollback()
return err
}
2014-03-20 21:04:56 +01:00
rawSql = "UPDATE `user` SET num_followings = num_followings - 1 WHERE id = ?"
if _, err = session.Exec(rawSql, userId); err != nil {
2014-02-14 15:20:57 +01:00
session.Rollback()
return err
}
return session.Commit()
}