public Pager findPager(Pager pager, Criteria criteria) {
Assert.notNull(pager, "pager is required");
Assert.notNull(criteria, "criteria is required");
Integer pageNumber = pager.getPageNumber();
Integer pageSize = pager.getPageSize();
String searchBy = pager.getSearchBy();
String keyword = pager.getKeyword();
String orderBy = pager.getOrderBy();
Pager.Order order = pager.getOrder();
if (StringUtils.isNotEmpty(searchBy) && StringUtils.isNotEmpty(keyword)) {
if (searchBy.contains(".")) {
String alias = StringUtils.substringBefore(searchBy, ".");
criteria.createAlias(alias, alias);
}
criteria.add(Restrictions.like(searchBy, "%" + keyword + "%"));
}
pager.setTotalCount(criteriaResultTotalCount(criteria));
if (StringUtils.isNotEmpty(orderBy) && order != null) {
if (order == Pager.Order.asc) {
criteria.addOrder(Order.asc(orderBy));
} else {
criteria.addOrder(Order.desc(orderBy));
}
}
ClassMetadata classMetadata = sessionFactory.getClassMetadata(entityClass);
if (!StringUtils.equals(orderBy, ORDER_LIST_PROPERTY_NAME)
&& ArrayUtils.contains(classMetadata.getPropertyNames(), ORDER_LIST_PROPERTY_NAME)) {
criteria.addOrder(Order.asc(ORDER_LIST_PROPERTY_NAME));
criteria.addOrder(Order.desc(CREATE_DATE_PROPERTY_NAME));
if (StringUtils.isEmpty(orderBy) || order == null) {
pager.setOrderBy(ORDER_LIST_PROPERTY_NAME);
pager.setOrder(Pager.Order.asc);
}
} else if (!StringUtils.equals(orderBy, CREATE_DATE_PROPERTY_NAME)
&& ArrayUtils.contains(classMetadata.getPropertyNames(), CREATE_DATE_PROPERTY_NAME)) {
criteria.addOrder(Order.desc(CREATE_DATE_PROPERTY_NAME));
if (StringUtils.isEmpty(orderBy) || order == null) {
pager.setOrderBy(CREATE_DATE_PROPERTY_NAME);
pager.setOrder(Pager.Order.desc);
}
}
criteria.setFirstResult((pageNumber - 1) * pageSize);
criteria.setMaxResults(pageSize);
pager.setResult(criteria.list());
return pager;
}
@SuppressWarnings("unchecked")
public List<T> getAllList() {
ClassMetadata classMetadata = sessionFactory.getClassMetadata(entityClass);
String hql;
if (ArrayUtils.contains(classMetadata.getPropertyNames(), ORDER_LIST_PROPERTY_NAME)) {
hql =
"from "
+ entityClass.getName()
+ " as entity order by entity."
+ ORDER_LIST_PROPERTY_NAME
+ " desc";
} else {
hql = "from " + entityClass.getName();
}
return getSession().createQuery(hql).list();
}
/**
* examines all {@link Type types} for this class and stores pointers to those fields which
* represent {@link IObject} instances. These fields may need to be locked when an object of
* this type is created or updated.
*/
Locks(ClassMetadata classMetadata) {
this.cm = classMetadata;
String[] name = cm.getPropertyNames();
Type[] type = cm.getPropertyTypes();
List<String[]> checks = new ArrayList<String[]>();
List<String[]> groupChecks = new ArrayList<String[]>();
this.size = type.length;
this.include = new boolean[size];
this.subnames = new String[size][];
this.subtypes = new Type[size][];
for (int i = 0; i < type.length; i++) {
if (type[i].isComponentType() && ((ComponentType) type[i]).isEmbedded()) {
EmbeddedComponentType embedded = (EmbeddedComponentType) type[i];
String[] sub_name = embedded.getPropertyNames();
Type[] sub_type = embedded.getSubtypes();
List<String> name_list = new ArrayList<String>();
List<Type> type_list = new ArrayList<Type>();
for (int j = 0; j < sub_type.length; j++) {
if (IObject.class.isAssignableFrom(sub_type[j].getReturnedClass())) {
String path = name[i] + "." + sub_name[j];
name_list.add(path);
type_list.add(sub_type[j]);
addCheck(checks, groupChecks, sub_type[j].getReturnedClass(), path);
}
}
add(
i,
name_list.toArray(new String[name_list.size()]),
type_list.toArray(new Type[type_list.size()]));
} else if (IObject.class.isAssignableFrom(type[i].getReturnedClass())) {
add(i);
addCheck(checks, groupChecks, type[i].getReturnedClass(), name[i]);
// Create checks for
}
}
this.checks = checks.toArray(new String[checks.size()][]);
this.groupChecks = groupChecks.toArray(new String[groupChecks.size()][]);
}
private void addChildExampleCriteria(Object exampleInstance, Criteria criteria, Session sesion) {
ClassMetadata metadata =
sesion.getSessionFactory().getClassMetadata(exampleInstance.getClass());
String[] propertyNames = metadata.getPropertyNames();
Type[] propertyTypes = metadata.getPropertyTypes();
// see if this example instance has any properties that are entities
for (int i = 0; i < propertyNames.length; i++) {
String propertyName = propertyNames[i];
Type propertyType = propertyTypes[i];
if (propertyType instanceof EntityType) {
// this property is an association - Hibernate's Example ignores
// these
Object value = metadata.getPropertyValue(exampleInstance, propertyName, EntityMode.POJO);
if (value != null) {
ClassMetadata childMetadata =
sesion.getSessionFactory().getClassMetadata(value.getClass());
Criteria childCriteria = criteria.createCriteria(propertyName);
if (childMetadata.hasIdentifierProperty()) {
Object id = childMetadata.getIdentifier(value, EntityMode.POJO);
if (id != null) {
// add the identifier to the child criteria
childCriteria.add(Restrictions.eq(childMetadata.getIdentifierPropertyName(), id));
}
}
// add the entity's fields as Example fields
childCriteria.add(Example.create(value));
// add this entity's associations
addChildExampleCriteria(value, childCriteria, sesion);
}
}
} // ~for
}
/**
* For each of the fields contained in this {@link Locks} object, parse out the type and the
* field name and store those as the key and value in the "value" argument.
*/
public void fillRelationships(SessionFactoryImplementor sfi, Map<String, Relationship> value) {
final Type[] types = cm.getPropertyTypes();
for (int t = 0; t < types.length; t++) {
final Type type = types[t];
final String name = type.getName();
String to = null;
Relationship field = null;
if (type instanceof EntityType) {
final EntityType entType = (EntityType) type;
to = entType.getAssociatedEntityName();
field = new Relationship(cm.getPropertyNames()[t], false);
} else if (types[t] instanceof CollectionType) {
final CollectionType colType = (CollectionType) types[t];
final Type elemType = colType.getElementType(sfi);
if (!elemType.isEntityType()) {
continue; // The case for count maps and other primitives.
}
to = elemType.getName();
int open = name.indexOf("(");
int close = name.lastIndexOf(")");
String role = name.substring(open + 1, close);
int dot = role.lastIndexOf(".");
field = new Relationship(role.substring(dot + 1), true);
}
if (to != null && field != null) {
Map<String, ClassMetadata> m = sfi.getAllClassMetadata();
for (Class<?> c : Impl.hierarchy(m, to)) {
value.put(c.getName(), field);
}
}
}
}
/**
* examines all model objects to see which fields contain a {@link Type} which points to this
* class. Uses {@link #locksFields(Type[])} since this is the inverse process.
*/
private String[][] lockedByFields(String klass, Map<String, ClassMetadata> m) {
if (m == null) {
throw new InternalException("ClassMetadata map cannot be null.");
}
List<String[]> fields = new ArrayList<String[]>();
for (String k : m.keySet()) {
ClassMetadata cm = m.get(k);
Type[] type = cm.getPropertyTypes();
String[] names = cm.getPropertyNames();
Locks inverse = locksHolder.get(k);
for (int i = 0; i < inverse.size(); i++) {
if (!inverse.include(i)) {
continue;
}
// this is an embedded component and must be treated
// specially. specifically, that we cannot compare against
// the top-level returnedClass name but rather against
// each of the individual subtype returnedClass names.
if (inverse.hasSubtypes(i)) {
for (int j = 0; j < inverse.numberOfSubtypes(i); j++) {
if (inverse.subtypeEquals(i, j, klass)) {
fields.add(new String[] {k, inverse.subtypeName(i, j)});
}
}
}
// no subtypes so can compare directly
else if (klass.equals(type[i].getReturnedClass().getName())) {
fields.add(new String[] {k, names[i]});
}
}
}
return fields.toArray(new String[fields.size()][2]);
}
public void /*test*/ AddNewProperty() {
System.out.println("******************* testAddNewProperty ********************");
PersistentClass userMapping = HibernateUtil.getClassMapping(User.class);
Column column = new Column();
column.setName("MOTTO");
column.setNullable(false);
column.setUnique(true);
column.setSqlType("VARCHAR");
userMapping.getTable().addColumn(column);
SimpleValue value = new SimpleValue();
value.setTable(userMapping.getTable());
value.addColumn(column);
value.setTypeName("string");
Property prop = new Property();
prop.setValue(value);
prop.setName("motto");
prop.setPropertyAccessorName("field");
prop.setNodeName(prop.getName());
userMapping.addProperty(prop);
HibernateUtil.rebuildSessionFactory();
ClassMetadata metadata = HibernateUtil.getClassMetadata(User.class);
String[] propNames = metadata.getPropertyNames();
boolean mottoFound = false;
for (int i = 0; i < propNames.length; i++) {
String propName = propNames[i];
if (propName.equalsIgnoreCase("motto")) {
mottoFound = true;
break;
}
}
assertTrue(mottoFound);
}
