2014-04-10 14:20:58 -04: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 10:58:08 -05:00
|
|
|
"bytes"
|
2014-09-23 15:30:04 -04:00
|
|
|
"container/list"
|
2014-04-10 14:20:58 -04:00
|
|
|
"crypto/sha256"
|
|
|
|
"encoding/hex"
|
|
|
|
"errors"
|
|
|
|
"fmt"
|
2014-11-21 10:58:08 -05:00
|
|
|
"image"
|
|
|
|
"image/jpeg"
|
2015-08-08 23:46:10 -04:00
|
|
|
_ "image/jpeg"
|
2015-11-13 16:43:43 -05:00
|
|
|
"image/png"
|
2014-04-10 14:20:58 -04:00
|
|
|
"os"
|
|
|
|
"path/filepath"
|
|
|
|
"strings"
|
|
|
|
"time"
|
|
|
|
|
2014-07-26 00:24:27 -04:00
|
|
|
"github.com/Unknwon/com"
|
2015-09-01 12:19:52 -04:00
|
|
|
"github.com/go-xorm/xorm"
|
2014-11-21 10:58:08 -05:00
|
|
|
"github.com/nfnt/resize"
|
2014-04-10 14:20:58 -04:00
|
|
|
|
2015-12-15 17:25:45 -05:00
|
|
|
"github.com/gogits/git-module"
|
2015-11-27 00:24:24 -05:00
|
|
|
|
2014-12-03 18:19:35 -05:00
|
|
|
"github.com/gogits/gogs/modules/avatar"
|
2014-04-10 14:20:58 -04:00
|
|
|
"github.com/gogits/gogs/modules/base"
|
|
|
|
"github.com/gogits/gogs/modules/log"
|
2016-02-20 17:10:05 -05:00
|
|
|
"github.com/gogits/gogs/modules/markdown"
|
2014-05-25 20:11:25 -04:00
|
|
|
"github.com/gogits/gogs/modules/setting"
|
2014-04-10 14:20:58 -04:00
|
|
|
)
|
|
|
|
|
2014-06-25 00:44:48 -04:00
|
|
|
type UserType int
|
|
|
|
|
2014-04-10 14:20:58 -04:00
|
|
|
const (
|
2016-03-11 15:33:12 -05:00
|
|
|
USER_TYPE_INDIVIDUAL UserType = iota // Historic reason to make it starts at 0.
|
|
|
|
USER_TYPE_ORGANIZATION
|
2014-04-10 14:20:58 -04:00
|
|
|
)
|
|
|
|
|
|
|
|
var (
|
2014-05-21 21:37:13 -04:00
|
|
|
ErrUserNotKeyOwner = errors.New("User does not the owner of public key")
|
2014-12-17 10:40:10 -05:00
|
|
|
ErrEmailNotExist = errors.New("E-mail does not exist")
|
|
|
|
ErrEmailNotActivated = errors.New("E-mail address has not been activated")
|
2014-05-11 02:12:45 -04: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 14:46:04 -04:00
|
|
|
ErrUnsupportedLoginType = errors.New("Login source is unknown")
|
2014-04-10 14:20:58 -04:00
|
|
|
)
|
|
|
|
|
|
|
|
// User represents the object of individual and member of organization.
|
|
|
|
type User struct {
|
2014-12-17 03:26:19 -05:00
|
|
|
Id int64
|
|
|
|
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)
|
2015-09-06 10:08:14 -04:00
|
|
|
Email string `xorm:"NOT NULL"`
|
2014-11-21 10:58:08 -05:00
|
|
|
Passwd string `xorm:"NOT NULL"`
|
|
|
|
LoginType LoginType
|
|
|
|
LoginSource int64 `xorm:"NOT NULL DEFAULT 0"`
|
|
|
|
LoginName string
|
2015-09-06 10:08:14 -04:00
|
|
|
Type UserType
|
2015-09-07 13:58:23 -04:00
|
|
|
OwnedOrgs []*User `xorm:"-"`
|
2014-11-21 10:58:08 -05:00
|
|
|
Orgs []*User `xorm:"-"`
|
|
|
|
Repos []*Repository `xorm:"-"`
|
|
|
|
Location string
|
|
|
|
Website string
|
2016-03-09 19:53:30 -05:00
|
|
|
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 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
|
2015-12-11 15:11:13 -05:00
|
|
|
// Maximum repository creation limit, -1 means use gloabl default
|
2015-12-10 12:48:45 -05:00
|
|
|
MaxRepoCreation int `xorm:"NOT NULL DEFAULT -1"`
|
2015-08-28 04:44:04 -04:00
|
|
|
|
2015-12-21 07:24:11 -05:00
|
|
|
// Permissions
|
2015-11-03 18:40:52 -05:00
|
|
|
IsActive bool
|
|
|
|
IsAdmin bool
|
|
|
|
AllowGitHook bool
|
|
|
|
AllowImportLocal bool // Allow migrate repository by local path
|
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
|
2014-06-27 03:37:01 -04:00
|
|
|
Description string
|
|
|
|
NumTeams int
|
|
|
|
NumMembers int
|
2014-06-28 15:43:25 -04:00
|
|
|
Teams []*Team `xorm:"-"`
|
|
|
|
Members []*User `xorm:"-"`
|
2014-04-10 14:20:58 -04:00
|
|
|
}
|
|
|
|
|
2016-03-09 19:53:30 -05:00
|
|
|
func (u *User) BeforeInsert() {
|
|
|
|
u.CreatedUnix = time.Now().UTC().Unix()
|
|
|
|
u.UpdatedUnix = u.CreatedUnix
|
|
|
|
}
|
|
|
|
|
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
|
|
|
}
|
2016-03-09 19:53:30 -05:00
|
|
|
u.UpdatedUnix = time.Now().UTC().Unix()
|
2015-12-10 12:37:53 -05:00
|
|
|
}
|
|
|
|
|
2015-09-01 12:19:52 -04:00
|
|
|
func (u *User) AfterSet(colName string, _ xorm.Cell) {
|
|
|
|
switch colName {
|
|
|
|
case "full_name":
|
2016-02-20 17:10:05 -05:00
|
|
|
u.FullName = markdown.Sanitizer.Sanitize(u.FullName)
|
2016-03-09 19:53:30 -05:00
|
|
|
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 12:19:52 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-10 19:02:57 -05:00
|
|
|
// returns true if user login type is LOGIN_PLAIN.
|
|
|
|
func (u *User) IsLocal() bool {
|
|
|
|
return u.LoginType <= LOGIN_PLAIN
|
|
|
|
}
|
|
|
|
|
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 {
|
|
|
|
_, has := HasForkedRepo(u.Id, repoID)
|
|
|
|
return has
|
|
|
|
}
|
|
|
|
|
2015-12-10 12:37:53 -05:00
|
|
|
func (u *User) RepoCreationNum() 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
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *User) CanCreateRepo() bool {
|
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
|
|
|
|
}
|
|
|
|
|
2015-11-03 18:40:52 -05:00
|
|
|
// 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-12-17 03:26:19 -05: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 {
|
2015-09-10 11:40:34 -04:00
|
|
|
ID int64 `xorm:"pk autoincr"`
|
|
|
|
UID int64 `xorm:"INDEX NOT NULL"`
|
2014-12-17 03:26:19 -05:00
|
|
|
Email string `xorm:"UNIQUE NOT NULL"`
|
|
|
|
IsActivated bool
|
2014-12-17 10:40:10 -05:00
|
|
|
IsPrimary bool `xorm:"-"`
|
2014-12-17 03:26:19 -05:00
|
|
|
}
|
|
|
|
|
2014-07-26 00:24:27 -04:00
|
|
|
// DashboardLink returns the user dashboard page link.
|
|
|
|
func (u *User) DashboardLink() string {
|
|
|
|
if u.IsOrganization() {
|
2014-09-19 20:11:34 -04:00
|
|
|
return setting.AppSubUrl + "/org/" + u.Name + "/dashboard/"
|
2014-07-26 00:24:27 -04:00
|
|
|
}
|
2014-09-19 20:11:34 -04: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 {
|
2014-09-28 07:55:58 -04:00
|
|
|
return setting.AppSubUrl + "/" + u.Name
|
2014-04-10 14:20:58 -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(
|
|
|
|
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 14:20:58 -04:00
|
|
|
|
2015-09-06 10:08:14 -04:00
|
|
|
// CustomAvatarPath returns user custom avatar file path.
|
|
|
|
func (u *User) CustomAvatarPath() string {
|
|
|
|
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)
|
|
|
|
}
|
2016-02-02 10:22:27 -05:00
|
|
|
if err = os.MkdirAll(filepath.Dir(u.CustomAvatarPath()), os.ModePerm); err != nil {
|
2015-09-06 10:08:14 -04:00
|
|
|
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 = jpeg.Encode(fw, img, nil); err != nil {
|
|
|
|
return fmt.Errorf("Encode: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
log.Info("New random avatar created: %d", u.Id)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2015-08-28 11:36:13 -04:00
|
|
|
func (u *User) RelAvatarLink() string {
|
|
|
|
defaultImgUrl := "/img/avatar_default.jpg"
|
2015-08-14 14:48:05 -04:00
|
|
|
if u.Id == -1 {
|
|
|
|
return defaultImgUrl
|
|
|
|
}
|
|
|
|
|
2014-11-21 10:58:08 -05:00
|
|
|
switch {
|
|
|
|
case u.UseCustomAvatar:
|
2015-09-06 10:08:14 -04:00
|
|
|
if !com.IsExist(u.CustomAvatarPath()) {
|
2015-08-08 23:46:10 -04:00
|
|
|
return defaultImgUrl
|
|
|
|
}
|
2015-08-28 11:36:13 -04:00
|
|
|
return "/avatars/" + com.ToStr(u.Id)
|
2015-03-12 20:32:38 -04:00
|
|
|
case setting.DisableGravatar, setting.OfflineMode:
|
2015-09-06 10:08:14 -04:00
|
|
|
if !com.IsExist(u.CustomAvatarPath()) {
|
|
|
|
if err := u.GenerateRandomAvatar(); err != nil {
|
|
|
|
log.Error(3, "GenerateRandomAvatar: %v", err)
|
2015-08-08 23:46:10 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-28 11:36:13 -04:00
|
|
|
return "/avatars/" + com.ToStr(u.Id)
|
2014-04-10 14:20:58 -04:00
|
|
|
}
|
2014-11-16 20:27:04 -05:00
|
|
|
return setting.GravatarSource + u.Avatar
|
2014-04-10 14:20:58 -04:00
|
|
|
}
|
|
|
|
|
2015-08-28 11:36:13 -04:00
|
|
|
// AvatarLink returns user gravatar link.
|
|
|
|
func (u *User) AvatarLink() string {
|
|
|
|
link := u.RelAvatarLink()
|
2015-09-02 05:16:30 -04:00
|
|
|
if link[0] == '/' && link[1] != '/' {
|
2015-08-28 11:36:13 -04:00
|
|
|
return setting.AppSubUrl + link
|
|
|
|
}
|
|
|
|
return link
|
|
|
|
}
|
|
|
|
|
2015-12-21 07:24:11 -05:00
|
|
|
// User.GetFollwoers returns range of user's followers.
|
|
|
|
func (u *User) GetFollowers(page int) ([]*User, error) {
|
|
|
|
users := make([]*User, 0, ItemsPerPage)
|
|
|
|
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 {
|
|
|
|
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)
|
|
|
|
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 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{
|
2014-06-25 00:44:48 -04:00
|
|
|
Name: u.Name,
|
|
|
|
Email: u.Email,
|
2014-04-10 14:20:58 -04:00
|
|
|
When: time.Now(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// EncodePasswd encodes password to safe format.
|
2014-06-25 00:44:48 -04: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 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 {
|
2014-08-02 13:47:33 -04:00
|
|
|
newUser := &User{Passwd: passwd, Salt: u.Salt}
|
|
|
|
newUser.EncodePasswd()
|
|
|
|
return u.Passwd == newUser.Passwd
|
|
|
|
}
|
|
|
|
|
2014-11-21 10:58:08 -05:00
|
|
|
// UploadAvatar saves custom avatar for user.
|
2014-12-06 20:22:48 -05:00
|
|
|
// FIXME: split uploads to different subdirs in case we have massive users.
|
2014-11-21 10:58:08 -05:00
|
|
|
func (u *User) UploadAvatar(data []byte) error {
|
|
|
|
img, _, err := image.Decode(bytes.NewReader(data))
|
|
|
|
if err != nil {
|
2015-11-13 16:43:43 -05:00
|
|
|
return fmt.Errorf("Decode: %v", err)
|
2014-11-21 10:58:08 -05:00
|
|
|
}
|
2015-09-06 18:19:30 -04:00
|
|
|
|
2015-11-16 11:11:59 -05:00
|
|
|
m := resize.Resize(290, 290, img, resize.NearestNeighbor)
|
2014-11-21 10:58:08 -05:00
|
|
|
|
|
|
|
sess := x.NewSession()
|
2015-09-06 18:19:30 -04:00
|
|
|
defer sessionRelease(sess)
|
2014-11-21 10:58:08 -05:00
|
|
|
if err = sess.Begin(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2015-11-13 16:43:43 -05:00
|
|
|
u.UseCustomAvatar = true
|
|
|
|
if err = updateUser(sess, u); err != nil {
|
|
|
|
return fmt.Errorf("updateUser: %v", err)
|
2014-11-21 10:58:08 -05:00
|
|
|
}
|
|
|
|
|
2014-11-21 12:51:36 -05:00
|
|
|
os.MkdirAll(setting.AvatarUploadPath, os.ModePerm)
|
2014-11-22 10:22:53 -05:00
|
|
|
fw, err := os.Create(u.CustomAvatarPath())
|
2014-11-21 10:58:08 -05:00
|
|
|
if err != nil {
|
2015-11-13 16:43:43 -05:00
|
|
|
return fmt.Errorf("Create: %v", err)
|
2014-11-21 10:58:08 -05:00
|
|
|
}
|
|
|
|
defer fw.Close()
|
2015-09-06 18:19:30 -04:00
|
|
|
|
2015-11-13 16:43:43 -05:00
|
|
|
if err = png.Encode(fw, m); err != nil {
|
|
|
|
return fmt.Errorf("Encode: %v", err)
|
2014-11-21 10:58:08 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
return sess.Commit()
|
|
|
|
}
|
|
|
|
|
2016-03-06 11:36:30 -05:00
|
|
|
// DeleteAvatar deletes the user's custom avatar.
|
|
|
|
func (u *User) DeleteAvatar() error {
|
2016-03-06 13:24:42 -05:00
|
|
|
log.Trace("DeleteAvatar[%d]: %s", u.Id, u.CustomAvatarPath())
|
2016-03-06 11:36:30 -05:00
|
|
|
os.Remove(u.CustomAvatarPath())
|
|
|
|
|
|
|
|
u.UseCustomAvatar = false
|
|
|
|
if err := UpdateUser(u); err != nil {
|
2016-03-06 13:24:42 -05:00
|
|
|
return fmt.Errorf("UpdateUser: %v", err)
|
2016-03-06 11:36:30 -05:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2015-08-13 14:43:40 -04:00
|
|
|
// IsAdminOfRepo returns true if user has admin or higher access of repository.
|
|
|
|
func (u *User) IsAdminOfRepo(repo *Repository) bool {
|
2016-03-05 20:45:23 -05:00
|
|
|
has, err := HasAccess(u, repo, ACCESS_MODE_ADMIN)
|
|
|
|
if err != nil {
|
|
|
|
log.Error(3, "HasAccess: %v", err)
|
2015-08-13 14:43:40 -04:00
|
|
|
}
|
2016-03-05 20:45:23 -05:00
|
|
|
return has
|
2015-08-13 14:43:40 -04:00
|
|
|
}
|
|
|
|
|
2016-03-05 20:45:23 -05:00
|
|
|
// IsWriterOfRepo returns true if user has write access to given repository.
|
|
|
|
func (u *User) IsWriterOfRepo(repo *Repository) bool {
|
2016-03-04 15:43:01 -05:00
|
|
|
has, err := HasAccess(u, repo, ACCESS_MODE_WRITE)
|
|
|
|
if err != nil {
|
|
|
|
log.Error(3, "HasAccess: %v", err)
|
|
|
|
}
|
|
|
|
return has
|
|
|
|
}
|
|
|
|
|
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-03-11 15:33:12 -05:00
|
|
|
return u.Type == USER_TYPE_ORGANIZATION
|
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.
|
|
|
|
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)
|
|
|
|
}
|
|
|
|
|
2015-09-06 08:54:08 -04:00
|
|
|
func (u *User) getOrganizationCount(e Engine) (int64, error) {
|
|
|
|
return e.Where("uid=?", u.Id).Count(new(OrgUser))
|
|
|
|
}
|
|
|
|
|
2014-06-28 15:43:25 -04:00
|
|
|
// GetOrganizationCount returns count of membership of organization of user.
|
|
|
|
func (u *User) GetOrganizationCount() (int64, error) {
|
2015-09-06 08:54:08 -04:00
|
|
|
return u.getOrganizationCount(x)
|
2014-06-28 15:43:25 -04:00
|
|
|
}
|
|
|
|
|
2014-08-24 09:09:05 -04:00
|
|
|
// 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
|
|
|
|
}
|
|
|
|
|
2015-09-07 13:58:23 -04:00
|
|
|
// GetOwnedOrganizations returns all organizations that user owns.
|
|
|
|
func (u *User) GetOwnedOrganizations() (err error) {
|
|
|
|
u.OwnedOrgs, err = GetOwnedOrgsByUserID(u.Id)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2014-06-28 00:40:07 -04:00
|
|
|
// GetOrganizations returns all organizations that user belongs to.
|
2015-12-17 02:28:47 -05:00
|
|
|
func (u *User) GetOrganizations(all bool) error {
|
|
|
|
ous, err := GetOrgUsersByUserID(u.Id, all)
|
2014-06-25 00:44:48 -04:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
u.Orgs = make([]*User, len(ous))
|
|
|
|
for i, ou := range ous {
|
2015-08-08 10:43:14 -04:00
|
|
|
u.Orgs[i], err = GetUserByID(ou.OrgID)
|
2014-06-25 00:44:48 -04:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
2014-04-10 14:20:58 -04:00
|
|
|
}
|
|
|
|
|
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 {
|
|
|
|
if len(u.FullName) > 0 {
|
|
|
|
return u.FullName
|
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
|
|
|
}
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2014-04-10 14:20:58 -04:00
|
|
|
// IsUserExist checks if given user name exist,
|
|
|
|
// the user name should be noncased unique.
|
2015-02-22 18:24:49 -05:00
|
|
|
// 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 14:20:58 -04:00
|
|
|
if len(name) == 0 {
|
|
|
|
return false, nil
|
|
|
|
}
|
2015-02-22 18:24:49 -05:00
|
|
|
return x.Where("id!=?", uid).Get(&User{LowerName: strings.ToLower(name)})
|
2014-04-10 14:20:58 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
// IsEmailUsed returns true if the e-mail has been used.
|
|
|
|
func IsEmailUsed(email string) (bool, error) {
|
|
|
|
if len(email) == 0 {
|
|
|
|
return false, nil
|
|
|
|
}
|
2015-08-05 05:36:22 -04:00
|
|
|
|
|
|
|
email = strings.ToLower(email)
|
2014-12-20 02:26:51 -05:00
|
|
|
if has, err := x.Get(&EmailAddress{Email: email}); has || err != nil {
|
|
|
|
return has, err
|
2014-12-17 03:26:19 -05:00
|
|
|
}
|
2014-06-21 00:51:41 -04:00
|
|
|
return x.Get(&User{Email: email})
|
2014-04-10 14:20:58 -04:00
|
|
|
}
|
|
|
|
|
2014-10-24 18:43:17 -04:00
|
|
|
// GetUserSalt returns a ramdom user salt token.
|
2014-04-10 14:20:58 -04:00
|
|
|
func GetUserSalt() string {
|
|
|
|
return base.GetRandomString(10)
|
|
|
|
}
|
|
|
|
|
2015-08-14 14:48:05 -04:00
|
|
|
// NewFakeUser creates and returns a fake user for someone has deleted his/her account.
|
|
|
|
func NewFakeUser() *User {
|
|
|
|
return &User{
|
|
|
|
Id: -1,
|
|
|
|
Name: "Someone",
|
|
|
|
LowerName: "someone",
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-25 00:44:48 -04:00
|
|
|
// CreateUser creates record of a new user.
|
2015-03-26 17:11:47 -04:00
|
|
|
func CreateUser(u *User) (err error) {
|
|
|
|
if err = IsUsableName(u.Name); err != nil {
|
|
|
|
return err
|
2014-06-25 00:44:48 -04:00
|
|
|
}
|
|
|
|
|
2015-02-22 18:24:49 -05:00
|
|
|
isExist, err := IsUserExist(0, u.Name)
|
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 {
|
2015-03-26 17:11:47 -04:00
|
|
|
return ErrUserAlreadyExist{u.Name}
|
2014-06-25 00:44:48 -04:00
|
|
|
}
|
|
|
|
|
2015-11-23 20:43:04 -05:00
|
|
|
u.Email = strings.ToLower(u.Email)
|
2014-06-25 00:44:48 -04:00
|
|
|
isExist, err = IsEmailUsed(u.Email)
|
|
|
|
if err != nil {
|
2014-07-26 00:24:27 -04:00
|
|
|
return err
|
2014-06-25 00:44:48 -04:00
|
|
|
} else if isExist {
|
2015-03-26 17:11:47 -04:00
|
|
|
return ErrEmailAlreadyUsed{u.Email}
|
2014-06-25 00:44:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
u.LowerName = strings.ToLower(u.Name)
|
|
|
|
u.AvatarEmail = u.Email
|
2016-02-14 23:14:55 -05:00
|
|
|
u.Avatar = base.HashEmail(u.AvatarEmail)
|
2014-06-25 00:44:48 -04:00
|
|
|
u.Rands = GetUserSalt()
|
|
|
|
u.Salt = GetUserSalt()
|
|
|
|
u.EncodePasswd()
|
2015-12-11 15:11:13 -05:00
|
|
|
u.MaxRepoCreation = -1
|
2014-06-25 00:44:48 -04:00
|
|
|
|
|
|
|
sess := x.NewSession()
|
|
|
|
defer sess.Close()
|
|
|
|
if err = sess.Begin(); err != nil {
|
2014-07-26 00:24:27 -04:00
|
|
|
return err
|
2014-06-25 00:44:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
if _, err = sess.Insert(u); err != nil {
|
|
|
|
sess.Rollback()
|
2014-07-26 00:24:27 -04:00
|
|
|
return err
|
|
|
|
} else if err = os.MkdirAll(UserPath(u.Name), os.ModePerm); err != nil {
|
2014-06-25 00:44:48 -04:00
|
|
|
sess.Rollback()
|
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
|
|
|
|
2015-08-18 16:58:45 -04:00
|
|
|
return sess.Commit()
|
2014-06-25 00:44:48 -04:00
|
|
|
}
|
|
|
|
|
2015-08-06 12:00:11 -04:00
|
|
|
func countUsers(e Engine) int64 {
|
|
|
|
count, _ := e.Where("type=0").Count(new(User))
|
|
|
|
return count
|
|
|
|
}
|
|
|
|
|
2014-07-07 04:15:08 -04:00
|
|
|
// CountUsers returns number of users.
|
|
|
|
func CountUsers() int64 {
|
2015-08-06 12:00:11 -04:00
|
|
|
return countUsers(x)
|
2014-07-07 04:15:08 -04:00
|
|
|
}
|
|
|
|
|
2015-09-11 20:42:26 -04: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 14:20:58 -04: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 00:24:27 -04:00
|
|
|
log.Error(4, "user.getVerifyUser: %v", err)
|
2014-04-10 14:20:58 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// verify active code when active account
|
|
|
|
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]
|
2014-07-26 00:24:27 -04:00
|
|
|
data := com.ToStr(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
|
|
|
|
}
|
|
|
|
|
2014-12-17 10:40:10 -05:00
|
|
|
// 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 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) {
|
2015-03-26 17:11:47 -04:00
|
|
|
if err = IsUsableName(newUserName); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
isExist, err := IsUserExist(0, newUserName)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if isExist {
|
|
|
|
return ErrUserAlreadyExist{newUserName}
|
2014-07-26 00:24:27 -04:00
|
|
|
}
|
|
|
|
|
2016-02-05 14:11:53 -05:00
|
|
|
if err = ChangeUsernameInPullRequests(u.Name, newUserName); err != nil {
|
2016-01-28 06:07:16 -05:00
|
|
|
return fmt.Errorf("ChangeUsernameInPullRequests: %v", err)
|
2016-01-27 16:45:03 -05:00
|
|
|
}
|
|
|
|
|
2016-02-05 14:11:53 -05:00
|
|
|
// Delete all local copies of repository wiki that user owns.
|
|
|
|
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)
|
|
|
|
}
|
|
|
|
|
2016-01-28 06:07:16 -05:00
|
|
|
return os.Rename(UserPath(u.Name), UserPath(newUserName))
|
2014-04-10 14:20:58 -04:00
|
|
|
}
|
|
|
|
|
2015-08-29 13:13:24 -04:00
|
|
|
func updateUser(e Engine, u *User) error {
|
2016-03-05 00:51:51 -05:00
|
|
|
// Organization does not need email
|
2015-09-06 10:08:14 -04:00
|
|
|
if !u.IsOrganization() {
|
|
|
|
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 {
|
|
|
|
return ErrEmailAlreadyUsed{u.Email}
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(u.AvatarEmail) == 0 {
|
|
|
|
u.AvatarEmail = u.Email
|
|
|
|
}
|
2016-02-14 23:14:55 -05:00
|
|
|
u.Avatar = base.HashEmail(u.AvatarEmail)
|
2014-11-30 18:29:16 -05:00
|
|
|
}
|
|
|
|
|
2014-06-05 22:07:35 -04:00
|
|
|
u.LowerName = strings.ToLower(u.Name)
|
2016-03-05 00:51:51 -05:00
|
|
|
u.Location = base.TruncateString(u.Location, 255)
|
|
|
|
u.Website = base.TruncateString(u.Website, 255)
|
|
|
|
u.Description = base.TruncateString(u.Description, 255)
|
2014-04-10 14:20:58 -04:00
|
|
|
|
2016-02-20 17:10:05 -05:00
|
|
|
u.FullName = markdown.Sanitizer.Sanitize(u.FullName)
|
2015-09-06 10:08:14 -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 {
|
|
|
|
return updateUser(x, u)
|
|
|
|
}
|
|
|
|
|
2015-09-06 08:54:08 -04:00
|
|
|
// deleteBeans deletes all given beans, beans should contain delete conditions.
|
|
|
|
func deleteBeans(e 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
|
|
|
|
}
|
|
|
|
|
2014-11-13 05:27:01 -05:00
|
|
|
// FIXME: need some kind of mechanism to record failure. HINT: system notice
|
2015-09-06 08:54:08 -04:00
|
|
|
func deleteUser(e *xorm.Session, u *User) error {
|
2015-08-17 05:05:37 -04:00
|
|
|
// Note: A user owns any repository or belongs to any organization
|
|
|
|
// cannot perform delete operation.
|
|
|
|
|
2014-04-10 14:20:58 -04:00
|
|
|
// Check ownership of repository.
|
2015-09-06 08:54:08 -04:00
|
|
|
count, err := getRepositoryCount(e, u)
|
2014-04-10 14:20:58 -04:00
|
|
|
if err != nil {
|
2015-03-17 21:51:39 -04:00
|
|
|
return fmt.Errorf("GetRepositoryCount: %v", err)
|
2014-04-10 14:20:58 -04:00
|
|
|
} else if count > 0 {
|
2015-03-17 21:51:39 -04:00
|
|
|
return ErrUserOwnRepos{UID: u.Id}
|
2014-04-10 14:20:58 -04:00
|
|
|
}
|
|
|
|
|
2014-06-27 03:37:01 -04:00
|
|
|
// Check membership of organization.
|
2015-09-06 08:54:08 -04:00
|
|
|
count, err = u.getOrganizationCount(e)
|
2014-06-27 03:37:01 -04:00
|
|
|
if err != nil {
|
2015-03-17 21:51:39 -04:00
|
|
|
return fmt.Errorf("GetOrganizationCount: %v", err)
|
2014-06-27 03:37:01 -04:00
|
|
|
} else if count > 0 {
|
2015-03-17 21:51:39 -04:00
|
|
|
return ErrUserHasOrgs{UID: u.Id}
|
2014-06-27 03:37:01 -04:00
|
|
|
}
|
|
|
|
|
2015-08-17 05:05:37 -04:00
|
|
|
// ***** START: Watch *****
|
2015-03-17 21:51:39 -04:00
|
|
|
watches := make([]*Watch, 0, 10)
|
2015-09-06 08:54:08 -04:00
|
|
|
if err = e.Find(&watches, &Watch{UserID: u.Id}); 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
|
|
|
}
|
2015-03-17 21:51:39 -04:00
|
|
|
for i := range watches {
|
2015-09-06 08:54:08 -04:00
|
|
|
if _, err = e.Exec("UPDATE `repository` SET num_watches=num_watches-1 WHERE id=?", watches[i].RepoID); err != nil {
|
2015-08-17 05:05:37 -04:00
|
|
|
return fmt.Errorf("decrease repository watch number[%d]: %v", watches[i].RepoID, 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 *****
|
|
|
|
stars := make([]*Star, 0, 10)
|
2015-09-06 08:54:08 -04:00
|
|
|
if err = e.Find(&stars, &Star{UID: u.Id}); err != nil {
|
2015-08-17 05:05:37 -04:00
|
|
|
return fmt.Errorf("get all stars: %v", err)
|
|
|
|
}
|
|
|
|
for i := range stars {
|
2015-09-06 08:54:08 -04:00
|
|
|
if _, err = e.Exec("UPDATE `repository` SET num_stars=num_stars-1 WHERE id=?", stars[i].RepoID); err != nil {
|
2015-08-17 05:05:37 -04:00
|
|
|
return fmt.Errorf("decrease repository star number[%d]: %v", stars[i].RepoID, err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// ***** END: Star *****
|
2015-03-17 21:51:39 -04:00
|
|
|
|
2015-08-17 05:05:37 -04:00
|
|
|
// ***** START: Follow *****
|
|
|
|
followers := make([]*Follow, 0, 10)
|
2015-09-06 08:54:08 -04:00
|
|
|
if err = e.Find(&followers, &Follow{UserID: u.Id}); err != nil {
|
2015-08-17 05:05:37 -04:00
|
|
|
return fmt.Errorf("get all followers: %v", err)
|
|
|
|
}
|
|
|
|
for i := range followers {
|
2015-09-06 08:54:08 -04:00
|
|
|
if _, err = e.Exec("UPDATE `user` SET num_followers=num_followers-1 WHERE id=?", followers[i].UserID); err != nil {
|
2015-08-17 05:05:37 -04:00
|
|
|
return fmt.Errorf("decrease user follower number[%d]: %v", followers[i].UserID, 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,
|
2015-08-17 05:05:37 -04:00
|
|
|
&AccessToken{UID: u.Id},
|
2015-03-17 21:51:39 -04:00
|
|
|
&Collaboration{UserID: u.Id},
|
2015-08-17 05:05:37 -04:00
|
|
|
&Access{UserID: u.Id},
|
2015-03-17 21:51:39 -04:00
|
|
|
&Watch{UserID: u.Id},
|
2015-08-17 05:05:37 -04:00
|
|
|
&Star{UID: u.Id},
|
|
|
|
&Follow{FollowID: u.Id},
|
|
|
|
&Action{UserID: u.Id},
|
2015-08-14 14:48:05 -04:00
|
|
|
&IssueUser{UID: u.Id},
|
2015-09-10 11:40:34 -04:00
|
|
|
&EmailAddress{UID: 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
|
|
|
|
2015-08-17 05:05:37 -04:00
|
|
|
// ***** START: PublicKey *****
|
2014-05-06 16:28:52 -04:00
|
|
|
keys := make([]*PublicKey, 0, 10)
|
2015-09-06 08:54:08 -04:00
|
|
|
if err = e.Find(&keys, &PublicKey{OwnerID: u.Id}); err != nil {
|
2015-08-17 05:05:37 -04:00
|
|
|
return fmt.Errorf("get all public keys: %v", err)
|
2014-04-10 14:20:58 -04:00
|
|
|
}
|
|
|
|
for _, key := range keys {
|
2015-09-06 08:54:08 -04:00
|
|
|
if err = deletePublicKey(e, key.ID); err != nil {
|
2015-08-17 05:05:37 -04:00
|
|
|
return fmt.Errorf("deletePublicKey: %v", err)
|
2014-04-10 14:20:58 -04:00
|
|
|
}
|
|
|
|
}
|
2015-08-17 05:05:37 -04:00
|
|
|
// ***** END: PublicKey *****
|
2014-04-10 14:20:58 -04:00
|
|
|
|
2015-08-14 14:48:05 -04:00
|
|
|
// Clear assignee.
|
2015-09-06 08:54:08 -04:00
|
|
|
if _, err = e.Exec("UPDATE `issue` SET assignee_id=0 WHERE assignee_id=?", 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
|
|
|
}
|
|
|
|
|
2015-09-06 08:54:08 -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
|
|
|
// FIXME: system notice
|
|
|
|
// Note: There are something just cannot be roll back,
|
|
|
|
// so just keep error logs of those operations.
|
|
|
|
|
|
|
|
RewriteAllPublicKeys()
|
|
|
|
os.RemoveAll(UserPath(u.Name))
|
2015-08-11 15:46:08 -04:00
|
|
|
os.Remove(u.CustomAvatarPath())
|
2014-04-10 14:20:58 -04:00
|
|
|
|
2015-08-17 05:05:37 -04:00
|
|
|
return nil
|
2014-06-21 00:51:41 -04:00
|
|
|
}
|
|
|
|
|
2015-09-06 08:54:08 -04: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 13:26:20 -04:00
|
|
|
// Note: don't wrapper error here.
|
|
|
|
return err
|
2015-09-06 08:54:08 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
return sess.Commit()
|
|
|
|
}
|
|
|
|
|
2014-12-17 03:26:19 -05:00
|
|
|
// DeleteInactivateUsers deletes all inactivate users and email addresses.
|
2015-08-17 05:05:37 -04:00
|
|
|
func DeleteInactivateUsers() (err error) {
|
|
|
|
users := make([]*User, 0, 10)
|
|
|
|
if err = x.Where("is_active=?", false).Find(&users); err != nil {
|
|
|
|
return fmt.Errorf("get all inactive users: %v", err)
|
|
|
|
}
|
|
|
|
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
|
|
|
|
}
|
2014-12-17 03:26:19 -05:00
|
|
|
}
|
2015-08-17 05:05:37 -04:00
|
|
|
|
|
|
|
_, err = x.Where("is_activated=?", false).Delete(new(EmailAddress))
|
2014-04-10 14:20:58 -04:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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
|
|
|
}
|
|
|
|
|
2015-11-04 21:57:10 -05:00
|
|
|
func GetUserByKeyID(keyID int64) (*User, error) {
|
2014-04-10 14:20:58 -04:00
|
|
|
user := new(User)
|
2015-11-04 21:57:10 -05: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 14:20:58 -04:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if !has {
|
2014-05-21 21:37:13 -04:00
|
|
|
return nil, ErrUserNotKeyOwner
|
2014-04-10 14:20:58 -04:00
|
|
|
}
|
|
|
|
return user, nil
|
|
|
|
}
|
|
|
|
|
2015-08-08 10:43:14 -04:00
|
|
|
func getUserByID(e Engine, id int64) (*User, error) {
|
2014-06-05 22:07:35 -04:00
|
|
|
u := new(User)
|
2015-02-13 00:58:46 -05: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 {
|
2015-08-04 23:14:17 -04:00
|
|
|
return nil, ErrUserNotExist{id, ""}
|
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) {
|
|
|
|
return getUserByID(x, id)
|
2015-02-13 00:58:46 -05:00
|
|
|
}
|
|
|
|
|
2015-08-10 09:47:23 -04:00
|
|
|
// GetAssigneeByID returns the user with write access of repository by given ID.
|
|
|
|
func GetAssigneeByID(repo *Repository, userID int64) (*User, error) {
|
|
|
|
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 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) {
|
|
|
|
if len(name) == 0 {
|
2015-08-04 23:14:17 -04:00
|
|
|
return nil, ErrUserNotExist{0, name}
|
2014-04-10 14:20:58 -04:00
|
|
|
}
|
2014-10-24 18:43:17 -04:00
|
|
|
u := &User{LowerName: strings.ToLower(name)}
|
|
|
|
has, err := x.Get(u)
|
2014-04-10 14:20:58 -04:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if !has {
|
2015-08-04 23:14:17 -04:00
|
|
|
return nil, ErrUserNotExist{0, name}
|
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
|
|
|
}
|
|
|
|
|
2014-10-11 18:02:48 -04:00
|
|
|
// GetUserEmailsByNames returns a list of e-mails corresponds to names.
|
2014-04-10 14:20:58 -04: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
|
|
|
|
}
|
|
|
|
|
2014-05-07 16:51:14 -04:00
|
|
|
// 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
|
|
|
|
}
|
|
|
|
|
2015-02-21 22:13:47 -05:00
|
|
|
// GetEmailAddresses returns all e-mail addresses belongs to given user.
|
2014-12-17 10:40:10 -05:00
|
|
|
func GetEmailAddresses(uid int64) ([]*EmailAddress, error) {
|
|
|
|
emails := make([]*EmailAddress, 0, 5)
|
2014-12-21 02:16:56 -05:00
|
|
|
err := x.Where("uid=?", uid).Find(&emails)
|
2014-12-17 10:40:10 -05:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2015-08-08 10:43:14 -04:00
|
|
|
u, err := GetUserByID(uid)
|
2014-12-17 10:40:10 -05:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2014-12-20 02:26:51 -05:00
|
|
|
isPrimaryFound := false
|
2014-12-17 10:40:10 -05:00
|
|
|
for _, email := range emails {
|
|
|
|
if email.Email == u.Email {
|
2014-12-20 02:26:51 -05:00
|
|
|
isPrimaryFound = true
|
2014-12-17 10:40:10 -05:00
|
|
|
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 02:26:51 -05:00
|
|
|
if !isPrimaryFound {
|
2015-02-21 22:13:47 -05:00
|
|
|
emails = append(emails, &EmailAddress{
|
|
|
|
Email: u.Email,
|
|
|
|
IsActivated: true,
|
|
|
|
IsPrimary: true,
|
|
|
|
})
|
2014-12-17 10:40:10 -05:00
|
|
|
}
|
|
|
|
return emails, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func AddEmailAddress(email *EmailAddress) error {
|
2015-12-15 22:57:18 -05:00
|
|
|
email.Email = strings.ToLower(strings.TrimSpace(email.Email))
|
2014-12-17 10:40:10 -05:00
|
|
|
used, err := IsEmailUsed(email.Email)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if used {
|
2015-03-26 17:11:47 -04:00
|
|
|
return ErrEmailAlreadyUsed{email.Email}
|
2014-12-17 10:40:10 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
_, err = x.Insert(email)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2015-12-15 22:57:18 -05:00
|
|
|
func AddEmailAddresses(emails []*EmailAddress) error {
|
|
|
|
if len(emails) == 0 {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if any of them has been used
|
|
|
|
for i := range emails {
|
|
|
|
emails[i].Email = strings.ToLower(strings.TrimSpace(emails[i].Email))
|
|
|
|
used, err := IsEmailUsed(emails[i].Email)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if used {
|
|
|
|
return ErrEmailAlreadyUsed{emails[i].Email}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if _, err := x.Insert(emails); err != nil {
|
|
|
|
return fmt.Errorf("Insert: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-12-17 10:40:10 -05:00
|
|
|
func (email *EmailAddress) Activate() error {
|
|
|
|
email.IsActivated = true
|
2015-09-10 11:40:34 -04:00
|
|
|
if _, err := x.Id(email.ID).AllCols().Update(email); err != nil {
|
2014-12-17 10:40:10 -05:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2015-09-10 11:40:34 -04:00
|
|
|
if user, err := GetUserByID(email.UID); err != nil {
|
2014-12-17 10:40:10 -05:00
|
|
|
return err
|
|
|
|
} else {
|
|
|
|
user.Rands = GetUserSalt()
|
|
|
|
return UpdateUser(user)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-15 22:57:18 -05:00
|
|
|
func DeleteEmailAddress(email *EmailAddress) (err error) {
|
|
|
|
if email.ID > 0 {
|
|
|
|
_, err = x.Id(email.ID).Delete(new(EmailAddress))
|
|
|
|
} else {
|
|
|
|
_, err = x.Where("email=?", email.Email).Delete(new(EmailAddress))
|
2014-12-17 10:40:10 -05:00
|
|
|
}
|
2015-12-15 22:57:18 -05:00
|
|
|
return err
|
|
|
|
}
|
2014-12-17 10:40:10 -05:00
|
|
|
|
2015-12-15 22:57:18 -05:00
|
|
|
func DeleteEmailAddresses(emails []*EmailAddress) (err error) {
|
|
|
|
for i := range emails {
|
|
|
|
if err = DeleteEmailAddress(emails[i]); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2014-12-17 10:40:10 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
|
}
|
|
|
|
|
2015-09-10 11:40:34 -04:00
|
|
|
user := &User{Id: email.UID}
|
2014-12-17 10:40:10 -05:00
|
|
|
has, err = x.Get(user)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if !has {
|
2015-09-10 11:40:34 -04:00
|
|
|
return ErrUserNotExist{email.UID, ""}
|
2014-12-17 10:40:10 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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 {
|
2015-09-10 11:40:34 -04:00
|
|
|
former_primary_email.UID = user.Id
|
2014-12-17 10:40:10 -05:00
|
|
|
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-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
|
|
|
}
|
|
|
|
|
2014-09-26 08:55:13 -04:00
|
|
|
// ValidateCommitWithEmail chceck if author's e-mail of commit is corresponsind to a user.
|
2015-12-09 20:46:05 -05:00
|
|
|
func ValidateCommitWithEmail(c *git.Commit) *User {
|
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.
|
|
|
|
func ValidateCommitsWithEmails(oldCommits *list.List) *list.List {
|
2015-08-05 05:36:22 -04:00
|
|
|
var (
|
|
|
|
u *User
|
|
|
|
emails = map[string]*User{}
|
|
|
|
newCommits = list.New()
|
|
|
|
e = oldCommits.Front()
|
|
|
|
)
|
2014-09-23 15:30:04 -04:00
|
|
|
for e != nil {
|
2015-12-09 20:46:05 -05:00
|
|
|
c := e.Value.(*git.Commit)
|
2014-09-23 15:30:04 -04:00
|
|
|
|
2014-09-23 23:18:14 -04:00
|
|
|
if v, ok := emails[c.Author.Email]; !ok {
|
2014-11-21 10:58:08 -05:00
|
|
|
u, _ = GetUserByEmail(c.Author.Email)
|
|
|
|
emails[c.Author.Email] = u
|
2014-09-23 23:18:14 -04:00
|
|
|
} else {
|
2014-11-21 10:58:08 -05:00
|
|
|
u = v
|
2014-09-23 15:30:04 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
newCommits.PushBack(UserCommit{
|
2014-11-21 10:58:08 -05:00
|
|
|
User: u,
|
|
|
|
Commit: c,
|
2014-09-23 15:30:04 -04:00
|
|
|
})
|
|
|
|
e = e.Next()
|
|
|
|
}
|
|
|
|
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) {
|
|
|
|
if len(email) == 0 {
|
2015-08-04 23:14:17 -04:00
|
|
|
return nil, ErrUserNotExist{0, "email"}
|
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}
|
2014-06-21 00:51:41 -04:00
|
|
|
has, err := x.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
|
2015-08-05 05:36:22 -04:00
|
|
|
emailAddress := &EmailAddress{Email: email, IsActivated: true}
|
2014-12-17 03:26:19 -05:00
|
|
|
has, err = x.Get(emailAddress)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
if has {
|
2015-09-10 11:40:34 -04:00
|
|
|
return GetUserByID(emailAddress.UID)
|
2014-12-17 03:26:19 -05:00
|
|
|
}
|
|
|
|
|
2015-11-13 17:10:25 -05:00
|
|
|
return nil, ErrUserNotExist{0, email}
|
2014-04-10 14:20:58 -04:00
|
|
|
}
|
|
|
|
|
2016-03-11 15:33:12 -05:00
|
|
|
type SearchUserOptions struct {
|
|
|
|
Keyword string
|
|
|
|
Type UserType
|
|
|
|
OrderBy string
|
|
|
|
Page int
|
|
|
|
PageSize int // Can be smaller than or equal to setting.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)
|
|
|
|
|
|
|
|
if opts.PageSize <= 0 || opts.PageSize > setting.ExplorePagingNum {
|
|
|
|
opts.PageSize = setting.ExplorePagingNum
|
|
|
|
}
|
|
|
|
if opts.Page <= 0 {
|
|
|
|
opts.Page = 1
|
|
|
|
}
|
|
|
|
|
2016-03-15 09:16:58 -04:00
|
|
|
searchQuery := "%" + opts.Keyword + "%"
|
2016-03-11 15:33:12 -05:00
|
|
|
users = make([]*User, 0, opts.PageSize)
|
|
|
|
// Append conditions
|
2016-03-15 09:16:58 -04:00
|
|
|
sess := x.Where("lower_name like ?", searchQuery).
|
|
|
|
Or("full_name like ?", searchQuery).
|
|
|
|
And("type = ?", opts.Type)
|
2016-03-11 15:33:12 -05:00
|
|
|
|
|
|
|
var countSess xorm.Session
|
|
|
|
countSess = *sess
|
|
|
|
count, err := countSess.Count(new(User))
|
|
|
|
if err != nil {
|
|
|
|
return nil, 0, fmt.Errorf("Count: %v", err)
|
2014-04-30 23:48:01 -04:00
|
|
|
}
|
|
|
|
|
2016-03-11 16:11:33 -05:00
|
|
|
if len(opts.OrderBy) > 0 {
|
|
|
|
sess.OrderBy(opts.OrderBy)
|
|
|
|
}
|
2016-03-11 15:33:12 -05:00
|
|
|
return users, count, sess.Limit(opts.PageSize, (opts.Page-1)*opts.PageSize).Find(&users)
|
2014-04-30 23:48:01 -04:00
|
|
|
}
|
|
|
|
|
2015-12-21 07:24:11 -05:00
|
|
|
// ___________ .__ .__
|
|
|
|
// \_ _____/___ | | | | ______ _ __
|
|
|
|
// | __)/ _ \| | | | / _ \ \/ \/ /
|
|
|
|
// | \( <_> ) |_| |_( <_> ) /
|
|
|
|
// \___ / \____/|____/____/\____/ \/\_/
|
|
|
|
// \/
|
|
|
|
|
|
|
|
// Follow represents relations of user and his/her followers.
|
2014-04-10 14:20:58 -04:00
|
|
|
type Follow struct {
|
2015-08-17 05:05:37 -04:00
|
|
|
ID int64 `xorm:"pk autoincr"`
|
|
|
|
UserID int64 `xorm:"UNIQUE(follow)"`
|
|
|
|
FollowID int64 `xorm:"UNIQUE(follow)"`
|
2014-04-10 14:20:58 -04:00
|
|
|
}
|
|
|
|
|
2015-12-21 07:24:11 -05:00
|
|
|
func IsFollowing(userID, followID int64) bool {
|
|
|
|
has, _ := x.Get(&Follow{UserID: userID, FollowID: followID})
|
|
|
|
return has
|
|
|
|
}
|
|
|
|
|
2014-04-10 14:20:58 -04:00
|
|
|
// FollowUser marks someone be another's follower.
|
2015-12-21 07:24:11 -05:00
|
|
|
func FollowUser(userID, followID int64) (err error) {
|
|
|
|
if userID == followID || IsFollowing(userID, followID) {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-10-03 13:12:54 -04:00
|
|
|
sess := x.NewSession()
|
2015-12-21 07:24:11 -05:00
|
|
|
defer sessionRelease(sess)
|
|
|
|
if err = sess.Begin(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2014-04-10 14:20:58 -04:00
|
|
|
|
2015-12-21 07:24:11 -05:00
|
|
|
if _, err = sess.Insert(&Follow{UserID: userID, FollowID: followID}); err != nil {
|
2014-04-10 14:20:58 -04:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2015-12-21 07:24:11 -05:00
|
|
|
if _, err = sess.Exec("UPDATE `user` SET num_followers = num_followers + 1 WHERE id = ?", followID); err != nil {
|
2014-04-10 14:20:58 -04:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2015-12-21 07:24:11 -05:00
|
|
|
if _, err = sess.Exec("UPDATE `user` SET num_following = num_following + 1 WHERE id = ?", userID); err != nil {
|
2014-04-10 14:20:58 -04:00
|
|
|
return err
|
|
|
|
}
|
2014-10-03 13:12:54 -04:00
|
|
|
return sess.Commit()
|
2014-04-10 14:20:58 -04:00
|
|
|
}
|
|
|
|
|
2015-12-21 07:24:11 -05: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 14:20:58 -04:00
|
|
|
}
|
|
|
|
|
2015-12-21 07:24:11 -05:00
|
|
|
sess := x.NewSession()
|
|
|
|
defer sessionRelease(sess)
|
|
|
|
if err = sess.Begin(); err != nil {
|
2014-04-10 14:20:58 -04:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2015-12-21 07:24:11 -05:00
|
|
|
if _, err = sess.Delete(&Follow{UserID: userID, FollowID: followID}); err != nil {
|
2014-04-10 14:20:58 -04:00
|
|
|
return err
|
|
|
|
}
|
2014-07-24 13:15:31 -04:00
|
|
|
|
2015-12-21 07:24:11 -05:00
|
|
|
if _, err = sess.Exec("UPDATE `user` SET num_followers = num_followers - 1 WHERE id = ?", followID); err != nil {
|
2014-07-24 13:15:31 -04:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2015-12-21 07:24:11 -05:00
|
|
|
if _, err = sess.Exec("UPDATE `user` SET num_following = num_following - 1 WHERE id = ?", userID); err != nil {
|
2014-07-24 13:15:31 -04:00
|
|
|
return err
|
|
|
|
}
|
2015-12-21 07:24:11 -05:00
|
|
|
return sess.Commit()
|
2014-07-24 13:15:31 -04:00
|
|
|
}
|