niki/vendor/github.com/brianvoe/gofakeit/v6/payment.go

443 lines
14 KiB
Go

package gofakeit
import (
"math"
"math/rand"
"strconv"
"strings"
"time"
"github.com/brianvoe/gofakeit/v6/data"
)
// CurrencyInfo is a struct of currency information
type CurrencyInfo struct {
Short string `json:"short" xml:"short"`
Long string `json:"long" xml:"long"`
}
// Currency will generate a struct with random currency information
func Currency() *CurrencyInfo { return currency(globalFaker.Rand) }
// Currency will generate a struct with random currency information
func (f *Faker) Currency() *CurrencyInfo { return currency(f.Rand) }
func currency(r *rand.Rand) *CurrencyInfo {
index := r.Intn(len(data.Data["currency"]["short"]))
return &CurrencyInfo{
Short: data.Data["currency"]["short"][index],
Long: data.Data["currency"]["long"][index],
}
}
// CurrencyShort will generate a random short currency value
func CurrencyShort() string { return currencyShort(globalFaker.Rand) }
// CurrencyShort will generate a random short currency value
func (f *Faker) CurrencyShort() string { return currencyShort(f.Rand) }
func currencyShort(r *rand.Rand) string { return getRandValue(r, []string{"currency", "short"}) }
// CurrencyLong will generate a random long currency name
func CurrencyLong() string { return currencyLong(globalFaker.Rand) }
// CurrencyLong will generate a random long currency name
func (f *Faker) CurrencyLong() string { return currencyLong(f.Rand) }
func currencyLong(r *rand.Rand) string { return getRandValue(r, []string{"currency", "long"}) }
// Price will take in a min and max value and return a formatted price
func Price(min, max float64) float64 { return price(globalFaker.Rand, min, max) }
// Price will take in a min and max value and return a formatted price
func (f *Faker) Price(min, max float64) float64 { return price(f.Rand, min, max) }
func price(r *rand.Rand, min, max float64) float64 {
return math.Floor(float64Range(r, min, max)*100) / 100
}
// CreditCardInfo is a struct containing credit variables
type CreditCardInfo struct {
Type string `json:"type" xml:"type"`
Number string `json:"number" xml:"number"`
Exp string `json:"exp" xml:"exp"`
Cvv string `json:"cvv" xml:"cvv"`
}
// CreditCard will generate a struct full of credit card information
func CreditCard() *CreditCardInfo { return creditCard(globalFaker.Rand) }
// CreditCard will generate a struct full of credit card information
func (f *Faker) CreditCard() *CreditCardInfo { return creditCard(f.Rand) }
func creditCard(r *rand.Rand) *CreditCardInfo {
ccType := randomString(r, data.CreditCardTypes)
return &CreditCardInfo{
Type: data.CreditCards[randomString(r, data.CreditCardTypes)].Display,
Number: creditCardNumber(r, &CreditCardOptions{Types: []string{ccType}}),
Exp: creditCardExp(r),
Cvv: generate(r, strings.Repeat("#", int(data.CreditCards[randomString(r, data.CreditCardTypes)].Code.Size))),
}
}
// CreditCardType will generate a random credit card type string
func CreditCardType() string { return creditCardType(globalFaker.Rand) }
// CreditCardType will generate a random credit card type string
func (f *Faker) CreditCardType() string { return creditCardType(f.Rand) }
func creditCardType(r *rand.Rand) string {
return data.CreditCards[randomString(r, data.CreditCardTypes)].Display
}
// CreditCardOptions is the options for credit card number
type CreditCardOptions struct {
Types []string `json:"types"`
Bins []string `json:"bins"` // optional parameter of prepended numbers
Gaps bool `json:"gaps"`
}
// CreditCardNumber will generate a random luhn credit card number
func CreditCardNumber(cco *CreditCardOptions) string { return creditCardNumber(globalFaker.Rand, cco) }
// CreditCardNumber will generate a random luhn credit card number
func (f *Faker) CreditCardNumber(cco *CreditCardOptions) string { return creditCardNumber(f.Rand, cco) }
func creditCardNumber(r *rand.Rand, cco *CreditCardOptions) string {
if cco == nil {
cco = &CreditCardOptions{}
}
if cco.Types == nil || len(cco.Types) == 0 {
cco.Types = data.CreditCardTypes
}
ccType := randomString(r, cco.Types)
// Get Card info
var cardInfo data.CreditCardInfo
if info, ok := data.CreditCards[ccType]; ok {
cardInfo = info
} else {
ccType = randomString(r, data.CreditCardTypes)
cardInfo = data.CreditCards[ccType]
}
// Get length and pattern
length := randomUint(r, cardInfo.Lengths)
numStr := ""
if len(cco.Bins) >= 1 {
numStr = randomString(r, cco.Bins)
} else {
numStr = strconv.FormatUint(uint64(randomUint(r, cardInfo.Patterns)), 10)
}
numStr += strings.Repeat("#", int(length)-len(numStr))
numStr = numerify(r, numStr)
ui, _ := strconv.ParseUint(numStr, 10, 64)
// Loop through until its a valid luhn
for {
valid := isLuhn(strconv.FormatUint(ui, 10))
if valid {
break
}
ui++
}
numStr = strconv.FormatUint(ui, 10)
// Add gaps to number
if cco.Gaps {
for i, spot := range cardInfo.Gaps {
numStr = numStr[:(int(spot)+i)] + " " + numStr[(int(spot)+i):]
}
}
return numStr
}
// CreditCardExp will generate a random credit card expiration date string
// Exp date will always be a future date
func CreditCardExp() string { return creditCardExp(globalFaker.Rand) }
// CreditCardExp will generate a random credit card expiration date string
// Exp date will always be a future date
func (f *Faker) CreditCardExp() string { return creditCardExp(f.Rand) }
func creditCardExp(r *rand.Rand) string {
month := strconv.Itoa(randIntRange(r, 1, 12))
if len(month) == 1 {
month = "0" + month
}
var currentYear = time.Now().Year() - 2000
return month + "/" + strconv.Itoa(randIntRange(r, currentYear+1, currentYear+10))
}
// CreditCardCvv will generate a random CVV number
// Its a string because you could have 017 as an exp date
func CreditCardCvv() string { return creditCardCvv(globalFaker.Rand) }
// CreditCardCvv will generate a random CVV number
// Its a string because you could have 017 as an exp date
func (f *Faker) CreditCardCvv() string { return creditCardCvv(f.Rand) }
func creditCardCvv(r *rand.Rand) string { return numerify(r, "###") }
// isLuhn check is used for checking if credit card is a valid luhn card
func isLuhn(s string) bool {
var t = [...]int{0, 2, 4, 6, 8, 1, 3, 5, 7, 9}
odd := len(s) & 1
var sum int
for i, c := range s {
if c < '0' || c > '9' {
return false
}
if i&1 == odd {
sum += t[c-'0']
} else {
sum += int(c - '0')
}
}
return sum%10 == 0
}
// AchRouting will generate a 9 digit routing number
func AchRouting() string { return achRouting(globalFaker.Rand) }
// AchRouting will generate a 9 digit routing number
func (f *Faker) AchRouting() string { return achRouting(f.Rand) }
func achRouting(r *rand.Rand) string { return numerify(r, "#########") }
// AchAccount will generate a 12 digit account number
func AchAccount() string { return achAccount(globalFaker.Rand) }
// AchAccount will generate a 12 digit account number
func (f *Faker) AchAccount() string { return achAccount(f.Rand) }
func achAccount(r *rand.Rand) string { return numerify(r, "############") }
// BitcoinAddress will generate a random bitcoin address consisting of numbers, upper and lower characters
func BitcoinAddress() string { return bitcoinAddress(globalFaker.Rand) }
// BitcoinAddress will generate a random bitcoin address consisting of numbers, upper and lower characters
func (f *Faker) BitcoinAddress() string { return bitcoinAddress(f.Rand) }
func bitcoinAddress(r *rand.Rand) string {
return randomString(r, []string{"1", "3"}) + password(r, true, true, true, false, false, number(r, 25, 34))
}
// BitcoinPrivateKey will generate a random bitcoin private key base58 consisting of numbers, upper and lower characters
func BitcoinPrivateKey() string { return bitcoinPrivateKey(globalFaker.Rand) }
// BitcoinPrivateKey will generate a random bitcoin private key base58 consisting of numbers, upper and lower characters
func (f *Faker) BitcoinPrivateKey() string { return bitcoinPrivateKey(f.Rand) }
func bitcoinPrivateKey(r *rand.Rand) string {
var b strings.Builder
for i := 0; i < 49; i++ {
b.WriteString(randCharacter(r, base58))
}
return "5" + randomString(r, []string{"H", "J", "K"}) + b.String()
}
func addPaymentLookup() {
AddFuncLookup("currency", Info{
Display: "Currency",
Category: "payment",
Description: "Medium of exchange, often in the form of paper money or coins, used for trade and transactions",
Example: `{
"short": "IQD",
"long": "Iraq Dinar"
}`,
Output: "map[string]string",
ContentType: "application/json",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return currency(r), nil
},
})
AddFuncLookup("currencyshort", Info{
Display: "Currency Short",
Category: "payment",
Description: "Short 3-letter word used to represent a specific currency",
Example: "USD",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return currencyShort(r), nil
},
})
AddFuncLookup("currencylong", Info{
Display: "Currency Long",
Category: "payment",
Description: "Complete name of a specific currency used for official identification in financial transactions",
Example: "United States Dollar",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return currencyLong(r), nil
},
})
AddFuncLookup("price", Info{
Display: "Price",
Category: "payment",
Description: "The amount of money or value assigned to a product, service, or asset in a transaction",
Example: "92.26",
Output: "float64",
Params: []Param{
{Field: "min", Display: "Min", Type: "float", Default: "0", Description: "Minimum price value"},
{Field: "max", Display: "Max", Type: "float", Default: "1000", Description: "Maximum price value"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
min, err := info.GetFloat64(m, "min")
if err != nil {
return nil, err
}
max, err := info.GetFloat64(m, "max")
if err != nil {
return nil, err
}
return price(r, min, max), nil
},
})
AddFuncLookup("creditcard", Info{
Display: "Credit Card",
Category: "payment",
Description: "Plastic card allowing users to make purchases on credit, with payment due at a later date",
Example: `{
"type": "UnionPay",
"number": "4364599489953698",
"exp": "02/24",
"cvv": "300"
}`,
Output: "map[string]any",
ContentType: "application/json",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return creditCard(r), nil
},
})
AddFuncLookup("creditcardtype", Info{
Display: "Credit Card Type",
Category: "payment",
Description: "Classification of credit cards based on the issuing company",
Example: "Visa",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return creditCardType(r), nil
},
})
AddFuncLookup("creditcardnumber", Info{
Display: "Credit Card Number",
Category: "payment",
Description: "Unique numerical identifier on a credit card used for making electronic payments and transactions",
Example: "4136459948995369",
Output: "string",
Params: []Param{
{
Field: "types", Display: "Types", Type: "[]string", Default: "all",
Options: []string{"visa", "mastercard", "american-express", "diners-club", "discover", "jcb", "unionpay", "maestro", "elo", "hiper", "hipercard"},
Description: "A select number of types you want to use when generating a credit card number",
},
{Field: "bins", Display: "Bins", Type: "[]string", Optional: true, Description: "Optional list of prepended bin numbers to pick from"},
{Field: "gaps", Display: "Gaps", Type: "bool", Default: "false", Description: "Whether or not to have gaps in number"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
types, err := info.GetStringArray(m, "types")
if err != nil {
return nil, err
}
if len(types) == 1 && types[0] == "all" {
types = []string{}
}
bins, _ := info.GetStringArray(m, "bins")
gaps, err := info.GetBool(m, "gaps")
if err != nil {
return nil, err
}
options := CreditCardOptions{
Types: types,
Gaps: gaps,
}
if len(bins) >= 1 {
options.Bins = bins
}
return creditCardNumber(r, &options), nil
},
})
AddFuncLookup("creditcardexp", Info{
Display: "Credit Card Exp",
Category: "payment",
Description: "Date when a credit card becomes invalid and cannot be used for transactions",
Example: "01/21",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return creditCardExp(r), nil
},
})
AddFuncLookup("creditcardcvv", Info{
Display: "Credit Card CVV",
Category: "payment",
Description: "Three or four-digit security code on a credit card used for online and remote transactions",
Example: "513",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return creditCardCvv(r), nil
},
})
AddFuncLookup("achrouting", Info{
Display: "ACH Routing Number",
Category: "payment",
Description: "Unique nine-digit code used in the U.S. for identifying the bank and processing electronic transactions",
Example: "513715684",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return achRouting(r), nil
},
})
AddFuncLookup("achaccount", Info{
Display: "ACH Account Number",
Category: "payment",
Description: "A bank account number used for Automated Clearing House transactions and electronic transfers",
Example: "491527954328",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return achAccount(r), nil
},
})
AddFuncLookup("bitcoinaddress", Info{
Display: "Bitcoin Address",
Category: "payment",
Description: "Cryptographic identifier used to receive, store, and send Bitcoin cryptocurrency in a peer-to-peer network",
Example: "1lWLbxojXq6BqWX7X60VkcDIvYA",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return bitcoinAddress(r), nil
},
})
AddFuncLookup("bitcoinprivatekey", Info{
Display: "Bitcoin Private Key",
Category: "payment",
Description: "Secret, secure code that allows the owner to access and control their Bitcoin holdings",
Example: "5vrbXTADWJ6sQBSYd6lLkG97jljNc0X9VPBvbVqsIH9lWOLcoqg",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return bitcoinPrivateKey(r), nil
},
})
}