Richfaces DataTable: Server Side Pagination, Sorting and Filtering

PaginatingDataModel.java

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.el.Expression;
import javax.faces.context.FacesContext;

import org.ajax4jsf.model.DataVisitor;
import org.ajax4jsf.model.Range;
import org.ajax4jsf.model.SequenceRange;
import org.ajax4jsf.model.SerializableDataModel;
import org.richfaces.model.ExtendedFilterField;
import org.richfaces.model.FilterField;
import org.richfaces.model.Modifiable;
import org.richfaces.model.Ordering;
import org.richfaces.model.SortField2;

public abstract class PaginatingDataModel<T, U> extends SerializableDataModel implements Modifiable {

    private static final long serialVersionUID = 2954923950179861809L;

    protected U currentPk;
    
    protected int rowIndex;

    protected boolean descending = true;

    protected String sortField = null;
    
    protected HashMap<String,Object> filterMap = new HashMap<String,Object>();

    protected boolean detached = false;

    protected List<U> wrappedKeys = new ArrayList<U>();

    protected Integer rowCount;

    protected Map<U, T> wrappedData = new HashMap<U, T>();

    /**
     * 
     * @see org.ajax4jsf.model.ExtendedDataModel#getRowKey()
     */
    @Override
    public Object getRowKey() {
        return currentPk;
    }

    /**
     * 
     * @see org.ajax4jsf.model.ExtendedDataModel#setRowKey(java.lang.Object)
     */

    @SuppressWarnings("unchecked")
    @Override
    public void setRowKey(final Object key) {
        this.currentPk = (U) key;
    }

    /**
     * 
     * @see org.ajax4jsf.model.SerializableDataModel#update()
     */
    @Override
    public void update() {
        detached = false;
    }

    /**
     * 
     * @see org.ajax4jsf.model.ExtendedDataModel#getSerializableModel(org.ajax4jsf.model.Range)
     */
    @Override
    public SerializableDataModel getSerializableModel(final Range range) {
        if (wrappedKeys != null) {
            detached = true;
            return this;
        }
        return null;
    }

    /**
     * 
     * @see javax.faces.model.DataModel#setRowIndex(int)
     */
    @Override
    public void setRowIndex(final int arg0) {
        rowIndex = arg0;
    }

    /**
     * 
     * @see javax.faces.model.DataModel#setWrappedData(java.lang.Object)
     */
    @Override
    public void setWrappedData(final Object data) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * @see javax.faces.model.DataModel#getRowIndex()
     */
    @Override
    public int getRowIndex() {
        return rowIndex;
    }

    /**
     * 
     * @see javax.faces.model.DataModel#getWrappedData()
     */
    @Override
    public Object getWrappedData() {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * @see org.ajax4jsf.model.ExtendedDataModel#walk(javax.faces.context.FacesContext, org.ajax4jsf.model.DataVisitor,
     *      org.ajax4jsf.model.Range, java.lang.Object)
     */
    @Override
    public void walk(final FacesContext context, final DataVisitor visitor, final Range range, final Object argument)
            throws IOException {
        final int firstRow = ((SequenceRange) range).getFirstRow();
        final int numberOfRows = ((SequenceRange) range).getRows();
        if (detached) {
            for (final U key : wrappedKeys) {
                setRowKey(key);
                visitor.process(context, key, argument);
            }
        } else { // if not serialized, than we request data from data provider
            wrappedKeys = new ArrayList<U>();
            for (final T object : findObjects(firstRow, numberOfRows, sortField, filterMap, descending)) {
                wrappedKeys.add(getId(object));
                wrappedData.put(getId(object), object);
                visitor.process(context, getId(object), argument);
            }
        }
    }

    /**
     * 
     * @see javax.faces.model.DataModel#isRowAvailable()
     */

    @Override
    public boolean isRowAvailable() {
        if (currentPk == null) {
            return false;
        }
        if (wrappedKeys.contains(currentPk)) {
            return true;
        }
        if (wrappedData.entrySet().contains(currentPk)) {
            return true;
        }
        try {
            if (getObjectById(currentPk) != null) {
                return true;
            }
        } catch (final Exception e) {
        }
        return false;
    }

    /**
     * 
     * @see javax.faces.model.DataModel#getRowData()
     */
    @Override
    public Object getRowData() {
        if (currentPk == null) {
            return null;
        }
        T object = wrappedData.get(currentPk);
        if (object == null) {
            object = getObjectById(currentPk);
            wrappedData.put(currentPk, object);
        }
        return object;
    }

    /**
     * 
     * @see javax.faces.model.DataModel#getRowCount()
     */
    @Override
    public int getRowCount() {
        if (rowCount == null) {
            rowCount = getNumRecords(filterMap).intValue();
        }
        return rowCount;
    }

    @Override
    public void modify(List<FilterField> filterFields, List<SortField2> sortFields) {
        filterMap.clear();
        SortField2 sortField2 = null;
        String expressionStr = null;
        ExtendedFilterField extendedFilterField = null;
        Expression expression = null;
        String value = null;
        if (sortFields != null && !sortFields.isEmpty()) {
            sortField2 = sortFields.get(0);
            expression = sortField2.getExpression();
            expressionStr = expression.getExpressionString();
            if (!expression.isLiteralText()) {
                expressionStr = expressionStr.replaceAll("[#|$]{1}\\{.*?\\.", "").replaceAll("\\}", "");
            }
            this.sortField = expressionStr;
            if (sortField2.getOrdering() == Ordering.DESCENDING) {
                this.descending = true;
            } else {
                this.descending = false;
            }
        }
        if (filterFields != null && !filterFields.isEmpty()) {
            for (FilterField filterField : filterFields) {
                if (filterField instanceof ExtendedFilterField) {
                    extendedFilterField = (ExtendedFilterField) filterField;
                    value = extendedFilterField.getFilterValue();
                    if (value != null && !value.equals("")) {
                        expression = extendedFilterField.getExpression();
                        expressionStr = expression.getExpressionString();
                        if (!expression.isLiteralText()) {
                            expressionStr = expressionStr.replaceAll("[#|$]{1}\\{.*?\\.", "").replaceAll("\\}", "");
                        }
                        filterMap.put(expressionStr, value);
                    }
                }
            }
        }
    }

    /**
     * @param object
     * 
     * @return U
     */
    public abstract U getId(T object);

    /**
     * 
     * @param firstRow
     * 
     * @param numberOfRows
     * 
     * @param sortField
     * 
     * @param descending
     * 
     * @return List<T>
     */
    public abstract List<T> findObjects(int firstRow, int numberOfRows, String sortField, HashMap<String,Object> filterMap, boolean descending);

    /**
     * 
     * @param id
     * 
     * @return T
     */
    public abstract T getObjectById(U id);

    /**
     * 
     * @return Long
     */
    public abstract Long getNumRecords(HashMap<String,Object> filterMap);

}

PersonPaginatingDataModel.java

import java.util.HashMap;
import java.util.List;

import org.jboss.seam.annotations.In;
import org.jboss.seam.annotations.Name;

import at.ooegkk.svnet.juhealth.entity.Person;
import at.ooegkk.svnet.juhealth.service.PersonService;

@Name("personPaginatingDataModel")
public class PersonPaginatingDataModel extends PaginatingDataModel<Person, Long> {
    
    private static final long serialVersionUID = 1868068053701471139L;
    
    @In(required = false)
    private PersonService personService;

    /**
     * @see PaginatingDataModel#getId
     */
    @Override
    public Long getId(Person person) {
        return person.getId();
    }

    /**
     * @see PaginatingDataModel#findObjects
     */
    @Override
    public List<Person> findObjects(int firstRow, int maxResult, String sortField, HashMap<String,Object> filterMap, boolean descending) {
        return personService.getRange(firstRow, maxResult, sortField, filterMap, descending);
    }

    /**
     * @see PaginatingDataModel#getObjectById(java.lang.Object)
     */
    @Override
    public Person getObjectById(Long id) {
        return personService.getPersonById(id);
    }

    /**
     * 
     * @see PaginatingDataModel#getNumRecords
     */
    @Override
    public Long getNumRecords(HashMap<String,Object> filterMap) {
        return personService.getCount(filterMap);
    }
}

PersonService.java

import java.util.HashMap;
import java.util.List;

import javax.ejb.Remote;

import at.ooegkk.svnet.juhealth.entity.Person;

@Remote
public interface PersonService {

 public List<Person> findAllPersons();
 public void save(Person p);
 public void merge(Person p);
 public void remove(Person p);
 public Person getPersonById(Long id);
 public Long getCount(HashMap<String,Object> filterMap);
 public List<Person> getRange(Integer firstRow, Integer maxResult, String sortField, HashMap<String,Object> filterMap, boolean descending);
    
}

PersonServiceImpl.java

import java.util.HashMap;
import java.util.List;

import javax.ejb.EJB;
import javax.ejb.Stateless;

import at.ooegkk.svnet.juhealth.dao.GenericDAO;
import at.ooegkk.svnet.juhealth.dao.PersonDAO;
import at.ooegkk.svnet.juhealth.entity.Person;
import at.ooegkk.svnet.juhealth.service.PersonService;

@Stateless
@SuppressWarnings("unchecked")
public class PersonServiceImpl implements PersonService {

 @EJB(name="svnet-juhealth-EAR/PersonDAOImpl/local")
 private PersonDAO personDAOImpl;
 
 public List<Person> findAllPersons() {
  List<Person> allPersons = personDAOImpl.findAll(Person.class);
  return allPersons;
 }
 
 public void save(Person person) {
  personDAOImpl.persist(person);
 }

 public void merge(Person person) {
  personDAOImpl.merge(person);
 }
 
 public void remove(Person person) {
  personDAOImpl.remove(person);
 }
 
 public Person getPersonById(Long id) {
  Person p = (Person) personDAOImpl.findById(Person.class, id);
  return p;
 }
 
 public Long getCount(HashMap<String,Object> filterMap) {
        Long count = personDAOImpl.getCount(Person.class, filterMap);
        return count;
    }
    
    public List<Person> getRange(Integer firstRow, Integer maxResult, String sortField, HashMap<String,Object> filterMap, boolean descending) {
        List<Person> list = null;
        if (descending) {
            list = personDAOImpl.findByFilter(Person.class, firstRow, maxResult, sortField, GenericDAO.SORT_ORDER.DESC, filterMap);
        } else {
            list = personDAOImpl.findByFilter(Person.class, firstRow, maxResult, sortField, GenericDAO.SORT_ORDER.ASC, filterMap);
        }
        return list;
    }

}

GenericDAO.java

package at.ooegkk.svnet.juhealth.dao;

import java.util.HashMap;
import java.util.List;
import java.util.Set;

import javax.ejb.Local;

@SuppressWarnings("unchecked")
@Local
public interface GenericDAO {

    public enum SORT_ORDER {
        ASC, DESC
    };

    public Object findById(Class entityClass, long id);

    public List findAll(Class entityClass);

    public List findAll(Class entityClass, String orderByAttribute, SORT_ORDER sortOrder);

    public List findAll(Class entityClass, int maxResult);

    public List findAll(Class entityClass, int firstRow, int maxResult);

    public List findAll(Class entityClass, int maxResult, String orderByAttribute, SORT_ORDER sortOrder);

    public void persist(Object entity, boolean flushImmediate);

    public void persist(Object entity);

    public Object merge(Object entity, boolean flushImmediate);

    public Object merge(Object entity);

    public void remove(Object entity, boolean flushImmediate);

    public void remove(Object entity);

    public Set<String> exludeNames();

    public Long getCount(Class entityClass);
    
    public Long getCount(Class entityClass, HashMap<String,Object> filterMap);

    public List findByFilter(Class entityClass, int firstRow, int maxResult, String orderByAttribute, SORT_ORDER sortOrder,
            HashMap<String, Object> filterMap);

}

GenericDAOImpl.java

import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

import at.ooegkk.svnet.juhealth.dao.GenericDAO;

@SuppressWarnings("unchecked")
@Stateless
public class GenericDAOImpl implements GenericDAO {
 
 @PersistenceContext(unitName="svnet-juhealth")
 private EntityManager entityManager;

 public EntityManager getEntityManager() {
  return entityManager;
 }

 public void setEntityManager(EntityManager entityManager) {
  this.entityManager = entityManager;
 }

 public Object findById(Class entityClass, long id) {
  return getEntityManager().find(entityClass, id);
 }

 public List findAll(Class entityClass) {
  return getEntityManager().createQuery(
    "select e from " + entityClass.getName() + " e ")
    .getResultList();
 }

 public List findAll(Class entityClass, 
   String orderByAttribute, SORT_ORDER sortOrder) {
  String sortOrderString = "desc";
  if (sortOrder == SORT_ORDER.ASC) {
   sortOrderString = "asc";
  }
  return getEntityManager().createQuery(
    "select e from " + entityClass.getName() + " e order by " +
    orderByAttribute + " " + sortOrderString).getResultList();
 }

 public List findAll(Class entityClass, int maxResult) {
  Query q = getEntityManager().createQuery(
    "select e from " + entityClass.getName() + " e ");
  if (maxResult > 0) {
   q.setMaxResults(maxResult);
  }
  return q.getResultList();
 }
 
 public List findAll(Class entityClass, int firstRow, int maxResult) {
        Query q = getEntityManager().createQuery(
                "select e from " + entityClass.getName() + " e ");
        if (firstRow > 0) {
            q.setFirstResult(firstRow);
        }
        if (maxResult > 0) {
            q.setMaxResults(maxResult);
        }
        return q.getResultList();
    }

 public List findAll(Class entityClass, int maxResult,
   String orderByAttribute, SORT_ORDER sortOrder) {
  String sortOrderString = "desc";
  if (sortOrder == SORT_ORDER.ASC) {
   sortOrderString = "asc";
  }
  Query q = getEntityManager().createQuery(
    "select e from " + entityClass.getName() + " e order by "
      + orderByAttribute + " " + sortOrderString);
  if (maxResult > 0) {
   q.setMaxResults(maxResult);
  }
  return q.getResultList();
 }

 public void persist(Object entity, boolean flushImmediate) {
  getEntityManager().persist(entity);
  if (flushImmediate)
   getEntityManager().flush();
 }

 public void persist(Object entity) {
  this.persist(entity, false);
 }

 public Object merge(Object entity, boolean flushImmediate) {
  Object obj = getEntityManager().merge(entity);
  if (flushImmediate)
   getEntityManager().flush();
  return obj;
 }

 public Object merge(Object entity) {
  return this.merge(entity, false);
 }

 public void remove(Object entity, boolean flushImmediate) {
  getEntityManager().remove(getEntityManager().merge(entity));
  if (flushImmediate)
   getEntityManager().flush();
 }

 public void remove(Object entity) {
  this.remove(entity, false);
 }

 public Set<String> exludeNames() {
  return new HashSet<String>();
 }
 
 public Long getCount(Class entityClass) {
        Query q = getEntityManager().createQuery(
                "select count(e) from " + entityClass.getName() + " e ");
        return (Long) q.getSingleResult();
 }
 
 public Long getCount(Class entityClass, HashMap<String,Object> filterMap) {
     StringBuffer query = new StringBuffer();
     query.append("select count(e) from " + entityClass.getName() + " e");
     // where clause
        query.append(this.getWhereClause(filterMap));
        Query q = getEntityManager().createQuery(query.toString());
        // parameter
        q = this.getParameteredQuery(q, filterMap);
     return (Long) q.getSingleResult();
    }
 
 public List findByFilter(Class entityClass, int firstRow, int maxResult,
            String orderByAttribute, SORT_ORDER sortOrder, HashMap<String,Object> filterMap) {
     StringBuffer query = new StringBuffer();
     query.append("SELECT e FROM " + entityClass.getName() + " e");
     // sort order
        String sortOrderString = "desc";
        if (sortOrder == SORT_ORDER.ASC) {
            sortOrderString = "asc";
        }
        // where clause
        query.append(this.getWhereClause(filterMap));
        // order by
        if (orderByAttribute != null) {
            query.append(" ORDER BY " + orderByAttribute + " " + sortOrderString);
        }
        Query q = getEntityManager().createQuery(query.toString());
        // parameter
        q = this.getParameteredQuery(q, filterMap);
        if (firstRow > 0) {
            q.setFirstResult(firstRow);
        }
        if (maxResult > 0) {
            q.setMaxResults(maxResult);
        }
        return q.getResultList();
    }
 
 private String getWhereClause(HashMap<String,Object> filterMap) {
     StringBuffer query = new StringBuffer();
     if (filterMap != null && !filterMap.isEmpty()) {
            query.append(" WHERE");
            boolean first = true;
            for (String column : filterMap.keySet()) {
                if (first) {
                    first = false;
                } else {
                    query.append(" AND");
                }
                if (filterMap.get(column) instanceof String) {
                    query.append(" UPPER(e." + column + ") LIKE :" + column);
                } else {
                    query.append(" e." + column + " = :" + column);
                }
            }
        }
     return query.toString();
 }
 
 private Query getParameteredQuery(Query q, HashMap<String,Object> filterMap) {
     if (filterMap != null && !filterMap.isEmpty()) {
            for (String column : filterMap.keySet()) {
                if (filterMap.get(column) instanceof String) {
                    String value = (String) filterMap.get(column);
                    q.setParameter(column, value.toUpperCase() + "%");
                } else {
                    q.setParameter(column, filterMap.get(column));
                }
            }
        }
     return q;
 }
 
}

PersonDAO.java

import javax.ejb.Local;

@Local
public interface PersonDAO extends GenericDAO {

}

PersonDAOImpl.java

import javax.ejb.Stateless;

import at.ooegkk.svnet.juhealth.dao.PersonDAO;

@Stateless
public class PersonDAOImpl extends GenericDAOImpl implements PersonDAO {
    
}

AbstractEntity.java

import java.io.Serializable;

import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.MappedSuperclass;

@MappedSuperclass
public class AbstractEntity implements Serializable {

 /**
  * 
  */
 private static final long serialVersionUID = 1L;
 
 private Long id;


 @Id
 @GeneratedValue(strategy=GenerationType.AUTO)
 public Long getId() {
  return id;
 }

 public void setId(Long id) {
  this.id = id;
 }

}

Person.java

import java.io.Serializable;
import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.OneToOne;
import javax.persistence.Table;

import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
import org.hibernate.validator.Length;
import org.hibernate.validator.NotNull;
import org.jboss.seam.annotations.Name;

import at.ooegkk.intranet.example.validator.VSNR;

@Name("person")
@Entity
@Table
@Cache(usage=CacheConcurrencyStrategy.READ_WRITE)
public class Person extends AbstractEntity implements Serializable {
 /**
  * 
  */
 private static final long serialVersionUID = 1L;
 private String vorname;
 private String nachname;
 private String vsnr;
 private Date geburtsdatum;
 private Address adresse = new Address();
 
 @Column
 @NotNull(message="#{messages['field.required']}")
 public String getVorname() {
  return vorname;
 }
 public void setVorname(String vorname) {  
  this.vorname = vorname;
 }
 @Column
 public String getNachname() {
  return nachname;
 }
 public void setNachname(String nachname) {
  this.nachname = nachname;
 }
 @Column
 @NotNull
 @Length(max=10,min=10)
 public String getVsnr() {
  return vsnr;
 }
 public void setVsnr(String vsnr) {
  this.vsnr = vsnr;
 }
 @OneToOne(targetEntity=Address.class)
 @Cascade(value=CascadeType.ALL)
 public Address getAdresse() {
  return adresse;
 }
 public void setAdresse(Address adresse) {
  this.adresse = adresse;
 }
 @Column
 public Date getGeburtsdatum() {
  return geburtsdatum;
 }
 public void setGeburtsdatum(Date geburtsdatum) {
  this.geburtsdatum = geburtsdatum;
 }
}

Address.java

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Table;

import org.hibernate.validator.NotNull;
import org.jboss.seam.annotations.Name;

@Entity
@Table
@Name("adresse")
public class Address extends AbstractEntity implements Serializable {
 
 /**
  * 
  */
 private static final long serialVersionUID = 1L;
 private Integer plz;
 private String ort;
 private String strasse;
 @Column
 public Integer getPlz() {
  return plz;
 }
 public void setPlz(Integer plz) {
  this.plz = plz;
 }
 @Column
 public String getOrt() {
  return ort;
 }
 public void setOrt(String ort) {
  this.ort = ort;
 }
 @Column
 @NotNull
 public String getStrasse() {
  return strasse;
 }
 public void setStrasse(String strasse) {
  this.strasse = strasse;
 }
}

index.xhtml

<rich:dataTable value="#{personPaginatingDataModel}" var="person" rows="3" reRender="scroller" id="simpletable" width="100%" rowClasses="firstrow,secondrow"<
 <f:facet name="header"<
  <h:outputText value="Personen"/<
 </f:facet<
 <rich:column width="10%"<
  <s:link action="#{personManager.personEdit}"<
   <f:param name="personId" value="#{person.id}"/<
   <img src="/img/icon_bearbeiten.gif" alt="Bearbeiten"/<
  </s:link<
 </rich:column<
 <rich:column width="18%"< 
  <f:facet name="header"<
   <h:outputText value="SVNR"/<
  </f:facet<
  <h:outputText value="#{person.vsnr}"/<
 </rich:column<
 <rich:column sortBy="#{person.vorname}" filterBy="#{person.vorname}" filterEvent="onkeyup" filterValue="#{personManager.currentVornameFilterValue}" width="18%"< 
  <f:facet name="header"<
   <h:outputText value="Vorname"/<
  </f:facet<
  <h:outputText value="#{person.vorname}"/<
 </rich:column<
 <rich:column filterBy="#{person.nachname}" filterEvent="onkeyup" filterValue="#{personManager.currentNachnameFilterValue}" width="18%"< 
  <f:facet name="header"<
   <h:outputText value="Nachname"/<
  </f:facet<
  <h:outputText value="#{person.nachname}"/<
 </rich:column<
 <rich:column width="18%"<
  <f:facet name="header"<
   <h:outputText value="Strasse"/<
  </f:facet<
  <h:outputText value="#{person.adresse.strasse}"/<
 </rich:column< 
 <rich:column width="8%"<
  <f:facet name="header"<
   <h:outputText value="PLZ"/<
  </f:facet<
  <h:outputText value="#{person.adresse.plz}"/<
 </rich:column< 
 <rich:column width="10%"<
  <f:facet name="header"<
   <h:outputText value="Ort"/<
  </f:facet<
  <h:outputText value="#{person.adresse.ort}"/<
 </rich:column<
</rich:dataTable<
<rich:datascroller id="scroller" renderIfSinglePage="false" for="simpletable"<</rich:datascroller<

Edit at 2012/09/26: The reason that some readers were asking for the source code of the PersonManager, I edited this post. Because I have improved the PersonManager since the creation of the first post, I inserted an older version from the repository. Hopefully it is compatible with the other code.

PersonManager

import java.util.List;

import org.jboss.seam.ScopeType;
import org.jboss.seam.annotations.Begin;
import org.jboss.seam.annotations.End;
import org.jboss.seam.annotations.In;
import org.jboss.seam.annotations.Name;
import org.jboss.seam.annotations.Out;
import org.jboss.seam.annotations.Scope;
import org.jboss.seam.annotations.web.RequestParameter;

import at.ooegkk.svnet.juhealth.datamodel.PersonPaginatingDataModel;
import at.ooegkk.svnet.juhealth.entity.Person;
import at.ooegkk.svnet.juhealth.service.PersonService;

@Name("personManager")
@Scope(ScopeType.SESSION)
public class PersonManager {

    @In(required = false)
    private PersonService personService;

    @In(create = true)
    @Out(required = false)
    public Person person;

    @Out(required = false)
    public Person searchPerson = new Person();

    @RequestParameter
    public Long personId;

    public String currentVornameFilterValue;

    public String currentNachnameFilterValue;

    @In(create = true)
    public PersonPaginatingDataModel personPaginatingDataModel;

    public PersonManager() {
    }

    public Person getPerson() {
        return person;
    }

    public void setPerson(Person person) {
        this.person = person;
    }

    public Person getSearchPerson() {
        return searchPerson;
    }

    public void setSearchPerson(Person searchPerson) {
        this.searchPerson = searchPerson;
    }

    public PersonPaginatingDataModel getPersonPaginatingDataModel() {
        return personPaginatingDataModel;
    }

    public void setPersonPaginatingDataModel(PersonPaginatingDataModel personPaginatingDataModel) {
        this.personPaginatingDataModel = personPaginatingDataModel;
    }

    public String personenList() {
        return "personenList";
    }

    public String personAdd() {
        return "personAdd";
    }

    @Begin(join = true)
    @End
    public String personSave() throws Exception {
        try {
            if (person.getId() == null) {
                this.personService.save(person);
            } else {
                this.personService.merge(person);
            }
            return "personSave";
        } catch (Exception e) {
            throw e;
        }
    }

    public String personReset() throws Exception {
        try {
            person = new Person();
            return "personReset";
        } catch (Exception e) {
            throw e;
        }
    }

    public String personEdit() throws Exception {
        try {
            person = this.personService.getPersonById(personId);
            return "personEdit";
        } catch (Exception e) {
            throw e;
        }
    }

    public String personenSearch() throws Exception {
        try {
            return "personenSearch";
        } catch (Exception e) {
            throw e;
        }
    }

    public List getPersonen() throws Exception {
        try {
            return this.personService.findAllPersons();
        } catch (Exception e) {
            throw e;
        }
    }

    public String getCurrentVornameFilterValue() {
        return currentVornameFilterValue;
    }

    public void setCurrentVornameFilterValue(String currentVornameFilterValue) {
        this.currentVornameFilterValue = currentVornameFilterValue;
    }

    public String getCurrentNachnameFilterValue() {
        return currentNachnameFilterValue;
    }

    public void setCurrentNachnameFilterValue(String currentNachnameFilterValue) {
        this.currentNachnameFilterValue = currentNachnameFilterValue;
    }

}