chun_qiu
bc5076ee41
- 触控小键盘补回 3×4 网格样式：上一版重写 CSS 时漏掉了 .keypad/.key， 按钮退化成行内小方块；现在恢复 46px 圆角键、⌫/✓ 功能键和「触控」开关态。 - 通行证（原「包赛季」）：整段有效期在独立日历上按套餐色连续着色（18% 透明度）， 每一格显示同一个「已完成 / 总单数」（0/1 或 1/1）；完成后色块保留并显示 1/1。 沿用 season_done 记录完成日期，交互动线不变。 - 新增深渊模式：套餐设置周期天数 N 与周期数 X；开通时从开始日排出 X 个 N 天周期， 结束日 = 开始日 + N×X − 1。周期内任意一天完成即算该周期完成；同一周期重复完成 不重复计数；撤销该周期最后一条完成打卡会回退计数。独立日历连续着色，每格显示 同一个「已完成周期 / 总周期数」。 - 全量把「包赛季」改名为「通行证」；套餐表单新增通行证 / 深渊选项，深渊显示 N/X 字段； 客户开通表单、套餐批量开通、订阅列表、客户订阅卡片、日历待办行同步适配， 通行证 / 深渊不再显示「追加时长」（提交也会被服务端拒绝）。 - 快速完成 / 批量完成对通行证改为整段完成，对深渊走周期打卡，不再错误地按日写打卡。 - 配色改为淡蓝 / 暗蓝：亮色用暗蓝主色 + 淡蓝纸底，暗色用海军蓝底 + 淡蓝强调； 默认套餐色改为 #3B6EA5；大屏同步蓝调并修正热力图例与今日数字的对比度。 - 大屏页签排除通行证 / 深渊（它们不计每日热力，避免点开是空日历）；「今日待打」 仍会列出待处理的通行证 / 深渊。 - 数据迁移：packages.abyss / packages.cycle_days / subscriptions.abyss / subscriptions.cycle_days，老库启动自动补列。 - 修复手机端整段色块把 7 列日历撑出屏幕：日历改成 minmax(0,1fr)，小屏色块缩小。 - 版本号 1.10.0 → 1.11.0。 验证：gofmt / go vet / go test 全绿；亮暗两套、1440 与 390 两档截图走查； 通行证 0/1 → 1/1、深渊 1/4 → 2/4、同周期重复完成不重复计数、撤销回退均实测通过。
711 lines
22 KiB
Go
711 lines
22 KiB
Go
package store
|
|
|
|
import (
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
"daili/internal/domain"
|
|
)
|
|
|
|
// Subscription 服务订阅。
|
|
type Subscription struct {
|
|
ID int64
|
|
CustomerID int64
|
|
PackageID int64
|
|
Unit string
|
|
Status string
|
|
StartDate string
|
|
EndDate string
|
|
TotalCount int
|
|
UsedCount int
|
|
Note string
|
|
CreatedBy int64
|
|
CreatedAt string
|
|
UpdatedAt string
|
|
ClosedAt string
|
|
// Season 通行证；SeasonDone 标记整段完成的日期（空=未完成）
|
|
Season bool
|
|
SeasonDone string
|
|
// Abyss 深渊模式：CycleDays 天一个周期，TotalCount 是周期总数
|
|
Abyss bool
|
|
CycleDays int
|
|
|
|
// 联表
|
|
PackageName string
|
|
PackageColor string
|
|
CustomerTail string
|
|
CustomerName string
|
|
CustomerContact string
|
|
|
|
// 客户归属的打手（管理员）
|
|
AssigneeID int64
|
|
AssigneeName string
|
|
AssigneeColor string
|
|
}
|
|
|
|
// Eval 计算展示状态。
|
|
func (s *Subscription) Eval(today time.Time, warnDays int) domain.Eval {
|
|
return domain.EvalSub(s.Unit, s.Status, s.StartDate, s.EndDate, s.TotalCount, s.UsedCount, today, warnDays)
|
|
}
|
|
|
|
// IsCount 是否按次套餐。
|
|
func (s *Subscription) IsCount() bool { return s.Unit == domain.UnitCount }
|
|
|
|
// IsBlock 是否整段型（通行证 / 深渊）：日历上按连续色块展示，不按天计任务。
|
|
func (s *Subscription) IsBlock() bool { return s.Season || s.Abyss }
|
|
|
|
// BlockTotal 返回整段型订阅的总单数：通行证固定 1，深渊为周期数。
|
|
func (s *Subscription) BlockTotal() int {
|
|
if s.Season {
|
|
return 1
|
|
}
|
|
if s.Abyss {
|
|
return s.TotalCount
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// BlockDone 返回整段型订阅的已完成单数：通行证看完成标记，深渊看已完成周期数。
|
|
func (s *Subscription) BlockDone() int {
|
|
if s.Season {
|
|
if s.SeasonDone != "" {
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
if s.Abyss {
|
|
return s.UsedCount
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// Pause 暂停分段。
|
|
type Pause struct {
|
|
ID int64
|
|
SubID int64
|
|
StartAt string
|
|
EndAt string
|
|
StartDate string
|
|
EndDate string
|
|
}
|
|
|
|
// Adjustment 追加记录。
|
|
type Adjustment struct {
|
|
ID int64
|
|
SubID int64
|
|
Kind string
|
|
BaseDate string
|
|
OldEndDate string
|
|
NewEndDate string
|
|
DaysAdded int
|
|
CountAdded int
|
|
OldTotal int
|
|
NewTotal int
|
|
Note string
|
|
OperatorID int64
|
|
OperatorName string
|
|
CreatedAt string
|
|
|
|
// 联表
|
|
CustomerTail string
|
|
CustomerName string
|
|
PackageName string
|
|
}
|
|
|
|
// KindLabel 返回追加类型的中文名。
|
|
func (a *Adjustment) KindLabel() string {
|
|
switch a.Kind {
|
|
case "initial":
|
|
return "开通"
|
|
case "extend_days":
|
|
return "追加天数"
|
|
case "add_count":
|
|
return "追加次数"
|
|
case "set_end_date":
|
|
return "调整结束日"
|
|
}
|
|
return "调整"
|
|
}
|
|
|
|
const subSelect = `SELECT s.id,s.customer_id,s.package_id,s.unit,s.status,s.start_date,IFNULL(s.end_date,''),
|
|
s.total_count,s.used_count,s.note,IFNULL(s.created_by,0),s.created_at,s.updated_at,IFNULL(s.closed_at,''),
|
|
IFNULL(s.season,0),IFNULL(s.season_done,''),IFNULL(s.abyss,0),IFNULL(s.cycle_days,0),
|
|
p.name,p.color,c.tail,c.name,IFNULL(c.contact,''),
|
|
IFNULL(c.assignee_id,0),
|
|
IFNULL((SELECT u.display_name FROM users u WHERE u.id=c.assignee_id),''),
|
|
IFNULL((SELECT u.color FROM users u WHERE u.id=c.assignee_id),'')
|
|
FROM subscriptions s
|
|
JOIN packages p ON p.id=s.package_id
|
|
JOIN customers c ON c.id=s.customer_id`
|
|
|
|
func scanSub(row interface{ Scan(dest ...any) error }) (*Subscription, error) {
|
|
var s Subscription
|
|
var seasonInt, abyssInt, cycleDays int
|
|
err := row.Scan(&s.ID, &s.CustomerID, &s.PackageID, &s.Unit, &s.Status, &s.StartDate, &s.EndDate,
|
|
&s.TotalCount, &s.UsedCount, &s.Note, &s.CreatedBy, &s.CreatedAt, &s.UpdatedAt, &s.ClosedAt,
|
|
&seasonInt, &s.SeasonDone, &abyssInt, &cycleDays,
|
|
&s.PackageName, &s.PackageColor, &s.CustomerTail, &s.CustomerName, &s.CustomerContact,
|
|
&s.AssigneeID, &s.AssigneeName, &s.AssigneeColor)
|
|
if err != nil {
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return nil, ErrNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
s.Season = seasonInt == 1
|
|
s.Abyss = abyssInt == 1
|
|
s.CycleDays = cycleDays
|
|
return &s, nil
|
|
}
|
|
|
|
// Sub 取单个订阅。
|
|
func (db *DB) Sub(id int64) (*Subscription, error) {
|
|
return scanSub(db.sql.QueryRow(subSelect+` WHERE s.id=?`, id))
|
|
}
|
|
|
|
// SubsByCustomer 取某客户的订阅。
|
|
func (db *DB) SubsByCustomer(customerID int64) ([]Subscription, error) {
|
|
return db.querySubs(subSelect+` WHERE s.customer_id=? ORDER BY s.status, s.id`, customerID)
|
|
}
|
|
|
|
// SubsByCustomers 批量取订阅（客户列表聚合用）。
|
|
func (db *DB) SubsByCustomers(ids []int64) ([]Subscription, error) {
|
|
if len(ids) == 0 {
|
|
return nil, nil
|
|
}
|
|
ph := placeholders(len(ids))
|
|
args := make([]any, len(ids))
|
|
for i, id := range ids {
|
|
args[i] = id
|
|
}
|
|
return db.querySubs(subSelect+` WHERE s.customer_id IN (`+ph+`) ORDER BY s.id`, args...)
|
|
}
|
|
|
|
func (db *DB) querySubs(q string, args ...any) ([]Subscription, error) {
|
|
rows, err := db.sql.Query(q, args...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
out := []Subscription{}
|
|
for rows.Next() {
|
|
s, err := scanSub(rows)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, *s)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
func placeholders(n int) string {
|
|
if n <= 0 {
|
|
return ""
|
|
}
|
|
return strings.TrimSuffix(strings.Repeat("?,", n), ",")
|
|
}
|
|
|
|
// SubFilter 订阅列表筛选。
|
|
type SubFilter struct {
|
|
Q string
|
|
State string
|
|
PackageID int64
|
|
Limit int
|
|
Offset int
|
|
Today time.Time
|
|
}
|
|
|
|
const expiredExpr = `((s.unit='day' AND s.end_date < ?) OR (s.unit='count' AND (s.used_count>=s.total_count OR (IFNULL(s.end_date,'')<>'' AND s.end_date < ?))))`
|
|
|
|
// ListSubs 分页查询订阅。
|
|
func (db *DB) ListSubs(f SubFilter) ([]Subscription, int, error) {
|
|
where := []string{"1=1"}
|
|
args := []any{}
|
|
today := domain.Date(f.Today)
|
|
if q := strings.TrimSpace(f.Q); q != "" {
|
|
like := "%" + q + "%"
|
|
where = append(where, "(c.tail LIKE ? OR c.name LIKE ? OR p.name LIKE ?)")
|
|
args = append(args, like, like, like)
|
|
}
|
|
if f.PackageID > 0 {
|
|
where = append(where, "s.package_id=?")
|
|
args = append(args, f.PackageID)
|
|
}
|
|
switch f.State {
|
|
case "active":
|
|
where = append(where, "s.status='active'", "NOT "+expiredExpr)
|
|
args = append(args, today, today)
|
|
case "paused":
|
|
where = append(where, "s.status='paused'")
|
|
case "closed":
|
|
where = append(where, "s.status='closed'")
|
|
case "expired":
|
|
where = append(where, "s.status<>'closed'", expiredExpr)
|
|
args = append(args, today, today)
|
|
case "due7":
|
|
where = append(where, "s.status<>'closed'", "s.end_date IS NOT NULL", "s.end_date BETWEEN ? AND ?")
|
|
args = append(args, today, domain.Date(domain.AddDays(f.Today, 6)))
|
|
case "due3":
|
|
where = append(where, "s.status<>'closed'", "s.end_date IS NOT NULL", "s.end_date BETWEEN ? AND ?")
|
|
args = append(args, today, domain.Date(domain.AddDays(f.Today, 2)))
|
|
case "due_today":
|
|
where = append(where, "s.status<>'closed'", "s.end_date = ?")
|
|
args = append(args, today)
|
|
}
|
|
w := strings.Join(where, " AND ")
|
|
var total int
|
|
if err := db.sql.QueryRow(`SELECT COUNT(*) FROM subscriptions s
|
|
JOIN packages p ON p.id=s.package_id JOIN customers c ON c.id=s.customer_id WHERE `+w, args...).Scan(&total); err != nil {
|
|
return nil, 0, err
|
|
}
|
|
lim := f.Limit
|
|
if lim <= 0 {
|
|
lim = 30
|
|
}
|
|
q := subSelect + ` WHERE ` + w + ` ORDER BY s.status, IFNULL(s.end_date,'9999-12-31'), s.id DESC LIMIT ? OFFSET ?`
|
|
subs, err := db.querySubs(q, append(args, lim, f.Offset)...)
|
|
return subs, total, err
|
|
}
|
|
|
|
// CalendarSubs 取与 [from,to] 日期区间相交的订阅（用于日历）。
|
|
func (db *DB) CalendarSubs(from, to string) ([]Subscription, error) {
|
|
return db.querySubs(subSelect+` WHERE s.status<>'closed' AND IFNULL(c.archived,0)=0
|
|
AND s.start_date <= ? AND IFNULL(s.end_date,'')<>'' AND s.end_date >= ?
|
|
ORDER BY s.id`, to, from)
|
|
}
|
|
|
|
// DueOn 某天到期的订阅。
|
|
func (db *DB) DueOn(date string) ([]Subscription, error) {
|
|
return db.querySubs(subSelect+` WHERE s.status<>'closed' AND IFNULL(c.archived,0)=0 AND s.end_date=? ORDER BY s.id`, date)
|
|
}
|
|
|
|
// CreateSubInput 新建订阅入参。
|
|
type CreateSubInput struct {
|
|
CustomerID int64
|
|
PackageID int64
|
|
StartDate string
|
|
EndDate string
|
|
Days int
|
|
TotalCount int
|
|
Note string
|
|
OperatorID int64
|
|
}
|
|
|
|
// CreateSub 新建订阅，并写入初始追加记录。
|
|
func (db *DB) CreateSub(in CreateSubInput) (*Subscription, error) {
|
|
pkg, err := db.Package(in.PackageID)
|
|
if err != nil {
|
|
return nil, errors.New("套餐不存在")
|
|
}
|
|
if pkg.Archived {
|
|
return nil, errors.New("该套餐已归档，不能新建订阅")
|
|
}
|
|
if pkg.Season && strings.TrimSpace(in.StartDate) == "" {
|
|
in.StartDate = pkg.SeasonStart
|
|
}
|
|
start, err := domain.ParseDate(in.StartDate)
|
|
if err != nil {
|
|
return nil, errors.New("开始日期格式不正确")
|
|
}
|
|
unit := pkg.Unit
|
|
endDate := ""
|
|
days := 0
|
|
total := 0
|
|
if unit == domain.UnitDay {
|
|
days = in.Days
|
|
if days <= 0 {
|
|
days = pkg.DefaultAmount
|
|
}
|
|
if days <= 0 {
|
|
days = 30
|
|
}
|
|
if in.EndDate != "" {
|
|
end, err := domain.ParseDate(in.EndDate)
|
|
if err != nil {
|
|
return nil, errors.New("结束日期格式不正确")
|
|
}
|
|
if domain.DayDiff(start, end) < 0 {
|
|
return nil, errors.New("结束日期不能早于开始日期")
|
|
}
|
|
endDate = domain.Date(end)
|
|
days = domain.DayDiff(start, end) + 1
|
|
} else {
|
|
endDate = domain.Date(domain.AddDays(start, days-1))
|
|
}
|
|
} else {
|
|
total = in.TotalCount
|
|
if total <= 0 {
|
|
total = pkg.DefaultAmount
|
|
}
|
|
if total <= 0 {
|
|
return nil, errors.New("总次数必须大于 0")
|
|
}
|
|
if in.EndDate != "" {
|
|
end, err := domain.ParseDate(in.EndDate)
|
|
if err != nil {
|
|
return nil, errors.New("有效期格式不正确")
|
|
}
|
|
if domain.DayDiff(start, end) < 0 {
|
|
return nil, errors.New("有效期不能早于开始日期")
|
|
}
|
|
endDate = domain.Date(end)
|
|
} else if pkg.DefaultValidityDays > 0 {
|
|
endDate = domain.Date(domain.AddDays(start, pkg.DefaultValidityDays-1))
|
|
}
|
|
}
|
|
if pkg.Abyss {
|
|
if pkg.CycleDays <= 0 {
|
|
return nil, errors.New("该深渊套餐未设置周期天数")
|
|
}
|
|
total = in.TotalCount
|
|
if total <= 0 {
|
|
total = pkg.DefaultAmount
|
|
}
|
|
if total <= 0 {
|
|
total = 1
|
|
}
|
|
endDate = domain.Date(domain.AddDays(start, pkg.CycleDays*total-1))
|
|
unit = domain.UnitDay
|
|
days = pkg.CycleDays * total
|
|
} else if pkg.Season {
|
|
if pkg.SeasonStart == "" || pkg.SeasonEnd == "" {
|
|
return nil, errors.New("该通行证套餐未设置起止日期")
|
|
}
|
|
end, err := domain.ParseDate(pkg.SeasonEnd)
|
|
if err != nil {
|
|
return nil, errors.New("通行证结束日期不正确")
|
|
}
|
|
if domain.DayDiff(domain.Today(), end) < 0 {
|
|
return nil, errors.New("该通行证已结束，不能开通")
|
|
}
|
|
if domain.DayDiff(start, end) < 0 {
|
|
return nil, errors.New("通行证结束日期早于开始日期")
|
|
}
|
|
endDate = domain.Date(end)
|
|
unit = domain.UnitDay
|
|
days = domain.DayDiff(start, end) + 1
|
|
}
|
|
|
|
now := nowStamp()
|
|
var id int64
|
|
err = db.withTx(func(tx *sql.Tx) error {
|
|
var existing int64
|
|
err := tx.QueryRow(`SELECT id FROM subscriptions WHERE customer_id=? AND package_id=?`,
|
|
in.CustomerID, in.PackageID).Scan(&existing)
|
|
if err == nil {
|
|
return errors.New("该客户已订阅此套餐，请改用「追加时长」")
|
|
}
|
|
if !errors.Is(err, sql.ErrNoRows) {
|
|
return err
|
|
}
|
|
res, err := tx.Exec(`INSERT INTO subscriptions(customer_id,package_id,unit,status,start_date,end_date,total_count,used_count,note,created_by,created_at,updated_at,season,abyss,cycle_days)
|
|
VALUES(?,?,?,'active',?,?,?,0,?,?,?,?,?,?,?)`,
|
|
in.CustomerID, in.PackageID, unit, domain.Date(start), nullIfEmpty(endDate), total, in.Note, nullIfZero(in.OperatorID), now, now, b2i(pkg.Season), b2i(pkg.Abyss), pkg.CycleDays)
|
|
if err != nil {
|
|
if isUnique(err) {
|
|
return errors.New("该客户已订阅此套餐，请改用「追加时长」")
|
|
}
|
|
return err
|
|
}
|
|
id, _ = res.LastInsertId()
|
|
_, err = tx.Exec(`INSERT INTO sub_adjustments(sub_id,kind,base_date,old_end_date,new_end_date,days_added,count_added,old_total,new_total,note,operator_id,created_at)
|
|
VALUES(?,?,?,?,?,?,?,?,?,?,?,?)`,
|
|
id, "initial", domain.Date(start), "", nullIfEmpty(endDate), days, 0, 0, total, "新建订阅", nullIfZero(in.OperatorID), now)
|
|
return err
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return db.Sub(id)
|
|
}
|
|
|
|
func nullIfEmpty(s string) any {
|
|
if s == "" {
|
|
return nil
|
|
}
|
|
return s
|
|
}
|
|
|
|
// ExtendDays 按日追加：手动指定新的结束日，自动换算计算起点与追加天数。
|
|
func (db *DB) ExtendDays(subID int64, newEndDate, note string, operatorID int64) (domain.ExtendPlan, error) {
|
|
var plan domain.ExtendPlan
|
|
today := domain.Today()
|
|
newEnd, err := domain.ParseDate(newEndDate)
|
|
if err != nil {
|
|
return plan, errors.New("请选择新的终止日期")
|
|
}
|
|
err = db.withTx(func(tx *sql.Tx) error {
|
|
s, err := scanSub(tx.QueryRow(subSelect+` WHERE s.id=?`, subID))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if s.Unit != domain.UnitDay {
|
|
return errors.New("该订阅按次计费，请使用「追加次数」")
|
|
}
|
|
if s.Status == domain.StatusClosed {
|
|
return errors.New("订阅已结束，请先「重新启用」")
|
|
}
|
|
oldEnd := domain.ParseDateOr(s.EndDate, today)
|
|
plan = domain.PlanExtend(oldEnd, newEnd, today)
|
|
if plan.Backwards {
|
|
return fmt.Errorf("所选日期早于计算起点 %s，不会增加时长", domain.Date(plan.Base))
|
|
}
|
|
status := s.Status
|
|
if status == domain.StatusPaused {
|
|
status = domain.StatusActive
|
|
}
|
|
if _, err := tx.Exec(`UPDATE subscriptions SET end_date=?, status=?, updated_at=? WHERE id=?`,
|
|
domain.Date(newEnd), status, nowStamp(), subID); err != nil {
|
|
return err
|
|
}
|
|
_, err = tx.Exec(`INSERT INTO sub_adjustments(sub_id,kind,base_date,old_end_date,new_end_date,days_added,count_added,old_total,new_total,note,operator_id,created_at)
|
|
VALUES(?,?,?,?,?,?,0,0,0,?,?,?)`,
|
|
subID, "extend_days", domain.Date(plan.Base), s.EndDate, domain.Date(newEnd), plan.Days, note, nullIfZero(operatorID), nowStamp())
|
|
return err
|
|
})
|
|
return plan, err
|
|
}
|
|
|
|
// AddCount 按次追加次数（可同时调整有效期）。
|
|
func (db *DB) AddCount(subID int64, add int, newEndDate, note string, operatorID int64) error {
|
|
if add <= 0 {
|
|
return errors.New("追加次数必须大于 0")
|
|
}
|
|
err := db.withTx(func(tx *sql.Tx) error {
|
|
s, err := scanSub(tx.QueryRow(subSelect+` WHERE s.id=?`, subID))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if s.Unit != domain.UnitCount {
|
|
return errors.New("该订阅按日计费，请使用「追加天数」")
|
|
}
|
|
if s.Status == domain.StatusClosed {
|
|
return errors.New("订阅已结束，请先「重新启用」")
|
|
}
|
|
endDate := s.EndDate
|
|
if newEndDate != "" {
|
|
end, err := domain.ParseDate(newEndDate)
|
|
if err != nil {
|
|
return errors.New("有效期格式不正确")
|
|
}
|
|
if end.Before(domain.ParseDateOr(s.StartDate, domain.Today())) {
|
|
return errors.New("有效期不能早于开始日期")
|
|
}
|
|
endDate = domain.Date(end)
|
|
}
|
|
status := s.Status
|
|
if status == domain.StatusPaused {
|
|
status = domain.StatusActive
|
|
}
|
|
newTotal := s.TotalCount + add
|
|
if _, err := tx.Exec(`UPDATE subscriptions SET total_count=?, end_date=?, status=?, updated_at=? WHERE id=?`,
|
|
newTotal, nullIfEmpty(endDate), status, nowStamp(), subID); err != nil {
|
|
return err
|
|
}
|
|
_, err = tx.Exec(`INSERT INTO sub_adjustments(sub_id,kind,old_end_date,new_end_date,days_added,count_added,old_total,new_total,note,operator_id,created_at)
|
|
VALUES(?,?,?,?,0,?,?,?,?,?,?)`,
|
|
subID, "add_count", s.EndDate, endDate, add, s.TotalCount, newTotal, note, nullIfZero(operatorID), nowStamp())
|
|
return err
|
|
})
|
|
return err
|
|
}
|
|
|
|
// PauseSub 暂停订阅。
|
|
func (db *DB) PauseSub(subID, operatorID int64) error {
|
|
return db.withTx(func(tx *sql.Tx) error {
|
|
s, err := scanSub(tx.QueryRow(subSelect+` WHERE s.id=?`, subID))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if s.Status == domain.StatusPaused {
|
|
return errors.New("订阅已处于暂停状态")
|
|
}
|
|
if s.Status == domain.StatusClosed {
|
|
return errors.New("订阅已结束，无法暂停")
|
|
}
|
|
now := nowStamp()
|
|
if _, err := tx.Exec(`INSERT INTO sub_pauses(sub_id,start_at) VALUES(?,?)`, subID, now); err != nil {
|
|
return err
|
|
}
|
|
_, err = tx.Exec(`UPDATE subscriptions SET status='paused', updated_at=? WHERE id=?`, now, subID)
|
|
return err
|
|
})
|
|
}
|
|
|
|
// ResumeSub 恢复订阅，按日套餐顺延结束日，返回顺延天数。
|
|
func (db *DB) ResumeSub(subID, operatorID int64) (int, error) {
|
|
var shift int
|
|
today := domain.Today()
|
|
err := db.withTx(func(tx *sql.Tx) error {
|
|
s, err := scanSub(tx.QueryRow(subSelect+` WHERE s.id=?`, subID))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if s.Status != domain.StatusPaused {
|
|
return errors.New("订阅未处于暂停状态")
|
|
}
|
|
var startAt string
|
|
err = tx.QueryRow(`SELECT start_at FROM sub_pauses WHERE sub_id=? AND end_at IS NULL ORDER BY id DESC LIMIT 1`, subID).Scan(&startAt)
|
|
if err != nil && !errors.Is(err, sql.ErrNoRows) {
|
|
return err
|
|
}
|
|
if err == nil {
|
|
ps := domain.ParseDateOr(startAt[:10], today)
|
|
shift = domain.DayDiff(ps, today)
|
|
if shift < 0 {
|
|
shift = 0
|
|
}
|
|
}
|
|
now := nowStamp()
|
|
if _, err := tx.Exec(`UPDATE sub_pauses SET end_at=? WHERE sub_id=? AND end_at IS NULL`, now, subID); err != nil {
|
|
return err
|
|
}
|
|
if s.Unit == domain.UnitDay && shift > 0 {
|
|
oldEnd := domain.ParseDateOr(s.EndDate, today)
|
|
if _, err := tx.Exec(`UPDATE subscriptions SET end_date=? WHERE id=?`,
|
|
domain.Date(domain.AddDays(oldEnd, shift)), subID); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
_, err = tx.Exec(`UPDATE subscriptions SET status='active', updated_at=? WHERE id=?`, now, subID)
|
|
return err
|
|
})
|
|
return shift, err
|
|
}
|
|
|
|
// CloseSub 结束订阅。
|
|
func (db *DB) CloseSub(subID int64) error {
|
|
now := nowStamp()
|
|
_, err := db.sql.Exec(`UPDATE subscriptions SET status='closed', closed_at=?, updated_at=? WHERE id=? AND status<>'closed'`,
|
|
now, now, subID)
|
|
return err
|
|
}
|
|
|
|
// ReopenSub 重新启用已结束的订阅。
|
|
func (db *DB) ReopenSub(subID int64) error {
|
|
_, err := db.sql.Exec(`UPDATE subscriptions SET status='active', closed_at=NULL, updated_at=? WHERE id=?`, nowStamp(), subID)
|
|
return err
|
|
}
|
|
|
|
// AdjustmentsBySub 取某订阅的追加记录（新→旧）。
|
|
func (db *DB) AdjustmentsBySub(subID int64) ([]Adjustment, error) {
|
|
return db.queryAdjustments(`SELECT a.id,a.sub_id,a.kind,IFNULL(a.base_date,''),IFNULL(a.old_end_date,''),IFNULL(a.new_end_date,''),
|
|
a.days_added,a.count_added,a.old_total,a.new_total,a.note,IFNULL(a.operator_id,0),IFNULL(u.display_name,''),a.created_at,
|
|
c.tail,c.name,p.name
|
|
FROM sub_adjustments a
|
|
LEFT JOIN users u ON u.id=a.operator_id
|
|
JOIN subscriptions s ON s.id=a.sub_id
|
|
JOIN customers c ON c.id=s.customer_id
|
|
JOIN packages p ON p.id=s.package_id
|
|
WHERE a.sub_id=? ORDER BY a.id DESC`, subID)
|
|
}
|
|
|
|
// RecentAdjustments 最近追加记录。
|
|
func (db *DB) RecentAdjustments(limit int) ([]Adjustment, error) {
|
|
return db.queryAdjustments(`SELECT a.id,a.sub_id,a.kind,IFNULL(a.base_date,''),IFNULL(a.old_end_date,''),IFNULL(a.new_end_date,''),
|
|
a.days_added,a.count_added,a.old_total,a.new_total,a.note,IFNULL(a.operator_id,0),IFNULL(u.display_name,''),a.created_at,
|
|
c.tail,c.name,p.name
|
|
FROM sub_adjustments a
|
|
LEFT JOIN users u ON u.id=a.operator_id
|
|
JOIN subscriptions s ON s.id=a.sub_id
|
|
JOIN customers c ON c.id=s.customer_id
|
|
JOIN packages p ON p.id=s.package_id
|
|
ORDER BY a.id DESC LIMIT ?`, limit)
|
|
}
|
|
|
|
func (db *DB) queryAdjustments(q string, args ...any) ([]Adjustment, error) {
|
|
rows, err := db.sql.Query(q, args...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
out := []Adjustment{}
|
|
for rows.Next() {
|
|
var a Adjustment
|
|
if err := rows.Scan(&a.ID, &a.SubID, &a.Kind, &a.BaseDate, &a.OldEndDate, &a.NewEndDate,
|
|
&a.DaysAdded, &a.CountAdded, &a.OldTotal, &a.NewTotal, &a.Note, &a.OperatorID, &a.OperatorName, &a.CreatedAt,
|
|
&a.CustomerTail, &a.CustomerName, &a.PackageName); err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, a)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
// PausesForSubs 批量取暂停分段。
|
|
func (db *DB) PausesForSubs(ids []int64) (map[int64][]Pause, error) {
|
|
out := map[int64][]Pause{}
|
|
if len(ids) == 0 {
|
|
return out, nil
|
|
}
|
|
args := make([]any, len(ids))
|
|
for i, id := range ids {
|
|
args[i] = id
|
|
}
|
|
rows, err := db.sql.Query(`SELECT id,sub_id,start_at,IFNULL(end_at,'') FROM sub_pauses
|
|
WHERE sub_id IN (`+placeholders(len(ids))+`) ORDER BY id`, args...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var p Pause
|
|
if err := rows.Scan(&p.ID, &p.SubID, &p.StartAt, &p.EndAt); err != nil {
|
|
return nil, err
|
|
}
|
|
if len(p.StartAt) >= 10 {
|
|
p.StartDate = p.StartAt[:10]
|
|
}
|
|
if len(p.EndAt) >= 10 {
|
|
p.EndDate = p.EndAt[:10]
|
|
}
|
|
out[p.SubID] = append(out[p.SubID], p)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
// CountActiveSubs 活跃订阅数。
|
|
func (db *DB) CountActiveSubs(today string) (int, error) {
|
|
var n int
|
|
err := db.sql.QueryRow(`SELECT COUNT(*) FROM subscriptions s WHERE s.status='active'
|
|
AND IFNULL((SELECT archived FROM customers c WHERE c.id=s.customer_id),0)=0 AND (
|
|
(s.unit='day' AND s.end_date >= ?) OR
|
|
(s.unit='count' AND (IFNULL(s.end_date,'')='' OR s.end_date >= ?) AND s.used_count < s.total_count)
|
|
)`, today, today).Scan(&n)
|
|
return n, err
|
|
}
|
|
|
|
// SubTitle 生成「1234 老张 · 包月日常」式标题。
|
|
func (s *Subscription) SubTitle() string {
|
|
return fmt.Sprintf("%s %s · %s", s.CustomerTail, s.CustomerName, s.PackageName)
|
|
}
|
|
|
|
// SeasonComplete 把通行证订阅整段标记为已完成。
|
|
func (db *DB) SeasonComplete(subID int64, date string) error {
|
|
sub, err := db.Sub(subID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !sub.Season {
|
|
return errors.New("不是通行证订阅")
|
|
}
|
|
_, err = db.sql.Exec(`UPDATE subscriptions SET season_done=?, updated_at=? WHERE id=?`,
|
|
date, nowStamp(), subID)
|
|
return err
|
|
}
|
|
|
|
// DeleteSubscription 彻底删除订阅；打卡、暂停、追加、加急随外键级联删除。
|
|
func (db *DB) DeleteSubscription(subID int64) error {
|
|
res, err := db.sql.Exec(`DELETE FROM subscriptions WHERE id=?`, subID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if n, _ := res.RowsAffected(); n == 0 {
|
|
return ErrNotFound
|
|
}
|
|
return nil
|
|
}
|