perms-system-server/internal/logic/product/createProductLogic.go

package product

import (
	"context"
	"crypto/rand"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"regexp"
	"time"

	"perms-system-server/internal/consts"
	authHelper "perms-system-server/internal/logic/auth"
	productModel "perms-system-server/internal/model/product"
	"perms-system-server/internal/model/productmember"
	userModel "perms-system-server/internal/model/user"
	"perms-system-server/internal/response"
	"perms-system-server/internal/svc"
	"perms-system-server/internal/types"
	"perms-system-server/internal/util"

	"github.com/zeromicro/go-zero/core/logx"
	"github.com/zeromicro/go-zero/core/stores/sqlx"
	"golang.org/x/crypto/bcrypt"
)

// 审计 M-4：CreateProduct 不再把 adminPassword/appSecret 明文写入响应体；改为把"真正的初始凭证"
// 暂存 Redis，并只把一次性消费票据放进响应。票据本身是短期（5 分钟）+ 一次性，即使被上游日志/APM
// 错误记录，也只能换一次而无法长期复用。
const (
	initialCredentialsTTL       = 5 * time.Minute
	initialCredentialsKeyPrefix = "pm:initcred:"
)

// initialCredentialsPayload 实际落 Redis 的凭证载荷。放在内部文件以避免跨包暴露结构。
type initialCredentialsPayload struct {
	AppKey        string `json:"appKey"`
	AppSecret     string `json:"appSecret"`
	AdminUser     string `json:"adminUser"`
	AdminPassword string `json:"adminPassword"`
}

var productCodeRegexp = regexp.MustCompile(`^[a-zA-Z][a-zA-Z0-9_-]{1,63}$`)

type CreateProductLogic struct {
	logx.Logger
	ctx    context.Context
	svcCtx *svc.ServiceContext
}

func NewCreateProductLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateProductLogic {
	return &CreateProductLogic{
		Logger: logx.WithContext(ctx),
		ctx:    ctx,
		svcCtx: svcCtx,
	}
}

// CreateProduct 创建产品。仅超管可调用，自动生成 appKey/appSecret 和产品专属管理员账号，用于接入新的业务产品。
func (l *CreateProductLogic) CreateProduct(req *types.CreateProductReq) (resp *types.CreateProductResp, err error) {
	if err := authHelper.RequireSuperAdmin(l.ctx); err != nil {
		return nil, err
	}

	if !productCodeRegexp.MatchString(req.Code) {
		return nil, response.ErrBadRequest("产品编码只能包含字母、数字、下划线和中划线，须以字母开头，长度2-64")
	}
	if len(req.Name) > 64 {
		return nil, response.ErrBadRequest("产品名称长度不能超过64个字符")
	}
	if len(req.Remark) > 255 {
		return nil, response.ErrBadRequest("备注长度不能超过255个字符")
	}

	_, findErr := l.svcCtx.SysProductModel.FindOneByCode(l.ctx, req.Code)
	if findErr == nil {
		return nil, response.ErrConflict("产品编码已存在")
	}

	appKey, err := generateRandomHex(16)
	if err != nil {
		return nil, err
	}
	rawAppSecret, err := generateRandomHex(32)
	if err != nil {
		return nil, err
	}
	appSecretHash, err := bcrypt.GenerateFromPassword([]byte(rawAppSecret), bcrypt.DefaultCost)
	if err != nil {
		return nil, err
	}
	now := time.Now().Unix()

	adminUsername := fmt.Sprintf("admin_%s", req.Code)
	if _, err := l.svcCtx.SysUserModel.FindOneByUsername(l.ctx, adminUsername); err == nil {
		return nil, response.ErrConflict(fmt.Sprintf("用户名 %s 已存在，无法自动创建管理员账号", adminUsername))
	}
	adminPassword, err := generateRandomHex(12)
	if err != nil {
		return nil, err
	}
	hashedPwd, err := bcrypt.GenerateFromPassword([]byte(adminPassword), bcrypt.DefaultCost)
	if err != nil {
		return nil, err
	}

	var (
		productId int64
		adminId   int64
		memberId  int64
	)

	err = l.svcCtx.SysProductModel.TransactCtx(l.ctx, func(ctx context.Context, session sqlx.Session) error {
		result, err := l.svcCtx.SysProductModel.InsertWithTx(ctx, session, &productModel.SysProduct{
			Code:       req.Code,
			Name:       req.Name,
			AppKey:     appKey,
			AppSecret:  string(appSecretHash),
			Remark:     req.Remark,
			Status:     consts.StatusEnabled,
			CreateTime: now,
			UpdateTime: now,
		})
		if err != nil {
			return err
		}
		productId, _ = result.LastInsertId()

		userResult, err := l.svcCtx.SysUserModel.InsertWithTx(ctx, session, &userModel.SysUser{
			Username:           adminUsername,
			Password:           string(hashedPwd),
			Nickname:           fmt.Sprintf("%s管理员", req.Name),
			IsSuperAdmin:       consts.IsSuperAdminNo,
			MustChangePassword: consts.MustChangePasswordYes,
			Status:             consts.StatusEnabled,
			CreateTime:         now,
			UpdateTime:         now,
		})
		if err != nil {
			return err
		}
		adminId, _ = userResult.LastInsertId()

		memberResult, err := l.svcCtx.SysProductMemberModel.InsertWithTx(ctx, session, &productmember.SysProductMember{
			ProductCode: req.Code,
			UserId:      adminId,
			MemberType:  consts.MemberTypeAdmin,
			Status:      consts.StatusEnabled,
			CreateTime:  now,
			UpdateTime:  now,
		})
		if err != nil {
			return err
		}
		memberId, _ = memberResult.LastInsertId()
		return nil
	})

	if err != nil {
		// 前置的 FindOneByCode / FindOneByUsername 已经在大多数合法请求里把"产品码/用户名已存在"
		// 分辨清楚并返回具体文案。落到这里的 1062 基本都是同秒并发创建的稀有竞态，按审计 M-5 的
		// 建议不再用 strings.Contains 匹配 MySQL 错误消息中的索引名（不同版本的文案不稳定，
		// 改索引名会导致静默降级成通用冲突）；直接统一回通用冲突让前端重试，由 pre-check 负责语义。
		if util.IsDuplicateEntryErr(err) {
			return nil, response.ErrConflict("数据冲突，请稍后重试")
		}
		return nil, err
	}

	// 生成一次性凭证票据（32 字节随机，hex 编码）。
	// 审计 M-1：DB 事务已成功提交，下面任一失败路径都必须把 product / user / product_member 三行
	// 一并补偿删除，否则新产生的 admin 明文密码只存在于本次内存里，一旦响应返回 500，账号就成了
	// 永久孤儿（仓库里没有 Delete/ResetInitCred 接口，只能手工改库）。补偿事务本身也可能失败，
	// 所以必须同步打一条 audit=create_product_orphan_cleanup 的 ERROR 日志把 productId/adminId/
	// memberId 落盘，作为告警与人工回捞的最后兜底。
	ticket, err := generateRandomHex(32)
	if err != nil {
		logx.WithContext(l.ctx).Errorf("CreateProduct: generate credentials ticket failed: %v", err)
		l.compensateCreatedRows(productId, adminId, memberId, req.Code, adminUsername, "generate_ticket_failed", err)
		return nil, response.NewCodeError(500, "生成初始凭证票据失败，请稍后重试")
	}
	payload := initialCredentialsPayload{
		AppKey:        appKey,
		AppSecret:     rawAppSecret,
		AdminUser:     adminUsername,
		AdminPassword: adminPassword,
	}
	buf, mErr := json.Marshal(&payload)
	if mErr != nil {
		logx.WithContext(l.ctx).Errorf("CreateProduct: marshal credentials payload failed: %v", mErr)
		l.compensateCreatedRows(productId, adminId, memberId, req.Code, adminUsername, "marshal_payload_failed", mErr)
		return nil, response.NewCodeError(500, "封装初始凭证失败，请稍后重试")
	}
	ticketKey := initialCredentialsKeyPrefix + ticket
	if setErr := l.svcCtx.Redis.SetexCtx(l.ctx, ticketKey, string(buf), int(initialCredentialsTTL/time.Second)); setErr != nil {
		logx.WithContext(l.ctx).Errorf("CreateProduct: stash credentials to redis failed: %v", setErr)
		l.compensateCreatedRows(productId, adminId, memberId, req.Code, adminUsername, "redis_setex_failed", setErr)
		return nil, response.NewCodeError(503, "暂存初始凭证失败，请稍后重试")
	}

	// 仅脱敏字段 + ticket 落响应体。productCode / adminUser 属于可公开的管理信息。
	logx.WithContext(l.ctx).Infof("CreateProduct: product=%s admin=%s credentialsTicketIssued ttl=%s",
		req.Code, adminUsername, initialCredentialsTTL)

	return &types.CreateProductResp{
		Id:                   productId,
		Code:                 req.Code,
		AppKey:               appKey,
		AdminUser:            adminUsername,
		CredentialsTicket:    ticket,
		CredentialsExpiresAt: time.Now().Add(initialCredentialsTTL).Unix(),
	}, nil
}

func generateRandomHex(byteLen int) (string, error) {
	b := make([]byte, byteLen)
	if _, err := rand.Read(b); err != nil {
		return "", fmt.Errorf("generate random bytes failed: %w", err)
	}
	return hex.EncodeToString(b), nil
}

// compensateCreatedRows 是审计 M-1 要求的失败补偿：事务已提交后 ticket/Redis 环节失败时，
// 把刚刚落盘的 sys_product_member / sys_user / sys_product 三行按"子 → 父"顺序全部删掉，
// 把副作用回到"从未创建"状态。补偿事务本身失败的概率不为 0（DB 再抖一次），因此我们：
//  1. 不让补偿失败吞掉原始响应（原始响应已经是 500/503，用户已知失败，继续返就行）；
//  2. 把三个主键落一条 audit=create_product_orphan_cleanup 的 ERROR 日志，带原始错误原因，
//     让告警侧能在第一时间拉出孤儿行做人工处理；
//  3. 补偿成功也打一条 INFO，让回归/测试能观测到补偿路径确实走到。
func (l *CreateProductLogic) compensateCreatedRows(productId, adminId, memberId int64, productCode, adminUsername, reason string, cause error) {
	if productId == 0 && adminId == 0 && memberId == 0 {
		return
	}
	// 用独立 context：l.ctx 走到这里有可能已经带了客户端取消/超时语义，但补偿是"一次尝试"
	// 的后端动作，不应被请求链路取消；5s 超时保证不阻塞响应返回。
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	compErr := l.svcCtx.SysProductModel.TransactCtx(ctx, func(txCtx context.Context, session sqlx.Session) error {
		if memberId > 0 {
			if err := l.svcCtx.SysProductMemberModel.DeleteWithTx(txCtx, session, memberId); err != nil {
				return fmt.Errorf("delete product_member: %w", err)
			}
		}
		if adminId > 0 {
			if err := l.svcCtx.SysUserModel.DeleteWithTx(txCtx, session, adminId); err != nil {
				return fmt.Errorf("delete user: %w", err)
			}
		}
		if productId > 0 {
			if err := l.svcCtx.SysProductModel.DeleteWithTx(txCtx, session, productId); err != nil {
				return fmt.Errorf("delete product: %w", err)
			}
		}
		return nil
	})
	if compErr != nil {
		logx.WithContext(l.ctx).Errorw("create product compensation failed",
			logx.Field("audit", "create_product_orphan_cleanup"),
			logx.Field("result", "compensate_failed"),
			logx.Field("reason", reason),
			logx.Field("cause", fmt.Sprintf("%v", cause)),
			logx.Field("productId", productId),
			logx.Field("productCode", productCode),
			logx.Field("adminId", adminId),
			logx.Field("adminUsername", adminUsername),
			logx.Field("memberId", memberId),
			logx.Field("compensationErr", compErr.Error()),
		)
		return
	}
	logx.WithContext(l.ctx).Infow("create product compensated after post-commit failure",
		logx.Field("audit", "create_product_orphan_cleanup"),
		logx.Field("result", "compensated"),
		logx.Field("reason", reason),
		logx.Field("cause", fmt.Sprintf("%v", cause)),
		logx.Field("productId", productId),
		logx.Field("productCode", productCode),
		logx.Field("adminId", adminId),
		logx.Field("adminUsername", adminUsername),
		logx.Field("memberId", memberId),
	)
}