feat: SEO improvements, invite rebate fixes, upstream sync

common/constants.go

@@ -124,6 +124,16 @@ var TelegramBotName = ""
 var QuotaForNewUser = 0
 var QuotaForInviter = 0
 var QuotaForInvitee = 0
+
+// Invite top-up rebate (invitee top-up → inviter aff_quota). Default off for safe merges.
+// Only top-ups completed at/after InviteTopupRebateEnabledAt are eligible.
+// Historical top-ups before the feature was turned on are never backfilled.
+var InviteTopupRebateEnabled = false
+var InviteTopupRebateRatioBp = 100       // 100 basis points = 1.00%
+var InviteTopupRebateBackfillMinutes = 5 // scheduled backfill interval; min 1, max 1440
+// InviteTopupRebateEnabledAt is unix seconds when the feature was last turned ON.
+// 0 means "never enabled" (or unknown) — backfill grants nothing until set on enable.
+var InviteTopupRebateEnabledAt int64 = 0
 var ChannelDisableThreshold = 5.0
 var AutomaticDisableChannelEnabled = false
 var AutomaticEnableChannelEnabled = false

common/seo.go

@@ -0,0 +1,63 @@
+package common
+
+import "strings"
+
+// SEO options (admin-configurable). Empty strings mean "use built-in defaults" on the client.
+var (
+	// SEOTitle is the full document title when set (long-tail OK).
+	// If empty, title is built as: SystemName + " - " + SEOTitleSuffix (or default suffix).
+	SEOTitle = ""
+	// SEOTitleSuffix is appended after SystemName when SEOTitle is empty.
+	SEOTitleSuffix = ""
+	SEODescription = ""
+	SEOKeywords    = ""
+	SEOSiteURL     = ""
+	SEOOGImage     = ""
+	SEORobotsIndex = true
+)
+
+// DefaultSEOTitleSuffix returns a long-tail title suffix for search.
+func DefaultSEOTitleSuffix(lang string) string {
+	if strings.HasPrefix(strings.ToLower(lang), "zh") {
+		return "AI大模型API网关|OpenAI/Claude/Gemini兼容|统一接口管理与分发平台"
+	}
+	return "AI LLM API Gateway | OpenAI Claude Gemini Compatible | Unified Model Hub"
+}
+
+// BuildSEOTitle builds the final page title from options + system name.
+func BuildSEOTitle(systemName, lang string) string {
+	if t := strings.TrimSpace(SEOTitle); t != "" {
+		return t
+	}
+	name := strings.TrimSpace(systemName)
+	if name == "" {
+		name = SystemName
+	}
+	if name == "" {
+		name = "New API"
+	}
+	suffix := strings.TrimSpace(SEOTitleSuffix)
+	if suffix == "" {
+		suffix = DefaultSEOTitleSuffix(lang)
+	}
+	if suffix == "" {
+		return name
+	}
+	return name + " - " + suffix
+}
+
+// DefaultSEODescription returns a language-aware fallback meta description.
+func DefaultSEODescription(lang string) string {
+	if strings.HasPrefix(strings.ToLower(lang), "zh") {
+		return "统一的 AI 模型网关与管理平台，支持 OpenAI / Claude / Gemini 兼容接口，集中管理多模型 API 密钥、渠道分发与用量计费。"
+	}
+	return "Unified AI API gateway and admin dashboard with OpenAI / Claude / Gemini compatible APIs, multi-channel routing, key management and usage billing."
+}
+
+// DefaultSEOKeywords returns a language-aware fallback keywords string.
+func DefaultSEOKeywords(lang string) string {
+	if strings.HasPrefix(strings.ToLower(lang), "zh") {
+		return "AI API,大模型API,LLM网关,OpenAI兼容接口,Claude API,Gemini API,API聚合分发,模型管理"
+	}
+	return "AI API, LLM API Gateway, OpenAI Compatible API, Claude API, Gemini API, model aggregation, API distribution"
+}

controller/invite_rebate.go

@@ -0,0 +1,109 @@
+package controller
+
+import (
+	"strconv"
+
+	"github.com/QuantumNous/new-api/common"
+	"github.com/QuantumNous/new-api/model"
+	"github.com/gin-gonic/gin"
+)
+
+func GetSelfInviteRebateSummary(c *gin.Context) {
+	userId := c.GetInt("id")
+	inviteeCount, topupSum, rebateSum, err := model.GetInviteRebateSummaryForInviter(userId)
+	if err != nil {
+		common.ApiError(c, err)
+		return
+	}
+	user, err := model.GetUserById(userId, true)
+	if err != nil {
+		common.ApiError(c, err)
+		return
+	}
+	common.ApiSuccess(c, gin.H{
+		"invitee_count":     inviteeCount,
+		"topup_quota_sum":   topupSum,
+		"rebate_quota_sum":  rebateSum,
+		"aff_quota":         user.AffQuota,
+		"aff_history_quota": user.AffHistoryQuota,
+		"enabled":           common.InviteTopupRebateEnabled,
+		"ratio_bp":          common.InviteTopupRebateRatioBp,
+	})
+}
+
+func GetSelfInviteRebateLogs(c *gin.Context) {
+	userId := c.GetInt("id")
+	pageInfo := common.GetPageQuery(c)
+	items, total, err := model.ListInviteRebatesForInviter(userId, pageInfo)
+	if err != nil {
+		common.ApiError(c, err)
+		return
+	}
+	pageInfo.SetTotal(int(total))
+	pageInfo.SetItems(items)
+	common.ApiSuccess(c, pageInfo)
+}
+
+func GetSelfInviteRebateInvitees(c *gin.Context) {
+	userId := c.GetInt("id")
+	pageInfo := common.GetPageQuery(c)
+	items, total, err := model.ListInviteesWithRebateStats(userId, pageInfo)
+	if err != nil {
+		common.ApiError(c, err)
+		return
+	}
+	pageInfo.SetTotal(int(total))
+	pageInfo.SetItems(items)
+	common.ApiSuccess(c, pageInfo)
+}
+
+func GetAdminInviteRebates(c *gin.Context) {
+	pageInfo := common.GetPageQuery(c)
+	inviterId, _ := strconv.Atoi(c.Query("inviter_id"))
+	inviteeId, _ := strconv.Atoi(c.Query("invitee_id"))
+	start, _ := strconv.ParseInt(c.Query("start_timestamp"), 10, 64)
+	end, _ := strconv.ParseInt(c.Query("end_timestamp"), 10, 64)
+	items, total, err := model.ListAllInviteRebates(inviterId, inviteeId, start, end, pageInfo)
+	if err != nil {
+		common.ApiError(c, err)
+		return
+	}
+	pageInfo.SetTotal(int(total))
+	pageInfo.SetItems(items)
+	common.ApiSuccess(c, pageInfo)
+}
+
+func GetAdminInviteRebateSummary(c *gin.Context) {
+	inviterId, _ := strconv.Atoi(c.Query("inviter_id"))
+	topupSum, rebateSum, rowCount, err := model.GetInviteRebateAdminSummary(inviterId)
+	if err != nil {
+		common.ApiError(c, err)
+		return
+	}
+	common.ApiSuccess(c, gin.H{
+		"topup_quota_sum":  topupSum,
+		"rebate_quota_sum": rebateSum,
+		"row_count":        rowCount,
+		"enabled":          common.InviteTopupRebateEnabled,
+		"ratio_bp":         common.InviteTopupRebateRatioBp,
+	})
+}
+
+func GetInviteRebateLeaderboard(c *gin.Context) {
+	userId := c.GetInt("id")
+	by := c.DefaultQuery("by", "rebate")
+	if by != "invitees" {
+		by = "rebate"
+	}
+	limit, _ := strconv.Atoi(c.DefaultQuery("limit", "20"))
+	items, myRank, err := model.ListInviteRebateLeaderboard(by, limit, userId)
+	if err != nil {
+		common.ApiError(c, err)
+		return
+	}
+	common.ApiSuccess(c, gin.H{
+		"by":      by,
+		"items":   items,
+		"my_rank": myRank,
+	})
+}

controller/invite_rebate_task.go

@@ -0,0 +1,70 @@
+package controller
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/QuantumNous/new-api/common"
+	"github.com/QuantumNous/new-api/model"
+)
+
+// inviteRebateBackfillPayload controls one invite_rebate_backfill run.
+// Scheduled runs leave Limit empty (defaults to 100). Manual triggers may set Limit.
+type inviteRebateBackfillPayload struct {
+	Limit int `json:"limit,omitempty"`
+}
+
+// inviteRebateBackfillHandler periodically re-grants missing invite rebates for
+// successful top-ups that have no invite_rebates ledger row (e.g. epay path
+// where grant failed after user credit, or historical gaps after enabling the feature).
+type inviteRebateBackfillHandler struct{}
+
+func (inviteRebateBackfillHandler) Type() string {
+	return model.SystemTaskTypeInviteRebateBackfill
+}
+
+func (inviteRebateBackfillHandler) Enabled() bool {
+	return common.InviteTopupRebateEnabled
+}
+
+func (inviteRebateBackfillHandler) Interval() time.Duration {
+	minutes := common.InviteTopupRebateBackfillMinutes
+	if minutes < 1 {
+		minutes = 5
+	}
+	if minutes > 1440 {
+		minutes = 1440
+	}
+	return time.Duration(minutes) * time.Minute
+}
+
+func (inviteRebateBackfillHandler) NewPayload() any {
+	return inviteRebateBackfillPayload{Limit: 100}
+}
+
+func (inviteRebateBackfillHandler) Run(ctx context.Context, task *model.SystemTask, runnerID string) {
+	payload := inviteRebateBackfillPayload{}
+	if err := task.DecodePayload(&payload); err != nil {
+		// tolerate empty/legacy payload
+		payload.Limit = 100
+	}
+	limit := payload.Limit
+	if limit <= 0 {
+		limit = 100
+	}
+	scanned, granted, err := model.BackfillMissingInviteTopupRebates(limit)
+	summary := map[string]any{
+		"scanned": scanned,
+		"granted": granted,
+		"limit":   limit,
+	}
+	if err != nil {
+		finishSystemTaskHandler(task, runnerID, model.SystemTaskStatusFailed, summary, err)
+		return
+	}
+	if granted > 0 {
+		common.SysLog(fmt.Sprintf("invite rebate backfill completed: scanned=%d granted=%d limit=%d", scanned, granted, limit))
+	}
+	finishSystemTaskHandler(task, runnerID, model.SystemTaskStatusSucceeded, summary, nil)
+}

controller/misc.go

@@ -66,6 +66,13 @@ func GetStatus(c *gin.Context) {
 		"theme":                       "default",
 		"system_name":                 common.SystemName,
 		"logo":                        common.Logo,
+		"seo_title":                   common.SEOTitle,
+		"seo_title_suffix":            common.SEOTitleSuffix,
+		"seo_description":             common.SEODescription,
+		"seo_keywords":                common.SEOKeywords,
+		"seo_site_url":                common.SEOSiteURL,
+		"seo_og_image":                common.SEOOGImage,
+		"seo_robots_index":            common.SEORobotsIndex,
 		"footer_html":                 common.Footer,
 		"wechat_qrcode":               common.WeChatAccountQRCodeImageURL,
 		"wechat_login":                common.WeChatAuthEnabled,

controller/oauth.go

@@ -361,10 +361,19 @@ func findOrCreateOAuthUser(c *gin.Context, provider oauth.Provider, oauthUser *o
 	user.Role = common.RoleCommonUser
 	user.Status = common.UserStatusEnabled
 
-	// Handle affiliate code
+	// Handle affiliate code (same rules as Register: refuse disabled inviters).
 	inviterId := 0
+	affiliateCode = strings.TrimSpace(affiliateCode)
+	if len(affiliateCode) > 32 {
+		affiliateCode = affiliateCode[:32]
+	}
 	if affiliateCode != "" {
 		inviterId, _ = model.GetUserIdByAffCode(affiliateCode)
+		if inviterId > 0 {
+			if inviter, err := model.GetUserById(inviterId, false); err != nil || inviter == nil || inviter.Status != common.UserStatusEnabled {
+				inviterId = 0
+			}
+		}
 	}
 
 	// Use transaction to ensure user creation and OAuth binding are atomic

controller/seo.go

@@ -0,0 +1,100 @@
+package controller
+
+import (
+	"fmt"
+	"html"
+	"net/http"
+	"strings"
+
+	"github.com/QuantumNous/new-api/common"
+	"github.com/QuantumNous/new-api/setting/system_setting"
+
+	"github.com/gin-gonic/gin"
+)
+
+func seoSiteBase(c *gin.Context) string {
+	// Prefer configured absolute site URL only. Do not trust Request.Host —
+	// without SEOSiteURL/ServerAddress, omit absolute links rather than
+	// emitting attacker-controlled Host into robots/sitemap.
+	common.OptionMapRWMutex.RLock()
+	siteURL := common.SEOSiteURL
+	serverAddr := system_setting.ServerAddress
+	common.OptionMapRWMutex.RUnlock()
+
+	site := strings.TrimRight(strings.TrimSpace(siteURL), "/")
+	if site == "" {
+		site = strings.TrimRight(strings.TrimSpace(serverAddr), "/")
+	}
+	return site
+}
+
+// RobotsTxt serves GET /robots.txt for crawlers (no SPA).
+func RobotsTxt(c *gin.Context) {
+	common.OptionMapRWMutex.RLock()
+	robotsIndex := common.SEORobotsIndex
+	common.OptionMapRWMutex.RUnlock()
+
+	var b strings.Builder
+	b.WriteString("User-agent: *\n")
+	if robotsIndex {
+		b.WriteString("Allow: /\n")
+		b.WriteString("Disallow: /console\n")
+		b.WriteString("Disallow: /dashboard\n")
+		b.WriteString("Disallow: /api/\n")
+		b.WriteString("Disallow: /token\n")
+		b.WriteString("Disallow: /topup\n")
+		b.WriteString("Disallow: /log\n")
+		b.WriteString("Disallow: /setting\n")
+		b.WriteString("Disallow: /channel\n")
+		b.WriteString("Disallow: /user\n")
+		b.WriteString("\n")
+		if site := seoSiteBase(c); site != "" {
+			b.WriteString("Sitemap: ")
+			b.WriteString(site)
+			b.WriteString("/sitemap.xml\n")
+		}
+	} else {
+		b.WriteString("Disallow: /\n")
+	}
+	c.Data(http.StatusOK, "text/plain; charset=utf-8", []byte(b.String()))
+}
+
+type sitemapEntry struct {
+	path       string
+	changefreq string
+	priority   string
+}
+
+// SitemapXML serves GET /sitemap.xml with core public URLs.
+func SitemapXML(c *gin.Context) {
+	site := seoSiteBase(c)
+	if site == "" {
+		c.Data(http.StatusOK, "application/xml; charset=utf-8", []byte(
+			`<?xml version="1.0" encoding="UTF-8"?><urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"></urlset>`,
+		))
+		return
+	}
+
+	entries := []sitemapEntry{
+		{"/", "daily", "1.0"},
+		{"/pricing", "weekly", "0.8"},
+		{"/about", "monthly", "0.6"},
+		{"/rankings", "daily", "0.7"},
+		{"/login", "monthly", "0.3"},
+		{"/register", "monthly", "0.3"},
+	}
+
+	var b strings.Builder
+	b.WriteString(`<?xml version="1.0" encoding="UTF-8"?>`)
+	b.WriteString(`<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">`)
+	escapedSite := html.EscapeString(site)
+	for _, e := range entries {
+		b.WriteString("<url>")
+		b.WriteString(fmt.Sprintf("<loc>%s%s</loc>", escapedSite, e.path))
+		b.WriteString(fmt.Sprintf("<changefreq>%s</changefreq>", e.changefreq))
+		b.WriteString(fmt.Sprintf("<priority>%s</priority>", e.priority))
+		b.WriteString("</url>")
+	}
+	b.WriteString(`</urlset>`)
+	c.Data(http.StatusOK, "application/xml; charset=utf-8", []byte(b.String()))
+}