Initial commit

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-15 13:57:10 +08:00
commit 8679200f41
1897 changed files with 257900 additions and 0 deletions
@@ -0,0 +1,348 @@
+package vipcardexperimentser
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"91porn-server/app/proto"
+	"91porn-server/models/v/vipcardexperimentmod"
+
+	"go.mongodb.org/mongo-driver/bson/primitive"
+)
+
+const maxEventsPerRequest = 50
+
+type EventInput struct {
+	EventID      string             `json:"eventId"`
+	EventName    string             `json:"eventName"`
+	SessionID    string             `json:"sessionId"`
+	OccurredAt   time.Time          `json:"occurredAt"`
+	ExperimentID string             `json:"experimentId"`
+	Variant      string             `json:"variant"`
+	ProductID    primitive.ObjectID `json:"productId"`
+}
+
+type EventsRequest struct {
+	Events []EventInput `json:"events" binding:"required"`
+}
+
+type EventsResponse struct {
+	Accepted   int `json:"accepted"`
+	Duplicated int `json:"duplicated"`
+}
+
+// ApplyToProductResponse applies the active experiment to the normal product response.
+// No experiment or an unusable configuration keeps the legacy response unchanged.
+func ApplyToProductResponse(uid uint64, response *proto.ProductRes, now time.Time) error {
+	if response == nil {
+		return nil
+	}
+	response.ExperimentStatus = vipcardexperimentmod.StatusDisabled
+	if uid == 0 {
+		return nil
+	}
+	experiment, err := vipcardexperimentmod.Current(now)
+	if err != nil || experiment == nil {
+		return err
+	}
+	variant := experiment.Assign(uid)
+	config, ok := experiment.ConfigFor(variant)
+	if !ok {
+		return nil
+	}
+	if !applyExperiment(response, experiment.ExperimentID, variant, config) {
+		return nil
+	}
+	otherConfig := experiment.VariantA
+	if variant == vipcardexperimentmod.VariantA {
+		otherConfig = experiment.VariantB
+	}
+	filterOtherVariantProducts(response, config.ProductIDs, otherConfig.ProductIDs)
+	return nil
+}
+
+func applyExperiment(
+	response *proto.ProductRes,
+	experimentID string,
+	variant string,
+	config vipcardexperimentmod.VariantConfig,
+) bool {
+	if !applyVariant(response, config) {
+		return false
+	}
+	response.ExperimentID = experimentID
+	response.ExperimentStatus = vipcardexperimentmod.StatusActive
+	response.Variant = variant
+	response.SkinKey = config.SkinKey
+	if !config.DefaultProductID.IsZero() {
+		response.DefaultProductID = config.DefaultProductID.Hex()
+	}
+	response.UIConfig = toResponseUIConfig(config.UIConfig)
+	return true
+}
+
+func toResponseUIConfig(config *vipcardexperimentmod.UIConfig) *proto.VIPCardUIConfig {
+	if config == nil {
+		return nil
+	}
+	response := &proto.VIPCardUIConfig{
+		BackgroundImage: config.BackgroundImage,
+		BadgeStyles:     make([]proto.VIPCardBadgeStyle, len(config.BadgeStyles)),
+	}
+	for i, style := range config.BadgeStyles {
+		response.BadgeStyles[i] = proto.VIPCardBadgeStyle{
+			BadgeType:       style.BadgeType,
+			BackgroundColor: style.BackgroundColor,
+			TextColor:       style.TextColor,
+		}
+	}
+	return response
+}
+
+func applyVariant(response *proto.ProductRes, config vipcardexperimentmod.VariantConfig) bool {
+	productByID := make(map[primitive.ObjectID]proto.VIPListRes)
+	positionByID := make(map[primitive.ObjectID]int)
+	for positionIndex := range response.List {
+		for _, product := range response.List[positionIndex].List {
+			productByID[product.ID] = product
+			positionByID[product.ID] = positionIndex
+		}
+	}
+
+	badges := make(map[primitive.ObjectID]vipcardexperimentmod.ProductBadge, len(config.ProductBadges))
+	for _, badge := range config.ProductBadges {
+		badges[badge.ProductID] = badge
+	}
+	affectedPositions := make(map[int]struct{})
+	orderedPositionIndexes := make([]int, 0, len(response.List))
+	selectedByPosition := make(map[int][]proto.VIPListRes)
+	defaultVisible := config.DefaultProductID.IsZero()
+	for productOrder, productID := range config.ProductIDs {
+		product, exists := productByID[productID]
+		if !exists {
+			continue
+		}
+		product.Sort = productOrder + 1
+		positionIndex := positionByID[productID]
+		if _, affected := affectedPositions[positionIndex]; !affected {
+			affectedPositions[positionIndex] = struct{}{}
+			orderedPositionIndexes = append(orderedPositionIndexes, positionIndex)
+		}
+		if badge, exists := badges[productID]; exists {
+			product.BadgeType = badge.BadgeType
+			product.BadgeText = badge.BadgeText
+		}
+		if productID == config.DefaultProductID {
+			defaultVisible = true
+		}
+		selectedByPosition[positionIndex] = append(selectedByPosition[positionIndex], product)
+	}
+	if len(affectedPositions) == 0 {
+		return false
+	}
+	if !defaultVisible {
+		return false
+	}
+	firstAffectedPosition := len(response.List)
+	for positionIndex := range affectedPositions {
+		if positionIndex < firstAffectedPosition {
+			firstAffectedPosition = positionIndex
+		}
+	}
+	orderedPositions := make([]proto.ProductList, 0, len(orderedPositionIndexes))
+	for _, positionIndex := range orderedPositionIndexes {
+		position := response.List[positionIndex]
+		position.List = selectedByPosition[positionIndex]
+		orderedPositions = append(orderedPositions, position)
+	}
+	positions := make([]proto.ProductList, 0, len(response.List))
+	for positionIndex, position := range response.List {
+		if positionIndex == firstAffectedPosition {
+			positions = append(positions, orderedPositions...)
+		}
+		if _, affected := affectedPositions[positionIndex]; affected {
+			continue
+		}
+		positions = append(positions, position)
+	}
+	response.List = positions
+	return true
+}
+
+// filterOtherVariantProducts removes products configured exclusively for the
+// other experiment variant while preserving positions that do not participate
+// in the experiment. This keeps the product response consistent with the
+// attribution validation performed when an order is created.
+func filterOtherVariantProducts(
+	response *proto.ProductRes,
+	currentProductIDs, otherProductIDs []primitive.ObjectID,
+) {
+	if response == nil {
+		return
+	}
+	current := make(map[primitive.ObjectID]struct{}, len(currentProductIDs))
+	for _, productID := range currentProductIDs {
+		current[productID] = struct{}{}
+	}
+	blocked := make(map[primitive.ObjectID]struct{}, len(otherProductIDs))
+	for _, productID := range otherProductIDs {
+		if _, shared := current[productID]; !shared {
+			blocked[productID] = struct{}{}
+		}
+	}
+	if len(blocked) == 0 {
+		return
+	}
+
+	positions := make([]proto.ProductList, 0, len(response.List))
+	for _, position := range response.List {
+		products := make([]proto.VIPListRes, 0, len(position.List))
+		for _, product := range position.List {
+			if _, excluded := blocked[product.ID]; excluded {
+				continue
+			}
+			products = append(products, product)
+		}
+		if len(products) == 0 {
+			continue
+		}
+		position.List = products
+		positions = append(positions, position)
+	}
+	response.List = positions
+}
+
+func RecordEvents(uid uint64, request EventsRequest, now time.Time) (EventsResponse, error) {
+	response := EventsResponse{}
+	if uid == 0 {
+		return response, fmt.Errorf("authenticated user is required")
+	}
+	if len(request.Events) == 0 || len(request.Events) > maxEventsPerRequest {
+		return response, fmt.Errorf("events must contain 1-%d items", maxEventsPerRequest)
+	}
+	experiments := make(map[string]*vipcardexperimentmod.Experiment)
+	events := make([]*vipcardexperimentmod.AnalyticsEvent, 0, len(request.Events))
+	for _, input := range request.Events {
+		event, experiment, err := validateEvent(uid, input, now, experiments)
+		if err != nil {
+			return EventsResponse{}, err
+		}
+		events = append(events, event)
+		experiments[experiment.ExperimentID] = experiment
+	}
+	for _, event := range events {
+		inserted, err := vipcardexperimentmod.InsertEvent(event)
+		if err != nil {
+			return EventsResponse{}, err
+		}
+		if inserted {
+			response.Accepted++
+		} else {
+			response.Duplicated++
+		}
+	}
+	return response, nil
+}
+
+func validateEvent(
+	uid uint64,
+	input EventInput,
+	now time.Time,
+	experiments map[string]*vipcardexperimentmod.Experiment,
+) (*vipcardexperimentmod.AnalyticsEvent, *vipcardexperimentmod.Experiment, error) {
+	input.EventID = strings.TrimSpace(input.EventID)
+	input.EventName = strings.ToUpper(strings.TrimSpace(input.EventName))
+	input.SessionID = strings.TrimSpace(input.SessionID)
+	input.ExperimentID = strings.TrimSpace(input.ExperimentID)
+	input.Variant = strings.ToUpper(strings.TrimSpace(input.Variant))
+	if input.EventID == "" || len(input.EventID) > 128 {
+		return nil, nil, fmt.Errorf("eventId is required and must not exceed 128 characters")
+	}
+	if !vipcardexperimentmod.ValidEventName(input.EventName) {
+		return nil, nil, fmt.Errorf("unsupported eventName: %s", input.EventName)
+	}
+	if input.SessionID == "" || len(input.SessionID) > 128 {
+		return nil, nil, fmt.Errorf("sessionId is required and must not exceed 128 characters")
+	}
+	if input.ExperimentID == "" {
+		return nil, nil, fmt.Errorf("experimentId is required")
+	}
+	if len(input.ExperimentID) > 128 {
+		return nil, nil, fmt.Errorf("experimentId must not exceed 128 characters")
+	}
+	if input.OccurredAt.IsZero() || input.OccurredAt.After(now.Add(5*time.Minute)) {
+		return nil, nil, fmt.Errorf("occurredAt is invalid")
+	}
+	experiment := experiments[input.ExperimentID]
+	var err error
+	if experiment == nil {
+		experiment, err = vipcardexperimentmod.FindByExperimentID(input.ExperimentID)
+		if err != nil {
+			return nil, nil, err
+		}
+		if experiment == nil {
+			return nil, nil, fmt.Errorf("experiment does not exist")
+		}
+	}
+	if !eventOccurredWithinExperiment(experiment, input.OccurredAt) {
+		return nil, nil, fmt.Errorf("occurredAt is outside the experiment period")
+	}
+	config, ok := experiment.ConfigFor(input.Variant)
+	if !ok {
+		return nil, nil, fmt.Errorf("variant must be A or B")
+	}
+	if assigned := experiment.Assign(uid); assigned != input.Variant {
+		return nil, nil, fmt.Errorf("variant does not match user assignment")
+	}
+	if input.EventName == vipcardexperimentmod.EventProductImpression {
+		if input.ProductID.IsZero() {
+			return nil, nil, fmt.Errorf("productId is required for VIP_PRODUCT_IMPRESSION")
+		}
+		if !containsProduct(config.ProductIDs, input.ProductID) {
+			return nil, nil, fmt.Errorf("productId does not belong to variant")
+		}
+	} else {
+		input.ProductID = primitive.NilObjectID
+	}
+	return &vipcardexperimentmod.AnalyticsEvent{
+		EventID:      input.EventID,
+		EventName:    input.EventName,
+		UID:          uid,
+		SessionID:    input.SessionID,
+		OccurredAt:   input.OccurredAt,
+		ExperimentID: input.ExperimentID,
+		Variant:      input.Variant,
+		ProductID:    input.ProductID,
+	}, experiment, nil
+}
+
+func eventOccurredWithinExperiment(experiment *vipcardexperimentmod.Experiment, occurredAt time.Time) bool {
+	const clockSkew = 5 * time.Minute
+	startAt := experiment.PublishedAt
+	if experiment.StartAt != nil && (startAt.IsZero() || experiment.StartAt.After(startAt)) {
+		startAt = *experiment.StartAt
+	}
+	if !startAt.IsZero() && occurredAt.Before(startAt.Add(-clockSkew)) {
+		return false
+	}
+	var endAt *time.Time
+	if experiment.EndAt != nil {
+		end := *experiment.EndAt
+		endAt = &end
+	}
+	if experiment.DisabledAt != nil && (endAt == nil || experiment.DisabledAt.Before(*endAt)) {
+		end := *experiment.DisabledAt
+		endAt = &end
+	}
+	return endAt == nil || !occurredAt.After(endAt.Add(clockSkew))
+}
+
+func containsProduct(ids []primitive.ObjectID, target primitive.ObjectID) bool {
+	for _, id := range ids {
+		if id == target {
+			return true
+		}
+	}
+	return false
+}