yunzerwebsiteallinone/go/controllers/backend_site_settings.go

package controllers

import (
	"encoding/json"
	"io"
	"strconv"
	"strings"
	"time"

	"server/models"
	"server/pkg/identity"
	"server/pkg/jwtutil"

	beego "github.com/beego/beego/v2/server/web"
)

// BackendSiteSettingsController 租户站点设置（站点基本信息）
// 对应前端 normalSettings.vue 的：
// - GET  /backend/normalInfos
// - POST /backend/saveNormalInfos
// - GET  /platform/normalInfos
// - POST /platform/saveNormalInfos
type BackendSiteSettingsController struct {
	beego.Controller
}

func (c *BackendSiteSettingsController) jsonErr(httpStatus, bizCode int, msg string) {
	c.Ctx.Output.SetStatus(httpStatus)
	c.Data["json"] = map[string]interface{}{"code": bizCode, "msg": msg}
	_ = c.ServeJSON()
}

func (c *BackendSiteSettingsController) claimsByPath() (*jwtutil.Claims, error) {
	return identity.ClaimsByPath(c.Ctx.Request.Header.Get("Authorization"), c.Ctx.Request.URL.Path)
}

func parseBackendUint64Flexible(v interface{}) uint64 {
	if v == nil {
		return 0
	}
	switch x := v.(type) {
	case float64:
		if x <= 0 {
			return 0
		}
		return uint64(x)
	case string:
		s := strings.TrimSpace(x)
		if s == "" {
			return 0
		}
		n, err := strconv.ParseUint(s, 10, 64)
		if err != nil || n == 0 {
			return 0
		}
		return n
	default:
		return 0
	}
}

type backendNormalInfosOutput struct {
	Sitename              string `json:"sitename"`
	Companyintroduction   string `json:"companyintroduction"`
	Description           string `json:"description"`
	Copyright             string `json:"copyright"`
	Companyname           string `json:"companyname"`
	CompanyShortName      string `json:"company_short_name"`
	CompanyEnglishName    string `json:"company_english_name"`
	CompanyEnglishShort   string `json:"company_english_short_name"`
	Icp                   string `json:"icp"`
	Logo                  string `json:"logo"`
	Logow                 string `json:"logow"`
	Ico                   string `json:"ico"`
}

// GetNormalInfos GET /backend/normalInfos 或 /platform/normalInfos
func (c *BackendSiteSettingsController) GetNormalInfos() {
	claims, err := c.claimsByPath()
	if err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, err.Error())
		return
	}

	// 归属租户由 resolveBackendTenantID 统一裁决（backend 端只认令牌）
	tid := c.resolveBackendTenantID(claims, nil)

	out := backendNormalInfosOutput{
		Sitename:            "",
		Companyintroduction: "",
		Description:         "",
		Copyright:           "",
		Companyname:         "",
		Icp:                 "",
		Logo:                "",
		Logow:               "",
		Ico:                 "",
	}

	// tid 缺失时不报错，直接返回空对象给前端渲染（避免 UI 直接崩）。
	if tid == 0 {
		c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success", "data": out}
		_ = c.ServeJSON()
		return
	}

	var rows []models.TenantSiteSetting
	_, err = models.Orm.QueryTable(new(models.TenantSiteSetting)).
		Filter("tid", tid).
		Filter("delete_time__isnull", true).
		Limit(1).
		All(&rows)
	if err != nil {
		c.jsonErr(500, 500, "获取失败: "+err.Error())
		return
	}
	if len(rows) > 0 {
		r := rows[0]
		out.Sitename = r.Sitename
		out.Companyintroduction = r.Companyintroduction
		out.Logo = r.Logo
		out.Logow = r.Logow
		out.Ico = r.Ico
		out.Description = r.Description
		out.Copyright = r.Copyright
		out.Companyname = r.Companyname
		out.Icp = r.Icp
	}

	// 扩展字段（企业简称 / 企业英文名称 / 企业英文简称）存放在 yz_system_tenant_setting_items
	if ext, eerr := c.getBackendSettingItems(tid, []string{
		"company_short_name", "company_english_name", "company_english_short_name",
	}); eerr == nil {
		out.CompanyShortName = ext["company_short_name"]
		out.CompanyEnglishName = ext["company_english_name"]
		out.CompanyEnglishShort = ext["company_english_short_name"]
	}

	c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success", "data": out}
	_ = c.ServeJSON()
}

// backendBrandOutput 后台顶栏品牌（Logo 优先用平台配置）
type backendBrandOutput struct {
	Sitename   string `json:"sitename"` // 主标题
	Subtitle   string `json:"subtitle"` // 副标题
	Intro      string `json:"intro"`
	Ico        string `json:"ico"`        // 浏览器标签页图标（favicon）
	LogoSquare string `json:"logoSquare"` // 正方形 Logo（浅色主题 / 顶栏小图标）
	LogoRect   string `json:"logoRect"`   // 长方形 Logo（浅色主题 / 横向品牌图）
	Logo       string `json:"logo"`       // 官网深色 Logo（浅色背景）
	Logow      string `json:"logow"`      // 官网浅色 Logo（深色背景）

	// 深色主题专用 Logo：留空时前端回退到上面的浅色主题版本
	LogoSquareDark string `json:"logoSquareDark"`
	LogoRectDark   string `json:"logoRectDark"`
}

// GetBrand GET /backend/brand 后台顶栏品牌信息（顶栏左上角 Logo / 站点名 / 简介）
// 取值优先级：
//  1. 平台「系统设置 - 平台设置 - 平台信息」（logo_square / logo_rect / sitename / platform_intro）
//  2. 平台「官网管理 - 站点设置」（yz_platform_site_setting：logo 深色 / logow 浅色）
//  3. 平台「平台设置 - 登录页设置」的 login_logo（仅在以上都没配 logo 时兜底）
//  4. 当前租户自己的站点设置（yz_tenant_site_setting，租户在 backend「站点设置」上传的图片）
//
// 都没有配置时返回空串，前端保留内置的品牌占位标记。
func (c *BackendSiteSettingsController) GetBrand() {
	claims, err := c.claimsByPath()
	if err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, err.Error())
		return
	}

	tags := models.GetPlatformSiteTagMap()
	out := backendBrandOutput{
		Sitename:       strings.TrimSpace(tags["sitename"]),
		Subtitle:       strings.TrimSpace(tags["subtitle"]),
		Intro:          strings.TrimSpace(tags["platform_intro"]),
		Ico:            strings.TrimSpace(tags["ico"]),
		LogoSquare:     strings.TrimSpace(tags["logo_square"]),
		LogoRect:       strings.TrimSpace(tags["logo_rect"]),
		LogoSquareDark: strings.TrimSpace(tags["logo_square_dark"]),
		LogoRectDark:   strings.TrimSpace(tags["logo_rect_dark"]),
		Logo:           strings.TrimSpace(tags["logo"]),
		Logow:          strings.TrimSpace(tags["logow"]),
	}
	if out.Logo == "" {
		out.Logo = strings.TrimSpace(tags["login_logo"])
	}
	if out.Logo == "" {
		out.Logo = out.LogoRect
	}

	// 平台未配置的项回落到租户站点设置，避免顶栏退化成占位标记
	if out.Logo == "" || out.Logow == "" || out.Sitename == "" {
		if tid := c.resolveBackendTenantID(claims, nil); tid > 0 {
			var rows []models.TenantSiteSetting
			if _, qerr := models.Orm.QueryTable(new(models.TenantSiteSetting)).
				Filter("tid", tid).
				Filter("delete_time__isnull", true).
				Limit(1).
				All(&rows); qerr == nil && len(rows) > 0 {
				r := rows[0]
				if out.Logo == "" {
					out.Logo = strings.TrimSpace(r.Logo)
				}
				if out.Logow == "" {
					out.Logow = strings.TrimSpace(r.Logow)
				}
				if out.Sitename == "" {
					out.Sitename = strings.TrimSpace(r.Sitename)
				}
			}
		}
	}

	c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success", "data": out}
	_ = c.ServeJSON()
}

type backendNormalInfosPayload struct {
	// 前端会传 tid（但我们仍优先使用 token 的 tenant_id）
	Tid interface{} `json:"tid"`

	Sitename              string `json:"sitename"`
	Companyintroduction   string `json:"companyintroduction"`
	Logo                  string `json:"logo"`
	Logow                 string `json:"logow"`
	Ico                   string `json:"ico"`
	Description           string `json:"description"`
	Copyright             string `json:"copyright"`
	Companyname           string `json:"companyname"`
	CompanyShortName      string `json:"company_short_name"`
	CompanyEnglishName    string `json:"company_english_name"`
	CompanyEnglishShort   string `json:"company_english_short_name"`
	Icp                   string `json:"icp"`
}

// SaveNormalInfos POST /backend/saveNormalInfos 或 /platform/saveNormalInfos
func (c *BackendSiteSettingsController) SaveNormalInfos() {
	claims, err := c.claimsByPath()
	if err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, err.Error())
		return
	}

	raw, err := io.ReadAll(c.Ctx.Request.Body)
	if err != nil {
		c.jsonErr(400, 400, "参数错误")
		return
	}

	var p backendNormalInfosPayload
	if uerr := json.Unmarshal(raw, &p); uerr != nil {
		c.jsonErr(400, 400, "参数错误")
		return
	}

	tid := c.resolveBackendTenantID(claims, p.Tid)
	if tid == 0 {
		c.jsonErr(400, 400, "tid不能为空")
		return
	}

	sitename := strings.TrimSpace(p.Sitename)
	if sitename == "" {
		c.jsonErr(400, 400, "站点名称不能为空")
		return
	}

	now := time.Now()

	up := map[string]interface{}{
		"tid":                 tid,
		"sitename":            sitename,
		"companyintroduction": strings.TrimSpace(p.Companyintroduction),
		"logo":                strings.TrimSpace(p.Logo),
		"logow":               strings.TrimSpace(p.Logow),
		"ico":                 strings.TrimSpace(p.Ico),
		"description":         strings.TrimSpace(p.Description),
		"copyright":           strings.TrimSpace(p.Copyright),
		"companyname":         strings.TrimSpace(p.Companyname),
		"icp":                 strings.TrimSpace(p.Icp),
		"update_time":         now,
	}

	cnt, err := models.Orm.QueryTable(new(models.TenantSiteSetting)).
		Filter("tid", tid).
		Filter("delete_time__isnull", true).
		Count()
	if err != nil {
		c.jsonErr(500, 500, "保存失败: "+err.Error())
		return
	}

	if cnt == 0 {
		row := &models.TenantSiteSetting{
			Tid:                 tid,
			Sitename:            sitename,
			Companyintroduction: strings.TrimSpace(p.Companyintroduction),
			Logo:                strings.TrimSpace(p.Logo),
			Logow:               strings.TrimSpace(p.Logow),
			Ico:                 strings.TrimSpace(p.Ico),
			Description:         strings.TrimSpace(p.Description),
			Copyright:           strings.TrimSpace(p.Copyright),
			Companyname:         strings.TrimSpace(p.Companyname),
			Icp:                 strings.TrimSpace(p.Icp),
			CreateTime:          now,
			UpdateTime:          &now,
		}
		_, err = models.Orm.Insert(row)
		if err != nil {
			c.jsonErr(500, 500, "保存失败: "+err.Error())
			return
		}
	} else {
		_, err = models.Orm.QueryTable(new(models.TenantSiteSetting)).
			Filter("tid", tid).
			Filter("delete_time__isnull", true).
			Update(up)
		if err != nil {
			c.jsonErr(500, 500, "保存失败: "+err.Error())
			return
		}
	}

	// 扩展字段（企业简称 / 企业英文名称 / 企业英文简称）
	if err = c.saveBackendSettingItems(tid, map[string]string{
		"company_short_name":        strings.TrimSpace(p.CompanyShortName),
		"company_english_name":      strings.TrimSpace(p.CompanyEnglishName),
		"company_english_short_name": strings.TrimSpace(p.CompanyEnglishShort),
	}); err != nil {
		c.jsonErr(500, 500, "保存扩展信息失败: "+err.Error())
		return
	}

	c.Data["json"] = map[string]interface{}{"code": 200, "msg": "保存成功"}
	_ = c.ServeJSON()
}

// resolveBackendTenantID 取站点设置归属租户：
//   - backend 路径只认登录态，忽略 ?tid= 与请求体里的 tid——否则改一个参数就能读写别的企业站点设置；
//   - platform 路径下平台管理员令牌的 tenant_id 为 0，需要按参数指定要维护哪家企业。
func (c *BackendSiteSettingsController) resolveBackendTenantID(claims *jwtutil.Claims, payloadTid interface{}) uint64 {
	if claims != nil && claims.TenantId > 0 {
		return uint64(claims.TenantId)
	}
	if !strings.HasPrefix(strings.ToLower(c.Ctx.Request.URL.Path), "/platform/") {
		return 0
	}
	if tid := parseBackendUint64Flexible(payloadTid); tid > 0 {
		return tid
	}
	return parseBackendUint64Flexible(strings.TrimSpace(c.GetString("tid")))
}

func (c *BackendSiteSettingsController) getBackendSettingItems(tid uint64, keys []string) (map[string]string, error) {
	out := make(map[string]string, len(keys))
	for _, key := range keys {
		out[key] = ""
	}

	type rowItem struct {
		SettingKey   string
		SettingValue string
	}
	var rows []rowItem
	_, err := models.Orm.Raw(
		"SELECT setting_key, IFNULL(setting_value, '') AS setting_value FROM yz_system_tenant_setting_items WHERE tid = ? AND setting_key IN ('"+strings.Join(keys, "','")+"') AND delete_time IS NULL",
		tid,
	).QueryRows(&rows)
	if err != nil {
		return out, err
	}

	for _, row := range rows {
		out[row.SettingKey] = row.SettingValue
	}
	return out, nil
}

func (c *BackendSiteSettingsController) saveBackendSettingItems(tid uint64, values map[string]string) error {
	for key, value := range values {
		_, err := models.Orm.Raw(`
INSERT INTO yz_system_tenant_setting_items (tid, setting_key, setting_value, create_time, update_time)
VALUES (?, ?, ?, NOW(), NOW())
ON DUPLICATE KEY UPDATE setting_value = VALUES(setting_value), update_time = NOW(), delete_time = NULL
`, tid, key, value).Exec()
		if err != nil {
			return err
		}
	}
	return nil
}

// GetLegalInfos GET /backend/legalInfos
func (c *BackendSiteSettingsController) GetLegalInfos() {
	claims, err := c.claimsByPath()
	if err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, err.Error())
		return
	}

	tid := c.resolveBackendTenantID(claims, nil)
	if tid == 0 {
		c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success", "data": []map[string]string{
			{"label": "legalNotice", "value": ""},
			{"label": "privacyTerms", "value": ""},
		}}
		_ = c.ServeJSON()
		return
	}

	values, err := c.getBackendSettingItems(tid, []string{"legalNotice", "privacyTerms"})
	if err != nil {
		c.jsonErr(500, 500, "获取失败: "+err.Error())
		return
	}

	c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success", "data": []map[string]string{
		{"label": "legalNotice", "value": values["legalNotice"]},
		{"label": "privacyTerms", "value": values["privacyTerms"]},
	}}
	_ = c.ServeJSON()
}

type backendLegalInfosPayload struct {
	Tid          interface{} `json:"tid"`
	LegalNotice  string      `json:"legalNotice"`
	PrivacyTerms string      `json:"privacyTerms"`
}

// SaveLegalInfos POST /backend/saveLegalInfos
func (c *BackendSiteSettingsController) SaveLegalInfos() {
	claims, err := c.claimsByPath()
	if err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, err.Error())
		return
	}

	raw, err := io.ReadAll(c.Ctx.Request.Body)
	if err != nil {
		c.jsonErr(400, 400, "参数错误")
		return
	}
	var p backendLegalInfosPayload
	if err := json.Unmarshal(raw, &p); err != nil {
		c.jsonErr(400, 400, "参数错误")
		return
	}

	tid := c.resolveBackendTenantID(claims, p.Tid)
	if tid == 0 {
		c.jsonErr(400, 400, "tid不能为空")
		return
	}

	err = c.saveBackendSettingItems(tid, map[string]string{
		"legalNotice":  strings.TrimSpace(p.LegalNotice),
		"privacyTerms": strings.TrimSpace(p.PrivacyTerms),
	})
	if err != nil {
		c.jsonErr(500, 500, "保存失败: "+err.Error())
		return
	}

	c.Data["json"] = map[string]interface{}{"code": 200, "msg": "保存成功"}
	_ = c.ServeJSON()
}

// GetCompanyInfos GET /backend/companyInfos
func (c *BackendSiteSettingsController) GetCompanyInfos() {
	claims, err := c.claimsByPath()
	if err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, err.Error())
		return
	}

	tid := c.resolveBackendTenantID(claims, nil)
	out := map[string]interface{}{
		"contact_phone": "",
		"contact_email": "",
		"address":       "",
		"worktime":      "",
	}
	if tid == 0 {
		c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success", "data": out}
		_ = c.ServeJSON()
		return
	}

	var row models.SystemTenant
	err = models.Orm.QueryTable(new(models.SystemTenant)).
		Filter("id", tid).
		Filter("delete_time__isnull", true).
		One(&row)
	if err != nil {
		c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success", "data": out}
		_ = c.ServeJSON()
		return
	}

	if row.ContactPhone != nil {
		out["contact_phone"] = *row.ContactPhone
	}
	if row.ContactEmail != nil {
		out["contact_email"] = *row.ContactEmail
	}
	if row.Address != nil {
		out["address"] = *row.Address
	}
	if row.Worktime != nil {
		out["worktime"] = *row.Worktime
	}

	c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success", "data": out}
	_ = c.ServeJSON()
}

type backendCompanyInfosPayload struct {
	Tid          interface{} `json:"tid"`
	ContactPhone string      `json:"contact_phone"`
	ContactEmail string      `json:"contact_email"`
	Address      string      `json:"address"`
	Worktime     string      `json:"worktime"`
}

// SaveCompanyInfos POST /backend/saveCompanyInfos
func (c *BackendSiteSettingsController) SaveCompanyInfos() {
	claims, err := c.claimsByPath()
	if err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, err.Error())
		return
	}

	raw, err := io.ReadAll(c.Ctx.Request.Body)
	if err != nil {
		c.jsonErr(400, 400, "参数错误")
		return
	}
	var p backendCompanyInfosPayload
	if err := json.Unmarshal(raw, &p); err != nil {
		c.jsonErr(400, 400, "参数错误")
		return
	}

	tid := c.resolveBackendTenantID(claims, p.Tid)
	if tid == 0 {
		c.jsonErr(400, 400, "tid不能为空")
		return
	}

	_, err = models.Orm.QueryTable(new(models.SystemTenant)).
		Filter("id", tid).
		Filter("delete_time__isnull", true).
		Update(map[string]interface{}{
			"contact_phone": strings.TrimSpace(p.ContactPhone),
			"contact_email": strings.TrimSpace(p.ContactEmail),
			"address":       strings.TrimSpace(p.Address),
			"worktime":      strings.TrimSpace(p.Worktime),
			"update_time":   time.Now(),
		})
	if err != nil {
		c.jsonErr(500, 500, "保存失败: "+err.Error())
		return
	}

	c.Data["json"] = map[string]interface{}{"code": 200, "msg": "保存成功"}
	_ = c.ServeJSON()
}

// GetCompanySeo GET /backend/companySeo
func (c *BackendSiteSettingsController) GetCompanySeo() {
	claims, err := c.claimsByPath()
	if err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, err.Error())
		return
	}

	tid := c.resolveBackendTenantID(claims, nil)
	out := map[string]string{
		"seoTitle":       "",
		"seoKeywords":    "",
		"seoDescription": "",
	}
	if tid == 0 {
		c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success", "data": out}
		_ = c.ServeJSON()
		return
	}

	values, err := c.getBackendSettingItems(tid, []string{"seoTitle", "seoKeywords", "seoDescription"})
	if err != nil {
		c.jsonErr(500, 500, "获取失败: "+err.Error())
		return
	}
	out["seoTitle"] = values["seoTitle"]
	out["seoKeywords"] = values["seoKeywords"]
	out["seoDescription"] = values["seoDescription"]

	c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success", "data": out}
	_ = c.ServeJSON()
}

type backendCompanySeoPayload struct {
	Tid            interface{} `json:"tid"`
	SeoTitle       string      `json:"seoTitle"`
	SeoKeywords    string      `json:"seoKeywords"`
	SeoDescription string      `json:"seoDescription"`
}

// SaveCompanySeo POST /backend/saveCompanySeo
func (c *BackendSiteSettingsController) SaveCompanySeo() {
	claims, err := c.claimsByPath()
	if err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, err.Error())
		return
	}

	raw, err := io.ReadAll(c.Ctx.Request.Body)
	if err != nil {
		c.jsonErr(400, 400, "参数错误")
		return
	}
	var p backendCompanySeoPayload
	if err := json.Unmarshal(raw, &p); err != nil {
		c.jsonErr(400, 400, "参数错误")
		return
	}

	tid := c.resolveBackendTenantID(claims, p.Tid)
	if tid == 0 {
		c.jsonErr(400, 400, "tid不能为空")
		return
	}

	err = c.saveBackendSettingItems(tid, map[string]string{
		"seoTitle":       strings.TrimSpace(p.SeoTitle),
		"seoKeywords":    strings.TrimSpace(p.SeoKeywords),
		"seoDescription": strings.TrimSpace(p.SeoDescription),
	})
	if err != nil {
		c.jsonErr(500, 500, "保存失败: "+err.Error())
		return
	}

	c.Data["json"] = map[string]interface{}{"code": 200, "msg": "保存成功"}
	_ = c.ServeJSON()
}