zhangyan/cmr-mini
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

完善多赛道联调与全局产品架构

Browse Source
This commit is contained in:
zhangyan
2026-04-02 18:11:43 +08:00
parent 6964e26ec9
commit 0e28f70bad
45 changed files with 4819 additions and 282 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
backend/internal/service/entry_home_service.go
View File

@@ -55,6 +55,8 @@ type EntrySessionSummary struct {
EventName string `json:"eventName"`
ReleaseID *string `json:"releaseId,omitempty"`
ConfigLabel *string `json:"configLabel,omitempty"`
VariantID *string `json:"variantId,omitempty"`
VariantName *string `json:"variantName,omitempty"`
RouteCode *string `json:"routeCode,omitempty"`
LaunchedAt string `json:"launchedAt"`
StartedAt *string `json:"startedAt,omitempty"`
@@ -139,10 +141,12 @@ func (s *EntryHomeService) GetEntryHome(ctx context.Context, input EntryHomeInpu
func buildEntrySessionSummary(session *postgres.Session) EntrySessionSummary {
summary := EntrySessionSummary{
ID: session.SessionPublicID,
Status: session.Status,
RouteCode: session.RouteCode,
LaunchedAt: session.LaunchedAt.Format(timeRFC3339),
ID: session.SessionPublicID,
Status: session.Status,
VariantID: session.VariantID,
VariantName: session.VariantName,
RouteCode: session.RouteCode,
LaunchedAt: session.LaunchedAt.Format(timeRFC3339),
}
if session.EventPublicID != nil {
summary.EventID = *session.EventPublicID

7
backend/internal/service/event_play_service.go
View File

@@ -35,6 +35,8 @@ type EventPlayResult struct {
} `json:"release,omitempty"`
ResolvedRelease *ResolvedReleaseView `json:"resolvedRelease,omitempty"`
Play struct {
AssignmentMode *string `json:"assignmentMode,omitempty"`
CourseVariants []CourseVariantView `json:"courseVariants,omitempty"`
CanLaunch bool `json:"canLaunch"`
PrimaryAction string `json:"primaryAction"`
Reason string `json:"reason"`
@@ -77,6 +79,11 @@ func (s *EventPlayService) GetEventPlay(ctx context.Context, input EventPlayInpu
result.Event.DisplayName = event.DisplayName
result.Event.Summary = event.Summary
result.Event.Status = event.Status
variantPlan := resolveVariantPlan(event.ReleasePayloadJSON)
result.Play.AssignmentMode = variantPlan.AssignmentMode
if len(variantPlan.CourseVariants) > 0 {
result.Play.CourseVariants = variantPlan.CourseVariants
}
if event.CurrentReleasePubID != nil && event.ConfigLabel != nil && event.ManifestURL != nil {
result.Release = &struct {
ID string `json:"id"`

31
backend/internal/service/event_service.go
View File

@@ -37,6 +37,7 @@ type LaunchEventInput struct {
EventPublicID string
UserID string
ReleaseID string `json:"releaseId,omitempty"`
VariantID string `json:"variantId,omitempty"`
ClientType string `json:"clientType"`
DeviceKey string `json:"deviceKey"`
}
@@ -49,6 +50,7 @@ type LaunchEventResult struct {
Launch struct {
Source string `json:"source"`
ResolvedRelease *ResolvedReleaseView `json:"resolvedRelease,omitempty"`
Variant *VariantBindingView `json:"variant,omitempty"`
Config struct {
ConfigURL string `json:"configUrl"`
ConfigLabel string `json:"configLabel"`
@@ -115,6 +117,7 @@ func (s *EventService) GetEventDetail(ctx context.Context, eventPublicID string)
func (s *EventService) LaunchEvent(ctx context.Context, input LaunchEventInput) (*LaunchEventResult, error) {
input.EventPublicID = strings.TrimSpace(input.EventPublicID)
input.ReleaseID = strings.TrimSpace(input.ReleaseID)
input.VariantID = strings.TrimSpace(input.VariantID)
input.DeviceKey = strings.TrimSpace(input.DeviceKey)
if err := validateClientType(input.ClientType); err != nil {
return nil, err
@@ -139,6 +142,24 @@ func (s *EventService) LaunchEvent(ctx context.Context, input LaunchEventInput)
if input.ReleaseID != "" && input.ReleaseID != *event.CurrentReleasePubID {
return nil, apperr.New(http.StatusConflict, "release_not_launchable", "requested release is not the current published release")
}
variantPlan := resolveVariantPlan(event.ReleasePayloadJSON)
variant, err := resolveLaunchVariant(variantPlan, input.VariantID)
if err != nil {
return nil, err
}
routeCode := event.RouteCode
var assignmentMode *string
var variantID *string
var variantName *string
if variant != nil {
resultMode := variant.AssignmentMode
assignmentMode = &resultMode
variantID = &variant.ID
variantName = &variant.Name
if variant.RouteCode != nil {
routeCode = variant.RouteCode
}
}
tx, err := s.store.Begin(ctx)
if err != nil {
@@ -163,7 +184,10 @@ func (s *EventService) LaunchEvent(ctx context.Context, input LaunchEventInput)
EventReleaseID: *event.CurrentReleaseID,
DeviceKey: input.DeviceKey,
ClientType: input.ClientType,
RouteCode: event.RouteCode,
AssignmentMode: assignmentMode,
VariantID: variantID,
VariantName: variantName,
RouteCode: routeCode,
SessionTokenHash: security.HashText(sessionToken),
SessionTokenExpiresAt: sessionTokenExpiresAt,
})
@@ -180,16 +204,17 @@ func (s *EventService) LaunchEvent(ctx context.Context, input LaunchEventInput)
result.Event.DisplayName = event.DisplayName
result.Launch.Source = LaunchSourceEventCurrentRelease
result.Launch.ResolvedRelease = buildResolvedReleaseFromEvent(event, LaunchSourceEventCurrentRelease)
result.Launch.Variant = variant
result.Launch.Config.ConfigURL = *event.ManifestURL
result.Launch.Config.ConfigLabel = *event.ConfigLabel
result.Launch.Config.ConfigChecksumSha256 = event.ManifestChecksum
result.Launch.Config.ReleaseID = *event.CurrentReleasePubID
result.Launch.Config.RouteCode = event.RouteCode
result.Launch.Config.RouteCode = routeCode
result.Launch.Business.Source = "direct-event"
result.Launch.Business.EventID = event.PublicID
result.Launch.Business.SessionID = session.SessionPublicID
result.Launch.Business.SessionToken = sessionToken
result.Launch.Business.SessionTokenExpiresAt = session.SessionTokenExpiresAt.Format(time.RFC3339)
result.Launch.Business.RouteCode = event.RouteCode
result.Launch.Business.RouteCode = routeCode
return result, nil
}

6
backend/internal/service/session_service.go
View File

@@ -26,6 +26,9 @@ type SessionResult struct {
Status string `json:"status"`
ClientType string `json:"clientType"`
DeviceKey string `json:"deviceKey"`
AssignmentMode *string `json:"assignmentMode,omitempty"`
VariantID *string `json:"variantId,omitempty"`
VariantName *string `json:"variantName,omitempty"`
RouteCode *string `json:"routeCode,omitempty"`
SessionTokenExpiresAt string `json:"sessionTokenExpiresAt"`
LaunchedAt string `json:"launchedAt"`
@@ -264,6 +267,9 @@ func buildSessionResult(session *postgres.Session) *SessionResult {
result.Session.Status = session.Status
result.Session.ClientType = session.ClientType
result.Session.DeviceKey = session.DeviceKey
result.Session.AssignmentMode = session.AssignmentMode
result.Session.VariantID = session.VariantID
result.Session.VariantName = session.VariantName
result.Session.RouteCode = session.RouteCode
result.Session.SessionTokenExpiresAt = session.SessionTokenExpiresAt.Format(time.RFC3339)
result.Session.LaunchedAt = session.LaunchedAt.Format(time.RFC3339)

189
backend/internal/service/variant_contract.go Normal file
View File

@@ -0,0 +1,189 @@
package service
import (
"crypto/rand"
"encoding/json"
"fmt"
"math/big"
"net/http"
"strings"
"cmr-backend/internal/apperr"
)
const (
AssignmentModeManual = "manual"
AssignmentModeRandom = "random"
AssignmentModeServerAssigned = "server-assigned"
)
type CourseVariantView struct {
ID string `json:"id"`
Name string `json:"name"`
Description *string `json:"description,omitempty"`
RouteCode *string `json:"routeCode,omitempty"`
Selectable bool `json:"selectable"`
}
type VariantBindingView struct {
ID string `json:"id"`
Name string `json:"name"`
RouteCode *string `json:"routeCode,omitempty"`
AssignmentMode string `json:"assignmentMode"`
}
type VariantPlan struct {
AssignmentMode *string
CourseVariants []CourseVariantView
}
func resolveVariantPlan(payloadJSON *string) VariantPlan {
if payloadJSON == nil || strings.TrimSpace(*payloadJSON) == "" {
return VariantPlan{}
}
var payload map[string]any
if err := json.Unmarshal([]byte(*payloadJSON), &payload); err != nil {
return VariantPlan{}
}
play, _ := payload["play"].(map[string]any)
if len(play) == 0 {
return VariantPlan{}
}
result := VariantPlan{}
if rawMode, ok := play["assignmentMode"].(string); ok {
if normalized := normalizeAssignmentMode(rawMode); normalized != nil {
result.AssignmentMode = normalized
}
}
rawVariants, _ := play["courseVariants"].([]any)
if len(rawVariants) == 0 {
return result
}
for _, raw := range rawVariants {
item, ok := raw.(map[string]any)
if !ok {
continue
}
id, _ := item["id"].(string)
name, _ := item["name"].(string)
id = strings.TrimSpace(id)
name = strings.TrimSpace(name)
if id == "" || name == "" {
continue
}
var description *string
if value, ok := item["description"].(string); ok && strings.TrimSpace(value) != "" {
trimmed := strings.TrimSpace(value)
description = &trimmed
}
var routeCode *string
if value, ok := item["routeCode"].(string); ok && strings.TrimSpace(value) != "" {
trimmed := strings.TrimSpace(value)
routeCode = &trimmed
}
selectable := true
if value, ok := item["selectable"].(bool); ok {
selectable = value
}
result.CourseVariants = append(result.CourseVariants, CourseVariantView{
ID: id,
Name: name,
Description: description,
RouteCode: routeCode,
Selectable: selectable,
})
}
return result
}
func resolveLaunchVariant(plan VariantPlan, requestedVariantID string) (*VariantBindingView, error) {
requestedVariantID = strings.TrimSpace(requestedVariantID)
if len(plan.CourseVariants) == 0 {
return nil, nil
}
mode := AssignmentModeManual
if plan.AssignmentMode != nil {
mode = *plan.AssignmentMode
}
if requestedVariantID != "" {
for _, item := range plan.CourseVariants {
if item.ID == requestedVariantID {
if !item.Selectable && mode == AssignmentModeManual {
return nil, apperr.New(http.StatusBadRequest, "variant_not_selectable", "requested variant is not selectable")
}
return &VariantBindingView{
ID: item.ID,
Name: item.Name,
RouteCode: item.RouteCode,
AssignmentMode: mode,
}, nil
}
}
return nil, apperr.New(http.StatusBadRequest, "variant_not_found", "requested variant does not exist")
}
selected, err := selectDefaultVariant(plan.CourseVariants, mode)
if err != nil {
return nil, err
}
return &VariantBindingView{
ID: selected.ID,
Name: selected.Name,
RouteCode: selected.RouteCode,
AssignmentMode: mode,
}, nil
}
func normalizeAssignmentMode(value string) *string {
switch strings.TrimSpace(value) {
case AssignmentModeManual:
mode := AssignmentModeManual
return &mode
case AssignmentModeRandom:
mode := AssignmentModeRandom
return &mode
case AssignmentModeServerAssigned:
mode := AssignmentModeServerAssigned
return &mode
default:
return nil
}
}
func selectDefaultVariant(items []CourseVariantView, mode string) (*CourseVariantView, error) {
candidates := make([]CourseVariantView, 0, len(items))
for _, item := range items {
if item.Selectable {
candidates = append(candidates, item)
}
}
if len(candidates) == 0 {
candidates = append(candidates, items...)
}
if len(candidates) == 0 {
return nil, apperr.New(http.StatusBadRequest, "variant_not_found", "course variants are empty")
}
switch mode {
case AssignmentModeRandom:
index, err := rand.Int(rand.Reader, big.NewInt(int64(len(candidates))))
if err != nil {
return nil, apperr.New(http.StatusInternalServerError, "variant_select_failed", fmt.Sprintf("failed to select random variant: %v", err))
}
selected := candidates[int(index.Int64())]
return &selected, nil
case AssignmentModeServerAssigned, AssignmentModeManual:
fallthrough
default:
selected := candidates[0]
return &selected, nil
}
}