user.go 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095
  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. "bytes"
  7. "container/list"
  8. "crypto/sha256"
  9. "encoding/hex"
  10. "errors"
  11. "fmt"
  12. "image"
  13. "image/jpeg"
  14. _ "image/jpeg"
  15. "os"
  16. "path"
  17. "path/filepath"
  18. "strings"
  19. "time"
  20. "github.com/Unknwon/com"
  21. "github.com/go-xorm/xorm"
  22. "github.com/nfnt/resize"
  23. "github.com/gogits/gogs/modules/avatar"
  24. "github.com/gogits/gogs/modules/base"
  25. "github.com/gogits/gogs/modules/git"
  26. "github.com/gogits/gogs/modules/log"
  27. "github.com/gogits/gogs/modules/setting"
  28. )
  29. type UserType int
  30. const (
  31. INDIVIDUAL UserType = iota // Historic reason to make it starts at 0.
  32. ORGANIZATION
  33. )
  34. var (
  35. ErrUserNotKeyOwner = errors.New("User does not the owner of public key")
  36. ErrEmailNotExist = errors.New("E-mail does not exist")
  37. ErrEmailNotActivated = errors.New("E-mail address has not been activated")
  38. ErrUserNameIllegal = errors.New("User name contains illegal characters")
  39. ErrLoginSourceNotExist = errors.New("Login source does not exist")
  40. ErrLoginSourceNotActived = errors.New("Login source is not actived")
  41. ErrUnsupportedLoginType = errors.New("Login source is unknown")
  42. )
  43. // User represents the object of individual and member of organization.
  44. type User struct {
  45. Id int64
  46. LowerName string `xorm:"UNIQUE NOT NULL"`
  47. Name string `xorm:"UNIQUE NOT NULL"`
  48. FullName string
  49. // Email is the primary email address (to be used for communication).
  50. Email string `xorm:"NOT NULL"`
  51. Passwd string `xorm:"NOT NULL"`
  52. LoginType LoginType
  53. LoginSource int64 `xorm:"NOT NULL DEFAULT 0"`
  54. LoginName string
  55. Type UserType
  56. OwnedOrgs []*User `xorm:"-"`
  57. Orgs []*User `xorm:"-"`
  58. Repos []*Repository `xorm:"-"`
  59. Location string
  60. Website string
  61. Rands string `xorm:"VARCHAR(10)"`
  62. Salt string `xorm:"VARCHAR(10)"`
  63. Created time.Time `xorm:"CREATED"`
  64. Updated time.Time `xorm:"UPDATED"`
  65. // Remember visibility choice for convenience.
  66. LastRepoVisibility bool
  67. // Permissions.
  68. IsActive bool
  69. IsAdmin bool
  70. AllowGitHook bool
  71. // Avatar.
  72. Avatar string `xorm:"VARCHAR(2048) NOT NULL"`
  73. AvatarEmail string `xorm:"NOT NULL"`
  74. UseCustomAvatar bool
  75. // Counters.
  76. NumFollowers int
  77. NumFollowings int
  78. NumStars int
  79. NumRepos int
  80. // For organization.
  81. Description string
  82. NumTeams int
  83. NumMembers int
  84. Teams []*Team `xorm:"-"`
  85. Members []*User `xorm:"-"`
  86. }
  87. func (u *User) AfterSet(colName string, _ xorm.Cell) {
  88. switch colName {
  89. case "full_name":
  90. u.FullName = base.Sanitizer.Sanitize(u.FullName)
  91. case "created":
  92. u.Created = regulateTimeZone(u.Created)
  93. }
  94. }
  95. // EmailAdresses is the list of all email addresses of a user. Can contain the
  96. // primary email address, but is not obligatory
  97. type EmailAddress struct {
  98. ID int64 `xorm:"pk autoincr"`
  99. UID int64 `xorm:"INDEX NOT NULL"`
  100. Email string `xorm:"UNIQUE NOT NULL"`
  101. IsActivated bool
  102. IsPrimary bool `xorm:"-"`
  103. }
  104. // DashboardLink returns the user dashboard page link.
  105. func (u *User) DashboardLink() string {
  106. if u.IsOrganization() {
  107. return setting.AppSubUrl + "/org/" + u.Name + "/dashboard/"
  108. }
  109. return setting.AppSubUrl + "/"
  110. }
  111. // HomeLink returns the user or organization home page link.
  112. func (u *User) HomeLink() string {
  113. if u.IsOrganization() {
  114. return setting.AppSubUrl + "/org/" + u.Name
  115. }
  116. return setting.AppSubUrl + "/" + u.Name
  117. }
  118. // GenerateEmailActivateCode generates an activate code based on user information and given e-mail.
  119. func (u *User) GenerateEmailActivateCode(email string) string {
  120. code := base.CreateTimeLimitCode(
  121. com.ToStr(u.Id)+email+u.LowerName+u.Passwd+u.Rands,
  122. setting.Service.ActiveCodeLives, nil)
  123. // Add tail hex username
  124. code += hex.EncodeToString([]byte(u.LowerName))
  125. return code
  126. }
  127. // GenerateActivateCode generates an activate code based on user information.
  128. func (u *User) GenerateActivateCode() string {
  129. return u.GenerateEmailActivateCode(u.Email)
  130. }
  131. // CustomAvatarPath returns user custom avatar file path.
  132. func (u *User) CustomAvatarPath() string {
  133. return filepath.Join(setting.AvatarUploadPath, com.ToStr(u.Id))
  134. }
  135. // GenerateRandomAvatar generates a random avatar for user.
  136. func (u *User) GenerateRandomAvatar() error {
  137. seed := u.Email
  138. if len(seed) == 0 {
  139. seed = u.Name
  140. }
  141. img, err := avatar.RandomImage([]byte(seed))
  142. if err != nil {
  143. return fmt.Errorf("RandomImage: %v", err)
  144. }
  145. if err = os.MkdirAll(path.Dir(u.CustomAvatarPath()), os.ModePerm); err != nil {
  146. return fmt.Errorf("MkdirAll: %v", err)
  147. }
  148. fw, err := os.Create(u.CustomAvatarPath())
  149. if err != nil {
  150. return fmt.Errorf("Create: %v", err)
  151. }
  152. defer fw.Close()
  153. if err = jpeg.Encode(fw, img, nil); err != nil {
  154. return fmt.Errorf("Encode: %v", err)
  155. }
  156. log.Info("New random avatar created: %d", u.Id)
  157. return nil
  158. }
  159. func (u *User) RelAvatarLink() string {
  160. defaultImgUrl := "/img/avatar_default.jpg"
  161. if u.Id == -1 {
  162. return defaultImgUrl
  163. }
  164. switch {
  165. case u.UseCustomAvatar:
  166. if !com.IsExist(u.CustomAvatarPath()) {
  167. return defaultImgUrl
  168. }
  169. return "/avatars/" + com.ToStr(u.Id)
  170. case setting.DisableGravatar, setting.OfflineMode:
  171. if !com.IsExist(u.CustomAvatarPath()) {
  172. if err := u.GenerateRandomAvatar(); err != nil {
  173. log.Error(3, "GenerateRandomAvatar: %v", err)
  174. }
  175. }
  176. return "/avatars/" + com.ToStr(u.Id)
  177. case setting.Service.EnableCacheAvatar:
  178. return "/avatar/" + u.Avatar
  179. }
  180. return setting.GravatarSource + u.Avatar
  181. }
  182. // AvatarLink returns user gravatar link.
  183. func (u *User) AvatarLink() string {
  184. link := u.RelAvatarLink()
  185. if link[0] == '/' && link[1] != '/' {
  186. return setting.AppSubUrl + link
  187. }
  188. return link
  189. }
  190. // NewGitSig generates and returns the signature of given user.
  191. func (u *User) NewGitSig() *git.Signature {
  192. return &git.Signature{
  193. Name: u.Name,
  194. Email: u.Email,
  195. When: time.Now(),
  196. }
  197. }
  198. // EncodePasswd encodes password to safe format.
  199. func (u *User) EncodePasswd() {
  200. newPasswd := base.PBKDF2([]byte(u.Passwd), []byte(u.Salt), 10000, 50, sha256.New)
  201. u.Passwd = fmt.Sprintf("%x", newPasswd)
  202. }
  203. // ValidatePassword checks if given password matches the one belongs to the user.
  204. func (u *User) ValidatePassword(passwd string) bool {
  205. newUser := &User{Passwd: passwd, Salt: u.Salt}
  206. newUser.EncodePasswd()
  207. return u.Passwd == newUser.Passwd
  208. }
  209. // UploadAvatar saves custom avatar for user.
  210. // FIXME: split uploads to different subdirs in case we have massive users.
  211. func (u *User) UploadAvatar(data []byte) error {
  212. u.UseCustomAvatar = true
  213. img, _, err := image.Decode(bytes.NewReader(data))
  214. if err != nil {
  215. return err
  216. }
  217. m := resize.Resize(234, 234, img, resize.NearestNeighbor)
  218. sess := x.NewSession()
  219. defer sessionRelease(sess)
  220. if err = sess.Begin(); err != nil {
  221. return err
  222. }
  223. if _, err = sess.Id(u.Id).AllCols().Update(u); err != nil {
  224. return err
  225. }
  226. os.MkdirAll(setting.AvatarUploadPath, os.ModePerm)
  227. fw, err := os.Create(u.CustomAvatarPath())
  228. if err != nil {
  229. return err
  230. }
  231. defer fw.Close()
  232. if err = jpeg.Encode(fw, m, nil); err != nil {
  233. return err
  234. }
  235. return sess.Commit()
  236. }
  237. // IsAdminOfRepo returns true if user has admin or higher access of repository.
  238. func (u *User) IsAdminOfRepo(repo *Repository) bool {
  239. if err := repo.GetOwner(); err != nil {
  240. log.Error(3, "GetOwner: %v", err)
  241. return false
  242. }
  243. if repo.Owner.IsOrganization() {
  244. has, err := HasAccess(u, repo, ACCESS_MODE_ADMIN)
  245. if err != nil {
  246. log.Error(3, "HasAccess: %v", err)
  247. return false
  248. }
  249. return has
  250. }
  251. return repo.IsOwnedBy(u.Id)
  252. }
  253. // IsOrganization returns true if user is actually a organization.
  254. func (u *User) IsOrganization() bool {
  255. return u.Type == ORGANIZATION
  256. }
  257. // IsUserOrgOwner returns true if user is in the owner team of given organization.
  258. func (u *User) IsUserOrgOwner(orgId int64) bool {
  259. return IsOrganizationOwner(orgId, u.Id)
  260. }
  261. // IsPublicMember returns true if user public his/her membership in give organization.
  262. func (u *User) IsPublicMember(orgId int64) bool {
  263. return IsPublicMembership(orgId, u.Id)
  264. }
  265. func (u *User) getOrganizationCount(e Engine) (int64, error) {
  266. return e.Where("uid=?", u.Id).Count(new(OrgUser))
  267. }
  268. // GetOrganizationCount returns count of membership of organization of user.
  269. func (u *User) GetOrganizationCount() (int64, error) {
  270. return u.getOrganizationCount(x)
  271. }
  272. // GetRepositories returns all repositories that user owns, including private repositories.
  273. func (u *User) GetRepositories() (err error) {
  274. u.Repos, err = GetRepositories(u.Id, true)
  275. return err
  276. }
  277. // GetOwnedOrganizations returns all organizations that user owns.
  278. func (u *User) GetOwnedOrganizations() (err error) {
  279. u.OwnedOrgs, err = GetOwnedOrgsByUserID(u.Id)
  280. return err
  281. }
  282. // GetOrganizations returns all organizations that user belongs to.
  283. func (u *User) GetOrganizations() error {
  284. ous, err := GetOrgUsersByUserId(u.Id)
  285. if err != nil {
  286. return err
  287. }
  288. u.Orgs = make([]*User, len(ous))
  289. for i, ou := range ous {
  290. u.Orgs[i], err = GetUserByID(ou.OrgID)
  291. if err != nil {
  292. return err
  293. }
  294. }
  295. return nil
  296. }
  297. // DisplayName returns full name if it's not empty,
  298. // returns username otherwise.
  299. func (u *User) DisplayName() string {
  300. if len(u.FullName) > 0 {
  301. return u.FullName
  302. }
  303. return u.Name
  304. }
  305. // IsUserExist checks if given user name exist,
  306. // the user name should be noncased unique.
  307. // If uid is presented, then check will rule out that one,
  308. // it is used when update a user name in settings page.
  309. func IsUserExist(uid int64, name string) (bool, error) {
  310. if len(name) == 0 {
  311. return false, nil
  312. }
  313. return x.Where("id!=?", uid).Get(&User{LowerName: strings.ToLower(name)})
  314. }
  315. // IsEmailUsed returns true if the e-mail has been used.
  316. func IsEmailUsed(email string) (bool, error) {
  317. if len(email) == 0 {
  318. return false, nil
  319. }
  320. email = strings.ToLower(email)
  321. if has, err := x.Get(&EmailAddress{Email: email}); has || err != nil {
  322. return has, err
  323. }
  324. return x.Get(&User{Email: email})
  325. }
  326. // GetUserSalt returns a ramdom user salt token.
  327. func GetUserSalt() string {
  328. return base.GetRandomString(10)
  329. }
  330. // NewFakeUser creates and returns a fake user for someone has deleted his/her account.
  331. func NewFakeUser() *User {
  332. return &User{
  333. Id: -1,
  334. Name: "Someone",
  335. LowerName: "someone",
  336. }
  337. }
  338. // CreateUser creates record of a new user.
  339. func CreateUser(u *User) (err error) {
  340. if err = IsUsableName(u.Name); err != nil {
  341. return err
  342. }
  343. isExist, err := IsUserExist(0, u.Name)
  344. if err != nil {
  345. return err
  346. } else if isExist {
  347. return ErrUserAlreadyExist{u.Name}
  348. }
  349. isExist, err = IsEmailUsed(u.Email)
  350. if err != nil {
  351. return err
  352. } else if isExist {
  353. return ErrEmailAlreadyUsed{u.Email}
  354. }
  355. u.LowerName = strings.ToLower(u.Name)
  356. u.AvatarEmail = u.Email
  357. u.Avatar = avatar.HashEmail(u.AvatarEmail)
  358. u.Rands = GetUserSalt()
  359. u.Salt = GetUserSalt()
  360. u.EncodePasswd()
  361. sess := x.NewSession()
  362. defer sess.Close()
  363. if err = sess.Begin(); err != nil {
  364. return err
  365. }
  366. if _, err = sess.Insert(u); err != nil {
  367. sess.Rollback()
  368. return err
  369. } else if err = os.MkdirAll(UserPath(u.Name), os.ModePerm); err != nil {
  370. sess.Rollback()
  371. return err
  372. }
  373. return sess.Commit()
  374. }
  375. func countUsers(e Engine) int64 {
  376. count, _ := e.Where("type=0").Count(new(User))
  377. return count
  378. }
  379. // CountUsers returns number of users.
  380. func CountUsers() int64 {
  381. return countUsers(x)
  382. }
  383. // Users returns number of users in given page.
  384. func Users(page, pageSize int) ([]*User, error) {
  385. users := make([]*User, 0, pageSize)
  386. return users, x.Limit(pageSize, (page-1)*pageSize).Where("type=0").Asc("id").Find(&users)
  387. }
  388. // get user by erify code
  389. func getVerifyUser(code string) (user *User) {
  390. if len(code) <= base.TimeLimitCodeLength {
  391. return nil
  392. }
  393. // use tail hex username query user
  394. hexStr := code[base.TimeLimitCodeLength:]
  395. if b, err := hex.DecodeString(hexStr); err == nil {
  396. if user, err = GetUserByName(string(b)); user != nil {
  397. return user
  398. }
  399. log.Error(4, "user.getVerifyUser: %v", err)
  400. }
  401. return nil
  402. }
  403. // verify active code when active account
  404. func VerifyUserActiveCode(code string) (user *User) {
  405. minutes := setting.Service.ActiveCodeLives
  406. if user = getVerifyUser(code); user != nil {
  407. // time limit code
  408. prefix := code[:base.TimeLimitCodeLength]
  409. data := com.ToStr(user.Id) + user.Email + user.LowerName + user.Passwd + user.Rands
  410. if base.VerifyTimeLimitCode(data, minutes, prefix) {
  411. return user
  412. }
  413. }
  414. return nil
  415. }
  416. // verify active code when active account
  417. func VerifyActiveEmailCode(code, email string) *EmailAddress {
  418. minutes := setting.Service.ActiveCodeLives
  419. if user := getVerifyUser(code); user != nil {
  420. // time limit code
  421. prefix := code[:base.TimeLimitCodeLength]
  422. data := com.ToStr(user.Id) + email + user.LowerName + user.Passwd + user.Rands
  423. if base.VerifyTimeLimitCode(data, minutes, prefix) {
  424. emailAddress := &EmailAddress{Email: email}
  425. if has, _ := x.Get(emailAddress); has {
  426. return emailAddress
  427. }
  428. }
  429. }
  430. return nil
  431. }
  432. // ChangeUserName changes all corresponding setting from old user name to new one.
  433. func ChangeUserName(u *User, newUserName string) (err error) {
  434. if err = IsUsableName(newUserName); err != nil {
  435. return err
  436. }
  437. isExist, err := IsUserExist(0, newUserName)
  438. if err != nil {
  439. return err
  440. } else if isExist {
  441. return ErrUserAlreadyExist{newUserName}
  442. }
  443. return os.Rename(UserPath(u.LowerName), UserPath(newUserName))
  444. }
  445. func updateUser(e Engine, u *User) error {
  446. // Organization does not need e-mail.
  447. if !u.IsOrganization() {
  448. u.Email = strings.ToLower(u.Email)
  449. has, err := e.Where("id!=?", u.Id).And("type=?", u.Type).And("email=?", u.Email).Get(new(User))
  450. if err != nil {
  451. return err
  452. } else if has {
  453. return ErrEmailAlreadyUsed{u.Email}
  454. }
  455. if len(u.AvatarEmail) == 0 {
  456. u.AvatarEmail = u.Email
  457. }
  458. u.Avatar = avatar.HashEmail(u.AvatarEmail)
  459. }
  460. u.LowerName = strings.ToLower(u.Name)
  461. if len(u.Location) > 255 {
  462. u.Location = u.Location[:255]
  463. }
  464. if len(u.Website) > 255 {
  465. u.Website = u.Website[:255]
  466. }
  467. if len(u.Description) > 255 {
  468. u.Description = u.Description[:255]
  469. }
  470. u.FullName = base.Sanitizer.Sanitize(u.FullName)
  471. _, err := e.Id(u.Id).AllCols().Update(u)
  472. return err
  473. }
  474. // UpdateUser updates user's information.
  475. func UpdateUser(u *User) error {
  476. return updateUser(x, u)
  477. }
  478. // deleteBeans deletes all given beans, beans should contain delete conditions.
  479. func deleteBeans(e Engine, beans ...interface{}) (err error) {
  480. for i := range beans {
  481. if _, err = e.Delete(beans[i]); err != nil {
  482. return err
  483. }
  484. }
  485. return nil
  486. }
  487. // FIXME: need some kind of mechanism to record failure. HINT: system notice
  488. func deleteUser(e *xorm.Session, u *User) error {
  489. // Note: A user owns any repository or belongs to any organization
  490. // cannot perform delete operation.
  491. // Check ownership of repository.
  492. count, err := getRepositoryCount(e, u)
  493. if err != nil {
  494. return fmt.Errorf("GetRepositoryCount: %v", err)
  495. } else if count > 0 {
  496. return ErrUserOwnRepos{UID: u.Id}
  497. }
  498. // Check membership of organization.
  499. count, err = u.getOrganizationCount(e)
  500. if err != nil {
  501. return fmt.Errorf("GetOrganizationCount: %v", err)
  502. } else if count > 0 {
  503. return ErrUserHasOrgs{UID: u.Id}
  504. }
  505. // ***** START: Watch *****
  506. watches := make([]*Watch, 0, 10)
  507. if err = e.Find(&watches, &Watch{UserID: u.Id}); err != nil {
  508. return fmt.Errorf("get all watches: %v", err)
  509. }
  510. for i := range watches {
  511. if _, err = e.Exec("UPDATE `repository` SET num_watches=num_watches-1 WHERE id=?", watches[i].RepoID); err != nil {
  512. return fmt.Errorf("decrease repository watch number[%d]: %v", watches[i].RepoID, err)
  513. }
  514. }
  515. // ***** END: Watch *****
  516. // ***** START: Star *****
  517. stars := make([]*Star, 0, 10)
  518. if err = e.Find(&stars, &Star{UID: u.Id}); err != nil {
  519. return fmt.Errorf("get all stars: %v", err)
  520. }
  521. for i := range stars {
  522. if _, err = e.Exec("UPDATE `repository` SET num_stars=num_stars-1 WHERE id=?", stars[i].RepoID); err != nil {
  523. return fmt.Errorf("decrease repository star number[%d]: %v", stars[i].RepoID, err)
  524. }
  525. }
  526. // ***** END: Star *****
  527. // ***** START: Follow *****
  528. followers := make([]*Follow, 0, 10)
  529. if err = e.Find(&followers, &Follow{UserID: u.Id}); err != nil {
  530. return fmt.Errorf("get all followers: %v", err)
  531. }
  532. for i := range followers {
  533. if _, err = e.Exec("UPDATE `user` SET num_followers=num_followers-1 WHERE id=?", followers[i].UserID); err != nil {
  534. return fmt.Errorf("decrease user follower number[%d]: %v", followers[i].UserID, err)
  535. }
  536. }
  537. // ***** END: Follow *****
  538. if err = deleteBeans(e,
  539. &AccessToken{UID: u.Id},
  540. &Collaboration{UserID: u.Id},
  541. &Access{UserID: u.Id},
  542. &Watch{UserID: u.Id},
  543. &Star{UID: u.Id},
  544. &Follow{FollowID: u.Id},
  545. &Action{UserID: u.Id},
  546. &IssueUser{UID: u.Id},
  547. &EmailAddress{UID: u.Id},
  548. ); err != nil {
  549. return fmt.Errorf("deleteUser: %v", err)
  550. }
  551. // ***** START: PublicKey *****
  552. keys := make([]*PublicKey, 0, 10)
  553. if err = e.Find(&keys, &PublicKey{OwnerID: u.Id}); err != nil {
  554. return fmt.Errorf("get all public keys: %v", err)
  555. }
  556. for _, key := range keys {
  557. if err = deletePublicKey(e, key.ID); err != nil {
  558. return fmt.Errorf("deletePublicKey: %v", err)
  559. }
  560. }
  561. // ***** END: PublicKey *****
  562. // Clear assignee.
  563. if _, err = e.Exec("UPDATE `issue` SET assignee_id=0 WHERE assignee_id=?", u.Id); err != nil {
  564. return fmt.Errorf("clear assignee: %v", err)
  565. }
  566. if _, err = e.Id(u.Id).Delete(new(User)); err != nil {
  567. return fmt.Errorf("Delete: %v", err)
  568. }
  569. // FIXME: system notice
  570. // Note: There are something just cannot be roll back,
  571. // so just keep error logs of those operations.
  572. RewriteAllPublicKeys()
  573. os.RemoveAll(UserPath(u.Name))
  574. os.Remove(u.CustomAvatarPath())
  575. return nil
  576. }
  577. // DeleteUser completely and permanently deletes everything of a user,
  578. // but issues/comments/pulls will be kept and shown as someone has been deleted.
  579. func DeleteUser(u *User) (err error) {
  580. sess := x.NewSession()
  581. defer sessionRelease(sess)
  582. if err = sess.Begin(); err != nil {
  583. return err
  584. }
  585. if err = deleteUser(sess, u); err != nil {
  586. // Note: don't wrapper error here.
  587. return err
  588. }
  589. return sess.Commit()
  590. }
  591. // DeleteInactivateUsers deletes all inactivate users and email addresses.
  592. func DeleteInactivateUsers() (err error) {
  593. users := make([]*User, 0, 10)
  594. if err = x.Where("is_active=?", false).Find(&users); err != nil {
  595. return fmt.Errorf("get all inactive users: %v", err)
  596. }
  597. for _, u := range users {
  598. if err = DeleteUser(u); err != nil {
  599. // Ignore users that were set inactive by admin.
  600. if IsErrUserOwnRepos(err) || IsErrUserHasOrgs(err) {
  601. continue
  602. }
  603. return err
  604. }
  605. }
  606. _, err = x.Where("is_activated=?", false).Delete(new(EmailAddress))
  607. return err
  608. }
  609. // UserPath returns the path absolute path of user repositories.
  610. func UserPath(userName string) string {
  611. return filepath.Join(setting.RepoRootPath, strings.ToLower(userName))
  612. }
  613. func GetUserByKeyId(keyId int64) (*User, error) {
  614. user := new(User)
  615. 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)
  616. if err != nil {
  617. return nil, err
  618. } else if !has {
  619. return nil, ErrUserNotKeyOwner
  620. }
  621. return user, nil
  622. }
  623. func getUserByID(e Engine, id int64) (*User, error) {
  624. u := new(User)
  625. has, err := e.Id(id).Get(u)
  626. if err != nil {
  627. return nil, err
  628. } else if !has {
  629. return nil, ErrUserNotExist{id, ""}
  630. }
  631. return u, nil
  632. }
  633. // GetUserByID returns the user object by given ID if exists.
  634. func GetUserByID(id int64) (*User, error) {
  635. return getUserByID(x, id)
  636. }
  637. // GetAssigneeByID returns the user with write access of repository by given ID.
  638. func GetAssigneeByID(repo *Repository, userID int64) (*User, error) {
  639. has, err := HasAccess(&User{Id: userID}, repo, ACCESS_MODE_WRITE)
  640. if err != nil {
  641. return nil, err
  642. } else if !has {
  643. return nil, ErrUserNotExist{userID, ""}
  644. }
  645. return GetUserByID(userID)
  646. }
  647. // GetUserByName returns user by given name.
  648. func GetUserByName(name string) (*User, error) {
  649. if len(name) == 0 {
  650. return nil, ErrUserNotExist{0, name}
  651. }
  652. u := &User{LowerName: strings.ToLower(name)}
  653. has, err := x.Get(u)
  654. if err != nil {
  655. return nil, err
  656. } else if !has {
  657. return nil, ErrUserNotExist{0, name}
  658. }
  659. return u, nil
  660. }
  661. // GetUserEmailsByNames returns a list of e-mails corresponds to names.
  662. func GetUserEmailsByNames(names []string) []string {
  663. mails := make([]string, 0, len(names))
  664. for _, name := range names {
  665. u, err := GetUserByName(name)
  666. if err != nil {
  667. continue
  668. }
  669. mails = append(mails, u.Email)
  670. }
  671. return mails
  672. }
  673. // GetUserIdsByNames returns a slice of ids corresponds to names.
  674. func GetUserIdsByNames(names []string) []int64 {
  675. ids := make([]int64, 0, len(names))
  676. for _, name := range names {
  677. u, err := GetUserByName(name)
  678. if err != nil {
  679. continue
  680. }
  681. ids = append(ids, u.Id)
  682. }
  683. return ids
  684. }
  685. // GetEmailAddresses returns all e-mail addresses belongs to given user.
  686. func GetEmailAddresses(uid int64) ([]*EmailAddress, error) {
  687. emails := make([]*EmailAddress, 0, 5)
  688. err := x.Where("uid=?", uid).Find(&emails)
  689. if err != nil {
  690. return nil, err
  691. }
  692. u, err := GetUserByID(uid)
  693. if err != nil {
  694. return nil, err
  695. }
  696. isPrimaryFound := false
  697. for _, email := range emails {
  698. if email.Email == u.Email {
  699. isPrimaryFound = true
  700. email.IsPrimary = true
  701. } else {
  702. email.IsPrimary = false
  703. }
  704. }
  705. // We alway want the primary email address displayed, even if it's not in
  706. // the emailaddress table (yet)
  707. if !isPrimaryFound {
  708. emails = append(emails, &EmailAddress{
  709. Email: u.Email,
  710. IsActivated: true,
  711. IsPrimary: true,
  712. })
  713. }
  714. return emails, nil
  715. }
  716. func AddEmailAddress(email *EmailAddress) error {
  717. email.Email = strings.ToLower(email.Email)
  718. used, err := IsEmailUsed(email.Email)
  719. if err != nil {
  720. return err
  721. } else if used {
  722. return ErrEmailAlreadyUsed{email.Email}
  723. }
  724. _, err = x.Insert(email)
  725. return err
  726. }
  727. func (email *EmailAddress) Activate() error {
  728. email.IsActivated = true
  729. if _, err := x.Id(email.ID).AllCols().Update(email); err != nil {
  730. return err
  731. }
  732. if user, err := GetUserByID(email.UID); err != nil {
  733. return err
  734. } else {
  735. user.Rands = GetUserSalt()
  736. return UpdateUser(user)
  737. }
  738. }
  739. func DeleteEmailAddress(email *EmailAddress) error {
  740. has, err := x.Get(email)
  741. if err != nil {
  742. return err
  743. } else if !has {
  744. return ErrEmailNotExist
  745. }
  746. if _, err = x.Id(email.ID).Delete(email); err != nil {
  747. return err
  748. }
  749. return nil
  750. }
  751. func MakeEmailPrimary(email *EmailAddress) error {
  752. has, err := x.Get(email)
  753. if err != nil {
  754. return err
  755. } else if !has {
  756. return ErrEmailNotExist
  757. }
  758. if !email.IsActivated {
  759. return ErrEmailNotActivated
  760. }
  761. user := &User{Id: email.UID}
  762. has, err = x.Get(user)
  763. if err != nil {
  764. return err
  765. } else if !has {
  766. return ErrUserNotExist{email.UID, ""}
  767. }
  768. // Make sure the former primary email doesn't disappear
  769. former_primary_email := &EmailAddress{Email: user.Email}
  770. has, err = x.Get(former_primary_email)
  771. if err != nil {
  772. return err
  773. } else if !has {
  774. former_primary_email.UID = user.Id
  775. former_primary_email.IsActivated = user.IsActive
  776. x.Insert(former_primary_email)
  777. }
  778. user.Email = email.Email
  779. _, err = x.Id(user.Id).AllCols().Update(user)
  780. return err
  781. }
  782. // UserCommit represents a commit with validation of user.
  783. type UserCommit struct {
  784. User *User
  785. *git.Commit
  786. }
  787. // ValidateCommitWithEmail chceck if author's e-mail of commit is corresponsind to a user.
  788. func ValidateCommitWithEmail(c *git.Commit) *User {
  789. u, err := GetUserByEmail(c.Author.Email)
  790. if err != nil {
  791. return nil
  792. }
  793. return u
  794. }
  795. // ValidateCommitsWithEmails checks if authors' e-mails of commits are corresponding to users.
  796. func ValidateCommitsWithEmails(oldCommits *list.List) *list.List {
  797. var (
  798. u *User
  799. emails = map[string]*User{}
  800. newCommits = list.New()
  801. e = oldCommits.Front()
  802. )
  803. for e != nil {
  804. c := e.Value.(*git.Commit)
  805. if v, ok := emails[c.Author.Email]; !ok {
  806. u, _ = GetUserByEmail(c.Author.Email)
  807. emails[c.Author.Email] = u
  808. } else {
  809. u = v
  810. }
  811. newCommits.PushBack(UserCommit{
  812. User: u,
  813. Commit: c,
  814. })
  815. e = e.Next()
  816. }
  817. return newCommits
  818. }
  819. // GetUserByEmail returns the user object by given e-mail if exists.
  820. func GetUserByEmail(email string) (*User, error) {
  821. if len(email) == 0 {
  822. return nil, ErrUserNotExist{0, "email"}
  823. }
  824. email = strings.ToLower(email)
  825. // First try to find the user by primary email
  826. user := &User{Email: email}
  827. has, err := x.Get(user)
  828. if err != nil {
  829. return nil, err
  830. }
  831. if has {
  832. return user, nil
  833. }
  834. // Otherwise, check in alternative list for activated email addresses
  835. emailAddress := &EmailAddress{Email: email, IsActivated: true}
  836. has, err = x.Get(emailAddress)
  837. if err != nil {
  838. return nil, err
  839. }
  840. if has {
  841. return GetUserByID(emailAddress.UID)
  842. }
  843. return nil, ErrUserNotExist{0, "email"}
  844. }
  845. // SearchUserByName returns given number of users whose name contains keyword.
  846. func SearchUserByName(opt SearchOption) (us []*User, err error) {
  847. if len(opt.Keyword) == 0 {
  848. return us, nil
  849. }
  850. opt.Keyword = strings.ToLower(opt.Keyword)
  851. us = make([]*User, 0, opt.Limit)
  852. err = x.Limit(opt.Limit).Where("type=0").And("lower_name like ?", "%"+opt.Keyword+"%").Find(&us)
  853. return us, err
  854. }
  855. // Follow is connection request for receiving user notification.
  856. type Follow struct {
  857. ID int64 `xorm:"pk autoincr"`
  858. UserID int64 `xorm:"UNIQUE(follow)"`
  859. FollowID int64 `xorm:"UNIQUE(follow)"`
  860. }
  861. // FollowUser marks someone be another's follower.
  862. func FollowUser(userId int64, followId int64) (err error) {
  863. sess := x.NewSession()
  864. defer sess.Close()
  865. sess.Begin()
  866. if _, err = sess.Insert(&Follow{UserID: userId, FollowID: followId}); err != nil {
  867. sess.Rollback()
  868. return err
  869. }
  870. rawSql := "UPDATE `user` SET num_followers = num_followers + 1 WHERE id = ?"
  871. if _, err = sess.Exec(rawSql, followId); err != nil {
  872. sess.Rollback()
  873. return err
  874. }
  875. rawSql = "UPDATE `user` SET num_followings = num_followings + 1 WHERE id = ?"
  876. if _, err = sess.Exec(rawSql, userId); err != nil {
  877. sess.Rollback()
  878. return err
  879. }
  880. return sess.Commit()
  881. }
  882. // UnFollowUser unmarks someone be another's follower.
  883. func UnFollowUser(userId int64, unFollowId int64) (err error) {
  884. session := x.NewSession()
  885. defer session.Close()
  886. session.Begin()
  887. if _, err = session.Delete(&Follow{UserID: userId, FollowID: unFollowId}); err != nil {
  888. session.Rollback()
  889. return err
  890. }
  891. rawSql := "UPDATE `user` SET num_followers = num_followers - 1 WHERE id = ?"
  892. if _, err = session.Exec(rawSql, unFollowId); err != nil {
  893. session.Rollback()
  894. return err
  895. }
  896. rawSql = "UPDATE `user` SET num_followings = num_followings - 1 WHERE id = ?"
  897. if _, err = session.Exec(rawSql, userId); err != nil {
  898. session.Rollback()
  899. return err
  900. }
  901. return session.Commit()
  902. }
  903. func UpdateMentions(userNames []string, issueId int64) error {
  904. for i := range userNames {
  905. userNames[i] = strings.ToLower(userNames[i])
  906. }
  907. users := make([]*User, 0, len(userNames))
  908. if err := x.Where("lower_name IN (?)", strings.Join(userNames, "\",\"")).OrderBy("lower_name ASC").Find(&users); err != nil {
  909. return err
  910. }
  911. ids := make([]int64, 0, len(userNames))
  912. for _, user := range users {
  913. ids = append(ids, user.Id)
  914. if !user.IsOrganization() {
  915. continue
  916. }
  917. if user.NumMembers == 0 {
  918. continue
  919. }
  920. tempIds := make([]int64, 0, user.NumMembers)
  921. orgUsers, err := GetOrgUsersByOrgId(user.Id)
  922. if err != nil {
  923. return err
  924. }
  925. for _, orgUser := range orgUsers {
  926. tempIds = append(tempIds, orgUser.ID)
  927. }
  928. ids = append(ids, tempIds...)
  929. }
  930. if err := UpdateIssueUsersByMentions(ids, issueId); err != nil {
  931. return err
  932. }
  933. return nil
  934. }