304 lines
10 KiB
Go
304 lines
10 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
|
|
"cmr-backend/internal/apperr"
|
|
"cmr-backend/internal/platform/security"
|
|
"cmr-backend/internal/store/postgres"
|
|
)
|
|
|
|
const (
|
|
GuestLaunchSource = "public-default-experience"
|
|
GuestIdentityProvider = "guest_device"
|
|
GuestIdentityType = "guest"
|
|
)
|
|
|
|
type PublicExperienceService struct {
|
|
store *postgres.Store
|
|
mapService *MapExperienceService
|
|
eventService *EventService
|
|
}
|
|
|
|
type PublicEventPlayInput struct {
|
|
EventPublicID string
|
|
}
|
|
|
|
type PublicLaunchEventInput struct {
|
|
EventPublicID string `json:"-"`
|
|
ReleaseID string `json:"releaseId,omitempty"`
|
|
VariantID string `json:"variantId,omitempty"`
|
|
ClientType string `json:"clientType"`
|
|
DeviceKey string `json:"deviceKey"`
|
|
}
|
|
|
|
func NewPublicExperienceService(store *postgres.Store, mapService *MapExperienceService, eventService *EventService) *PublicExperienceService {
|
|
return &PublicExperienceService{
|
|
store: store,
|
|
mapService: mapService,
|
|
eventService: eventService,
|
|
}
|
|
}
|
|
|
|
func (s *PublicExperienceService) ListMaps(ctx context.Context, input ListExperienceMapsInput) ([]ExperienceMapSummary, error) {
|
|
return s.mapService.ListMaps(ctx, input)
|
|
}
|
|
|
|
func (s *PublicExperienceService) GetMapDetail(ctx context.Context, mapPublicID string) (*ExperienceMapDetail, error) {
|
|
return s.mapService.GetMapDetail(ctx, mapPublicID)
|
|
}
|
|
|
|
func (s *PublicExperienceService) GetEventDetail(ctx context.Context, eventPublicID string) (*EventDetailResult, error) {
|
|
event, err := s.store.GetEventByPublicID(ctx, strings.TrimSpace(eventPublicID))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := ensurePublicExperienceEvent(event); err != nil {
|
|
return nil, err
|
|
}
|
|
return s.eventService.GetEventDetail(ctx, eventPublicID)
|
|
}
|
|
|
|
func (s *PublicExperienceService) GetEventPlay(ctx context.Context, input PublicEventPlayInput) (*EventPlayResult, error) {
|
|
input.EventPublicID = strings.TrimSpace(input.EventPublicID)
|
|
if input.EventPublicID == "" {
|
|
return nil, apperr.New(http.StatusBadRequest, "invalid_params", "event id is required")
|
|
}
|
|
|
|
event, err := s.store.GetEventByPublicID(ctx, input.EventPublicID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := ensurePublicExperienceEvent(event); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
result := &EventPlayResult{}
|
|
result.Event.ID = event.PublicID
|
|
result.Event.Slug = event.Slug
|
|
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"`
|
|
ConfigLabel string `json:"configLabel"`
|
|
ManifestURL string `json:"manifestUrl"`
|
|
ManifestChecksumSha256 *string `json:"manifestChecksumSha256,omitempty"`
|
|
RouteCode *string `json:"routeCode,omitempty"`
|
|
}{
|
|
ID: *event.CurrentReleasePubID,
|
|
ConfigLabel: *event.ConfigLabel,
|
|
ManifestURL: *event.ManifestURL,
|
|
ManifestChecksumSha256: event.ManifestChecksum,
|
|
RouteCode: event.RouteCode,
|
|
}
|
|
}
|
|
result.ResolvedRelease = buildResolvedReleaseFromEvent(event, GuestLaunchSource)
|
|
result.Runtime = buildRuntimeSummaryFromEvent(event)
|
|
if preview, err := buildPreviewFromPayload(event.ReleasePayloadJSON); err != nil {
|
|
return nil, err
|
|
} else {
|
|
result.Preview = preview
|
|
}
|
|
result.CurrentPresentation = buildPresentationSummaryFromEvent(event)
|
|
if enrichedPresentation, err := loadPresentationSummaryByPublicID(ctx, s.store, event.PresentationID); err != nil {
|
|
return nil, err
|
|
} else if enrichedPresentation != nil {
|
|
result.CurrentPresentation = enrichedPresentation
|
|
}
|
|
result.CurrentContentBundle = buildContentBundleSummaryFromEvent(event)
|
|
if enrichedBundle, err := loadContentBundleSummaryByPublicID(ctx, s.store, event.ContentBundleID); err != nil {
|
|
return nil, err
|
|
} else if enrichedBundle != nil {
|
|
result.CurrentContentBundle = enrichedBundle
|
|
}
|
|
|
|
canLaunch, launchReason := evaluateEventLaunchReadiness(event)
|
|
result.Play.CanLaunch = canLaunch
|
|
if canLaunch {
|
|
result.Play.LaunchSource = GuestLaunchSource
|
|
result.Play.PrimaryAction = "start"
|
|
result.Play.Reason = "guest can start default experience"
|
|
return result, nil
|
|
}
|
|
result.Play.PrimaryAction = "unavailable"
|
|
result.Play.Reason = launchReason
|
|
return result, nil
|
|
}
|
|
|
|
func (s *PublicExperienceService) LaunchEvent(ctx context.Context, input PublicLaunchEventInput) (*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 input.EventPublicID == "" || input.DeviceKey == "" {
|
|
return nil, apperr.New(http.StatusBadRequest, "invalid_params", "event id and deviceKey are required")
|
|
}
|
|
if err := validateClientType(input.ClientType); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
event, err := s.store.GetEventByPublicID(ctx, input.EventPublicID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := ensurePublicExperienceEvent(event); err != nil {
|
|
return nil, err
|
|
}
|
|
if canLaunch, reason := evaluateEventLaunchReadiness(event); !canLaunch {
|
|
return nil, launchReadinessError(reason)
|
|
}
|
|
if input.ReleaseID != "" && event.CurrentReleasePubID != nil && 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 {
|
|
return nil, err
|
|
}
|
|
defer tx.Rollback(ctx)
|
|
|
|
guestUser, err := s.findOrCreateGuestUser(ctx, tx, input.ClientType, input.DeviceKey)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := s.store.TouchUserLogin(ctx, tx, guestUser.ID); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
sessionPublicID, err := security.GeneratePublicID("sess")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
sessionToken, err := security.GenerateToken(32)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
sessionTokenExpiresAt := time.Now().UTC().Add(2 * time.Hour)
|
|
|
|
session, err := s.store.CreateGameSession(ctx, tx, postgres.CreateGameSessionParams{
|
|
SessionPublicID: sessionPublicID,
|
|
UserID: guestUser.ID,
|
|
EventID: event.ID,
|
|
EventReleaseID: *event.CurrentReleaseID,
|
|
DeviceKey: input.DeviceKey,
|
|
ClientType: input.ClientType,
|
|
AssignmentMode: assignmentMode,
|
|
VariantID: variantID,
|
|
VariantName: variantName,
|
|
RouteCode: routeCode,
|
|
SessionTokenHash: security.HashText(sessionToken),
|
|
SessionTokenExpiresAt: sessionTokenExpiresAt,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
result := &LaunchEventResult{}
|
|
result.Event.ID = event.PublicID
|
|
result.Event.DisplayName = event.DisplayName
|
|
result.Launch.Source = GuestLaunchSource
|
|
result.Launch.ResolvedRelease = buildResolvedReleaseFromEvent(event, GuestLaunchSource)
|
|
result.Launch.Variant = variant
|
|
result.Launch.Runtime = buildRuntimeSummaryFromEvent(event)
|
|
result.Launch.Presentation = buildPresentationSummaryFromEvent(event)
|
|
if enrichedPresentation, err := loadPresentationSummaryByPublicID(ctx, s.store, event.PresentationID); err != nil {
|
|
return nil, err
|
|
} else if enrichedPresentation != nil {
|
|
result.Launch.Presentation = enrichedPresentation
|
|
}
|
|
result.Launch.ContentBundle = buildContentBundleSummaryFromEvent(event)
|
|
if enrichedBundle, err := loadContentBundleSummaryByPublicID(ctx, s.store, event.ContentBundleID); err != nil {
|
|
return nil, err
|
|
} else if enrichedBundle != nil {
|
|
result.Launch.ContentBundle = enrichedBundle
|
|
}
|
|
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 = routeCode
|
|
result.Launch.Business.Source = GuestLaunchSource
|
|
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 = routeCode
|
|
result.Launch.Business.IsGuest = true
|
|
return result, nil
|
|
}
|
|
|
|
func (s *PublicExperienceService) findOrCreateGuestUser(ctx context.Context, tx postgres.Tx, clientType, deviceKey string) (*postgres.User, error) {
|
|
providerSubject := clientType + ":" + deviceKey
|
|
user, err := s.store.FindUserByProviderSubject(ctx, tx, GuestIdentityProvider, providerSubject)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if user != nil {
|
|
return user, nil
|
|
}
|
|
userPublicID, err := security.GeneratePublicID("usr")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
user, err = s.store.CreateUser(ctx, tx, postgres.CreateUserParams{
|
|
PublicID: userPublicID,
|
|
Status: "active",
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := s.store.CreateIdentity(ctx, tx, postgres.CreateIdentityParams{
|
|
UserID: user.ID,
|
|
IdentityType: GuestIdentityType,
|
|
Provider: GuestIdentityProvider,
|
|
ProviderSubj: providerSubject,
|
|
ProfileJSON: "{}",
|
|
}); err != nil {
|
|
return nil, err
|
|
}
|
|
return user, nil
|
|
}
|
|
|
|
func ensurePublicExperienceEvent(event *postgres.Event) error {
|
|
if event == nil {
|
|
return apperr.New(http.StatusNotFound, "event_not_found", "event not found")
|
|
}
|
|
if !event.IsDefaultExperience {
|
|
return apperr.New(http.StatusForbidden, "event_not_public", "event is not available in guest mode")
|
|
}
|
|
return nil
|
|
}
|