DeforaNetworks/corteza
3
0
Fork 0
Code Activity

Fix handler/request codegens

Browse Source 
Missing return caused malformed response output:
{"error":{"message":"invalid username/password combination"}}{"response":false}

Remove param logging when params.Fill() returns an error
This commit is contained in:
Denis Arh
2019-05-28 10:51:56 +02:00
parent 22476933f4
commit 5c750fb7cf
29 changed files with 427 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files
codegen/templates/http_handlers_inline.tpl
+3 -1
View File
@@ -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) {
compose/rest/handlers/attachment.go
+15 -5
View File
@@ -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) {
compose/rest/handlers/chart.go
+15 -5
View File
@@ -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) {
compose/rest/handlers/module.go
+15 -5
View File
@@ -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) {
compose/rest/handlers/namespace.go
+15 -5
View File
@@ -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) {
compose/rest/handlers/notification.go
+3 -1
View File
@@ -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) {
compose/rest/handlers/page.go
+24 -8
View File
@@ -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) {
compose/rest/handlers/permissions.go
+15 -5
View File
@@ -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) {
compose/rest/handlers/record.go
+21 -7
View File
@@ -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) {
compose/rest/handlers/trigger.go
+15 -5
View File
@@ -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) {
messaging/rest/handlers/activity.go
+3 -1
View File
@@ -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) {
messaging/rest/handlers/attachment.go
+6 -2
View File
@@ -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) {
messaging/rest/handlers/channel.go
+36 -12
View File
@@ -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) {
messaging/rest/handlers/commands.go
+3 -1
View File
@@ -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) {
messaging/rest/handlers/message.go
+36 -12
View File
@@ -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) {
messaging/rest/handlers/permissions.go
+15 -5
View File
@@ -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) {
messaging/rest/handlers/search.go
+6 -2
View File
@@ -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) {
messaging/rest/handlers/status.go
+9 -3
View File
@@ -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) {
messaging/rest/handlers/webhooks.go
+15 -5
View File
@@ -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) {
messaging/rest/handlers/webhooks_public.go
+6 -2
View File
@@ -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) {
pkg/logger/handlers.go
+4 -6
View File
@@ -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),
system/rest/handlers/application.go
+15 -5
View File
@@ -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) {
system/rest/handlers/auth.go
+12 -4
View File
@@ -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) {
system/rest/handlers/auth_internal.go
+21 -7
View File
@@ -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) {
system/rest/handlers/organisation.go
+18 -6
View File
@@ -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) {
system/rest/handlers/permissions.go
+15 -5
View File
@@ -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) {
system/rest/handlers/role.go
+33 -11
View File
@@ -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) {
system/rest/handlers/settings.go
+12 -4
View File
@@ -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) {
system/rest/handlers/user.go
+21 -7
View File
@@ -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) {