diff --git a/codegen/templates/http_handlers_inline.tpl b/codegen/templates/http_handlers_inline.tpl index ad0e30049..cdfb6413b 100644 --- a/codegen/templates/http_handlers_inline.tpl +++ b/codegen/templates/http_handlers_inline.tpl @@ -35,14 +35,16 @@ func New{name|expose}(h {name|expose}API) *{name|expose} { defer r.Body.Close() params := request.New{name|capitalize}{call.name|capitalize}() if err := params.Fill(r); err != nil { - logger.LogParamError("{name|expose}.{call.name|capitalize}", r, err, params.Auditable()) + logger.LogParamError("{name|expose}.{call.name|capitalize}", r, err) resputil.JSON(w, err) return } + value, err := h.{call.name|capitalize}(r.Context(), params) if err != nil { logger.LogControllerError("{name|expose}.{call.name|capitalize}", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("{name|expose}.{call.name|capitalize}", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/compose/rest/handlers/attachment.go b/compose/rest/handlers/attachment.go index 49b88f830..0102dd3ea 100644 --- a/compose/rest/handlers/attachment.go +++ b/compose/rest/handlers/attachment.go @@ -51,14 +51,16 @@ func NewAttachment(h AttachmentAPI) *Attachment { defer r.Body.Close() params := request.NewAttachmentList() if err := params.Fill(r); err != nil { - logger.LogParamError("Attachment.List", r, err, params.Auditable()) + logger.LogParamError("Attachment.List", r, err) resputil.JSON(w, err) return } + value, err := h.List(r.Context(), params) if err != nil { logger.LogControllerError("Attachment.List", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Attachment.List", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -69,14 +71,16 @@ func NewAttachment(h AttachmentAPI) *Attachment { defer r.Body.Close() params := request.NewAttachmentRead() if err := params.Fill(r); err != nil { - logger.LogParamError("Attachment.Read", r, err, params.Auditable()) + logger.LogParamError("Attachment.Read", r, err) resputil.JSON(w, err) return } + value, err := h.Read(r.Context(), params) if err != nil { logger.LogControllerError("Attachment.Read", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Attachment.Read", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -87,14 +91,16 @@ func NewAttachment(h AttachmentAPI) *Attachment { defer r.Body.Close() params := request.NewAttachmentDelete() if err := params.Fill(r); err != nil { - logger.LogParamError("Attachment.Delete", r, err, params.Auditable()) + logger.LogParamError("Attachment.Delete", r, err) resputil.JSON(w, err) return } + value, err := h.Delete(r.Context(), params) if err != nil { logger.LogControllerError("Attachment.Delete", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Attachment.Delete", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -105,14 +111,16 @@ func NewAttachment(h AttachmentAPI) *Attachment { defer r.Body.Close() params := request.NewAttachmentOriginal() if err := params.Fill(r); err != nil { - logger.LogParamError("Attachment.Original", r, err, params.Auditable()) + logger.LogParamError("Attachment.Original", r, err) resputil.JSON(w, err) return } + value, err := h.Original(r.Context(), params) if err != nil { logger.LogControllerError("Attachment.Original", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Attachment.Original", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -123,14 +131,16 @@ func NewAttachment(h AttachmentAPI) *Attachment { defer r.Body.Close() params := request.NewAttachmentPreview() if err := params.Fill(r); err != nil { - logger.LogParamError("Attachment.Preview", r, err, params.Auditable()) + logger.LogParamError("Attachment.Preview", r, err) resputil.JSON(w, err) return } + value, err := h.Preview(r.Context(), params) if err != nil { logger.LogControllerError("Attachment.Preview", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Attachment.Preview", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/compose/rest/handlers/chart.go b/compose/rest/handlers/chart.go index 51bf5716e..2398b7848 100644 --- a/compose/rest/handlers/chart.go +++ b/compose/rest/handlers/chart.go @@ -51,14 +51,16 @@ func NewChart(h ChartAPI) *Chart { defer r.Body.Close() params := request.NewChartList() if err := params.Fill(r); err != nil { - logger.LogParamError("Chart.List", r, err, params.Auditable()) + logger.LogParamError("Chart.List", r, err) resputil.JSON(w, err) return } + value, err := h.List(r.Context(), params) if err != nil { logger.LogControllerError("Chart.List", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Chart.List", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -69,14 +71,16 @@ func NewChart(h ChartAPI) *Chart { defer r.Body.Close() params := request.NewChartCreate() if err := params.Fill(r); err != nil { - logger.LogParamError("Chart.Create", r, err, params.Auditable()) + logger.LogParamError("Chart.Create", r, err) resputil.JSON(w, err) return } + value, err := h.Create(r.Context(), params) if err != nil { logger.LogControllerError("Chart.Create", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Chart.Create", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -87,14 +91,16 @@ func NewChart(h ChartAPI) *Chart { defer r.Body.Close() params := request.NewChartRead() if err := params.Fill(r); err != nil { - logger.LogParamError("Chart.Read", r, err, params.Auditable()) + logger.LogParamError("Chart.Read", r, err) resputil.JSON(w, err) return } + value, err := h.Read(r.Context(), params) if err != nil { logger.LogControllerError("Chart.Read", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Chart.Read", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -105,14 +111,16 @@ func NewChart(h ChartAPI) *Chart { defer r.Body.Close() params := request.NewChartUpdate() if err := params.Fill(r); err != nil { - logger.LogParamError("Chart.Update", r, err, params.Auditable()) + logger.LogParamError("Chart.Update", r, err) resputil.JSON(w, err) return } + value, err := h.Update(r.Context(), params) if err != nil { logger.LogControllerError("Chart.Update", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Chart.Update", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -123,14 +131,16 @@ func NewChart(h ChartAPI) *Chart { defer r.Body.Close() params := request.NewChartDelete() if err := params.Fill(r); err != nil { - logger.LogParamError("Chart.Delete", r, err, params.Auditable()) + logger.LogParamError("Chart.Delete", r, err) resputil.JSON(w, err) return } + value, err := h.Delete(r.Context(), params) if err != nil { logger.LogControllerError("Chart.Delete", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Chart.Delete", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/compose/rest/handlers/module.go b/compose/rest/handlers/module.go index f9b9b6c73..03e420c17 100644 --- a/compose/rest/handlers/module.go +++ b/compose/rest/handlers/module.go @@ -51,14 +51,16 @@ func NewModule(h ModuleAPI) *Module { defer r.Body.Close() params := request.NewModuleList() if err := params.Fill(r); err != nil { - logger.LogParamError("Module.List", r, err, params.Auditable()) + logger.LogParamError("Module.List", r, err) resputil.JSON(w, err) return } + value, err := h.List(r.Context(), params) if err != nil { logger.LogControllerError("Module.List", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Module.List", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -69,14 +71,16 @@ func NewModule(h ModuleAPI) *Module { defer r.Body.Close() params := request.NewModuleCreate() if err := params.Fill(r); err != nil { - logger.LogParamError("Module.Create", r, err, params.Auditable()) + logger.LogParamError("Module.Create", r, err) resputil.JSON(w, err) return } + value, err := h.Create(r.Context(), params) if err != nil { logger.LogControllerError("Module.Create", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Module.Create", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -87,14 +91,16 @@ func NewModule(h ModuleAPI) *Module { defer r.Body.Close() params := request.NewModuleRead() if err := params.Fill(r); err != nil { - logger.LogParamError("Module.Read", r, err, params.Auditable()) + logger.LogParamError("Module.Read", r, err) resputil.JSON(w, err) return } + value, err := h.Read(r.Context(), params) if err != nil { logger.LogControllerError("Module.Read", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Module.Read", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -105,14 +111,16 @@ func NewModule(h ModuleAPI) *Module { defer r.Body.Close() params := request.NewModuleUpdate() if err := params.Fill(r); err != nil { - logger.LogParamError("Module.Update", r, err, params.Auditable()) + logger.LogParamError("Module.Update", r, err) resputil.JSON(w, err) return } + value, err := h.Update(r.Context(), params) if err != nil { logger.LogControllerError("Module.Update", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Module.Update", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -123,14 +131,16 @@ func NewModule(h ModuleAPI) *Module { defer r.Body.Close() params := request.NewModuleDelete() if err := params.Fill(r); err != nil { - logger.LogParamError("Module.Delete", r, err, params.Auditable()) + logger.LogParamError("Module.Delete", r, err) resputil.JSON(w, err) return } + value, err := h.Delete(r.Context(), params) if err != nil { logger.LogControllerError("Module.Delete", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Module.Delete", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/compose/rest/handlers/namespace.go b/compose/rest/handlers/namespace.go index de3207111..588835faf 100644 --- a/compose/rest/handlers/namespace.go +++ b/compose/rest/handlers/namespace.go @@ -51,14 +51,16 @@ func NewNamespace(h NamespaceAPI) *Namespace { defer r.Body.Close() params := request.NewNamespaceList() if err := params.Fill(r); err != nil { - logger.LogParamError("Namespace.List", r, err, params.Auditable()) + logger.LogParamError("Namespace.List", r, err) resputil.JSON(w, err) return } + value, err := h.List(r.Context(), params) if err != nil { logger.LogControllerError("Namespace.List", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Namespace.List", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -69,14 +71,16 @@ func NewNamespace(h NamespaceAPI) *Namespace { defer r.Body.Close() params := request.NewNamespaceCreate() if err := params.Fill(r); err != nil { - logger.LogParamError("Namespace.Create", r, err, params.Auditable()) + logger.LogParamError("Namespace.Create", r, err) resputil.JSON(w, err) return } + value, err := h.Create(r.Context(), params) if err != nil { logger.LogControllerError("Namespace.Create", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Namespace.Create", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -87,14 +91,16 @@ func NewNamespace(h NamespaceAPI) *Namespace { defer r.Body.Close() params := request.NewNamespaceRead() if err := params.Fill(r); err != nil { - logger.LogParamError("Namespace.Read", r, err, params.Auditable()) + logger.LogParamError("Namespace.Read", r, err) resputil.JSON(w, err) return } + value, err := h.Read(r.Context(), params) if err != nil { logger.LogControllerError("Namespace.Read", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Namespace.Read", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -105,14 +111,16 @@ func NewNamespace(h NamespaceAPI) *Namespace { defer r.Body.Close() params := request.NewNamespaceUpdate() if err := params.Fill(r); err != nil { - logger.LogParamError("Namespace.Update", r, err, params.Auditable()) + logger.LogParamError("Namespace.Update", r, err) resputil.JSON(w, err) return } + value, err := h.Update(r.Context(), params) if err != nil { logger.LogControllerError("Namespace.Update", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Namespace.Update", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -123,14 +131,16 @@ func NewNamespace(h NamespaceAPI) *Namespace { defer r.Body.Close() params := request.NewNamespaceDelete() if err := params.Fill(r); err != nil { - logger.LogParamError("Namespace.Delete", r, err, params.Auditable()) + logger.LogParamError("Namespace.Delete", r, err) resputil.JSON(w, err) return } + value, err := h.Delete(r.Context(), params) if err != nil { logger.LogControllerError("Namespace.Delete", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Namespace.Delete", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/compose/rest/handlers/notification.go b/compose/rest/handlers/notification.go index e9d55862b..09dc1ca11 100644 --- a/compose/rest/handlers/notification.go +++ b/compose/rest/handlers/notification.go @@ -43,14 +43,16 @@ func NewNotification(h NotificationAPI) *Notification { defer r.Body.Close() params := request.NewNotificationEmailSend() if err := params.Fill(r); err != nil { - logger.LogParamError("Notification.EmailSend", r, err, params.Auditable()) + logger.LogParamError("Notification.EmailSend", r, err) resputil.JSON(w, err) return } + value, err := h.EmailSend(r.Context(), params) if err != nil { logger.LogControllerError("Notification.EmailSend", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Notification.EmailSend", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/compose/rest/handlers/page.go b/compose/rest/handlers/page.go index 143434e68..db6dd9a15 100644 --- a/compose/rest/handlers/page.go +++ b/compose/rest/handlers/page.go @@ -57,14 +57,16 @@ func NewPage(h PageAPI) *Page { defer r.Body.Close() params := request.NewPageList() if err := params.Fill(r); err != nil { - logger.LogParamError("Page.List", r, err, params.Auditable()) + logger.LogParamError("Page.List", r, err) resputil.JSON(w, err) return } + value, err := h.List(r.Context(), params) if err != nil { logger.LogControllerError("Page.List", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Page.List", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -75,14 +77,16 @@ func NewPage(h PageAPI) *Page { defer r.Body.Close() params := request.NewPageCreate() if err := params.Fill(r); err != nil { - logger.LogParamError("Page.Create", r, err, params.Auditable()) + logger.LogParamError("Page.Create", r, err) resputil.JSON(w, err) return } + value, err := h.Create(r.Context(), params) if err != nil { logger.LogControllerError("Page.Create", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Page.Create", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -93,14 +97,16 @@ func NewPage(h PageAPI) *Page { defer r.Body.Close() params := request.NewPageRead() if err := params.Fill(r); err != nil { - logger.LogParamError("Page.Read", r, err, params.Auditable()) + logger.LogParamError("Page.Read", r, err) resputil.JSON(w, err) return } + value, err := h.Read(r.Context(), params) if err != nil { logger.LogControllerError("Page.Read", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Page.Read", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -111,14 +117,16 @@ func NewPage(h PageAPI) *Page { defer r.Body.Close() params := request.NewPageTree() if err := params.Fill(r); err != nil { - logger.LogParamError("Page.Tree", r, err, params.Auditable()) + logger.LogParamError("Page.Tree", r, err) resputil.JSON(w, err) return } + value, err := h.Tree(r.Context(), params) if err != nil { logger.LogControllerError("Page.Tree", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Page.Tree", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -129,14 +137,16 @@ func NewPage(h PageAPI) *Page { defer r.Body.Close() params := request.NewPageUpdate() if err := params.Fill(r); err != nil { - logger.LogParamError("Page.Update", r, err, params.Auditable()) + logger.LogParamError("Page.Update", r, err) resputil.JSON(w, err) return } + value, err := h.Update(r.Context(), params) if err != nil { logger.LogControllerError("Page.Update", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Page.Update", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -147,14 +157,16 @@ func NewPage(h PageAPI) *Page { defer r.Body.Close() params := request.NewPageReorder() if err := params.Fill(r); err != nil { - logger.LogParamError("Page.Reorder", r, err, params.Auditable()) + logger.LogParamError("Page.Reorder", r, err) resputil.JSON(w, err) return } + value, err := h.Reorder(r.Context(), params) if err != nil { logger.LogControllerError("Page.Reorder", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Page.Reorder", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -165,14 +177,16 @@ func NewPage(h PageAPI) *Page { defer r.Body.Close() params := request.NewPageDelete() if err := params.Fill(r); err != nil { - logger.LogParamError("Page.Delete", r, err, params.Auditable()) + logger.LogParamError("Page.Delete", r, err) resputil.JSON(w, err) return } + value, err := h.Delete(r.Context(), params) if err != nil { logger.LogControllerError("Page.Delete", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Page.Delete", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -183,14 +197,16 @@ func NewPage(h PageAPI) *Page { defer r.Body.Close() params := request.NewPageUpload() if err := params.Fill(r); err != nil { - logger.LogParamError("Page.Upload", r, err, params.Auditable()) + logger.LogParamError("Page.Upload", r, err) resputil.JSON(w, err) return } + value, err := h.Upload(r.Context(), params) if err != nil { logger.LogControllerError("Page.Upload", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Page.Upload", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/compose/rest/handlers/permissions.go b/compose/rest/handlers/permissions.go index 611ead652..bb9619914 100644 --- a/compose/rest/handlers/permissions.go +++ b/compose/rest/handlers/permissions.go @@ -51,14 +51,16 @@ func NewPermissions(h PermissionsAPI) *Permissions { defer r.Body.Close() params := request.NewPermissionsList() if err := params.Fill(r); err != nil { - logger.LogParamError("Permissions.List", r, err, params.Auditable()) + logger.LogParamError("Permissions.List", r, err) resputil.JSON(w, err) return } + value, err := h.List(r.Context(), params) if err != nil { logger.LogControllerError("Permissions.List", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Permissions.List", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -69,14 +71,16 @@ func NewPermissions(h PermissionsAPI) *Permissions { defer r.Body.Close() params := request.NewPermissionsEffective() if err := params.Fill(r); err != nil { - logger.LogParamError("Permissions.Effective", r, err, params.Auditable()) + logger.LogParamError("Permissions.Effective", r, err) resputil.JSON(w, err) return } + value, err := h.Effective(r.Context(), params) if err != nil { logger.LogControllerError("Permissions.Effective", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Permissions.Effective", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -87,14 +91,16 @@ func NewPermissions(h PermissionsAPI) *Permissions { defer r.Body.Close() params := request.NewPermissionsRead() if err := params.Fill(r); err != nil { - logger.LogParamError("Permissions.Read", r, err, params.Auditable()) + logger.LogParamError("Permissions.Read", r, err) resputil.JSON(w, err) return } + value, err := h.Read(r.Context(), params) if err != nil { logger.LogControllerError("Permissions.Read", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Permissions.Read", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -105,14 +111,16 @@ func NewPermissions(h PermissionsAPI) *Permissions { defer r.Body.Close() params := request.NewPermissionsDelete() if err := params.Fill(r); err != nil { - logger.LogParamError("Permissions.Delete", r, err, params.Auditable()) + logger.LogParamError("Permissions.Delete", r, err) resputil.JSON(w, err) return } + value, err := h.Delete(r.Context(), params) if err != nil { logger.LogControllerError("Permissions.Delete", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Permissions.Delete", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -123,14 +131,16 @@ func NewPermissions(h PermissionsAPI) *Permissions { defer r.Body.Close() params := request.NewPermissionsUpdate() if err := params.Fill(r); err != nil { - logger.LogParamError("Permissions.Update", r, err, params.Auditable()) + logger.LogParamError("Permissions.Update", r, err) resputil.JSON(w, err) return } + value, err := h.Update(r.Context(), params) if err != nil { logger.LogControllerError("Permissions.Update", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Permissions.Update", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/compose/rest/handlers/record.go b/compose/rest/handlers/record.go index 68b29862f..6491b9a50 100644 --- a/compose/rest/handlers/record.go +++ b/compose/rest/handlers/record.go @@ -55,14 +55,16 @@ func NewRecord(h RecordAPI) *Record { defer r.Body.Close() params := request.NewRecordReport() if err := params.Fill(r); err != nil { - logger.LogParamError("Record.Report", r, err, params.Auditable()) + logger.LogParamError("Record.Report", r, err) resputil.JSON(w, err) return } + value, err := h.Report(r.Context(), params) if err != nil { logger.LogControllerError("Record.Report", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Record.Report", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -73,14 +75,16 @@ func NewRecord(h RecordAPI) *Record { defer r.Body.Close() params := request.NewRecordList() if err := params.Fill(r); err != nil { - logger.LogParamError("Record.List", r, err, params.Auditable()) + logger.LogParamError("Record.List", r, err) resputil.JSON(w, err) return } + value, err := h.List(r.Context(), params) if err != nil { logger.LogControllerError("Record.List", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Record.List", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -91,14 +95,16 @@ func NewRecord(h RecordAPI) *Record { defer r.Body.Close() params := request.NewRecordCreate() if err := params.Fill(r); err != nil { - logger.LogParamError("Record.Create", r, err, params.Auditable()) + logger.LogParamError("Record.Create", r, err) resputil.JSON(w, err) return } + value, err := h.Create(r.Context(), params) if err != nil { logger.LogControllerError("Record.Create", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Record.Create", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -109,14 +115,16 @@ func NewRecord(h RecordAPI) *Record { defer r.Body.Close() params := request.NewRecordRead() if err := params.Fill(r); err != nil { - logger.LogParamError("Record.Read", r, err, params.Auditable()) + logger.LogParamError("Record.Read", r, err) resputil.JSON(w, err) return } + value, err := h.Read(r.Context(), params) if err != nil { logger.LogControllerError("Record.Read", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Record.Read", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -127,14 +135,16 @@ func NewRecord(h RecordAPI) *Record { defer r.Body.Close() params := request.NewRecordUpdate() if err := params.Fill(r); err != nil { - logger.LogParamError("Record.Update", r, err, params.Auditable()) + logger.LogParamError("Record.Update", r, err) resputil.JSON(w, err) return } + value, err := h.Update(r.Context(), params) if err != nil { logger.LogControllerError("Record.Update", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Record.Update", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -145,14 +155,16 @@ func NewRecord(h RecordAPI) *Record { defer r.Body.Close() params := request.NewRecordDelete() if err := params.Fill(r); err != nil { - logger.LogParamError("Record.Delete", r, err, params.Auditable()) + logger.LogParamError("Record.Delete", r, err) resputil.JSON(w, err) return } + value, err := h.Delete(r.Context(), params) if err != nil { logger.LogControllerError("Record.Delete", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Record.Delete", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -163,14 +175,16 @@ func NewRecord(h RecordAPI) *Record { defer r.Body.Close() params := request.NewRecordUpload() if err := params.Fill(r); err != nil { - logger.LogParamError("Record.Upload", r, err, params.Auditable()) + logger.LogParamError("Record.Upload", r, err) resputil.JSON(w, err) return } + value, err := h.Upload(r.Context(), params) if err != nil { logger.LogControllerError("Record.Upload", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Record.Upload", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/compose/rest/handlers/trigger.go b/compose/rest/handlers/trigger.go index ca8cbf0aa..d56fbe2bd 100644 --- a/compose/rest/handlers/trigger.go +++ b/compose/rest/handlers/trigger.go @@ -51,14 +51,16 @@ func NewTrigger(h TriggerAPI) *Trigger { defer r.Body.Close() params := request.NewTriggerList() if err := params.Fill(r); err != nil { - logger.LogParamError("Trigger.List", r, err, params.Auditable()) + logger.LogParamError("Trigger.List", r, err) resputil.JSON(w, err) return } + value, err := h.List(r.Context(), params) if err != nil { logger.LogControllerError("Trigger.List", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Trigger.List", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -69,14 +71,16 @@ func NewTrigger(h TriggerAPI) *Trigger { defer r.Body.Close() params := request.NewTriggerCreate() if err := params.Fill(r); err != nil { - logger.LogParamError("Trigger.Create", r, err, params.Auditable()) + logger.LogParamError("Trigger.Create", r, err) resputil.JSON(w, err) return } + value, err := h.Create(r.Context(), params) if err != nil { logger.LogControllerError("Trigger.Create", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Trigger.Create", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -87,14 +91,16 @@ func NewTrigger(h TriggerAPI) *Trigger { defer r.Body.Close() params := request.NewTriggerRead() if err := params.Fill(r); err != nil { - logger.LogParamError("Trigger.Read", r, err, params.Auditable()) + logger.LogParamError("Trigger.Read", r, err) resputil.JSON(w, err) return } + value, err := h.Read(r.Context(), params) if err != nil { logger.LogControllerError("Trigger.Read", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Trigger.Read", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -105,14 +111,16 @@ func NewTrigger(h TriggerAPI) *Trigger { defer r.Body.Close() params := request.NewTriggerUpdate() if err := params.Fill(r); err != nil { - logger.LogParamError("Trigger.Update", r, err, params.Auditable()) + logger.LogParamError("Trigger.Update", r, err) resputil.JSON(w, err) return } + value, err := h.Update(r.Context(), params) if err != nil { logger.LogControllerError("Trigger.Update", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Trigger.Update", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -123,14 +131,16 @@ func NewTrigger(h TriggerAPI) *Trigger { defer r.Body.Close() params := request.NewTriggerDelete() if err := params.Fill(r); err != nil { - logger.LogParamError("Trigger.Delete", r, err, params.Auditable()) + logger.LogParamError("Trigger.Delete", r, err) resputil.JSON(w, err) return } + value, err := h.Delete(r.Context(), params) if err != nil { logger.LogControllerError("Trigger.Delete", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Trigger.Delete", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/messaging/rest/handlers/activity.go b/messaging/rest/handlers/activity.go index 82e3414b3..b23e8c046 100644 --- a/messaging/rest/handlers/activity.go +++ b/messaging/rest/handlers/activity.go @@ -43,14 +43,16 @@ func NewActivity(h ActivityAPI) *Activity { defer r.Body.Close() params := request.NewActivitySend() if err := params.Fill(r); err != nil { - logger.LogParamError("Activity.Send", r, err, params.Auditable()) + logger.LogParamError("Activity.Send", r, err) resputil.JSON(w, err) return } + value, err := h.Send(r.Context(), params) if err != nil { logger.LogControllerError("Activity.Send", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Activity.Send", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/messaging/rest/handlers/attachment.go b/messaging/rest/handlers/attachment.go index 80ffe01d9..f560c6a41 100644 --- a/messaging/rest/handlers/attachment.go +++ b/messaging/rest/handlers/attachment.go @@ -45,14 +45,16 @@ func NewAttachment(h AttachmentAPI) *Attachment { defer r.Body.Close() params := request.NewAttachmentOriginal() if err := params.Fill(r); err != nil { - logger.LogParamError("Attachment.Original", r, err, params.Auditable()) + logger.LogParamError("Attachment.Original", r, err) resputil.JSON(w, err) return } + value, err := h.Original(r.Context(), params) if err != nil { logger.LogControllerError("Attachment.Original", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Attachment.Original", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -63,14 +65,16 @@ func NewAttachment(h AttachmentAPI) *Attachment { defer r.Body.Close() params := request.NewAttachmentPreview() if err := params.Fill(r); err != nil { - logger.LogParamError("Attachment.Preview", r, err, params.Auditable()) + logger.LogParamError("Attachment.Preview", r, err) resputil.JSON(w, err) return } + value, err := h.Preview(r.Context(), params) if err != nil { logger.LogControllerError("Attachment.Preview", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Attachment.Preview", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/messaging/rest/handlers/channel.go b/messaging/rest/handlers/channel.go index 4dab04044..c0704b5ce 100644 --- a/messaging/rest/handlers/channel.go +++ b/messaging/rest/handlers/channel.go @@ -65,14 +65,16 @@ func NewChannel(h ChannelAPI) *Channel { defer r.Body.Close() params := request.NewChannelList() if err := params.Fill(r); err != nil { - logger.LogParamError("Channel.List", r, err, params.Auditable()) + logger.LogParamError("Channel.List", r, err) resputil.JSON(w, err) return } + value, err := h.List(r.Context(), params) if err != nil { logger.LogControllerError("Channel.List", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Channel.List", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -83,14 +85,16 @@ func NewChannel(h ChannelAPI) *Channel { defer r.Body.Close() params := request.NewChannelCreate() if err := params.Fill(r); err != nil { - logger.LogParamError("Channel.Create", r, err, params.Auditable()) + logger.LogParamError("Channel.Create", r, err) resputil.JSON(w, err) return } + value, err := h.Create(r.Context(), params) if err != nil { logger.LogControllerError("Channel.Create", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Channel.Create", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -101,14 +105,16 @@ func NewChannel(h ChannelAPI) *Channel { defer r.Body.Close() params := request.NewChannelUpdate() if err := params.Fill(r); err != nil { - logger.LogParamError("Channel.Update", r, err, params.Auditable()) + logger.LogParamError("Channel.Update", r, err) resputil.JSON(w, err) return } + value, err := h.Update(r.Context(), params) if err != nil { logger.LogControllerError("Channel.Update", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Channel.Update", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -119,14 +125,16 @@ func NewChannel(h ChannelAPI) *Channel { defer r.Body.Close() params := request.NewChannelState() if err := params.Fill(r); err != nil { - logger.LogParamError("Channel.State", r, err, params.Auditable()) + logger.LogParamError("Channel.State", r, err) resputil.JSON(w, err) return } + value, err := h.State(r.Context(), params) if err != nil { logger.LogControllerError("Channel.State", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Channel.State", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -137,14 +145,16 @@ func NewChannel(h ChannelAPI) *Channel { defer r.Body.Close() params := request.NewChannelSetFlag() if err := params.Fill(r); err != nil { - logger.LogParamError("Channel.SetFlag", r, err, params.Auditable()) + logger.LogParamError("Channel.SetFlag", r, err) resputil.JSON(w, err) return } + value, err := h.SetFlag(r.Context(), params) if err != nil { logger.LogControllerError("Channel.SetFlag", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Channel.SetFlag", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -155,14 +165,16 @@ func NewChannel(h ChannelAPI) *Channel { defer r.Body.Close() params := request.NewChannelRemoveFlag() if err := params.Fill(r); err != nil { - logger.LogParamError("Channel.RemoveFlag", r, err, params.Auditable()) + logger.LogParamError("Channel.RemoveFlag", r, err) resputil.JSON(w, err) return } + value, err := h.RemoveFlag(r.Context(), params) if err != nil { logger.LogControllerError("Channel.RemoveFlag", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Channel.RemoveFlag", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -173,14 +185,16 @@ func NewChannel(h ChannelAPI) *Channel { defer r.Body.Close() params := request.NewChannelRead() if err := params.Fill(r); err != nil { - logger.LogParamError("Channel.Read", r, err, params.Auditable()) + logger.LogParamError("Channel.Read", r, err) resputil.JSON(w, err) return } + value, err := h.Read(r.Context(), params) if err != nil { logger.LogControllerError("Channel.Read", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Channel.Read", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -191,14 +205,16 @@ func NewChannel(h ChannelAPI) *Channel { defer r.Body.Close() params := request.NewChannelMembers() if err := params.Fill(r); err != nil { - logger.LogParamError("Channel.Members", r, err, params.Auditable()) + logger.LogParamError("Channel.Members", r, err) resputil.JSON(w, err) return } + value, err := h.Members(r.Context(), params) if err != nil { logger.LogControllerError("Channel.Members", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Channel.Members", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -209,14 +225,16 @@ func NewChannel(h ChannelAPI) *Channel { defer r.Body.Close() params := request.NewChannelJoin() if err := params.Fill(r); err != nil { - logger.LogParamError("Channel.Join", r, err, params.Auditable()) + logger.LogParamError("Channel.Join", r, err) resputil.JSON(w, err) return } + value, err := h.Join(r.Context(), params) if err != nil { logger.LogControllerError("Channel.Join", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Channel.Join", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -227,14 +245,16 @@ func NewChannel(h ChannelAPI) *Channel { defer r.Body.Close() params := request.NewChannelPart() if err := params.Fill(r); err != nil { - logger.LogParamError("Channel.Part", r, err, params.Auditable()) + logger.LogParamError("Channel.Part", r, err) resputil.JSON(w, err) return } + value, err := h.Part(r.Context(), params) if err != nil { logger.LogControllerError("Channel.Part", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Channel.Part", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -245,14 +265,16 @@ func NewChannel(h ChannelAPI) *Channel { defer r.Body.Close() params := request.NewChannelInvite() if err := params.Fill(r); err != nil { - logger.LogParamError("Channel.Invite", r, err, params.Auditable()) + logger.LogParamError("Channel.Invite", r, err) resputil.JSON(w, err) return } + value, err := h.Invite(r.Context(), params) if err != nil { logger.LogControllerError("Channel.Invite", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Channel.Invite", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -263,14 +285,16 @@ func NewChannel(h ChannelAPI) *Channel { defer r.Body.Close() params := request.NewChannelAttach() if err := params.Fill(r); err != nil { - logger.LogParamError("Channel.Attach", r, err, params.Auditable()) + logger.LogParamError("Channel.Attach", r, err) resputil.JSON(w, err) return } + value, err := h.Attach(r.Context(), params) if err != nil { logger.LogControllerError("Channel.Attach", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Channel.Attach", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/messaging/rest/handlers/commands.go b/messaging/rest/handlers/commands.go index ed79f3921..0fa6c7b99 100644 --- a/messaging/rest/handlers/commands.go +++ b/messaging/rest/handlers/commands.go @@ -43,14 +43,16 @@ func NewCommands(h CommandsAPI) *Commands { defer r.Body.Close() params := request.NewCommandsList() if err := params.Fill(r); err != nil { - logger.LogParamError("Commands.List", r, err, params.Auditable()) + logger.LogParamError("Commands.List", r, err) resputil.JSON(w, err) return } + value, err := h.List(r.Context(), params) if err != nil { logger.LogControllerError("Commands.List", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Commands.List", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/messaging/rest/handlers/message.go b/messaging/rest/handlers/message.go index be1d2386c..6d3cfa096 100644 --- a/messaging/rest/handlers/message.go +++ b/messaging/rest/handlers/message.go @@ -65,14 +65,16 @@ func NewMessage(h MessageAPI) *Message { defer r.Body.Close() params := request.NewMessageCreate() if err := params.Fill(r); err != nil { - logger.LogParamError("Message.Create", r, err, params.Auditable()) + logger.LogParamError("Message.Create", r, err) resputil.JSON(w, err) return } + value, err := h.Create(r.Context(), params) if err != nil { logger.LogControllerError("Message.Create", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Message.Create", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -83,14 +85,16 @@ func NewMessage(h MessageAPI) *Message { defer r.Body.Close() params := request.NewMessageExecuteCommand() if err := params.Fill(r); err != nil { - logger.LogParamError("Message.ExecuteCommand", r, err, params.Auditable()) + logger.LogParamError("Message.ExecuteCommand", r, err) resputil.JSON(w, err) return } + value, err := h.ExecuteCommand(r.Context(), params) if err != nil { logger.LogControllerError("Message.ExecuteCommand", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Message.ExecuteCommand", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -101,14 +105,16 @@ func NewMessage(h MessageAPI) *Message { defer r.Body.Close() params := request.NewMessageMarkAsRead() if err := params.Fill(r); err != nil { - logger.LogParamError("Message.MarkAsRead", r, err, params.Auditable()) + logger.LogParamError("Message.MarkAsRead", r, err) resputil.JSON(w, err) return } + value, err := h.MarkAsRead(r.Context(), params) if err != nil { logger.LogControllerError("Message.MarkAsRead", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Message.MarkAsRead", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -119,14 +125,16 @@ func NewMessage(h MessageAPI) *Message { defer r.Body.Close() params := request.NewMessageEdit() if err := params.Fill(r); err != nil { - logger.LogParamError("Message.Edit", r, err, params.Auditable()) + logger.LogParamError("Message.Edit", r, err) resputil.JSON(w, err) return } + value, err := h.Edit(r.Context(), params) if err != nil { logger.LogControllerError("Message.Edit", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Message.Edit", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -137,14 +145,16 @@ func NewMessage(h MessageAPI) *Message { defer r.Body.Close() params := request.NewMessageDelete() if err := params.Fill(r); err != nil { - logger.LogParamError("Message.Delete", r, err, params.Auditable()) + logger.LogParamError("Message.Delete", r, err) resputil.JSON(w, err) return } + value, err := h.Delete(r.Context(), params) if err != nil { logger.LogControllerError("Message.Delete", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Message.Delete", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -155,14 +165,16 @@ func NewMessage(h MessageAPI) *Message { defer r.Body.Close() params := request.NewMessageReplyCreate() if err := params.Fill(r); err != nil { - logger.LogParamError("Message.ReplyCreate", r, err, params.Auditable()) + logger.LogParamError("Message.ReplyCreate", r, err) resputil.JSON(w, err) return } + value, err := h.ReplyCreate(r.Context(), params) if err != nil { logger.LogControllerError("Message.ReplyCreate", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Message.ReplyCreate", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -173,14 +185,16 @@ func NewMessage(h MessageAPI) *Message { defer r.Body.Close() params := request.NewMessagePinCreate() if err := params.Fill(r); err != nil { - logger.LogParamError("Message.PinCreate", r, err, params.Auditable()) + logger.LogParamError("Message.PinCreate", r, err) resputil.JSON(w, err) return } + value, err := h.PinCreate(r.Context(), params) if err != nil { logger.LogControllerError("Message.PinCreate", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Message.PinCreate", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -191,14 +205,16 @@ func NewMessage(h MessageAPI) *Message { defer r.Body.Close() params := request.NewMessagePinRemove() if err := params.Fill(r); err != nil { - logger.LogParamError("Message.PinRemove", r, err, params.Auditable()) + logger.LogParamError("Message.PinRemove", r, err) resputil.JSON(w, err) return } + value, err := h.PinRemove(r.Context(), params) if err != nil { logger.LogControllerError("Message.PinRemove", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Message.PinRemove", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -209,14 +225,16 @@ func NewMessage(h MessageAPI) *Message { defer r.Body.Close() params := request.NewMessageBookmarkCreate() if err := params.Fill(r); err != nil { - logger.LogParamError("Message.BookmarkCreate", r, err, params.Auditable()) + logger.LogParamError("Message.BookmarkCreate", r, err) resputil.JSON(w, err) return } + value, err := h.BookmarkCreate(r.Context(), params) if err != nil { logger.LogControllerError("Message.BookmarkCreate", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Message.BookmarkCreate", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -227,14 +245,16 @@ func NewMessage(h MessageAPI) *Message { defer r.Body.Close() params := request.NewMessageBookmarkRemove() if err := params.Fill(r); err != nil { - logger.LogParamError("Message.BookmarkRemove", r, err, params.Auditable()) + logger.LogParamError("Message.BookmarkRemove", r, err) resputil.JSON(w, err) return } + value, err := h.BookmarkRemove(r.Context(), params) if err != nil { logger.LogControllerError("Message.BookmarkRemove", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Message.BookmarkRemove", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -245,14 +265,16 @@ func NewMessage(h MessageAPI) *Message { defer r.Body.Close() params := request.NewMessageReactionCreate() if err := params.Fill(r); err != nil { - logger.LogParamError("Message.ReactionCreate", r, err, params.Auditable()) + logger.LogParamError("Message.ReactionCreate", r, err) resputil.JSON(w, err) return } + value, err := h.ReactionCreate(r.Context(), params) if err != nil { logger.LogControllerError("Message.ReactionCreate", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Message.ReactionCreate", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -263,14 +285,16 @@ func NewMessage(h MessageAPI) *Message { defer r.Body.Close() params := request.NewMessageReactionRemove() if err := params.Fill(r); err != nil { - logger.LogParamError("Message.ReactionRemove", r, err, params.Auditable()) + logger.LogParamError("Message.ReactionRemove", r, err) resputil.JSON(w, err) return } + value, err := h.ReactionRemove(r.Context(), params) if err != nil { logger.LogControllerError("Message.ReactionRemove", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Message.ReactionRemove", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/messaging/rest/handlers/permissions.go b/messaging/rest/handlers/permissions.go index b35b3fc93..e230e1381 100644 --- a/messaging/rest/handlers/permissions.go +++ b/messaging/rest/handlers/permissions.go @@ -51,14 +51,16 @@ func NewPermissions(h PermissionsAPI) *Permissions { defer r.Body.Close() params := request.NewPermissionsList() if err := params.Fill(r); err != nil { - logger.LogParamError("Permissions.List", r, err, params.Auditable()) + logger.LogParamError("Permissions.List", r, err) resputil.JSON(w, err) return } + value, err := h.List(r.Context(), params) if err != nil { logger.LogControllerError("Permissions.List", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Permissions.List", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -69,14 +71,16 @@ func NewPermissions(h PermissionsAPI) *Permissions { defer r.Body.Close() params := request.NewPermissionsEffective() if err := params.Fill(r); err != nil { - logger.LogParamError("Permissions.Effective", r, err, params.Auditable()) + logger.LogParamError("Permissions.Effective", r, err) resputil.JSON(w, err) return } + value, err := h.Effective(r.Context(), params) if err != nil { logger.LogControllerError("Permissions.Effective", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Permissions.Effective", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -87,14 +91,16 @@ func NewPermissions(h PermissionsAPI) *Permissions { defer r.Body.Close() params := request.NewPermissionsRead() if err := params.Fill(r); err != nil { - logger.LogParamError("Permissions.Read", r, err, params.Auditable()) + logger.LogParamError("Permissions.Read", r, err) resputil.JSON(w, err) return } + value, err := h.Read(r.Context(), params) if err != nil { logger.LogControllerError("Permissions.Read", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Permissions.Read", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -105,14 +111,16 @@ func NewPermissions(h PermissionsAPI) *Permissions { defer r.Body.Close() params := request.NewPermissionsDelete() if err := params.Fill(r); err != nil { - logger.LogParamError("Permissions.Delete", r, err, params.Auditable()) + logger.LogParamError("Permissions.Delete", r, err) resputil.JSON(w, err) return } + value, err := h.Delete(r.Context(), params) if err != nil { logger.LogControllerError("Permissions.Delete", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Permissions.Delete", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -123,14 +131,16 @@ func NewPermissions(h PermissionsAPI) *Permissions { defer r.Body.Close() params := request.NewPermissionsUpdate() if err := params.Fill(r); err != nil { - logger.LogParamError("Permissions.Update", r, err, params.Auditable()) + logger.LogParamError("Permissions.Update", r, err) resputil.JSON(w, err) return } + value, err := h.Update(r.Context(), params) if err != nil { logger.LogControllerError("Permissions.Update", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Permissions.Update", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/messaging/rest/handlers/search.go b/messaging/rest/handlers/search.go index f991caede..41db2d619 100644 --- a/messaging/rest/handlers/search.go +++ b/messaging/rest/handlers/search.go @@ -45,14 +45,16 @@ func NewSearch(h SearchAPI) *Search { defer r.Body.Close() params := request.NewSearchMessages() if err := params.Fill(r); err != nil { - logger.LogParamError("Search.Messages", r, err, params.Auditable()) + logger.LogParamError("Search.Messages", r, err) resputil.JSON(w, err) return } + value, err := h.Messages(r.Context(), params) if err != nil { logger.LogControllerError("Search.Messages", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Search.Messages", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -63,14 +65,16 @@ func NewSearch(h SearchAPI) *Search { defer r.Body.Close() params := request.NewSearchThreads() if err := params.Fill(r); err != nil { - logger.LogParamError("Search.Threads", r, err, params.Auditable()) + logger.LogParamError("Search.Threads", r, err) resputil.JSON(w, err) return } + value, err := h.Threads(r.Context(), params) if err != nil { logger.LogControllerError("Search.Threads", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Search.Threads", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/messaging/rest/handlers/status.go b/messaging/rest/handlers/status.go index 1afa2ef65..41a05366a 100644 --- a/messaging/rest/handlers/status.go +++ b/messaging/rest/handlers/status.go @@ -47,14 +47,16 @@ func NewStatus(h StatusAPI) *Status { defer r.Body.Close() params := request.NewStatusList() if err := params.Fill(r); err != nil { - logger.LogParamError("Status.List", r, err, params.Auditable()) + logger.LogParamError("Status.List", r, err) resputil.JSON(w, err) return } + value, err := h.List(r.Context(), params) if err != nil { logger.LogControllerError("Status.List", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Status.List", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -65,14 +67,16 @@ func NewStatus(h StatusAPI) *Status { defer r.Body.Close() params := request.NewStatusSet() if err := params.Fill(r); err != nil { - logger.LogParamError("Status.Set", r, err, params.Auditable()) + logger.LogParamError("Status.Set", r, err) resputil.JSON(w, err) return } + value, err := h.Set(r.Context(), params) if err != nil { logger.LogControllerError("Status.Set", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Status.Set", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -83,14 +87,16 @@ func NewStatus(h StatusAPI) *Status { defer r.Body.Close() params := request.NewStatusDelete() if err := params.Fill(r); err != nil { - logger.LogParamError("Status.Delete", r, err, params.Auditable()) + logger.LogParamError("Status.Delete", r, err) resputil.JSON(w, err) return } + value, err := h.Delete(r.Context(), params) if err != nil { logger.LogControllerError("Status.Delete", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Status.Delete", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/messaging/rest/handlers/webhooks.go b/messaging/rest/handlers/webhooks.go index c8618ca7a..82912baa1 100644 --- a/messaging/rest/handlers/webhooks.go +++ b/messaging/rest/handlers/webhooks.go @@ -51,14 +51,16 @@ func NewWebhooks(h WebhooksAPI) *Webhooks { defer r.Body.Close() params := request.NewWebhooksList() if err := params.Fill(r); err != nil { - logger.LogParamError("Webhooks.List", r, err, params.Auditable()) + logger.LogParamError("Webhooks.List", r, err) resputil.JSON(w, err) return } + value, err := h.List(r.Context(), params) if err != nil { logger.LogControllerError("Webhooks.List", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Webhooks.List", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -69,14 +71,16 @@ func NewWebhooks(h WebhooksAPI) *Webhooks { defer r.Body.Close() params := request.NewWebhooksCreate() if err := params.Fill(r); err != nil { - logger.LogParamError("Webhooks.Create", r, err, params.Auditable()) + logger.LogParamError("Webhooks.Create", r, err) resputil.JSON(w, err) return } + value, err := h.Create(r.Context(), params) if err != nil { logger.LogControllerError("Webhooks.Create", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Webhooks.Create", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -87,14 +91,16 @@ func NewWebhooks(h WebhooksAPI) *Webhooks { defer r.Body.Close() params := request.NewWebhooksUpdate() if err := params.Fill(r); err != nil { - logger.LogParamError("Webhooks.Update", r, err, params.Auditable()) + logger.LogParamError("Webhooks.Update", r, err) resputil.JSON(w, err) return } + value, err := h.Update(r.Context(), params) if err != nil { logger.LogControllerError("Webhooks.Update", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Webhooks.Update", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -105,14 +111,16 @@ func NewWebhooks(h WebhooksAPI) *Webhooks { defer r.Body.Close() params := request.NewWebhooksGet() if err := params.Fill(r); err != nil { - logger.LogParamError("Webhooks.Get", r, err, params.Auditable()) + logger.LogParamError("Webhooks.Get", r, err) resputil.JSON(w, err) return } + value, err := h.Get(r.Context(), params) if err != nil { logger.LogControllerError("Webhooks.Get", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Webhooks.Get", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -123,14 +131,16 @@ func NewWebhooks(h WebhooksAPI) *Webhooks { defer r.Body.Close() params := request.NewWebhooksDelete() if err := params.Fill(r); err != nil { - logger.LogParamError("Webhooks.Delete", r, err, params.Auditable()) + logger.LogParamError("Webhooks.Delete", r, err) resputil.JSON(w, err) return } + value, err := h.Delete(r.Context(), params) if err != nil { logger.LogControllerError("Webhooks.Delete", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Webhooks.Delete", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/messaging/rest/handlers/webhooks_public.go b/messaging/rest/handlers/webhooks_public.go index b9a50d62b..a61684a4f 100644 --- a/messaging/rest/handlers/webhooks_public.go +++ b/messaging/rest/handlers/webhooks_public.go @@ -45,14 +45,16 @@ func NewWebhooksPublic(h WebhooksPublicAPI) *WebhooksPublic { defer r.Body.Close() params := request.NewWebhooksPublicDelete() if err := params.Fill(r); err != nil { - logger.LogParamError("WebhooksPublic.Delete", r, err, params.Auditable()) + logger.LogParamError("WebhooksPublic.Delete", r, err) resputil.JSON(w, err) return } + value, err := h.Delete(r.Context(), params) if err != nil { logger.LogControllerError("WebhooksPublic.Delete", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("WebhooksPublic.Delete", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -63,14 +65,16 @@ func NewWebhooksPublic(h WebhooksPublicAPI) *WebhooksPublic { defer r.Body.Close() params := request.NewWebhooksPublicCreate() if err := params.Fill(r); err != nil { - logger.LogParamError("WebhooksPublic.Create", r, err, params.Auditable()) + logger.LogParamError("WebhooksPublic.Create", r, err) resputil.JSON(w, err) return } + value, err := h.Create(r.Context(), params) if err != nil { logger.LogControllerError("WebhooksPublic.Create", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("WebhooksPublic.Create", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/pkg/logger/handlers.go b/pkg/logger/handlers.go index bc83fc570..9cd9d8545 100644 --- a/pkg/logger/handlers.go +++ b/pkg/logger/handlers.go @@ -6,19 +6,18 @@ import ( "go.uber.org/zap" ) -// LogParamError for logggin invalid params -func LogParamError(name string, r *http.Request, err error, params interface{}) { - ContextValue(r.Context()).Error( +// LogParamError for loggin invalid params +func LogParamError(name string, r *http.Request, err error) { + ContextValue(r.Context()).Debug( "invalid params for REST controller "+name, zap.Error(err), zap.String("controller", name), - zap.Any("params", params), ) } // LogControllerError for logging errors inside REST controllers func LogControllerError(name string, r *http.Request, err error, params interface{}) { - ContextValue(r.Context()).Error( + ContextValue(r.Context()).Debug( "error in REST controller "+name, zap.Error(err), zap.String("controller", name), @@ -30,7 +29,6 @@ func LogControllerError(name string, r *http.Request, err error, params interfac // // Each log entry has it's own set of fields func LogControllerCall(name string, r *http.Request, params interface{}) { - // @todo params should provide an (auditable?) interface that would return obfuscated data ContextValue(r.Context()).Debug( "REST controller "+name+" called", zap.String("controller", name), diff --git a/system/rest/handlers/application.go b/system/rest/handlers/application.go index 4de83b75b..f832e4199 100644 --- a/system/rest/handlers/application.go +++ b/system/rest/handlers/application.go @@ -51,14 +51,16 @@ func NewApplication(h ApplicationAPI) *Application { defer r.Body.Close() params := request.NewApplicationList() if err := params.Fill(r); err != nil { - logger.LogParamError("Application.List", r, err, params.Auditable()) + logger.LogParamError("Application.List", r, err) resputil.JSON(w, err) return } + value, err := h.List(r.Context(), params) if err != nil { logger.LogControllerError("Application.List", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Application.List", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -69,14 +71,16 @@ func NewApplication(h ApplicationAPI) *Application { defer r.Body.Close() params := request.NewApplicationCreate() if err := params.Fill(r); err != nil { - logger.LogParamError("Application.Create", r, err, params.Auditable()) + logger.LogParamError("Application.Create", r, err) resputil.JSON(w, err) return } + value, err := h.Create(r.Context(), params) if err != nil { logger.LogControllerError("Application.Create", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Application.Create", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -87,14 +91,16 @@ func NewApplication(h ApplicationAPI) *Application { defer r.Body.Close() params := request.NewApplicationUpdate() if err := params.Fill(r); err != nil { - logger.LogParamError("Application.Update", r, err, params.Auditable()) + logger.LogParamError("Application.Update", r, err) resputil.JSON(w, err) return } + value, err := h.Update(r.Context(), params) if err != nil { logger.LogControllerError("Application.Update", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Application.Update", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -105,14 +111,16 @@ func NewApplication(h ApplicationAPI) *Application { defer r.Body.Close() params := request.NewApplicationRead() if err := params.Fill(r); err != nil { - logger.LogParamError("Application.Read", r, err, params.Auditable()) + logger.LogParamError("Application.Read", r, err) resputil.JSON(w, err) return } + value, err := h.Read(r.Context(), params) if err != nil { logger.LogControllerError("Application.Read", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Application.Read", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -123,14 +131,16 @@ func NewApplication(h ApplicationAPI) *Application { defer r.Body.Close() params := request.NewApplicationDelete() if err := params.Fill(r); err != nil { - logger.LogParamError("Application.Delete", r, err, params.Auditable()) + logger.LogParamError("Application.Delete", r, err) resputil.JSON(w, err) return } + value, err := h.Delete(r.Context(), params) if err != nil { logger.LogControllerError("Application.Delete", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Application.Delete", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/system/rest/handlers/auth.go b/system/rest/handlers/auth.go index 1ba439e5f..b550f954b 100644 --- a/system/rest/handlers/auth.go +++ b/system/rest/handlers/auth.go @@ -49,14 +49,16 @@ func NewAuth(h AuthAPI) *Auth { defer r.Body.Close() params := request.NewAuthSettings() if err := params.Fill(r); err != nil { - logger.LogParamError("Auth.Settings", r, err, params.Auditable()) + logger.LogParamError("Auth.Settings", r, err) resputil.JSON(w, err) return } + value, err := h.Settings(r.Context(), params) if err != nil { logger.LogControllerError("Auth.Settings", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Auth.Settings", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -67,14 +69,16 @@ func NewAuth(h AuthAPI) *Auth { defer r.Body.Close() params := request.NewAuthCheck() if err := params.Fill(r); err != nil { - logger.LogParamError("Auth.Check", r, err, params.Auditable()) + logger.LogParamError("Auth.Check", r, err) resputil.JSON(w, err) return } + value, err := h.Check(r.Context(), params) if err != nil { logger.LogControllerError("Auth.Check", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Auth.Check", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -85,14 +89,16 @@ func NewAuth(h AuthAPI) *Auth { defer r.Body.Close() params := request.NewAuthExchangeAuthToken() if err := params.Fill(r); err != nil { - logger.LogParamError("Auth.ExchangeAuthToken", r, err, params.Auditable()) + logger.LogParamError("Auth.ExchangeAuthToken", r, err) resputil.JSON(w, err) return } + value, err := h.ExchangeAuthToken(r.Context(), params) if err != nil { logger.LogControllerError("Auth.ExchangeAuthToken", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Auth.ExchangeAuthToken", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -103,14 +109,16 @@ func NewAuth(h AuthAPI) *Auth { defer r.Body.Close() params := request.NewAuthLogout() if err := params.Fill(r); err != nil { - logger.LogParamError("Auth.Logout", r, err, params.Auditable()) + logger.LogParamError("Auth.Logout", r, err) resputil.JSON(w, err) return } + value, err := h.Logout(r.Context(), params) if err != nil { logger.LogControllerError("Auth.Logout", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Auth.Logout", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/system/rest/handlers/auth_internal.go b/system/rest/handlers/auth_internal.go index e09ea4e6d..76fa447f1 100644 --- a/system/rest/handlers/auth_internal.go +++ b/system/rest/handlers/auth_internal.go @@ -55,14 +55,16 @@ func NewAuthInternal(h AuthInternalAPI) *AuthInternal { defer r.Body.Close() params := request.NewAuthInternalLogin() if err := params.Fill(r); err != nil { - logger.LogParamError("AuthInternal.Login", r, err, params.Auditable()) + logger.LogParamError("AuthInternal.Login", r, err) resputil.JSON(w, err) return } + value, err := h.Login(r.Context(), params) if err != nil { logger.LogControllerError("AuthInternal.Login", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("AuthInternal.Login", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -73,14 +75,16 @@ func NewAuthInternal(h AuthInternalAPI) *AuthInternal { defer r.Body.Close() params := request.NewAuthInternalSignup() if err := params.Fill(r); err != nil { - logger.LogParamError("AuthInternal.Signup", r, err, params.Auditable()) + logger.LogParamError("AuthInternal.Signup", r, err) resputil.JSON(w, err) return } + value, err := h.Signup(r.Context(), params) if err != nil { logger.LogControllerError("AuthInternal.Signup", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("AuthInternal.Signup", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -91,14 +95,16 @@ func NewAuthInternal(h AuthInternalAPI) *AuthInternal { defer r.Body.Close() params := request.NewAuthInternalRequestPasswordReset() if err := params.Fill(r); err != nil { - logger.LogParamError("AuthInternal.RequestPasswordReset", r, err, params.Auditable()) + logger.LogParamError("AuthInternal.RequestPasswordReset", r, err) resputil.JSON(w, err) return } + value, err := h.RequestPasswordReset(r.Context(), params) if err != nil { logger.LogControllerError("AuthInternal.RequestPasswordReset", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("AuthInternal.RequestPasswordReset", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -109,14 +115,16 @@ func NewAuthInternal(h AuthInternalAPI) *AuthInternal { defer r.Body.Close() params := request.NewAuthInternalExchangePasswordResetToken() if err := params.Fill(r); err != nil { - logger.LogParamError("AuthInternal.ExchangePasswordResetToken", r, err, params.Auditable()) + logger.LogParamError("AuthInternal.ExchangePasswordResetToken", r, err) resputil.JSON(w, err) return } + value, err := h.ExchangePasswordResetToken(r.Context(), params) if err != nil { logger.LogControllerError("AuthInternal.ExchangePasswordResetToken", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("AuthInternal.ExchangePasswordResetToken", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -127,14 +135,16 @@ func NewAuthInternal(h AuthInternalAPI) *AuthInternal { defer r.Body.Close() params := request.NewAuthInternalResetPassword() if err := params.Fill(r); err != nil { - logger.LogParamError("AuthInternal.ResetPassword", r, err, params.Auditable()) + logger.LogParamError("AuthInternal.ResetPassword", r, err) resputil.JSON(w, err) return } + value, err := h.ResetPassword(r.Context(), params) if err != nil { logger.LogControllerError("AuthInternal.ResetPassword", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("AuthInternal.ResetPassword", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -145,14 +155,16 @@ func NewAuthInternal(h AuthInternalAPI) *AuthInternal { defer r.Body.Close() params := request.NewAuthInternalConfirmEmail() if err := params.Fill(r); err != nil { - logger.LogParamError("AuthInternal.ConfirmEmail", r, err, params.Auditable()) + logger.LogParamError("AuthInternal.ConfirmEmail", r, err) resputil.JSON(w, err) return } + value, err := h.ConfirmEmail(r.Context(), params) if err != nil { logger.LogControllerError("AuthInternal.ConfirmEmail", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("AuthInternal.ConfirmEmail", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -163,14 +175,16 @@ func NewAuthInternal(h AuthInternalAPI) *AuthInternal { defer r.Body.Close() params := request.NewAuthInternalChangePassword() if err := params.Fill(r); err != nil { - logger.LogParamError("AuthInternal.ChangePassword", r, err, params.Auditable()) + logger.LogParamError("AuthInternal.ChangePassword", r, err) resputil.JSON(w, err) return } + value, err := h.ChangePassword(r.Context(), params) if err != nil { logger.LogControllerError("AuthInternal.ChangePassword", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("AuthInternal.ChangePassword", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/system/rest/handlers/organisation.go b/system/rest/handlers/organisation.go index 141fa7435..602c083a9 100644 --- a/system/rest/handlers/organisation.go +++ b/system/rest/handlers/organisation.go @@ -53,14 +53,16 @@ func NewOrganisation(h OrganisationAPI) *Organisation { defer r.Body.Close() params := request.NewOrganisationList() if err := params.Fill(r); err != nil { - logger.LogParamError("Organisation.List", r, err, params.Auditable()) + logger.LogParamError("Organisation.List", r, err) resputil.JSON(w, err) return } + value, err := h.List(r.Context(), params) if err != nil { logger.LogControllerError("Organisation.List", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Organisation.List", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -71,14 +73,16 @@ func NewOrganisation(h OrganisationAPI) *Organisation { defer r.Body.Close() params := request.NewOrganisationCreate() if err := params.Fill(r); err != nil { - logger.LogParamError("Organisation.Create", r, err, params.Auditable()) + logger.LogParamError("Organisation.Create", r, err) resputil.JSON(w, err) return } + value, err := h.Create(r.Context(), params) if err != nil { logger.LogControllerError("Organisation.Create", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Organisation.Create", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -89,14 +93,16 @@ func NewOrganisation(h OrganisationAPI) *Organisation { defer r.Body.Close() params := request.NewOrganisationUpdate() if err := params.Fill(r); err != nil { - logger.LogParamError("Organisation.Update", r, err, params.Auditable()) + logger.LogParamError("Organisation.Update", r, err) resputil.JSON(w, err) return } + value, err := h.Update(r.Context(), params) if err != nil { logger.LogControllerError("Organisation.Update", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Organisation.Update", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -107,14 +113,16 @@ func NewOrganisation(h OrganisationAPI) *Organisation { defer r.Body.Close() params := request.NewOrganisationDelete() if err := params.Fill(r); err != nil { - logger.LogParamError("Organisation.Delete", r, err, params.Auditable()) + logger.LogParamError("Organisation.Delete", r, err) resputil.JSON(w, err) return } + value, err := h.Delete(r.Context(), params) if err != nil { logger.LogControllerError("Organisation.Delete", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Organisation.Delete", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -125,14 +133,16 @@ func NewOrganisation(h OrganisationAPI) *Organisation { defer r.Body.Close() params := request.NewOrganisationRead() if err := params.Fill(r); err != nil { - logger.LogParamError("Organisation.Read", r, err, params.Auditable()) + logger.LogParamError("Organisation.Read", r, err) resputil.JSON(w, err) return } + value, err := h.Read(r.Context(), params) if err != nil { logger.LogControllerError("Organisation.Read", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Organisation.Read", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -143,14 +153,16 @@ func NewOrganisation(h OrganisationAPI) *Organisation { defer r.Body.Close() params := request.NewOrganisationArchive() if err := params.Fill(r); err != nil { - logger.LogParamError("Organisation.Archive", r, err, params.Auditable()) + logger.LogParamError("Organisation.Archive", r, err) resputil.JSON(w, err) return } + value, err := h.Archive(r.Context(), params) if err != nil { logger.LogControllerError("Organisation.Archive", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Organisation.Archive", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/system/rest/handlers/permissions.go b/system/rest/handlers/permissions.go index db401bb3a..7d6576cdf 100644 --- a/system/rest/handlers/permissions.go +++ b/system/rest/handlers/permissions.go @@ -51,14 +51,16 @@ func NewPermissions(h PermissionsAPI) *Permissions { defer r.Body.Close() params := request.NewPermissionsList() if err := params.Fill(r); err != nil { - logger.LogParamError("Permissions.List", r, err, params.Auditable()) + logger.LogParamError("Permissions.List", r, err) resputil.JSON(w, err) return } + value, err := h.List(r.Context(), params) if err != nil { logger.LogControllerError("Permissions.List", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Permissions.List", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -69,14 +71,16 @@ func NewPermissions(h PermissionsAPI) *Permissions { defer r.Body.Close() params := request.NewPermissionsEffective() if err := params.Fill(r); err != nil { - logger.LogParamError("Permissions.Effective", r, err, params.Auditable()) + logger.LogParamError("Permissions.Effective", r, err) resputil.JSON(w, err) return } + value, err := h.Effective(r.Context(), params) if err != nil { logger.LogControllerError("Permissions.Effective", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Permissions.Effective", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -87,14 +91,16 @@ func NewPermissions(h PermissionsAPI) *Permissions { defer r.Body.Close() params := request.NewPermissionsRead() if err := params.Fill(r); err != nil { - logger.LogParamError("Permissions.Read", r, err, params.Auditable()) + logger.LogParamError("Permissions.Read", r, err) resputil.JSON(w, err) return } + value, err := h.Read(r.Context(), params) if err != nil { logger.LogControllerError("Permissions.Read", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Permissions.Read", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -105,14 +111,16 @@ func NewPermissions(h PermissionsAPI) *Permissions { defer r.Body.Close() params := request.NewPermissionsDelete() if err := params.Fill(r); err != nil { - logger.LogParamError("Permissions.Delete", r, err, params.Auditable()) + logger.LogParamError("Permissions.Delete", r, err) resputil.JSON(w, err) return } + value, err := h.Delete(r.Context(), params) if err != nil { logger.LogControllerError("Permissions.Delete", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Permissions.Delete", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -123,14 +131,16 @@ func NewPermissions(h PermissionsAPI) *Permissions { defer r.Body.Close() params := request.NewPermissionsUpdate() if err := params.Fill(r); err != nil { - logger.LogParamError("Permissions.Update", r, err, params.Auditable()) + logger.LogParamError("Permissions.Update", r, err) resputil.JSON(w, err) return } + value, err := h.Update(r.Context(), params) if err != nil { logger.LogControllerError("Permissions.Update", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Permissions.Update", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/system/rest/handlers/role.go b/system/rest/handlers/role.go index 84689c8c9..ad5951171 100644 --- a/system/rest/handlers/role.go +++ b/system/rest/handlers/role.go @@ -63,14 +63,16 @@ func NewRole(h RoleAPI) *Role { defer r.Body.Close() params := request.NewRoleList() if err := params.Fill(r); err != nil { - logger.LogParamError("Role.List", r, err, params.Auditable()) + logger.LogParamError("Role.List", r, err) resputil.JSON(w, err) return } + value, err := h.List(r.Context(), params) if err != nil { logger.LogControllerError("Role.List", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Role.List", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -81,14 +83,16 @@ func NewRole(h RoleAPI) *Role { defer r.Body.Close() params := request.NewRoleCreate() if err := params.Fill(r); err != nil { - logger.LogParamError("Role.Create", r, err, params.Auditable()) + logger.LogParamError("Role.Create", r, err) resputil.JSON(w, err) return } + value, err := h.Create(r.Context(), params) if err != nil { logger.LogControllerError("Role.Create", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Role.Create", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -99,14 +103,16 @@ func NewRole(h RoleAPI) *Role { defer r.Body.Close() params := request.NewRoleUpdate() if err := params.Fill(r); err != nil { - logger.LogParamError("Role.Update", r, err, params.Auditable()) + logger.LogParamError("Role.Update", r, err) resputil.JSON(w, err) return } + value, err := h.Update(r.Context(), params) if err != nil { logger.LogControllerError("Role.Update", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Role.Update", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -117,14 +123,16 @@ func NewRole(h RoleAPI) *Role { defer r.Body.Close() params := request.NewRoleRead() if err := params.Fill(r); err != nil { - logger.LogParamError("Role.Read", r, err, params.Auditable()) + logger.LogParamError("Role.Read", r, err) resputil.JSON(w, err) return } + value, err := h.Read(r.Context(), params) if err != nil { logger.LogControllerError("Role.Read", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Role.Read", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -135,14 +143,16 @@ func NewRole(h RoleAPI) *Role { defer r.Body.Close() params := request.NewRoleDelete() if err := params.Fill(r); err != nil { - logger.LogParamError("Role.Delete", r, err, params.Auditable()) + logger.LogParamError("Role.Delete", r, err) resputil.JSON(w, err) return } + value, err := h.Delete(r.Context(), params) if err != nil { logger.LogControllerError("Role.Delete", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Role.Delete", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -153,14 +163,16 @@ func NewRole(h RoleAPI) *Role { defer r.Body.Close() params := request.NewRoleArchive() if err := params.Fill(r); err != nil { - logger.LogParamError("Role.Archive", r, err, params.Auditable()) + logger.LogParamError("Role.Archive", r, err) resputil.JSON(w, err) return } + value, err := h.Archive(r.Context(), params) if err != nil { logger.LogControllerError("Role.Archive", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Role.Archive", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -171,14 +183,16 @@ func NewRole(h RoleAPI) *Role { defer r.Body.Close() params := request.NewRoleMove() if err := params.Fill(r); err != nil { - logger.LogParamError("Role.Move", r, err, params.Auditable()) + logger.LogParamError("Role.Move", r, err) resputil.JSON(w, err) return } + value, err := h.Move(r.Context(), params) if err != nil { logger.LogControllerError("Role.Move", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Role.Move", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -189,14 +203,16 @@ func NewRole(h RoleAPI) *Role { defer r.Body.Close() params := request.NewRoleMerge() if err := params.Fill(r); err != nil { - logger.LogParamError("Role.Merge", r, err, params.Auditable()) + logger.LogParamError("Role.Merge", r, err) resputil.JSON(w, err) return } + value, err := h.Merge(r.Context(), params) if err != nil { logger.LogControllerError("Role.Merge", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Role.Merge", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -207,14 +223,16 @@ func NewRole(h RoleAPI) *Role { defer r.Body.Close() params := request.NewRoleMemberList() if err := params.Fill(r); err != nil { - logger.LogParamError("Role.MemberList", r, err, params.Auditable()) + logger.LogParamError("Role.MemberList", r, err) resputil.JSON(w, err) return } + value, err := h.MemberList(r.Context(), params) if err != nil { logger.LogControllerError("Role.MemberList", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Role.MemberList", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -225,14 +243,16 @@ func NewRole(h RoleAPI) *Role { defer r.Body.Close() params := request.NewRoleMemberAdd() if err := params.Fill(r); err != nil { - logger.LogParamError("Role.MemberAdd", r, err, params.Auditable()) + logger.LogParamError("Role.MemberAdd", r, err) resputil.JSON(w, err) return } + value, err := h.MemberAdd(r.Context(), params) if err != nil { logger.LogControllerError("Role.MemberAdd", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Role.MemberAdd", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -243,14 +263,16 @@ func NewRole(h RoleAPI) *Role { defer r.Body.Close() params := request.NewRoleMemberRemove() if err := params.Fill(r); err != nil { - logger.LogParamError("Role.MemberRemove", r, err, params.Auditable()) + logger.LogParamError("Role.MemberRemove", r, err) resputil.JSON(w, err) return } + value, err := h.MemberRemove(r.Context(), params) if err != nil { logger.LogControllerError("Role.MemberRemove", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Role.MemberRemove", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/system/rest/handlers/settings.go b/system/rest/handlers/settings.go index 5c2fb19d1..d850eb6b2 100644 --- a/system/rest/handlers/settings.go +++ b/system/rest/handlers/settings.go @@ -49,14 +49,16 @@ func NewSettings(h SettingsAPI) *Settings { defer r.Body.Close() params := request.NewSettingsList() if err := params.Fill(r); err != nil { - logger.LogParamError("Settings.List", r, err, params.Auditable()) + logger.LogParamError("Settings.List", r, err) resputil.JSON(w, err) return } + value, err := h.List(r.Context(), params) if err != nil { logger.LogControllerError("Settings.List", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Settings.List", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -67,14 +69,16 @@ func NewSettings(h SettingsAPI) *Settings { defer r.Body.Close() params := request.NewSettingsUpdate() if err := params.Fill(r); err != nil { - logger.LogParamError("Settings.Update", r, err, params.Auditable()) + logger.LogParamError("Settings.Update", r, err) resputil.JSON(w, err) return } + value, err := h.Update(r.Context(), params) if err != nil { logger.LogControllerError("Settings.Update", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Settings.Update", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -85,14 +89,16 @@ func NewSettings(h SettingsAPI) *Settings { defer r.Body.Close() params := request.NewSettingsGet() if err := params.Fill(r); err != nil { - logger.LogParamError("Settings.Get", r, err, params.Auditable()) + logger.LogParamError("Settings.Get", r, err) resputil.JSON(w, err) return } + value, err := h.Get(r.Context(), params) if err != nil { logger.LogControllerError("Settings.Get", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Settings.Get", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -103,14 +109,16 @@ func NewSettings(h SettingsAPI) *Settings { defer r.Body.Close() params := request.NewSettingsSet() if err := params.Fill(r); err != nil { - logger.LogParamError("Settings.Set", r, err, params.Auditable()) + logger.LogParamError("Settings.Set", r, err) resputil.JSON(w, err) return } + value, err := h.Set(r.Context(), params) if err != nil { logger.LogControllerError("Settings.Set", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("Settings.Set", r, params.Auditable()) if !serveHTTP(value, w, r) { diff --git a/system/rest/handlers/user.go b/system/rest/handlers/user.go index da4f2f452..ff8b189a5 100644 --- a/system/rest/handlers/user.go +++ b/system/rest/handlers/user.go @@ -55,14 +55,16 @@ func NewUser(h UserAPI) *User { defer r.Body.Close() params := request.NewUserList() if err := params.Fill(r); err != nil { - logger.LogParamError("User.List", r, err, params.Auditable()) + logger.LogParamError("User.List", r, err) resputil.JSON(w, err) return } + value, err := h.List(r.Context(), params) if err != nil { logger.LogControllerError("User.List", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("User.List", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -73,14 +75,16 @@ func NewUser(h UserAPI) *User { defer r.Body.Close() params := request.NewUserCreate() if err := params.Fill(r); err != nil { - logger.LogParamError("User.Create", r, err, params.Auditable()) + logger.LogParamError("User.Create", r, err) resputil.JSON(w, err) return } + value, err := h.Create(r.Context(), params) if err != nil { logger.LogControllerError("User.Create", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("User.Create", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -91,14 +95,16 @@ func NewUser(h UserAPI) *User { defer r.Body.Close() params := request.NewUserUpdate() if err := params.Fill(r); err != nil { - logger.LogParamError("User.Update", r, err, params.Auditable()) + logger.LogParamError("User.Update", r, err) resputil.JSON(w, err) return } + value, err := h.Update(r.Context(), params) if err != nil { logger.LogControllerError("User.Update", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("User.Update", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -109,14 +115,16 @@ func NewUser(h UserAPI) *User { defer r.Body.Close() params := request.NewUserRead() if err := params.Fill(r); err != nil { - logger.LogParamError("User.Read", r, err, params.Auditable()) + logger.LogParamError("User.Read", r, err) resputil.JSON(w, err) return } + value, err := h.Read(r.Context(), params) if err != nil { logger.LogControllerError("User.Read", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("User.Read", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -127,14 +135,16 @@ func NewUser(h UserAPI) *User { defer r.Body.Close() params := request.NewUserDelete() if err := params.Fill(r); err != nil { - logger.LogParamError("User.Delete", r, err, params.Auditable()) + logger.LogParamError("User.Delete", r, err) resputil.JSON(w, err) return } + value, err := h.Delete(r.Context(), params) if err != nil { logger.LogControllerError("User.Delete", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("User.Delete", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -145,14 +155,16 @@ func NewUser(h UserAPI) *User { defer r.Body.Close() params := request.NewUserSuspend() if err := params.Fill(r); err != nil { - logger.LogParamError("User.Suspend", r, err, params.Auditable()) + logger.LogParamError("User.Suspend", r, err) resputil.JSON(w, err) return } + value, err := h.Suspend(r.Context(), params) if err != nil { logger.LogControllerError("User.Suspend", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("User.Suspend", r, params.Auditable()) if !serveHTTP(value, w, r) { @@ -163,14 +175,16 @@ func NewUser(h UserAPI) *User { defer r.Body.Close() params := request.NewUserUnsuspend() if err := params.Fill(r); err != nil { - logger.LogParamError("User.Unsuspend", r, err, params.Auditable()) + logger.LogParamError("User.Unsuspend", r, err) resputil.JSON(w, err) return } + value, err := h.Unsuspend(r.Context(), params) if err != nil { logger.LogControllerError("User.Unsuspend", r, err, params.Auditable()) resputil.JSON(w, err) + return } logger.LogControllerCall("User.Unsuspend", r, params.Auditable()) if !serveHTTP(value, w, r) {