zhengchen.tao/ezbookkeeping
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

use the daylight saving time zone as default time zone rather than the current standard time zone during the DST

Browse Source
This commit is contained in:
MaysWind
2025-12-24 00:33:47 +08:00
parent c35cbbda15
commit 76af5d946a
96 changed files with 1179 additions and 882 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/utils/datetimes.go
+15 -10
View File
@@ -224,12 +224,17 @@ func ParseFromLongDateTimeToMaxUnixTime(t string) (time.Time, error) {
return time.ParseInLocation(longDateTimeFormat, t, timezone)
}
// ParseFromLongDateTime parses a formatted string in long date time format
func ParseFromLongDateTime(t string, utcOffset int16) (time.Time, error) {
// ParseFromLongDateTimeInFixedUtcOffset parses a formatted string in long date time format
func ParseFromLongDateTimeInFixedUtcOffset(t string, utcOffset int16) (time.Time, error) {
timezone := time.FixedZone("Timezone", int(utcOffset)*60)
return time.ParseInLocation(longDateTimeFormat, t, timezone)
}
// ParseFromLongDateTimeInTimeZone parses a formatted string in long date time format
func ParseFromLongDateTimeInTimeZone(t string, timezone *time.Location) (time.Time, error) {
return time.ParseInLocation(longDateTimeFormat, t, timezone)
}
// ParseFromLongDateTimeWithTimezone parses a formatted string in long date time format
func ParseFromLongDateTimeWithTimezone(t string) (time.Time, error) {
return time.Parse(longDateTimeWithTimezoneFormat, t)
@@ -245,14 +250,14 @@ func ParseFromLongDateTimeWithTimezoneRFC3339Format(t string) (time.Time, error)
return time.Parse(longDateTimeWithTimezoneRFC3339Format, t)
}
// ParseFromLongDateTimeWithoutSecond parses a formatted string in long date time format (no second)
func ParseFromLongDateTimeWithoutSecond(t string, utcOffset int16) (time.Time, error) {
// ParseFromLongDateTimeWithoutSecondInFixedUtcOffset parses a formatted string in long date time format (no second) with fixed UTC offset
func ParseFromLongDateTimeWithoutSecondInFixedUtcOffset(t string, utcOffset int16) (time.Time, error) {
timezone := time.FixedZone("Timezone", int(utcOffset)*60)
return time.ParseInLocation(longDateTimeWithoutSecondFormat, t, timezone)
}
// ParseFromShortDateTime parses a formatted string in short date time format
func ParseFromShortDateTime(t string, utcOffset int16) (time.Time, error) {
// ParseFromShortDateTimeInFixedUtcOffset parses a formatted string in short date time format with fixed UTC offset
func ParseFromShortDateTimeInFixedUtcOffset(t string, utcOffset int16) (time.Time, error) {
timezone := time.FixedZone("Timezone", int(utcOffset)*60)
return time.ParseInLocation(shortDateTimeFormat, t, timezone)
}
@@ -282,8 +287,8 @@ func IsUnixTimeEqualsYearAndMonth(unixTime int64, timezone *time.Location, year
}
// GetTimezoneOffsetMinutes returns offset minutes according specified timezone
func GetTimezoneOffsetMinutes(timezone *time.Location) int16 {
_, tzOffset := time.Now().In(timezone).Zone()
func GetTimezoneOffsetMinutes(unixTime int64, timezone *time.Location) int16 {
_, tzOffset := parseFromUnixTime(unixTime).In(timezone).Zone()
tzMinuteOffset := int16(tzOffset / 60)
return tzMinuteOffset
@@ -298,8 +303,8 @@ func GetServerTimezoneOffsetMinutes() int16 {
}
// FormatTimezoneOffset returns "+/-HH:MM" format of timezone
func FormatTimezoneOffset(timezone *time.Location) string {
tzMinutesOffset := GetTimezoneOffsetMinutes(timezone)
func FormatTimezoneOffset(unixTime int64, timezone *time.Location) string {
tzMinutesOffset := GetTimezoneOffsetMinutes(unixTime, timezone)
sign := "+"
hourAbsOffset := tzMinutesOffset / 60
pkg/utils/datetimes_test.go
+68 -17
View File
@@ -215,15 +215,36 @@ func TestParseFromLongDateTimeToMaxUnixTime(t *testing.T) {
assert.Equal(t, expectedValue, actualValue)
}
func TestParseFromLongDateTime(t *testing.T) {
func TestParseFromLongDateTimeInFixedUtcOffset(t *testing.T) {
expectedValue := int64(1617228083)
actualTime, err := ParseFromLongDateTime("2021-04-01 06:01:23", 480)
actualTime, err := ParseFromLongDateTimeInFixedUtcOffset("2021-04-01 06:01:23", 480)
assert.Equal(t, nil, err)
actualValue := actualTime.Unix()
assert.Equal(t, expectedValue, actualValue)
}
func TestParseFromLongDateTimeInTimeZone(t *testing.T) {
londonLocation, err := time.LoadLocation("Europe/London")
assert.Equal(t, nil, err)
// during standard time (UTC+0)
expectedValue := int64(1577858483)
actualTime, err := ParseFromLongDateTimeInTimeZone("2020-01-01 06:01:23", londonLocation)
assert.Equal(t, nil, err)
actualValue := actualTime.Unix()
assert.Equal(t, expectedValue, actualValue)
// during daylight saving time (UTC+1)
expectedValue = int64(1619845283)
actualTime, err = ParseFromLongDateTimeInTimeZone("2021-05-01 06:01:23", londonLocation)
assert.Equal(t, nil, err)
actualValue = actualTime.Unix()
assert.Equal(t, expectedValue, actualValue)
}
func TestParseFromLongDateTimeWithTimezone(t *testing.T) {
expectedValue := int64(1617238883)
actualTime, err := ParseFromLongDateTimeWithTimezone("2021-04-01 06:01:23+05:00")
@@ -251,18 +272,18 @@ func TestParseFromLongDateTimeWithTimezoneRFC3339Format(t *testing.T) {
assert.Equal(t, expectedValue, actualValue)
}
func TestParseFromLongDateTimeWithoutSecond(t *testing.T) {
func TestParseFromLongDateTimeWithoutSecondInFixedUtcOffset(t *testing.T) {
expectedValue := int64(1691947440)
actualTime, err := ParseFromLongDateTimeWithoutSecond("2023-08-13 17:24", 0)
actualTime, err := ParseFromLongDateTimeWithoutSecondInFixedUtcOffset("2023-08-13 17:24", 0)
assert.Equal(t, nil, err)
actualValue := actualTime.Unix()
assert.Equal(t, expectedValue, actualValue)
}
func TestParseFromShortDateTime(t *testing.T) {
func TestParseFromShortDateTimeInFixedUtcOffset(t *testing.T) {
expectedValue := int64(1617228083)
actualTime, err := ParseFromShortDateTime("2021-4-1 6:1:23", 480)
actualTime, err := ParseFromShortDateTimeInFixedUtcOffset("2021-4-1 6:1:23", 480)
assert.Equal(t, nil, err)
actualValue := actualTime.Unix()
@@ -312,52 +333,82 @@ func TestIsUnixTimeEqualsYearAndMonth(t *testing.T) {
assert.Equal(t, false, actualValue)
}
func TestGetTimezoneOffsetMinutes(t *testing.T) {
func TestGetTimezoneOffsetMinutes_FixedTimezone(t *testing.T) {
timezone := time.FixedZone("Test Timezone", 120*60)
expectedValue := int16(120)
actualValue := GetTimezoneOffsetMinutes(timezone)
actualValue := GetTimezoneOffsetMinutes(time.Now().Unix(), timezone)
assert.Equal(t, expectedValue, actualValue)
timezone = time.FixedZone("Test Timezone", 345*60)
expectedValue = int16(345)
actualValue = GetTimezoneOffsetMinutes(timezone)
actualValue = GetTimezoneOffsetMinutes(time.Now().Unix(), timezone)
assert.Equal(t, expectedValue, actualValue)
timezone = time.FixedZone("Test Timezone", -720*60)
expectedValue = int16(-720)
actualValue = GetTimezoneOffsetMinutes(timezone)
actualValue = GetTimezoneOffsetMinutes(time.Now().Unix(), timezone)
assert.Equal(t, expectedValue, actualValue)
timezone = time.FixedZone("Test Timezone", 0)
expectedValue = int16(0)
actualValue = GetTimezoneOffsetMinutes(timezone)
actualValue = GetTimezoneOffsetMinutes(time.Now().Unix(), timezone)
assert.Equal(t, expectedValue, actualValue)
}
func TestFormatTimezoneOffset(t *testing.T) {
func TestGetTimezoneOffsetMinutes_TimezoneWithDST(t *testing.T) {
londonLocation, err := time.LoadLocation("Europe/London")
assert.Equal(t, nil, err)
// during standard time (UTC+0)
expectedValue := int16(0)
actualValue := GetTimezoneOffsetMinutes(1577858483, londonLocation) // 2020-01-01 06:01:23 +00:00
assert.Equal(t, expectedValue, actualValue)
// during daylight saving time (UTC+1)
expectedValue = int16(60)
actualValue = GetTimezoneOffsetMinutes(1619845283, londonLocation) // 2021-05-01 06:01:23 +01:00
assert.Equal(t, expectedValue, actualValue)
}
func TestFormatTimezoneOffset_FixedTimezone(t *testing.T) {
timezone := time.FixedZone("Test Timezone", 120*60)
expectedValue := "+02:00"
actualValue := FormatTimezoneOffset(timezone)
actualValue := FormatTimezoneOffset(time.Now().Unix(), timezone)
assert.Equal(t, expectedValue, actualValue)
timezone = time.FixedZone("Test Timezone", 345*60)
expectedValue = "+05:45"
actualValue = FormatTimezoneOffset(timezone)
actualValue = FormatTimezoneOffset(time.Now().Unix(), timezone)
assert.Equal(t, expectedValue, actualValue)
timezone = time.FixedZone("Test Timezone", -720*60)
expectedValue = "-12:00"
actualValue = FormatTimezoneOffset(timezone)
actualValue = FormatTimezoneOffset(time.Now().Unix(), timezone)
assert.Equal(t, expectedValue, actualValue)
timezone = time.FixedZone("Test Timezone", -150*60)
expectedValue = "-02:30"
actualValue = FormatTimezoneOffset(timezone)
actualValue = FormatTimezoneOffset(time.Now().Unix(), timezone)
assert.Equal(t, expectedValue, actualValue)
timezone = time.FixedZone("Test Timezone", 0)
expectedValue = "+00:00"
actualValue = FormatTimezoneOffset(timezone)
actualValue = FormatTimezoneOffset(time.Now().Unix(), timezone)
assert.Equal(t, expectedValue, actualValue)
}
func TestFormatTimezoneOffset_TimezoneWithDST(t *testing.T) {
londonLocation, err := time.LoadLocation("Europe/London")
assert.Equal(t, nil, err)
// during standard time (UTC+0)
expectedValue := "+00:00"
actualValue := FormatTimezoneOffset(1577858483, londonLocation) // 2020-01-01 06:01:23 +00:00
assert.Equal(t, expectedValue, actualValue)
// during daylight saving time (UTC+1)
expectedValue = "+01:00"
actualValue = FormatTimezoneOffset(1619845283, londonLocation) // 2021-05-01 06:01:23 +01:00
assert.Equal(t, expectedValue, actualValue)
}