Fixing merge conflicts

4 files changed, 520 insertions, 42 deletions

diff --git a/api/command.go b/api/command.go
index 94b2cd2f8..52ff8fffd 100644
--- a/api/command.go
+++ b/api/command.go
@@ -145,7 +145,7 @@ func echoCommand(c *Context, command *model.Command) bool {
 
 			time.Sleep(time.Duration(delay) * time.Second)
 
-			if _, err := CreatePost(c, post, false); err != nil {
+			if _, err := CreatePost(c, post, true); err != nil {
 				l4g.Error("Unable to create /echo post, err=%v", err)
 			}
 		}()
diff --git a/api/post.go b/api/post.go
index 58fd3488a..73a63cb72 100644
--- a/api/post.go
+++ b/api/post.go
@@ -13,6 +13,7 @@ import (
 	"net/http"
 	"net/url"
 	"path/filepath"
+	"regexp"
 	"strconv"
 	"strings"
 	"time"
@@ -55,11 +56,15 @@ func createPost(c *Context, w http.ResponseWriter, r *http.Request) {
 
 		return
 	} else {
+		if result := <-Srv.Store.Channel().UpdateLastViewedAt(post.ChannelId, c.Session.UserId); result.Err != nil {
+			l4g.Error("Encountered error updating last viewed, channel_id=%s, user_id=%s, err=%v", post.ChannelId, c.Session.UserId, result.Err)
+		}
+
 		w.Write([]byte(rp.ToJson()))
 	}
 }
 
-func CreatePost(c *Context, post *model.Post, doUpdateLastViewed bool) (*model.Post, *model.AppError) {
+func CreatePost(c *Context, post *model.Post, triggerWebhooks bool) (*model.Post, *model.AppError) {
 	var pchan store.StoreChannel
 	if len(post.RootId) > 0 {
 		pchan = Srv.Store.Post().Get(post.RootId)
@@ -130,50 +135,193 @@ func CreatePost(c *Context, post *model.Post, doUpdateLastViewed bool) (*model.P
 	var rpost *model.Post
 	if result := <-Srv.Store.Post().Save(post); result.Err != nil {
 		return nil, result.Err
-	} else if doUpdateLastViewed && (<-Srv.Store.Channel().UpdateLastViewedAt(post.ChannelId, c.Session.UserId)).Err != nil {
-		return nil, result.Err
 	} else {
 		rpost = result.Data.(*model.Post)
 
-		fireAndForgetNotifications(rpost, c.Session.TeamId, c.GetSiteURL())
+		handlePostEventsAndForget(c, rpost, triggerWebhooks)
 
 	}
 
 	return rpost, nil
 }
 
-func fireAndForgetNotifications(post *model.Post, teamId, siteURL string) {
+func CreateWebhookPost(c *Context, channelId, text, overrideUsername, overrideIconUrl string) (*model.Post, *model.AppError) {
+	// parse links into Markdown format
+	linkWithTextRegex := regexp.MustCompile(`<([^<\|]+)\|([^>]+)>`)
+	text = linkWithTextRegex.ReplaceAllString(text, "[${2}](${1})")
+
+	linkRegex := regexp.MustCompile(`<\s*(\S*)\s*>`)
+	text = linkRegex.ReplaceAllString(text, "${1}")
+
+	post := &model.Post{UserId: c.Session.UserId, ChannelId: channelId, Message: text}
+	post.AddProp("from_webhook", "true")
+
+	if utils.Cfg.ServiceSettings.EnablePostUsernameOverride {
+		if len(overrideUsername) != 0 {
+			post.AddProp("override_username", overrideUsername)
+		} else {
+			post.AddProp("override_username", model.DEFAULT_WEBHOOK_USERNAME)
+		}
+	}
 
+	if utils.Cfg.ServiceSettings.EnablePostIconOverride {
+		if len(overrideIconUrl) != 0 {
+			post.AddProp("override_icon_url", overrideIconUrl)
+		} else {
+			post.AddProp("override_icon_url", model.DEFAULT_WEBHOOK_ICON)
+		}
+	}
+
+	if _, err := CreatePost(c, post, false); err != nil {
+		return nil, model.NewAppError("CreateWebhookPost", "Error creating post", "err="+err.Message)
+	}
+
+	return post, nil
+}
+
+func handlePostEventsAndForget(c *Context, post *model.Post, triggerWebhooks bool) {
 	go func() {
-		// Get a list of user names (to be used as keywords) and ids for the given team
-		uchan := Srv.Store.User().GetProfiles(teamId)
-		echan := Srv.Store.Channel().GetMembers(post.ChannelId)
+		tchan := Srv.Store.Team().Get(c.Session.TeamId)
 		cchan := Srv.Store.Channel().Get(post.ChannelId)
-		tchan := Srv.Store.Team().Get(teamId)
+		uchan := Srv.Store.User().Get(post.UserId)
+
+		var team *model.Team
+		if result := <-tchan; result.Err != nil {
+			l4g.Error("Encountered error getting team, team_id=%s, err=%v", c.Session.TeamId, result.Err)
+			return
+		} else {
+			team = result.Data.(*model.Team)
+		}
 
 		var channel *model.Channel
-		var channelName string
-		var bodyText string
-		var subjectText string
 		if result := <-cchan; result.Err != nil {
-			l4g.Error("Failed to retrieve channel channel_id=%v, err=%v", post.ChannelId, result.Err)
+			l4g.Error("Encountered error getting channel, channel_id=%s, err=%v", post.ChannelId, result.Err)
 			return
 		} else {
 			channel = result.Data.(*model.Channel)
-			if channel.Type == model.CHANNEL_DIRECT {
-				bodyText = "You have one new message."
-				subjectText = "New Direct Message"
-			} else {
-				bodyText = "You have one new mention."
-				subjectText = "New Mention"
-				channelName = channel.DisplayName
+		}
+
+		fireAndForgetNotifications(c, post, team, channel)
+
+		var user *model.User
+		if result := <-uchan; result.Err != nil {
+			l4g.Error("Encountered error getting user, user_id=%s, err=%v", post.UserId, result.Err)
+			return
+		} else {
+			user = result.Data.(*model.User)
+		}
+
+		if triggerWebhooks {
+			handleWebhookEventsAndForget(c, post, team, channel, user)
+		}
+	}()
+}
+
+func handleWebhookEventsAndForget(c *Context, post *model.Post, team *model.Team, channel *model.Channel, user *model.User) {
+	go func() {
+		hchan := Srv.Store.Webhook().GetOutgoingByTeam(c.Session.TeamId)
+
+		hooks := []*model.OutgoingWebhook{}
+
+		if result := <-hchan; result.Err != nil {
+			l4g.Error("Encountered error getting webhooks by team, err=%v", result.Err)
+			return
+		} else {
+			hooks = result.Data.([]*model.OutgoingWebhook)
+		}
+
+		if len(hooks) == 0 {
+			return
+		}
+
+		firstWord := strings.Split(post.Message, " ")[0]
+
+		relevantHooks := []*model.OutgoingWebhook{}
+
+		for _, hook := range hooks {
+			if hook.ChannelId == post.ChannelId {
+				if len(hook.TriggerWords) == 0 || hook.HasTriggerWord(firstWord) {
+					relevantHooks = append(relevantHooks, hook)
+				}
+			} else if len(hook.ChannelId) == 0 && hook.HasTriggerWord(firstWord) {
+				relevantHooks = append(relevantHooks, hook)
 			}
 		}
 
+		for _, hook := range relevantHooks {
+			go func() {
+				p := url.Values{}
+				p.Set("token", hook.Token)
+
+				p.Set("team_id", hook.TeamId)
+				p.Set("team_domain", team.Name)
+
+				p.Set("channel_id", post.ChannelId)
+				p.Set("channel_name", channel.Name)
+
+				p.Set("timestamp", strconv.FormatInt(post.CreateAt/1000, 10))
+
+				p.Set("user_id", post.UserId)
+				p.Set("user_name", user.Username)
+
+				p.Set("text", post.Message)
+				p.Set("trigger_word", firstWord)
+
+				client := &http.Client{}
+
+				for _, url := range hook.CallbackURLs {
+					go func() {
+						req, _ := http.NewRequest("POST", url, strings.NewReader(p.Encode()))
+						req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+						req.Header.Set("Accept", "application/json")
+						if resp, err := client.Do(req); err != nil {
+							l4g.Error("Event POST failed, err=%s", err.Error())
+						} else {
+							respProps := model.MapFromJson(resp.Body)
+
+							// copy the context and create a mock session for posting the message
+							mockSession := model.Session{UserId: hook.CreatorId, TeamId: hook.TeamId, IsOAuth: false}
+							newContext := &Context{mockSession, model.NewId(), "", c.Path, nil, c.teamURLValid, c.teamURL, c.siteURL}
+
+							if text, ok := respProps["text"]; ok {
+								if _, err := CreateWebhookPost(newContext, post.ChannelId, text, respProps["username"], respProps["icon_url"]); err != nil {
+									l4g.Error("Failed to create response post, err=%v", err)
+								}
+							}
+						}
+					}()
+				}
+
+			}()
+		}
+
+	}()
+
+}
+
+func fireAndForgetNotifications(c *Context, post *model.Post, team *model.Team, channel *model.Channel) {
+
+	go func() {
+		// Get a list of user names (to be used as keywords) and ids for the given team
+		uchan := Srv.Store.User().GetProfiles(c.Session.TeamId)
+		echan := Srv.Store.Channel().GetMembers(post.ChannelId)
+
+		var channelName string
+		var bodyText string
+		var subjectText string
+		if channel.Type == model.CHANNEL_DIRECT {
+			bodyText = "You have one new message."
+			subjectText = "New Direct Message"
+		} else {
+			bodyText = "You have one new mention."
+			subjectText = "New Mention"
+			channelName = channel.DisplayName
+		}
+
 		var mentionedUsers []string
 
 		if result := <-uchan; result.Err != nil {
-			l4g.Error("Failed to retrieve user profiles team_id=%v, err=%v", teamId, result.Err)
+			l4g.Error("Failed to retrieve user profiles team_id=%v, err=%v", c.Session.TeamId, result.Err)
 			return
 		} else {
 			profileMap := result.Data.(map[string]*model.User)
@@ -296,23 +444,15 @@ func fireAndForgetNotifications(post *model.Post, teamId, siteURL string) {
 					mentionedUsers = append(mentionedUsers, k)
 				}
 
-				var teamDisplayName string
-				var teamURL string
-				if result := <-tchan; result.Err != nil {
-					l4g.Error("Failed to retrieve team team_id=%v, err=%v", teamId, result.Err)
-					return
-				} else {
-					teamDisplayName = result.Data.(*model.Team).DisplayName
-					teamURL = siteURL + "/" + result.Data.(*model.Team).Name
-				}
+				teamURL := c.GetSiteURL() + "/" + team.Name
 
 				// Build and send the emails
 				location, _ := time.LoadLocation("UTC")
 				tm := time.Unix(post.CreateAt/1000, 0).In(location)
 
 				subjectPage := NewServerTemplatePage("post_subject")
-				subjectPage.Props["SiteURL"] = siteURL
-				subjectPage.Props["TeamDisplayName"] = teamDisplayName
+				subjectPage.Props["SiteURL"] = c.GetSiteURL()
+				subjectPage.Props["TeamDisplayName"] = team.DisplayName
 				subjectPage.Props["SubjectText"] = subjectText
 				subjectPage.Props["Month"] = tm.Month().String()[:3]
 				subjectPage.Props["Day"] = fmt.Sprintf("%d", tm.Day())
@@ -330,9 +470,9 @@ func fireAndForgetNotifications(post *model.Post, teamId, siteURL string) {
 					}
 
 					bodyPage := NewServerTemplatePage("post_body")
-					bodyPage.Props["SiteURL"] = siteURL
+					bodyPage.Props["SiteURL"] = c.GetSiteURL()
 					bodyPage.Props["Nickname"] = profileMap[id].FirstName
-					bodyPage.Props["TeamDisplayName"] = teamDisplayName
+					bodyPage.Props["TeamDisplayName"] = team.DisplayName
 					bodyPage.Props["ChannelName"] = channelName
 					bodyPage.Props["BodyText"] = bodyText
 					bodyPage.Props["SenderName"] = senderName
@@ -399,7 +539,7 @@ func fireAndForgetNotifications(post *model.Post, teamId, siteURL string) {
 			}
 		}
 
-		message := model.NewMessage(teamId, post.ChannelId, post.UserId, model.ACTION_POSTED)
+		message := model.NewMessage(c.Session.TeamId, post.ChannelId, post.UserId, model.ACTION_POSTED)
 		message.Add("post", post.ToJson())
 
 		if len(post.Filenames) != 0 {
diff --git a/api/webhook.go b/api/webhook.go
index de4ba6691..34c308879 100644
--- a/api/webhook.go
+++ b/api/webhook.go
@@ -18,6 +18,11 @@ func InitWebhook(r *mux.Router) {
 	sr.Handle("/incoming/create", ApiUserRequired(createIncomingHook)).Methods("POST")
 	sr.Handle("/incoming/delete", ApiUserRequired(deleteIncomingHook)).Methods("POST")
 	sr.Handle("/incoming/list", ApiUserRequired(getIncomingHooks)).Methods("GET")
+
+	sr.Handle("/outgoing/create", ApiUserRequired(createOutgoingHook)).Methods("POST")
+	sr.Handle("/outgoing/regen_token", ApiUserRequired(regenOutgoingHookToken)).Methods("POST")
+	sr.Handle("/outgoing/delete", ApiUserRequired(deleteOutgoingHook)).Methods("POST")
+	sr.Handle("/outgoing/list", ApiUserRequired(getOutgoingHooks)).Methods("GET")
 }
 
 func createIncomingHook(c *Context, w http.ResponseWriter, r *http.Request) {
@@ -50,9 +55,11 @@ func createIncomingHook(c *Context, w http.ResponseWriter, r *http.Request) {
 		channel = result.Data.(*model.Channel)
 	}
 
-	if !c.HasPermissionsToChannel(pchan, "createIncomingHook") && channel.Type != model.CHANNEL_OPEN {
-		c.LogAudit("fail - bad channel permissions")
-		return
+	if !c.HasPermissionsToChannel(pchan, "createIncomingHook") {
+		if channel.Type != model.CHANNEL_OPEN || channel.TeamId != c.Session.TeamId {
+			c.LogAudit("fail - bad channel permissions")
+			return
+		}
 	}
 
 	if result := <-Srv.Store.Webhook().SaveIncoming(hook); result.Err != nil {
@@ -67,7 +74,7 @@ func createIncomingHook(c *Context, w http.ResponseWriter, r *http.Request) {
 
 func deleteIncomingHook(c *Context, w http.ResponseWriter, r *http.Request) {
 	if !utils.Cfg.ServiceSettings.EnableIncomingWebhooks {
-		c.Err = model.NewAppError("createIncomingHook", "Incoming webhooks have been disabled by the system admin.", "")
+		c.Err = model.NewAppError("deleteIncomingHook", "Incoming webhooks have been disabled by the system admin.", "")
 		c.Err.StatusCode = http.StatusNotImplemented
 		return
 	}
@@ -87,7 +94,7 @@ func deleteIncomingHook(c *Context, w http.ResponseWriter, r *http.Request) {
 		return
 	} else {
 		if c.Session.UserId != result.Data.(*model.IncomingWebhook).UserId && !c.IsTeamAdmin() {
-			c.LogAudit("fail - inappropriate conditions")
+			c.LogAudit("fail - inappropriate permissions")
 			c.Err = model.NewAppError("deleteIncomingHook", "Inappropriate permissions to delete incoming webhook", "user_id="+c.Session.UserId)
 			return
 		}
@@ -104,7 +111,7 @@ func deleteIncomingHook(c *Context, w http.ResponseWriter, r *http.Request) {
 
 func getIncomingHooks(c *Context, w http.ResponseWriter, r *http.Request) {
 	if !utils.Cfg.ServiceSettings.EnableIncomingWebhooks {
-		c.Err = model.NewAppError("createIncomingHook", "Incoming webhooks have been disabled by the system admin.", "")
+		c.Err = model.NewAppError("getIncomingHooks", "Incoming webhooks have been disabled by the system admin.", "")
 		c.Err.StatusCode = http.StatusNotImplemented
 		return
 	}
@@ -117,3 +124,153 @@ func getIncomingHooks(c *Context, w http.ResponseWriter, r *http.Request) {
 		w.Write([]byte(model.IncomingWebhookListToJson(hooks)))
 	}
 }
+
+func createOutgoingHook(c *Context, w http.ResponseWriter, r *http.Request) {
+	if !utils.Cfg.ServiceSettings.EnableOutgoingWebhooks {
+		c.Err = model.NewAppError("createOutgoingHook", "Outgoing webhooks have been disabled by the system admin.", "")
+		c.Err.StatusCode = http.StatusNotImplemented
+		return
+	}
+
+	c.LogAudit("attempt")
+
+	hook := model.OutgoingWebhookFromJson(r.Body)
+
+	if hook == nil {
+		c.SetInvalidParam("createOutgoingHook", "webhook")
+		return
+	}
+
+	hook.CreatorId = c.Session.UserId
+	hook.TeamId = c.Session.TeamId
+
+	if len(hook.ChannelId) != 0 {
+		cchan := Srv.Store.Channel().Get(hook.ChannelId)
+		pchan := Srv.Store.Channel().CheckPermissionsTo(c.Session.TeamId, hook.ChannelId, c.Session.UserId)
+
+		var channel *model.Channel
+		if result := <-cchan; result.Err != nil {
+			c.Err = result.Err
+			return
+		} else {
+			channel = result.Data.(*model.Channel)
+		}
+
+		if channel.Type != model.CHANNEL_OPEN {
+			c.LogAudit("fail - not open channel")
+		}
+
+		if !c.HasPermissionsToChannel(pchan, "createOutgoingHook") {
+			if channel.Type != model.CHANNEL_OPEN || channel.TeamId != c.Session.TeamId {
+				c.LogAudit("fail - bad channel permissions")
+				return
+			}
+		}
+	} else if len(hook.TriggerWords) == 0 {
+		c.Err = model.NewAppError("createOutgoingHook", "Either trigger_words or channel_id must be set", "")
+		return
+	}
+
+	if result := <-Srv.Store.Webhook().SaveOutgoing(hook); result.Err != nil {
+		c.Err = result.Err
+		return
+	} else {
+		c.LogAudit("success")
+		rhook := result.Data.(*model.OutgoingWebhook)
+		w.Write([]byte(rhook.ToJson()))
+	}
+}
+
+func getOutgoingHooks(c *Context, w http.ResponseWriter, r *http.Request) {
+	if !utils.Cfg.ServiceSettings.EnableOutgoingWebhooks {
+		c.Err = model.NewAppError("getOutgoingHooks", "Outgoing webhooks have been disabled by the system admin.", "")
+		c.Err.StatusCode = http.StatusNotImplemented
+		return
+	}
+
+	if result := <-Srv.Store.Webhook().GetOutgoingByCreator(c.Session.UserId); result.Err != nil {
+		c.Err = result.Err
+		return
+	} else {
+		hooks := result.Data.([]*model.OutgoingWebhook)
+		w.Write([]byte(model.OutgoingWebhookListToJson(hooks)))
+	}
+}
+
+func deleteOutgoingHook(c *Context, w http.ResponseWriter, r *http.Request) {
+	if !utils.Cfg.ServiceSettings.EnableIncomingWebhooks {
+		c.Err = model.NewAppError("deleteOutgoingHook", "Outgoing webhooks have been disabled by the system admin.", "")
+		c.Err.StatusCode = http.StatusNotImplemented
+		return
+	}
+
+	c.LogAudit("attempt")
+
+	props := model.MapFromJson(r.Body)
+
+	id := props["id"]
+	if len(id) == 0 {
+		c.SetInvalidParam("deleteIncomingHook", "id")
+		return
+	}
+
+	if result := <-Srv.Store.Webhook().GetOutgoing(id); result.Err != nil {
+		c.Err = result.Err
+		return
+	} else {
+		if c.Session.UserId != result.Data.(*model.OutgoingWebhook).CreatorId && !c.IsTeamAdmin() {
+			c.LogAudit("fail - inappropriate permissions")
+			c.Err = model.NewAppError("deleteOutgoingHook", "Inappropriate permissions to delete outcoming webhook", "user_id="+c.Session.UserId)
+			return
+		}
+	}
+
+	if err := (<-Srv.Store.Webhook().DeleteOutgoing(id, model.GetMillis())).Err; err != nil {
+		c.Err = err
+		return
+	}
+
+	c.LogAudit("success")
+	w.Write([]byte(model.MapToJson(props)))
+}
+
+func regenOutgoingHookToken(c *Context, w http.ResponseWriter, r *http.Request) {
+	if !utils.Cfg.ServiceSettings.EnableIncomingWebhooks {
+		c.Err = model.NewAppError("regenOutgoingHookToken", "Outgoing webhooks have been disabled by the system admin.", "")
+		c.Err.StatusCode = http.StatusNotImplemented
+		return
+	}
+
+	c.LogAudit("attempt")
+
+	props := model.MapFromJson(r.Body)
+
+	id := props["id"]
+	if len(id) == 0 {
+		c.SetInvalidParam("regenOutgoingHookToken", "id")
+		return
+	}
+
+	var hook *model.OutgoingWebhook
+	if result := <-Srv.Store.Webhook().GetOutgoing(id); result.Err != nil {
+		c.Err = result.Err
+		return
+	} else {
+		hook = result.Data.(*model.OutgoingWebhook)
+
+		if c.Session.UserId != hook.CreatorId && !c.IsTeamAdmin() {
+			c.LogAudit("fail - inappropriate permissions")
+			c.Err = model.NewAppError("regenOutgoingHookToken", "Inappropriate permissions to regenerate outcoming webhook token", "user_id="+c.Session.UserId)
+			return
+		}
+	}
+
+	hook.Token = model.NewId()
+
+	if result := <-Srv.Store.Webhook().UpdateOutgoing(hook); result.Err != nil {
+		c.Err = result.Err
+		return
+	} else {
+		w.Write([]byte(result.Data.(*model.OutgoingWebhook).ToJson()))
+	}
+}
diff --git a/api/webhook_test.go b/api/webhook_test.go
index 16b9c9529..4c04a9922 100644
--- a/api/webhook_test.go
+++ b/api/webhook_test.go
@@ -152,6 +152,187 @@ func TestDeleteIncomingHook(t *testing.T) {
 	}
 }
 
+func TestCreateOutgoingHook(t *testing.T) {
+	Setup()
+
+	team := &model.Team{DisplayName: "Name", Name: "z-z-" + model.NewId() + "a", Email: "test@nowhere.com", Type: model.TEAM_OPEN}
+	team = Client.Must(Client.CreateTeam(team)).Data.(*model.Team)
+
+	user := &model.User{TeamId: team.Id, Email: model.NewId() + "corey@test.com", Nickname: "Corey Hulen", Password: "pwd"}
+	user = Client.Must(Client.CreateUser(user, "")).Data.(*model.User)
+	store.Must(Srv.Store.User().VerifyEmail(user.Id))
+
+	Client.LoginByEmail(team.Name, user.Email, "pwd")
+
+	channel1 := &model.Channel{DisplayName: "Test API Name", Name: "a" + model.NewId() + "a", Type: model.CHANNEL_OPEN, TeamId: team.Id}
+	channel1 = Client.Must(Client.CreateChannel(channel1)).Data.(*model.Channel)
+
+	channel2 := &model.Channel{DisplayName: "Test API Name", Name: "a" + model.NewId() + "a", Type: model.CHANNEL_OPEN, TeamId: team.Id}
+	channel2 = Client.Must(Client.CreateChannel(channel2)).Data.(*model.Channel)
+
+	hook := &model.OutgoingWebhook{ChannelId: channel1.Id, CallbackURLs: []string{"http://nowhere.com"}}
+
+	if utils.Cfg.ServiceSettings.EnableOutgoingWebhooks {
+		var rhook *model.OutgoingWebhook
+		if result, err := Client.CreateOutgoingWebhook(hook); err != nil {
+			t.Fatal(err)
+		} else {
+			rhook = result.Data.(*model.OutgoingWebhook)
+		}
+
+		if hook.ChannelId != rhook.ChannelId {
+			t.Fatal("channel ids didn't match")
+		}
+
+		if rhook.CreatorId != user.Id {
+			t.Fatal("user ids didn't match")
+		}
+
+		if rhook.TeamId != team.Id {
+			t.Fatal("team ids didn't match")
+		}
+
+		hook = &model.OutgoingWebhook{ChannelId: "junk", CallbackURLs: []string{"http://nowhere.com"}}
+		if _, err := Client.CreateOutgoingWebhook(hook); err == nil {
+			t.Fatal("should have failed - bad channel id")
+		}
+
+		hook = &model.OutgoingWebhook{ChannelId: channel2.Id, CreatorId: "123", TeamId: "456", CallbackURLs: []string{"http://nowhere.com"}}
+		if result, err := Client.CreateOutgoingWebhook(hook); err != nil {
+			t.Fatal(err)
+		} else {
+			if result.Data.(*model.OutgoingWebhook).CreatorId != user.Id {
+				t.Fatal("bad user id wasn't overwritten")
+			}
+			if result.Data.(*model.OutgoingWebhook).TeamId != team.Id {
+				t.Fatal("bad team id wasn't overwritten")
+			}
+		}
+	} else {
+		if _, err := Client.CreateOutgoingWebhook(hook); err == nil {
+			t.Fatal("should have errored - webhooks turned off")
+		}
+	}
+}
+
+func TestListOutgoingHooks(t *testing.T) {
+	Setup()
+
+	team := &model.Team{DisplayName: "Name", Name: "z-z-" + model.NewId() + "a", Email: "test@nowhere.com", Type: model.TEAM_OPEN}
+	team = Client.Must(Client.CreateTeam(team)).Data.(*model.Team)
+
+	user := &model.User{TeamId: team.Id, Email: model.NewId() + "corey@test.com", Nickname: "Corey Hulen", Password: "pwd"}
+	user = Client.Must(Client.CreateUser(user, "")).Data.(*model.User)
+	store.Must(Srv.Store.User().VerifyEmail(user.Id))
+
+	Client.LoginByEmail(team.Name, user.Email, "pwd")
+
+	channel1 := &model.Channel{DisplayName: "Test API Name", Name: "a" + model.NewId() + "a", Type: model.CHANNEL_OPEN, TeamId: team.Id}
+	channel1 = Client.Must(Client.CreateChannel(channel1)).Data.(*model.Channel)
+
+	if utils.Cfg.ServiceSettings.EnableOutgoingWebhooks {
+		hook1 := &model.OutgoingWebhook{ChannelId: channel1.Id, CallbackURLs: []string{"http://nowhere.com"}}
+		hook1 = Client.Must(Client.CreateOutgoingWebhook(hook1)).Data.(*model.OutgoingWebhook)
+
+		hook2 := &model.OutgoingWebhook{TriggerWords: []string{"trigger"}, CallbackURLs: []string{"http://nowhere.com"}}
+		hook2 = Client.Must(Client.CreateOutgoingWebhook(hook2)).Data.(*model.OutgoingWebhook)
+
+		if result, err := Client.ListOutgoingWebhooks(); err != nil {
+			t.Fatal(err)
+		} else {
+			hooks := result.Data.([]*model.OutgoingWebhook)
+
+			if len(hooks) != 2 {
+				t.Fatal("incorrect number of hooks")
+			}
+		}
+	} else {
+		if _, err := Client.ListOutgoingWebhooks(); err == nil {
+			t.Fatal("should have errored - webhooks turned off")
+		}
+	}
+}
+
+func TestDeleteOutgoingHook(t *testing.T) {
+	Setup()
+
+	team := &model.Team{DisplayName: "Name", Name: "z-z-" + model.NewId() + "a", Email: "test@nowhere.com", Type: model.TEAM_OPEN}
+	team = Client.Must(Client.CreateTeam(team)).Data.(*model.Team)
+
+	user := &model.User{TeamId: team.Id, Email: model.NewId() + "corey@test.com", Nickname: "Corey Hulen", Password: "pwd"}
+	user = Client.Must(Client.CreateUser(user, "")).Data.(*model.User)
+	store.Must(Srv.Store.User().VerifyEmail(user.Id))
+
+	Client.LoginByEmail(team.Name, user.Email, "pwd")
+
+	channel1 := &model.Channel{DisplayName: "Test API Name", Name: "a" + model.NewId() + "a", Type: model.CHANNEL_OPEN, TeamId: team.Id}
+	channel1 = Client.Must(Client.CreateChannel(channel1)).Data.(*model.Channel)
+
+	if utils.Cfg.ServiceSettings.EnableOutgoingWebhooks {
+		hook := &model.OutgoingWebhook{ChannelId: channel1.Id, CallbackURLs: []string{"http://nowhere.com"}}
+		hook = Client.Must(Client.CreateOutgoingWebhook(hook)).Data.(*model.OutgoingWebhook)
+
+		data := make(map[string]string)
+		data["id"] = hook.Id
+
+		if _, err := Client.DeleteOutgoingWebhook(data); err != nil {
+			t.Fatal(err)
+		}
+
+		hooks := Client.Must(Client.ListOutgoingWebhooks()).Data.([]*model.OutgoingWebhook)
+		if len(hooks) != 0 {
+			t.Fatal("delete didn't work properly")
+		}
+	} else {
+		data := make(map[string]string)
+		data["id"] = "123"
+
+		if _, err := Client.DeleteOutgoingWebhook(data); err == nil {
+			t.Fatal("should have errored - webhooks turned off")
+		}
+	}
+}
+
+func TestRegenOutgoingHookToken(t *testing.T) {
+	Setup()
+
+	team := &model.Team{DisplayName: "Name", Name: "z-z-" + model.NewId() + "a", Email: "test@nowhere.com", Type: model.TEAM_OPEN}
+	team = Client.Must(Client.CreateTeam(team)).Data.(*model.Team)
+
+	user := &model.User{TeamId: team.Id, Email: model.NewId() + "corey@test.com", Nickname: "Corey Hulen", Password: "pwd"}
+	user = Client.Must(Client.CreateUser(user, "")).Data.(*model.User)
+	store.Must(Srv.Store.User().VerifyEmail(user.Id))
+
+	Client.LoginByEmail(team.Name, user.Email, "pwd")
+
+	channel1 := &model.Channel{DisplayName: "Test API Name", Name: "a" + model.NewId() + "a", Type: model.CHANNEL_OPEN, TeamId: team.Id}
+	channel1 = Client.Must(Client.CreateChannel(channel1)).Data.(*model.Channel)
+
+	if utils.Cfg.ServiceSettings.EnableOutgoingWebhooks {
+		hook := &model.OutgoingWebhook{ChannelId: channel1.Id, CallbackURLs: []string{"http://nowhere.com"}}
+		hook = Client.Must(Client.CreateOutgoingWebhook(hook)).Data.(*model.OutgoingWebhook)
+
+		data := make(map[string]string)
+		data["id"] = hook.Id
+
+		if result, err := Client.RegenOutgoingWebhookToken(data); err != nil {
+			t.Fatal(err)
+		} else {
+			if result.Data.(*model.OutgoingWebhook).Token == hook.Token {
+				t.Fatal("regen didn't work properly")
+			}
+		}
+
+	} else {
+		data := make(map[string]string)
+		data["id"] = "123"
+
+		if _, err := Client.RegenOutgoingWebhookToken(data); err == nil {
+			t.Fatal("should have errored - webhooks turned off")
+		}
+	}
+}
+
 func TestZZWebSocketTearDown(t *testing.T) {
 	// *IMPORTANT* - Kind of hacky
 	// This should be the last function in any test file