ekzyis/snappy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: ekzyis:develop
Branches Tags
ekzyis:develop
ekzyis:v0.8.2
ekzyis:v0.8.1
ekzyis:v0.8.0
ekzyis:v0.7.0
ekzyis:v0.6.2
ekzyis:v0.6.1
ekzyis:v0.6.0
ekzyis:v0.5.4
ekzyis:v0.5.3
ekzyis:v0.5.2
ekzyis:v0.5.1
ekzyis:v0.5.1rc1
ekzyis:v0.5.0
ekzyis:v0.4.2
ekzyis:v0.4.1
ekzyis:v0.4.0
ekzyis:v0.3.3
ekzyis:v0.3.2
ekzyis:v0.3.1
ekzyis:v0.3.0
ekzyis:v0.2.0
ekzyis:v0.1.1
ekzyis:v0.1.0
..
compare: ekzyis:v0.4.0
Branches Tags
ekzyis:develop
ekzyis:v0.8.2
ekzyis:v0.8.1
ekzyis:v0.8.0
ekzyis:v0.7.0
ekzyis:v0.6.2
ekzyis:v0.6.1
ekzyis:v0.6.0
ekzyis:v0.5.4
ekzyis:v0.5.3
ekzyis:v0.5.2
ekzyis:v0.5.1
ekzyis:v0.5.1rc1
ekzyis:v0.5.0
ekzyis:v0.4.2
ekzyis:v0.4.1
ekzyis:v0.4.0
ekzyis:v0.3.3
ekzyis:v0.3.2
ekzyis:v0.3.1
ekzyis:v0.3.0
ekzyis:v0.2.0
ekzyis:v0.1.1
ekzyis:v0.1.0

No commits in common. "develop" and "v0.4.0" have entirely different histories.
develop ... v0.4.0

14 changed files with 134 additions and 817 deletions
Show Stats Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1 +0,0 @@
.env

9
README.md
View File

@ -1,11 +1,14 @@
# snappy # snappy
<p align="center"> <div style="text-align: center">
<img src="https://stacker.news/favicon.png" width="64" height="64" /> <img src="https://stacker.news/favicon.png" width="64" height="64" />
<img src="https://go.dev/blog/go-brand/Go-Logo/PNG/Go-Logo_Blue.png" width="64" height="64" /> <img src="https://go.dev/blog/go-brand/Go-Logo/PNG/Go-Logo_Blue.png" width="64" height="64" />
</p>
<p align="center">A Go client for the <a href="https://stacker.news" target="_blank">Stacker News</a> GraphQL API</p> [stacker.news](https://stacker.news) API client package for Go
</div>
## How to use ## How to use

128
client.go
View File

@ -1,128 +0,0 @@
package sn
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"net/http"
"os"
)
type Client struct {
BaseUrl string
ApiUrl string
ApiKey string
MediaUrl string
}
func NewClient(options ...func(*Client)) *Client {
c := &Client{}
for _, o := range options {
o(c)
}
// set defaults
var ok bool
if c.BaseUrl == "" {
c.BaseUrl, ok = os.LookupEnv("SN_BASE_URL")
if !ok {
c.BaseUrl = "https://stacker.news"
}
}
if c.ApiKey == "" {
c.ApiKey = os.Getenv("SN_API_KEY")
}
if c.MediaUrl == "" {
c.MediaUrl, ok = os.LookupEnv("SN_MEDIA_URL")
if !ok {
c.MediaUrl = "https://m.stacker.news"
}
}
c.ApiUrl = fmt.Sprintf("%s/api/graphql", c.BaseUrl)
return c
}
func WithApiKey(apiKey string) func(*Client) {
return func(c *Client) {
c.ApiKey = apiKey
}
}
func WithBaseUrl(baseUrl string) func(*Client) {
return func(c *Client) {
c.BaseUrl = baseUrl
}
}
func WithMediaUrl(mediaUrl string) func(*Client) {
return func(c *Client) {
c.MediaUrl = mediaUrl
}
}
type GqlBody struct {
Query string `json:"query"`
Variables map[string]interface{} `json:"variables,omitempty"`
}
type GqlError struct {
Message string `json:"message"`
}
func (c *Client) callApi(body GqlBody) (*http.Response, error) {
bodyJSON, err := json.Marshal(body)
if err != nil {
err = fmt.Errorf("error encoding SN payload: %w", err)
return nil, err
}
req, err := http.NewRequest("POST", c.ApiUrl, bytes.NewBuffer(bodyJSON))
if err != nil {
err = fmt.Errorf("error preparing SN request: %w", err)
return nil, err
}
req.Header.Set("Content-Type", "application/json")
if c.ApiKey != "" {
req.Header.Set("X-Api-Key", c.ApiKey)
}
client := http.DefaultClient
resp, err := client.Do(req)
if err != nil {
return nil, err
}
return resp, nil
}
func (c *Client) checkForErrors(err []GqlError) error {
if len(err) > 0 {
errMsg, marshalErr := json.Marshal(err)
if marshalErr != nil {
return marshalErr
}
return errors.New(string(errMsg))
}
return nil
}
func (c *Client) checkForPayInErrors(payIn PayIn) error {
privates := payIn.PayerPrivates
if privates.PayInFailureReason != "" {
return fmt.Errorf("mutation failed: %s", privates.PayInFailureReason)
}
bolt11 := privates.PayInBolt11
if bolt11.Id != 0 {
return fmt.Errorf("mutation failed: bolt11 payment required")
}
result := privates.Result
if result.Id == 0 {
return fmt.Errorf("mutation failed: no result id")
}
return nil
}

132
client_test.go
View File

@ -1,132 +0,0 @@
package sn_test
import (
"bufio"
"fmt"
"log"
"os"
"strings"
"testing"
sn "github.com/ekzyis/snappy"
)
var (
c = testClient()
)
func TestQueryItems(t *testing.T) {
var (
cursor *sn.ItemsCursor
err error
)
if cursor, err = c.Items(nil); err != nil {
t.Error(err)
return
}
if len(cursor.Items) == 0 {
t.Error("items cursor empty")
return
}
}
func TestMutationCreateComment(t *testing.T) {
var (
parentId = 349
text = "test comment"
err error
)
// TODO: return result, invoice, paymentMethod from CreateComment and run assertions on that
if _, err = c.CreateComment(parentId, text); err != nil {
t.Error(err)
return
}
}
func TestMutationPostDiscussion(t *testing.T) {
var (
title = "test discussion"
text = "test discussion text"
sub = "bitcoin"
err error
)
// TODO: return result, invoice, paymentMethod from CreateComment and run assertions on that
if _, err = c.PostDiscussion(title, text, sub); err != nil {
t.Error(err)
return
}
}
func TestMutationPostLink(t *testing.T) {
var (
url = "https://stacker.news"
title = "test discussion"
text = "test discussion text"
sub = "bitcoin"
err error
)
// TODO: return result, invoice, paymentMethod from CreateComment and run assertions on that
if _, err = c.PostLink(url, title, text, sub); err != nil {
t.Error(err)
return
}
}
func testClient() *sn.Client {
loadEnv()
baseUrl, set := os.LookupEnv("TEST_SN_BASE_URL")
if !set {
baseUrl = "http://localhost:3000"
}
log.Printf("baseUrl=%s\n", baseUrl)
apiKey, set := os.LookupEnv("TEST_SN_API_KEY")
if !set {
log.Fatalf("TEST_SN_API_KEY is not set")
}
log.Printf("apiKey=%s\n", apiKey)
return sn.NewClient(
sn.WithBaseUrl(baseUrl),
sn.WithApiKey(apiKey),
)
}
func loadEnv() {
var (
f *os.File
s *bufio.Scanner
err error
)
if f, err = os.Open(".env"); err != nil {
log.Fatalf("error opening .env: %v", err)
}
defer f.Close()
s = bufio.NewScanner(f)
s.Split(bufio.ScanLines)
for s.Scan() {
line := s.Text()
parts := strings.SplitN(line, "=", 2)
// Check if we have exactly 2 parts (key and value)
if len(parts) == 2 {
os.Setenv(parts[0], parts[1])
} else {
log.Fatalf(".env: invalid line: %s\n", line)
}
}
// Check for errors during scanning
if err = s.Err(); err != nil {
fmt.Println("error scanning .env:", err)
}
}

2
go.mod
View File

@ -1,5 +1,3 @@
module github.com/ekzyis/snappy module github.com/ekzyis/snappy
go 1.20 go 1.20
require gopkg.in/guregu/null.v4 v4.0.0 // indirect

2
go.sum
View File

@ -1,2 +0,0 @@
gopkg.in/guregu/null.v4 v4.0.0 h1:1Wm3S1WEA2I26Kq+6vcW+w0gcDo44YKYD7YIEJNHDjg=
gopkg.in/guregu/null.v4 v4.0.0/go.mod h1:YoQhUrADuG3i9WqesrCmpNRwm1ypAgSHYqoOcTu/JrI=

97
invoice.go
View File

@ -1,97 +0,0 @@
package sn
import (
"encoding/json"
"fmt"
"time"
)
type Invoice struct {
Id int `json:"id,string"`
Hash string `json:"hash"`
Hmac string `json:"hmac"`
Bolt11 string `json:"bolt11"`
SatsRequested int `json:"satsRequested"`
SatsReceived int `json:"satsReceived"`
Cancelled bool `json:"cancelled"`
ConfirmedAt time.Time `json:"createdAt"`
ExpiresAt time.Time `json:"expiresAt"`
Nostr map[string]interface{} `json:"nostr"`
IsHeld bool `json:"isHeld"`
Comment string `json:"comment"`
Lud18Data map[string]interface{} `json:"lud18Data"`
ConfirmedPreimage string `json:"confirmedPreimage"`
ActionState string `json:"actionState"`
ActionType string `json:"actionType"`
}
type PaymentMethod string
const (
PaymentMethodFeeCredits PaymentMethod = "FEE_CREDIT"
PaymentMethodOptimistic PaymentMethod = "OPTIMISTIC"
PaymentMethodPessimistic PaymentMethod = "PESSIMISTIC"
)
type CreateInvoiceArgs struct {
Amount int
ExpireSecs int
HodlInvoice bool
}
type CreateInvoiceResponse struct {
Errors []GqlError `json:"errors"`
Data struct {
CreateInvoice Invoice `json:"createInvoice"`
} `json:"data"`
}
func (c *Client) CreateInvoice(args *CreateInvoiceArgs) (*Invoice, error) {
if args == nil {
args = &CreateInvoiceArgs{}
}
body := GqlBody{
// TODO: add createdAt
// when I wrote this code, createdAt returned null but is non-nullable
// so I had to remove it.
Query: `
mutation createInvoice($amount: Int!, $expireSecs: Int, $hodlInvoice: Boolean) {
createInvoice(amount: $amount, expireSecs: $expireSecs, hodlInvoice: $hodlInvoice) {
id
hash
hmac
bolt11
satsRequested
satsReceived
isHeld
comment
confirmedPreimage
expiresAt
confirmedAt
}
}`,
Variables: map[string]interface{}{
"amount": args.Amount,
},
}
resp, err := c.callApi(body)
if err != nil {
return nil, err
}
defer resp.Body.Close()
var respBody CreateInvoiceResponse
err = json.NewDecoder(resp.Body).Decode(&respBody)
if err != nil {
err = fmt.Errorf("error decoding items: %w", err)
return nil, err
}
err = c.checkForErrors(respBody.Errors)
if err != nil {
return nil, err
}
return &respBody.Data.CreateInvoice, nil
}

125
notifications.go
View File

@ -1,125 +0,0 @@
package sn
import (
"encoding/json"
"fmt"
"time"
)
type Notification struct {
Id int `json:"id,string"`
Type string `json:"__typename"`
Item Item `json:"item"`
}
type NotificationsCursor struct {
LastChecked time.Time `json:"lastChecked"`
Cursor string `json:"cursor"`
Notifications []Notification `json:"notifications"`
}
type NotificationsResponse struct {
Errors []GqlError `json:"errors"`
Data struct {
Notifications NotificationsCursor `json:"notifications"`
} `json:"data"`
}
func (c *Client) Notifications() (*NotificationsCursor, error) {
body := GqlBody{
Query: `
fragment ItemFields on Item {
id
user {
id
name
}
parentId
createdAt
deletedAt
title
text
}
query notifications {
notifications {
lastChecked
cursor
notifications {
__typename
... on Reply {
id
item {
...ItemFields
}
}
... on Mention {
id
item {
...ItemFields
}
}
}
}
}
`,
Variables: map[string]interface{}{},
}
resp, err := c.callApi(body)
if err != nil {
return nil, err
}
defer resp.Body.Close()
var respBody NotificationsResponse
err = json.NewDecoder(resp.Body).Decode(&respBody)
if err != nil {
err = fmt.Errorf("error decoding notifications: %w", err)
return nil, err
}
err = c.checkForErrors(respBody.Errors)
if err != nil {
return nil, err
}
return &respBody.Data.Notifications, nil
}
func (c *Client) Mentions() ([]Notification, error) {
return c.filterNotifications(
func(n Notification) bool {
return n.Type == "Mention"
},
)
}
func (c *Client) Replies() ([]Notification, error) {
return c.filterNotifications(
func(n Notification) bool {
return n.Type == "Reply"
},
)
}
func (c *Client) filterNotifications(f func(Notification) bool) ([]Notification, error) {
var (
n *NotificationsCursor
err error
)
if n, err = c.Notifications(); err != nil {
return nil, err
}
return filter(n.Notifications, f), nil
}
func filter[T any](s []T, f func(T) bool) []T {
var r []T
for _, v := range s {
if f(v) {
r = append(r, v)
}
}
return r
}

82
pkg/client.go Normal file
View File

@ -0,0 +1,82 @@
package sn
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"net/http"
"os"
)
type ClientOptions struct {
BaseUrl string
ApiKey string
}
type Client struct {
BaseUrl string
ApiUrl string
ApiKey string
}
func NewClient(options *ClientOptions) *Client {
if options.BaseUrl == "" {
options.BaseUrl = "https://stacker.news"
}
if options.ApiKey == "" {
options.ApiKey = os.Getenv("SN_API_KEY")
}
return &Client{
BaseUrl: options.BaseUrl,
ApiUrl: fmt.Sprintf("%s/api/graphql", options.BaseUrl),
ApiKey: options.ApiKey,
}
}
type GqlBody struct {
Query string `json:"query"`
Variables map[string]interface{} `json:"variables,omitempty"`
}
type GqlError struct {
Message string `json:"message"`
}
func (c *Client) callApi(body GqlBody) (*http.Response, error) {
bodyJSON, err := json.Marshal(body)
if err != nil {
err = fmt.Errorf("error encoding SN payload: %w", err)
return nil, err
}
req, err := http.NewRequest("POST", c.ApiUrl, bytes.NewBuffer(bodyJSON))
if err != nil {
err = fmt.Errorf("error preparing SN request: %w", err)
return nil, err
}
req.Header.Set("Content-Type", "application/json")
if c.ApiKey != "" {
req.Header.Set("X-Api-Key", c.ApiKey)
}
client := http.DefaultClient
resp, err := client.Do(req)
if err != nil {
return nil, err
}
return resp, nil
}
func (c *Client) checkForErrors(err []GqlError) error {
if len(err) > 0 {
errMsg, marshalErr := json.Marshal(err)
if marshalErr != nil {
return marshalErr
}
return errors.New(string(errMsg))
}
return nil
}

179
items.go → pkg/items.go
View File

@ -4,19 +4,15 @@ import (
"encoding/json" "encoding/json"
"fmt" "fmt"
"time" "time"
"gopkg.in/guregu/null.v4"
) )
type Item struct { type Item struct {
Id int `json:"id,string"` Id int `json:"id,string"`
ParentId int `json:"parentId"` ParentId int `json:"parentId,string"`
Title string `json:"title"` Title string `json:"title"`
Url string `json:"url"` Url string `json:"url"`
Text string `json:"text"`
Sats int `json:"sats"` Sats int `json:"sats"`
CreatedAt time.Time `json:"createdAt"` CreatedAt time.Time `json:"createdAt"`
DeletedAt null.Time `json:"deletedAt"`
Comments []Comment `json:"comments"` Comments []Comment `json:"comments"`
NComments int `json:"ncomments"` NComments int `json:"ncomments"`
User User `json:"user"` User User `json:"user"`
@ -24,7 +20,7 @@ type Item struct {
type Comment struct { type Comment struct {
Id int `json:"id,string"` Id int `json:"id,string"`
ParentId int `json:"parentId"` ParentId int `json:"parentId,string"`
CreatedAt time.Time `json:"createdAt"` CreatedAt time.Time `json:"createdAt"`
Text string `json:"text"` Text string `json:"text"`
User User `json:"user"` User User `json:"user"`
@ -47,13 +43,6 @@ type ItemsCursor struct {
Cursor string `json:"cursor"` Cursor string `json:"cursor"`
} }
type ItemResponse struct {
Errors []GqlError `json:"errors"`
Data struct {
Item Item `json:"item"`
} `json:"data"`
}
type ItemsResponse struct { type ItemsResponse struct {
Errors []GqlError `json:"errors"` Errors []GqlError `json:"errors"`
Data struct { Data struct {
@ -61,37 +50,24 @@ type ItemsResponse struct {
} `json:"data"` } `json:"data"`
} }
type PayIn struct {
Id int `json:"id"`
PayerPrivates struct {
PayInFailureReason string `json:"payInFailureReason"`
PayInBolt11 struct {
Id int `json:"id"`
} `json:"payInBolt11"`
Result struct {
Id int `json:"id,string"`
} `json:"result"`
} `json:"payerPrivates"`
}
type UpsertDiscussionResponse struct { type UpsertDiscussionResponse struct {
Errors []GqlError `json:"errors"` Errors []GqlError `json:"errors"`
Data struct { Data struct {
UpsertDiscussion PayIn `json:"upsertDiscussion"` UpsertDiscussion Item `json:"upsertDiscussion"`
} `json:"data"` } `json:"data"`
} }
type UpsertLinkResponse struct { type UpsertLinkResponse struct {
Errors []GqlError `json:"errors"` Errors []GqlError `json:"errors"`
Data struct { Data struct {
UpsertLink PayIn `json:"upsertLink"` UpsertLink Item `json:"upsertLink"`
} `json:"data"` } `json:"data"`
} }
type UpsertCommentResponse struct { type CreateCommentsResponse struct {
Errors []GqlError `json:"errors"` Errors []GqlError `json:"errors"`
Data struct { Data struct {
UpsertComment PayIn `json:"upsertComment"` CreateComment Comment `json:"createComment"`
} `json:"data"` } `json:"data"`
} }
@ -117,55 +93,6 @@ type DupesError struct {
Dupes []Dupe Dupes []Dupe
} }
func (e *DupesError) Error() string {
return fmt.Sprintf("found %d dupes for %s", len(e.Dupes), e.Url)
}
func (c *Client) Item(id int) (*Item, error) {
body := GqlBody{
Query: `
query item($id: ID!) {
item(id: $id) {
id
parentId
title
url
text
sats
createdAt
deletedAt
ncomments
user {
id
name
}
}
}`,
Variables: map[string]interface{}{
"id": id,
},
}
resp, err := c.callApi(body)
if err != nil {
return nil, err
}
defer resp.Body.Close()
var respBody ItemResponse
err = json.NewDecoder(resp.Body).Decode(&respBody)
if err != nil {
err = fmt.Errorf("error decoding item: %w", err)
return nil, err
}
err = c.checkForErrors(respBody.Errors)
if err != nil {
return nil, err
}
return &respBody.Data.Item, nil
}
func (c *Client) Items(query *ItemsQuery) (*ItemsCursor, error) { func (c *Client) Items(query *ItemsQuery) (*ItemsCursor, error) {
if query == nil { if query == nil {
query = &ItemsQuery{} query = &ItemsQuery{}
@ -179,17 +106,42 @@ func (c *Client) Items(query *ItemsQuery) (*ItemsCursor, error) {
items { items {
id id
parentId parentId
title
url
text
sats
createdAt createdAt
deletedAt deletedAt
ncomments title
url
user { user {
id id
name name
} }
otsHash
position
sats
boost
bounty
bountyPaidTo
path
upvotes
meSats
meDontLikeSats
meBookmark
meSubscription
outlawed
freebie
ncomments
commentSats
lastCommentAt
maxBid
isJob
company
location
remote
subName
pollCost
status
uploadId
mine
position
}, },
} }
}`, }`,
@ -234,17 +186,6 @@ func (c *Client) PostDiscussion(title string, text string, sub string) (int, err
mutation upsertDiscussion($title: String!, $text: String, $sub: String) { mutation upsertDiscussion($title: String!, $text: String, $sub: String) {
upsertDiscussion(title: $title, text: $text, sub: $sub) { upsertDiscussion(title: $title, text: $text, sub: $sub) {
id id
payerPrivates {
payInFailureReason
payInBolt11 {
id
}
result {
... on Item {
id
}
}
}
} }
}`, }`,
Variables: map[string]interface{}{ Variables: map[string]interface{}{
@ -272,13 +213,7 @@ func (c *Client) PostDiscussion(title string, text string, sub string) (int, err
return -1, err return -1, err
} }
payIn := respBody.Data.UpsertDiscussion return respBody.Data.UpsertDiscussion.Id, nil
err = c.checkForPayInErrors(payIn)
if err != nil {
return -1, err
}
return payIn.PayerPrivates.Result.Id, nil
} }
func (c *Client) PostLink(url string, title string, text string, sub string) (int, error) { func (c *Client) PostLink(url string, title string, text string, sub string) (int, error) {
@ -287,17 +222,6 @@ func (c *Client) PostLink(url string, title string, text string, sub string) (in
mutation upsertLink($url: String!, $title: String!, $text: String, $sub: String!) { mutation upsertLink($url: String!, $title: String!, $text: String, $sub: String!) {
upsertLink(url: $url, title: $title, text: $text, sub: $sub) { upsertLink(url: $url, title: $title, text: $text, sub: $sub) {
id id
payerPrivates {
payInFailureReason
payInBolt11 {
id
}
result {
... on Item {
id
}
}
}
} }
}`, }`,
Variables: map[string]interface{}{ Variables: map[string]interface{}{
@ -326,13 +250,7 @@ func (c *Client) PostLink(url string, title string, text string, sub string) (in
return -1, err return -1, err
} }
payIn := respBody.Data.UpsertLink return respBody.Data.UpsertLink.Id, nil
err = c.checkForPayInErrors(payIn)
if err != nil {
return -1, err
}
return payIn.PayerPrivates.Result.Id, nil
} }
func (c *Client) CreateComment(parentId int, text string) (int, error) { func (c *Client) CreateComment(parentId int, text string) (int, error) {
@ -341,17 +259,6 @@ func (c *Client) CreateComment(parentId int, text string) (int, error) {
mutation upsertComment($parentId: ID!, $text: String!) { mutation upsertComment($parentId: ID!, $text: String!) {
upsertComment(parentId: $parentId, text: $text) { upsertComment(parentId: $parentId, text: $text) {
id id
payerPrivates {
payInFailureReason
payInBolt11 {
id
}
result {
... on Item {
id
}
}
}
} }
}`, }`,
Variables: map[string]interface{}{ Variables: map[string]interface{}{
@ -366,7 +273,7 @@ func (c *Client) CreateComment(parentId int, text string) (int, error) {
} }
defer resp.Body.Close() defer resp.Body.Close()
var respBody UpsertCommentResponse var respBody CreateCommentsResponse
err = json.NewDecoder(resp.Body).Decode(&respBody) err = json.NewDecoder(resp.Body).Decode(&respBody)
if err != nil { if err != nil {
err = fmt.Errorf("error decoding upsertComment: %w", err) err = fmt.Errorf("error decoding upsertComment: %w", err)
@ -378,13 +285,7 @@ func (c *Client) CreateComment(parentId int, text string) (int, error) {
return -1, err return -1, err
} }
payIn := respBody.Data.UpsertComment return respBody.Data.CreateComment.Id, nil
err = c.checkForPayInErrors(payIn)
if err != nil {
return -1, err
}
return payIn.PayerPrivates.Result.Id, nil
} }
func (c *Client) Dupes(url string) (*[]Dupe, error) { func (c *Client) Dupes(url string) (*[]Dupe, error) {

0
rss.go → pkg/rss.go
View File

6
pkg/user.go Normal file
View File

@ -0,0 +1,6 @@
package sn
type User struct {
Id int `json:"id,string"`
Name string `json:"name"`
}

131
upload.go
View File

@ -1,131 +0,0 @@
package sn
import (
"bytes"
"encoding/json"
"fmt"
"image"
"image/png"
"io"
"mime/multipart"
"net/http"
)
type GetSignedPOST struct {
Url string `json:"url"`
Fields map[string]string `json:"fields"`
}
type GetSignedPOSTResponse struct {
Errors []GqlError `json:"errors"`
Data struct {
GetSignedPOST GetSignedPOST `json:"getSignedPOST"`
} `json:"data"`
}
func (c *Client) UploadImage(img *image.RGBA) (string, error) {
var (
b = img.Bounds()
width = b.Dx()
height = b.Dy()
type_ = "image/png"
size int
)
var imgBuf bytes.Buffer
if err := png.Encode(&imgBuf, img); err != nil {
return "", err
}
size = imgBuf.Len()
// get signed URL for S3 upload
body := GqlBody{
Query: `
mutation getSignedPOST($type: String!, $size: Int!, $width: Int!, $height: Int!, $avatar: Boolean) {
getSignedPOST(type: $type, size: $size, width: $width, height: $height, avatar: $avatar) {
url
fields
}
}`,
Variables: map[string]interface{}{
"type": type_,
"size": size,
"width": width,
"height": height,
"avatar": false,
},
}
resp, err := c.callApi(body)
if err != nil {
return "", err
}
defer resp.Body.Close()
var respBody GetSignedPOSTResponse
err = json.NewDecoder(resp.Body).Decode(&respBody)
if err != nil {
err = fmt.Errorf("error decoding getSignedPOST: %w", err)
return "", err
}
err = c.checkForErrors(respBody.Errors)
if err != nil {
return "", err
}
s3Url := respBody.Data.GetSignedPOST.Url
fields := respBody.Data.GetSignedPOST.Fields
// create multipart form
var (
buf bytes.Buffer
w = multipart.NewWriter(&buf)
fw io.Writer
)
for k, v := range fields {
if fw, err = w.CreateFormField(k); err != nil {
return "", err
}
fw.Write([]byte(v))
}
for k, v := range map[string]string{
"Content-Type": type_,
"Cache-Control": "max-age=31536000",
"acl": "public-read",
} {
if fw, err = w.CreateFormField(k); err != nil {
return "", err
}
fw.Write([]byte(v))
}
if fw, err = w.CreateFormFile("file", "image.png"); err != nil {
return "", err
}
fw.Write(imgBuf.Bytes())
if err = w.Close(); err != nil {
return "", err
}
// upload to S3
var req *http.Request
if req, err = http.NewRequest("POST", s3Url, &buf); err != nil {
return "", err
}
req.Header.Set("Content-Type", w.FormDataContentType())
client := http.DefaultClient
if resp, err = client.Do(req); err != nil {
return "", err
}
defer resp.Body.Close()
imgId := respBody.Data.GetSignedPOST.Fields["key"]
imgUrl := fmt.Sprintf("%s/%s", c.MediaUrl, imgId)
return imgUrl, nil
}

57
user.go
View File

@ -1,57 +0,0 @@
package sn
import (
"encoding/json"
"fmt"
)
type User struct {
Id int `json:"id,string"`
Name string `json:"name"`
Privates UserPrivates `json:"privates"`
}
type UserPrivates struct {
Sats int `json:"sats"`
}
type MeResponse struct {
Errors []GqlError `json:"errors"`
Data struct {
Me User `json:"me"`
} `json:"data"`
}
func (c *Client) Me() (*User, error) {
body := GqlBody{
Query: `
query me {
me {
id
name
privates {
sats
}
}
}`,
}
resp, err := c.callApi(body)
if err != nil {
return nil, err
}
defer resp.Body.Close()
var respBody MeResponse
err = json.NewDecoder(resp.Body).Decode(&respBody)
if err != nil {
err = fmt.Errorf("error decoding me: %w", err)
return nil, err
}
err = c.checkForErrors(respBody.Errors)
if err != nil {
return nil, err
}
return &respBody.Data.Me, nil
}