source: branches/TaskRewrite/src/grails-app/controllers/PersonController.groovy @ 60

/**
 * User controller.
 */
@Secured(['ROLE_ADMIN'])
class PersonController {

        def authenticateService

        // the delete, save and update actions only accept POST requests
        static Map allowedMethods = [delete: 'POST', save: 'POST', update: 'POST']

        def index = {
                redirect action: list, params: params
        }

        def list = {
                if (!params.max) {
                        params.max = 10
                }
                [personList: Person.list(params)]
        }

        def show = {
                def person = Person.get(params.id)
                if (!person) {
                        flash.message = "Person not found with id $params.id"
                        redirect action: list
                        return
                }
                List roleNames = []
                for (role in person.authorities) {
                        roleNames << role.authority
                }
                roleNames.sort { n1, n2 ->
                        n1 <=> n2
                }
                [person: person, roleNames: roleNames]
        }

        /**
         * Person delete action. Before removing an existing person,
         * he should be removed from those authorities which he is involved.
         */
        def delete = {

                def person = Person.get(params.id)
                if (person) {
                        def authPrincipal = authenticateService.principal()
                        //avoid self-delete if the logged-in user is an admin
                        if (!(authPrincipal instanceof String) && authPrincipal.username == person.loginName) {
                                flash.message = "You can not delete yourself, please login as another admin and try again"
                        }
                        else {
                                //first, delete this person from Persons_Authorities table.
                                Authority.findAll().each { it.removeFromPersons(person) }
                                person.delete()
                                flash.message = "Person $params.id deleted."
                        }
                }
                else {
                        flash.message = "Person not found with id $params.id"
                }

                redirect action: list
        }

        def edit = {

                def person = Person.get(params.id)
                if (!person) {
                        flash.message = "Person not found with id $params.id"
                        redirect action: list
                        return
                }

                return buildPersonModel(person)
        }

        /**
         * Person update action.
         */
        def update = {

                def person = Person.get(params.id)
                if (!person) {
                        flash.message = "Person not found with id $params.id"
                        redirect action: edit, id: params.id
                        return
                }

                long version = params.version.toLong()
                if (person.version > version) {
                        person.errors.rejectValue 'version', "person.optimistic.locking.failure",
                                "Another user has updated this Person while you were editing."
                                render view: 'edit', model: buildPersonModel(person)
                        return
                }

                def oldPassword = person.password
                person.properties = params
                if (!params.password.equals(oldPassword)) {
                        person.password = authenticateService.encodePassword(params.password)
                }
                if (person.save()) {
                        Authority.findAll().each { it.removeFromPersons(person) }
                        addRoles(person)
                        redirect action: show, id: person.id
                }
                else {
                        render view: 'edit', model: buildPersonModel(person)
                }
        }

        def create = {
                [person: new Person(params), authorityList: Authority.list()]
        }

        /**
         * Person save action.
         */
        def save = {

                def person = new Person()
                person.properties = params
                person.password = authenticateService.encodePassword(params.password)
                if (person.save()) {
                        addRoles(person)
                        redirect action: show, id: person.id
                }
                else {
                        render view: 'create', model: [authorityList: Authority.list(), person: person]
                }
        }

        private void addRoles(person) {
                for (String key in params.keySet()) {
                        if (key.contains('ROLE') && 'on' == params.get(key)) {
                                Authority.findByAuthority(key).addToPersons(person)
                        }
                }
        }

        private Map buildPersonModel(person) {

                List roles = Authority.list()
                roles.sort { r1, r2 ->
                        r1.authority <=> r2.authority
                }
                Set userRoleNames = []
                for (role in person.authorities) {
                        userRoleNames << role.authority
                }
                LinkedHashMap<Authority, Boolean> roleMap = [:]
                for (role in roles) {
                        roleMap[(role)] = userRoleNames.contains(role.authority)
                }

                return [person: person, roleMap: roleMap]
        }
}