156 lines
3.3 KiB
Markdown
156 lines
3.3 KiB
Markdown
# Server Events
|
|
|
|
## How To
|
|
|
|
In this Example i use the generic-di package to Inject a Service into a Event.
|
|
First you have to create some Event Handler and/or Effects that was fired when a Event happens.
|
|
Then you give the Effects and the EventHandlers to a Registration to serve it.
|
|
|
|
services/external_service.go
|
|
|
|
```go
|
|
package services
|
|
|
|
import (
|
|
di "git.apihub24.de/admin/generic-di"
|
|
)
|
|
|
|
func init() {
|
|
di.Injectable(newExternalService)
|
|
}
|
|
|
|
// this Service is only a Example to show how to use a real world authentication service!
|
|
type IExternalService interface {
|
|
CheckLogin(string, string) bool
|
|
}
|
|
|
|
type externalService struct {}
|
|
|
|
func newExternalService() IExternalService {
|
|
return &externalService{}
|
|
}
|
|
|
|
func (service *externalService) CheckLogin(name, password string) bool {
|
|
return len(name) > 0 && len(password) > 0
|
|
}
|
|
```
|
|
|
|
events/login_event.go
|
|
|
|
```go
|
|
package events
|
|
|
|
import (
|
|
|
|
di "git.apihub24.de/admin/generic-di"
|
|
)
|
|
|
|
// a Struct of the Login success EventData
|
|
type UserLogin struct {
|
|
UserName string `json:"userName"`
|
|
}
|
|
|
|
// a Struct of the Login EventData
|
|
type LoginData struct {
|
|
Login string `json:"login"`
|
|
Password string `json:"password"`
|
|
}
|
|
|
|
type LoginEvent struct {
|
|
someExternalService services.IExternalService
|
|
}
|
|
|
|
func NewLoginEvent() *LoginEvent {
|
|
return &LoginEvent{
|
|
someExternalService: di.Inject[services.IExternalService]()
|
|
}
|
|
}
|
|
|
|
// implement a Method to get the EventName String
|
|
func (event *LoginEvent) GetEventName() string {
|
|
return "login"
|
|
}
|
|
|
|
// implement a Method to check if the Event can Execute
|
|
func (event *LoginEvent) CanExecute(ctx *serverevents.Context) bool {
|
|
return true
|
|
}
|
|
|
|
// implement a Method to send non Authorized Response
|
|
func (event *UserLoginEvent) SendNotAuthorizedResponse(ctx *serverevents.Context) {
|
|
}
|
|
|
|
// implement a Method to Handle a Event
|
|
func (event *UserLoginEvent) Handle(ctx *serverevents.Context) {
|
|
data, dataParseErr := serverevents.GetEventData[LoginData](ctx)
|
|
if dataParseErr != nil {
|
|
ctx.Send(http.StatusInternalServerError, "text/plain", []byte(dataParseErr.Error()))
|
|
return
|
|
}
|
|
|
|
if !event.someExternalService.CheckLogin(data.Login, data.Password) {
|
|
// send a new Event to the Client
|
|
ctx.Emit(serverevents.Event{
|
|
Type: "login fail",
|
|
Data: "login fails!",
|
|
})
|
|
return
|
|
}
|
|
|
|
ctx.Emit(serverevents.Event{
|
|
Type: "login success",
|
|
Data: UserLogin{
|
|
UserName: "some Username",
|
|
},
|
|
})
|
|
}
|
|
```
|
|
|
|
effects/login_success_effect.go
|
|
|
|
```go
|
|
package effects
|
|
|
|
type LoginSuccessEffect struct {}
|
|
|
|
func NewLoginSuccessEffect() *LoginSuccessEffect {
|
|
return &LoginSuccessEffect{}
|
|
}
|
|
|
|
// implement a Method that gives the Name of the Event to listen
|
|
func (effect *LoginSuccessEffect) OnEvent() string {
|
|
return "login success"
|
|
}
|
|
|
|
// implement a Method to Handle the Effect triggered
|
|
func (effect *LoginSuccessEffect) Execute(ctx *serverevents.Context) {
|
|
// do something on login success here...
|
|
}
|
|
```
|
|
|
|
main.go
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
serverevents "git.apihub24.de/admin/server_events"
|
|
)
|
|
|
|
func main() {
|
|
port := ":8080"
|
|
|
|
serverevents.RegisterEvents([]serverevents.EventHandler{
|
|
events.NewLoginEvent(),
|
|
}, []serverevents.Effect{
|
|
effects.NewLoginSuccessEffect(),
|
|
}, nil)
|
|
|
|
log.Default().Printf("Start Server at Port %s", port)
|
|
err := http.ListenAndServe(port, nil)
|
|
if err != nil {
|
|
log.Fatalf("Error on start Server: %v", err)
|
|
}
|
|
}
|
|
```
|