Don't hold back

Main.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+  "geoffrey/commands"
+
+  "os"
+)
+
+func main() {
+  commands.RegisterCommand(&commands.ServerCommand{})
+  commands.RegisterCommand(&commands.HelpCommand{})
+
+  commands.RunCommand(os.Args[1:])
+}

Procfile

@@ -0,0 +1 @@
+web: geoffrey server

README.md

@@ -0,0 +1,2 @@
+# GeoffreyBot
+Geoffrey is a guinea pig/GroupMe bot with a new lease on life

api/CatFacts.go

@@ -0,0 +1,48 @@
+package api
+
+import (
+	"net/http"
+	"errors"
+	"strings"
+)
+
+const catFactsBaseUrl = "https://catfact.ninja"
+
+const catFactEndpoint = catFactsBaseUrl + "/fact"
+const catFactFactKey = "fact"
+
+func GetCatFact() (string, error) {
+	resp, err := http.Get(catFactEndpoint)
+
+	if (err != nil) {
+		return "", err
+	}
+
+	defer resp.Body.Close()
+
+	if (resp.StatusCode != 200) {
+		return "", buildStatusError("Error recieved from cat facts endpoint", resp)
+	}
+
+	body, err := getBodyJson(resp)
+
+	if (err != nil) {
+		return "", err
+	}
+
+	if fact, exists := body[catFactFactKey]; exists {
+		return sanitizeCatFact(fact), nil
+	} else {
+		return "", errors.New("Could not parse fact out of response body!")
+	}
+}
+
+func GetCatFactAsync(channel chan StringResult) {
+	fact, err := GetCatFact()
+	channel <- StringResult{fact, err}
+}
+
+func sanitizeCatFact(fact string) string {
+	fact = strings.Replace(fact, "\"", "'", -1) // Remove quote marks
+	return strings.Replace(fact, "\\", "", -1) // Remove backslashes
+}

api/DropBox.go

@@ -0,0 +1,50 @@
+package api
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"errors"
+	"os"
+)
+
+const dropboxContentBaseUrl = "https://content.dropboxapi.com/2/"
+const dropboxFileDownloadUrl = dropboxContentBaseUrl + "files/download"
+
+const dropboxAccessTokenEnvVar = "DROPBOX_ACCESS_TOKEN"
+
+// DownloadFile retrieves a file from dropbox at the given path
+// If is the caller's responsibility to close the file stream
+func DownloadFile(filePath string) (io.ReadCloser, error) {
+	token := os.Getenv(dropboxAccessTokenEnvVar)
+	if token == "" {
+		return nil, errors.New("Could not download file; " + dropboxAccessTokenEnvVar + " env var not set")
+	}
+
+	client := &http.Client{}
+	request, err := http.NewRequest("POST", dropboxFileDownloadUrl, nil)
+	addAuthHeader(token, request)
+
+	arg := fmt.Sprintf(`{"path":"%v"}`, filePath)
+
+	request.Header.Add("Dropbox-API-Arg", arg)
+
+	resp, err := client.Do(request)
+
+	if err != nil {
+		return nil, err
+	}
+
+	if (resp.StatusCode != 200) {
+		respBody, _ := ioutil.ReadAll(resp.Body)
+		resp.Body.Close()
+		return nil, errors.New("Error downloading file: " + string(respBody))
+	}
+
+	return resp.Body, nil
+}
+
+func addAuthHeader(token string, request *http.Request) {
+	request.Header.Add("Authorization", "Bearer " + token)
+}

api/GroupMe.go

@@ -0,0 +1,110 @@
+package api
+
+import (
+	"io/ioutil"
+	"bytes"
+	"net/http"
+	"fmt"
+	"os"
+	"strconv"
+	"geoffrey/types"
+)
+
+const groupMeBaseUrl = "https://api.groupme.com/v3"
+const botPostMessageUrl = groupMeBaseUrl + "/bots/post"
+
+const jsonContentType = "application/json"
+
+const botIdEnvironmentVar = "BOT_ID"
+
+var botId string = ""
+
+func PostGroupMeMessage(message string) {
+	id := getBotId()
+	if (id == "") {
+		fmt.Printf("Cannot send message; $%v environment variable not set\n", botIdEnvironmentVar)
+		return
+	}
+
+	body := fmt.Sprintf(`{
+		"bot_id": "%v",
+		"text": "%v"
+	}`, id, message)
+
+	postGroupMeMessage(body)
+}
+
+func PostGroupMeMessageWithPicture(message string, imageUrl string) {
+	id := getBotId()
+	if (id == "") {
+		fmt.Printf("Cannot send message; $%v environment variable not set\n", botIdEnvironmentVar)
+		return
+	}
+
+	body := fmt.Sprintf(`{
+		"bot_id": "%v",
+		"text": "%v",
+		"picture_url": "%v"
+	}`, id, message, imageUrl)
+
+	postGroupMeMessage(body)
+}
+
+func PostGroupMeMessageWithMentions(message string, mentions ...types.GroupMeMessageMention) {
+	id := getBotId()
+	if (id == "") {
+		fmt.Printf("Cannot send message; $%v environment variable not set\n", botIdEnvironmentVar)
+		return
+	}
+
+	var lociArr = ""
+	var userIdArr = ""
+
+	if (len(mentions) > 0) {
+		for _, mention := range(mentions) {
+			lociArr += "[" + strconv.Itoa(mention.StartIndex) + "," + strconv.Itoa(mention.Length) + "],"
+			userIdArr += `"` + mention.UserId + `",`
+		}
+
+		// Cut off extra commas
+		lociArr = lociArr[:len(lociArr)-1]
+		userIdArr = userIdArr[:len(userIdArr)-1]
+	}
+
+	body := fmt.Sprintf(`{
+			"bot_id": "%v",
+			"text": "%v",
+			"attachments": [{
+				"type": "mentions",	
+				"loci": [%v],
+				"user_ids": [%v]
+			}]
+		}`, botId, message, lociArr, userIdArr)
+
+	postGroupMeMessage(body)
+}
+
+// postGroupMeMessage is the internal function that both public post functions delegate to
+func postGroupMeMessage(postBody string) {
+	resp, err := http.Post(botPostMessageUrl, jsonContentType, bytes.NewBufferString(postBody))
+
+	if (err != nil) {
+		fmt.Printf("Error posting message; %v", err)
+		return
+	}
+
+	if (resp.StatusCode != 202) {
+		respBody, _ := ioutil.ReadAll(resp.Body)
+		fmt.Printf("Post failed; response code: %v: %v;\n\tbody: %v\n", resp.StatusCode, resp.Status, string(respBody))
+	}
+
+	resp.Body.Close()
+}
+
+func getBotId() string {
+	if botId == "" {
+		botId = os.Getenv(botIdEnvironmentVar)
+	}
+
+	return botId
+}

api/GroupMeImages.go

@@ -0,0 +1,61 @@
+package api
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"os"
+)
+
+type responseData struct {
+	Data payload `json:"payload"`
+}
+
+type payload struct {
+	Url string `json:"url"`
+	PictureUrl string `json:"picture_url"`
+}
+
+const groupMeImageServiceUrl = "https://image.groupme.com/pictures?access_token=%v"
+
+const groupMeAccessTokenEnvVar = "GM_ACCESS_TOKEN"
+
+// Process Image posts the given image to GroupMe's image service
+// and returns the group me url of the image
+func ProcessImage(image io.Reader) string {
+	token := os.Getenv(groupMeAccessTokenEnvVar)
+	if token == "" {
+		fmt.Println("Cannot process image; GM_ACCESS_TOKEN env var not set")
+		return ""
+	}
+
+	url := fmt.Sprintf(groupMeImageServiceUrl, token)
+
+	resp, err := http.Post(url, "image/jpeg", image)
+
+	defer resp.Body.Close()
+
+	if err != nil {
+		fmt.Printf("Error from GroupMe image servce: %v", err)
+		return ""
+	}
+
+	respBody, _ := ioutil.ReadAll(resp.Body)
+
+	if resp.StatusCode != 200 {
+		return string(respBody)
+	}
+
+	respPayload := responseData{}
+
+	err = json.Unmarshal(respBody, &respPayload)
+
+	if err != nil {
+		fmt.Printf("Error converting response body to JSON: %v\n", err)
+		return ""
+	}
+
+	return respPayload.Data.PictureUrl
+}

api/NetUtils.go

@@ -0,0 +1,34 @@
+package api
+
+import (
+	"strconv"
+	"encoding/json"
+	"net/http"
+	"io/ioutil"
+	"errors"
+)
+
+type StringResult struct {
+	Result string
+	Err error
+}
+
+// getBodyJson takes an http.Response pointer and reads all of its data into a map
+func getBodyJson(response *http.Response) (map[string] string, error) {
+	bodyBytes, err := ioutil.ReadAll(response.Body)
+
+	if (err != nil) {
+		return nil, err
+	}
+
+	bodyMap := make(map[string] string)
+
+	json.Unmarshal(bodyBytes, &bodyMap)
+
+	return bodyMap, nil
+}
+
+// buildStatusError takes an http response and builds an error with the status code and message in it
+func buildStatusError(message string, response *http.Response) error {
+	return errors.New(message + "; Status " + strconv.Itoa(response.StatusCode) + ": " + response.Status)
+}

api/Temporize.go

@@ -0,0 +1,64 @@
+package api
+
+import (
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"fmt"
+	"time"
+	"math/rand"
+	"os"
+)
+
+const temporizeURLEnvironmentVar = "TEMPORIZE_URL"
+
+var temporizeUrl = ""
+
+// ScheduleSingleEventInAWeek will schedule an event for approximately a week (4-7 days) from today
+// at a random time around noon 
+func ScheduleSingleEventInAWeek(callbackUrl string) {
+	now := time.Now()
+	rand.Seed(now.Unix())
+
+	later := now.AddDate(0, 0, 4 + rand.Intn(3))
+	later = time.Date(later.Year(), 
+					later.Month(),
+					later.Day(),
+					rand.Intn(24),
+					rand.Intn(60),
+					0, 0, time.UTC)
+
+	ScheduleSingleEvent(later, callbackUrl)
+}
+
+func ScheduleSingleEvent(t time.Time, callbackUrl string) {
+	baseUrl := getTemporizeUrl()
+	if baseUrl == "" {
+		fmt.Printf("Cannot schedule event; $%v environment variable not set\n", temporizeURLEnvironmentVar)
+		return
+	}
+
+	url := fmt.Sprintf("%v/v1/events/%v/%v", baseUrl, t.Format(time.RFC3339), url.QueryEscape(callbackUrl))
+
+	resp, err := http.Post(url, "text/plain", nil)
+
+	if (err != nil) {
+		fmt.Printf("Error scheduling event; %v", err)
+		return
+	}
+
+	if (resp.StatusCode != 200) {
+		respBody, _ := ioutil.ReadAll(resp.Body)
+		fmt.Printf("Error scheduling event; Post failed; response code: %v: %v;\n\tbody: %v\n", resp.StatusCode, resp.Status, string(respBody))
+	}
+
+	resp.Body.Close()
+}
+
+func getTemporizeUrl() string {
+	if temporizeUrl == "" {
+		temporizeUrl = os.Getenv(temporizeURLEnvironmentVar)
+	}
+
+	return temporizeUrl
+}