DeforaNetworks/corteza
3
0
Fork 0
Code Activity

upd(all): regenerate handlers

Browse Source
This commit is contained in:
Tit Petric
2019-04-26 22:04:31 +02:00
parent 2cca75cb1d
commit 98a3fc059e
26 changed files with 2000 additions and 375 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
crm/rest/handlers/attachment.go
View File

@@ -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
}
},
}
}

95
crm/rest/handlers/chart.go
View File

@@ -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
}
},
}
}

95
crm/rest/handlers/module.go
View File

@@ -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
}
},
}
}

19
crm/rest/handlers/notification.go
View File

@@ -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
}
},
}
}

152
crm/rest/handlers/page.go
View File

@@ -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
}
},
}
}

19
crm/rest/handlers/permissions.go
View File

@@ -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
}
},
}
}

133
crm/rest/handlers/record.go
View File

@@ -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
}
},
}
}

95
crm/rest/handlers/trigger.go
View File

@@ -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
}
},
}
}

19
messaging/rest/handlers/activity.go
View File

@@ -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
}
},
}
}

38
messaging/rest/handlers/attachment.go
View File

@@ -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
}
},
}
}

228
messaging/rest/handlers/channel.go
View File

@@ -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
}
},
}
}

19
messaging/rest/handlers/commands.go
View File

@@ -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
}
},
}
}

228
messaging/rest/handlers/message.go
View File

@@ -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
}
},
}
}

19
messaging/rest/handlers/permissions.go
View File

@@ -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
}
},
}
}

19
messaging/rest/handlers/search.go
View File

@@ -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
}
},
}
}

57
messaging/rest/handlers/status.go
View File

@@ -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
}
},
}
}

95
messaging/rest/handlers/webhooks.go
View File

@@ -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
}
},
}
}

38
messaging/rest/handlers/webhooks_public.go
View File

@@ -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
}
},
}
}

95
system/rest/handlers/application.go
View File

@@ -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
}
},
}
}

76
system/rest/handlers/auth.go
View File

@@ -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
}
},
}
}

133
system/rest/handlers/auth_internal.go
View File

@@ -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
}
},
}
}

114
system/rest/handlers/organisation.go
View File

@@ -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
}
},
}
}

95
system/rest/handlers/permissions.go
View File

@@ -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
}
},
}
}

209
system/rest/handlers/role.go
View File

@@ -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
}
},
}
}

76
system/rest/handlers/settings.go
View File

@@ -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
}
},
}
}

133
system/rest/handlers/user.go
View File

@@ -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
}
},
}
}