payments

Documentation

Index

• Constants
• Variables
• type Accounts
• type Balance
• type CardInfo
• type Charge
• type Coupon
• type CouponDuration
• type CouponType
• type CouponUsage
• type Coupons
• type Credit
• type CreditCard
• type CreditCards
• type Credits
• type CreditsPage
• type DepositBonus
• type DepositWallets
• type Invoice
• type Invoices
• type PaymentStatus
• type ProjectCharge
• type StorjTokens
• type Transaction
• type TransactionID
  • func (id TransactionID) String() string
• type TransactionInfo
• type TransactionStatus
  • func (status TransactionStatus) String() string
• type WalletPayment

Constants

const (
	// CouponOnce indicates that a coupon can only be applied once.
	CouponOnce CouponDuration = "once"
	// CouponRepeating indicates that a coupon is applied every billing period for a definite amount of time.
	CouponRepeating = "repeating"
	// CouponForever indicates that a coupon is applied every billing period forever.
	CouponForever = "forever"
)

const (
	// NoCoupon represents an invalid coupon registration attempt.
	NoCoupon CouponType = "noCoupon"
	// FreeTierCoupon represents the default free tier coupon.
	FreeTierCoupon = "freeTierCoupon"
	// SignupCoupon represents a valid promo code coupon.
	SignupCoupon = "signupCoupon"
)

const (
	// PaymentStatusConfirmed indicates that payment has required number of confirmations.
	PaymentStatusConfirmed = "confirmed"
	// PaymentStatusPending indicates that payment has not meet confirmation requirements.
	PaymentStatusPending = "pending"
)

Variables

var ErrAccountNotSetup = errs.Class("payment account is not set up")

ErrAccountNotSetup is an error type which indicates that payment account is not created.

Types

type Accounts

type Accounts interface {
	// Setup creates a payment account for the user.
	// If account is already set up it will return nil.
	Setup(ctx context.Context, userID uuid.UUID, email string, signupPromoCode string) (CouponType, error)

	// Balance returns an object that represents current free credits and coins balance in cents.
	Balance(ctx context.Context, userID uuid.UUID) (Balance, error)

	// ProjectCharges returns how much money current user will be charged for each project.
	ProjectCharges(ctx context.Context, userID uuid.UUID, since, before time.Time) ([]ProjectCharge, error)

	// CheckProjectInvoicingStatus returns error if for the given project there are outstanding project records and/or usage
	// which have not been applied/invoiced yet (meaning sent over to stripe).
	CheckProjectInvoicingStatus(ctx context.Context, projectID uuid.UUID) error

	// CheckProjectUsageStatus returns error if for the given project there is some usage for current or previous month.
	CheckProjectUsageStatus(ctx context.Context, projectID uuid.UUID) error

	// Charges returns list of all credit card charges related to account.
	Charges(ctx context.Context, userID uuid.UUID) ([]Charge, error)

	// CreditCards exposes all needed functionality to manage account credit cards.
	CreditCards() CreditCards

	// StorjTokens exposes all storj token related functionality.
	StorjTokens() StorjTokens

	// Invoices exposes all needed functionality to manage account invoices.
	Invoices() Invoices

	// Coupons exposes all needed functionality to manage coupons.
	Coupons() Coupons
}

Accounts exposes all needed functionality to manage payment accounts.

architecture: Service

type Balance

type Balance struct {
	FreeCredits int64 `json:"freeCredits"`
	Coins       int64 `json:"coins"`
}

Balance is an entity that holds free credits and coins balance of user. Earned by applying of promotional coupon and coins depositing, respectively.

type CardInfo

type CardInfo struct {
	ID       string `json:"id"`
	Brand    string `json:"brand"`
	LastFour string `json:"lastFour"`
}

CardInfo holds information about credit card used for charge.

type Charge

type Charge struct {
	ID        string    `json:"id"`
	Amount    int64     `json:"amount"`
	CardInfo  CardInfo  `json:"card"`
	CreatedAt time.Time `json:"createdAt"`
}

Charge contains charge details.

type Coupon

type Coupon struct {
	ID         string         `json:"id"`
	PromoCode  string         `json:"promoCode"`
	Name       string         `json:"name"`
	AmountOff  int64          `json:"amountOff"`
	PercentOff float64        `json:"percentOff"`
	AddedAt    time.Time      `json:"addedAt"`
	ExpiresAt  time.Time      `json:"expiresAt"`
	Duration   CouponDuration `json:"duration"`
}

Coupon describes a discount to the payment account of a user.

type CouponDuration

type CouponDuration string

CouponDuration represents how many billing periods a coupon is applied.

type CouponType

type CouponType string

CouponType is an enum representing the outcome a coupon validation check.

type CouponUsage

type CouponUsage struct {
	Coupon      Coupon
	Amount      int64
	PeriodStart time.Time
	PeriodEnd   time.Time
}

CouponUsage describes the usage of a coupon on an invoice.

type Coupons

type Coupons interface {
	// GetByUserID returns the coupon applied to the specified user.
	GetByUserID(ctx context.Context, userID uuid.UUID) (*Coupon, error)

	// ApplyCouponCode attempts to apply a coupon code to the user.
	ApplyCouponCode(ctx context.Context, userID uuid.UUID, couponCode string) (*Coupon, error)
}

Coupons exposes all needed functionality to manage coupons.

architecture: Service

type Credit

type Credit struct {
	UserID        uuid.UUID                  `json:"userId"`
	Amount        int64                      `json:"credit"`
	TransactionID coinpayments.TransactionID `json:"transactionId"`
	Created       time.Time                  `json:"created"`
}

Credit is an entity that holds bonus balance of user, earned by depositing with storj coins.

type CreditCard

type CreditCard struct {
	ID        string `json:"id"`
	ExpMonth  int    `json:"expMonth"`
	ExpYear   int    `json:"expYear"`
	Brand     string `json:"brand"`
	Last4     string `json:"last4"`
	IsDefault bool   `json:"isDefault"`
}

CreditCard holds all public information about credit card.

type CreditCards

type CreditCards interface {
	// List returns a list of credit cards for a given payment account.
	List(ctx context.Context, userID uuid.UUID) ([]CreditCard, error)

	// Add is used to save new credit card and attach it to payment account.
	Add(ctx context.Context, userID uuid.UUID, cardToken string) error

	// Remove is used to detach a credit card from payment account.
	Remove(ctx context.Context, userID uuid.UUID, cardID string) error

	// RemoveAll is used to detach all credit cards from payment account.
	// It should only be used in case of a user deletion.
	RemoveAll(ctx context.Context, userID uuid.UUID) error

	// MakeDefault makes a credit card default payment method.
	// this credit card should be attached to account before make it default.
	MakeDefault(ctx context.Context, userID uuid.UUID, cardID string) error
}

CreditCards exposes all needed functionality to manage account credit cards.

architecture: Service

type Credits

type Credits interface {
	// Create attaches a credit for payment account.
	Create(ctx context.Context, credit Credit) (err error)

	// ListByUserID return list of all credits of specified payment account.
	ListByUserID(ctx context.Context, userID uuid.UUID) ([]Credit, error)
}

Credits exposes all needed functionality to manage credits.

architecture: Service

type CreditsPage

type CreditsPage struct {
	Credits    []Credit
	Next       bool
	NextOffset int64
}

CreditsPage holds set of credits and indicates if there are more credits to fetch.

type DepositBonus

type DepositBonus struct {
	TransactionID TransactionID
	AmountCents   int64
	Percentage    int64
	CreatedAt     time.Time
}

DepositBonus defines a bonus received for depositing tokens.

type DepositWallets

type DepositWallets interface {
	// Claim gets a new crypto wallet and associates it with a user.
	Claim(ctx context.Context, userID uuid.UUID) (blockchain.Address, error)
	// Get returns the crypto wallet address associated with the given user.
	Get(ctx context.Context, userID uuid.UUID) (blockchain.Address, error)
	// Payments returns payments for a particular wallet.
	Payments(ctx context.Context, wallet blockchain.Address, limit int, offset int64) ([]WalletPayment, error)
}

DepositWallets exposes all needed functionality to manage token deposit wallets.

architecture: Service

type Invoice

type Invoice struct {
	ID          string    `json:"id"`
	Description string    `json:"description"`
	Amount      int64     `json:"amount"`
	Status      string    `json:"status"`
	Link        string    `json:"link"`
	Start       time.Time `json:"start"`
	End         time.Time `json:"end"`
}

Invoice holds all public information about invoice.

type Invoices

type Invoices interface {
	// List returns a list of invoices for a given payment account.
	List(ctx context.Context, userID uuid.UUID) ([]Invoice, error)
	// ListWithDiscounts returns a list of invoices and coupon usages for a given payment account.
	ListWithDiscounts(ctx context.Context, userID uuid.UUID) ([]Invoice, []CouponUsage, error)
	// CheckPendingItems returns if pending invoice items for a given payment account exist.
	CheckPendingItems(ctx context.Context, userID uuid.UUID) (existingItems bool, err error)
}

Invoices exposes all needed functionality to manage account invoices.

architecture: Service

type PaymentStatus

type PaymentStatus string

PaymentStatus indicates payment status.

type ProjectCharge

type ProjectCharge struct {
	accounting.ProjectUsage

	ProjectID uuid.UUID `json:"projectId"`
	// StorageGbHrs shows how much cents we should pay for storing GB*Hrs.
	StorageGbHrs int64 `json:"storagePrice"`
	// Egress shows how many cents we should pay for Egress.
	Egress int64 `json:"egressPrice"`
	// SegmentCount shows how many cents we should pay for objects count.
	SegmentCount int64 `json:"segmentPrice"`
}

ProjectCharge shows project usage and how much money current project will charge in the end of the month.

type StorjTokens

type StorjTokens interface {
	// Deposit creates deposit transaction for specified amount in cents.
	Deposit(ctx context.Context, userID uuid.UUID, amount int64) (*Transaction, error)
	// ListTransactionInfos returns all transactions associated with user.
	ListTransactionInfos(ctx context.Context, userID uuid.UUID) ([]TransactionInfo, error)
	// ListDepositBonuses returns all deposit bonuses associated with user.
	ListDepositBonuses(ctx context.Context, userID uuid.UUID) ([]DepositBonus, error)
}

StorjTokens defines all payments STORJ token related functionality.

architecture: Service

type Transaction

type Transaction struct {
	ID        TransactionID
	Amount    currency.Amount
	Rate      decimal.Decimal
	Address   string
	Status    TransactionStatus
	Timeout   time.Duration
	Link      string
	CreatedAt time.Time
}

Transaction defines deposit transaction which accepts user funds on a specific wallet address.

type TransactionID

type TransactionID []byte

TransactionID is a transaction ID type.

func (TransactionID) String

func (id TransactionID) String() string

String returns string representation of transaction id.

type TransactionInfo

type TransactionInfo struct {
	ID            TransactionID
	Amount        currency.Amount
	Received      currency.Amount
	AmountCents   int64
	ReceivedCents int64
	Address       string
	Status        TransactionStatus
	Link          string
	ExpiresAt     time.Time
	CreatedAt     time.Time
}

TransactionInfo holds transaction data with additional information such as links and expiration time.

type TransactionStatus

type TransactionStatus string

TransactionStatus defines allowed statuses for deposit transactions.

const (
	// TransactionStatusPaid is a transaction which successfully received required funds.
	TransactionStatusPaid TransactionStatus = "paid"
	// TransactionStatusPending is a transaction which accepts funds.
	TransactionStatusPending TransactionStatus = "pending"
	// TransactionStatusCancelled is a transaction that is cancelled and no longer accepting new funds.
	TransactionStatusCancelled TransactionStatus = "cancelled"
)

func (TransactionStatus) String

func (status TransactionStatus) String() string

String returns string representation of transaction status.

type WalletPayment

type WalletPayment struct {
	From        blockchain.Address `json:"from"`
	To          blockchain.Address `json:"to"`
	TokenValue  currency.Amount    `json:"tokenValue"`
	USDValue    currency.Amount    `json:"usdValue"`
	Status      PaymentStatus      `json:"status"`
	BlockHash   blockchain.Hash    `json:"blockHash"`
	BlockNumber int64              `json:"blockNumber"`
	Transaction blockchain.Hash    `json:"transaction"`
	LogIndex    int                `json:"logIndex"`
	Timestamp   time.Time          `json:"timestamp"`
}

WalletPayment holds storj token payment data.