/
module.go
115 lines (105 loc) · 3.89 KB
/
module.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
package auth
import (
"flamingo.me/flamingo/core/auth/application"
fakeService "flamingo.me/flamingo/core/auth/application/fake"
"flamingo.me/flamingo/core/auth/application/store"
"flamingo.me/flamingo/core/auth/interfaces"
fakeController "flamingo.me/flamingo/core/auth/interfaces/fake"
"flamingo.me/flamingo/framework/config"
"flamingo.me/flamingo/framework/dingo"
"flamingo.me/flamingo/framework/router"
)
// Module for core.auth
type Module struct {
UseFake bool `inject:"config:auth.useFake"`
PreventSimultaneousSessions bool `inject:"config:auth.preventSimultaneousSessions"`
SessionBackend string `inject:"config:session.backend"`
}
// Configure core.auth module
func (m *Module) Configure(injector *dingo.Injector) {
injector.Bind(application.AuthManager{}).In(dingo.ChildSingleton)
injector.Bind((*interfaces.LogoutRedirectAware)(nil)).To(interfaces.DefaultLogoutRedirect{})
if !m.UseFake {
injector.Bind((*application.UserServiceInterface)(nil)).To(application.UserService{})
injector.Bind((*interfaces.LoginControllerInterface)(nil)).To(interfaces.LoginController{})
injector.Bind((*interfaces.CallbackControllerInterface)(nil)).To(interfaces.CallbackController{})
injector.Bind((*interfaces.LogoutControllerInterface)(nil)).To(interfaces.LogoutController{})
} else {
injector.Bind((*application.UserServiceInterface)(nil)).To(fakeService.UserService{})
injector.Bind((*interfaces.LoginControllerInterface)(nil)).To(fakeController.LoginController{})
injector.Bind((*interfaces.CallbackControllerInterface)(nil)).To(fakeController.CallbackController{})
injector.Bind((*interfaces.LogoutControllerInterface)(nil)).To(fakeController.LogoutController{})
}
if !m.PreventSimultaneousSessions {
injector.Bind((*store.Store)(nil)).To(store.Nil{})
} else {
switch m.SessionBackend {
case "redis":
injector.Bind((*store.Store)(nil)).To(store.Redis{}).AsEagerSingleton()
case "memory":
injector.Bind((*store.Store)(nil)).To(store.Memory{}).AsEagerSingleton()
case "file":
injector.Bind((*store.Store)(nil)).To(store.File{}).AsEagerSingleton()
default:
injector.Bind((*store.Store)(nil)).To(store.Nil{}).AsEagerSingleton()
}
}
injector.Bind((*application.Synchronizer)(nil)).To(application.SynchronizerImpl{})
router.Bind(injector, new(routes))
}
func (m *Module) DefaultConfig() config.Map {
return config.Map{
"auth": config.Map{
"useFake": false,
"preventSimultaneousSessions": false,
"fakeUserData": config.Map{},
"fakeLoginTemplate": "",
"scopes": config.Slice{"profile", "email"},
"claims": config.Map{
"idToken": config.Slice{},
"userInfo": config.Slice{},
},
"tokenExtras": config.Slice{},
"mapping": config.Map{
"idToken": config.Map{
"sub": "sub",
"email": "email",
"name": "name",
},
"userInfo": config.Map{
"sub": "sub",
"email": "email",
"name": "name",
},
},
},
}
}
type routes struct {
login interfaces.LoginControllerInterface
logout interfaces.LogoutControllerInterface
callback interfaces.CallbackControllerInterface
user *interfaces.UserController
}
// Inject routes dependencies
func (r *routes) Inject(
login interfaces.LoginControllerInterface,
logout interfaces.LogoutControllerInterface,
callback interfaces.CallbackControllerInterface,
user *interfaces.UserController,
) {
r.login = login
r.logout = logout
r.callback = callback
r.user = user
}
// Routes module
func (r *routes) Routes(registry *router.Registry) {
registry.Route("/auth/login", `auth.login(redirecturl?="")`)
registry.HandleGet("auth.login", r.login.Get)
registry.Route("/auth/callback", "auth.callback")
registry.HandleGet("auth.callback", r.callback.Get)
registry.Route("/auth/logout", "auth.logout")
registry.HandleGet("auth.logout", r.logout.Get)
registry.HandleData("user", r.user.Data)
}