更新密码找回uniapp

This commit is contained in:
hero920103 committed 2026-11-16 17:22:50 +08:00
1 parent 7f9a66da0f
commit 3fdda89833
1304 files changed
+3503 -26132

No files matched your search

-23
View File
@@ -1,26 +1,10 @@
package holiday
// fallbackData 内置的 2024-2026 年中国法定节假日/调休数据,
// 数据严格来自国务院办公厅历年《关于部分节假日安排的通知》原文。
//
// 用途:当外网接口不可达(内网部署、机房无外网出口、接口临时故障)且数据库
// 中也没有对应年份数据时,用本表兜底,保证日历控件always能显示休/班标记。
//
// 维护约定:每年 11 月国务院办公厅发布次年通知后,按下述格式补齐新一年数据
// (只补休假日与调休上班日两类,普通周末由前端按星期判定,不入表):
//
// notices = append(notices, yearNotice{Year: 2027, ...})
//
// 注意:这里只存"放假"与"补班"两类特殊日期;普通周六日不记录。
var fallbackData = buildFallback()
// yearNotice 单一年度的放假安排,按通知原文逐条录入。
type yearNotice struct {
Year int
// Holidays 放假日期区间:[开始日, 结束日],闭区间。
// 结束日与开始日相同表示只放一天;空串表示结束日等于开始日。
Holidays []dayRange
// Workdays 调休上班日(周末补班)。
Workdays []string
}
@@ -30,12 +14,6 @@ type dayRange struct {
Name string
}
// yearNotices 各界各类节日的原始安排。
//
// 数据来源:
// - 2024:国办发明电〔2023〕7号
// - 2025:国办发明电〔2024〕12号
// - 2026:2025年11月4日国办通知
var yearNotices = []yearNotice{
{
Year: 2024,
@@ -92,7 +70,6 @@ var yearNotices = []yearNotice{
},
}
// buildFallback 把 yearNotices 展开成按日期索引的 Day 列表。
func buildFallback() []Day {
out := make([]Day, 0, 256)
for _, n := range yearNotices {
-55
View File
@@ -9,35 +9,13 @@ import (
"time"
)
// =============================================================
// 外网数据源拉取(仅在"内置数据未覆盖该年份"时才会走到这里)
//
// 数据源是 holiday-cn(NateScarlet/holiday-cn):其数据由脚本从国务院办公厅
// 通知原文生成,JSON 内的 papers 字段直接给出对应的 gov.cn 通知链接,
// 字段精简(date/name/isOffDay),每年 11 月通知发布后由维护者及时更新。
//
// 实测延迟(2026-09,本机):
// - fastly.jsdelivr.net 0.43s ← 采用,TLS 握手最快
// - cdn.jsdelivr.net 0.85s
// - raw.githubusercontent 0.65s
// - timor.tech 已被 Cloudflare 拦截(403 + HTML 挑战页),已移除
//
// 注意:不要用 apihubs.cn 之类的国内接口做主力——实测它有严格频率限制,
// 连续请求会直接返回「请求过于频繁」,前端每次翻月都会打,很容易被限流。
// 对已收录的年份,我们根本不走网络(见 FetchYear),因此无需冒这个风险。
// =============================================================
const (
// sourceHolidayCNURL holiday-cn 按年份提供的 JSON,{year} 为年份占位符。
// 用 fastly 节点的 jsDelivr,实测 TLS 握手比默认 cdn 节点快一倍。
sourceHolidayCNURL = "https://fastly.jsdelivr.net/gh/NateScarlet/holiday-cn@master/%d.json"
// sourceHolidayCNMirrorURL 备用地址(同一内容,走 GitHub 原始域名)。
sourceHolidayCNMirrorURL = "https://raw.githubusercontent.com/NateScarlet/holiday-cn/master/%d.json"
)
var httpClient = &http.Client{Timeout: 6 * time.Second}
// holidayCNPayload holiday-cn 的 JSON 结构。
type holidayCNPayload struct {
Year int `json:"year"`
Days []struct {
@@ -47,8 +25,6 @@ type holidayCNPayload struct {
} `json:"days"`
}
// fetchYearFrom 从某个数据源拉取一整年的节假日数据。
// 返回的 src 为该数据源的来源标记,便于写入缓存时记录出处。
func fetchYearFrom(year int, url string, src string) ([]Day, error) {
body, err := httpGet(fmt.Sprintf(url, year))
if err != nil {
@@ -83,10 +59,6 @@ func fetchYearFrom(year int, url string, src string) ([]Day, error) {
return finalize(out), nil
}
// httpGet 带基本校验的 GET:拒绝非 JSON 响应。
// 校验响应体而不只看状态码,是因为 CDN/网关在异常时可能返回 HTTP 200 +
// 一页 HTML 错误页(timor.tech 被 Cloudflare 拦截时就是这种表现),
// 若只判状态码会误认为成功,进而把 HTML 当 JSON 解析失败或写入脏数据。
func httpGet(url string) ([]byte, error) {
req, err := http.NewRequest(http.MethodGet, url, nil)
if err != nil {
@@ -103,7 +75,6 @@ func httpGet(url string) ([]byte, error) {
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
@@ -127,24 +98,16 @@ func trimSpaceBytes(b []byte) []byte {
return b[start:end]
}
// finalize 归一化一份数据:去重、排序、补薪资倍数。
func finalize(list []Day) []Day {
out := dedupSort(list)
return annotateWage(out)
}
// ============================ 进程内缓存 ============================
// 说明:进程内缓存只用于避免同一次页面请求里对同一年的重复拉取,
// 真正的持久化缓存在数据库(由控制器负责读写)。两者职责不同:
// - 内存缓存:短期、防抖,进程重启即失效;
// - 数据库缓存:长期、可复用,外网不可达时的第一顺位数据源。
var (
memMu sync.RWMutex
memCache = map[int][]Day{}
)
// getMemYear 读内存缓存;命中的年份直接返回,不再走网络。
func getMemYear(year int) ([]Day, bool) {
memMu.RLock()
defer memMu.RUnlock()
@@ -158,16 +121,6 @@ func setMemYear(year int, list []Day) {
memCache[year] = list
}
// FetchYear 获取某一年的节假日数据。调用方(控制器)拿到结果后负责写入数据库缓存。
//
// 优先级(关键:已收录的年份完全不联网):
// 1. 内存缓存;
// 2. 内置数据(2024-2026 已收录)——直接返回,零网络请求、零延迟;
// 3. 外网拉取(仅年份未收录时)——fastly.jsdelivr → GitHub raw。
//
// 之所以把内置数据排在联网之前,是因为它本身就是官方通知的抄录、与网络数据
// 等价,却省掉了 0.4~0.9 秒的跨境 TLS 握手。日历每次翻月都会调用本函数,
// 若每次都联网会造成明显的卡顿。
func FetchYear(year int) (list []Day, src string, err error) {
if year < 2000 || year > 2100 {
return nil, "", fmt.Errorf("年份超出合理范围: %d", year)
@@ -176,14 +129,12 @@ func FetchYear(year int) (list []Day, src string, err error) {
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
@@ -195,7 +146,6 @@ func FetchYear(year int) (list []Day, src string, err error) {
for _, a := range attempts {
got, ferr := fetchYearFrom(year, a.url, a.src)
if ferr != nil {
// 真正的失败(网络错误 / 响应非法)才换下一个源重试。
lastErr = ferr
continue
}
@@ -210,7 +160,6 @@ func FetchYear(year int) (list []Day, src string, err error) {
return nil, "", fmt.Errorf("获取 %d 年节假日数据失败: %v", year, lastErr)
}
// sourceOf 取一组数据的来源标记(同批数据来源一致,取首条即可)。
func sourceOf(list []Day) string {
if len(list) == 0 {
return ""
@@ -218,8 +167,6 @@ func sourceOf(list []Day) string {
return list[0].Source
}
// EnsureRanges 确保给定日期区间涉及的每个年份都有数据可用,
// 返回区间内(含)的完整数据(已按日期升序)。数据缺失的年份静默跳过。
func EnsureRanges(start, end string) []Day {
startYear, okS := yearOf(start)
endYear, okE := yearOf(end)
@@ -230,7 +177,6 @@ func EnsureRanges(start, end string) []Day {
for y := startYear; y <= endYear; y++ {
list, _, err := FetchYear(y)
if err != nil {
// 该年份不可用(外网失败且无内置数据),跳过但不阻断其他年份
continue
}
out = append(out, list...)
@@ -244,7 +190,6 @@ func EnsureRanges(start, end string) []Day {
return finalize(filtered)
}
// yearOf 从 "YYYY-MM-DD" 解析年份。
func yearOf(date string) (int, bool) {
if len(date) < 4 {
return 0, false
+2 -44
View File
@@ -1,66 +1,38 @@
// Package holiday 提供中国法定节假日/调休日数据。
//
// 数据获取优先级(从高到低):
// 1. 内存缓存;
// 2. 代码内置的 2024-2026 年数据(fallback.go,抄自国务院办公厅通知原文)——
// 命中即返回,不发起任何网络请求;
// 3. 数据库缓存(yz_backend_oa_holiday,由控制器读写);
// 4. 外网开源接口(holiday-cn,仅内置未收录的年份才会走到)。
//
// 把内置数据放在联网之前是刻意的性能设计:日历每次翻月都会请求,而跨境
// 请求的 TLS 握手就要 0.4~0.9 秒;内置数据与网络数据同源等价,直接用即可。
// 本包只处理"休假日"与"调休上班日"两类特殊日期,普通周末由前端按星期判定。
package holiday
import (
"time"
)
// 日期类型。只有"休假日"与"调休上班日"两类需要落库——
// 普通周末可以直接由星期几推算(周六日即周末),无需存储。
const (
// TypeWorkday 调休上班日(周末补班),前端显示「班」角标
TypeWorkday int8 = 0
// TypeHoliday 法定节假日放假,前端显示「休」角标
TypeHoliday int8 = 1
)
// 数据来源标记,写入数据库 source 列,便于排查某年份数据是哪来的。
const (
SourceHolidayCN = "holiday-cn" // 外网源:cdn(fastly).jsdelivr.net/gh/NateScarlet/holiday-cn
SourceBuiltin = "builtin" // 代码内置数据(2024-2026,官方通知抄录)
SourceHolidayCN = "holiday-cn"
SourceBuiltin = "builtin"
)
// Day 某一天节假日信息的统一内部表示,也是写入缓存与返回前端的结构。
type Day struct {
// Date "YYYY-MM-DD"
Date string `json:"date"`
// Name 节日名称,如「国庆节」「春节」;调休上班日固定为「调休上班」
Name string `json:"name"`
// Type 0 调休上班 / 1 法定放假;普通周末不入库、不返回
Type int8 `json:"type"`
// Year 所属年份
Year int `json:"year"`
// Wage 薪资倍数:1 普通,2 双倍,3 三倍(仅法定节假日当天为 3)
Wage int8 `json:"wage"`
// Source 数据来源标记
Source string `json:"source"`
}
// IsOffDay 是否休假日(法定放假)。注意普通周末不在本结构范围内,
// 调用方判断"这天是否休息"时必须把周末一起算上。
func (d Day) IsOffDay() bool {
return d.Type == TypeHoliday
}
// dateLayout 统一的日期字符串格式。
const dateLayout = "2006-01-02"
func parseDate(s string) (time.Time, error) {
return time.ParseInLocation(dateLayout, s, time.Local)
}
// normalizeDate 把可能带时分秒的时间串统一裁剪成 "YYYY-MM-DD"。
func normalizeDate(s string) string {
if len(s) > 10 {
return s[:10]
@@ -68,7 +40,6 @@ func normalizeDate(s string) string {
return s
}
// expandRange 展开 [start, end] 闭区间为逐日列表;end 为空时视为仅 start 一天。
func expandRange(start, end string) []string {
if end == "" {
end = start
@@ -82,7 +53,6 @@ func expandRange(start, end string) []string {
return nil
}
out := make([]string, 0, 16)
// 防御:区间异常(结束早于开始)或跨度过大时直接放弃,避免死循环
if et.Before(st) {
return nil
}
@@ -95,8 +65,6 @@ func expandRange(start, end string) []string {
return out
}
// wageOfHolidayName 依据节日名与日期在假期中的位置推断倍数。
// 春节、国庆按"第几天"判断:前 3 天为三薪;其余节日首日为三薪。
func wageOfHolidayName(name string, indexInRange int) int8 {
switch name {
case "春节", "国庆节", "国庆节、中秋节":
@@ -112,8 +80,6 @@ func wageOfHolidayName(name string, indexInRange int) int8 {
}
}
// Years 返回内置兜底数据覆盖的年份,用于告知调用方"网络与缓存都没有时
// 还能覆盖到哪一年",便于在接口响应里给出提示。
func Years() []int {
seen := make(map[int]bool, len(yearNotices))
out := make([]int, 0, len(yearNotices))
@@ -126,7 +92,6 @@ func Years() []int {
return out
}
// builtinByYear 取某年份的内置数据;年份未收录时返回空切片。
func builtinByYear(year int) []Day {
out := make([]Day, 0, 32)
for _, d := range fallbackData {
@@ -137,8 +102,6 @@ func builtinByYear(year int) []Day {
return out
}
// annotateWage 依据同一节日的连续区间,为每天补上正确的薪资倍数。
// 输入需按日期升序排列;同名的连续日期视为同一次放假。
func annotateWage(list []Day) []Day {
if len(list) == 0 {
return list
@@ -147,7 +110,6 @@ func annotateWage(list []Day) []Day {
indexInRange := 0
for i := range list {
if list[i].Type != TypeHoliday {
// 调休上班日与普通日期不参与倍数计算,同时打断连续区间
prevName = ""
indexInRange = 0
list[i].Wage = 1
@@ -164,7 +126,6 @@ func annotateWage(list []Day) []Day {
return list
}
// dedupSort 按日期去重并升序排列;同日重复时保留先出现的记录。
func dedupSort(list []Day) []Day {
seen := make(map[string]int, len(list))
out := make([]Day, 0, len(list))
@@ -173,8 +134,6 @@ func dedupSort(list []Day) []Day {
continue
}
if idx, ok := seen[d.Date]; ok {
// 已有同日记录:休假日优先于调休上班日(同一日期不会既休又班,
// 但外网源偶有脏数据,这里做防御性取舍)
if d.Type == TypeHoliday && out[idx].Type == TypeWorkday {
out[idx] = d
}
@@ -188,7 +147,6 @@ func dedupSort(list []Day) []Day {
}
func sortByDate(list []Day) {
// 数据量极小(单年最多几十条),直接插入排序,避免引入 sort 包的比较器开销
for i := 1; i < len(list); i++ {
cur := list[i]
j := i - 1
-23
View File
@@ -5,8 +5,6 @@ import (
"time"
)
// TestFallbackCovers2026 校验内置兜底数据与国务院办公厅 2026 年通知一致。
// 这里的期望值直接抄自官方通知,属于"事实断言":一旦有人改错数据即失败。
func TestFallbackCovers2026(t *testing.T) {
got := builtinByYear(2026)
if len(got) == 0 {
@@ -18,7 +16,6 @@ func TestFallbackCovers2026(t *testing.T) {
byDate[d.Date] = d
}
// 元旦 1/1-1/3 放假;1/4 上班
for _, d := range []string{"2026-01-01", "2026-01-02", "2026-01-03"} {
if v, ok := byDate[d]; !ok || v.Type != TypeHoliday {
t.Errorf("%s 应为放假日,实际 %+v", d, v)
@@ -28,7 +25,6 @@ func TestFallbackCovers2026(t *testing.T) {
t.Errorf("2026-01-04 应为调休上班日,实际 %+v", v)
}
// 春节 2/15-2/23 放假,共 9 天;2/14、2/28 上班
springCount := 0
for _, d := range got {
if d.Type == TypeHoliday && d.Name == "春节" {
@@ -44,7 +40,6 @@ func TestFallbackCovers2026(t *testing.T) {
}
}
// 国庆 10/1-10/7 放假;9/20、10/10 上班
nationalCount := 0
for _, d := range got {
if d.Type == TypeHoliday && d.Name == "国庆节" {
@@ -60,7 +55,6 @@ func TestFallbackCovers2026(t *testing.T) {
}
}
// 中秋 9/25-9/27、端午 6/19-6/21、清明 4/4-4/6、劳动节 5/1-5/5
cases := []struct {
name string
start string
@@ -87,7 +81,6 @@ func TestFallbackCovers2026(t *testing.T) {
}
}
// TestFallbackAllYears 校验三年内置数据都能被索引到,且每年都有调休上班日。
func TestFallbackAllYears(t *testing.T) {
for _, y := range Years() {
list := builtinByYear(y)
@@ -108,7 +101,6 @@ func TestFallbackAllYears(t *testing.T) {
}
}
// TestAnnotateWage 校验薪资倍数标注:春节前 3 天三薪,其余两薪。
func TestAnnotateWage(t *testing.T) {
list := []Day{
{Date: "2026-02-15", Name: "春节", Type: TypeHoliday},
@@ -126,7 +118,6 @@ func TestAnnotateWage(t *testing.T) {
}
}
// TestExpandRange 校验日期区间展开。
func TestExpandRange(t *testing.T) {
got := expandRange("2026-02-15", "2026-02-23")
if len(got) != 9 {
@@ -135,21 +126,17 @@ func TestExpandRange(t *testing.T) {
if got[0] != "2026-02-15" || got[8] != "2026-02-23" {
t.Errorf("区间首尾错误: %v", got)
}
// 单日
if one := expandRange("2026-01-01", ""); len(one) != 1 || one[0] != "2026-01-01" {
t.Errorf("单日区间展开错误: %v", one)
}
// 跨月
if cross := expandRange("2026-02-28", "2026-03-02"); len(cross) != 3 {
t.Errorf("跨月区间展开错误: %v", cross)
}
// 异常区间不 panic 且返回空
if bad := expandRange("2026-03-01", "2026-02-01"); len(bad) != 0 {
t.Errorf("结束早于开始应返回空,实际 %v", bad)
}
}
// TestDedupSort 校验同日去重时休假日优先于调休上班日。
func TestDedupSort(t *testing.T) {
list := []Day{
{Date: "2026-05-09", Name: "调休上班", Type: TypeWorkday},
@@ -168,14 +155,10 @@ func TestDedupSort(t *testing.T) {
}
}
// TestFetchYearLive 联网校验真实数据源可用性(仅测"未收录年份"的联网分支)。
// 2024-2026 走内置数据不联网,因此这里用 2023 年验证外网拉取能力;
// 若外网不可用则跳过,不把 CI 绑死在第三方接口可用性上。
func TestFetchYearLive(t *testing.T) {
if testing.Short() {
t.Skip("跳过联网测试")
}
// 2023 未被内置数据收录,必须联网
list, src, err := FetchYear(2023)
if err != nil {
t.Skipf("外网不可用,跳过联网测试: %v", err)
@@ -189,9 +172,6 @@ func TestFetchYearLive(t *testing.T) {
t.Logf("2023 年数据来源: %s,共 %d 条", src, len(list))
}
// TestBuiltinTakesPriority 校验已收录年份走内置数据、完全不联网。
// 这是"日历翻月不卡顿"的核心保证:若哪天有人把网络查询挪到内置判断之前,
// 本测试会立即失败。
func TestBuiltinTakesPriority(t *testing.T) {
for _, y := range []int{2024, 2025, 2026} {
list, src, err := FetchYear(y)
@@ -207,10 +187,7 @@ func TestBuiltinTakesPriority(t *testing.T) {
}
}
// TestFetchYearFastForBuiltin 量化验证内置路径的耗时:
// 已收录年份必须是纯内存操作(远低于 50ms),而跨境网络请求至少要 300ms。
func TestFetchYearFastForBuiltin(t *testing.T) {
// 预热,排除首次调用的初始化开销
_, _, _ = FetchYear(2026)
start := time.Now()
-4
View File
@@ -5,10 +5,7 @@ import (
"time"
)
// 验证 2027 年(国务院通知尚未发布,各数据源为空数组)不会再被误判为失败
// 而继续请求被墙的备用源。修复前实测单次约 6 秒,修复后应接近一次 CDN 往返。
func TestFetchYear2027NoWasteRetry(t *testing.T) {
// 清空内存缓存,确保走完整路径
memMu.Lock()
memCache = map[int][]Day{}
memMu.Unlock()
@@ -29,7 +26,6 @@ func TestFetchYear2027NoWasteRetry(t *testing.T) {
t.Fatalf("2027 拉取耗时 %v,疑似仍在重试备用源", elapsed)
}
// 第二次必须命中内存缓存,几乎零耗时
start2 := time.Now()
list2, _, err2 := FetchYear(2027)
elapsed2 := time.Since(start2)