repo.go 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798
  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. "errors"
  7. "fmt"
  8. "io/ioutil"
  9. "os"
  10. "os/exec"
  11. "path"
  12. "path/filepath"
  13. "strings"
  14. "time"
  15. "unicode/utf8"
  16. "github.com/Unknwon/cae/zip"
  17. "github.com/Unknwon/com"
  18. "github.com/gogits/git"
  19. "github.com/gogits/gogs/modules/base"
  20. "github.com/gogits/gogs/modules/log"
  21. )
  22. var (
  23. ErrRepoAlreadyExist = errors.New("Repository already exist")
  24. ErrRepoNotExist = errors.New("Repository does not exist")
  25. ErrRepoFileNotExist = errors.New("Target Repo file does not exist")
  26. ErrRepoNameIllegal = errors.New("Repository name contains illegal characters")
  27. ErrRepoFileNotLoaded = errors.New("repo file not loaded")
  28. ErrMirrorNotExist = errors.New("Mirror does not exist")
  29. )
  30. var (
  31. LanguageIgns, Licenses []string
  32. )
  33. func LoadRepoConfig() {
  34. LanguageIgns = strings.Split(base.Cfg.MustValue("repository", "LANG_IGNS"), "|")
  35. Licenses = strings.Split(base.Cfg.MustValue("repository", "LICENSES"), "|")
  36. }
  37. func NewRepoContext() {
  38. zip.Verbose = false
  39. // Check if server has basic git setting.
  40. stdout, stderr, err := com.ExecCmd("git", "config", "--get", "user.name")
  41. if strings.Contains(stderr, "fatal:") {
  42. fmt.Printf("repo.NewRepoContext(fail to get git user.name): %s", stderr)
  43. os.Exit(2)
  44. } else if err != nil || len(strings.TrimSpace(stdout)) == 0 {
  45. if _, stderr, err = com.ExecCmd("git", "config", "--global", "user.email", "gogitservice@gmail.com"); err != nil {
  46. fmt.Printf("repo.NewRepoContext(fail to set git user.email): %s", stderr)
  47. os.Exit(2)
  48. } else if _, stderr, err = com.ExecCmd("git", "config", "--global", "user.name", "Gogs"); err != nil {
  49. fmt.Printf("repo.NewRepoContext(fail to set git user.name): %s", stderr)
  50. os.Exit(2)
  51. }
  52. }
  53. }
  54. // Repository represents a git repository.
  55. type Repository struct {
  56. Id int64
  57. OwnerId int64 `xorm:"unique(s)"`
  58. Owner *User `xorm:"-"`
  59. ForkId int64
  60. LowerName string `xorm:"unique(s) index not null"`
  61. Name string `xorm:"index not null"`
  62. Description string
  63. Website string
  64. NumWatches int
  65. NumStars int
  66. NumForks int
  67. NumIssues int
  68. NumClosedIssues int
  69. NumOpenIssues int `xorm:"-"`
  70. NumTags int `xorm:"-"`
  71. IsPrivate bool
  72. IsMirror bool
  73. IsBare bool
  74. IsGoget bool
  75. DefaultBranch string
  76. Created time.Time `xorm:"created"`
  77. Updated time.Time `xorm:"updated"`
  78. }
  79. // IsRepositoryExist returns true if the repository with given name under user has already existed.
  80. func IsRepositoryExist(user *User, repoName string) (bool, error) {
  81. repo := Repository{OwnerId: user.Id}
  82. has, err := orm.Where("lower_name = ?", strings.ToLower(repoName)).Get(&repo)
  83. if err != nil {
  84. return has, err
  85. } else if !has {
  86. return false, nil
  87. }
  88. return com.IsDir(RepoPath(user.Name, repoName)), nil
  89. }
  90. var (
  91. illegalEquals = []string{"raw", "install", "api", "avatar", "user", "help", "stars", "issues", "pulls", "commits", "repo", "template", "admin"}
  92. illegalSuffixs = []string{".git"}
  93. )
  94. // IsLegalName returns false if name contains illegal characters.
  95. func IsLegalName(repoName string) bool {
  96. repoName = strings.ToLower(repoName)
  97. for _, char := range illegalEquals {
  98. if repoName == char {
  99. return false
  100. }
  101. }
  102. for _, char := range illegalSuffixs {
  103. if strings.HasSuffix(repoName, char) {
  104. return false
  105. }
  106. }
  107. return true
  108. }
  109. // Mirror represents a mirror information of repository.
  110. type Mirror struct {
  111. Id int64
  112. RepoId int64
  113. RepoName string // <user name>/<repo name>
  114. Interval int // Hour.
  115. Updated time.Time `xorm:"UPDATED"`
  116. NextUpdate time.Time
  117. }
  118. func GetMirror(repoId int64) (*Mirror, error) {
  119. m := &Mirror{RepoId: repoId}
  120. has, err := orm.Get(m)
  121. if err != nil {
  122. return nil, err
  123. } else if !has {
  124. return nil, ErrMirrorNotExist
  125. }
  126. return m, nil
  127. }
  128. func UpdateMirror(m *Mirror) error {
  129. _, err := orm.Id(m.Id).Update(m)
  130. return err
  131. }
  132. // MirrorUpdate checks and updates mirror repositories.
  133. func MirrorUpdate() {
  134. if err := orm.Iterate(new(Mirror), func(idx int, bean interface{}) error {
  135. m := bean.(*Mirror)
  136. if m.NextUpdate.After(time.Now()) {
  137. return nil
  138. }
  139. repoPath := filepath.Join(base.RepoRootPath, m.RepoName+".git")
  140. _, stderr, err := com.ExecCmdDir(repoPath, "git", "remote", "update")
  141. if err != nil {
  142. return err
  143. } else if strings.Contains(stderr, "fatal:") {
  144. return errors.New(stderr)
  145. } else if err = git.UnpackRefs(repoPath); err != nil {
  146. return err
  147. }
  148. m.NextUpdate = time.Now().Add(time.Duration(m.Interval) * time.Hour)
  149. return UpdateMirror(m)
  150. }); err != nil {
  151. log.Error("repo.MirrorUpdate: %v", err)
  152. }
  153. }
  154. // MirrorRepository creates a mirror repository from source.
  155. func MirrorRepository(repoId int64, userName, repoName, repoPath, url string) error {
  156. _, stderr, err := com.ExecCmd("git", "clone", "--mirror", url, repoPath)
  157. if err != nil {
  158. return err
  159. } else if strings.Contains(stderr, "fatal:") {
  160. return errors.New(stderr)
  161. }
  162. if _, err = orm.InsertOne(&Mirror{
  163. RepoId: repoId,
  164. RepoName: strings.ToLower(userName + "/" + repoName),
  165. Interval: 24,
  166. NextUpdate: time.Now().Add(24 * time.Hour),
  167. }); err != nil {
  168. return err
  169. }
  170. return git.UnpackRefs(repoPath)
  171. }
  172. // MigrateRepository migrates a existing repository from other project hosting.
  173. func MigrateRepository(user *User, name, desc string, private, mirror bool, url string) (*Repository, error) {
  174. repo, err := CreateRepository(user, name, desc, "", "", private, mirror, false)
  175. if err != nil {
  176. return nil, err
  177. }
  178. // Clone to temprory path and do the init commit.
  179. tmpDir := filepath.Join(os.TempDir(), fmt.Sprintf("%d", time.Now().Nanosecond()))
  180. os.MkdirAll(tmpDir, os.ModePerm)
  181. repoPath := RepoPath(user.Name, name)
  182. repo.IsBare = false
  183. if mirror {
  184. if err = MirrorRepository(repo.Id, user.Name, repo.Name, repoPath, url); err != nil {
  185. return repo, err
  186. }
  187. repo.IsMirror = true
  188. return repo, UpdateRepository(repo)
  189. }
  190. // Clone from local repository.
  191. _, stderr, err := com.ExecCmd("git", "clone", repoPath, tmpDir)
  192. if err != nil {
  193. return repo, err
  194. } else if strings.Contains(stderr, "fatal:") {
  195. return repo, errors.New("git clone: " + stderr)
  196. }
  197. // Pull data from source.
  198. _, stderr, err = com.ExecCmdDir(tmpDir, "git", "pull", url)
  199. if err != nil {
  200. return repo, err
  201. } else if strings.Contains(stderr, "fatal:") {
  202. return repo, errors.New("git pull: " + stderr)
  203. }
  204. // Push data to local repository.
  205. if _, stderr, err = com.ExecCmdDir(tmpDir, "git", "push", "origin", "master"); err != nil {
  206. return repo, err
  207. } else if strings.Contains(stderr, "fatal:") {
  208. return repo, errors.New("git push: " + stderr)
  209. }
  210. return repo, UpdateRepository(repo)
  211. }
  212. // CreateRepository creates a repository for given user or orgnaziation.
  213. func CreateRepository(user *User, name, desc, lang, license string, private, mirror, initReadme bool) (*Repository, error) {
  214. if !IsLegalName(name) {
  215. return nil, ErrRepoNameIllegal
  216. }
  217. isExist, err := IsRepositoryExist(user, name)
  218. if err != nil {
  219. return nil, err
  220. } else if isExist {
  221. return nil, ErrRepoAlreadyExist
  222. }
  223. repo := &Repository{
  224. OwnerId: user.Id,
  225. Name: name,
  226. LowerName: strings.ToLower(name),
  227. Description: desc,
  228. IsPrivate: private,
  229. IsBare: lang == "" && license == "" && !initReadme,
  230. DefaultBranch: "master",
  231. }
  232. repoPath := RepoPath(user.Name, repo.Name)
  233. sess := orm.NewSession()
  234. defer sess.Close()
  235. sess.Begin()
  236. if _, err = sess.Insert(repo); err != nil {
  237. if err2 := os.RemoveAll(repoPath); err2 != nil {
  238. log.Error("repo.CreateRepository(repo): %v", err)
  239. return nil, errors.New(fmt.Sprintf(
  240. "delete repo directory %s/%s failed(1): %v", user.Name, repo.Name, err2))
  241. }
  242. sess.Rollback()
  243. return nil, err
  244. }
  245. mode := AU_WRITABLE
  246. if mirror {
  247. mode = AU_READABLE
  248. }
  249. access := Access{
  250. UserName: user.LowerName,
  251. RepoName: strings.ToLower(path.Join(user.Name, repo.Name)),
  252. Mode: mode,
  253. }
  254. if _, err = sess.Insert(&access); err != nil {
  255. sess.Rollback()
  256. if err2 := os.RemoveAll(repoPath); err2 != nil {
  257. log.Error("repo.CreateRepository(access): %v", err)
  258. return nil, errors.New(fmt.Sprintf(
  259. "delete repo directory %s/%s failed(2): %v", user.Name, repo.Name, err2))
  260. }
  261. return nil, err
  262. }
  263. rawSql := "UPDATE `user` SET num_repos = num_repos + 1 WHERE id = ?"
  264. if _, err = sess.Exec(rawSql, user.Id); err != nil {
  265. sess.Rollback()
  266. if err2 := os.RemoveAll(repoPath); err2 != nil {
  267. log.Error("repo.CreateRepository(repo count): %v", err)
  268. return nil, errors.New(fmt.Sprintf(
  269. "delete repo directory %s/%s failed(3): %v", user.Name, repo.Name, err2))
  270. }
  271. return nil, err
  272. }
  273. if err = sess.Commit(); err != nil {
  274. sess.Rollback()
  275. if err2 := os.RemoveAll(repoPath); err2 != nil {
  276. log.Error("repo.CreateRepository(commit): %v", err)
  277. return nil, errors.New(fmt.Sprintf(
  278. "delete repo directory %s/%s failed(3): %v", user.Name, repo.Name, err2))
  279. }
  280. return nil, err
  281. }
  282. if !repo.IsPrivate {
  283. if err = NewRepoAction(user, repo); err != nil {
  284. log.Error("repo.CreateRepository(NewRepoAction): %v", err)
  285. }
  286. }
  287. if err = WatchRepo(user.Id, repo.Id, true); err != nil {
  288. log.Error("repo.CreateRepository(WatchRepo): %v", err)
  289. }
  290. // No need for init for mirror.
  291. if mirror {
  292. return repo, nil
  293. }
  294. if err = initRepository(repoPath, user, repo, initReadme, lang, license); err != nil {
  295. return nil, err
  296. }
  297. c := exec.Command("git", "update-server-info")
  298. c.Dir = repoPath
  299. if err = c.Run(); err != nil {
  300. log.Error("repo.CreateRepository(exec update-server-info): %v", err)
  301. }
  302. return repo, nil
  303. }
  304. // extractGitBareZip extracts git-bare.zip to repository path.
  305. func extractGitBareZip(repoPath string) error {
  306. z, err := zip.Open("conf/content/git-bare.zip")
  307. if err != nil {
  308. return err
  309. }
  310. defer z.Close()
  311. return z.ExtractTo(repoPath)
  312. }
  313. // initRepoCommit temporarily changes with work directory.
  314. func initRepoCommit(tmpPath string, sig *git.Signature) (err error) {
  315. var stderr string
  316. if _, stderr, err = com.ExecCmdDir(tmpPath, "git", "add", "--all"); err != nil {
  317. return errors.New("git add: " + stderr)
  318. }
  319. if _, stderr, err = com.ExecCmdDir(tmpPath, "git", "commit", fmt.Sprintf("--author='%s <%s>'", sig.Name, sig.Email),
  320. "-m", "Init commit"); err != nil {
  321. return errors.New("git commit: " + stderr)
  322. }
  323. if _, stderr, err = com.ExecCmdDir(tmpPath, "git", "push", "origin", "master"); err != nil {
  324. return errors.New("git push: " + stderr)
  325. }
  326. return nil
  327. }
  328. func createHookUpdate(hookPath, content string) error {
  329. pu, err := os.OpenFile(hookPath, os.O_CREATE|os.O_WRONLY, 0777)
  330. if err != nil {
  331. return err
  332. }
  333. defer pu.Close()
  334. _, err = pu.WriteString(content)
  335. return err
  336. }
  337. // SetRepoEnvs sets environment variables for command update.
  338. func SetRepoEnvs(userId int64, userName, repoName string) {
  339. os.Setenv("userId", base.ToStr(userId))
  340. os.Setenv("userName", userName)
  341. os.Setenv("repoName", repoName)
  342. }
  343. // InitRepository initializes README and .gitignore if needed.
  344. func initRepository(f string, user *User, repo *Repository, initReadme bool, repoLang, license string) error {
  345. repoPath := RepoPath(user.Name, repo.Name)
  346. // Create bare new repository.
  347. if err := extractGitBareZip(repoPath); err != nil {
  348. return err
  349. }
  350. rp := strings.NewReplacer("\\", "/", " ", "\\ ")
  351. // hook/post-update
  352. if err := createHookUpdate(filepath.Join(repoPath, "hooks", "update"),
  353. fmt.Sprintf("#!/usr/bin/env %s\n%s update $1 $2 $3\n", base.ScriptType,
  354. rp.Replace(appPath))); err != nil {
  355. return err
  356. }
  357. // Initialize repository according to user's choice.
  358. fileName := map[string]string{}
  359. if initReadme {
  360. fileName["readme"] = "README.md"
  361. }
  362. if repoLang != "" {
  363. fileName["gitign"] = ".gitignore"
  364. }
  365. if license != "" {
  366. fileName["license"] = "LICENSE"
  367. }
  368. // Clone to temprory path and do the init commit.
  369. tmpDir := filepath.Join(os.TempDir(), fmt.Sprintf("%d", time.Now().Nanosecond()))
  370. os.MkdirAll(tmpDir, os.ModePerm)
  371. _, stderr, err := com.ExecCmd("git", "clone", repoPath, tmpDir)
  372. if err != nil {
  373. return err
  374. } else if strings.Contains(stderr, "fatal:") {
  375. return errors.New("git clone: " + stderr)
  376. }
  377. // README
  378. if initReadme {
  379. defaultReadme := repo.Name + "\n" + strings.Repeat("=",
  380. utf8.RuneCountInString(repo.Name)) + "\n\n" + repo.Description
  381. if err := ioutil.WriteFile(filepath.Join(tmpDir, fileName["readme"]),
  382. []byte(defaultReadme), 0644); err != nil {
  383. return err
  384. }
  385. }
  386. // .gitignore
  387. if repoLang != "" {
  388. filePath := "conf/gitignore/" + repoLang
  389. if com.IsFile(filePath) {
  390. if err := com.Copy(filePath,
  391. filepath.Join(tmpDir, fileName["gitign"])); err != nil {
  392. return err
  393. }
  394. }
  395. }
  396. // LICENSE
  397. if license != "" {
  398. filePath := "conf/license/" + license
  399. if com.IsFile(filePath) {
  400. if err := com.Copy(filePath,
  401. filepath.Join(tmpDir, fileName["license"])); err != nil {
  402. return err
  403. }
  404. }
  405. }
  406. if len(fileName) == 0 {
  407. return nil
  408. }
  409. SetRepoEnvs(user.Id, user.Name, repo.Name)
  410. // Apply changes and commit.
  411. return initRepoCommit(tmpDir, user.NewGitSig())
  412. }
  413. // UserRepo reporesents a repository with user name.
  414. type UserRepo struct {
  415. *Repository
  416. UserName string
  417. }
  418. // GetRepos returns given number of repository objects with offset.
  419. func GetRepos(num, offset int) ([]UserRepo, error) {
  420. repos := make([]Repository, 0, num)
  421. if err := orm.Limit(num, offset).Asc("id").Find(&repos); err != nil {
  422. return nil, err
  423. }
  424. urepos := make([]UserRepo, len(repos))
  425. for i := range repos {
  426. urepos[i].Repository = &repos[i]
  427. u := new(User)
  428. has, err := orm.Id(urepos[i].Repository.OwnerId).Get(u)
  429. if err != nil {
  430. return nil, err
  431. } else if !has {
  432. return nil, ErrUserNotExist
  433. }
  434. urepos[i].UserName = u.Name
  435. }
  436. return urepos, nil
  437. }
  438. // RepoPath returns repository path by given user and repository name.
  439. func RepoPath(userName, repoName string) string {
  440. return filepath.Join(UserPath(userName), strings.ToLower(repoName)+".git")
  441. }
  442. // TransferOwnership transfers all corresponding setting from old user to new one.
  443. func TransferOwnership(user *User, newOwner string, repo *Repository) (err error) {
  444. newUser, err := GetUserByName(newOwner)
  445. if err != nil {
  446. return err
  447. }
  448. // Update accesses.
  449. accesses := make([]Access, 0, 10)
  450. if err = orm.Find(&accesses, &Access{RepoName: user.LowerName + "/" + repo.LowerName}); err != nil {
  451. return err
  452. }
  453. sess := orm.NewSession()
  454. defer sess.Close()
  455. if err = sess.Begin(); err != nil {
  456. return err
  457. }
  458. for i := range accesses {
  459. accesses[i].RepoName = newUser.LowerName + "/" + repo.LowerName
  460. if accesses[i].UserName == user.LowerName {
  461. accesses[i].UserName = newUser.LowerName
  462. }
  463. if err = UpdateAccessWithSession(sess, &accesses[i]); err != nil {
  464. return err
  465. }
  466. }
  467. // Update repository.
  468. repo.OwnerId = newUser.Id
  469. if _, err := sess.Id(repo.Id).Update(repo); err != nil {
  470. sess.Rollback()
  471. return err
  472. }
  473. // Update user repository number.
  474. rawSql := "UPDATE `user` SET num_repos = num_repos + 1 WHERE id = ?"
  475. if _, err = sess.Exec(rawSql, newUser.Id); err != nil {
  476. sess.Rollback()
  477. return err
  478. }
  479. rawSql = "UPDATE `user` SET num_repos = num_repos - 1 WHERE id = ?"
  480. if _, err = sess.Exec(rawSql, user.Id); err != nil {
  481. sess.Rollback()
  482. return err
  483. }
  484. // Add watch of new owner to repository.
  485. if !IsWatching(newUser.Id, repo.Id) {
  486. if err = WatchRepo(newUser.Id, repo.Id, true); err != nil {
  487. sess.Rollback()
  488. return err
  489. }
  490. }
  491. if err = TransferRepoAction(user, newUser, repo); err != nil {
  492. sess.Rollback()
  493. return err
  494. }
  495. // Change repository directory name.
  496. if err = os.Rename(RepoPath(user.Name, repo.Name), RepoPath(newUser.Name, repo.Name)); err != nil {
  497. sess.Rollback()
  498. return err
  499. }
  500. return sess.Commit()
  501. }
  502. // ChangeRepositoryName changes all corresponding setting from old repository name to new one.
  503. func ChangeRepositoryName(userName, oldRepoName, newRepoName string) (err error) {
  504. // Update accesses.
  505. accesses := make([]Access, 0, 10)
  506. if err = orm.Find(&accesses, &Access{RepoName: strings.ToLower(userName + "/" + oldRepoName)}); err != nil {
  507. return err
  508. }
  509. sess := orm.NewSession()
  510. defer sess.Close()
  511. if err = sess.Begin(); err != nil {
  512. return err
  513. }
  514. for i := range accesses {
  515. accesses[i].RepoName = userName + "/" + newRepoName
  516. if err = UpdateAccessWithSession(sess, &accesses[i]); err != nil {
  517. return err
  518. }
  519. }
  520. // Change repository directory name.
  521. if err = os.Rename(RepoPath(userName, oldRepoName), RepoPath(userName, newRepoName)); err != nil {
  522. sess.Rollback()
  523. return err
  524. }
  525. return sess.Commit()
  526. }
  527. func UpdateRepository(repo *Repository) error {
  528. repo.LowerName = strings.ToLower(repo.Name)
  529. if len(repo.Description) > 255 {
  530. repo.Description = repo.Description[:255]
  531. }
  532. if len(repo.Website) > 255 {
  533. repo.Website = repo.Website[:255]
  534. }
  535. _, err := orm.Id(repo.Id).AllCols().Update(repo)
  536. return err
  537. }
  538. // DeleteRepository deletes a repository for a user or orgnaztion.
  539. func DeleteRepository(userId, repoId int64, userName string) (err error) {
  540. repo := &Repository{Id: repoId, OwnerId: userId}
  541. has, err := orm.Get(repo)
  542. if err != nil {
  543. return err
  544. } else if !has {
  545. return ErrRepoNotExist
  546. }
  547. sess := orm.NewSession()
  548. defer sess.Close()
  549. if err = sess.Begin(); err != nil {
  550. return err
  551. }
  552. if _, err = sess.Delete(&Repository{Id: repoId}); err != nil {
  553. sess.Rollback()
  554. return err
  555. }
  556. if _, err := sess.Delete(&Access{RepoName: strings.ToLower(path.Join(userName, repo.Name))}); err != nil {
  557. sess.Rollback()
  558. return err
  559. }
  560. if _, err := sess.Delete(&Action{RepoId: repo.Id}); err != nil {
  561. sess.Rollback()
  562. return err
  563. }
  564. if _, err = sess.Delete(&Watch{RepoId: repoId}); err != nil {
  565. sess.Rollback()
  566. return err
  567. }
  568. if _, err = sess.Delete(&Mirror{RepoId: repoId}); err != nil {
  569. sess.Rollback()
  570. return err
  571. }
  572. rawSql := "UPDATE `user` SET num_repos = num_repos - 1 WHERE id = ?"
  573. if _, err = sess.Exec(rawSql, userId); err != nil {
  574. sess.Rollback()
  575. return err
  576. }
  577. if err = sess.Commit(); err != nil {
  578. sess.Rollback()
  579. return err
  580. }
  581. if err = os.RemoveAll(RepoPath(userName, repo.Name)); err != nil {
  582. // TODO: log and delete manully
  583. log.Error("delete repo %s/%s failed: %v", userName, repo.Name, err)
  584. return err
  585. }
  586. return nil
  587. }
  588. // GetRepositoryByName returns the repository by given name under user if exists.
  589. func GetRepositoryByName(userId int64, repoName string) (*Repository, error) {
  590. repo := &Repository{
  591. OwnerId: userId,
  592. LowerName: strings.ToLower(repoName),
  593. }
  594. has, err := orm.Get(repo)
  595. if err != nil {
  596. return nil, err
  597. } else if !has {
  598. return nil, ErrRepoNotExist
  599. }
  600. return repo, err
  601. }
  602. // GetRepositoryById returns the repository by given id if exists.
  603. func GetRepositoryById(id int64) (*Repository, error) {
  604. repo := &Repository{}
  605. has, err := orm.Id(id).Get(repo)
  606. if err != nil {
  607. return nil, err
  608. } else if !has {
  609. return nil, ErrRepoNotExist
  610. }
  611. return repo, err
  612. }
  613. // GetRepositories returns the list of repositories of given user.
  614. func GetRepositories(user *User, private bool) ([]Repository, error) {
  615. repos := make([]Repository, 0, 10)
  616. sess := orm.Desc("updated")
  617. if !private {
  618. sess.Where("is_private=?", false)
  619. }
  620. err := sess.Find(&repos, &Repository{OwnerId: user.Id})
  621. return repos, err
  622. }
  623. // GetRecentUpdatedRepositories returns the list of repositories that are recently updated.
  624. func GetRecentUpdatedRepositories() (repos []*Repository, err error) {
  625. err = orm.Where("is_private=?", false).Limit(5).Desc("updated").Find(&repos)
  626. return repos, err
  627. }
  628. // GetRepositoryCount returns the total number of repositories of user.
  629. func GetRepositoryCount(user *User) (int64, error) {
  630. return orm.Count(&Repository{OwnerId: user.Id})
  631. }
  632. // Watch is connection request for receiving repository notifycation.
  633. type Watch struct {
  634. Id int64
  635. RepoId int64 `xorm:"UNIQUE(watch)"`
  636. UserId int64 `xorm:"UNIQUE(watch)"`
  637. }
  638. // Watch or unwatch repository.
  639. func WatchRepo(userId, repoId int64, watch bool) (err error) {
  640. if watch {
  641. if _, err = orm.Insert(&Watch{RepoId: repoId, UserId: userId}); err != nil {
  642. return err
  643. }
  644. rawSql := "UPDATE `repository` SET num_watches = num_watches + 1 WHERE id = ?"
  645. _, err = orm.Exec(rawSql, repoId)
  646. } else {
  647. if _, err = orm.Delete(&Watch{0, repoId, userId}); err != nil {
  648. return err
  649. }
  650. rawSql := "UPDATE `repository` SET num_watches = num_watches - 1 WHERE id = ?"
  651. _, err = orm.Exec(rawSql, repoId)
  652. }
  653. return err
  654. }
  655. // GetWatches returns all watches of given repository.
  656. func GetWatches(repoId int64) ([]Watch, error) {
  657. watches := make([]Watch, 0, 10)
  658. err := orm.Find(&watches, &Watch{RepoId: repoId})
  659. return watches, err
  660. }
  661. // NotifyWatchers creates batch of actions for every watcher.
  662. func NotifyWatchers(act *Action) error {
  663. // Add feeds for user self and all watchers.
  664. watches, err := GetWatches(act.RepoId)
  665. if err != nil {
  666. return errors.New("repo.NotifyWatchers(get watches): " + err.Error())
  667. }
  668. // Add feed for actioner.
  669. act.UserId = act.ActUserId
  670. if _, err = orm.InsertOne(act); err != nil {
  671. return errors.New("repo.NotifyWatchers(create action): " + err.Error())
  672. }
  673. for i := range watches {
  674. if act.ActUserId == watches[i].UserId {
  675. continue
  676. }
  677. act.Id = 0
  678. act.UserId = watches[i].UserId
  679. if _, err = orm.InsertOne(act); err != nil {
  680. return errors.New("repo.NotifyWatchers(create action): " + err.Error())
  681. }
  682. }
  683. return nil
  684. }
  685. // IsWatching checks if user has watched given repository.
  686. func IsWatching(userId, repoId int64) bool {
  687. has, _ := orm.Get(&Watch{0, repoId, userId})
  688. return has
  689. }
  690. func ForkRepository(reposName string, userId int64) {
  691. }