13 | func MapKeyArrInterface(m map[string]string) []interface{} {
14 | var n []interface{}
15 | for k := range m {
16 | n = append(n, k)
17 | }
18 | return n
19 | }
20 |
--------------------------------------------------------------------------------
/pkg/exchanger/openexchangerates.go:
--------------------------------------------------------------------------------
1 | package exchanger
2 |
3 | import (
4 | "fmt"
5 | "github.com/bitly/go-simplejson"
6 | "io/ioutil"
7 | "log"
8 | "net"
9 | "net/http"
10 | "time"
11 | )
12 |
13 | type openExchangeRatesApi struct {
14 | attributes
15 | }
16 |
17 | var (
18 | openExchangeRatesApiUrl = `https://openexchangerates.org/api/convert/1/%s/%s?app_id=%s`
19 | openExchangeRatesApiHeaders = map[string][]string{
20 | `Accept`: {`text/html,application/xhtml+xml,application/xml,application/json`},
21 | `Accept-Encoding`: {`text`},
22 | }
23 | )
24 |
25 | func (c *openExchangeRatesApi) requestRate(from string, to string, opt ...interface{}) (*openExchangeRatesApi, error) {
26 |
27 | // todo add option opt to add more headers or client configurations
28 | // free mem-leak
29 | // optimize for memory leak
30 | // todo optimize curl connection
31 |
32 | url := fmt.Sprintf(openExchangeRatesApiUrl, c.apiKey, from, to)
33 | req, _ := http.NewRequest("GET", url, nil)
34 |
35 | openExchangeRatesApiHeaders[`User-Agent`] = []string{c.userAgent}
36 | req.Header = openExchangeRatesApiHeaders
37 |
38 | res, err := c.Client.Do(req)
39 |
40 | if err != nil {
41 | return nil, err
42 | }
43 | defer res.Body.Close()
44 |
45 | body, err := ioutil.ReadAll(res.Body)
46 | if err != nil {
47 | return nil, err
48 | }
49 |
50 | // free mem-leak
51 | // todo discard data
52 | c.responseBody = string(body)
53 | return c, nil
54 | }
55 |
56 | // GetRateValue ... get exchange rate value
57 | func (c *openExchangeRatesApi) GetRateValue() float64 {
58 | return c.rateValue
59 | }
60 |
61 | // GetRateDateTime ... return rate datetime
62 | func (c *openExchangeRatesApi) GetRateDateTime() string {
63 | return c.rateDate.Format(time.RFC3339)
64 | }
65 |
66 | // GetExchangerName ... return exchanger name
67 | func (c *openExchangeRatesApi) GetExchangerName() string {
68 | return c.name
69 | }
70 |
71 | // Latest ... populate latest exchange rate
72 | func (c *openExchangeRatesApi) Latest(from string, to string, opt ...interface{}) error {
73 |
74 | _, err := c.requestRate(from, to, opt)
75 | if err != nil {
76 | log.Print(err)
77 | return err
78 | }
79 |
80 | // if from currency is same as converted currency return value of 1
81 | if from == to {
82 | c.rateValue = 1
83 | return nil
84 | }
85 |
86 | json, err := simplejson.NewJson([]byte(c.responseBody))
87 |
88 | if err != nil {
89 | log.Print(err)
90 | return err
91 | }
92 |
93 | // opening price
94 | value := json.GetPath(`response`).
95 | MustFloat64()
96 | // todo handle error
97 | if value <= 0 {
98 | return fmt.Errorf(`error in retrieving exhcange rate is 0`)
99 | }
100 | c.rateValue = value
101 | c.rateDate = time.Now()
102 | return nil
103 | }
104 |
105 | // NewOpenExchangeRatesApi ... return new instance of openExchangeRatesApi
106 | func NewOpenExchangeRatesApi(opt map[string]string) *openExchangeRatesApi {
107 | keepAliveTimeout := 600 * time.Second
108 | timeout := 5 * time.Second
109 | defaultTransport := &http.Transport{
110 | DialContext: (&net.Dialer{
111 | Timeout: 30 * time.Second,
112 | KeepAlive: keepAliveTimeout,
113 | DualStack: true,
114 | }).DialContext,
115 | MaxIdleConns: 100,
116 | MaxIdleConnsPerHost: 100,
117 | }
118 |
119 | client := &http.Client{
120 | Transport: defaultTransport,
121 | Timeout: timeout,
122 | }
123 |
124 | attr := attributes{
125 | name: `openexchangerates`,
126 | Client: client,
127 | apiKey: opt[`apiKey`],
128 | userAgent: `Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:21.0) Gecko/20100101 Firefox/21.0`,
129 | }
130 | if opt[`userAgent`] != "" {
131 | attr.userAgent = opt[`userAgent`]
132 | }
133 |
134 | r := &openExchangeRatesApi{attr}
135 | return r
136 | }
137 |
--------------------------------------------------------------------------------
/pkg/exchanger/openexchangerates_test.go:
--------------------------------------------------------------------------------
1 | package exchanger
2 |
3 | import (
4 | "github.com/me-io/go-swap/test/staticMock"
5 | "github.com/stretchr/testify/assert"
6 | "testing"
7 | )
8 |
9 | func TestOpenExchangeRatesApi_Latest(t *testing.T) {
10 | rate := NewOpenExchangeRatesApi(nil)
11 | assert.Equal(t, rate.name, `openexchangerates`)
12 |
13 | rate.Client.Transport = staticMock.NewTestMT()
14 |
15 | rate.Latest(`EUR`, `EUR`)
16 | assert.Equal(t, float64(1), rate.GetRateValue())
17 |
18 | rate.Latest(`USD`, `AED`)
19 | assert.Equal(t, float64(3.6571), rate.GetRateValue())
20 | }
21 |
--------------------------------------------------------------------------------
/pkg/exchanger/themoneyconverter.go:
--------------------------------------------------------------------------------
1 | package exchanger
2 |
3 | import (
4 | "fmt"
5 | "io/ioutil"
6 | "log"
7 | "net"
8 | "net/http"
9 | "regexp"
10 | "strconv"
11 | "strings"
12 | "time"
13 | )
14 |
15 | // @link : https://themoneyconverter.com/AED/EUR.aspx?amount=1
16 |
17 | type theMoneyConverterApi struct {
18 | attributes
19 | }
20 |
21 | var (
22 | theMoneyConverterApiUrl = `https://themoneyconverter.com/%s/%s.aspx?amount=1`
23 | theMoneyConverterApiHeaders = map[string][]string{
24 | `Accept`: {`text/html`},
25 | }
26 | )
27 |
28 | func (c *theMoneyConverterApi) requestRate(from string, to string, opt ...interface{}) (*theMoneyConverterApi, error) {
29 |
30 | // todo add option opt to add more headers or client configurations
31 | // free mem-leak
32 | // optimize for memory leak
33 | // todo optimize curl connection
34 |
35 | // format the url and replace currency
36 | url := fmt.Sprintf(theMoneyConverterApiUrl, from, to)
37 | // prepare the request
38 | req, _ := http.NewRequest("GET", url, nil)
39 | // assign the request headers
40 | theMoneyConverterApiHeaders[`User-Agent`] = []string{c.userAgent}
41 | req.Header = theMoneyConverterApiHeaders
42 |
43 | // execute the request
44 | res, err := c.Client.Do(req)
45 |
46 | if err != nil {
47 | return nil, err
48 | }
49 | defer res.Body.Close()
50 |
51 | body, err := ioutil.ReadAll(res.Body)
52 | if err != nil {
53 | return nil, err
54 | }
55 |
56 | // free mem-leak
57 | // todo discard data
58 | c.responseBody = string(body)
59 | return c, nil
60 | }
61 |
62 | // GetRateValue ... get exchange rate value
63 | func (c *theMoneyConverterApi) GetRateValue() float64 {
64 | return c.rateValue
65 | }
66 |
67 | // GetRateDateTime ... return rate datetime
68 | func (c *theMoneyConverterApi) GetRateDateTime() string {
69 | return c.rateDate.Format(time.RFC3339)
70 | }
71 |
72 | // GetExchangerName ... return exchanger name
73 | func (c *theMoneyConverterApi) GetExchangerName() string {
74 | return c.name
75 | }
76 |
77 | // Latest ... populate latest exchange rate
78 | func (c *theMoneyConverterApi) Latest(from string, to string, opt ...interface{}) error {
79 |
80 | // todo cache layer
81 | _, err := c.requestRate(from, to, opt)
82 | if err != nil {
83 | log.Print(err)
84 | return err
85 | }
86 |
87 | // if from currency is same as converted currency return value of 1
88 | if from == to {
89 | c.rateValue = 1
90 | return nil
91 | }
92 |
93 | validID := regexp.MustCompile(`(?s)output(.*)>(.*)`)
94 | stringMatches := validID.FindStringSubmatch(c.responseBody)
95 |
96 | stringMatch := strings.TrimSpace(strings.Replace(stringMatches[2], "\n", "", -1))
97 | stringMatch = strings.Replace(stringMatch, fmt.Sprintf("%d %s = ", 1, from), "", -1)
98 | stringMatch = strings.Replace(stringMatch, fmt.Sprintf(" %s", to), "", -1)
99 |
100 | c.rateValue, err = strconv.ParseFloat(stringMatch, 64)
101 | c.rateDate = time.Now()
102 |
103 | if err != nil {
104 | log.Print(err)
105 | return err
106 | }
107 | return nil
108 | }
109 |
110 | // NewTheMoneyConverterApi ... return new instance of theMoneyConverterApi
111 | func NewTheMoneyConverterApi(opt map[string]string) *theMoneyConverterApi {
112 |
113 | keepAliveTimeout := 600 * time.Second
114 | timeout := 5 * time.Second
115 | defaultTransport := &http.Transport{
116 | DialContext: (&net.Dialer{
117 | Timeout: 30 * time.Second,
118 | KeepAlive: keepAliveTimeout,
119 | DualStack: true,
120 | }).DialContext,
121 | MaxIdleConns: 100,
122 | MaxIdleConnsPerHost: 100,
123 | }
124 |
125 | client := &http.Client{
126 | Transport: defaultTransport,
127 | Timeout: timeout,
128 | }
129 |
130 | attr := attributes{
131 | name: `themoneyconverter`,
132 | Client: client,
133 | userAgent: `Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:21.0) Gecko/20100101 Firefox/21.0`,
134 | }
135 | if opt[`userAgent`] != "" {
136 | attr.userAgent = opt[`userAgent`]
137 | }
138 |
139 | r := &theMoneyConverterApi{attr}
140 |
141 | return r
142 | }
143 |
--------------------------------------------------------------------------------
/pkg/exchanger/themoneyconverter_test.go:
--------------------------------------------------------------------------------
1 | package exchanger
2 |
3 | import (
4 | "github.com/me-io/go-swap/test/staticMock"
5 | "github.com/stretchr/testify/assert"
6 | "testing"
7 | )
8 |
9 | func TestTheMoneyConverterApi_Latest(t *testing.T) {
10 | rate := NewTheMoneyConverterApi(nil)
11 | assert.Equal(t, rate.name, `themoneyconverter`)
12 |
13 | rate.Client.Transport = staticMock.NewTestMT()
14 |
15 | rate.Latest(`EUR`, `EUR`)
16 | assert.Equal(t, float64(1), rate.GetRateValue())
17 |
18 | rate.Latest(`USD`, `AED`)
19 | assert.Equal(t, float64(3.6725), rate.GetRateValue())
20 | }
21 |
--------------------------------------------------------------------------------
/pkg/exchanger/types.go:
--------------------------------------------------------------------------------
1 | package exchanger
2 |
3 | import (
4 | "net/http"
5 | "time"
6 | )
7 |
8 | // Rate ... Rate interface
9 | type Rate interface {
10 | GetRateValue() float64
11 | GetRateDateTime() string
12 | GetExchangerName() string
13 | }
14 |
15 | // Exchanger ... Exchanger interface
16 | type Exchanger interface {
17 | Latest(string, string, ...interface{}) error
18 | Rate
19 | }
20 |
21 | // attributes ... Exchanger attributes
22 | type attributes struct {
23 | apiVersion string
24 | apiKey string
25 | userAgent string
26 | responseBody string
27 | rateValue float64
28 | rateDate time.Time
29 | name string
30 | Client *http.Client // exposed for custom http clients or testing
31 | }
32 |
--------------------------------------------------------------------------------
/pkg/exchanger/yahoo.go:
--------------------------------------------------------------------------------
1 | package exchanger
2 |
3 | import (
4 | "fmt"
5 | "github.com/bitly/go-simplejson"
6 | "io/ioutil"
7 | "log"
8 | "math"
9 | "net"
10 | "net/http"
11 | "time"
12 | )
13 |
14 | type yahooApi struct {
15 | attributes
16 | }
17 |
18 | var (
19 | yahooApiUrl = `https://query1.finance.yahoo.com/v8/finance/chart/%s%s=X?region=US&lang=en-US&includePrePost=false&interval=1d&range=1d&corsDomain=finance.yahoo.com&.tsrc=finance`
20 | yahooApiHeaders = map[string][]string{
21 | `Accept`: {`text/html,application/xhtml+xml,application/xml,application/json`},
22 | `Accept-Encoding`: {`text`},
23 | }
24 | )
25 |
26 | func (c *yahooApi) requestRate(from string, to string, opt ...interface{}) (*yahooApi, error) {
27 |
28 | // todo add option opt to add more headers or client configurations
29 | // free mem-leak
30 | // optimize for memory leak
31 | // todo optimize curl connection
32 |
33 | url := fmt.Sprintf(yahooApiUrl, from, to)
34 | req, _ := http.NewRequest("GET", url, nil)
35 |
36 | yahooApiHeaders[`User-Agent`] = []string{c.userAgent}
37 | req.Header = yahooApiHeaders
38 |
39 | res, err := c.Client.Do(req)
40 |
41 | if err != nil {
42 | return nil, err
43 | }
44 | defer res.Body.Close()
45 |
46 | body, err := ioutil.ReadAll(res.Body)
47 | if err != nil {
48 | return nil, err
49 | }
50 |
51 | // free mem-leak
52 | // todo discard data
53 | c.responseBody = string(body)
54 | return c, nil
55 | }
56 |
57 | // GetRateValue ... get exchange rate value
58 | func (c *yahooApi) GetRateValue() float64 {
59 | return c.rateValue
60 | }
61 |
62 | // GetRateDateTime ... return rate datetime
63 | func (c *yahooApi) GetRateDateTime() string {
64 | return c.rateDate.Format(time.RFC3339)
65 | }
66 |
67 | // GetExchangerName ... return exchanger name
68 | func (c *yahooApi) GetExchangerName() string {
69 | return c.name
70 | }
71 |
72 | // Latest ... populate latest exchange rate
73 | func (c *yahooApi) Latest(from string, to string, opt ...interface{}) error {
74 |
75 | _, err := c.requestRate(from, to, opt)
76 | if err != nil {
77 | log.Print(err)
78 | return err
79 | }
80 |
81 | json, err := simplejson.NewJson([]byte(c.responseBody))
82 |
83 | if err != nil {
84 | log.Print(err)
85 | return err
86 | }
87 |
88 | // opening price
89 | value := json.GetPath(`chart`, `result`).
90 | GetIndex(0).
91 | //GetPath(`indicators`, `adjclose`).
92 | //GetIndex(0).
93 | //GetPath(`adjclose`).
94 | //GetIndex(0).
95 | GetPath(`indicators`, `quote`).
96 | GetIndex(0).
97 | GetPath(`open`).
98 | GetIndex(0).
99 | MustFloat64()
100 | // todo handle error
101 | if value <= 0 {
102 | return fmt.Errorf(`error in retrieving exhcange rate is 0`)
103 | }
104 | c.rateValue = math.Round(value*1000000) / 1000000
105 | c.rateDate = time.Now()
106 | return nil
107 | }
108 |
109 | // NewYahooApi ... return new instance of yahooApi
110 | func NewYahooApi(opt map[string]string) *yahooApi {
111 | keepAliveTimeout := 600 * time.Second
112 | timeout := 5 * time.Second
113 | defaultTransport := &http.Transport{
114 | DialContext: (&net.Dialer{
115 | Timeout: 30 * time.Second,
116 | KeepAlive: keepAliveTimeout,
117 | DualStack: true,
118 | }).DialContext,
119 | MaxIdleConns: 100,
120 | MaxIdleConnsPerHost: 100,
121 | }
122 |
123 | client := &http.Client{
124 | Transport: defaultTransport,
125 | Timeout: timeout,
126 | }
127 |
128 | attr := attributes{
129 | name: `yahoo`,
130 | Client: client,
131 | userAgent: `Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:21.0) Gecko/20100101 Firefox/21.0`,
132 | }
133 | if opt[`userAgent`] != "" {
134 | attr.userAgent = opt[`userAgent`]
135 | }
136 |
137 | r := &yahooApi{attr}
138 | return r
139 | }
140 |
--------------------------------------------------------------------------------
/pkg/exchanger/yahoo_test.go:
--------------------------------------------------------------------------------
1 | package exchanger
2 |
3 | import (
4 | "github.com/me-io/go-swap/test/staticMock"
5 | "github.com/stretchr/testify/assert"
6 | "testing"
7 | )
8 |
9 | func TestYahooApi_Latest(t *testing.T) {
10 | rate := NewYahooApi(nil)
11 | assert.Equal(t, rate.name, `yahoo`)
12 |
13 | rate.Client.Transport = staticMock.NewTestMT()
14 |
15 | rate.Latest(`USD`, `EUR`)
16 | assert.Equal(t, float64(0.272272), rate.GetRateValue())
17 | }
18 |
--------------------------------------------------------------------------------
/pkg/swap/doc.go:
--------------------------------------------------------------------------------
1 | package swap // import "github.com/me-io/go-swap/pkg/swap"
2 |
--------------------------------------------------------------------------------
/pkg/swap/swap.go:
--------------------------------------------------------------------------------
1 | package swap
2 |
3 | import (
4 | "fmt"
5 | ex "github.com/me-io/go-swap/pkg/exchanger"
6 | "log"
7 | "reflect"
8 | "strings"
9 | )
10 |
11 | // NewSwap ... configure new swap instance
12 | func NewSwap(opt ...string) *Swap {
13 | // todo add options
14 | // cache
15 | // timeout etc ...
16 | return &Swap{}
17 | }
18 |
19 | // AddExchanger ... add service to the swap stack
20 | func (b *Swap) AddExchanger(interfaceClass ex.Exchanger) *Swap {
21 | if interfaceClass != nil {
22 | b.exchangers = append(b.exchangers, interfaceClass)
23 | }
24 | return b
25 | }
26 |
27 | // Build ... build and init swap object
28 | func (b *Swap) Build() *Swap {
29 | return b
30 | }
31 |
32 | // Latest ... get latest rate exchange from the first api that respond from the swap stack
33 | func (b *Swap) Latest(currencyPair string) ex.Exchanger {
34 | if len(b.exchangers) < 1 {
35 | // configure at least one service
36 | log.Panic(400)
37 | }
38 |
39 | // todo
40 | var currentSrc ex.Exchanger
41 | errArr := map[string]string{}
42 |
43 | args := strings.Split(currencyPair, "/")
44 | for _, srv := range b.exchangers {
45 | err := srv.Latest(args[0], args[1], nil)
46 |
47 | if err != nil {
48 | // add errors to array so we can log them
49 | errArr[reflect.TypeOf(srv).String()] = fmt.Sprint(err)
50 | continue
51 | }
52 | // assign the service after first working service and break the loop
53 | currentSrc = srv
54 | break
55 | }
56 |
57 | if currentSrc == nil {
58 | log.Panic(errArr)
59 | }
60 | return currentSrc
61 | }
62 |
--------------------------------------------------------------------------------
/pkg/swap/swap_test.go:
--------------------------------------------------------------------------------
1 | package swap
2 |
3 | import (
4 | ex "github.com/me-io/go-swap/pkg/exchanger"
5 | "github.com/me-io/go-swap/test/staticMock"
6 | "github.com/stretchr/testify/assert"
7 | "reflect"
8 | "testing"
9 | )
10 |
11 | func TestSwap_New(t *testing.T) {
12 | SwapTest := NewSwap()
13 | assert.Equal(t, "*swap.Swap", reflect.TypeOf(SwapTest).String())
14 | }
15 |
16 | //func TestSwap_Latest_Error(t *testing.T) {
17 | // SwapTest := NewSwap()
18 | // assert.Equal(t, "*swap.Swap", reflect.TypeOf(SwapTest).String())
19 | // SwapTest.Build()
20 | // SwapTest.Latest("EUR/USD")
21 | //}
22 |
23 | func TestSwap_AddExchanger(t *testing.T) {
24 | SwapTest := NewSwap()
25 |
26 | g := ex.NewGoogleApi(nil)
27 | g.Client.Transport = staticMock.NewTestMT()
28 | y := ex.NewYahooApi(nil)
29 | y.Client.Transport = staticMock.NewTestMT()
30 |
31 | SwapTest.
32 | AddExchanger(g).
33 | AddExchanger(y).
34 | Build()
35 | assert.Equal(t, "*swap.Swap", reflect.TypeOf(SwapTest).String())
36 | }
37 |
38 | func TestSwap_Build_Google(t *testing.T) {
39 | SwapTest := NewSwap()
40 |
41 | g := ex.NewGoogleApi(nil)
42 | g.Client.Transport = staticMock.NewTestMT()
43 |
44 | SwapTest.
45 | AddExchanger(g).
46 | Build()
47 |
48 | euroToUsdRate := SwapTest.Latest("EUR/USD")
49 | assert.Equal(t, float64(3.67), euroToUsdRate.GetRateValue())
50 | assert.Equal(t, `google`, euroToUsdRate.GetExchangerName())
51 |
52 | usdToUsdRate := SwapTest.Latest("USD/USD")
53 | assert.Equal(t, float64(1), usdToUsdRate.GetRateValue())
54 | assert.Equal(t, `google`, euroToUsdRate.GetExchangerName())
55 | }
56 |
57 | func TestSwap_Build_Yahoo(t *testing.T) {
58 | SwapTest := NewSwap()
59 |
60 | y := ex.NewYahooApi(nil)
61 | y.Client.Transport = staticMock.NewTestMT()
62 |
63 | SwapTest.
64 | AddExchanger(y).
65 | Build()
66 |
67 | euroToUsdRate := SwapTest.Latest("EUR/USD")
68 | assert.Equal(t, float64(0.272272), euroToUsdRate.GetRateValue())
69 | assert.Equal(t, `yahoo`, euroToUsdRate.GetExchangerName())
70 | }
71 |
72 | func TestSwap_Build_Stack_Google_Yahoo(t *testing.T) {
73 | SwapTest := NewSwap()
74 | g := ex.NewGoogleApi(nil)
75 | g.Client.Transport = staticMock.NewTestMT()
76 | y := ex.NewYahooApi(nil)
77 | y.Client.Transport = staticMock.NewTestMT()
78 |
79 | SwapTest.
80 | AddExchanger(g).
81 | AddExchanger(y).
82 | Build()
83 |
84 | euroToUsdRate := SwapTest.Latest("EUR/USD")
85 | assert.Equal(t, float64(3.67), euroToUsdRate.GetRateValue())
86 | assert.Equal(t, `google`, euroToUsdRate.GetExchangerName())
87 | }
88 |
--------------------------------------------------------------------------------
/pkg/swap/types.go:
--------------------------------------------------------------------------------
1 | package swap
2 |
3 | import (
4 | ex "github.com/me-io/go-swap/pkg/exchanger"
5 | )
6 |
7 | // Swap ... main struct
8 | type Swap struct {
9 | exchangers []ex.Exchanger
10 | cache interface{}
11 | }
12 |
--------------------------------------------------------------------------------
/scripts/build-docker.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 |
3 | REPO_NAME="meio/go-swap-server"
4 | GIT_TAG=`git describe --tags --always --dirty`
5 | GO_VER=`go version`
6 | OS="linux"
7 | ARCH="amd64"
8 | DOCKER_TAG="${OS}-${ARCH}-${GIT_TAG}"
9 |
10 | # build only tag branch in this format 0.0.0
11 | if [[ ${GIT_TAG} =~ ^[[:digit:].[:digit:].[:digit:]]+$ ]]; then
12 | true
13 | echo "TAG: ${GIT_TAG} - start build"
14 | else
15 | echo "TAG: ${GIT_TAG} - skip build"
16 | exit 0
17 | fi
18 |
19 | # build only with go version 1.11
20 | if [[ ${GO_VER} =~ 1\.11 ]]; then
21 | echo "GO_VER: ${GO_VER} - start build"
22 | else
23 | echo "GO_VER: ${GO_VER} - skip build"
24 | exit 0
25 | fi
26 |
27 | if [[ ! -z "${DOCKER_PASSWORD}" && ! -z "${DOCKER_USERNAME}" ]]
28 | then
29 | echo "${DOCKER_PASSWORD}" | docker login -u "${DOCKER_USERNAME}" --password-stdin
30 | fi
31 |
32 | TAG_EXIST=`curl -s "https://hub.docker.com/v2/repositories/${REPO_NAME}/tags/${DOCKER_TAG}/" | grep '"id":'`
33 |
34 | if [[ ! -z ${TAG_EXIST} ]]; then
35 | echo "${REPO_NAME}:${DOCKER_TAG} already exist"
36 | exit 0
37 | fi
38 |
39 |
40 | docker build --build-arg BUILD_DATE=`date -u +"%Y-%m-%dT%H:%M:%SZ"` \
41 | --build-arg VCS_REF=`git rev-parse --short HEAD` \
42 | --build-arg DOCKER_TAG="${DOCKER_TAG}" \
43 | --build-arg VERSION="${GIT_TAG}" \
44 | -t ${REPO_NAME}:${DOCKER_TAG} -f .dockerfile-${OS}-${ARCH} .
45 |
46 | if [[ $? != 0 ]]; then
47 | echo "${REPO_NAME}:${DOCKER_TAG} build failed"
48 | exit 1
49 | fi
50 |
51 |
52 | if [[ -z ${TAG_EXIST} ]]; then
53 | docker push ${REPO_NAME}:${DOCKER_TAG}
54 | echo "${REPO_NAME}:${DOCKER_TAG} pushed successfully"
55 |
56 | fi
57 |
58 | # push latest
59 | docker build --build-arg BUILD_DATE=`date -u +"%Y-%m-%dT%H:%M:%SZ"` \
60 | --build-arg VCS_REF=`git rev-parse --short HEAD` \
61 | --build-arg DOCKER_TAG="${DOCKER_TAG}" \
62 | --build-arg VERSION="${GIT_TAG}" \
63 | -t ${REPO_NAME}:latest -f .dockerfile-${OS}-${ARCH} .
64 |
65 | docker push ${REPO_NAME}:latest
66 | echo "${REPO_NAME}:latest pushed successfully"
67 |
68 | # update microbadger.com
69 | curl -XPOST "https://hooks.microbadger.com/images/meio/go-swap-server/TOoBKgNqzCZH6dNBlAopouqsLF0="
70 |
--------------------------------------------------------------------------------
/scripts/build-local.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 |
3 | set -o errexit
4 | set -o nounset
5 | set -o pipefail
6 |
7 | export CGO_ENABLED=0
8 | my_dir="$(dirname "$0")"
9 |
10 | go build -o ${my_dir}/../bin/server cmd/server/*.go
11 |
--------------------------------------------------------------------------------
/scripts/build.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 |
3 | set -o errexit
4 | set -o nounset
5 | set -o pipefail
6 |
7 | if [ -z "${PKG}" ]; then
8 | echo "PKG must be set"
9 | exit 1
10 | fi
11 | if [ -z "${ARCH}" ]; then
12 | echo "ARCH must be set"
13 | exit 1
14 | fi
15 | if [ -z "${VERSION}" ]; then
16 | echo "VERSION must be set"
17 | exit 1
18 | fi
19 |
20 | if [ -z "${OS}" ]; then
21 | echo "OS must be set"
22 | exit 1
23 | fi
24 |
25 | export CGO_ENABLED=0
26 | export GOARCH="${ARCH}"
27 | export GOOS="${OS}"
28 |
29 | go install \
30 | -installsuffix "static" \
31 | -ldflags "-X ${PKG}/pkg/version.VERSION=${VERSION}" \
32 | ./...
33 |
--------------------------------------------------------------------------------
/scripts/docker-entrypoint.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 |
3 | exec ${BINSRC_ENV} "$@"
4 |
5 |
--------------------------------------------------------------------------------
/scripts/server-docker.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 |
3 | set -o errexit
4 | set -o nounset
5 | set -o pipefail
6 |
7 | my_dir="$(dirname "$0")"
8 |
9 | docker pull meio/go-swap-server:latest
10 | docker run --rm --name go-swap-server -u 0 -p 5000:5000 -it meio/go-swap-server:latest
11 |
--------------------------------------------------------------------------------
/scripts/server-redis.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 |
3 | set -o errexit
4 | set -o nounset
5 | set -o pipefail
6 |
7 | my_dir="$(dirname "$0")"
8 |
9 | GO_FILES=`find ${my_dir}/../cmd/server/. -type f \( -iname "*.go" ! -iname "*_test.go" \)`
10 | cmd="go run ${GO_FILES} -CACHE=redis -REDIS_URL=redis://localhost:6379"
11 | ${cmd}
12 |
--------------------------------------------------------------------------------
/scripts/server.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 |
3 | set -o errexit
4 | set -o nounset
5 | set -o pipefail
6 |
7 | my_dir="$(dirname "$0")"
8 |
9 | GO_FILES=`find ${my_dir}/../cmd/server/. -type f \( -iname "*.go" ! -iname "*_test.go" \)`
10 | go run ${GO_FILES}
11 |
--------------------------------------------------------------------------------
/scripts/test.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 |
3 | set -o errexit
4 | set -o nounset
5 | set -o pipefail
6 |
7 | export CGO_ENABLED=0
8 |
9 | TARGETS=$(for d in "$@"; do echo ./$d/...; done)
10 |
11 | echo "Running tests: Install packages: "
12 | go test -v -i -installsuffix "static" ${TARGETS} # Install packages that are dependencies of the test. Do not run the test..
13 | echo "Running tests: Run: "
14 | go test -covermode=count -coverprofile=profile.cov -v -installsuffix "static" ${TARGETS}
15 | echo
16 |
17 | echo -n "Checking gofmt: "
18 | ERRS=$(find "$@" -type f -name \*.go | xargs gofmt -l 2>&1 || true)
19 | if [ -n "${ERRS}" ]; then
20 | echo "FAIL - the following files need to be gofmt'ed:"
21 | for e in ${ERRS}; do
22 | echo " $e"
23 | done
24 | echo
25 | exit 1
26 | fi
27 | echo "PASS"
28 | echo
29 |
30 | echo -n "Checking go vet: "
31 | ERRS=$(go vet ${TARGETS} 2>&1 || true)
32 | if [ -n "${ERRS}" ]; then
33 | echo "FAIL"
34 | echo "${ERRS}"
35 | echo
36 | exit 1
37 | fi
38 | echo "PASS"
39 | echo
40 |
--------------------------------------------------------------------------------
/test/scripts/google.json:
--------------------------------------------------------------------------------
1 | {
2 | "amount": 3,
3 | "exchanger": [
4 | {
5 | "name": "google",
6 | "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:21.0) Gecko/20100101 Firefox/21.0"
7 | }
8 | ],
9 | "from": "USD",
10 | "to": "AED",
11 | "decimalPoints": 4
12 | }
13 |
--------------------------------------------------------------------------------
/test/scripts/multi_1.json:
--------------------------------------------------------------------------------
1 | {
2 | "amount": 3,
3 | "exchanger": [
4 | {
5 | "name": "currencyLayer",
6 | "apiKey": "12312",
7 | "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:21.0) Gecko/20100101 Firefox/21.0"
8 | },
9 | {
10 | "name": "yahoo",
11 | "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:21.0) Gecko/20100101 Firefox/21.0"
12 | },
13 | {
14 | "name": "google",
15 | "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:21.0) Gecko/20100101 Firefox/21.0"
16 | },
17 | {
18 | "name": "fixer",
19 | "apiKey": "12312",
20 | "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:21.0) Gecko/20100101 Firefox/21.0"
21 | },
22 | {
23 | "name": "google",
24 | "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:21.0) Gecko/20100101 Firefox/21.0"
25 | }
26 | ],
27 | "from": "USD",
28 | "to": "AED",
29 | "decimalPoints": 5
30 | }
31 |
--------------------------------------------------------------------------------
/test/scripts/request.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 |
3 | my_dir="$(dirname "$0")"
4 | filename=${1-multi_1}
5 | file=${my_dir}/${filename}.json
6 | host=${2-localhost}
7 | port=${3-5000}
8 | echo "file: ${file}"
9 |
10 | curl -X POST -H "Content-Type: application/json" -d @${file} http://${host}:${port}/convert
11 |
--------------------------------------------------------------------------------
/test/scripts/yahoo.json:
--------------------------------------------------------------------------------
1 | {
2 | "amount": 3,
3 | "exchanger": [
4 | {
5 | "name": "yahoo",
6 | "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:21.0) Gecko/20100101 Firefox/21.0"
7 | }
8 | ],
9 | "from": "USD",
10 | "to": "AED",
11 | "cacheTime": "10s",
12 | "decimalPoints": 6
13 | }
14 |
--------------------------------------------------------------------------------
/test/staticMock/1forge_json_aed_usd.json:
--------------------------------------------------------------------------------
1 | {
2 | "value": 3.675,
3 | "text": "1 USD is worth 3.675 AED",
4 | "timestamp": 1538254496
5 | }
6 |
--------------------------------------------------------------------------------
/test/staticMock/currencylayer_json_aed_usd.json:
--------------------------------------------------------------------------------
1 | {
2 | "success": true,
3 | "terms": "https:\/\/currencylayer.com\/terms",
4 | "privacy": "https:\/\/currencylayer.com\/privacy",
5 | "query": {
6 | "from": "AED",
7 | "to": "USD",
8 | "amount": 25
9 | },
10 | "info": {
11 | "timestamp": 1537250111,
12 | "quote": 0.272256
13 | },
14 | "result": 6.8064
15 | }
16 |
--------------------------------------------------------------------------------
/test/staticMock/doc.go:
--------------------------------------------------------------------------------
1 | package staticMock // import "github.com/me-io/go-swap/test/staticMock"
2 |
--------------------------------------------------------------------------------
/test/staticMock/fixer_json_aed_usd.json:
--------------------------------------------------------------------------------
1 | {
2 | "success": true,
3 | "query": {
4 | "from": "GBP",
5 | "to": "JPY",
6 | "amount": 25
7 | },
8 | "info": {
9 | "timestamp": 1519328414,
10 | "rate": 148.972231
11 | },
12 | "historical": "",
13 | "date": "2018-02-22",
14 | "result": 3724.305775
15 | }
16 |
--------------------------------------------------------------------------------
/test/staticMock/google_html_aed_usd.html:
--------------------------------------------------------------------------------
1 | |
2 |
9 | |
10 |
--------------------------------------------------------------------------------
/test/staticMock/openexchangerates_json_aed_usd.json:
--------------------------------------------------------------------------------
1 | {
2 | "disclaimer": "https://openexchangerates.org/terms/",
3 | "license": "https://openexchangerates.org/license/",
4 | "request": {
5 | "query": "/convert/1/USD/AED",
6 | "amount": 1,
7 | "from": "USD",
8 | "to": "AED"
9 | },
10 | "meta": {
11 | "timestamp": 1449885661,
12 | "rate": 3.6571
13 | },
14 | "response": 3.6571
15 | }
16 |
--------------------------------------------------------------------------------
/test/staticMock/themoneyconverter_html_aed_usd.html:
--------------------------------------------------------------------------------
1 |
2 |
5 |
6 |
10 |
--------------------------------------------------------------------------------
/test/staticMock/transport.go:
--------------------------------------------------------------------------------
1 | package staticMock
2 |
3 | import (
4 | "io/ioutil"
5 | "net/http"
6 | "path/filepath"
7 | "runtime"
8 | "strings"
9 | )
10 |
11 | type mT struct{}
12 |
13 | // NewTestMT ... return new RoundTripper for mocking http response
14 | func NewTestMT() http.RoundTripper {
15 | return &mT{}
16 | }
17 |
18 | // Implement http.RoundTripper
19 | func (t *mT) RoundTrip(req *http.Request) (*http.Response, error) {
20 | // Create mocked http.Response
21 | response := &http.Response{
22 | Header: make(http.Header),
23 | Request: req,
24 | StatusCode: http.StatusOK,
25 | }
26 | // url := req.URL.RequestURI()
27 | host := req.URL.Host
28 |
29 | _, filename, _, _ := runtime.Caller(0)
30 | tPath := filepath.Dir(filename)
31 |
32 | responseBody := ``
33 | response.Header.Set("Content-Type", "application/json")
34 |
35 | switch {
36 | case host == `www.google.com`:
37 | response.Header.Set("Content-Type", "text/html")
38 | fc, _ := ioutil.ReadFile(tPath + `/google_html_aed_usd.html`)
39 | responseBody = string(fc)
40 | break
41 | case host == `query1.finance.yahoo.com`:
42 | fp, _ := filepath.Abs(tPath + `/yahoo_json_aed_usd.json`)
43 | fc, _ := ioutil.ReadFile(fp)
44 | responseBody = string(fc)
45 | break
46 | case host == `apilayer.net`:
47 | fp, _ := filepath.Abs(tPath + `/currencylayer_json_aed_usd.json`)
48 | fc, _ := ioutil.ReadFile(fp)
49 | responseBody = string(fc)
50 | break
51 | case host == `data.fixer.io`:
52 | fp, _ := filepath.Abs(tPath + `/fixer_json_aed_usd.json`)
53 | fc, _ := ioutil.ReadFile(fp)
54 | responseBody = string(fc)
55 | break
56 | case host == `forex.1forge.com`:
57 | fp, _ := filepath.Abs(tPath + `/1forge_json_aed_usd.json`)
58 | fc, _ := ioutil.ReadFile(fp)
59 | responseBody = string(fc)
60 | break
61 | case host == `themoneyconverter.com`:
62 | fp, _ := filepath.Abs(tPath + `/themoneyconverter_html_aed_usd.html`)
63 | fc, _ := ioutil.ReadFile(fp)
64 | responseBody = string(fc)
65 | break
66 | case host == `openexchangerates.org`:
67 | fp, _ := filepath.Abs(tPath + `/openexchangerates_json_aed_usd.json`)
68 | fc, _ := ioutil.ReadFile(fp)
69 | responseBody = string(fc)
70 | break
71 | default:
72 |
73 | }
74 |
75 | response.Body = ioutil.NopCloser(strings.NewReader(responseBody))
76 | return response, nil
77 | }
78 |
--------------------------------------------------------------------------------
/test/staticMock/yahoo_json_aed_usd.json:
--------------------------------------------------------------------------------
1 | {
2 | "chart": {
3 | "result": [
4 | {
5 | "meta": {
6 | "currency": "USD",
7 | "symbol": "AEDUSD=X",
8 | "exchangeName": "CCY",
9 | "instrumentType": "CURRENCY",
10 | "firstTradeDate": 1070236800,
11 | "gmtoffset": 3600,
12 | "timezone": "BST",
13 | "exchangeTimezoneName": "Europe/London",
14 | "chartPreviousClose": 0.2723,
15 | "priceHint": 4,
16 | "currentTradingPeriod": {
17 | "pre": {
18 | "timezone": "BST",
19 | "start": 1537138800,
20 | "end": 1537138800,
21 | "gmtoffset": 3600
22 | },
23 | "regular": {
24 | "timezone": "BST",
25 | "start": 1537138800,
26 | "end": 1537225140,
27 | "gmtoffset": 3600
28 | },
29 | "post": {
30 | "timezone": "BST",
31 | "start": 1537225140,
32 | "end": 1537225140,
33 | "gmtoffset": 3600
34 | }
35 | },
36 | "dataGranularity": "1d",
37 | "validRanges": [
38 | "1d",
39 | "5d",
40 | "1mo",
41 | "3mo",
42 | "6mo",
43 | "1y",
44 | "2y",
45 | "5y",
46 | "10y",
47 | "ytd",
48 | "max"
49 | ]
50 | },
51 | "timestamp": [
52 | 1537186345
53 | ],
54 | "indicators": {
55 | "quote": [
56 | {
57 | "open": [
58 | 0.2722718417644501
59 | ],
60 | "volume": [
61 | 0
62 | ],
63 | "high": [
64 | 0.27238309383392334
65 | ],
66 | "low": [
67 | 0.27226442098617554
68 | ],
69 | "close": [
70 | 0.2722792625427246
71 | ]
72 | }
73 | ],
74 | "adjclose": [
75 | {
76 | "adjclose": [
77 | 0.2722792625427246
78 | ]
79 | }
80 | ]
81 | }
82 | }
83 | ],
84 | "error": null
85 | }
86 | }
87 |
--------------------------------------------------------------------------------
/version.go:
--------------------------------------------------------------------------------
1 | package go_swap
2 |
3 | // VERSION is the app-global version string, which should be substituted with a
4 | // real value during build.
5 | var VERSION = "0.0.1"
6 |
--------------------------------------------------------------------------------
22 | 
25 |
26 |
27 | #### /GET Examples for single exchanger:
28 | - [GET /convert?from=USD&to=AED&amount=2&exchanger=yahoo](https://go-swap-server.herokuapp.com/convert?from=USD&to=AED&amount=100&exchanger=yahoo)
29 | - [GET /convert?from=EUR&to=GBP&amount=1&exchanger=google&cacheTime=300s](https://go-swap-server.herokuapp.com/convert?from=EUR&to=GBP&amount=100&exchanger=google&cacheTime=300s)
30 | - [GET /convert?from=USD&to=SAR&amount=1&exchanger=themoneyconverter](https://go-swap-server.herokuapp.com/convert?from=USD&to=SAR&amount=100&exchanger=themoneyconverter)
31 |
32 | #### /POST Examples for single or multi exchanger:
33 | - CURL examples:
34 | ```bash
35 | curl -X POST \
36 | https://go-swap-server.herokuapp.com/convert \
37 | -H 'Content-Type: application/json' \
38 | -d '{
39 | "amount": 2.5,
40 | "from": "USD",
41 | "to": "AED",
42 | "decimalPoints": 4,
43 | "cacheTime": "120s",
44 | "exchanger": [
45 | {
46 | "name": "yahoo"
47 | },
48 | {
49 | "name": "google"
50 | },
51 | {
52 | "name": "themoneyconverter",
53 | "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:21.0) Gecko/20100101 Firefox/21.0"
54 | }
55 | ]
56 | }'
57 |
58 | # Response example
59 | # {
60 | # "to": "AED",
61 | # "from": "USD",
62 | # "exchangerName": "yahoo",
63 | # "exchangeValue": 3.6721,
64 | # "originalAmount": 2.5,
65 | # "convertedAmount": 9.1802,
66 | # "convertedText": "2.5 USD is worth 9.1802 AED",
67 | # "rateDateTime": "2018-09-30T07:45:45Z",
68 | # "rateFromCache": false
69 | # }
70 | ```
71 | - [Run in SwaggerUI](https://go-swap-server.herokuapp.com/swagger)
72 | - [](https://app.getpostman.com/run-collection/5f8445ef9a390fd3faa1)
73 |
74 | ## QuickStart
75 |
76 |
77 | 
78 |
79 | 
138 |
139 | ## Documentation
140 | The documentation for the current branch can be found [here](#documentation).
141 |
142 |
143 | ## Services
144 | |Exchanger |type |# |$|
145 | |:--- |:---- |:--- |:---|
146 | |[Google][1] |HTML / Regex |:heavy_check_mark: |Free|
147 | |[Yahoo][2] |JSON / API |:heavy_check_mark: |Free|
148 | |[Currency Layer][3] |JSON / API |:heavy_check_mark: |Paid - ApiKey|
149 | |[Fixer.io][4] |JSON / API |:heavy_check_mark: |Paid - ApiKey|
150 | |[1forge][7] |API |:heavy_check_mark: |Freemium / Paid - ApiKey|
151 | |[The Money Converter][5] |HTML / Regex |:heavy_check_mark: |Free|
152 | |[Open Exchange Rates][6] |API |:heavy_check_mark: |Freemium / Paid - ApiKey|
153 |
154 | [1]: //google.com
155 | [2]: //yahoo.com
156 | [3]: //currencylayer.com
157 | [4]: //fixer.io
158 | [5]: //themoneyconverter.com
159 | [6]: //openexchangerates.org
160 | [7]: //1forge.com
161 |
162 | ### Uptime Monitor
163 |
164 | 
165 |
166 |
167 | ## TODO LIST
168 | - [ ] error structure for empty json or regex not matched
169 | - [ ] convert panic to api json error
170 | - [ ] increase tests
171 | - [ ] verbose logging
172 | - [ ] godoc
173 | - [ ] static bundle public folder `./cmd/server/public`
174 | - [ ] v 1.0.0 release ( docker / binary github / homebrew mac )
175 | - [ ] support historical rates if possible
176 | - [ ] benchmark & performance optimization ` memory leak`
177 | - [ ] contributors list
178 |
179 | ## Contributing
180 |
181 | Anyone is welcome to [contribute](CONTRIBUTING.md), however, if you decide to get involved, please take a moment to review the guidelines:
182 |
183 | * [Only one feature or change per pull request](CONTRIBUTING.md#only-one-feature-or-change-per-pull-request)
184 | * [Write meaningful commit messages](CONTRIBUTING.md#write-meaningful-commit-messages)
185 | * [Follow the existing coding standards](CONTRIBUTING.md#follow-the-existing-coding-standards)
186 |
187 | #### Credits
188 | > Inspired by [florianv/swap](https://github.com/florianv/swap)
189 |
190 | ## License
191 |
192 | The code is available under the [MIT license](LICENSE.md).
193 |
--------------------------------------------------------------------------------
/app.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "Currency Converter Server",
3 | "description": "Golang Currency Converter Server",
4 | "website": "https://github.com/me-io/go-swap",
5 | "repository": "https://github.com/me-io/go-swap",
6 | "logo": "https://raw.githubusercontent.com/me-io/go-swap/master/icon.png",
7 | "keywords": [
8 | "golang",
9 | "currency",
10 | "currencylayer",
11 | "yahoo currency",
12 | "google currency",
13 | "fixer",
14 | "1forge"
15 | ],
16 | "success_url": "/",
17 | "stack": "heroku-16",
18 | "image": "heroku/go:latest",
19 | "formation": {
20 | "web": {
21 | "quantity": 1,
22 | "size": "free"
23 | }
24 | },
25 | "addons": [
26 | "heroku-redis:hobby-dev"
27 | ],
28 | "env": {
29 | "CACHE_ENV": {
30 | "description": "Cache driver ( memory or redis )",
31 | "value": "redis"
32 | }
33 | },
34 | "buildpacks": [
35 | {
36 | "url": "heroku/go"
37 | }
38 | ]
39 | }
40 |
--------------------------------------------------------------------------------
/cmd/server/convert.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "bytes"
5 | "crypto/md5"
6 | "encoding/json"
7 | "fmt"
8 | "github.com/go-ozzo/ozzo-validation"
9 | ex "github.com/me-io/go-swap/pkg/exchanger"
10 | "github.com/me-io/go-swap/pkg/swap"
11 | "io/ioutil"
12 | "math"
13 | "net/http"
14 | "time"
15 | )
16 |
17 | // Validate ... Validation function for convertReqObj
18 | func (c *convertReqObj) Validate() error {
19 |
20 | return validation.ValidateStruct(c,
21 | validation.Field(&c.Amount, validation.Required),
22 | validation.Field(&c.From, validation.Required, validation.In(ex.CurrencyListArr...)),
23 | validation.Field(&c.To, validation.Required, validation.In(ex.CurrencyListArr...)),
24 | validation.Field(&c.Exchanger, validation.Required),
25 | )
26 |
27 | //if ex.CurrencyList[c.To] == "" || ex.CurrencyList[c.From] == "" {
28 | // return fmt.Errorf("currency %s or %s is not supported", c.From, c.To)
29 | //}
30 | }
31 |
32 | // Hash ... return md5 string hash of the convertReqObj with 1 Unit Amount to cache the rate only for 1 Unit Amount
33 | func (c convertReqObj) Hash() string {
34 | // hash exchange key only with 1 Unit value
35 | c.Amount = 1
36 | jsonBytes, _ := json.Marshal(c)
37 | md5Sum := md5.Sum(jsonBytes)
38 | return fmt.Sprintf("%x", md5Sum[:])
39 | }
40 |
41 | // Convert ... Main convert function attached to the router handler
42 | var Convert = func(w http.ResponseWriter, r *http.Request) {
43 | if r.Method == "POST" {
44 | ConvertPost(w, r)
45 | }
46 | if r.Method == "GET" {
47 | ConvertGet(w, r)
48 | }
49 | }
50 |
51 | // ConvertGet ... handle GET request and simulate payload from get query params to ConvertPost function
52 | var ConvertGet = func(w http.ResponseWriter, r *http.Request) {
53 |
54 | query := r.URL.Query()
55 | apiKey := query.Get("apiKey")
56 | exchanger := query.Get("exchanger")
57 | amount := query.Get("amount")
58 | from := query.Get("from")
59 | to := query.Get("to")
60 | cacheTime := query.Get("cacheTime")
61 |
62 | payload := fmt.Sprintf(`{
63 | "amount": %s,
64 | "exchanger": [
65 | {
66 | "name": "%s",
67 | "apiKey": "%s"
68 | }
69 | ],
70 | "from": "%s",
71 | "to": "%s",
72 | "cacheTime":"%s"
73 | }`, amount, exchanger, apiKey, from, to, cacheTime)
74 |
75 | bytePayload := []byte(payload)
76 | bytePayloadReader := bytes.NewReader(bytePayload)
77 |
78 | r.Body = ioutil.NopCloser(bytePayloadReader)
79 | ConvertPost(w, r)
80 | }
81 |
82 | // ConvertPost ... handle POST request, build Swap object, get and cache the currency exchange rate and amount
83 | var ConvertPost = func(w http.ResponseWriter, r *http.Request) {
84 |
85 | convertReq := &convertReqObj{}
86 |
87 | if err := json.
88 | NewDecoder(r.Body).
89 | Decode(convertReq); err != nil {
90 | Logger.Panic(err)
91 | }
92 |
93 | if err := convertReq.Validate(); err != nil {
94 | Logger.Panic(err)
95 | }
96 |
97 | decimalPoint := convertReq.DecimalPoints
98 | if decimalPoint == 0 {
99 | decimalPoint = 4
100 | }
101 |
102 | currencyCacheKey := convertReq.Hash()
103 |
104 | currencyCachedVal := Storage.Get(currencyCacheKey)
105 | // default cache time
106 | if convertReq.CacheTime == "" {
107 | convertReq.CacheTime = "120s"
108 | }
109 | currencyCacheTime, _ := time.ParseDuration(convertReq.CacheTime)
110 |
111 | convertRes := &convertResObj{}
112 | if string(currencyCachedVal) == "" {
113 | Swap := swap.NewSwap()
114 | for _, v := range convertReq.Exchanger {
115 |
116 | var e ex.Exchanger
117 | opt := map[string]string{`userAgent`: v.UserAgent, `apiKey`: v.ApiKey, `apiVersion`: v.ApiVersion}
118 |
119 | switch v.Name {
120 | case `google`:
121 | e = ex.NewGoogleApi(opt)
122 | break
123 | case `yahoo`:
124 | e = ex.NewYahooApi(opt)
125 | break
126 | case `currencylayer`:
127 | e = ex.NewCurrencyLayerApi(opt)
128 | break
129 | case `fixer`:
130 | e = ex.NewFixerApi(opt)
131 | break
132 | case `1forge`:
133 | e = ex.NewOneForgeApi(opt)
134 | break
135 | case `themoneyconverter`:
136 | e = ex.NewTheMoneyConverterApi(opt)
137 | break
138 | case `openexchangerates`:
139 | e = ex.NewOpenExchangeRatesApi(opt)
140 | break
141 | }
142 | Swap.AddExchanger(e)
143 | }
144 | Swap.Build()
145 |
146 | rate := Swap.Latest(convertReq.From + `/` + convertReq.To)
147 |
148 | convertRes.From = convertReq.From
149 | convertRes.To = convertReq.To
150 | convertRes.ExchangeValue = rate.GetRateValue()
151 | convertRes.RateDateTime = rate.GetRateDateTime()
152 | convertRes.ExchangerName = rate.GetExchangerName()
153 | convertRes.RateFromCache = false
154 |
155 | var err error
156 | if currencyCachedVal, err = json.Marshal(convertRes); err != nil {
157 | Logger.Panic(err)
158 | }
159 | Storage.Set(currencyCacheKey, currencyCachedVal, currencyCacheTime)
160 | w.Header().Set("X-Cache", "Miss")
161 | } else {
162 | // get from cache
163 | w.Header().Set("X-Cache", "Hit")
164 | json.Unmarshal(currencyCachedVal, &convertRes)
165 | convertRes.RateFromCache = true
166 | }
167 |
168 | convertedAmount := math.Round(convertReq.Amount*convertRes.ExchangeValue*math.Pow10(decimalPoint)) / math.Pow10(decimalPoint)
169 | convertRes.ConvertedAmount = convertedAmount
170 | convertRes.OriginalAmount = convertReq.Amount
171 |
172 | // formatted message like "1 USD is worth 3.675 AED"
173 | convertRes.ConvertedText = fmt.Sprintf("%g %s is worth %g %s", convertRes.OriginalAmount, convertRes.From, convertRes.ConvertedAmount, convertRes.To)
174 |
175 | currencyJsonVal, err := json.Marshal(convertRes)
176 | if err != nil {
177 | Logger.Panic(err)
178 | }
179 |
180 | //Set Content-Type header so that clients will know how to read response
181 | w.Header().Set("Content-Type", "application/json")
182 | w.WriteHeader(http.StatusOK)
183 | w.Write(currencyJsonVal)
184 | }
185 |
--------------------------------------------------------------------------------
/cmd/server/convert_test.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "bytes"
5 | "github.com/stretchr/testify/assert"
6 | "io/ioutil"
7 | "net/http"
8 | "testing"
9 | )
10 |
11 | type testResponseWriter struct {
12 | }
13 |
14 | var testResponse string
15 |
16 | func (c testResponseWriter) Header() http.Header {
17 | return map[string][]string{}
18 | }
19 |
20 | func (c testResponseWriter) Write(i []byte) (int, error) {
21 | testResponse = string(i)
22 | return 0, nil
23 | }
24 |
25 | func (c testResponseWriter) WriteHeader(statusCode int) {
26 | }
27 |
28 | func TestConvertObj_Convert(t *testing.T) {
29 | payloadArr := []string{
30 | `{
31 | "amount": 4.5,
32 | "exchanger": [
33 | {
34 | "name": "google",
35 | "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:21.0) Gecko/20100101 Firefox/21.0"
36 | }
37 | ],
38 | "from": "USD",
39 | "to": "AED"
40 | }`,
41 | `{
42 | "amount": 4.5,
43 | "exchanger": [
44 | {
45 | "name": "yahoo",
46 | "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:21.0) Gecko/20100101 Firefox/21.0"
47 | }
48 | ],
49 | "from": "USD",
50 | "to": "AED"
51 | }`, `{
52 | "amount": 5.5,
53 | "exchanger": [
54 | {
55 | "name": "yahoo",
56 | "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:21.0) Gecko/20100101 Firefox/21.0"
57 | }
58 | ],
59 | "from": "USD",
60 | "to": "AED"
61 | }`,
62 | `{
63 | "amount": 4.5,
64 | "exchanger": [
65 | {
66 | "name": "google",
67 | "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:21.0) Gecko/20100101 Firefox/21.0"
68 | },
69 | {
70 | "name": "yahoo",
71 | "userAgent": "Chrome"
72 | },
73 | {
74 | "name": "currencyLayer",
75 | "apiKey": "12312",
76 | "userAgent": "currencyLayer Chrome"
77 | },
78 | {
79 | "name": "fixer",
80 | "apiKey": "12312",
81 | "userAgent": "currencyLayer fixer"
82 | }
83 | ],
84 | "from": "USD",
85 | "to": "AED"
86 | }`,
87 | }
88 |
89 | expectedName := map[int]string{
90 | 0: "google",
91 | 1: "yahoo",
92 | 2: "yahoo",
93 | 3: "google",
94 | }
95 | expectedRateCache := map[int]string{
96 | 0: "false",
97 | 1: "false",
98 | 2: "true",
99 | 3: "false",
100 | }
101 |
102 | for k, payload := range payloadArr {
103 | // mock the payload
104 | bytePayload := []byte(payload)
105 | bytePayloadReader := bytes.NewReader(bytePayload)
106 |
107 | w := testResponseWriter{}
108 |
109 | r := &http.Request{}
110 | r.Body = ioutil.NopCloser(bytePayloadReader)
111 |
112 | ConvertPost(w, r)
113 | assert.Contains(t, testResponse, expectedName[k])
114 | assert.Contains(t, testResponse, expectedRateCache[k])
115 | }
116 | }
117 |
--------------------------------------------------------------------------------
/cmd/server/doc.go:
--------------------------------------------------------------------------------
1 | package main // import "github.com/me-io/go-swap/cmd/server"
2 |
--------------------------------------------------------------------------------
/cmd/server/helpers.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "fmt"
5 | "log"
6 | "os"
7 | "path/filepath"
8 | )
9 |
10 | // LsFiles ... list file in directory
11 | func LsFiles(pattern string) {
12 | err := filepath.Walk(pattern,
13 | func(path string, info os.FileInfo, err error) error {
14 | if err != nil {
15 | return err
16 | }
17 | fmt.Println(path, info.Size())
18 | return nil
19 | })
20 | if err != nil {
21 | log.Println(err)
22 | }
23 | }
24 |
--------------------------------------------------------------------------------
/cmd/server/helpers_test.go:
--------------------------------------------------------------------------------
1 | package main
2 |
--------------------------------------------------------------------------------
/cmd/server/main.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "flag"
5 | "fmt"
6 | "github.com/me-io/go-swap/pkg/cache"
7 | "github.com/me-io/go-swap/pkg/cache/memory"
8 | "github.com/me-io/go-swap/pkg/cache/redis"
9 | "github.com/op/go-logging"
10 | "net/http"
11 | "os"
12 | "path/filepath"
13 | "runtime"
14 | "time"
15 | )
16 |
17 | var (
18 | host *string
19 | port *int
20 | cacheDriver *string
21 | redisUrl *string
22 | // Storage ... Server Cache Storage
23 | Storage cache.Storage
24 | // Logger ... Logger Driver
25 | Logger = logging.MustGetLogger("go-swap-server")
26 |
27 | format = logging.MustStringFormatter(
28 | `%{color}%{time:2006-01-02T15:04:05.999999} %{shortfunc} ▶ %{level:.8s} %{id:03x}%{color:reset} %{message}`,
29 | )
30 |
31 | routes = map[string]func(w http.ResponseWriter, r *http.Request){
32 | `/convert`: Convert,
33 | }
34 | _, filename, _, _ = runtime.Caller(0)
35 | defaultStaticPath = filepath.Dir(filename) + `/public`
36 | staticPath = &defaultStaticPath
37 | )
38 |
39 | // init ... init function of the server
40 | func init() {
41 | // Logging
42 | backendStderr := logging.NewLogBackend(os.Stderr, "", 0)
43 | backendFormatted := logging.NewBackendFormatter(backendStderr, format)
44 | // Only DEBUG and more severe messages should be sent to backend1
45 | backendLevelFormatted := logging.AddModuleLevel(backendFormatted)
46 | backendLevelFormatted.SetLevel(logging.DEBUG, "")
47 | // Set the backend to be used.
48 | logging.SetBackend(backendLevelFormatted)
49 |
50 | // Caching
51 | host = flag.String(`H`, `0.0.0.0`, `Host binding address`)
52 | port = flag.Int(`P`, 5000, `Host binding port`)
53 | cacheDriver = flag.String(`CACHE`, `memory`, `Cache driver (default memory)`)
54 | redisUrl = flag.String(`REDIS_URL`, ``, `Redis URI for redis cache driver`)
55 | staticPath = flag.String(`STATIC_PATH`, defaultStaticPath, `Webserver static path`)
56 |
57 | flag.Parse()
58 |
59 | var err error
60 |
61 | switch *cacheDriver {
62 | case `redis`:
63 | if Storage, err = redis.NewStorage(*redisUrl); err != nil {
64 | Logger.Panic(err)
65 | }
66 | break
67 | default:
68 | Storage = memory.NewStorage()
69 | }
70 |
71 | }
72 |
73 | // main ... main function start the server
74 | func main() {
75 |
76 | Logger.Infof("host %s", *host)
77 | Logger.Infof("port %d", *port)
78 | Logger.Infof("cacheDriver %s", *cacheDriver)
79 | Logger.Infof("REDIS_URL %s", *redisUrl)
80 | Logger.Infof("Static dir %s", *staticPath)
81 |
82 | // handle routers
83 | for k, v := range routes {
84 | http.HandleFunc(k, v)
85 | }
86 |
87 | go serveHTTP(*host, *port)
88 | select {}
89 | }
90 |
91 | // serveHTTP ... initiate the HTTP Server
92 | func serveHTTP(host string, port int) {
93 |
94 | mux := http.NewServeMux()
95 | for k, v := range routes {
96 | mux.HandleFunc(k, v)
97 | }
98 |
99 | handleStatic(mux)
100 |
101 | addr := fmt.Sprintf("%v:%d", host, port)
102 | server := &http.Server{
103 | Addr: addr,
104 | Handler: mux,
105 | ReadTimeout: 10 * time.Second,
106 | WriteTimeout: 10 * time.Second,
107 | MaxHeaderBytes: 1 << 20,
108 | }
109 |
110 | Logger.Infof("Server Started @ %v:%d", host, port)
111 |
112 | err := server.ListenAndServe()
113 | Logger.Error(err.Error())
114 | }
115 |
116 | func handleStatic(mux *http.ServeMux) {
117 | mux.Handle(`/`, http.FileServer(http.Dir(*staticPath)))
118 | }
119 |
--------------------------------------------------------------------------------
/cmd/server/public/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/me-io/go-swap/b8d825d1873d6bc8f26df343b47f6d0a6b115a50/cmd/server/public/favicon.ico
--------------------------------------------------------------------------------
/cmd/server/public/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | Hello Swap Server
7 |
8 |
9 |
--------------------------------------------------------------------------------
/cmd/server/public/swagger/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |