user.go 9.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354
  1. // Copyright 2014 The Gogs Authors. All rights reserved.
  2. // Use of this source code is governed by a MIT-style
  3. // license that can be found in the LICENSE file.
  4. package models
  5. import (
  6. "encoding/hex"
  7. "errors"
  8. "fmt"
  9. "os"
  10. "path/filepath"
  11. "strings"
  12. "time"
  13. "github.com/dchest/scrypt"
  14. "github.com/gogits/git"
  15. "github.com/gogits/gogs/modules/base"
  16. "github.com/gogits/gogs/modules/log"
  17. )
  18. // User types.
  19. const (
  20. UT_INDIVIDUAL = iota + 1
  21. UT_ORGANIZATION
  22. )
  23. // Login types.
  24. const (
  25. LT_PLAIN = iota + 1
  26. LT_LDAP
  27. )
  28. // User represents the object of individual and member of organization.
  29. type User struct {
  30. Id int64
  31. LowerName string `xorm:"unique not null"`
  32. Name string `xorm:"unique not null"`
  33. Email string `xorm:"unique not null"`
  34. Passwd string `xorm:"not null"`
  35. LoginType int
  36. Type int
  37. NumFollowers int
  38. NumFollowings int
  39. NumStars int
  40. NumRepos int
  41. Avatar string `xorm:"varchar(2048) not null"`
  42. AvatarEmail string `xorm:"not null"`
  43. Location string
  44. Website string
  45. IsActive bool
  46. Rands string `xorm:"VARCHAR(10)"`
  47. Created time.Time `xorm:"created"`
  48. Updated time.Time `xorm:"updated"`
  49. }
  50. // HomeLink returns the user home page link.
  51. func (user *User) HomeLink() string {
  52. return "/user/" + user.LowerName
  53. }
  54. // AvatarLink returns the user gravatar link.
  55. func (user *User) AvatarLink() string {
  56. return "http://1.gravatar.com/avatar/" + user.Avatar
  57. }
  58. type Follow struct {
  59. Id int64
  60. UserId int64 `xorm:"unique(s)"`
  61. FollowId int64 `xorm:"unique(s)"`
  62. Created time.Time `xorm:"created"`
  63. }
  64. var (
  65. ErrUserOwnRepos = errors.New("User still have ownership of repositories")
  66. ErrUserAlreadyExist = errors.New("User already exist")
  67. ErrUserNotExist = errors.New("User does not exist")
  68. ErrEmailAlreadyUsed = errors.New("E-mail already used")
  69. )
  70. // IsUserExist checks if given user name exist,
  71. // the user name should be noncased unique.
  72. func IsUserExist(name string) (bool, error) {
  73. return orm.Get(&User{LowerName: strings.ToLower(name)})
  74. }
  75. // IsEmailUsed returns true if the e-mail has been used.
  76. func IsEmailUsed(email string) (bool, error) {
  77. return orm.Get(&User{Email: email})
  78. }
  79. // NewGitSig generates and returns the signature of given user.
  80. func (user *User) NewGitSig() *git.Signature {
  81. return &git.Signature{
  82. Name: user.Name,
  83. Email: user.Email,
  84. When: time.Now(),
  85. }
  86. }
  87. // return a user salt token
  88. func GetUserSalt() string {
  89. return base.GetRandomString(10)
  90. }
  91. // RegisterUser creates record of a new user.
  92. func RegisterUser(user *User) (*User, error) {
  93. isExist, err := IsUserExist(user.Name)
  94. if err != nil {
  95. return nil, err
  96. } else if isExist {
  97. return nil, ErrUserAlreadyExist
  98. }
  99. isExist, err = IsEmailUsed(user.Email)
  100. if err != nil {
  101. return nil, err
  102. } else if isExist {
  103. return nil, ErrEmailAlreadyUsed
  104. }
  105. user.LowerName = strings.ToLower(user.Name)
  106. user.Avatar = base.EncodeMd5(user.Email)
  107. user.AvatarEmail = user.Email
  108. user.Rands = GetUserSalt()
  109. if err = user.EncodePasswd(); err != nil {
  110. return nil, err
  111. } else if _, err = orm.Insert(user); err != nil {
  112. return nil, err
  113. } else if err = os.MkdirAll(UserPath(user.Name), os.ModePerm); err != nil {
  114. if _, err := orm.Id(user.Id).Delete(&User{}); err != nil {
  115. return nil, errors.New(fmt.Sprintf(
  116. "both create userpath %s and delete table record faild: %v", user.Name, err))
  117. }
  118. return nil, err
  119. }
  120. return user, nil
  121. }
  122. // get user by erify code
  123. func getVerifyUser(code string) (user *User) {
  124. if len(code) <= base.TimeLimitCodeLength {
  125. return nil
  126. }
  127. // use tail hex username query user
  128. hexStr := code[base.TimeLimitCodeLength:]
  129. if b, err := hex.DecodeString(hexStr); err == nil {
  130. if user, err = GetUserByName(string(b)); user != nil {
  131. return user
  132. }
  133. log.Error("user.getVerifyUser: %v", err)
  134. }
  135. return nil
  136. }
  137. // verify active code when active account
  138. func VerifyUserActiveCode(code string) (user *User) {
  139. minutes := base.Service.ActiveCodeLives
  140. if user = getVerifyUser(code); user != nil {
  141. // time limit code
  142. prefix := code[:base.TimeLimitCodeLength]
  143. data := base.ToStr(user.Id) + user.Email + user.LowerName + user.Passwd + user.Rands
  144. if base.VerifyTimeLimitCode(data, minutes, prefix) {
  145. return user
  146. }
  147. }
  148. return nil
  149. }
  150. // UpdateUser updates user's information.
  151. func UpdateUser(user *User) (err error) {
  152. _, err = orm.Id(user.Id).UseBool().Update(user)
  153. return err
  154. }
  155. // DeleteUser completely deletes everything of the user.
  156. func DeleteUser(user *User) error {
  157. // Check ownership of repository.
  158. count, err := GetRepositoryCount(user)
  159. if err != nil {
  160. return errors.New("modesl.GetRepositories: " + err.Error())
  161. } else if count > 0 {
  162. return ErrUserOwnRepos
  163. }
  164. // TODO: check issues, other repos' commits
  165. // Delete all feeds.
  166. if _, err = orm.Delete(&Action{UserId: user.Id}); err != nil {
  167. return err
  168. }
  169. // Delete all SSH keys.
  170. keys := make([]PublicKey, 0, 10)
  171. if err = orm.Find(&keys, &PublicKey{OwnerId: user.Id}); err != nil {
  172. return err
  173. }
  174. for _, key := range keys {
  175. if err = DeletePublicKey(&key); err != nil {
  176. return err
  177. }
  178. }
  179. // Delete user directory.
  180. if err = os.RemoveAll(UserPath(user.Name)); err != nil {
  181. return err
  182. }
  183. _, err = orm.Delete(user)
  184. // TODO: delete and update follower information.
  185. return err
  186. }
  187. // EncodePasswd encodes password to safe format.
  188. func (user *User) EncodePasswd() error {
  189. newPasswd, err := scrypt.Key([]byte(user.Passwd), []byte(base.SecretKey), 16384, 8, 1, 64)
  190. user.Passwd = fmt.Sprintf("%x", newPasswd)
  191. return err
  192. }
  193. // UserPath returns the path absolute path of user repositories.
  194. func UserPath(userName string) string {
  195. return filepath.Join(RepoRootPath, strings.ToLower(userName))
  196. }
  197. func GetUserByKeyId(keyId int64) (*User, error) {
  198. user := new(User)
  199. rawSql := "SELECT a.* FROM user AS a, public_key AS b WHERE a.id = b.owner_id AND b.id=?"
  200. if base.Cfg.MustValue("database", "DB_TYPE") == "postgres" {
  201. rawSql = "SELECT a.* FROM \"user\" AS a, public_key AS b WHERE a.id = b.owner_id AND b.id=?"
  202. }
  203. has, err := orm.Sql(rawSql, keyId).Get(user)
  204. if err != nil {
  205. return nil, err
  206. } else if !has {
  207. err = errors.New("not exist key owner")
  208. return nil, err
  209. }
  210. return user, nil
  211. }
  212. // GetUserById returns the user object by given id if exists.
  213. func GetUserById(id int64) (*User, error) {
  214. user := new(User)
  215. has, err := orm.Id(id).Get(user)
  216. if err != nil {
  217. return nil, err
  218. }
  219. if !has {
  220. return nil, ErrUserNotExist
  221. }
  222. return user, nil
  223. }
  224. // GetUserByName returns the user object by given name if exists.
  225. func GetUserByName(name string) (*User, error) {
  226. if len(name) == 0 {
  227. return nil, ErrUserNotExist
  228. }
  229. user := &User{
  230. LowerName: strings.ToLower(name),
  231. }
  232. has, err := orm.Get(user)
  233. if err != nil {
  234. return nil, err
  235. } else if !has {
  236. return nil, ErrUserNotExist
  237. }
  238. return user, nil
  239. }
  240. // LoginUserPlain validates user by raw user name and password.
  241. func LoginUserPlain(name, passwd string) (*User, error) {
  242. user := User{LowerName: strings.ToLower(name), Passwd: passwd}
  243. if err := user.EncodePasswd(); err != nil {
  244. return nil, err
  245. }
  246. has, err := orm.Get(&user)
  247. if err != nil {
  248. return nil, err
  249. } else if !has {
  250. err = ErrUserNotExist
  251. }
  252. return &user, err
  253. }
  254. // FollowUser marks someone be another's follower.
  255. func FollowUser(userId int64, followId int64) (err error) {
  256. session := orm.NewSession()
  257. defer session.Close()
  258. session.Begin()
  259. if _, err = session.Insert(&Follow{UserId: userId, FollowId: followId}); err != nil {
  260. session.Rollback()
  261. return err
  262. }
  263. rawSql := "UPDATE user SET num_followers = num_followers + 1 WHERE id = ?"
  264. if base.Cfg.MustValue("database", "DB_TYPE") == "postgres" {
  265. rawSql = "UPDATE \"user\" SET num_followers = num_followers + 1 WHERE id = ?"
  266. }
  267. if _, err = session.Exec(rawSql, followId); err != nil {
  268. session.Rollback()
  269. return err
  270. }
  271. rawSql = "UPDATE user SET num_followings = num_followings + 1 WHERE id = ?"
  272. if base.Cfg.MustValue("database", "DB_TYPE") == "postgres" {
  273. rawSql = "UPDATE \"user\" SET num_followings = num_followings + 1 WHERE id = ?"
  274. }
  275. if _, err = session.Exec(rawSql, userId); err != nil {
  276. session.Rollback()
  277. return err
  278. }
  279. return session.Commit()
  280. }
  281. // UnFollowUser unmarks someone be another's follower.
  282. func UnFollowUser(userId int64, unFollowId int64) (err error) {
  283. session := orm.NewSession()
  284. defer session.Close()
  285. session.Begin()
  286. if _, err = session.Delete(&Follow{UserId: userId, FollowId: unFollowId}); err != nil {
  287. session.Rollback()
  288. return err
  289. }
  290. rawSql := "UPDATE user SET num_followers = num_followers - 1 WHERE id = ?"
  291. if base.Cfg.MustValue("database", "DB_TYPE") == "postgres" {
  292. rawSql = "UPDATE \"user\" SET num_followers = num_followers - 1 WHERE id = ?"
  293. }
  294. if _, err = session.Exec(rawSql, unFollowId); err != nil {
  295. session.Rollback()
  296. return err
  297. }
  298. rawSql = "UPDATE user SET num_followings = num_followings - 1 WHERE id = ?"
  299. if base.Cfg.MustValue("database", "DB_TYPE") == "postgres" {
  300. rawSql = "UPDATE \"user\" SET num_followings = num_followings - 1 WHERE id = ?"
  301. }
  302. if _, err = session.Exec(rawSql, userId); err != nil {
  303. session.Rollback()
  304. return err
  305. }
  306. return session.Commit()
  307. }