github.com/psyb0t/mattermost-server@v4.6.1-0.20180125161845-5503a1351abf+incompatible/app/webhook.go (about)

     1  // Copyright (c) 2016-present Mattermost, Inc. All Rights Reserved.
     2  // See License.txt for license information.
     3  
     4  package app
     5  
     6  import (
     7  	"io"
     8  	"net/http"
     9  	"regexp"
    10  	"strings"
    11  	"unicode/utf8"
    12  
    13  	l4g "github.com/alecthomas/log4go"
    14  	"github.com/mattermost/mattermost-server/model"
    15  	"github.com/mattermost/mattermost-server/store"
    16  	"github.com/mattermost/mattermost-server/utils"
    17  )
    18  
    19  const (
    20  	TRIGGERWORDS_EXACT_MATCH = 0
    21  	TRIGGERWORDS_STARTS_WITH = 1
    22  )
    23  
    24  func (a *App) handleWebhookEvents(post *model.Post, team *model.Team, channel *model.Channel, user *model.User) *model.AppError {
    25  	if !a.Config().ServiceSettings.EnableOutgoingWebhooks {
    26  		return nil
    27  	}
    28  
    29  	if channel.Type != model.CHANNEL_OPEN {
    30  		return nil
    31  	}
    32  
    33  	hchan := a.Srv.Store.Webhook().GetOutgoingByTeam(team.Id, -1, -1)
    34  	result := <-hchan
    35  	if result.Err != nil {
    36  		return result.Err
    37  	}
    38  
    39  	hooks := result.Data.([]*model.OutgoingWebhook)
    40  	if len(hooks) == 0 {
    41  		return nil
    42  	}
    43  
    44  	var firstWord, triggerWord string
    45  
    46  	splitWords := strings.Fields(post.Message)
    47  	if len(splitWords) > 0 {
    48  		firstWord = splitWords[0]
    49  	}
    50  
    51  	relevantHooks := []*model.OutgoingWebhook{}
    52  	for _, hook := range hooks {
    53  		if hook.ChannelId == post.ChannelId || len(hook.ChannelId) == 0 {
    54  			if hook.ChannelId == post.ChannelId && len(hook.TriggerWords) == 0 {
    55  				relevantHooks = append(relevantHooks, hook)
    56  				triggerWord = ""
    57  			} else if hook.TriggerWhen == TRIGGERWORDS_EXACT_MATCH && hook.TriggerWordExactMatch(firstWord) {
    58  				relevantHooks = append(relevantHooks, hook)
    59  				triggerWord = hook.GetTriggerWord(firstWord, true)
    60  			} else if hook.TriggerWhen == TRIGGERWORDS_STARTS_WITH && hook.TriggerWordStartsWith(firstWord) {
    61  				relevantHooks = append(relevantHooks, hook)
    62  				triggerWord = hook.GetTriggerWord(firstWord, false)
    63  			}
    64  		}
    65  	}
    66  
    67  	for _, hook := range relevantHooks {
    68  		payload := &model.OutgoingWebhookPayload{
    69  			Token:       hook.Token,
    70  			TeamId:      hook.TeamId,
    71  			TeamDomain:  team.Name,
    72  			ChannelId:   post.ChannelId,
    73  			ChannelName: channel.Name,
    74  			Timestamp:   post.CreateAt,
    75  			UserId:      post.UserId,
    76  			UserName:    user.Username,
    77  			PostId:      post.Id,
    78  			Text:        post.Message,
    79  			TriggerWord: triggerWord,
    80  			FileIds:     strings.Join(post.FileIds, ","),
    81  		}
    82  		a.Go(func(hook *model.OutgoingWebhook) func() {
    83  			return func() {
    84  				a.TriggerWebhook(payload, hook, post, channel)
    85  			}
    86  		}(hook))
    87  	}
    88  
    89  	return nil
    90  }
    91  
    92  func (a *App) TriggerWebhook(payload *model.OutgoingWebhookPayload, hook *model.OutgoingWebhook, post *model.Post, channel *model.Channel) {
    93  	var body io.Reader
    94  	var contentType string
    95  	if hook.ContentType == "application/json" {
    96  		body = strings.NewReader(payload.ToJSON())
    97  		contentType = "application/json"
    98  	} else {
    99  		body = strings.NewReader(payload.ToFormValues())
   100  		contentType = "application/x-www-form-urlencoded"
   101  	}
   102  
   103  	for _, url := range hook.CallbackURLs {
   104  		a.Go(func(url string) func() {
   105  			return func() {
   106  				req, _ := http.NewRequest("POST", url, body)
   107  				req.Header.Set("Content-Type", contentType)
   108  				req.Header.Set("Accept", "application/json")
   109  				if resp, err := a.HTTPClient(false).Do(req); err != nil {
   110  					l4g.Error(utils.T("api.post.handle_webhook_events_and_forget.event_post.error"), err.Error())
   111  				} else {
   112  					defer consumeAndClose(resp)
   113  
   114  					webhookResp := model.OutgoingWebhookResponseFromJson(resp.Body)
   115  
   116  					if webhookResp != nil && webhookResp.Text != nil {
   117  						postRootId := ""
   118  						if webhookResp.ResponseType == model.OUTGOING_HOOK_RESPONSE_TYPE_COMMENT {
   119  							postRootId = post.Id
   120  						}
   121  						if len(webhookResp.Props) == 0 {
   122  							webhookResp.Props = make(model.StringInterface)
   123  						}
   124  						webhookResp.Props["webhook_display_name"] = hook.DisplayName
   125  						if _, err := a.CreateWebhookPost(hook.CreatorId, channel, *webhookResp.Text, webhookResp.Username, webhookResp.IconURL, webhookResp.Props, webhookResp.Type, postRootId); err != nil {
   126  							l4g.Error(utils.T("api.post.handle_webhook_events_and_forget.create_post.error"), err)
   127  						}
   128  					}
   129  				}
   130  			}
   131  		}(url))
   132  	}
   133  }
   134  
   135  func SplitWebhookPost(post *model.Post) ([]*model.Post, *model.AppError) {
   136  	splits := make([]*model.Post, 0)
   137  	remainingText := post.Message
   138  
   139  	base := *post
   140  	base.Message = ""
   141  	base.Props = make(map[string]interface{})
   142  	for k, v := range post.Props {
   143  		if k != "attachments" {
   144  			base.Props[k] = v
   145  		}
   146  	}
   147  	if utf8.RuneCountInString(model.StringInterfaceToJson(base.Props)) > model.POST_PROPS_MAX_USER_RUNES {
   148  		return nil, model.NewAppError("SplitWebhookPost", "web.incoming_webhook.split_props_length.app_error", map[string]interface{}{"Max": model.POST_PROPS_MAX_USER_RUNES}, "", http.StatusBadRequest)
   149  	}
   150  
   151  	for utf8.RuneCountInString(remainingText) > model.POST_MESSAGE_MAX_RUNES {
   152  		split := base
   153  		x := 0
   154  		for index := range remainingText {
   155  			x++
   156  			if x > model.POST_MESSAGE_MAX_RUNES {
   157  				split.Message = remainingText[:index]
   158  				remainingText = remainingText[index:]
   159  				break
   160  			}
   161  		}
   162  		splits = append(splits, &split)
   163  	}
   164  
   165  	split := base
   166  	split.Message = remainingText
   167  	splits = append(splits, &split)
   168  
   169  	attachments, _ := post.Props["attachments"].([]*model.SlackAttachment)
   170  	for _, attachment := range attachments {
   171  		newAttachment := *attachment
   172  		for {
   173  			lastSplit := splits[len(splits)-1]
   174  			newProps := make(map[string]interface{})
   175  			for k, v := range lastSplit.Props {
   176  				newProps[k] = v
   177  			}
   178  			origAttachments, _ := newProps["attachments"].([]*model.SlackAttachment)
   179  			newProps["attachments"] = append(origAttachments, &newAttachment)
   180  			newPropsString := model.StringInterfaceToJson(newProps)
   181  			runeCount := utf8.RuneCountInString(newPropsString)
   182  
   183  			if runeCount <= model.POST_PROPS_MAX_USER_RUNES {
   184  				lastSplit.Props = newProps
   185  				break
   186  			}
   187  
   188  			if len(origAttachments) > 0 {
   189  				newSplit := base
   190  				splits = append(splits, &newSplit)
   191  				continue
   192  			}
   193  
   194  			truncationNeeded := runeCount - model.POST_PROPS_MAX_USER_RUNES
   195  			textRuneCount := utf8.RuneCountInString(attachment.Text)
   196  			if textRuneCount < truncationNeeded {
   197  				return nil, model.NewAppError("SplitWebhookPost", "web.incoming_webhook.split_props_length.app_error", map[string]interface{}{"Max": model.POST_PROPS_MAX_USER_RUNES}, "", http.StatusBadRequest)
   198  			}
   199  			x := 0
   200  			for index := range attachment.Text {
   201  				x++
   202  				if x > textRuneCount-truncationNeeded {
   203  					newAttachment.Text = newAttachment.Text[:index]
   204  					break
   205  				}
   206  			}
   207  			lastSplit.Props = newProps
   208  			break
   209  		}
   210  	}
   211  
   212  	return splits, nil
   213  }
   214  
   215  func (a *App) CreateWebhookPost(userId string, channel *model.Channel, text, overrideUsername, overrideIconUrl string, props model.StringInterface, postType string, postRootId string) (*model.Post, *model.AppError) {
   216  	// parse links into Markdown format
   217  	linkWithTextRegex := regexp.MustCompile(`<([^<\|]+)\|([^>]+)>`)
   218  	text = linkWithTextRegex.ReplaceAllString(text, "[${2}](${1})")
   219  
   220  	post := &model.Post{UserId: userId, ChannelId: channel.Id, Message: text, Type: postType, RootId: postRootId}
   221  	post.AddProp("from_webhook", "true")
   222  
   223  	if strings.HasPrefix(post.Type, model.POST_SYSTEM_MESSAGE_PREFIX) {
   224  		err := model.NewAppError("CreateWebhookPost", "api.context.invalid_param.app_error", map[string]interface{}{"Name": "post.type"}, "", http.StatusBadRequest)
   225  		return nil, err
   226  	}
   227  
   228  	if metrics := a.Metrics; metrics != nil {
   229  		metrics.IncrementWebhookPost()
   230  	}
   231  
   232  	if a.Config().ServiceSettings.EnablePostUsernameOverride {
   233  		if len(overrideUsername) != 0 {
   234  			post.AddProp("override_username", overrideUsername)
   235  		} else {
   236  			post.AddProp("override_username", model.DEFAULT_WEBHOOK_USERNAME)
   237  		}
   238  	}
   239  
   240  	if a.Config().ServiceSettings.EnablePostIconOverride {
   241  		if len(overrideIconUrl) != 0 {
   242  			post.AddProp("override_icon_url", overrideIconUrl)
   243  		}
   244  	}
   245  
   246  	if len(props) > 0 {
   247  		for key, val := range props {
   248  			if key == "attachments" {
   249  				if attachments, success := val.([]*model.SlackAttachment); success {
   250  					parseSlackAttachment(post, attachments)
   251  				}
   252  			} else if key != "override_icon_url" && key != "override_username" && key != "from_webhook" {
   253  				post.AddProp(key, val)
   254  			}
   255  		}
   256  	}
   257  
   258  	splits, err := SplitWebhookPost(post)
   259  	if err != nil {
   260  		return nil, err
   261  	}
   262  
   263  	for _, split := range splits {
   264  		if _, err := a.CreatePostMissingChannel(split, false); err != nil {
   265  			return nil, model.NewAppError("CreateWebhookPost", "api.post.create_webhook_post.creating.app_error", nil, "err="+err.Message, http.StatusInternalServerError)
   266  		}
   267  	}
   268  
   269  	return splits[0], nil
   270  }
   271  
   272  func (a *App) CreateIncomingWebhookForChannel(creatorId string, channel *model.Channel, hook *model.IncomingWebhook) (*model.IncomingWebhook, *model.AppError) {
   273  	if !a.Config().ServiceSettings.EnableIncomingWebhooks {
   274  		return nil, model.NewAppError("CreateIncomingWebhookForChannel", "api.incoming_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
   275  	}
   276  
   277  	hook.UserId = creatorId
   278  	hook.TeamId = channel.TeamId
   279  
   280  	if !a.Config().ServiceSettings.EnablePostUsernameOverride {
   281  		hook.Username = ""
   282  	}
   283  	if !a.Config().ServiceSettings.EnablePostIconOverride {
   284  		hook.IconURL = ""
   285  	}
   286  
   287  	if hook.Username != "" && !model.IsValidUsername(hook.Username) {
   288  		return nil, model.NewAppError("CreateIncomingWebhookForChannel", "api.incoming_webhook.invalid_username.app_error", nil, "", http.StatusBadRequest)
   289  	}
   290  
   291  	if result := <-a.Srv.Store.Webhook().SaveIncoming(hook); result.Err != nil {
   292  		return nil, result.Err
   293  	} else {
   294  		return result.Data.(*model.IncomingWebhook), nil
   295  	}
   296  }
   297  
   298  func (a *App) UpdateIncomingWebhook(oldHook, updatedHook *model.IncomingWebhook) (*model.IncomingWebhook, *model.AppError) {
   299  	if !a.Config().ServiceSettings.EnableIncomingWebhooks {
   300  		return nil, model.NewAppError("UpdateIncomingWebhook", "api.incoming_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
   301  	}
   302  
   303  	if !a.Config().ServiceSettings.EnablePostUsernameOverride {
   304  		updatedHook.Username = oldHook.Username
   305  	}
   306  	if !a.Config().ServiceSettings.EnablePostIconOverride {
   307  		updatedHook.IconURL = oldHook.IconURL
   308  	}
   309  
   310  	if updatedHook.Username != "" && !model.IsValidUsername(updatedHook.Username) {
   311  		return nil, model.NewAppError("UpdateIncomingWebhook", "api.incoming_webhook.invalid_username.app_error", nil, "", http.StatusBadRequest)
   312  	}
   313  
   314  	updatedHook.Id = oldHook.Id
   315  	updatedHook.UserId = oldHook.UserId
   316  	updatedHook.CreateAt = oldHook.CreateAt
   317  	updatedHook.UpdateAt = model.GetMillis()
   318  	updatedHook.TeamId = oldHook.TeamId
   319  	updatedHook.DeleteAt = oldHook.DeleteAt
   320  
   321  	if result := <-a.Srv.Store.Webhook().UpdateIncoming(updatedHook); result.Err != nil {
   322  		return nil, result.Err
   323  	} else {
   324  		a.InvalidateCacheForWebhook(oldHook.Id)
   325  		return result.Data.(*model.IncomingWebhook), nil
   326  	}
   327  }
   328  
   329  func (a *App) DeleteIncomingWebhook(hookId string) *model.AppError {
   330  	if !a.Config().ServiceSettings.EnableIncomingWebhooks {
   331  		return model.NewAppError("DeleteIncomingWebhook", "api.incoming_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
   332  	}
   333  
   334  	if result := <-a.Srv.Store.Webhook().DeleteIncoming(hookId, model.GetMillis()); result.Err != nil {
   335  		return result.Err
   336  	}
   337  
   338  	a.InvalidateCacheForWebhook(hookId)
   339  
   340  	return nil
   341  }
   342  
   343  func (a *App) GetIncomingWebhook(hookId string) (*model.IncomingWebhook, *model.AppError) {
   344  	if !a.Config().ServiceSettings.EnableIncomingWebhooks {
   345  		return nil, model.NewAppError("GetIncomingWebhook", "api.incoming_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
   346  	}
   347  
   348  	if result := <-a.Srv.Store.Webhook().GetIncoming(hookId, true); result.Err != nil {
   349  		return nil, result.Err
   350  	} else {
   351  		return result.Data.(*model.IncomingWebhook), nil
   352  	}
   353  }
   354  
   355  func (a *App) GetIncomingWebhooksForTeamPage(teamId string, page, perPage int) ([]*model.IncomingWebhook, *model.AppError) {
   356  	if !a.Config().ServiceSettings.EnableIncomingWebhooks {
   357  		return nil, model.NewAppError("GetIncomingWebhooksForTeamPage", "api.incoming_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
   358  	}
   359  
   360  	if result := <-a.Srv.Store.Webhook().GetIncomingByTeam(teamId, page*perPage, perPage); result.Err != nil {
   361  		return nil, result.Err
   362  	} else {
   363  		return result.Data.([]*model.IncomingWebhook), nil
   364  	}
   365  }
   366  
   367  func (a *App) GetIncomingWebhooksPage(page, perPage int) ([]*model.IncomingWebhook, *model.AppError) {
   368  	if !a.Config().ServiceSettings.EnableIncomingWebhooks {
   369  		return nil, model.NewAppError("GetIncomingWebhooksPage", "api.incoming_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
   370  	}
   371  
   372  	if result := <-a.Srv.Store.Webhook().GetIncomingList(page*perPage, perPage); result.Err != nil {
   373  		return nil, result.Err
   374  	} else {
   375  		return result.Data.([]*model.IncomingWebhook), nil
   376  	}
   377  }
   378  
   379  func (a *App) CreateOutgoingWebhook(hook *model.OutgoingWebhook) (*model.OutgoingWebhook, *model.AppError) {
   380  	if !a.Config().ServiceSettings.EnableOutgoingWebhooks {
   381  		return nil, model.NewAppError("CreateOutgoingWebhook", "api.outgoing_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
   382  	}
   383  
   384  	if len(hook.ChannelId) != 0 {
   385  		cchan := a.Srv.Store.Channel().Get(hook.ChannelId, true)
   386  
   387  		var channel *model.Channel
   388  		if result := <-cchan; result.Err != nil {
   389  			return nil, result.Err
   390  		} else {
   391  			channel = result.Data.(*model.Channel)
   392  		}
   393  
   394  		if channel.Type != model.CHANNEL_OPEN {
   395  			return nil, model.NewAppError("CreateOutgoingWebhook", "api.outgoing_webhook.disabled.app_error", nil, "", http.StatusForbidden)
   396  		}
   397  
   398  		if channel.Type != model.CHANNEL_OPEN || channel.TeamId != hook.TeamId {
   399  			return nil, model.NewAppError("CreateOutgoingWebhook", "api.webhook.create_outgoing.permissions.app_error", nil, "", http.StatusForbidden)
   400  		}
   401  	} else if len(hook.TriggerWords) == 0 {
   402  		return nil, model.NewAppError("CreateOutgoingWebhook", "api.webhook.create_outgoing.triggers.app_error", nil, "", http.StatusBadRequest)
   403  	}
   404  
   405  	if result := <-a.Srv.Store.Webhook().GetOutgoingByTeam(hook.TeamId, -1, -1); result.Err != nil {
   406  		return nil, result.Err
   407  	} else {
   408  		allHooks := result.Data.([]*model.OutgoingWebhook)
   409  
   410  		for _, existingOutHook := range allHooks {
   411  			urlIntersect := utils.StringArrayIntersection(existingOutHook.CallbackURLs, hook.CallbackURLs)
   412  			triggerIntersect := utils.StringArrayIntersection(existingOutHook.TriggerWords, hook.TriggerWords)
   413  
   414  			if existingOutHook.ChannelId == hook.ChannelId && len(urlIntersect) != 0 && len(triggerIntersect) != 0 {
   415  				return nil, model.NewAppError("CreateOutgoingWebhook", "api.webhook.create_outgoing.intersect.app_error", nil, "", http.StatusInternalServerError)
   416  			}
   417  		}
   418  	}
   419  
   420  	if result := <-a.Srv.Store.Webhook().SaveOutgoing(hook); result.Err != nil {
   421  		return nil, result.Err
   422  	} else {
   423  		return result.Data.(*model.OutgoingWebhook), nil
   424  	}
   425  }
   426  
   427  func (a *App) UpdateOutgoingWebhook(oldHook, updatedHook *model.OutgoingWebhook) (*model.OutgoingWebhook, *model.AppError) {
   428  	if !a.Config().ServiceSettings.EnableOutgoingWebhooks {
   429  		return nil, model.NewAppError("UpdateOutgoingWebhook", "api.outgoing_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
   430  	}
   431  
   432  	if len(updatedHook.ChannelId) > 0 {
   433  		channel, err := a.GetChannel(updatedHook.ChannelId)
   434  		if err != nil {
   435  			return nil, err
   436  		}
   437  
   438  		if channel.Type != model.CHANNEL_OPEN {
   439  			return nil, model.NewAppError("UpdateOutgoingWebhook", "api.webhook.create_outgoing.not_open.app_error", nil, "", http.StatusForbidden)
   440  		}
   441  
   442  		if channel.TeamId != oldHook.TeamId {
   443  			return nil, model.NewAppError("UpdateOutgoingWebhook", "api.webhook.create_outgoing.permissions.app_error", nil, "", http.StatusForbidden)
   444  		}
   445  	} else if len(updatedHook.TriggerWords) == 0 {
   446  		return nil, model.NewAppError("UpdateOutgoingWebhook", "api.webhook.create_outgoing.triggers.app_error", nil, "", http.StatusInternalServerError)
   447  	}
   448  
   449  	var result store.StoreResult
   450  	if result = <-a.Srv.Store.Webhook().GetOutgoingByTeam(oldHook.TeamId, -1, -1); result.Err != nil {
   451  		return nil, result.Err
   452  	}
   453  
   454  	allHooks := result.Data.([]*model.OutgoingWebhook)
   455  
   456  	for _, existingOutHook := range allHooks {
   457  		urlIntersect := utils.StringArrayIntersection(existingOutHook.CallbackURLs, updatedHook.CallbackURLs)
   458  		triggerIntersect := utils.StringArrayIntersection(existingOutHook.TriggerWords, updatedHook.TriggerWords)
   459  
   460  		if existingOutHook.ChannelId == updatedHook.ChannelId && len(urlIntersect) != 0 && len(triggerIntersect) != 0 && existingOutHook.Id != updatedHook.Id {
   461  			return nil, model.NewAppError("UpdateOutgoingWebhook", "api.webhook.update_outgoing.intersect.app_error", nil, "", http.StatusBadRequest)
   462  		}
   463  	}
   464  
   465  	updatedHook.CreatorId = oldHook.CreatorId
   466  	updatedHook.CreateAt = oldHook.CreateAt
   467  	updatedHook.DeleteAt = oldHook.DeleteAt
   468  	updatedHook.TeamId = oldHook.TeamId
   469  	updatedHook.UpdateAt = model.GetMillis()
   470  
   471  	if result = <-a.Srv.Store.Webhook().UpdateOutgoing(updatedHook); result.Err != nil {
   472  		return nil, result.Err
   473  	} else {
   474  		return result.Data.(*model.OutgoingWebhook), nil
   475  	}
   476  }
   477  
   478  func (a *App) GetOutgoingWebhook(hookId string) (*model.OutgoingWebhook, *model.AppError) {
   479  	if !a.Config().ServiceSettings.EnableOutgoingWebhooks {
   480  		return nil, model.NewAppError("GetOutgoingWebhook", "api.outgoing_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
   481  	}
   482  
   483  	if result := <-a.Srv.Store.Webhook().GetOutgoing(hookId); result.Err != nil {
   484  		return nil, result.Err
   485  	} else {
   486  		return result.Data.(*model.OutgoingWebhook), nil
   487  	}
   488  }
   489  
   490  func (a *App) GetOutgoingWebhooksPage(page, perPage int) ([]*model.OutgoingWebhook, *model.AppError) {
   491  	if !a.Config().ServiceSettings.EnableOutgoingWebhooks {
   492  		return nil, model.NewAppError("GetOutgoingWebhooksPage", "api.outgoing_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
   493  	}
   494  
   495  	if result := <-a.Srv.Store.Webhook().GetOutgoingList(page*perPage, perPage); result.Err != nil {
   496  		return nil, result.Err
   497  	} else {
   498  		return result.Data.([]*model.OutgoingWebhook), nil
   499  	}
   500  }
   501  
   502  func (a *App) GetOutgoingWebhooksForChannelPage(channelId string, page, perPage int) ([]*model.OutgoingWebhook, *model.AppError) {
   503  	if !a.Config().ServiceSettings.EnableOutgoingWebhooks {
   504  		return nil, model.NewAppError("GetOutgoingWebhooksForChannelPage", "api.outgoing_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
   505  	}
   506  
   507  	if result := <-a.Srv.Store.Webhook().GetOutgoingByChannel(channelId, page*perPage, perPage); result.Err != nil {
   508  		return nil, result.Err
   509  	} else {
   510  		return result.Data.([]*model.OutgoingWebhook), nil
   511  	}
   512  }
   513  
   514  func (a *App) GetOutgoingWebhooksForTeamPage(teamId string, page, perPage int) ([]*model.OutgoingWebhook, *model.AppError) {
   515  	if !a.Config().ServiceSettings.EnableOutgoingWebhooks {
   516  		return nil, model.NewAppError("GetOutgoingWebhooksForTeamPage", "api.outgoing_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
   517  	}
   518  
   519  	if result := <-a.Srv.Store.Webhook().GetOutgoingByTeam(teamId, page*perPage, perPage); result.Err != nil {
   520  		return nil, result.Err
   521  	} else {
   522  		return result.Data.([]*model.OutgoingWebhook), nil
   523  	}
   524  }
   525  
   526  func (a *App) DeleteOutgoingWebhook(hookId string) *model.AppError {
   527  	if !a.Config().ServiceSettings.EnableOutgoingWebhooks {
   528  		return model.NewAppError("DeleteOutgoingWebhook", "api.outgoing_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
   529  	}
   530  
   531  	if result := <-a.Srv.Store.Webhook().DeleteOutgoing(hookId, model.GetMillis()); result.Err != nil {
   532  		return result.Err
   533  	}
   534  
   535  	return nil
   536  }
   537  
   538  func (a *App) RegenOutgoingWebhookToken(hook *model.OutgoingWebhook) (*model.OutgoingWebhook, *model.AppError) {
   539  	if !a.Config().ServiceSettings.EnableOutgoingWebhooks {
   540  		return nil, model.NewAppError("RegenOutgoingWebhookToken", "api.outgoing_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
   541  	}
   542  
   543  	hook.Token = model.NewId()
   544  
   545  	if result := <-a.Srv.Store.Webhook().UpdateOutgoing(hook); result.Err != nil {
   546  		return nil, result.Err
   547  	} else {
   548  		return result.Data.(*model.OutgoingWebhook), nil
   549  	}
   550  }
   551  
   552  func (a *App) HandleIncomingWebhook(hookId string, req *model.IncomingWebhookRequest) *model.AppError {
   553  	if !a.Config().ServiceSettings.EnableIncomingWebhooks {
   554  		return model.NewAppError("HandleIncomingWebhook", "web.incoming_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
   555  	}
   556  
   557  	hchan := a.Srv.Store.Webhook().GetIncoming(hookId, true)
   558  
   559  	if req == nil {
   560  		return model.NewAppError("HandleIncomingWebhook", "web.incoming_webhook.parse.app_error", nil, "", http.StatusBadRequest)
   561  	}
   562  
   563  	text := req.Text
   564  	if len(text) == 0 && req.Attachments == nil {
   565  		return model.NewAppError("HandleIncomingWebhook", "web.incoming_webhook.text.app_error", nil, "", http.StatusBadRequest)
   566  	}
   567  
   568  	channelName := req.ChannelName
   569  	webhookType := req.Type
   570  
   571  	var hook *model.IncomingWebhook
   572  	if result := <-hchan; result.Err != nil {
   573  		return model.NewAppError("HandleIncomingWebhook", "web.incoming_webhook.invalid.app_error", nil, "err="+result.Err.Message, http.StatusBadRequest)
   574  	} else {
   575  		hook = result.Data.(*model.IncomingWebhook)
   576  	}
   577  
   578  	if len(req.Props) == 0 {
   579  		req.Props = make(model.StringInterface)
   580  	}
   581  
   582  	req.Props["webhook_display_name"] = hook.DisplayName
   583  
   584  	text = a.ProcessSlackText(text)
   585  	req.Attachments = a.ProcessSlackAttachments(req.Attachments)
   586  	// attachments is in here for slack compatibility
   587  	if len(req.Attachments) > 0 {
   588  		req.Props["attachments"] = req.Attachments
   589  		webhookType = model.POST_SLACK_ATTACHMENT
   590  	}
   591  
   592  	var channel *model.Channel
   593  	var cchan store.StoreChannel
   594  
   595  	if len(channelName) != 0 {
   596  		if channelName[0] == '@' {
   597  			if result := <-a.Srv.Store.User().GetByUsername(channelName[1:]); result.Err != nil {
   598  				return model.NewAppError("HandleIncomingWebhook", "web.incoming_webhook.user.app_error", nil, "err="+result.Err.Message, http.StatusBadRequest)
   599  			} else {
   600  				if ch, err := a.GetDirectChannel(hook.UserId, result.Data.(*model.User).Id); err != nil {
   601  					return err
   602  				} else {
   603  					channel = ch
   604  				}
   605  			}
   606  		} else if channelName[0] == '#' {
   607  			cchan = a.Srv.Store.Channel().GetByName(hook.TeamId, channelName[1:], true)
   608  		} else {
   609  			cchan = a.Srv.Store.Channel().GetByName(hook.TeamId, channelName, true)
   610  		}
   611  	} else {
   612  		cchan = a.Srv.Store.Channel().Get(hook.ChannelId, true)
   613  	}
   614  
   615  	if channel == nil {
   616  		result := <-cchan
   617  		if result.Err != nil {
   618  			return model.NewAppError("HandleIncomingWebhook", "web.incoming_webhook.channel.app_error", nil, "err="+result.Err.Message, result.Err.StatusCode)
   619  		} else {
   620  			channel = result.Data.(*model.Channel)
   621  		}
   622  	}
   623  
   624  	if utils.IsLicensed() && *a.Config().TeamSettings.ExperimentalTownSquareIsReadOnly &&
   625  		channel.Name == model.DEFAULT_CHANNEL {
   626  		return model.NewAppError("HandleIncomingWebhook", "api.post.create_post.town_square_read_only", nil, "", http.StatusForbidden)
   627  	}
   628  
   629  	if channel.Type != model.CHANNEL_OPEN && !a.HasPermissionToChannel(hook.UserId, channel.Id, model.PERMISSION_READ_CHANNEL) {
   630  		return model.NewAppError("HandleIncomingWebhook", "web.incoming_webhook.permissions.app_error", nil, "", http.StatusForbidden)
   631  	}
   632  
   633  	overrideUsername := hook.Username
   634  	if req.Username != "" {
   635  		overrideUsername = req.Username
   636  	}
   637  
   638  	overrideIconUrl := hook.IconURL
   639  	if req.IconURL != "" {
   640  		overrideIconUrl = req.IconURL
   641  	}
   642  
   643  	_, err := a.CreateWebhookPost(hook.UserId, channel, text, overrideUsername, overrideIconUrl, req.Props, webhookType, "")
   644  	return err
   645  }
   646  
   647  func (a *App) CreateCommandWebhook(commandId string, args *model.CommandArgs) (*model.CommandWebhook, *model.AppError) {
   648  	hook := &model.CommandWebhook{
   649  		CommandId: commandId,
   650  		UserId:    args.UserId,
   651  		ChannelId: args.ChannelId,
   652  		RootId:    args.RootId,
   653  		ParentId:  args.ParentId,
   654  	}
   655  
   656  	if result := <-a.Srv.Store.CommandWebhook().Save(hook); result.Err != nil {
   657  		return nil, result.Err
   658  	} else {
   659  		return result.Data.(*model.CommandWebhook), nil
   660  	}
   661  }
   662  
   663  func (a *App) HandleCommandWebhook(hookId string, response *model.CommandResponse) *model.AppError {
   664  	if response == nil {
   665  		return model.NewAppError("HandleCommandWebhook", "web.command_webhook.parse.app_error", nil, "", http.StatusBadRequest)
   666  	}
   667  
   668  	var hook *model.CommandWebhook
   669  	if result := <-a.Srv.Store.CommandWebhook().Get(hookId); result.Err != nil {
   670  		return model.NewAppError("HandleCommandWebhook", "web.command_webhook.invalid.app_error", nil, "err="+result.Err.Message, result.Err.StatusCode)
   671  	} else {
   672  		hook = result.Data.(*model.CommandWebhook)
   673  	}
   674  
   675  	var cmd *model.Command
   676  	if result := <-a.Srv.Store.Command().Get(hook.CommandId); result.Err != nil {
   677  		return model.NewAppError("HandleCommandWebhook", "web.command_webhook.command.app_error", nil, "err="+result.Err.Message, http.StatusBadRequest)
   678  	} else {
   679  		cmd = result.Data.(*model.Command)
   680  	}
   681  
   682  	args := &model.CommandArgs{
   683  		UserId:    hook.UserId,
   684  		ChannelId: hook.ChannelId,
   685  		TeamId:    cmd.TeamId,
   686  		RootId:    hook.RootId,
   687  		ParentId:  hook.ParentId,
   688  	}
   689  
   690  	if result := <-a.Srv.Store.CommandWebhook().TryUse(hook.Id, 5); result.Err != nil {
   691  		return model.NewAppError("HandleCommandWebhook", "web.command_webhook.invalid.app_error", nil, "err="+result.Err.Message, result.Err.StatusCode)
   692  	}
   693  
   694  	_, err := a.HandleCommandResponse(cmd, args, response, false)
   695  	return err
   696  }