com.linkare.commons.jpa.security.User Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jpa.security Show documentation
Project containing the base domain model for security concerns in JPA projects.
The newest version!
package com.linkare.commons.jpa.security;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
import javax.persistence.JoinColumn;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;

import org.hibernate.envers.Audited;

import com.linkare.commons.utils.EqualityUtils;

/**
 * 
 * @author Paulo Zenida - Linkare TI
 * 
 */
@Entity
@NamedQueries({ @NamedQuery(name = User.FIND_ALL_QUERYNAME, query = "Select u from User u"),
	@NamedQuery(name = User.COUNT_ALL_QUERYNAME, query = "Select count(u) from User u"),
	@NamedQuery(name = User.FIND_BY_USERNAME_QUERYNAME, query = "Select u from User u where u.username = :" + User.QUERY_PARAM_USERNAME) })
@DiscriminatorValue("User")
@Audited
public class User extends Principal {

    private static final long serialVersionUID = -4468638508611970845L;

    public static final String ERROR_USER_CANNOT_HAVE_CHILD_ROLES = "error.user.cannot.have.child.roles";

    public static final String ERROR_USER_CANNOT_HAVE_CHILD_GROUPS = "error.user.cannot.have.child.groups";

    public static final String ERROR_USER_CANNOT_HAVE_CHILD_USERS = "error.user.cannot.have.child.users";

    public static final String ERROR_USER_CANNOT_REMOVE_CHILD_PRINCIPAL = "error.user.cannot.remove.child.principal";

    public static final String ERROR_USER_CANNOT_ADD_CHILD_PRINCIPAL = "error.user.cannot.add.child.principal";

    public static final String ERROR_USER_CANNOT_HAVE_PRINCIPAL_MEMBERS = "error.user.cannot.have.principal.members";

    public static final String ERROR_USER_CANNOT_HAVE_DIRECT_PARENT_USERS = "error.user.cannot.have.direct.parent.users";

    public static final String ERROR_USER_CANNOT_HAVE_DIRECT_CHILD_USERS = "error.user.cannot.have.direct.child.users";

    public static final String ERROR_USER_CANNOT_HAVE_DIRECT_CHILD_ROLES = "error.user.cannot.have.direct.child.roles";

    public static final String ERROR_USER_CANNOT_HAVE_DIRECT_CHILD_GROUPS = "error.user.cannot.have.direct.child.groups";

    public static final String ERROR_USER_CANNOT_HAVE_ANY_CHILD = "error.user.cannot.have.any.child";

    public static final String ERROR_USER_CANNOT_HAVE_DIRECT_CHILDS = "error.user.cannot.have.direct.childs";

    public static final String QUERY_PARAM_USERNAME = "username";

    public static final String FIND_ALL_QUERYNAME = "User.findAll";

    public static final String COUNT_ALL_QUERYNAME = "User.countAll";

    public static final String FIND_BY_USERNAME_QUERYNAME = "User.findByUsername";

    @Basic(optional = false)
    @Column(insertable = true, updatable = false, unique = false, name = "username")
    private String username;

    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
    private List identifications = new ArrayList();

    @OneToOne(optional = true, cascade = CascadeType.ALL)
    @JoinColumn(name = "key_subject", insertable = true, updatable = true, nullable = true)
    private Subject subject;

    public User() {
	super();
    }

    public User(final String username) {
	this(null, username);
    }

    /**
     * 
     * @param subject
     * @param username
     */
    public User(final Subject subject, final String username) {
	this();
	this.subject = subject;
	this.username = username;
    }

    /**
     * @return the username
     */
    public String getUsername() {
	return username;
    }

    /**
     * @param username
     *            the username to set
     */
    public void setUsername(String username) {
	this.username = username;
    }

    /**
     * @return the subject
     */
    public Subject getSubject() {
	return subject;
    }

    /**
     * @param subject
     *            the subject to set
     */
    public void setSubject(Subject subject) {
	this.subject = subject;
	this.subject.setUser(this);
    }

    /**
     * @return the identifications
     */
    public List getIdentifications() {
	return Collections.unmodifiableList(identifications);
    }

    /**
     * @param identifications
     *            the identifications to set
     */
    public void setIdentifications(List identifications) {
	this.identifications = identifications;
    }

    public void addIdentification(final Identification identification) {
	identification.setUser(this);
    }

    public void removeIdentification(final Identification identification) {
	identification.setUser(null);
    }

    void internalAddIdentification(final Identification identification) {
	identifications.add(identification);
    }

    void internalRemoveIdentification(final Identification identification) {
	identifications.remove(identification);
    }

    @Override
    public boolean isUser() {
	return true;
    }

    @Override
    public List getDirectChildren() {
	throw new UnsupportedOperationException(ERROR_USER_CANNOT_HAVE_DIRECT_CHILDS);
    }

    @Override
    public List getAllChildren() {
	throw new UnsupportedOperationException(ERROR_USER_CANNOT_HAVE_ANY_CHILD);
    }

    @Override
    public List getDirectChildGroups() {
	throw new UnsupportedOperationException(ERROR_USER_CANNOT_HAVE_DIRECT_CHILD_GROUPS);
    }

    @Override
    public List getDirectChildRoles() {
	throw new UnsupportedOperationException(ERROR_USER_CANNOT_HAVE_DIRECT_CHILD_ROLES);
    }

    @Override
    public List getDirectChildUsers() {
	throw new UnsupportedOperationException(ERROR_USER_CANNOT_HAVE_DIRECT_CHILD_USERS);
    }

    @Override
    public List getDirectParentUsers() {
	throw new UnsupportedOperationException(ERROR_USER_CANNOT_HAVE_DIRECT_PARENT_USERS);
    }

    @Override
    public boolean hasMember(Principal principal) {
	throw new UnsupportedOperationException(ERROR_USER_CANNOT_HAVE_PRINCIPAL_MEMBERS);
    }

    @Override
    public void addDirectChild(Principal child) {
	throw new UnsupportedOperationException(ERROR_USER_CANNOT_ADD_CHILD_PRINCIPAL);
    }

    @Override
    public void removeDirectChild(Principal child) {
	throw new UnsupportedOperationException(ERROR_USER_CANNOT_REMOVE_CHILD_PRINCIPAL);
    }

    @Override
    public boolean hasDirectChildren() {
	return false;
    }

    @Override
    public boolean hasAnyChild() {
	return false;
    }

    @Override
    public List getAllUsers() {
	throw new UnsupportedOperationException(ERROR_USER_CANNOT_HAVE_CHILD_USERS);
    }

    @Override
    public List getAllChildGroups() {
	throw new UnsupportedOperationException(ERROR_USER_CANNOT_HAVE_CHILD_GROUPS);
    }

    @Override
    public List getAllChildRoles() {
	throw new UnsupportedOperationException(ERROR_USER_CANNOT_HAVE_CHILD_ROLES);
    }

    public Login login() {
	for (final Identification identification : getIdentifications()) {
	    if (identification.isLogin()) {
		return (Login) identification;
	    }
	}
	return null;
    }

    public Login getLogin() {
	final Login login = login();
	return login == null ? new Login(this) : login;
    }

    public boolean hasLogin() {
	return login() != null;
    }

    @Override
    public boolean equals(final Object other) {
	if (!(other instanceof User)) {
	    return false;
	}
	return equalsTo((User) other);
    }

    @Override
    public int hashCode() {
	int result = 14;
	result = 29 * result + (getUsername() != null ? getUsername().hashCode() : 0);
	return result;
    }

    private boolean equalsTo(final User other) {
	return EqualityUtils.equals(getUsername(), other.getUsername());
    }

    @Override
    public String toString() {
	return getUsername();
    }

    @Override
    public boolean delete() {
	deleteIdentifications();
	removeDirectParents();
	return true;
    }

    private void deleteIdentifications() {
	final Iterator it = identifications.iterator();
	while (it.hasNext()) {
	    final Identification identification = it.next();
	    identification.delete();
	    it.remove();
	}
    }
}