chore: directory migration - gateway→server, web→client/electron

This commit is contained in:
2026-09-08 19:16:35 +08:00
parent fd9f99a3f9
commit f9d757b5e5
243 changed files with 5095 additions and 228 deletions

View File

@ -0,0 +1,205 @@
// Package lunar 把公历与农历互转,并提供「按农历推进」的重复规则计算。
//
// 为什么要单独一层而不直接用 lunar-go:
//
// 1. **lunar-go 在非法日期上 panic 而不是返回 error**。
// `NewLunarFromYmd(2027, 9, 30)` 直接 panic("only 29 days in lunar
// year 2027 month 9") —— 农历月是 29 或 30 天不定,「每月农历三十」
// 这条规则必然会撞上 29 天的月份。调度器里一次 panic 就让那一轮所有
// 提醒全部落空(虽然有 recover 兜底,但结果是那一条提醒永久卡住)。
//
// 2. **闰月用负数月份表示**(-6 = 闰六月),这个约定藏在库内部。
// 2025 有闰六月、2028 有闰五月,而 2026/2027 没有 —— 「每年农历某月
// 某日」跨过闰月年份时必须决定落在哪个月,这个决策不该散落在 repo 里。
//
// 3. **按农历推进不能靠加固定天数**。农历月 29~30 天、农历年 353~385 天
// (闰年多一个月)。用 AddDate 近似会越推越偏,一年下来能差半个月。
package lunar
import (
"fmt"
"time"
"github.com/6tail/lunar-go/calendar"
)
// Date 是一个农历日期。
//
// Month 为负数表示闰月(-6 = 闰六月),与 lunar-go 的约定一致 ——
// 刻意沿用而不另造一个 IsLeap bool:两种表示混用时转换处极易写反,
// 而负数在数值比较里天然排在正数前面(闰六月在六月之后,需要注意这一点,
// 见 monthsInYear 的排序)。
type Date struct {
Year int
Month int // 负数 = 闰月
Day int
}
// FromSolar 把公历时刻转成农历日期。
//
// 只取年月日,时分秒由调用方保留 —— 农历只定义到「日」,
// 「农历七月十五早上九点」的「九点」是公历时钟的概念。
func FromSolar(t time.Time) Date {
s := calendar.NewSolarFromYmd(t.Year(), int(t.Month()), t.Day())
l := s.GetLunar()
return Date{Year: l.GetYear(), Month: l.GetMonth(), Day: l.GetDay()}
}
// ToSolar 把农历日期转回公历,并带上给定的时分秒。
//
// **日期会被夹到该农历月的实际天数内**:请求农历三十而该月只有 29 天时
// 返回廿九,而不是 panic 也不是滚到下个月的初一。
//
// 夹而不滚的理由:「每月农历三十」的语义是「月末那天」,滚到下月初一会让
// 提醒出现在完全错误的日子(且与前一次提醒只隔一天)。
//
// 返回的 clamped 说明是否发生了夹取 —— 调用方据此决定是否要在 UI 上提示。
func (d Date) ToSolar(loc *time.Location, hour, min, sec, nsec int) (t time.Time, clamped bool, err error) {
days, err := DaysInMonth(d.Year, d.Month)
if err != nil {
return time.Time{}, false, err
}
day := d.Day
if day > days {
day = days
clamped = true
}
if day < 1 {
return time.Time{}, false, fmt.Errorf("农历日 %d 非法", d.Day)
}
// lunar-go 在非法输入上 panic,这里兜住转成 error:
// 上面已经夹过日期,理论上不会触发,但闰月不存在之类的组合仍可能进来。
var solar *calendar.Solar
func() {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("农历 %d-%d-%d 无法转公历: %v", d.Year, d.Month, day, r)
}
}()
solar = calendar.NewLunarFromYmd(d.Year, d.Month, day).GetSolar()
}()
if err != nil {
return time.Time{}, false, err
}
if solar == nil {
return time.Time{}, false, fmt.Errorf("农历 %d-%d-%d 转公历得到空值", d.Year, d.Month, day)
}
return time.Date(solar.GetYear(), time.Month(solar.GetMonth()), solar.GetDay(),
hour, min, sec, nsec, loc), clamped, nil
}
// DaysInMonth 返回某个农历月有多少天(29 或 30)。
//
// Month 为负数时查闰月。该年没有这个闰月则返回错误 ——
// 这不是异常情况:「每年农历闰六月十五」这条规则在没有闰六月的年份
// 本来就无法落地,调用方需要据此跳过而不是猜一个日子。
func DaysInMonth(year, month int) (int, error) {
var days int
var found bool
// LunarYear.GetMonths() 是 *list.List,元素为 *LunarMonth。
// 一个 LunarYear 对象里会带上跨年边界的月份,因此必须同时比对 year。
ly := calendar.NewLunarYear(year)
for e := ly.GetMonths().Front(); e != nil; e = e.Next() {
lm, ok := e.Value.(*calendar.LunarMonth)
if !ok {
continue
}
if lm.GetYear() == year && lm.GetMonth() == month {
days = lm.GetDayCount()
found = true
break
}
}
if !found {
if month < 0 {
return 0, fmt.Errorf("农历 %d 年没有闰 %d 月", year, -month)
}
return 0, fmt.Errorf("农历 %d 年没有 %d 月", year, month)
}
return days, nil
}
// LeapMonth 返回某农历年的闰月(0 = 无闰月)。
func LeapMonth(year int) int {
return calendar.NewLunarYear(year).GetLeapMonth()
}
// AddMonths 在农历上推进若干个月。
//
// 逐月走而不是「月份数 + n 再取模」:中间可能夹着闰月,
// 而闰月是否存在取决于年份,没有闭式公式。
//
// 闰月的处理:**推进时跳过闰月**。从六月推一个月得七月,不是闰六月。
// 理由是「每月十五」这类规则的用户期望是一年 12 次,
// 把闰月算进去会让闰年多出一次提醒 —— 那是农历年的性质,不是提醒的性质。
// 想要闰月本身的提醒应该用 lunar_yearly 指定 -6 月。
func (d Date) AddMonths(n int) Date {
y, m := d.Year, d.Month
// 从闰月出发时先归到对应的正月份:闰六月 +1 → 七月
if m < 0 {
m = -m
}
for i := 0; i < n; i++ {
m++
if m > 12 {
m = 1
y++
}
}
return Date{Year: y, Month: m, Day: d.Day}
}
// AddYears 在农历上推进若干年,月份与日期保持不变。
//
// 从闰月出发时(Month < 0)目标年没有同一个闰月,退回对应的正月份 ——
// 「去年闰六月十五」在今年最接近的对应日就是六月十五。
// 直接放弃(不再提醒)更糟:那是静默地让重复事件消失。
func (d Date) AddYears(n int) Date {
y := d.Year + n
m := d.Month
if m < 0 && LeapMonth(y) != -m {
m = -m
}
return Date{Year: y, Month: m, Day: d.Day}
}
// String 给出「二〇二六年七月廿二」这样的中文农历表示。
//
// UI 上必须显示它:农历事件的公历日期每年都在变,
// 只显示公历会让人无法确认「这条规则是不是我想的那个农历日子」。
func (d Date) String() string {
days, err := DaysInMonth(d.Year, d.Month)
if err != nil {
return fmt.Sprintf("农历 %d 年%d月%d日(无效)", d.Year, d.Month, d.Day)
}
day := d.Day
if day > days {
day = days
}
var out string
func() {
defer func() {
if r := recover(); r != nil {
out = fmt.Sprintf("农历 %d-%d-%d", d.Year, d.Month, d.Day)
}
}()
out = calendar.NewLunarFromYmd(d.Year, d.Month, day).String()
}()
return out
}
// FormatSolar 把公历时刻渲染成「2026-09-03(农历七月廿二)」。
//
// 给提醒正文与 UI 用:两种历都写出来,人才能确认规则没被理解错。
func FormatSolar(t time.Time) string {
d := FromSolar(t)
full := d.String()
// 去掉年份部分(「二〇二六年」共 4 个中文字符 + 「年」),只留月日 ——
// 公历年份已经在前面写了,重复一遍反而更难读。
if r := []rune(full); len(r) > 5 && r[4] == '年' {
full = string(r[5:])
}
return fmt.Sprintf("%s(农历%s)", t.Format("2006-01-02"), full)
}