user.go 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423
  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. var (
  29. ErrUserOwnRepos = errors.New("User still have ownership of repositories")
  30. ErrUserAlreadyExist = errors.New("User already exist")
  31. ErrUserNotExist = errors.New("User does not exist")
  32. ErrEmailAlreadyUsed = errors.New("E-mail already used")
  33. ErrUserNameIllegal = errors.New("User name contains illegal characters")
  34. ErrKeyNotExist = errors.New("Public key does not exist")
  35. )
  36. // User represents the object of individual and member of organization.
  37. type User struct {
  38. Id int64
  39. LowerName string `xorm:"unique not null"`
  40. Name string `xorm:"unique not null"`
  41. Email string `xorm:"unique not null"`
  42. Passwd string `xorm:"not null"`
  43. LoginType int
  44. Type int
  45. NumFollowers int
  46. NumFollowings int
  47. NumStars int
  48. NumRepos int
  49. Avatar string `xorm:"varchar(2048) not null"`
  50. AvatarEmail string `xorm:"not null"`
  51. Location string
  52. Website string
  53. IsActive bool
  54. IsAdmin bool
  55. Rands string `xorm:"VARCHAR(10)"`
  56. Created time.Time `xorm:"created"`
  57. Updated time.Time `xorm:"updated"`
  58. }
  59. // HomeLink returns the user home page link.
  60. func (user *User) HomeLink() string {
  61. return "/user/" + user.Name
  62. }
  63. // AvatarLink returns the user gravatar link.
  64. func (user *User) AvatarLink() string {
  65. if base.Service.EnableCacheAvatar {
  66. return "/avatar/" + user.Avatar
  67. }
  68. return "http://1.gravatar.com/avatar/" + user.Avatar
  69. }
  70. // NewGitSig generates and returns the signature of given user.
  71. func (user *User) NewGitSig() *git.Signature {
  72. return &git.Signature{
  73. Name: user.Name,
  74. Email: user.Email,
  75. When: time.Now(),
  76. }
  77. }
  78. // EncodePasswd encodes password to safe format.
  79. func (user *User) EncodePasswd() error {
  80. newPasswd, err := scrypt.Key([]byte(user.Passwd), []byte(base.SecretKey), 16384, 8, 1, 64)
  81. user.Passwd = fmt.Sprintf("%x", newPasswd)
  82. return err
  83. }
  84. // Member represents user is member of organization.
  85. type Member struct {
  86. Id int64
  87. OrgId int64 `xorm:"unique(member) index"`
  88. UserId int64 `xorm:"unique(member)"`
  89. }
  90. // IsUserExist checks if given user name exist,
  91. // the user name should be noncased unique.
  92. func IsUserExist(name string) (bool, error) {
  93. return orm.Get(&User{LowerName: strings.ToLower(name)})
  94. }
  95. // IsEmailUsed returns true if the e-mail has been used.
  96. func IsEmailUsed(email string) (bool, error) {
  97. return orm.Get(&User{Email: email})
  98. }
  99. // return a user salt token
  100. func GetUserSalt() string {
  101. return base.GetRandomString(10)
  102. }
  103. // RegisterUser creates record of a new user.
  104. func RegisterUser(user *User) (*User, error) {
  105. if !IsLegalName(user.Name) {
  106. return nil, ErrUserNameIllegal
  107. }
  108. isExist, err := IsUserExist(user.Name)
  109. if err != nil {
  110. return nil, err
  111. } else if isExist {
  112. return nil, ErrUserAlreadyExist
  113. }
  114. isExist, err = IsEmailUsed(user.Email)
  115. if err != nil {
  116. return nil, err
  117. } else if isExist {
  118. return nil, ErrEmailAlreadyUsed
  119. }
  120. user.LowerName = strings.ToLower(user.Name)
  121. user.Avatar = base.EncodeMd5(user.Email)
  122. user.AvatarEmail = user.Email
  123. user.Rands = GetUserSalt()
  124. if err = user.EncodePasswd(); err != nil {
  125. return nil, err
  126. } else if _, err = orm.Insert(user); err != nil {
  127. return nil, err
  128. } else if err = os.MkdirAll(UserPath(user.Name), os.ModePerm); err != nil {
  129. if _, err := orm.Id(user.Id).Delete(&User{}); err != nil {
  130. return nil, errors.New(fmt.Sprintf(
  131. "both create userpath %s and delete table record faild: %v", user.Name, err))
  132. }
  133. return nil, err
  134. }
  135. if user.Id == 1 {
  136. user.IsAdmin = true
  137. user.IsActive = true
  138. _, err = orm.Id(user.Id).UseBool().Update(user)
  139. }
  140. return user, err
  141. }
  142. // GetUsers returns given number of user objects with offset.
  143. func GetUsers(num, offset int) ([]User, error) {
  144. users := make([]User, 0, num)
  145. err := orm.Limit(num, offset).Asc("id").Find(&users)
  146. return users, err
  147. }
  148. // get user by erify code
  149. func getVerifyUser(code string) (user *User) {
  150. if len(code) <= base.TimeLimitCodeLength {
  151. return nil
  152. }
  153. // use tail hex username query user
  154. hexStr := code[base.TimeLimitCodeLength:]
  155. if b, err := hex.DecodeString(hexStr); err == nil {
  156. if user, err = GetUserByName(string(b)); user != nil {
  157. return user
  158. }
  159. log.Error("user.getVerifyUser: %v", err)
  160. }
  161. return nil
  162. }
  163. // verify active code when active account
  164. func VerifyUserActiveCode(code string) (user *User) {
  165. minutes := base.Service.ActiveCodeLives
  166. if user = getVerifyUser(code); user != nil {
  167. // time limit code
  168. prefix := code[:base.TimeLimitCodeLength]
  169. data := base.ToStr(user.Id) + user.Email + user.LowerName + user.Passwd + user.Rands
  170. if base.VerifyTimeLimitCode(data, minutes, prefix) {
  171. return user
  172. }
  173. }
  174. return nil
  175. }
  176. // ChangeUserName changes all corresponding setting from old user name to new one.
  177. func ChangeUserName(user *User, newUserName string) (err error) {
  178. newUserName = strings.ToLower(newUserName)
  179. // Update accesses of user.
  180. accesses := make([]Access, 0, 10)
  181. if err = orm.Find(&accesses, &Access{UserName: user.LowerName}); err != nil {
  182. return err
  183. }
  184. for i := range accesses {
  185. accesses[i].UserName = newUserName
  186. if strings.HasPrefix(accesses[i].RepoName, user.LowerName+"/") {
  187. accesses[i].RepoName = strings.Replace(accesses[i].RepoName, user.LowerName, newUserName, 1)
  188. if err = UpdateAccess(&accesses[i]); err != nil {
  189. return err
  190. }
  191. }
  192. }
  193. repos, err := GetRepositories(user)
  194. if err != nil {
  195. return err
  196. }
  197. for i := range repos {
  198. accesses = make([]Access, 0, 10)
  199. // Update accesses of user repository.
  200. if err = orm.Find(&accesses, &Access{RepoName: user.LowerName + "/" + repos[i].LowerName}); err != nil {
  201. return err
  202. }
  203. for j := range accesses {
  204. accesses[j].RepoName = newUserName + "/" + repos[i].LowerName
  205. if err = UpdateAccess(&accesses[j]); err != nil {
  206. return err
  207. }
  208. }
  209. }
  210. // Change user directory name.
  211. return os.Rename(UserPath(user.LowerName), UserPath(newUserName))
  212. }
  213. // UpdateUser updates user's information.
  214. func UpdateUser(user *User) (err error) {
  215. user.LowerName = strings.ToLower(user.Name)
  216. if len(user.Location) > 255 {
  217. user.Location = user.Location[:255]
  218. }
  219. if len(user.Website) > 255 {
  220. user.Website = user.Website[:255]
  221. }
  222. _, err = orm.Id(user.Id).AllCols().Update(user)
  223. return err
  224. }
  225. // DeleteUser completely deletes everything of the user.
  226. func DeleteUser(user *User) error {
  227. // Check ownership of repository.
  228. count, err := GetRepositoryCount(user)
  229. if err != nil {
  230. return errors.New("modesl.GetRepositories: " + err.Error())
  231. } else if count > 0 {
  232. return ErrUserOwnRepos
  233. }
  234. // TODO: check issues, other repos' commits
  235. // Delete all feeds.
  236. if _, err = orm.Delete(&Action{UserId: user.Id}); err != nil {
  237. return err
  238. }
  239. // Delete all accesses.
  240. if _, err = orm.Delete(&Access{UserName: user.LowerName}); err != nil {
  241. return err
  242. }
  243. // Delete all SSH keys.
  244. keys := make([]PublicKey, 0, 10)
  245. if err = orm.Find(&keys, &PublicKey{OwnerId: user.Id}); err != nil {
  246. return err
  247. }
  248. for _, key := range keys {
  249. if err = DeletePublicKey(&key); err != nil {
  250. return err
  251. }
  252. }
  253. // Delete user directory.
  254. if err = os.RemoveAll(UserPath(user.Name)); err != nil {
  255. return err
  256. }
  257. _, err = orm.Delete(user)
  258. // TODO: delete and update follower information.
  259. return err
  260. }
  261. // UserPath returns the path absolute path of user repositories.
  262. func UserPath(userName string) string {
  263. return filepath.Join(base.RepoRootPath, strings.ToLower(userName))
  264. }
  265. func GetUserByKeyId(keyId int64) (*User, error) {
  266. user := new(User)
  267. rawSql := "SELECT a.* FROM `user` AS a, public_key AS b WHERE a.id = b.owner_id AND b.id=?"
  268. has, err := orm.Sql(rawSql, keyId).Get(user)
  269. if err != nil {
  270. return nil, err
  271. } else if !has {
  272. err = errors.New("not exist key owner")
  273. return nil, err
  274. }
  275. return user, nil
  276. }
  277. // GetUserById returns the user object by given id if exists.
  278. func GetUserById(id int64) (*User, error) {
  279. user := new(User)
  280. has, err := orm.Id(id).Get(user)
  281. if err != nil {
  282. return nil, err
  283. }
  284. if !has {
  285. return nil, ErrUserNotExist
  286. }
  287. return user, nil
  288. }
  289. // GetUserByName returns the user object by given name if exists.
  290. func GetUserByName(name string) (*User, error) {
  291. if len(name) == 0 {
  292. return nil, ErrUserNotExist
  293. }
  294. user := &User{LowerName: strings.ToLower(name)}
  295. has, err := orm.Get(user)
  296. if err != nil {
  297. return nil, err
  298. } else if !has {
  299. return nil, ErrUserNotExist
  300. }
  301. return user, nil
  302. }
  303. // LoginUserPlain validates user by raw user name and password.
  304. func LoginUserPlain(name, passwd string) (*User, error) {
  305. user := User{LowerName: strings.ToLower(name), Passwd: passwd}
  306. if err := user.EncodePasswd(); err != nil {
  307. return nil, err
  308. }
  309. has, err := orm.Get(&user)
  310. if err != nil {
  311. return nil, err
  312. } else if !has {
  313. err = ErrUserNotExist
  314. }
  315. return &user, err
  316. }
  317. // Follow is connection request for receiving user notifycation.
  318. type Follow struct {
  319. Id int64
  320. UserId int64 `xorm:"unique(follow)"`
  321. FollowId int64 `xorm:"unique(follow)"`
  322. }
  323. // FollowUser marks someone be another's follower.
  324. func FollowUser(userId int64, followId int64) (err error) {
  325. session := orm.NewSession()
  326. defer session.Close()
  327. session.Begin()
  328. if _, err = session.Insert(&Follow{UserId: userId, FollowId: followId}); err != nil {
  329. session.Rollback()
  330. return err
  331. }
  332. rawSql := "UPDATE `user` SET num_followers = num_followers + 1 WHERE id = ?"
  333. if _, err = session.Exec(rawSql, followId); err != nil {
  334. session.Rollback()
  335. return err
  336. }
  337. rawSql = "UPDATE `user` SET num_followings = num_followings + 1 WHERE id = ?"
  338. if _, err = session.Exec(rawSql, userId); err != nil {
  339. session.Rollback()
  340. return err
  341. }
  342. return session.Commit()
  343. }
  344. // UnFollowUser unmarks someone be another's follower.
  345. func UnFollowUser(userId int64, unFollowId int64) (err error) {
  346. session := orm.NewSession()
  347. defer session.Close()
  348. session.Begin()
  349. if _, err = session.Delete(&Follow{UserId: userId, FollowId: unFollowId}); err != nil {
  350. session.Rollback()
  351. return err
  352. }
  353. rawSql := "UPDATE `user` SET num_followers = num_followers - 1 WHERE id = ?"
  354. if _, err = session.Exec(rawSql, unFollowId); err != nil {
  355. session.Rollback()
  356. return err
  357. }
  358. rawSql = "UPDATE `user` SET num_followings = num_followings - 1 WHERE id = ?"
  359. if _, err = session.Exec(rawSql, userId); err != nil {
  360. session.Rollback()
  361. return err
  362. }
  363. return session.Commit()
  364. }