first commit

internal/handler/template_handler.go

@@ -0,0 +1,801 @@
+package handler
+
+import (
+	"fmt"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/subconverter-go/internal/config"
+	"github.com/subconverter-go/internal/logging"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+// TemplateHandler 模板处理器
+type TemplateHandler struct {
+	templateManager *config.TemplateManager
+	logger          *logging.Logger
+	configManager  *config.ConfigManager
+}
+
+// TemplateInfo 模板信息
+type TemplateInfo struct {
+	Name        string `json:"name"`
+	Type        string `json:"type"`
+	Description string `json:"description"`
+	Size        int64  `json:"size"`
+}
+
+// RulesetInfo 规则集信息
+type RulesetInfo struct {
+	Name        string `json:"name"`
+	Type        string `json:"type"`
+	Description string `json:"description"`
+	RuleCount   int    `json:"rule_count"`
+}
+
+// TemplateListRequest 模板列表请求
+type TemplateListRequest struct {
+	Type    string `query:"type"`     // 模板类型: clash, surge, quanx, loon, surfboard, v2ray
+	Format  string `query:"format"`   // 格式: json, yaml
+	Profile string `query:"profile"`  // 配置文件名
+}
+
+// TemplateRenderRequest 模板渲染请求
+type TemplateRenderRequest struct {
+	Template   string                 `json:"template"`    // 模板名称
+	Profile    string                 `json:"profile"`     // 配置文件名
+	Variables  map[string]interface{} `json:"variables"`  // 自定义变量
+	Target     string                 `json:"target"`      // 目标格式
+	NodeData   interface{}            `json:"node_data"`   // 节点数据
+	GroupName  string                 `json:"group_name"`  // 组名
+}
+
+// TemplateRenderResponse 模板渲染响应
+type TemplateRenderResponse struct {
+	Success   bool                   `json:"success"`
+	Content   string                 `json:"content"`
+	Variables map[string]interface{} `json:"variables"`
+	Metadata  map[string]interface{} `json:"metadata"`
+	Error     string                 `json:"error,omitempty"`
+}
+
+
+// NewTemplateHandler 创建模板处理器
+func NewTemplateHandler(templateManager *config.TemplateManager, logger *logging.Logger, configManager *config.ConfigManager) *TemplateHandler {
+	return &TemplateHandler{
+		templateManager: templateManager,
+		logger:          logger,
+		configManager:  configManager,
+	}
+}
+
+// RegisterRoutes 注册路由
+func (h *TemplateHandler) RegisterRoutes(app *fiber.App) {
+	// 原项目兼容性路由 - /render 端点
+	app.Get("/render", h.RenderDirect)
+
+	// 模板相关路由
+	app.Get("/api/templates", h.ListTemplates)
+	app.Get("/api/templates/:name", h.GetTemplate)
+	app.Post("/api/templates/render", h.RenderTemplate)
+	app.Get("/api/templates/:name/preview", h.PreviewTemplate)
+
+	// 规则集相关路由
+	app.Get("/api/rulesets", h.ListRulesets)
+	app.Get("/api/rulesets/:name", h.GetRuleset)
+	app.Get("/api/rulesets/:name/content", h.GetRulesetContent)
+
+	// 配置文件相关路由
+	app.Get("/api/profiles", h.ListProfiles)
+	app.Get("/api/profiles/:name", h.GetProfile)
+	app.Post("/api/profiles/:name/apply", h.ApplyProfile)
+
+	// 代码片段相关路由
+	app.Get("/api/snippets", h.ListSnippets)
+	app.Get("/api/snippets/:name", h.GetSnippet)
+
+	// 模板管理路由
+	app.Post("/api/templates/reload", h.ReloadTemplates)
+	app.Get("/api/templates/info", h.GetTemplatesInfo)
+}
+
+// RenderDirect 直接渲染模板（原项目兼容性端点）
+func (h *TemplateHandler) RenderDirect(c *fiber.Ctx) error {
+	path := c.Query("path")
+	if path == "" {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"success": false,
+			"error":   "path parameter is required",
+		})
+	}
+
+	// 验证路径安全性，防止目录遍历攻击
+	if strings.Contains(path, "..") || strings.HasPrefix(path, "/") {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"success": false,
+			"error":   "Invalid path",
+		})
+	}
+
+	// 从模板路径中提取模板名称
+	templateName := strings.TrimSuffix(path, filepath.Ext(path))
+
+	// 检查模板是否存在
+	if _, exists := h.templateManager.GetTemplate(templateName); !exists {
+		return c.Status(fiber.StatusNotFound).JSON(fiber.Map{
+			"success": false,
+			"error":   fmt.Sprintf("Template '%s' not found", templateName),
+		})
+	}
+
+	// 准备模板变量，从URL参数中获取
+	variables := h.prepareTemplateVariables(c)
+
+	// 渲染模板
+	content, err := h.templateManager.RenderTemplate(templateName, variables)
+	if err != nil {
+		h.logger.Errorf("Failed to render template %s: %v", templateName, err)
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"success": false,
+			"error":   fmt.Sprintf("Failed to render template: %v", err),
+		})
+	}
+
+	// 根据模板类型设置Content-Type
+	contentType := h.getContentType(templateName)
+	c.Set("Content-Type", contentType)
+
+	return c.SendString(content)
+}
+
+// prepareTemplateVariables 准备模板变量
+func (h *TemplateHandler) prepareTemplateVariables(c *fiber.Ctx) config.TemplateVariables {
+	// 从查询参数中提取模板变量
+	requestConfig := config.RequestConfig{
+		Target: c.Query("target", "clash"),
+		Clash:  make(map[string]interface{}),
+		Surge:  make(map[string]interface{}),
+	}
+
+	// 处理额外的查询参数
+	for key, value := range c.Queries() {
+		switch {
+		case strings.HasPrefix(key, "clash."):
+			paramName := strings.TrimPrefix(key, "clash.")
+			requestConfig.Clash[paramName] = value
+		case strings.HasPrefix(key, "surge."):
+			paramName := strings.TrimPrefix(key, "surge.")
+			requestConfig.Surge[paramName] = value
+		}
+	}
+
+	localConfig := config.LocalConfig{
+		Clash: make(map[string]interface{}),
+		Surge: make(map[string]interface{}),
+	}
+
+	// 获取全局配置
+	globalConfig := config.TemplateConfig{
+		Clash: config.ClashConfig{
+			HTTPPort:           7890,
+			SocksPort:          7891,
+			AllowLAN:           true,
+			LogLevel:           "info",
+			ExternalController: "127.0.0.1:9090",
+		},
+		Surge: config.SurgeConfig{
+			Port:            8080,
+			ProxyHTTPPort:   8081,
+			ProxySOCKS5Port: 8082,
+			MixedPort:       8080,
+			AllowLAN:        true,
+			LogLevel:        "info",
+		},
+		// 可以添加其他客户端的默认配置
+	}
+
+	return config.TemplateVariables{
+		Global:     globalConfig,
+		NodeInfo:   h.getSampleNodeData(),
+		GroupName:  c.Query("group", "Proxy"),
+		UpdateTime: time.Now().Format("2006-01-02 15:04:05"),
+		UserInfo:   "",
+		TotalNodes: 1,
+		Request:    requestConfig,
+		Local:      localConfig,
+	}
+}
+
+// ListTemplates 列出所有模板
+func (h *TemplateHandler) ListTemplates(c *fiber.Ctx) error {
+	var req TemplateListRequest
+	if err := c.QueryParser(&req); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"success": false,
+			"error":   "Invalid request parameters",
+		})
+	}
+
+	templates := h.templateManager.ListTemplates()
+	var filteredTemplates []TemplateInfo
+
+	for _, name := range templates {
+		// 根据类型过滤
+		if req.Type != "" {
+			if !h.isTemplateOfType(name, req.Type) {
+				continue
+			}
+		}
+
+		templateInfo := TemplateInfo{
+			Name:        name,
+			Type:        h.getTemplateType(name),
+			Description: h.getTemplateDescription(name),
+		}
+
+		// 获取模板文件大小
+		if content, err := h.templateManager.RenderTemplate(name, config.TemplateVariables{}); err == nil {
+			templateInfo.Size = int64(len(content))
+		}
+
+		filteredTemplates = append(filteredTemplates, templateInfo)
+	}
+
+	// 根据格式返回不同响应
+	if req.Format == "yaml" {
+		return c.JSON(filteredTemplates)
+	}
+
+	return c.JSON(fiber.Map{
+		"success":   true,
+		"templates": filteredTemplates,
+		"total":     len(filteredTemplates),
+	})
+}
+
+// GetTemplate 获取特定模板
+func (h *TemplateHandler) GetTemplate(c *fiber.Ctx) error {
+	name := c.Params("name")
+	if name == "" {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"success": false,
+			"error":   "Template name is required",
+		})
+	}
+
+	_, exists := h.templateManager.GetTemplate(name)
+	if !exists {
+		return c.Status(fiber.StatusNotFound).JSON(fiber.Map{
+			"success": false,
+			"error":   "Template not found",
+		})
+	}
+
+	// 返回模板信息
+	templateInfo := fiber.Map{
+		"name":        name,
+		"type":        h.getTemplateType(name),
+		"description": h.getTemplateDescription(name),
+		"exists":      true,
+	}
+
+	return c.JSON(fiber.Map{
+		"success": true,
+		"template": templateInfo,
+	})
+}
+
+// RenderTemplate 渲染模板
+func (h *TemplateHandler) RenderTemplate(c *fiber.Ctx) error {
+	var req TemplateRenderRequest
+	if err := c.BodyParser(&req); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"success": false,
+			"error":   "Invalid request body",
+		})
+	}
+
+	// 验证必需参数
+	if req.Template == "" {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"success": false,
+			"error":   "Template name is required",
+		})
+	}
+
+	// 准备模板变量
+	variables := config.TemplateVariables{
+		GroupName:  req.GroupName,
+		NodeInfo:   req.NodeData,
+		TotalNodes: h.getTotalNodes(req.NodeData),
+	}
+
+	// 应用自定义变量
+	if req.Variables != nil {
+		if global, ok := req.Variables["global"]; ok {
+			if globalMap, ok := global.(map[string]interface{}); ok {
+				variables.Global = h.parseGlobalConfig(globalMap)
+			}
+		}
+	}
+
+	// 渲染模板
+	content, err := h.templateManager.RenderTemplateWithDefaults(
+		req.Template,
+		variables.GroupName,
+		variables.NodeInfo,
+		variables.TotalNodes,
+	)
+
+	if err != nil {
+		h.logger.Errorf("Failed to render template %s: %v", req.Template, err)
+		return c.Status(fiber.StatusInternalServerError).JSON(TemplateRenderResponse{
+			Success: false,
+			Error:   fmt.Sprintf("Failed to render template: %v", err),
+		})
+	}
+
+	// 构建响应
+	response := TemplateRenderResponse{
+		Success: true,
+		Content: content,
+		Variables: map[string]interface{}{
+			"group_name":  variables.GroupName,
+			"total_nodes": variables.TotalNodes,
+			"template":    req.Template,
+		},
+		Metadata: map[string]interface{}{
+			"template_name": req.Template,
+			"target":       req.Target,
+			"group_name":   req.GroupName,
+			"node_count":   variables.TotalNodes,
+		},
+	}
+
+	return c.JSON(response)
+}
+
+// PreviewTemplate 预览模板
+func (h *TemplateHandler) PreviewTemplate(c *fiber.Ctx) error {
+	name := c.Params("name")
+	if name == "" {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"success": false,
+			"error":   "Template name is required",
+		})
+	}
+
+	// 使用示例数据预览
+	sampleData := h.getSampleNodeData()
+
+	content, err := h.templateManager.RenderTemplateWithDefaults(
+		name,
+		"SampleGroup",
+		sampleData,
+		1,
+	)
+
+	if err != nil {
+		h.logger.Errorf("Failed to preview template %s: %v", name, err)
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"success": false,
+			"error":   fmt.Sprintf("Failed to preview template: %v", err),
+		})
+	}
+
+	// 根据模板类型设置Content-Type
+	contentType := h.getContentType(name)
+	c.Set("Content-Type", contentType)
+
+	return c.SendString(content)
+}
+
+// ListRulesets 列出所有规则集
+func (h *TemplateHandler) ListRulesets(c *fiber.Ctx) error {
+	rulesets := h.templateManager.ListRulesets()
+	var rulesetInfos []RulesetInfo
+
+	for _, name := range rulesets {
+		if content, exists := h.templateManager.GetRuleset(name); exists {
+			rulesetInfos = append(rulesetInfos, RulesetInfo{
+				Name:        name,
+				Type:        h.getRulesetType(name),
+				Description: h.getRulesetDescription(name),
+				RuleCount:   h.countRules(content),
+			})
+		}
+	}
+
+	return c.JSON(fiber.Map{
+		"success":  true,
+		"rulesets": rulesetInfos,
+		"total":    len(rulesetInfos),
+	})
+}
+
+// GetRuleset 获取规则集信息
+func (h *TemplateHandler) GetRuleset(c *fiber.Ctx) error {
+	name := c.Params("name")
+	if name == "" {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"success": false,
+			"error":   "Ruleset name is required",
+		})
+	}
+
+	content, exists := h.templateManager.GetRuleset(name)
+	if !exists {
+		return c.Status(fiber.StatusNotFound).JSON(fiber.Map{
+			"success": false,
+			"error":   "Ruleset not found",
+		})
+	}
+
+	rulesetInfo := RulesetInfo{
+		Name:        name,
+		Type:        h.getRulesetType(name),
+		Description: h.getRulesetDescription(name),
+		RuleCount:   h.countRules(content),
+	}
+
+	return c.JSON(fiber.Map{
+		"success": true,
+		"ruleset": rulesetInfo,
+	})
+}
+
+// GetRulesetContent 获取规则集内容
+func (h *TemplateHandler) GetRulesetContent(c *fiber.Ctx) error {
+	name := c.Params("name")
+	if name == "" {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"success": false,
+			"error":   "Ruleset name is required",
+		})
+	}
+
+	content, exists := h.templateManager.GetRuleset(name)
+	if !exists {
+		return c.Status(fiber.StatusNotFound).JSON(fiber.Map{
+			"success": false,
+			"error":   "Ruleset not found",
+		})
+	}
+
+	c.Set("Content-Type", "text/plain")
+	return c.SendString(content)
+}
+
+// ListProfiles 列出所有配置文件
+func (h *TemplateHandler) ListProfiles(c *fiber.Ctx) error {
+	profiles := h.templateManager.ListProfileConfigs()
+
+	return c.JSON(fiber.Map{
+		"success":  true,
+		"profiles": profiles,
+		"total":    len(profiles),
+	})
+}
+
+// GetProfile 获取配置文件
+func (h *TemplateHandler) GetProfile(c *fiber.Ctx) error {
+	name := c.Params("name")
+	if name == "" {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"success": false,
+			"error":   "Profile name is required",
+		})
+	}
+
+	profile, exists := h.templateManager.GetProfileConfig(name)
+	if !exists {
+		return c.Status(fiber.StatusNotFound).JSON(fiber.Map{
+			"success": false,
+			"error":   "Profile not found",
+		})
+	}
+
+	return c.JSON(fiber.Map{
+		"success": true,
+		"profile": profile,
+	})
+}
+
+// ApplyProfile 应用配置文件
+func (h *TemplateHandler) ApplyProfile(c *fiber.Ctx) error {
+	name := c.Params("name")
+	if name == "" {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"success": false,
+			"error":   "Profile name is required",
+		})
+	}
+
+	// 这里简化处理，实际应该解析并应用配置文件
+	_, exists := h.templateManager.GetProfileConfig(name)
+	if !exists {
+		return c.Status(fiber.StatusNotFound).JSON(fiber.Map{
+			"success": false,
+			"error":   "Profile not found",
+		})
+	}
+
+	h.logger.Infof("Applied profile: %s", name)
+
+	return c.JSON(fiber.Map{
+		"success": true,
+		"message": fmt.Sprintf("Profile '%s' applied successfully", name),
+	})
+}
+
+// ListSnippets 列出所有代码片段
+func (h *TemplateHandler) ListSnippets(c *fiber.Ctx) error {
+	snippets := make(map[string]string)
+
+	// 这里简化处理，实际应该从templateManager获取
+	snippets["groups.txt"] = "Proxy group configuration snippets"
+	snippets["rename_node.txt"] = "Node renaming snippets"
+
+	return c.JSON(fiber.Map{
+		"success":  true,
+		"snippets": snippets,
+		"total":    len(snippets),
+	})
+}
+
+// GetSnippet 获取代码片段
+func (h *TemplateHandler) GetSnippet(c *fiber.Ctx) error {
+	name := c.Params("name")
+	if name == "" {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"success": false,
+			"error":   "Snippet name is required",
+		})
+	}
+
+	snippet, exists := h.templateManager.GetSnippet(name)
+	if !exists {
+		return c.Status(fiber.StatusNotFound).JSON(fiber.Map{
+			"success": false,
+			"error":   "Snippet not found",
+		})
+	}
+
+	c.Set("Content-Type", "text/plain")
+	return c.SendString(snippet)
+}
+
+// ReloadTemplates 重新加载模板
+func (h *TemplateHandler) ReloadTemplates(c *fiber.Ctx) error {
+	if err := h.templateManager.Reload(); err != nil {
+		h.logger.Errorf("Failed to reload templates: %v", err)
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"success": false,
+			"error":   fmt.Sprintf("Failed to reload templates: %v", err),
+		})
+	}
+
+	h.logger.Info("Templates reloaded successfully")
+	return c.JSON(fiber.Map{
+		"success": true,
+		"message": "Templates reloaded successfully",
+	})
+}
+
+// GetTemplatesInfo 获取模板系统信息
+func (h *TemplateHandler) GetTemplatesInfo(c *fiber.Ctx) error {
+	templates := h.templateManager.ListTemplates()
+	rulesets := h.templateManager.ListRulesets()
+	profiles := h.templateManager.ListProfileConfigs()
+
+	info := fiber.Map{
+		"template_count":  len(templates),
+		"ruleset_count":   len(rulesets),
+		"profile_count":   len(profiles),
+		"base_path":       h.configManager.GetBasePath(),
+		"supported_types": []string{"clash", "surge", "quanx", "loon", "surfboard", "v2ray"},
+	}
+
+	return c.JSON(fiber.Map{
+		"success": true,
+		"info":    info,
+	})
+}
+
+// 辅助方法
+
+// isTemplateOfType 检查模板是否为指定类型
+func (h *TemplateHandler) isTemplateOfType(name, templateType string) bool {
+	return strings.Contains(strings.ToLower(name), strings.ToLower(templateType))
+}
+
+// getTemplateType 获取模板类型
+func (h *TemplateHandler) getTemplateType(name string) string {
+	name = strings.ToLower(name)
+	switch {
+	case strings.Contains(name, "clash"):
+		return "clash"
+	case strings.Contains(name, "surge"):
+		return "surge"
+	case strings.Contains(name, "quanx"):
+		return "quanx"
+	case strings.Contains(name, "loon"):
+		return "loon"
+	case strings.Contains(name, "surfboard"):
+		return "surfboard"
+	case strings.Contains(name, "v2ray"):
+		return "v2ray"
+	default:
+		return "unknown"
+	}
+}
+
+// getTemplateDescription 获取模板描述
+func (h *TemplateHandler) getTemplateDescription(name string) string {
+	descriptions := map[string]string{
+		"GeneralClashConfig": "General Clash configuration template",
+		"forcerule":          "Force rule configuration template",
+		"surge.conf":         "Surge configuration template",
+		"quan.conf":          "Quantumult configuration template",
+		"loon.conf":          "Loon configuration template",
+		"surfboard.conf":     "Surfboard configuration template",
+	}
+
+	if desc, exists := descriptions[name]; exists {
+		return desc
+	}
+	return fmt.Sprintf("Template: %s", name)
+}
+
+// getRulesetType 获取规则集类型
+func (h *TemplateHandler) getRulesetType(name string) string {
+	ext := filepath.Ext(name)
+	switch ext {
+	case ".list":
+		return "domain_list"
+	case ".txt":
+		return "text_rules"
+	case ".rules":
+		return "rules"
+	default:
+		return "unknown"
+	}
+}
+
+// getRulesetDescription 获取规则集描述
+func (h *TemplateHandler) getRulesetDescription(name string) string {
+	// 这里可以根据规则集名称返回描述
+	return fmt.Sprintf("Ruleset: %s", name)
+}
+
+// countRules 计算规则数量
+func (h *TemplateHandler) countRules(content string) int {
+	lines := strings.Split(content, "\n")
+	count := 0
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line != "" && !strings.HasPrefix(line, "#") {
+			count++
+		}
+	}
+	return count
+}
+
+// parseGlobalConfig 解析全局配置
+func (h *TemplateHandler) parseGlobalConfig(cfg map[string]interface{}) config.TemplateConfig {
+	var globalConfig config.TemplateConfig
+
+	// 解析Clash配置
+	if clash, ok := cfg["clash"].(map[string]interface{}); ok {
+		globalConfig.Clash.HTTPPort = h.getInt(clash, "http_port", 7890)
+		globalConfig.Clash.SocksPort = h.getInt(clash, "socks_port", 7891)
+		globalConfig.Clash.AllowLAN = h.getBool(clash, "allow_lan", true)
+		globalConfig.Clash.LogLevel = h.getString(clash, "log_level", "info")
+		globalConfig.Clash.ExternalController = h.getString(clash, "external_controller", "127.0.0.1:9090")
+	}
+
+	// 解析Surge配置
+	if surge, ok := cfg["surge"].(map[string]interface{}); ok {
+		globalConfig.Surge.Port = h.getInt(surge, "port", 8080)
+		globalConfig.Surge.ProxyHTTPPort = h.getInt(surge, "proxy_http_port", 8081)
+		globalConfig.Surge.ProxySOCKS5Port = h.getInt(surge, "proxy_socks5_port", 8082)
+		globalConfig.Surge.MixedPort = h.getInt(surge, "mixed_port", 8080)
+		globalConfig.Surge.AllowLAN = h.getBool(surge, "allow_lan", true)
+		globalConfig.Surge.LogLevel = h.getString(surge, "log_level", "info")
+	}
+
+	return globalConfig
+}
+
+// getInt 获取整数值
+func (h *TemplateHandler) getInt(m map[string]interface{}, key string, defaultValue int) int {
+	if val, ok := m[key]; ok {
+		switch v := val.(type) {
+		case float64:
+			return int(v)
+		case int:
+			return v
+		case string:
+			if i, err := strconv.Atoi(v); err == nil {
+				return i
+			}
+		}
+	}
+	return defaultValue
+}
+
+// getBool 获取布尔值
+func (h *TemplateHandler) getBool(m map[string]interface{}, key string, defaultValue bool) bool {
+	if val, ok := m[key]; ok {
+		switch v := val.(type) {
+		case bool:
+			return v
+		case string:
+			if b, err := strconv.ParseBool(v); err == nil {
+				return b
+			}
+		}
+	}
+	return defaultValue
+}
+
+// getString 获取字符串值
+func (h *TemplateHandler) getString(m map[string]interface{}, key string, defaultValue string) string {
+	if val, ok := m[key]; ok {
+		if str, ok := val.(string); ok {
+			return str
+		}
+	}
+	return defaultValue
+}
+
+// getTotalNodes 获取节点总数
+func (h *TemplateHandler) getTotalNodes(nodeData interface{}) int {
+	if nodeData == nil {
+		return 0
+	}
+
+	// 根据不同的数据结构计算节点数量
+	switch data := nodeData.(type) {
+	case []interface{}:
+		return len(data)
+	case map[string]interface{}:
+		if proxies, ok := data["proxies"].([]interface{}); ok {
+			return len(proxies)
+		}
+	}
+
+	return 1 // 默认返回1
+}
+
+// getSampleNodeData 获取示例节点数据
+func (h *TemplateHandler) getSampleNodeData() interface{} {
+	return map[string]interface{}{
+		"remark":   "Sample Server",
+		"hostname": "sample.example.com",
+		"port":     443,
+		"type":     "shadowsocks",
+		"settings": map[string]interface{}{
+			"method":   "aes-256-gcm",
+			"password": "sample-password",
+		},
+	}
+}
+
+// getContentType 获取内容类型
+func (h *TemplateHandler) getContentType(name string) string {
+	ext := filepath.Ext(name)
+	switch ext {
+	case ".yml", ".yaml":
+		return "application/x-yaml"
+	case ".json":
+		return "application/json"
+	case ".conf":
+		return "text/plain"
+	default:
+		return "text/plain"
+	}
+}