lychiyu/bbgo_origin
1
0
Fork 0
mirror of https://github.com/c9s/bbgo.git synced 2024-09-20 08:11:08 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #761 from narumiruna/glassnode/simplify

Browse Source 
datasource: refactor glassnodeapi
This commit is contained in:
なるみ 2022-06-25 20:31:56 +08:00 committed by GitHub
commit a74eca3773
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
39 changed files with 372 additions and 3649 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
pkg/datasource/glassnode/datasource.go
View File

@ -18,19 +18,38 @@ func New(apiKey string) *DataSource {
return &DataSource{client: client}
}
// query last futures open interest
// https://docs.glassnode.com/api/derivatives#futures-open-interest
func (d *DataSource) QueryFuturesOpenInterest(ctx context.Context, currency string) (float64, error) {
req := glassnodeapi.DerivativesRequest{
Client: d.client,
Asset: currency,
// 25 hours ago
Since: time.Now().Add(-25 * time.Hour).Unix(),
Interval: glassnodeapi.Interval24h,
Metric: "futures_open_interest_sum",
func (d *DataSource) Query(ctx context.Context, category, metric, asset string, options QueryOptions) (glassnodeapi.DataSlice, error) {
req := glassnodeapi.Request{
Client: d.client,
Asset: asset,
Since: options.Since,
Until: options.Until,
Interval: options.Interval,
Category: category,
Metric: metric,
}
resp, err := req.Do(ctx)
if err != nil {
return nil, err
}
return glassnodeapi.DataSlice(resp), nil
}
// query last futures open interest
// https://docs.glassnode.com/api/derivatives#futures-open-interest
func (d *DataSource) QueryFuturesOpenInterest(ctx context.Context, currency string) (float64, error) {
until := time.Now()
since := until.Add(-24 * time.Hour)
options := QueryOptions{
Since: &since,
Until: &until,
}
resp, err := d.Query(ctx, "derivatives", "futures_open_interest_sum", currency, options)
if err != nil {
return 0, err
}
@ -41,16 +60,16 @@ func (d *DataSource) QueryFuturesOpenInterest(ctx context.Context, currency stri
// query last market cap in usd
// https://docs.glassnode.com/api/market#market-cap
func (d *DataSource) QueryMarketCapInUSD(ctx context.Context, currency string) (float64, error) {
req := glassnodeapi.MarketRequest{
Client: d.client,
Asset: currency,
// 25 hours ago
Since: time.Now().Add(-25 * time.Hour).Unix(),
Interval: glassnodeapi.Interval24h,
Metric: "marketcap_usd",
until := time.Now()
since := until.Add(-24 * time.Hour)
options := QueryOptions{
Since: &since,
Until: &until,
}
resp, err := req.Do(ctx)
resp, err := d.Query(ctx, "market", "marketcap_usd", currency, options)
if err != nil {
return 0, err
}

17
pkg/datasource/glassnode/glassnodeapi/addresses.go
View File

@ -1,17 +0,0 @@
package glassnodeapi
import "github.com/c9s/requestgen"
//go:generate requestgen -method GET -type AddressesRequest -url "/v1/metrics/addresses/:metric" -responseType Response
type AddressesRequest struct {
Client requestgen.AuthenticatedAPIClient
Asset string `param:"a,required,query"`
Since int64 `param:"s,query"`
Until int64 `param:"u,query"`
Interval Interval `param:"i,query"`
Format Format `param:"f,query"`
TimestampFormat string `param:"timestamp_format,query"`
Metric string `param:"metric,slug"`
}

196
pkg/datasource/glassnode/glassnodeapi/addresses_request_requestgen.go
View File

@ -1,196 +0,0 @@
// Code generated by "requestgen -method GET -type AddressesRequest -url /v1/metrics/addresses/:metric -responseType Response"; DO NOT EDIT.
package glassnodeapi
import (
"context"
"encoding/json"
"fmt"
"net/url"
"regexp"
)
func (a *AddressesRequest) SetAsset(Asset string) *AddressesRequest {
a.Asset = Asset
return a
}
func (a *AddressesRequest) SetSince(Since int64) *AddressesRequest {
a.Since = Since
return a
}
func (a *AddressesRequest) SetUntil(Until int64) *AddressesRequest {
a.Until = Until
return a
}
func (a *AddressesRequest) SetInterval(Interval Interval) *AddressesRequest {
a.Interval = Interval
return a
}
func (a *AddressesRequest) SetFormat(Format Format) *AddressesRequest {
a.Format = Format
return a
}
func (a *AddressesRequest) SetTimestampFormat(TimestampFormat string) *AddressesRequest {
a.TimestampFormat = TimestampFormat
return a
}
func (a *AddressesRequest) SetMetric(Metric string) *AddressesRequest {
a.Metric = Metric
return a
}
// GetQueryParameters builds and checks the query parameters and returns url.Values
func (a *AddressesRequest) GetQueryParameters() (url.Values, error) {
var params = map[string]interface{}{}
// check Asset field -> json key a
Asset := a.Asset
// TEMPLATE check-required
if len(Asset) == 0 {
return nil, fmt.Errorf("a is required, empty string given")
}
// END TEMPLATE check-required
// assign parameter of Asset
params["a"] = Asset
// check Since field -> json key s
Since := a.Since
// assign parameter of Since
params["s"] = Since
// check Until field -> json key u
Until := a.Until
// assign parameter of Until
params["u"] = Until
// check Interval field -> json key i
Interval := a.Interval
// assign parameter of Interval
params["i"] = Interval
// check Format field -> json key f
Format := a.Format
// assign parameter of Format
params["f"] = Format
// check TimestampFormat field -> json key timestamp_format
TimestampFormat := a.TimestampFormat
// assign parameter of TimestampFormat
params["timestamp_format"] = TimestampFormat
query := url.Values{}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParameters builds and checks the parameters and return the result in a map object
func (a *AddressesRequest) GetParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
return params, nil
}
// GetParametersQuery converts the parameters from GetParameters into the url.Values format
func (a *AddressesRequest) GetParametersQuery() (url.Values, error) {
query := url.Values{}
params, err := a.GetParameters()
if err != nil {
return query, err
}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParametersJSON converts the parameters from GetParameters into the JSON format
func (a *AddressesRequest) GetParametersJSON() ([]byte, error) {
params, err := a.GetParameters()
if err != nil {
return nil, err
}
return json.Marshal(params)
}
// GetSlugParameters builds and checks the slug parameters and return the result in a map object
func (a *AddressesRequest) GetSlugParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
// check Metric field -> json key metric
Metric := a.Metric
// assign parameter of Metric
params["metric"] = Metric
return params, nil
}
func (a *AddressesRequest) applySlugsToUrl(url string, slugs map[string]string) string {
for k, v := range slugs {
needleRE := regexp.MustCompile(":" + k + "\\b")
url = needleRE.ReplaceAllString(url, v)
}
return url
}
func (a *AddressesRequest) GetSlugsMap() (map[string]string, error) {
slugs := map[string]string{}
params, err := a.GetSlugParameters()
if err != nil {
return slugs, nil
}
for k, v := range params {
slugs[k] = fmt.Sprintf("%v", v)
}
return slugs, nil
}
func (a *AddressesRequest) Do(ctx context.Context) (Response, error) {
// no body params
var params interface{}
query, err := a.GetQueryParameters()
if err != nil {
return nil, err
}
apiURL := "/v1/metrics/addresses/:metric"
slugs, err := a.GetSlugsMap()
if err != nil {
return nil, err
}
apiURL = a.applySlugsToUrl(apiURL, slugs)
req, err := a.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params)
if err != nil {
return nil, err
}
response, err := a.Client.SendRequest(req)
if err != nil {
return nil, err
}
var apiResponse Response
if err := response.DecodeJSON(&apiResponse); err != nil {
return nil, err
}
return apiResponse, nil
}

17
pkg/datasource/glassnode/glassnodeapi/blockchain.go
View File

@ -1,17 +0,0 @@
package glassnodeapi
import "github.com/c9s/requestgen"
//go:generate requestgen -method GET -type BlockchainRequest -url "/v1/metrics/blockchain/:metric" -responseType Response
type BlockchainRequest struct {
Client requestgen.AuthenticatedAPIClient
Asset string `param:"a,required,query"`
Since int64 `param:"s,query"`
Until int64 `param:"u,query"`
Interval Interval `param:"i,query"`
Format Format `param:"f,query"`
TimestampFormat string `param:"timestamp_format,query"`
Metric string `param:"metric,slug"`
}

196
pkg/datasource/glassnode/glassnodeapi/blockchain_request_requestgen.go
View File

@ -1,196 +0,0 @@
// Code generated by "requestgen -method GET -type BlockchainRequest -url /v1/metrics/blockchain/:metric -responseType Response"; DO NOT EDIT.
package glassnodeapi
import (
"context"
"encoding/json"
"fmt"
"net/url"
"regexp"
)
func (b *BlockchainRequest) SetAsset(Asset string) *BlockchainRequest {
b.Asset = Asset
return b
}
func (b *BlockchainRequest) SetSince(Since int64) *BlockchainRequest {
b.Since = Since
return b
}
func (b *BlockchainRequest) SetUntil(Until int64) *BlockchainRequest {
b.Until = Until
return b
}
func (b *BlockchainRequest) SetInterval(Interval Interval) *BlockchainRequest {
b.Interval = Interval
return b
}
func (b *BlockchainRequest) SetFormat(Format Format) *BlockchainRequest {
b.Format = Format
return b
}
func (b *BlockchainRequest) SetTimestampFormat(TimestampFormat string) *BlockchainRequest {
b.TimestampFormat = TimestampFormat
return b
}
func (b *BlockchainRequest) SetMetric(Metric string) *BlockchainRequest {
b.Metric = Metric
return b
}
// GetQueryParameters builds and checks the query parameters and returns url.Values
func (b *BlockchainRequest) GetQueryParameters() (url.Values, error) {
var params = map[string]interface{}{}
// check Asset field -> json key a
Asset := b.Asset
// TEMPLATE check-required
if len(Asset) == 0 {
return nil, fmt.Errorf("a is required, empty string given")
}
// END TEMPLATE check-required
// assign parameter of Asset
params["a"] = Asset
// check Since field -> json key s
Since := b.Since
// assign parameter of Since
params["s"] = Since
// check Until field -> json key u
Until := b.Until
// assign parameter of Until
params["u"] = Until
// check Interval field -> json key i
Interval := b.Interval
// assign parameter of Interval
params["i"] = Interval
// check Format field -> json key f
Format := b.Format
// assign parameter of Format
params["f"] = Format
// check TimestampFormat field -> json key timestamp_format
TimestampFormat := b.TimestampFormat
// assign parameter of TimestampFormat
params["timestamp_format"] = TimestampFormat
query := url.Values{}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParameters builds and checks the parameters and return the result in a map object
func (b *BlockchainRequest) GetParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
return params, nil
}
// GetParametersQuery converts the parameters from GetParameters into the url.Values format
func (b *BlockchainRequest) GetParametersQuery() (url.Values, error) {
query := url.Values{}
params, err := b.GetParameters()
if err != nil {
return query, err
}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParametersJSON converts the parameters from GetParameters into the JSON format
func (b *BlockchainRequest) GetParametersJSON() ([]byte, error) {
params, err := b.GetParameters()
if err != nil {
return nil, err
}
return json.Marshal(params)
}
// GetSlugParameters builds and checks the slug parameters and return the result in a map object
func (b *BlockchainRequest) GetSlugParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
// check Metric field -> json key metric
Metric := b.Metric
// assign parameter of Metric
params["metric"] = Metric
return params, nil
}
func (b *BlockchainRequest) applySlugsToUrl(url string, slugs map[string]string) string {
for k, v := range slugs {
needleRE := regexp.MustCompile(":" + k + "\\b")
url = needleRE.ReplaceAllString(url, v)
}
return url
}
func (b *BlockchainRequest) GetSlugsMap() (map[string]string, error) {
slugs := map[string]string{}
params, err := b.GetSlugParameters()
if err != nil {
return slugs, nil
}
for k, v := range params {
slugs[k] = fmt.Sprintf("%v", v)
}
return slugs, nil
}
func (b *BlockchainRequest) Do(ctx context.Context) (Response, error) {
// no body params
var params interface{}
query, err := b.GetQueryParameters()
if err != nil {
return nil, err
}
apiURL := "/v1/metrics/blockchain/:metric"
slugs, err := b.GetSlugsMap()
if err != nil {
return nil, err
}
apiURL = b.applySlugsToUrl(apiURL, slugs)
req, err := b.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params)
if err != nil {
return nil, err
}
response, err := b.Client.SendRequest(req)
if err != nil {
return nil, err
}
var apiResponse Response
if err := response.DecodeJSON(&apiResponse); err != nil {
return nil, err
}
return apiResponse, nil
}

17
pkg/datasource/glassnode/glassnodeapi/defi.go
View File

@ -1,17 +0,0 @@
package glassnodeapi
import "github.com/c9s/requestgen"
//go:generate requestgen -method GET -type DefiRequest -url "/v1/metrics/defi/:metric" -responseType Response
type DefiRequest struct {
Client requestgen.AuthenticatedAPIClient
Asset string `param:"a,required,query"`
Since int64 `param:"s,query"`
Until int64 `param:"u,query"`
Interval Interval `param:"i,query"`
Format Format `param:"f,query"`
TimestampFormat string `param:"timestamp_format,query"`
Metric string `param:"metric,slug"`
}

196
pkg/datasource/glassnode/glassnodeapi/defi_request_requestgen.go
View File

@ -1,196 +0,0 @@
// Code generated by "requestgen -method GET -type DefiRequest -url /v1/metrics/defi/:metric -responseType Response"; DO NOT EDIT.
package glassnodeapi
import (
"context"
"encoding/json"
"fmt"
"net/url"
"regexp"
)
func (d *DefiRequest) SetAsset(Asset string) *DefiRequest {
d.Asset = Asset
return d
}
func (d *DefiRequest) SetSince(Since int64) *DefiRequest {
d.Since = Since
return d
}
func (d *DefiRequest) SetUntil(Until int64) *DefiRequest {
d.Until = Until
return d
}
func (d *DefiRequest) SetInterval(Interval Interval) *DefiRequest {
d.Interval = Interval
return d
}
func (d *DefiRequest) SetFormat(Format Format) *DefiRequest {
d.Format = Format
return d
}
func (d *DefiRequest) SetTimestampFormat(TimestampFormat string) *DefiRequest {
d.TimestampFormat = TimestampFormat
return d
}
func (d *DefiRequest) SetMetric(Metric string) *DefiRequest {
d.Metric = Metric
return d
}
// GetQueryParameters builds and checks the query parameters and returns url.Values
func (d *DefiRequest) GetQueryParameters() (url.Values, error) {
var params = map[string]interface{}{}
// check Asset field -> json key a
Asset := d.Asset
// TEMPLATE check-required
if len(Asset) == 0 {
return nil, fmt.Errorf("a is required, empty string given")
}
// END TEMPLATE check-required
// assign parameter of Asset
params["a"] = Asset
// check Since field -> json key s
Since := d.Since
// assign parameter of Since
params["s"] = Since
// check Until field -> json key u
Until := d.Until
// assign parameter of Until
params["u"] = Until
// check Interval field -> json key i
Interval := d.Interval
// assign parameter of Interval
params["i"] = Interval
// check Format field -> json key f
Format := d.Format
// assign parameter of Format
params["f"] = Format
// check TimestampFormat field -> json key timestamp_format
TimestampFormat := d.TimestampFormat
// assign parameter of TimestampFormat
params["timestamp_format"] = TimestampFormat
query := url.Values{}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParameters builds and checks the parameters and return the result in a map object
func (d *DefiRequest) GetParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
return params, nil
}
// GetParametersQuery converts the parameters from GetParameters into the url.Values format
func (d *DefiRequest) GetParametersQuery() (url.Values, error) {
query := url.Values{}
params, err := d.GetParameters()
if err != nil {
return query, err
}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParametersJSON converts the parameters from GetParameters into the JSON format
func (d *DefiRequest) GetParametersJSON() ([]byte, error) {
params, err := d.GetParameters()
if err != nil {
return nil, err
}
return json.Marshal(params)
}
// GetSlugParameters builds and checks the slug parameters and return the result in a map object
func (d *DefiRequest) GetSlugParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
// check Metric field -> json key metric
Metric := d.Metric
// assign parameter of Metric
params["metric"] = Metric
return params, nil
}
func (d *DefiRequest) applySlugsToUrl(url string, slugs map[string]string) string {
for k, v := range slugs {
needleRE := regexp.MustCompile(":" + k + "\\b")
url = needleRE.ReplaceAllString(url, v)
}
return url
}
func (d *DefiRequest) GetSlugsMap() (map[string]string, error) {
slugs := map[string]string{}
params, err := d.GetSlugParameters()
if err != nil {
return slugs, nil
}
for k, v := range params {
slugs[k] = fmt.Sprintf("%v", v)
}
return slugs, nil
}
func (d *DefiRequest) Do(ctx context.Context) (Response, error) {
// no body params
var params interface{}
query, err := d.GetQueryParameters()
if err != nil {
return nil, err
}
apiURL := "/v1/metrics/defi/:metric"
slugs, err := d.GetSlugsMap()
if err != nil {
return nil, err
}
apiURL = d.applySlugsToUrl(apiURL, slugs)
req, err := d.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params)
if err != nil {
return nil, err
}
response, err := d.Client.SendRequest(req)
if err != nil {
return nil, err
}
var apiResponse Response
if err := response.DecodeJSON(&apiResponse); err != nil {
return nil, err
}
return apiResponse, nil
}

17
pkg/datasource/glassnode/glassnodeapi/derivatives.go
View File

@ -1,17 +0,0 @@
package glassnodeapi
import "github.com/c9s/requestgen"
//go:generate requestgen -method GET -type DerivativesRequest -url "/v1/metrics/derivatives/:metric" -responseType Response
type DerivativesRequest struct {
Client requestgen.AuthenticatedAPIClient
Asset string `param:"a,required,query"`
Since int64 `param:"s,query"`
Until int64 `param:"u,query"`
Interval Interval `param:"i,query"`
Format Format `param:"f,query"`
TimestampFormat string `param:"timestamp_format,query"`
Metric string `param:"metric,slug"`
}

196
pkg/datasource/glassnode/glassnodeapi/derivatives_request_requestgen.go
View File

@ -1,196 +0,0 @@
// Code generated by "requestgen -method GET -type DerivativesRequest -url /v1/metrics/derivatives/:metric -responseType Response"; DO NOT EDIT.
package glassnodeapi
import (
"context"
"encoding/json"
"fmt"
"net/url"
"regexp"
)
func (d *DerivativesRequest) SetAsset(Asset string) *DerivativesRequest {
d.Asset = Asset
return d
}
func (d *DerivativesRequest) SetSince(Since int64) *DerivativesRequest {
d.Since = Since
return d
}
func (d *DerivativesRequest) SetUntil(Until int64) *DerivativesRequest {
d.Until = Until
return d
}
func (d *DerivativesRequest) SetInterval(Interval Interval) *DerivativesRequest {
d.Interval = Interval
return d
}
func (d *DerivativesRequest) SetFormat(Format Format) *DerivativesRequest {
d.Format = Format
return d
}
func (d *DerivativesRequest) SetTimestampFormat(TimestampFormat string) *DerivativesRequest {
d.TimestampFormat = TimestampFormat
return d
}
func (d *DerivativesRequest) SetMetric(Metric string) *DerivativesRequest {
d.Metric = Metric
return d
}
// GetQueryParameters builds and checks the query parameters and returns url.Values
func (d *DerivativesRequest) GetQueryParameters() (url.Values, error) {
var params = map[string]interface{}{}
// check Asset field -> json key a
Asset := d.Asset
// TEMPLATE check-required
if len(Asset) == 0 {
return nil, fmt.Errorf("a is required, empty string given")
}
// END TEMPLATE check-required
// assign parameter of Asset
params["a"] = Asset
// check Since field -> json key s
Since := d.Since
// assign parameter of Since
params["s"] = Since
// check Until field -> json key u
Until := d.Until
// assign parameter of Until
params["u"] = Until
// check Interval field -> json key i
Interval := d.Interval
// assign parameter of Interval
params["i"] = Interval
// check Format field -> json key f
Format := d.Format
// assign parameter of Format
params["f"] = Format
// check TimestampFormat field -> json key timestamp_format
TimestampFormat := d.TimestampFormat
// assign parameter of TimestampFormat
params["timestamp_format"] = TimestampFormat
query := url.Values{}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParameters builds and checks the parameters and return the result in a map object
func (d *DerivativesRequest) GetParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
return params, nil
}
// GetParametersQuery converts the parameters from GetParameters into the url.Values format
func (d *DerivativesRequest) GetParametersQuery() (url.Values, error) {
query := url.Values{}
params, err := d.GetParameters()
if err != nil {
return query, err
}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParametersJSON converts the parameters from GetParameters into the JSON format
func (d *DerivativesRequest) GetParametersJSON() ([]byte, error) {
params, err := d.GetParameters()
if err != nil {
return nil, err
}
return json.Marshal(params)
}
// GetSlugParameters builds and checks the slug parameters and return the result in a map object
func (d *DerivativesRequest) GetSlugParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
// check Metric field -> json key metric
Metric := d.Metric
// assign parameter of Metric
params["metric"] = Metric
return params, nil
}
func (d *DerivativesRequest) applySlugsToUrl(url string, slugs map[string]string) string {
for k, v := range slugs {
needleRE := regexp.MustCompile(":" + k + "\\b")
url = needleRE.ReplaceAllString(url, v)
}
return url
}
func (d *DerivativesRequest) GetSlugsMap() (map[string]string, error) {
slugs := map[string]string{}
params, err := d.GetSlugParameters()
if err != nil {
return slugs, nil
}
for k, v := range params {
slugs[k] = fmt.Sprintf("%v", v)
}
return slugs, nil
}
func (d *DerivativesRequest) Do(ctx context.Context) (Response, error) {
// no body params
var params interface{}
query, err := d.GetQueryParameters()
if err != nil {
return nil, err
}
apiURL := "/v1/metrics/derivatives/:metric"
slugs, err := d.GetSlugsMap()
if err != nil {
return nil, err
}
apiURL = d.applySlugsToUrl(apiURL, slugs)
req, err := d.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params)
if err != nil {
return nil, err
}
response, err := d.Client.SendRequest(req)
if err != nil {
return nil, err
}
var apiResponse Response
if err := response.DecodeJSON(&apiResponse); err != nil {
return nil, err
}
return apiResponse, nil
}

17
pkg/datasource/glassnode/glassnodeapi/distribution.go
View File

@ -1,17 +0,0 @@
package glassnodeapi
import "github.com/c9s/requestgen"
//go:generate requestgen -method GET -type DistributionRequest -url "/v1/metrics/distribution/:metric" -responseType Response
type DistributionRequest struct {
Client requestgen.AuthenticatedAPIClient
Asset string `param:"a,required,query"`
Since int64 `param:"s,query"`
Until int64 `param:"u,query"`
Interval Interval `param:"i,query"`
Format Format `param:"f,query"`
TimestampFormat string `param:"timestamp_format,query"`
Metric string `param:"metric,slug"`
}

196
pkg/datasource/glassnode/glassnodeapi/distribution_request_requestgen.go
View File

@ -1,196 +0,0 @@
// Code generated by "requestgen -method GET -type DistributionRequest -url /v1/metrics/distribution/:metric -responseType Response"; DO NOT EDIT.
package glassnodeapi
import (
"context"
"encoding/json"
"fmt"
"net/url"
"regexp"
)
func (d *DistributionRequest) SetAsset(Asset string) *DistributionRequest {
d.Asset = Asset
return d
}
func (d *DistributionRequest) SetSince(Since int64) *DistributionRequest {
d.Since = Since
return d
}
func (d *DistributionRequest) SetUntil(Until int64) *DistributionRequest {
d.Until = Until
return d
}
func (d *DistributionRequest) SetInterval(Interval Interval) *DistributionRequest {
d.Interval = Interval
return d
}
func (d *DistributionRequest) SetFormat(Format Format) *DistributionRequest {
d.Format = Format
return d
}
func (d *DistributionRequest) SetTimestampFormat(TimestampFormat string) *DistributionRequest {
d.TimestampFormat = TimestampFormat
return d
}
func (d *DistributionRequest) SetMetric(Metric string) *DistributionRequest {
d.Metric = Metric
return d
}
// GetQueryParameters builds and checks the query parameters and returns url.Values
func (d *DistributionRequest) GetQueryParameters() (url.Values, error) {
var params = map[string]interface{}{}
// check Asset field -> json key a
Asset := d.Asset
// TEMPLATE check-required
if len(Asset) == 0 {
return nil, fmt.Errorf("a is required, empty string given")
}
// END TEMPLATE check-required
// assign parameter of Asset
params["a"] = Asset
// check Since field -> json key s
Since := d.Since
// assign parameter of Since
params["s"] = Since
// check Until field -> json key u
Until := d.Until
// assign parameter of Until
params["u"] = Until
// check Interval field -> json key i
Interval := d.Interval
// assign parameter of Interval
params["i"] = Interval
// check Format field -> json key f
Format := d.Format
// assign parameter of Format
params["f"] = Format
// check TimestampFormat field -> json key timestamp_format
TimestampFormat := d.TimestampFormat
// assign parameter of TimestampFormat
params["timestamp_format"] = TimestampFormat
query := url.Values{}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParameters builds and checks the parameters and return the result in a map object
func (d *DistributionRequest) GetParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
return params, nil
}
// GetParametersQuery converts the parameters from GetParameters into the url.Values format
func (d *DistributionRequest) GetParametersQuery() (url.Values, error) {
query := url.Values{}
params, err := d.GetParameters()
if err != nil {
return query, err
}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParametersJSON converts the parameters from GetParameters into the JSON format
func (d *DistributionRequest) GetParametersJSON() ([]byte, error) {
params, err := d.GetParameters()
if err != nil {
return nil, err
}
return json.Marshal(params)
}
// GetSlugParameters builds and checks the slug parameters and return the result in a map object
func (d *DistributionRequest) GetSlugParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
// check Metric field -> json key metric
Metric := d.Metric
// assign parameter of Metric
params["metric"] = Metric
return params, nil
}
func (d *DistributionRequest) applySlugsToUrl(url string, slugs map[string]string) string {
for k, v := range slugs {
needleRE := regexp.MustCompile(":" + k + "\\b")
url = needleRE.ReplaceAllString(url, v)
}
return url
}
func (d *DistributionRequest) GetSlugsMap() (map[string]string, error) {
slugs := map[string]string{}
params, err := d.GetSlugParameters()
if err != nil {
return slugs, nil
}
for k, v := range params {
slugs[k] = fmt.Sprintf("%v", v)
}
return slugs, nil
}
func (d *DistributionRequest) Do(ctx context.Context) (Response, error) {
// no body params
var params interface{}
query, err := d.GetQueryParameters()
if err != nil {
return nil, err
}
apiURL := "/v1/metrics/distribution/:metric"
slugs, err := d.GetSlugsMap()
if err != nil {
return nil, err
}
apiURL = d.applySlugsToUrl(apiURL, slugs)
req, err := d.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params)
if err != nil {
return nil, err
}
response, err := d.Client.SendRequest(req)
if err != nil {
return nil, err
}
var apiResponse Response
if err := response.DecodeJSON(&apiResponse); err != nil {
return nil, err
}
return apiResponse, nil
}

17
pkg/datasource/glassnode/glassnodeapi/entities.go
View File

@ -1,17 +0,0 @@
package glassnodeapi
import "github.com/c9s/requestgen"
//go:generate requestgen -method GET -type EntitiesRequest -url "/v1/metrics/entities/:metric" -responseType Response
type EntitiesRequest struct {
Client requestgen.AuthenticatedAPIClient
Asset string `param:"a,required,query"`
Since int64 `param:"s,query"`
Until int64 `param:"u,query"`
Interval Interval `param:"i,query"`
Format Format `param:"f,query"`
TimestampFormat string `param:"timestamp_format,query"`
Metric string `param:"metric,slug"`
}

196
pkg/datasource/glassnode/glassnodeapi/entities_request_requestgen.go
View File

@ -1,196 +0,0 @@
// Code generated by "requestgen -method GET -type EntitiesRequest -url /v1/metrics/entities/:metric -responseType Response"; DO NOT EDIT.
package glassnodeapi
import (
"context"
"encoding/json"
"fmt"
"net/url"
"regexp"
)
func (e *EntitiesRequest) SetAsset(Asset string) *EntitiesRequest {
e.Asset = Asset
return e
}
func (e *EntitiesRequest) SetSince(Since int64) *EntitiesRequest {
e.Since = Since
return e
}
func (e *EntitiesRequest) SetUntil(Until int64) *EntitiesRequest {
e.Until = Until
return e
}
func (e *EntitiesRequest) SetInterval(Interval Interval) *EntitiesRequest {
e.Interval = Interval
return e
}
func (e *EntitiesRequest) SetFormat(Format Format) *EntitiesRequest {
e.Format = Format
return e
}
func (e *EntitiesRequest) SetTimestampFormat(TimestampFormat string) *EntitiesRequest {
e.TimestampFormat = TimestampFormat
return e
}
func (e *EntitiesRequest) SetMetric(Metric string) *EntitiesRequest {
e.Metric = Metric
return e
}
// GetQueryParameters builds and checks the query parameters and returns url.Values
func (e *EntitiesRequest) GetQueryParameters() (url.Values, error) {
var params = map[string]interface{}{}
// check Asset field -> json key a
Asset := e.Asset
// TEMPLATE check-required
if len(Asset) == 0 {
return nil, fmt.Errorf("a is required, empty string given")
}
// END TEMPLATE check-required
// assign parameter of Asset
params["a"] = Asset
// check Since field -> json key s
Since := e.Since
// assign parameter of Since
params["s"] = Since
// check Until field -> json key u
Until := e.Until
// assign parameter of Until
params["u"] = Until
// check Interval field -> json key i
Interval := e.Interval
// assign parameter of Interval
params["i"] = Interval
// check Format field -> json key f
Format := e.Format
// assign parameter of Format
params["f"] = Format
// check TimestampFormat field -> json key timestamp_format
TimestampFormat := e.TimestampFormat
// assign parameter of TimestampFormat
params["timestamp_format"] = TimestampFormat
query := url.Values{}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParameters builds and checks the parameters and return the result in a map object
func (e *EntitiesRequest) GetParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
return params, nil
}
// GetParametersQuery converts the parameters from GetParameters into the url.Values format
func (e *EntitiesRequest) GetParametersQuery() (url.Values, error) {
query := url.Values{}
params, err := e.GetParameters()
if err != nil {
return query, err
}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParametersJSON converts the parameters from GetParameters into the JSON format
func (e *EntitiesRequest) GetParametersJSON() ([]byte, error) {
params, err := e.GetParameters()
if err != nil {
return nil, err
}
return json.Marshal(params)
}
// GetSlugParameters builds and checks the slug parameters and return the result in a map object
func (e *EntitiesRequest) GetSlugParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
// check Metric field -> json key metric
Metric := e.Metric
// assign parameter of Metric
params["metric"] = Metric
return params, nil
}
func (e *EntitiesRequest) applySlugsToUrl(url string, slugs map[string]string) string {
for k, v := range slugs {
needleRE := regexp.MustCompile(":" + k + "\\b")
url = needleRE.ReplaceAllString(url, v)
}
return url
}
func (e *EntitiesRequest) GetSlugsMap() (map[string]string, error) {
slugs := map[string]string{}
params, err := e.GetSlugParameters()
if err != nil {
return slugs, nil
}
for k, v := range params {
slugs[k] = fmt.Sprintf("%v", v)
}
return slugs, nil
}
func (e *EntitiesRequest) Do(ctx context.Context) (Response, error) {
// no body params
var params interface{}
query, err := e.GetQueryParameters()
if err != nil {
return nil, err
}
apiURL := "/v1/metrics/entities/:metric"
slugs, err := e.GetSlugsMap()
if err != nil {
return nil, err
}
apiURL = e.applySlugsToUrl(apiURL, slugs)
req, err := e.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params)
if err != nil {
return nil, err
}
response, err := e.Client.SendRequest(req)
if err != nil {
return nil, err
}
var apiResponse Response
if err := response.DecodeJSON(&apiResponse); err != nil {
return nil, err
}
return apiResponse, nil
}

17
pkg/datasource/glassnode/glassnodeapi/eth2.go
View File

@ -1,17 +0,0 @@
package glassnodeapi
import "github.com/c9s/requestgen"
//go:generate requestgen -method GET -type ETH2Request -url "/v1/metrics/eth2/:metric" -responseType Response
type ETH2Request struct {
Client requestgen.AuthenticatedAPIClient
Asset string `param:"a,required,query"`
Since int64 `param:"s,query"`
Until int64 `param:"u,query"`
Interval Interval `param:"i,query"`
Format Format `param:"f,query"`
TimestampFormat string `param:"timestamp_format,query"`
Metric string `param:"metric,slug"`
}

196
pkg/datasource/glassnode/glassnodeapi/eth_2_request_requestgen.go
View File

@ -1,196 +0,0 @@
// Code generated by "requestgen -method GET -type ETH2Request -url /v1/metrics/eth2/:metric -responseType Response"; DO NOT EDIT.
package glassnodeapi
import (
"context"
"encoding/json"
"fmt"
"net/url"
"regexp"
)
func (e *ETH2Request) SetAsset(Asset string) *ETH2Request {
e.Asset = Asset
return e
}
func (e *ETH2Request) SetSince(Since int64) *ETH2Request {
e.Since = Since
return e
}
func (e *ETH2Request) SetUntil(Until int64) *ETH2Request {
e.Until = Until
return e
}
func (e *ETH2Request) SetInterval(Interval Interval) *ETH2Request {
e.Interval = Interval
return e
}
func (e *ETH2Request) SetFormat(Format Format) *ETH2Request {
e.Format = Format
return e
}
func (e *ETH2Request) SetTimestampFormat(TimestampFormat string) *ETH2Request {
e.TimestampFormat = TimestampFormat
return e
}
func (e *ETH2Request) SetMetric(Metric string) *ETH2Request {
e.Metric = Metric
return e
}
// GetQueryParameters builds and checks the query parameters and returns url.Values
func (e *ETH2Request) GetQueryParameters() (url.Values, error) {
var params = map[string]interface{}{}
// check Asset field -> json key a
Asset := e.Asset
// TEMPLATE check-required
if len(Asset) == 0 {
return nil, fmt.Errorf("a is required, empty string given")
}
// END TEMPLATE check-required
// assign parameter of Asset
params["a"] = Asset
// check Since field -> json key s
Since := e.Since
// assign parameter of Since
params["s"] = Since
// check Until field -> json key u
Until := e.Until
// assign parameter of Until
params["u"] = Until
// check Interval field -> json key i
Interval := e.Interval
// assign parameter of Interval
params["i"] = Interval
// check Format field -> json key f
Format := e.Format
// assign parameter of Format
params["f"] = Format
// check TimestampFormat field -> json key timestamp_format
TimestampFormat := e.TimestampFormat
// assign parameter of TimestampFormat
params["timestamp_format"] = TimestampFormat
query := url.Values{}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParameters builds and checks the parameters and return the result in a map object
func (e *ETH2Request) GetParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
return params, nil
}
// GetParametersQuery converts the parameters from GetParameters into the url.Values format
func (e *ETH2Request) GetParametersQuery() (url.Values, error) {
query := url.Values{}
params, err := e.GetParameters()
if err != nil {
return query, err
}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParametersJSON converts the parameters from GetParameters into the JSON format
func (e *ETH2Request) GetParametersJSON() ([]byte, error) {
params, err := e.GetParameters()
if err != nil {
return nil, err
}
return json.Marshal(params)
}
// GetSlugParameters builds and checks the slug parameters and return the result in a map object
func (e *ETH2Request) GetSlugParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
// check Metric field -> json key metric
Metric := e.Metric
// assign parameter of Metric
params["metric"] = Metric
return params, nil
}
func (e *ETH2Request) applySlugsToUrl(url string, slugs map[string]string) string {
for k, v := range slugs {
needleRE := regexp.MustCompile(":" + k + "\\b")
url = needleRE.ReplaceAllString(url, v)
}
return url
}
func (e *ETH2Request) GetSlugsMap() (map[string]string, error) {
slugs := map[string]string{}
params, err := e.GetSlugParameters()
if err != nil {
return slugs, nil
}
for k, v := range params {
slugs[k] = fmt.Sprintf("%v", v)
}
return slugs, nil
}
func (e *ETH2Request) Do(ctx context.Context) (Response, error) {
// no body params
var params interface{}
query, err := e.GetQueryParameters()
if err != nil {
return nil, err
}
apiURL := "/v1/metrics/eth2/:metric"
slugs, err := e.GetSlugsMap()
if err != nil {
return nil, err
}
apiURL = e.applySlugsToUrl(apiURL, slugs)
req, err := e.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params)
if err != nil {
return nil, err
}
response, err := e.Client.SendRequest(req)
if err != nil {
return nil, err
}
var apiResponse Response
if err := response.DecodeJSON(&apiResponse); err != nil {
return nil, err
}
return apiResponse, nil
}

17
pkg/datasource/glassnode/glassnodeapi/fees.go
View File

@ -1,17 +0,0 @@
package glassnodeapi
import "github.com/c9s/requestgen"
//go:generate requestgen -method GET -type FeesRequest -url "/v1/metrics/fees/:metric" -responseType Response
type FeesRequest struct {
Client requestgen.AuthenticatedAPIClient
Asset string `param:"a,required,query"`
Since int64 `param:"s,query"`
Until int64 `param:"u,query"`
Interval Interval `param:"i,query"`
Format Format `param:"f,query"`
TimestampFormat string `param:"timestamp_format,query"`
Metric string `param:"metric,slug"`
}

196
pkg/datasource/glassnode/glassnodeapi/fees_request_requestgen.go
View File

@ -1,196 +0,0 @@
// Code generated by "requestgen -method GET -type FeesRequest -url /v1/metrics/fees/:metric -responseType Response"; DO NOT EDIT.
package glassnodeapi
import (
"context"
"encoding/json"
"fmt"
"net/url"
"regexp"
)
func (f *FeesRequest) SetAsset(Asset string) *FeesRequest {
f.Asset = Asset
return f
}
func (f *FeesRequest) SetSince(Since int64) *FeesRequest {
f.Since = Since
return f
}
func (f *FeesRequest) SetUntil(Until int64) *FeesRequest {
f.Until = Until
return f
}
func (f *FeesRequest) SetInterval(Interval Interval) *FeesRequest {
f.Interval = Interval
return f
}
func (f *FeesRequest) SetFormat(Format Format) *FeesRequest {
f.Format = Format
return f
}
func (f *FeesRequest) SetTimestampFormat(TimestampFormat string) *FeesRequest {
f.TimestampFormat = TimestampFormat
return f
}
func (f *FeesRequest) SetMetric(Metric string) *FeesRequest {
f.Metric = Metric
return f
}
// GetQueryParameters builds and checks the query parameters and returns url.Values
func (f *FeesRequest) GetQueryParameters() (url.Values, error) {
var params = map[string]interface{}{}
// check Asset field -> json key a
Asset := f.Asset
// TEMPLATE check-required
if len(Asset) == 0 {
return nil, fmt.Errorf("a is required, empty string given")
}
// END TEMPLATE check-required
// assign parameter of Asset
params["a"] = Asset
// check Since field -> json key s
Since := f.Since
// assign parameter of Since
params["s"] = Since
// check Until field -> json key u
Until := f.Until
// assign parameter of Until
params["u"] = Until
// check Interval field -> json key i
Interval := f.Interval
// assign parameter of Interval
params["i"] = Interval
// check Format field -> json key f
Format := f.Format
// assign parameter of Format
params["f"] = Format
// check TimestampFormat field -> json key timestamp_format
TimestampFormat := f.TimestampFormat
// assign parameter of TimestampFormat
params["timestamp_format"] = TimestampFormat
query := url.Values{}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParameters builds and checks the parameters and return the result in a map object
func (f *FeesRequest) GetParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
return params, nil
}
// GetParametersQuery converts the parameters from GetParameters into the url.Values format
func (f *FeesRequest) GetParametersQuery() (url.Values, error) {
query := url.Values{}
params, err := f.GetParameters()
if err != nil {
return query, err
}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParametersJSON converts the parameters from GetParameters into the JSON format
func (f *FeesRequest) GetParametersJSON() ([]byte, error) {
params, err := f.GetParameters()
if err != nil {
return nil, err
}
return json.Marshal(params)
}
// GetSlugParameters builds and checks the slug parameters and return the result in a map object
func (f *FeesRequest) GetSlugParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
// check Metric field -> json key metric
Metric := f.Metric
// assign parameter of Metric
params["metric"] = Metric
return params, nil
}
func (f *FeesRequest) applySlugsToUrl(url string, slugs map[string]string) string {
for k, v := range slugs {
needleRE := regexp.MustCompile(":" + k + "\\b")
url = needleRE.ReplaceAllString(url, v)
}
return url
}
func (f *FeesRequest) GetSlugsMap() (map[string]string, error) {
slugs := map[string]string{}
params, err := f.GetSlugParameters()
if err != nil {
return slugs, nil
}
for k, v := range params {
slugs[k] = fmt.Sprintf("%v", v)
}
return slugs, nil
}
func (f *FeesRequest) Do(ctx context.Context) (Response, error) {
// no body params
var params interface{}
query, err := f.GetQueryParameters()
if err != nil {
return nil, err
}
apiURL := "/v1/metrics/fees/:metric"
slugs, err := f.GetSlugsMap()
if err != nil {
return nil, err
}
apiURL = f.applySlugsToUrl(apiURL, slugs)
req, err := f.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params)
if err != nil {
return nil, err
}
response, err := f.Client.SendRequest(req)
if err != nil {
return nil, err
}
var apiResponse Response
if err := response.DecodeJSON(&apiResponse); err != nil {
return nil, err
}
return apiResponse, nil
}

17
pkg/datasource/glassnode/glassnodeapi/indicators.go
View File

@ -1,17 +0,0 @@
package glassnodeapi
import "github.com/c9s/requestgen"
//go:generate requestgen -method GET -type IndicatorsRequest -url "/v1/metrics/indicators/:metric" -responseType Response
type IndicatorsRequest struct {
Client requestgen.AuthenticatedAPIClient
Asset string `param:"a,required,query"`
Since int64 `param:"s,query"`
Until int64 `param:"u,query"`
Interval Interval `param:"i,query"`
Format Format `param:"f,query"`
TimestampFormat string `param:"timestamp_format,query"`
Metric string `param:"metric,slug"`
}

196
pkg/datasource/glassnode/glassnodeapi/indicators_request_requestgen.go
View File

@ -1,196 +0,0 @@
// Code generated by "requestgen -method GET -type IndicatorsRequest -url /v1/metrics/indicators/:metric -responseType Response"; DO NOT EDIT.
package glassnodeapi
import (
"context"
"encoding/json"
"fmt"
"net/url"
"regexp"
)
func (i *IndicatorsRequest) SetAsset(Asset string) *IndicatorsRequest {
i.Asset = Asset
return i
}
func (i *IndicatorsRequest) SetSince(Since int64) *IndicatorsRequest {
i.Since = Since
return i
}
func (i *IndicatorsRequest) SetUntil(Until int64) *IndicatorsRequest {
i.Until = Until
return i
}
func (i *IndicatorsRequest) SetInterval(Interval Interval) *IndicatorsRequest {
i.Interval = Interval
return i
}
func (i *IndicatorsRequest) SetFormat(Format Format) *IndicatorsRequest {
i.Format = Format
return i
}
func (i *IndicatorsRequest) SetTimestampFormat(TimestampFormat string) *IndicatorsRequest {
i.TimestampFormat = TimestampFormat
return i
}
func (i *IndicatorsRequest) SetMetric(Metric string) *IndicatorsRequest {
i.Metric = Metric
return i
}
// GetQueryParameters builds and checks the query parameters and returns url.Values
func (i *IndicatorsRequest) GetQueryParameters() (url.Values, error) {
var params = map[string]interface{}{}
// check Asset field -> json key a
Asset := i.Asset
// TEMPLATE check-required
if len(Asset) == 0 {
return nil, fmt.Errorf("a is required, empty string given")
}
// END TEMPLATE check-required
// assign parameter of Asset
params["a"] = Asset
// check Since field -> json key s
Since := i.Since
// assign parameter of Since
params["s"] = Since
// check Until field -> json key u
Until := i.Until
// assign parameter of Until
params["u"] = Until
// check Interval field -> json key i
Interval := i.Interval
// assign parameter of Interval
params["i"] = Interval
// check Format field -> json key f
Format := i.Format
// assign parameter of Format
params["f"] = Format
// check TimestampFormat field -> json key timestamp_format
TimestampFormat := i.TimestampFormat
// assign parameter of TimestampFormat
params["timestamp_format"] = TimestampFormat
query := url.Values{}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParameters builds and checks the parameters and return the result in a map object
func (i *IndicatorsRequest) GetParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
return params, nil
}
// GetParametersQuery converts the parameters from GetParameters into the url.Values format
func (i *IndicatorsRequest) GetParametersQuery() (url.Values, error) {
query := url.Values{}
params, err := i.GetParameters()
if err != nil {
return query, err
}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParametersJSON converts the parameters from GetParameters into the JSON format
func (i *IndicatorsRequest) GetParametersJSON() ([]byte, error) {
params, err := i.GetParameters()
if err != nil {
return nil, err
}
return json.Marshal(params)
}
// GetSlugParameters builds and checks the slug parameters and return the result in a map object
func (i *IndicatorsRequest) GetSlugParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
// check Metric field -> json key metric
Metric := i.Metric
// assign parameter of Metric
params["metric"] = Metric
return params, nil
}
func (i *IndicatorsRequest) applySlugsToUrl(url string, slugs map[string]string) string {
for k, v := range slugs {
needleRE := regexp.MustCompile(":" + k + "\\b")
url = needleRE.ReplaceAllString(url, v)
}
return url
}
func (i *IndicatorsRequest) GetSlugsMap() (map[string]string, error) {
slugs := map[string]string{}
params, err := i.GetSlugParameters()
if err != nil {
return slugs, nil
}
for k, v := range params {
slugs[k] = fmt.Sprintf("%v", v)
}
return slugs, nil
}
func (i *IndicatorsRequest) Do(ctx context.Context) (Response, error) {
// no body params
var params interface{}
query, err := i.GetQueryParameters()
if err != nil {
return nil, err
}
apiURL := "/v1/metrics/indicators/:metric"
slugs, err := i.GetSlugsMap()
if err != nil {
return nil, err
}
apiURL = i.applySlugsToUrl(apiURL, slugs)
req, err := i.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params)
if err != nil {
return nil, err
}
response, err := i.Client.SendRequest(req)
if err != nil {
return nil, err
}
var apiResponse Response
if err := response.DecodeJSON(&apiResponse); err != nil {
return nil, err
}
return apiResponse, nil
}

17
pkg/datasource/glassnode/glassnodeapi/institutions.go
View File

@ -1,17 +0,0 @@
package glassnodeapi
import "github.com/c9s/requestgen"
//go:generate requestgen -method GET -type InstitutionsRequest -url "/v1/metrics/institutions/:metric" -responseType Response
type InstitutionsRequest struct {
Client requestgen.AuthenticatedAPIClient
Asset string `param:"a,required,query"`
Since int64 `param:"s,query"`
Until int64 `param:"u,query"`
Interval Interval `param:"i,query"`
Format Format `param:"f,query"`
TimestampFormat string `param:"timestamp_format,query"`
Metric string `param:"metric,slug"`
}

196
pkg/datasource/glassnode/glassnodeapi/institutions_request_requestgen.go
View File

@ -1,196 +0,0 @@
// Code generated by "requestgen -method GET -type InstitutionsRequest -url /v1/metrics/institutions/:metric -responseType Response"; DO NOT EDIT.
package glassnodeapi
import (
"context"
"encoding/json"
"fmt"
"net/url"
"regexp"
)
func (i *InstitutionsRequest) SetAsset(Asset string) *InstitutionsRequest {
i.Asset = Asset
return i
}
func (i *InstitutionsRequest) SetSince(Since int64) *InstitutionsRequest {
i.Since = Since
return i
}
func (i *InstitutionsRequest) SetUntil(Until int64) *InstitutionsRequest {
i.Until = Until
return i
}
func (i *InstitutionsRequest) SetInterval(Interval Interval) *InstitutionsRequest {
i.Interval = Interval
return i
}
func (i *InstitutionsRequest) SetFormat(Format Format) *InstitutionsRequest {
i.Format = Format
return i
}
func (i *InstitutionsRequest) SetTimestampFormat(TimestampFormat string) *InstitutionsRequest {
i.TimestampFormat = TimestampFormat
return i
}
func (i *InstitutionsRequest) SetMetric(Metric string) *InstitutionsRequest {
i.Metric = Metric
return i
}
// GetQueryParameters builds and checks the query parameters and returns url.Values
func (i *InstitutionsRequest) GetQueryParameters() (url.Values, error) {
var params = map[string]interface{}{}
// check Asset field -> json key a
Asset := i.Asset
// TEMPLATE check-required
if len(Asset) == 0 {
return nil, fmt.Errorf("a is required, empty string given")
}
// END TEMPLATE check-required
// assign parameter of Asset
params["a"] = Asset
// check Since field -> json key s
Since := i.Since
// assign parameter of Since
params["s"] = Since
// check Until field -> json key u
Until := i.Until
// assign parameter of Until
params["u"] = Until
// check Interval field -> json key i
Interval := i.Interval
// assign parameter of Interval
params["i"] = Interval
// check Format field -> json key f
Format := i.Format
// assign parameter of Format
params["f"] = Format
// check TimestampFormat field -> json key timestamp_format
TimestampFormat := i.TimestampFormat
// assign parameter of TimestampFormat
params["timestamp_format"] = TimestampFormat
query := url.Values{}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParameters builds and checks the parameters and return the result in a map object
func (i *InstitutionsRequest) GetParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
return params, nil
}
// GetParametersQuery converts the parameters from GetParameters into the url.Values format
func (i *InstitutionsRequest) GetParametersQuery() (url.Values, error) {
query := url.Values{}
params, err := i.GetParameters()
if err != nil {
return query, err
}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParametersJSON converts the parameters from GetParameters into the JSON format
func (i *InstitutionsRequest) GetParametersJSON() ([]byte, error) {
params, err := i.GetParameters()
if err != nil {
return nil, err
}
return json.Marshal(params)
}
// GetSlugParameters builds and checks the slug parameters and return the result in a map object
func (i *InstitutionsRequest) GetSlugParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
// check Metric field -> json key metric
Metric := i.Metric
// assign parameter of Metric
params["metric"] = Metric
return params, nil
}
func (i *InstitutionsRequest) applySlugsToUrl(url string, slugs map[string]string) string {
for k, v := range slugs {
needleRE := regexp.MustCompile(":" + k + "\\b")
url = needleRE.ReplaceAllString(url, v)
}
return url
}
func (i *InstitutionsRequest) GetSlugsMap() (map[string]string, error) {
slugs := map[string]string{}
params, err := i.GetSlugParameters()
if err != nil {
return slugs, nil
}
for k, v := range params {
slugs[k] = fmt.Sprintf("%v", v)
}
return slugs, nil
}
func (i *InstitutionsRequest) Do(ctx context.Context) (Response, error) {
// no body params
var params interface{}
query, err := i.GetQueryParameters()
if err != nil {
return nil, err
}
apiURL := "/v1/metrics/institutions/:metric"
slugs, err := i.GetSlugsMap()
if err != nil {
return nil, err
}
apiURL = i.applySlugsToUrl(apiURL, slugs)
req, err := i.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params)
if err != nil {
return nil, err
}
response, err := i.Client.SendRequest(req)
if err != nil {
return nil, err
}
var apiResponse Response
if err := response.DecodeJSON(&apiResponse); err != nil {
return nil, err
}
return apiResponse, nil
}

17
pkg/datasource/glassnode/glassnodeapi/lightning.go
View File

@ -1,17 +0,0 @@
package glassnodeapi
import "github.com/c9s/requestgen"
//go:generate requestgen -method GET -type LightningRequest -url "/v1/metrics/lightning/:metric" -responseType Response
type LightningRequest struct {
Client requestgen.AuthenticatedAPIClient
Asset string `param:"a,required,query"`
Since int64 `param:"s,query"`
Until int64 `param:"u,query"`
Interval Interval `param:"i,query"`
Format Format `param:"f,query"`
TimestampFormat string `param:"timestamp_format,query"`
Metric string `param:"metric,slug"`
}

196
pkg/datasource/glassnode/glassnodeapi/lightning_request_requestgen.go
View File

@ -1,196 +0,0 @@
// Code generated by "requestgen -method GET -type LightningRequest -url /v1/metrics/lightning/:metric -responseType Response"; DO NOT EDIT.
package glassnodeapi
import (
"context"
"encoding/json"
"fmt"
"net/url"
"regexp"
)
func (l *LightningRequest) SetAsset(Asset string) *LightningRequest {
l.Asset = Asset
return l
}
func (l *LightningRequest) SetSince(Since int64) *LightningRequest {
l.Since = Since
return l
}
func (l *LightningRequest) SetUntil(Until int64) *LightningRequest {
l.Until = Until
return l
}
func (l *LightningRequest) SetInterval(Interval Interval) *LightningRequest {
l.Interval = Interval
return l
}
func (l *LightningRequest) SetFormat(Format Format) *LightningRequest {
l.Format = Format
return l
}
func (l *LightningRequest) SetTimestampFormat(TimestampFormat string) *LightningRequest {
l.TimestampFormat = TimestampFormat
return l
}
func (l *LightningRequest) SetMetric(Metric string) *LightningRequest {
l.Metric = Metric
return l
}
// GetQueryParameters builds and checks the query parameters and returns url.Values
func (l *LightningRequest) GetQueryParameters() (url.Values, error) {
var params = map[string]interface{}{}
// check Asset field -> json key a
Asset := l.Asset
// TEMPLATE check-required
if len(Asset) == 0 {
return nil, fmt.Errorf("a is required, empty string given")
}
// END TEMPLATE check-required
// assign parameter of Asset
params["a"] = Asset
// check Since field -> json key s
Since := l.Since
// assign parameter of Since
params["s"] = Since
// check Until field -> json key u
Until := l.Until
// assign parameter of Until
params["u"] = Until
// check Interval field -> json key i
Interval := l.Interval
// assign parameter of Interval
params["i"] = Interval
// check Format field -> json key f
Format := l.Format
// assign parameter of Format
params["f"] = Format
// check TimestampFormat field -> json key timestamp_format
TimestampFormat := l.TimestampFormat
// assign parameter of TimestampFormat
params["timestamp_format"] = TimestampFormat
query := url.Values{}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParameters builds and checks the parameters and return the result in a map object
func (l *LightningRequest) GetParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
return params, nil
}
// GetParametersQuery converts the parameters from GetParameters into the url.Values format
func (l *LightningRequest) GetParametersQuery() (url.Values, error) {
query := url.Values{}
params, err := l.GetParameters()
if err != nil {
return query, err
}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParametersJSON converts the parameters from GetParameters into the JSON format
func (l *LightningRequest) GetParametersJSON() ([]byte, error) {
params, err := l.GetParameters()
if err != nil {
return nil, err
}
return json.Marshal(params)
}
// GetSlugParameters builds and checks the slug parameters and return the result in a map object
func (l *LightningRequest) GetSlugParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
// check Metric field -> json key metric
Metric := l.Metric
// assign parameter of Metric
params["metric"] = Metric
return params, nil
}
func (l *LightningRequest) applySlugsToUrl(url string, slugs map[string]string) string {
for k, v := range slugs {
needleRE := regexp.MustCompile(":" + k + "\\b")
url = needleRE.ReplaceAllString(url, v)
}
return url
}
func (l *LightningRequest) GetSlugsMap() (map[string]string, error) {
slugs := map[string]string{}
params, err := l.GetSlugParameters()
if err != nil {
return slugs, nil
}
for k, v := range params {
slugs[k] = fmt.Sprintf("%v", v)
}
return slugs, nil
}
func (l *LightningRequest) Do(ctx context.Context) (Response, error) {
// no body params
var params interface{}
query, err := l.GetQueryParameters()
if err != nil {
return nil, err
}
apiURL := "/v1/metrics/lightning/:metric"
slugs, err := l.GetSlugsMap()
if err != nil {
return nil, err
}
apiURL = l.applySlugsToUrl(apiURL, slugs)
req, err := l.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params)
if err != nil {
return nil, err
}
response, err := l.Client.SendRequest(req)
if err != nil {
return nil, err
}
var apiResponse Response
if err := response.DecodeJSON(&apiResponse); err != nil {
return nil, err
}
return apiResponse, nil
}

17
pkg/datasource/glassnode/glassnodeapi/market.go
View File

@ -1,17 +0,0 @@
package glassnodeapi
import "github.com/c9s/requestgen"
//go:generate requestgen -method GET -type MarketRequest -url "/v1/metrics/market/:metric" -responseType Response
type MarketRequest struct {
Client requestgen.AuthenticatedAPIClient
Asset string `param:"a,required,query"`
Since int64 `param:"s,query"`
Until int64 `param:"u,query"`
Interval Interval `param:"i,query"`
Format Format `param:"f,query"`
TimestampFormat string `param:"timestamp_format,query"`
Metric string `param:"metric,slug"`
}

196
pkg/datasource/glassnode/glassnodeapi/market_request_requestgen.go
View File

@ -1,196 +0,0 @@
// Code generated by "requestgen -method GET -type MarketRequest -url /v1/metrics/market/:metric -responseType Response"; DO NOT EDIT.
package glassnodeapi
import (
"context"
"encoding/json"
"fmt"
"net/url"
"regexp"
)
func (m *MarketRequest) SetAsset(Asset string) *MarketRequest {
m.Asset = Asset
return m
}
func (m *MarketRequest) SetSince(Since int64) *MarketRequest {
m.Since = Since
return m
}
func (m *MarketRequest) SetUntil(Until int64) *MarketRequest {
m.Until = Until
return m
}
func (m *MarketRequest) SetInterval(Interval Interval) *MarketRequest {
m.Interval = Interval
return m
}
func (m *MarketRequest) SetFormat(Format Format) *MarketRequest {
m.Format = Format
return m
}
func (m *MarketRequest) SetTimestampFormat(TimestampFormat string) *MarketRequest {
m.TimestampFormat = TimestampFormat
return m
}
func (m *MarketRequest) SetMetric(Metric string) *MarketRequest {
m.Metric = Metric
return m
}
// GetQueryParameters builds and checks the query parameters and returns url.Values
func (m *MarketRequest) GetQueryParameters() (url.Values, error) {
var params = map[string]interface{}{}
// check Asset field -> json key a
Asset := m.Asset
// TEMPLATE check-required
if len(Asset) == 0 {
return nil, fmt.Errorf("a is required, empty string given")
}
// END TEMPLATE check-required
// assign parameter of Asset
params["a"] = Asset
// check Since field -> json key s
Since := m.Since
// assign parameter of Since
params["s"] = Since
// check Until field -> json key u
Until := m.Until
// assign parameter of Until
params["u"] = Until
// check Interval field -> json key i
Interval := m.Interval
// assign parameter of Interval
params["i"] = Interval
// check Format field -> json key f
Format := m.Format
// assign parameter of Format
params["f"] = Format
// check TimestampFormat field -> json key timestamp_format
TimestampFormat := m.TimestampFormat
// assign parameter of TimestampFormat
params["timestamp_format"] = TimestampFormat
query := url.Values{}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParameters builds and checks the parameters and return the result in a map object
func (m *MarketRequest) GetParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
return params, nil
}
// GetParametersQuery converts the parameters from GetParameters into the url.Values format
func (m *MarketRequest) GetParametersQuery() (url.Values, error) {
query := url.Values{}
params, err := m.GetParameters()
if err != nil {
return query, err
}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParametersJSON converts the parameters from GetParameters into the JSON format
func (m *MarketRequest) GetParametersJSON() ([]byte, error) {
params, err := m.GetParameters()
if err != nil {
return nil, err
}
return json.Marshal(params)
}
// GetSlugParameters builds and checks the slug parameters and return the result in a map object
func (m *MarketRequest) GetSlugParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
// check Metric field -> json key metric
Metric := m.Metric
// assign parameter of Metric
params["metric"] = Metric
return params, nil
}
func (m *MarketRequest) applySlugsToUrl(url string, slugs map[string]string) string {
for k, v := range slugs {
needleRE := regexp.MustCompile(":" + k + "\\b")
url = needleRE.ReplaceAllString(url, v)
}
return url
}
func (m *MarketRequest) GetSlugsMap() (map[string]string, error) {
slugs := map[string]string{}
params, err := m.GetSlugParameters()
if err != nil {
return slugs, nil
}
for k, v := range params {
slugs[k] = fmt.Sprintf("%v", v)
}
return slugs, nil
}
func (m *MarketRequest) Do(ctx context.Context) (Response, error) {
// no body params
var params interface{}
query, err := m.GetQueryParameters()
if err != nil {
return nil, err
}
apiURL := "/v1/metrics/market/:metric"
slugs, err := m.GetSlugsMap()
if err != nil {
return nil, err
}
apiURL = m.applySlugsToUrl(apiURL, slugs)
req, err := m.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params)
if err != nil {
return nil, err
}
response, err := m.Client.SendRequest(req)
if err != nil {
return nil, err
}
var apiResponse Response
if err := response.DecodeJSON(&apiResponse); err != nil {
return nil, err
}
return apiResponse, nil
}

17
pkg/datasource/glassnode/glassnodeapi/mempool.go
View File

@ -1,17 +0,0 @@
package glassnodeapi
import "github.com/c9s/requestgen"
//go:generate requestgen -method GET -type MempoolRequest -url "/v1/metrics/mempool/:metric" -responseType Response
type MempoolRequest struct {
Client requestgen.AuthenticatedAPIClient
Asset string `param:"a,required,query"`
Since int64 `param:"s,query"`
Until int64 `param:"u,query"`
Interval Interval `param:"i,query"`
Format Format `param:"f,query"`
TimestampFormat string `param:"timestamp_format,query"`
Metric string `param:"metric,slug"`
}

196
pkg/datasource/glassnode/glassnodeapi/mempool_request_requestgen.go
View File

@ -1,196 +0,0 @@
// Code generated by "requestgen -method GET -type MempoolRequest -url /v1/metrics/mempool/:metric -responseType Response"; DO NOT EDIT.
package glassnodeapi
import (
"context"
"encoding/json"
"fmt"
"net/url"
"regexp"
)
func (m *MempoolRequest) SetAsset(Asset string) *MempoolRequest {
m.Asset = Asset
return m
}
func (m *MempoolRequest) SetSince(Since int64) *MempoolRequest {
m.Since = Since
return m
}
func (m *MempoolRequest) SetUntil(Until int64) *MempoolRequest {
m.Until = Until
return m
}
func (m *MempoolRequest) SetInterval(Interval Interval) *MempoolRequest {
m.Interval = Interval
return m
}
func (m *MempoolRequest) SetFormat(Format Format) *MempoolRequest {
m.Format = Format
return m
}
func (m *MempoolRequest) SetTimestampFormat(TimestampFormat string) *MempoolRequest {
m.TimestampFormat = TimestampFormat
return m
}
func (m *MempoolRequest) SetMetric(Metric string) *MempoolRequest {
m.Metric = Metric
return m
}
// GetQueryParameters builds and checks the query parameters and returns url.Values
func (m *MempoolRequest) GetQueryParameters() (url.Values, error) {
var params = map[string]interface{}{}
// check Asset field -> json key a
Asset := m.Asset
// TEMPLATE check-required
if len(Asset) == 0 {
return nil, fmt.Errorf("a is required, empty string given")
}
// END TEMPLATE check-required
// assign parameter of Asset
params["a"] = Asset
// check Since field -> json key s
Since := m.Since
// assign parameter of Since
params["s"] = Since
// check Until field -> json key u
Until := m.Until
// assign parameter of Until
params["u"] = Until
// check Interval field -> json key i
Interval := m.Interval
// assign parameter of Interval
params["i"] = Interval
// check Format field -> json key f
Format := m.Format
// assign parameter of Format
params["f"] = Format
// check TimestampFormat field -> json key timestamp_format
TimestampFormat := m.TimestampFormat
// assign parameter of TimestampFormat
params["timestamp_format"] = TimestampFormat
query := url.Values{}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParameters builds and checks the parameters and return the result in a map object
func (m *MempoolRequest) GetParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
return params, nil
}
// GetParametersQuery converts the parameters from GetParameters into the url.Values format
func (m *MempoolRequest) GetParametersQuery() (url.Values, error) {
query := url.Values{}
params, err := m.GetParameters()
if err != nil {
return query, err
}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParametersJSON converts the parameters from GetParameters into the JSON format
func (m *MempoolRequest) GetParametersJSON() ([]byte, error) {
params, err := m.GetParameters()
if err != nil {
return nil, err
}
return json.Marshal(params)
}
// GetSlugParameters builds and checks the slug parameters and return the result in a map object
func (m *MempoolRequest) GetSlugParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
// check Metric field -> json key metric
Metric := m.Metric
// assign parameter of Metric
params["metric"] = Metric
return params, nil
}
func (m *MempoolRequest) applySlugsToUrl(url string, slugs map[string]string) string {
for k, v := range slugs {
needleRE := regexp.MustCompile(":" + k + "\\b")
url = needleRE.ReplaceAllString(url, v)
}
return url
}
func (m *MempoolRequest) GetSlugsMap() (map[string]string, error) {
slugs := map[string]string{}
params, err := m.GetSlugParameters()
if err != nil {
return slugs, nil
}
for k, v := range params {
slugs[k] = fmt.Sprintf("%v", v)
}
return slugs, nil
}
func (m *MempoolRequest) Do(ctx context.Context) (Response, error) {
// no body params
var params interface{}
query, err := m.GetQueryParameters()
if err != nil {
return nil, err
}
apiURL := "/v1/metrics/mempool/:metric"
slugs, err := m.GetSlugsMap()
if err != nil {
return nil, err
}
apiURL = m.applySlugsToUrl(apiURL, slugs)
req, err := m.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params)
if err != nil {
return nil, err
}
response, err := m.Client.SendRequest(req)
if err != nil {
return nil, err
}
var apiResponse Response
if err := response.DecodeJSON(&apiResponse); err != nil {
return nil, err
}
return apiResponse, nil
}

17
pkg/datasource/glassnode/glassnodeapi/mining.go
View File

@ -1,17 +0,0 @@
package glassnodeapi
import "github.com/c9s/requestgen"
//go:generate requestgen -method GET -type MiningRequest -url "/v1/metrics/mining/:metric" -responseType Response
type MiningRequest struct {
Client requestgen.AuthenticatedAPIClient
Asset string `param:"a,required,query"`
Since int64 `param:"s,query"`
Until int64 `param:"u,query"`
Interval Interval `param:"i,query"`
Format Format `param:"f,query"`
TimestampFormat string `param:"timestamp_format,query"`
Metric string `param:"metric,slug"`
}

196
pkg/datasource/glassnode/glassnodeapi/mining_request_requestgen.go
View File

@ -1,196 +0,0 @@
// Code generated by "requestgen -method GET -type MiningRequest -url /v1/metrics/mining/:metric -responseType Response"; DO NOT EDIT.
package glassnodeapi
import (
"context"
"encoding/json"
"fmt"
"net/url"
"regexp"
)
func (m *MiningRequest) SetAsset(Asset string) *MiningRequest {
m.Asset = Asset
return m
}
func (m *MiningRequest) SetSince(Since int64) *MiningRequest {
m.Since = Since
return m
}
func (m *MiningRequest) SetUntil(Until int64) *MiningRequest {
m.Until = Until
return m
}
func (m *MiningRequest) SetInterval(Interval Interval) *MiningRequest {
m.Interval = Interval
return m
}
func (m *MiningRequest) SetFormat(Format Format) *MiningRequest {
m.Format = Format
return m
}
func (m *MiningRequest) SetTimestampFormat(TimestampFormat string) *MiningRequest {
m.TimestampFormat = TimestampFormat
return m
}
func (m *MiningRequest) SetMetric(Metric string) *MiningRequest {
m.Metric = Metric
return m
}
// GetQueryParameters builds and checks the query parameters and returns url.Values
func (m *MiningRequest) GetQueryParameters() (url.Values, error) {
var params = map[string]interface{}{}
// check Asset field -> json key a
Asset := m.Asset
// TEMPLATE check-required
if len(Asset) == 0 {
return nil, fmt.Errorf("a is required, empty string given")
}
// END TEMPLATE check-required
// assign parameter of Asset
params["a"] = Asset
// check Since field -> json key s
Since := m.Since
// assign parameter of Since
params["s"] = Since
// check Until field -> json key u
Until := m.Until
// assign parameter of Until
params["u"] = Until
// check Interval field -> json key i
Interval := m.Interval
// assign parameter of Interval
params["i"] = Interval
// check Format field -> json key f
Format := m.Format
// assign parameter of Format
params["f"] = Format
// check TimestampFormat field -> json key timestamp_format
TimestampFormat := m.TimestampFormat
// assign parameter of TimestampFormat
params["timestamp_format"] = TimestampFormat
query := url.Values{}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParameters builds and checks the parameters and return the result in a map object
func (m *MiningRequest) GetParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
return params, nil
}
// GetParametersQuery converts the parameters from GetParameters into the url.Values format
func (m *MiningRequest) GetParametersQuery() (url.Values, error) {
query := url.Values{}
params, err := m.GetParameters()
if err != nil {
return query, err
}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParametersJSON converts the parameters from GetParameters into the JSON format
func (m *MiningRequest) GetParametersJSON() ([]byte, error) {
params, err := m.GetParameters()
if err != nil {
return nil, err
}
return json.Marshal(params)
}
// GetSlugParameters builds and checks the slug parameters and return the result in a map object
func (m *MiningRequest) GetSlugParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
// check Metric field -> json key metric
Metric := m.Metric
// assign parameter of Metric
params["metric"] = Metric
return params, nil
}
func (m *MiningRequest) applySlugsToUrl(url string, slugs map[string]string) string {
for k, v := range slugs {
needleRE := regexp.MustCompile(":" + k + "\\b")
url = needleRE.ReplaceAllString(url, v)
}
return url
}
func (m *MiningRequest) GetSlugsMap() (map[string]string, error) {
slugs := map[string]string{}
params, err := m.GetSlugParameters()
if err != nil {
return slugs, nil
}
for k, v := range params {
slugs[k] = fmt.Sprintf("%v", v)
}
return slugs, nil
}
func (m *MiningRequest) Do(ctx context.Context) (Response, error) {
// no body params
var params interface{}
query, err := m.GetQueryParameters()
if err != nil {
return nil, err
}
apiURL := "/v1/metrics/mining/:metric"
slugs, err := m.GetSlugsMap()
if err != nil {
return nil, err
}
apiURL = m.applySlugsToUrl(apiURL, slugs)
req, err := m.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params)
if err != nil {
return nil, err
}
response, err := m.Client.SendRequest(req)
if err != nil {
return nil, err
}
var apiResponse Response
if err := response.DecodeJSON(&apiResponse); err != nil {
return nil, err
}
return apiResponse, nil
}

17
pkg/datasource/glassnode/glassnodeapi/protocols.go
View File

@ -1,17 +0,0 @@
package glassnodeapi
import "github.com/c9s/requestgen"
//go:generate requestgen -method GET -type ProtocolsRequest -url "/v1/metrics/protocols/:metric" -responseType Response
type ProtocolsRequest struct {
Client requestgen.AuthenticatedAPIClient
Asset string `param:"a,required,query"`
Since int64 `param:"s,query"`
Until int64 `param:"u,query"`
Interval Interval `param:"i,query"`
Format Format `param:"f,query"`
TimestampFormat string `param:"timestamp_format,query"`
Metric string `param:"metric,slug"`
}

196
pkg/datasource/glassnode/glassnodeapi/protocols_request_requestgen.go
View File

@ -1,196 +0,0 @@
// Code generated by "requestgen -method GET -type ProtocolsRequest -url /v1/metrics/protocols/:metric -responseType Response"; DO NOT EDIT.
package glassnodeapi
import (
"context"
"encoding/json"
"fmt"
"net/url"
"regexp"
)
func (p *ProtocolsRequest) SetAsset(Asset string) *ProtocolsRequest {
p.Asset = Asset
return p
}
func (p *ProtocolsRequest) SetSince(Since int64) *ProtocolsRequest {
p.Since = Since
return p
}
func (p *ProtocolsRequest) SetUntil(Until int64) *ProtocolsRequest {
p.Until = Until
return p
}
func (p *ProtocolsRequest) SetInterval(Interval Interval) *ProtocolsRequest {
p.Interval = Interval
return p
}
func (p *ProtocolsRequest) SetFormat(Format Format) *ProtocolsRequest {
p.Format = Format
return p
}
func (p *ProtocolsRequest) SetTimestampFormat(TimestampFormat string) *ProtocolsRequest {
p.TimestampFormat = TimestampFormat
return p
}
func (p *ProtocolsRequest) SetMetric(Metric string) *ProtocolsRequest {
p.Metric = Metric
return p
}
// GetQueryParameters builds and checks the query parameters and returns url.Values
func (p *ProtocolsRequest) GetQueryParameters() (url.Values, error) {
var params = map[string]interface{}{}
// check Asset field -> json key a
Asset := p.Asset
// TEMPLATE check-required
if len(Asset) == 0 {
return nil, fmt.Errorf("a is required, empty string given")
}
// END TEMPLATE check-required
// assign parameter of Asset
params["a"] = Asset
// check Since field -> json key s
Since := p.Since
// assign parameter of Since
params["s"] = Since
// check Until field -> json key u
Until := p.Until
// assign parameter of Until
params["u"] = Until
// check Interval field -> json key i
Interval := p.Interval
// assign parameter of Interval
params["i"] = Interval
// check Format field -> json key f
Format := p.Format
// assign parameter of Format
params["f"] = Format
// check TimestampFormat field -> json key timestamp_format
TimestampFormat := p.TimestampFormat
// assign parameter of TimestampFormat
params["timestamp_format"] = TimestampFormat
query := url.Values{}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParameters builds and checks the parameters and return the result in a map object
func (p *ProtocolsRequest) GetParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
return params, nil
}
// GetParametersQuery converts the parameters from GetParameters into the url.Values format
func (p *ProtocolsRequest) GetParametersQuery() (url.Values, error) {
query := url.Values{}
params, err := p.GetParameters()
if err != nil {
return query, err
}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParametersJSON converts the parameters from GetParameters into the JSON format
func (p *ProtocolsRequest) GetParametersJSON() ([]byte, error) {
params, err := p.GetParameters()
if err != nil {
return nil, err
}
return json.Marshal(params)
}
// GetSlugParameters builds and checks the slug parameters and return the result in a map object
func (p *ProtocolsRequest) GetSlugParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
// check Metric field -> json key metric
Metric := p.Metric
// assign parameter of Metric
params["metric"] = Metric
return params, nil
}
func (p *ProtocolsRequest) applySlugsToUrl(url string, slugs map[string]string) string {
for k, v := range slugs {
needleRE := regexp.MustCompile(":" + k + "\\b")
url = needleRE.ReplaceAllString(url, v)
}
return url
}
func (p *ProtocolsRequest) GetSlugsMap() (map[string]string, error) {
slugs := map[string]string{}
params, err := p.GetSlugParameters()
if err != nil {
return slugs, nil
}
for k, v := range params {
slugs[k] = fmt.Sprintf("%v", v)
}
return slugs, nil
}
func (p *ProtocolsRequest) Do(ctx context.Context) (Response, error) {
// no body params
var params interface{}
query, err := p.GetQueryParameters()
if err != nil {
return nil, err
}
apiURL := "/v1/metrics/protocols/:metric"
slugs, err := p.GetSlugsMap()
if err != nil {
return nil, err
}
apiURL = p.applySlugsToUrl(apiURL, slugs)
req, err := p.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params)
if err != nil {
return nil, err
}
response, err := p.Client.SendRequest(req)
if err != nil {
return nil, err
}
var apiResponse Response
if err := response.DecodeJSON(&apiResponse); err != nil {
return nil, err
}
return apiResponse, nil
}

23
pkg/datasource/glassnode/glassnodeapi/request.go Normal file
View File

@ -0,0 +1,23 @@
package glassnodeapi
import (
"time"
"github.com/c9s/requestgen"
)
//go:generate requestgen -method GET -type Request -url "/v1/metrics/:category/:metric" -responseType DataSlice
type Request struct {
Client requestgen.AuthenticatedAPIClient
Asset string `param:"a,required,query"`
Since *time.Time `param:"s,query,seconds"`
Until *time.Time `param:"u,query,seconds"`
Interval *Interval `param:"i,query"`
Format *Format `param:"f,query" default:"JSON"`
Currency *string `param:"c,query"`
TimestampFormat *string `param:"timestamp_format,query"`
Category string `param:"category,slug"`
Metric string `param:"metric,slug"`
}

288
pkg/datasource/glassnode/glassnodeapi/request_requestgen.go Normal file
View File

@ -0,0 +1,288 @@
// Code generated by "requestgen -method GET -type Request -url /v1/metrics/:category/:metric -responseType DataSlice"; DO NOT EDIT.
package glassnodeapi
import (
"context"
"encoding/json"
"fmt"
"net/url"
"reflect"
"regexp"
"strconv"
"time"
)
func (r *Request) SetAsset(Asset string) *Request {
r.Asset = Asset
return r
}
func (r *Request) SetSince(Since time.Time) *Request {
r.Since = &Since
return r
}
func (r *Request) SetUntil(Until time.Time) *Request {
r.Until = &Until
return r
}
func (r *Request) SetInterval(Interval Interval) *Request {
r.Interval = &Interval
return r
}
func (r *Request) SetFormat(Format Format) *Request {
r.Format = &Format
return r
}
func (r *Request) SetCurrency(Currency string) *Request {
r.Currency = &Currency
return r
}
func (r *Request) SetTimestampFormat(TimestampFormat string) *Request {
r.TimestampFormat = &TimestampFormat
return r
}
func (r *Request) SetCategory(Category string) *Request {
r.Category = Category
return r
}
func (r *Request) SetMetric(Metric string) *Request {
r.Metric = Metric
return r
}
// GetQueryParameters builds and checks the query parameters and returns url.Values
func (r *Request) GetQueryParameters() (url.Values, error) {
var params = map[string]interface{}{}
// check Asset field -> json key a
Asset := r.Asset
// TEMPLATE check-required
if len(Asset) == 0 {
return nil, fmt.Errorf("a is required, empty string given")
}
// END TEMPLATE check-required
// assign parameter of Asset
params["a"] = Asset
// check Since field -> json key s
if r.Since != nil {
Since := *r.Since
// assign parameter of Since
// convert time.Time to seconds time stamp
params["s"] = strconv.FormatInt(Since.Unix(), 10)
} else {
}
// check Until field -> json key u
if r.Until != nil {
Until := *r.Until
// assign parameter of Until
// convert time.Time to seconds time stamp
params["u"] = strconv.FormatInt(Until.Unix(), 10)
} else {
}
// check Interval field -> json key i
if r.Interval != nil {
Interval := *r.Interval
// TEMPLATE check-valid-values
switch Interval {
case Interval1h, Interval24h, Interval10m, Interval1w, Interval1m:
params["i"] = Interval
default:
return nil, fmt.Errorf("i value %v is invalid", Interval)
}
// END TEMPLATE check-valid-values
// assign parameter of Interval
params["i"] = Interval
} else {
}
// check Format field -> json key f
if r.Format != nil {
Format := *r.Format
// TEMPLATE check-valid-values
switch Format {
case FormatJSON, FormatCSV:
params["f"] = Format
default:
return nil, fmt.Errorf("f value %v is invalid", Format)
}
// END TEMPLATE check-valid-values
// assign parameter of Format
params["f"] = Format
} else {
Format := "JSON"
// assign parameter of Format
params["f"] = Format
}
// check Currency field -> json key c
if r.Currency != nil {
Currency := *r.Currency
// assign parameter of Currency
params["c"] = Currency
} else {
}
// check TimestampFormat field -> json key timestamp_format
if r.TimestampFormat != nil {
TimestampFormat := *r.TimestampFormat
// assign parameter of TimestampFormat
params["timestamp_format"] = TimestampFormat
} else {
}
query := url.Values{}
for _k, _v := range params {
query.Add(_k, fmt.Sprintf("%v", _v))
}
return query, nil
}
// GetParameters builds and checks the parameters and return the result in a map object
func (r *Request) GetParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
return params, nil
}
// GetParametersQuery converts the parameters from GetParameters into the url.Values format
func (r *Request) GetParametersQuery() (url.Values, error) {
query := url.Values{}
params, err := r.GetParameters()
if err != nil {
return query, err
}
for _k, _v := range params {
if r.isVarSlice(_v) {
r.iterateSlice(_v, func(it interface{}) {
query.Add(_k+"[]", fmt.Sprintf("%v", it))
})
} else {
query.Add(_k, fmt.Sprintf("%v", _v))
}
}
return query, nil
}
// GetParametersJSON converts the parameters from GetParameters into the JSON format
func (r *Request) GetParametersJSON() ([]byte, error) {
params, err := r.GetParameters()
if err != nil {
return nil, err
}
return json.Marshal(params)
}
// GetSlugParameters builds and checks the slug parameters and return the result in a map object
func (r *Request) GetSlugParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
// check Category field -> json key category
Category := r.Category
// assign parameter of Category
params["category"] = Category
// check Metric field -> json key metric
Metric := r.Metric
// assign parameter of Metric
params["metric"] = Metric
return params, nil
}
func (r *Request) applySlugsToUrl(url string, slugs map[string]string) string {
for _k, _v := range slugs {
needleRE := regexp.MustCompile(":" + _k + "\\b")
url = needleRE.ReplaceAllString(url, _v)
}
return url
}
func (r *Request) iterateSlice(slice interface{}, _f func(it interface{})) {
sliceValue := reflect.ValueOf(slice)
for _i := 0; _i < sliceValue.Len(); _i++ {
it := sliceValue.Index(_i).Interface()
_f(it)
}
}
func (r *Request) isVarSlice(_v interface{}) bool {
rt := reflect.TypeOf(_v)
switch rt.Kind() {
case reflect.Slice:
return true
}
return false
}
func (r *Request) GetSlugsMap() (map[string]string, error) {
slugs := map[string]string{}
params, err := r.GetSlugParameters()
if err != nil {
return slugs, nil
}
for _k, _v := range params {
slugs[_k] = fmt.Sprintf("%v", _v)
}
return slugs, nil
}
func (r *Request) Do(ctx context.Context) (DataSlice, error) {
// no body params
var params interface{}
query, err := r.GetQueryParameters()
if err != nil {
return nil, err
}
apiURL := "/v1/metrics/:category/:metric"
slugs, err := r.GetSlugsMap()
if err != nil {
return nil, err
}
apiURL = r.applySlugsToUrl(apiURL, slugs)
req, err := r.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params)
if err != nil {
return nil, err
}
response, err := r.Client.SendRequest(req)
if err != nil {
return nil, err
}
var apiResponse DataSlice
if err := response.DecodeJSON(&apiResponse); err != nil {
return nil, err
}
return apiResponse, nil
}

17
pkg/datasource/glassnode/glassnodeapi/supply.go
View File

@ -1,17 +0,0 @@
package glassnodeapi
import "github.com/c9s/requestgen"
//go:generate requestgen -method GET -type SupplyRequest -url "/v1/metrics/supply/:metric" -responseType Response
type SupplyRequest struct {
Client requestgen.AuthenticatedAPIClient
Asset string `param:"a,required,query"`
Since int64 `param:"s,query"`
Until int64 `param:"u,query"`
Interval Interval `param:"i,query"`
Format Format `param:"f,query"`
TimestampFormat string `param:"timestamp_format,query"`
Metric string `param:"metric,slug"`
}

196
pkg/datasource/glassnode/glassnodeapi/supply_request_requestgen.go
View File

@ -1,196 +0,0 @@
// Code generated by "requestgen -method GET -type SupplyRequest -url /v1/metrics/supply/:metric -responseType Response"; DO NOT EDIT.
package glassnodeapi
import (
"context"
"encoding/json"
"fmt"
"net/url"
"regexp"
)
func (s *SupplyRequest) SetAsset(Asset string) *SupplyRequest {
s.Asset = Asset
return s
}
func (s *SupplyRequest) SetSince(Since int64) *SupplyRequest {
s.Since = Since
return s
}
func (s *SupplyRequest) SetUntil(Until int64) *SupplyRequest {
s.Until = Until
return s
}
func (s *SupplyRequest) SetInterval(Interval Interval) *SupplyRequest {
s.Interval = Interval
return s
}
func (s *SupplyRequest) SetFormat(Format Format) *SupplyRequest {
s.Format = Format
return s
}
func (s *SupplyRequest) SetTimestampFormat(TimestampFormat string) *SupplyRequest {
s.TimestampFormat = TimestampFormat
return s
}
func (s *SupplyRequest) SetMetric(Metric string) *SupplyRequest {
s.Metric = Metric
return s
}
// GetQueryParameters builds and checks the query parameters and returns url.Values
func (s *SupplyRequest) GetQueryParameters() (url.Values, error) {
var params = map[string]interface{}{}
// check Asset field -> json key a
Asset := s.Asset
// TEMPLATE check-required
if len(Asset) == 0 {
return nil, fmt.Errorf("a is required, empty string given")
}
// END TEMPLATE check-required
// assign parameter of Asset
params["a"] = Asset
// check Since field -> json key s
Since := s.Since
// assign parameter of Since
params["s"] = Since
// check Until field -> json key u
Until := s.Until
// assign parameter of Until
params["u"] = Until
// check Interval field -> json key i
Interval := s.Interval
// assign parameter of Interval
params["i"] = Interval
// check Format field -> json key f
Format := s.Format
// assign parameter of Format
params["f"] = Format
// check TimestampFormat field -> json key timestamp_format
TimestampFormat := s.TimestampFormat
// assign parameter of TimestampFormat
params["timestamp_format"] = TimestampFormat
query := url.Values{}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParameters builds and checks the parameters and return the result in a map object
func (s *SupplyRequest) GetParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
return params, nil
}
// GetParametersQuery converts the parameters from GetParameters into the url.Values format
func (s *SupplyRequest) GetParametersQuery() (url.Values, error) {
query := url.Values{}
params, err := s.GetParameters()
if err != nil {
return query, err
}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParametersJSON converts the parameters from GetParameters into the JSON format
func (s *SupplyRequest) GetParametersJSON() ([]byte, error) {
params, err := s.GetParameters()
if err != nil {
return nil, err
}
return json.Marshal(params)
}
// GetSlugParameters builds and checks the slug parameters and return the result in a map object
func (s *SupplyRequest) GetSlugParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
// check Metric field -> json key metric
Metric := s.Metric
// assign parameter of Metric
params["metric"] = Metric
return params, nil
}
func (s *SupplyRequest) applySlugsToUrl(url string, slugs map[string]string) string {
for k, v := range slugs {
needleRE := regexp.MustCompile(":" + k + "\\b")
url = needleRE.ReplaceAllString(url, v)
}
return url
}
func (s *SupplyRequest) GetSlugsMap() (map[string]string, error) {
slugs := map[string]string{}
params, err := s.GetSlugParameters()
if err != nil {
return slugs, nil
}
for k, v := range params {
slugs[k] = fmt.Sprintf("%v", v)
}
return slugs, nil
}
func (s *SupplyRequest) Do(ctx context.Context) (Response, error) {
// no body params
var params interface{}
query, err := s.GetQueryParameters()
if err != nil {
return nil, err
}
apiURL := "/v1/metrics/supply/:metric"
slugs, err := s.GetSlugsMap()
if err != nil {
return nil, err
}
apiURL = s.applySlugsToUrl(apiURL, slugs)
req, err := s.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params)
if err != nil {
return nil, err
}
response, err := s.Client.SendRequest(req)
if err != nil {
return nil, err
}
var apiResponse Response
if err := response.DecodeJSON(&apiResponse); err != nil {
return nil, err
}
return apiResponse, nil
}

17
pkg/datasource/glassnode/glassnodeapi/transactions.go
View File

@ -1,17 +0,0 @@
package glassnodeapi
import "github.com/c9s/requestgen"
//go:generate requestgen -method GET -type TransactionsRequest -url "/v1/metrics/transactions/:metric" -responseType Response
type TransactionsRequest struct {
Client requestgen.AuthenticatedAPIClient
Asset string `param:"a,required,query"`
Since int64 `param:"s,query"`
Until int64 `param:"u,query"`
Interval Interval `param:"i,query"`
Format Format `param:"f,query"`
TimestampFormat string `param:"timestamp_format,query"`
Metric string `param:"metric,slug"`
}

196
pkg/datasource/glassnode/glassnodeapi/transactions_request_requestgen.go
View File

@ -1,196 +0,0 @@
// Code generated by "requestgen -method GET -type TransactionsRequest -url /v1/metrics/transactions/:metric -responseType Response"; DO NOT EDIT.
package glassnodeapi
import (
"context"
"encoding/json"
"fmt"
"net/url"
"regexp"
)
func (t *TransactionsRequest) SetAsset(Asset string) *TransactionsRequest {
t.Asset = Asset
return t
}
func (t *TransactionsRequest) SetSince(Since int64) *TransactionsRequest {
t.Since = Since
return t
}
func (t *TransactionsRequest) SetUntil(Until int64) *TransactionsRequest {
t.Until = Until
return t
}
func (t *TransactionsRequest) SetInterval(Interval Interval) *TransactionsRequest {
t.Interval = Interval
return t
}
func (t *TransactionsRequest) SetFormat(Format Format) *TransactionsRequest {
t.Format = Format
return t
}
func (t *TransactionsRequest) SetTimestampFormat(TimestampFormat string) *TransactionsRequest {
t.TimestampFormat = TimestampFormat
return t
}
func (t *TransactionsRequest) SetMetric(Metric string) *TransactionsRequest {
t.Metric = Metric
return t
}
// GetQueryParameters builds and checks the query parameters and returns url.Values
func (t *TransactionsRequest) GetQueryParameters() (url.Values, error) {
var params = map[string]interface{}{}
// check Asset field -> json key a
Asset := t.Asset
// TEMPLATE check-required
if len(Asset) == 0 {
return nil, fmt.Errorf("a is required, empty string given")
}
// END TEMPLATE check-required
// assign parameter of Asset
params["a"] = Asset
// check Since field -> json key s
Since := t.Since
// assign parameter of Since
params["s"] = Since
// check Until field -> json key u
Until := t.Until
// assign parameter of Until
params["u"] = Until
// check Interval field -> json key i
Interval := t.Interval
// assign parameter of Interval
params["i"] = Interval
// check Format field -> json key f
Format := t.Format
// assign parameter of Format
params["f"] = Format
// check TimestampFormat field -> json key timestamp_format
TimestampFormat := t.TimestampFormat
// assign parameter of TimestampFormat
params["timestamp_format"] = TimestampFormat
query := url.Values{}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParameters builds and checks the parameters and return the result in a map object
func (t *TransactionsRequest) GetParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
return params, nil
}
// GetParametersQuery converts the parameters from GetParameters into the url.Values format
func (t *TransactionsRequest) GetParametersQuery() (url.Values, error) {
query := url.Values{}
params, err := t.GetParameters()
if err != nil {
return query, err
}
for k, v := range params {
query.Add(k, fmt.Sprintf("%v", v))
}
return query, nil
}
// GetParametersJSON converts the parameters from GetParameters into the JSON format
func (t *TransactionsRequest) GetParametersJSON() ([]byte, error) {
params, err := t.GetParameters()
if err != nil {
return nil, err
}
return json.Marshal(params)
}
// GetSlugParameters builds and checks the slug parameters and return the result in a map object
func (t *TransactionsRequest) GetSlugParameters() (map[string]interface{}, error) {
var params = map[string]interface{}{}
// check Metric field -> json key metric
Metric := t.Metric
// assign parameter of Metric
params["metric"] = Metric
return params, nil
}
func (t *TransactionsRequest) applySlugsToUrl(url string, slugs map[string]string) string {
for k, v := range slugs {
needleRE := regexp.MustCompile(":" + k + "\\b")
url = needleRE.ReplaceAllString(url, v)
}
return url
}
func (t *TransactionsRequest) GetSlugsMap() (map[string]string, error) {
slugs := map[string]string{}
params, err := t.GetSlugParameters()
if err != nil {
return slugs, nil
}
for k, v := range params {
slugs[k] = fmt.Sprintf("%v", v)
}
return slugs, nil
}
func (t *TransactionsRequest) Do(ctx context.Context) (Response, error) {
// no body params
var params interface{}
query, err := t.GetQueryParameters()
if err != nil {
return nil, err
}
apiURL := "/v1/metrics/transactions/:metric"
slugs, err := t.GetSlugsMap()
if err != nil {
return nil, err
}
apiURL = t.applySlugsToUrl(apiURL, slugs)
req, err := t.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params)
if err != nil {
return nil, err
}
response, err := t.Client.SendRequest(req)
if err != nil {
return nil, err
}
var apiResponse Response
if err := response.DecodeJSON(&apiResponse); err != nil {
return nil, err
}
return apiResponse, nil
}

20
pkg/datasource/glassnode/glassnodeapi/types.go
View File

@ -72,50 +72,50 @@ and
...
]
both can be stored into the Response structure.
both can be stored into the DataSlice structure.
Note: use `HasOptions` to verify the type of response.
*/
type Response []Data
type DataSlice []Data
type Data struct {
Timestamp Timestamp `json:"t"`
Value float64 `json:"v"`
Options map[string]float64 `json:"o"`
}
func (s Response) IsEmpty() bool {
func (s DataSlice) IsEmpty() bool {
return len(s) == 0
}
func (s Response) First() Data {
func (s DataSlice) First() Data {
if s.IsEmpty() {
return Data{}
}
return s[0]
}
func (s Response) FirstValue() float64 {
func (s DataSlice) FirstValue() float64 {
return s.First().Value
}
func (s Response) FirstOptions() map[string]float64 {
func (s DataSlice) FirstOptions() map[string]float64 {
return s.First().Options
}
func (s Response) Last() Data {
func (s DataSlice) Last() Data {
if s.IsEmpty() {
return Data{}
}
return s[len(s)-1]
}
func (s Response) LastValue() float64 {
func (s DataSlice) LastValue() float64 {
return s.Last().Value
}
func (s Response) LastOptions() map[string]float64 {
func (s DataSlice) LastOptions() map[string]float64 {
return s.Last().Options
}
func (s Response) HasOptions() bool {
func (s DataSlice) HasOptions() bool {
return len(s.First().Options) != 0
}

14
pkg/datasource/glassnode/types.go Normal file
View File

@ -0,0 +1,14 @@
package glassnode
import (
"time"
"github.com/c9s/bbgo/pkg/datasource/glassnode/glassnodeapi"
)
type QueryOptions struct {
Since *time.Time
Until *time.Time
Interval *glassnodeapi.Interval
Currency *string
}