Updated JSON tags to omit if empty

Fixed AddMember response parsing
added bot post message example

bots_api.go

@@ -1,10 +1,10 @@
 package groupme
 
 import (
-	"errors"
+	"bytes"
+	"encoding/json"
 	"fmt"
 	"net/http"
-	"net/url"
 )
 
 // GroupMe documentation: https://dev.groupme.com/docs/v3#bots
@@ -37,20 +37,24 @@ Parameters:
 	GroupID - required
 */
 func (c *Client) CreateBot(bot *Bot) (*Bot, error) {
-	httpReq, err := http.NewRequest("POST", c.endpointBase+createBotEndpoint, nil)
+	URL := c.endpointBase + createBotEndpoint
+
+	var data = struct {
+		Bot *Bot `json:"bot,omitempty"`
+	}{
+		bot,
+	}
+
+	jsonBytes, err := json.Marshal(&data)
 	if err != nil {
 		return nil, err
 	}
 
-	if bot == nil {
-		return nil, errors.New("bot cannot be nil")
+	httpReq, err := http.NewRequest("POST", URL, bytes.NewBuffer(jsonBytes))
+	if err != nil {
+		return nil, err
 	}
 
-	data := url.Values{}
-	data.Add("bot", bot.String())
-
-	httpReq.PostForm = data
-
 	var resp Bot
 	err = c.doWithAuthToken(httpReq, &resp)
 	if err != nil {
@@ -77,20 +81,26 @@ Parameters:
 func (c *Client) PostBotMessage(botID ID, text string, pictureURL *string) error {
 	URL := fmt.Sprintf(c.endpointBase + postBotMessageEndpoint)
 
-	httpReq, err := http.NewRequest("POST", URL, nil)
+	var data = struct {
+		BotID      ID      `json:"bot_id"`
+		Text       string  `json:"text"`
+		PictureURL *string `json:",omitempty"`
+	}{
+		botID,
+		text,
+		pictureURL,
+	}
+
+	jsonBytes, err := json.Marshal(&data)
 	if err != nil {
 		return err
 	}
 
-	data := url.Values{}
-	data.Add("bot_id", string(botID))
-	data.Add("text", text)
-	if pictureURL != nil {
-		data.Add("picture_url", *pictureURL)
+	httpReq, err := http.NewRequest("POST", URL, bytes.NewBuffer(jsonBytes))
+	if err != nil {
+		return err
 	}
 
-	httpReq.PostForm = data
-
 	return c.do(httpReq, nil)
 }
 
@@ -129,15 +139,21 @@ Parameters:
 func (c *Client) DestroyBot(botID ID) error {
 	URL := fmt.Sprintf(c.endpointBase + destroyBotEndpoint)
 
-	httpReq, err := http.NewRequest("POST", URL, nil)
+	var data = struct {
+		BotID ID `json:"bot_id"`
+	}{
+		botID,
+	}
+
+	jsonBytes, err := json.Marshal(&data)
 	if err != nil {
 		return err
 	}
 
-	data := url.Values{}
-	data.Add("bot_id", string(botID))
-
-	httpReq.PostForm = data
+	httpReq, err := http.NewRequest("POST", URL, bytes.NewBuffer(jsonBytes))
+	if err != nil {
+		return err
+	}
 
 	return c.doWithAuthToken(httpReq, nil)
 }

client.go

@@ -3,7 +3,7 @@ package groupme
 import (
 	"bytes"
 	"encoding/json"
-	"errors"
+	"fmt"
 	"io/ioutil"
 	"net/http"
 )
@@ -23,7 +23,8 @@ type Client struct {
 // NewClient creates a new GroupMe API Client
 func NewClient(authToken string) *Client {
 	return &Client{
-		httpClient:         new(http.Client),
+		// TODO: enable transport information passing in
+		httpClient:         &http.Client{},
 		endpointBase:       GroupMeAPIBase,
 		authorizationToken: authToken,
 	}
@@ -59,19 +60,24 @@ func (r response) UnmarshalJSON(bs []byte) error {
 }
 
 func (c Client) do(req *http.Request, i interface{}) error {
+	if req.Method == "POST" {
+		req.Header.Set("Content-Type", "application/json")
+	}
+
 	getResp, err := c.httpClient.Do(req)
 	if err != nil {
 		return err
 	}
+	defer getResp.Body.Close()
+
+	bytes, err := ioutil.ReadAll(getResp.Body)
+	if err != nil {
+		return err
+	}
 
 	// Check Status Code is 1XX or 2XX
 	if getResp.StatusCode/100 > 2 {
-		return errors.New(getResp.Status)
-	}
-
-	bytes, err := ioutil.ReadAll(getResp.Body)
-	if err != nil {
-		return err
+		return fmt.Errorf("%s: %s", getResp.Status, string(bytes))
 	}
 
 	if i == nil {

client_test.go

@@ -30,6 +30,14 @@ func (s *ClientSuite) TestClient_Close() {
 	s.Assert().NoError(s.client.Close())
 }
 
+func (s *ClientSuite) TestClient_do_PostContentType() {
+	req, err := http.NewRequest("POST", "", nil)
+	s.Require().NoError(err)
+
+	s.Assert().Error(s.client.do(req, struct{}{}))
+	s.Assert().EqualValues(req.Header.Get("Content-Type"), "application/json")
+}
+
 func (s *ClientSuite) TestClient_do_DoError() {
 	req, err := http.NewRequest("", "", nil)
 	s.Require().NoError(err)

direct_messages_api.go

@@ -1,9 +1,10 @@
 package groupme
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
 	"net/http"
-	"net/url"
 
 	"github.com/google/uuid"
 )
@@ -121,17 +122,23 @@ Parameters:
 */
 func (c *Client) CreateDirectMessage(m *Message) (*Message, error) {
 	URL := fmt.Sprintf(c.endpointBase + createDirectMessageEndpoint)
-	httpReq, err := http.NewRequest("POST", URL, nil)
+
+	m.SourceGUID = uuid.New().String()
+	var data = struct {
+		DirectMessage *Message `json:"direct_message,omitempty"`
+	}{
+		m,
+	}
+
+	jsonBytes, err := json.Marshal(&data)
 	if err != nil {
 		return nil, err
 	}
 
-	m.SourceGUID = uuid.New().String()
-
-	data := url.Values{}
-	data.Set("direct_message", m.String())
-
-	httpReq.PostForm = data
+	httpReq, err := http.NewRequest("POST", URL, bytes.NewBuffer(jsonBytes))
+	if err != nil {
+		return nil, err
+	}
 
 	var resp struct {
 		*Message `json:"message"`

examples/post_bot_message/main.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/densestvoid/groupme"
+)
+
+// This is not a real Bot ID. Please find yours by logging
+// into the GroupMe development website: https://dev.groupme.com/bots
+const botID = "0123456789ABCDEF"
+
+// A short program that gets the gets the first 5 groups
+// the user is part of, and then the first 10 messages of
+// the first group in that list
+func main() {
+	// Create a new client with your auth token
+	client := groupme.NewClient("")
+	fmt.Println(client.PostBotMessage(botID, "Your message here!", nil))
+}

groups_api.go

@@ -1,10 +1,11 @@
 package groupme
 
 import (
+	"bytes"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"net/http"
-	"net/url"
 	"strconv"
 )
 
@@ -172,27 +173,17 @@ Create a new group
 Parameters: See GroupSettings
 */
 func (c *Client) CreateGroup(gs GroupSettings) (*Group, error) {
-	httpReq, err := http.NewRequest("POST", c.endpointBase+createGroupEndpoint, nil)
+	URL := fmt.Sprintf(c.endpointBase + createGroupEndpoint)
+
+	jsonBytes, err := json.Marshal(&gs)
 	if err != nil {
 		return nil, err
 	}
 
-	data := url.Values{}
-	if gs.Name == "" {
-		return nil, fmt.Errorf("GroupsCreateRequest Name field is required")
+	httpReq, err := http.NewRequest("POST", URL, bytes.NewBuffer(jsonBytes))
+	if err != nil {
+		return nil, err
 	}
-	data.Set("name", gs.Name)
-
-	if gs.Description != "" {
-		data.Set("description", gs.Description)
-	}
-	if gs.ImageURL != "" {
-		data.Set("image_url", gs.ImageURL)
-	}
-	if gs.Share {
-		data.Set("share", "true")
-	}
-	httpReq.PostForm = data
 
 	var resp Group
 	err = c.doWithAuthToken(httpReq, &resp)
@@ -217,28 +208,15 @@ Parameters:
 func (c *Client) UpdateGroup(groupID ID, gs GroupSettings) (*Group, error) {
 	URL := fmt.Sprintf(c.endpointBase+updateGroupEndpoint, groupID)
 
-	httpReq, err := http.NewRequest("POST", URL, nil)
+	jsonBytes, err := json.Marshal(&gs)
 	if err != nil {
 		return nil, err
 	}
 
-	data := url.Values{}
-	if gs.Name != "" {
-		data.Set("name", gs.Name)
+	httpReq, err := http.NewRequest("POST", URL, bytes.NewBuffer(jsonBytes))
+	if err != nil {
+		return nil, err
 	}
-	if gs.Description != "" {
-		data.Set("description", gs.Description)
-	}
-	if gs.ImageURL != "" {
-		data.Set("image_url", gs.ImageURL)
-	}
-	if gs.OfficeMode {
-		data.Set("office_mode", "true")
-	}
-	if gs.Share {
-		data.Set("share", "true")
-	}
-	httpReq.PostForm = data
 
 	var resp Group
 	err = c.doWithAuthToken(httpReq, &resp)
@@ -311,14 +289,23 @@ Parameters:
 	groupID - required, ID(string)
 */
 func (c *Client) RejoinGroup(groupID ID) (*Group, error) {
-	httpReq, err := http.NewRequest("POST", c.endpointBase+rejoinGroupEndpoint, nil)
+	URL := fmt.Sprintf(c.endpointBase + rejoinGroupEndpoint)
+
+	var data = struct {
+		GroupID ID `json:"group_id"`
+	}{
+		groupID,
+	}
+
+	jsonBytes, err := json.Marshal(&data)
 	if err != nil {
 		return nil, err
 	}
 
-	data := url.Values{}
-	data.Set("group_id", string(groupID))
-	httpReq.PostForm = data
+	httpReq, err := http.NewRequest("POST", URL, bytes.NewBuffer(jsonBytes))
+	if err != nil {
+		return nil, err
+	}
 
 	var resp Group
 	err = c.doWithAuthToken(httpReq, &resp)
@@ -344,14 +331,23 @@ the result of change owner action for the request
 Parameters: See ChangeOwnerRequest
 */
 func (c *Client) ChangeGroupOwner(reqs ChangeOwnerRequest) (ChangeOwnerResult, error) {
-	httpReq, err := http.NewRequest("POST", c.endpointBase+changeGroupOwnerEndpoint, nil)
+	URL := fmt.Sprintf(c.endpointBase + changeGroupOwnerEndpoint)
+
+	var data = struct {
+		Requests []ChangeOwnerRequest `json:"requests"`
+	}{
+		[]ChangeOwnerRequest{reqs},
+	}
+
+	jsonBytes, err := json.Marshal(&data)
 	if err != nil {
 		return ChangeOwnerResult{}, err
 	}
 
-	data := url.Values{}
-	data.Set("requests", marshal([]ChangeOwnerRequest{reqs}))
-	httpReq.PostForm = data
+	httpReq, err := http.NewRequest("POST", URL, bytes.NewBuffer(jsonBytes))
+	if err != nil {
+		return ChangeOwnerResult{}, err
+	}
 
 	var resp struct {
 		Results []ChangeOwnerResult `json:"results"`

groups_api_test.go

@@ -56,14 +56,6 @@ func (s *GroupsAPISuite) TestGroupsCreate() {
 	s.Assert().NotZero(group)
 }
 
-func (s *GroupsAPISuite) TestGroupsCreate_EmptyName() {
-	group, err := s.client.CreateGroup(GroupSettings{
-		Name: "",
-	})
-	s.Require().Error(err)
-	s.Assert().Zero(group)
-}
-
 func (s *GroupsAPISuite) TestGroupsUpdate() {
 	group, err := s.client.UpdateGroup("1", GroupSettings{
 		"Test",

json.go

@@ -8,8 +8,8 @@ import (
 // Meta is the error type returned in the GroupMe response.
 // Meant for clients that can't read HTTP status codes
 type Meta struct {
-	Code   HTTPStatusCode `json:"code"`
-	Errors []string       `json:"errors"`
+	Code   HTTPStatusCode `json:"code,omitempty"`
+	Errors []string       `json:"errors,omitempty"`
 }
 
 // Error returns the code and the error list as a string.
@@ -20,35 +20,35 @@ func (m Meta) Error() string {
 
 // Group is a GroupMe group, returned in JSON API responses
 type Group struct {
-	ID   ID     `json:"id"`
-	Name string `json:"name"`
+	ID   ID     `json:"id,omitempty"`
+	Name string `json:"name,omitempty"`
 	// Type of group (private|public)
-	Type          string        `json:"type"`
-	Description   string        `json:"description"`
-	ImageURL      string        `json:"image_url"`
-	CreatorUserID ID            `json:"creator_user_id"`
-	CreatedAt     Timestamp     `json:"created_at"`
-	UpdatedAt     Timestamp     `json:"updated_at"`
-	Members       []*Member     `json:"members"`
-	ShareURL      string        `json:"share_url"`
-	Messages      GroupMessages `json:"messages"`
+	Type          string        `json:"type,omitempty"`
+	Description   string        `json:"description,omitempty"`
+	ImageURL      string        `json:"image_url,omitempty"`
+	CreatorUserID ID            `json:"creator_user_id,omitempty"`
+	CreatedAt     Timestamp     `json:"created_at,omitempty"`
+	UpdatedAt     Timestamp     `json:"updated_at,omitempty"`
+	Members       []*Member     `json:"members,omitempty"`
+	ShareURL      string        `json:"share_url,omitempty"`
+	Messages      GroupMessages `json:"messages,omitempty"`
 }
 
 // GroupMessages is a Group field, only returned in Group JSON API responses
 type GroupMessages struct {
-	Count                uint           `json:"count"`
-	LastMessageID        ID             `json:"last_message_id"`
-	LastMessageCreatedAt Timestamp      `json:"last_message_created_at"`
-	Preview              MessagePreview `json:"preview"`
+	Count                uint           `json:"count,omitempty"`
+	LastMessageID        ID             `json:"last_message_id,omitempty"`
+	LastMessageCreatedAt Timestamp      `json:"last_message_created_at,omitempty"`
+	Preview              MessagePreview `json:"preview,omitempty"`
 }
 
 // MessagePreview is a GroupMessages field, only returned in Group JSON API responses.
 // Abbreviated form of Message type
 type MessagePreview struct {
-	Nickname    string        `json:"nickname"`
-	Text        string        `json:"text"`
-	ImageURL    string        `json:"image_url"`
-	Attachments []*Attachment `json:"attachments"`
+	Nickname    string        `json:"nickname,omitempty"`
+	Text        string        `json:"text,omitempty"`
+	ImageURL    string        `json:"image_url,omitempty"`
+	Attachments []*Attachment `json:"attachments,omitempty"`
 }
 
 // GetMemberByUserID gets the group member by their UserID,
@@ -81,14 +81,14 @@ func (g Group) String() string {
 
 // Member is a GroupMe group member, returned in JSON API responses
 type Member struct {
-	ID           ID     `json:"id"`
-	UserID       ID     `json:"user_id"`
-	Nickname     string `json:"nickname"`
-	Muted        bool   `json:"muted"`
-	ImageURL     string `json:"image_url"`
-	AutoKicked   bool   `json:"autokicked"`
-	AppInstalled bool   `json:"app_installed"`
-	GUID         string `json:"guid"`
+	ID           ID     `json:"id,omitempty"`
+	UserID       ID     `json:"user_id,omitempty"`
+	Nickname     string `json:"nickname,omitempty"`
+	Muted        bool   `json:"muted,omitempty"`
+	ImageURL     string `json:"image_url,omitempty"`
+	AutoKicked   bool   `json:"autokicked,omitempty"`
+	AppInstalled bool   `json:"app_installed,omitempty"`
+	GUID         string `json:"guid,omitempty"`
 }
 
 func (m Member) String() string {
@@ -97,25 +97,25 @@ func (m Member) String() string {
 
 // Message is a GroupMe group message, returned in JSON API responses
 type Message struct {
-	ID             ID         `json:"id"`
-	SourceGUID     string     `json:"source_guid"`
-	CreatedAt      Timestamp  `json:"created_at"`
-	GroupID        ID         `json:"group_id"`
-	UserID         ID         `json:"user_id"`
-	BotID          ID         `json:"bot_id"`
-	SenderID       ID         `json:"sender_id"`
-	SenderType     SenderType `json:"sender_type"`
-	System         bool       `json:"system"`
-	Name           string     `json:"name"`
-	RecipientID    ID         `json:"recipient_id"`
-	ConversationID ID         `json:"conversation_id"`
-	AvatarURL      string     `json:"avatar_url"`
+	ID             ID         `json:"id,omitempty"`
+	SourceGUID     string     `json:"source_guid,omitempty"`
+	CreatedAt      Timestamp  `json:"created_at,omitempty"`
+	GroupID        ID         `json:"group_id,omitempty"`
+	UserID         ID         `json:"user_id,omitempty"`
+	BotID          ID         `json:"bot_id,omitempty"`
+	SenderID       ID         `json:"sender_id,omitempty"`
+	SenderType     SenderType `json:"sender_type,omitempty"`
+	System         bool       `json:"system,omitempty"`
+	Name           string     `json:"name,omitempty"`
+	RecipientID    ID         `json:"recipient_id,omitempty"`
+	ConversationID ID         `json:"conversation_id,omitempty"`
+	AvatarURL      string     `json:"avatar_url,omitempty"`
 	// Maximum length of 1000 characters
-	Text string `json:"text"`
+	Text string `json:"text,omitempty"`
 	// Must be an image service URL (i.groupme.com)
-	ImageURL    string        `json:"image_url"`
-	FavoritedBy []string      `json:"favorited_by"`
-	Attachments []*Attachment `json:"attachments"`
+	ImageURL    string        `json:"image_url,omitempty"`
+	FavoritedBy []string      `json:"favorited_by,omitempty"`
+	Attachments []*Attachment `json:"attachments,omitempty"`
 }
 
 func (m Message) String() string {
@@ -143,15 +143,15 @@ const (
 
 // Attachment is a GroupMe message attachment, returned in JSON API responses
 type Attachment struct {
-	Type        AttachmentType `json:"type"`
-	Loci        [][]int        `json:"loci"`
-	UserIDs     []ID           `json:"user_ids"`
-	URL         string         `json:"url"`
-	Name        string         `json:"name"`
-	Latitude    string         `json:"lat"`
-	Longitude   string         `json:"lng"`
-	Placeholder string         `json:"placeholder"`
-	Charmap     [][]int        `json:"charmap"`
+	Type        AttachmentType `json:"type,omitempty"`
+	Loci        [][]int        `json:"loci,omitempty"`
+	UserIDs     []ID           `json:"user_ids,omitempty"`
+	URL         string         `json:"url,omitempty"`
+	Name        string         `json:"name,omitempty"`
+	Latitude    string         `json:"lat,omitempty"`
+	Longitude   string         `json:"lng,omitempty"`
+	Placeholder string         `json:"placeholder,omitempty"`
+	Charmap     [][]int        `json:"charmap,omitempty"`
 }
 
 func (a Attachment) String() string {
@@ -160,15 +160,15 @@ func (a Attachment) String() string {
 
 // User is a GroupMe user, returned in JSON API responses
 type User struct {
-	ID          ID          `json:"id"`
-	PhoneNumber PhoneNumber `json:"phone_number"`
-	ImageURL    string      `json:"image_url"`
-	Name        string      `json:"name"`
-	CreatedAt   Timestamp   `json:"created_at"`
-	UpdatedAt   Timestamp   `json:"updated_at"`
-	AvatarURL   string      `json:"avatar_url"`
-	Email       string      `json:"email"`
-	SMS         bool        `json:"sms"`
+	ID          ID          `json:"id,omitempty"`
+	PhoneNumber PhoneNumber `json:"phone_number,omitempty"`
+	ImageURL    string      `json:"image_url,omitempty"`
+	Name        string      `json:"name,omitempty"`
+	CreatedAt   Timestamp   `json:"created_at,omitempty"`
+	UpdatedAt   Timestamp   `json:"updated_at,omitempty"`
+	AvatarURL   string      `json:"avatar_url,omitempty"`
+	Email       string      `json:"email,omitempty"`
+	SMS         bool        `json:"sms,omitempty"`
 }
 
 func (u User) String() string {
@@ -178,11 +178,11 @@ func (u User) String() string {
 // Chat is a GroupMe direct message conversation between two users,
 // returned in JSON API responses
 type Chat struct {
-	CreatedAt     Timestamp `json:"created_at"`
-	UpdatedAt     Timestamp `json:"updated_at"`
-	LastMessage   *Message  `json:"last_message"`
-	MessagesCount int       `json:"messages_count"`
-	OtherUser     User      `json:"other_user"`
+	CreatedAt     Timestamp `json:"created_at,omitempty"`
+	UpdatedAt     Timestamp `json:"updated_at,omitempty"`
+	LastMessage   *Message  `json:"last_message,omitempty"`
+	MessagesCount int       `json:"messages_count,omitempty"`
+	OtherUser     User      `json:"other_user,omitempty"`
 }
 
 func (c Chat) String() string {
@@ -190,12 +190,12 @@ func (c Chat) String() string {
 }
 
 type Bot struct {
-	BotID          ID     `json:"bot_id"`
-	GroupID        ID     `json:"group_id"`
-	Name           string `json:"name"`
-	AvatarURL      string `json:"avatar_url"`
-	CallbackURL    string `json:"callback_url"`
-	DMNotification bool   `json:"dm_notification"`
+	BotID          ID     `json:"bot_id,omitempty"`
+	GroupID        ID     `json:"group_id,omitempty"`
+	Name           string `json:"name,omitempty"`
+	AvatarURL      string `json:"avatar_url,omitempty"`
+	CallbackURL    string `json:"callback_url,omitempty"`
+	DMNotification bool   `json:"dm_notification,omitempty"`
 }
 
 func (b Bot) String() string {
@@ -203,9 +203,9 @@ func (b Bot) String() string {
 }
 
 type Block struct {
-	UserID        ID        `json:"user_id"`
-	BlockedUserID ID        `json:"blocked_user_id"`
-	CreatedAT     Timestamp `json:"created_at"`
+	UserID        ID        `json:"user_id,omitempty"`
+	BlockedUserID ID        `json:"blocked_user_id,omitempty"`
+	CreatedAT     Timestamp `json:"created_at,omitempty"`
 }
 
 func (b Block) String() string {

members_api.go

@@ -1,10 +1,10 @@
 package groupme
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"net/http"
-	"net/url"
 )
 
 // GroupMe documentation: https://dev.groupme.com/docs/v3#members
@@ -49,21 +49,24 @@ Parameters:
 func (c *Client) AddMembers(groupID ID, members ...*Member) (string, error) {
 	URL := fmt.Sprintf(c.endpointBase+addMembersEndpoint, groupID)
 
-	httpReq, err := http.NewRequest("POST", URL, nil)
+	var data = struct {
+		Members []*Member `json:"members"`
+	}{
+		members,
+	}
+
+	jsonBytes, err := json.Marshal(&data)
 	if err != nil {
 		return "", err
 	}
 
-	data := url.Values{}
-	bytes, err := json.Marshal(members)
+	httpReq, err := http.NewRequest("POST", URL, bytes.NewBuffer(jsonBytes))
 	if err != nil {
 		return "", err
 	}
-	data.Set("members", string(bytes))
-	httpReq.PostForm = data
 
 	var resp struct {
-		ResultsID string `json:"result_id"`
+		ResultsID string `json:"results_id"`
 	}
 
 	err = c.doWithAuthToken(httpReq, &resp)
@@ -147,21 +150,24 @@ between 1 and 50 characters.
 func (c *Client) UpdateMember(groupID ID, nickname string) (*Member, error) {
 	URL := fmt.Sprintf(c.endpointBase+updateMemberEndpoint, groupID)
 
-	httpReq, err := http.NewRequest("POST", URL, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	type membership struct {
+	type Nickname struct {
 		Nickname string `json:"nickname"`
 	}
+	var data = struct {
+		Membership Nickname `json:"membership"`
+	}{
+		Nickname{nickname},
+	}
 
-	data := url.Values{}
-	bytes, err := json.Marshal(membership{nickname})
+	jsonBytes, err := json.Marshal(&data)
+	if err != nil {
+		return nil, err
+	}
+
+	httpReq, err := http.NewRequest("POST", URL, bytes.NewBuffer(jsonBytes))
 	if err != nil {
 		return nil, err
 	}
-	data.Add("membership", string(bytes))
 
 	var resp Member
 

messages_api.go

@@ -1,9 +1,10 @@
 package groupme
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
 	"net/http"
-	"net/url"
 	"strconv"
 
 	"github.com/google/uuid"
@@ -150,17 +151,23 @@ Parameters:
 */
 func (c *Client) CreateMessage(groupID ID, m *Message) (*Message, error) {
 	URL := fmt.Sprintf(c.endpointBase+createMessagesEndpoint, groupID)
-	httpReq, err := http.NewRequest("POST", URL, nil)
+
+	m.SourceGUID = uuid.New().String()
+	var data = struct {
+		Message *Message `json:"message"`
+	}{
+		m,
+	}
+
+	jsonBytes, err := json.Marshal(&data)
 	if err != nil {
 		return nil, err
 	}
 
-	m.SourceGUID = uuid.New().String()
-
-	data := url.Values{}
-	data.Set("message", m.String())
-
-	httpReq.PostForm = data
+	httpReq, err := http.NewRequest("POST", URL, bytes.NewBuffer(jsonBytes))
+	if err != nil {
+		return nil, err
+	}
 
 	var resp struct {
 		*Message `json:"message"`

sms_mode_api.go

@@ -1,10 +1,10 @@
 package groupme
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
 	"net/http"
-	"net/url"
-	"strconv"
 )
 
 // GroupMe documentation: https://dev.groupme.com/docs/v3#sms_mode
@@ -36,20 +36,26 @@ Parameters:
 		delivered to the device.
 */
 func (c *Client) CreateSMSMode(duration int, registrationID *ID) error {
-	httpReq, err := http.NewRequest("POST", c.endpointBase+createSMSModeEndpoint, nil)
+	URL := fmt.Sprintf(c.endpointBase + createSMSModeEndpoint)
+
+	var data = struct {
+		Duration       int `json:"duration"`
+		RegistrationID *ID `json:"registration_id,omitempty"`
+	}{
+		duration,
+		registrationID,
+	}
+
+	jsonBytes, err := json.Marshal(&data)
 	if err != nil {
 		return err
 	}
 
-	data := url.Values{}
-	data.Add("duration", strconv.Itoa(duration))
-
-	if registrationID != nil {
-		data.Add("registration_id", registrationID.String())
+	httpReq, err := http.NewRequest("POST", URL, bytes.NewBuffer(jsonBytes))
+	if err != nil {
+		return err
 	}
 
-	httpReq.PostForm = data
-
 	err = c.doWithAuthToken(httpReq, nil)
 	if err != nil {
 		return err

users_api.go

@@ -1,9 +1,10 @@
 package groupme
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
 	"net/http"
-	"net/url"
 )
 
 // GroupMe documentation: https://dev.groupme.com/docs/v3#users
@@ -70,31 +71,16 @@ Parameters: See UserSettings
 func (c *Client) UpdateMyUser(us UserSettings) (*User, error) {
 	URL := fmt.Sprintf(c.endpointBase + updateMyUserEndpoint)
 
-	httpReq, err := http.NewRequest("POST", URL, nil)
+	jsonBytes, err := json.Marshal(&us)
 	if err != nil {
 		return nil, err
 	}
 
-	data := url.Values{}
-
-	if us.AvatarURL != "" {
-		data.Add("avatar_url", us.AvatarURL)
+	httpReq, err := http.NewRequest("POST", URL, bytes.NewBuffer(jsonBytes))
+	if err != nil {
+		return nil, err
 	}
 
-	if us.Name != "" {
-		data.Add("name", us.Name)
-	}
-
-	if us.Email != "" {
-		data.Add("email", us.Email)
-	}
-
-	if us.ZipCode != "" {
-		data.Add("zip_code", us.ZipCode)
-	}
-
-	httpReq.PostForm = data
-
 	var resp User
 	err = c.doWithAuthToken(httpReq, &resp)
 	if err != nil {