satellite/console: added new endpoint for the project pricing migration

Issue: storj/storj-private#1615

Change-Id: I4cabc56c3e81b11308449bbfa20d06c5434d728a

Author: VitaliiShpital

satellite/console/README.md

@@ -38,3 +38,46 @@ STORJ_CONSOLE_PLACEMENT_SELF_SERVE_DETAILS: |
 - `title`: Title for displaying placement, used in UI
 - `description`: Description of the placement, used in UI
 - `wait-list-url`: Optional URL for a wait list if the placement is not available yet.
+
+## Legacy Placement Product Mapping for Migration
+
+### STORJ_CONSOLE_LEGACY_PLACEMENT_PRODUCT_MAPPING_FOR_MIGRATION
+
+This configuration provides an override mapping from legacy placement IDs to product IDs,
+used during project pricing migration from classic to new pricing tiers.
+
+#### Purpose
+
+When migrating "classic" projects to the new pricing model,
+legacy placements need to be mapped to product IDs in the new billing system.
+This config allows satellite operators to define custom mappings for specific legacy placements that may require different product assignments than the default behavior.
+
+#### How It Works
+
+During project pricing migration (via the `/projects/{id}/migrate-pricing` endpoint),
+the system builds a composite mapping of placements to products in the following priority order:
+
+1. Partner-specific mappings (if applicable)
+2. Default placement-to-product mappings (from `STORJ_PAYMENTS_PLACEMENT_PRICE_OVERRIDES`)
+3. **Override mappings from this config** (highest priority)
+
+This config provides the final override layer,
+ensuring that specific legacy placements can be mapped to the correct product IDs regardless of partner or default settings.
+
+#### Configuration Format
+
+The value is a JSON object mapping placement IDs (as strings) to product IDs (as integers):
+
+```
+STORJ_CONSOLE_LEGACY_PLACEMENT_PRODUCT_MAPPING_FOR_MIGRATION: '{"0":1,"12":2}'
+```
+
+In this example:
+- Legacy placement `0` maps to product ID `1`
+- Legacy placement `12` maps to product ID `2`
+
+#### Related Configuration
+
+- `STORJ_CONSOLE_LEGACY_PLACEMENTS`: Defines which placement IDs are considered "legacy"
+- `STORJ_PAYMENTS_PLACEMENT_PRICE_OVERRIDES`: Default placement-to-product mappings for new placements
+- `STORJ_CONSOLE_PLACEMENT_ALLOWED_PLACEMENT_IDS_FOR_NEW_PROJECTS`: Placements available after migration

satellite/console/config.go

@@ -62,7 +62,9 @@ type Config struct {
 	NewPricingStartDate               string                    `help:"the date (YYYY-MM-DD) when new pricing tiers will be enabled" default:"2025-11-01"`
 	ProductPriceSummaries             []string                  `help:"the pricing summaries gotten from configured products" default:"" hidden:"true"`
 	MemberAccountsEnabled             bool                      `help:"whether member accounts are enabled" default:"false"`
-	LegacyPlacements                  []string                  `help:"list of placement IDs that are considered legacy placements" default:""`
+
+	LegacyPlacements                          []string                 `help:"list of placement IDs that are considered legacy placements" default:""`
+	LegacyPlacementProductMappingForMigration PlacementProductMappings `help:"mapping of legacy placement IDs to product IDs for migration" default:""`
 
 	ManagedEncryption SatelliteManagedEncryptionConfig
 	RestAPIKeys       RestAPIKeysConfig
@@ -338,3 +340,46 @@ func (pd *PlacementDetails) Get(placement storj.PlacementConstraint) (details Pl
 	}
 	return PlacementDetail{}, false
 }
+
+// PlacementProductMappings represents a mapping between placement IDs and product IDs.
+type PlacementProductMappings struct {
+	mappings map[storj.PlacementConstraint]int32
+}
+
+// Ensure that PlacementProductMappings implements pflag.Value.
+var _ pflag.Value = (*PlacementProductMappings)(nil)
+
+// Type returns the type of the pflag.Value.
+func (*PlacementProductMappings) Type() string { return "entitlements.PlacementProductMappings" }
+
+// String returns a string representation of the PlacementProductMappings.
+func (ppm *PlacementProductMappings) String() string {
+	if ppm == nil || len(ppm.mappings) == 0 {
+		return ""
+	}
+
+	data, err := json.Marshal(ppm.mappings)
+	if err != nil {
+		return ""
+	}
+
+	return string(data)
+}
+
+// Set parses and sets the PlacementProductMappings from a string.
+func (ppm *PlacementProductMappings) Set(value string) error {
+	if value == "" {
+		return nil
+	}
+
+	value = strings.TrimSpace(value)
+
+	mappings := make(map[storj.PlacementConstraint]int32)
+	if err := json.Unmarshal([]byte(value), &mappings); err != nil {
+		return errs.New("failed to parse PlacementProductMappings: %w", err)
+	}
+
+	ppm.mappings = mappings
+
+	return nil
+}

satellite/console/consoleweb/consoleapi/projects.go

@@ -717,6 +717,41 @@ func (p *Projects) GetConfig(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
+// MigratePricing migrates classic project to use new storage tiers.
+func (p *Projects) MigratePricing(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	var err error
+	defer mon.Task()(&ctx)(&err)
+
+	w.Header().Set("Content-Type", "application/json")
+
+	idParam, ok := mux.Vars(r)["id"]
+	if !ok {
+		p.serveJSONError(ctx, w, http.StatusBadRequest, errs.New("missing id route param"))
+		return
+	}
+
+	id, err := uuid.FromString(idParam)
+	if err != nil {
+		p.serveJSONError(ctx, w, http.StatusBadRequest, err)
+	}
+
+	err = p.service.MigrateProjectPricing(ctx, id)
+	if err != nil {
+		status := http.StatusInternalServerError
+
+		switch {
+		case console.ErrUnauthorized.Has(err) || console.ErrNoMembership.Has(err):
+			status = http.StatusUnauthorized
+		case console.ErrConflict.Has(err):
+			status = http.StatusConflict
+		case console.ErrForbidden.Has(err):
+			status = http.StatusForbidden
+		}
+		p.serveJSONError(ctx, w, status, err)
+	}
+}
+
 // InviteUser sends a project invitation to a user.
 func (p *Projects) InviteUser(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()

satellite/console/consoleweb/server.go

@@ -313,6 +313,10 @@ func NewServer(logger *zap.Logger, config Config, service *console.Service, cons
 	projectsRouter.Handle("/{id}/invite-link", http.HandlerFunc(projectsController.GetInviteLink)).Methods(http.MethodGet, http.MethodOptions)
 	projectsRouter.Handle("/{id}/emission", http.HandlerFunc(projectsController.GetEmissionImpact)).Methods(http.MethodGet, http.MethodOptions)
 	projectsRouter.Handle("/{id}/config", http.HandlerFunc(projectsController.GetConfig)).Methods(http.MethodGet, http.MethodOptions)
+	if entitlementsEnabled {
+		projectsRouter.Handle("/{id}/migrate-pricing", server.withCSRFProtection(http.HandlerFunc(projectsController.MigratePricing))).Methods(http.MethodPost, http.MethodOptions)
+	}
+
 	projectsRouter.Handle("/invitations", http.HandlerFunc(projectsController.GetUserInvitations)).Methods(http.MethodGet, http.MethodOptions)
 	projectsRouter.Handle("/invitations/{id}/respond", server.withCSRFProtection(http.HandlerFunc(projectsController.RespondToInvitation))).Methods(http.MethodPost, http.MethodOptions)
 

satellite/console/service.go

@@ -4412,6 +4412,71 @@ func (s *Service) validateLimits(ctx context.Context, project *Project, updatedL
 	return nil
 }
 
+// MigrateProjectPricing is a method for migrating project pricing to new model.
+func (s *Service) MigrateProjectPricing(ctx context.Context, publicProjectID uuid.UUID) (err error) {
+	defer mon.Task()(&ctx)(&err)
+
+	user, err := s.getUserAndAuditLog(ctx, "migrate project pricing")
+	if err != nil {
+		return ErrUnauthorized.Wrap(err)
+	}
+
+	isMember, err := s.isProjectMember(ctx, user.ID, publicProjectID)
+	if err != nil {
+		return ErrUnauthorized.Wrap(err)
+	}
+	if isMember.membership.Role != RoleAdmin {
+		return ErrForbidden.New("only project owner or admin may migrate project pricing")
+	}
+
+	if !s.entitlementsConfig.Enabled || s.legacyPlacements == nil {
+		return ErrForbidden.New("project pricing migration is not available")
+	}
+
+	p := isMember.project
+
+	if ent, err := s.entitlementsService.Projects().GetByPublicID(ctx, p.PublicID); err == nil && ent.NewBucketPlacements != nil {
+		if !slices.Equal(ent.NewBucketPlacements, s.legacyPlacements) {
+			return ErrConflict.New("project pricing migration is only available for classic projects")
+		}
+	}
+
+	partnerMap, defaultMap := s.accounts.GetPlacementProductMappings(string(p.UserAgent))
+
+	mapping := entitlements.PlacementProductMappings{}
+	for placement, productID := range partnerMap {
+		mapping[storj.PlacementConstraint(placement)] = productID
+	}
+	for placement, productID := range defaultMap {
+		if _, exists := mapping[storj.PlacementConstraint(placement)]; !exists {
+			mapping[storj.PlacementConstraint(placement)] = productID
+		}
+	}
+	for placement, productID := range s.config.LegacyPlacementProductMappingForMigration.mappings {
+		mapping[placement] = productID
+	}
+
+	feats := entitlements.ProjectFeatures{
+		NewBucketPlacements:      s.config.Placement.AllowedPlacementIdsForNewProjects,
+		PlacementProductMappings: mapping,
+	}
+	featBytes, err := json.Marshal(feats)
+	if err != nil {
+		return Error.Wrap(err)
+	}
+
+	_, err = s.store.Entitlements().UpsertByScope(ctx, &entitlements.Entitlement{
+		Scope:     entitlements.ConvertPublicIDToProjectScope(p.PublicID),
+		Features:  featBytes,
+		UpdatedAt: s.nowFn(),
+	})
+	if err != nil {
+		return Error.Wrap(err)
+	}
+
+	return nil
+}
+
 // RequestLimitIncrease is a method for requesting limit increase for a project.
 func (s *Service) RequestLimitIncrease(ctx context.Context, projectID uuid.UUID, info LimitRequestInfo) (err error) {
 	defer mon.Task()(&ctx)(&err)