Fork to maintain patches against the official gitea for https://code.ceondo.com https://github.com/go-gitea/gitea

issue_stopwatch.go 3.6KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165
  1. // Copyright 2017 The Gitea 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. "fmt"
  7. "time"
  8. )
  9. // Stopwatch represents a stopwatch for time tracking.
  10. type Stopwatch struct {
  11. ID int64 `xorm:"pk autoincr"`
  12. IssueID int64 `xorm:"INDEX"`
  13. UserID int64 `xorm:"INDEX"`
  14. Created time.Time `xorm:"-"`
  15. CreatedUnix int64
  16. }
  17. // BeforeInsert will be invoked by XORM before inserting a record
  18. // representing this object.
  19. func (s *Stopwatch) BeforeInsert() {
  20. s.CreatedUnix = time.Now().Unix()
  21. }
  22. // AfterLoad is invoked from XORM after setting the values of all fields of this object.
  23. func (s *Stopwatch) AfterLoad() {
  24. s.Created = time.Unix(s.CreatedUnix, 0).Local()
  25. }
  26. func getStopwatch(e Engine, userID, issueID int64) (sw *Stopwatch, exists bool, err error) {
  27. sw = new(Stopwatch)
  28. exists, err = e.
  29. Where("user_id = ?", userID).
  30. And("issue_id = ?", issueID).
  31. Get(sw)
  32. return
  33. }
  34. // StopwatchExists returns true if the stopwatch exists
  35. func StopwatchExists(userID int64, issueID int64) bool {
  36. _, exists, _ := getStopwatch(x, userID, issueID)
  37. return exists
  38. }
  39. // HasUserStopwatch returns true if the user has a stopwatch
  40. func HasUserStopwatch(userID int64) (exists bool, sw *Stopwatch, err error) {
  41. sw = new(Stopwatch)
  42. exists, err = x.
  43. Where("user_id = ?", userID).
  44. Get(sw)
  45. return
  46. }
  47. // CreateOrStopIssueStopwatch will create or remove a stopwatch and will log it into issue's timeline.
  48. func CreateOrStopIssueStopwatch(user *User, issue *Issue) error {
  49. sw, exists, err := getStopwatch(x, user.ID, issue.ID)
  50. if err != nil {
  51. return err
  52. }
  53. if exists {
  54. // Create tracked time out of the time difference between start date and actual date
  55. timediff := time.Now().Unix() - sw.CreatedUnix
  56. // Create TrackedTime
  57. tt := &TrackedTime{
  58. Created: time.Now(),
  59. IssueID: issue.ID,
  60. UserID: user.ID,
  61. Time: timediff,
  62. }
  63. if _, err := x.Insert(tt); err != nil {
  64. return err
  65. }
  66. if _, err := CreateComment(&CreateCommentOptions{
  67. Doer: user,
  68. Issue: issue,
  69. Repo: issue.Repo,
  70. Content: secToTime(timediff),
  71. Type: CommentTypeStopTracking,
  72. }); err != nil {
  73. return err
  74. }
  75. if _, err := x.Delete(sw); err != nil {
  76. return err
  77. }
  78. } else {
  79. // Create stopwatch
  80. sw = &Stopwatch{
  81. UserID: user.ID,
  82. IssueID: issue.ID,
  83. Created: time.Now(),
  84. }
  85. if _, err := x.Insert(sw); err != nil {
  86. return err
  87. }
  88. if _, err := CreateComment(&CreateCommentOptions{
  89. Doer: user,
  90. Issue: issue,
  91. Repo: issue.Repo,
  92. Type: CommentTypeStartTracking,
  93. }); err != nil {
  94. return err
  95. }
  96. }
  97. return nil
  98. }
  99. // CancelStopwatch removes the given stopwatch and logs it into issue's timeline.
  100. func CancelStopwatch(user *User, issue *Issue) error {
  101. sw, exists, err := getStopwatch(x, user.ID, issue.ID)
  102. if err != nil {
  103. return err
  104. }
  105. if exists {
  106. if _, err := x.Delete(sw); err != nil {
  107. return err
  108. }
  109. if _, err := CreateComment(&CreateCommentOptions{
  110. Doer: user,
  111. Issue: issue,
  112. Repo: issue.Repo,
  113. Type: CommentTypeCancelTracking,
  114. }); err != nil {
  115. return err
  116. }
  117. }
  118. return nil
  119. }
  120. func secToTime(duration int64) string {
  121. seconds := duration % 60
  122. minutes := (duration / (60)) % 60
  123. hours := duration / (60 * 60)
  124. var hrs string
  125. if hours > 0 {
  126. hrs = fmt.Sprintf("%dh", hours)
  127. }
  128. if minutes > 0 {
  129. if hours == 0 {
  130. hrs = fmt.Sprintf("%dmin", minutes)
  131. } else {
  132. hrs = fmt.Sprintf("%s %dmin", hrs, minutes)
  133. }
  134. }
  135. if seconds > 0 {
  136. if hours == 0 && minutes == 0 {
  137. hrs = fmt.Sprintf("%ds", seconds)
  138. } else {
  139. hrs = fmt.Sprintf("%s %ds", hrs, seconds)
  140. }
  141. }
  142. return hrs
  143. }