sxchnge/backend/pkg/model/signup_provisioning.go

package model

import (
	"strings"
	"time"

	"git.sendico.io/tech/sxchnge/bff/pkg/db/storable"
	"git.sendico.io/tech/sxchnge/bff/pkg/mservice"
	"go.mongodb.org/mongo-driver/v2/bson"
)

type SignupProvisioningState string

const (
	SignupProvisioningStateStarted            SignupProvisioningState = "started"
	SignupProvisioningStateProvisioning       SignupProvisioningState = "provisioning"
	SignupProvisioningStateCompensating       SignupProvisioningState = "compensating"
	SignupProvisioningStateFailedPartialClean SignupProvisioningState = "failed_partial_cleanup"
	SignupProvisioningStateFailedClean        SignupProvisioningState = "failed_clean"
	SignupProvisioningStateCompleted          SignupProvisioningState = "completed"
)

type SignupProvisioningCleanupStatus string

const (
	SignupProvisioningCleanupStatusNotNeeded SignupProvisioningCleanupStatus = "not_needed"
	SignupProvisioningCleanupStatusPending   SignupProvisioningCleanupStatus = "pending"
	SignupProvisioningCleanupStatusRunning   SignupProvisioningCleanupStatus = "running"
	SignupProvisioningCleanupStatusComplete  SignupProvisioningCleanupStatus = "complete"
	SignupProvisioningCleanupStatusPartial   SignupProvisioningCleanupStatus = "partial"
)

type SignupProvisioningTarget struct {
	Chain           ChainNetwork `bson:"chain" json:"chain"`
	TokenSymbol     string       `bson:"tokenSymbol" json:"tokenSymbol"`
	ContractAddress string       `bson:"contractAddress,omitempty" json:"contractAddress,omitempty"`
}

func (t *SignupProvisioningTarget) Normalize() {
	if t == nil {
		return
	}
	t.Chain = ChainNetwork(strings.TrimSpace(t.Chain.String()))
	t.TokenSymbol = strings.ToUpper(strings.TrimSpace(t.TokenSymbol))
	t.ContractAddress = strings.TrimSpace(t.ContractAddress)
}

type SignupProvisionedWallet struct {
	Chain     ChainNetwork `bson:"chain" json:"chain"`
	WalletRef string       `bson:"walletRef" json:"walletRef"`
}

func (w *SignupProvisionedWallet) Normalize() {
	if w == nil {
		return
	}
	w.Chain = ChainNetwork(strings.TrimSpace(w.Chain.String()))
	w.WalletRef = strings.TrimSpace(w.WalletRef)
}

type SignupProvisionedRoute struct {
	WalletRef string `bson:"walletRef" json:"walletRef"`
	RouteRef  string `bson:"routeRef" json:"routeRef"`
}

func (r *SignupProvisionedRoute) Normalize() {
	if r == nil {
		return
	}
	r.WalletRef = strings.TrimSpace(r.WalletRef)
	r.RouteRef = strings.TrimSpace(r.RouteRef)
}

type SignupProvisioningRecord struct {
	storable.Base `bson:",inline" json:",inline"`

	NormalizedLogin  string                          `bson:"normalizedLogin" json:"normalizedLogin"`
	OrganizationRef  string                          `bson:"organizationRef,omitempty" json:"organizationRef,omitempty"`
	AttemptID        string                          `bson:"attemptId" json:"attemptId"`
	State            SignupProvisioningState         `bson:"state" json:"state"`
	CleanupStatus    SignupProvisioningCleanupStatus `bson:"cleanupStatus" json:"cleanupStatus"`
	LeaseOwner       string                          `bson:"leaseOwner" json:"leaseOwner"`
	LeaseExpiresAt   time.Time                       `bson:"leaseExpiresAt" json:"leaseExpiresAt"`
	HeartbeatAt      time.Time                       `bson:"heartbeatAt" json:"heartbeatAt"`
	SelectedTargets  []SignupProvisioningTarget      `bson:"selectedTargets,omitempty" json:"selectedTargets,omitempty"`
	Wallets          []SignupProvisionedWallet       `bson:"wallets,omitempty" json:"wallets,omitempty"`
	Routes           []SignupProvisionedRoute        `bson:"routes,omitempty" json:"routes,omitempty"`
	StepStatus       map[string]string               `bson:"stepStatus,omitempty" json:"stepStatus,omitempty"`
	LastError        string                          `bson:"lastError,omitempty" json:"lastError,omitempty"`
	LastCleanupError string                          `bson:"lastCleanupError,omitempty" json:"lastCleanupError,omitempty"`
	ExpiresAt        *time.Time                      `bson:"expiresAt,omitempty" json:"expiresAt,omitempty"`
}

func (*SignupProvisioningRecord) Collection() string {
	return mservice.SignupProvisioning
}

func (r *SignupProvisioningRecord) Normalize() {
	if r == nil {
		return
	}
	r.NormalizedLogin = strings.ToLower(strings.TrimSpace(r.NormalizedLogin))
	r.OrganizationRef = strings.TrimSpace(r.OrganizationRef)
	r.AttemptID = strings.TrimSpace(r.AttemptID)
	r.LeaseOwner = strings.TrimSpace(r.LeaseOwner)
	r.LastError = strings.TrimSpace(r.LastError)
	r.LastCleanupError = strings.TrimSpace(r.LastCleanupError)

	for i := range r.SelectedTargets {
		r.SelectedTargets[i].Normalize()
	}
	for i := range r.Wallets {
		r.Wallets[i].Normalize()
	}
	for i := range r.Routes {
		r.Routes[i].Normalize()
	}
	if r.StepStatus == nil {
		r.StepStatus = map[string]string{}
	}
}

func (r *SignupProvisioningRecord) Active() bool {
	if r == nil {
		return false
	}
	switch r.State {
	case SignupProvisioningStateStarted, SignupProvisioningStateProvisioning, SignupProvisioningStateCompensating:
		return true
	default:
		return false
	}
}

func (r *SignupProvisioningRecord) Terminal() bool {
	if r == nil {
		return false
	}
	switch r.State {
	case SignupProvisioningStateFailedPartialClean, SignupProvisioningStateFailedClean, SignupProvisioningStateCompleted:
		return true
	default:
		return false
	}
}

func (r *SignupProvisioningRecord) OrganizationObjectID() bson.ObjectID {
	ref, _ := bson.ObjectIDFromHex(strings.TrimSpace(r.OrganizationRef))
	return ref
}