package max //go:generate -command GetRequest requestgen -method GET //go:generate -command PostRequest requestgen -method POST import ( "encoding/json" "fmt" "strings" "github.com/c9s/requestgen" "github.com/c9s/bbgo/pkg/fixedpoint" "github.com/c9s/bbgo/pkg/types" ) type RewardType string const ( RewardAirdrop = RewardType("airdrop_reward") RewardCommission = RewardType("commission") RewardHolding = RewardType("holding_reward") RewardMining = RewardType("mining_reward") RewardTrading = RewardType("trading_reward") RewardRedemption = RewardType("redemption_reward") RewardVipRebate = RewardType("vip_rebate") ) func ParseRewardType(s string) (RewardType, error) { switch s { case "airdrop_reward": return RewardAirdrop, nil case "commission": return RewardCommission, nil case "holding_reward": return RewardHolding, nil case "mining_reward": return RewardMining, nil case "trading_reward": return RewardTrading, nil case "vip_rebate": return RewardVipRebate, nil case "redemption_reward": return RewardRedemption, nil } return RewardType(""), fmt.Errorf("unknown reward type: %s", s) } func (t *RewardType) UnmarshalJSON(o []byte) error { var s string var err = json.Unmarshal(o, &s) if err != nil { return err } rt, err := ParseRewardType(s) if err != nil { return err } *t = rt return nil } func (t RewardType) RewardType() (types.RewardType, error) { switch t { case RewardAirdrop: return types.RewardAirdrop, nil case RewardCommission: return types.RewardCommission, nil case RewardHolding: return types.RewardHolding, nil case RewardMining: return types.RewardMining, nil case RewardTrading: return types.RewardTrading, nil case RewardVipRebate: return types.RewardVipRebate, nil } return types.RewardType(""), fmt.Errorf("unknown reward type: %s", t) } type Reward struct { // UUID here is more like SN, not the real UUID UUID string `json:"uuid"` Type RewardType `json:"type"` Currency string `json:"currency"` Amount fixedpoint.Value `json:"amount"` State string `json:"state"` Note string `json:"note"` // Unix timestamp in seconds CreatedAt types.Timestamp `json:"created_at"` } func (reward Reward) Reward() (*types.Reward, error) { rt, err := reward.Type.RewardType() if err != nil { return nil, err } return &types.Reward{ UUID: reward.UUID, Exchange: types.ExchangeMax, Type: rt, Currency: strings.ToUpper(reward.Currency), Quantity: reward.Amount, State: reward.State, Note: reward.Note, Spent: false, CreatedAt: types.Time(reward.CreatedAt), }, nil } type RewardService struct { client requestgen.AuthenticatedAPIClient } func (s *RewardService) NewGetRewardsRequest() *GetRewardsRequest { return &GetRewardsRequest{client: s.client} } func (s *RewardService) NewGetRewardsOfTypeRequest(pathType RewardType) *GetRewardsOfTypeRequest { return &GetRewardsOfTypeRequest{client: s.client, pathType: &pathType} } //go:generate GetRequest -url "v2/rewards/:path_type" -type GetRewardsOfTypeRequest -responseType []Reward type GetRewardsOfTypeRequest struct { client requestgen.AuthenticatedAPIClient pathType *RewardType `param:"path_type,slug"` // From Unix-timestamp from *int64 `param:"from"` // To Unix-timestamp to *int64 `param:"to"` page *int64 `param:"page"` limit *int64 `param:"limit"` offset *int64 `param:"offset"` } //go:generate GetRequest -url "v2/rewards" -type GetRewardsRequest -responseType []Reward type GetRewardsRequest struct { client requestgen.AuthenticatedAPIClient currency *string `param:"currency"` // From Unix-timestamp from *int64 `param:"from"` // To Unix-timestamp to *int64 `param:"to"` page *int64 `param:"page"` limit *int64 `param:"limit"` offset *int64 `param:"offset"` }