203 lines
4.6 KiB
Go
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
|
|
}
|