forgejo/models/user.go

896 lines
22 KiB
Go
Raw Normal View History

2014-04-10 20:20:58 +02: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 16:58:08 +01:00
"bytes"
2014-09-23 21:30:04 +02:00
"container/list"
2014-04-10 20:20:58 +02:00
"crypto/sha256"
"encoding/hex"
"errors"
"fmt"
2014-11-21 16:58:08 +01:00
"image"
"image/jpeg"
2014-04-10 20:20:58 +02:00
"os"
"path/filepath"
"strings"
"time"
2014-07-26 06:24:27 +02:00
"github.com/Unknwon/com"
2014-11-21 16:58:08 +01:00
"github.com/nfnt/resize"
2014-04-10 20:20:58 +02:00
"github.com/gogits/gogs/modules/avatar"
2014-04-10 20:20:58 +02:00
"github.com/gogits/gogs/modules/base"
2014-07-26 06:24:27 +02:00
"github.com/gogits/gogs/modules/git"
2014-04-10 20:20:58 +02:00
"github.com/gogits/gogs/modules/log"
2014-05-26 02:11:25 +02:00
"github.com/gogits/gogs/modules/setting"
2014-04-10 20:20:58 +02:00
)
2014-06-25 06:44:48 +02:00
type UserType int
2014-04-10 20:20:58 +02:00
const (
2014-06-25 06:44:48 +02:00
INDIVIDUAL UserType = iota // Historic reason to make it starts at 0.
ORGANIZATION
2014-04-10 20:20:58 +02:00
)
var (
2014-05-11 08:12:45 +02:00
ErrUserAlreadyExist = errors.New("User already exist")
ErrUserNotExist = errors.New("User does not exist")
2014-05-22 03:37:13 +02:00
ErrUserNotKeyOwner = errors.New("User does not the owner of public key")
2014-05-11 08:12:45 +02:00
ErrEmailAlreadyUsed = errors.New("E-mail already used")
ErrEmailNotExist = errors.New("E-mail does not exist")
ErrEmailNotActivated = errors.New("E-mail address has not been activated")
2014-05-11 08:12:45 +02: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 20:46:04 +02:00
ErrUnsupportedLoginType = errors.New("Login source is unknown")
2014-04-10 20:20:58 +02:00
)
// User represents the object of individual and member of organization.
type User struct {
Id int64
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).
2014-11-21 19:10:00 +01:00
Email string `xorm:"UNIQUE(s) NOT NULL"`
2014-11-21 16:58:08 +01:00
Passwd string `xorm:"NOT NULL"`
LoginType LoginType
LoginSource int64 `xorm:"NOT NULL DEFAULT 0"`
LoginName string
2014-11-21 19:10:00 +01:00
Type UserType `xorm:"UNIQUE(s)"`
2014-11-21 16:58:08 +01: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:"CREATED"`
Updated time.Time `xorm:"UPDATED"`
// Permissions.
IsActive bool
IsAdmin bool
AllowGitHook bool
// Avatar.
Avatar string `xorm:"VARCHAR(2048) NOT NULL"`
AvatarEmail string `xorm:"NOT NULL"`
UseCustomAvatar bool
// Counters.
2014-04-10 20:20:58 +02:00
NumFollowers int
NumFollowings int
NumStars int
NumRepos int
2014-06-25 06:44:48 +02:00
// For organization.
2014-06-27 09:37:01 +02:00
Description string
NumTeams int
NumMembers int
2014-06-28 21:43:25 +02:00
Teams []*Team `xorm:"-"`
Members []*User `xorm:"-"`
2014-04-10 20:20:58 +02:00
}
// EmailAdresses is the list of all email addresses of a user. Can contain the
// primary email address, but is not obligatory
type EmailAddress struct {
Id int64
2014-12-20 08:26:51 +01:00
Uid int64 `xorm:"INDEX NOT NULL"`
Email string `xorm:"UNIQUE NOT NULL"`
IsActivated bool
IsPrimary bool `xorm:"-"`
}
2014-07-26 06:24:27 +02:00
// DashboardLink returns the user dashboard page link.
func (u *User) DashboardLink() string {
if u.IsOrganization() {
2014-09-20 02:11:34 +02:00
return setting.AppSubUrl + "/org/" + u.Name + "/dashboard/"
2014-07-26 06:24:27 +02:00
}
2014-09-20 02:11:34 +02:00
return setting.AppSubUrl + "/"
2014-07-26 06:24:27 +02:00
}
2014-04-10 20:20:58 +02:00
// HomeLink returns the user home page link.
2014-06-25 06:44:48 +02:00
func (u *User) HomeLink() string {
2014-09-28 13:55:58 +02:00
return setting.AppSubUrl + "/" + u.Name
2014-04-10 20:20:58 +02:00
}
2014-06-06 04:07:35 +02:00
// AvatarLink returns user gravatar link.
2014-06-25 06:44:48 +02:00
func (u *User) AvatarLink() string {
2014-11-21 16:58:08 +01:00
switch {
case u.UseCustomAvatar:
return setting.AppSubUrl + "/avatars/" + com.ToStr(u.Id)
case setting.DisableGravatar, setting.OfflineMode:
return setting.AppSubUrl + "/img/avatar_default.jpg"
2014-11-21 16:58:08 +01:00
case setting.Service.EnableCacheAvatar:
return setting.AppSubUrl + "/avatar/" + u.Avatar
2014-04-10 20:20:58 +02:00
}
2014-11-17 02:27:04 +01:00
return setting.GravatarSource + u.Avatar
2014-04-10 20:20:58 +02:00
}
// NewGitSig generates and returns the signature of given user.
2014-06-25 06:44:48 +02:00
func (u *User) NewGitSig() *git.Signature {
2014-04-10 20:20:58 +02:00
return &git.Signature{
2014-06-25 06:44:48 +02:00
Name: u.Name,
Email: u.Email,
2014-04-10 20:20:58 +02:00
When: time.Now(),
}
}
// EncodePasswd encodes password to safe format.
2014-06-25 06:44:48 +02:00
func (u *User) EncodePasswd() {
newPasswd := base.PBKDF2([]byte(u.Passwd), []byte(u.Salt), 10000, 50, sha256.New)
u.Passwd = fmt.Sprintf("%x", newPasswd)
}
2014-08-02 19:47:33 +02:00
// ValidtePassword checks if given password matches the one belongs to the user.
func (u *User) ValidtePassword(passwd string) bool {
newUser := &User{Passwd: passwd, Salt: u.Salt}
newUser.EncodePasswd()
return u.Passwd == newUser.Passwd
}
2014-11-22 16:22:53 +01:00
// CustomAvatarPath returns user custom avatar file path.
func (u *User) CustomAvatarPath() string {
return filepath.Join(setting.AvatarUploadPath, com.ToStr(u.Id))
}
2014-11-21 16:58:08 +01:00
// UploadAvatar saves custom avatar for user.
2014-12-07 02:22:48 +01:00
// FIXME: split uploads to different subdirs in case we have massive users.
2014-11-21 16:58:08 +01:00
func (u *User) UploadAvatar(data []byte) error {
u.UseCustomAvatar = true
img, _, err := image.Decode(bytes.NewReader(data))
if err != nil {
return err
}
m := resize.Resize(200, 200, img, resize.NearestNeighbor)
sess := x.NewSession()
defer sess.Close()
if err = sess.Begin(); err != nil {
return err
}
if _, err = sess.Id(u.Id).AllCols().Update(u); err != nil {
sess.Rollback()
return err
}
2014-11-21 18:51:36 +01:00
os.MkdirAll(setting.AvatarUploadPath, os.ModePerm)
2014-11-22 16:22:53 +01:00
fw, err := os.Create(u.CustomAvatarPath())
2014-11-21 16:58:08 +01:00
if err != nil {
sess.Rollback()
return err
}
defer fw.Close()
if err = jpeg.Encode(fw, m, nil); err != nil {
sess.Rollback()
return err
}
return sess.Commit()
}
2014-06-28 06:40:07 +02:00
// IsOrganization returns true if user is actually a organization.
2014-06-25 06:44:48 +02:00
func (u *User) IsOrganization() bool {
return u.Type == ORGANIZATION
}
// IsUserOrgOwner returns true if user is in the owner team of given organization.
func (u *User) IsUserOrgOwner(orgId int64) bool {
return IsOrganizationOwner(orgId, u.Id)
}
// IsPublicMember returns true if user public his/her membership in give organization.
func (u *User) IsPublicMember(orgId int64) bool {
return IsPublicMembership(orgId, u.Id)
}
2014-06-28 21:43:25 +02:00
// GetOrganizationCount returns count of membership of organization of user.
func (u *User) GetOrganizationCount() (int64, error) {
return x.Where("uid=?", u.Id).Count(new(OrgUser))
}
// GetRepositories returns all repositories that user owns, including private repositories.
func (u *User) GetRepositories() (err error) {
u.Repos, err = GetRepositories(u.Id, true)
return err
}
2014-06-28 06:40:07 +02:00
// GetOrganizations returns all organizations that user belongs to.
2014-06-25 06:44:48 +02:00
func (u *User) GetOrganizations() error {
ous, err := GetOrgUsersByUserId(u.Id)
if err != nil {
return err
}
u.Orgs = make([]*User, len(ous))
for i, ou := range ous {
u.Orgs[i], err = GetUserById(ou.OrgID)
2014-06-25 06:44:48 +02:00
if err != nil {
return err
}
}
return nil
2014-04-10 20:20:58 +02:00
}
// GetFullNameFallback returns Full Name if set, otherwise username
func (u *User) GetFullNameFallback() string {
if u.FullName == "" {
return u.Name
}
return u.FullName
}
2014-04-10 20:20:58 +02: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 20:20:58 +02:00
if len(name) == 0 {
return false, nil
}
return x.Where("id!=?", uid).Get(&User{LowerName: strings.ToLower(name)})
2014-04-10 20:20:58 +02:00
}
// IsEmailUsed returns true if the e-mail has been used.
func IsEmailUsed(email string) (bool, error) {
if len(email) == 0 {
return false, nil
}
2014-12-20 08:26:51 +01:00
if has, err := x.Get(&EmailAddress{Email: email}); has || err != nil {
return has, err
}
2014-06-21 06:51:41 +02:00
return x.Get(&User{Email: email})
2014-04-10 20:20:58 +02:00
}
2014-10-25 00:43:17 +02:00
// GetUserSalt returns a ramdom user salt token.
2014-04-10 20:20:58 +02:00
func GetUserSalt() string {
return base.GetRandomString(10)
}
2014-06-25 06:44:48 +02:00
// CreateUser creates record of a new user.
2014-07-26 06:24:27 +02:00
func CreateUser(u *User) error {
2014-06-25 06:44:48 +02:00
if !IsLegalName(u.Name) {
2014-07-26 06:24:27 +02:00
return ErrUserNameIllegal
2014-06-25 06:44:48 +02:00
}
isExist, err := IsUserExist(0, u.Name)
2014-06-25 06:44:48 +02:00
if err != nil {
2014-07-26 06:24:27 +02:00
return err
2014-06-25 06:44:48 +02:00
} else if isExist {
2014-07-26 06:24:27 +02:00
return ErrUserAlreadyExist
2014-06-25 06:44:48 +02:00
}
isExist, err = IsEmailUsed(u.Email)
if err != nil {
2014-07-26 06:24:27 +02:00
return err
2014-06-25 06:44:48 +02:00
} else if isExist {
2014-07-26 06:24:27 +02:00
return ErrEmailAlreadyUsed
2014-06-25 06:44:48 +02:00
}
u.LowerName = strings.ToLower(u.Name)
u.AvatarEmail = u.Email
u.Avatar = avatar.HashEmail(u.AvatarEmail)
2014-06-25 06:44:48 +02:00
u.Rands = GetUserSalt()
u.Salt = GetUserSalt()
u.EncodePasswd()
sess := x.NewSession()
defer sess.Close()
if err = sess.Begin(); err != nil {
2014-07-26 06:24:27 +02:00
return err
2014-06-25 06:44:48 +02:00
}
if _, err = sess.Insert(u); err != nil {
sess.Rollback()
2014-07-26 06:24:27 +02:00
return err
} else if err = os.MkdirAll(UserPath(u.Name), os.ModePerm); err != nil {
2014-06-25 06:44:48 +02:00
sess.Rollback()
2014-07-26 06:24:27 +02:00
return err
} else if err = sess.Commit(); err != nil {
return err
2014-06-25 06:44:48 +02:00
}
2014-06-25 06:44:48 +02:00
// Auto-set admin for user whose ID is 1.
if u.Id == 1 {
u.IsAdmin = true
u.IsActive = true
_, err = x.Id(u.Id).UseBool().Update(u)
}
2014-07-26 06:24:27 +02:00
return err
2014-06-25 06:44:48 +02:00
}
// CountUsers returns number of users.
func CountUsers() int64 {
count, _ := x.Where("type=0").Count(new(User))
return count
}
2014-04-10 20:20:58 +02:00
// GetUsers returns given number of user objects with offset.
2014-08-29 14:50:43 +02:00
func GetUsers(num, offset int) ([]*User, error) {
users := make([]*User, 0, num)
2014-07-04 22:48:36 +02:00
err := x.Limit(num, offset).Where("type=0").Asc("id").Find(&users)
2014-04-10 20:20:58 +02:00
return users, err
}
// 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 06:24:27 +02:00
log.Error(4, "user.getVerifyUser: %v", err)
2014-04-10 20:20:58 +02:00
}
return nil
}
// verify active code when active account
func VerifyUserActiveCode(code string) (user *User) {
2014-05-26 02:11:25 +02:00
minutes := setting.Service.ActiveCodeLives
2014-04-10 20:20:58 +02:00
if user = getVerifyUser(code); user != nil {
// time limit code
prefix := code[:base.TimeLimitCodeLength]
2014-07-26 06:24:27 +02:00
data := com.ToStr(user.Id) + user.Email + user.LowerName + user.Passwd + user.Rands
2014-04-10 20:20:58 +02: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]
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 20:20:58 +02:00
// ChangeUserName changes all corresponding setting from old user name to new one.
2014-07-26 06:24:27 +02:00
func ChangeUserName(u *User, newUserName string) (err error) {
if !IsLegalName(newUserName) {
return ErrUserNameIllegal
}
return os.Rename(UserPath(u.LowerName), UserPath(newUserName))
2014-04-10 20:20:58 +02:00
}
// UpdateUser updates user's information.
2014-07-26 06:24:27 +02:00
func UpdateUser(u *User) error {
has, err := x.Where("id!=?", u.Id).And("type=?", u.Type).And("email=?", u.Email).Get(new(User))
2014-12-01 00:29:16 +01:00
if err != nil {
return err
} else if has {
return ErrEmailAlreadyUsed
}
2014-06-06 04:07:35 +02:00
u.LowerName = strings.ToLower(u.Name)
2014-04-10 20:20:58 +02:00
2014-06-06 04:07:35 +02:00
if len(u.Location) > 255 {
u.Location = u.Location[:255]
2014-04-10 20:20:58 +02:00
}
2014-06-06 04:07:35 +02:00
if len(u.Website) > 255 {
u.Website = u.Website[:255]
2014-04-10 20:20:58 +02:00
}
2014-06-27 09:37:01 +02:00
if len(u.Description) > 255 {
u.Description = u.Description[:255]
}
2014-04-10 20:20:58 +02:00
if u.AvatarEmail == "" {
u.AvatarEmail = u.Email
}
u.Avatar = avatar.HashEmail(u.AvatarEmail)
u.FullName = base.Sanitizer.Sanitize(u.FullName)
2014-12-01 00:29:16 +01:00
_, err = x.Id(u.Id).AllCols().Update(u)
2014-04-10 20:20:58 +02:00
return err
}
// 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 11:27:01 +01:00
// FIXME: need some kind of mechanism to record failure. HINT: system notice
2014-06-28 06:40:07 +02:00
// DeleteUser completely and permanently deletes everything of user.
2014-06-27 09:37:01 +02:00
func DeleteUser(u *User) error {
2014-04-10 20:20:58 +02:00
// Check ownership of repository.
2014-06-27 09:37:01 +02:00
count, err := GetRepositoryCount(u)
2014-04-10 20:20:58 +02:00
if err != nil {
return fmt.Errorf("GetRepositoryCount: %v", err)
2014-04-10 20:20:58 +02:00
} else if count > 0 {
return ErrUserOwnRepos{UID: u.Id}
2014-04-10 20:20:58 +02:00
}
2014-06-27 09:37:01 +02:00
// Check membership of organization.
2014-06-28 21:43:25 +02:00
count, err = u.GetOrganizationCount()
2014-06-27 09:37:01 +02:00
if err != nil {
return fmt.Errorf("GetOrganizationCount: %v", err)
2014-06-27 09:37:01 +02:00
} else if count > 0 {
return ErrUserHasOrgs{UID: u.Id}
2014-06-27 09:37:01 +02:00
}
// Get watches before session.
watches := make([]*Watch, 0, 10)
if err = x.Where("user_id=?", u.Id).Find(&watches); err != nil {
return fmt.Errorf("get all watches: %v", err)
2014-04-10 20:20:58 +02:00
}
repoIDs := make([]int64, 0, len(watches))
for i := range watches {
repoIDs = append(repoIDs, watches[i].RepoID)
2014-04-12 03:47:39 +02:00
}
// FIXME: check issues, other repos' commits
sess := x.NewSession()
defer sessionRelease(sess)
if err = sess.Begin(); err != nil {
2014-04-10 20:20:58 +02:00
return err
}
if err = DeleteBeans(sess,
&Follow{FollowID: u.Id},
&Oauth2{Uid: u.Id},
&Action{UserID: u.Id},
&Access{UserID: u.Id},
&Collaboration{UserID: u.Id},
&EmailAddress{Uid: u.Id},
&Watch{UserID: u.Id},
); err != nil {
2014-04-10 20:20:58 +02:00
return err
}
// Decrease all watch numbers.
for i := range repoIDs {
if _, err = sess.Exec("UPDATE `repository` SET num_watches=num_watches-1 WHERE id=?", repoIDs[i]); err != nil {
return err
}
}
2014-04-10 20:20:58 +02:00
// Delete all SSH keys.
2014-05-06 22:28:52 +02:00
keys := make([]*PublicKey, 0, 10)
if err = sess.Find(&keys, &PublicKey{OwnerId: u.Id}); err != nil {
2014-04-10 20:20:58 +02:00
return err
}
for _, key := range keys {
2014-05-06 22:28:52 +02:00
if err = DeletePublicKey(key); err != nil {
2014-04-10 20:20:58 +02:00
return err
}
}
if _, err = sess.Delete(u); err != nil {
return err
}
2014-04-10 20:20:58 +02:00
// Delete user directory.
2014-06-27 09:37:01 +02:00
if err = os.RemoveAll(UserPath(u.Name)); err != nil {
2014-04-10 20:20:58 +02:00
return err
}
return sess.Commit()
2014-06-21 06:51:41 +02:00
}
// DeleteInactivateUsers deletes all inactivate users and email addresses.
2014-06-21 06:51:41 +02:00
func DeleteInactivateUsers() error {
_, err := x.Where("is_active=?", false).Delete(new(User))
if err == nil {
2014-12-20 08:26:51 +01:00
_, err = x.Where("is_activated=?", false).Delete(new(EmailAddress))
}
2014-04-10 20:20:58 +02:00
return err
}
// UserPath returns the path absolute path of user repositories.
func UserPath(userName string) string {
2014-05-26 02:11:25 +02:00
return filepath.Join(setting.RepoRootPath, strings.ToLower(userName))
2014-04-10 20:20:58 +02:00
}
func GetUserByKeyId(keyId int64) (*User, error) {
user := new(User)
2015-02-12 03:58:37 +01: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 20:20:58 +02:00
if err != nil {
return nil, err
} else if !has {
2014-05-22 03:37:13 +02:00
return nil, ErrUserNotKeyOwner
2014-04-10 20:20:58 +02:00
}
return user, nil
}
2015-02-13 06:58:46 +01:00
func getUserById(e Engine, id int64) (*User, error) {
2014-06-06 04:07:35 +02:00
u := new(User)
2015-02-13 06:58:46 +01:00
has, err := e.Id(id).Get(u)
2014-04-10 20:20:58 +02:00
if err != nil {
return nil, err
2014-06-06 04:07:35 +02:00
} else if !has {
2014-04-10 20:20:58 +02:00
return nil, ErrUserNotExist
}
2014-06-06 04:07:35 +02:00
return u, nil
2014-04-10 20:20:58 +02:00
}
2015-02-13 06:58:46 +01:00
// GetUserById returns the user object by given ID if exists.
func GetUserById(id int64) (*User, error) {
return getUserById(x, id)
}
2014-10-25 00:43:17 +02:00
// GetUserByName returns user by given name.
2014-04-10 20:20:58 +02:00
func GetUserByName(name string) (*User, error) {
if len(name) == 0 {
return nil, ErrUserNotExist
}
2014-10-25 00:43:17 +02:00
u := &User{LowerName: strings.ToLower(name)}
has, err := x.Get(u)
2014-04-10 20:20:58 +02:00
if err != nil {
return nil, err
} else if !has {
return nil, ErrUserNotExist
}
2014-10-25 00:43:17 +02:00
return u, nil
2014-04-10 20:20:58 +02:00
}
// GetUserEmailsByNames returns a list of e-mails corresponds to names.
2014-04-10 20:20:58 +02: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
}
ids = append(ids, u.Id)
}
return ids
}
// GetEmailAddresses returns all e-mail addresses belongs to given user.
func GetEmailAddresses(uid int64) ([]*EmailAddress, error) {
emails := make([]*EmailAddress, 0, 5)
err := x.Where("uid=?", uid).Find(&emails)
if err != nil {
return nil, err
}
u, err := GetUserById(uid)
if err != nil {
return nil, err
}
2014-12-20 08:26:51 +01:00
isPrimaryFound := false
for _, email := range emails {
if email.Email == u.Email {
2014-12-20 08:26:51 +01:00
isPrimaryFound = true
email.IsPrimary = true
} else {
email.IsPrimary = false
}
}
// We alway want the primary email address displayed, even if it's not in
// the emailaddress table (yet)
2014-12-20 08:26:51 +01:00
if !isPrimaryFound {
emails = append(emails, &EmailAddress{
Email: u.Email,
IsActivated: true,
IsPrimary: true,
})
}
return emails, nil
}
func AddEmailAddress(email *EmailAddress) error {
used, err := IsEmailUsed(email.Email)
if err != nil {
return err
} else if used {
return ErrEmailAlreadyUsed
}
_, err = x.Insert(email)
return err
}
func (email *EmailAddress) Activate() error {
email.IsActivated = true
if _, err := x.Id(email.Id).AllCols().Update(email); err != nil {
return err
}
2014-12-20 08:26:51 +01:00
if user, err := GetUserById(email.Uid); err != nil {
return err
} else {
user.Rands = GetUserSalt()
return UpdateUser(user)
}
}
func DeleteEmailAddress(email *EmailAddress) error {
has, err := x.Get(email)
if err != nil {
return err
} else if !has {
return ErrEmailNotExist
}
if _, err = x.Delete(email); err != nil {
return err
}
return nil
}
func MakeEmailPrimary(email *EmailAddress) error {
has, err := x.Get(email)
if err != nil {
return err
} else if !has {
return ErrEmailNotExist
}
if !email.IsActivated {
return ErrEmailNotActivated
}
2014-12-20 08:26:51 +01:00
user := &User{Id: email.Uid}
has, err = x.Get(user)
if err != nil {
return err
} else if !has {
return ErrUserNotExist
}
// Make sure the former primary email doesn't disappear
former_primary_email := &EmailAddress{Email: user.Email}
has, err = x.Get(former_primary_email)
if err != nil {
return err
} else if !has {
2014-12-20 08:26:51 +01:00
former_primary_email.Uid = user.Id
former_primary_email.IsActivated = user.IsActive
x.Insert(former_primary_email)
}
user.Email = email.Email
_, err = x.Id(user.Id).AllCols().Update(user)
return err
}
2014-12-07 02:22:48 +01:00
// UserCommit represents a commit with validation of user.
2014-09-23 21:30:04 +02:00
type UserCommit struct {
2014-11-21 16:58:08 +01:00
User *User
2014-09-23 21:30:04 +02:00
*git.Commit
}
2014-09-26 14:55:13 +02:00
// ValidateCommitWithEmail chceck if author's e-mail of commit is corresponsind to a user.
2014-11-21 16:58:08 +01:00
func ValidateCommitWithEmail(c *git.Commit) *User {
2014-09-26 14:55:13 +02:00
u, err := GetUserByEmail(c.Author.Email)
2014-11-21 16:58:08 +01:00
if err != nil {
return nil
2014-09-26 14:55:13 +02:00
}
2014-11-21 16:58:08 +01:00
return u
2014-09-26 14:55:13 +02:00
}
// ValidateCommitsWithEmails checks if authors' e-mails of commits are corresponding to users.
func ValidateCommitsWithEmails(oldCommits *list.List) *list.List {
2014-11-21 16:58:08 +01:00
emails := map[string]*User{}
2014-09-23 21:30:04 +02:00
newCommits := list.New()
e := oldCommits.Front()
for e != nil {
c := e.Value.(*git.Commit)
2014-11-21 16:58:08 +01:00
var u *User
2014-09-24 05:18:14 +02:00
if v, ok := emails[c.Author.Email]; !ok {
2014-11-21 16:58:08 +01:00
u, _ = GetUserByEmail(c.Author.Email)
emails[c.Author.Email] = u
2014-09-24 05:18:14 +02:00
} else {
2014-11-21 16:58:08 +01:00
u = v
2014-09-23 21:30:04 +02:00
}
newCommits.PushBack(UserCommit{
2014-11-21 16:58:08 +01:00
User: u,
Commit: c,
2014-09-23 21:30:04 +02:00
})
e = e.Next()
}
return newCommits
}
2014-04-10 20:20:58 +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
}
// First try to find the user by primary email
2014-04-10 20:20:58 +02:00
user := &User{Email: strings.ToLower(email)}
2014-06-21 06:51:41 +02:00
has, err := x.Get(user)
2014-04-10 20:20:58 +02:00
if err != nil {
return nil, err
}
if has {
return user, nil
}
// Otherwise, check in alternative list for activated email addresses
emailAddress := &EmailAddress{Email: strings.ToLower(email), IsActivated: true}
has, err = x.Get(emailAddress)
if err != nil {
return nil, err
}
if has {
2014-12-20 08:26:51 +01:00
return GetUserById(emailAddress.Uid)
}
return nil, ErrUserNotExist
2014-04-10 20:20:58 +02:00
}
2014-05-01 05:48:01 +02:00
// SearchUserByName returns given number of users whose name contains keyword.
2014-08-26 12:11:15 +02:00
func SearchUserByName(opt SearchOption) (us []*User, err error) {
if len(opt.Keyword) == 0 {
2014-05-01 05:48:01 +02:00
return us, nil
}
2014-08-26 12:11:15 +02:00
opt.Keyword = strings.ToLower(opt.Keyword)
2014-05-01 05:48:01 +02:00
2014-08-26 12:11:15 +02:00
us = make([]*User, 0, opt.Limit)
err = x.Limit(opt.Limit).Where("type=0").And("lower_name like ?", "%"+opt.Keyword+"%").Find(&us)
2014-05-01 05:48:01 +02:00
return us, err
}
2014-12-07 02:22:48 +01:00
// Follow is connection request for receiving user notification.
2014-04-10 20:20:58 +02:00
type Follow struct {
Id int64
UserID int64 `xorm:"unique(follow)"`
FollowID int64 `xorm:"unique(follow)"`
2014-04-10 20:20:58 +02:00
}
// FollowUser marks someone be another's follower.
func FollowUser(userId int64, followId int64) (err error) {
2014-10-03 19:12:54 +02:00
sess := x.NewSession()
defer sess.Close()
sess.Begin()
2014-04-10 20:20:58 +02:00
if _, err = sess.Insert(&Follow{UserID: userId, FollowID: followId}); err != nil {
2014-10-03 19:12:54 +02:00
sess.Rollback()
2014-04-10 20:20:58 +02:00
return err
}
rawSql := "UPDATE `user` SET num_followers = num_followers + 1 WHERE id = ?"
2014-10-03 19:12:54 +02:00
if _, err = sess.Exec(rawSql, followId); err != nil {
sess.Rollback()
2014-04-10 20:20:58 +02:00
return err
}
rawSql = "UPDATE `user` SET num_followings = num_followings + 1 WHERE id = ?"
2014-10-03 19:12:54 +02:00
if _, err = sess.Exec(rawSql, userId); err != nil {
sess.Rollback()
2014-04-10 20:20:58 +02:00
return err
}
2014-10-03 19:12:54 +02:00
return sess.Commit()
2014-04-10 20:20:58 +02:00
}
// UnFollowUser unmarks someone be another's follower.
func UnFollowUser(userId int64, unFollowId int64) (err error) {
2014-06-21 06:51:41 +02:00
session := x.NewSession()
2014-04-10 20:20:58 +02:00
defer session.Close()
session.Begin()
if _, err = session.Delete(&Follow{UserID: userId, FollowID: unFollowId}); err != nil {
2014-04-10 20:20:58 +02:00
session.Rollback()
return err
}
rawSql := "UPDATE `user` SET num_followers = num_followers - 1 WHERE id = ?"
if _, err = session.Exec(rawSql, unFollowId); err != nil {
session.Rollback()
return err
}
rawSql = "UPDATE `user` SET num_followings = num_followings - 1 WHERE id = ?"
if _, err = session.Exec(rawSql, userId); err != nil {
session.Rollback()
return err
}
return session.Commit()
}
func UpdateMentions(userNames []string, issueId int64) error {
users := make([]*User, 0, len(userNames))
if err := x.Where("name IN (?)", strings.Join(userNames, "\",\"")).OrderBy("name ASC").Find(&users); err != nil {
return err
}
ids := make([]int64, 0, len(userNames))
for _, user := range users {
ids = append(ids, user.Id)
if user.Type == INDIVIDUAL {
continue
}
if user.NumMembers == 0 {
continue
}
tempIds := make([]int64, 0, user.NumMembers)
orgUsers, err := GetOrgUsersByOrgId(user.Id)
if err != nil {
return err
}
for _, orgUser := range orgUsers {
tempIds = append(tempIds, orgUser.ID)
}
ids = append(ids, tempIds...)
}
if err := UpdateIssueUserPairsByMentions(ids, issueId); err != nil {
return err
}
return nil
}