watsonb8/groupme-lib
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

API POST Calls Update

Browse Source 
POST calls were not getting their JSON data written
This commit is contained in:
densestvoid 2020-08-23 21:25:02 -04:00
parent 010fd832ac
commit d8cdcf4ef2
9 changed files with 159 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
bots_api.go
View File

@ -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)
}

16
client.go
View File

@ -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,
}
@ -63,17 +64,18 @@ func (c Client) do(req *http.Request, i interface{}) error {
if err != nil {
return err
}
// Check Status Code is 1XX or 2XX
if getResp.StatusCode/100 > 2 {
return errors.New(getResp.Status)
}
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 fmt.Errorf("%s: %s", getResp.Status, string(bytes))
}
if i == nil {
return nil
}

23
direct_messages_api.go
View File

@ -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"`

80
groups_api.go
View File

@ -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"`

8
groups_api_test.go
View File

@ -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",

36
members_api.go
View File

@ -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,18 +49,21 @@ 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"`
@ -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

23
messages_api.go
View File

@ -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"`

26
sms_mode_api.go
View File

@ -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

26
users_api.go
View File

@ -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 {