tool.go 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620
  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 base
  5. import (
  6. "bytes"
  7. "crypto/hmac"
  8. "crypto/md5"
  9. "crypto/rand"
  10. "crypto/sha1"
  11. "encoding/hex"
  12. "encoding/json"
  13. "fmt"
  14. "hash"
  15. "math"
  16. "strconv"
  17. "strings"
  18. "time"
  19. )
  20. // Encode string to md5 hex value
  21. func EncodeMd5(str string) string {
  22. m := md5.New()
  23. m.Write([]byte(str))
  24. return hex.EncodeToString(m.Sum(nil))
  25. }
  26. // GetRandomString generate random string by specify chars.
  27. func GetRandomString(n int, alphabets ...byte) string {
  28. const alphanum = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
  29. var bytes = make([]byte, n)
  30. rand.Read(bytes)
  31. for i, b := range bytes {
  32. if len(alphabets) == 0 {
  33. bytes[i] = alphanum[b%byte(len(alphanum))]
  34. } else {
  35. bytes[i] = alphabets[b%byte(len(alphabets))]
  36. }
  37. }
  38. return string(bytes)
  39. }
  40. // http://code.google.com/p/go/source/browse/pbkdf2/pbkdf2.go?repo=crypto
  41. func PBKDF2(password, salt []byte, iter, keyLen int, h func() hash.Hash) []byte {
  42. prf := hmac.New(h, password)
  43. hashLen := prf.Size()
  44. numBlocks := (keyLen + hashLen - 1) / hashLen
  45. var buf [4]byte
  46. dk := make([]byte, 0, numBlocks*hashLen)
  47. U := make([]byte, hashLen)
  48. for block := 1; block <= numBlocks; block++ {
  49. // N.B.: || means concatenation, ^ means XOR
  50. // for each block T_i = U_1 ^ U_2 ^ ... ^ U_iter
  51. // U_1 = PRF(password, salt || uint(i))
  52. prf.Reset()
  53. prf.Write(salt)
  54. buf[0] = byte(block >> 24)
  55. buf[1] = byte(block >> 16)
  56. buf[2] = byte(block >> 8)
  57. buf[3] = byte(block)
  58. prf.Write(buf[:4])
  59. dk = prf.Sum(dk)
  60. T := dk[len(dk)-hashLen:]
  61. copy(U, T)
  62. // U_n = PRF(password, U_(n-1))
  63. for n := 2; n <= iter; n++ {
  64. prf.Reset()
  65. prf.Write(U)
  66. U = U[:0]
  67. U = prf.Sum(U)
  68. for x := range U {
  69. T[x] ^= U[x]
  70. }
  71. }
  72. }
  73. return dk[:keyLen]
  74. }
  75. // verify time limit code
  76. func VerifyTimeLimitCode(data string, minutes int, code string) bool {
  77. if len(code) <= 18 {
  78. return false
  79. }
  80. // split code
  81. start := code[:12]
  82. lives := code[12:18]
  83. if d, err := StrTo(lives).Int(); err == nil {
  84. minutes = d
  85. }
  86. // right active code
  87. retCode := CreateTimeLimitCode(data, minutes, start)
  88. if retCode == code && minutes > 0 {
  89. // check time is expired or not
  90. before, _ := DateParse(start, "YmdHi")
  91. now := time.Now()
  92. if before.Add(time.Minute*time.Duration(minutes)).Unix() > now.Unix() {
  93. return true
  94. }
  95. }
  96. return false
  97. }
  98. const TimeLimitCodeLength = 12 + 6 + 40
  99. // create a time limit code
  100. // code format: 12 length date time string + 6 minutes string + 40 sha1 encoded string
  101. func CreateTimeLimitCode(data string, minutes int, startInf interface{}) string {
  102. format := "YmdHi"
  103. var start, end time.Time
  104. var startStr, endStr string
  105. if startInf == nil {
  106. // Use now time create code
  107. start = time.Now()
  108. startStr = DateFormat(start, format)
  109. } else {
  110. // use start string create code
  111. startStr = startInf.(string)
  112. start, _ = DateParse(startStr, format)
  113. startStr = DateFormat(start, format)
  114. }
  115. end = start.Add(time.Minute * time.Duration(minutes))
  116. endStr = DateFormat(end, format)
  117. // create sha1 encode string
  118. sh := sha1.New()
  119. sh.Write([]byte(data + SecretKey + startStr + endStr + ToStr(minutes)))
  120. encoded := hex.EncodeToString(sh.Sum(nil))
  121. code := fmt.Sprintf("%s%06d%s", startStr, minutes, encoded)
  122. return code
  123. }
  124. // AvatarLink returns avatar link by given e-mail.
  125. func AvatarLink(email string) string {
  126. if Service.EnableCacheAvatar {
  127. return "/avatar/" + EncodeMd5(email)
  128. }
  129. return "http://1.gravatar.com/avatar/" + EncodeMd5(email)
  130. }
  131. // Seconds-based time units
  132. const (
  133. Minute = 60
  134. Hour = 60 * Minute
  135. Day = 24 * Hour
  136. Week = 7 * Day
  137. Month = 30 * Day
  138. Year = 12 * Month
  139. )
  140. func computeTimeDiff(diff int64) (int64, string) {
  141. diffStr := ""
  142. switch {
  143. case diff <= 0:
  144. diff = 0
  145. diffStr = "now"
  146. case diff < 2:
  147. diff = 0
  148. diffStr = "1 second"
  149. case diff < 1*Minute:
  150. diffStr = fmt.Sprintf("%d seconds", diff)
  151. diff = 0
  152. case diff < 2*Minute:
  153. diff -= 1 * Minute
  154. diffStr = "1 minute"
  155. case diff < 1*Hour:
  156. diffStr = fmt.Sprintf("%d minutes", diff/Minute)
  157. diff -= diff / Minute * Minute
  158. case diff < 2*Hour:
  159. diff -= 1 * Hour
  160. diffStr = "1 hour"
  161. case diff < 1*Day:
  162. diffStr = fmt.Sprintf("%d hours", diff/Hour)
  163. diff -= diff / Hour * Hour
  164. case diff < 2*Day:
  165. diff -= 1 * Day
  166. diffStr = "1 day"
  167. case diff < 1*Week:
  168. diffStr = fmt.Sprintf("%d days", diff/Day)
  169. diff -= diff / Day * Day
  170. case diff < 2*Week:
  171. diff -= 1 * Week
  172. diffStr = "1 week"
  173. case diff < 1*Month:
  174. diffStr = fmt.Sprintf("%d weeks", diff/Week)
  175. diff -= diff / Week * Week
  176. case diff < 2*Month:
  177. diff -= 1 * Month
  178. diffStr = "1 month"
  179. case diff < 1*Year:
  180. diffStr = fmt.Sprintf("%d months", diff/Month)
  181. diff -= diff / Month * Month
  182. case diff < 2*Year:
  183. diff -= 1 * Year
  184. diffStr = "1 year"
  185. default:
  186. diffStr = fmt.Sprintf("%d years", diff/Year)
  187. diff = 0
  188. }
  189. return diff, diffStr
  190. }
  191. // TimeSincePro calculates the time interval and generate full user-friendly string.
  192. func TimeSincePro(then time.Time) string {
  193. now := time.Now()
  194. diff := now.Unix() - then.Unix()
  195. if then.After(now) {
  196. return "future"
  197. }
  198. var timeStr, diffStr string
  199. for {
  200. if diff == 0 {
  201. break
  202. }
  203. diff, diffStr = computeTimeDiff(diff)
  204. timeStr += ", " + diffStr
  205. }
  206. return strings.TrimPrefix(timeStr, ", ")
  207. }
  208. // TimeSince calculates the time interval and generate user-friendly string.
  209. func TimeSince(then time.Time) string {
  210. now := time.Now()
  211. lbl := "ago"
  212. diff := now.Unix() - then.Unix()
  213. if then.After(now) {
  214. lbl = "from now"
  215. diff = then.Unix() - now.Unix()
  216. }
  217. switch {
  218. case diff <= 0:
  219. return "now"
  220. case diff <= 2:
  221. return fmt.Sprintf("1 second %s", lbl)
  222. case diff < 1*Minute:
  223. return fmt.Sprintf("%d seconds %s", diff, lbl)
  224. case diff < 2*Minute:
  225. return fmt.Sprintf("1 minute %s", lbl)
  226. case diff < 1*Hour:
  227. return fmt.Sprintf("%d minutes %s", diff/Minute, lbl)
  228. case diff < 2*Hour:
  229. return fmt.Sprintf("1 hour %s", lbl)
  230. case diff < 1*Day:
  231. return fmt.Sprintf("%d hours %s", diff/Hour, lbl)
  232. case diff < 2*Day:
  233. return fmt.Sprintf("1 day %s", lbl)
  234. case diff < 1*Week:
  235. return fmt.Sprintf("%d days %s", diff/Day, lbl)
  236. case diff < 2*Week:
  237. return fmt.Sprintf("1 week %s", lbl)
  238. case diff < 1*Month:
  239. return fmt.Sprintf("%d weeks %s", diff/Week, lbl)
  240. case diff < 2*Month:
  241. return fmt.Sprintf("1 month %s", lbl)
  242. case diff < 1*Year:
  243. return fmt.Sprintf("%d months %s", diff/Month, lbl)
  244. case diff < 2*Year:
  245. return fmt.Sprintf("1 year %s", lbl)
  246. default:
  247. return fmt.Sprintf("%d years %s", diff/Year, lbl)
  248. }
  249. return then.String()
  250. }
  251. const (
  252. Byte = 1
  253. KByte = Byte * 1024
  254. MByte = KByte * 1024
  255. GByte = MByte * 1024
  256. TByte = GByte * 1024
  257. PByte = TByte * 1024
  258. EByte = PByte * 1024
  259. )
  260. var bytesSizeTable = map[string]uint64{
  261. "b": Byte,
  262. "kb": KByte,
  263. "mb": MByte,
  264. "gb": GByte,
  265. "tb": TByte,
  266. "pb": PByte,
  267. "eb": EByte,
  268. }
  269. func logn(n, b float64) float64 {
  270. return math.Log(n) / math.Log(b)
  271. }
  272. func humanateBytes(s uint64, base float64, sizes []string) string {
  273. if s < 10 {
  274. return fmt.Sprintf("%dB", s)
  275. }
  276. e := math.Floor(logn(float64(s), base))
  277. suffix := sizes[int(e)]
  278. val := float64(s) / math.Pow(base, math.Floor(e))
  279. f := "%.0f"
  280. if val < 10 {
  281. f = "%.1f"
  282. }
  283. return fmt.Sprintf(f+"%s", val, suffix)
  284. }
  285. // FileSize calculates the file size and generate user-friendly string.
  286. func FileSize(s int64) string {
  287. sizes := []string{"B", "KB", "MB", "GB", "TB", "PB", "EB"}
  288. return humanateBytes(uint64(s), 1024, sizes)
  289. }
  290. // Subtract deals with subtraction of all types of number.
  291. func Subtract(left interface{}, right interface{}) interface{} {
  292. var rleft, rright int64
  293. var fleft, fright float64
  294. var isInt bool = true
  295. switch left.(type) {
  296. case int:
  297. rleft = int64(left.(int))
  298. case int8:
  299. rleft = int64(left.(int8))
  300. case int16:
  301. rleft = int64(left.(int16))
  302. case int32:
  303. rleft = int64(left.(int32))
  304. case int64:
  305. rleft = left.(int64)
  306. case float32:
  307. fleft = float64(left.(float32))
  308. isInt = false
  309. case float64:
  310. fleft = left.(float64)
  311. isInt = false
  312. }
  313. switch right.(type) {
  314. case int:
  315. rright = int64(right.(int))
  316. case int8:
  317. rright = int64(right.(int8))
  318. case int16:
  319. rright = int64(right.(int16))
  320. case int32:
  321. rright = int64(right.(int32))
  322. case int64:
  323. rright = right.(int64)
  324. case float32:
  325. fright = float64(left.(float32))
  326. isInt = false
  327. case float64:
  328. fleft = left.(float64)
  329. isInt = false
  330. }
  331. if isInt {
  332. return rleft - rright
  333. } else {
  334. return fleft + float64(rleft) - (fright + float64(rright))
  335. }
  336. }
  337. // DateFormat pattern rules.
  338. var datePatterns = []string{
  339. // year
  340. "Y", "2006", // A full numeric representation of a year, 4 digits Examples: 1999 or 2003
  341. "y", "06", //A two digit representation of a year Examples: 99 or 03
  342. // month
  343. "m", "01", // Numeric representation of a month, with leading zeros 01 through 12
  344. "n", "1", // Numeric representation of a month, without leading zeros 1 through 12
  345. "M", "Jan", // A short textual representation of a month, three letters Jan through Dec
  346. "F", "January", // A full textual representation of a month, such as January or March January through December
  347. // day
  348. "d", "02", // Day of the month, 2 digits with leading zeros 01 to 31
  349. "j", "2", // Day of the month without leading zeros 1 to 31
  350. // week
  351. "D", "Mon", // A textual representation of a day, three letters Mon through Sun
  352. "l", "Monday", // A full textual representation of the day of the week Sunday through Saturday
  353. // time
  354. "g", "3", // 12-hour format of an hour without leading zeros 1 through 12
  355. "G", "15", // 24-hour format of an hour without leading zeros 0 through 23
  356. "h", "03", // 12-hour format of an hour with leading zeros 01 through 12
  357. "H", "15", // 24-hour format of an hour with leading zeros 00 through 23
  358. "a", "pm", // Lowercase Ante meridiem and Post meridiem am or pm
  359. "A", "PM", // Uppercase Ante meridiem and Post meridiem AM or PM
  360. "i", "04", // Minutes with leading zeros 00 to 59
  361. "s", "05", // Seconds, with leading zeros 00 through 59
  362. // time zone
  363. "T", "MST",
  364. "P", "-07:00",
  365. "O", "-0700",
  366. // RFC 2822
  367. "r", time.RFC1123Z,
  368. }
  369. // Parse Date use PHP time format.
  370. func DateParse(dateString, format string) (time.Time, error) {
  371. replacer := strings.NewReplacer(datePatterns...)
  372. format = replacer.Replace(format)
  373. return time.ParseInLocation(format, dateString, time.Local)
  374. }
  375. // Date takes a PHP like date func to Go's time format.
  376. func DateFormat(t time.Time, format string) string {
  377. replacer := strings.NewReplacer(datePatterns...)
  378. format = replacer.Replace(format)
  379. return t.Format(format)
  380. }
  381. // convert string to specify type
  382. type StrTo string
  383. func (f StrTo) Exist() bool {
  384. return string(f) != string(0x1E)
  385. }
  386. func (f StrTo) Int() (int, error) {
  387. v, err := strconv.ParseInt(f.String(), 10, 32)
  388. return int(v), err
  389. }
  390. func (f StrTo) Int64() (int64, error) {
  391. v, err := strconv.ParseInt(f.String(), 10, 64)
  392. return int64(v), err
  393. }
  394. func (f StrTo) String() string {
  395. if f.Exist() {
  396. return string(f)
  397. }
  398. return ""
  399. }
  400. // convert any type to string
  401. func ToStr(value interface{}, args ...int) (s string) {
  402. switch v := value.(type) {
  403. case bool:
  404. s = strconv.FormatBool(v)
  405. case float32:
  406. s = strconv.FormatFloat(float64(v), 'f', argInt(args).Get(0, -1), argInt(args).Get(1, 32))
  407. case float64:
  408. s = strconv.FormatFloat(v, 'f', argInt(args).Get(0, -1), argInt(args).Get(1, 64))
  409. case int:
  410. s = strconv.FormatInt(int64(v), argInt(args).Get(0, 10))
  411. case int8:
  412. s = strconv.FormatInt(int64(v), argInt(args).Get(0, 10))
  413. case int16:
  414. s = strconv.FormatInt(int64(v), argInt(args).Get(0, 10))
  415. case int32:
  416. s = strconv.FormatInt(int64(v), argInt(args).Get(0, 10))
  417. case int64:
  418. s = strconv.FormatInt(v, argInt(args).Get(0, 10))
  419. case uint:
  420. s = strconv.FormatUint(uint64(v), argInt(args).Get(0, 10))
  421. case uint8:
  422. s = strconv.FormatUint(uint64(v), argInt(args).Get(0, 10))
  423. case uint16:
  424. s = strconv.FormatUint(uint64(v), argInt(args).Get(0, 10))
  425. case uint32:
  426. s = strconv.FormatUint(uint64(v), argInt(args).Get(0, 10))
  427. case uint64:
  428. s = strconv.FormatUint(v, argInt(args).Get(0, 10))
  429. case string:
  430. s = v
  431. case []byte:
  432. s = string(v)
  433. default:
  434. s = fmt.Sprintf("%v", v)
  435. }
  436. return s
  437. }
  438. type argInt []int
  439. func (a argInt) Get(i int, args ...int) (r int) {
  440. if i >= 0 && i < len(a) {
  441. r = a[i]
  442. }
  443. if len(args) > 0 {
  444. r = args[0]
  445. }
  446. return
  447. }
  448. type Actioner interface {
  449. GetOpType() int
  450. GetActUserName() string
  451. GetActEmail() string
  452. GetRepoName() string
  453. GetBranch() string
  454. GetContent() string
  455. }
  456. // ActionIcon accepts a int that represents action operation type
  457. // and returns a icon class name.
  458. func ActionIcon(opType int) string {
  459. switch opType {
  460. case 1: // Create repository.
  461. return "plus-circle"
  462. case 5: // Commit repository.
  463. return "arrow-circle-o-right"
  464. case 6: // Create issue.
  465. return "exclamation-circle"
  466. case 8: // Transfer repository.
  467. return "share"
  468. default:
  469. return "invalid type"
  470. }
  471. }
  472. const (
  473. TPL_CREATE_REPO = `<a href="/user/%s">%s</a> created repository <a href="/%s">%s</a>`
  474. TPL_COMMIT_REPO = `<a href="/user/%s">%s</a> pushed to <a href="/%s/src/%s">%s</a> at <a href="/%s">%s</a>%s`
  475. TPL_COMMIT_REPO_LI = `<div><img src="%s?s=16" alt="user-avatar"/> <a href="/%s/commit/%s">%s</a> %s</div>`
  476. TPL_CREATE_ISSUE = `<a href="/user/%s">%s</a> opened issue <a href="/%s/issues/%s">%s#%s</a>
  477. <div><img src="%s?s=16" alt="user-avatar"/> %s</div>`
  478. TPL_TRANSFER_REPO = `<a href="/user/%s">%s</a> transfered repository <code>%s</code> to <a href="/%s">%s</a>`
  479. )
  480. type PushCommit struct {
  481. Sha1 string
  482. Message string
  483. AuthorEmail string
  484. AuthorName string
  485. }
  486. type PushCommits struct {
  487. Len int
  488. Commits []*PushCommit
  489. }
  490. // ActionDesc accepts int that represents action operation type
  491. // and returns the description.
  492. func ActionDesc(act Actioner) string {
  493. actUserName := act.GetActUserName()
  494. email := act.GetActEmail()
  495. repoName := act.GetRepoName()
  496. repoLink := actUserName + "/" + repoName
  497. branch := act.GetBranch()
  498. content := act.GetContent()
  499. switch act.GetOpType() {
  500. case 1: // Create repository.
  501. return fmt.Sprintf(TPL_CREATE_REPO, actUserName, actUserName, repoLink, repoName)
  502. case 5: // Commit repository.
  503. var push *PushCommits
  504. if err := json.Unmarshal([]byte(content), &push); err != nil {
  505. return err.Error()
  506. }
  507. buf := bytes.NewBuffer([]byte("\n"))
  508. for _, commit := range push.Commits {
  509. buf.WriteString(fmt.Sprintf(TPL_COMMIT_REPO_LI, AvatarLink(commit.AuthorEmail), repoLink, commit.Sha1, commit.Sha1[:7], commit.Message) + "\n")
  510. }
  511. if push.Len > 3 {
  512. buf.WriteString(fmt.Sprintf(`<div><a href="/%s/%s/commits/%s">%d other commits >></a></div>`, actUserName, repoName, branch, push.Len))
  513. }
  514. return fmt.Sprintf(TPL_COMMIT_REPO, actUserName, actUserName, repoLink, branch, branch, repoLink, repoLink,
  515. buf.String())
  516. case 6: // Create issue.
  517. infos := strings.SplitN(content, "|", 2)
  518. return fmt.Sprintf(TPL_CREATE_ISSUE, actUserName, actUserName, repoLink, infos[0], repoLink, infos[0],
  519. AvatarLink(email), infos[1])
  520. case 8: // Transfer repository.
  521. newRepoLink := content + "/" + repoName
  522. return fmt.Sprintf(TPL_TRANSFER_REPO, actUserName, actUserName, repoLink, newRepoLink, newRepoLink)
  523. default:
  524. return "invalid type"
  525. }
  526. }
  527. func DiffTypeToStr(diffType int) string {
  528. diffTypes := map[int]string{
  529. 1: "add", 2: "modify", 3: "del",
  530. }
  531. return diffTypes[diffType]
  532. }
  533. func DiffLineTypeToStr(diffType int) string {
  534. switch diffType {
  535. case 2:
  536. return "add"
  537. case 3:
  538. return "del"
  539. case 4:
  540. return "tag"
  541. }
  542. return "same"
  543. }