quotation service fixed

api/payments/storage/model/payment.go

@@ -75,10 +75,11 @@ type Rail string
 const (
 	RailUnspecified        Rail = "UNSPECIFIED"
 	RailCrypto             Rail = "CRYPTO"
-	RailProviderSettlement Rail = "PROVIDER_SETTLEMENT"
+	RailProviderSettlement Rail = "SETTLEMENT"
 	RailLedger             Rail = "LEDGER"
-	RailCardPayout         Rail = "CARD_PAYOUT"
-	RailFiatOnRamp         Rail = "FIAT_ONRAMP"
+	RailCardPayout         Rail = "CARD"
+	RailFiatOnRamp         Rail = "ONRAMP"
+	RailFiatOffRamp        Rail = "OFFRAMP"
 )
 
 // RailOperation identifies an explicit action within a payment plan.

api/payments/storage/model/plan_template.go

@@ -42,8 +42,8 @@ func (t *PaymentPlanTemplate) Normalize() {
 	if t == nil {
 		return
 	}
-	t.FromRail = Rail(strings.ToUpper(strings.TrimSpace(string(t.FromRail))))
-	t.ToRail = Rail(strings.ToUpper(strings.TrimSpace(string(t.ToRail))))
+	t.FromRail = normalizeRail(t.FromRail)
+	t.ToRail = normalizeRail(t.ToRail)
 	t.Network = strings.ToUpper(strings.TrimSpace(t.Network))
 	if len(t.Steps) == 0 {
 		return
@@ -51,7 +51,7 @@ func (t *PaymentPlanTemplate) Normalize() {
 	for i := range t.Steps {
 		step := &t.Steps[i]
 		step.StepID = strings.TrimSpace(step.StepID)
-		step.Rail = Rail(strings.ToUpper(strings.TrimSpace(string(step.Rail))))
+		step.Rail = normalizeRail(step.Rail)
 		step.Operation = strings.ToLower(strings.TrimSpace(step.Operation))
 		step.ReportVisibility = NormalizeReportVisibility(step.ReportVisibility)
 		step.CommitPolicy = normalizeCommitPolicy(step.CommitPolicy)

api/payments/storage/model/rails.go

@@ -0,0 +1,62 @@
+package model
+
+import "strings"
+
+var supportedRails = map[Rail]struct{}{
+	RailCrypto:             {},
+	RailProviderSettlement: {},
+	RailLedger:             {},
+	RailCardPayout:         {},
+	RailFiatOnRamp:         {},
+	RailFiatOffRamp:        {},
+}
+
+// ParseRail canonicalizes string values into a Rail token.
+func ParseRail(value string) Rail {
+	clean := strings.ToUpper(strings.TrimSpace(value))
+	if clean == "" {
+		return RailUnspecified
+	}
+	clean = strings.ReplaceAll(clean, "-", "_")
+	clean = strings.ReplaceAll(clean, " ", "_")
+	for strings.Contains(clean, "__") {
+		clean = strings.ReplaceAll(clean, "__", "_")
+	}
+
+	switch clean {
+	case string(RailCrypto), "RAIL_CRYPTO":
+		return RailCrypto
+	case string(RailProviderSettlement), "PROVIDER_SETTLEMENT", "RAIL_SETTLEMENT", "RAIL_PROVIDER_SETTLEMENT":
+		return RailProviderSettlement
+	case string(RailLedger), "RAIL_LEDGER":
+		return RailLedger
+	case string(RailCardPayout), "CARD_PAYOUT", "RAIL_CARD", "RAIL_CARD_PAYOUT":
+		return RailCardPayout
+	case string(RailFiatOnRamp), "FIAT_ONRAMP", "RAIL_ONRAMP", "RAIL_FIAT_ONRAMP":
+		return RailFiatOnRamp
+	case string(RailFiatOffRamp), "FIAT_OFFRAMP", "RAIL_OFFRAMP", "RAIL_FIAT_OFFRAMP":
+		return RailFiatOffRamp
+	default:
+		return RailUnspecified
+	}
+}
+
+// IsSupportedRail reports whether rail is recognized by payment planning.
+func IsSupportedRail(rail Rail) bool {
+	_, ok := supportedRails[ParseRail(string(rail))]
+	return ok
+}
+
+func normalizeRail(value Rail) Rail {
+	parsed := ParseRail(string(value))
+	if parsed != RailUnspecified {
+		return parsed
+	}
+
+	clean := strings.ToUpper(strings.TrimSpace(string(value)))
+	if clean == "" {
+		return RailUnspecified
+	}
+
+	return Rail(clean)
+}

api/payments/storage/model/rails_test.go

@@ -0,0 +1,28 @@
+package model
+
+import "testing"
+
+func TestParseRail(t *testing.T) {
+	cases := []struct {
+		name  string
+		input string
+		want  Rail
+	}{
+		{name: "crypto", input: "crypto", want: RailCrypto},
+		{name: "settlement canonical", input: "SETTLEMENT", want: RailProviderSettlement},
+		{name: "settlement legacy", input: "provider_settlement", want: RailProviderSettlement},
+		{name: "card canonical", input: "card", want: RailCardPayout},
+		{name: "card legacy", input: "card_payout", want: RailCardPayout},
+		{name: "onramp", input: "fiat_onramp", want: RailFiatOnRamp},
+		{name: "offramp", input: "fiat_offramp", want: RailFiatOffRamp},
+		{name: "unknown", input: "telegram", want: RailUnspecified},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := ParseRail(tc.input); got != tc.want {
+				t.Fatalf("ParseRail(%q) = %q, want %q", tc.input, got, tc.want)
+			}
+		})
+	}
+}

api/payments/storage/model/route.go

@@ -28,8 +28,8 @@ func (r *PaymentRoute) Normalize() {
 	if r == nil {
 		return
 	}
-	r.FromRail = Rail(strings.ToUpper(strings.TrimSpace(string(r.FromRail))))
-	r.ToRail = Rail(strings.ToUpper(strings.TrimSpace(string(r.ToRail))))
+	r.FromRail = normalizeRail(r.FromRail)
+	r.ToRail = normalizeRail(r.ToRail)
 	r.Network = strings.ToUpper(strings.TrimSpace(r.Network))
 }