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 }