mirror of https://github.com/go-gitea/gitea
Display ui time with customize time location (#7792)
* display ui time with customize time location * fix lint * rename UILocation to DefaultUILocation * move time related functions to modules/timeutil * fix tests * fix tests * fix build * fix swaggerpull/7878/head^2
Lunny Xiao
5 years ago
committed by
GitHub
parent
5a44be627c
commit
85202d4784
@ -0,0 +1,36 @@ |
||||
// Copyright 2019 The Gitea Authors. All rights reserved.
|
||||
// Use of this source code is governed by a MIT-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package timeutil |
||||
|
||||
import ( |
||||
"time" |
||||
|
||||
"code.gitea.io/gitea/modules/setting" |
||||
) |
||||
|
||||
var ( |
||||
langTimeFormats = map[string]string{ |
||||
"zh-CN": "2006年01月02日 15时04分05秒", |
||||
"en-US": time.RFC1123, |
||||
"lv-LV": "02.01.2006. 15:04:05", |
||||
} |
||||
) |
||||
|
||||
// GetLangTimeFormat represents the default time format for the language
|
||||
func GetLangTimeFormat(lang string) string { |
||||
return langTimeFormats[lang] |
||||
} |
||||
|
||||
// GetTimeFormat represents the
|
||||
func GetTimeFormat(lang string) string { |
||||
if setting.TimeFormat == "" { |
||||
format := GetLangTimeFormat(lang) |
||||
if format == "" { |
||||
format = time.RFC1123 |
||||
} |
||||
return format |
||||
} |
||||
return setting.TimeFormat |
||||
} |
||||
@ -0,0 +1,164 @@ |
||||
// Copyright 2019 The Gitea Authors. All rights reserved.
|
||||
// Use of this source code is governed by a MIT-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package timeutil |
||||
|
||||
import ( |
||||
"fmt" |
||||
"html/template" |
||||
"strings" |
||||
"time" |
||||
|
||||
"code.gitea.io/gitea/modules/setting" |
||||
|
||||
"github.com/Unknwon/i18n" |
||||
) |
||||
|
||||
// Seconds-based time units
|
||||
const ( |
||||
Minute = 60 |
||||
Hour = 60 * Minute |
||||
Day = 24 * Hour |
||||
Week = 7 * Day |
||||
Month = 30 * Day |
||||
Year = 12 * Month |
||||
) |
||||
|
||||
func computeTimeDiff(diff int64, lang string) (int64, string) { |
||||
diffStr := "" |
||||
switch { |
||||
case diff <= 0: |
||||
diff = 0 |
||||
diffStr = i18n.Tr(lang, "tool.now") |
||||
case diff < 2: |
||||
diff = 0 |
||||
diffStr = i18n.Tr(lang, "tool.1s") |
||||
case diff < 1*Minute: |
||||
diffStr = i18n.Tr(lang, "tool.seconds", diff) |
||||
diff = 0 |
||||
|
||||
case diff < 2*Minute: |
||||
diff -= 1 * Minute |
||||
diffStr = i18n.Tr(lang, "tool.1m") |
||||
case diff < 1*Hour: |
||||
diffStr = i18n.Tr(lang, "tool.minutes", diff/Minute) |
||||
diff -= diff / Minute * Minute |
||||
|
||||
case diff < 2*Hour: |
||||
diff -= 1 * Hour |
||||
diffStr = i18n.Tr(lang, "tool.1h") |
||||
case diff < 1*Day: |
||||
diffStr = i18n.Tr(lang, "tool.hours", diff/Hour) |
||||
diff -= diff / Hour * Hour |
||||
|
||||
case diff < 2*Day: |
||||
diff -= 1 * Day |
||||
diffStr = i18n.Tr(lang, "tool.1d") |
||||
case diff < 1*Week: |
||||
diffStr = i18n.Tr(lang, "tool.days", diff/Day) |
||||
diff -= diff / Day * Day |
||||
|
||||
case diff < 2*Week: |
||||
diff -= 1 * Week |
||||
diffStr = i18n.Tr(lang, "tool.1w") |
||||
case diff < 1*Month: |
||||
diffStr = i18n.Tr(lang, "tool.weeks", diff/Week) |
||||
diff -= diff / Week * Week |
||||
|
||||
case diff < 2*Month: |
||||
diff -= 1 * Month |
||||
diffStr = i18n.Tr(lang, "tool.1mon") |
||||
case diff < 1*Year: |
||||
diffStr = i18n.Tr(lang, "tool.months", diff/Month) |
||||
diff -= diff / Month * Month |
||||
|
||||
case diff < 2*Year: |
||||
diff -= 1 * Year |
||||
diffStr = i18n.Tr(lang, "tool.1y") |
||||
default: |
||||
diffStr = i18n.Tr(lang, "tool.years", diff/Year) |
||||
diff -= (diff / Year) * Year |
||||
} |
||||
return diff, diffStr |
||||
} |
||||
|
||||
// MinutesToFriendly returns a user friendly string with number of minutes
|
||||
// converted to hours and minutes.
|
||||
func MinutesToFriendly(minutes int, lang string) string { |
||||
duration := time.Duration(minutes) * time.Minute |
||||
return TimeSincePro(time.Now().Add(-duration), lang) |
||||
} |
||||
|
||||
// TimeSincePro calculates the time interval and generate full user-friendly string.
|
||||
func TimeSincePro(then time.Time, lang string) string { |
||||
return timeSincePro(then, time.Now(), lang) |
||||
} |
||||
|
||||
func timeSincePro(then, now time.Time, lang string) string { |
||||
diff := now.Unix() - then.Unix() |
||||
|
||||
if then.After(now) { |
||||
return i18n.Tr(lang, "tool.future") |
||||
} |
||||
if diff == 0 { |
||||
return i18n.Tr(lang, "tool.now") |
||||
} |
||||
|
||||
var timeStr, diffStr string |
||||
for { |
||||
if diff == 0 { |
||||
break |
||||
} |
||||
|
||||
diff, diffStr = computeTimeDiff(diff, lang) |
||||
timeStr += ", " + diffStr |
||||
} |
||||
return strings.TrimPrefix(timeStr, ", ") |
||||
} |
||||
|
||||
func timeSince(then, now time.Time, lang string) string { |
||||
return timeSinceUnix(then.Unix(), now.Unix(), lang) |
||||
} |
||||
|
||||
func timeSinceUnix(then, now int64, lang string) string { |
||||
lbl := "tool.ago" |
||||
diff := now - then |
||||
if then > now { |
||||
lbl = "tool.from_now" |
||||
diff = then - now |
||||
} |
||||
if diff <= 0 { |
||||
return i18n.Tr(lang, "tool.now") |
||||
} |
||||
|
||||
_, diffStr := computeTimeDiff(diff, lang) |
||||
return i18n.Tr(lang, lbl, diffStr) |
||||
} |
||||
|
||||
// RawTimeSince retrieves i18n key of time since t
|
||||
func RawTimeSince(t time.Time, lang string) string { |
||||
return timeSince(t, time.Now(), lang) |
||||
} |
||||
|
||||
// TimeSince calculates the time interval and generate user-friendly string.
|
||||
func TimeSince(then time.Time, lang string) template.HTML { |
||||
return htmlTimeSince(then, time.Now(), lang) |
||||
} |
||||
|
||||
func htmlTimeSince(then, now time.Time, lang string) template.HTML { |
||||
return template.HTML(fmt.Sprintf(`<span class="time-since" title="%s">%s</span>`, |
||||
then.In(setting.DefaultUILocation).Format(GetTimeFormat(lang)), |
||||
timeSince(then, now, lang))) |
||||
} |
||||
|
||||
// TimeSinceUnix calculates the time interval and generate user-friendly string.
|
||||
func TimeSinceUnix(then TimeStamp, lang string) template.HTML { |
||||
return htmlTimeSinceUnix(then, TimeStamp(time.Now().Unix()), lang) |
||||
} |
||||
|
||||
func htmlTimeSinceUnix(then, now TimeStamp, lang string) template.HTML { |
||||
return template.HTML(fmt.Sprintf(`<span class="time-since" title="%s">%s</span>`, |
||||
then.FormatInLocation(GetTimeFormat(lang), setting.DefaultUILocation), |
||||
timeSinceUnix(int64(then), int64(now), lang))) |
||||
} |
||||
@ -0,0 +1,163 @@ |
||||
// Copyright 2019 The Gitea Authors. All rights reserved.
|
||||
// Use of this source code is governed by a MIT-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package timeutil |
||||
|
||||
import ( |
||||
"os" |
||||
"testing" |
||||
"time" |
||||
|
||||
"code.gitea.io/gitea/modules/setting" |
||||
|
||||
"github.com/Unknwon/i18n" |
||||
macaroni18n "github.com/go-macaron/i18n" |
||||
"github.com/stretchr/testify/assert" |
||||
) |
||||
|
||||
var BaseDate time.Time |
||||
|
||||
// time durations
|
||||
const ( |
||||
DayDur = 24 * time.Hour |
||||
WeekDur = 7 * DayDur |
||||
MonthDur = 30 * DayDur |
||||
YearDur = 12 * MonthDur |
||||
) |
||||
|
||||
func TestMain(m *testing.M) { |
||||
// setup
|
||||
macaroni18n.I18n(macaroni18n.Options{ |
||||
Directory: "../../options/locale/", |
||||
DefaultLang: "en-US", |
||||
Langs: []string{"en-US"}, |
||||
Names: []string{"english"}, |
||||
}) |
||||
BaseDate = time.Date(2000, time.January, 1, 0, 0, 0, 0, time.UTC) |
||||
|
||||
// run the tests
|
||||
retVal := m.Run() |
||||
|
||||
os.Exit(retVal) |
||||
} |
||||
|
||||
func TestTimeSince(t *testing.T) { |
||||
assert.Equal(t, "now", timeSince(BaseDate, BaseDate, "en")) |
||||
|
||||
// test that each diff in `diffs` yields the expected string
|
||||
test := func(expected string, diffs ...time.Duration) { |
||||
for _, diff := range diffs { |
||||
actual := timeSince(BaseDate, BaseDate.Add(diff), "en") |
||||
assert.Equal(t, i18n.Tr("en", "tool.ago", expected), actual) |
||||
actual = timeSince(BaseDate.Add(diff), BaseDate, "en") |
||||
assert.Equal(t, i18n.Tr("en", "tool.from_now", expected), actual) |
||||
} |
||||
} |
||||
test("1 second", time.Second, time.Second+50*time.Millisecond) |
||||
test("2 seconds", 2*time.Second, 2*time.Second+50*time.Millisecond) |
||||
test("1 minute", time.Minute, time.Minute+30*time.Second) |
||||
test("2 minutes", 2*time.Minute, 2*time.Minute+30*time.Second) |
||||
test("1 hour", time.Hour, time.Hour+30*time.Minute) |
||||
test("2 hours", 2*time.Hour, 2*time.Hour+30*time.Minute) |
||||
test("1 day", DayDur, DayDur+12*time.Hour) |
||||
test("2 days", 2*DayDur, 2*DayDur+12*time.Hour) |
||||
test("1 week", WeekDur, WeekDur+3*DayDur) |
||||
test("2 weeks", 2*WeekDur, 2*WeekDur+3*DayDur) |
||||
test("1 month", MonthDur, MonthDur+15*DayDur) |
||||
test("2 months", 2*MonthDur, 2*MonthDur+15*DayDur) |
||||
test("1 year", YearDur, YearDur+6*MonthDur) |
||||
test("2 years", 2*YearDur, 2*YearDur+6*MonthDur) |
||||
} |
||||
|
||||
func TestTimeSincePro(t *testing.T) { |
||||
assert.Equal(t, "now", timeSincePro(BaseDate, BaseDate, "en")) |
||||
|
||||
// test that a difference of `diff` yields the expected string
|
||||
test := func(expected string, diff time.Duration) { |
||||
actual := timeSincePro(BaseDate, BaseDate.Add(diff), "en") |
||||
assert.Equal(t, expected, actual) |
||||
assert.Equal(t, "future", timeSincePro(BaseDate.Add(diff), BaseDate, "en")) |
||||
} |
||||
test("1 second", time.Second) |
||||
test("2 seconds", 2*time.Second) |
||||
test("1 minute", time.Minute) |
||||
test("1 minute, 1 second", time.Minute+time.Second) |
||||
test("1 minute, 59 seconds", time.Minute+59*time.Second) |
||||
test("2 minutes", 2*time.Minute) |
||||
test("1 hour", time.Hour) |
||||
test("1 hour, 1 second", time.Hour+time.Second) |
||||
test("1 hour, 59 minutes, 59 seconds", time.Hour+59*time.Minute+59*time.Second) |
||||
test("2 hours", 2*time.Hour) |
||||
test("1 day", DayDur) |
||||
test("1 day, 23 hours, 59 minutes, 59 seconds", |
||||
DayDur+23*time.Hour+59*time.Minute+59*time.Second) |
||||
test("2 days", 2*DayDur) |
||||
test("1 week", WeekDur) |
||||
test("2 weeks", 2*WeekDur) |
||||
test("1 month", MonthDur) |
||||
test("3 months", 3*MonthDur) |
||||
test("1 year", YearDur) |
||||
test("2 years, 3 months, 1 week, 2 days, 4 hours, 12 minutes, 17 seconds", |
||||
2*YearDur+3*MonthDur+WeekDur+2*DayDur+4*time.Hour+ |
||||
12*time.Minute+17*time.Second) |
||||
} |
||||
|
||||
func TestHtmlTimeSince(t *testing.T) { |
||||
setting.TimeFormat = time.UnixDate |
||||
setting.DefaultUILocation = time.UTC |
||||
// test that `diff` yields a result containing `expected`
|
||||
test := func(expected string, diff time.Duration) { |
||||
actual := htmlTimeSince(BaseDate, BaseDate.Add(diff), "en") |
||||
assert.Contains(t, actual, `title="Sat Jan 1 00:00:00 UTC 2000"`) |
||||
assert.Contains(t, actual, expected) |
||||
} |
||||
test("1 second", time.Second) |
||||
test("3 minutes", 3*time.Minute+5*time.Second) |
||||
test("1 day", DayDur+18*time.Hour) |
||||
test("1 week", WeekDur+6*DayDur) |
||||
test("3 months", 3*MonthDur+3*WeekDur) |
||||
test("2 years", 2*YearDur) |
||||
test("3 years", 3*YearDur+11*MonthDur+4*WeekDur) |
||||
} |
||||
|
||||
func TestComputeTimeDiff(t *testing.T) { |
||||
// test that for each offset in offsets,
|
||||
// computeTimeDiff(base + offset) == (offset, str)
|
||||
test := func(base int64, str string, offsets ...int64) { |
||||
for _, offset := range offsets { |
||||
diff, diffStr := computeTimeDiff(base+offset, "en") |
||||
assert.Equal(t, offset, diff) |
||||
assert.Equal(t, str, diffStr) |
||||
} |
||||
} |
||||
test(0, "now", 0) |
||||
test(1, "1 second", 0) |
||||
test(2, "2 seconds", 0) |
||||
test(Minute, "1 minute", 0, 1, 30, Minute-1) |
||||
test(2*Minute, "2 minutes", 0, Minute-1) |
||||
test(Hour, "1 hour", 0, 1, Hour-1) |
||||
test(5*Hour, "5 hours", 0, Hour-1) |
||||
test(Day, "1 day", 0, 1, Day-1) |
||||
test(5*Day, "5 days", 0, Day-1) |
||||
test(Week, "1 week", 0, 1, Week-1) |
||||
test(3*Week, "3 weeks", 0, 4*Day+25000) |
||||
test(Month, "1 month", 0, 1, Month-1) |
||||
test(10*Month, "10 months", 0, Month-1) |
||||
test(Year, "1 year", 0, Year-1) |
||||
test(3*Year, "3 years", 0, Year-1) |
||||
} |
||||
|
||||
func TestMinutesToFriendly(t *testing.T) { |
||||
// test that a number of minutes yields the expected string
|
||||
test := func(expected string, minutes int) { |
||||
actual := MinutesToFriendly(minutes, "en") |
||||
assert.Equal(t, expected, actual) |
||||
} |
||||
test("1 minute", 1) |
||||
test("2 minutes", 2) |
||||
test("1 hour", 60) |
||||
test("1 hour, 1 minute", 61) |
||||
test("1 hour, 2 minutes", 62) |
||||
test("2 hours", 120) |
||||
} |
||||
Loading…
Reference in new issue