短链失效处理与过期策略：软删除、续期、归档与回收完整方案

CREATE TABLE short_links (
    id              BIGINT PRIMARY KEY AUTO_INCREMENT,
    slug            VARCHAR(16) NOT NULL UNIQUE,
    target_url      TEXT NOT NULL,

    -- 生命周期状态
    status          ENUM('ACTIVE', 'EXPIRING', 'EXPIRED', 'ARCHIVED', 'DELETED')
                    DEFAULT 'ACTIVE',

    -- 过期控制
    expires_at      DATETIME NULL,
    expiry_notice_sent BOOLEAN DEFAULT FALSE,  -- 是否已发送临期通知

    -- 软删除字段
    deleted_at      DATETIME NULL,
    deleted_by      VARCHAR(64) NULL,
    delete_reason   VARCHAR(255) NULL,

    -- 归档信息
    archived_at     DATETIME NULL,
    archive_target  TEXT NULL,     -- 归档后跳转的目标（如说明页）

    created_at      DATETIME DEFAULT CURRENT_TIMESTAMP,
    updated_at      DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,

    INDEX idx_status (status),
    INDEX idx_expires_at (expires_at),
    INDEX idx_deleted_at (deleted_at),
    INDEX idx_status_created (status, created_at)
);

-- 软删除视图表：只展示未删除的链接
CREATE VIEW active_short_links AS
SELECT * FROM short_links
WHERE deleted_at IS NULL AND status != 'DELETED';

package service

import (
    "context"
    "database/sql"
    "errors"
    "time"
    "fmt"
)

type LinkStatus string

const (
    StatusActive    LinkStatus = "ACTIVE"
    StatusExpiring  LinkStatus = "EXPIRING"
    StatusExpired   LinkStatus = "EXPIRED"
    StatusArchived  LinkStatus = "ARCHIVED"
    StatusDeleted   LinkStatus = "DELETED"
)

type ShortLink struct {
    ID              int64
    Slug            string
    TargetURL       string
    Status          LinkStatus
    ExpiresAt       *time.Time
    ExpiryNoticeSent bool
    DeletedAt       *time.Time
    DeletedBy       string
    DeleteReason    string
    ArchivedAt      *time.Time
    ArchiveTarget   string
}

// SoftDelete 软删除：只标记，不物理删除
func (s *LinkService) SoftDelete(ctx context.Context, slug string, operator string, reason string) error {
    now := time.Now()

    result, err := s.db.ExecContext(ctx, `
        UPDATE short_links
        SET status = ?,
            deleted_at = ?,
            deleted_by = ?,
            delete_reason = ?,
            updated_at = ?
        WHERE slug = ? AND deleted_at IS NULL
    `, StatusDeleted, now, operator, reason, now, slug)

    if err != nil {
        return fmt.Errorf("soft delete failed: %w", err)
    }

    rows, _ := result.RowsAffected()
    if rows == 0 {
        return errors.New("link not found or already deleted")
    }

    // 记录审计日志
    s.auditLog.Record(ctx, AuditEvent{
        Action:   "SOFT_DELETE",
        Target:   slug,
        Operator: operator,
        Reason:   reason,
        Time:     now,
    })

    // 清除缓存
    s.cache.Delete(ctx, slug)

    return nil
}

// Restore 从软删除恢复
func (s *LinkService) Restore(ctx context.Context, slug string, operator string) error {
    result, err := s.db.ExecContext(ctx, `
        UPDATE short_links
        SET status = CASE
                WHEN expires_at IS NOT NULL AND expires_at > NOW() THEN ?
                WHEN expires_at IS NOT NULL AND expires_at <= NOW() THEN ?
                ELSE ?
            END,
            deleted_at = NULL,
            deleted_by = NULL,
            delete_reason = NULL,
            updated_at = NOW()
        WHERE slug = ? AND deleted_at IS NOT NULL
    `, StatusActive, StatusExpired, StatusActive, slug)

    if err != nil {
        return fmt.Errorf("restore failed: %w", err)
    }

    rows, _ := result.RowsAffected()
    if rows == 0 {
        return errors.New("link not found or not deleted")
    }

    s.auditLog.Record(ctx, AuditEvent{
        Action:   "RESTORE",
        Target:   slug,
        Operator: operator,
        Time:     time.Now(),
    })

    return nil
}

// HardDelete 物理删除（仅供定时任务调用，延迟执行）
func (s *LinkService) HardDelete(ctx context.Context, before time.Time) (int64, error) {
    result, err := s.db.ExecContext(ctx, `
        DELETE FROM short_links
        WHERE deleted_at IS NOT NULL AND deleted_at < ?
    `, before)

    if err != nil {
        return 0, err
    }

    return result.RowsAffected()
}

type ExpiryTier string

const (
    TierPermanent   ExpiryTier = "PERMANENT"   // 永久有效
    TierLongTerm    ExpiryTier = "LONG_TERM"   // 1年
    TierMedium      ExpiryTier = "MEDIUM"      // 90天
    TierShort       ExpiryTier = "SHORT"       // 7天
    TierOneTime     ExpiryTier = "ONE_TIME"    // 一次性，首次点击后N小时过期
)

var tierDurations = map[ExpiryTier]time.Duration{
    TierPermanent: 0,  // 不过期
    TierLongTerm:  365 * 24 * time.Hour,
    TierMedium:    90 * 24 * time.Hour,
    TierShort:     7 * 24 * time.Hour,
    TierOneTime:   24 * time.Hour, // 首次点击后24小时
}

// NoticeWorker 临期通知任务（每日执行）
func (w *NoticeWorker) SendExpiryNotices(ctx context.Context) error {
    // 查询7天内过期且未通知的链接
    rows, err := w.db.QueryContext(ctx, `
        SELECT slug, target_url, user_id, expires_at
        FROM short_links
        WHERE status = 'ACTIVE'
          AND expires_at BETWEEN NOW() AND DATE_ADD(NOW(), INTERVAL 7 DAY)
          AND expiry_notice_sent = FALSE
    `)
    if err != nil {
        return err
    }
    defer rows.Close()

    for rows.Next() {
        var slug, targetURL, userID string
        var expiresAt time.Time
        rows.Scan(&slug, &targetURL, &userID, &expiresAt)

        daysUntil := int(time.Until(expiresAt).Hours() / 24)

        // 发送通知
        w.notifier.Send(ctx, Notification{
            UserID:  userID,
            Type:    "LINK_EXPIRING",
            Title:   fmt.Sprintf("短链将在 %d 天后过期", daysUntil),
            Body:    fmt.Sprintf("链接 %s 指向 %s 将在 %s 过期。点击续期保留链接。", slug, targetURL, expiresAt.Format("2006-01-02")),
            ActionURL: fmt.Sprintf("/dashboard/links/%s/renew", slug),
        })

        // 标记已通知
        w.db.ExecContext(ctx, `
            UPDATE short_links SET expiry_notice_sent = TRUE WHERE slug = ?
        `, slug)
    }

    return nil
}

// AutoRenewal 根据链接活跃度自动续期
func (s *LinkService) AutoRenewal(ctx context.Context) error {
    // 查找即将过期但仍有活跃的链接
    _, err := s.db.ExecContext(ctx, `
        UPDATE short_links sl
        JOIN (
            SELECT link_slug
            FROM click_events
            WHERE created_at > DATE_SUB(NOW(), INTERVAL 7 DAY)
            GROUP BY link_slug
            HAVING COUNT(*) >= 3  -- 7天内至少3次点击
        ) ce ON sl.slug = ce.link_slug
        SET sl.expires_at = DATE_ADD(sl.expires_at, INTERVAL 90 DAY),
            sl.expiry_notice_sent = FALSE,
            sl.updated_at = NOW()
        WHERE sl.status = 'ACTIVE'
          AND sl.expires_at BETWEEN NOW() AND DATE_ADD(NOW(), INTERVAL 7 DAY)
          AND sl.tier = 'MEDIUM'
    `)
    return err
}

type ArchiveConfig struct {
    DefaultTarget   string            // 默认归档跳转
    CategoryTargets map[string]string // 按分类的归档目标
    CampaignTargets map[string]string // 按活动的归档目标
}

func (s *LinkService) GetArchiveTarget(link ShortLink) string {
    // 1. 链接级别自定义归档目标
    if link.ArchiveTarget != "" {
        return link.ArchiveTarget
    }

    // 2. 按活动匹配
    if target, ok := s.archiveConfig.CampaignTargets[link.CampaignID]; ok {
        return target
    }

    // 3. 按分类匹配
    if target, ok := s.archiveConfig.CategoryTargets[link.Category]; ok {
        return target
    }

    // 4. 兜底：目标域名首页
    parsed, _ := url.Parse(link.TargetURL)
    if parsed != nil {
        return fmt.Sprintf("%s://%s", parsed.Scheme, parsed.Host)
    }

    // 5. 全局默认
    return s.archiveConfig.DefaultTarget
}

<!-- templates/expired.html -->
<!DOCTYPE html>
<html>
<head>
    <title>链接已过期 - {{ .BrandName }}</title>
    <meta name="robots" content="noindex">
    <style>
        body { font-family: system-ui; text-align: center; padding: 80px 20px; }
        .container { max-width: 500px; margin: 0 auto; }
        .icon { font-size: 64px; margin-bottom: 20px; }
        h1 { color: #333; }
        .cta { margin-top: 30px; }
        .cta a { display: inline-block; padding: 12px 24px; background: #007bff; color: white; text-decoration: none; border-radius: 6px; }
        .countdown { color: #666; margin-top: 15px; }
    </style>
</head>
<body>
    <div class="container">
        <div class="icon">⏰</div>
        <h1>此链接已过期</h1>
        <p>{{ .Message }}</p>

        {{ if .CanRenew }}
        <div class="cta">
            <a href="/renew/{{ .Slug }}">续期链接（{{ .DaysLeft }}天内有效）</a>
        </div>
        {{ end }}

        <div class="cta">
            <a href="{{ .ArchiveTarget }}" style="background: #6c757d;">访问相关页面</a>
        </div>

        <p class="countdown">链接创建于 {{ .CreatedAt }} · 共被访问 {{ .Clicks }} 次</p>
    </div>
</body>
</html>

// ReclaimWorker 短码回收任务
func (w *ReclaimWorker) ReclaimShortCodes(ctx context.Context) (int64, error) {
    tx, err := w.db.BeginTx(ctx, nil)
    if err != nil {
        return 0, err
    }
    defer tx.Rollback()

    // 1. 标记可回收的短码
    result, err := tx.ExecContext(ctx, `
        UPDATE short_links
        SET status = 'DELETED',
            deleted_at = NOW(),
            delete_reason = 'SYSTEM_RECLAIM: expired and low-value',
            slug = CONCAT('RECLAIMED_', slug)  -- 释放原slug
        WHERE (status = 'EXPIRED' OR (status = 'DELETED' AND deleted_at < DATE_SUB(NOW(), INTERVAL 90 DAY)))
          AND clicks < 10
          AND is_custom_slug = FALSE
          AND COALESCE(last_user_login, created_at) < DATE_SUB(NOW(), INTERVAL 180 DAY)
          AND (deleted_at IS NULL OR deleted_at < DATE_SUB(NOW(), INTERVAL 90 DAY))
    `)
    if err != nil {
        return 0, err
    }

    // 2. 将原slug记录到回收池（可选，用于防止重复分配冲突）
    _, err = tx.ExecContext(ctx, `
        INSERT INTO reclaimed_slugs (original_slug, reclaimed_at, previous_link_id)
        SELECT SUBSTRING(slug, 11), NOW(), id
        FROM short_links
        WHERE slug LIKE 'RECLAIMED_%'
        ON DUPLICATE KEY UPDATE reclaimed_at = NOW()
    `)
    if err != nil {
        return 0, err
    }

    if err := tx.Commit(); err != nil {
        return 0, err
    }

    count, _ := result.RowsAffected()
    return count, nil
}

// TargetHealthChecker 目标链接健康检查
func (c *TargetHealthChecker) Check(ctx context.Context) error {
    rows, err := c.db.QueryContext(ctx, `
        SELECT id, slug, target_url
        FROM short_links
        WHERE status = 'ACTIVE'
          AND (last_health_check IS NULL OR last_health_check < DATE_SUB(NOW(), INTERVAL 24 HOUR))
        LIMIT 1000
    `)
    if err != nil {
        return err
    }
    defer rows.Close()

    for rows.Next() {
        var id int64
        var slug, targetURL string
        rows.Scan(&id, &slug, &targetURL)

        // HTTP HEAD 检查
        client := &http.Client{Timeout: 10 * time.Second}
        resp, err := client.Head(targetURL)

        status := "HEALTHY"
        statusCode := 0
        if err != nil {
            status = "UNREACHABLE"
        } else {
            statusCode = resp.StatusCode
            if resp.StatusCode >= 400 {
                status = "BROKEN"
            } else if resp.StatusCode >= 300 {
                status = "REDIRECT"
            }
            resp.Body.Close()
        }

        // 更新健康状态
        c.db.ExecContext(ctx, `
            UPDATE short_links
            SET last_health_check = NOW(),
                health_status = ?,
                health_status_code = ?,
                health_fail_count = CASE WHEN ? IN ('BROKEN', 'UNREACHABLE') THEN health_fail_count + 1 ELSE 0 END
            WHERE id = ?
        `, status, statusCode, status, id)

        // 连续3次失败，发送告警
        if status == "BROKEN" || status == "UNREACHABLE" {
            var failCount int
            c.db.QueryRowContext(ctx, `SELECT health_fail_count FROM short_links WHERE id = ?`, id).Scan(&failCount)
            if failCount >= 3 {
                c.alertManager.Send(ctx, Alert{
                    Level:   "WARNING",
                    Title:   fmt.Sprintf("短链目标页面异常: %s", slug),
                    Message: fmt.Sprintf("目标 %s 连续 %d 次检测失败（HTTP %d）", targetURL, failCount, statusCode),
                })
            }
        }
    }

    return nil
}

// RedirectHandler 带兜底的跳转处理
func (h *RedirectHandler) Handle(w http.ResponseWriter, r *http.Request) {
    slug := extractSlug(r.URL.Path)

    link, err := h.service.GetLink(r.Context(), slug)
    if err != nil {
        h.render404(w, r)
        return
    }

    // 状态检查
    if link.Status == StatusExpired {
        h.renderExpired(w, r, link)
        return
    }

    if link.Status == StatusDeleted || link.Status == StatusArchived {
        h.renderGone(w, r, link)
        return
    }

    // 目标健康检查兜底
    if link.HealthStatus == "BROKEN" && link.HealthFailCount >= 3 {
        // 连续失败，尝试备用目标或显示提示
        fallback := h.service.GetArchiveTarget(*link)
        if fallback != link.TargetURL {
            http.Redirect(w, r, fallback, http.StatusTemporaryRedirect)
            return
        }
        // 否则依然跳转，让用户看到真实错误
    }

    // 正常跳转
    http.Redirect(w, r, link.TargetURL, http.StatusMovedPermanently)
}