un po 'vecchio, ma potrebbe venire in mano per chiunque altro cercando gruppi:
Nella classe User:
Set<RoleGroup> getAuthorities() {
(UserRoleGroup.findAllByUser(this) as List<UserRoleGroup>)*.roleGroup as Set<RoleGroup>
}
Set<Role> getRoles() {
(UserRoleGroup?.findAllByUser(this)?.roleGroup?.authorities.collect{it}?.flatten() ?: oldRoles) as Set<Role>
}
List<String> getRoleNames() {
(UserRoleGroup?.findAllByUser(this)?.roleGroup?.collect{it.authorities.authority}?.flatten()?: oldRoles.authority) as List<String>
}
//Above will look up from userRoleGroup roleGroup.authorities = UserRole below
Set<Role> getOldRoles() {
(UserRole.findAllByUser(this) as List<Role>)*.role as Set<Role>
}
ero stato utilizzando i ruoli, anche se i gruppi sono stati abilitati ed autenticazione contro i vecchi oldRoles metodo:
import grails.plugin.springsecurity.userdetails.GormUserDetailsService
import grails.transaction.Transactional
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken
import org.springframework.security.core.Authentication
import org.springframework.security.core.GrantedAuthority
import org.springframework.security.core.authority.SimpleGrantedAuthority
import org.springframework.security.core.context.SecurityContextHolder
import org.springframework.security.core.userdetails.UserDetails
import org.springframework.security.core.userdetails.UsernameNotFoundException
class MySpringSecurityAuthenticator extends GormUserDetailsService{
UserDetails loadUserByUsername(String username, boolean loadRoles)
throws UsernameNotFoundException {
return loadUserByUsername(username)
}
@Transactional
UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
//enable login with either username or password
User user = User.find {
username == username || attributes.emailAddress == username || userCode == username
}
//if (!user) throw new UsernameNotFoundException('User not found', username)
if (!user) throw new UsernameNotFoundException('User not found')
return loadUserByUsername(user)
}
@Transactional
UserDetails loadUserByUsername(User user) throws UsernameNotFoundException {
if (!user) throw new UsernameNotFoundException('User not found')
//UserDetails.withNewSession {
//getAuthorities(user.oldRoles)
UserDetails userDetails = new org.springframework.security.core.userdetails.User(user.username, user.password,
user.enabled, !user.accountExpired, !user.passwordExpired, !user.accountLocked,getAuthoritiesFromGroup(user.authorities))
Authentication authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities())
SecurityContextHolder.getContext().setAuthentication(authentication)
return userDetails
//}
}
public static List<GrantedAuthority> getAuthoritiesFromGroup(Set<RoleGroup> roles) {
List<GrantedAuthority> authorities = new ArrayList<GrantedAuthority>()
roles?.each { role ->
println "-- role = ${role} vs ${role.getClass()}"
authorities.add(new SimpleGrantedAuthority(role.name))
}
return authorities
}
public static List<GrantedAuthority> getAuthorities(Set<Role> roles) {
List<GrantedAuthority> authorities = new ArrayList<GrantedAuthority>()
roles?.each { role ->
println "-- role = ${role} vs ${role.getClass()}"
authorities.add(new SimpleGrantedAuthority(role.authority))
}
return authorities
}
}
e nella mia primavera/resources.groovy:
userDetailsService(MySpringSecurityAuthenticator){
grailsApplication = ref('grailsApplication')
}
Quanto sopra aveva fatto finora è stato tornare a ruoli utente e l'aggiunta di loro per l'autenticazione tramite gestore .. getAuthorities (user.oldRoles)
ora ho cambiato il metodo di cui sopra per leggere i nomi dei gruppi tramite getAuthoritiesFromGroup (user.authorities)
Questo analizza semplicemente i nomi dei gruppi, che come un lato (effetto) di versione che sto usando devono includere anche la parola ROLE_GROUPNAME
Così ora se creare
@Transactional
def grantPermission(User user, String role='ROLE_ADMIN', String group='ROLE_SUPERGROUP') {
def adminRole = Role.findByAuthority(role)
if (!adminRole) {
adminRole = new Role(authority: role).save(flush: true)
}
UserRole.create user, adminRole, true
def adminRoleGroup = RoleGroup.findByName(group)
if (!adminRoleGroup) {
adminRoleGroup = new RoleGroup(name: group).save(flush: true)
}
def adminRoleGroupRole = RoleGroupRole.findByRole(adminRole)
if (!adminRoleGroupRole) {
adminRoleGroupRole = new RoleGroupRole(role: adminRole, roleGroup: adminRoleGroup).save(flush: true)
}
def alreadyDone = UserRoleGroup.findByUserAndRoleGroup(user,adminRoleGroup)
if (!alreadyDone) {
new UserRoleGroup(user: user, roleGroup: adminRoleGroup).save(flush: true)
}
}
mi aspetto di autenticazione con i nomi dei gruppi e non i ruoli utente in modo insomma ho dovuto cambiare il mio controller per
@Secured("hasAnyRole('ROLE_SUPERGROUP')")
speranza ha senso dovrebbe essere semplice da seguire vuole solo tempo per ottenere la tua testa intorno a tutto ..
A questo punto sto ancora giocando e non vorrei usare come risposta concreta dato che sono un po 'come hackerarlo per aggiungere i miei gruppi come le mie autorità e se volessi potrebbe aggiungere un altro gancio per andare oltre attraverso ciascuno di quei gruppi e ciascuno dei ruoli effettivi in esso pure - non so cosa produrrà - al momento
Voglio cambiarlo in requestMaps e spostarlo in db quindi molto da cambiare e deciderò se dovrei tornare indietro o usare i gruppi so che in questo modo posso configurare meno nomi sui controller e fare affidamento sui nomi dei gruppi ..
in entrambi i casi la sua sotto il cofano di tutto e ti dà una chiara idea di qualche anno su, ma può tornare utile per gli altri
aggiornamento così ho deciso di andare con: ,getAuthorities(user.roles)
Dove Set<Role> getRoles() { metodo all'interno del po 'sopra di codice
La ragione è abbastanza semplice:
results?.each {
it.user=User.get(it.id)
println "-- \n${it.id}:${it.user.roles} \n${it.id}:${it.user.oldRoles}"
7:[Role(authority:ROLE_ADMIN), Role(authority:ROLE_ADMINAHHA)]
7:[Role(authority:ROLE_ADMIN)]
Come potete vedere ho aggiunto un nuovo utente utilizzando i getOldRoles vedo solo 1 ruolo sulle getRoles ottengo 2 ruoli .. Ho aggiunto utente con 2 ruoli ..
Quindi questo ora analizzerà tutti i ruoli utente e li aggiungerà a List<GrantedAuthority> l'autenticazione sarà ancora tramite i nomi RUOLO effettivi generati come in precedenza.
Significa solo quando ho disattivare un gruppo da parte dell'utente dovrebbe interrompere il caricamento che il permesso per l'utente ..
questo è ciò che il modello dovrebbe fare