1
2
3
4
5
6
7
8
9
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
package faker
import (
_ "embed"
"encoding/json"
"reflect"
"github.com/go-faker/faker/v4/pkg/options"
)
var (
//go:embed misc/addresses-us-1000.min.json
addressesUSBytes []byte
addressesUS []RealAddress
//go:embed misc/country_info.json
countriesBytes []byte
countries []CountryInfo
)
func init() {
data := struct {
Addresses []RealAddress `json:"addresses"`
Countries []CountryInfo `json:"countries"`
}{}
if err := json.Unmarshal(addressesUSBytes, &data); err != nil {
panic(err)
}
addressesUS = data.Addresses
if err := json.Unmarshal(countriesBytes, &data); err != nil {
panic(err)
}
countries = data.Countries
}
// GetAddress returns a new Addresser interface of Address
func GetAddress() Addresser {
address := &Address{}
return address
}
// Addresser is logical layer for Address
type Addresser interface {
Latitude(v reflect.Value) (interface{}, error)
Longitude(v reflect.Value) (interface{}, error)
RealWorld(v reflect.Value) (interface{}, error)
CountryInfo(v reflect.Value) (interface{}, error)
}
// Address struct
type Address struct{}
func (i Address) latitude() float32 {
return (rand.Float32() * 180) - 90
}
// Latitude sets latitude of the address
func (i Address) Latitude(v reflect.Value) (interface{}, error) {
kind := v.Kind()
val := i.latitude()
if kind == reflect.Float32 {
return val, nil
}
return float64(val), nil
}
func (i Address) longitude() float32 {
return (rand.Float32() * 360) - 180
}
// Longitude sets longitude of the address
func (i Address) Longitude(v reflect.Value) (interface{}, error) {
kind := v.Kind()
val := i.longitude()
if kind == reflect.Float32 {
return val, nil
}
return float64(val), nil
}
func (i Address) realWorld() RealAddress {
return addressesUS[rand.Intn(len(addressesUS))]
}
func (i Address) countryInfo() CountryInfo {
return countries[rand.Intn(len(countries))]
}
func (i Address) CountryInfo(_ reflect.Value) (interface{}, error) {
return i.countryInfo(), nil
}
// RealWorld sets real world address
func (i Address) RealWorld(_ reflect.Value) (interface{}, error) {
return i.realWorld(), nil
}
// Longitude get fake longitude randomly
func Longitude(opts ...options.OptionFunc) float64 {
return singleFakeData(LONGITUDE, func() interface{} {
address := Address{}
return float64(address.longitude())
}, opts...).(float64)
}
// Latitude get fake latitude randomly
func Latitude(opts ...options.OptionFunc) float64 {
return singleFakeData(LATITUDE, func() interface{} {
address := Address{}
return float64(address.latitude())
}, opts...).(float64)
}
type RealCoordinates struct {
Latitude float64 `json:"lat"`
Longitude float64 `json:"lng"`
}
type RealAddress struct {
Address string `json:"address1"`
City string `json:"city"`
State string `json:"state"`
PostalCode string `json:"postalCode"`
Coordinates RealCoordinates `json:"coordinates"`
}
// GetRealAddress get real world address randomly
func GetRealAddress(opts ...options.OptionFunc) RealAddress {
return singleFakeData(RealAddressTag, func() interface{} {
address := Address{}
return address.realWorld()
}, opts...).(RealAddress)
}
type CountryInfo struct {
Abbr string `json:"abbr"`
Name string `json:"name"`
Capital string `json:"capital"`
Population string `json:"population"`
Continent string `json:"continent"`
}
func GetCountryInfo(opts ...options.OptionFunc) CountryInfo {
return singleFakeData(CountryInfoTag, func() interface{} {
address := Address{}
return address.countryInfo()
}, opts...).(CountryInfo)
}
|
