Files
yunzerwebsiteallinone/go/pkg/holiday/fetch.go
T
2026-11-16 17:22:50 +08:00

203 lines
4.6 KiB
Go

package holiday
import (
"encoding/json"
"fmt"
"io"
"net/http"
"sync"
"time"
)
const (
sourceHolidayCNURL = "https://fastly.jsdelivr.net/gh/NateScarlet/holiday-cn@master/%d.json"
sourceHolidayCNMirrorURL = "https://raw.githubusercontent.com/NateScarlet/holiday-cn/master/%d.json"
)
var httpClient = &http.Client{Timeout: 6 * time.Second}
type holidayCNPayload struct {
Year int `json:"year"`
Days []struct {
Name string `json:"name"`
Date string `json:"date"`
IsOffDay bool `json:"isOffDay"`
} `json:"days"`
}
func fetchYearFrom(year int, url string, src string) ([]Day, error) {
body, err := httpGet(fmt.Sprintf(url, year))
if err != nil {
return nil, err
}
var p holidayCNPayload
if err := json.Unmarshal(body, &p); err != nil {
return nil, fmt.Errorf("解析 holiday-cn 数据失败: %w", err)
}
out := make([]Day, 0, len(p.Days))
for _, d := range p.Days {
if d.Date == "" {
continue
}
t := TypeWorkday
if d.IsOffDay {
t = TypeHoliday
}
name := d.Name
if name == "" {
name = "节假日"
}
out = append(out, Day{
Date: normalizeDate(d.Date),
Name: name,
Type: t,
Year: year,
Source: src,
})
}
return finalize(out), nil
}
func httpGet(url string) ([]byte, error) {
req, err := http.NewRequest(http.MethodGet, url, nil)
if err != nil {
return nil, err
}
req.Header.Set("User-Agent", "yunzer-oa/1.0")
req.Header.Set("Accept", "application/json")
resp, err := httpClient.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("HTTP %d", resp.StatusCode)
}
body, err := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
if err != nil {
return nil, err
}
trimmed := trimSpaceBytes(body)
if len(trimmed) == 0 || (trimmed[0] != '{' && trimmed[0] != '[') {
return nil, fmt.Errorf("响应不是 JSON(可能被拦截或代理改写了内容)")
}
return trimmed, nil
}
func trimSpaceBytes(b []byte) []byte {
start := 0
for start < len(b) && (b[start] == ' ' || b[start] == '\n' || b[start] == '\r' || b[start] == '\t' || b[start] == 0xEF || b[start] == 0xBB || b[start] == 0xBF) {
start++
}
end := len(b)
for end > start && (b[end-1] == ' ' || b[end-1] == '\n' || b[end-1] == '\r' || b[end-1] == '\t') {
end--
}
return b[start:end]
}
func finalize(list []Day) []Day {
out := dedupSort(list)
return annotateWage(out)
}
var (
memMu sync.RWMutex
memCache = map[int][]Day{}
)
func getMemYear(year int) ([]Day, bool) {
memMu.RLock()
defer memMu.RUnlock()
v, ok := memCache[year]
return v, ok
}
func setMemYear(year int, list []Day) {
memMu.Lock()
defer memMu.Unlock()
memCache[year] = list
}
func FetchYear(year int) (list []Day, src string, err error) {
if year < 2000 || year > 2100 {
return nil, "", fmt.Errorf("年份超出合理范围: %d", year)
}
if cached, ok := getMemYear(year); ok {
return cached, sourceOf(cached), nil
}
if builtin := builtinByYear(year); len(builtin) > 0 {
finalized := finalize(builtin)
setMemYear(year, finalized)
return finalized, SourceBuiltin, nil
}
attempts := []struct {
url string
src string
}{
{sourceHolidayCNURL, SourceHolidayCN},
{sourceHolidayCNMirrorURL, SourceHolidayCN},
}
var lastErr error
for _, a := range attempts {
got, ferr := fetchYearFrom(year, a.url, a.src)
if ferr != nil {
lastErr = ferr
continue
}
// 请求成功但数据为空,是正常状态而非失败:国务院通常在头一年 11 月
// 左右发布次年安排,此前各数据源的该年份就是空数组。
// 这里必须当作"已确认无数据"缓存下来并直接返回,
// 否则会被误判为失败、继续请求被墙的备用源,白白卡满超时(实测 6 秒)。
setMemYear(year, got)
return got, a.src, nil
}
return nil, "", fmt.Errorf("获取 %d 年节假日数据失败: %v", year, lastErr)
}
func sourceOf(list []Day) string {
if len(list) == 0 {
return ""
}
return list[0].Source
}
func EnsureRanges(start, end string) []Day {
startYear, okS := yearOf(start)
endYear, okE := yearOf(end)
if !okS || !okE || endYear < startYear {
return nil
}
out := make([]Day, 0, 64)
for y := startYear; y <= endYear; y++ {
list, _, err := FetchYear(y)
if err != nil {
continue
}
out = append(out, list...)
}
filtered := make([]Day, 0, len(out))
for _, d := range out {
if d.Date >= start && d.Date <= end {
filtered = append(filtered, d)
}
}
return finalize(filtered)
}
func yearOf(date string) (int, bool) {
if len(date) < 4 {
return 0, false
}
y, err := time.Parse("2006", date[:4])
if err != nil {
return 0, false
}
return y.Year(), true
}