JakeHillion/storj
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

satellite/payments/stripecoinpayments: implement invoice price override

Browse Source 
This change allows for overriding project usage prices for a specific
partner so that users who sign up with that partner do not need their
invoices to be manually adjusted.

Relates to storj/storj-private#90

Change-Id: Ia54a9cc7c2f8064922bbb15861f974e5dea82d5a
This commit is contained in:
Jeremy Wharton 2023-01-11 21:41:14 -06:00 committed by Storj Robot
parent 5644fb1a7e
commit 5d656e66bf
15 changed files with 181 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
cmd/satellite/billing.go
View File

@ -71,6 +71,7 @@ func setupPayments(log *zap.Logger, db satellite.DB) (*stripecoinpayments.Servic
db.Wallets(),
db.Billing(),
db.Console().Projects(),
db.Console().Users(),
db.ProjectAccounting(),
prices,
priceOverrides,

1
satellite/admin.go
View File

@ -168,6 +168,7 @@ func NewAdmin(log *zap.Logger, full *identity.FullIdentity, db DB, metabaseDB *m
peer.DB.Wallets(),
peer.DB.Billing(),
peer.DB.Console().Projects(),
peer.DB.Console().Users(),
peer.DB.ProjectAccounting(),
prices,
priceOverrides,

1
satellite/api.go
View File

@ -561,6 +561,7 @@ func NewAPI(log *zap.Logger, full *identity.FullIdentity, db DB,
peer.DB.Wallets(),
peer.DB.Billing(),
peer.DB.Console().Projects(),
peer.DB.Console().Users(),
peer.DB.ProjectAccounting(),
prices,
priceOverrides,

1
satellite/console/consoleweb/consoleql/mutation_test.go
View File

@ -98,6 +98,7 @@ func TestGraphqlMutation(t *testing.T) {
db.Wallets(),
db.Billing(),
db.Console().Projects(),
db.Console().Users(),
db.ProjectAccounting(),
prices,
priceOverrides,

1
satellite/console/consoleweb/consoleql/query_test.go
View File

@ -82,6 +82,7 @@ func TestGraphqlQuery(t *testing.T) {
db.Wallets(),
db.Billing(),
db.Console().Projects(),
db.Console().Users(),
db.ProjectAccounting(),
prices,
priceOverrides,

1
satellite/core.go
View File

@ -537,6 +537,7 @@ func New(log *zap.Logger, full *identity.FullIdentity, db DB,
peer.DB.Wallets(),
peer.DB.Billing(),
peer.DB.Console().Projects(),
peer.DB.Console().Users(),
peer.DB.ProjectAccounting(),
prices,
priceOverrides,

5
satellite/payments/account.go
View File

@ -29,6 +29,11 @@ type Accounts interface {
// 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)
// GetProjectUsagePriceModel returns the project usage price model for a user agent.
// If the user agent is malformed or does not contain a valid partner ID, the default
// price model is returned.
GetProjectUsagePriceModel(userAgent []byte) ProjectUsagePriceModel
// 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

16
satellite/payments/paymentsconfig/config.go
View File

@ -11,6 +11,7 @@ import (
"github.com/spf13/pflag"
"github.com/zeebo/errs"
"storj.io/storj/satellite/payments"
"storj.io/storj/satellite/payments/billing"
"storj.io/storj/satellite/payments/storjscan"
"storj.io/storj/satellite/payments/stripecoinpayments"
@ -41,8 +42,8 @@ type ProjectUsagePrice struct {
Segment string `help:"price user should pay for segments stored on network per month in dollars/segment" default:"0.0000088" testDefault:"0.0000022"`
}
// ToModel returns the stripecoinpayments.ProjectUsagePriceModel representation of the project usage price.
func (p ProjectUsagePrice) ToModel() (model stripecoinpayments.ProjectUsagePriceModel, err error) {
// ToModel returns the payments.ProjectUsagePriceModel representation of the project usage price.
func (p ProjectUsagePrice) ToModel() (model payments.ProjectUsagePriceModel, err error) {
storageTBMonthDollars, err := decimal.NewFromString(p.StorageTB)
if err != nil {
return model, Error.Wrap(err)
@ -57,7 +58,7 @@ func (p ProjectUsagePrice) ToModel() (model stripecoinpayments.ProjectUsagePrice
}
// Shift is to change the precision from TB dollars to MB cents
return stripecoinpayments.ProjectUsagePriceModel{
return payments.ProjectUsagePriceModel{
StorageMBMonthCents: storageTBMonthDollars.Shift(-6).Shift(2),
EgressMBCents: egressTBDollars.Shift(-6).Shift(2),
SegmentMonthCents: segmentMonthDollars.Shift(2),
@ -132,9 +133,14 @@ func (p *ProjectUsagePriceOverrides) Set(s string) error {
return nil
}
// SetMap sets the internal mapping between partners and project usage prices.
func (p *ProjectUsagePriceOverrides) SetMap(overrides map[string]ProjectUsagePrice) {
p.overrideMap = overrides
}
// ToModels returns the price overrides represented as a mapping between partners and project usage price models.
func (p ProjectUsagePriceOverrides) ToModels() (map[string]stripecoinpayments.ProjectUsagePriceModel, error) {
models := make(map[string]stripecoinpayments.ProjectUsagePriceModel)
func (p ProjectUsagePriceOverrides) ToModels() (map[string]payments.ProjectUsagePriceModel, error) {
models := make(map[string]payments.ProjectUsagePriceModel)
for partner, prices := range p.overrideMap {
model, err := prices.ToModel()
if err != nil {

10
satellite/payments/paymentsconfig/config_test.go
View File

@ -11,12 +11,12 @@ import (
"github.com/shopspring/decimal"
"github.com/stretchr/testify/require"
"storj.io/storj/satellite/payments"
"storj.io/storj/satellite/payments/paymentsconfig"
"storj.io/storj/satellite/payments/stripecoinpayments"
)
func TestProjectUsagePriceOverrides(t *testing.T) {
type Prices map[string]stripecoinpayments.ProjectUsagePriceModel
type Prices map[string]payments.ProjectUsagePriceModel
cases := []struct {
testID string
@ -41,7 +41,7 @@ func TestProjectUsagePriceOverrides(t *testing.T) {
configValue: "partner:1,2,3",
expectedModel: Prices{
// Shift is to change the precision from TB dollars to MB cents
"partner": stripecoinpayments.ProjectUsagePriceModel{
"partner": payments.ProjectUsagePriceModel{
StorageMBMonthCents: decimal.NewFromInt(1).Shift(-4),
EgressMBCents: decimal.NewFromInt(2).Shift(-4),
SegmentMonthCents: decimal.NewFromInt(3).Shift(2),
@ -57,12 +57,12 @@ func TestProjectUsagePriceOverrides(t *testing.T) {
testID: "multiple price overrides",
configValue: "partner1:1,2,3;partner2:4,5,6",
expectedModel: Prices{
"partner1": stripecoinpayments.ProjectUsagePriceModel{
"partner1": payments.ProjectUsagePriceModel{
StorageMBMonthCents: decimal.NewFromInt(1).Shift(-4),
EgressMBCents: decimal.NewFromInt(2).Shift(-4),
SegmentMonthCents: decimal.NewFromInt(3).Shift(2),
},
"partner2": stripecoinpayments.ProjectUsagePriceModel{
"partner2": payments.ProjectUsagePriceModel{
StorageMBMonthCents: decimal.NewFromInt(4).Shift(-4),
EgressMBCents: decimal.NewFromInt(5).Shift(-4),
SegmentMonthCents: decimal.NewFromInt(6).Shift(2),

9
satellite/payments/projectcharges.go
View File

@ -4,6 +4,8 @@
package payments
import (
"github.com/shopspring/decimal"
"storj.io/common/uuid"
"storj.io/storj/satellite/accounting"
)
@ -20,3 +22,10 @@ type ProjectCharge struct {
// SegmentCount shows how many cents we should pay for objects count.
SegmentCount int64 `json:"segmentPrice"`
}
// ProjectUsagePriceModel represents price model for project usage.
type ProjectUsagePriceModel struct {
StorageMBMonthCents decimal.Decimal `json:"storageMBMonthCents"`
EgressMBCents decimal.Decimal `json:"egressMBCents"`
SegmentMonthCents decimal.Decimal `json:"segmentMonthCents"`
}

28
satellite/payments/stripecoinpayments/accounts.go
View File

@ -10,6 +10,7 @@ import (
"github.com/stripe/stripe-go/v72"
"github.com/zeebo/errs"
"storj.io/common/useragent"
"storj.io/common/uuid"
"storj.io/storj/satellite/payments"
)
@ -119,13 +120,19 @@ func (accounts *accounts) ProjectCharges(ctx context.Context, userID uuid.UUID,
return nil, Error.Wrap(err)
}
user, err := accounts.service.usersDB.Get(ctx, userID)
if err != nil {
return nil, Error.Wrap(err)
}
for _, project := range projects {
usage, err := accounts.service.usageDB.GetProjectTotal(ctx, project.ID, since, before)
if err != nil {
return charges, Error.Wrap(err)
}
projectPrice := accounts.service.calculateProjectUsagePrice(usage.Egress, usage.Storage, usage.SegmentCount)
pricing := accounts.GetProjectUsagePriceModel(user.UserAgent)
projectPrice := accounts.service.calculateProjectUsagePrice(usage.Egress, usage.Storage, usage.SegmentCount, pricing)
charges = append(charges, payments.ProjectCharge{
ProjectUsage: *usage,
@ -140,6 +147,25 @@ func (accounts *accounts) ProjectCharges(ctx context.Context, userID uuid.UUID,
return charges, nil
}
// GetProjectUsagePriceModel returns the project usage price model for a user agent.
// If the user agent is malformed or does not contain a valid partner ID, the default
// price model is returned.
func (accounts *accounts) GetProjectUsagePriceModel(userAgent []byte) payments.ProjectUsagePriceModel {
if userAgent == nil {
return accounts.service.usagePrices
}
entries, err := useragent.ParseEntries(userAgent)
if err != nil {
return accounts.service.usagePrices
}
for _, entry := range entries {
if override, ok := accounts.service.usagePriceOverrides[entry.Product]; ok {
return override
}
}
return accounts.service.usagePrices
}
// 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).
func (accounts *accounts) CheckProjectInvoicingStatus(ctx context.Context, projectID uuid.UUID) (err error) {

1
satellite/payments/stripecoinpayments/accounts_test.go
View File

@ -76,6 +76,7 @@ func TestSignupCouponCodes(t *testing.T) {
db.Wallets(),
db.Billing(),
db.Console().Projects(),
db.Console().Users(),
db.ProjectAccounting(),
prices,
priceOverrides,

44
satellite/payments/stripecoinpayments/service.go
View File

@ -61,11 +61,12 @@ type Service struct {
billingDB billing.TransactionsDB
projectsDB console.Projects
usersDB console.Users
usageDB accounting.ProjectAccounting
stripeClient StripeClient
usagePrices ProjectUsagePriceModel
usagePriceOverrides map[string]ProjectUsagePriceModel
usagePrices payments.ProjectUsagePriceModel
usagePriceOverrides map[string]payments.ProjectUsagePriceModel
// BonusRate amount of percents
BonusRate int64
// Coupon Values
@ -79,21 +80,15 @@ type Service struct {
nowFn func() time.Time
}
// ProjectUsagePriceModel represents price model for project usage.
type ProjectUsagePriceModel struct {
StorageMBMonthCents decimal.Decimal
EgressMBCents decimal.Decimal
SegmentMonthCents decimal.Decimal
}
// NewService creates a Service instance.
func NewService(log *zap.Logger, stripeClient StripeClient, config Config, db DB, walletsDB storjscan.WalletsDB, billingDB billing.TransactionsDB, projectsDB console.Projects, usageDB accounting.ProjectAccounting, usagePrices ProjectUsagePriceModel, usagePriceOverrides map[string]ProjectUsagePriceModel, bonusRate int64) (*Service, error) {
func NewService(log *zap.Logger, stripeClient StripeClient, config Config, db DB, walletsDB storjscan.WalletsDB, billingDB billing.TransactionsDB, projectsDB console.Projects, usersDB console.Users, usageDB accounting.ProjectAccounting, usagePrices payments.ProjectUsagePriceModel, usagePriceOverrides map[string]payments.ProjectUsagePriceModel, bonusRate int64) (*Service, error) {
return &Service{
log: log,
db: db,
walletsDB: walletsDB,
billingDB: billingDB,
projectsDB: projectsDB,
usersDB: usersDB,
usageDB: usageDB,
stripeClient: stripeClient,
usagePrices: usagePrices,
@ -463,7 +458,14 @@ func (service *Service) applyProjectRecords(ctx context.Context, records []Proje
return 0, errs.Wrap(err)
}
if skipped, err := service.createInvoiceItems(ctx, cusID, proj.Name, record); err != nil {
owner, err := service.usersDB.Get(ctx, proj.OwnerID)
if err != nil {
service.log.Error("Owner does not exist for project.", zap.Stringer("Owner ID", proj.OwnerID), zap.Stringer("Project ID", record.ProjectID))
return 0, errs.Wrap(err)
}
pricing := service.Accounts().GetProjectUsagePriceModel(owner.UserAgent)
if skipped, err := service.createInvoiceItems(ctx, cusID, proj.Name, record, pricing); err != nil {
return 0, errs.Wrap(err)
} else if skipped {
skipCount++
@ -474,7 +476,7 @@ func (service *Service) applyProjectRecords(ctx context.Context, records []Proje
}
// createInvoiceItems creates invoice line items for stripe customer.
func (service *Service) createInvoiceItems(ctx context.Context, cusID, projName string, record ProjectRecord) (skipped bool, err error) {
func (service *Service) createInvoiceItems(ctx context.Context, cusID, projName string, record ProjectRecord, priceModel payments.ProjectUsagePriceModel) (skipped bool, err error) {
defer mon.Task()(&ctx)(&err)
if err = service.db.ProjectRecords().Consume(ctx, record.ID); err != nil {
@ -485,7 +487,7 @@ func (service *Service) createInvoiceItems(ctx context.Context, cusID, projName
return true, nil
}
items := service.InvoiceItemsFromProjectRecord(projName, record)
items := service.InvoiceItemsFromProjectRecord(projName, record, priceModel)
for _, item := range items {
item.Currency = stripe.String(string(stripe.CurrencyUSD))
item.Customer = stripe.String(cusID)
@ -501,25 +503,25 @@ func (service *Service) createInvoiceItems(ctx context.Context, cusID, projName
}
// InvoiceItemsFromProjectRecord calculates Stripe invoice item from project record.
func (service *Service) InvoiceItemsFromProjectRecord(projName string, record ProjectRecord) (result []*stripe.InvoiceItemParams) {
func (service *Service) InvoiceItemsFromProjectRecord(projName string, record ProjectRecord, priceModel payments.ProjectUsagePriceModel) (result []*stripe.InvoiceItemParams) {
projectItem := &stripe.InvoiceItemParams{}
projectItem.Description = stripe.String(fmt.Sprintf("Project %s - Segment Storage (MB-Month)", projName))
projectItem.Quantity = stripe.Int64(storageMBMonthDecimal(record.Storage).IntPart())
storagePrice, _ := service.usagePrices.StorageMBMonthCents.Float64()
storagePrice, _ := priceModel.StorageMBMonthCents.Float64()
projectItem.UnitAmountDecimal = stripe.Float64(storagePrice)
result = append(result, projectItem)
projectItem = &stripe.InvoiceItemParams{}
projectItem.Description = stripe.String(fmt.Sprintf("Project %s - Egress Bandwidth (MB)", projName))
projectItem.Quantity = stripe.Int64(egressMBDecimal(record.Egress).IntPart())
egressPrice, _ := service.usagePrices.EgressMBCents.Float64()
egressPrice, _ := priceModel.EgressMBCents.Float64()
projectItem.UnitAmountDecimal = stripe.Float64(egressPrice)
result = append(result, projectItem)
projectItem = &stripe.InvoiceItemParams{}
projectItem.Description = stripe.String(fmt.Sprintf("Project %s - Segment Fee (Segment-Month)", projName))
projectItem.Quantity = stripe.Int64(segmentMonthDecimal(record.Segments).IntPart())
segmentPrice, _ := service.usagePrices.SegmentMonthCents.Float64()
segmentPrice, _ := priceModel.SegmentMonthCents.Float64()
projectItem.UnitAmountDecimal = stripe.Float64(segmentPrice)
result = append(result, projectItem)
service.log.Info("invoice items", zap.Any("result", result))
@ -772,11 +774,11 @@ func (price projectUsagePrice) TotalInt64() int64 {
}
// calculateProjectUsagePrice calculate project usage price.
func (service *Service) calculateProjectUsagePrice(egress int64, storage, segments float64) projectUsagePrice {
func (service *Service) calculateProjectUsagePrice(egress int64, storage, segments float64, pricing payments.ProjectUsagePriceModel) projectUsagePrice {
return projectUsagePrice{
Storage: service.usagePrices.StorageMBMonthCents.Mul(storageMBMonthDecimal(storage)).Round(0),
Egress: service.usagePrices.EgressMBCents.Mul(egressMBDecimal(egress)).Round(0),
Segments: service.usagePrices.SegmentMonthCents.Mul(segmentMonthDecimal(segments)).Round(0),
Storage: pricing.StorageMBMonthCents.Mul(storageMBMonthDecimal(storage)).Round(0),
Egress: pricing.EgressMBCents.Mul(egressMBDecimal(egress)).Round(0),
Segments: pricing.SegmentMonthCents.Mul(segmentMonthDecimal(segments)).Round(0),
}
}

92
satellite/payments/stripecoinpayments/service_test.go
View File

@ -5,6 +5,7 @@ package stripecoinpayments_test
import (
"context"
"fmt"
"strconv"
"testing"
"time"
@ -25,7 +26,9 @@ import (
"storj.io/storj/satellite/accounting"
"storj.io/storj/satellite/console"
"storj.io/storj/satellite/metabase"
"storj.io/storj/satellite/payments"
"storj.io/storj/satellite/payments/billing"
"storj.io/storj/satellite/payments/paymentsconfig"
"storj.io/storj/satellite/payments/stripecoinpayments"
)
@ -273,7 +276,8 @@ func TestService_InvoiceItemsFromProjectRecord(t *testing.T) {
Segments: tc.Segments,
}
items := satellite.API.Payments.StripeService.InvoiceItemsFromProjectRecord("project name", record)
pricing := satellite.API.Payments.Accounts.GetProjectUsagePriceModel(nil)
items := satellite.API.Payments.StripeService.InvoiceItemsFromProjectRecord("project name", record, pricing)
require.Equal(t, tc.StorageQuantity, *items[0].Quantity)
require.Equal(t, expectedStoragePrice, *items[0].UnitAmountDecimal)
@ -489,3 +493,89 @@ func generateProjectStorage(ctx context.Context, tb testing.TB, db satellite.DB,
err = db.ProjectAccounting().SaveTallies(ctx, end, tallies)
require.NoError(tb, err)
}
func TestProjectUsagePrice(t *testing.T) {
var (
defaultPrice = paymentsconfig.ProjectUsagePrice{
StorageTB: "1",
EgressTB: "2",
Segment: "3",
}
partnerName = "partner"
partnerPrice = paymentsconfig.ProjectUsagePrice{
StorageTB: "4",
EgressTB: "5",
Segment: "6",
}
)
defaultModel, err := defaultPrice.ToModel()
require.NoError(t, err)
partnerModel, err := partnerPrice.ToModel()
require.NoError(t, err)
testplanet.Run(t, testplanet.Config{
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 0,
Reconfigure: testplanet.Reconfigure{
Satellite: func(log *zap.Logger, index int, config *satellite.Config) {
config.Payments.UsagePrice = defaultPrice
config.Payments.UsagePriceOverrides.SetMap(map[string]paymentsconfig.ProjectUsagePrice{
partnerName: partnerPrice,
})
},
},
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
sat := planet.Satellites[0]
// pick a specific date so that it doesn't fail if it's the last day of the month
// keep month + 1 because user needs to be created before calculation
period := time.Date(time.Now().Year(), time.Now().Month()+1, 20, 0, 0, 0, 0, time.UTC)
sat.API.Payments.StripeService.SetNow(func() time.Time {
return time.Date(period.Year(), period.Month()+1, 1, 0, 0, 0, 0, time.UTC)
})
for i, tt := range []struct {
name string
userAgent []byte
expectedPrice payments.ProjectUsagePriceModel
}{
{"default pricing", nil, defaultModel},
{"default pricing - user agent is not valid partner ID", []byte("invalid/v0.0"), defaultModel},
{"partner pricing - user agent is partner ID", []byte(partnerName), partnerModel},
{"partner pricing - user agent includes partner ID", []byte("invalid/v0.0 " + partnerName + " invalid/v0.0"), partnerModel},
} {
t.Run(tt.name, func(t *testing.T) {
user, err := sat.AddUser(ctx, console.CreateUser{
FullName: "Test User",
Email: fmt.Sprintf("user%d@mail.test", i),
UserAgent: tt.userAgent,
}, 1)
require.NoError(t, err)
project, err := sat.AddProject(ctx, user.ID, "testproject")
require.NoError(t, err)
err = sat.DB.Orders().UpdateBucketBandwidthSettle(ctx, project.ID, []byte("testbucket"),
pb.PieceAction_GET, memory.TB.Int64(), 0, period)
require.NoError(t, err)
err = sat.API.Payments.StripeService.PrepareInvoiceProjectRecords(ctx, period)
require.NoError(t, err)
err = sat.API.Payments.StripeService.InvoiceApplyProjectRecords(ctx, period)
require.NoError(t, err)
cusID, err := sat.DB.StripeCoinPayments().Customers().GetCustomerID(ctx, user.ID)
require.NoError(t, err)
items := getCustomerInvoiceItems(sat.API.Payments.StripeClient, cusID)
require.Len(t, items, 3)
storage, _ := tt.expectedPrice.StorageMBMonthCents.Float64()
require.Equal(t, storage, items[0].UnitAmountDecimal)
egress, _ := tt.expectedPrice.EgressMBCents.Float64()
require.Equal(t, egress, items[1].UnitAmountDecimal)
segment, _ := tt.expectedPrice.SegmentMonthCents.Float64()
require.Equal(t, segment, items[2].UnitAmountDecimal)
})
}
})
}

3
satellite/payments/stripecoinpayments/stripemock.go
View File

@ -528,6 +528,9 @@ func (m *mockInvoiceItems) New(params *stripe.InvoiceItemParams) (*stripe.Invoic
item := &stripe.InvoiceItem{
Metadata: params.Metadata,
}
if params.UnitAmountDecimal != nil {
item.UnitAmountDecimal = *params.UnitAmountDecimal
}
m.items[*params.Customer] = append(m.items[*params.Customer], item)
return item, nil