diff --git a/crm/rest/handlers/attachment.go b/crm/rest/handlers/attachment.go index 675f5919a..9a1225521 100644 --- a/crm/rest/handlers/attachment.go +++ b/crm/rest/handlers/attachment.go @@ -47,30 +47,82 @@ func NewAttachment(ah AttachmentAPI) *Attachment { List: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewAttachmentList() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.List(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.List(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Details: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewAttachmentDetails() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.Details(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.Details(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Original: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewAttachmentOriginal() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.Original(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.Original(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Preview: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewAttachmentPreview() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.Preview(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.Preview(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/crm/rest/handlers/chart.go b/crm/rest/handlers/chart.go index 3ed4ffc01..7dc5880e8 100644 --- a/crm/rest/handlers/chart.go +++ b/crm/rest/handlers/chart.go @@ -49,37 +49,102 @@ func NewChart(ch ChartAPI) *Chart { List: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewChartList() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ch.List(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ch.List(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Create: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewChartCreate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ch.Create(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ch.Create(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Read: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewChartRead() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ch.Read(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ch.Read(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Update: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewChartUpdate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ch.Update(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ch.Update(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Delete: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewChartDelete() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ch.Delete(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ch.Delete(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/crm/rest/handlers/module.go b/crm/rest/handlers/module.go index 13163c590..ad8f4bad8 100644 --- a/crm/rest/handlers/module.go +++ b/crm/rest/handlers/module.go @@ -49,37 +49,102 @@ func NewModule(mh ModuleAPI) *Module { List: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewModuleList() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return mh.List(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := mh.List(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Create: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewModuleCreate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return mh.Create(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := mh.Create(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Read: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewModuleRead() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return mh.Read(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := mh.Read(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Update: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewModuleUpdate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return mh.Update(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := mh.Update(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Delete: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewModuleDelete() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return mh.Delete(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := mh.Delete(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/crm/rest/handlers/notification.go b/crm/rest/handlers/notification.go index b59a33e0d..802382de4 100644 --- a/crm/rest/handlers/notification.go +++ b/crm/rest/handlers/notification.go @@ -41,9 +41,22 @@ func NewNotification(nh NotificationAPI) *Notification { EmailSend: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewNotificationEmailSend() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return nh.EmailSend(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := nh.EmailSend(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/crm/rest/handlers/page.go b/crm/rest/handlers/page.go index 27a6c3729..2e5b2b3ef 100644 --- a/crm/rest/handlers/page.go +++ b/crm/rest/handlers/page.go @@ -55,58 +55,162 @@ func NewPage(ph PageAPI) *Page { List: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewPageList() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ph.List(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ph.List(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Create: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewPageCreate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ph.Create(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ph.Create(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Read: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewPageRead() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ph.Read(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ph.Read(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Tree: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewPageTree() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ph.Tree(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ph.Tree(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Update: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewPageUpdate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ph.Update(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ph.Update(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Reorder: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewPageReorder() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ph.Reorder(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ph.Reorder(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Delete: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewPageDelete() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ph.Delete(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ph.Delete(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Upload: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewPageUpload() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ph.Upload(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ph.Upload(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/crm/rest/handlers/permissions.go b/crm/rest/handlers/permissions.go index e5fef112d..09fa705f4 100644 --- a/crm/rest/handlers/permissions.go +++ b/crm/rest/handlers/permissions.go @@ -41,9 +41,22 @@ func NewPermissions(ph PermissionsAPI) *Permissions { Effective: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewPermissionsEffective() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ph.Effective(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ph.Effective(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/crm/rest/handlers/record.go b/crm/rest/handlers/record.go index 7033ec014..e80b7b067 100644 --- a/crm/rest/handlers/record.go +++ b/crm/rest/handlers/record.go @@ -53,51 +53,142 @@ func NewRecord(rh RecordAPI) *Record { Report: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewRecordReport() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return rh.Report(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := rh.Report(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, List: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewRecordList() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return rh.List(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := rh.List(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Create: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewRecordCreate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return rh.Create(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := rh.Create(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Read: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewRecordRead() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return rh.Read(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := rh.Read(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Update: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewRecordUpdate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return rh.Update(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := rh.Update(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Delete: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewRecordDelete() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return rh.Delete(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := rh.Delete(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Upload: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewRecordUpload() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return rh.Upload(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := rh.Upload(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/crm/rest/handlers/trigger.go b/crm/rest/handlers/trigger.go index 9eda061dd..d5e6108ae 100644 --- a/crm/rest/handlers/trigger.go +++ b/crm/rest/handlers/trigger.go @@ -49,37 +49,102 @@ func NewTrigger(th TriggerAPI) *Trigger { List: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewTriggerList() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return th.List(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := th.List(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Create: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewTriggerCreate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return th.Create(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := th.Create(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Read: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewTriggerRead() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return th.Read(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := th.Read(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Update: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewTriggerUpdate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return th.Update(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := th.Update(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Delete: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewTriggerDelete() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return th.Delete(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := th.Delete(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/messaging/rest/handlers/activity.go b/messaging/rest/handlers/activity.go index a6344cf97..736436008 100644 --- a/messaging/rest/handlers/activity.go +++ b/messaging/rest/handlers/activity.go @@ -41,9 +41,22 @@ func NewActivity(ah ActivityAPI) *Activity { Send: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewActivitySend() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.Send(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.Send(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/messaging/rest/handlers/attachment.go b/messaging/rest/handlers/attachment.go index 8ddbcf0d1..dba1e8833 100644 --- a/messaging/rest/handlers/attachment.go +++ b/messaging/rest/handlers/attachment.go @@ -43,16 +43,42 @@ func NewAttachment(ah AttachmentAPI) *Attachment { Original: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewAttachmentOriginal() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.Original(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.Original(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Preview: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewAttachmentPreview() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.Preview(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.Preview(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/messaging/rest/handlers/channel.go b/messaging/rest/handlers/channel.go index b64f7b55e..278216bee 100644 --- a/messaging/rest/handlers/channel.go +++ b/messaging/rest/handlers/channel.go @@ -63,86 +63,242 @@ func NewChannel(ch ChannelAPI) *Channel { List: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewChannelList() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ch.List(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ch.List(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Create: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewChannelCreate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ch.Create(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ch.Create(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Update: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewChannelUpdate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ch.Update(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ch.Update(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, State: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewChannelState() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ch.State(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ch.State(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, SetFlag: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewChannelSetFlag() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ch.SetFlag(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ch.SetFlag(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, RemoveFlag: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewChannelRemoveFlag() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ch.RemoveFlag(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ch.RemoveFlag(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Read: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewChannelRead() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ch.Read(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ch.Read(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Members: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewChannelMembers() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ch.Members(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ch.Members(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Join: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewChannelJoin() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ch.Join(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ch.Join(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Part: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewChannelPart() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ch.Part(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ch.Part(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Invite: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewChannelInvite() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ch.Invite(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ch.Invite(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Attach: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewChannelAttach() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ch.Attach(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ch.Attach(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/messaging/rest/handlers/commands.go b/messaging/rest/handlers/commands.go index 25b340c34..70bd1fc10 100644 --- a/messaging/rest/handlers/commands.go +++ b/messaging/rest/handlers/commands.go @@ -41,9 +41,22 @@ func NewCommands(ch CommandsAPI) *Commands { List: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewCommandsList() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ch.List(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ch.List(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/messaging/rest/handlers/message.go b/messaging/rest/handlers/message.go index 5d8977571..f551a1b26 100644 --- a/messaging/rest/handlers/message.go +++ b/messaging/rest/handlers/message.go @@ -63,86 +63,242 @@ func NewMessage(mh MessageAPI) *Message { Create: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewMessageCreate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return mh.Create(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := mh.Create(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, ExecuteCommand: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewMessageExecuteCommand() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return mh.ExecuteCommand(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := mh.ExecuteCommand(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, MarkAsRead: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewMessageMarkAsRead() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return mh.MarkAsRead(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := mh.MarkAsRead(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Edit: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewMessageEdit() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return mh.Edit(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := mh.Edit(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Delete: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewMessageDelete() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return mh.Delete(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := mh.Delete(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, ReplyCreate: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewMessageReplyCreate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return mh.ReplyCreate(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := mh.ReplyCreate(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, PinCreate: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewMessagePinCreate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return mh.PinCreate(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := mh.PinCreate(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, PinRemove: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewMessagePinRemove() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return mh.PinRemove(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := mh.PinRemove(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, BookmarkCreate: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewMessageBookmarkCreate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return mh.BookmarkCreate(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := mh.BookmarkCreate(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, BookmarkRemove: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewMessageBookmarkRemove() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return mh.BookmarkRemove(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := mh.BookmarkRemove(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, ReactionCreate: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewMessageReactionCreate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return mh.ReactionCreate(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := mh.ReactionCreate(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, ReactionRemove: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewMessageReactionRemove() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return mh.ReactionRemove(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := mh.ReactionRemove(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/messaging/rest/handlers/permissions.go b/messaging/rest/handlers/permissions.go index e6f4e7948..74c6b74a5 100644 --- a/messaging/rest/handlers/permissions.go +++ b/messaging/rest/handlers/permissions.go @@ -41,9 +41,22 @@ func NewPermissions(ph PermissionsAPI) *Permissions { Effective: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewPermissionsEffective() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ph.Effective(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ph.Effective(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/messaging/rest/handlers/search.go b/messaging/rest/handlers/search.go index db2f8c30b..a9c67fabb 100644 --- a/messaging/rest/handlers/search.go +++ b/messaging/rest/handlers/search.go @@ -41,9 +41,22 @@ func NewSearch(sh SearchAPI) *Search { Messages: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewSearchMessages() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return sh.Messages(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := sh.Messages(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/messaging/rest/handlers/status.go b/messaging/rest/handlers/status.go index a9c2cb1ba..f932a2d86 100644 --- a/messaging/rest/handlers/status.go +++ b/messaging/rest/handlers/status.go @@ -45,23 +45,62 @@ func NewStatus(sh StatusAPI) *Status { List: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewStatusList() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return sh.List(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := sh.List(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Set: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewStatusSet() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return sh.Set(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := sh.Set(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Delete: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewStatusDelete() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return sh.Delete(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := sh.Delete(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/messaging/rest/handlers/webhooks.go b/messaging/rest/handlers/webhooks.go index d0d4e3281..73d14974f 100644 --- a/messaging/rest/handlers/webhooks.go +++ b/messaging/rest/handlers/webhooks.go @@ -49,37 +49,102 @@ func NewWebhooks(wh WebhooksAPI) *Webhooks { List: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewWebhooksList() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return wh.List(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := wh.List(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Create: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewWebhooksCreate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return wh.Create(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := wh.Create(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Update: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewWebhooksUpdate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return wh.Update(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := wh.Update(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Get: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewWebhooksGet() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return wh.Get(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := wh.Get(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Delete: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewWebhooksDelete() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return wh.Delete(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := wh.Delete(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/messaging/rest/handlers/webhooks_public.go b/messaging/rest/handlers/webhooks_public.go index acc83515d..fb87c351f 100644 --- a/messaging/rest/handlers/webhooks_public.go +++ b/messaging/rest/handlers/webhooks_public.go @@ -43,16 +43,42 @@ func NewWebhooksPublic(wh WebhooksPublicAPI) *WebhooksPublic { Delete: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewWebhooksPublicDelete() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return wh.Delete(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := wh.Delete(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Create: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewWebhooksPublicCreate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return wh.Create(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := wh.Create(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/system/rest/handlers/application.go b/system/rest/handlers/application.go index 4b640321e..84a5404fe 100644 --- a/system/rest/handlers/application.go +++ b/system/rest/handlers/application.go @@ -49,37 +49,102 @@ func NewApplication(ah ApplicationAPI) *Application { List: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewApplicationList() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.List(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.List(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Create: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewApplicationCreate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.Create(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.Create(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Update: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewApplicationUpdate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.Update(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.Update(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Read: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewApplicationRead() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.Read(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.Read(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Delete: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewApplicationDelete() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.Delete(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.Delete(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/system/rest/handlers/auth.go b/system/rest/handlers/auth.go index 3663abff7..20e375aa7 100644 --- a/system/rest/handlers/auth.go +++ b/system/rest/handlers/auth.go @@ -47,30 +47,82 @@ func NewAuth(ah AuthAPI) *Auth { Settings: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewAuthSettings() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.Settings(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.Settings(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Check: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewAuthCheck() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.Check(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.Check(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, ExchangeAuthToken: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewAuthExchangeAuthToken() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.ExchangeAuthToken(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.ExchangeAuthToken(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Logout: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewAuthLogout() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.Logout(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.Logout(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/system/rest/handlers/auth_internal.go b/system/rest/handlers/auth_internal.go index b27e08572..bc86ed6bc 100644 --- a/system/rest/handlers/auth_internal.go +++ b/system/rest/handlers/auth_internal.go @@ -53,51 +53,142 @@ func NewAuthInternal(ah AuthInternalAPI) *AuthInternal { Login: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewAuthInternalLogin() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.Login(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.Login(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Signup: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewAuthInternalSignup() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.Signup(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.Signup(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, RequestPasswordReset: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewAuthInternalRequestPasswordReset() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.RequestPasswordReset(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.RequestPasswordReset(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, ExchangePasswordResetToken: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewAuthInternalExchangePasswordResetToken() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.ExchangePasswordResetToken(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.ExchangePasswordResetToken(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, ResetPassword: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewAuthInternalResetPassword() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.ResetPassword(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.ResetPassword(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, ConfirmEmail: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewAuthInternalConfirmEmail() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.ConfirmEmail(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.ConfirmEmail(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, ChangePassword: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewAuthInternalChangePassword() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ah.ChangePassword(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ah.ChangePassword(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/system/rest/handlers/organisation.go b/system/rest/handlers/organisation.go index 84a86acd7..3f0d1dfb0 100644 --- a/system/rest/handlers/organisation.go +++ b/system/rest/handlers/organisation.go @@ -51,44 +51,122 @@ func NewOrganisation(oh OrganisationAPI) *Organisation { List: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewOrganisationList() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return oh.List(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := oh.List(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Create: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewOrganisationCreate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return oh.Create(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := oh.Create(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Update: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewOrganisationUpdate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return oh.Update(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := oh.Update(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Delete: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewOrganisationDelete() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return oh.Delete(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := oh.Delete(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Read: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewOrganisationRead() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return oh.Read(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := oh.Read(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Archive: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewOrganisationArchive() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return oh.Archive(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := oh.Archive(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/system/rest/handlers/permissions.go b/system/rest/handlers/permissions.go index c97a41b21..e6c2866c1 100644 --- a/system/rest/handlers/permissions.go +++ b/system/rest/handlers/permissions.go @@ -49,37 +49,102 @@ func NewPermissions(ph PermissionsAPI) *Permissions { List: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewPermissionsList() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ph.List(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ph.List(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Effective: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewPermissionsEffective() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ph.Effective(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ph.Effective(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Read: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewPermissionsRead() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ph.Read(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ph.Read(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Delete: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewPermissionsDelete() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ph.Delete(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ph.Delete(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Update: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewPermissionsUpdate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return ph.Update(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := ph.Update(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/system/rest/handlers/role.go b/system/rest/handlers/role.go index a3573d656..4c9220b83 100644 --- a/system/rest/handlers/role.go +++ b/system/rest/handlers/role.go @@ -61,79 +61,222 @@ func NewRole(rh RoleAPI) *Role { List: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewRoleList() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return rh.List(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := rh.List(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Create: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewRoleCreate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return rh.Create(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := rh.Create(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Update: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewRoleUpdate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return rh.Update(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := rh.Update(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Read: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewRoleRead() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return rh.Read(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := rh.Read(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Delete: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewRoleDelete() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return rh.Delete(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := rh.Delete(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Archive: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewRoleArchive() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return rh.Archive(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := rh.Archive(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Move: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewRoleMove() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return rh.Move(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := rh.Move(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Merge: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewRoleMerge() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return rh.Merge(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := rh.Merge(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, MemberList: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewRoleMemberList() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return rh.MemberList(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := rh.MemberList(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, MemberAdd: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewRoleMemberAdd() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return rh.MemberAdd(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := rh.MemberAdd(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, MemberRemove: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewRoleMemberRemove() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return rh.MemberRemove(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := rh.MemberRemove(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/system/rest/handlers/settings.go b/system/rest/handlers/settings.go index 7cd7df87c..9daf07c80 100644 --- a/system/rest/handlers/settings.go +++ b/system/rest/handlers/settings.go @@ -47,30 +47,82 @@ func NewSettings(sh SettingsAPI) *Settings { List: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewSettingsList() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return sh.List(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := sh.List(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Update: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewSettingsUpdate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return sh.Update(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := sh.Update(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Get: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewSettingsGet() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return sh.Get(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := sh.Get(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Set: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewSettingsSet() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return sh.Set(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := sh.Set(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } } diff --git a/system/rest/handlers/user.go b/system/rest/handlers/user.go index 6e3877d93..e3800bfd4 100644 --- a/system/rest/handlers/user.go +++ b/system/rest/handlers/user.go @@ -53,51 +53,142 @@ func NewUser(uh UserAPI) *User { List: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewUserList() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return uh.List(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := uh.List(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Create: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewUserCreate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return uh.Create(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := uh.Create(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Update: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewUserUpdate() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return uh.Update(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := uh.Update(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Read: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewUserRead() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return uh.Read(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := uh.Read(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Delete: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewUserDelete() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return uh.Delete(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := uh.Delete(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Suspend: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewUserSuspend() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return uh.Suspend(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := uh.Suspend(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, Unsuspend: func(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() params := request.NewUserUnsuspend() - resputil.JSON(w, params.Fill(r), func() (interface{}, error) { - return uh.Unsuspend(r.Context(), params) - }) + if err := params.Fill(r); err != nil { + resputil.JSON(w, err) + return + } + if value, err := uh.Unsuspend(r.Context(), params); err != nil { + resputil.JSON(w, err) + return + } else { + switch fn := value.(type) { + case func(http.ResponseWriter, *http.Request): + fn(w, r) + return + } + resputil.JSON(w, value) + return + } }, } }