wx_service/internal/common/auth/service/auth_service.go

package service

import (
	"context"
	"errors"
	"fmt"
	"strings"
	"sync"

	"wx_service/internal/model"
	smokemodel "wx_service/internal/smoke/model"

	"gorm.io/gorm"
)

var (
	ErrCodeRequired        = errors.New("code is required")
	ErrMiniProgramRequired = errors.New("mini program id is required")
	ErrMiniProgramNotFound = errors.New("mini program not found")
)

const defaultAvatarURL = "https://linghu-wmr.oss-cn-beijing.aliyuncs.com/smt/avatar.png"

type AuthService struct {
	db                *gorm.DB
	miniProgramSvc    *MiniProgramService
	wechatClientCache map[uint]*WeChatClient
	cacheMu           sync.RWMutex
}

type LoginRequest struct {
	MiniProgramID uint
	Code          string
	NickName      string
	AvatarURL     string
	Gender        *int
	Phone         string
}

type LoginResult struct {
	User        *model.User
	SessionKey  string
	MiniProgram *model.MiniProgram
	Mode        string
}

func NewAuthService(db *gorm.DB, miniProgramSvc *MiniProgramService) *AuthService {
	return &AuthService{
		db:                db,
		miniProgramSvc:    miniProgramSvc,
		wechatClientCache: make(map[uint]*WeChatClient),
	}
}

func (s *AuthService) LoginWithCode(ctx context.Context, req LoginRequest) (*LoginResult, error) {
	if req.MiniProgramID == 0 {
		return nil, ErrMiniProgramRequired
	}
	if req.Code == "" {
		return nil, ErrCodeRequired
	}

	miniProgram, err := s.miniProgramSvc.GetByID(ctx, req.MiniProgramID)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, ErrMiniProgramNotFound
		}
		return nil, fmt.Errorf("load mini program: %w", err)
	}

	client := s.getWeChatClient(miniProgram)
	session, err := client.Code2Session(ctx, req.Code)
	if err != nil {
		return nil, err
	}
	if session.OpenID == "" {
		return nil, fmt.Errorf("wechat response missing openid")
	}

	avatarURL := normalizeAvatarURL(req.AvatarURL)

	tx := s.db.WithContext(ctx)
	var user model.User
	err = tx.Where("mini_program_id = ? AND open_id = ?", miniProgram.ID, session.OpenID).First(&user).Error
	if errors.Is(err, gorm.ErrRecordNotFound) {
		user = model.User{
			MiniProgramID: miniProgram.ID,
			OpenID:        session.OpenID,
			UnionID:       session.UnionID,
			NickName:      req.NickName,
			AvatarURL:     avatarURL,
			Phone:         req.Phone,
			SessionKey:    session.SessionKey,
		}
		if req.Gender != nil {
			user.Gender = *req.Gender
		}
		if err := tx.Create(&user).Error; err != nil {
			return nil, fmt.Errorf("create user: %w", err)
		}
	} else if err != nil {
		return nil, fmt.Errorf("query user: %w", err)
	} else {
		updates := map[string]interface{}{
			"session_key": session.SessionKey,
		}
		if session.UnionID != "" && session.UnionID != user.UnionID {
			updates["union_id"] = session.UnionID
			user.UnionID = session.UnionID
		}
		if req.NickName != "" && req.NickName != user.NickName {
			updates["nick_name"] = req.NickName
			user.NickName = req.NickName
		}
		if req.AvatarURL != "" && avatarURL != user.AvatarURL {
			updates["avatar_url"] = avatarURL
			user.AvatarURL = avatarURL
		}
		if strings.TrimSpace(user.AvatarURL) == "" {
			updates["avatar_url"] = defaultAvatarURL
			user.AvatarURL = defaultAvatarURL
		}
		if req.Phone != "" && req.Phone != user.Phone {
			updates["phone"] = req.Phone
			user.Phone = req.Phone
		}
		if req.Gender != nil && user.Gender != *req.Gender {
			updates["gender"] = *req.Gender
			user.Gender = *req.Gender
		}
		if len(updates) > 0 {
			if err := tx.Model(&user).Updates(updates).Error; err != nil {
				return nil, fmt.Errorf("update user: %w", err)
			}
		}
		user.SessionKey = session.SessionKey
	}

	result := &LoginResult{
		User:        &user,
		SessionKey:  session.SessionKey,
		MiniProgram: miniProgram,
	}
	if mode, err := s.getSmokeMode(ctx, int(user.ID)); err == nil {
		result.Mode = mode
	}
	return result, nil
}

func (s *AuthService) getSmokeMode(ctx context.Context, uid int) (string, error) {
	var profile smokemodel.SmokeUserProfile
	err := s.db.WithContext(ctx).
		Select("mode").
		Where("uid = ? AND deleted_at IS NULL", uid).
		First(&profile).Error
	if err == nil {
		return normalizeSmokeMode(profile.Mode), nil
	}
	if errors.Is(err, gorm.ErrRecordNotFound) {
		return "", nil
	}
	return "", fmt.Errorf("load smoke profile mode: %w", err)
}

func normalizeSmokeMode(mode string) string {
	switch strings.TrimSpace(mode) {
	case "quit":
		return "quit"
	case "record":
		return "record"
	default:
		return ""
	}
}

func (s *AuthService) getWeChatClient(mp *model.MiniProgram) *WeChatClient {
	s.cacheMu.RLock()
	client, ok := s.wechatClientCache[mp.ID]
	s.cacheMu.RUnlock()
	if ok {
		return client
	}

	newClient := NewWeChatClient(mp.AppID, mp.AppSecret, nil)
	s.cacheMu.Lock()
	s.wechatClientCache[mp.ID] = newClient
	s.cacheMu.Unlock()
	return newClient
}

func normalizeAvatarURL(raw string) string {
	text := strings.TrimSpace(raw)
	if text == "" {
		return defaultAvatarURL
	}
	return text
}