amir_tavakolian
/
niki
forked from ebhomengo/niki
1
0
Fork 0
Code Pull Requests Activity
niki/vendor/github.com/brianvoe/gofakeit/v7/person.go

783 lines
22 KiB
Go
Raw Blame History

package gofakeit
import (
"math"
"strconv"
"strings"
)
// PersonInfo is a struct of person information
type PersonInfo struct {
FirstName string `json:"first_name" xml:"first_name"`
LastName string `json:"last_name" xml:"last_name"`
Gender string `json:"gender" xml:"gender"`
Age int `json:"age" xml:"age"`
SSN string `json:"ssn" xml:"ssn"`
Hobby string `json:"hobby" xml:"hobby"`
Job *JobInfo `json:"job" xml:"job"`
Address *AddressInfo `json:"address" xml:"address"`
Contact *ContactInfo `json:"contact" xml:"contact"`
CreditCard *CreditCardInfo `json:"credit_card" xml:"credit_card"`
}
// Person will generate a struct with person information
func Person() *PersonInfo { return person(GlobalFaker) }
// Person will generate a struct with person information
func (f *Faker) Person() *PersonInfo { return person(f) }
func person(f *Faker) *PersonInfo {
return &PersonInfo{
FirstName: firstName(f),
LastName: lastName(f),
Gender: gender(f),
Age: age(f),
SSN: ssn(f),
Hobby: hobby(f),
Job: job(f),
Address: address(f),
Contact: contact(f),
CreditCard: creditCard(f),
}
}
// Name will generate a random First and Last Name
func Name() string { return name(GlobalFaker) }
// Name will generate a random First and Last Name
func (f *Faker) Name() string { return name(f) }
func name(f *Faker) string {
return getRandValue(f, []string{"person", "first"}) + " " + getRandValue(f, []string{"person", "last"})
}
// FirstName will generate a random first name
func FirstName() string { return firstName(GlobalFaker) }
// FirstName will generate a random first name
func (f *Faker) FirstName() string { return firstName(f) }
func firstName(f *Faker) string { return getRandValue(f, []string{"person", "first"}) }
// MiddleName will generate a random middle name
func MiddleName() string { return middleName(GlobalFaker) }
// MiddleName will generate a random middle name
func (f *Faker) MiddleName() string { return middleName(f) }
func middleName(f *Faker) string { return getRandValue(f, []string{"person", "middle"}) }
// LastName will generate a random last name
func LastName() string { return lastName(GlobalFaker) }
// LastName will generate a random last name
func (f *Faker) LastName() string { return lastName(f) }
func lastName(f *Faker) string { return getRandValue(f, []string{"person", "last"}) }
// NamePrefix will generate a random name prefix
func NamePrefix() string { return namePrefix(GlobalFaker) }
// NamePrefix will generate a random name prefix
func (f *Faker) NamePrefix() string { return namePrefix(f) }
func namePrefix(f *Faker) string { return getRandValue(f, []string{"person", "prefix"}) }
// NameSuffix will generate a random name suffix
func NameSuffix() string { return nameSuffix(GlobalFaker) }
// NameSuffix will generate a random name suffix
func (f *Faker) NameSuffix() string { return nameSuffix(f) }
func nameSuffix(f *Faker) string { return getRandValue(f, []string{"person", "suffix"}) }
// Age will generate a random age between 0 and 100
func Age() int { return age(GlobalFaker) }
// Age will generate a random age between 0 and 100
func (f *Faker) Age() int { return age(f) }
func age(f *Faker) int { return randIntRange(f, 0, 100) }
// Ethnicity will generate a random ethnicity string
func Ethnicity() string { return ethnicity(GlobalFaker) }
// Ethnicity will generate a random ethnicity string
func (f *Faker) Ethnicity() string { return ethnicity(f) }
func ethnicity(f *Faker) string { return getRandValue(f, []string{"person", "ethnicity"}) }
// SSN will generate a random Social Security Number
func SSN() string { return ssn(GlobalFaker) }
// SSN will generate a random Social Security Number
func (f *Faker) SSN() string { return ssn(f) }
func ssn(f *Faker) string { return strconv.Itoa(randIntRange(f, 100000000, 999999999)) }
// EIN will generate a random Employer Identification Number
func EIN() string { return ein(GlobalFaker) }
// EIN will generate a random Employer Identification Number
func (f *Faker) EIN() string { return ein(f) }
func ein(f *Faker) string {
// EIN format: XX-XXXXXXX (2 digits, dash, 7 digits)
// First two digits have specific valid prefixes
prefixes := []string{"10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99"}
prefix := prefixes[f.IntN(len(prefixes))]
// Generate 7 random digits
sevenDigits := ""
for i := 0; i < 7; i++ {
sevenDigits += string(rune('0' + f.IntN(10)))
}
return prefix + "-" + sevenDigits
}
// Gender will generate a random gender string
func Gender() string { return gender(GlobalFaker) }
// Gender will generate a random gender string
func (f *Faker) Gender() string { return gender(f) }
func gender(f *Faker) string {
if boolFunc(f) {
return "male"
}
return "female"
}
// Hobby will generate a random hobby string
func Hobby() string { return hobby(GlobalFaker) }
// Hobby will generate a random hobby string
func (f *Faker) Hobby() string { return hobby(f) }
func hobby(f *Faker) string { return getRandValue(f, []string{"person", "hobby"}) }
// SocialMedia will generate a random social media string
func SocialMedia() string { return socialMedia(GlobalFaker) }
// SocialMedia will generate a random social media string
func (f *Faker) SocialMedia() string { return socialMedia(f) }
func socialMedia(f *Faker) string {
template := getRandValue(f, []string{"person", "social_media"})
social, err := generate(f, template)
if err != nil {
return template // fallback to raw template if generation fails
}
return social
}
// Bio will generate a random biography using mad libs style templates
func Bio() string {
return bio(GlobalFaker)
}
// Bio will generate a random biography using mad libs style templates
func (f *Faker) Bio() string {
return bio(f)
}
func bio(f *Faker) string {
template := getRandValue(f, []string{"person", "bio"})
// Use generate function to process the template with all available lookups
bio, err := generate(f, template)
if err != nil {
return template // fallback to raw template if generation fails
}
return bio
}
// ContactInfo struct full of contact info
type ContactInfo struct {
Phone string `json:"phone" xml:"phone"`
Email string `json:"email" xml:"email"`
}
// Contact will generate a struct with information randomly populated contact information
func Contact() *ContactInfo { return contact(GlobalFaker) }
// Contact will generate a struct with information randomly populated contact information
func (f *Faker) Contact() *ContactInfo { return contact(f) }
func contact(f *Faker) *ContactInfo {
return &ContactInfo{
Phone: phone(f),
Email: email(f),
}
}
// Phone will generate a random phone number string
func Phone() string { return phone(GlobalFaker) }
// Phone will generate a random phone number string
func (f *Faker) Phone() string { return phone(f) }
func phone(f *Faker) string { return replaceWithNumbers(f, "##########") }
// PhoneFormatted will generate a random phone number string
func PhoneFormatted() string { return phoneFormatted(GlobalFaker) }
// PhoneFormatted will generate a random phone number string
func (f *Faker) PhoneFormatted() string { return phoneFormatted(f) }
func phoneFormatted(f *Faker) string {
return replaceWithNumbers(f, getRandValue(f, []string{"person", "phone"}))
}
// Email will generate a random email string
func Email() string { return email(GlobalFaker) }
// Email will generate a random email string
func (f *Faker) Email() string { return email(f) }
func email(f *Faker) string {
email := getRandValue(f, []string{"person", "first"}) + getRandValue(f, []string{"person", "last"})
email += "@"
email += getRandValue(f, []string{"person", "last"}) + "." + getRandValue(f, []string{"internet", "domain_suffix"})
return strings.ToLower(email)
}
// Teams takes in an array of people and team names and randomly places the people into teams as evenly as possible
func Teams(peopleArray []string, teamsArray []string) map[string][]string {
return teams(GlobalFaker, peopleArray, teamsArray)
}
// Teams takes in an array of people and team names and randomly places the people into teams as evenly as possible
func (f *Faker) Teams(peopleArray []string, teamsArray []string) map[string][]string {
return teams(f, peopleArray, teamsArray)
}
func teams(f *Faker, people []string, teams []string) map[string][]string {
// Shuffle the people if more than 1
if len(people) > 1 {
shuffleStrings(f, people)
}
peopleIndex := 0
teamsOutput := make(map[string][]string)
numPer := math.Ceil(float64(len(people)) / float64(len(teams)))
for _, team := range teams {
teamsOutput[team] = []string{}
for i := 0.00; i < numPer; i++ {
if peopleIndex < len(people) {
teamsOutput[team] = append(teamsOutput[team], people[peopleIndex])
peopleIndex++
}
}
}
return teamsOutput
}
func addPersonLookup() {
AddFuncLookup("person", Info{
Display: "Person",
Category: "person",
Description: "Personal data, like name and contact details, used for identification and communication",
Example: `{
"first_name": "Markus",
"last_name": "Moen",
"gender": "male",
"age": 30,
"ssn": "275413589",
"image": "https://picsum.photos/208/500",
"hobby": "Lacrosse",
"job": {
"company": "Intermap Technologies",
"title": "Developer",
"descriptor": "Direct",
"level": "Paradigm"
},
"address": {
"address": "369 North Cornerbury, Miami, North Dakota 24259",
"street": "369 North Cornerbury",
"city": "Miami",
"state": "North Dakota",
"zip": "24259",
"country": "Ghana",
"latitude": -6.662595,
"longitude": 23.921575
},
"contact": {
"phone": "3023202027",
"email": "lamarkoelpin@heaney.biz"
},
"credit_card": {
"type": "Maestro",
"number": "39800889982276",
"exp": "01/29",
"cvv": "932"
}
}`,
Output: "map[string]any",
ContentType: "application/json",
Aliases: []string{
"person record",
"identity profile",
"user profile",
"personal info",
"individual data",
},
Keywords: []string{
"profile", "identity", "individual",
"user", "account", "record", "contact",
"name", "details", "attributes", "information",
"bio", "demographics", "personal", "data",
},
Generate: func(f *Faker, m *MapParams, info *Info) (any, error) {
return person(f), nil
},
})
// full name
AddFuncLookup("name", Info{
Display: "Name",
Category: "person",
Description: "The given and family name of an individual",
Example: "Markus Moen",
Output: "string",
Aliases: []string{
"full name",
"person name",
"complete name",
"name string",
"display name",
},
Keywords: []string{
"fullname", "given", "family",
"first", "last", "forename", "surname",
"display", "legal",
},
Generate: func(f *Faker, m *MapParams, info *Info) (any, error) { return name(f), nil },
})
// name prefix (honorific)
AddFuncLookup("nameprefix", Info{
Display: "Name Prefix",
Category: "person",
Description: "A title or honorific added before a person's name",
Example: "Mr.",
Output: "string",
Aliases: []string{
"name prefix",
"honorific",
"title prefix",
"courtesy title",
"pre-nominal",
},
Keywords: []string{
"prefix", "title", "mr", "ms", "mrs",
"dr", "prof", "sir", "madam", "rev", "fr",
},
Generate: func(f *Faker, m *MapParams, info *Info) (any, error) { return namePrefix(f), nil },
})
// name suffix (generational/professional)
AddFuncLookup("namesuffix", Info{
Display: "Name Suffix",
Category: "person",
Description: "A title or designation added after a person's name",
Example: "Jr.",
Output: "string",
Aliases: []string{
"name suffix",
"post nominal",
"suffix designation",
"generational suffix",
"professional suffix",
},
Keywords: []string{
"suffix", "jr", "sr", "iii", "iv",
"esq", "phd", "md", "mba", "cpa",
"designation",
},
Generate: func(f *Faker, m *MapParams, info *Info) (any, error) { return nameSuffix(f), nil },
})
// first name
AddFuncLookup("firstname", Info{
Display: "First Name",
Category: "person",
Description: "The name given to a person at birth",
Example: "Markus",
Output: "string",
Aliases: []string{
"first name",
"given name",
"forename",
"personal name",
"given label",
},
Keywords: []string{
"first", "given", "name",
"preferred", "callname", "initial",
"personal",
},
Generate: func(f *Faker, m *MapParams, info *Info) (any, error) { return firstName(f), nil },
})
// middle name
AddFuncLookup("middlename", Info{
Display: "Middle Name",
Category: "person",
Description: "Name between a person's first name and last name",
Example: "Belinda",
Output: "string",
Aliases: []string{
"middle name",
"second name",
"additional name",
"secondary name",
"middle initial label",
},
Keywords: []string{
"middle", "second", "additional", "secondary",
"name", "initial", "intermediate", "optional",
},
Generate: func(f *Faker, m *MapParams, info *Info) (any, error) { return middleName(f), nil },
})
// last name
AddFuncLookup("lastname", Info{
Display: "Last Name",
Category: "person",
Description: "The family name or surname of an individual",
Example: "Daniel",
Output: "string",
Aliases: []string{
"last name",
"family name",
"surname",
"patronymic",
"family designation",
},
Keywords: []string{
"last", "family", "name",
"lineage", "heritage", "ancestry", "clan",
"tribe",
},
Generate: func(f *Faker, m *MapParams, info *Info) (any, error) { return lastName(f), nil },
})
// gender
AddFuncLookup("gender", Info{
Display: "Gender",
Category: "person",
Description: "Classification that identifies gender",
Example: "male",
Output: "string",
Aliases: []string{
"gender identity",
"gender label",
"sex category",
"gender marker",
"presentation",
},
Keywords: []string{
"male", "female", "nonbinary",
"identity", "label", "category", "sex",
},
Generate: func(f *Faker, m *MapParams, info *Info) (any, error) { return gender(f), nil },
})
// age
AddFuncLookup("age", Info{
Display: "Age",
Category: "person",
Description: "The number of years a person has lived",
Example: "40",
Output: "int",
Aliases: []string{
"age of person", "person age", "age of individual", "years old", "years of age",
},
Keywords: []string{
"years", "old", "birthday", "birthdate", "birth-date",
"lifespan", "maturity", "elderly", "young", "adult", "teenager", "child",
"senior", "juvenile", "minor", "majority", "minority", "generation",
},
Generate: func(f *Faker, m *MapParams, info *Info) (any, error) { return age(f), nil },
})
// ethnicity
AddFuncLookup("ethnicity", Info{
Display: "Ethnicity",
Category: "person",
Description: "Classification that identifies a person's cultural or ethnic background",
Example: "German",
Output: "string",
Aliases: []string{
"ethnic background",
"ethnic identity",
"cultural background",
"cultural heritage",
"ethnic origin",
},
Keywords: []string{
"ethnic", "heritage", "ancestry",
"origin", "identity", "cultural", "nationality",
"background", "descent", "lineage",
},
Generate: func(f *Faker, m *MapParams, info *Info) (any, error) { return ethnicity(f), nil },
})
// ssn
AddFuncLookup("ssn", Info{
Display: "SSN",
Category: "person",
Description: "Unique nine-digit identifier used for government and financial purposes in the United States",
Example: "296446360",
Output: "string",
Aliases: []string{
"social security number",
"ssn number",
"us ssn",
"tax id us",
"federal id",
},
Keywords: []string{
"social", "security", "number",
"us", "tax", "irs", "employment",
"benefits", "identification",
},
Generate: func(f *Faker, m *MapParams, info *Info) (any, error) { return ssn(f), nil },
})
AddFuncLookup("ein", Info{
Display: "EIN",
Category: "person",
Description: "Nine-digit Employer Identification Number used by businesses for tax purposes",
Example: "12-3456789",
Output: "string",
Aliases: []string{
"employer id",
"tax id",
"business tax id",
"federal tax id",
"irs number",
},
Keywords: []string{
"employer", "identification", "tax", "business", "federal", "irs", "number", "id",
},
Generate: func(f *Faker, m *MapParams, info *Info) (any, error) { return ein(f), nil },
})
// hobby
AddFuncLookup("hobby", Info{
Display: "Hobby",
Category: "person",
Description: "An activity pursued for leisure and pleasure",
Example: "Swimming",
Output: "string",
Aliases: []string{
"pastime",
"leisure activity",
"recreational activity",
"interest",
"free-time pursuit",
},
Keywords: []string{
"leisure", "recreation",
"activity", "sport", "craft",
"game", "collection",
},
Generate: func(f *Faker, m *MapParams, info *Info) (any, error) { return hobby(f), nil },
})
AddFuncLookup("socialmedia", Info{
Display: "Social Media",
Category: "person",
Description: "Random social media string",
Example: "https://twitter.com/ImpossibleTrousers",
Output: "string",
Aliases: []string{
"social media",
"social link",
"social url",
"social handle",
"social username",
"social profile",
"profile link",
"profile url",
"profile handle",
"account link",
"account url",
"account handle",
"username handle",
"screen name",
// platform-intent phrases (useful for fuzzy scoring)
"twitter link",
"x link",
"instagram link",
"linkedin url",
"github url",
"tiktok handle",
"facebook profile",
},
Keywords: []string{
"social", "media", "profile", "account", "handle", "username",
"screenname", "link", "url",
"twitter", "x", "instagram", "linkedin", "github",
"tiktok", "facebook", "dribbble", "behance",
},
Generate: func(f *Faker, m *MapParams, info *Info) (any, error) { return socialMedia(f), nil },
})
AddFuncLookup("bio", Info{
Display: "Biography",
Category: "person",
Description: "Random biography",
Example: "Born in New York, John grew up to become a Software Engineer who codes applications.",
Output: "string",
Aliases: []string{
"bio",
"short bio",
"mini bio",
"one line bio",
"profile bio",
"user bio",
"author bio",
"about",
"about me",
"profile summary",
"personal summary",
"blurb",
"elevator pitch",
},
Keywords: []string{
"profile", "summary", "tagline", "intro",
"overview", "description", "story", "background",
"career", "job", "role", "hobby", "personal", "person",
"one-liner", "author", "user",
},
Generate: func(f *Faker, m *MapParams, info *Info) (any, error) { return f.Bio(), nil },
})
// email
AddFuncLookup("email", Info{
Display: "Email",
Category: "person",
Description: "Electronic mail address",
Example: "markusmoen@pagac.net",
Output: "string",
Aliases: []string{
"email address",
"mail address",
"contact email",
"user email",
"electronic mailbox",
},
Keywords: []string{
"address", "mail", "inbox",
"account", "contact", "sender", "recipient",
"domain", "username",
},
Generate: func(f *Faker, m *MapParams, info *Info) (any, error) { return email(f), nil },
})
// phone (raw digits)
AddFuncLookup("phone", Info{
Display: "Phone",
Category: "person",
Description: "Numerical sequence used to contact individuals via telephone or mobile devices",
Example: "6136459948",
Output: "string",
Aliases: []string{
"phone number",
"telephone number",
"mobile number",
"contact number",
"voice number",
},
Keywords: []string{
"number", "telephone", "mobile",
"contact", "dial", "cell", "landline",
"e164", "voice",
},
Generate: func(f *Faker, m *MapParams, info *Info) (any, error) { return phone(f), nil },
})
// phone formatted (readable)
AddFuncLookup("phoneformatted", Info{
Display: "Phone Formatted",
Category: "person",
Description: "Formatted phone number of a person",
Example: "136-459-9489",
Output: "string",
Aliases: []string{
"formatted phone",
"pretty phone",
"display phone",
"readable phone",
"formatted telephone",
},
Keywords: []string{
"phone", "formatted", "format", "pattern",
"dashes", "parentheses", "spaces", "separators",
"telephone", "contact",
},
Generate: func(f *Faker, m *MapParams, info *Info) (any, error) { return phoneFormatted(f), nil },
})
AddFuncLookup("teams", Info{
Display: "Teams",
Category: "person",
Description: "Randomly split people into teams",
Example: `{
"Team 1": [
"Justin",
"Connor",
"Jeff"
],
"Team 2": [
"Sharon",
"Fabian",
"Billy"
],
"Team 3": [
"Steve",
"Robert"
]
}`,
Output: "map[string][]string",
ContentType: "application/json",
Aliases: []string{
"people grouping",
"team assignment",
"random partition",
"group allocator",
"roster builder",
},
Keywords: []string{
"randomly", "person", "into",
"distribution", "allocation", "roster", "squad",
},
Params: []Param{
{Field: "people", Display: "Strings", Type: "[]string", Description: "Array of people"},
{Field: "teams", Display: "Strings", Type: "[]string", Description: "Array of teams"},
},
Generate: func(f *Faker, m *MapParams, info *Info) (any, error) {
people, err := info.GetStringArray(m, "people")
if err != nil {
return nil, err
}
teamsArray, err := info.GetStringArray(m, "teams")
if err != nil {
return nil, err
}
return teams(f, people, teamsArray), nil
},
})
}
View Git Blame Copy Permalink