github.com/mattermosttest/mattermost-server/v5@v5.0.0-20200917143240-9dfa12e121f9/api4/webhook.go (about) 1 // Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved. 2 // See LICENSE.txt for license information. 3 4 package api4 5 6 import ( 7 "net/http" 8 9 "github.com/mattermost/mattermost-server/v5/audit" 10 "github.com/mattermost/mattermost-server/v5/model" 11 ) 12 13 func (api *API) InitWebhook() { 14 api.BaseRoutes.IncomingHooks.Handle("", api.ApiSessionRequired(createIncomingHook)).Methods("POST") 15 api.BaseRoutes.IncomingHooks.Handle("", api.ApiSessionRequired(getIncomingHooks)).Methods("GET") 16 api.BaseRoutes.IncomingHook.Handle("", api.ApiSessionRequired(getIncomingHook)).Methods("GET") 17 api.BaseRoutes.IncomingHook.Handle("", api.ApiSessionRequired(updateIncomingHook)).Methods("PUT") 18 api.BaseRoutes.IncomingHook.Handle("", api.ApiSessionRequired(deleteIncomingHook)).Methods("DELETE") 19 20 api.BaseRoutes.OutgoingHooks.Handle("", api.ApiSessionRequired(createOutgoingHook)).Methods("POST") 21 api.BaseRoutes.OutgoingHooks.Handle("", api.ApiSessionRequired(getOutgoingHooks)).Methods("GET") 22 api.BaseRoutes.OutgoingHook.Handle("", api.ApiSessionRequired(getOutgoingHook)).Methods("GET") 23 api.BaseRoutes.OutgoingHook.Handle("", api.ApiSessionRequired(updateOutgoingHook)).Methods("PUT") 24 api.BaseRoutes.OutgoingHook.Handle("", api.ApiSessionRequired(deleteOutgoingHook)).Methods("DELETE") 25 api.BaseRoutes.OutgoingHook.Handle("/regen_token", api.ApiSessionRequired(regenOutgoingHookToken)).Methods("POST") 26 } 27 28 func createIncomingHook(c *Context, w http.ResponseWriter, r *http.Request) { 29 hook := model.IncomingWebhookFromJson(r.Body) 30 if hook == nil { 31 c.SetInvalidParam("incoming_webhook") 32 return 33 } 34 35 channel, err := c.App.GetChannel(hook.ChannelId) 36 if err != nil { 37 c.Err = err 38 return 39 } 40 41 auditRec := c.MakeAuditRecord("createIncomingHook", audit.Fail) 42 defer c.LogAuditRec(auditRec) 43 auditRec.AddMeta("channel", channel) 44 c.LogAudit("attempt") 45 46 if !c.App.SessionHasPermissionToTeam(*c.App.Session(), channel.TeamId, model.PERMISSION_MANAGE_INCOMING_WEBHOOKS) { 47 c.SetPermissionError(model.PERMISSION_MANAGE_INCOMING_WEBHOOKS) 48 return 49 } 50 51 if channel.Type != model.CHANNEL_OPEN && !c.App.SessionHasPermissionToChannel(*c.App.Session(), channel.Id, model.PERMISSION_READ_CHANNEL) { 52 c.LogAudit("fail - bad channel permissions") 53 c.SetPermissionError(model.PERMISSION_READ_CHANNEL) 54 return 55 } 56 57 incomingHook, err := c.App.CreateIncomingWebhookForChannel(c.App.Session().UserId, channel, hook) 58 if err != nil { 59 c.Err = err 60 return 61 } 62 63 auditRec.Success() 64 auditRec.AddMeta("hook", incomingHook) 65 c.LogAudit("success") 66 67 w.WriteHeader(http.StatusCreated) 68 w.Write([]byte(incomingHook.ToJson())) 69 } 70 71 func updateIncomingHook(c *Context, w http.ResponseWriter, r *http.Request) { 72 c.RequireHookId() 73 if c.Err != nil { 74 return 75 } 76 77 updatedHook := model.IncomingWebhookFromJson(r.Body) 78 if updatedHook == nil { 79 c.SetInvalidParam("incoming_webhook") 80 return 81 } 82 83 // The hook being updated in the payload must be the same one as indicated in the URL. 84 if updatedHook.Id != c.Params.HookId { 85 c.SetInvalidParam("hook_id") 86 return 87 } 88 89 auditRec := c.MakeAuditRecord("updateIncomingHook", audit.Fail) 90 defer c.LogAuditRec(auditRec) 91 auditRec.AddMeta("hook_id", c.Params.HookId) 92 c.LogAudit("attempt") 93 94 oldHook, err := c.App.GetIncomingWebhook(c.Params.HookId) 95 if err != nil { 96 c.Err = err 97 return 98 } 99 auditRec.AddMeta("team_id", oldHook.TeamId) 100 101 if updatedHook.TeamId == "" { 102 updatedHook.TeamId = oldHook.TeamId 103 } 104 105 if updatedHook.TeamId != oldHook.TeamId { 106 c.Err = model.NewAppError("updateIncomingHook", "api.webhook.team_mismatch.app_error", nil, "user_id="+c.App.Session().UserId, http.StatusBadRequest) 107 return 108 } 109 110 channel, err := c.App.GetChannel(updatedHook.ChannelId) 111 if err != nil { 112 c.Err = err 113 return 114 } 115 auditRec.AddMeta("channel_id", channel.Id) 116 auditRec.AddMeta("channel_name", channel.Name) 117 118 if channel.TeamId != updatedHook.TeamId { 119 c.SetInvalidParam("channel_id") 120 return 121 } 122 123 if !c.App.SessionHasPermissionToTeam(*c.App.Session(), channel.TeamId, model.PERMISSION_MANAGE_INCOMING_WEBHOOKS) { 124 c.SetPermissionError(model.PERMISSION_MANAGE_INCOMING_WEBHOOKS) 125 return 126 } 127 128 if c.App.Session().UserId != oldHook.UserId && !c.App.SessionHasPermissionToTeam(*c.App.Session(), channel.TeamId, model.PERMISSION_MANAGE_OTHERS_INCOMING_WEBHOOKS) { 129 c.LogAudit("fail - inappropriate permissions") 130 c.SetPermissionError(model.PERMISSION_MANAGE_OTHERS_INCOMING_WEBHOOKS) 131 return 132 } 133 134 if channel.Type != model.CHANNEL_OPEN && !c.App.SessionHasPermissionToChannel(*c.App.Session(), channel.Id, model.PERMISSION_READ_CHANNEL) { 135 c.LogAudit("fail - bad channel permissions") 136 c.SetPermissionError(model.PERMISSION_READ_CHANNEL) 137 return 138 } 139 140 incomingHook, err := c.App.UpdateIncomingWebhook(oldHook, updatedHook) 141 if err != nil { 142 c.Err = err 143 return 144 } 145 146 auditRec.Success() 147 c.LogAudit("success") 148 149 w.WriteHeader(http.StatusCreated) 150 w.Write([]byte(incomingHook.ToJson())) 151 } 152 153 func getIncomingHooks(c *Context, w http.ResponseWriter, r *http.Request) { 154 teamId := r.URL.Query().Get("team_id") 155 userId := c.App.Session().UserId 156 157 var hooks []*model.IncomingWebhook 158 var err *model.AppError 159 160 if len(teamId) > 0 { 161 if !c.App.SessionHasPermissionToTeam(*c.App.Session(), teamId, model.PERMISSION_MANAGE_INCOMING_WEBHOOKS) { 162 c.SetPermissionError(model.PERMISSION_MANAGE_INCOMING_WEBHOOKS) 163 return 164 } 165 166 // Remove userId as a filter if they have permission to manage others. 167 if c.App.SessionHasPermissionToTeam(*c.App.Session(), teamId, model.PERMISSION_MANAGE_OTHERS_INCOMING_WEBHOOKS) { 168 userId = "" 169 } 170 171 hooks, err = c.App.GetIncomingWebhooksForTeamPageByUser(teamId, userId, c.Params.Page, c.Params.PerPage) 172 } else { 173 if !c.App.SessionHasPermissionTo(*c.App.Session(), model.PERMISSION_MANAGE_INCOMING_WEBHOOKS) { 174 c.SetPermissionError(model.PERMISSION_MANAGE_INCOMING_WEBHOOKS) 175 return 176 } 177 178 // Remove userId as a filter if they have permission to manage others. 179 if c.App.SessionHasPermissionTo(*c.App.Session(), model.PERMISSION_MANAGE_OTHERS_INCOMING_WEBHOOKS) { 180 userId = "" 181 } 182 183 hooks, err = c.App.GetIncomingWebhooksPageByUser(userId, c.Params.Page, c.Params.PerPage) 184 } 185 186 if err != nil { 187 c.Err = err 188 return 189 } 190 191 w.Write([]byte(model.IncomingWebhookListToJson(hooks))) 192 } 193 194 func getIncomingHook(c *Context, w http.ResponseWriter, r *http.Request) { 195 c.RequireHookId() 196 if c.Err != nil { 197 return 198 } 199 200 hookId := c.Params.HookId 201 202 var err *model.AppError 203 var hook *model.IncomingWebhook 204 var channel *model.Channel 205 206 hook, err = c.App.GetIncomingWebhook(hookId) 207 if err != nil { 208 c.Err = err 209 return 210 } 211 212 auditRec := c.MakeAuditRecord("getIncomingHook", audit.Fail) 213 defer c.LogAuditRec(auditRec) 214 auditRec.AddMeta("hook_id", hook.Id) 215 auditRec.AddMeta("hook_display", hook.DisplayName) 216 auditRec.AddMeta("channel_id", hook.ChannelId) 217 auditRec.AddMeta("team_id", hook.TeamId) 218 c.LogAudit("attempt") 219 220 channel, err = c.App.GetChannel(hook.ChannelId) 221 if err != nil { 222 c.Err = err 223 return 224 } 225 226 if !c.App.SessionHasPermissionToTeam(*c.App.Session(), hook.TeamId, model.PERMISSION_MANAGE_INCOMING_WEBHOOKS) || 227 (channel.Type != model.CHANNEL_OPEN && !c.App.SessionHasPermissionToChannel(*c.App.Session(), hook.ChannelId, model.PERMISSION_READ_CHANNEL)) { 228 c.LogAudit("fail - bad permissions") 229 c.SetPermissionError(model.PERMISSION_MANAGE_INCOMING_WEBHOOKS) 230 return 231 } 232 233 if c.App.Session().UserId != hook.UserId && !c.App.SessionHasPermissionToTeam(*c.App.Session(), hook.TeamId, model.PERMISSION_MANAGE_OTHERS_INCOMING_WEBHOOKS) { 234 c.LogAudit("fail - inappropriate permissions") 235 c.SetPermissionError(model.PERMISSION_MANAGE_OTHERS_INCOMING_WEBHOOKS) 236 return 237 } 238 239 auditRec.Success() 240 c.LogAudit("success") 241 242 w.Write([]byte(hook.ToJson())) 243 } 244 245 func deleteIncomingHook(c *Context, w http.ResponseWriter, r *http.Request) { 246 c.RequireHookId() 247 if c.Err != nil { 248 return 249 } 250 251 hookId := c.Params.HookId 252 253 var err *model.AppError 254 var hook *model.IncomingWebhook 255 var channel *model.Channel 256 257 hook, err = c.App.GetIncomingWebhook(hookId) 258 if err != nil { 259 c.Err = err 260 return 261 } 262 263 channel, err = c.App.GetChannel(hook.ChannelId) 264 if err != nil { 265 c.Err = err 266 return 267 } 268 269 auditRec := c.MakeAuditRecord("deleteIncomingHook", audit.Fail) 270 defer c.LogAuditRec(auditRec) 271 auditRec.AddMeta("hook_id", hook.Id) 272 auditRec.AddMeta("hook_display", hook.DisplayName) 273 auditRec.AddMeta("channel_id", channel.Id) 274 auditRec.AddMeta("channel_name", channel.Name) 275 auditRec.AddMeta("team_id", hook.TeamId) 276 277 if !c.App.SessionHasPermissionToTeam(*c.App.Session(), hook.TeamId, model.PERMISSION_MANAGE_INCOMING_WEBHOOKS) || 278 (channel.Type != model.CHANNEL_OPEN && !c.App.SessionHasPermissionToChannel(*c.App.Session(), hook.ChannelId, model.PERMISSION_READ_CHANNEL)) { 279 c.LogAudit("fail - bad permissions") 280 c.SetPermissionError(model.PERMISSION_MANAGE_INCOMING_WEBHOOKS) 281 return 282 } 283 284 if c.App.Session().UserId != hook.UserId && !c.App.SessionHasPermissionToTeam(*c.App.Session(), hook.TeamId, model.PERMISSION_MANAGE_OTHERS_INCOMING_WEBHOOKS) { 285 c.LogAudit("fail - inappropriate permissions") 286 c.SetPermissionError(model.PERMISSION_MANAGE_OTHERS_INCOMING_WEBHOOKS) 287 return 288 } 289 290 if err = c.App.DeleteIncomingWebhook(hookId); err != nil { 291 c.Err = err 292 return 293 } 294 295 auditRec.Success() 296 ReturnStatusOK(w) 297 } 298 299 func updateOutgoingHook(c *Context, w http.ResponseWriter, r *http.Request) { 300 c.RequireHookId() 301 if c.Err != nil { 302 return 303 } 304 305 updatedHook := model.OutgoingWebhookFromJson(r.Body) 306 if updatedHook == nil { 307 c.SetInvalidParam("outgoing_webhook") 308 return 309 } 310 311 // The hook being updated in the payload must be the same one as indicated in the URL. 312 if updatedHook.Id != c.Params.HookId { 313 c.SetInvalidParam("hook_id") 314 return 315 } 316 317 auditRec := c.MakeAuditRecord("updateOutgoingHook", audit.Fail) 318 defer c.LogAuditRec(auditRec) 319 auditRec.AddMeta("hook_id", updatedHook.Id) 320 auditRec.AddMeta("hook_display", updatedHook.DisplayName) 321 auditRec.AddMeta("channel_id", updatedHook.ChannelId) 322 auditRec.AddMeta("team_id", updatedHook.TeamId) 323 c.LogAudit("attempt") 324 325 oldHook, err := c.App.GetOutgoingWebhook(c.Params.HookId) 326 if err != nil { 327 c.Err = err 328 return 329 } 330 331 if updatedHook.TeamId == "" { 332 updatedHook.TeamId = oldHook.TeamId 333 } 334 335 if updatedHook.TeamId != oldHook.TeamId { 336 c.Err = model.NewAppError("updateOutgoingHook", "api.webhook.team_mismatch.app_error", nil, "user_id="+c.App.Session().UserId, http.StatusBadRequest) 337 return 338 } 339 340 if !c.App.SessionHasPermissionToTeam(*c.App.Session(), updatedHook.TeamId, model.PERMISSION_MANAGE_OUTGOING_WEBHOOKS) { 341 c.SetPermissionError(model.PERMISSION_MANAGE_OUTGOING_WEBHOOKS) 342 return 343 } 344 345 if c.App.Session().UserId != oldHook.CreatorId && !c.App.SessionHasPermissionToTeam(*c.App.Session(), updatedHook.TeamId, model.PERMISSION_MANAGE_OTHERS_OUTGOING_WEBHOOKS) { 346 c.LogAudit("fail - inappropriate permissions") 347 c.SetPermissionError(model.PERMISSION_MANAGE_OTHERS_OUTGOING_WEBHOOKS) 348 return 349 } 350 351 updatedHook.CreatorId = c.App.Session().UserId 352 353 rhook, err := c.App.UpdateOutgoingWebhook(oldHook, updatedHook) 354 if err != nil { 355 c.Err = err 356 return 357 } 358 359 auditRec.Success() 360 c.LogAudit("success") 361 362 w.Write([]byte(rhook.ToJson())) 363 } 364 365 func createOutgoingHook(c *Context, w http.ResponseWriter, r *http.Request) { 366 hook := model.OutgoingWebhookFromJson(r.Body) 367 if hook == nil { 368 c.SetInvalidParam("outgoing_webhook") 369 return 370 } 371 372 auditRec := c.MakeAuditRecord("createOutgoingHook", audit.Fail) 373 defer c.LogAuditRec(auditRec) 374 auditRec.AddMeta("hook_id", hook.Id) 375 c.LogAudit("attempt") 376 377 hook.CreatorId = c.App.Session().UserId 378 379 if !c.App.SessionHasPermissionToTeam(*c.App.Session(), hook.TeamId, model.PERMISSION_MANAGE_OUTGOING_WEBHOOKS) { 380 c.SetPermissionError(model.PERMISSION_MANAGE_OUTGOING_WEBHOOKS) 381 return 382 } 383 384 rhook, err := c.App.CreateOutgoingWebhook(hook) 385 if err != nil { 386 c.LogAudit("fail") 387 c.Err = err 388 return 389 } 390 391 auditRec.Success() 392 auditRec.AddMeta("hook_display", rhook.DisplayName) 393 auditRec.AddMeta("channel_id", rhook.ChannelId) 394 auditRec.AddMeta("team_id", rhook.TeamId) 395 c.LogAudit("success") 396 397 w.WriteHeader(http.StatusCreated) 398 w.Write([]byte(rhook.ToJson())) 399 } 400 401 func getOutgoingHooks(c *Context, w http.ResponseWriter, r *http.Request) { 402 channelId := r.URL.Query().Get("channel_id") 403 teamId := r.URL.Query().Get("team_id") 404 userId := c.App.Session().UserId 405 406 var hooks []*model.OutgoingWebhook 407 var err *model.AppError 408 409 if len(channelId) > 0 { 410 if !c.App.SessionHasPermissionToChannel(*c.App.Session(), channelId, model.PERMISSION_MANAGE_OUTGOING_WEBHOOKS) { 411 c.SetPermissionError(model.PERMISSION_MANAGE_OUTGOING_WEBHOOKS) 412 return 413 } 414 415 // Remove userId as a filter if they have permission to manage others. 416 if c.App.SessionHasPermissionToChannel(*c.App.Session(), channelId, model.PERMISSION_MANAGE_OTHERS_OUTGOING_WEBHOOKS) { 417 userId = "" 418 } 419 420 hooks, err = c.App.GetOutgoingWebhooksForChannelPageByUser(channelId, userId, c.Params.Page, c.Params.PerPage) 421 } else if len(teamId) > 0 { 422 if !c.App.SessionHasPermissionToTeam(*c.App.Session(), teamId, model.PERMISSION_MANAGE_OUTGOING_WEBHOOKS) { 423 c.SetPermissionError(model.PERMISSION_MANAGE_OUTGOING_WEBHOOKS) 424 return 425 } 426 427 // Remove userId as a filter if they have permission to manage others. 428 if c.App.SessionHasPermissionToTeam(*c.App.Session(), teamId, model.PERMISSION_MANAGE_OTHERS_OUTGOING_WEBHOOKS) { 429 userId = "" 430 } 431 432 hooks, err = c.App.GetOutgoingWebhooksForTeamPageByUser(teamId, userId, c.Params.Page, c.Params.PerPage) 433 } else { 434 if !c.App.SessionHasPermissionTo(*c.App.Session(), model.PERMISSION_MANAGE_OUTGOING_WEBHOOKS) { 435 c.SetPermissionError(model.PERMISSION_MANAGE_OUTGOING_WEBHOOKS) 436 return 437 } 438 439 // Remove userId as a filter if they have permission to manage others. 440 if c.App.SessionHasPermissionTo(*c.App.Session(), model.PERMISSION_MANAGE_OTHERS_OUTGOING_WEBHOOKS) { 441 userId = "" 442 } 443 444 hooks, err = c.App.GetOutgoingWebhooksPageByUser(userId, c.Params.Page, c.Params.PerPage) 445 } 446 447 if err != nil { 448 c.Err = err 449 return 450 } 451 452 w.Write([]byte(model.OutgoingWebhookListToJson(hooks))) 453 } 454 455 func getOutgoingHook(c *Context, w http.ResponseWriter, r *http.Request) { 456 c.RequireHookId() 457 if c.Err != nil { 458 return 459 } 460 461 hook, err := c.App.GetOutgoingWebhook(c.Params.HookId) 462 if err != nil { 463 c.Err = err 464 return 465 } 466 467 auditRec := c.MakeAuditRecord("getOutgoingHook", audit.Fail) 468 defer c.LogAuditRec(auditRec) 469 auditRec.AddMeta("hook_id", hook.Id) 470 auditRec.AddMeta("hook_display", hook.DisplayName) 471 auditRec.AddMeta("channel_id", hook.ChannelId) 472 auditRec.AddMeta("team_id", hook.TeamId) 473 c.LogAudit("attempt") 474 475 if !c.App.SessionHasPermissionToTeam(*c.App.Session(), hook.TeamId, model.PERMISSION_MANAGE_OUTGOING_WEBHOOKS) { 476 c.SetPermissionError(model.PERMISSION_MANAGE_OUTGOING_WEBHOOKS) 477 return 478 } 479 480 if c.App.Session().UserId != hook.CreatorId && !c.App.SessionHasPermissionToTeam(*c.App.Session(), hook.TeamId, model.PERMISSION_MANAGE_OTHERS_OUTGOING_WEBHOOKS) { 481 c.LogAudit("fail - inappropriate permissions") 482 c.SetPermissionError(model.PERMISSION_MANAGE_OTHERS_OUTGOING_WEBHOOKS) 483 return 484 } 485 486 auditRec.Success() 487 c.LogAudit("success") 488 489 w.Write([]byte(hook.ToJson())) 490 } 491 492 func regenOutgoingHookToken(c *Context, w http.ResponseWriter, r *http.Request) { 493 c.RequireHookId() 494 if c.Err != nil { 495 return 496 } 497 498 hook, err := c.App.GetOutgoingWebhook(c.Params.HookId) 499 if err != nil { 500 c.Err = err 501 return 502 } 503 504 auditRec := c.MakeAuditRecord("regenOutgoingHookToken", audit.Fail) 505 defer c.LogAuditRec(auditRec) 506 auditRec.AddMeta("hook_id", hook.Id) 507 auditRec.AddMeta("hook_display", hook.DisplayName) 508 auditRec.AddMeta("channel_id", hook.ChannelId) 509 auditRec.AddMeta("team_id", hook.TeamId) 510 c.LogAudit("attempt") 511 512 if !c.App.SessionHasPermissionToTeam(*c.App.Session(), hook.TeamId, model.PERMISSION_MANAGE_OUTGOING_WEBHOOKS) { 513 c.SetPermissionError(model.PERMISSION_MANAGE_OUTGOING_WEBHOOKS) 514 return 515 } 516 517 if c.App.Session().UserId != hook.CreatorId && !c.App.SessionHasPermissionToTeam(*c.App.Session(), hook.TeamId, model.PERMISSION_MANAGE_OTHERS_OUTGOING_WEBHOOKS) { 518 c.LogAudit("fail - inappropriate permissions") 519 c.SetPermissionError(model.PERMISSION_MANAGE_OTHERS_OUTGOING_WEBHOOKS) 520 return 521 } 522 523 rhook, err := c.App.RegenOutgoingWebhookToken(hook) 524 if err != nil { 525 c.Err = err 526 return 527 } 528 529 auditRec.Success() 530 c.LogAudit("success") 531 532 w.Write([]byte(rhook.ToJson())) 533 } 534 535 func deleteOutgoingHook(c *Context, w http.ResponseWriter, r *http.Request) { 536 c.RequireHookId() 537 if c.Err != nil { 538 return 539 } 540 541 hook, err := c.App.GetOutgoingWebhook(c.Params.HookId) 542 if err != nil { 543 c.Err = err 544 return 545 } 546 547 auditRec := c.MakeAuditRecord("deleteOutgoingHook", audit.Fail) 548 defer c.LogAuditRec(auditRec) 549 auditRec.AddMeta("hook_id", hook.Id) 550 auditRec.AddMeta("hook_display", hook.DisplayName) 551 auditRec.AddMeta("channel_id", hook.ChannelId) 552 auditRec.AddMeta("team_id", hook.TeamId) 553 c.LogAudit("attempt") 554 555 if !c.App.SessionHasPermissionToTeam(*c.App.Session(), hook.TeamId, model.PERMISSION_MANAGE_OUTGOING_WEBHOOKS) { 556 c.SetPermissionError(model.PERMISSION_MANAGE_OUTGOING_WEBHOOKS) 557 return 558 } 559 560 if c.App.Session().UserId != hook.CreatorId && !c.App.SessionHasPermissionToTeam(*c.App.Session(), hook.TeamId, model.PERMISSION_MANAGE_OTHERS_OUTGOING_WEBHOOKS) { 561 c.LogAudit("fail - inappropriate permissions") 562 c.SetPermissionError(model.PERMISSION_MANAGE_OTHERS_OUTGOING_WEBHOOKS) 563 return 564 } 565 566 if err := c.App.DeleteOutgoingWebhook(hook.Id); err != nil { 567 c.LogAudit("fail") 568 c.Err = err 569 return 570 } 571 572 auditRec.Success() 573 c.LogAudit("success") 574 575 ReturnStatusOK(w) 576 }